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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* Helper routines for C++ support in GDB.
2
   Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
 
5
   Contributed by MontaVista Software.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "cp-support.h"
24
#include "gdb_string.h"
25
#include "demangle.h"
26
#include "gdb_assert.h"
27
#include "gdbcmd.h"
28
#include "dictionary.h"
29
#include "objfiles.h"
30
#include "frame.h"
31
#include "symtab.h"
32
#include "block.h"
33
#include "complaints.h"
34
#include "gdbtypes.h"
35
#include "exceptions.h"
36
#include "expression.h"
37
#include "value.h"
38
 
39
#include "safe-ctype.h"
40
 
41
#include "psymtab.h"
42
 
43
#define d_left(dc) (dc)->u.s_binary.left
44
#define d_right(dc) (dc)->u.s_binary.right
45
 
46
/* Functions related to demangled name parsing.  */
47
 
48
static unsigned int cp_find_first_component_aux (const char *name,
49
                                                 int permissive);
50
 
51
static void demangled_name_complaint (const char *name);
52
 
53
/* Functions/variables related to overload resolution.  */
54
 
55
static int sym_return_val_size = -1;
56
static int sym_return_val_index;
57
static struct symbol **sym_return_val;
58
 
59
static void overload_list_add_symbol (struct symbol *sym,
60
                                      const char *oload_name);
61
 
62
static void make_symbol_overload_list_using (const char *func_name,
63
                                             const char *namespace);
64
 
65
static void make_symbol_overload_list_qualified (const char *func_name);
66
 
67
/* The list of "maint cplus" commands.  */
68
 
69
struct cmd_list_element *maint_cplus_cmd_list = NULL;
70
 
71
/* The actual commands.  */
72
 
73
static void maint_cplus_command (char *arg, int from_tty);
74
static void first_component_command (char *arg, int from_tty);
75
 
76
/* Operator validation.
77
   NOTE: Multi-byte operators (usually the assignment variety operator)
78
   must appear before the single byte version, i.e., "+=" before "+".  */
79
static const char *operator_tokens[] =
80
  {
81
    "++", "+=", "+", "->*", "->", "--", "-=", "-", "*=", "*", "/=", "/",
82
    "%=", "%", "!=", "==", "!", "&&", "<<=", "<<", ">>=", ">>",
83
    "<=", "<", ">=", ">", "~", "&=", "&", "|=", "||", "|", "^=", "^",
84
    "=", "()", "[]", ",", "new", "delete"
85
    /* new[] and delete[] require special whitespace handling */
86
  };
87
 
88
/* Return 1 if STRING is clearly already in canonical form.  This
89
   function is conservative; things which it does not recognize are
90
   assumed to be non-canonical, and the parser will sort them out
91
   afterwards.  This speeds up the critical path for alphanumeric
92
   identifiers.  */
93
 
94
static int
95
cp_already_canonical (const char *string)
96
{
97
  /* Identifier start character [a-zA-Z_].  */
98
  if (!ISIDST (string[0]))
99
    return 0;
100
 
101
  /* These are the only two identifiers which canonicalize to other
102
     than themselves or an error: unsigned -> unsigned int and
103
     signed -> int.  */
104
  if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
105
    return 0;
106
  else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
107
    return 0;
108
 
109
  /* Identifier character [a-zA-Z0-9_].  */
110
  while (ISIDNUM (string[1]))
111
    string++;
112
 
113
  if (string[1] == '\0')
114
    return 1;
115
  else
116
    return 0;
117
}
118
 
119
/* Parse STRING and convert it to canonical form.  If parsing fails,
120
   or if STRING is already canonical, return NULL.  Otherwise return
121
   the canonical form.  The return value is allocated via xmalloc.  */
122
 
123
char *
124
cp_canonicalize_string (const char *string)
125
{
126
  struct demangle_component *ret_comp;
127
  unsigned int estimated_len;
128
  char *ret;
129
 
130
  if (cp_already_canonical (string))
131
    return NULL;
132
 
133
  ret_comp = cp_demangled_name_to_comp (string, NULL);
134
  if (ret_comp == NULL)
135
    return NULL;
136
 
137
  estimated_len = strlen (string) * 2;
138
  ret = cp_comp_to_string (ret_comp, estimated_len);
139
 
140
  if (strcmp (string, ret) == 0)
141
    {
142
      xfree (ret);
143
      return NULL;
144
    }
145
 
146
  return ret;
147
}
148
 
149
/* Convert a mangled name to a demangle_component tree.  *MEMORY is set to the
150
   block of used memory that should be freed when finished with the tree.
151
   DEMANGLED_P is set to the char * that should be freed when finished with
152
   the tree, or NULL if none was needed.  OPTIONS will be passed to the
153
   demangler.  */
154
 
155
static struct demangle_component *
156
mangled_name_to_comp (const char *mangled_name, int options,
157
                      void **memory, char **demangled_p)
158
{
159
  struct demangle_component *ret;
160
  char *demangled_name;
161
 
162
  /* If it looks like a v3 mangled name, then try to go directly
163
     to trees.  */
164
  if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
165
    {
166
      ret = cplus_demangle_v3_components (mangled_name, options, memory);
167
      if (ret)
168
        {
169
          *demangled_p = NULL;
170
          return ret;
171
        }
172
    }
173
 
174
  /* If it doesn't, or if that failed, then try to demangle the name.  */
175
  demangled_name = cplus_demangle (mangled_name, options);
176
  if (demangled_name == NULL)
177
   return NULL;
178
 
179
  /* If we could demangle the name, parse it to build the component tree.  */
180
  ret = cp_demangled_name_to_comp (demangled_name, NULL);
181
 
182
  if (ret == NULL)
183
    {
184
      xfree (demangled_name);
185
      return NULL;
186
    }
187
 
188
  *demangled_p = demangled_name;
189
  return ret;
190
}
191
 
192
/* Return the name of the class containing method PHYSNAME.  */
193
 
194
char *
195
cp_class_name_from_physname (const char *physname)
196
{
197
  void *storage = NULL;
198
  char *demangled_name = NULL, *ret;
199
  struct demangle_component *ret_comp, *prev_comp, *cur_comp;
200
  int done;
201
 
202
  ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
203
                                   &demangled_name);
204
  if (ret_comp == NULL)
205
    return NULL;
206
 
207
  done = 0;
208
 
209
  /* First strip off any qualifiers, if we have a function or method.  */
210
  while (!done)
211
    switch (ret_comp->type)
212
      {
213
      case DEMANGLE_COMPONENT_CONST:
214
      case DEMANGLE_COMPONENT_RESTRICT:
215
      case DEMANGLE_COMPONENT_VOLATILE:
216
      case DEMANGLE_COMPONENT_CONST_THIS:
217
      case DEMANGLE_COMPONENT_RESTRICT_THIS:
218
      case DEMANGLE_COMPONENT_VOLATILE_THIS:
219
      case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
220
        ret_comp = d_left (ret_comp);
221
        break;
222
      default:
223
        done = 1;
224
        break;
225
      }
226
 
227
  /* If what we have now is a function, discard the argument list.  */
228
  if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
229
    ret_comp = d_left (ret_comp);
230
 
231
  /* If what we have now is a template, strip off the template
232
     arguments.  The left subtree may be a qualified name.  */
233
  if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
234
    ret_comp = d_left (ret_comp);
235
 
236
  /* What we have now should be a name, possibly qualified.  Additional
237
     qualifiers could live in the left subtree or the right subtree.  Find
238
     the last piece.  */
239
  done = 0;
240
  prev_comp = NULL;
241
  cur_comp = ret_comp;
242
  while (!done)
243
    switch (cur_comp->type)
244
      {
245
      case DEMANGLE_COMPONENT_QUAL_NAME:
246
      case DEMANGLE_COMPONENT_LOCAL_NAME:
247
        prev_comp = cur_comp;
248
        cur_comp = d_right (cur_comp);
249
        break;
250
      case DEMANGLE_COMPONENT_TEMPLATE:
251
      case DEMANGLE_COMPONENT_NAME:
252
      case DEMANGLE_COMPONENT_CTOR:
253
      case DEMANGLE_COMPONENT_DTOR:
254
      case DEMANGLE_COMPONENT_OPERATOR:
255
      case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
256
        done = 1;
257
        break;
258
      default:
259
        done = 1;
260
        cur_comp = NULL;
261
        break;
262
      }
263
 
264
  ret = NULL;
265
  if (cur_comp != NULL && prev_comp != NULL)
266
    {
267
      /* We want to discard the rightmost child of PREV_COMP.  */
268
      *prev_comp = *d_left (prev_comp);
269
      /* The ten is completely arbitrary; we don't have a good estimate.  */
270
      ret = cp_comp_to_string (ret_comp, 10);
271
    }
272
 
273
  xfree (storage);
274
  if (demangled_name)
275
    xfree (demangled_name);
276
  return ret;
277
}
278
 
279
/* Return the child of COMP which is the basename of a method, variable,
280
   et cetera.  All scope qualifiers are discarded, but template arguments
281
   will be included.  The component tree may be modified.  */
282
 
283
static struct demangle_component *
284
unqualified_name_from_comp (struct demangle_component *comp)
285
{
286
  struct demangle_component *ret_comp = comp, *last_template;
287
  int done;
288
 
289
  done = 0;
290
  last_template = NULL;
291
  while (!done)
292
    switch (ret_comp->type)
293
      {
294
      case DEMANGLE_COMPONENT_QUAL_NAME:
295
      case DEMANGLE_COMPONENT_LOCAL_NAME:
296
        ret_comp = d_right (ret_comp);
297
        break;
298
      case DEMANGLE_COMPONENT_TYPED_NAME:
299
        ret_comp = d_left (ret_comp);
300
        break;
301
      case DEMANGLE_COMPONENT_TEMPLATE:
302
        gdb_assert (last_template == NULL);
303
        last_template = ret_comp;
304
        ret_comp = d_left (ret_comp);
305
        break;
306
      case DEMANGLE_COMPONENT_CONST:
307
      case DEMANGLE_COMPONENT_RESTRICT:
308
      case DEMANGLE_COMPONENT_VOLATILE:
309
      case DEMANGLE_COMPONENT_CONST_THIS:
310
      case DEMANGLE_COMPONENT_RESTRICT_THIS:
311
      case DEMANGLE_COMPONENT_VOLATILE_THIS:
312
      case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
313
        ret_comp = d_left (ret_comp);
314
        break;
315
      case DEMANGLE_COMPONENT_NAME:
316
      case DEMANGLE_COMPONENT_CTOR:
317
      case DEMANGLE_COMPONENT_DTOR:
318
      case DEMANGLE_COMPONENT_OPERATOR:
319
      case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
320
        done = 1;
321
        break;
322
      default:
323
        return NULL;
324
        break;
325
      }
326
 
327
  if (last_template)
328
    {
329
      d_left (last_template) = ret_comp;
330
      return last_template;
331
    }
332
 
333
  return ret_comp;
334
}
335
 
336
/* Return the name of the method whose linkage name is PHYSNAME.  */
337
 
338
char *
339
method_name_from_physname (const char *physname)
340
{
341
  void *storage = NULL;
342
  char *demangled_name = NULL, *ret;
343
  struct demangle_component *ret_comp;
344
 
345
  ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
346
                                   &demangled_name);
347
  if (ret_comp == NULL)
348
    return NULL;
349
 
350
  ret_comp = unqualified_name_from_comp (ret_comp);
351
 
352
  ret = NULL;
353
  if (ret_comp != NULL)
354
    /* The ten is completely arbitrary; we don't have a good estimate.  */
355
    ret = cp_comp_to_string (ret_comp, 10);
356
 
357
  xfree (storage);
358
  if (demangled_name)
359
    xfree (demangled_name);
360
  return ret;
361
}
362
 
363
/* If FULL_NAME is the demangled name of a C++ function (including an
364
   arg list, possibly including namespace/class qualifications),
365
   return a new string containing only the function name (without the
366
   arg list/class qualifications).  Otherwise, return NULL.  The
367
   caller is responsible for freeing the memory in question.  */
368
 
369
char *
370
cp_func_name (const char *full_name)
371
{
372
  char *ret;
373
  struct demangle_component *ret_comp;
374
 
375
  ret_comp = cp_demangled_name_to_comp (full_name, NULL);
376
  if (!ret_comp)
377
    return NULL;
378
 
379
  ret_comp = unqualified_name_from_comp (ret_comp);
380
 
381
  ret = NULL;
382
  if (ret_comp != NULL)
383
    ret = cp_comp_to_string (ret_comp, 10);
384
 
385
  return ret;
386
}
387
 
388
/* DEMANGLED_NAME is the name of a function, including parameters and
389
   (optionally) a return type.  Return the name of the function without
390
   parameters or return type, or NULL if we can not parse the name.  */
391
 
392
char *
393
cp_remove_params (const char *demangled_name)
394
{
395
  int done = 0;
396
  struct demangle_component *ret_comp;
397
  char *ret = NULL;
398
 
399
  if (demangled_name == NULL)
400
    return NULL;
401
 
402
  ret_comp = cp_demangled_name_to_comp (demangled_name, NULL);
403
  if (ret_comp == NULL)
404
    return NULL;
405
 
406
  /* First strip off any qualifiers, if we have a function or method.  */
407
  while (!done)
408
    switch (ret_comp->type)
409
      {
410
      case DEMANGLE_COMPONENT_CONST:
411
      case DEMANGLE_COMPONENT_RESTRICT:
412
      case DEMANGLE_COMPONENT_VOLATILE:
413
      case DEMANGLE_COMPONENT_CONST_THIS:
414
      case DEMANGLE_COMPONENT_RESTRICT_THIS:
415
      case DEMANGLE_COMPONENT_VOLATILE_THIS:
416
      case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
417
        ret_comp = d_left (ret_comp);
418
        break;
419
      default:
420
        done = 1;
421
        break;
422
      }
423
 
424
  /* What we have now should be a function.  Return its name.  */
425
  if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
426
    ret = cp_comp_to_string (d_left (ret_comp), 10);
427
 
428
  return ret;
429
}
430
 
431
/* Here are some random pieces of trivia to keep in mind while trying
432
   to take apart demangled names:
433
 
434
   - Names can contain function arguments or templates, so the process
435
     has to be, to some extent recursive: maybe keep track of your
436
     depth based on encountering <> and ().
437
 
438
   - Parentheses don't just have to happen at the end of a name: they
439
     can occur even if the name in question isn't a function, because
440
     a template argument might be a type that's a function.
441
 
442
   - Conversely, even if you're trying to deal with a function, its
443
     demangled name might not end with ')': it could be a const or
444
     volatile class method, in which case it ends with "const" or
445
     "volatile".
446
 
447
   - Parentheses are also used in anonymous namespaces: a variable
448
     'foo' in an anonymous namespace gets demangled as "(anonymous
449
     namespace)::foo".
450
 
451
   - And operator names can contain parentheses or angle brackets.  */
452
 
453
/* FIXME: carlton/2003-03-13: We have several functions here with
454
   overlapping functionality; can we combine them?  Also, do they
455
   handle all the above considerations correctly?  */
456
 
457
 
458
/* This returns the length of first component of NAME, which should be
459
   the demangled name of a C++ variable/function/method/etc.
460
   Specifically, it returns the index of the first colon forming the
461
   boundary of the first component: so, given 'A::foo' or 'A::B::foo'
462
   it returns the 1, and given 'foo', it returns 0.  */
463
 
464
/* The character in NAME indexed by the return value is guaranteed to
465
   always be either ':' or '\0'.  */
466
 
467
/* NOTE: carlton/2003-03-13: This function is currently only intended
468
   for internal use: it's probably not entirely safe when called on
469
   user-generated input, because some of the 'index += 2' lines in
470
   cp_find_first_component_aux might go past the end of malformed
471
   input.  */
472
 
473
unsigned int
474
cp_find_first_component (const char *name)
475
{
476
  return cp_find_first_component_aux (name, 0);
477
}
478
 
479
/* Helper function for cp_find_first_component.  Like that function,
480
   it returns the length of the first component of NAME, but to make
481
   the recursion easier, it also stops if it reaches an unexpected ')'
482
   or '>' if the value of PERMISSIVE is nonzero.  */
483
 
484
/* Let's optimize away calls to strlen("operator").  */
485
 
486
#define LENGTH_OF_OPERATOR 8
487
 
488
static unsigned int
489
cp_find_first_component_aux (const char *name, int permissive)
490
{
491
  unsigned int index = 0;
492
  /* Operator names can show up in unexpected places.  Since these can
493
     contain parentheses or angle brackets, they can screw up the
494
     recursion.  But not every string 'operator' is part of an
495
     operater name: e.g. you could have a variable 'cooperator'.  So
496
     this variable tells us whether or not we should treat the string
497
     'operator' as starting an operator.  */
498
  int operator_possible = 1;
499
 
500
  for (;; ++index)
501
    {
502
      switch (name[index])
503
        {
504
        case '<':
505
          /* Template; eat it up.  The calls to cp_first_component
506
             should only return (I hope!) when they reach the '>'
507
             terminating the component or a '::' between two
508
             components.  (Hence the '+ 2'.)  */
509
          index += 1;
510
          for (index += cp_find_first_component_aux (name + index, 1);
511
               name[index] != '>';
512
               index += cp_find_first_component_aux (name + index, 1))
513
            {
514
              if (name[index] != ':')
515
                {
516
                  demangled_name_complaint (name);
517
                  return strlen (name);
518
                }
519
              index += 2;
520
            }
521
          operator_possible = 1;
522
          break;
523
        case '(':
524
          /* Similar comment as to '<'.  */
525
          index += 1;
526
          for (index += cp_find_first_component_aux (name + index, 1);
527
               name[index] != ')';
528
               index += cp_find_first_component_aux (name + index, 1))
529
            {
530
              if (name[index] != ':')
531
                {
532
                  demangled_name_complaint (name);
533
                  return strlen (name);
534
                }
535
              index += 2;
536
            }
537
          operator_possible = 1;
538
          break;
539
        case '>':
540
        case ')':
541
          if (permissive)
542
            return index;
543
          else
544
            {
545
              demangled_name_complaint (name);
546
              return strlen (name);
547
            }
548
        case '\0':
549
        case ':':
550
          return index;
551
        case 'o':
552
          /* Operator names can screw up the recursion.  */
553
          if (operator_possible
554
              && strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
555
            {
556
              index += LENGTH_OF_OPERATOR;
557
              while (ISSPACE(name[index]))
558
                ++index;
559
              switch (name[index])
560
                {
561
                  /* Skip over one less than the appropriate number of
562
                     characters: the for loop will skip over the last
563
                     one.  */
564
                case '<':
565
                  if (name[index + 1] == '<')
566
                    index += 1;
567
                  else
568
                    index += 0;
569
                  break;
570
                case '>':
571
                case '-':
572
                  if (name[index + 1] == '>')
573
                    index += 1;
574
                  else
575
                    index += 0;
576
                  break;
577
                case '(':
578
                  index += 1;
579
                  break;
580
                default:
581
                  index += 0;
582
                  break;
583
                }
584
            }
585
          operator_possible = 0;
586
          break;
587
        case ' ':
588
        case ',':
589
        case '.':
590
        case '&':
591
        case '*':
592
          /* NOTE: carlton/2003-04-18: I'm not sure what the precise
593
             set of relevant characters are here: it's necessary to
594
             include any character that can show up before 'operator'
595
             in a demangled name, and it's safe to include any
596
             character that can't be part of an identifier's name.  */
597
          operator_possible = 1;
598
          break;
599
        default:
600
          operator_possible = 0;
601
          break;
602
        }
603
    }
604
}
605
 
606
/* Complain about a demangled name that we don't know how to parse.
607
   NAME is the demangled name in question.  */
608
 
609
static void
610
demangled_name_complaint (const char *name)
611
{
612
  complaint (&symfile_complaints,
613
             "unexpected demangled name '%s'", name);
614
}
615
 
616
/* If NAME is the fully-qualified name of a C++
617
   function/variable/method/etc., this returns the length of its
618
   entire prefix: all of the namespaces and classes that make up its
619
   name.  Given 'A::foo', it returns 1, given 'A::B::foo', it returns
620
   4, given 'foo', it returns 0.  */
621
 
622
unsigned int
623
cp_entire_prefix_len (const char *name)
624
{
625
  unsigned int current_len = cp_find_first_component (name);
626
  unsigned int previous_len = 0;
627
 
628
  while (name[current_len] != '\0')
629
    {
630
      gdb_assert (name[current_len] == ':');
631
      previous_len = current_len;
632
      /* Skip the '::'.  */
633
      current_len += 2;
634
      current_len += cp_find_first_component (name + current_len);
635
    }
636
 
637
  return previous_len;
638
}
639
 
640
/* Overload resolution functions.  */
641
 
642
/* Test to see if SYM is a symbol that we haven't seen corresponding
643
   to a function named OLOAD_NAME.  If so, add it to the current
644
   completion list. */
645
 
646
static void
647
overload_list_add_symbol (struct symbol *sym, const char *oload_name)
648
{
649
  int newsize;
650
  int i;
651
  char *sym_name;
652
 
653
  /* If there is no type information, we can't do anything, so skip */
654
  if (SYMBOL_TYPE (sym) == NULL)
655
    return;
656
 
657
  /* skip any symbols that we've already considered. */
658
  for (i = 0; i < sym_return_val_index; ++i)
659
    if (strcmp (SYMBOL_LINKAGE_NAME (sym),
660
                SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
661
      return;
662
 
663
  /* Get the demangled name without parameters */
664
  sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
665
  if (!sym_name)
666
    return;
667
 
668
  /* skip symbols that cannot match */
669
  if (strcmp (sym_name, oload_name) != 0)
670
    {
671
      xfree (sym_name);
672
      return;
673
    }
674
 
675
  xfree (sym_name);
676
 
677
  /* We have a match for an overload instance, so add SYM to the current list
678
   * of overload instances */
679
  if (sym_return_val_index + 3 > sym_return_val_size)
680
    {
681
      newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
682
      sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize);
683
    }
684
  sym_return_val[sym_return_val_index++] = sym;
685
  sym_return_val[sym_return_val_index] = NULL;
686
}
687
 
688
/* Return a null-terminated list of pointers to function symbols that
689
   are named FUNC_NAME and are visible within NAMESPACE.  */
690
 
691
struct symbol **
692
make_symbol_overload_list (const char *func_name,
693
                           const char *namespace)
694
{
695
  struct cleanup *old_cleanups;
696
  const char *name;
697
 
698
  sym_return_val_size = 100;
699
  sym_return_val_index = 0;
700
  sym_return_val = xmalloc ((sym_return_val_size + 1) *
701
                            sizeof (struct symbol *));
702
  sym_return_val[0] = NULL;
703
 
704
  old_cleanups = make_cleanup (xfree, sym_return_val);
705
 
706
  make_symbol_overload_list_using (func_name, namespace);
707
 
708
  if (namespace[0] == '\0')
709
    name = func_name;
710
  else
711
    {
712
      char *concatenated_name
713
        = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
714
      strcpy (concatenated_name, namespace);
715
      strcat (concatenated_name, "::");
716
      strcat (concatenated_name, func_name);
717
      name = concatenated_name;
718
    }
719
 
720
  make_symbol_overload_list_qualified (name);
721
 
722
  discard_cleanups (old_cleanups);
723
 
724
  return sym_return_val;
725
}
726
 
727
/* Add all symbols with a name matching NAME in BLOCK to the overload
728
   list.  */
729
 
730
static void
731
make_symbol_overload_list_block (const char *name,
732
                                 const struct block *block)
733
{
734
  struct dict_iterator iter;
735
  struct symbol *sym;
736
 
737
  const struct dictionary *dict = BLOCK_DICT (block);
738
 
739
  for (sym = dict_iter_name_first (dict, name, &iter);
740
       sym != NULL;
741
       sym = dict_iter_name_next (name, &iter))
742
    overload_list_add_symbol (sym, name);
743
}
744
 
745
/* Adds the function FUNC_NAME from NAMESPACE to the overload set.  */
746
 
747
static void
748
make_symbol_overload_list_namespace (const char *func_name,
749
                                     const char *namespace)
750
{
751
  const char *name;
752
  const struct block *block = NULL;
753
 
754
  if (namespace[0] == '\0')
755
    name = func_name;
756
  else
757
    {
758
      char *concatenated_name
759
        = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
760
 
761
      strcpy (concatenated_name, namespace);
762
      strcat (concatenated_name, "::");
763
      strcat (concatenated_name, func_name);
764
      name = concatenated_name;
765
    }
766
 
767
  /* Look in the static block.  */
768
  block = block_static_block (get_selected_block (0));
769
  make_symbol_overload_list_block (name, block);
770
 
771
  /* Look in the global block.  */
772
  block = block_global_block (block);
773
  make_symbol_overload_list_block (name, block);
774
 
775
}
776
 
777
/* Search the namespace of the given type and namespace of and public base
778
 types.  */
779
 
780
static void
781
make_symbol_overload_list_adl_namespace (struct type *type,
782
                                         const char *func_name)
783
{
784
  char *namespace;
785
  char *type_name;
786
  int i, prefix_len;
787
 
788
  while (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF
789
         || TYPE_CODE (type) == TYPE_CODE_ARRAY
790
         || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
791
    {
792
      if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
793
        type = check_typedef(type);
794
      else
795
        type = TYPE_TARGET_TYPE (type);
796
    }
797
 
798
  type_name = TYPE_NAME (type);
799
 
800
  if (type_name == NULL)
801
    return;
802
 
803
  prefix_len = cp_entire_prefix_len (type_name);
804
 
805
  if (prefix_len != 0)
806
    {
807
      namespace = alloca (prefix_len + 1);
808
      strncpy (namespace, type_name, prefix_len);
809
      namespace[prefix_len] = '\0';
810
 
811
      make_symbol_overload_list_namespace (func_name, namespace);
812
    }
813
 
814
  /* Check public base type */
815
  if (TYPE_CODE (type) == TYPE_CODE_CLASS)
816
    for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
817
      {
818
        if (BASETYPE_VIA_PUBLIC (type, i))
819
          make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type, i),
820
                                                   func_name);
821
      }
822
}
823
 
824
/* Adds the the overload list overload candidates for FUNC_NAME found through
825
   argument dependent lookup.  */
826
 
827
struct symbol **
828
make_symbol_overload_list_adl (struct type **arg_types, int nargs,
829
                               const char *func_name)
830
{
831
  int i;
832
 
833
  gdb_assert (sym_return_val_size != -1);
834
 
835
  for (i = 1; i <= nargs; i++)
836
    make_symbol_overload_list_adl_namespace (arg_types[i - 1], func_name);
837
 
838
  return sym_return_val;
839
}
840
 
841
/* Used for cleanups to reset the "searched" flag in case of an error.  */
842
 
843
static void
844
reset_directive_searched (void *data)
845
{
846
  struct using_direct *direct = data;
847
  direct->searched = 0;
848
}
849
 
850
/* This applies the using directives to add namespaces to search in,
851
   and then searches for overloads in all of those namespaces.  It
852
   adds the symbols found to sym_return_val.  Arguments are as in
853
   make_symbol_overload_list.  */
854
 
855
static void
856
make_symbol_overload_list_using (const char *func_name,
857
                                 const char *namespace)
858
{
859
  struct using_direct *current;
860
  const struct block *block;
861
 
862
  /* First, go through the using directives.  If any of them apply,
863
     look in the appropriate namespaces for new functions to match
864
     on.  */
865
 
866
  for (block = get_selected_block (0);
867
       block != NULL;
868
       block = BLOCK_SUPERBLOCK (block))
869
    for (current = block_using (block);
870
        current != NULL;
871
        current = current->next)
872
      {
873
        /* Prevent recursive calls.  */
874
        if (current->searched)
875
          continue;
876
 
877
        /* If this is a namespace alias or imported declaration ignore it.  */
878
        if (current->alias != NULL || current->declaration != NULL)
879
          continue;
880
 
881
        if (strcmp (namespace, current->import_dest) == 0)
882
          {
883
            /* Mark this import as searched so that the recursive call does
884
               not search it again.  */
885
            struct cleanup *old_chain;
886
            current->searched = 1;
887
            old_chain = make_cleanup (reset_directive_searched, current);
888
 
889
            make_symbol_overload_list_using (func_name, current->import_src);
890
 
891
            current->searched = 0;
892
            discard_cleanups (old_chain);
893
          }
894
      }
895
 
896
  /* Now, add names for this namespace.  */
897
  make_symbol_overload_list_namespace (func_name, namespace);
898
}
899
 
900
/* This does the bulk of the work of finding overloaded symbols.
901
   FUNC_NAME is the name of the overloaded function we're looking for
902
   (possibly including namespace info).  */
903
 
904
static void
905
make_symbol_overload_list_qualified (const char *func_name)
906
{
907
  struct symbol *sym;
908
  struct symtab *s;
909
  struct objfile *objfile;
910
  const struct block *b, *surrounding_static_block = 0;
911
  struct dict_iterator iter;
912
  const struct dictionary *dict;
913
 
914
  /* Look through the partial symtabs for all symbols which begin
915
     by matching FUNC_NAME.  Make sure we read that symbol table in. */
916
 
917
  ALL_OBJFILES (objfile)
918
  {
919
    if (objfile->sf)
920
      objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
921
  }
922
 
923
  /* Search upwards from currently selected frame (so that we can
924
     complete on local vars.  */
925
 
926
  for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
927
    make_symbol_overload_list_block (func_name, b);
928
 
929
  surrounding_static_block = block_static_block (get_selected_block (0));
930
 
931
  /* Go through the symtabs and check the externs and statics for
932
     symbols which match.  */
933
 
934
  ALL_PRIMARY_SYMTABS (objfile, s)
935
  {
936
    QUIT;
937
    b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
938
    make_symbol_overload_list_block (func_name, b);
939
  }
940
 
941
  ALL_PRIMARY_SYMTABS (objfile, s)
942
  {
943
    QUIT;
944
    b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
945
    /* Don't do this block twice.  */
946
    if (b == surrounding_static_block)
947
      continue;
948
    make_symbol_overload_list_block (func_name, b);
949
  }
950
}
951
 
952
/* Lookup the rtti type for a class name. */
953
 
954
struct type *
955
cp_lookup_rtti_type (const char *name, struct block *block)
956
{
957
  struct symbol * rtti_sym;
958
  struct type * rtti_type;
959
 
960
  rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
961
 
962
  if (rtti_sym == NULL)
963
    {
964
      warning (_("RTTI symbol not found for class '%s'"), name);
965
      return NULL;
966
    }
967
 
968
  if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
969
    {
970
      warning (_("RTTI symbol for class '%s' is not a type"), name);
971
      return NULL;
972
    }
973
 
974
  rtti_type = SYMBOL_TYPE (rtti_sym);
975
 
976
  switch (TYPE_CODE (rtti_type))
977
    {
978
    case TYPE_CODE_CLASS:
979
      break;
980
    case TYPE_CODE_NAMESPACE:
981
      /* chastain/2003-11-26: the symbol tables often contain fake
982
         symbols for namespaces with the same name as the struct.
983
         This warning is an indication of a bug in the lookup order
984
         or a bug in the way that the symbol tables are populated.  */
985
      warning (_("RTTI symbol for class '%s' is a namespace"), name);
986
      return NULL;
987
    default:
988
      warning (_("RTTI symbol for class '%s' has bad type"), name);
989
      return NULL;
990
    }
991
 
992
  return rtti_type;
993
}
994
 
995
/* Don't allow just "maintenance cplus".  */
996
 
997
static  void
998
maint_cplus_command (char *arg, int from_tty)
999
{
1000
  printf_unfiltered (_("\"maintenance cplus\" must be followed by the name of a command.\n"));
1001
  help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
1002
}
1003
 
1004
/* This is a front end for cp_find_first_component, for unit testing.
1005
   Be careful when using it: see the NOTE above
1006
   cp_find_first_component.  */
1007
 
1008
static void
1009
first_component_command (char *arg, int from_tty)
1010
{
1011
  int len;
1012
  char *prefix;
1013
 
1014
  if (!arg)
1015
    return;
1016
 
1017
  len = cp_find_first_component (arg);
1018
  prefix = alloca (len + 1);
1019
 
1020
  memcpy (prefix, arg, len);
1021
  prefix[len] = '\0';
1022
 
1023
  printf_unfiltered ("%s\n", prefix);
1024
}
1025
 
1026
extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
1027
 
1028
#define SKIP_SPACE(P)                           \
1029
  do                                            \
1030
  {                                             \
1031
    while (*(P) == ' ' || *(P) == '\t')         \
1032
      ++(P);                                    \
1033
  }                                             \
1034
  while (0)
1035
 
1036
/* Returns the length of the operator name or 0 if INPUT does not
1037
   point to a valid C++ operator.  INPUT should start with "operator".  */
1038
int
1039
cp_validate_operator (const char *input)
1040
{
1041
  int i;
1042
  char *copy;
1043
  const char *p;
1044
  struct expression *expr;
1045
  struct value *val;
1046
  struct gdb_exception except;
1047
 
1048
  p = input;
1049
 
1050
  if (strncmp (p, "operator", 8) == 0)
1051
    {
1052
      int valid = 0;
1053
 
1054
      p += 8;
1055
      SKIP_SPACE (p);
1056
      for (i = 0; i < sizeof (operator_tokens) / sizeof (operator_tokens[0]);
1057
           ++i)
1058
        {
1059
          int length = strlen (operator_tokens[i]);
1060
 
1061
          /* By using strncmp here, we MUST have operator_tokens ordered!
1062
             See additional notes where operator_tokens is defined above.  */
1063
          if (strncmp (p, operator_tokens[i], length) == 0)
1064
            {
1065
              const char *op = p;
1066
 
1067
              valid = 1;
1068
              p += length;
1069
 
1070
              if (strncmp (op, "new", 3) == 0
1071
                  || strncmp (op, "delete", 6) == 0)
1072
                {
1073
 
1074
                  /* Special case: new[] and delete[].  We must be careful
1075
                     to swallow whitespace before/in "[]".  */
1076
                  SKIP_SPACE (p);
1077
 
1078
                  if (*p == '[')
1079
                    {
1080
                      ++p;
1081
                      SKIP_SPACE (p);
1082
                      if (*p == ']')
1083
                        ++p;
1084
                      else
1085
                        valid = 0;
1086
                    }
1087
                }
1088
 
1089
              if (valid)
1090
                return (p - input);
1091
            }
1092
        }
1093
 
1094
      /* Check input for a conversion operator.  */
1095
 
1096
      /* Skip past base typename */
1097
      while (*p != '*' && *p != '&' && *p != 0 && *p != ' ')
1098
        ++p;
1099
      SKIP_SPACE (p);
1100
 
1101
      /* Add modifiers '*'/'&' */
1102
      while (*p == '*' || *p == '&')
1103
        {
1104
          ++p;
1105
          SKIP_SPACE (p);
1106
        }
1107
 
1108
      /* Check for valid type.  [Remember: input starts with
1109
         "operator".]  */
1110
      copy = savestring (input + 8, p - input - 8);
1111
      expr = NULL;
1112
      val = NULL;
1113
      TRY_CATCH (except, RETURN_MASK_ALL)
1114
        {
1115
          expr = parse_expression (copy);
1116
          val = evaluate_type (expr);
1117
        }
1118
 
1119
      xfree (copy);
1120
      if (expr)
1121
        xfree (expr);
1122
 
1123
      if (val != NULL && value_type (val) != NULL)
1124
        return (p - input);
1125
    }
1126
 
1127
  return 0;
1128
}
1129
 
1130
void
1131
_initialize_cp_support (void)
1132
{
1133
  add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
1134
                  _("C++ maintenance commands."), &maint_cplus_cmd_list,
1135
                  "maintenance cplus ", 0, &maintenancelist);
1136
  add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);
1137
 
1138
  add_cmd ("first_component", class_maintenance, first_component_command,
1139
           _("Print the first class/namespace component of NAME."),
1140
           &maint_cplus_cmd_list);
1141
}

powered by: WebSVN 2.1.0

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