1d506c26d9
This commit is the result of the following actions:
- Running gdb/copyright.py to update all of the copyright headers to
include 2024,
- Manually updating a few files the copyright.py script told me to
update, these files had copyright headers embedded within the
file,
- Regenerating gdbsupport/Makefile.in to refresh it's copyright
date,
- Using grep to find other files that still mentioned 2023. If
these files were updated last year from 2022 to 2023 then I've
updated them this year to 2024.
I'm sure I've probably missed some dates. Feel free to fix them up as
you spot them.
256 lines
4.6 KiB
C++
256 lines
4.6 KiB
C++
/* This testcase is part of GDB, the GNU debugger.
|
|
|
|
Copyright 2017-2024 Free Software Foundation, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include <cstddef>
|
|
|
|
/* Code for operator() tests. */
|
|
|
|
struct test_unique_op_call
|
|
{
|
|
void operator() (int);
|
|
};
|
|
|
|
void
|
|
test_unique_op_call::operator() (int)
|
|
{}
|
|
|
|
struct test_op_call
|
|
{
|
|
void operator() ();
|
|
void operator() (int);
|
|
void operator() (long);
|
|
|
|
template<typename T>
|
|
void operator() (T *);
|
|
};
|
|
|
|
void
|
|
test_op_call::operator() (int)
|
|
{}
|
|
|
|
void
|
|
test_op_call::operator() ()
|
|
{}
|
|
|
|
void
|
|
test_op_call::operator() (long)
|
|
{}
|
|
|
|
template<typename T>
|
|
void
|
|
test_op_call::operator() (T *t)
|
|
{
|
|
}
|
|
|
|
/* Code for operator[] tests. */
|
|
|
|
struct test_unique_op_array
|
|
{
|
|
void operator[] (int);
|
|
};
|
|
|
|
void
|
|
test_unique_op_array::operator[] (int)
|
|
{}
|
|
|
|
struct test_op_array
|
|
{
|
|
void operator[] (int);
|
|
void operator[] (long);
|
|
|
|
template<typename T>
|
|
void operator[] (T *);
|
|
};
|
|
|
|
void
|
|
test_op_array::operator[] (int)
|
|
{}
|
|
|
|
void
|
|
test_op_array::operator[] (long)
|
|
{}
|
|
|
|
template<typename T>
|
|
void
|
|
test_op_array::operator[] (T *t)
|
|
{}
|
|
|
|
/* Code for operator new tests. */
|
|
|
|
static int dummy;
|
|
|
|
struct test_op_new
|
|
{
|
|
void *operator new (size_t);
|
|
};
|
|
|
|
void *
|
|
test_op_new::operator new (size_t)
|
|
{
|
|
return &dummy;
|
|
}
|
|
|
|
/* Code for operator delete tests. */
|
|
|
|
struct test_op_delete
|
|
{
|
|
void operator delete (void *);
|
|
};
|
|
|
|
void
|
|
test_op_delete::operator delete (void *)
|
|
{
|
|
}
|
|
|
|
/* Code for operator new[] tests. */
|
|
|
|
struct test_op_new_array
|
|
{
|
|
void *operator new[] (size_t);
|
|
};
|
|
|
|
void *
|
|
test_op_new_array::operator new[] (size_t)
|
|
{
|
|
return &dummy;
|
|
}
|
|
|
|
/* Code for operator delete[] tests. */
|
|
|
|
struct test_op_delete_array
|
|
{
|
|
void operator delete[] (void *);
|
|
};
|
|
|
|
void
|
|
test_op_delete_array::operator delete[] (void *)
|
|
{
|
|
}
|
|
|
|
/* Code for user-defined conversion tests. */
|
|
|
|
struct test_op_conversion_res;
|
|
|
|
struct test_op_conversion
|
|
{
|
|
operator const volatile test_op_conversion_res **() const volatile;
|
|
};
|
|
|
|
test_op_conversion::operator const volatile test_op_conversion_res **()
|
|
const volatile
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* Code for the assignment operator tests. */
|
|
|
|
struct test_op_assign
|
|
{
|
|
test_op_assign operator= (const test_op_assign &);
|
|
};
|
|
|
|
test_op_assign
|
|
test_op_assign::operator= (const test_op_assign &)
|
|
{
|
|
return test_op_assign ();
|
|
}
|
|
|
|
/* Code for the arrow operator tests. */
|
|
|
|
struct test_op_arrow
|
|
{
|
|
test_op_arrow operator-> ();
|
|
};
|
|
|
|
test_op_arrow
|
|
test_op_arrow::operator-> ()
|
|
{
|
|
return test_op_arrow ();
|
|
}
|
|
|
|
/* Code for the logical/arithmetic operators tests. */
|
|
|
|
struct E
|
|
{
|
|
};
|
|
|
|
#define GEN_OP(NS, ...) \
|
|
namespace test_ops { \
|
|
void operator __VA_ARGS__ {} \
|
|
} \
|
|
namespace test_op_ ## NS { \
|
|
void operator __VA_ARGS__ {} \
|
|
}
|
|
|
|
GEN_OP (PLUS_A, += (E, E) )
|
|
GEN_OP (PLUS, + (E, E) )
|
|
GEN_OP (MINUS_A, -= (E, E) )
|
|
GEN_OP (MINUS, - (E, E) )
|
|
GEN_OP (MOD_A, %= (E, E) )
|
|
GEN_OP (MOD, % (E, E) )
|
|
GEN_OP (EQ, == (E, E) )
|
|
GEN_OP (NEQ, != (E, E) )
|
|
GEN_OP (LAND, && (E, E) )
|
|
GEN_OP (LOR, || (E, E) )
|
|
GEN_OP (SL_A, <<= (E, E) )
|
|
GEN_OP (SR_A, >>= (E, E) )
|
|
GEN_OP (SL, << (E, E) )
|
|
GEN_OP (SR, >> (E, E) )
|
|
GEN_OP (OE, |= (E, E) )
|
|
GEN_OP (BIT_O, | (E, E) )
|
|
GEN_OP (XOR_A, ^= (E, E) )
|
|
GEN_OP (XOR, ^ (E, E) )
|
|
GEN_OP (BIT_AND_A, &= (E, E) )
|
|
GEN_OP (BIT_AND, & (E, E) )
|
|
GEN_OP (LT, < (E, E) )
|
|
GEN_OP (LTE, <= (E, E) )
|
|
GEN_OP (GTE, >= (E, E) )
|
|
GEN_OP (GT, > (E, E) )
|
|
GEN_OP (MUL_A, *= (E, E) )
|
|
GEN_OP (MUL, * (E, E) )
|
|
GEN_OP (DIV_A, /= (E, E) )
|
|
GEN_OP (DIV, / (E, E) )
|
|
GEN_OP (NEG, ~ (E) )
|
|
GEN_OP (NOT, ! (E) )
|
|
GEN_OP (PRE_INC, ++ (E) )
|
|
GEN_OP (POST_INC, ++ (E, int) )
|
|
GEN_OP (PRE_DEC, -- (E) )
|
|
GEN_OP (POST_DEC, -- (E, int) )
|
|
GEN_OP (COMMA, , (E, E) )
|
|
|
|
int
|
|
main ()
|
|
{
|
|
test_op_call opcall;
|
|
opcall ();
|
|
opcall (1);
|
|
opcall (1l);
|
|
opcall ((int *) 0);
|
|
|
|
test_unique_op_call opcall2;
|
|
opcall2 (1);
|
|
|
|
test_op_array op_array;
|
|
op_array[1];
|
|
op_array[1l];
|
|
op_array[(int *) 0];
|
|
|
|
test_unique_op_array unique_op_array;
|
|
unique_op_array[1];
|
|
|
|
return 0;
|
|
}
|