Re: [RFA] New tests for 'const' and 'volatile' expressions

Fernando Nasser
2001-11-14T21:53:55Z

Michael Snyder wrote:
>
> This is a test that I forgot to submit back in September,
> after submitting the changes to the expression parser that
> permitted more complex expressions involving const and volatile.

Nice, new tests are good!

> I've tested the test on several native and embedded targets.
>

Do they pass?

Fernando

> 2001-11-13 Michael Snyder <msnyder@redhat.com>
>
> * gdb.base/cvexpr.c, gdb.base/cvexpr.exp: New files.
> Tests for expressions using 'const' and 'volatile'.
>
> /* Copyright (C) 2001 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 2 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, write to the Free Software
> Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
>
> Please email any bugs, comments, and/or additions to this file to:
> bug-gdb@prep.ai.mit.edu */
>
> /*
> * Initial set of typed variables borrowed from ptype.c
> */
>
> #if !defined (__STDC__) && !defined (_AIX)
> #define signed /**/
> #endif
>
> char v_char;
> signed char v_signed_char;
> unsigned char v_unsigned_char;
>
> short v_short;
> signed short v_signed_short;
> unsigned short v_unsigned_short;
>
> int v_int;
> signed int v_signed_int;
> unsigned int v_unsigned_int;
>
> long v_long;
> signed long v_signed_long;
> unsigned long v_unsigned_long;
>
> long long v_long_long;
> signed long long v_signed_long_long;
> unsigned long long v_unsigned_long_long;
>
> float v_float;
> double v_double;
>
> /*
> * Now some derived types, which are arrays, functions-returning,
> * pointers, structures, unions, and enumerations.
> */
>
> /**** arrays *******/
>
> char v_char_array[2];
> signed char v_signed_char_array[2];
> unsigned char v_unsigned_char_array[2];
>
> short v_short_array[2];
> signed short v_signed_short_array[2];
> unsigned short v_unsigned_short_array[2];
>
> int v_int_array[2];
> signed int v_signed_int_array[2];
> unsigned int v_unsigned_int_array[2];
>
> long v_long_array[2];
> signed long v_signed_long_array[2];
> unsigned long v_unsigned_long_array[2];
>
> float v_float_array[2];
> double v_double_array[2];
>
> /* PR 3742 */
> typedef char t_char_array[];
>
> /**** pointers *******/
>
> char *v_char_pointer;
> signed char *v_signed_char_pointer;
> unsigned char *v_unsigned_char_pointer;
>
> short *v_short_pointer;
> signed short *v_signed_short_pointer;
> unsigned short *v_unsigned_short_pointer;
>
> int *v_int_pointer;
> signed int *v_signed_int_pointer;
> unsigned int *v_unsigned_int_pointer;
>
> long *v_long_pointer;
> signed long *v_signed_long_pointer;
> unsigned long *v_unsigned_long_pointer;
>
> float *v_float_pointer;
> double *v_double_pointer;
>
> char **v_char_pointer_pointer;
> signed char **v_signed_char_pointer_pointer;
> unsigned char **v_unsigned_char_pointer_pointer;
>
> short **v_short_pointer_pointer;
> signed short **v_signed_short_pointer_pointer;
> unsigned short **v_unsigned_short_pointer_pointer;
>
> int **v_int_pointer_pointer;
> signed int **v_signed_int_pointer_pointer;
> unsigned int **v_unsigned_int_pointer_pointer;
>
> long **v_long_pointer_pointer;
> signed long **v_signed_long_pointer_pointer;
> unsigned long **v_unsigned_long_pointer_pointer;
>
> float **v_float_pointer_pointer;
> double **v_double_pointer_pointer;
>
> /**** pointers to arrays, arrays of pointers *******/
>
> char *v_char_array_pointer[2];
> signed char *v_signed_char_array_pointer[2];
> unsigned char *v_unsigned_char_array_pointer[2];
>
> short *v_short_array_pointer[2];
> signed short *v_signed_short_array_pointer[2];
> unsigned short *v_unsigned_short_array_pointer[2];
>
> int *v_int_array_pointer[2];
> signed int *v_signed_int_array_pointer[2];
> unsigned int *v_unsigned_int_array_pointer[2];
>
> long *v_long_array_pointer[2];
> signed long *v_signed_long_array_pointer[2];
> unsigned long *v_unsigned_long_array_pointer[2];
>
> float *v_float_array_pointer[2];
> double *v_double_array_pointer[2];
>
> char (*v_char_pointer_array)[2];
> signed char (*v_signed_char_pointer_array)[2];
> unsigned char (*v_unsigned_char_pointer_array)[2];
>
> short (*v_short_pointer_array)[2];
> signed short (*v_signed_short_pointer_array)[2];
> unsigned short (*v_unsigned_short_pointer_array)[2];
>
> int (*v_int_pointer_array)[2];
> signed int (*v_signed_int_pointer_array)[2];
> unsigned int (*v_unsigned_int_pointer_array)[2];
>
> long (*v_long_pointer_array)[2];
> signed long (*v_signed_long_pointer_array)[2];
> unsigned long (*v_unsigned_long_pointer_array)[2];
>
> float (*v_float_pointer_array)[2];
> double (*v_double_pointer_array)[2];
>
> /**** structs *******/
>
> struct t_struct {
> char v_char_member;
> short v_short_member;
> int v_int_member;
> long v_long_member;
> float v_float_member;
> double v_double_member;
> } v_struct1;
>
> struct t_struct *v_t_struct_p;
>
> struct {
> char v_char_member;
> short v_short_member;
> int v_int_member;
> long v_long_member;
> float v_float_member;
> double v_double_member;
> } v_struct2;
>
> /* typedef'd struct without a tag. */
> typedef struct {
> double v_double_member;
> int v_int_member;
> } t_struct3;
> /* GCC seems to want a variable of this type, or else it won't put out
> a symbol. */
> t_struct3 v_struct3;
>
> /**** unions *******/
>
> union t_union {
> char v_char_member;
> short v_short_member;
> int v_int_member;
> long v_long_member;
> float v_float_member;
> double v_double_member;
> } v_union;
>
> union {
> char v_char_member;
> short v_short_member;
> int v_int_member;
> long v_long_member;
> float v_float_member;
> double v_double_member;
> } v_union2;
>
> /* typedef'd union without a tag. */
> typedef union {
> double v_double_member;
> int v_int_member;
> } t_union3;
> /* GCC seems to want a variable of this type, or else it won't put out
> a symbol. */
> t_union3 v_union3;
>
> /**** Enumerations *******/
>
> enum
> /* Work around the bug for compilers which don't put out the right stabs. */
> #if __GNUC__ < 2 && !defined (_AIX)
> primary1_tag
> #endif
> {red1, green1, blue1} primary1;
>
> enum {red, green, blue} primary;
> enum colors {yellow, purple, pink} nonprimary;
>
> enum {chevy, ford} clunker;
> enum cars {bmw, porsche} sportscar;
>
> #undef FALSE
> #undef TRUE
> typedef enum {FALSE, TRUE} boolean;
> boolean v_boolean;
> /*note: aCC has bool type predefined with 'false' and 'true'*/
> typedef enum bvals {my_false, my_true} boolean2;
> boolean2 v_boolean2;
>
> enum misordered {two = 2, one = 1, zero = 0, three = 3};
>
> /* Seems like we need a variable of this type to get the type to be put
> in the executable, at least for AIX xlc. */
> enum misordered v_misordered = three;
>
> /**** Function pointers *******/
>
> char (*v_char_func) (int, int*);
> signed char (*v_signed_char_func) (int, int*);
> unsigned char (*v_unsigned_char_func) (int, int*);
>
> short (*v_short_func) (int, int*);
> signed short (*v_signed_short_func) (int, int*);
> unsigned short (*v_unsigned_short_func) (int, int*);
>
> int (*v_int_func) (int, int*);
> signed int (*v_signed_int_func) (int, int*);
> unsigned int (*v_unsigned_int_func) (int, int*);
>
> long (*v_long_func) (int, int*);
> signed long (*v_signed_long_func) (int, int*);
> unsigned long (*v_unsigned_long_func) (int, int*);
>
> long long (*v_long_long_func) (int, int*);
> signed long long (*v_signed_long_long_func) (int, int*);
> unsigned long long (*v_unsigned_long_long_func) (int, int*);
>
> float (*v_float_func) (int, int*);
> double (*v_double_func) (int, int*);
>
> int main ()
> {
> }
>
> # Copyright (C) 2001 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 2 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, write to the Free Software
> # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
>
> # Please email any bugs, comments, and/or additions to this file to:
> # bug-gdb@prep.ai.mit.edu
>
> # Written by Michael Snyder, Red Hat, Inc., 9/20/2001
>
> # This file is part of the gdb testsuite
> # Tests for type expressions using const and volatile keywords.
>
> if $tracelevel then {
> strace $tracelevel
> }
>
> #
> # test running programs
> #
> set prms_id 0
> set bug_id 0
>
> set testfile "cvexpr"
> set srcfile ${testfile}.c
> set binfile ${objdir}/${subdir}/${testfile}
>
> if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
> gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
> }
>
> gdb_exit
> gdb_start
> gdb_reinitialize_dir $srcdir/$subdir
> gdb_load ${binfile}
>
> if [target_info exists gdb_stub] {
> gdb_step_for_stub;
> }
>
> gdb_test "set print sevenbit-strings" "" ""
> gdb_test "set print address off" "" ""
> gdb_test "set width 0" "" ""
>
> set ws "\[ \t\]*"
>
> #
> # Test casting a scalar to const
> #
>
> gdb_test "whatis (const char) v_char" \
> "type = const char" \
> "(const char)"
> gdb_test "whatis (const signed char) v_signed_char" \
> "type = const signed char" \
> "(const signed char)"
> gdb_test "whatis (const unsigned char) v_unsigned_char" \
> "type = const (unsigned char|char)" \
> "(const unsigned char)"
> gdb_test "whatis (const short) v_short" \
> "type = const (short|short int)" \
> "(const short)"
> gdb_test "whatis (const signed short) v_signed_short" \
> "type = const (short|short int|signed short|signed short int)" \
> "(const signed short)"
> gdb_test "whatis (const unsigned short) v_unsigned_short" \
> "type = const (unsigned short|short unsigned int)" \
> "(const unsigned short)"
> gdb_test "whatis (const int) v_int" \
> "type = const int" \
> "(const int)"
> gdb_test "whatis (const signed int) v_signed_int" \
> "type = const (signed int|int)" \
> "(const signed int)"
> gdb_test "whatis (const unsigned int) v_unsigned_int" \
> "type = const unsigned int" \
> "(const unsigned int)"
> gdb_test "whatis (const long) v_long" \
> "type = const (long|long int)" \
> "(const long)"
> gdb_test "whatis (const signed long) v_signed_long" \
> "type = const (signed |)long( int|)" \
> "(const signed long)"
> gdb_test "whatis (const unsigned long) v_unsigned_long" \
> "type = const (unsigned long|long unsigned int)" \
> "(const unsigned long)"
> gdb_test "whatis (const long long) v_long_long" \
> "type = const long long( int|)" \
> "(const long long)"
> gdb_test "whatis (const signed long long) v_signed_long_long" \
> "type = const (signed |)long long( int|)" \
> "(const signed long long)"
> gdb_test "whatis (const unsigned long long) v_unsigned_long_long" \
> "type = const (unsigned long long|long long unsigned int)" \
> "(const unsigned long long)"
> gdb_test "whatis (const float) v_float" \
> "type = const float" \
> "(const float)"
> gdb_test "whatis (const double) v_double" \
> "type = const double" \
> "(const double)"
>
> #
> # Test casting a scalar to volatile
> #
>
> gdb_test "whatis (volatile char) v_char" \
> "type = volatile char" \
> "(volatile char)"
> gdb_test "whatis (volatile signed char) v_signed_char" \
> "type = volatile signed char" \
> "(volatile signed char)"
> gdb_test "whatis (volatile unsigned char) v_unsigned_char" \
> "type = volatile (unsigned char|char)" \
> "(volatile unsigned char)"
> gdb_test "whatis (volatile short) v_short" \
> "type = volatile (short|short int)" \
> "(volatile short)"
> gdb_test "whatis (volatile signed short) v_signed_short" \
> "type = volatile (short|short int|signed short|signed short int)" \
> "(volatile signed short)"
> gdb_test "whatis (volatile unsigned short) v_unsigned_short" \
> "type = volatile (unsigned short|short unsigned int)" \
> "(volatile unsigned short)"
> gdb_test "whatis (volatile int) v_int" \
> "type = volatile int" \
> "(volatile int)"
> gdb_test "whatis (volatile signed int) v_signed_int" \
> "type = volatile (signed int|int)" \
> "(volatile signed int)"
> gdb_test "whatis (volatile unsigned int) v_unsigned_int" \
> "type = volatile unsigned int" \
> "(volatile unsigned int)"
> gdb_test "whatis (volatile long) v_long" \
> "type = volatile (long|long int)" \
> "(volatile long)"
> gdb_test "whatis (volatile signed long) v_signed_long" \
> "type = volatile (signed |)long( int|)" \
> "(volatile signed long)"
> gdb_test "whatis (volatile unsigned long) v_unsigned_long" \
> "type = volatile (unsigned long|long unsigned int)" \
> "(volatile unsigned long)"
> gdb_test "whatis (volatile long long) v_long_long" \
> "type = volatile long long( int|)" \
> "(volatile long long)"
> gdb_test "whatis (volatile signed long long) v_signed_long_long" \
> "type = volatile (signed |)long long( int|)" \
> "(volatile signed long long)"
> gdb_test "whatis (volatile unsigned long long) v_unsigned_long_long" \
> "type = volatile (unsigned long long|long long unsigned int)" \
> "(volatile unsigned long long)"
> gdb_test "whatis (volatile float) v_float" \
> "type = volatile float" \
> "(volatile float)"
> gdb_test "whatis (volatile double) v_double" \
> "type = volatile double" \
> "(volatile double)"
>
> #
> # Combine const and volatile
> #
>
> gdb_test "whatis (const volatile int) v_int" \
> "type = const volatile int" \
> "(const volatile int)"
> gdb_test "whatis (volatile const int) v_int" \
> "type = const volatile int" \
> "(volatile const int)"
> gdb_test "whatis (const int volatile) v_int" \
> "type = const volatile int" \
> "(const int volatile)"
> gdb_test "whatis (volatile int const) v_int" \
> "type = const volatile int" \
> "(volatile int const)"
> gdb_test "whatis (int const volatile) v_int" \
> "type = const volatile int" \
> "(int const volatile)"
> gdb_test "whatis (int volatile const) v_int" \
> "type = const volatile int" \
> "(int volatile const)"
>
> gdb_test "whatis (const volatile int *) v_int_pointer" \
> "type = const volatile int${ws}\\*" \
> "(const volatile int *)"
> gdb_test "whatis (volatile const int *) v_int_pointer" \
> "type = const volatile int${ws}\\*" \
> "(volatile const int *)"
> gdb_test "whatis (const int volatile *) v_int_pointer" \
> "type = const volatile int${ws}\\*" \
> "(const int volatile)"
> gdb_test "whatis (volatile int const *) v_int_pointer" \
> "type = const volatile int${ws}\\*" \
> "(volatile int const *)"
> gdb_test "whatis (int const volatile *) v_int_pointer" \
> "type = const volatile int${ws}\\*" \
> "(int const volatile *)"
> gdb_test "whatis (int volatile const *) v_int_pointer" \
> "type = const volatile int${ws}\\*" \
> "(int volatile const *)"
> gdb_test "whatis (int * const volatile) v_int_pointer" \
> "type = int${ws}\\*${ws}const volatile" \
> "(int * const volatile)"
> gdb_test "whatis (int * volatile const) v_int_pointer" \
> "type = int${ws}\\*${ws}const volatile" \
> "(int * volatile const)"
>
> #
> # Put 'signed' and 'unsigned' before const/volatile (FIXME)
> #
>
> #gdb_test "whatis (signed const char) v_signed_char" \
> # "type = const char" \
> # "(signed const char)"
> #gdb_test "whatis (unsigned const char) v_unsigned_char" \
> # "type = const (unsigned char|char)" \
> # "(unsigned const char)"
> #gdb_test "whatis (signed const short) v_signed_short" \
> # "type = const (short|short int|signed short|signed short int)" \
> # "(signed const short)"
> #gdb_test "whatis (unsigned const short) v_unsigned_short" \
> # "type = const (unsigned short|short unsigned int)" \
> # "(unsigned const short)"
> #gdb_test "whatis (signed const int) v_signed_int" \
> # "type = const (signed int|int)" \
> # "(signed const int)"
> #gdb_test "whatis (unsigned const int) v_unsigned_int" \
> # "type = const unsigned int" \
> # "(unsigned const int)"
> #gdb_test "whatis (signed const long) v_signed_long" \
> # "type = const (signed |)long( int|)" \
> # "(signed const long)"
> #gdb_test "whatis (unsigned const long) v_unsigned_long" \
> # "type = const (unsigned long|long unsigned int)" \
> # "(unsigned const long)"
> #gdb_test "whatis (signed const long long) v_signed_long_long" \
> # "type = const (signed |)long long( int|)" \
> # "(signed const long long)"
> #gdb_test "whatis (unsigned const long long) v_unsigned_long_long" \
> # "type = const (unsigned long long|long long unsigned int)" \
> # "(const unsigned long long)"
>
> #gdb_test "whatis (signed volatile char) v_signed_char" \
> # "type = volatile char" \
> # "(signed volatile char)"
> #gdb_test "whatis (unsigned volatile char) v_unsigned_char" \
> # "type = volatile (unsigned char|char)" \
> # "(unsigned volatile char)"
> #gdb_test "whatis (signed volatile short) v_signed_short" \
> # "type = volatile (short|short int|signed short|signed short int)" \
> # "(signed volatile short)"
> #gdb_test "whatis (unsigned volatile short) v_unsigned_short" \
> # "type = volatile (unsigned short|short unsigned int)" \
> # "(unsigned volatile short)"
> #gdb_test "whatis (signed volatile int) v_signed_int" \
> # "type = volatile (signed int|int)" \
> # "(signed volatile int)"
> #gdb_test "whatis (unsigned volatile int) v_unsigned_int" \
> # "type = volatile unsigned int" \
> # "(unsigned volatile int)"
> #gdb_test "whatis (signed volatile long) v_signed_long" \
> # "type = volatile (signed |)long( int|)" \
> # "(signed volatile long)"
> #gdb_test "whatis (unsigned volatile long) v_unsigned_long" \
> # "type = volatile (unsigned long|long unsigned int)" \
> # "(unsigned volatile long)"
> #gdb_test "whatis (signed volatile long long) v_signed_long_long" \
> # "type = volatile (signed |)long long( int|)" \
> # "(signed volatile long long)"
> #gdb_test "whatis (unsigned volatile long long) v_unsigned_long_long" \
> # "type = volatile (unsigned long long|long long unsigned int)" \
> # "(unsigned volatile long long)"
>
> #
> # Now put the 'const' and 'volatile' keywords after the base type.
> #
>
> gdb_test "whatis (char const) v_char" \
> "type = const char" \
> "(char const)"
> gdb_test "whatis (signed char const) v_signed_char" \
> "type = const signed char" \
> "(signed char const)"
> gdb_test "whatis (unsigned char const) v_unsigned_char" \
> "type = const (unsigned char|char)" \
> "(unsigned char const)"
> gdb_test "whatis (short const) v_short" \
> "type = const (short|short int)" \
> "(short const)"
> gdb_test "whatis (signed short const) v_signed_short" \
> "type = const (short|short int|signed short|signed short int)" \
> "(signed short const)"
> gdb_test "whatis (unsigned short const) v_unsigned_short" \
> "type = const (unsigned short|short unsigned int)" \
> "(unsigned short const)"
> gdb_test "whatis (int const) v_int" \
> "type = const int" \
> "(int const)"
> gdb_test "whatis (signed int const) v_signed_int" \
> "type = const (signed int|int)" \
> "(signed int const)"
> gdb_test "whatis (unsigned int const) v_unsigned_int" \
> "type = const unsigned int" \
> "(unsigned int const)"
> gdb_test "whatis (long const) v_long" \
> "type = const (long|long int)" \
> "(long const)"
> gdb_test "whatis (signed long const) v_signed_long" \
> "type = const (signed |)long( int|)" \
> "(signed long const)"
> gdb_test "whatis (unsigned long const) v_unsigned_long" \
> "type = const (unsigned long|long unsigned int)" \
> "(unsigned long const)"
> gdb_test "whatis (long long const) v_long_long" \
> "type = const long long( int|)" \
> "(long long const)"
> gdb_test "whatis (signed long long const) v_signed_long_long" \
> "type = const (signed |)long long( int|)" \
> "(signed long long const)"
> gdb_test "whatis (unsigned long long const) v_unsigned_long_long" \
> "type = const (unsigned long long|long long unsigned int)" \
> "(unsigned long long const)"
> gdb_test "whatis (float const) v_float" \
> "type = const float" \
> "(float const)"
> gdb_test "whatis (double const) v_double" \
> "type = const double" \
> "(double const)"
>
> gdb_test "whatis (char volatile) v_char" \
> "type = volatile char" \
> "(char volatile)"
> gdb_test "whatis (signed char volatile) v_signed_char" \
> "type = volatile signed char" \
> "(signed char volatile)"
> gdb_test "whatis (unsigned char volatile) v_unsigned_char" \
> "type = volatile (unsigned char|char)" \
> "(unsigned char volatile)"
> gdb_test "whatis (short volatile) v_short" \
> "type = volatile (short|short int)" \
> "(short volatile)"
> gdb_test "whatis (signed short volatile) v_signed_short" \
> "type = volatile (short|short int|signed short|signed short int)" \
> "(signed short volatile)"
> gdb_test "whatis (unsigned short volatile) v_unsigned_short" \
> "type = volatile (unsigned short|short unsigned int)" \
> "(unsigned short volatile)"
> gdb_test "whatis (int volatile) v_int" \
> "type = volatile int" \
> "(int volatile)"
> gdb_test "whatis (signed int volatile) v_signed_int" \
> "type = volatile (signed int|int)" \
> "(signed int volatile)"
> gdb_test "whatis (unsigned int volatile) v_unsigned_int" \
> "type = volatile unsigned int" \
> "(unsigned int volatile)"
> gdb_test "whatis (long volatile) v_long" \
> "type = volatile (long|long int)" \
> "(long volatile)"
> gdb_test "whatis (signed long volatile) v_signed_long" \
> "type = volatile (signed |)long( int|)" \
> "(signed long volatile)"
> gdb_test "whatis (unsigned long volatile) v_unsigned_long" \
> "type = volatile (unsigned long|long unsigned int)" \
> "(unsigned long volatile)"
> gdb_test "whatis (long long volatile) v_long_long" \
> "type = volatile long long( int|)" \
> "(long long volatile)"
> gdb_test "whatis (signed long long volatile) v_signed_long_long" \
> "type = volatile (signed |)long long( int|)" \
> "(signed long long volatile)"
> gdb_test "whatis (unsigned long long volatile) v_unsigned_long_long" \
> "type = volatile (unsigned long long|long long unsigned int)" \
> "(unsigned long long volatile)"
> gdb_test "whatis (float volatile) v_float" \
> "type = volatile float" \
> "(float volatile)"
> gdb_test "whatis (double volatile) v_double" \
> "type = volatile double" \
> "(double volatile)"
>
> #
> # enums
> #
>
> gdb_test "whatis (const enum misordered) v_misordered" \
> "type = const enum misordered" \
> "(const enum misordered)"
> gdb_test "whatis (enum misordered const) v_misordered" \
> "type = const enum misordered" \
> "(enum misordered const)"
> gdb_test "whatis (volatile enum misordered) v_misordered" \
> "type = volatile enum misordered" \
> "(volatile enum misordered)"
> gdb_test "whatis (enum misordered volatile) v_misordered" \
> "type = volatile enum misordered" \
> "(enum misordered volatile)"
>
> #
> # Pointers
> #
>
> gdb_test "whatis (const int *) v_int_pointer" \
> "type = const int${ws}\\*" \
> "(const int *)"
> gdb_test "whatis (int const *) v_int_pointer" \
> "type = const int${ws}\\*" \
> "(int const *)"
> gdb_test "whatis (int * const) v_int_pointer" \
> "type = int \\*${ws}const" \
> "(int * const)"
> gdb_test "whatis (const int * const) v_int_pointer" \
> "type = const int${ws}\\*${ws}const" \
> "(const int * const)"
> gdb_test "whatis (int const * const) v_int_pointer" \
> "type = const int${ws}\\*${ws}const" \
> "(int const * const)"
>
> gdb_test "whatis (const int **) v_int_pointer_pointer" \
> "type = const int${ws}\\*${ws}\\*" \
> "(const int **)"
> gdb_test "whatis (int const **) v_int_pointer_pointer" \
> "type = const int${ws}\\*${ws}\\*" \
> "(int const **)"
> gdb_test "whatis (int ** const) v_int_pointer_pointer" \
> "type = int \\*${ws}\\*${ws}const" \
> "(int ** const)"
> gdb_test "whatis (const int * const *) v_int_pointer_pointer" \
> "type = const int${ws}\\*${ws}const${ws}\\*" \
> "(const int * const *)"
> gdb_test "whatis (int const * const *) v_int_pointer_pointer" \
> "type = const int${ws}\\*${ws}const${ws}\\*" \
> "(int const * const *)"
> gdb_test "whatis (const int * const * const) v_int_pointer_pointer" \
> "type = const int${ws}\\*${ws}const${ws}\\*${ws}const" \
> "(const int * const * const)"
> gdb_test "whatis (int const * const * const) v_int_pointer_pointer" \
> "type = const int${ws}\\*${ws}const${ws}\\*${ws}const" \
> "(int const * const * const)"
>
> #
> # Arrays TODO
> #
>
> #
> # Pointers to arrays, arrays of pointers TODO
> #
>
> #
> # Structs and Unions
> #
>
> gdb_test "whatis (const struct t_struct) v_struct1" \
> "type = const struct t_struct" \
> "(const struct t_struct)"
> gdb_test "whatis (const union t_union) v_union" \
> "type = const union t_union" \
> "(const union t_union)"
> gdb_test "whatis (struct t_struct const) v_struct1" \
> "type = const struct t_struct" \
> "(struct t_struct const)"
> gdb_test "whatis (union t_union const) v_union" \
> "type = const union t_union" \
> "(union t_union const)"
> gdb_test "whatis (const struct t_struct *) &v_struct1" \
> "type = const struct t_struct${ws}\\*" \
> "(const struct t_struct *)"
> gdb_test "whatis (const union t_union *) &v_union" \
> "type = const union t_union${ws}\\*" \
> "(const union t_union *)"
> gdb_test "whatis (struct t_struct const *) &v_struct1" \
> "type = const struct t_struct${ws}\\*" \
> "(struct t_struct const *)"
> gdb_test "whatis (union t_union const *) &v_union" \
> "type = const union t_union${ws}\\*" \
> "(union t_union const *)"
> gdb_test "whatis (struct t_struct * const) &v_struct1" \
> "type = struct t_struct${ws}\\*${ws}const" \
> "(struct t_struct * const)"
> gdb_test "whatis (union t_union * const) &v_union" \
> "type = union t_union${ws}\\*${ws}const" \
> "(union t_union * const)"
> gdb_test "whatis (const struct t_struct * const) &v_struct1" \
> "type = const struct t_struct${ws}\\*${ws}const" \
> "(const struct t_struct * const)"
> gdb_test "whatis (const union t_union * const) &v_union" \
> "type = const union t_union${ws}\\*${ws}const" \
> "(const union t_union * const)"
> gdb_test "whatis (struct t_struct const * const) &v_struct1" \
> "type = const struct t_struct${ws}\\*${ws}const" \
> "(struct t_struct const * const)"
> gdb_test "whatis (union t_union const * const) &v_union" \
> "type = const union t_union${ws}\\*${ws}const" \
> "(union t_union const * const)"
>
> #
> # Function pointers TODO
> #

--
Fernando Nasser
Red Hat - Toronto E-Mail: fnasser@redhat.com
2323 Yonge Street, Suite #300
Toronto, Ontario M4P 2C9