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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [parse.c] - Blame information for rev 227

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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