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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [cp/] [lex.c] - Blame information for rev 826

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 283 jeremybenn
/* Separate lexical analyzer for GNU C++.
2
   Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
4
   Free Software Foundation, Inc.
5
   Hacked by Michael Tiemann (tiemann@cygnus.com)
6
 
7
This file is part of GCC.
8
 
9
GCC 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, or (at your option)
12
any later version.
13
 
14
GCC 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 GCC; see the file COPYING3.  If not see
21
<http://www.gnu.org/licenses/>.  */
22
 
23
 
24
/* This file is the lexical analyzer for GNU C++.  */
25
 
26
#include "config.h"
27
#include "system.h"
28
#include "coretypes.h"
29
#include "tm.h"
30
#include "input.h"
31
#include "tree.h"
32
#include "cp-tree.h"
33
#include "cpplib.h"
34
#include "flags.h"
35
#include "c-pragma.h"
36
#include "toplev.h"
37
#include "output.h"
38
#include "tm_p.h"
39
#include "timevar.h"
40
 
41
static int interface_strcmp (const char *);
42
static void init_cp_pragma (void);
43
 
44
static tree parse_strconst_pragma (const char *, int);
45
static void handle_pragma_vtable (cpp_reader *);
46
static void handle_pragma_unit (cpp_reader *);
47
static void handle_pragma_interface (cpp_reader *);
48
static void handle_pragma_implementation (cpp_reader *);
49
static void handle_pragma_java_exceptions (cpp_reader *);
50
 
51
static void init_operators (void);
52
static void copy_lang_type (tree);
53
 
54
/* A constraint that can be tested at compile time.  */
55
#define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
56
 
57
/* Functions and data structures for #pragma interface.
58
 
59
   `#pragma implementation' means that the main file being compiled
60
   is considered to implement (provide) the classes that appear in
61
   its main body.  I.e., if this is file "foo.cc", and class `bar'
62
   is defined in "foo.cc", then we say that "foo.cc implements bar".
63
 
64
   All main input files "implement" themselves automagically.
65
 
66
   `#pragma interface' means that unless this file (of the form "foo.h"
67
   is not presently being included by file "foo.cc", the
68
   CLASSTYPE_INTERFACE_ONLY bit gets set.  The effect is that none
69
   of the vtables nor any of the inline functions defined in foo.h
70
   will ever be output.
71
 
72
   There are cases when we want to link files such as "defs.h" and
73
   "main.cc".  In this case, we give "defs.h" a `#pragma interface',
74
   and "main.cc" has `#pragma implementation "defs.h"'.  */
75
 
76
struct impl_files
77
{
78
  const char *filename;
79
  struct impl_files *next;
80
};
81
 
82
static struct impl_files *impl_file_chain;
83
 
84
/* True if we saw "#pragma GCC java_exceptions".  */
85
bool pragma_java_exceptions;
86
 
87
void
88
cxx_finish (void)
89
{
90
  c_common_finish ();
91
}
92
 
93
/* A mapping from tree codes to operator name information.  */
94
operator_name_info_t operator_name_info[(int) MAX_TREE_CODES];
95
/* Similar, but for assignment operators.  */
96
operator_name_info_t assignment_operator_name_info[(int) MAX_TREE_CODES];
97
 
98
/* Initialize data structures that keep track of operator names.  */
99
 
100
#define DEF_OPERATOR(NAME, C, M, AR, AP) \
101
 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
102
#include "operators.def"
103
#undef DEF_OPERATOR
104
 
105
static void
106
init_operators (void)
107
{
108
  tree identifier;
109
  char buffer[256];
110
  struct operator_name_info_t *oni;
111
 
112
#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)                   \
113
  sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
114
  identifier = get_identifier (buffer);                                     \
115
  IDENTIFIER_OPNAME_P (identifier) = 1;                                     \
116
                                                                            \
117
  oni = (ASSN_P                                                             \
118
         ? &assignment_operator_name_info[(int) CODE]                       \
119
         : &operator_name_info[(int) CODE]);                                \
120
  oni->identifier = identifier;                                             \
121
  oni->name = NAME;                                                         \
122
  oni->mangled_name = MANGLING;                                             \
123
  oni->arity = ARITY;
124
 
125
#include "operators.def"
126
#undef DEF_OPERATOR
127
 
128
  operator_name_info[(int) ERROR_MARK].identifier
129
    = get_identifier ("<invalid operator>");
130
 
131
  /* Handle some special cases.  These operators are not defined in
132
     the language, but can be produced internally.  We may need them
133
     for error-reporting.  (Eventually, we should ensure that this
134
     does not happen.  Error messages involving these operators will
135
     be confusing to users.)  */
136
 
137
  operator_name_info [(int) INIT_EXPR].name
138
    = operator_name_info [(int) MODIFY_EXPR].name;
139
  operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
140
  operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
141
  operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
142
  operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
143
  operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
144
  operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
145
  operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
146
  operator_name_info [(int) ABS_EXPR].name = "abs";
147
  operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
148
  operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
149
  operator_name_info [(int) RANGE_EXPR].name = "...";
150
  operator_name_info [(int) UNARY_PLUS_EXPR].name = "+";
151
 
152
  assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
153
    = "(exact /=)";
154
  assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
155
    = "(ceiling /=)";
156
  assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
157
    = "(floor /=)";
158
  assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
159
    = "(round /=)";
160
  assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
161
    = "(ceiling %=)";
162
  assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
163
    = "(floor %=)";
164
  assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
165
    = "(round %=)";
166
}
167
 
168
/* Initialize the reserved words.  */
169
 
170
void
171
init_reswords (void)
172
{
173
  unsigned int i;
174
  tree id;
175
  int mask = 0;
176
 
177
  if (cxx_dialect != cxx0x)
178
    mask |= D_CXX0X;
179
  if (flag_no_asm)
180
    mask |= D_ASM | D_EXT;
181
  if (flag_no_gnu_keywords)
182
    mask |= D_EXT;
183
 
184
  /* The Objective-C keywords are all context-dependent.  */
185
  mask |= D_OBJC;
186
 
187
  ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
188
  for (i = 0; i < num_c_common_reswords; i++)
189
    {
190
      if (c_common_reswords[i].disable & D_CONLY)
191
        continue;
192
      id = get_identifier (c_common_reswords[i].word);
193
      C_SET_RID_CODE (id, c_common_reswords[i].rid);
194
      ridpointers [(int) c_common_reswords[i].rid] = id;
195
      if (! (c_common_reswords[i].disable & mask))
196
        C_IS_RESERVED_WORD (id) = 1;
197
    }
198
}
199
 
200
static void
201
init_cp_pragma (void)
202
{
203
  c_register_pragma (0, "vtable", handle_pragma_vtable);
204
  c_register_pragma (0, "unit", handle_pragma_unit);
205
  c_register_pragma (0, "interface", handle_pragma_interface);
206
  c_register_pragma (0, "implementation", handle_pragma_implementation);
207
  c_register_pragma ("GCC", "interface", handle_pragma_interface);
208
  c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
209
  c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
210
}
211
 
212
/* TRUE if a code represents a statement.  */
213
 
214
bool statement_code_p[MAX_TREE_CODES];
215
 
216
/* Initialize the C++ front end.  This function is very sensitive to
217
   the exact order that things are done here.  It would be nice if the
218
   initialization done by this routine were moved to its subroutines,
219
   and the ordering dependencies clarified and reduced.  */
220
bool
221
cxx_init (void)
222
{
223
  location_t saved_loc;
224
  unsigned int i;
225
  static const enum tree_code stmt_codes[] = {
226
   CTOR_INITIALIZER,    TRY_BLOCK,      HANDLER,
227
   EH_SPEC_BLOCK,       USING_STMT,     TAG_DEFN,
228
   IF_STMT,             CLEANUP_STMT,   FOR_STMT,
229
   WHILE_STMT,          DO_STMT,        BREAK_STMT,
230
   CONTINUE_STMT,       SWITCH_STMT,    EXPR_STMT
231
  };
232
 
233
  memset (&statement_code_p, 0, sizeof (statement_code_p));
234
  for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
235
    statement_code_p[stmt_codes[i]] = true;
236
 
237
  saved_loc = input_location;
238
  input_location = BUILTINS_LOCATION;
239
 
240
  init_reswords ();
241
  init_tree ();
242
  init_cp_semantics ();
243
  init_operators ();
244
  init_method ();
245
  init_error ();
246
 
247
  current_function_decl = NULL;
248
 
249
  class_type_node = ridpointers[(int) RID_CLASS];
250
 
251
  cxx_init_decl_processing ();
252
 
253
  if (c_common_init () == false)
254
    {
255
      input_location = saved_loc;
256
      return false;
257
    }
258
 
259
  init_cp_pragma ();
260
 
261
  init_repo ();
262
 
263
  input_location = saved_loc;
264
  return true;
265
}
266
 
267
/* Return nonzero if S is not considered part of an
268
   INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
269
 
270
static int
271
interface_strcmp (const char* s)
272
{
273
  /* Set the interface/implementation bits for this scope.  */
274
  struct impl_files *ifiles;
275
  const char *s1;
276
 
277
  for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
278
    {
279
      const char *t1 = ifiles->filename;
280
      s1 = s;
281
 
282
      if (*s1 != *t1 || *s1 == 0)
283
        continue;
284
 
285
      while (*s1 == *t1 && *s1 != 0)
286
        s1++, t1++;
287
 
288
      /* A match.  */
289
      if (*s1 == *t1)
290
        return 0;
291
 
292
      /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
293
      if (strchr (s1, '.') || strchr (t1, '.'))
294
        continue;
295
 
296
      if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
297
        continue;
298
 
299
      /* A match.  */
300
      return 0;
301
    }
302
 
303
  /* No matches.  */
304
  return 1;
305
}
306
 
307
 
308
 
309
/* Parse a #pragma whose sole argument is a string constant.
310
   If OPT is true, the argument is optional.  */
311
static tree
312
parse_strconst_pragma (const char* name, int opt)
313
{
314
  tree result, x;
315
  enum cpp_ttype t;
316
 
317
  t = pragma_lex (&result);
318
  if (t == CPP_STRING)
319
    {
320
      if (pragma_lex (&x) != CPP_EOF)
321
        warning (0, "junk at end of #pragma %s", name);
322
      return result;
323
    }
324
 
325
  if (t == CPP_EOF && opt)
326
    return NULL_TREE;
327
 
328
  error ("invalid #pragma %s", name);
329
  return error_mark_node;
330
}
331
 
332
static void
333
handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
334
{
335
  parse_strconst_pragma ("vtable", 0);
336
  sorry ("#pragma vtable no longer supported");
337
}
338
 
339
static void
340
handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
341
{
342
  /* Validate syntax, but don't do anything.  */
343
  parse_strconst_pragma ("unit", 0);
344
}
345
 
346
static void
347
handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
348
{
349
  tree fname = parse_strconst_pragma ("interface", 1);
350
  struct c_fileinfo *finfo;
351
  const char *filename;
352
 
353
  if (fname == error_mark_node)
354
    return;
355
  else if (fname == 0)
356
    filename = lbasename (input_filename);
357
  else
358
    filename = TREE_STRING_POINTER (fname);
359
 
360
  finfo = get_fileinfo (input_filename);
361
 
362
  if (impl_file_chain == 0)
363
    {
364
      /* If this is zero at this point, then we are
365
         auto-implementing.  */
366
      if (main_input_filename == 0)
367
        main_input_filename = input_filename;
368
    }
369
 
370
  finfo->interface_only = interface_strcmp (filename);
371
  /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
372
     a definition in another file.  */
373
  if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
374
    finfo->interface_unknown = 0;
375
}
376
 
377
/* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
378
   We used to only allow this at toplevel, but that restriction was buggy
379
   in older compilers and it seems reasonable to allow it in the headers
380
   themselves, too.  It only needs to precede the matching #p interface.
381
 
382
   We don't touch finfo->interface_only or finfo->interface_unknown;
383
   the user must specify a matching #p interface for this to have
384
   any effect.  */
385
 
386
static void
387
handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
388
{
389
  tree fname = parse_strconst_pragma ("implementation", 1);
390
  const char *filename;
391
  struct impl_files *ifiles = impl_file_chain;
392
 
393
  if (fname == error_mark_node)
394
    return;
395
 
396
  if (fname == 0)
397
    {
398
      if (main_input_filename)
399
        filename = main_input_filename;
400
      else
401
        filename = input_filename;
402
      filename = lbasename (filename);
403
    }
404
  else
405
    {
406
      filename = TREE_STRING_POINTER (fname);
407
      if (cpp_included_before (parse_in, filename, input_location))
408
        warning (0, "#pragma implementation for %qs appears after "
409
                 "file is included", filename);
410
    }
411
 
412
  for (; ifiles; ifiles = ifiles->next)
413
    {
414
      if (! strcmp (ifiles->filename, filename))
415
        break;
416
    }
417
  if (ifiles == 0)
418
    {
419
      ifiles = XNEW (struct impl_files);
420
      ifiles->filename = xstrdup (filename);
421
      ifiles->next = impl_file_chain;
422
      impl_file_chain = ifiles;
423
    }
424
}
425
 
426
/* Indicate that this file uses Java-personality exception handling.  */
427
static void
428
handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
429
{
430
  tree x;
431
  if (pragma_lex (&x) != CPP_EOF)
432
    warning (0, "junk at end of #pragma GCC java_exceptions");
433
 
434
  choose_personality_routine (lang_java);
435
  pragma_java_exceptions = true;
436
}
437
 
438
/* Issue an error message indicating that the lookup of NAME (an
439
   IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
440
 
441
tree
442
unqualified_name_lookup_error (tree name)
443
{
444
  if (IDENTIFIER_OPNAME_P (name))
445
    {
446
      if (name != ansi_opname (ERROR_MARK))
447
        error ("%qD not defined", name);
448
    }
449
  else
450
    {
451
      error ("%qD was not declared in this scope", name);
452
      /* Prevent repeated error messages by creating a VAR_DECL with
453
         this NAME in the innermost block scope.  */
454
      if (current_function_decl)
455
        {
456
          tree decl;
457
          decl = build_decl (input_location,
458
                             VAR_DECL, name, error_mark_node);
459
          DECL_CONTEXT (decl) = current_function_decl;
460
          push_local_binding (name, decl, 0);
461
          /* Mark the variable as used so that we do not get warnings
462
             about it being unused later.  */
463
          TREE_USED (decl) = 1;
464
        }
465
    }
466
 
467
  return error_mark_node;
468
}
469
 
470
/* Like unqualified_name_lookup_error, but NAME is an unqualified-id
471
   used as a function.  Returns an appropriate expression for
472
   NAME.  */
473
 
474
tree
475
unqualified_fn_lookup_error (tree name)
476
{
477
  if (processing_template_decl)
478
    {
479
      /* In a template, it is invalid to write "f()" or "f(3)" if no
480
         declaration of "f" is available.  Historically, G++ and most
481
         other compilers accepted that usage since they deferred all name
482
         lookup until instantiation time rather than doing unqualified
483
         name lookup at template definition time; explain to the user what
484
         is going wrong.
485
 
486
         Note that we have the exact wording of the following message in
487
         the manual (trouble.texi, node "Name lookup"), so they need to
488
         be kept in synch.  */
489
      permerror (input_location, "there are no arguments to %qD that depend on a template "
490
                 "parameter, so a declaration of %qD must be available",
491
                 name, name);
492
 
493
      if (!flag_permissive)
494
        {
495
          static bool hint;
496
          if (!hint)
497
            {
498
              inform (input_location, "(if you use %<-fpermissive%>, G++ will accept your "
499
                     "code, but allowing the use of an undeclared name is "
500
                     "deprecated)");
501
              hint = true;
502
            }
503
        }
504
      return name;
505
    }
506
 
507
  return unqualified_name_lookup_error (name);
508
}
509
 
510
tree
511
build_lang_decl (enum tree_code code, tree name, tree type)
512
{
513
  tree t;
514
 
515
  t = build_decl (input_location,
516
                  code, name, type);
517
  retrofit_lang_decl (t);
518
 
519
  return t;
520
}
521
 
522
/* Add DECL_LANG_SPECIFIC info to T.  Called from build_lang_decl
523
   and pushdecl (for functions generated by the back end).  */
524
 
525
void
526
retrofit_lang_decl (tree t)
527
{
528
  struct lang_decl *ld;
529
  size_t size;
530
  int sel;
531
 
532
  if (TREE_CODE (t) == FUNCTION_DECL)
533
    sel = 1, size = sizeof (struct lang_decl_fn);
534
  else if (TREE_CODE (t) == NAMESPACE_DECL)
535
    sel = 2, size = sizeof (struct lang_decl_ns);
536
  else if (TREE_CODE (t) == PARM_DECL)
537
    sel = 3, size = sizeof (struct lang_decl_parm);
538
  else if (LANG_DECL_HAS_MIN (t))
539
    sel = 0, size = sizeof (struct lang_decl_min);
540
  else
541
    gcc_unreachable ();
542
 
543
  ld = GGC_CNEWVAR (struct lang_decl, size);
544
 
545
  ld->u.base.selector = sel;
546
 
547
  DECL_LANG_SPECIFIC (t) = ld;
548
  if (current_lang_name == lang_name_cplusplus
549
      || decl_linkage (t) == lk_none)
550
    SET_DECL_LANGUAGE (t, lang_cplusplus);
551
  else if (current_lang_name == lang_name_c)
552
    SET_DECL_LANGUAGE (t, lang_c);
553
  else if (current_lang_name == lang_name_java)
554
    SET_DECL_LANGUAGE (t, lang_java);
555
  else
556
    gcc_unreachable ();
557
 
558
#ifdef GATHER_STATISTICS
559
  tree_node_counts[(int)lang_decl] += 1;
560
  tree_node_sizes[(int)lang_decl] += size;
561
#endif
562
}
563
 
564
void
565
cxx_dup_lang_specific_decl (tree node)
566
{
567
  int size;
568
  struct lang_decl *ld;
569
 
570
  if (! DECL_LANG_SPECIFIC (node))
571
    return;
572
 
573
  if (TREE_CODE (node) == FUNCTION_DECL)
574
    size = sizeof (struct lang_decl_fn);
575
  else if (TREE_CODE (node) == NAMESPACE_DECL)
576
    size = sizeof (struct lang_decl_ns);
577
  else if (TREE_CODE (node) == PARM_DECL)
578
    size = sizeof (struct lang_decl_parm);
579
  else if (LANG_DECL_HAS_MIN (node))
580
    size = sizeof (struct lang_decl_min);
581
  else
582
    gcc_unreachable ();
583
 
584
  ld = GGC_NEWVAR (struct lang_decl, size);
585
  memcpy (ld, DECL_LANG_SPECIFIC (node), size);
586
  DECL_LANG_SPECIFIC (node) = ld;
587
 
588
#ifdef GATHER_STATISTICS
589
  tree_node_counts[(int)lang_decl] += 1;
590
  tree_node_sizes[(int)lang_decl] += size;
591
#endif
592
}
593
 
594
/* Copy DECL, including any language-specific parts.  */
595
 
596
tree
597
copy_decl (tree decl)
598
{
599
  tree copy;
600
 
601
  copy = copy_node (decl);
602
  cxx_dup_lang_specific_decl (copy);
603
  return copy;
604
}
605
 
606
/* Replace the shared language-specific parts of NODE with a new copy.  */
607
 
608
static void
609
copy_lang_type (tree node)
610
{
611
  int size;
612
  struct lang_type *lt;
613
 
614
  if (! TYPE_LANG_SPECIFIC (node))
615
    return;
616
 
617
  if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
618
    size = sizeof (struct lang_type);
619
  else
620
    size = sizeof (struct lang_type_ptrmem);
621
  lt = GGC_NEWVAR (struct lang_type, size);
622
  memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
623
  TYPE_LANG_SPECIFIC (node) = lt;
624
 
625
#ifdef GATHER_STATISTICS
626
  tree_node_counts[(int)lang_type] += 1;
627
  tree_node_sizes[(int)lang_type] += size;
628
#endif
629
}
630
 
631
/* Copy TYPE, including any language-specific parts.  */
632
 
633
tree
634
copy_type (tree type)
635
{
636
  tree copy;
637
 
638
  copy = copy_node (type);
639
  copy_lang_type (copy);
640
  return copy;
641
}
642
 
643
tree
644
cxx_make_type (enum tree_code code)
645
{
646
  tree t = make_node (code);
647
 
648
  /* Create lang_type structure.  */
649
  if (RECORD_OR_UNION_CODE_P (code)
650
      || code == BOUND_TEMPLATE_TEMPLATE_PARM)
651
    {
652
      struct lang_type *pi = GGC_CNEW (struct lang_type);
653
 
654
      TYPE_LANG_SPECIFIC (t) = pi;
655
      pi->u.c.h.is_lang_type_class = 1;
656
 
657
#ifdef GATHER_STATISTICS
658
      tree_node_counts[(int)lang_type] += 1;
659
      tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
660
#endif
661
    }
662
 
663
  /* Set up some flags that give proper default behavior.  */
664
  if (RECORD_OR_UNION_CODE_P (code))
665
    {
666
      struct c_fileinfo *finfo = get_fileinfo (input_filename);
667
      SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
668
      CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
669
    }
670
 
671
  return t;
672
}
673
 
674
tree
675
make_class_type (enum tree_code code)
676
{
677
  tree t = cxx_make_type (code);
678
  SET_CLASS_TYPE_P (t, 1);
679
  return t;
680
}
681
 
682
/* Returns true if we are currently in the main source file, or in a
683
   template instantiation started from the main source file.  */
684
 
685
bool
686
in_main_input_context (void)
687
{
688
  struct tinst_level *tl = outermost_tinst_level();
689
 
690
  if (tl)
691
    return strcmp (main_input_filename,
692
                  LOCATION_FILE (tl->locus)) == 0;
693
  else
694
    return strcmp (main_input_filename, input_filename) == 0;
695
}

powered by: WebSVN 2.1.0

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