1 /* Parse expressions for GDB.
3 Copyright (C) 1986, 1989-2001, 2004-2005, 2007-2012 Free Software
6 Modified from expread.y by the Department of Computer Science at the
7 State University of New York at Buffalo, 1991.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 /* Parse an expression from text in a string,
25 and return the result as a struct expression pointer.
26 That structure contains arithmetic operations in reverse polish,
27 with constants represented by operations that are followed by special data.
28 See expression.h for the details of the format.
29 What is important here is that it can be built up sequentially
30 during the process of parsing; the lower levels of the tree always
31 come first in the result. */
35 #include "arch-utils.h"
36 #include "gdb_string.h"
40 #include "expression.h"
45 #include "parser-defs.h"
47 #include "symfile.h" /* for overlay functions */
50 #include "gdb_assert.h"
54 #include "exceptions.h"
55 #include "user-regs.h"
57 /* Standard set of definitions for printing, dumping, prefixifying,
58 * and evaluating expressions. */
60 const struct exp_descriptor exp_descriptor_standard
=
62 print_subexp_standard
,
63 operator_length_standard
,
64 operator_check_standard
,
66 dump_subexp_body_standard
,
67 evaluate_subexp_standard
70 /* Global variables declared in parser-defs.h (and commented there). */
71 struct expression
*expout
;
74 const struct block
*expression_context_block
;
75 CORE_ADDR expression_context_pc
;
76 const struct block
*innermost_block
;
78 static struct type_stack type_stack
;
84 /* True if parsing an expression to attempt completion. */
87 /* The index of the last struct expression directly before a '.' or
88 '->'. This is set when parsing and is only used when completing a
89 field name. It is -1 if no dereference operation was found. */
90 static int expout_last_struct
= -1;
92 /* If we are completing a tagged type name, this will be nonzero. */
93 static enum type_code expout_tag_completion_type
= TYPE_CODE_UNDEF
;
95 /* The token for tagged type name completion. */
96 static char *expout_completion_name
;
99 static unsigned int expressiondebug
= 0;
101 show_expressiondebug (struct ui_file
*file
, int from_tty
,
102 struct cmd_list_element
*c
, const char *value
)
104 fprintf_filtered (file
, _("Expression debugging is %s.\n"), value
);
108 /* Non-zero if an expression parser should set yydebug. */
112 show_parserdebug (struct ui_file
*file
, int from_tty
,
113 struct cmd_list_element
*c
, const char *value
)
115 fprintf_filtered (file
, _("Parser debugging is %s.\n"), value
);
119 static void free_funcalls (void *ignore
);
121 static int prefixify_subexp (struct expression
*, struct expression
*, int,
124 static struct expression
*parse_exp_in_context (char **, CORE_ADDR
,
125 const struct block
*, int,
128 void _initialize_parse (void);
130 /* Data structure for saving values of arglist_len for function calls whose
131 arguments contain other function calls. */
135 struct funcall
*next
;
139 static struct funcall
*funcall_chain
;
141 /* Begin counting arguments for a function call,
142 saving the data about any containing call. */
149 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
150 new->next
= funcall_chain
;
151 new->arglist_len
= arglist_len
;
156 /* Return the number of arguments in a function call just terminated,
157 and restore the data for the containing function call. */
162 int val
= arglist_len
;
163 struct funcall
*call
= funcall_chain
;
165 funcall_chain
= call
->next
;
166 arglist_len
= call
->arglist_len
;
171 /* Free everything in the funcall chain.
172 Used when there is an error inside parsing. */
175 free_funcalls (void *ignore
)
177 struct funcall
*call
, *next
;
179 for (call
= funcall_chain
; call
; call
= next
)
186 /* This page contains the functions for adding data to the struct expression
187 being constructed. */
189 /* See definition in parser-defs.h. */
192 initialize_expout (int initial_size
, const struct language_defn
*lang
,
193 struct gdbarch
*gdbarch
)
195 expout_size
= initial_size
;
197 expout
= xmalloc (sizeof (struct expression
)
198 + EXP_ELEM_TO_BYTES (expout_size
));
199 expout
->language_defn
= lang
;
200 expout
->gdbarch
= gdbarch
;
203 /* See definition in parser-defs.h. */
206 reallocate_expout (void)
208 /* Record the actual number of expression elements, and then
209 reallocate the expression memory so that we free up any
212 expout
->nelts
= expout_ptr
;
213 expout
= xrealloc ((char *) expout
,
214 sizeof (struct expression
)
215 + EXP_ELEM_TO_BYTES (expout_ptr
));
218 /* Add one element to the end of the expression. */
220 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
221 a register through here. */
224 write_exp_elt (const union exp_element
*expelt
)
226 if (expout_ptr
>= expout_size
)
229 expout
= (struct expression
*)
230 xrealloc ((char *) expout
, sizeof (struct expression
)
231 + EXP_ELEM_TO_BYTES (expout_size
));
233 expout
->elts
[expout_ptr
++] = *expelt
;
237 write_exp_elt_opcode (enum exp_opcode expelt
)
239 union exp_element tmp
;
241 memset (&tmp
, 0, sizeof (union exp_element
));
243 write_exp_elt (&tmp
);
247 write_exp_elt_sym (struct symbol
*expelt
)
249 union exp_element tmp
;
251 memset (&tmp
, 0, sizeof (union exp_element
));
253 write_exp_elt (&tmp
);
257 write_exp_elt_block (const struct block
*b
)
259 union exp_element tmp
;
261 memset (&tmp
, 0, sizeof (union exp_element
));
263 write_exp_elt (&tmp
);
267 write_exp_elt_objfile (struct objfile
*objfile
)
269 union exp_element tmp
;
271 memset (&tmp
, 0, sizeof (union exp_element
));
272 tmp
.objfile
= objfile
;
273 write_exp_elt (&tmp
);
277 write_exp_elt_longcst (LONGEST expelt
)
279 union exp_element tmp
;
281 memset (&tmp
, 0, sizeof (union exp_element
));
282 tmp
.longconst
= expelt
;
283 write_exp_elt (&tmp
);
287 write_exp_elt_dblcst (DOUBLEST expelt
)
289 union exp_element tmp
;
291 memset (&tmp
, 0, sizeof (union exp_element
));
292 tmp
.doubleconst
= expelt
;
293 write_exp_elt (&tmp
);
297 write_exp_elt_decfloatcst (gdb_byte expelt
[16])
299 union exp_element tmp
;
302 for (index
= 0; index
< 16; index
++)
303 tmp
.decfloatconst
[index
] = expelt
[index
];
305 write_exp_elt (&tmp
);
309 write_exp_elt_type (struct type
*expelt
)
311 union exp_element tmp
;
313 memset (&tmp
, 0, sizeof (union exp_element
));
315 write_exp_elt (&tmp
);
319 write_exp_elt_intern (struct internalvar
*expelt
)
321 union exp_element tmp
;
323 memset (&tmp
, 0, sizeof (union exp_element
));
324 tmp
.internalvar
= expelt
;
325 write_exp_elt (&tmp
);
328 /* Add a string constant to the end of the expression.
330 String constants are stored by first writing an expression element
331 that contains the length of the string, then stuffing the string
332 constant itself into however many expression elements are needed
333 to hold it, and then writing another expression element that contains
334 the length of the string. I.e. an expression element at each end of
335 the string records the string length, so you can skip over the
336 expression elements containing the actual string bytes from either
337 end of the string. Note that this also allows gdb to handle
338 strings with embedded null bytes, as is required for some languages.
340 Don't be fooled by the fact that the string is null byte terminated,
341 this is strictly for the convenience of debugging gdb itself.
342 Gdb does not depend up the string being null terminated, since the
343 actual length is recorded in expression elements at each end of the
344 string. The null byte is taken into consideration when computing how
345 many expression elements are required to hold the string constant, of
350 write_exp_string (struct stoken str
)
352 int len
= str
.length
;
356 /* Compute the number of expression elements required to hold the string
357 (including a null byte terminator), along with one expression element
358 at each end to record the actual string length (not including the
359 null byte terminator). */
361 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
363 /* Ensure that we have enough available expression elements to store
366 if ((expout_ptr
+ lenelt
) >= expout_size
)
368 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
369 expout
= (struct expression
*)
370 xrealloc ((char *) expout
, (sizeof (struct expression
)
371 + EXP_ELEM_TO_BYTES (expout_size
)));
374 /* Write the leading length expression element (which advances the current
375 expression element index), then write the string constant followed by a
376 terminating null byte, and then write the trailing length expression
379 write_exp_elt_longcst ((LONGEST
) len
);
380 strdata
= (char *) &expout
->elts
[expout_ptr
];
381 memcpy (strdata
, str
.ptr
, len
);
382 *(strdata
+ len
) = '\0';
383 expout_ptr
+= lenelt
- 2;
384 write_exp_elt_longcst ((LONGEST
) len
);
387 /* Add a vector of string constants to the end of the expression.
389 This adds an OP_STRING operation, but encodes the contents
390 differently from write_exp_string. The language is expected to
391 handle evaluation of this expression itself.
393 After the usual OP_STRING header, TYPE is written into the
394 expression as a long constant. The interpretation of this field is
395 up to the language evaluator.
397 Next, each string in VEC is written. The length is written as a
398 long constant, followed by the contents of the string. */
401 write_exp_string_vector (int type
, struct stoken_vector
*vec
)
405 /* Compute the size. We compute the size in number of slots to
406 avoid issues with string padding. */
408 for (i
= 0; i
< vec
->len
; ++i
)
410 /* One slot for the length of this element, plus the number of
411 slots needed for this string. */
412 n_slots
+= 1 + BYTES_TO_EXP_ELEM (vec
->tokens
[i
].length
);
415 /* One more slot for the type of the string. */
418 /* Now compute a phony string length. */
419 len
= EXP_ELEM_TO_BYTES (n_slots
) - 1;
422 if ((expout_ptr
+ n_slots
) >= expout_size
)
424 expout_size
= max (expout_size
* 2, expout_ptr
+ n_slots
+ 10);
425 expout
= (struct expression
*)
426 xrealloc ((char *) expout
, (sizeof (struct expression
)
427 + EXP_ELEM_TO_BYTES (expout_size
)));
430 write_exp_elt_opcode (OP_STRING
);
431 write_exp_elt_longcst (len
);
432 write_exp_elt_longcst (type
);
434 for (i
= 0; i
< vec
->len
; ++i
)
436 write_exp_elt_longcst (vec
->tokens
[i
].length
);
437 memcpy (&expout
->elts
[expout_ptr
], vec
->tokens
[i
].ptr
,
438 vec
->tokens
[i
].length
);
439 expout_ptr
+= BYTES_TO_EXP_ELEM (vec
->tokens
[i
].length
);
442 write_exp_elt_longcst (len
);
443 write_exp_elt_opcode (OP_STRING
);
446 /* Add a bitstring constant to the end of the expression.
448 Bitstring constants are stored by first writing an expression element
449 that contains the length of the bitstring (in bits), then stuffing the
450 bitstring constant itself into however many expression elements are
451 needed to hold it, and then writing another expression element that
452 contains the length of the bitstring. I.e. an expression element at
453 each end of the bitstring records the bitstring length, so you can skip
454 over the expression elements containing the actual bitstring bytes from
455 either end of the bitstring. */
458 write_exp_bitstring (struct stoken str
)
460 int bits
= str
.length
; /* length in bits */
461 int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
465 /* Compute the number of expression elements required to hold the bitstring,
466 along with one expression element at each end to record the actual
467 bitstring length in bits. */
469 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
471 /* Ensure that we have enough available expression elements to store
474 if ((expout_ptr
+ lenelt
) >= expout_size
)
476 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
477 expout
= (struct expression
*)
478 xrealloc ((char *) expout
, (sizeof (struct expression
)
479 + EXP_ELEM_TO_BYTES (expout_size
)));
482 /* Write the leading length expression element (which advances the current
483 expression element index), then write the bitstring constant, and then
484 write the trailing length expression element. */
486 write_exp_elt_longcst ((LONGEST
) bits
);
487 strdata
= (char *) &expout
->elts
[expout_ptr
];
488 memcpy (strdata
, str
.ptr
, len
);
489 expout_ptr
+= lenelt
- 2;
490 write_exp_elt_longcst ((LONGEST
) bits
);
493 /* Add the appropriate elements for a minimal symbol to the end of
497 write_exp_msymbol (struct minimal_symbol
*msymbol
)
499 struct objfile
*objfile
= msymbol_objfile (msymbol
);
500 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
502 CORE_ADDR addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
503 struct obj_section
*section
= SYMBOL_OBJ_SECTION (msymbol
);
504 enum minimal_symbol_type type
= MSYMBOL_TYPE (msymbol
);
507 /* The minimal symbol might point to a function descriptor;
508 resolve it to the actual code address instead. */
509 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
, ¤t_target
);
512 struct minimal_symbol
*ifunc_msym
= lookup_minimal_symbol_by_pc (pc
);
514 /* In this case, assume we have a code symbol instead of
517 if (ifunc_msym
!= NULL
&& MSYMBOL_TYPE (ifunc_msym
) == mst_text_gnu_ifunc
518 && SYMBOL_VALUE_ADDRESS (ifunc_msym
) == pc
)
520 /* A function descriptor has been resolved but PC is still in the
521 STT_GNU_IFUNC resolver body (such as because inferior does not
522 run to be able to call it). */
524 type
= mst_text_gnu_ifunc
;
532 if (overlay_debugging
)
533 addr
= symbol_overlayed_address (addr
, section
);
535 write_exp_elt_opcode (OP_LONG
);
536 /* Let's make the type big enough to hold a 64-bit address. */
537 write_exp_elt_type (objfile_type (objfile
)->builtin_core_addr
);
538 write_exp_elt_longcst ((LONGEST
) addr
);
539 write_exp_elt_opcode (OP_LONG
);
541 if (section
&& section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
)
543 write_exp_elt_opcode (UNOP_MEMVAL_TLS
);
544 write_exp_elt_objfile (objfile
);
545 write_exp_elt_type (objfile_type (objfile
)->nodebug_tls_symbol
);
546 write_exp_elt_opcode (UNOP_MEMVAL_TLS
);
550 write_exp_elt_opcode (UNOP_MEMVAL
);
555 case mst_solib_trampoline
:
556 write_exp_elt_type (objfile_type (objfile
)->nodebug_text_symbol
);
559 case mst_text_gnu_ifunc
:
560 write_exp_elt_type (objfile_type (objfile
)
561 ->nodebug_text_gnu_ifunc_symbol
);
568 write_exp_elt_type (objfile_type (objfile
)->nodebug_data_symbol
);
571 case mst_slot_got_plt
:
572 write_exp_elt_type (objfile_type (objfile
)->nodebug_got_plt_symbol
);
576 write_exp_elt_type (objfile_type (objfile
)->nodebug_unknown_symbol
);
579 write_exp_elt_opcode (UNOP_MEMVAL
);
582 /* Mark the current index as the starting location of a structure
583 expression. This is used when completing on field names. */
586 mark_struct_expression (void)
588 gdb_assert (parse_completion
589 && expout_tag_completion_type
== TYPE_CODE_UNDEF
);
590 expout_last_struct
= expout_ptr
;
593 /* Indicate that the current parser invocation is completing a tag.
594 TAG is the type code of the tag, and PTR and LENGTH represent the
595 start of the tag name. */
598 mark_completion_tag (enum type_code tag
, const char *ptr
, int length
)
600 gdb_assert (parse_completion
601 && expout_tag_completion_type
== TYPE_CODE_UNDEF
602 && expout_completion_name
== NULL
603 && expout_last_struct
== -1);
604 gdb_assert (tag
== TYPE_CODE_UNION
605 || tag
== TYPE_CODE_STRUCT
606 || tag
== TYPE_CODE_CLASS
607 || tag
== TYPE_CODE_ENUM
);
608 expout_tag_completion_type
= tag
;
609 expout_completion_name
= xmalloc (length
+ 1);
610 memcpy (expout_completion_name
, ptr
, length
);
611 expout_completion_name
[length
] = '\0';
615 /* Recognize tokens that start with '$'. These include:
617 $regname A native register name or a "standard
620 $variable A convenience variable with a name chosen
623 $digits Value history with index <digits>, starting
624 from the first value which has index 1.
626 $$digits Value history with index <digits> relative
627 to the last value. I.e. $$0 is the last
628 value, $$1 is the one previous to that, $$2
629 is the one previous to $$1, etc.
631 $ | $0 | $$0 The last value in the value history.
633 $$ An abbreviation for the second to the last
634 value in the value history, I.e. $$1 */
637 write_dollar_variable (struct stoken str
)
639 struct symbol
*sym
= NULL
;
640 struct minimal_symbol
*msym
= NULL
;
641 struct internalvar
*isym
= NULL
;
643 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
644 and $$digits (equivalent to $<-digits> if you could type that). */
648 /* Double dollar means negate the number and add -1 as well.
649 Thus $$ alone means -1. */
650 if (str
.length
>= 2 && str
.ptr
[1] == '$')
657 /* Just dollars (one or two). */
661 /* Is the rest of the token digits? */
662 for (; i
< str
.length
; i
++)
663 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
667 i
= atoi (str
.ptr
+ 1 + negate
);
673 /* Handle tokens that refer to machine registers:
674 $ followed by a register name. */
675 i
= user_reg_map_name_to_regnum (parse_gdbarch
,
676 str
.ptr
+ 1, str
.length
- 1);
678 goto handle_register
;
680 /* Any names starting with $ are probably debugger internal variables. */
682 isym
= lookup_only_internalvar (copy_name (str
) + 1);
685 write_exp_elt_opcode (OP_INTERNALVAR
);
686 write_exp_elt_intern (isym
);
687 write_exp_elt_opcode (OP_INTERNALVAR
);
691 /* On some systems, such as HP-UX and hppa-linux, certain system routines
692 have names beginning with $ or $$. Check for those, first. */
694 sym
= lookup_symbol (copy_name (str
), (struct block
*) NULL
,
698 write_exp_elt_opcode (OP_VAR_VALUE
);
699 write_exp_elt_block (block_found
); /* set by lookup_symbol */
700 write_exp_elt_sym (sym
);
701 write_exp_elt_opcode (OP_VAR_VALUE
);
704 msym
= lookup_minimal_symbol (copy_name (str
), NULL
, NULL
);
707 write_exp_msymbol (msym
);
711 /* Any other names are assumed to be debugger internal variables. */
713 write_exp_elt_opcode (OP_INTERNALVAR
);
714 write_exp_elt_intern (create_internalvar (copy_name (str
) + 1));
715 write_exp_elt_opcode (OP_INTERNALVAR
);
718 write_exp_elt_opcode (OP_LAST
);
719 write_exp_elt_longcst ((LONGEST
) i
);
720 write_exp_elt_opcode (OP_LAST
);
723 write_exp_elt_opcode (OP_REGISTER
);
726 write_exp_string (str
);
727 write_exp_elt_opcode (OP_REGISTER
);
733 find_template_name_end (char *p
)
736 int just_seen_right
= 0;
737 int just_seen_colon
= 0;
738 int just_seen_space
= 0;
740 if (!p
|| (*p
!= '<'))
751 /* In future, may want to allow these?? */
754 depth
++; /* start nested template */
755 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
756 return 0; /* but not after : or :: or > or space */
759 if (just_seen_colon
|| just_seen_right
)
760 return 0; /* end a (nested?) template */
761 just_seen_right
= 1; /* but not after : or :: */
762 if (--depth
== 0) /* also disallow >>, insist on > > */
763 return ++p
; /* if outermost ended, return */
766 if (just_seen_space
|| (just_seen_colon
> 1))
767 return 0; /* nested class spec coming up */
768 just_seen_colon
++; /* we allow :: but not :::: */
773 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
774 (*p
>= 'A' && *p
<= 'Z') ||
775 (*p
>= '0' && *p
<= '9') ||
776 (*p
== '_') || (*p
== ',') || /* commas for template args */
777 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
778 (*p
== '(') || (*p
== ')') || /* function types */
779 (*p
== '[') || (*p
== ']'))) /* array types */
793 /* Return a null-terminated temporary copy of the name of a string token.
795 Tokens that refer to names do so with explicit pointer and length,
796 so they can share the storage that lexptr is parsing.
797 When it is necessary to pass a name to a function that expects
798 a null-terminated string, the substring is copied out
799 into a separate block of storage.
801 N.B. A single buffer is reused on each call. */
804 copy_name (struct stoken token
)
806 /* A temporary buffer for identifiers, so we can null-terminate them.
807 We allocate this with xrealloc. parse_exp_1 used to allocate with
808 alloca, using the size of the whole expression as a conservative
809 estimate of the space needed. However, macro expansion can
810 introduce names longer than the original expression; there's no
811 practical way to know beforehand how large that might be. */
812 static char *namecopy
;
813 static size_t namecopy_size
;
815 /* Make sure there's enough space for the token. */
816 if (namecopy_size
< token
.length
+ 1)
818 namecopy_size
= token
.length
+ 1;
819 namecopy
= xrealloc (namecopy
, token
.length
+ 1);
822 memcpy (namecopy
, token
.ptr
, token
.length
);
823 namecopy
[token
.length
] = 0;
829 /* See comments on parser-defs.h. */
832 prefixify_expression (struct expression
*expr
)
834 int len
= sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
835 struct expression
*temp
;
836 int inpos
= expr
->nelts
, outpos
= 0;
838 temp
= (struct expression
*) alloca (len
);
840 /* Copy the original expression into temp. */
841 memcpy (temp
, expr
, len
);
843 return prefixify_subexp (temp
, expr
, inpos
, outpos
);
846 /* Return the number of exp_elements in the postfix subexpression
847 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
850 length_of_subexp (struct expression
*expr
, int endpos
)
854 operator_length (expr
, endpos
, &oplen
, &args
);
858 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
865 /* Sets *OPLENP to the length of the operator whose (last) index is
866 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
870 operator_length (const struct expression
*expr
, int endpos
, int *oplenp
,
873 expr
->language_defn
->la_exp_desc
->operator_length (expr
, endpos
,
877 /* Default value for operator_length in exp_descriptor vectors. */
880 operator_length_standard (const struct expression
*expr
, int endpos
,
881 int *oplenp
, int *argsp
)
885 enum f90_range_type range_type
;
889 error (_("?error in operator_length_standard"));
891 i
= (int) expr
->elts
[endpos
- 1].opcode
;
897 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
898 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
912 case OP_VAR_ENTRY_VALUE
:
922 case OP_F77_UNDETERMINED_ARGLIST
:
924 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
928 oplen
= 4 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
932 case OP_OBJC_MSGCALL
: /* Objective C message (method) call. */
934 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
943 case UNOP_DYNAMIC_CAST
:
944 case UNOP_REINTERPRET_CAST
:
945 case UNOP_MEMVAL_TYPE
:
957 case UNOP_MEMVAL_TLS
:
977 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
978 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
983 case STRUCTOP_STRUCT
:
990 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
991 NSString constant. */
992 case OP_OBJC_SELECTOR
: /* Objective C "@selector" pseudo-op. */
994 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
995 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
1000 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
1001 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
1011 case MULTI_SUBSCRIPT
:
1013 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
1016 case BINOP_ASSIGN_MODIFY
:
1029 range_type
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
1032 case LOW_BOUND_DEFAULT
:
1033 case HIGH_BOUND_DEFAULT
:
1036 case BOTH_BOUND_DEFAULT
:
1039 case NONE_BOUND_DEFAULT
:
1047 args
= 1 + (i
< (int) BINOP_END
);
1054 /* Copy the subexpression ending just before index INEND in INEXPR
1055 into OUTEXPR, starting at index OUTBEG.
1056 In the process, convert it from suffix to prefix form.
1057 If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1058 Otherwise, it returns the index of the subexpression which is the
1059 left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
1062 prefixify_subexp (struct expression
*inexpr
,
1063 struct expression
*outexpr
, int inend
, int outbeg
)
1071 operator_length (inexpr
, inend
, &oplen
, &args
);
1073 /* Copy the final operator itself, from the end of the input
1074 to the beginning of the output. */
1076 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
1077 EXP_ELEM_TO_BYTES (oplen
));
1080 if (expout_last_struct
== inend
)
1081 result
= outbeg
- oplen
;
1083 /* Find the lengths of the arg subexpressions. */
1084 arglens
= (int *) alloca (args
* sizeof (int));
1085 for (i
= args
- 1; i
>= 0; i
--)
1087 oplen
= length_of_subexp (inexpr
, inend
);
1092 /* Now copy each subexpression, preserving the order of
1093 the subexpressions, but prefixifying each one.
1094 In this loop, inend starts at the beginning of
1095 the expression this level is working on
1096 and marches forward over the arguments.
1097 outbeg does similarly in the output. */
1098 for (i
= 0; i
< args
; i
++)
1104 r
= prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
1107 /* Return immediately. We probably have only parsed a
1108 partial expression, so we don't want to try to reverse
1109 the other operands. */
1118 /* Read an expression from the string *STRINGPTR points to,
1119 parse it, and return a pointer to a struct expression that we malloc.
1120 Use block BLOCK as the lexical context for variable names;
1121 if BLOCK is zero, use the block of the selected stack frame.
1122 Meanwhile, advance *STRINGPTR to point after the expression,
1123 at the first nonwhite character that is not part of the expression
1124 (possibly a null character).
1126 If COMMA is nonzero, stop if a comma is reached. */
1129 parse_exp_1 (char **stringptr
, CORE_ADDR pc
, const struct block
*block
,
1132 return parse_exp_in_context (stringptr
, pc
, block
, comma
, 0, NULL
);
1135 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1136 no value is expected from the expression.
1137 OUT_SUBEXP is set when attempting to complete a field name; in this
1138 case it is set to the index of the subexpression on the
1139 left-hand-side of the struct op. If not doing such completion, it
1140 is left untouched. */
1142 static struct expression
*
1143 parse_exp_in_context (char **stringptr
, CORE_ADDR pc
, const struct block
*block
,
1144 int comma
, int void_context_p
, int *out_subexp
)
1146 volatile struct gdb_exception except
;
1147 struct cleanup
*old_chain
;
1148 const struct language_defn
*lang
= NULL
;
1151 lexptr
= *stringptr
;
1155 type_stack
.depth
= 0;
1156 expout_last_struct
= -1;
1157 expout_tag_completion_type
= TYPE_CODE_UNDEF
;
1158 xfree (expout_completion_name
);
1159 expout_completion_name
= NULL
;
1161 comma_terminates
= comma
;
1163 if (lexptr
== 0 || *lexptr
== 0)
1164 error_no_arg (_("expression to compute"));
1166 old_chain
= make_cleanup (free_funcalls
, 0 /*ignore*/);
1169 expression_context_block
= block
;
1171 /* If no context specified, try using the current frame, if any. */
1172 if (!expression_context_block
)
1173 expression_context_block
= get_selected_block (&expression_context_pc
);
1175 expression_context_pc
= BLOCK_START (expression_context_block
);
1177 expression_context_pc
= pc
;
1179 /* Fall back to using the current source static context, if any. */
1181 if (!expression_context_block
)
1183 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
1185 expression_context_block
1186 = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal
.symtab
), STATIC_BLOCK
);
1187 if (expression_context_block
)
1188 expression_context_pc
= BLOCK_START (expression_context_block
);
1191 if (language_mode
== language_mode_auto
&& block
!= NULL
)
1193 /* Find the language associated to the given context block.
1194 Default to the current language if it can not be determined.
1196 Note that using the language corresponding to the current frame
1197 can sometimes give unexpected results. For instance, this
1198 routine is often called several times during the inferior
1199 startup phase to re-parse breakpoint expressions after
1200 a new shared library has been loaded. The language associated
1201 to the current frame at this moment is not relevant for
1202 the breakpoint. Using it would therefore be silly, so it seems
1203 better to rely on the current language rather than relying on
1204 the current frame language to parse the expression. That's why
1205 we do the following language detection only if the context block
1206 has been specifically provided. */
1207 struct symbol
*func
= block_linkage_function (block
);
1210 lang
= language_def (SYMBOL_LANGUAGE (func
));
1211 if (lang
== NULL
|| lang
->la_language
== language_unknown
)
1212 lang
= current_language
;
1215 lang
= current_language
;
1217 initialize_expout (10, lang
, get_current_arch ());
1219 TRY_CATCH (except
, RETURN_MASK_ALL
)
1221 if (lang
->la_parser ())
1222 lang
->la_error (NULL
);
1224 if (except
.reason
< 0)
1226 if (! parse_completion
)
1229 throw_exception (except
);
1233 discard_cleanups (old_chain
);
1235 reallocate_expout ();
1237 /* Convert expression from postfix form as generated by yacc
1238 parser, to a prefix form. */
1240 if (expressiondebug
)
1241 dump_raw_expression (expout
, gdb_stdlog
,
1242 "before conversion to prefix form");
1244 subexp
= prefixify_expression (expout
);
1246 *out_subexp
= subexp
;
1248 lang
->la_post_parser (&expout
, void_context_p
);
1250 if (expressiondebug
)
1251 dump_prefix_expression (expout
, gdb_stdlog
);
1253 *stringptr
= lexptr
;
1257 /* Parse STRING as an expression, and complain if this fails
1258 to use up all of the contents of STRING. */
1261 parse_expression (char *string
)
1263 struct expression
*exp
;
1265 exp
= parse_exp_1 (&string
, 0, 0, 0);
1267 error (_("Junk after end of expression."));
1271 /* Parse STRING as an expression. If parsing ends in the middle of a
1272 field reference, return the type of the left-hand-side of the
1273 reference; furthermore, if the parsing ends in the field name,
1274 return the field name in *NAME. If the parsing ends in the middle
1275 of a field reference, but the reference is somehow invalid, throw
1276 an exception. In all other cases, return NULL. Returned non-NULL
1277 *NAME must be freed by the caller. */
1280 parse_expression_for_completion (char *string
, char **name
,
1281 enum type_code
*code
)
1283 struct expression
*exp
= NULL
;
1286 volatile struct gdb_exception except
;
1288 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1290 parse_completion
= 1;
1291 exp
= parse_exp_in_context (&string
, 0, 0, 0, 0, &subexp
);
1293 parse_completion
= 0;
1294 if (except
.reason
< 0 || ! exp
)
1297 if (expout_tag_completion_type
!= TYPE_CODE_UNDEF
)
1299 *code
= expout_tag_completion_type
;
1300 *name
= expout_completion_name
;
1301 expout_completion_name
= NULL
;
1305 if (expout_last_struct
== -1)
1311 *name
= extract_field_op (exp
, &subexp
);
1318 /* This might throw an exception. If so, we want to let it
1320 val
= evaluate_subexpression_type (exp
, subexp
);
1321 /* (*NAME) is a part of the EXP memory block freed below. */
1322 *name
= xstrdup (*name
);
1325 return value_type (val
);
1328 /* A post-parser that does nothing. */
1331 null_post_parser (struct expression
**exp
, int void_context_p
)
1335 /* Parse floating point value P of length LEN.
1336 Return 0 (false) if invalid, 1 (true) if valid.
1337 The successfully parsed number is stored in D.
1338 *SUFFIX points to the suffix of the number in P.
1340 NOTE: This accepts the floating point syntax that sscanf accepts. */
1343 parse_float (const char *p
, int len
, DOUBLEST
*d
, const char **suffix
)
1348 copy
= xmalloc (len
+ 1);
1349 memcpy (copy
, p
, len
);
1352 num
= sscanf (copy
, "%" DOUBLEST_SCAN_FORMAT
"%n", d
, &n
);
1355 /* The sscanf man page suggests not making any assumptions on the effect
1356 of %n on the result, so we don't.
1357 That is why we simply test num == 0. */
1365 /* Parse floating point value P of length LEN, using the C syntax for floats.
1366 Return 0 (false) if invalid, 1 (true) if valid.
1367 The successfully parsed number is stored in *D.
1368 Its type is taken from builtin_type (gdbarch) and is stored in *T. */
1371 parse_c_float (struct gdbarch
*gdbarch
, const char *p
, int len
,
1372 DOUBLEST
*d
, struct type
**t
)
1376 const struct builtin_type
*builtin_types
= builtin_type (gdbarch
);
1378 if (! parse_float (p
, len
, d
, &suffix
))
1381 suffix_len
= p
+ len
- suffix
;
1383 if (suffix_len
== 0)
1384 *t
= builtin_types
->builtin_double
;
1385 else if (suffix_len
== 1)
1387 /* Handle suffixes: 'f' for float, 'l' for long double. */
1388 if (tolower (*suffix
) == 'f')
1389 *t
= builtin_types
->builtin_float
;
1390 else if (tolower (*suffix
) == 'l')
1391 *t
= builtin_types
->builtin_long_double
;
1401 /* Stuff for maintaining a stack of types. Currently just used by C, but
1402 probably useful for any language which declares its types "backwards". */
1404 /* Ensure that there are HOWMUCH open slots on the type stack STACK. */
1407 type_stack_reserve (struct type_stack
*stack
, int howmuch
)
1409 if (stack
->depth
+ howmuch
>= stack
->size
)
1412 if (stack
->size
< howmuch
)
1413 stack
->size
= howmuch
;
1414 stack
->elements
= xrealloc (stack
->elements
,
1415 stack
->size
* sizeof (union type_stack_elt
));
1419 /* Ensure that there is a single open slot in the global type stack. */
1422 check_type_stack_depth (void)
1424 type_stack_reserve (&type_stack
, 1);
1427 /* A helper function for insert_type and insert_type_address_space.
1428 This does work of expanding the type stack and inserting the new
1429 element, ELEMENT, into the stack at location SLOT. */
1432 insert_into_type_stack (int slot
, union type_stack_elt element
)
1434 check_type_stack_depth ();
1436 if (slot
< type_stack
.depth
)
1437 memmove (&type_stack
.elements
[slot
+ 1], &type_stack
.elements
[slot
],
1438 (type_stack
.depth
- slot
) * sizeof (union type_stack_elt
));
1439 type_stack
.elements
[slot
] = element
;
1443 /* Insert a new type, TP, at the bottom of the type stack. If TP is
1444 tp_pointer or tp_reference, it is inserted at the bottom. If TP is
1445 a qualifier, it is inserted at slot 1 (just above a previous
1446 tp_pointer) if there is anything on the stack, or simply pushed if
1447 the stack is empty. Other values for TP are invalid. */
1450 insert_type (enum type_pieces tp
)
1452 union type_stack_elt element
;
1455 gdb_assert (tp
== tp_pointer
|| tp
== tp_reference
1456 || tp
== tp_const
|| tp
== tp_volatile
);
1458 /* If there is anything on the stack (we know it will be a
1459 tp_pointer), insert the qualifier above it. Otherwise, simply
1460 push this on the top of the stack. */
1461 if (type_stack
.depth
&& (tp
== tp_const
|| tp
== tp_volatile
))
1467 insert_into_type_stack (slot
, element
);
1471 push_type (enum type_pieces tp
)
1473 check_type_stack_depth ();
1474 type_stack
.elements
[type_stack
.depth
++].piece
= tp
;
1478 push_type_int (int n
)
1480 check_type_stack_depth ();
1481 type_stack
.elements
[type_stack
.depth
++].int_val
= n
;
1484 /* Insert a tp_space_identifier and the corresponding address space
1485 value into the stack. STRING is the name of an address space, as
1486 recognized by address_space_name_to_int. If the stack is empty,
1487 the new elements are simply pushed. If the stack is not empty,
1488 this function assumes that the first item on the stack is a
1489 tp_pointer, and the new values are inserted above the first
1493 insert_type_address_space (char *string
)
1495 union type_stack_elt element
;
1498 /* If there is anything on the stack (we know it will be a
1499 tp_pointer), insert the address space qualifier above it.
1500 Otherwise, simply push this on the top of the stack. */
1501 if (type_stack
.depth
)
1506 element
.piece
= tp_space_identifier
;
1507 insert_into_type_stack (slot
, element
);
1508 element
.int_val
= address_space_name_to_int (parse_gdbarch
, string
);
1509 insert_into_type_stack (slot
, element
);
1515 if (type_stack
.depth
)
1516 return type_stack
.elements
[--type_stack
.depth
].piece
;
1523 if (type_stack
.depth
)
1524 return type_stack
.elements
[--type_stack
.depth
].int_val
;
1525 /* "Can't happen". */
1529 /* Pop a type list element from the global type stack. */
1531 static VEC (type_ptr
) *
1534 gdb_assert (type_stack
.depth
);
1535 return type_stack
.elements
[--type_stack
.depth
].typelist_val
;
1538 /* Pop a type_stack element from the global type stack. */
1540 static struct type_stack
*
1541 pop_type_stack (void)
1543 gdb_assert (type_stack
.depth
);
1544 return type_stack
.elements
[--type_stack
.depth
].stack_val
;
1547 /* Append the elements of the type stack FROM to the type stack TO.
1548 Always returns TO. */
1551 append_type_stack (struct type_stack
*to
, struct type_stack
*from
)
1553 type_stack_reserve (to
, from
->depth
);
1555 memcpy (&to
->elements
[to
->depth
], &from
->elements
[0],
1556 from
->depth
* sizeof (union type_stack_elt
));
1557 to
->depth
+= from
->depth
;
1562 /* Push the type stack STACK as an element on the global type stack. */
1565 push_type_stack (struct type_stack
*stack
)
1567 check_type_stack_depth ();
1568 type_stack
.elements
[type_stack
.depth
++].stack_val
= stack
;
1569 push_type (tp_type_stack
);
1572 /* Copy the global type stack into a newly allocated type stack and
1573 return it. The global stack is cleared. The returned type stack
1574 must be freed with type_stack_cleanup. */
1577 get_type_stack (void)
1579 struct type_stack
*result
= XNEW (struct type_stack
);
1581 *result
= type_stack
;
1582 type_stack
.depth
= 0;
1583 type_stack
.size
= 0;
1584 type_stack
.elements
= NULL
;
1589 /* A cleanup function that destroys a single type stack. */
1592 type_stack_cleanup (void *arg
)
1594 struct type_stack
*stack
= arg
;
1596 xfree (stack
->elements
);
1600 /* Push a function type with arguments onto the global type stack.
1601 LIST holds the argument types. If the final item in LIST is NULL,
1602 then the function will be varargs. */
1605 push_typelist (VEC (type_ptr
) *list
)
1607 check_type_stack_depth ();
1608 type_stack
.elements
[type_stack
.depth
++].typelist_val
= list
;
1609 push_type (tp_function_with_arguments
);
1612 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1613 as modified by all the stuff on the stack. */
1615 follow_types (struct type
*follow_type
)
1619 int make_volatile
= 0;
1620 int make_addr_space
= 0;
1624 switch (pop_type ())
1629 follow_type
= make_cv_type (make_const
,
1630 TYPE_VOLATILE (follow_type
),
1633 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1636 if (make_addr_space
)
1637 follow_type
= make_type_with_address_space (follow_type
,
1639 make_const
= make_volatile
= 0;
1640 make_addr_space
= 0;
1648 case tp_space_identifier
:
1649 make_addr_space
= pop_type_int ();
1652 follow_type
= lookup_pointer_type (follow_type
);
1654 follow_type
= make_cv_type (make_const
,
1655 TYPE_VOLATILE (follow_type
),
1658 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1661 if (make_addr_space
)
1662 follow_type
= make_type_with_address_space (follow_type
,
1664 make_const
= make_volatile
= 0;
1665 make_addr_space
= 0;
1668 follow_type
= lookup_reference_type (follow_type
);
1670 follow_type
= make_cv_type (make_const
,
1671 TYPE_VOLATILE (follow_type
),
1674 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1677 if (make_addr_space
)
1678 follow_type
= make_type_with_address_space (follow_type
,
1680 make_const
= make_volatile
= 0;
1681 make_addr_space
= 0;
1684 array_size
= pop_type_int ();
1685 /* FIXME-type-allocation: need a way to free this type when we are
1688 lookup_array_range_type (follow_type
,
1689 0, array_size
>= 0 ? array_size
- 1 : 0);
1691 TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type
) = 1;
1694 /* FIXME-type-allocation: need a way to free this type when we are
1696 follow_type
= lookup_function_type (follow_type
);
1699 case tp_function_with_arguments
:
1701 VEC (type_ptr
) *args
= pop_typelist ();
1704 = lookup_function_type_with_arguments (follow_type
,
1705 VEC_length (type_ptr
, args
),
1706 VEC_address (type_ptr
,
1708 VEC_free (type_ptr
, args
);
1714 struct type_stack
*stack
= pop_type_stack ();
1715 /* Sort of ugly, but not really much worse than the
1717 struct type_stack save
= type_stack
;
1719 type_stack
= *stack
;
1720 follow_type
= follow_types (follow_type
);
1721 gdb_assert (type_stack
.depth
== 0);
1727 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1732 /* This function avoids direct calls to fprintf
1733 in the parser generated debug code. */
1735 parser_fprintf (FILE *x
, const char *y
, ...)
1741 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1744 fprintf_unfiltered (gdb_stderr
, " Unknown FILE used.\n");
1745 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1750 /* Implementation of the exp_descriptor method operator_check. */
1753 operator_check_standard (struct expression
*exp
, int pos
,
1754 int (*objfile_func
) (struct objfile
*objfile
,
1758 const union exp_element
*const elts
= exp
->elts
;
1759 struct type
*type
= NULL
;
1760 struct objfile
*objfile
= NULL
;
1762 /* Extended operators should have been already handled by exp_descriptor
1763 iterate method of its specific language. */
1764 gdb_assert (elts
[pos
].opcode
< OP_EXTENDED0
);
1766 /* Track the callers of write_exp_elt_type for this table. */
1768 switch (elts
[pos
].opcode
)
1781 type
= elts
[pos
+ 1].type
;
1786 LONGEST arg
, nargs
= elts
[pos
+ 1].longconst
;
1788 for (arg
= 0; arg
< nargs
; arg
++)
1790 struct type
*type
= elts
[pos
+ 2 + arg
].type
;
1791 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1793 if (objfile
&& (*objfile_func
) (objfile
, data
))
1799 case UNOP_MEMVAL_TLS
:
1800 objfile
= elts
[pos
+ 1].objfile
;
1801 type
= elts
[pos
+ 2].type
;
1806 const struct block
*const block
= elts
[pos
+ 1].block
;
1807 const struct symbol
*const symbol
= elts
[pos
+ 2].symbol
;
1809 /* Check objfile where the variable itself is placed.
1810 SYMBOL_OBJ_SECTION (symbol) may be NULL. */
1811 if ((*objfile_func
) (SYMBOL_SYMTAB (symbol
)->objfile
, data
))
1814 /* Check objfile where is placed the code touching the variable. */
1815 objfile
= lookup_objfile_from_block (block
);
1817 type
= SYMBOL_TYPE (symbol
);
1822 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1824 if (type
&& TYPE_OBJFILE (type
)
1825 && (*objfile_func
) (TYPE_OBJFILE (type
), data
))
1827 if (objfile
&& (*objfile_func
) (objfile
, data
))
1833 /* Call OBJFILE_FUNC for any TYPE and OBJFILE found being referenced by EXP.
1834 The functions are never called with NULL OBJFILE. Functions get passed an
1835 arbitrary caller supplied DATA pointer. If any of the functions returns
1836 non-zero value then (any other) non-zero value is immediately returned to
1837 the caller. Otherwise zero is returned after iterating through whole EXP.
1841 exp_iterate (struct expression
*exp
,
1842 int (*objfile_func
) (struct objfile
*objfile
, void *data
),
1847 for (endpos
= exp
->nelts
; endpos
> 0; )
1849 int pos
, args
, oplen
= 0;
1851 operator_length (exp
, endpos
, &oplen
, &args
);
1852 gdb_assert (oplen
> 0);
1854 pos
= endpos
- oplen
;
1855 if (exp
->language_defn
->la_exp_desc
->operator_check (exp
, pos
,
1856 objfile_func
, data
))
1865 /* Helper for exp_uses_objfile. */
1868 exp_uses_objfile_iter (struct objfile
*exp_objfile
, void *objfile_voidp
)
1870 struct objfile
*objfile
= objfile_voidp
;
1872 if (exp_objfile
->separate_debug_objfile_backlink
)
1873 exp_objfile
= exp_objfile
->separate_debug_objfile_backlink
;
1875 return exp_objfile
== objfile
;
1878 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1879 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1883 exp_uses_objfile (struct expression
*exp
, struct objfile
*objfile
)
1885 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
1887 return exp_iterate (exp
, exp_uses_objfile_iter
, objfile
);
1891 _initialize_parse (void)
1893 type_stack
.size
= 0;
1894 type_stack
.depth
= 0;
1895 type_stack
.elements
= NULL
;
1897 add_setshow_zuinteger_cmd ("expression", class_maintenance
,
1899 _("Set expression debugging."),
1900 _("Show expression debugging."),
1901 _("When non-zero, the internal representation "
1902 "of expressions will be printed."),
1904 show_expressiondebug
,
1905 &setdebuglist
, &showdebuglist
);
1906 add_setshow_boolean_cmd ("parser", class_maintenance
,
1908 _("Set parser debugging."),
1909 _("Show parser debugging."),
1910 _("When non-zero, expression parser "
1911 "tracing will be enabled."),
1914 &setdebuglist
, &showdebuglist
);