projects / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
2001-09-20 Michael Snyder <msnyder@redhat.com>
[binutils-gdb.git] / gdb / parse.c
diff --git a/gdb/parse.c b/gdb/parse.c
index a39c21dcfcb531a4601a36c91cd11ea9d575e2e5..64966edf2b5aa543f5a9decda9619a8196cb6a44 100644 (file)
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -1,5 +1,6 @@
 /* Parse expressions for GDB.
 /* Parse expressions for GDB.
-   Copyright (C) 1986, 89, 90, 91, 94, 98, 1999 Free Software Foundation, Inc.
+   Copyright 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+   1998, 1999, 2000, 2001 Free Software Foundation, Inc.
    Modified from expread.y by the Department of Computer Science at the
    State University of New York at Buffalo, 1991.
 
    Modified from expread.y by the Department of Computer Science at the
    State University of New York at Buffalo, 1991.
 
@@ -43,6 +44,10 @@
 #include "parser-defs.h"
 #include "gdbcmd.h"
 #include "symfile.h"           /* for overlay functions */
 #include "parser-defs.h"
 #include "gdbcmd.h"
 #include "symfile.h"           /* for overlay functions */
+#include "inferior.h"          /* for NUM_PSEUDO_REGS.  NOTE: replace 
+                                  with "gdbarch.h" when appropriate.  */
+#include "doublest.h"
+
 \f
 /* Symbols which architectures can redefine.  */
 
 \f
 /* Symbols which architectures can redefine.  */
 
@@ -108,9 +113,7 @@ struct std_regs *std_regs;
    REGISTER_NAME; std_regs; or a target specific alias hook. */
 
 int
    REGISTER_NAME; std_regs; or a target specific alias hook. */
 
 int
-target_map_name_to_register (str, len)
-     char *str;
-     int len;
+target_map_name_to_register (char *str, int len)
 {
   int i;
 
 {
   int i;
 
@@ -131,7 +134,15 @@ target_map_name_to_register (str, len)
        return i;
       }
 
        return i;
       }
 
-  /* Try standard aliases */
+  /* Try pseudo-registers, if any. */
+  for (i = NUM_REGS; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
+    if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
+       && STREQN (str, REGISTER_NAME (i), len))
+      {
+       return i;
+      }
+
+  /* Try standard aliases. */
   for (i = 0; i < num_std_regs; i++)
     if (std_regs[i].name && len == strlen (std_regs[i].name)
        && STREQN (str, std_regs[i].name, len))
   for (i = 0; i < num_std_regs; i++)
     if (std_regs[i].name && len == strlen (std_regs[i].name)
        && STREQN (str, std_regs[i].name, len))
@@ -146,7 +157,7 @@ target_map_name_to_register (str, len)
    saving the data about any containing call.  */
 
 void
    saving the data about any containing call.  */
 
 void
-start_arglist ()
+start_arglist (void)
 {
   register struct funcall *new;
 
 {
   register struct funcall *new;
 
@@ -161,13 +172,13 @@ start_arglist ()
    and restore the data for the containing function call.  */
 
 int
    and restore the data for the containing function call.  */
 
 int
-end_arglist ()
+end_arglist (void)
 {
   register int val = arglist_len;
   register struct funcall *call = funcall_chain;
   funcall_chain = call->next;
   arglist_len = call->arglist_len;
 {
   register int val = arglist_len;
   register struct funcall *call = funcall_chain;
   funcall_chain = call->next;
   arglist_len = call->arglist_len;
-  free ((PTR) call);
+  xfree (call);
   return val;
 }
 
   return val;
 }
 
@@ -182,7 +193,7 @@ free_funcalls (void *ignore)
   for (call = funcall_chain; call; call = next)
     {
       next = call->next;
   for (call = funcall_chain; call; call = next)
     {
       next = call->next;
-      free ((PTR) call);
+      xfree (call);
     }
 }
 \f
     }
 }
 \f
@@ -195,8 +206,7 @@ free_funcalls (void *ignore)
    a register through here */
 
 void
    a register through here */
 
 void
-write_exp_elt (expelt)
-     union exp_element expelt;
+write_exp_elt (union exp_element expelt)
 {
   if (expout_ptr >= expout_size)
     {
 {
   if (expout_ptr >= expout_size)
     {
@@ -209,8 +219,7 @@ write_exp_elt (expelt)
 }
 
 void
 }
 
 void
-write_exp_elt_opcode (expelt)
-     enum exp_opcode expelt;
+write_exp_elt_opcode (enum exp_opcode expelt)
 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 
@@ -220,8 +229,7 @@ write_exp_elt_opcode (expelt)
 }
 
 void
 }
 
 void
-write_exp_elt_sym (expelt)
-     struct symbol *expelt;
+write_exp_elt_sym (struct symbol *expelt)
 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 
@@ -231,8 +239,7 @@ write_exp_elt_sym (expelt)
 }
 
 void
 }
 
 void
-write_exp_elt_block (b)
-     struct block *b;
+write_exp_elt_block (struct block *b)
 {
   union exp_element tmp;
   tmp.block = b;
 {
   union exp_element tmp;
   tmp.block = b;
@@ -240,8 +247,7 @@ write_exp_elt_block (b)
 }
 
 void
 }
 
 void
-write_exp_elt_longcst (expelt)
-     LONGEST expelt;
+write_exp_elt_longcst (LONGEST expelt)
 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 
@@ -251,8 +257,7 @@ write_exp_elt_longcst (expelt)
 }
 
 void
 }
 
 void
-write_exp_elt_dblcst (expelt)
-     DOUBLEST expelt;
+write_exp_elt_dblcst (DOUBLEST expelt)
 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 
@@ -262,8 +267,7 @@ write_exp_elt_dblcst (expelt)
 }
 
 void
 }
 
 void
-write_exp_elt_type (expelt)
-     struct type *expelt;
+write_exp_elt_type (struct type *expelt)
 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 
@@ -273,8 +277,7 @@ write_exp_elt_type (expelt)
 }
 
 void
 }
 
 void
-write_exp_elt_intern (expelt)
-     struct internalvar *expelt;
+write_exp_elt_intern (struct internalvar *expelt)
 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 
@@ -305,8 +308,7 @@ write_exp_elt_intern (expelt)
 
 
 void
 
 
 void
-write_exp_string (str)
-     struct stoken str;
+write_exp_string (struct stoken str)
 {
   register int len = str.length;
   register int lenelt;
 {
   register int len = str.length;
   register int lenelt;
@@ -355,8 +357,7 @@ write_exp_string (str)
    either end of the bitstring. */
 
 void
    either end of the bitstring. */
 
 void
-write_exp_bitstring (str)
-     struct stoken str;
+write_exp_bitstring (struct stoken str)
 {
   register int bits = str.length;      /* length in bits */
   register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 {
   register int bits = str.length;      /* length in bits */
   register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
@@ -403,15 +404,15 @@ static struct type *msym_data_symbol_type;
 static struct type *msym_unknown_symbol_type;
 
 void
 static struct type *msym_unknown_symbol_type;
 
 void
-write_exp_msymbol (msymbol, text_symbol_type, data_symbol_type)
-     struct minimal_symbol *msymbol;
-     struct type *text_symbol_type;
-     struct type *data_symbol_type;
+write_exp_msymbol (struct minimal_symbol *msymbol, 
+                  struct type *text_symbol_type, 
+                  struct type *data_symbol_type)
 {
   CORE_ADDR addr;
 
   write_exp_elt_opcode (OP_LONG);
 {
   CORE_ADDR addr;
 
   write_exp_elt_opcode (OP_LONG);
-  write_exp_elt_type (lookup_pointer_type (builtin_type_void));
+  /* Let's make the type big enough to hold a 64-bit address.  */
+  write_exp_elt_type (builtin_type_CORE_ADDR);
 
   addr = SYMBOL_VALUE_ADDRESS (msymbol);
   if (overlay_debugging)
 
   addr = SYMBOL_VALUE_ADDRESS (msymbol);
   if (overlay_debugging)
@@ -467,8 +468,7 @@ write_exp_msymbol (msymbol, text_symbol_type, data_symbol_type)
  */
 
 void
  */
 
 void
-write_dollar_variable (str)
-     struct stoken str;
+write_dollar_variable (struct stoken str)
 {
   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
      and $$digits (equivalent to $<-digits> if you could type that). */
 {
   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
      and $$digits (equivalent to $<-digits> if you could type that). */
@@ -584,12 +584,8 @@ static const char coloncolon[2] =
 {':', ':'};
 
 struct symbol *
 {':', ':'};
 
 struct symbol *
-parse_nested_classes_for_hpacc (name, len, token, class_prefix, argptr)
-     char *name;
-     int len;
-     char **token;
-     int *class_prefix;
-     char **argptr;
+parse_nested_classes_for_hpacc (char *name, int len, char **token,
+                               int *class_prefix, char **argptr)
 {
   /* Comment below comes from decode_line_1 which has very similar
      code, which is called for "break" command parsing. */
 {
   /* Comment below comes from decode_line_1 which has very similar
      code, which is called for "break" command parsing. */
@@ -743,8 +739,7 @@ parse_nested_classes_for_hpacc (name, len, token, class_prefix, argptr)
 }
 
 char *
 }
 
 char *
-find_template_name_end (p)
-     char *p;
+find_template_name_end (char *p)
 {
   int depth = 1;
   int just_seen_right = 0;
 {
   int depth = 1;
   int just_seen_right = 0;
@@ -809,8 +804,7 @@ find_template_name_end (p)
    of a string token.  */
 
 char *
    of a string token.  */
 
 char *
-copy_name (token)
-     struct stoken token;
+copy_name (struct stoken token)
 {
   memcpy (namecopy, token.ptr, token.length);
   namecopy[token.length] = 0;
 {
   memcpy (namecopy, token.ptr, token.length);
   namecopy[token.length] = 0;
@@ -821,8 +815,7 @@ copy_name (token)
    to prefix form (in which we can conveniently print or execute it).  */
 
 static void
    to prefix form (in which we can conveniently print or execute it).  */
 
 static void
-prefixify_expression (expr)
-     register struct expression *expr;
+prefixify_expression (register struct expression *expr)
 {
   register int len =
   sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 {
   register int len =
   sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
@@ -841,9 +834,7 @@ prefixify_expression (expr)
    whose last exp_element is at index ENDPOS - 1 in EXPR.  */
 
 int
    whose last exp_element is at index ENDPOS - 1 in EXPR.  */
 
 int
-length_of_subexp (expr, endpos)
-     register struct expression *expr;
-     register int endpos;
+length_of_subexp (register struct expression *expr, register int endpos)
 {
   register int oplen = 1;
   register int args = 0;
 {
   register int oplen = 1;
   register int args = 0;
@@ -977,11 +968,8 @@ length_of_subexp (expr, endpos)
    In the process, convert it from suffix to prefix form.  */
 
 static void
    In the process, convert it from suffix to prefix form.  */
 
 static void
-prefixify_subexp (inexpr, outexpr, inend, outbeg)
-     register struct expression *inexpr;
-     struct expression *outexpr;
-     register int inend;
-     int outbeg;
+prefixify_subexp (register struct expression *inexpr,
+                 struct expression *outexpr, register int inend, int outbeg)
 {
   register int oplen = 1;
   register int args = 0;
 {
   register int oplen = 1;
   register int args = 0;
@@ -1146,10 +1134,7 @@ prefixify_subexp (inexpr, outexpr, inend, outbeg)
    If COMMA is nonzero, stop if a comma is reached.  */
 
 struct expression *
    If COMMA is nonzero, stop if a comma is reached.  */
 
 struct expression *
-parse_exp_1 (stringptr, block, comma)
-     char **stringptr;
-     struct block *block;
-     int comma;
+parse_exp_1 (char **stringptr, struct block *block, int comma)
 {
   struct cleanup *old_chain;
 
 {
   struct cleanup *old_chain;
 
@@ -1211,8 +1196,7 @@ parse_exp_1 (stringptr, block, comma)
    to use up all of the contents of STRING.  */
 
 struct expression *
    to use up all of the contents of STRING.  */
 
 struct expression *
-parse_expression (string)
-     char *string;
+parse_expression (char *string)
 {
   register struct expression *exp;
   exp = parse_exp_1 (&string, 0, 0);
 {
   register struct expression *exp;
   exp = parse_exp_1 (&string, 0, 0);
@@ -1225,8 +1209,7 @@ parse_expression (string)
    probably useful for any language which declares its types "backwards".  */
 
 void
    probably useful for any language which declares its types "backwards".  */
 
 void
-push_type (tp)
-     enum type_pieces tp;
+push_type (enum type_pieces tp)
 {
   if (type_stack_depth == type_stack_size)
     {
 {
   if (type_stack_depth == type_stack_size)
     {
@@ -1238,8 +1221,7 @@ push_type (tp)
 }
 
 void
 }
 
 void
-push_type_int (n)
-     int n;
+push_type_int (int n)
 {
   if (type_stack_depth == type_stack_size)
     {
 {
   if (type_stack_depth == type_stack_size)
     {
@@ -1251,7 +1233,7 @@ push_type_int (n)
 }
 
 enum type_pieces
 }
 
 enum type_pieces
-pop_type ()
+pop_type (void)
 {
   if (type_stack_depth)
     return type_stack[--type_stack_depth].piece;
 {
   if (type_stack_depth)
     return type_stack[--type_stack_depth].piece;
@@ -1259,7 +1241,7 @@ pop_type ()
 }
 
 int
 }
 
 int
-pop_type_int ()
+pop_type_int (void)
 {
   if (type_stack_depth)
     return type_stack[--type_stack_depth].int_val;
 {
   if (type_stack_depth)
     return type_stack[--type_stack_depth].int_val;
@@ -1270,10 +1252,11 @@ pop_type_int ()
 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
    as modified by all the stuff on the stack.  */
 struct type *
 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
    as modified by all the stuff on the stack.  */
 struct type *
-follow_types (follow_type)
-     struct type *follow_type;
+follow_types (struct type *follow_type)
 {
   int done = 0;
 {
   int done = 0;
+  int make_const = 0;
+  int make_volatile = 0;
   int array_size;
   struct type *range_type;
 
   int array_size;
   struct type *range_type;
 
@@ -1282,12 +1265,40 @@ follow_types (follow_type)
       {
       case tp_end:
        done = 1;
       {
       case tp_end:
        done = 1;
+       if (make_const)
+         follow_type = make_cv_type (make_const, 
+                                     TYPE_VOLATILE (follow_type), 
+                                     follow_type, 0);
+       if (make_volatile)
+         follow_type = make_cv_type (TYPE_CONST (follow_type), 
+                                     make_volatile, 
+                                     follow_type, 0);
+       break;
+      case tp_const:
+       make_const = 1;
+       break;
+      case tp_volatile:
+       make_volatile = 1;
        break;
       case tp_pointer:
        follow_type = lookup_pointer_type (follow_type);
        break;
       case tp_pointer:
        follow_type = lookup_pointer_type (follow_type);
+       if (make_const)
+         follow_type = make_cv_type (make_const, 
+                                     TYPE_VOLATILE (follow_type), 
+                                     follow_type, 0);
+       if (make_volatile)
+         follow_type = make_cv_type (TYPE_CONST (follow_type), 
+                                     make_volatile, 
+                                     follow_type, 0);
+       make_const = make_volatile = 0;
        break;
       case tp_reference:
        follow_type = lookup_reference_type (follow_type);
        break;
       case tp_reference:
        follow_type = lookup_reference_type (follow_type);
+       if (make_const)
+         follow_type = make_cv_type (make_const, TYPE_VOLATILE (follow_type), follow_type, 0);
+       if (make_volatile)
+         follow_type = make_cv_type (TYPE_CONST (follow_type), make_volatile, follow_type, 0);
+       make_const = make_volatile = 0;
        break;
       case tp_array:
        array_size = pop_type_int ();
        break;
       case tp_array:
        array_size = pop_type_int ();
@@ -1315,7 +1326,7 @@ follow_types (follow_type)
 \f
 static void build_parse (void);
 static void
 \f
 static void build_parse (void);
 static void
-build_parse ()
+build_parse (void)
 {
   int i;
 
 {
   int i;
 
@@ -1354,30 +1365,42 @@ build_parse ()
   i = 0;
   /* fill it in */
 #ifdef PC_REGNUM
   i = 0;
   /* fill it in */
 #ifdef PC_REGNUM
-  std_regs[i].name = "pc";
-  std_regs[i].regnum = PC_REGNUM;
-  i++;
+  if (PC_REGNUM >= 0)
+    {
+      std_regs[i].name = "pc";
+      std_regs[i].regnum = PC_REGNUM;
+      i++;
+    }
 #endif
 #ifdef FP_REGNUM
 #endif
 #ifdef FP_REGNUM
-  std_regs[i].name = "fp";
-  std_regs[i].regnum = FP_REGNUM;
-  i++;
+  if (FP_REGNUM >= 0)
+    {
+      std_regs[i].name = "fp";
+      std_regs[i].regnum = FP_REGNUM;
+      i++;
+    }
 #endif
 #ifdef SP_REGNUM
 #endif
 #ifdef SP_REGNUM
-  std_regs[i].name = "sp";
-  std_regs[i].regnum = SP_REGNUM;
-  i++;
+  if (SP_REGNUM >= 0)
+    {
+      std_regs[i].name = "sp";
+      std_regs[i].regnum = SP_REGNUM;
+      i++;
+    }
 #endif
 #ifdef PS_REGNUM
 #endif
 #ifdef PS_REGNUM
-  std_regs[i].name = "ps";
-  std_regs[i].regnum = PS_REGNUM;
-  i++;
+  if (PS_REGNUM >= 0)
+    {
+      std_regs[i].name = "ps";
+      std_regs[i].regnum = PS_REGNUM;
+      i++;
+    }
 #endif
   memset (&std_regs[i], 0, sizeof (std_regs[i]));
 }
 
 void
 #endif
   memset (&std_regs[i], 0, sizeof (std_regs[i]));
 }
 
 void
-_initialize_parse ()
+_initialize_parse (void)
 {
   type_stack_size = 80;
   type_stack_depth = 0;
 {
   type_stack_size = 80;
   type_stack_depth = 0;