OSDN Git Service

Index: gcc/ChangeLog
[pf3gnuchains/gcc-fork.git] / libcpp / init.c
1 /* CPP Library.
2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4    Contributed by Per Bothner, 1994-95.
5    Based on CCCP program by Paul Rubin, June 1986
6    Adapted to ANSI C, Richard Stallman, Jan 1987
7
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
11 later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "cpplib.h"
25 #include "internal.h"
26 #include "mkdeps.h"
27 #include "localedir.h"
28
29 static void init_library (void);
30 static void mark_named_operators (cpp_reader *);
31 static void read_original_filename (cpp_reader *);
32 static void read_original_directory (cpp_reader *);
33 static void post_options (cpp_reader *);
34
35 /* If we have designated initializers (GCC >2.7) these tables can be
36    initialized, constant data.  Otherwise, they have to be filled in at
37    runtime.  */
38 #if HAVE_DESIGNATED_INITIALIZERS
39
40 #define init_trigraph_map()  /* Nothing.  */
41 #define TRIGRAPH_MAP \
42 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
43
44 #define END };
45 #define s(p, v) [p] = v,
46
47 #else
48
49 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
50  static void init_trigraph_map (void) { \
51  unsigned char *x = _cpp_trigraph_map;
52
53 #define END }
54 #define s(p, v) x[p] = v;
55
56 #endif
57
58 TRIGRAPH_MAP
59   s('=', '#')   s(')', ']')     s('!', '|')
60   s('(', '[')   s('\'', '^')    s('>', '}')
61   s('/', '\\')  s('<', '{')     s('-', '~')
62 END
63
64 #undef s
65 #undef END
66 #undef TRIGRAPH_MAP
67
68 /* A set of booleans indicating what CPP features each source language
69    requires.  */
70 struct lang_flags
71 {
72   char c99;
73   char cplusplus;
74   char extended_numbers;
75   char std;
76   char cplusplus_comments;
77   char digraphs;
78 };
79
80 static const struct lang_flags lang_defaults[] =
81 { /*              c99 c++ xnum std  //   digr  */
82   /* GNUC89 */  { 0,  0,  1,   0,   1,   1     },
83   /* GNUC99 */  { 1,  0,  1,   0,   1,   1     },
84   /* STDC89 */  { 0,  0,  0,   1,   0,   0     },
85   /* STDC94 */  { 0,  0,  0,   1,   0,   1     },
86   /* STDC99 */  { 1,  0,  1,   1,   1,   1     },
87   /* GNUCXX */  { 0,  1,  1,   0,   1,   1     },
88   /* CXX98  */  { 0,  1,  1,   1,   1,   1     },
89   /* ASM    */  { 0,  0,  1,   0,   1,   0     }
90 };
91
92 /* Sets internal flags correctly for a given language.  */
93 void
94 cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
95 {
96   const struct lang_flags *l = &lang_defaults[(int) lang];
97
98   CPP_OPTION (pfile, lang) = lang;
99
100   CPP_OPTION (pfile, c99)                = l->c99;
101   CPP_OPTION (pfile, cplusplus)          = l->cplusplus;
102   CPP_OPTION (pfile, extended_numbers)   = l->extended_numbers;
103   CPP_OPTION (pfile, std)                = l->std;
104   CPP_OPTION (pfile, trigraphs)          = l->std;
105   CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
106   CPP_OPTION (pfile, digraphs)           = l->digraphs;
107 }
108
109 /* Initialize library global state.  */
110 static void
111 init_library (void)
112 {
113   static int initialized = 0;
114
115   if (! initialized)
116     {
117       initialized = 1;
118
119       /* Set up the trigraph map.  This doesn't need to do anything if
120          we were compiled with a compiler that supports C99 designated
121          initializers.  */
122       init_trigraph_map ();
123
124 #ifdef ENABLE_NLS
125        (void) bindtextdomain (PACKAGE, LOCALEDIR);
126 #endif
127     }
128 }
129
130 /* Initialize a cpp_reader structure.  */
131 cpp_reader *
132 cpp_create_reader (enum c_lang lang, hash_table *table,
133                    struct line_maps *line_table)
134 {
135   cpp_reader *pfile;
136
137   /* Initialize this instance of the library if it hasn't been already.  */
138   init_library ();
139
140   pfile = xcalloc (1, sizeof (cpp_reader));
141
142   cpp_set_lang (pfile, lang);
143   CPP_OPTION (pfile, warn_multichar) = 1;
144   CPP_OPTION (pfile, discard_comments) = 1;
145   CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
146   CPP_OPTION (pfile, show_column) = 1;
147   CPP_OPTION (pfile, tabstop) = 8;
148   CPP_OPTION (pfile, operator_names) = 1;
149   CPP_OPTION (pfile, warn_trigraphs) = 2;
150   CPP_OPTION (pfile, warn_endif_labels) = 1;
151   CPP_OPTION (pfile, warn_deprecated) = 1;
152   CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
153   CPP_OPTION (pfile, dollars_in_ident) = 1;
154   CPP_OPTION (pfile, warn_dollars) = 1;
155   CPP_OPTION (pfile, warn_variadic_macros) = 1;
156   CPP_OPTION (pfile, warn_normalize) = normalized_C;
157
158   /* Default CPP arithmetic to something sensible for the host for the
159      benefit of dumb users like fix-header.  */
160   CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
161   CPP_OPTION (pfile, char_precision) = CHAR_BIT;
162   CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
163   CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
164   CPP_OPTION (pfile, unsigned_char) = 0;
165   CPP_OPTION (pfile, unsigned_wchar) = 1;
166   CPP_OPTION (pfile, bytes_big_endian) = 1;  /* does not matter */
167
168   /* Default to no charset conversion.  */
169   CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
170   CPP_OPTION (pfile, wide_charset) = 0;
171
172   /* Default the input character set to UTF-8.  */
173   CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
174
175   /* A fake empty "directory" used as the starting point for files
176      looked up without a search path.  Name cannot be '/' because we
177      don't want to prepend anything at all to filenames using it.  All
178      other entries are correct zero-initialized.  */
179   pfile->no_search_path.name = (char *) "";
180
181   /* Initialize the line map.  */
182   pfile->line_table = line_table;
183
184   /* Initialize lexer state.  */
185   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
186
187   /* Set up static tokens.  */
188   pfile->avoid_paste.type = CPP_PADDING;
189   pfile->avoid_paste.val.source = NULL;
190   pfile->eof.type = CPP_EOF;
191   pfile->eof.flags = 0;
192
193   /* Create a token buffer for the lexer.  */
194   _cpp_init_tokenrun (&pfile->base_run, 250);
195   pfile->cur_run = &pfile->base_run;
196   pfile->cur_token = pfile->base_run.base;
197
198   /* Initialize the base context.  */
199   pfile->context = &pfile->base_context;
200   pfile->base_context.macro = 0;
201   pfile->base_context.prev = pfile->base_context.next = 0;
202
203   /* Aligned and unaligned storage.  */
204   pfile->a_buff = _cpp_get_buff (pfile, 0);
205   pfile->u_buff = _cpp_get_buff (pfile, 0);
206
207   /* The expression parser stack.  */
208   _cpp_expand_op_stack (pfile);
209
210   /* Initialize the buffer obstack.  */
211   _obstack_begin (&pfile->buffer_ob, 0, 0,
212                   (void *(*) (long)) xmalloc,
213                   (void (*) (void *)) free);
214
215   _cpp_init_files (pfile);
216
217   _cpp_init_hashtable (pfile, table);
218
219   return pfile;
220 }
221
222 /* Free resources used by PFILE.  Accessing PFILE after this function
223    returns leads to undefined behavior.  Returns the error count.  */
224 void
225 cpp_destroy (cpp_reader *pfile)
226 {
227   cpp_context *context, *contextn;
228   tokenrun *run, *runn;
229
230   free (pfile->op_stack);
231
232   while (CPP_BUFFER (pfile) != NULL)
233     _cpp_pop_buffer (pfile);
234
235   if (pfile->out.base)
236     free (pfile->out.base);
237
238   if (pfile->macro_buffer)
239     {
240       free (pfile->macro_buffer);
241       pfile->macro_buffer = NULL;
242       pfile->macro_buffer_len = 0;
243     }
244
245   if (pfile->deps)
246     deps_free (pfile->deps);
247   obstack_free (&pfile->buffer_ob, 0);
248
249   _cpp_destroy_hashtable (pfile);
250   _cpp_cleanup_files (pfile);
251   _cpp_destroy_iconv (pfile);
252
253   _cpp_free_buff (pfile->a_buff);
254   _cpp_free_buff (pfile->u_buff);
255   _cpp_free_buff (pfile->free_buffs);
256
257   for (run = &pfile->base_run; run; run = runn)
258     {
259       runn = run->next;
260       free (run->base);
261       if (run != &pfile->base_run)
262         free (run);
263     }
264
265   for (context = pfile->base_context.next; context; context = contextn)
266     {
267       contextn = context->next;
268       free (context);
269     }
270
271   free (pfile);
272 }
273
274 /* This structure defines one built-in identifier.  A node will be
275    entered in the hash table under the name NAME, with value VALUE.
276
277    There are two tables of these.  builtin_array holds all the
278    "builtin" macros: these are handled by builtin_macro() in
279    macro.c.  Builtin is somewhat of a misnomer -- the property of
280    interest is that these macros require special code to compute their
281    expansions.  The value is a "builtin_type" enumerator.
282
283    operator_array holds the C++ named operators.  These are keywords
284    which act as aliases for punctuators.  In C++, they cannot be
285    altered through #define, and #if recognizes them as operators.  In
286    C, these are not entered into the hash table at all (but see
287    <iso646.h>).  The value is a token-type enumerator.  */
288 struct builtin
289 {
290   const uchar *name;
291   unsigned short len;
292   unsigned short value;
293 };
294
295 #define B(n, t)    { DSC(n), t }
296 static const struct builtin builtin_array[] =
297 {
298   B("__TIME__",          BT_TIME),
299   B("__DATE__",          BT_DATE),
300   B("__FILE__",          BT_FILE),
301   B("__BASE_FILE__",     BT_BASE_FILE),
302   B("__LINE__",          BT_SPECLINE),
303   B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
304   /* Keep builtins not used for -traditional-cpp at the end, and
305      update init_builtins() if any more are added.  */
306   B("_Pragma",           BT_PRAGMA),
307   B("__STDC__",          BT_STDC),
308 };
309
310 static const struct builtin operator_array[] =
311 {
312   B("and",      CPP_AND_AND),
313   B("and_eq",   CPP_AND_EQ),
314   B("bitand",   CPP_AND),
315   B("bitor",    CPP_OR),
316   B("compl",    CPP_COMPL),
317   B("not",      CPP_NOT),
318   B("not_eq",   CPP_NOT_EQ),
319   B("or",       CPP_OR_OR),
320   B("or_eq",    CPP_OR_EQ),
321   B("xor",      CPP_XOR),
322   B("xor_eq",   CPP_XOR_EQ)
323 };
324 #undef B
325
326 /* Mark the C++ named operators in the hash table.  */
327 static void
328 mark_named_operators (cpp_reader *pfile)
329 {
330   const struct builtin *b;
331
332   for (b = operator_array;
333        b < (operator_array + ARRAY_SIZE (operator_array));
334        b++)
335     {
336       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
337       hp->flags |= NODE_OPERATOR;
338       hp->is_directive = 0;
339       hp->directive_index = b->value;
340     }
341 }
342
343 /* Read the builtins table above and enter them, and language-specific
344    macros, into the hash table.  HOSTED is true if this is a hosted
345    environment.  */
346 void
347 cpp_init_builtins (cpp_reader *pfile, int hosted)
348 {
349   const struct builtin *b;
350   size_t n = ARRAY_SIZE (builtin_array);
351
352   if (CPP_OPTION (pfile, traditional))
353     n -= 2;
354
355   for(b = builtin_array; b < builtin_array + n; b++)
356     {
357       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
358       hp->type = NT_MACRO;
359       hp->flags |= NODE_BUILTIN | NODE_WARN;
360       hp->value.builtin = b->value;
361     }
362
363   if (CPP_OPTION (pfile, cplusplus))
364     _cpp_define_builtin (pfile, "__cplusplus 1");
365   else if (CPP_OPTION (pfile, lang) == CLK_ASM)
366     _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
367   else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
368     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
369   else if (CPP_OPTION (pfile, c99))
370     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
371
372   if (hosted)
373     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
374   else
375     _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
376
377   if (CPP_OPTION (pfile, objc))
378     _cpp_define_builtin (pfile, "__OBJC__ 1");
379 }
380
381 /* Sanity-checks are dependent on command-line options, so it is
382    called as a subroutine of cpp_read_main_file ().  */
383 #if ENABLE_CHECKING
384 static void sanity_checks (cpp_reader *);
385 static void sanity_checks (cpp_reader *pfile)
386 {
387   cppchar_t test = 0;
388   size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
389
390   /* Sanity checks for assumptions about CPP arithmetic and target
391      type precisions made by cpplib.  */
392   test--;
393   if (test < 1)
394     cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
395
396   if (CPP_OPTION (pfile, precision) > max_precision)
397     cpp_error (pfile, CPP_DL_ICE,
398                "preprocessor arithmetic has maximum precision of %lu bits;"
399                " target requires %lu bits",
400                (unsigned long) max_precision,
401                (unsigned long) CPP_OPTION (pfile, precision));
402
403   if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
404     cpp_error (pfile, CPP_DL_ICE,
405                "CPP arithmetic must be at least as precise as a target int");
406
407   if (CPP_OPTION (pfile, char_precision) < 8)
408     cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
409
410   if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
411     cpp_error (pfile, CPP_DL_ICE,
412                "target wchar_t is narrower than target char");
413
414   if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
415     cpp_error (pfile, CPP_DL_ICE,
416                "target int is narrower than target char");
417
418   /* This is assumed in eval_token() and could be fixed if necessary.  */
419   if (sizeof (cppchar_t) > sizeof (cpp_num_part))
420     cpp_error (pfile, CPP_DL_ICE,
421                "CPP half-integer narrower than CPP character");
422
423   if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
424     cpp_error (pfile, CPP_DL_ICE,
425                "CPP on this host cannot handle wide character constants over"
426                " %lu bits, but the target requires %lu bits",
427                (unsigned long) BITS_PER_CPPCHAR_T,
428                (unsigned long) CPP_OPTION (pfile, wchar_precision));
429 }
430 #else
431 # define sanity_checks(PFILE)
432 #endif
433
434 /* This is called after options have been parsed, and partially
435    processed.  */
436 void
437 cpp_post_options (cpp_reader *pfile)
438 {
439   sanity_checks (pfile);
440
441   post_options (pfile);
442
443   /* Mark named operators before handling command line macros.  */
444   if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
445     mark_named_operators (pfile);
446 }
447
448 /* Setup for processing input from the file named FNAME, or stdin if
449    it is the empty string.  Return the original filename
450    on success (e.g. foo.i->foo.c), or NULL on failure.  */
451 const char *
452 cpp_read_main_file (cpp_reader *pfile, const char *fname)
453 {
454   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
455     {
456       if (!pfile->deps)
457         pfile->deps = deps_init ();
458
459       /* Set the default target (if there is none already).  */
460       deps_add_default_target (pfile->deps, fname);
461     }
462
463   pfile->main_file
464     = _cpp_find_file (pfile, fname, &pfile->no_search_path, false);
465   if (_cpp_find_failed (pfile->main_file))
466     return NULL;
467
468   _cpp_stack_file (pfile, pfile->main_file, false);
469
470   /* For foo.i, read the original filename foo.c now, for the benefit
471      of the front ends.  */
472   if (CPP_OPTION (pfile, preprocessed))
473     {
474       read_original_filename (pfile);
475       fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
476     }
477   return fname;
478 }
479
480 /* For preprocessed files, if the first tokens are of the form # NUM.
481    handle the directive so we know the original file name.  This will
482    generate file_change callbacks, which the front ends must handle
483    appropriately given their state of initialization.  */
484 static void
485 read_original_filename (cpp_reader *pfile)
486 {
487   const cpp_token *token, *token1;
488
489   /* Lex ahead; if the first tokens are of the form # NUM, then
490      process the directive, otherwise back up.  */
491   token = _cpp_lex_direct (pfile);
492   if (token->type == CPP_HASH)
493     {
494       token1 = _cpp_lex_direct (pfile);
495       _cpp_backup_tokens (pfile, 1);
496
497       /* If it's a #line directive, handle it.  */
498       if (token1->type == CPP_NUMBER)
499         {
500           _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
501           read_original_directory (pfile);
502           return;
503         }
504     }
505
506   /* Backup as if nothing happened.  */
507   _cpp_backup_tokens (pfile, 1);
508 }
509
510 /* For preprocessed files, if the tokens following the first filename
511    line is of the form # <line> "/path/name//", handle the
512    directive so we know the original current directory.  */
513 static void
514 read_original_directory (cpp_reader *pfile)
515 {
516   const cpp_token *hash, *token;
517
518   /* Lex ahead; if the first tokens are of the form # NUM, then
519      process the directive, otherwise back up.  */
520   hash = _cpp_lex_direct (pfile);
521   if (hash->type != CPP_HASH)
522     {
523       _cpp_backup_tokens (pfile, 1);
524       return;
525     }
526
527   token = _cpp_lex_direct (pfile);
528
529   if (token->type != CPP_NUMBER)
530     {
531       _cpp_backup_tokens (pfile, 2);
532       return;
533     }
534
535   token = _cpp_lex_direct (pfile);
536
537   if (token->type != CPP_STRING
538       || ! (token->val.str.len >= 5
539             && token->val.str.text[token->val.str.len-2] == '/'
540             && token->val.str.text[token->val.str.len-3] == '/'))
541     {
542       _cpp_backup_tokens (pfile, 3);
543       return;
544     }
545
546   if (pfile->cb.dir_change)
547     {
548       char *debugdir = alloca (token->val.str.len - 3);
549
550       memcpy (debugdir, (const char *) token->val.str.text + 1,
551               token->val.str.len - 4);
552       debugdir[token->val.str.len - 4] = '\0';
553
554       pfile->cb.dir_change (pfile, debugdir);
555     }      
556 }
557
558 /* This is called at the end of preprocessing.  It pops the last
559    buffer and writes dependency output, and returns the number of
560    errors.
561
562    Maybe it should also reset state, such that you could call
563    cpp_start_read with a new filename to restart processing.  */
564 int
565 cpp_finish (cpp_reader *pfile, FILE *deps_stream)
566 {
567   /* Warn about unused macros before popping the final buffer.  */
568   if (CPP_OPTION (pfile, warn_unused_macros))
569     cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
570
571   /* lex.c leaves the final buffer on the stack.  This it so that
572      it returns an unending stream of CPP_EOFs to the client.  If we
573      popped the buffer, we'd dereference a NULL buffer pointer and
574      segfault.  It's nice to allow the client to do worry-free excess
575      cpp_get_token calls.  */
576   while (pfile->buffer)
577     _cpp_pop_buffer (pfile);
578
579   /* Don't write the deps file if there are errors.  */
580   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
581       && deps_stream && pfile->errors == 0)
582     {
583       deps_write (pfile->deps, deps_stream, 72);
584
585       if (CPP_OPTION (pfile, deps.phony_targets))
586         deps_phony_targets (pfile->deps, deps_stream);
587     }
588
589   /* Report on headers that could use multiple include guards.  */
590   if (CPP_OPTION (pfile, print_include_names))
591     _cpp_report_missing_guards (pfile);
592
593   return pfile->errors;
594 }
595
596 static void
597 post_options (cpp_reader *pfile)
598 {
599   /* -Wtraditional is not useful in C++ mode.  */
600   if (CPP_OPTION (pfile, cplusplus))
601     CPP_OPTION (pfile, warn_traditional) = 0;
602
603   /* Permanently disable macro expansion if we are rescanning
604      preprocessed text.  Read preprocesed source in ISO mode.  */
605   if (CPP_OPTION (pfile, preprocessed))
606     {
607       pfile->state.prevent_expansion = 1;
608       CPP_OPTION (pfile, traditional) = 0;
609     }
610
611   if (CPP_OPTION (pfile, warn_trigraphs) == 2)
612     CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
613
614   if (CPP_OPTION (pfile, traditional))
615     {
616       CPP_OPTION (pfile, cplusplus_comments) = 0;
617
618       /* Traditional CPP does not accurately track column information.  */
619       CPP_OPTION (pfile, show_column) = 0;
620       CPP_OPTION (pfile, trigraphs) = 0;
621       CPP_OPTION (pfile, warn_trigraphs) = 0;
622     }
623 }