Studying note of GCC-3.4.6 source (29)

4.1.2. Set up flags controlling lexer

Below, flag_inline_trees, it is 0 if we should not perform inlining, 1 if we should expand functions calls inline at the tree level, and 2 if we should consider all functions to be inline candidates.
And flag_inline_functions if nonzero, the compiler is allowed to select certain simple functions to be expanded in line at the point of the function call. This variable is automatically set by -O3 unless the -fno-inline-functions flag is specified. Next, flag_no_inline if nonzero, causes the compiler to ignore the inline keyword. Further flag_really_no_inline, if nonzero, means that we don't want inlining by virtue of -fno-inline, not just because the tree inliner turned us off.
Obvious, if flag_really_no_inline is nonzero, unless using attribute “always_inline”, inline functions won’t be expanded. But if lag_no_inline and flag_inline_functions both are nonzero, the compiler will determine which to be expanded.

c_common_post_option (continue)

1087 flag_inline_trees = 1;
1088
1089 /* Use tree inlining if possible. Function instrumentation is only
1090 done in the RTL level, so we disable tree inlining. */
1091 if (flag_instrument_function_entry_exit)
1092 {
1093 flag_no_inline = 1;
1094 flag_really_no_inline = 1;
1095 }
1096 else
1097 {
1098 if (!flag_no_inline)
1099 flag_no_inline = 1;
1100 if (flag_inline_functions)
1101 {
1102 flag_inline_trees = 2;
1103 flag_inline_functions = 0;
1104 }
1105 }
1106
1107 /* -Wextra implies -Wsign-compare, but not if explicitly
1108 overridden. */
1109 if (warn_sign_compare == -1)
1110 warn_sign_compare = extra_warnings;
1111
1112 /* Special format checking options don't work without -Wformat; warn if
1113 they are used. */
1114 if (warn_format_y2k && !warn_format)
1115 warning ("-Wformat-y2k ignored without -Wformat");
1116 if (warn_format_extra_args && ! warn_format)
1117 warning ("-Wformat-extra-args ignored without -Wformat");
1118 if (warn_format_zero_length && ! warn_format)
1119 warning ("-Wformat-zero-length ignored without -Wformat");
1120 if (warn_format_nonliteral && ! warn_format)
1121 warning ("-Wformat-nonliteral ignored without -Wformat");
1122 if (warn_format_security && ! warn_format)
1123 warning ("-Wformat-security ignored without -Wformat");
1124 if (warn_missing_format_attribute && ! warn_format)
1125 warning ("-Wmissing-format-attribute ignored without -Wformat");
1126
1127 if (flag_preprocess_only)
1128 {
1129 /* Open the output now. We must do so even if flag_no_output is
1130 on, because there may be other output than from the actual
1131 preprocessing (e.g. from -dM). */
1132 if (out_fname [0] == '/0')
1133 out_fname = stdout;
1134 else
1135 out_fname = fopen (out_fname, "w");
1136
1137 if (out_fname == NULL)
1138 {
1139 fatal_error ("opening output file %s: %m", out_fname);
1140 return false;
1141 }
1142
1143 if (num_in_fnames > 1)
1144 error ("too many filenames given. Type %s --help for usage",
1145 progname);
1146
1147 init_pp_output (out_fname);
1148 }
1149 else
1150 {
1151 init_c_lex ();
1152
1153 /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */
1154 input_line = 0;
1155 }
1156
1157 cb = cpp_get_callbacks (parse_in);
1158 cb->file_change = cb_file_change;
1159 cb->dir_change = cb_dir_change;
1160 cpp_post_options (parse_in);

If we don’t require just preprocessing and then stop, thus line 1151 above does the initialization related to lex stage.

77 void
78 init_c_lex (void) in c-lex.c
79 {
80 struct cpp_callbacks *cb;
81 struct c_fileinfo *toplevel;
82
83 /* Set up filename timing. Must happen before cpp_read_main_file. */
84 file_info_tree = splay_tree_new ((splay_tree_compare_fn)strcmp,
85 0,
86 (splay_tree_delete_value_fn)free);
87 toplevel = get_fileinfo ("<top level>");
88 if (flag_detailed_statistics)
89 {
90 header_time = 0;
91 body_time = get_run_time ();
92 toplevel->time = body_time;
93 }
94
95 cb = cpp_get_callbacks (parse_in);
96
97 cb->line_change = cb_line_change;
98 cb->ident = cb_ident;
99 cb->def_pragma = cb_def_pragma;
100 cb->valid_pch = c_common_valid_pch;
101 cb->read_pch = c_common_read_pch;
102
103 /* Set the debug callbacks if we can use them. */
104 if (debug_info_level == DINFO_LEVEL_VERBOSE
105 && (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG
106 || write_symbols == VMS_AND_DWARF2_DEBUG))
107 {
108 cb->define = cb_define;
109 cb->undef = cb_undef;
110 }
111 }

Above, at line 84, creates a root node for splay-tree (self adjusting binary searching tree). This tree is used to records time of file in compiling.
cpp_get_callbacks, at line 95 above, fetches the address of cb field of cpp_reader, which bundles language dependent handlers here.
We have seen the definition of cpp_options, it is the collection of flags that controls the behavior of the lexer. At line 1161 in c_common_post_option, cpp_post_options adjusts these flags.

441 void
442 cpp_post_options (cpp_reader *pfile) in cpppinit.c
443 {
444 sanity_checks (pfile);
445
446 post_options (pfile);
447
448 /* Mark named operators before handling command line macros. */
449 if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
450 mark_named_operators (pfile);
451 }

Below at line 623, field traditional in cpp_reader is set by option -traditional-cpp (default value is 0), if nonzero, means using traditional preprocessor.

605 static void
606 post_options (cpp_reader *pfile) in cpppinit.c
607 {
608 /* -Wtraditional is not useful in C++ mode. */
609 if (CPP_OPTION (pfile, cplusplus))
610 CPP_OPTION (pfile, warn_traditional) = 0;
611
612 /* Permanently disable macro expansion if we are rescanning
613 preprocessed text. Read preprocesed source in ISO mode. */
614 if (CPP_OPTION (pfile, preprocessed))
615 {
616 pfile->state.prevent_expansion = 1;
617 CPP_OPTION (pfile, traditional) = 0;
618 }
619
620 if (CPP_OPTION (pfile, warn_trigraphs) == 2)
621 CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
622
623 if (CPP_OPTION (pfile, traditional))
624 {
625 CPP_OPTION (pfile, cplusplus_comments) = 0;
626
627 /* Traditional CPP does not accurately track column information. */
628 CPP_OPTION (pfile, show_column) = 0;
629 CPP_OPTION (pfile, trigraphs) = 0;
630 CPP_OPTION (pfile, warn_trigraphs) = 0;
631 }
632 }

As long as using C++, operator_names will also be set, mark_named_operators inserts C++ operators into hash_table of cpp_reader.

320 static void
321 mark_named_operators (cpp_reader *pfile) in cpppinit.c
322 {
323 const struct builtin *b;
324
325 for (b = operator_array;
326 b < (operator_array + ARRAY_SIZE (operator_array));
327 b++)
328 {
329 cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
330 hp->flags |= NODE_OPERATOR;
331 hp->is_directive = 0;
332 hp->directive_index = b->value;
333 }
334 }

Above at line 325, operator_array is of type builtin which is just records the literal name of the builtin funciton and its enum value associated. The builtin operators of C++ are: and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq. The value of builtin is defined in TTYPE_TABLE, which is the identifer for the builtin object.

281 struct builtin in cpppinit.c
282 {
283 const uchar *name;
284 unsigned short len;
285 unsigned short value;
286 };

288 #define B(n, t) { DSC(n), t }

303 static const struct builtin operator_array[] =
304 {
305 B("and", CPP_AND_AND),
306 B("and_eq", CPP_AND_EQ),
307 B("bitand", CPP_AND),
308 B("bitor", CPP_OR),
309 B("compl", CPP_COMPL),
310 B("not", CPP_NOT),
311 B("not_eq", CPP_NOT_EQ),
312 B("or", CPP_OR_OR),
313 B("or_eq", CPP_OR_EQ),
314 B("xor", CPP_XOR),
315 B("xor_eq", CPP_XOR_EQ)
316 };
317 #undef B

Above cpp_lookup at line 329 will insert the node into hash_table of cpp_reader which has element of type ht_identifier (but cpp_hashnode indeed).