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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [gcc/] [c-opts.c] - Blame information for rev 16

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

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

powered by: WebSVN 2.1.0

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