?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
struct / union in initializer, RFE #901.
[sdcc.git] / sdcc / support / cpp / gcc / optc-gen.awk
blob2bd58a17cc3b7fcefb3c7474c4477c683e5b0125
1 # Copyright (C) 2003-2022 Free Software Foundation, Inc.
2 # Contributed by Kelley Cook, June 2004.
3 # Original code from Neil Booth, May 2003.
4 #
5 # This program is free software; you can redistribute it and/or modify it
6 # under the terms of the GNU General Public License as published by the
7 # Free Software Foundation; either version 3, or (at your option) any
8 # later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program; see the file COPYING3. If not see
17 # <http://www.gnu.org/licenses/>.
18
19 # This Awk script reads in the option records generated from
20 # opt-gather.awk, combines the flags of duplicate options and generates a
21 # C file.
22 #
23
24 # This program uses functions from opt-functions.awk and code from
25 # opt-read.awk.
26 #
27 # Usage: awk -f opt-functions.awk -f opt-read.awk -f optc-gen.awk \
28 # [-v header_name=header.h] < inputfile > options.cc
29
30 # Dump that array of options into a C file.
31 END {
32
33
34 # Combine the flags of identical switches. Switches
35 # appear many times if they are handled by many front
36 # ends, for example.
37 for (i = 0; i < n_opts; i++) {
38 merged_flags[i] = flags[i]
39 }
40 for (i = 0; i < n_opts; i++) {
41 while(i + 1 != n_opts && opts[i] == opts[i + 1] ) {
42 merged_flags[i + 1] = merged_flags[i] " " merged_flags[i + 1];
43 i++;
44 }
45 }
46
47 # Record EnabledBy and LangEnabledBy uses.
48 n_enabledby = 0;
49 for (i = 0; i < n_langs; i++) {
50 n_enabledby_lang[i] = 0;
51 }
52 for (i = 0; i < n_opts; i++) {
53 enabledby_arg = opt_args("EnabledBy", flags[i]);
54 if (enabledby_arg != "") {
55 logical_and = index(enabledby_arg, " && ");
56 if (logical_and != 0) {
57 # EnabledBy(arg1 && arg2)
58 split_sep = " && ";
59 } else {
60 # EnabledBy(arg) or EnabledBy(arg1 || arg2 || arg3)
61 split_sep = " \\|\\| ";
62 }
63 n_enabledby_names = split(enabledby_arg, enabledby_names, split_sep);
64 if (logical_and != 0 && n_enabledby_names > 2) {
65 print "#error " opts[i] " EnabledBy(Wfoo && Wbar && Wbaz) currently not supported"
66 }
67 for (j = 1; j <= n_enabledby_names; j++) {
68 enabledby_name = enabledby_names[j];
69 enabledby_index = opt_numbers[enabledby_name];
70 if (enabledby_index == "") {
71 print "#error " opts[i] " Enabledby(" enabledby_name "), unknown option '" enabledby_name "'"
72 } else if (!flag_set_p("Common", merged_flags[enabledby_index])) {
73 print "#error " opts[i] " Enabledby(" enabledby_name "), '" \
74 enabledby_name "' must have flag 'Common'" \
75 " to use Enabledby(), otherwise use LangEnabledBy()"
76 } else {
77 condition = "";
78 if (logical_and != 0) {
79 opt_var_name_1 = search_var_name(enabledby_names[1], opt_numbers, opts, flags, n_opts);
80 opt_var_name_2 = search_var_name(enabledby_names[2], opt_numbers, opts, flags, n_opts);
81 if (opt_var_name_1 == "") {
82 print "#error " enabledby_names[1] " does not have a Var() flag"
83 }
84 if (opt_var_name_2 == "") {
85 print "#error " enabledby_names[2] " does not have a Var() flag"
86 }
87 condition = "opts->x_" opt_var_name_1 " && opts->x_" opt_var_name_2;
88 }
89 if (enables[enabledby_name] == "") {
90 enabledby[n_enabledby] = enabledby_name;
91 n_enabledby++;
92 }
93 enables[enabledby_name] = enables[enabledby_name] opts[i] ";";
94 enablesif[enabledby_name] = enablesif[enabledby_name] condition ";";
95 }
96 }
97 }
98
99 enabledby_arg = opt_args("LangEnabledBy", flags[i]);
100 if (enabledby_arg != "") {
101 enabledby_n_args = n_args(enabledby_arg)
102 if (enabledby_n_args != 2 \
103 && enabledby_n_args != 4) {
104 print "#error " opts[i] " LangEnabledBy(" enabledby_arg ") must specify two or four arguments"
105 }
106
107 enabledby_langs = nth_arg(0, enabledby_arg);
108 if (enabledby_langs == "")
109 print "#error " opts[i] " LangEnabledBy(" enabledby_arg ") must specify LANGUAGE"
110 enabledby_opt = nth_arg(1, enabledby_arg);
111 if (enabledby_opt == "")
112 print "#error " opts[i] " LangEnabledBy(" enabledby_arg ") must specify OPT"
113
114 enabledby_posarg_negarg = ""
115 if (enabledby_n_args == 4) {
116 enabledby_posarg = nth_arg(2, enabledby_arg);
117 enabledby_negarg = nth_arg(3, enabledby_arg);
118 if (enabledby_posarg == "" \
119 || enabledby_negarg == "")
120 print "#error " opts[i] " LangEnabledBy(" enabledby_arg ") with four arguments must specify POSARG and NEGARG"
121 else
122 enabledby_posarg_negarg = "," enabledby_posarg "," enabledby_negarg
123 }
124
125 n_enabledby_arg_langs = split(enabledby_langs, enabledby_arg_langs, " ");
126 n_enabledby_array = split(enabledby_opt, enabledby_array, " \\|\\| ");
127 for (k = 1; k <= n_enabledby_array; k++) {
128 enabledby_index = opt_numbers[enabledby_array[k]];
129 if (enabledby_index == "") {
130 print "#error " opts[i] " LangEnabledBy(" enabledby_arg "), unknown option '" enabledby_opt "'"
131 continue
132 }
133
134 for (j = 1; j <= n_enabledby_arg_langs; j++) {
135 lang_name = enabledby_arg_langs[j]
136 lang_index = lang_numbers[lang_name];
137 if (lang_index == "") {
138 print "// #error " opts[i] " LangEnabledBy(" enabledby_arg "), unknown language '" lang_name "'"
139 continue
140 }
141
142 lang_name = lang_sanitized_name(lang_name);
143
144 if (enables[lang_name,enabledby_array[k]] == "") {
145 enabledby[lang_name,n_enabledby_lang[lang_index]] = enabledby_array[k];
146 n_enabledby_lang[lang_index]++;
147 }
148 enables[lang_name,enabledby_array[k]] \
149 = enables[lang_name,enabledby_array[k]] opts[i] enabledby_posarg_negarg ";";
150 }
151 }
152 }
153
154 if (flag_set_p("Param", flags[i]) && !(opts[i] ~ "^-param="))
155 print "#error Parameter option name '" opts[i] "' must start with '-param='"
156 }
157
158
159 print "/* This file is auto-generated by optc-gen.awk. */"
160 print ""
161 n_headers = split(header_name, headers, " ")
162 for (i = 1; i <= n_headers; i++)
163 print "#include " quote headers[i] quote
164 print "#include " quote "opts.h" quote
165 print "#include " quote "intl.h" quote
166 print "#include " quote "insn-attr-common.h" quote
167 print ""
168
169 if (n_extra_c_includes > 0) {
170 for (i = 0; i < n_extra_c_includes; i++) {
171 print "#include " quote extra_c_includes[i] quote
172 }
173 print ""
174 }
175
176 for (i = 0; i < n_enums; i++) {
177 name = enum_names[i]
178 type = enum_type[name]
179 print "static const struct cl_enum_arg cl_enum_" name \
180 "_data[] = "
181 print "{"
182 print enum_data[name] " { NULL, 0, 0 }"
183 print "};"
184 print ""
185 print "static void"
186 print "cl_enum_" name "_set (void *var, int value)"
187 print "{"
188 print " *((" type " *) var) = (" type ") value;"
189 print "}"
190 print ""
191 print "static int"
192 print "cl_enum_" name "_get (const void *var)"
193 print "{"
194 print " return (int) *((const " type " *) var);"
195 print "}"
196 print ""
197 }
198
199 print "const struct cl_enum cl_enums[] ="
200 print "{"
201 for (i = 0; i < n_enums; i++) {
202 name = enum_names[i]
203 ehelp = enum_help[name]
204 if (ehelp == "")
205 ehelp = "NULL"
206 else
207 ehelp = quote ehelp quote
208 unknown_error = enum_unknown_error[name]
209 if (unknown_error == "")
210 unknown_error = "NULL"
211 else
212 unknown_error = quote unknown_error quote
213 print " {"
214 print " " ehelp ","
215 print " " unknown_error ","
216 print " cl_enum_" name "_data,"
217 print " sizeof (" enum_type[name] "),"
218 print " cl_enum_" name "_set,"
219 print " cl_enum_" name "_get"
220 print " },"
221 }
222 print "};"
223 print "const unsigned int cl_enums_count = " n_enums ";"
224 print ""
225
226 print "const struct gcc_options global_options_init =\n{"
227 for (i = 0; i < n_extra_vars; i++) {
228 var = extra_vars[i]
229 init = extra_vars[i]
230 if (var ~ "=" ) {
231 sub(".*= *", "", init)
232 } else {
233 init = "0"
234 }
235 sub(" *=.*", "", var)
236 name = var
237 sub("^.*[ *]", "", name)
238 sub("\\[.*\\]$", "", name)
239 var_seen[name] = 1
240 print " " init ", /* " name " */"
241 }
242 for (i = 0; i < n_opts; i++) {
243 name = var_name(flags[i]);
244 init = opt_args("Init", flags[i])
245
246 if (name == "") {
247 if (init != "")
248 print "#error " opts[i] " must specify Var to use Init"
249 continue;
250 }
251
252 if (init != "") {
253 if (name in var_init && var_init[name] != init)
254 print "#error multiple initializers for " name
255 var_init[name] = init
256 }
257 }
258 for (i = 0; i < n_opts; i++) {
259 name = var_name(flags[i]);
260 if (name == "")
261 continue;
262
263 if (name in var_seen)
264 continue;
265
266 if (name in var_init)
267 init = var_init[name]
268 else
269 init = "0"
270
271 print " " init ", /* " name " */"
272
273 var_seen[name] = 1;
274 }
275 for (i = 0; i < n_opts; i++) {
276 name = static_var(opts[i], flags[i]);
277 if (name != "") {
278 print " 0, /* " name " (private state) */"
279 print "#undef x_" name
280 }
281 }
282 for (i = 0; i < n_opts; i++) {
283 if (flag_set_p("SetByCombined", flags[i]))
284 print " false, /* frontend_set_" var_name(flags[i]) " */"
285 }
286 print "};"
287 print ""
288 print "struct gcc_options global_options;"
289 print "struct gcc_options global_options_set;"
290 print ""
291
292 print "const char * const lang_names[] =\n{"
293 for (i = 0; i < n_langs; i++) {
294 macros[i] = "CL_" lang_sanitized_name(langs[i])
295 s = substr(" ", length (macros[i]))
296 print " " quote langs[i] quote ","
297 }
298
299 print " 0\n};\n"
300 print "const unsigned int cl_options_count = N_OPTS;\n"
301 print "#if (1U << " n_langs ") > CL_MIN_OPTION_CLASS"
302 print " #error the number of languages exceeds the implementation limit"
303 print "#endif"
304 print "const unsigned int cl_lang_count = " n_langs ";\n"
305
306 print "const struct cl_option cl_options[] =\n{"
307
308 j = 0
309 for (i = 0; i < n_opts; i++) {
310 back_chain[i] = "N_OPTS";
311 indices[opts[i]] = j;
312 # Combine the flags of identical switches. Switches
313 # appear many times if they are handled by many front
314 # ends, for example.
315 while( i + 1 != n_opts && opts[i] == opts[i + 1] ) {
316 flags[i + 1] = flags[i] " " flags[i + 1];
317 if (help[i + 1] == "")
318 help[i + 1] = help[i]
319 else if (help[i] != "" && help[i + 1] != help[i]) {
320 print "#error Multiple different help strings for " \
321 opts[i] ":"
322 print "#error " help[i]
323 print "#error " help[i + 1]
324 }
325
326 i++;
327 back_chain[i] = "N_OPTS";
328 indices[opts[i]] = j;
329 }
330 j++;
331 }
332
333 optindex = 0
334 for (i = 0; i < n_opts; i++) {
335 # With identical flags, pick only the last one. The
336 # earlier loop ensured that it has all flags merged,
337 # and a nonempty help text if one of the texts was nonempty.
338 while( i + 1 != n_opts && opts[i] == opts[i + 1] ) {
339 i++;
340 }
341
342 len = length (opts[i]);
343 enum = opt_enum(opts[i])
344
345 # If this switch takes joined arguments, back-chain all
346 # subsequent switches to it for which it is a prefix. If
347 # a later switch S is a longer prefix of a switch T, T
348 # will be back-chained to S in a later iteration of this
349 # for() loop, which is what we want.
350 if (flag_set_p("Joined.*", flags[i])) {
351 for (j = i + 1; j < n_opts; j++) {
352 if (substr (opts[j], 1, len) != opts[i])
353 break;
354 back_chain[j] = enum;
355 }
356 }
357
358 s = substr(" ", length (opts[i]))
359 if (i + 1 == n_opts)
360 comma = ""
361
362 if (help[i] == "")
363 hlp = "NULL"
364 else
365 hlp = quote help[i] quote;
366
367 missing_arg_error = opt_args("MissingArgError", flags[i])
368 if (missing_arg_error == "")
369 missing_arg_error = "NULL"
370 else
371 missing_arg_error = quote missing_arg_error quote
372
373
374 warn_message = opt_args("Warn", flags[i])
375 if (warn_message == "")
376 warn_message = "NULL"
377 else
378 warn_message = quote warn_message quote
379
380 alias_arg = opt_args("Alias", flags[i])
381 if (alias_arg == "") {
382 if (flag_set_p("Ignore", flags[i])) {
383 alias_data = "NULL, NULL, OPT_SPECIAL_ignore"
384 if (warn_message != "NULL")
385 print "#error Ignored option with Warn"
386 if (var_name(flags[i]) != "")
387 print "#error Ignored option with Var"
388 }
389 else if (flag_set_p("Deprecated", flags[i]))
390 print "#error Deprecated was replaced with WarnRemoved"
391 else if (flag_set_p("WarnRemoved", flags[i])) {
392 alias_data = "NULL, NULL, OPT_SPECIAL_warn_removed"
393 if (warn_message != "NULL")
394 print "#error WarnRemoved option with Warn"
395 }
396 else
397 alias_data = "NULL, NULL, N_OPTS"
398 if (flag_set_p("Enum.*", flags[i])) {
399 if (!flag_set_p("RejectNegative", flags[i]) \
400 && !flag_set_p("EnumSet", flags[i]) \
401 && !flag_set_p("EnumBitSet", flags[i]) \
402 && opts[i] ~ "^[Wfgm]")
403 print "#error Enum allowing negative form"
404 }
405 } else {
406 alias_opt = nth_arg(0, alias_arg)
407 alias_posarg = nth_arg(1, alias_arg)
408 alias_negarg = nth_arg(2, alias_arg)
409
410 if (var_ref(opts[i], flags[i]) != "(unsigned short) -1")
411 print "#error Alias setting variable"
412
413 if (alias_posarg != "" && alias_negarg == "") {
414 if (!flag_set_p("RejectNegative", flags[i]) \
415 && opts[i] ~ "^[Wfm]")
416 print "#error Alias with single argument " \
417 "allowing negative form"
418 }
419 if (alias_posarg != "" \
420 && flag_set_p("NegativeAlias", flags[i])) {
421 print "#error Alias with multiple arguments " \
422 "used with NegativeAlias"
423 }
424
425 alias_opt = opt_enum(alias_opt)
426 if (alias_posarg == "")
427 alias_posarg = "NULL"
428 else
429 alias_posarg = quote alias_posarg quote
430 if (alias_negarg == "")
431 alias_negarg = "NULL"
432 else
433 alias_negarg = quote alias_negarg quote
434 alias_data = alias_posarg ", " alias_negarg ", " alias_opt
435 }
436
437 neg = opt_args("Negative", flags[i]);
438 if (neg != "")
439 idx = indices[neg]
440 else {
441 if (flag_set_p("RejectNegative", flags[i]))
442 idx = -1;
443 else {
444 if (opts[i] ~ "^[Wfgm]")
445 idx = indices[opts[i]];
446 else
447 idx = -1;
448 }
449 }
450 # Split the printf after %u to work around an ia64-hp-hpux11.23
451 # awk bug.
452 printf(" /* [%i] = */ {\n", optindex)
453 printf(" %c-%s%c,\n %s,\n %s,\n %s,\n %s, %s, %u,",
454 quote, opts[i], quote, hlp, missing_arg_error, warn_message,
455 alias_data, back_chain[i], len)
456 printf(" /* .neg_idx = */ %d,\n", idx)
457 condition = opt_args("Condition", flags[i])
458 cl_flags = switch_flags(flags[i])
459 cl_bit_fields = switch_bit_fields(flags[i])
460 cl_zero_bit_fields = switch_bit_fields("")
461 if (condition != "")
462 printf("#if %s\n" \
463 " %s,\n" \
464 " 0, %s,\n" \
465 "#else\n" \
466 " 0,\n" \
467 " 1 /* Disabled. */, %s,\n" \
468 "#endif\n",
469 condition, cl_flags, cl_bit_fields, cl_zero_bit_fields)
470 else
471 printf(" %s,\n" \
472 " 0, %s,\n",
473 cl_flags, cl_bit_fields)
474 printf(" %s, %s, %s }%s\n", var_ref(opts[i], flags[i]),
475 var_set(flags[i]), integer_range_info(opt_args("IntegerRange", flags[i]),
476 opt_args("Init", flags[i]), opts[i], flag_set_p("UInteger", flags[i])), comma)
477
478 # Bump up the informational option index.
479 ++optindex
480 }
481
482 print "};"
483
484 print "\n\n"
485 print "bool "
486 print "common_handle_option_auto (struct gcc_options *opts, "
487 print " struct gcc_options *opts_set, "
488 print " const struct cl_decoded_option *decoded, "
489 print " unsigned int lang_mask, int kind, "
490 print " location_t loc, "
491 print " const struct cl_option_handlers *handlers, "
492 print " diagnostic_context *dc) "
493 print "{ "
494 print " size_t scode = decoded->opt_index; "
495 print " HOST_WIDE_INT value = decoded->value; "
496 print " enum opt_code code = (enum opt_code) scode; "
497 print " "
498 print " gcc_assert (decoded->canonical_option_num_elements <= 2); "
499 print " "
500 print " switch (code) "
501 print " { "
502 # Handle EnabledBy
503 for (i = 0; i < n_enabledby; i++) {
504 enabledby_name = enabledby[i];
505 print " case " opt_enum(enabledby_name) ":"
506 n_enables = split(enables[enabledby_name], thisenable, ";");
507 n_enablesif = split(enablesif[enabledby_name], thisenableif, ";");
508 if (n_enables != n_enablesif) {
509 print "#error n_enables != n_enablesif: Something went wrong!"
510 }
511 for (j = 1; j < n_enables; j++) {
512 opt_var_name = var_name(flags[opt_numbers[thisenable[j]]]);
513 if (opt_var_name != "") {
514 condition = "!opts_set->x_" opt_var_name
515 if (thisenableif[j] != "") {
516 value = "(" thisenableif[j] ")"
517 } else {
518 value = "value"
519 }
520 print " if (" condition ")"
521 print " handle_generated_option (opts, opts_set,"
522 print " " opt_enum(thisenable[j]) ", NULL, " value ","
523 print " lang_mask, kind, loc, handlers, true, dc);"
524 } else {
525 print "#error " thisenable[j] " does not have a Var() flag"
526 }
527 }
528 print " break;\n"
529 }
530 print " default: "
531 print " break; "
532 print " } "
533 print " return true; "
534 print "} "
535
536 # Handle LangEnabledBy
537 for (i = 0; i < n_langs; i++) {
538 lang_name = lang_sanitized_name(langs[i]);
539 mark_unused = " ATTRIBUTE_UNUSED";
540
541 print "\n\n"
542 print "bool "
543 print lang_name "_handle_option_auto (struct gcc_options *opts" mark_unused ", "
544 print " struct gcc_options *opts_set" mark_unused ", "
545 print " size_t scode" mark_unused ", const char *arg" mark_unused ", HOST_WIDE_INT value" mark_unused ", "
546 print " unsigned int lang_mask" mark_unused ", int kind" mark_unused ", "
547 print " location_t loc" mark_unused ", "
548 print " const struct cl_option_handlers *handlers" mark_unused ", "
549 print " diagnostic_context *dc" mark_unused ") "
550 print "{ "
551 print " enum opt_code code = (enum opt_code) scode; "
552 print " "
553 print " switch (code) "
554 print " { "
555
556 for (k = 0; k < n_enabledby_lang[i]; k++) {
557 enabledby_name = enabledby[lang_name,k];
558 print " case " opt_enum(enabledby_name) ":"
559 n_thisenable = split(enables[lang_name,enabledby_name], thisenable, ";");
560 for (j = 1; j < n_thisenable; j++) {
561 n_thisenable_args = split(thisenable[j], thisenable_args, ",");
562 if (n_thisenable_args == 1) {
563 thisenable_opt = thisenable[j];
564 value = "value";
565 } else {
566 thisenable_opt = thisenable_args[1];
567 with_posarg = thisenable_args[2];
568 with_negarg = thisenable_args[3];
569 value = "value ? " with_posarg " : " with_negarg;
570 }
571 opt_var_name = var_name(flags[opt_numbers[thisenable_opt]]);
572 if (opt_var_name != "") {
573 print " if (!opts_set->x_" opt_var_name ")"
574 print " handle_generated_option (opts, opts_set,"
575 print " " opt_enum(thisenable_opt) ", NULL, " value ","
576 print " lang_mask, kind, loc, handlers, true, dc);"
577 } else {
578 print "#error " thisenable_opt " does not have a Var() flag"
579 }
580 }
581 print " break;\n"
582 }
583 print " default: "
584 print " break; "
585 print " } "
586 print " return true; "
587 print "} "
588 }
589
590 #Handle CPP()
591 print "\n"
592 print "#include " quote "cpplib.h" quote;
593 print "void"
594 print "cpp_handle_option_auto (const struct gcc_options * opts, "
595 print " size_t scode, struct cpp_options * cpp_opts)"
596 print "{ "
597 print " enum opt_code code = (enum opt_code) scode; "
598 print " "
599 print " switch (code) "
600 print " { "
601 for (i = 0; i < n_opts; i++) {
602 # With identical flags, pick only the last one. The
603 # earlier loop ensured that it has all flags merged,
604 # and a nonempty help text if one of the texts was nonempty.
605 while( i + 1 != n_opts && opts[i] == opts[i + 1] ) {
606 i++;
607 }
608
609 cpp_option = nth_arg(0, opt_args("CPP", flags[i]));
610 if (cpp_option != "") {
611 opt_var_name = var_name(flags[i]);
612 init = opt_args("Init", flags[i])
613 if (opt_var_name != "" && init != "") {
614 print " case " opt_enum(opts[i]) ":"
615 print " cpp_opts->" cpp_option " = opts->x_" opt_var_name ";"
616 print " break;"
617 } else if (opt_var_name == "" && init == "") {
618 print "#error CPP() requires setting Init() and Var() for " opts[i]
619 } else if (opt_var_name != "") {
620 print "#error CPP() requires setting Init() for " opts[i]
621 } else {
622 print "#error CPP() requires setting Var() for " opts[i]
623 }
624 }
625 }
626 print " default: "
627 print " break; "
628 print " } "
629 print "}\n"
630 print "void"
631 print "init_global_opts_from_cpp(struct gcc_options * opts, "
632 print " const struct cpp_options * cpp_opts)"
633 print "{ "
634 for (i = 0; i < n_opts; i++) {
635 # With identical flags, pick only the last one. The
636 # earlier loop ensured that it has all flags merged,
637 # and a nonempty help text if one of the texts was nonempty.
638 while( i + 1 != n_opts && opts[i] == opts[i + 1] ) {
639 i++;
640 }
641 cpp_option = nth_arg(0, opt_args("CPP", flags[i]));
642 opt_var_name = var_name(flags[i]);
643 if (cpp_option != "" && opt_var_name != "") {
644 print " opts->x_" opt_var_name " = cpp_opts->" cpp_option ";"
645 }
646 }
647 print "} "
648
649 split("", var_seen, ":")
650 print "\n#if !defined(GENERATOR_FILE) && defined(ENABLE_PLUGIN)"
651 print "DEBUG_VARIABLE const struct cl_var cl_vars[] =\n{"
652
653 for (i = 0; i < n_opts; i++) {
654 name = var_name(flags[i]);
655 if (name == "")
656 continue;
657 var_seen[name] = 1;
658 }
659
660 for (i = 0; i < n_extra_vars; i++) {
661 var = extra_vars[i]
662 sub(" *=.*", "", var)
663 name = var
664 sub("^.*[ *]", "", name)
665 sub("\\[.*\\]$", "", name)
666 if (name in var_seen)
667 continue;
668 print " { " quote name quote ", offsetof (struct gcc_options, x_" name ") },"
669 var_seen[name] = 1
670 }
671
672 print " { NULL, (unsigned short) -1 }\n};\n#endif"
673
674 }
SDCC git mirror