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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [c-opts.c] - Blame information for rev 827

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

Line No. Rev Author Line
1 38 julius
/* C/ObjC/C++ command line option handling.
2
   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
3
   Free Software Foundation, Inc.
4
   Contributed by Neil Booth.
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
#include "config.h"
23
#include "system.h"
24
#include "coretypes.h"
25
#include "tm.h"
26
#include "tree.h"
27
#include "c-common.h"
28
#include "c-pragma.h"
29
#include "flags.h"
30
#include "toplev.h"
31
#include "langhooks.h"
32
#include "tree-inline.h"
33
#include "diagnostic.h"
34
#include "intl.h"
35
#include "cppdefault.h"
36
#include "c-incpath.h"
37
#include "debug.h"              /* For debug_hooks.  */
38
#include "opts.h"
39
#include "options.h"
40
#include "mkdeps.h"
41
 
42
#ifndef DOLLARS_IN_IDENTIFIERS
43
# define DOLLARS_IN_IDENTIFIERS true
44
#endif
45
 
46
#ifndef TARGET_SYSTEM_ROOT
47
# define TARGET_SYSTEM_ROOT NULL
48
#endif
49
 
50
#ifndef TARGET_OPTF
51
#define TARGET_OPTF(ARG)
52
#endif
53
 
54
/* CPP's options.  */
55
static cpp_options *cpp_opts;
56
 
57
/* Input filename.  */
58
static const char *this_input_filename;
59
 
60
/* Filename and stream for preprocessed output.  */
61
static const char *out_fname;
62
static FILE *out_stream;
63
 
64
/* Append dependencies to deps_file.  */
65
static bool deps_append;
66
 
67
/* If dependency switches (-MF etc.) have been given.  */
68
static bool deps_seen;
69
 
70
/* If -v seen.  */
71
static bool verbose;
72
 
73
/* If -lang-fortran seen.  */
74
static bool lang_fortran = false;
75
 
76
/* Dependency output file.  */
77
static const char *deps_file;
78
 
79
/* The prefix given by -iprefix, if any.  */
80
static const char *iprefix;
81
 
82
/* The multilib directory given by -imultilib, if any.  */
83
static const char *imultilib;
84
 
85
/* The system root, if any.  Overridden by -isysroot.  */
86
static const char *sysroot = TARGET_SYSTEM_ROOT;
87
 
88
/* Zero disables all standard directories for headers.  */
89
static bool std_inc = true;
90
 
91
/* Zero disables the C++-specific standard directories for headers.  */
92
static bool std_cxx_inc = true;
93
 
94
/* If the quote chain has been split by -I-.  */
95
static bool quote_chain_split;
96
 
97
/* If -Wunused-macros.  */
98
static bool warn_unused_macros;
99
 
100
/* If -Wvariadic-macros.  */
101
static bool warn_variadic_macros = true;
102
 
103
/* Number of deferred options.  */
104
static size_t deferred_count;
105
 
106
/* Number of deferred options scanned for -include.  */
107
static size_t include_cursor;
108
 
109
static void set_Wimplicit (int);
110
static void handle_OPT_d (const char *);
111
static void set_std_cxx98 (int);
112
static void set_std_c89 (int, int);
113
static void set_std_c99 (int);
114
static void check_deps_environment_vars (void);
115
static void handle_deferred_opts (void);
116
static void sanitize_cpp_opts (void);
117
static void add_prefixed_path (const char *, size_t);
118
static void push_command_line_include (void);
119
static void cb_file_change (cpp_reader *, const struct line_map *);
120
static void cb_dir_change (cpp_reader *, const char *);
121
static void finish_options (void);
122
 
123
#ifndef STDC_0_IN_SYSTEM_HEADERS
124
#define STDC_0_IN_SYSTEM_HEADERS 0
125
#endif
126
 
127
/* Holds switches parsed by c_common_handle_option (), but whose
128
   handling is deferred to c_common_post_options ().  */
129
static void defer_opt (enum opt_code, const char *);
130
static struct deferred_opt
131
{
132
  enum opt_code code;
133
  const char *arg;
134
} *deferred_opts;
135
 
136
/* Complain that switch CODE expects an argument but none was
137
   provided.  OPT was the command-line option.  Return FALSE to get
138
   the default message in opts.c, TRUE if we provide a specialized
139
   one.  */
140
bool
141
c_common_missing_argument (const char *opt, size_t code)
142
{
143
  switch (code)
144
    {
145
    default:
146
      /* Pick up the default message.  */
147
      return false;
148
 
149
    case OPT_fconstant_string_class_:
150
      error ("no class name specified with %qs", opt);
151
      break;
152
 
153
    case OPT_A:
154
      error ("assertion missing after %qs", opt);
155
      break;
156
 
157
    case OPT_D:
158
    case OPT_U:
159
      error ("macro name missing after %qs", opt);
160
      break;
161
 
162
    case OPT_F:
163
    case OPT_I:
164
    case OPT_idirafter:
165
    case OPT_isysroot:
166
    case OPT_isystem:
167
    case OPT_iquote:
168
      error ("missing path after %qs", opt);
169
      break;
170
 
171
    case OPT_MF:
172
    case OPT_MD:
173
    case OPT_MMD:
174
    case OPT_include:
175
    case OPT_imacros:
176
    case OPT_o:
177
      error ("missing filename after %qs", opt);
178
      break;
179
 
180
    case OPT_MQ:
181
    case OPT_MT:
182
      error ("missing makefile target after %qs", opt);
183
      break;
184
    }
185
 
186
  return true;
187
}
188
 
189
/* Defer option CODE with argument ARG.  */
190
static void
191
defer_opt (enum opt_code code, const char *arg)
192
{
193
  deferred_opts[deferred_count].code = code;
194
  deferred_opts[deferred_count].arg = arg;
195
  deferred_count++;
196
}
197
 
198
/* Common initialization before parsing options.  */
199
unsigned int
200
c_common_init_options (unsigned int argc, const char **argv)
201
{
202
  static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
203
  unsigned int i, result;
204
 
205
  /* This is conditionalized only because that is the way the front
206
     ends used to do it.  Maybe this should be unconditional?  */
207
  if (c_dialect_cxx ())
208
    {
209
      /* By default wrap lines at 80 characters.  Is getenv
210
         ("COLUMNS") preferable?  */
211
      diagnostic_line_cutoff (global_dc) = 80;
212
      /* By default, emit location information once for every
213
         diagnostic message.  */
214
      diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
215
    }
216
 
217
  parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
218
                                ident_hash, &line_table);
219
 
220
  cpp_opts = cpp_get_options (parse_in);
221
  cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
222
  cpp_opts->objc = c_dialect_objc ();
223
 
224
  /* Reset to avoid warnings on internal definitions.  We set it just
225
     before passing on command-line options to cpplib.  */
226
  cpp_opts->warn_dollars = 0;
227
 
228
  flag_exceptions = c_dialect_cxx ();
229
  warn_pointer_arith = c_dialect_cxx ();
230
  warn_write_strings = c_dialect_cxx();
231
 
232
  deferred_opts = XNEWVEC (struct deferred_opt, argc);
233
 
234
  result = lang_flags[c_language];
235
 
236
  if (c_language == clk_c)
237
    {
238
      /* If preprocessing assembly language, accept any of the C-family
239
         front end options since the driver may pass them through.  */
240
      for (i = 1; i < argc; i++)
241
        if (! strcmp (argv[i], "-lang-asm"))
242
          {
243
            result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;
244
            break;
245
          }
246
 
247
#ifdef CL_Fortran
248
      for (i = 1; i < argc; i++)
249
        if (! strcmp (argv[i], "-lang-fortran"))
250
        {
251
            result |= CL_Fortran;
252
            break;
253
        }
254
#endif
255
    }
256
 
257
  return result;
258
}
259
 
260
/* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
261
   form of an -f or -W option was given.  Returns 0 if the switch was
262
   invalid, a negative number to prevent language-independent
263
   processing in toplev.c (a hack necessary for the short-term).  */
264
int
265
c_common_handle_option (size_t scode, const char *arg, int value)
266
{
267
  const struct cl_option *option = &cl_options[scode];
268
  enum opt_code code = (enum opt_code) scode;
269
  int result = 1;
270
 
271
  /* Prevent resetting the language standard to a C dialect when the driver
272
     has already determined that we're looking at assembler input.  */
273
  bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM);
274
 
275
  switch (code)
276
    {
277
    default:
278
      if (cl_options[code].flags & (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX))
279
        break;
280
#ifdef CL_Fortran
281
      if (lang_fortran && (cl_options[code].flags & (CL_Fortran)))
282
        break;
283
#endif
284
      result = 0;
285
      break;
286
 
287
    case OPT__output_pch_:
288
      pch_file = arg;
289
      break;
290
 
291
    case OPT_A:
292
      defer_opt (code, arg);
293
      break;
294
 
295
    case OPT_C:
296
      cpp_opts->discard_comments = 0;
297
      break;
298
 
299
    case OPT_CC:
300
      cpp_opts->discard_comments = 0;
301
      cpp_opts->discard_comments_in_macro_exp = 0;
302
      break;
303
 
304
    case OPT_D:
305
      defer_opt (code, arg);
306
      break;
307
 
308
    case OPT_E:
309
      flag_preprocess_only = 1;
310
      break;
311
 
312
    case OPT_H:
313
      cpp_opts->print_include_names = 1;
314
      break;
315
 
316
    case OPT_F:
317
      TARGET_OPTF (xstrdup (arg));
318
      break;
319
 
320
    case OPT_I:
321
      if (strcmp (arg, "-"))
322
        add_path (xstrdup (arg), BRACKET, 0, true);
323
      else
324
        {
325
          if (quote_chain_split)
326
            error ("-I- specified twice");
327
          quote_chain_split = true;
328
          split_quote_chain ();
329
          inform ("obsolete option -I- used, please use -iquote instead");
330
        }
331
      break;
332
 
333
    case OPT_M:
334
    case OPT_MM:
335
      /* When doing dependencies with -M or -MM, suppress normal
336
         preprocessed output, but still do -dM etc. as software
337
         depends on this.  Preprocessed output does occur if -MD, -MMD
338
         or environment var dependency generation is used.  */
339
      cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
340
      flag_no_output = 1;
341
      cpp_opts->inhibit_warnings = 1;
342
      break;
343
 
344
    case OPT_MD:
345
    case OPT_MMD:
346
      cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
347
      deps_file = arg;
348
      break;
349
 
350
    case OPT_MF:
351
      deps_seen = true;
352
      deps_file = arg;
353
      break;
354
 
355
    case OPT_MG:
356
      deps_seen = true;
357
      cpp_opts->deps.missing_files = true;
358
      break;
359
 
360
    case OPT_MP:
361
      deps_seen = true;
362
      cpp_opts->deps.phony_targets = true;
363
      break;
364
 
365
    case OPT_MQ:
366
    case OPT_MT:
367
      deps_seen = true;
368
      defer_opt (code, arg);
369
      break;
370
 
371
    case OPT_P:
372
      flag_no_line_commands = 1;
373
      break;
374
 
375
    case OPT_fworking_directory:
376
      flag_working_directory = value;
377
      break;
378
 
379
    case OPT_U:
380
      defer_opt (code, arg);
381
      break;
382
 
383
    case OPT_Wall:
384
      set_Wunused (value);
385
      set_Wformat (value);
386
      set_Wimplicit (value);
387
      warn_char_subscripts = value;
388
      warn_missing_braces = value;
389
      warn_parentheses = value;
390
      warn_return_type = value;
391
      warn_sequence_point = value;      /* Was C only.  */
392
      if (c_dialect_cxx ())
393
        warn_sign_compare = value;
394
      warn_switch = value;
395
      warn_strict_aliasing = value;
396
      warn_strict_overflow = value;
397
      warn_address = value;
398
 
399
      /* Only warn about unknown pragmas that are not in system
400
         headers.  */
401
      warn_unknown_pragmas = value;
402
 
403
      /* We save the value of warn_uninitialized, since if they put
404
         -Wuninitialized on the command line, we need to generate a
405
         warning about not using it without also specifying -O.  */
406
      if (warn_uninitialized != 1)
407
        warn_uninitialized = (value ? 2 : 0);
408
 
409
      if (!c_dialect_cxx ())
410
        /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
411
           can turn it off only if it's not explicit.  */
412
        warn_main = value * 2;
413
      else
414
        {
415
          /* C++-specific warnings.  */
416
          warn_reorder = value;
417
          warn_nontemplate_friend = value;
418
        }
419
 
420
      cpp_opts->warn_trigraphs = value;
421
      cpp_opts->warn_comments = value;
422
      cpp_opts->warn_num_sign_change = value;
423
      cpp_opts->warn_multichar = value; /* Was C++ only.  */
424
 
425
      if (warn_pointer_sign == -1)
426
        warn_pointer_sign = 1;
427
      break;
428
 
429
    case OPT_Wcomment:
430
    case OPT_Wcomments:
431
      cpp_opts->warn_comments = value;
432
      break;
433
 
434
    case OPT_Wdeprecated:
435
      cpp_opts->warn_deprecated = value;
436
      break;
437
 
438
    case OPT_Wendif_labels:
439
      cpp_opts->warn_endif_labels = value;
440
      break;
441
 
442
    case OPT_Werror:
443
      cpp_opts->warnings_are_errors = value;
444
      global_dc->warning_as_error_requested = value;
445
      break;
446
 
447
    case OPT_Werror_implicit_function_declaration:
448
      mesg_implicit_function_declaration = 2;
449
      break;
450
 
451
    case OPT_Wformat:
452
      set_Wformat (value);
453
      break;
454
 
455
    case OPT_Wformat_:
456
      set_Wformat (atoi (arg));
457
      break;
458
 
459
    case OPT_Wimplicit:
460
      set_Wimplicit (value);
461
      break;
462
 
463
    case OPT_Wimport:
464
      /* Silently ignore for now.  */
465
      break;
466
 
467
    case OPT_Winvalid_pch:
468
      cpp_opts->warn_invalid_pch = value;
469
      break;
470
 
471
    case OPT_Wmain:
472
      if (value)
473
        warn_main = 1;
474
      else
475
        warn_main = -1;
476
      break;
477
 
478
    case OPT_Wmissing_include_dirs:
479
      cpp_opts->warn_missing_include_dirs = value;
480
      break;
481
 
482
    case OPT_Wmultichar:
483
      cpp_opts->warn_multichar = value;
484
      break;
485
 
486
    case OPT_Wnormalized_:
487
      if (!value || (arg && strcasecmp (arg, "none") == 0))
488
        cpp_opts->warn_normalize = normalized_none;
489
      else if (!arg || strcasecmp (arg, "nfkc") == 0)
490
        cpp_opts->warn_normalize = normalized_KC;
491
      else if (strcasecmp (arg, "id") == 0)
492
        cpp_opts->warn_normalize = normalized_identifier_C;
493
      else if (strcasecmp (arg, "nfc") == 0)
494
        cpp_opts->warn_normalize = normalized_C;
495
      else
496
        error ("argument %qs to %<-Wnormalized%> not recognized", arg);
497
      break;
498
 
499
    case OPT_Wreturn_type:
500
      warn_return_type = value;
501
      break;
502
 
503
    case OPT_Wstrict_null_sentinel:
504
      warn_strict_null_sentinel = value;
505
      break;
506
 
507
    case OPT_Wsystem_headers:
508
      cpp_opts->warn_system_headers = value;
509
      break;
510
 
511
    case OPT_Wtraditional:
512
      cpp_opts->warn_traditional = value;
513
      break;
514
 
515
    case OPT_Wtrigraphs:
516
      cpp_opts->warn_trigraphs = value;
517
      break;
518
 
519
    case OPT_Wundef:
520
      cpp_opts->warn_undef = value;
521
      break;
522
 
523
    case OPT_Wunknown_pragmas:
524
      /* Set to greater than 1, so that even unknown pragmas in
525
         system headers will be warned about.  */
526
      warn_unknown_pragmas = value * 2;
527
      break;
528
 
529
    case OPT_Wunused_macros:
530
      warn_unused_macros = value;
531
      break;
532
 
533
    case OPT_Wvariadic_macros:
534
      warn_variadic_macros = value;
535
      break;
536
 
537
    case OPT_Wwrite_strings:
538
      warn_write_strings = value;
539
      break;
540
 
541
    case OPT_Weffc__:
542
      warn_ecpp = value;
543
      if (value)
544
        warn_nonvdtor = true;
545
      break;
546
 
547
    case OPT_ansi:
548
      if (!c_dialect_cxx ())
549
        set_std_c89 (false, true);
550
      else
551
        set_std_cxx98 (true);
552
      break;
553
 
554
    case OPT_d:
555
      handle_OPT_d (arg);
556
      break;
557
 
558
    case OPT_fcond_mismatch:
559
      if (!c_dialect_cxx ())
560
        {
561
          flag_cond_mismatch = value;
562
          break;
563
        }
564
      /* Fall through.  */
565
 
566
    case OPT_fall_virtual:
567
    case OPT_falt_external_templates:
568
    case OPT_fenum_int_equiv:
569
    case OPT_fexternal_templates:
570
    case OPT_fguiding_decls:
571
    case OPT_fhonor_std:
572
    case OPT_fhuge_objects:
573
    case OPT_flabels_ok:
574
    case OPT_fname_mangling_version_:
575
    case OPT_fnew_abi:
576
    case OPT_fnonnull_objects:
577
    case OPT_fsquangle:
578
    case OPT_fstrict_prototype:
579
    case OPT_fthis_is_variable:
580
    case OPT_fvtable_thunks:
581
    case OPT_fxref:
582
    case OPT_fvtable_gc:
583
      warning (0, "switch %qs is no longer supported", option->opt_text);
584
      break;
585
 
586
    case OPT_faccess_control:
587
      flag_access_control = value;
588
      break;
589
 
590
    case OPT_fasm:
591
      flag_no_asm = !value;
592
      break;
593
 
594
    case OPT_fbuiltin:
595
      flag_no_builtin = !value;
596
      break;
597
 
598
    case OPT_fbuiltin_:
599
      if (value)
600
        result = 0;
601
      else
602
        disable_builtin_function (arg);
603
      break;
604
 
605
    case OPT_fdollars_in_identifiers:
606
      cpp_opts->dollars_in_ident = value;
607
      break;
608
 
609
    case OPT_ffreestanding:
610
      value = !value;
611
      /* Fall through....  */
612
    case OPT_fhosted:
613
      flag_hosted = value;
614
      flag_no_builtin = !value;
615
      /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
616
      if (!value && warn_main == 2)
617
        warn_main = 0;
618
      break;
619
 
620
    case OPT_fshort_double:
621
      flag_short_double = value;
622
      break;
623
 
624
    case OPT_fshort_enums:
625
      flag_short_enums = value;
626
      break;
627
 
628
    case OPT_fshort_wchar:
629
      flag_short_wchar = value;
630
      break;
631
 
632
    case OPT_fsigned_bitfields:
633
      flag_signed_bitfields = value;
634
      break;
635
 
636
    case OPT_fsigned_char:
637
      flag_signed_char = value;
638
      break;
639
 
640
    case OPT_funsigned_bitfields:
641
      flag_signed_bitfields = !value;
642
      break;
643
 
644
    case OPT_funsigned_char:
645
      flag_signed_char = !value;
646
      break;
647
 
648
    case OPT_fcheck_new:
649
      flag_check_new = value;
650
      break;
651
 
652
    case OPT_fconserve_space:
653
      flag_conserve_space = value;
654
      break;
655
 
656
    case OPT_fconstant_string_class_:
657
      constant_string_class_name = arg;
658
      break;
659
 
660
    case OPT_fdefault_inline:
661
      flag_default_inline = value;
662
      break;
663
 
664
    case OPT_felide_constructors:
665
      flag_elide_constructors = value;
666
      break;
667
 
668
    case OPT_fenforce_eh_specs:
669
      flag_enforce_eh_specs = value;
670
      break;
671
 
672
    case OPT_fextended_identifiers:
673
      cpp_opts->extended_identifiers = value;
674
      break;
675
 
676
    case OPT_ffor_scope:
677
      flag_new_for_scope = value;
678
      break;
679
 
680
    case OPT_fgnu_keywords:
681
      flag_no_gnu_keywords = !value;
682
      break;
683
 
684
    case OPT_fgnu_runtime:
685
      flag_next_runtime = !value;
686
      break;
687
 
688
    case OPT_fhandle_exceptions:
689
      warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
690
      flag_exceptions = value;
691
      break;
692
 
693
    case OPT_fimplement_inlines:
694
      flag_implement_inlines = value;
695
      break;
696
 
697
    case OPT_fimplicit_inline_templates:
698
      flag_implicit_inline_templates = value;
699
      break;
700
 
701
    case OPT_fimplicit_templates:
702
      flag_implicit_templates = value;
703
      break;
704
 
705
    case OPT_fms_extensions:
706
      flag_ms_extensions = value;
707
      break;
708
 
709
    case OPT_fnext_runtime:
710
      flag_next_runtime = value;
711
      break;
712
 
713
    case OPT_fnil_receivers:
714
      flag_nil_receivers = value;
715
      break;
716
 
717
    case OPT_fnonansi_builtins:
718
      flag_no_nonansi_builtin = !value;
719
      break;
720
 
721
    case OPT_foperator_names:
722
      cpp_opts->operator_names = value;
723
      break;
724
 
725
    case OPT_foptional_diags:
726
      flag_optional_diags = value;
727
      break;
728
 
729
    case OPT_fpch_deps:
730
      cpp_opts->restore_pch_deps = value;
731
      break;
732
 
733
    case OPT_fpch_preprocess:
734
      flag_pch_preprocess = value;
735
      break;
736
 
737
    case OPT_fpermissive:
738
      flag_permissive = value;
739
      break;
740
 
741
    case OPT_fpreprocessed:
742
      cpp_opts->preprocessed = value;
743
      break;
744
 
745
    case OPT_freplace_objc_classes:
746
      flag_replace_objc_classes = value;
747
      break;
748
 
749
    case OPT_frepo:
750
      flag_use_repository = value;
751
      if (value)
752
        flag_implicit_templates = 0;
753
      break;
754
 
755
    case OPT_frtti:
756
      flag_rtti = value;
757
      break;
758
 
759
    case OPT_fshow_column:
760
      cpp_opts->show_column = value;
761
      break;
762
 
763
    case OPT_fstats:
764
      flag_detailed_statistics = value;
765
      break;
766
 
767
    case OPT_ftabstop_:
768
      /* It is documented that we silently ignore silly values.  */
769
      if (value >= 1 && value <= 100)
770
        cpp_opts->tabstop = value;
771
      break;
772
 
773
    case OPT_fexec_charset_:
774
      cpp_opts->narrow_charset = arg;
775
      break;
776
 
777
    case OPT_fwide_exec_charset_:
778
      cpp_opts->wide_charset = arg;
779
      break;
780
 
781
    case OPT_finput_charset_:
782
      cpp_opts->input_charset = arg;
783
      break;
784
 
785
    case OPT_ftemplate_depth_:
786
      max_tinst_depth = value;
787
      break;
788
 
789
    case OPT_fuse_cxa_atexit:
790
      flag_use_cxa_atexit = value;
791
      break;
792
 
793
    case OPT_fuse_cxa_get_exception_ptr:
794
      flag_use_cxa_get_exception_ptr = value;
795
      break;
796
 
797
    case OPT_fvisibility_inlines_hidden:
798
      visibility_options.inlines_hidden = value;
799
      break;
800
 
801
    case OPT_fweak:
802
      flag_weak = value;
803
      break;
804
 
805
    case OPT_fthreadsafe_statics:
806
      flag_threadsafe_statics = value;
807
      break;
808
 
809
    case OPT_fzero_link:
810
      flag_zero_link = value;
811
      break;
812
 
813
    case OPT_gen_decls:
814
      flag_gen_declaration = 1;
815
      break;
816
 
817
    case OPT_idirafter:
818
      add_path (xstrdup (arg), AFTER, 0, true);
819
      break;
820
 
821
    case OPT_imacros:
822
    case OPT_include:
823
      defer_opt (code, arg);
824
      break;
825
 
826
    case OPT_imultilib:
827
      imultilib = arg;
828
      break;
829
 
830
    case OPT_iprefix:
831
      iprefix = arg;
832
      break;
833
 
834
    case OPT_iquote:
835
      add_path (xstrdup (arg), QUOTE, 0, true);
836
      break;
837
 
838
    case OPT_isysroot:
839
      sysroot = arg;
840
      break;
841
 
842
    case OPT_isystem:
843
      add_path (xstrdup (arg), SYSTEM, 0, true);
844
      break;
845
 
846
    case OPT_iwithprefix:
847
      add_prefixed_path (arg, SYSTEM);
848
      break;
849
 
850
    case OPT_iwithprefixbefore:
851
      add_prefixed_path (arg, BRACKET);
852
      break;
853
 
854
    case OPT_lang_asm:
855
      cpp_set_lang (parse_in, CLK_ASM);
856
      cpp_opts->dollars_in_ident = false;
857
      break;
858
 
859
    case OPT_lang_fortran:
860
      lang_fortran = true;
861
      break;
862
 
863
    case OPT_lang_objc:
864
      cpp_opts->objc = 1;
865
      break;
866
 
867
    case OPT_nostdinc:
868
      std_inc = false;
869
      break;
870
 
871
    case OPT_nostdinc__:
872
      std_cxx_inc = false;
873
      break;
874
 
875
    case OPT_o:
876
      if (!out_fname)
877
        out_fname = arg;
878
      else
879
        error ("output filename specified twice");
880
      break;
881
 
882
      /* We need to handle the -pedantic switches here, rather than in
883
         c_common_post_options, so that a subsequent -Wno-endif-labels
884
         is not overridden.  */
885
    case OPT_pedantic_errors:
886
      cpp_opts->pedantic_errors = 1;
887
      /* Fall through.  */
888
    case OPT_pedantic:
889
      cpp_opts->pedantic = 1;
890
      cpp_opts->warn_endif_labels = 1;
891
      if (warn_pointer_sign == -1)
892
        warn_pointer_sign = 1;
893
      if (warn_overlength_strings == -1)
894
        warn_overlength_strings = 1;
895
      break;
896
 
897
    case OPT_print_objc_runtime_info:
898
      print_struct_values = 1;
899
      break;
900
 
901
    case OPT_print_pch_checksum:
902
      c_common_print_pch_checksum (stdout);
903
      exit_after_options = true;
904
      break;
905
 
906
    case OPT_remap:
907
      cpp_opts->remap = 1;
908
      break;
909
 
910
    case OPT_std_c__98:
911
    case OPT_std_gnu__98:
912
      if (!preprocessing_asm_p)
913
        set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
914
      break;
915
 
916
    case OPT_std_c89:
917
    case OPT_std_iso9899_1990:
918
    case OPT_std_iso9899_199409:
919
      if (!preprocessing_asm_p)
920
        set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
921
      break;
922
 
923
    case OPT_std_gnu89:
924
      if (!preprocessing_asm_p)
925
        set_std_c89 (false /* c94 */, false /* ISO */);
926
      break;
927
 
928
    case OPT_std_c99:
929
    case OPT_std_c9x:
930
    case OPT_std_iso9899_1999:
931
    case OPT_std_iso9899_199x:
932
      if (!preprocessing_asm_p)
933
        set_std_c99 (true /* ISO */);
934
      break;
935
 
936
    case OPT_std_gnu99:
937
    case OPT_std_gnu9x:
938
      if (!preprocessing_asm_p)
939
        set_std_c99 (false /* ISO */);
940
      break;
941
 
942
    case OPT_trigraphs:
943
      cpp_opts->trigraphs = 1;
944
      break;
945
 
946
    case OPT_traditional_cpp:
947
      cpp_opts->traditional = 1;
948
      break;
949
 
950
    case OPT_undef:
951
      flag_undef = 1;
952
      break;
953
 
954
    case OPT_w:
955
      cpp_opts->inhibit_warnings = 1;
956
      break;
957
 
958
    case OPT_v:
959
      verbose = true;
960
      break;
961
    }
962
 
963
  return result;
964
}
965
 
966
/* Post-switch processing.  */
967
bool
968
c_common_post_options (const char **pfilename)
969
{
970
  struct cpp_callbacks *cb;
971
 
972
  /* Canonicalize the input and output filenames.  */
973
  if (in_fnames == NULL)
974
    {
975
      in_fnames = XNEWVEC (const char *, 1);
976
      in_fnames[0] = "";
977
    }
978
  else if (strcmp (in_fnames[0], "-") == 0)
979
    in_fnames[0] = "";
980
 
981
  if (out_fname == NULL || !strcmp (out_fname, "-"))
982
    out_fname = "";
983
 
984
  if (cpp_opts->deps.style == DEPS_NONE)
985
    check_deps_environment_vars ();
986
 
987
  handle_deferred_opts ();
988
 
989
  sanitize_cpp_opts ();
990
 
991
  register_include_chains (parse_in, sysroot, iprefix, imultilib,
992
                           std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
993
 
994
#ifdef C_COMMON_OVERRIDE_OPTIONS
995
  /* Some machines may reject certain combinations of C
996
     language-specific options.  */
997
  C_COMMON_OVERRIDE_OPTIONS;
998
#endif
999
 
1000
  flag_inline_trees = 1;
1001
 
1002
  /* Use tree inlining.  */
1003
  if (!flag_no_inline)
1004
    flag_no_inline = 1;
1005
  if (flag_inline_functions)
1006
    flag_inline_trees = 2;
1007
 
1008
  /* We recognize -fgnu89-inline in preparation for 4.3 where the
1009
     option will be meaningful.  Here we just reject
1010
     -fno-gnu89-inline, since we don't support it.  */
1011
  if (!flag_gnu89_inline)
1012
    error ("-fno-gnu89-inline is not supported");
1013
 
1014
  /* If we are given more than one input file, we must use
1015
     unit-at-a-time mode.  */
1016
  if (num_in_fnames > 1)
1017
    flag_unit_at_a_time = 1;
1018
 
1019
  /* Default to ObjC sjlj exception handling if NeXT runtime.  */
1020
  if (flag_objc_sjlj_exceptions < 0)
1021
    flag_objc_sjlj_exceptions = flag_next_runtime;
1022
  if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
1023
    flag_exceptions = 1;
1024
 
1025
  /* -Wextra implies -Wsign-compare, -Wmissing-field-initializers and
1026
     -Woverride-init, but not if explicitly overridden.  */
1027
  if (warn_sign_compare == -1)
1028
    warn_sign_compare = extra_warnings;
1029
  if (warn_missing_field_initializers == -1)
1030
    warn_missing_field_initializers = extra_warnings;
1031
  if (warn_override_init == -1)
1032
    warn_override_init = extra_warnings;
1033
 
1034
  /* -Wpointer_sign is disabled by default, but it is enabled if any
1035
     of -Wall or -pedantic are given.  */
1036
  if (warn_pointer_sign == -1)
1037
    warn_pointer_sign = 0;
1038
 
1039
  /* -Woverlength-strings is off by default, but is enabled by -pedantic.
1040
     It is never enabled in C++, as the minimum limit is not normative
1041
     in that standard.  */
1042
  if (warn_overlength_strings == -1 || c_dialect_cxx ())
1043
    warn_overlength_strings = 0;
1044
 
1045
  /* Special format checking options don't work without -Wformat; warn if
1046
     they are used.  */
1047
  if (!warn_format)
1048
    {
1049
      warning (OPT_Wformat_y2k,
1050
               "-Wformat-y2k ignored without -Wformat");
1051
      warning (OPT_Wformat_extra_args,
1052
               "-Wformat-extra-args ignored without -Wformat");
1053
      warning (OPT_Wformat_zero_length,
1054
               "-Wformat-zero-length ignored without -Wformat");
1055
      warning (OPT_Wformat_nonliteral,
1056
               "-Wformat-nonliteral ignored without -Wformat");
1057
      warning (OPT_Wformat_security,
1058
               "-Wformat-security ignored without -Wformat");
1059
    }
1060
 
1061
  /* C99 requires special handling of complex multiplication and division;
1062
     -ffast-math and -fcx-limited-range are handled in process_options.  */
1063
  if (flag_isoc99)
1064
    flag_complex_method = 2;
1065
 
1066
  if (flag_preprocess_only)
1067
    {
1068
      /* Open the output now.  We must do so even if flag_no_output is
1069
         on, because there may be other output than from the actual
1070
         preprocessing (e.g. from -dM).  */
1071
      if (out_fname[0] == '\0')
1072
        out_stream = stdout;
1073
      else
1074
        out_stream = fopen (out_fname, "w");
1075
 
1076
      if (out_stream == NULL)
1077
        {
1078
          fatal_error ("opening output file %s: %m", out_fname);
1079
          return false;
1080
        }
1081
 
1082
      if (num_in_fnames > 1)
1083
        error ("too many filenames given.  Type %s --help for usage",
1084
               progname);
1085
 
1086
      init_pp_output (out_stream);
1087
    }
1088
  else
1089
    {
1090
      init_c_lex ();
1091
 
1092
      /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1093
      input_location = UNKNOWN_LOCATION;
1094
    }
1095
 
1096
  cb = cpp_get_callbacks (parse_in);
1097
  cb->file_change = cb_file_change;
1098
  cb->dir_change = cb_dir_change;
1099
  cpp_post_options (parse_in);
1100
 
1101
  input_location = UNKNOWN_LOCATION;
1102
 
1103
  /* If an error has occurred in cpplib, note it so we fail
1104
     immediately.  */
1105
  errorcount += cpp_errors (parse_in);
1106
 
1107
  *pfilename = this_input_filename
1108
    = cpp_read_main_file (parse_in, in_fnames[0]);
1109
  /* Don't do any compilation or preprocessing if there is no input file.  */
1110
  if (this_input_filename == NULL)
1111
    {
1112
      errorcount++;
1113
      return false;
1114
    }
1115
 
1116
  if (flag_working_directory
1117
      && flag_preprocess_only && !flag_no_line_commands)
1118
    pp_dir_change (parse_in, get_src_pwd ());
1119
 
1120
  return flag_preprocess_only;
1121
}
1122
 
1123
/* Front end initialization common to C, ObjC and C++.  */
1124
bool
1125
c_common_init (void)
1126
{
1127
  /* Set up preprocessor arithmetic.  Must be done after call to
1128
     c_common_nodes_and_builtins for type nodes to be good.  */
1129
  cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1130
  cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1131
  cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1132
  cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1133
  cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1134
  cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1135
 
1136
  /* This can't happen until after wchar_precision and bytes_big_endian
1137
     are known.  */
1138
  cpp_init_iconv (parse_in);
1139
 
1140
  if (version_flag)
1141
    c_common_print_pch_checksum (stderr);
1142
 
1143
  if (flag_preprocess_only)
1144
    {
1145
      finish_options ();
1146
      preprocess_file (parse_in);
1147
      return false;
1148
    }
1149
 
1150
  /* Has to wait until now so that cpplib has its hash table.  */
1151
  init_pragma ();
1152
 
1153
  return true;
1154
}
1155
 
1156
/* Initialize the integrated preprocessor after debug output has been
1157
   initialized; loop over each input file.  */
1158
void
1159
c_common_parse_file (int set_yydebug)
1160
{
1161
  unsigned int i;
1162
 
1163
  /* Enable parser debugging, if requested and we can.  If requested
1164
     and we can't, notify the user.  */
1165
#if YYDEBUG != 0
1166
  yydebug = set_yydebug;
1167
#else
1168
  if (set_yydebug)
1169
    warning (0, "YYDEBUG was not defined at build time, -dy ignored");
1170
#endif
1171
 
1172
  i = 0;
1173
  for (;;)
1174
    {
1175
      /* Start the main input file, if the debug writer wants it. */
1176
      if (debug_hooks->start_end_main_source_file)
1177
        (*debug_hooks->start_source_file) (0, this_input_filename);
1178
      finish_options ();
1179
      pch_init ();
1180
      push_file_scope ();
1181
      c_parse_file ();
1182
      finish_file ();
1183
      pop_file_scope ();
1184
      /* And end the main input file, if the debug writer wants it  */
1185
      if (debug_hooks->start_end_main_source_file)
1186
        (*debug_hooks->end_source_file) (0);
1187
      if (++i >= num_in_fnames)
1188
        break;
1189
      cpp_undef_all (parse_in);
1190
      this_input_filename
1191
        = cpp_read_main_file (parse_in, in_fnames[i]);
1192
      /* If an input file is missing, abandon further compilation.
1193
         cpplib has issued a diagnostic.  */
1194
      if (!this_input_filename)
1195
        break;
1196
    }
1197
}
1198
 
1199
/* Common finish hook for the C, ObjC and C++ front ends.  */
1200
void
1201
c_common_finish (void)
1202
{
1203
  FILE *deps_stream = NULL;
1204
 
1205
  if (cpp_opts->deps.style != DEPS_NONE)
1206
    {
1207
      /* If -M or -MM was seen without -MF, default output to the
1208
         output stream.  */
1209
      if (!deps_file)
1210
        deps_stream = out_stream;
1211
      else
1212
        {
1213
          deps_stream = fopen (deps_file, deps_append ? "a": "w");
1214
          if (!deps_stream)
1215
            fatal_error ("opening dependency file %s: %m", deps_file);
1216
        }
1217
    }
1218
 
1219
  /* For performance, avoid tearing down cpplib's internal structures
1220
     with cpp_destroy ().  */
1221
  errorcount += cpp_finish (parse_in, deps_stream);
1222
 
1223
  if (deps_stream && deps_stream != out_stream
1224
      && (ferror (deps_stream) || fclose (deps_stream)))
1225
    fatal_error ("closing dependency file %s: %m", deps_file);
1226
 
1227
  if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1228
    fatal_error ("when writing output to %s: %m", out_fname);
1229
}
1230
 
1231
/* Either of two environment variables can specify output of
1232
   dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1233
   DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1234
   and DEPS_TARGET is the target to mention in the deps.  They also
1235
   result in dependency information being appended to the output file
1236
   rather than overwriting it, and like Sun's compiler
1237
   SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1238
static void
1239
check_deps_environment_vars (void)
1240
{
1241
  char *spec;
1242
 
1243
  GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1244
  if (spec)
1245
    cpp_opts->deps.style = DEPS_USER;
1246
  else
1247
    {
1248
      GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1249
      if (spec)
1250
        {
1251
          cpp_opts->deps.style = DEPS_SYSTEM;
1252
          cpp_opts->deps.ignore_main_file = true;
1253
        }
1254
    }
1255
 
1256
  if (spec)
1257
    {
1258
      /* Find the space before the DEPS_TARGET, if there is one.  */
1259
      char *s = strchr (spec, ' ');
1260
      if (s)
1261
        {
1262
          /* Let the caller perform MAKE quoting.  */
1263
          defer_opt (OPT_MT, s + 1);
1264
          *s = '\0';
1265
        }
1266
 
1267
      /* Command line -MF overrides environment variables and default.  */
1268
      if (!deps_file)
1269
        deps_file = spec;
1270
 
1271
      deps_append = 1;
1272
      deps_seen = true;
1273
    }
1274
}
1275
 
1276
/* Handle deferred command line switches.  */
1277
static void
1278
handle_deferred_opts (void)
1279
{
1280
  size_t i;
1281
  struct deps *deps;
1282
 
1283
  /* Avoid allocating the deps buffer if we don't need it.
1284
     (This flag may be true without there having been -MT or -MQ
1285
     options, but we'll still need the deps buffer.)  */
1286
  if (!deps_seen)
1287
    return;
1288
 
1289
  deps = cpp_get_deps (parse_in);
1290
 
1291
  for (i = 0; i < deferred_count; i++)
1292
    {
1293
      struct deferred_opt *opt = &deferred_opts[i];
1294
 
1295
      if (opt->code == OPT_MT || opt->code == OPT_MQ)
1296
        deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1297
    }
1298
}
1299
 
1300
/* These settings are appropriate for GCC, but not necessarily so for
1301
   cpplib as a library.  */
1302
static void
1303
sanitize_cpp_opts (void)
1304
{
1305
  /* If we don't know what style of dependencies to output, complain
1306
     if any other dependency switches have been given.  */
1307
  if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1308
    error ("to generate dependencies you must specify either -M or -MM");
1309
 
1310
  /* -dM and dependencies suppress normal output; do it here so that
1311
     the last -d[MDN] switch overrides earlier ones.  */
1312
  if (flag_dump_macros == 'M')
1313
    flag_no_output = 1;
1314
 
1315
  /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1316
     -dM since at least glibc relies on -M -dM to work.  */
1317
  /* Also, flag_no_output implies flag_no_line_commands, always.  */
1318
  if (flag_no_output)
1319
    {
1320
      if (flag_dump_macros != 'M')
1321
        flag_dump_macros = 0;
1322
      flag_dump_includes = 0;
1323
      flag_no_line_commands = 1;
1324
    }
1325
 
1326
  cpp_opts->unsigned_char = !flag_signed_char;
1327
  cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1328
 
1329
  /* We want -Wno-long-long to override -pedantic -std=non-c99
1330
     and/or -Wtraditional, whatever the ordering.  */
1331
  cpp_opts->warn_long_long
1332
    = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1333
 
1334
  /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1335
     this also turns off warnings about GCCs extension.  */
1336
  cpp_opts->warn_variadic_macros
1337
    = warn_variadic_macros && (pedantic || warn_traditional);
1338
 
1339
  /* If we're generating preprocessor output, emit current directory
1340
     if explicitly requested or if debugging information is enabled.
1341
     ??? Maybe we should only do it for debugging formats that
1342
     actually output the current directory?  */
1343
  if (flag_working_directory == -1)
1344
    flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1345
}
1346
 
1347
/* Add include path with a prefix at the front of its name.  */
1348
static void
1349
add_prefixed_path (const char *suffix, size_t chain)
1350
{
1351
  char *path;
1352
  const char *prefix;
1353
  size_t prefix_len, suffix_len;
1354
 
1355
  suffix_len = strlen (suffix);
1356
  prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1357
  prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1358
 
1359
  path = (char *) xmalloc (prefix_len + suffix_len + 1);
1360
  memcpy (path, prefix, prefix_len);
1361
  memcpy (path + prefix_len, suffix, suffix_len);
1362
  path[prefix_len + suffix_len] = '\0';
1363
 
1364
  add_path (path, chain, 0, false);
1365
}
1366
 
1367
/* Handle -D, -U, -A, -imacros, and the first -include.  */
1368
static void
1369
finish_options (void)
1370
{
1371
  if (!cpp_opts->preprocessed)
1372
    {
1373
      size_t i;
1374
 
1375
      cb_file_change (parse_in,
1376
                      linemap_add (&line_table, LC_RENAME, 0,
1377
                                   _("<built-in>"), 0));
1378
 
1379
      cpp_init_builtins (parse_in, flag_hosted);
1380
      c_cpp_builtins (parse_in);
1381
 
1382
      /* We're about to send user input to cpplib, so make it warn for
1383
         things that we previously (when we sent it internal definitions)
1384
         told it to not warn.
1385
 
1386
         C99 permits implementation-defined characters in identifiers.
1387
         The documented meaning of -std= is to turn off extensions that
1388
         conflict with the specified standard, and since a strictly
1389
         conforming program cannot contain a '$', we do not condition
1390
         their acceptance on the -std= setting.  */
1391
      cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1392
 
1393
      cb_file_change (parse_in,
1394
                      linemap_add (&line_table, LC_RENAME, 0,
1395
                                   _("<command-line>"), 0));
1396
 
1397
      for (i = 0; i < deferred_count; i++)
1398
        {
1399
          struct deferred_opt *opt = &deferred_opts[i];
1400
 
1401
          if (opt->code == OPT_D)
1402
            cpp_define (parse_in, opt->arg);
1403
          else if (opt->code == OPT_U)
1404
            cpp_undef (parse_in, opt->arg);
1405
          else if (opt->code == OPT_A)
1406
            {
1407
              if (opt->arg[0] == '-')
1408
                cpp_unassert (parse_in, opt->arg + 1);
1409
              else
1410
                cpp_assert (parse_in, opt->arg);
1411
            }
1412
        }
1413
 
1414
      /* Handle -imacros after -D and -U.  */
1415
      for (i = 0; i < deferred_count; i++)
1416
        {
1417
          struct deferred_opt *opt = &deferred_opts[i];
1418
 
1419
          if (opt->code == OPT_imacros
1420
              && cpp_push_include (parse_in, opt->arg))
1421
            {
1422
              /* Disable push_command_line_include callback for now.  */
1423
              include_cursor = deferred_count + 1;
1424
              cpp_scan_nooutput (parse_in);
1425
            }
1426
        }
1427
    }
1428
 
1429
  include_cursor = 0;
1430
  push_command_line_include ();
1431
}
1432
 
1433
/* Give CPP the next file given by -include, if any.  */
1434
static void
1435
push_command_line_include (void)
1436
{
1437
  while (include_cursor < deferred_count)
1438
    {
1439
      struct deferred_opt *opt = &deferred_opts[include_cursor++];
1440
 
1441
      if (!cpp_opts->preprocessed && opt->code == OPT_include
1442
          && cpp_push_include (parse_in, opt->arg))
1443
        return;
1444
    }
1445
 
1446
  if (include_cursor == deferred_count)
1447
    {
1448
      include_cursor++;
1449
      /* -Wunused-macros should only warn about macros defined hereafter.  */
1450
      cpp_opts->warn_unused_macros = warn_unused_macros;
1451
      /* Restore the line map from <command line>.  */
1452
      if (!cpp_opts->preprocessed)
1453
        cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1454
 
1455
      /* Set this here so the client can change the option if it wishes,
1456
         and after stacking the main file so we don't trace the main file.  */
1457
      line_table.trace_includes = cpp_opts->print_include_names;
1458
    }
1459
}
1460
 
1461
/* File change callback.  Has to handle -include files.  */
1462
static void
1463
cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1464
                const struct line_map *new_map)
1465
{
1466
  if (flag_preprocess_only)
1467
    pp_file_change (new_map);
1468
  else
1469
    fe_file_change (new_map);
1470
 
1471
  if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1472
    push_command_line_include ();
1473
}
1474
 
1475
void
1476
cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1477
{
1478
  if (!set_src_pwd (dir))
1479
    warning (0, "too late for # directive to set debug directory");
1480
}
1481
 
1482
/* Set the C 89 standard (with 1994 amendments if C94, without GNU
1483
   extensions if ISO).  There is no concept of gnu94.  */
1484
static void
1485
set_std_c89 (int c94, int iso)
1486
{
1487
  cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1488
  flag_iso = iso;
1489
  flag_no_asm = iso;
1490
  flag_no_gnu_keywords = iso;
1491
  flag_no_nonansi_builtin = iso;
1492
  flag_isoc94 = c94;
1493
  flag_isoc99 = 0;
1494
}
1495
 
1496
/* Set the C 99 standard (without GNU extensions if ISO).  */
1497
static void
1498
set_std_c99 (int iso)
1499
{
1500
  cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1501
  flag_no_asm = iso;
1502
  flag_no_nonansi_builtin = iso;
1503
  flag_iso = iso;
1504
  flag_isoc99 = 1;
1505
  flag_isoc94 = 1;
1506
}
1507
 
1508
/* Set the C++ 98 standard (without GNU extensions if ISO).  */
1509
static void
1510
set_std_cxx98 (int iso)
1511
{
1512
  cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1513
  flag_no_gnu_keywords = iso;
1514
  flag_no_nonansi_builtin = iso;
1515
  flag_iso = iso;
1516
}
1517
 
1518
/* Handle setting implicit to ON.  */
1519
static void
1520
set_Wimplicit (int on)
1521
{
1522
  warn_implicit = on;
1523
  warn_implicit_int = on;
1524
  if (on)
1525
    {
1526
      if (mesg_implicit_function_declaration != 2)
1527
        mesg_implicit_function_declaration = 1;
1528
    }
1529
  else
1530
    mesg_implicit_function_declaration = 0;
1531
}
1532
 
1533
/* Args to -d specify what to dump.  Silently ignore
1534
   unrecognized options; they may be aimed at toplev.c.  */
1535
static void
1536
handle_OPT_d (const char *arg)
1537
{
1538
  char c;
1539
 
1540
  while ((c = *arg++) != '\0')
1541
    switch (c)
1542
      {
1543
      case 'M':                 /* Dump macros only.  */
1544
      case 'N':                 /* Dump names.  */
1545
      case 'D':                 /* Dump definitions.  */
1546
        flag_dump_macros = c;
1547
        break;
1548
 
1549
      case 'I':
1550
        flag_dump_includes = 1;
1551
        break;
1552
      }
1553
}

powered by: WebSVN 2.1.0

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