OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [parse.c] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* Parse expressions for GDB.
2
 
3
   Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4
   1998, 1999, 2000, 2001, 2004, 2005, 2007, 2008, 2009, 2010
5
   Free Software Foundation, Inc.
6
 
7
   Modified from expread.y by the Department of Computer Science at the
8
   State University of New York at Buffalo, 1991.
9
 
10
   This file is part of GDB.
11
 
12
   This program is free software; you can redistribute it and/or modify
13
   it under the terms of the GNU General Public License as published by
14
   the Free Software Foundation; either version 3 of the License, or
15
   (at your option) any later version.
16
 
17
   This program is distributed in the hope that it will be useful,
18
   but WITHOUT ANY WARRANTY; without even the implied warranty of
19
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
   GNU General Public License for more details.
21
 
22
   You should have received a copy of the GNU General Public License
23
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
24
 
25
/* Parse an expression from text in a string,
26
   and return the result as a  struct expression  pointer.
27
   That structure contains arithmetic operations in reverse polish,
28
   with constants represented by operations that are followed by special data.
29
   See expression.h for the details of the format.
30
   What is important here is that it can be built up sequentially
31
   during the process of parsing; the lower levels of the tree always
32
   come first in the result.  */
33
 
34
#include "defs.h"
35
#include <ctype.h>
36
#include "arch-utils.h"
37
#include "gdb_string.h"
38
#include "symtab.h"
39
#include "gdbtypes.h"
40
#include "frame.h"
41
#include "expression.h"
42
#include "value.h"
43
#include "command.h"
44
#include "language.h"
45
#include "f-lang.h"
46
#include "parser-defs.h"
47
#include "gdbcmd.h"
48
#include "symfile.h"            /* for overlay functions */
49
#include "inferior.h"
50
#include "doublest.h"
51
#include "gdb_assert.h"
52
#include "block.h"
53
#include "source.h"
54
#include "objfiles.h"
55
#include "exceptions.h"
56
#include "user-regs.h"
57
 
58
/* Standard set of definitions for printing, dumping, prefixifying,
59
 * and evaluating expressions.  */
60
 
61
const struct exp_descriptor exp_descriptor_standard =
62
  {
63
    print_subexp_standard,
64
    operator_length_standard,
65
    operator_check_standard,
66
    op_name_standard,
67
    dump_subexp_body_standard,
68
    evaluate_subexp_standard
69
  };
70
 
71
/* Global variables declared in parser-defs.h (and commented there).  */
72
struct expression *expout;
73
int expout_size;
74
int expout_ptr;
75
struct block *expression_context_block;
76
CORE_ADDR expression_context_pc;
77
struct block *innermost_block;
78
int arglist_len;
79
union type_stack_elt *type_stack;
80
int type_stack_depth, type_stack_size;
81
char *lexptr;
82
char *prev_lexptr;
83
int paren_depth;
84
int comma_terminates;
85
 
86
/* True if parsing an expression to find a field reference.  This is
87
   only used by completion.  */
88
int in_parse_field;
89
 
90
/* The index of the last struct expression directly before a '.' or
91
   '->'.  This is set when parsing and is only used when completing a
92
   field name.  It is -1 if no dereference operation was found.  */
93
static int expout_last_struct = -1;
94
 
95
/* A temporary buffer for identifiers, so we can null-terminate them.
96
 
97
   We allocate this with xrealloc.  parse_exp_1 used to allocate with
98
   alloca, using the size of the whole expression as a conservative
99
   estimate of the space needed.  However, macro expansion can
100
   introduce names longer than the original expression; there's no
101
   practical way to know beforehand how large that might be.  */
102
char *namecopy;
103
size_t namecopy_size;
104
 
105
static int expressiondebug = 0;
106
static void
107
show_expressiondebug (struct ui_file *file, int from_tty,
108
                      struct cmd_list_element *c, const char *value)
109
{
110
  fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
111
}
112
 
113
 
114
/* Non-zero if an expression parser should set yydebug.  */
115
int parser_debug;
116
 
117
static void
118
show_parserdebug (struct ui_file *file, int from_tty,
119
                  struct cmd_list_element *c, const char *value)
120
{
121
  fprintf_filtered (file, _("Parser debugging is %s.\n"), value);
122
}
123
 
124
 
125
static void free_funcalls (void *ignore);
126
 
127
static int prefixify_expression (struct expression *);
128
 
129
static int prefixify_subexp (struct expression *, struct expression *, int,
130
                             int);
131
 
132
static struct expression *parse_exp_in_context (char **, struct block *, int,
133
                                                int, int *);
134
 
135
void _initialize_parse (void);
136
 
137
/* Data structure for saving values of arglist_len for function calls whose
138
   arguments contain other function calls.  */
139
 
140
struct funcall
141
  {
142
    struct funcall *next;
143
    int arglist_len;
144
  };
145
 
146
static struct funcall *funcall_chain;
147
 
148
/* Begin counting arguments for a function call,
149
   saving the data about any containing call.  */
150
 
151
void
152
start_arglist (void)
153
{
154
  struct funcall *new;
155
 
156
  new = (struct funcall *) xmalloc (sizeof (struct funcall));
157
  new->next = funcall_chain;
158
  new->arglist_len = arglist_len;
159
  arglist_len = 0;
160
  funcall_chain = new;
161
}
162
 
163
/* Return the number of arguments in a function call just terminated,
164
   and restore the data for the containing function call.  */
165
 
166
int
167
end_arglist (void)
168
{
169
  int val = arglist_len;
170
  struct funcall *call = funcall_chain;
171
 
172
  funcall_chain = call->next;
173
  arglist_len = call->arglist_len;
174
  xfree (call);
175
  return val;
176
}
177
 
178
/* Free everything in the funcall chain.
179
   Used when there is an error inside parsing.  */
180
 
181
static void
182
free_funcalls (void *ignore)
183
{
184
  struct funcall *call, *next;
185
 
186
  for (call = funcall_chain; call; call = next)
187
    {
188
      next = call->next;
189
      xfree (call);
190
    }
191
}
192
 
193
/* This page contains the functions for adding data to the  struct expression
194
   being constructed.  */
195
 
196
/* Add one element to the end of the expression.  */
197
 
198
/* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
199
   a register through here */
200
 
201
void
202
write_exp_elt (union exp_element expelt)
203
{
204
  if (expout_ptr >= expout_size)
205
    {
206
      expout_size *= 2;
207
      expout = (struct expression *)
208
        xrealloc ((char *) expout, sizeof (struct expression)
209
                  + EXP_ELEM_TO_BYTES (expout_size));
210
    }
211
  expout->elts[expout_ptr++] = expelt;
212
}
213
 
214
void
215
write_exp_elt_opcode (enum exp_opcode expelt)
216
{
217
  union exp_element tmp;
218
 
219
  memset (&tmp, 0, sizeof (union exp_element));
220
  tmp.opcode = expelt;
221
  write_exp_elt (tmp);
222
}
223
 
224
void
225
write_exp_elt_sym (struct symbol *expelt)
226
{
227
  union exp_element tmp;
228
 
229
  memset (&tmp, 0, sizeof (union exp_element));
230
  tmp.symbol = expelt;
231
  write_exp_elt (tmp);
232
}
233
 
234
void
235
write_exp_elt_block (struct block *b)
236
{
237
  union exp_element tmp;
238
 
239
  memset (&tmp, 0, sizeof (union exp_element));
240
  tmp.block = b;
241
  write_exp_elt (tmp);
242
}
243
 
244
void
245
write_exp_elt_objfile (struct objfile *objfile)
246
{
247
  union exp_element tmp;
248
 
249
  memset (&tmp, 0, sizeof (union exp_element));
250
  tmp.objfile = objfile;
251
  write_exp_elt (tmp);
252
}
253
 
254
void
255
write_exp_elt_longcst (LONGEST expelt)
256
{
257
  union exp_element tmp;
258
 
259
  memset (&tmp, 0, sizeof (union exp_element));
260
  tmp.longconst = expelt;
261
  write_exp_elt (tmp);
262
}
263
 
264
void
265
write_exp_elt_dblcst (DOUBLEST expelt)
266
{
267
  union exp_element tmp;
268
 
269
  memset (&tmp, 0, sizeof (union exp_element));
270
  tmp.doubleconst = expelt;
271
  write_exp_elt (tmp);
272
}
273
 
274
void
275
write_exp_elt_decfloatcst (gdb_byte expelt[16])
276
{
277
  union exp_element tmp;
278
  int index;
279
 
280
  for (index = 0; index < 16; index++)
281
    tmp.decfloatconst[index] = expelt[index];
282
 
283
  write_exp_elt (tmp);
284
}
285
 
286
void
287
write_exp_elt_type (struct type *expelt)
288
{
289
  union exp_element tmp;
290
 
291
  memset (&tmp, 0, sizeof (union exp_element));
292
  tmp.type = expelt;
293
  write_exp_elt (tmp);
294
}
295
 
296
void
297
write_exp_elt_intern (struct internalvar *expelt)
298
{
299
  union exp_element tmp;
300
 
301
  memset (&tmp, 0, sizeof (union exp_element));
302
  tmp.internalvar = expelt;
303
  write_exp_elt (tmp);
304
}
305
 
306
/* Add a string constant to the end of the expression.
307
 
308
   String constants are stored by first writing an expression element
309
   that contains the length of the string, then stuffing the string
310
   constant itself into however many expression elements are needed
311
   to hold it, and then writing another expression element that contains
312
   the length of the string.  I.E. an expression element at each end of
313
   the string records the string length, so you can skip over the
314
   expression elements containing the actual string bytes from either
315
   end of the string.  Note that this also allows gdb to handle
316
   strings with embedded null bytes, as is required for some languages.
317
 
318
   Don't be fooled by the fact that the string is null byte terminated,
319
   this is strictly for the convenience of debugging gdb itself.
320
   Gdb does not depend up the string being null terminated, since the
321
   actual length is recorded in expression elements at each end of the
322
   string.  The null byte is taken into consideration when computing how
323
   many expression elements are required to hold the string constant, of
324
   course. */
325
 
326
 
327
void
328
write_exp_string (struct stoken str)
329
{
330
  int len = str.length;
331
  int lenelt;
332
  char *strdata;
333
 
334
  /* Compute the number of expression elements required to hold the string
335
     (including a null byte terminator), along with one expression element
336
     at each end to record the actual string length (not including the
337
     null byte terminator). */
338
 
339
  lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
340
 
341
  /* Ensure that we have enough available expression elements to store
342
     everything. */
343
 
344
  if ((expout_ptr + lenelt) >= expout_size)
345
    {
346
      expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
347
      expout = (struct expression *)
348
        xrealloc ((char *) expout, (sizeof (struct expression)
349
                                    + EXP_ELEM_TO_BYTES (expout_size)));
350
    }
351
 
352
  /* Write the leading length expression element (which advances the current
353
     expression element index), then write the string constant followed by a
354
     terminating null byte, and then write the trailing length expression
355
     element. */
356
 
357
  write_exp_elt_longcst ((LONGEST) len);
358
  strdata = (char *) &expout->elts[expout_ptr];
359
  memcpy (strdata, str.ptr, len);
360
  *(strdata + len) = '\0';
361
  expout_ptr += lenelt - 2;
362
  write_exp_elt_longcst ((LONGEST) len);
363
}
364
 
365
/* Add a vector of string constants to the end of the expression.
366
 
367
   This adds an OP_STRING operation, but encodes the contents
368
   differently from write_exp_string.  The language is expected to
369
   handle evaluation of this expression itself.
370
 
371
   After the usual OP_STRING header, TYPE is written into the
372
   expression as a long constant.  The interpretation of this field is
373
   up to the language evaluator.
374
 
375
   Next, each string in VEC is written.  The length is written as a
376
   long constant, followed by the contents of the string.  */
377
 
378
void
379
write_exp_string_vector (int type, struct stoken_vector *vec)
380
{
381
  int i, n_slots, len;
382
 
383
  /* Compute the size.  We compute the size in number of slots to
384
     avoid issues with string padding.  */
385
  n_slots = 0;
386
  for (i = 0; i < vec->len; ++i)
387
    {
388
      /* One slot for the length of this element, plus the number of
389
         slots needed for this string.  */
390
      n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
391
    }
392
 
393
  /* One more slot for the type of the string.  */
394
  ++n_slots;
395
 
396
  /* Now compute a phony string length.  */
397
  len = EXP_ELEM_TO_BYTES (n_slots) - 1;
398
 
399
  n_slots += 4;
400
  if ((expout_ptr + n_slots) >= expout_size)
401
    {
402
      expout_size = max (expout_size * 2, expout_ptr + n_slots + 10);
403
      expout = (struct expression *)
404
        xrealloc ((char *) expout, (sizeof (struct expression)
405
                                    + EXP_ELEM_TO_BYTES (expout_size)));
406
    }
407
 
408
  write_exp_elt_opcode (OP_STRING);
409
  write_exp_elt_longcst (len);
410
  write_exp_elt_longcst (type);
411
 
412
  for (i = 0; i < vec->len; ++i)
413
    {
414
      write_exp_elt_longcst (vec->tokens[i].length);
415
      memcpy (&expout->elts[expout_ptr], vec->tokens[i].ptr,
416
              vec->tokens[i].length);
417
      expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
418
    }
419
 
420
  write_exp_elt_longcst (len);
421
  write_exp_elt_opcode (OP_STRING);
422
}
423
 
424
/* Add a bitstring constant to the end of the expression.
425
 
426
   Bitstring constants are stored by first writing an expression element
427
   that contains the length of the bitstring (in bits), then stuffing the
428
   bitstring constant itself into however many expression elements are
429
   needed to hold it, and then writing another expression element that
430
   contains the length of the bitstring.  I.E. an expression element at
431
   each end of the bitstring records the bitstring length, so you can skip
432
   over the expression elements containing the actual bitstring bytes from
433
   either end of the bitstring. */
434
 
435
void
436
write_exp_bitstring (struct stoken str)
437
{
438
  int bits = str.length;        /* length in bits */
439
  int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
440
  int lenelt;
441
  char *strdata;
442
 
443
  /* Compute the number of expression elements required to hold the bitstring,
444
     along with one expression element at each end to record the actual
445
     bitstring length in bits. */
446
 
447
  lenelt = 2 + BYTES_TO_EXP_ELEM (len);
448
 
449
  /* Ensure that we have enough available expression elements to store
450
     everything. */
451
 
452
  if ((expout_ptr + lenelt) >= expout_size)
453
    {
454
      expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
455
      expout = (struct expression *)
456
        xrealloc ((char *) expout, (sizeof (struct expression)
457
                                    + EXP_ELEM_TO_BYTES (expout_size)));
458
    }
459
 
460
  /* Write the leading length expression element (which advances the current
461
     expression element index), then write the bitstring constant, and then
462
     write the trailing length expression element. */
463
 
464
  write_exp_elt_longcst ((LONGEST) bits);
465
  strdata = (char *) &expout->elts[expout_ptr];
466
  memcpy (strdata, str.ptr, len);
467
  expout_ptr += lenelt - 2;
468
  write_exp_elt_longcst ((LONGEST) bits);
469
}
470
 
471
/* Add the appropriate elements for a minimal symbol to the end of
472
   the expression.  */
473
 
474
void
475
write_exp_msymbol (struct minimal_symbol *msymbol)
476
{
477
  struct objfile *objfile = msymbol_objfile (msymbol);
478
  struct gdbarch *gdbarch = get_objfile_arch (objfile);
479
 
480
  CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
481
  struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
482
  enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
483
  CORE_ADDR pc;
484
 
485
  /* The minimal symbol might point to a function descriptor;
486
     resolve it to the actual code address instead.  */
487
  pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
488
  if (pc != addr)
489
    {
490
      /* In this case, assume we have a code symbol instead of
491
         a data symbol.  */
492
      type = mst_text;
493
      section = NULL;
494
      addr = pc;
495
    }
496
 
497
  if (overlay_debugging)
498
    addr = symbol_overlayed_address (addr, section);
499
 
500
  write_exp_elt_opcode (OP_LONG);
501
  /* Let's make the type big enough to hold a 64-bit address.  */
502
  write_exp_elt_type (objfile_type (objfile)->builtin_core_addr);
503
  write_exp_elt_longcst ((LONGEST) addr);
504
  write_exp_elt_opcode (OP_LONG);
505
 
506
  if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
507
    {
508
      write_exp_elt_opcode (UNOP_MEMVAL_TLS);
509
      write_exp_elt_objfile (objfile);
510
      write_exp_elt_type (objfile_type (objfile)->nodebug_tls_symbol);
511
      write_exp_elt_opcode (UNOP_MEMVAL_TLS);
512
      return;
513
    }
514
 
515
  write_exp_elt_opcode (UNOP_MEMVAL);
516
  switch (type)
517
    {
518
    case mst_text:
519
    case mst_file_text:
520
    case mst_solib_trampoline:
521
      write_exp_elt_type (objfile_type (objfile)->nodebug_text_symbol);
522
      break;
523
 
524
    case mst_data:
525
    case mst_file_data:
526
    case mst_bss:
527
    case mst_file_bss:
528
      write_exp_elt_type (objfile_type (objfile)->nodebug_data_symbol);
529
      break;
530
 
531
    default:
532
      write_exp_elt_type (objfile_type (objfile)->nodebug_unknown_symbol);
533
      break;
534
    }
535
  write_exp_elt_opcode (UNOP_MEMVAL);
536
}
537
 
538
/* Mark the current index as the starting location of a structure
539
   expression.  This is used when completing on field names.  */
540
 
541
void
542
mark_struct_expression (void)
543
{
544
  expout_last_struct = expout_ptr;
545
}
546
 
547
 
548
/* Recognize tokens that start with '$'.  These include:
549
 
550
   $regname     A native register name or a "standard
551
   register name".
552
 
553
   $variable    A convenience variable with a name chosen
554
   by the user.
555
 
556
   $digits              Value history with index <digits>, starting
557
   from the first value which has index 1.
558
 
559
   $$digits     Value history with index <digits> relative
560
   to the last value.  I.E. $$0 is the last
561
   value, $$1 is the one previous to that, $$2
562
   is the one previous to $$1, etc.
563
 
564
   $ | $0 | $$0 The last value in the value history.
565
 
566
   $$           An abbreviation for the second to the last
567
   value in the value history, I.E. $$1
568
 
569
 */
570
 
571
void
572
write_dollar_variable (struct stoken str)
573
{
574
  struct symbol *sym = NULL;
575
  struct minimal_symbol *msym = NULL;
576
  struct internalvar *isym = NULL;
577
 
578
  /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
579
     and $$digits (equivalent to $<-digits> if you could type that). */
580
 
581
  int negate = 0;
582
  int i = 1;
583
  /* Double dollar means negate the number and add -1 as well.
584
     Thus $$ alone means -1.  */
585
  if (str.length >= 2 && str.ptr[1] == '$')
586
    {
587
      negate = 1;
588
      i = 2;
589
    }
590
  if (i == str.length)
591
    {
592
      /* Just dollars (one or two) */
593
      i = -negate;
594
      goto handle_last;
595
    }
596
  /* Is the rest of the token digits?  */
597
  for (; i < str.length; i++)
598
    if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
599
      break;
600
  if (i == str.length)
601
    {
602
      i = atoi (str.ptr + 1 + negate);
603
      if (negate)
604
        i = -i;
605
      goto handle_last;
606
    }
607
 
608
  /* Handle tokens that refer to machine registers:
609
     $ followed by a register name.  */
610
  i = user_reg_map_name_to_regnum (parse_gdbarch,
611
                                   str.ptr + 1, str.length - 1);
612
  if (i >= 0)
613
    goto handle_register;
614
 
615
  /* Any names starting with $ are probably debugger internal variables.  */
616
 
617
  isym = lookup_only_internalvar (copy_name (str) + 1);
618
  if (isym)
619
    {
620
      write_exp_elt_opcode (OP_INTERNALVAR);
621
      write_exp_elt_intern (isym);
622
      write_exp_elt_opcode (OP_INTERNALVAR);
623
      return;
624
    }
625
 
626
  /* On some systems, such as HP-UX and hppa-linux, certain system routines
627
     have names beginning with $ or $$.  Check for those, first. */
628
 
629
  sym = lookup_symbol (copy_name (str), (struct block *) NULL,
630
                       VAR_DOMAIN, (int *) NULL);
631
  if (sym)
632
    {
633
      write_exp_elt_opcode (OP_VAR_VALUE);
634
      write_exp_elt_block (block_found);        /* set by lookup_symbol */
635
      write_exp_elt_sym (sym);
636
      write_exp_elt_opcode (OP_VAR_VALUE);
637
      return;
638
    }
639
  msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
640
  if (msym)
641
    {
642
      write_exp_msymbol (msym);
643
      return;
644
    }
645
 
646
  /* Any other names are assumed to be debugger internal variables.  */
647
 
648
  write_exp_elt_opcode (OP_INTERNALVAR);
649
  write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
650
  write_exp_elt_opcode (OP_INTERNALVAR);
651
  return;
652
handle_last:
653
  write_exp_elt_opcode (OP_LAST);
654
  write_exp_elt_longcst ((LONGEST) i);
655
  write_exp_elt_opcode (OP_LAST);
656
  return;
657
handle_register:
658
  write_exp_elt_opcode (OP_REGISTER);
659
  str.length--;
660
  str.ptr++;
661
  write_exp_string (str);
662
  write_exp_elt_opcode (OP_REGISTER);
663
  return;
664
}
665
 
666
 
667
char *
668
find_template_name_end (char *p)
669
{
670
  int depth = 1;
671
  int just_seen_right = 0;
672
  int just_seen_colon = 0;
673
  int just_seen_space = 0;
674
 
675
  if (!p || (*p != '<'))
676
    return 0;
677
 
678
  while (*++p)
679
    {
680
      switch (*p)
681
        {
682
        case '\'':
683
        case '\"':
684
        case '{':
685
        case '}':
686
          /* In future, may want to allow these?? */
687
          return 0;
688
        case '<':
689
          depth++;              /* start nested template */
690
          if (just_seen_colon || just_seen_right || just_seen_space)
691
            return 0;            /* but not after : or :: or > or space */
692
          break;
693
        case '>':
694
          if (just_seen_colon || just_seen_right)
695
            return 0;            /* end a (nested?) template */
696
          just_seen_right = 1;  /* but not after : or :: */
697
          if (--depth == 0)      /* also disallow >>, insist on > > */
698
            return ++p;         /* if outermost ended, return */
699
          break;
700
        case ':':
701
          if (just_seen_space || (just_seen_colon > 1))
702
            return 0;            /* nested class spec coming up */
703
          just_seen_colon++;    /* we allow :: but not :::: */
704
          break;
705
        case ' ':
706
          break;
707
        default:
708
          if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
709
                (*p >= 'A' && *p <= 'Z') ||
710
                (*p >= '0' && *p <= '9') ||
711
                (*p == '_') || (*p == ',') ||   /* commas for template args */
712
                (*p == '&') || (*p == '*') ||   /* pointer and ref types */
713
                (*p == '(') || (*p == ')') ||   /* function types */
714
                (*p == '[') || (*p == ']')))    /* array types */
715
            return 0;
716
        }
717
      if (*p != ' ')
718
        just_seen_space = 0;
719
      if (*p != ':')
720
        just_seen_colon = 0;
721
      if (*p != '>')
722
        just_seen_right = 0;
723
    }
724
  return 0;
725
}
726
 
727
 
728
 
729
/* Return a null-terminated temporary copy of the name
730
   of a string token.  */
731
 
732
char *
733
copy_name (struct stoken token)
734
{
735
  /* Make sure there's enough space for the token.  */
736
  if (namecopy_size < token.length + 1)
737
    {
738
      namecopy_size = token.length + 1;
739
      namecopy = xrealloc (namecopy, token.length + 1);
740
    }
741
 
742
  memcpy (namecopy, token.ptr, token.length);
743
  namecopy[token.length] = 0;
744
 
745
  return namecopy;
746
}
747
 
748
/* Reverse an expression from suffix form (in which it is constructed)
749
   to prefix form (in which we can conveniently print or execute it).
750
   Ordinarily this always returns -1.  However, if EXPOUT_LAST_STRUCT
751
   is not -1 (i.e., we are trying to complete a field name), it will
752
   return the index of the subexpression which is the left-hand-side
753
   of the struct operation at EXPOUT_LAST_STRUCT.  */
754
 
755
static int
756
prefixify_expression (struct expression *expr)
757
{
758
  int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
759
  struct expression *temp;
760
  int inpos = expr->nelts, outpos = 0;
761
 
762
  temp = (struct expression *) alloca (len);
763
 
764
  /* Copy the original expression into temp.  */
765
  memcpy (temp, expr, len);
766
 
767
  return prefixify_subexp (temp, expr, inpos, outpos);
768
}
769
 
770
/* Return the number of exp_elements in the postfix subexpression
771
   of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
772
 
773
int
774
length_of_subexp (struct expression *expr, int endpos)
775
{
776
  int oplen, args;
777
 
778
  operator_length (expr, endpos, &oplen, &args);
779
 
780
  while (args > 0)
781
    {
782
      oplen += length_of_subexp (expr, endpos - oplen);
783
      args--;
784
    }
785
 
786
  return oplen;
787
}
788
 
789
/* Sets *OPLENP to the length of the operator whose (last) index is
790
   ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
791
   operator takes.  */
792
 
793
void
794
operator_length (const struct expression *expr, int endpos, int *oplenp,
795
                 int *argsp)
796
{
797
  expr->language_defn->la_exp_desc->operator_length (expr, endpos,
798
                                                     oplenp, argsp);
799
}
800
 
801
/* Default value for operator_length in exp_descriptor vectors.  */
802
 
803
void
804
operator_length_standard (const struct expression *expr, int endpos,
805
                          int *oplenp, int *argsp)
806
{
807
  int oplen = 1;
808
  int args = 0;
809
  enum f90_range_type range_type;
810
  int i;
811
 
812
  if (endpos < 1)
813
    error (_("?error in operator_length_standard"));
814
 
815
  i = (int) expr->elts[endpos - 1].opcode;
816
 
817
  switch (i)
818
    {
819
      /* C++  */
820
    case OP_SCOPE:
821
      oplen = longest_to_int (expr->elts[endpos - 2].longconst);
822
      oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
823
      break;
824
 
825
    case OP_LONG:
826
    case OP_DOUBLE:
827
    case OP_DECFLOAT:
828
    case OP_VAR_VALUE:
829
      oplen = 4;
830
      break;
831
 
832
    case OP_TYPE:
833
    case OP_BOOL:
834
    case OP_LAST:
835
    case OP_INTERNALVAR:
836
      oplen = 3;
837
      break;
838
 
839
    case OP_COMPLEX:
840
      oplen = 3;
841
      args = 2;
842
      break;
843
 
844
    case OP_FUNCALL:
845
    case OP_F77_UNDETERMINED_ARGLIST:
846
      oplen = 3;
847
      args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
848
      break;
849
 
850
    case TYPE_INSTANCE:
851
      oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
852
      args = 1;
853
      break;
854
 
855
    case OP_OBJC_MSGCALL:       /* Objective C message (method) call */
856
      oplen = 4;
857
      args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
858
      break;
859
 
860
    case UNOP_MAX:
861
    case UNOP_MIN:
862
      oplen = 3;
863
      break;
864
 
865
    case BINOP_VAL:
866
    case UNOP_CAST:
867
    case UNOP_DYNAMIC_CAST:
868
    case UNOP_REINTERPRET_CAST:
869
    case UNOP_MEMVAL:
870
      oplen = 3;
871
      args = 1;
872
      break;
873
 
874
    case UNOP_MEMVAL_TLS:
875
      oplen = 4;
876
      args = 1;
877
      break;
878
 
879
    case UNOP_ABS:
880
    case UNOP_CAP:
881
    case UNOP_CHR:
882
    case UNOP_FLOAT:
883
    case UNOP_HIGH:
884
    case UNOP_ODD:
885
    case UNOP_ORD:
886
    case UNOP_TRUNC:
887
      oplen = 1;
888
      args = 1;
889
      break;
890
 
891
    case OP_ADL_FUNC:
892
      oplen = longest_to_int (expr->elts[endpos - 2].longconst);
893
      oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
894
      oplen++;
895
      oplen++;
896
      break;
897
 
898
    case OP_LABELED:
899
    case STRUCTOP_STRUCT:
900
    case STRUCTOP_PTR:
901
      args = 1;
902
      /* fall through */
903
    case OP_REGISTER:
904
    case OP_M2_STRING:
905
    case OP_STRING:
906
    case OP_OBJC_NSSTRING:      /* Objective C Foundation Class NSString constant */
907
    case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op */
908
    case OP_NAME:
909
      oplen = longest_to_int (expr->elts[endpos - 2].longconst);
910
      oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
911
      break;
912
 
913
    case OP_BITSTRING:
914
      oplen = longest_to_int (expr->elts[endpos - 2].longconst);
915
      oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
916
      oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
917
      break;
918
 
919
    case OP_ARRAY:
920
      oplen = 4;
921
      args = longest_to_int (expr->elts[endpos - 2].longconst);
922
      args -= longest_to_int (expr->elts[endpos - 3].longconst);
923
      args += 1;
924
      break;
925
 
926
    case TERNOP_COND:
927
    case TERNOP_SLICE:
928
    case TERNOP_SLICE_COUNT:
929
      args = 3;
930
      break;
931
 
932
      /* Modula-2 */
933
    case MULTI_SUBSCRIPT:
934
      oplen = 3;
935
      args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
936
      break;
937
 
938
    case BINOP_ASSIGN_MODIFY:
939
      oplen = 3;
940
      args = 2;
941
      break;
942
 
943
      /* C++ */
944
    case OP_THIS:
945
    case OP_OBJC_SELF:
946
      oplen = 2;
947
      break;
948
 
949
    case OP_F90_RANGE:
950
      oplen = 3;
951
 
952
      range_type = longest_to_int (expr->elts[endpos - 2].longconst);
953
      switch (range_type)
954
        {
955
        case LOW_BOUND_DEFAULT:
956
        case HIGH_BOUND_DEFAULT:
957
          args = 1;
958
          break;
959
        case BOTH_BOUND_DEFAULT:
960
          args = 0;
961
          break;
962
        case NONE_BOUND_DEFAULT:
963
          args = 2;
964
          break;
965
        }
966
 
967
      break;
968
 
969
    default:
970
      args = 1 + (i < (int) BINOP_END);
971
    }
972
 
973
  *oplenp = oplen;
974
  *argsp = args;
975
}
976
 
977
/* Copy the subexpression ending just before index INEND in INEXPR
978
   into OUTEXPR, starting at index OUTBEG.
979
   In the process, convert it from suffix to prefix form.
980
   If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
981
   Otherwise, it returns the index of the subexpression which is the
982
   left-hand-side of the expression at EXPOUT_LAST_STRUCT.  */
983
 
984
static int
985
prefixify_subexp (struct expression *inexpr,
986
                  struct expression *outexpr, int inend, int outbeg)
987
{
988
  int oplen;
989
  int args;
990
  int i;
991
  int *arglens;
992
  int result = -1;
993
 
994
  operator_length (inexpr, inend, &oplen, &args);
995
 
996
  /* Copy the final operator itself, from the end of the input
997
     to the beginning of the output.  */
998
  inend -= oplen;
999
  memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1000
          EXP_ELEM_TO_BYTES (oplen));
1001
  outbeg += oplen;
1002
 
1003
  if (expout_last_struct == inend)
1004
    result = outbeg - oplen;
1005
 
1006
  /* Find the lengths of the arg subexpressions.  */
1007
  arglens = (int *) alloca (args * sizeof (int));
1008
  for (i = args - 1; i >= 0; i--)
1009
    {
1010
      oplen = length_of_subexp (inexpr, inend);
1011
      arglens[i] = oplen;
1012
      inend -= oplen;
1013
    }
1014
 
1015
  /* Now copy each subexpression, preserving the order of
1016
     the subexpressions, but prefixifying each one.
1017
     In this loop, inend starts at the beginning of
1018
     the expression this level is working on
1019
     and marches forward over the arguments.
1020
     outbeg does similarly in the output.  */
1021
  for (i = 0; i < args; i++)
1022
    {
1023
      int r;
1024
 
1025
      oplen = arglens[i];
1026
      inend += oplen;
1027
      r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1028
      if (r != -1)
1029
        {
1030
          /* Return immediately.  We probably have only parsed a
1031
             partial expression, so we don't want to try to reverse
1032
             the other operands.  */
1033
          return r;
1034
        }
1035
      outbeg += oplen;
1036
    }
1037
 
1038
  return result;
1039
}
1040
 
1041
/* This page contains the two entry points to this file.  */
1042
 
1043
/* Read an expression from the string *STRINGPTR points to,
1044
   parse it, and return a pointer to a  struct expression  that we malloc.
1045
   Use block BLOCK as the lexical context for variable names;
1046
   if BLOCK is zero, use the block of the selected stack frame.
1047
   Meanwhile, advance *STRINGPTR to point after the expression,
1048
   at the first nonwhite character that is not part of the expression
1049
   (possibly a null character).
1050
 
1051
   If COMMA is nonzero, stop if a comma is reached.  */
1052
 
1053
struct expression *
1054
parse_exp_1 (char **stringptr, struct block *block, int comma)
1055
{
1056
  return parse_exp_in_context (stringptr, block, comma, 0, NULL);
1057
}
1058
 
1059
/* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1060
   no value is expected from the expression.
1061
   OUT_SUBEXP is set when attempting to complete a field name; in this
1062
   case it is set to the index of the subexpression on the
1063
   left-hand-side of the struct op.  If not doing such completion, it
1064
   is left untouched.  */
1065
 
1066
static struct expression *
1067
parse_exp_in_context (char **stringptr, struct block *block, int comma,
1068
                      int void_context_p, int *out_subexp)
1069
{
1070
  volatile struct gdb_exception except;
1071
  struct cleanup *old_chain;
1072
  const struct language_defn *lang = NULL;
1073
  int subexp;
1074
 
1075
  lexptr = *stringptr;
1076
  prev_lexptr = NULL;
1077
 
1078
  paren_depth = 0;
1079
  type_stack_depth = 0;
1080
  expout_last_struct = -1;
1081
 
1082
  comma_terminates = comma;
1083
 
1084
  if (lexptr == 0 || *lexptr == 0)
1085
    error_no_arg (_("expression to compute"));
1086
 
1087
  old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1088
  funcall_chain = 0;
1089
 
1090
  expression_context_block = block;
1091
 
1092
  /* If no context specified, try using the current frame, if any.  */
1093
  if (!expression_context_block)
1094
    expression_context_block = get_selected_block (&expression_context_pc);
1095
  else
1096
    expression_context_pc = BLOCK_START (expression_context_block);
1097
 
1098
  /* Fall back to using the current source static context, if any.  */
1099
 
1100
  if (!expression_context_block)
1101
    {
1102
      struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1103
      if (cursal.symtab)
1104
        expression_context_block
1105
          = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1106
      if (expression_context_block)
1107
        expression_context_pc = BLOCK_START (expression_context_block);
1108
    }
1109
 
1110
  if (language_mode == language_mode_auto && block != NULL)
1111
    {
1112
      /* Find the language associated to the given context block.
1113
         Default to the current language if it can not be determined.
1114
 
1115
         Note that using the language corresponding to the current frame
1116
         can sometimes give unexpected results.  For instance, this
1117
         routine is often called several times during the inferior
1118
         startup phase to re-parse breakpoint expressions after
1119
         a new shared library has been loaded.  The language associated
1120
         to the current frame at this moment is not relevant for
1121
         the breakpoint. Using it would therefore be silly, so it seems
1122
         better to rely on the current language rather than relying on
1123
         the current frame language to parse the expression. That's why
1124
         we do the following language detection only if the context block
1125
         has been specifically provided.  */
1126
      struct symbol *func = block_linkage_function (block);
1127
 
1128
      if (func != NULL)
1129
        lang = language_def (SYMBOL_LANGUAGE (func));
1130
      if (lang == NULL || lang->la_language == language_unknown)
1131
        lang = current_language;
1132
    }
1133
  else
1134
    lang = current_language;
1135
 
1136
  expout_size = 10;
1137
  expout_ptr = 0;
1138
  expout = (struct expression *)
1139
    xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1140
  expout->language_defn = lang;
1141
  expout->gdbarch = get_current_arch ();
1142
 
1143
  TRY_CATCH (except, RETURN_MASK_ALL)
1144
    {
1145
      if (lang->la_parser ())
1146
        lang->la_error (NULL);
1147
    }
1148
  if (except.reason < 0)
1149
    {
1150
      if (! in_parse_field)
1151
        {
1152
          xfree (expout);
1153
          throw_exception (except);
1154
        }
1155
    }
1156
 
1157
  discard_cleanups (old_chain);
1158
 
1159
  /* Record the actual number of expression elements, and then
1160
     reallocate the expression memory so that we free up any
1161
     excess elements. */
1162
 
1163
  expout->nelts = expout_ptr;
1164
  expout = (struct expression *)
1165
    xrealloc ((char *) expout,
1166
              sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1167
 
1168
  /* Convert expression from postfix form as generated by yacc
1169
     parser, to a prefix form. */
1170
 
1171
  if (expressiondebug)
1172
    dump_raw_expression (expout, gdb_stdlog,
1173
                         "before conversion to prefix form");
1174
 
1175
  subexp = prefixify_expression (expout);
1176
  if (out_subexp)
1177
    *out_subexp = subexp;
1178
 
1179
  lang->la_post_parser (&expout, void_context_p);
1180
 
1181
  if (expressiondebug)
1182
    dump_prefix_expression (expout, gdb_stdlog);
1183
 
1184
  *stringptr = lexptr;
1185
  return expout;
1186
}
1187
 
1188
/* Parse STRING as an expression, and complain if this fails
1189
   to use up all of the contents of STRING.  */
1190
 
1191
struct expression *
1192
parse_expression (char *string)
1193
{
1194
  struct expression *exp;
1195
 
1196
  exp = parse_exp_1 (&string, 0, 0);
1197
  if (*string)
1198
    error (_("Junk after end of expression."));
1199
  return exp;
1200
}
1201
 
1202
/* Parse STRING as an expression.  If parsing ends in the middle of a
1203
   field reference, return the type of the left-hand-side of the
1204
   reference; furthermore, if the parsing ends in the field name,
1205
   return the field name in *NAME.  In all other cases, return NULL.
1206
   Returned non-NULL *NAME must be freed by the caller.  */
1207
 
1208
struct type *
1209
parse_field_expression (char *string, char **name)
1210
{
1211
  struct expression *exp = NULL;
1212
  struct value *val;
1213
  int subexp;
1214
  volatile struct gdb_exception except;
1215
 
1216
  TRY_CATCH (except, RETURN_MASK_ALL)
1217
    {
1218
      in_parse_field = 1;
1219
      exp = parse_exp_in_context (&string, 0, 0, 0, &subexp);
1220
    }
1221
  in_parse_field = 0;
1222
  if (except.reason < 0 || ! exp)
1223
    return NULL;
1224
  if (expout_last_struct == -1)
1225
    {
1226
      xfree (exp);
1227
      return NULL;
1228
    }
1229
 
1230
  *name = extract_field_op (exp, &subexp);
1231
  if (!*name)
1232
    {
1233
      xfree (exp);
1234
      return NULL;
1235
    }
1236
  /* (*NAME) is a part of the EXP memory block freed below.  */
1237
  *name = xstrdup (*name);
1238
 
1239
  val = evaluate_subexpression_type (exp, subexp);
1240
  xfree (exp);
1241
 
1242
  return value_type (val);
1243
}
1244
 
1245
/* A post-parser that does nothing */
1246
 
1247
void
1248
null_post_parser (struct expression **exp, int void_context_p)
1249
{
1250
}
1251
 
1252
/* Stuff for maintaining a stack of types.  Currently just used by C, but
1253
   probably useful for any language which declares its types "backwards".  */
1254
 
1255
static void
1256
check_type_stack_depth (void)
1257
{
1258
  if (type_stack_depth == type_stack_size)
1259
    {
1260
      type_stack_size *= 2;
1261
      type_stack = (union type_stack_elt *)
1262
        xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1263
    }
1264
}
1265
 
1266
void
1267
push_type (enum type_pieces tp)
1268
{
1269
  check_type_stack_depth ();
1270
  type_stack[type_stack_depth++].piece = tp;
1271
}
1272
 
1273
void
1274
push_type_int (int n)
1275
{
1276
  check_type_stack_depth ();
1277
  type_stack[type_stack_depth++].int_val = n;
1278
}
1279
 
1280
void
1281
push_type_address_space (char *string)
1282
{
1283
  push_type_int (address_space_name_to_int (parse_gdbarch, string));
1284
}
1285
 
1286
enum type_pieces
1287
pop_type (void)
1288
{
1289
  if (type_stack_depth)
1290
    return type_stack[--type_stack_depth].piece;
1291
  return tp_end;
1292
}
1293
 
1294
int
1295
pop_type_int (void)
1296
{
1297
  if (type_stack_depth)
1298
    return type_stack[--type_stack_depth].int_val;
1299
  /* "Can't happen".  */
1300
  return 0;
1301
}
1302
 
1303
/* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1304
   as modified by all the stuff on the stack.  */
1305
struct type *
1306
follow_types (struct type *follow_type)
1307
{
1308
  int done = 0;
1309
  int make_const = 0;
1310
  int make_volatile = 0;
1311
  int make_addr_space = 0;
1312
  int array_size;
1313
 
1314
  while (!done)
1315
    switch (pop_type ())
1316
      {
1317
      case tp_end:
1318
        done = 1;
1319
        if (make_const)
1320
          follow_type = make_cv_type (make_const,
1321
                                      TYPE_VOLATILE (follow_type),
1322
                                      follow_type, 0);
1323
        if (make_volatile)
1324
          follow_type = make_cv_type (TYPE_CONST (follow_type),
1325
                                      make_volatile,
1326
                                      follow_type, 0);
1327
        if (make_addr_space)
1328
          follow_type = make_type_with_address_space (follow_type,
1329
                                                      make_addr_space);
1330
        make_const = make_volatile = 0;
1331
        make_addr_space = 0;
1332
        break;
1333
      case tp_const:
1334
        make_const = 1;
1335
        break;
1336
      case tp_volatile:
1337
        make_volatile = 1;
1338
        break;
1339
      case tp_space_identifier:
1340
        make_addr_space = pop_type_int ();
1341
        break;
1342
      case tp_pointer:
1343
        follow_type = lookup_pointer_type (follow_type);
1344
        if (make_const)
1345
          follow_type = make_cv_type (make_const,
1346
                                      TYPE_VOLATILE (follow_type),
1347
                                      follow_type, 0);
1348
        if (make_volatile)
1349
          follow_type = make_cv_type (TYPE_CONST (follow_type),
1350
                                      make_volatile,
1351
                                      follow_type, 0);
1352
        if (make_addr_space)
1353
          follow_type = make_type_with_address_space (follow_type,
1354
                                                      make_addr_space);
1355
        make_const = make_volatile = 0;
1356
        make_addr_space = 0;
1357
        break;
1358
      case tp_reference:
1359
        follow_type = lookup_reference_type (follow_type);
1360
        if (make_const)
1361
          follow_type = make_cv_type (make_const,
1362
                                      TYPE_VOLATILE (follow_type),
1363
                                      follow_type, 0);
1364
        if (make_volatile)
1365
          follow_type = make_cv_type (TYPE_CONST (follow_type),
1366
                                      make_volatile,
1367
                                      follow_type, 0);
1368
        if (make_addr_space)
1369
          follow_type = make_type_with_address_space (follow_type,
1370
                                                      make_addr_space);
1371
        make_const = make_volatile = 0;
1372
        make_addr_space = 0;
1373
        break;
1374
      case tp_array:
1375
        array_size = pop_type_int ();
1376
        /* FIXME-type-allocation: need a way to free this type when we are
1377
           done with it.  */
1378
        follow_type =
1379
          lookup_array_range_type (follow_type,
1380
                                   0, array_size >= 0 ? array_size - 1 : 0);
1381
        if (array_size < 0)
1382
          TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1;
1383
        break;
1384
      case tp_function:
1385
        /* FIXME-type-allocation: need a way to free this type when we are
1386
           done with it.  */
1387
        follow_type = lookup_function_type (follow_type);
1388
        break;
1389
      }
1390
  return follow_type;
1391
}
1392
 
1393
/* This function avoids direct calls to fprintf
1394
   in the parser generated debug code.  */
1395
void
1396
parser_fprintf (FILE *x, const char *y, ...)
1397
{
1398
  va_list args;
1399
 
1400
  va_start (args, y);
1401
  if (x == stderr)
1402
    vfprintf_unfiltered (gdb_stderr, y, args);
1403
  else
1404
    {
1405
      fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1406
      vfprintf_unfiltered (gdb_stderr, y, args);
1407
    }
1408
  va_end (args);
1409
}
1410
 
1411
/* Implementation of the exp_descriptor method operator_check.  */
1412
 
1413
int
1414
operator_check_standard (struct expression *exp, int pos,
1415
                         int (*objfile_func) (struct objfile *objfile,
1416
                                              void *data),
1417
                         void *data)
1418
{
1419
  const union exp_element *const elts = exp->elts;
1420
  struct type *type = NULL;
1421
  struct objfile *objfile = NULL;
1422
 
1423
  /* Extended operators should have been already handled by exp_descriptor
1424
     iterate method of its specific language.  */
1425
  gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1426
 
1427
  /* Track the callers of write_exp_elt_type for this table.  */
1428
 
1429
  switch (elts[pos].opcode)
1430
    {
1431
    case BINOP_VAL:
1432
    case OP_COMPLEX:
1433
    case OP_DECFLOAT:
1434
    case OP_DOUBLE:
1435
    case OP_LONG:
1436
    case OP_SCOPE:
1437
    case OP_TYPE:
1438
    case UNOP_CAST:
1439
    case UNOP_DYNAMIC_CAST:
1440
    case UNOP_REINTERPRET_CAST:
1441
    case UNOP_MAX:
1442
    case UNOP_MEMVAL:
1443
    case UNOP_MIN:
1444
      type = elts[pos + 1].type;
1445
      break;
1446
 
1447
    case TYPE_INSTANCE:
1448
      {
1449
        LONGEST arg, nargs = elts[pos + 1].longconst;
1450
 
1451
        for (arg = 0; arg < nargs; arg++)
1452
          {
1453
            struct type *type = elts[pos + 2 + arg].type;
1454
            struct objfile *objfile = TYPE_OBJFILE (type);
1455
 
1456
            if (objfile && (*objfile_func) (objfile, data))
1457
              return 1;
1458
          }
1459
      }
1460
      break;
1461
 
1462
    case UNOP_MEMVAL_TLS:
1463
      objfile = elts[pos + 1].objfile;
1464
      type = elts[pos + 2].type;
1465
      break;
1466
 
1467
    case OP_VAR_VALUE:
1468
      {
1469
        const struct block *const block = elts[pos + 1].block;
1470
        const struct symbol *const symbol = elts[pos + 2].symbol;
1471
 
1472
        /* Check objfile where the variable itself is placed.
1473
           SYMBOL_OBJ_SECTION (symbol) may be NULL.  */
1474
        if ((*objfile_func) (SYMBOL_SYMTAB (symbol)->objfile, data))
1475
          return 1;
1476
 
1477
        /* Check objfile where is placed the code touching the variable.  */
1478
        objfile = lookup_objfile_from_block (block);
1479
 
1480
        type = SYMBOL_TYPE (symbol);
1481
      }
1482
      break;
1483
    }
1484
 
1485
  /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL.  */
1486
 
1487
  if (type && TYPE_OBJFILE (type)
1488
      && (*objfile_func) (TYPE_OBJFILE (type), data))
1489
    return 1;
1490
  if (objfile && (*objfile_func) (objfile, data))
1491
    return 1;
1492
 
1493
  return 0;
1494
}
1495
 
1496
/* Call OBJFILE_FUNC for any TYPE and OBJFILE found being referenced by EXP.
1497
   The functions are never called with NULL OBJFILE.  Functions get passed an
1498
   arbitrary caller supplied DATA pointer.  If any of the functions returns
1499
   non-zero value then (any other) non-zero value is immediately returned to
1500
   the caller.  Otherwise zero is returned after iterating through whole EXP.
1501
   */
1502
 
1503
static int
1504
exp_iterate (struct expression *exp,
1505
             int (*objfile_func) (struct objfile *objfile, void *data),
1506
             void *data)
1507
{
1508
  int endpos;
1509
 
1510
  for (endpos = exp->nelts; endpos > 0; )
1511
    {
1512
      int pos, args, oplen = 0;
1513
 
1514
      operator_length (exp, endpos, &oplen, &args);
1515
      gdb_assert (oplen > 0);
1516
 
1517
      pos = endpos - oplen;
1518
      if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1519
                                                           objfile_func, data))
1520
        return 1;
1521
 
1522
      endpos = pos;
1523
    }
1524
 
1525
  return 0;
1526
}
1527
 
1528
/* Helper for exp_uses_objfile.  */
1529
 
1530
static int
1531
exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1532
{
1533
  struct objfile *objfile = objfile_voidp;
1534
 
1535
  if (exp_objfile->separate_debug_objfile_backlink)
1536
    exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1537
 
1538
  return exp_objfile == objfile;
1539
}
1540
 
1541
/* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1542
   is unloaded), otherwise return 0.  OBJFILE must not be a separate debug info
1543
   file.  */
1544
 
1545
int
1546
exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1547
{
1548
  gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1549
 
1550
  return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1551
}
1552
 
1553
void
1554
_initialize_parse (void)
1555
{
1556
  type_stack_size = 80;
1557
  type_stack_depth = 0;
1558
  type_stack = (union type_stack_elt *)
1559
    xmalloc (type_stack_size * sizeof (*type_stack));
1560
 
1561
  add_setshow_zinteger_cmd ("expression", class_maintenance,
1562
                            &expressiondebug, _("\
1563
Set expression debugging."), _("\
1564
Show expression debugging."), _("\
1565
When non-zero, the internal representation of expressions will be printed."),
1566
                            NULL,
1567
                            show_expressiondebug,
1568
                            &setdebuglist, &showdebuglist);
1569
  add_setshow_boolean_cmd ("parser", class_maintenance,
1570
                            &parser_debug, _("\
1571
Set parser debugging."), _("\
1572
Show parser debugging."), _("\
1573
When non-zero, expression parser tracing will be enabled."),
1574
                            NULL,
1575
                            show_parserdebug,
1576
                            &setdebuglist, &showdebuglist);
1577
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.