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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [c-opts.c] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* C/ObjC/C++ command line option handling.
2
   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 "incpath.h"
37
#include "debug.h"              /* For debug_hooks.  */
38
#include "opts.h"
39
#include "options.h"
40
#include "mkdeps.h"
41
#include "target.h"
42
#include "tm_p.h"
43
#include "c-tree.h"             /* For c_cpp_error.  */
44
 
45
#ifndef DOLLARS_IN_IDENTIFIERS
46
# define DOLLARS_IN_IDENTIFIERS true
47
#endif
48
 
49
#ifndef TARGET_SYSTEM_ROOT
50
# define TARGET_SYSTEM_ROOT NULL
51
#endif
52
 
53
#ifndef TARGET_OPTF
54
#define TARGET_OPTF(ARG)
55
#endif
56
 
57
/* CPP's options.  */
58
cpp_options *cpp_opts;
59
 
60
/* Input filename.  */
61
static const char *this_input_filename;
62
 
63
/* Filename and stream for preprocessed output.  */
64
static const char *out_fname;
65
static FILE *out_stream;
66
 
67
/* Append dependencies to deps_file.  */
68
static bool deps_append;
69
 
70
/* If dependency switches (-MF etc.) have been given.  */
71
static bool deps_seen;
72
 
73
/* If -v seen.  */
74
static bool verbose;
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_cxx0x (int);
113
static void set_std_c89 (int, int);
114
static void set_std_c99 (int);
115
static void check_deps_environment_vars (void);
116
static void handle_deferred_opts (void);
117
static void sanitize_cpp_opts (void);
118
static void add_prefixed_path (const char *, size_t);
119
static void push_command_line_include (void);
120
static void cb_file_change (cpp_reader *, const struct line_map *);
121
static void cb_dir_change (cpp_reader *, const char *);
122
static void finish_options (void);
123
 
124
#ifndef STDC_0_IN_SYSTEM_HEADERS
125
#define STDC_0_IN_SYSTEM_HEADERS 0
126
#endif
127
 
128
/* Holds switches parsed by c_common_handle_option (), but whose
129
   handling is deferred to c_common_post_options ().  */
130
static void defer_opt (enum opt_code, const char *);
131
static struct deferred_opt
132
{
133
  enum opt_code code;
134
  const char *arg;
135
} *deferred_opts;
136
 
137
/* Complain that switch CODE expects an argument but none was
138
   provided.  OPT was the command-line option.  Return FALSE to get
139
   the default message in opts.c, TRUE if we provide a specialized
140
   one.  */
141
bool
142
c_common_missing_argument (const char *opt, size_t code)
143
{
144
  switch (code)
145
    {
146
    default:
147
      /* Pick up the default message.  */
148
      return false;
149
 
150
    case OPT_fconstant_string_class_:
151
      error ("no class name specified with %qs", opt);
152
      break;
153
 
154
    case OPT_A:
155
      error ("assertion missing after %qs", opt);
156
      break;
157
 
158
    case OPT_D:
159
    case OPT_U:
160
      error ("macro name missing after %qs", opt);
161
      break;
162
 
163
    case OPT_F:
164
    case OPT_I:
165
    case OPT_idirafter:
166
    case OPT_isysroot:
167
    case OPT_isystem:
168
    case OPT_iquote:
169
      error ("missing path after %qs", opt);
170
      break;
171
 
172
    case OPT_MF:
173
    case OPT_MD:
174
    case OPT_MMD:
175
    case OPT_include:
176
    case OPT_imacros:
177
    case OPT_o:
178
      error ("missing filename after %qs", opt);
179
      break;
180
 
181
    case OPT_MQ:
182
    case OPT_MT:
183
      error ("missing makefile target after %qs", opt);
184
      break;
185
    }
186
 
187
  return true;
188
}
189
 
190
/* Defer option CODE with argument ARG.  */
191
static void
192
defer_opt (enum opt_code code, const char *arg)
193
{
194
  deferred_opts[deferred_count].code = code;
195
  deferred_opts[deferred_count].arg = arg;
196
  deferred_count++;
197
}
198
 
199
/* Common initialization before parsing options.  */
200
unsigned int
201
c_common_init_options (unsigned int argc, const char **argv)
202
{
203
  static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
204
  unsigned int i, result;
205
  struct cpp_callbacks *cb;
206
 
207
  /* This is conditionalized only because that is the way the front
208
     ends used to do it.  Maybe this should be unconditional?  */
209
  if (c_dialect_cxx ())
210
    {
211
      /* By default wrap lines at 80 characters.  Is getenv
212
         ("COLUMNS") preferable?  */
213
      diagnostic_line_cutoff (global_dc) = 80;
214
      /* By default, emit location information once for every
215
         diagnostic message.  */
216
      diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
217
    }
218
 
219
  parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
220
                                ident_hash, line_table);
221
  cb = cpp_get_callbacks (parse_in);
222
  cb->error = c_cpp_error;
223
 
224
  cpp_opts = cpp_get_options (parse_in);
225
  cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
226
  cpp_opts->objc = c_dialect_objc ();
227
 
228
  /* Reset to avoid warnings on internal definitions.  We set it just
229
     before passing on command-line options to cpplib.  */
230
  cpp_opts->warn_dollars = 0;
231
 
232
  flag_exceptions = c_dialect_cxx ();
233
  warn_pointer_arith = c_dialect_cxx ();
234
  warn_write_strings = c_dialect_cxx();
235
  flag_warn_unused_result = true;
236
 
237
  /* By default, C99-like requirements for complex multiply and divide.  */
238
  flag_complex_method = 2;
239
 
240
  deferred_opts = XNEWVEC (struct deferred_opt, argc);
241
 
242
  result = lang_flags[c_language];
243
 
244
  if (c_language == clk_c)
245
    {
246
      /* If preprocessing assembly language, accept any of the C-family
247
         front end options since the driver may pass them through.  */
248
      for (i = 1; i < argc; i++)
249
        if (! strcmp (argv[i], "-lang-asm"))
250
          {
251
            result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;
252
            break;
253
          }
254
    }
255
 
256
  return result;
257
}
258
 
259
/* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
260
   form of an -f or -W option was given.  Returns 0 if the switch was
261
   invalid, a negative number to prevent language-independent
262
   processing in toplev.c (a hack necessary for the short-term).  */
263
int
264
c_common_handle_option (size_t scode, const char *arg, int value)
265
{
266
  const struct cl_option *option = &cl_options[scode];
267
  enum opt_code code = (enum opt_code) scode;
268
  int result = 1;
269
 
270
  /* Prevent resetting the language standard to a C dialect when the driver
271
     has already determined that we're looking at assembler input.  */
272
  bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM);
273
 
274
  switch (code)
275
    {
276
    default:
277
      if (cl_options[code].flags & (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX))
278
        {
279
          if ((option->flags & CL_TARGET)
280
              && ! targetcm.handle_c_option (scode, arg, value))
281
            result = 0;
282
          break;
283
        }
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 (input_location, "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
      break;
342
 
343
    case OPT_MD:
344
    case OPT_MMD:
345
      cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
346
      cpp_opts->deps.need_preprocessor_output = true;
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
      warn_unused = 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
      warn_switch = value;
393
      if (warn_strict_aliasing == -1)
394
        set_Wstrict_aliasing (value);
395
      warn_address = value;
396
      if (warn_strict_overflow == -1)
397
        warn_strict_overflow = value;
398
      warn_array_bounds = value;
399
      warn_volatile_register_var = value;
400
 
401
      /* Only warn about unknown pragmas that are not in system
402
         headers.  */
403
      warn_unknown_pragmas = value;
404
 
405
      warn_uninitialized = value;
406
 
407
      if (!c_dialect_cxx ())
408
        {
409
          /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
410
             can turn it off only if it's not explicit.  */
411
          if (warn_main == -1)
412
            warn_main = (value ? 2 : 0);
413
 
414
          /* In C, -Wall turns on -Wenum-compare, which we do here.
415
             In C++ it is on by default, which is done in
416
             c_common_post_options.  */
417
          if (warn_enum_compare == -1)
418
            warn_enum_compare = value;
419
        }
420
      else
421
        {
422
          /* C++-specific warnings.  */
423
          warn_sign_compare = value;
424
          warn_reorder = value;
425
          warn_cxx0x_compat = value;
426
        }
427
 
428
      cpp_opts->warn_trigraphs = value;
429
      cpp_opts->warn_comments = value;
430
      cpp_opts->warn_num_sign_change = value;
431
 
432
      if (warn_pointer_sign == -1)
433
        warn_pointer_sign = value;
434
      break;
435
 
436
    case OPT_Wbuiltin_macro_redefined:
437
      cpp_opts->warn_builtin_macro_redefined = value;
438
      break;
439
 
440
    case OPT_Wcomment:
441
    case OPT_Wcomments:
442
      cpp_opts->warn_comments = value;
443
      break;
444
 
445
    case OPT_Wc___compat:
446
      /* Because -Wenum-compare is the default in C++, -Wc++-compat
447
         implies -Wenum-compare.  */
448
      if (warn_enum_compare == -1 && value)
449
        warn_enum_compare = value;
450
      /* Because C++ always warns about a goto which misses an
451
         initialization, -Wc++-compat turns on -Wjump-misses-init.  */
452
      if (warn_jump_misses_init == -1 && value)
453
        warn_jump_misses_init = value;
454
      cpp_opts->warn_cxx_operator_names = value;
455
      break;
456
 
457
    case OPT_Wdeprecated:
458
      cpp_opts->warn_deprecated = value;
459
      break;
460
 
461
    case OPT_Wendif_labels:
462
      cpp_opts->warn_endif_labels = value;
463
      break;
464
 
465
    case OPT_Werror:
466
      global_dc->warning_as_error_requested = value;
467
      break;
468
 
469
    case OPT_Werror_implicit_function_declaration:
470
      /* For backward compatibility, this is the same as
471
         -Werror=implicit-function-declaration.  */
472
      enable_warning_as_error ("implicit-function-declaration", value, CL_C | CL_ObjC);
473
      break;
474
 
475
    case OPT_Wformat:
476
      set_Wformat (value);
477
      break;
478
 
479
    case OPT_Wformat_:
480
      set_Wformat (atoi (arg));
481
      break;
482
 
483
    case OPT_Wimplicit:
484
      set_Wimplicit (value);
485
      break;
486
 
487
    case OPT_Wimport:
488
      /* Silently ignore for now.  */
489
      break;
490
 
491
    case OPT_Winvalid_pch:
492
      cpp_opts->warn_invalid_pch = value;
493
      break;
494
 
495
    case OPT_Wmissing_include_dirs:
496
      cpp_opts->warn_missing_include_dirs = value;
497
      break;
498
 
499
    case OPT_Wmultichar:
500
      cpp_opts->warn_multichar = value;
501
      break;
502
 
503
    case OPT_Wnormalized_:
504
      if (!value || (arg && strcasecmp (arg, "none") == 0))
505
        cpp_opts->warn_normalize = normalized_none;
506
      else if (!arg || strcasecmp (arg, "nfkc") == 0)
507
        cpp_opts->warn_normalize = normalized_KC;
508
      else if (strcasecmp (arg, "id") == 0)
509
        cpp_opts->warn_normalize = normalized_identifier_C;
510
      else if (strcasecmp (arg, "nfc") == 0)
511
        cpp_opts->warn_normalize = normalized_C;
512
      else
513
        error ("argument %qs to %<-Wnormalized%> not recognized", arg);
514
      break;
515
 
516
    case OPT_Wreturn_type:
517
      warn_return_type = value;
518
      break;
519
 
520
    case OPT_Wstrict_null_sentinel:
521
      warn_strict_null_sentinel = value;
522
      break;
523
 
524
    case OPT_Wtraditional:
525
      cpp_opts->warn_traditional = value;
526
      break;
527
 
528
    case OPT_Wtrigraphs:
529
      cpp_opts->warn_trigraphs = value;
530
      break;
531
 
532
    case OPT_Wundef:
533
      cpp_opts->warn_undef = value;
534
      break;
535
 
536
    case OPT_Wunknown_pragmas:
537
      /* Set to greater than 1, so that even unknown pragmas in
538
         system headers will be warned about.  */
539
      warn_unknown_pragmas = value * 2;
540
      break;
541
 
542
    case OPT_Wunused_macros:
543
      warn_unused_macros = value;
544
      break;
545
 
546
    case OPT_Wvariadic_macros:
547
      warn_variadic_macros = value;
548
      break;
549
 
550
    case OPT_Wwrite_strings:
551
      warn_write_strings = value;
552
      break;
553
 
554
    case OPT_Weffc__:
555
      warn_ecpp = value;
556
      if (value)
557
        warn_nonvdtor = true;
558
      break;
559
 
560
    case OPT_ansi:
561
      if (!c_dialect_cxx ())
562
        set_std_c89 (false, true);
563
      else
564
        set_std_cxx98 (true);
565
      break;
566
 
567
    case OPT_d:
568
      handle_OPT_d (arg);
569
      break;
570
 
571
    case OPT_fcond_mismatch:
572
      if (!c_dialect_cxx ())
573
        {
574
          flag_cond_mismatch = value;
575
          break;
576
        }
577
      /* Fall through.  */
578
 
579
    case OPT_fall_virtual:
580
    case OPT_falt_external_templates:
581
    case OPT_fenum_int_equiv:
582
    case OPT_fexternal_templates:
583
    case OPT_fguiding_decls:
584
    case OPT_fhonor_std:
585
    case OPT_fhuge_objects:
586
    case OPT_flabels_ok:
587
    case OPT_fname_mangling_version_:
588
    case OPT_fnew_abi:
589
    case OPT_fnonnull_objects:
590
    case OPT_fsquangle:
591
    case OPT_fstrict_prototype:
592
    case OPT_fthis_is_variable:
593
    case OPT_fvtable_thunks:
594
    case OPT_fxref:
595
    case OPT_fvtable_gc:
596
      warning (0, "switch %qs is no longer supported", option->opt_text);
597
      break;
598
 
599
    case OPT_faccess_control:
600
      flag_access_control = value;
601
      break;
602
 
603
    case OPT_fasm:
604
      flag_no_asm = !value;
605
      break;
606
 
607
    case OPT_fbuiltin:
608
      flag_no_builtin = !value;
609
      break;
610
 
611
    case OPT_fbuiltin_:
612
      if (value)
613
        result = 0;
614
      else
615
        disable_builtin_function (arg);
616
      break;
617
 
618
    case OPT_fdirectives_only:
619
      cpp_opts->directives_only = value;
620
      break;
621
 
622
    case OPT_fdollars_in_identifiers:
623
      cpp_opts->dollars_in_ident = value;
624
      break;
625
 
626
    case OPT_ffreestanding:
627
      value = !value;
628
      /* Fall through....  */
629
    case OPT_fhosted:
630
      flag_hosted = value;
631
      flag_no_builtin = !value;
632
      break;
633
 
634
    case OPT_fshort_double:
635
      flag_short_double = value;
636
      break;
637
 
638
    case OPT_fshort_enums:
639
      flag_short_enums = value;
640
      break;
641
 
642
    case OPT_fshort_wchar:
643
      flag_short_wchar = value;
644
      break;
645
 
646
    case OPT_fsigned_bitfields:
647
      flag_signed_bitfields = value;
648
      break;
649
 
650
    case OPT_fsigned_char:
651
      flag_signed_char = value;
652
      break;
653
 
654
    case OPT_funsigned_bitfields:
655
      flag_signed_bitfields = !value;
656
      break;
657
 
658
    case OPT_funsigned_char:
659
      flag_signed_char = !value;
660
      break;
661
 
662
    case OPT_fcheck_new:
663
      flag_check_new = value;
664
      break;
665
 
666
    case OPT_fconserve_space:
667
      flag_conserve_space = value;
668
      break;
669
 
670
    case OPT_fconstant_string_class_:
671
      constant_string_class_name = arg;
672
      break;
673
 
674
    case OPT_fdefault_inline:
675
      flag_default_inline = value;
676
      break;
677
 
678
    case OPT_felide_constructors:
679
      flag_elide_constructors = value;
680
      break;
681
 
682
    case OPT_fenforce_eh_specs:
683
      flag_enforce_eh_specs = value;
684
      break;
685
 
686
    case OPT_fextended_identifiers:
687
      cpp_opts->extended_identifiers = value;
688
      break;
689
 
690
    case OPT_ffor_scope:
691
      flag_new_for_scope = value;
692
      break;
693
 
694
    case OPT_fgnu_keywords:
695
      flag_no_gnu_keywords = !value;
696
      break;
697
 
698
    case OPT_fgnu_runtime:
699
      flag_next_runtime = !value;
700
      break;
701
 
702
    case OPT_fhandle_exceptions:
703
      warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
704
      flag_exceptions = value;
705
      break;
706
 
707
    case OPT_fimplement_inlines:
708
      flag_implement_inlines = value;
709
      break;
710
 
711
    case OPT_fimplicit_inline_templates:
712
      flag_implicit_inline_templates = value;
713
      break;
714
 
715
    case OPT_fimplicit_templates:
716
      flag_implicit_templates = value;
717
      break;
718
 
719
    case OPT_flax_vector_conversions:
720
      flag_lax_vector_conversions = value;
721
      break;
722
 
723
    case OPT_fms_extensions:
724
      flag_ms_extensions = value;
725
      break;
726
 
727
    case OPT_fnext_runtime:
728
      flag_next_runtime = value;
729
      break;
730
 
731
    case OPT_fnil_receivers:
732
      flag_nil_receivers = value;
733
      break;
734
 
735
    case OPT_fnonansi_builtins:
736
      flag_no_nonansi_builtin = !value;
737
      break;
738
 
739
    case OPT_foperator_names:
740
      cpp_opts->operator_names = value;
741
      break;
742
 
743
    case OPT_foptional_diags:
744
      flag_optional_diags = value;
745
      break;
746
 
747
    case OPT_fpch_deps:
748
      cpp_opts->restore_pch_deps = value;
749
      break;
750
 
751
    case OPT_fpch_preprocess:
752
      flag_pch_preprocess = value;
753
      break;
754
 
755
    case OPT_fpermissive:
756
      flag_permissive = value;
757
      break;
758
 
759
    case OPT_fpreprocessed:
760
      cpp_opts->preprocessed = value;
761
      break;
762
 
763
    case OPT_freplace_objc_classes:
764
      flag_replace_objc_classes = value;
765
      break;
766
 
767
    case OPT_frepo:
768
      flag_use_repository = value;
769
      if (value)
770
        flag_implicit_templates = 0;
771
      break;
772
 
773
    case OPT_frtti:
774
      flag_rtti = value;
775
      break;
776
 
777
    case OPT_fshow_column:
778
      cpp_opts->show_column = value;
779
      break;
780
 
781
    case OPT_fstats:
782
      flag_detailed_statistics = value;
783
      break;
784
 
785
    case OPT_ftabstop_:
786
      /* It is documented that we silently ignore silly values.  */
787
      if (value >= 1 && value <= 100)
788
        cpp_opts->tabstop = value;
789
      break;
790
 
791
    case OPT_fexec_charset_:
792
      cpp_opts->narrow_charset = arg;
793
      break;
794
 
795
    case OPT_fwide_exec_charset_:
796
      cpp_opts->wide_charset = arg;
797
      break;
798
 
799
    case OPT_finput_charset_:
800
      cpp_opts->input_charset = arg;
801
      break;
802
 
803
    case OPT_ftemplate_depth_:
804
      /* Kept for backwards compatibility.  */
805
    case OPT_ftemplate_depth_eq:
806
      max_tinst_depth = value;
807
      break;
808
 
809
    case OPT_fuse_cxa_atexit:
810
      flag_use_cxa_atexit = value;
811
      break;
812
 
813
    case OPT_fuse_cxa_get_exception_ptr:
814
      flag_use_cxa_get_exception_ptr = value;
815
      break;
816
 
817
    case OPT_fvisibility_inlines_hidden:
818
      visibility_options.inlines_hidden = value;
819
      break;
820
 
821
    case OPT_fweak:
822
      flag_weak = value;
823
      break;
824
 
825
    case OPT_fthreadsafe_statics:
826
      flag_threadsafe_statics = value;
827
      break;
828
 
829
    case OPT_fpretty_templates:
830
      flag_pretty_templates = value;
831
      break;
832
 
833
    case OPT_fzero_link:
834
      flag_zero_link = value;
835
      break;
836
 
837
    case OPT_gen_decls:
838
      flag_gen_declaration = 1;
839
      break;
840
 
841
    case OPT_femit_struct_debug_baseonly:
842
      set_struct_debug_option ("base");
843
      break;
844
 
845
    case OPT_femit_struct_debug_reduced:
846
      set_struct_debug_option ("dir:ord:sys,dir:gen:any,ind:base");
847
      break;
848
 
849
    case OPT_femit_struct_debug_detailed_:
850
      set_struct_debug_option (arg);
851
      break;
852
 
853
    case OPT_idirafter:
854
      add_path (xstrdup (arg), AFTER, 0, true);
855
      break;
856
 
857
    case OPT_imacros:
858
    case OPT_include:
859
      defer_opt (code, arg);
860
      break;
861
 
862
    case OPT_imultilib:
863
      imultilib = arg;
864
      break;
865
 
866
    case OPT_iprefix:
867
      iprefix = arg;
868
      break;
869
 
870
    case OPT_iquote:
871
      add_path (xstrdup (arg), QUOTE, 0, true);
872
      break;
873
 
874
    case OPT_isysroot:
875
      sysroot = arg;
876
      break;
877
 
878
    case OPT_isystem:
879
      add_path (xstrdup (arg), SYSTEM, 0, true);
880
      break;
881
 
882
    case OPT_iwithprefix:
883
      add_prefixed_path (arg, SYSTEM);
884
      break;
885
 
886
    case OPT_iwithprefixbefore:
887
      add_prefixed_path (arg, BRACKET);
888
      break;
889
 
890
    case OPT_lang_asm:
891
      cpp_set_lang (parse_in, CLK_ASM);
892
      cpp_opts->dollars_in_ident = false;
893
      break;
894
 
895
    case OPT_lang_objc:
896
      cpp_opts->objc = 1;
897
      break;
898
 
899
    case OPT_nostdinc:
900
      std_inc = false;
901
      break;
902
 
903
    case OPT_nostdinc__:
904
      std_cxx_inc = false;
905
      break;
906
 
907
    case OPT_o:
908
      if (!out_fname)
909
        out_fname = arg;
910
      else
911
        error ("output filename specified twice");
912
      break;
913
 
914
      /* We need to handle the -pedantic switches here, rather than in
915
         c_common_post_options, so that a subsequent -Wno-endif-labels
916
         is not overridden.  */
917
    case OPT_pedantic_errors:
918
    case OPT_pedantic:
919
      cpp_opts->pedantic = 1;
920
      cpp_opts->warn_endif_labels = 1;
921
      if (warn_pointer_sign == -1)
922
        warn_pointer_sign = 1;
923
      if (warn_overlength_strings == -1)
924
        warn_overlength_strings = 1;
925
      if (warn_main == -1)
926
        warn_main = 2;
927
      break;
928
 
929
    case OPT_print_objc_runtime_info:
930
      print_struct_values = 1;
931
      break;
932
 
933
    case OPT_print_pch_checksum:
934
      c_common_print_pch_checksum (stdout);
935
      exit_after_options = true;
936
      break;
937
 
938
    case OPT_remap:
939
      cpp_opts->remap = 1;
940
      break;
941
 
942
    case OPT_std_c__98:
943
    case OPT_std_gnu__98:
944
      if (!preprocessing_asm_p)
945
        set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
946
      break;
947
 
948
    case OPT_std_c__0x:
949
    case OPT_std_gnu__0x:
950
      if (!preprocessing_asm_p)
951
        set_std_cxx0x (code == OPT_std_c__0x /* ISO */);
952
      break;
953
 
954
    case OPT_std_c89:
955
    case OPT_std_c90:
956
    case OPT_std_iso9899_1990:
957
    case OPT_std_iso9899_199409:
958
      if (!preprocessing_asm_p)
959
        set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
960
      break;
961
 
962
    case OPT_std_gnu89:
963
    case OPT_std_gnu90:
964
      if (!preprocessing_asm_p)
965
        set_std_c89 (false /* c94 */, false /* ISO */);
966
      break;
967
 
968
    case OPT_std_c99:
969
    case OPT_std_c9x:
970
    case OPT_std_iso9899_1999:
971
    case OPT_std_iso9899_199x:
972
      if (!preprocessing_asm_p)
973
        set_std_c99 (true /* ISO */);
974
      break;
975
 
976
    case OPT_std_gnu99:
977
    case OPT_std_gnu9x:
978
      if (!preprocessing_asm_p)
979
        set_std_c99 (false /* ISO */);
980
      break;
981
 
982
    case OPT_trigraphs:
983
      cpp_opts->trigraphs = 1;
984
      break;
985
 
986
    case OPT_traditional_cpp:
987
      cpp_opts->traditional = 1;
988
      break;
989
 
990
    case OPT_undef:
991
      flag_undef = 1;
992
      break;
993
 
994
    case OPT_v:
995
      verbose = true;
996
      break;
997
 
998
    case OPT_Wabi:
999
      warn_psabi = value;
1000
      break;
1001
    }
1002
 
1003
  return result;
1004
}
1005
 
1006
/* Post-switch processing.  */
1007
bool
1008
c_common_post_options (const char **pfilename)
1009
{
1010
  struct cpp_callbacks *cb;
1011
 
1012
  /* Canonicalize the input and output filenames.  */
1013
  if (in_fnames == NULL)
1014
    {
1015
      in_fnames = XNEWVEC (const char *, 1);
1016
      in_fnames[0] = "";
1017
    }
1018
  else if (strcmp (in_fnames[0], "-") == 0)
1019
    in_fnames[0] = "";
1020
 
1021
  if (out_fname == NULL || !strcmp (out_fname, "-"))
1022
    out_fname = "";
1023
 
1024
  if (cpp_opts->deps.style == DEPS_NONE)
1025
    check_deps_environment_vars ();
1026
 
1027
  handle_deferred_opts ();
1028
 
1029
  sanitize_cpp_opts ();
1030
 
1031
  register_include_chains (parse_in, sysroot, iprefix, imultilib,
1032
                           std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
1033
 
1034
#ifdef C_COMMON_OVERRIDE_OPTIONS
1035
  /* Some machines may reject certain combinations of C
1036
     language-specific options.  */
1037
  C_COMMON_OVERRIDE_OPTIONS;
1038
#endif
1039
 
1040
  /* Excess precision other than "fast" requires front-end
1041
     support.  */
1042
  if (c_dialect_cxx ())
1043
    {
1044
      if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
1045
          && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
1046
        sorry ("-fexcess-precision=standard for C++");
1047
      flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1048
    }
1049
  else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT)
1050
    flag_excess_precision_cmdline = (flag_iso
1051
                                     ? EXCESS_PRECISION_STANDARD
1052
                                     : EXCESS_PRECISION_FAST);
1053
 
1054
  /* By default we use C99 inline semantics in GNU99 or C99 mode.  C99
1055
     inline semantics are not supported in GNU89 or C89 mode.  */
1056
  if (flag_gnu89_inline == -1)
1057
    flag_gnu89_inline = !flag_isoc99;
1058
  else if (!flag_gnu89_inline && !flag_isoc99)
1059
    error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode");
1060
 
1061
  /* Default to ObjC sjlj exception handling if NeXT runtime.  */
1062
  if (flag_objc_sjlj_exceptions < 0)
1063
    flag_objc_sjlj_exceptions = flag_next_runtime;
1064
  if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
1065
    flag_exceptions = 1;
1066
 
1067
  /* -Wextra implies the following flags
1068
     unless explicitly overridden.  */
1069
  if (warn_type_limits == -1)
1070
    warn_type_limits = extra_warnings;
1071
  if (warn_clobbered == -1)
1072
    warn_clobbered = extra_warnings;
1073
  if (warn_empty_body == -1)
1074
    warn_empty_body = extra_warnings;
1075
  if (warn_sign_compare == -1)
1076
    warn_sign_compare = extra_warnings;
1077
  if (warn_missing_field_initializers == -1)
1078
    warn_missing_field_initializers = extra_warnings;
1079
  if (warn_missing_parameter_type == -1)
1080
    warn_missing_parameter_type = extra_warnings;
1081
  if (warn_old_style_declaration == -1)
1082
    warn_old_style_declaration = extra_warnings;
1083
  if (warn_override_init == -1)
1084
    warn_override_init = extra_warnings;
1085
  if (warn_ignored_qualifiers == -1)
1086
    warn_ignored_qualifiers = extra_warnings;
1087
 
1088
  /* -Wpointer-sign is disabled by default, but it is enabled if any
1089
     of -Wall or -pedantic are given.  */
1090
  if (warn_pointer_sign == -1)
1091
    warn_pointer_sign = 0;
1092
 
1093
  if (warn_strict_aliasing == -1)
1094
    warn_strict_aliasing = 0;
1095
  if (warn_strict_overflow == -1)
1096
    warn_strict_overflow = 0;
1097
  if (warn_jump_misses_init == -1)
1098
    warn_jump_misses_init = 0;
1099
 
1100
  /* -Woverlength-strings is off by default, but is enabled by -pedantic.
1101
     It is never enabled in C++, as the minimum limit is not normative
1102
     in that standard.  */
1103
  if (warn_overlength_strings == -1 || c_dialect_cxx ())
1104
    warn_overlength_strings = 0;
1105
 
1106
  /* Wmain is enabled by default in C++ but not in C.  */
1107
  /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
1108
     even if -Wall was given (warn_main will be 2 if set by -Wall, 1
1109
     if set by -Wmain).  */
1110
  if (warn_main == -1)
1111
    warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
1112
  else if (warn_main == 2)
1113
    warn_main = flag_hosted ? 1 : 0;
1114
 
1115
  /* In C, -Wconversion enables -Wsign-conversion (unless disabled
1116
     through -Wno-sign-conversion). While in C++,
1117
     -Wsign-conversion needs to be requested explicitly.  */
1118
  if (warn_sign_conversion == -1)
1119
    warn_sign_conversion =  (c_dialect_cxx ()) ? 0 : warn_conversion;
1120
 
1121
  /* In C, -Wall and -Wc++-compat enable -Wenum-compare, which we do
1122
     in c_common_handle_option; if it has not yet been set, it is
1123
     disabled by default.  In C++, it is enabled by default.  */
1124
  if (warn_enum_compare == -1)
1125
    warn_enum_compare = c_dialect_cxx () ? 1 : 0;
1126
 
1127
  /* -Wpacked-bitfield-compat is on by default for the C languages.  The
1128
     warning is issued in stor-layout.c which is not part of the front-end so
1129
     we need to selectively turn it on here.  */
1130
  if (warn_packed_bitfield_compat == -1)
1131
    warn_packed_bitfield_compat = 1;
1132
 
1133
  /* Special format checking options don't work without -Wformat; warn if
1134
     they are used.  */
1135
  if (!warn_format)
1136
    {
1137
      warning (OPT_Wformat_y2k,
1138
               "-Wformat-y2k ignored without -Wformat");
1139
      warning (OPT_Wformat_extra_args,
1140
               "-Wformat-extra-args ignored without -Wformat");
1141
      warning (OPT_Wformat_zero_length,
1142
               "-Wformat-zero-length ignored without -Wformat");
1143
      warning (OPT_Wformat_nonliteral,
1144
               "-Wformat-nonliteral ignored without -Wformat");
1145
      warning (OPT_Wformat_contains_nul,
1146
               "-Wformat-contains-nul ignored without -Wformat");
1147
      warning (OPT_Wformat_security,
1148
               "-Wformat-security ignored without -Wformat");
1149
    }
1150
 
1151
  /* -Wimplicit-function-declaration is enabled by default for C99.  */
1152
  if (warn_implicit_function_declaration == -1)
1153
    warn_implicit_function_declaration = flag_isoc99;
1154
 
1155
  /* If we're allowing C++0x constructs, don't warn about C++0x
1156
     compatibility problems.  */
1157
  if (cxx_dialect == cxx0x)
1158
    warn_cxx0x_compat = 0;
1159
 
1160
  if (flag_preprocess_only)
1161
    {
1162
      /* Open the output now.  We must do so even if flag_no_output is
1163
         on, because there may be other output than from the actual
1164
         preprocessing (e.g. from -dM).  */
1165
      if (out_fname[0] == '\0')
1166
        out_stream = stdout;
1167
      else
1168
        out_stream = fopen (out_fname, "w");
1169
 
1170
      if (out_stream == NULL)
1171
        {
1172
          fatal_error ("opening output file %s: %m", out_fname);
1173
          return false;
1174
        }
1175
 
1176
      if (num_in_fnames > 1)
1177
        error ("too many filenames given.  Type %s --help for usage",
1178
               progname);
1179
 
1180
      init_pp_output (out_stream);
1181
    }
1182
  else
1183
    {
1184
      init_c_lex ();
1185
 
1186
      /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1187
      input_location = UNKNOWN_LOCATION;
1188
    }
1189
 
1190
  cb = cpp_get_callbacks (parse_in);
1191
  cb->file_change = cb_file_change;
1192
  cb->dir_change = cb_dir_change;
1193
  cpp_post_options (parse_in);
1194
 
1195
  input_location = UNKNOWN_LOCATION;
1196
 
1197
  *pfilename = this_input_filename
1198
    = cpp_read_main_file (parse_in, in_fnames[0]);
1199
  /* Don't do any compilation or preprocessing if there is no input file.  */
1200
  if (this_input_filename == NULL)
1201
    {
1202
      errorcount++;
1203
      return false;
1204
    }
1205
 
1206
  if (flag_working_directory
1207
      && flag_preprocess_only && !flag_no_line_commands)
1208
    pp_dir_change (parse_in, get_src_pwd ());
1209
 
1210
  return flag_preprocess_only;
1211
}
1212
 
1213
/* Front end initialization common to C, ObjC and C++.  */
1214
bool
1215
c_common_init (void)
1216
{
1217
  /* Set up preprocessor arithmetic.  Must be done after call to
1218
     c_common_nodes_and_builtins for type nodes to be good.  */
1219
  cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1220
  cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1221
  cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1222
  cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1223
  cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1224
  cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1225
 
1226
  /* This can't happen until after wchar_precision and bytes_big_endian
1227
     are known.  */
1228
  cpp_init_iconv (parse_in);
1229
 
1230
  if (version_flag)
1231
    c_common_print_pch_checksum (stderr);
1232
 
1233
  /* Has to wait until now so that cpplib has its hash table.  */
1234
  init_pragma ();
1235
 
1236
  if (flag_preprocess_only)
1237
    {
1238
      finish_options ();
1239
      preprocess_file (parse_in);
1240
      return false;
1241
    }
1242
 
1243
  return true;
1244
}
1245
 
1246
/* Initialize the integrated preprocessor after debug output has been
1247
   initialized; loop over each input file.  */
1248
void
1249
c_common_parse_file (int set_yydebug)
1250
{
1251
  unsigned int i;
1252
 
1253
  if (set_yydebug)
1254
    switch (c_language)
1255
      {
1256
      case clk_c:
1257
        warning(0, "The C parser does not support -dy, option ignored");
1258
        break;
1259
      case clk_objc:
1260
        warning(0,
1261
                "The Objective-C parser does not support -dy, option ignored");
1262
        break;
1263
      case clk_cxx:
1264
        warning(0, "The C++ parser does not support -dy, option ignored");
1265
        break;
1266
      case clk_objcxx:
1267
        warning(0,
1268
            "The Objective-C++ parser does not support -dy, option ignored");
1269
        break;
1270
      default:
1271
        gcc_unreachable ();
1272
    }
1273
 
1274
  i = 0;
1275
  for (;;)
1276
    {
1277
      /* Start the main input file, if the debug writer wants it. */
1278
      if (debug_hooks->start_end_main_source_file)
1279
        (*debug_hooks->start_source_file) (0, this_input_filename);
1280
      finish_options ();
1281
      pch_init ();
1282
      push_file_scope ();
1283
      c_parse_file ();
1284
      finish_file ();
1285
      pop_file_scope ();
1286
      /* And end the main input file, if the debug writer wants it  */
1287
      if (debug_hooks->start_end_main_source_file)
1288
        (*debug_hooks->end_source_file) (0);
1289
      if (++i >= num_in_fnames)
1290
        break;
1291
      cpp_undef_all (parse_in);
1292
      cpp_clear_file_cache (parse_in);
1293
      this_input_filename
1294
        = cpp_read_main_file (parse_in, in_fnames[i]);
1295
      /* If an input file is missing, abandon further compilation.
1296
         cpplib has issued a diagnostic.  */
1297
      if (!this_input_filename)
1298
        break;
1299
    }
1300
}
1301
 
1302
/* Common finish hook for the C, ObjC and C++ front ends.  */
1303
void
1304
c_common_finish (void)
1305
{
1306
  FILE *deps_stream = NULL;
1307
 
1308
  /* Don't write the deps file if there are errors.  */
1309
  if (cpp_opts->deps.style != DEPS_NONE && errorcount == 0)
1310
    {
1311
      /* If -M or -MM was seen without -MF, default output to the
1312
         output stream.  */
1313
      if (!deps_file)
1314
        deps_stream = out_stream;
1315
      else
1316
        {
1317
          deps_stream = fopen (deps_file, deps_append ? "a": "w");
1318
          if (!deps_stream)
1319
            fatal_error ("opening dependency file %s: %m", deps_file);
1320
        }
1321
    }
1322
 
1323
  /* For performance, avoid tearing down cpplib's internal structures
1324
     with cpp_destroy ().  */
1325
  cpp_finish (parse_in, deps_stream);
1326
 
1327
  if (deps_stream && deps_stream != out_stream
1328
      && (ferror (deps_stream) || fclose (deps_stream)))
1329
    fatal_error ("closing dependency file %s: %m", deps_file);
1330
 
1331
  if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1332
    fatal_error ("when writing output to %s: %m", out_fname);
1333
}
1334
 
1335
/* Either of two environment variables can specify output of
1336
   dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1337
   DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1338
   and DEPS_TARGET is the target to mention in the deps.  They also
1339
   result in dependency information being appended to the output file
1340
   rather than overwriting it, and like Sun's compiler
1341
   SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1342
static void
1343
check_deps_environment_vars (void)
1344
{
1345
  char *spec;
1346
 
1347
  GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1348
  if (spec)
1349
    cpp_opts->deps.style = DEPS_USER;
1350
  else
1351
    {
1352
      GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1353
      if (spec)
1354
        {
1355
          cpp_opts->deps.style = DEPS_SYSTEM;
1356
          cpp_opts->deps.ignore_main_file = true;
1357
        }
1358
    }
1359
 
1360
  if (spec)
1361
    {
1362
      /* Find the space before the DEPS_TARGET, if there is one.  */
1363
      char *s = strchr (spec, ' ');
1364
      if (s)
1365
        {
1366
          /* Let the caller perform MAKE quoting.  */
1367
          defer_opt (OPT_MT, s + 1);
1368
          *s = '\0';
1369
        }
1370
 
1371
      /* Command line -MF overrides environment variables and default.  */
1372
      if (!deps_file)
1373
        deps_file = spec;
1374
 
1375
      deps_append = 1;
1376
      deps_seen = true;
1377
    }
1378
}
1379
 
1380
/* Handle deferred command line switches.  */
1381
static void
1382
handle_deferred_opts (void)
1383
{
1384
  size_t i;
1385
  struct deps *deps;
1386
 
1387
  /* Avoid allocating the deps buffer if we don't need it.
1388
     (This flag may be true without there having been -MT or -MQ
1389
     options, but we'll still need the deps buffer.)  */
1390
  if (!deps_seen)
1391
    return;
1392
 
1393
  deps = cpp_get_deps (parse_in);
1394
 
1395
  for (i = 0; i < deferred_count; i++)
1396
    {
1397
      struct deferred_opt *opt = &deferred_opts[i];
1398
 
1399
      if (opt->code == OPT_MT || opt->code == OPT_MQ)
1400
        deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1401
    }
1402
}
1403
 
1404
/* These settings are appropriate for GCC, but not necessarily so for
1405
   cpplib as a library.  */
1406
static void
1407
sanitize_cpp_opts (void)
1408
{
1409
  /* If we don't know what style of dependencies to output, complain
1410
     if any other dependency switches have been given.  */
1411
  if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1412
    error ("to generate dependencies you must specify either -M or -MM");
1413
 
1414
  /* -dM and dependencies suppress normal output; do it here so that
1415
     the last -d[MDN] switch overrides earlier ones.  */
1416
  if (flag_dump_macros == 'M')
1417
    flag_no_output = 1;
1418
 
1419
  /* By default, -fdirectives-only implies -dD.  This allows subsequent phases
1420
     to perform proper macro expansion.  */
1421
  if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros)
1422
    flag_dump_macros = 'D';
1423
 
1424
  /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1425
     -dM since at least glibc relies on -M -dM to work.  */
1426
  /* Also, flag_no_output implies flag_no_line_commands, always.  */
1427
  if (flag_no_output)
1428
    {
1429
      if (flag_dump_macros != 'M')
1430
        flag_dump_macros = 0;
1431
      flag_dump_includes = 0;
1432
      flag_no_line_commands = 1;
1433
    }
1434
  else if (cpp_opts->deps.missing_files)
1435
    error ("-MG may only be used with -M or -MM");
1436
 
1437
  cpp_opts->unsigned_char = !flag_signed_char;
1438
  cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1439
 
1440
  /* Wlong-long is disabled by default. It is enabled by:
1441
      [-pedantic | -Wtraditional] -std=[gnu|c]++98 ; or
1442
      [-pedantic | -Wtraditional] -std=non-c99 .
1443
 
1444
      Either -Wlong-long or -Wno-long-long override any other settings.  */
1445
  if (warn_long_long == -1)
1446
    warn_long_long = ((pedantic || warn_traditional)
1447
                      && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99));
1448
  cpp_opts->warn_long_long = warn_long_long;
1449
 
1450
  /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1451
     this also turns off warnings about GCCs extension.  */
1452
  cpp_opts->warn_variadic_macros
1453
    = warn_variadic_macros && (pedantic || warn_traditional);
1454
 
1455
  /* If we're generating preprocessor output, emit current directory
1456
     if explicitly requested or if debugging information is enabled.
1457
     ??? Maybe we should only do it for debugging formats that
1458
     actually output the current directory?  */
1459
  if (flag_working_directory == -1)
1460
    flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1461
 
1462
  if (cpp_opts->directives_only)
1463
    {
1464
      if (warn_unused_macros)
1465
        error ("-fdirectives-only is incompatible with -Wunused_macros");
1466
      if (cpp_opts->traditional)
1467
        error ("-fdirectives-only is incompatible with -traditional");
1468
    }
1469
}
1470
 
1471
/* Add include path with a prefix at the front of its name.  */
1472
static void
1473
add_prefixed_path (const char *suffix, size_t chain)
1474
{
1475
  char *path;
1476
  const char *prefix;
1477
  size_t prefix_len, suffix_len;
1478
 
1479
  suffix_len = strlen (suffix);
1480
  prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1481
  prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1482
 
1483
  path = (char *) xmalloc (prefix_len + suffix_len + 1);
1484
  memcpy (path, prefix, prefix_len);
1485
  memcpy (path + prefix_len, suffix, suffix_len);
1486
  path[prefix_len + suffix_len] = '\0';
1487
 
1488
  add_path (path, chain, 0, false);
1489
}
1490
 
1491
/* Handle -D, -U, -A, -imacros, and the first -include.  */
1492
static void
1493
finish_options (void)
1494
{
1495
  if (!cpp_opts->preprocessed)
1496
    {
1497
      size_t i;
1498
 
1499
      cb_file_change (parse_in,
1500
                      linemap_add (line_table, LC_RENAME, 0,
1501
                                   _("<built-in>"), 0));
1502
 
1503
      cpp_init_builtins (parse_in, flag_hosted);
1504
      c_cpp_builtins (parse_in);
1505
 
1506
      /* We're about to send user input to cpplib, so make it warn for
1507
         things that we previously (when we sent it internal definitions)
1508
         told it to not warn.
1509
 
1510
         C99 permits implementation-defined characters in identifiers.
1511
         The documented meaning of -std= is to turn off extensions that
1512
         conflict with the specified standard, and since a strictly
1513
         conforming program cannot contain a '$', we do not condition
1514
         their acceptance on the -std= setting.  */
1515
      cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1516
 
1517
      cb_file_change (parse_in,
1518
                      linemap_add (line_table, LC_RENAME, 0,
1519
                                   _("<command-line>"), 0));
1520
 
1521
      for (i = 0; i < deferred_count; i++)
1522
        {
1523
          struct deferred_opt *opt = &deferred_opts[i];
1524
 
1525
          if (opt->code == OPT_D)
1526
            cpp_define (parse_in, opt->arg);
1527
          else if (opt->code == OPT_U)
1528
            cpp_undef (parse_in, opt->arg);
1529
          else if (opt->code == OPT_A)
1530
            {
1531
              if (opt->arg[0] == '-')
1532
                cpp_unassert (parse_in, opt->arg + 1);
1533
              else
1534
                cpp_assert (parse_in, opt->arg);
1535
            }
1536
        }
1537
 
1538
      /* Handle -imacros after -D and -U.  */
1539
      for (i = 0; i < deferred_count; i++)
1540
        {
1541
          struct deferred_opt *opt = &deferred_opts[i];
1542
 
1543
          if (opt->code == OPT_imacros
1544
              && cpp_push_include (parse_in, opt->arg))
1545
            {
1546
              /* Disable push_command_line_include callback for now.  */
1547
              include_cursor = deferred_count + 1;
1548
              cpp_scan_nooutput (parse_in);
1549
            }
1550
        }
1551
    }
1552
  else if (cpp_opts->directives_only)
1553
    cpp_init_special_builtins (parse_in);
1554
 
1555
  include_cursor = 0;
1556
  push_command_line_include ();
1557
}
1558
 
1559
/* Give CPP the next file given by -include, if any.  */
1560
static void
1561
push_command_line_include (void)
1562
{
1563
  while (include_cursor < deferred_count)
1564
    {
1565
      struct deferred_opt *opt = &deferred_opts[include_cursor++];
1566
 
1567
      if (!cpp_opts->preprocessed && opt->code == OPT_include
1568
          && cpp_push_include (parse_in, opt->arg))
1569
        return;
1570
    }
1571
 
1572
  if (include_cursor == deferred_count)
1573
    {
1574
      include_cursor++;
1575
      /* -Wunused-macros should only warn about macros defined hereafter.  */
1576
      cpp_opts->warn_unused_macros = warn_unused_macros;
1577
      /* Restore the line map from <command line>.  */
1578
      if (!cpp_opts->preprocessed)
1579
        cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1580
 
1581
      /* Set this here so the client can change the option if it wishes,
1582
         and after stacking the main file so we don't trace the main file.  */
1583
      line_table->trace_includes = cpp_opts->print_include_names;
1584
    }
1585
}
1586
 
1587
/* File change callback.  Has to handle -include files.  */
1588
static void
1589
cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1590
                const struct line_map *new_map)
1591
{
1592
  if (flag_preprocess_only)
1593
    pp_file_change (new_map);
1594
  else
1595
    fe_file_change (new_map);
1596
 
1597
  if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1598
    push_command_line_include ();
1599
}
1600
 
1601
void
1602
cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1603
{
1604
  if (!set_src_pwd (dir))
1605
    warning (0, "too late for # directive to set debug directory");
1606
}
1607
 
1608
/* Set the C 89 standard (with 1994 amendments if C94, without GNU
1609
   extensions if ISO).  There is no concept of gnu94.  */
1610
static void
1611
set_std_c89 (int c94, int iso)
1612
{
1613
  cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1614
  flag_iso = iso;
1615
  flag_no_asm = iso;
1616
  flag_no_gnu_keywords = iso;
1617
  flag_no_nonansi_builtin = iso;
1618
  flag_isoc94 = c94;
1619
  flag_isoc99 = 0;
1620
}
1621
 
1622
/* Set the C 99 standard (without GNU extensions if ISO).  */
1623
static void
1624
set_std_c99 (int iso)
1625
{
1626
  cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1627
  flag_no_asm = iso;
1628
  flag_no_nonansi_builtin = iso;
1629
  flag_iso = iso;
1630
  flag_isoc99 = 1;
1631
  flag_isoc94 = 1;
1632
}
1633
 
1634
/* Set the C++ 98 standard (without GNU extensions if ISO).  */
1635
static void
1636
set_std_cxx98 (int iso)
1637
{
1638
  cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1639
  flag_no_gnu_keywords = iso;
1640
  flag_no_nonansi_builtin = iso;
1641
  flag_iso = iso;
1642
  cxx_dialect = cxx98;
1643
}
1644
 
1645
/* Set the C++ 0x working draft "standard" (without GNU extensions if ISO).  */
1646
static void
1647
set_std_cxx0x (int iso)
1648
{
1649
  cpp_set_lang (parse_in, iso ? CLK_CXX0X: CLK_GNUCXX0X);
1650
  flag_no_gnu_keywords = iso;
1651
  flag_no_nonansi_builtin = iso;
1652
  flag_iso = iso;
1653
  cxx_dialect = cxx0x;
1654
}
1655
 
1656
/* Handle setting implicit to ON.  */
1657
static void
1658
set_Wimplicit (int on)
1659
{
1660
  warn_implicit = on;
1661
  warn_implicit_int = on;
1662
  warn_implicit_function_declaration = on;
1663
}
1664
 
1665
/* Args to -d specify what to dump.  Silently ignore
1666
   unrecognized options; they may be aimed at toplev.c.  */
1667
static void
1668
handle_OPT_d (const char *arg)
1669
{
1670
  char c;
1671
 
1672
  while ((c = *arg++) != '\0')
1673
    switch (c)
1674
      {
1675
      case 'M':                 /* Dump macros only.  */
1676
      case 'N':                 /* Dump names.  */
1677
      case 'D':                 /* Dump definitions.  */
1678
      case 'U':                 /* Dump used macros.  */
1679
        flag_dump_macros = c;
1680
        break;
1681
 
1682
      case 'I':
1683
        flag_dump_includes = 1;
1684
        break;
1685
      }
1686
}

powered by: WebSVN 2.1.0

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