c_common_handle_option (continue)
657 case OPT_Wwrite_strings:
658 if (!c_dialect_cxx ())
659 flag_const_strings = value;
660 else
661 warn_write_strings = value;
662 break;
663
664 case OPT_ansi:
665 if (!c_dialect_cxx ())
666 set_std_c89 (false, true);
667 else
668 set_std_cxx98 (true);
669 break;
670
671 case OPT_d:
672 handle_OPT_d (arg);
673 break;
674
675 case OPT_fcond_mismatch:
676 if (!c_dialect_cxx ())
677 {
678 flag_cond_mismatch = value;
679 break;
680 }
681 /* Fall through. */
682
683 case OPT_fall_virtual:
684 case OPT_falt_external_templates:
685 case OPT_fenum_int_equiv:
686 case OPT_fexternal_templates:
687 case OPT_fguiding_decls:
688 case OPT_fhonor_std:
689 case OPT_fhuge_objects:
690 case OPT_flabels_ok:
691 case OPT_fname_mangling_version_:
692 case OPT_fnew_abi:
693 case OPT_fnonnull_objects:
694 case OPT_fsquangle:
695 case OPT_fstrict_prototype:
696 case OPT_fthis_is_variable:
697 case OPT_fvtable_thunks:
698 case OPT_fxref:
699 case OPT_fvtable_gc:
700 warning ("switch /"%s/" is no longer supported", option->opt_text);
701 break;
702
703 case OPT_faccess_control:
704 flag_access_control = value;
705 break;
706
707 case OPT_fasm:
708 flag_no_asm = !value;
709 break;
710
711 case OPT_fbuiltin:
712 flag_no_builtin = !value;
713 break;
Above c_dialect_cxx returns 1 if the langauge is C++, and sets below variables accordingly:
flag_const_strings (C, C++, -Wwrite-strings) if nonzero, means give string constants the type `const char *', as mandated by the standard.
warn_write_strings (C, C++, -Wwrite-strings) if nonzero, warns about deprecated conversion from string constant to `char *'.
Line 664 handles option –ansi which specifies the standard to which the code should conform; and saves its parameter by below funcitons.
1522 static void
1523 set_std_c89 (int c94, int iso) in c-opts.c
1524 {
1525 cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1526 flag_iso = iso;
1527 flag_no_asm = iso;
1528 flag_no_gnu_keywords = iso;
1529 flag_no_nonansi_builtin = iso;
1530 flag_isoc94 = c94;
1531 flag_isoc99 = 0;
1532 flag_writable_strings = 0;
1533 }
Above, parse_in is a global object of cpp_reader. And the variables are:
flag_iso if nonzero, rejects macros in the user's namespace.
flag_no_asm (C, C++, ObjC, -fno-asm) if nonzero, for C, specifying -fno-asm disables the keywords asm, inline, and typeof. This option has no effect on the keywords __asm__, __inline__, and __typeof__. For C++, specifying -fno-asm disables the keyword typeof, but has no effect on asm and inline because they are part of the language. Other flags that effect these keywords are -ansi, -gnu-keywords, and -std.
flag_no_gnu_keywords (C++, -fno-gnu-keywords) if nonzero, disables the typeof keywords.
flag_no_nonansi_builtin (C++, -fno-nonansi-builtin) if nonzero, means don't recognize the non-ANSI builtin functions. -ansi sets this.
flag_isoc94 if nonzero, means enable C89 Amendment 1 features.
flag_isoc99 if nonzero, means use the ISO C99 dialect of C.
flag_writable_strings (C, C++, -fwritable-strings) if nonzero, stores string constants in data segment and doesn't uniquize them.
1549 static void
1550 set_std_cxx98 (int iso) in c-opts.c
1551 {
1552 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1553 flag_no_gnu_keywords = iso;
1554 flag_no_nonansi_builtin = iso;
1555 flag_iso = iso;
1556 }
At line 671, for option -dletters, one or more letters can be listed to specify when a debugging dump (or dumps) should occur and what the dump is to contain. This option is for use in debugging the compiler by making it possible to examine detailed information at various stages of compilation. Each output file is identified with a suffix of the pass number followed by some identifying letters. For example, the file dumped following pass 21, which is global register allocation, while compiling doline.c would be named doline.21.greg.
Letters for the -d option can be inserted in any combination and in any order. This feature has been implemented strictly for purposes of debugging the compiler, so you will find that not all the letters are implemented in every release. Note that the letters D, I, M, and N, in current version, only used by preprocessor (but in version later than v4.0, these letters must be used in conjunction with –E to be specified for preprocessor; otherwise they have different meanings). In current version, these letters have following meanings:
Letter |
Produce |
D |
in addition to the normal output after preprocessing, include all macro definitions in the output. |
I |
the preprocessor outputs the #include directives in addition to the other preprocessor output. |
M |
the preprocessor will output a list of the macro definitions in effect at the end of all preprocessing. |
N |
in addition to the normal output after preprocessing, include a list of all macros in the simplified form of #define name. |
1575 static void
1576 handle_OPT_d (const char *arg) in c-opts.c
1577 {
1578 char c;
1579
1580 while ((c = *arg++) != '/0')
1581 switch (c)
1582 {
1583 case 'M': /* Dump macros only. */
1584 case 'N': /* Dump names. */
1585 case 'D': /* Dump definitions. */
1586 flag_dump_macros = c;
1587 break;
1588
1589 case 'I':
1590 flag_dump_includes = 1;
1591 break;
1592 }
1593 }
Back in c_common_handle_option, at line 678:
flag_cond_mismatch (C, -fcond-mismatch), if nonzero, means allow type mismatches in conditional expressions; just make their values `void'.
flag_access_control (C++, -faccess-control) if nonzero, means want to obey access control semantics.
flag_no_builtin (C, ObjC, -fno-builtin) if nonzero, means don't recognize the non-ANSI builtin functions.
c_common_handle_option (continue)
715 case OPT_fbuiltin_:
716 if (value)
717 result = 0;
718 else
719 disable_builtin_function (arg);
720 break;
721
722 case OPT_fdollars_in_identifiers:
723 cpp_opts->dollars_in_ident = value;
724 break;
725
726 case OPT_fdump_:
727 if (!dump_switch_p (arg))
728 result = 0;
729 break;
730
731 case OPT_ffreestanding:
732 value = !value;
733 /* Fall through.... */
734 case OPT_fhosted:
735 flag_hosted = value;
736 flag_no_builtin = !value;
737 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
738 if (!value && warn_main == 2)
739 warn_main = 0;
740 break;
For current GCC, only –fno-builtin-function is supported. disabled_builtins saves the name of disabled function into list.
3491 void
3492 disable_builtin_function (const char *name) in c-common.c
3493 {
3494 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3495 error ("cannot disable built-in function `%s'", name);
3496 else
3497 {
3498 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3499 new->name = name;
3500 new->next = disabled_builtins;
3501 disabled_builtins = new;
3502 }
3503 }
Above, in c_common_handle_option, at line 735, flag_hosted (C, -fhosted) if nonzero, means the compiled program is to run in a hosted environment, which has the entire standard library available, and main() has a return type of int (the default value is 1).
c_common_handle_option (continue)
742 case OPT_fshort_double:
743 flag_short_double = value;
744 break;
745
746 case OPT_fshort_enums:
747 flag_short_enums = value;
748 break;
749
750 case OPT_fshort_wchar:
751 flag_short_wchar = value;
752 break;
753
754 case OPT_fsigned_bitfields:
755 flag_signed_bitfields = value;
756 explicit_flag_signed_bitfields = 1;
757 break;
758
759 case OPT_fsigned_char:
760 flag_signed_char = value;
761 break;
762
763 case OPT_funsigned_bitfields:
764 flag_signed_bitfields = !value;
765 explicit_flag_signed_bitfields = 1;
766 break;
767
768 case OPT_funsigned_char:
769 flag_signed_char = !value;
770 break;
771
772 case OPT_fcheck_new:
773 flag_check_new = value;
774 break;
775
776 case OPT_fconserve_space:
777 flag_conserve_space = value;
778 break;
779
780 case OPT_fconst_strings:
781 flag_const_strings = value;
782 break;
783
784 case OPT_fconstant_string_class_:
785 constant_string_class_name = arg;
786 break;
787
788 case OPT_fdefault_inline:
789 flag_default_inline = value;
790 break;
791
792 case OPT_felide_constructors:
793 flag_elide_constructors = value;
794 break;
795
796 case OPT_fenforce_eh_specs:
797 flag_enforce_eh_specs = value;
798 break;
799
800 case OPT_ffixed_form:
801 case OPT_ffixed_line_length_:
802 /* Fortran front end options ignored when preprocessing only. */
803 if (!flag_preprocess_only)
804 result = 0;
805 break;
806
807 case OPT_ffor_scope:
808 flag_new_for_scope = value;
809 break;
810
811 case OPT_fgnu_keywords:
812 flag_no_gnu_keywords = !value;
813 break;
814
815 case OPT_fgnu_runtime:
816 flag_next_runtime = !value;
817 break;
818
819 case OPT_fhandle_exceptions:
820 warning ("-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
821 flag_exceptions = value;
822 break;
823
824 case OPT_fimplement_inlines:
825 flag_implement_inlines = value;
826 break;
827
828 case OPT_fimplicit_inline_templates:
829 flag_implicit_inline_templates = value;
830 break;
831
832 case OPT_fimplicit_templates:
833 flag_implicit_templates = value;
834 break;
835
836 case OPT_fms_extensions:
837 flag_ms_extensions = value;
838 break;
839
840 case OPT_fnext_runtime:
841 flag_next_runtime = value;
842 break;
843
844 case OPT_fnil_receivers:
845 flag_nil_receivers = value;
846 break;
847
848 case OPT_fnonansi_builtins:
849 flag_no_nonansi_builtin = !value;
850 break;
851
852 case OPT_fobjc_exceptions:
853 flag_objc_exceptions = value;
854 break;
855
856 case OPT_foperator_names:
857 cpp_opts->operator_names = value;
858 break;
859
860 case OPT_foptional_diags:
861 flag_optional_diags = value;
862 break;
863
864 case OPT_fpch_deps:
865 cpp_opts->restore_pch_deps = value;
866 break;
867
868 case OPT_fpermissive:
869 flag_permissive = value;
870 break;
871
872 case OPT_fpreprocessed:
873 cpp_opts->preprocessed = value;
874 break;
875
876 case OPT_freplace_objc_classes:
877 flag_replace_objc_classes = value;
878 break;
879
880 case OPT_frepo:
881 flag_use_repository = value;
882 if (value)
883 flag_implicit_templates = 0;
884 break;
885
886 case OPT_frtti:
887 flag_rtti = value;
888 break;
889
890 case OPT_fshow_column:
891 cpp_opts->show_column = value;
892 break;
893
894 case OPT_fstats:
895 flag_detailed_statistics = value;
896 break;
897
898 case OPT_ftabstop_:
899 /* It is documented that we silently ignore silly values. */
900 if (value >= 1 && value <= 100)
901 cpp_opts->tabstop = value;
902 break;
903
904 case OPT_fexec_charset_:
905 cpp_opts->narrow_charset = arg;
906 break;
907
908 case OPT_fwide_exec_charset_:
909 cpp_opts->wide_charset = arg;
910 break;
911
912 case OPT_finput_charset_:
913 cpp_opts->input_charset = arg;
914 break;
915
916 case OPT_ftemplate_depth_:
917 max_tinst_depth = value;
918 break;
919
920 case OPT_fuse_cxa_atexit:
921 flag_use_cxa_atexit = value;
922 break;
923
924 case OPT_fweak:
925 flag_weak = value;
926 break;
927
928 case OPT_fzero_link:
929 flag_zero_link = value;
930 break;
931
932 case OPT_gen_decls:
933 flag_gen_declaration = 1;
934 break;
935
936 case OPT_idirafter:
937 add_path (xstrdup (arg), AFTER, 0);
938 break;
939
940 case OPT_imacros:
941 case OPT_include:
942 defer_opt (code, arg);
943 break;
944
945 case OPT_iprefix:
946 iprefix = arg;
947 break;
948
949 case OPT_isysroot:
950 sysroot = arg;
951 break;
952
953 case OPT_isystem:
954 add_path (xstrdup (arg), SYSTEM, 0);
955 break;
Above, flag_short_double if nonzero, means give `double' the same size as `float'.
flag_short_enums (-fshort-enums) if nonzero, means give an enum type only as many bytes as it needs.
flag_short_wchar (C, C++, -fshort-wchar) if nonzero, means give `wchar_t' the same size as `short'.
flag_signed_bitfields (C, -fsigned-bitfields), if nonzero, means to treat bitfields as signed unless they say `unsigned' (the default value is 1).
flag_signed_char (C, -fsigned-char) if nonzero, means `char' should be signed.
flag_check_new (C++, -fcheck-new) if nonzero, means want to check the return value of new and avoid calling constructors if it is a null pointer.
flag_conserve_space (C++, -fconserve-space) if nonzero, places global variables that are not initialized at compile time into the common segment (as is done in C). This reduces the size of the executable file because no space is allocated for them until the program loads. This flag no longer serves the purpose for most platforms because support has been added to store variables in BSS without making them common. Warning: If use of this option causes your program to crash when it is terminating, it could be because an object is being destroyed twice because object definitions were merged and assigned the same address.
flag_default_inline (C++, -fdefault-inline) if nonzero, means that member functions defined in class scope are inline by default (the default value is 1).
flag_elide_constructors (C++, -felide-constructor) if nonzero, the generated code that calls a function returning an object by value may be simplified by having the function construct the object directly in the specified return location instead of using a copy constructor to duplicate the one constructed inside the function. This could cause a problem if there are side effects in a constructor. (the default value is 1).
flag_enforce_eh_specs (C++, -fenforce-eh-specs) if nonzero, means to implement standard semantics for exception specifications, calling unexpected if an exception is thrown that doesn't match the specification. Zero means to treat them as assertions and optimize accordingly, but not check them (the default value is 1)
flag_new_for_scope (C++, -ffor-scope), this setting determines the scope of variables declared in the initialization section of the for statement. Specifying -ffor-scope limits the scope of the variables to the body of the loop. Specifying -fno-for-scope limits the scope of the variables from the point at which it is declared to the closing of the scope containing the for statement itself. The following example is valid with this option:
#include <stdio.h>
int main(int argc,char *argv[])
{
for(int i=0; i<10; i++) {
printf("Loop one %d/n",i);
}
printf("Out of loop %d/n",i);
return(0);
}
This is the default, for now.
flag_implement_inlines (C++, -fimplement-inlines) if nonzero, functions that are generated as inline code also have function bodies generated for them where they are defined. The option -fno-implement-inlines will suppress the generation of the function bodies for inline functions controlled by #pragma implementation. If no function body is generated, every call to it must be generated as inline code. (the default value 1).
flag_implicit_inline_templates (C++, -fimplicit-inline-templates) if nonzero, means that implicit instantiations of inline templates will be emitted if needed, even if instantiations of non-inline templates aren't (the default value is 1).
flag_implicit_templates (C++, -fimplicit-templates) if nonzero, means that implicit instantiations will be emitted if needed (the default value is 1).
flag_ms_extensions (C++, -fms-extensions) if nonzero, disables warning messages when using constructs defined in MFC, such as implicit int definition in data declarations and acquiring a pointer to a member function using nonstandard syntax.
flag_optional_diags (C++, -foptional-diags) if nonzero, means want to issue diagnostics that the standard says are not required (the default value is 1).
flag_permissive (C++, -fpermissive) if nonzero, diagnostic messages specifying that code does not conform to the standard are issued as warnings instead of errors. If nether -fpermissive nor -pedantic is specified, the -fpedantic-errors option is assumed.
flag_use_repository (C++, -frepo) if nonzero, means generate separate instantiation control files and juggle them at link time.
flag_rtti (C++, -frtti) if nonzero, means code generated for run time identification of every class containing virtual methods. If you use neither dynamic_cast nor typeid, you can save some space in each class by using -fno-rtti to supress the code generation. This flag has no effect on exception handling which generates rtti code as necessary. (the default value is 1).
flag_detailed_statistics (C++, -fstats) if nonzero, means displays statistical information about front-end processing. This information pertains to compiler internals and has no effect on its output (the default value is 0).
max_tinst_depth (C++, -ftemplate-depth-number) specifies maximum template instantiation depth. This limit is rather arbitrary, but it exists to limit the time it takes to notice infinite template instantiations (the default value is 500).
flag_use_cxa_atexit (C++, -fuse-cxa-atexit) causes global destructors to be run in the reverse order that the constructors completed instead of the reverse order that the constructors started. The order will differ only if one global constructor is invoked from inside another. This option will work only if the cxa_exit() function is part of the C runtime library.Without this option the atexit() function is used.
flag_weak (C++, -fweak) if nonzero, means want to emit defined symbols with common-like linkage as weak symbols where possible, in order to conform to C++ semantics. Otherwise, emit them as local symbols (the default value is 1).
iprefix, the prefix given by –iprefix prefix.
sysroot, the system root, if any. Overridden by –isysroot (the default value is nil).
c_common_handle_option (continue)
957 case OPT_iwithprefix:
958 add_prefixed_path (arg, SYSTEM);
959 break;
960
961 case OPT_iwithprefixbefore:
962 add_prefixed_path (arg, BRACKET);
963 break;
964
965 case OPT_lang_asm:
966 cpp_set_lang (parse_in, CLK_ASM);
967 cpp_opts->dollars_in_ident = false;
968 break;
969
970 case OPT_lang_objc:
971 cpp_opts->objc = 1;
972 break;
973
974 case OPT_nostdinc:
975 std_inc = false;
976 break;
977
978 case OPT_nostdinc__:
979 std_cxx_inc = false;
980 break;
981
982 case OPT_o:
983 if (!out_fname)
984 out_fname = arg;
985 else
986 error ("output filename specified twice");
987 break;
988
989 /* We need to handle the -pedantic switches here, rather than in
990 c_common_post_options, so that a subsequent -Wno-endif-labels
991 is not overridden. */
992 case OPT_pedantic_errors:
993 cpp_opts->pedantic_errors = 1;
994 /* Fall through. */
995 case OPT_pedantic:
996 cpp_opts->pedantic = 1;
997 cpp_opts->warn_endif_labels = 1;
998 break;
999
1000 case OPT_print_objc_runtime_info:
1001 print_struct_values = 1;
1002 break;
1003
1004 case OPT_remap:
1005 cpp_opts->remap = 1;
1006 break;
1007
1008 case OPT_std_c__98:
1009 case OPT_std_gnu__98:
1010 set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
1011 break;
1012
1013 case OPT_std_c89:
1014 case OPT_std_iso9899_1990:
1015 case OPT_std_iso9899_199409:
1016 set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
1017 break;
1018
1019 case OPT_std_gnu89:
1020 set_std_c89 (false /* c94 */, false /* ISO */);
1021 break;
1022
1023 case OPT_std_c99:
1024 case OPT_std_c9x:
1025 case OPT_std_iso9899_1999:
1026 case OPT_std_iso9899_199x:
1027 set_std_c99 (true /* ISO */);
1028 break;
1029
1030 case OPT_std_gnu99:
1031 case OPT_std_gnu9x:
1032 set_std_c99 (false /* ISO */);
1033 break;
1034
1035 case OPT_trigraphs:
1036 cpp_opts->trigraphs = 1;
1037 break;
1038
1039 case OPT_traditional_cpp:
1040 cpp_opts->traditional = 1;
1041 break;
1042
1043 case OPT_undef:
1044 flag_undef = 1;
1045 break;
1046
1047 case OPT_w:
1048 cpp_opts->inhibit_warnings = 1;
1049 break;
1050
1051 case OPT_v:
1052 verbose = true;
1053 break;
1054 }
1055
1056 return result;
1057 }
Switch –withprefix addes the directory name to the second list of directories searched for header files. The name is constructed by appending the prefix specified by -iprefix with the named directory. If no prefix has been specified on the command line prior to this option, the directory containing the installed passes of the compiler itself is used as the default.
To find a header file, GCC looks through the directories in the first list (the one that has names added to it by the -I option). If the header file is not found in the first list, the second list is searched.
And switch –iwithprefixbefore addes a name to the list of directories in the main include path. The name is constructed by appending the prefix specified by -iprefix with the named directory. If no prefix has been specified on the command line prior to this option, the directory containing the installed passes of the compiler itself is used as the default.
For these switches, add_prefixed_path is invoked. At line 1399, cpp_GCC_INCLUDE_DIR under x86/Linux target is “”, which is used when iprefix is unvailable.
1391 static void
1392 add_prefixed_path (const char *suffix, size_t chain) in c-opts.c
1393 {
1394 char *path;
1395 const char *prefix;
1396 size_t prefix_len, suffix_len;
1397
1398 suffix_len = strlen (suffix);
1399 prefix = iprefix ? iprefix: cpp_GCC_INCLUDE_DIR;
1400 prefix_len = iprefix? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1401
1402 path = xmalloc (prefix_len + suffix_len + 1);
1403 memcpy (path, prefix, prefix_len);
1404 memcpy (path + prefix_len, suffix, suffix_len);
1405 path[prefix_len + suffix_len] = '/0';
1406
1407 add_path (path, chain, 0);
1408 }
Above at line 965 in c_common_handle_option, for switch –lang-asm, field dollars_in_ident, if zero means dollar signs are punctuation.
For other switches
std_inc (-nostdinc), if zero, prevents the compiler from searching for heading files in the standard system directories. The only directories searched are the current directory and those specified by the -I option.
std_cxx_inc (-nostdinc++), if zero, prevents the compiler from searching for header files in the standard C++ directories, but continues to search in the other standard directories. This option is specifically for use in compiling the C++ libraries.
out_fname (-o filename), writes the output to the named file. This applies no matter what kind of output is being generated; it could be preprocessed source, assembly language, an object file, or a linked executable. Because only one output file can be specified, the -o option should not be used if several files are being produced. If the compiler produces a linked executable and the -o option is not specified to name it, the default name is a.out.
-pedantic-errors, this option is the same as -pedantic, except the diagnostics are issued as errors instead of warnings. For C++, if neither the -fpermissive nor the -pedantic option is specified, the -fpedantic-errors option is assumed.
-pedantic, issues warnings required by strict compliance to the ISO standards for C and C++. Without this option the GNU extensions are enabled, but ISO compliant programs should compile successfully (although some may require the -ansi option). For C, the standard applied is the one specified by the -std option. If -std is used to specify gnu89, then -pedantic applies the rules for C89. The -pedantic option issues only the diagnostic messages required by the ISO standard, so it is possible for code that does not comply with the standard to compile without a warning. There are no plans for GCC to implement an option that would force strict standards compliance. For C, the -pedantic option does not apply to any expression following __extension__.
For C++, if nether the -fpermissive nor the -pedantic option is specified, the -fpedantic-errors option is assumed.
At line 1004, -remap, this option instructs the preprocessor to check for the existence of a file named header.gcc in each directory containing include files. If the file exists, it is used to determine the actual name of the file being sought. Each line of the file contains the name of the header file being sought followed by the actual file name. For example, the following lines in a header.gcc file would cause header files with long names to be found under shorter names:
NotSupportedException.h notsup.h
RollbackException.h rollbak.h
TransactionRequiredException.h transreq.h
-trigraphs, supports ISO C trigraphs. This option is implied by -ansi and by -std. With this option set, each of the three-character sequences (each beginning with ??) that make up the nine trigraphs will be translated into a single character, according to the following table:
??= # ??( [ ??< {
??/ / ??) ] ??> }
??' ^ ??! | ??- ~
flag_undef (-undef), if nonzero, ihe preprocessor will not predefine any nonstandard macros. This option suppresses the architecture definitions such as __unix__, __OpenBSD__, __mips__, __linux__, __vax__, and so on.
-w, do not issue warning messages. Same as --no-warnings.
verbose (-v), if nonzero, displays the current version number of the compiler and displays all of the commands used to run each phase of the compile and link process. When used alone, this option will display the current version number of the compiler. When used in combination with the --help option, a complete list of the command line options is displayed.
Back to handle_option, c_common_handle_option if handles the switch successfully and completely, it will return 1, and for unrecognized switches, the result is depended upon permit_fortran_options which is decided by -traditional-cpp in c_common_init_options. Returning 0 will need be handled continually as below.