This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

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


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


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]