cde/util/tradcpp/main.c

   1 /*-
   2  * Copyright (c) 2010 The NetBSD Foundation, Inc.
   3  * All rights reserved.
   4  *
   5  * This code is derived from software contributed to The NetBSD Foundation
   6  * by David A. Holland.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  21  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27  * POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <stdio.h>
  31 #include <stdarg.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <errno.h>
  35
  36 #include "bool.h"
  37 #include "version.h"
  38 #include "config.h"
  39 #include "utils.h"
  40 #include "array.h"
  41 #include "mode.h"
  42 #include "place.h"
  43 #include "files.h"
  44 #include "directive.h"
  45 #include "macro.h"
  46
  47 struct mode mode = {
  48         .werror = false,
  49
  50         .input_allow_dollars = false,
  51         .input_tabstop = 8,
  52
  53         .do_stdinc = true,
  54         .do_stddef = true,
  55
  56         .do_output = true,
  57         .output_linenumbers = true,
  58         .output_cheaplinenumbers = false,
  59         .output_retain_comments = false,
  60         .output_file = NULL,
  61
  62         .do_depend = false,
  63         .depend_report_system = false,
  64         .depend_assume_generated = false,
  65         .depend_issue_fakerules = false,
  66         .depend_quote_target = true,
  67         .depend_target = NULL,
  68         .depend_file = NULL,
  69
  70         .do_macrolist = false,
  71         .macrolist_include_stddef = false,
  72         .macrolist_include_expansions = false,
  73
  74         .do_trace = false,
  75         .trace_namesonly = false,
  76         .trace_indented = false,
  77 };
  78
  79 struct warns warns = {
  80         .endiflabels = true,
  81         .nestcomment = false,
  82         .undef = false,
  83         .unused = false,
  84 };
  85
  86 ////////////////////////////////////////////////////////////
  87 // commandline macros
  88
  89 struct commandline_macro {
  90         struct place where;
  91         struct place where2;
  92         const char *macro;
  93         const char *expansion;
  94 };
  95
  96 static struct array commandline_macros;
  97
  98 static
  99 void
 100 commandline_macros_init(void)
 101 {
 102         array_init(&commandline_macros);
 103 }
 104
 105 static
 106 void
 107 commandline_macros_cleanup(void)
 108 {
 109         unsigned i, num;
 110         struct commandline_macro *cm;
 111
 112         num = array_num(&commandline_macros);
 113         for (i=0; i<num; i++) {
 114                 cm = array_get(&commandline_macros, i);
 115                 dofree(cm, sizeof(*cm));
 116         }
 117         array_setsize(&commandline_macros, 0);
 118
 119         array_cleanup(&commandline_macros);
 120 }
 121
 122 static
 123 void
 124 commandline_macro_add(const struct place *p, const char *macro,
 125                       const struct place *p2, const char *expansion)
 126 {
 127         struct commandline_macro *cm;
 128
 129         cm = domalloc(sizeof(*cm));
 130         cm->where = *p;
 131         cm->where2 = *p2;
 132         cm->macro = macro;
 133         cm->expansion = expansion;
 134
 135         array_add(&commandline_macros, cm, NULL);
 136 }
 137
 138 static
 139 void
 140 commandline_def(const struct place *p, char *str)
 141 {
 142         struct place p2;
 143         char *val;
 144
 145         if (*str == '\0') {
 146                 complain(NULL, "-D: macro name expected");
 147                 die();
 148         }
 149
 150         val = strchr(str, '=');
 151         if (val != NULL) {
 152                 *val = '\0';
 153                 val++;
 154         }
 155
 156         if (val) {
 157                 p2 = *p;
 158                 place_addcolumns(&p2, strlen(str));
 159         } else {
 160                 place_setbuiltin(&p2, 1);
 161         }
 162         commandline_macro_add(p, str, &p2, val ? val : "1");
 163 }
 164
 165 static
 166 void
 167 commandline_undef(const struct place *p, char *str)
 168 {
 169         if (*str == '\0') {
 170                 complain(NULL, "-U: macro name expected");
 171                 die();
 172         }
 173         commandline_macro_add(p, str, p, NULL);
 174 }
 175
 176 static
 177 void
 178 apply_commandline_macros(void)
 179 {
 180         struct commandline_macro *cm;
 181         unsigned i, num;
 182
 183         num = array_num(&commandline_macros);
 184         for (i=0; i<num; i++) {
 185                 cm = array_get(&commandline_macros, i);
 186                 if (cm->expansion != NULL) {
 187                         macro_define_plain(&cm->where, cm->macro,
 188                                            &cm->where2, cm->expansion);
 189                 } else {
 190                         macro_undef(cm->macro);
 191                 }
 192                 dofree(cm, sizeof(*cm));
 193         }
 194         array_setsize(&commandline_macros, 0);
 195 }
 196
 197 static
 198 void
 199 apply_magic_macro(unsigned num, const char *name)
 200 {
 201         struct place p;
 202
 203         place_setbuiltin(&p, num);
 204         macro_define_magic(&p, name);
 205 }
 206
 207 static
 208 void
 209 apply_builtin_macro(unsigned num, const char *name, const char *val)
 210 {
 211         struct place p;
 212
 213         place_setbuiltin(&p, num);
 214         macro_define_plain(&p, name, &p, val);
 215 }
 216
 217 static
 218 void
 219 apply_builtin_macros(void)
 220 {
 221         unsigned n = 1;
 222
 223         apply_magic_macro(n++, "__FILE__");
 224         apply_magic_macro(n++, "__LINE__");
 225
 226 #ifdef CONFIG_OS
 227         apply_builtin_macro(n++, CONFIG_OS, "1");
 228 #endif
 229 #ifdef CONFIG_OS_2
 230         apply_builtin_macro(n++, CONFIG_OS_2, "1");
 231 #endif
 232
 233 #ifdef CONFIG_CPU
 234         apply_builtin_macro(n++, CONFIG_CPU, "1");
 235 #endif
 236 #ifdef CONFIG_CPU_2
 237         apply_builtin_macro(n++, CONFIG_CPU_2, "1");
 238 #endif
 239
 240 #ifdef CONFIG_SIZE
 241         apply_builtin_macro(n++, CONFIG_SIZE, "1");
 242 #endif
 243 #ifdef CONFIG_BINFMT
 244         apply_builtin_macro(n++, CONFIG_BINFMT, "1");
 245 #endif
 246
 247 #ifdef CONFIG_COMPILER
 248         apply_builtin_macro(n++, CONFIG_COMPILER, VERSION_MAJOR);
 249         apply_builtin_macro(n++, CONFIG_COMPILER_MINOR, VERSION_MINOR);
 250         apply_builtin_macro(n++, "__VERSION__", VERSION_LONG);
 251 #endif
 252 }
 253
 254 ////////////////////////////////////////////////////////////
 255 // extra included files
 256
 257 struct commandline_file {
 258         struct place where;
 259         char *name;
 260         bool suppress_output;
 261 };
 262
 263 static struct array commandline_files;
 264
 265 static
 266 void
 267 commandline_files_init(void)
 268 {
 269         array_init(&commandline_files);
 270 }
 271
 272 static
 273 void
 274 commandline_files_cleanup(void)
 275 {
 276         unsigned i, num;
 277         struct commandline_file *cf;
 278
 279         num = array_num(&commandline_files);
 280         for (i=0; i<num; i++) {
 281                 cf = array_get(&commandline_files, i);
 282                 if (cf != NULL) {
 283                         dofree(cf, sizeof(*cf));
 284                 }
 285         }
 286         array_setsize(&commandline_files, 0);
 287
 288         array_cleanup(&commandline_files);
 289 }
 290
 291 static
 292 void
 293 commandline_addfile(const struct place *p, char *name, bool suppress_output)
 294 {
 295         struct commandline_file *cf;
 296
 297         cf = domalloc(sizeof(*cf));
 298         cf->where = *p;
 299         cf->name = name;
 300         cf->suppress_output = suppress_output;
 301         array_add(&commandline_files, cf, NULL);
 302 }
 303
 304 static
 305 void
 306 commandline_addfile_output(const struct place *p, char *name)
 307 {
 308         commandline_addfile(p, name, false);
 309 }
 310
 311 static
 312 void
 313 commandline_addfile_nooutput(const struct place *p, char *name)
 314 {
 315         commandline_addfile(p, name, true);
 316 }
 317
 318 static
 319 void
 320 read_commandline_files(void)
 321 {
 322         struct commandline_file *cf;
 323         unsigned i, num;
 324         bool save = false;
 325
 326         num = array_num(&commandline_files);
 327         for (i=0; i<num; i++) {
 328                 cf = array_get(&commandline_files, i);
 329                 array_set(&commandline_files, i, NULL);
 330                 if (cf->suppress_output) {
 331                         save = mode.do_output;
 332                         mode.do_output = false;
 333                         file_readquote(&cf->where, cf->name);
 334                         mode.do_output = save;
 335                 } else {
 336                         file_readquote(&cf->where, cf->name);
 337                 }
 338                 dofree(cf, sizeof(*cf));
 339         }
 340         array_setsize(&commandline_files, 0);
 341 }
 342
 343 ////////////////////////////////////////////////////////////
 344 // include path accumulation
 345
 346 static struct stringarray incpath_quote;
 347 static struct stringarray incpath_user;
 348 static struct stringarray incpath_system;
 349 static struct stringarray incpath_late;
 350 static const char *sysroot;
 351
 352 static
 353 void
 354 incpath_init(void)
 355 {
 356         stringarray_init(&incpath_quote);
 357         stringarray_init(&incpath_user);
 358         stringarray_init(&incpath_system);
 359         stringarray_init(&incpath_late);
 360 }
 361
 362 static
 363 void
 364 incpath_cleanup(void)
 365 {
 366         stringarray_setsize(&incpath_quote, 0);
 367         stringarray_setsize(&incpath_user, 0);
 368         stringarray_setsize(&incpath_system, 0);
 369         stringarray_setsize(&incpath_late, 0);
 370
 371         stringarray_cleanup(&incpath_quote);
 372         stringarray_cleanup(&incpath_user);
 373         stringarray_cleanup(&incpath_system);
 374         stringarray_cleanup(&incpath_late);
 375 }
 376
 377 static
 378 void
 379 commandline_isysroot(const struct place *p, char *dir)
 380 {
 381         (void)p;
 382         sysroot = dir;
 383 }
 384
 385 static
 386 void
 387 commandline_addincpath(struct stringarray *arr, char *s)
 388 {
 389         if (*s == '\0') {
 390                 complain(NULL, "Empty include directory");
 391                 die();
 392         }
 393         stringarray_add(arr, s, NULL);
 394 }
 395
 396 static
 397 void
 398 commandline_addincpath_quote(const struct place *p, char *dir)
 399 {
 400         (void)p;
 401         commandline_addincpath(&incpath_quote, dir);
 402 }
 403
 404 static
 405 void
 406 commandline_addincpath_user(const struct place *p, char *dir)
 407 {
 408         (void)p;
 409         commandline_addincpath(&incpath_user, dir);
 410 }
 411
 412 static
 413 void
 414 commandline_addincpath_system(const struct place *p, char *dir)
 415 {
 416         (void)p;
 417         commandline_addincpath(&incpath_system, dir);
 418 }
 419
 420 static
 421 void
 422 commandline_addincpath_late(const struct place *p, char *dir)
 423 {
 424         (void)p;
 425         commandline_addincpath(&incpath_late, dir);
 426 }
 427
 428 static
 429 void
 430 loadincludepath(void)
 431 {
 432         unsigned i, num;
 433         const char *dir;
 434         char *t;
 435
 436         num = stringarray_num(&incpath_quote);
 437         for (i=0; i<num; i++) {
 438                 dir = stringarray_get(&incpath_quote, i);
 439                 files_addquotepath(dir, false);
 440         }
 441         files_addquotepath(NULL, false);
 442
 443         num = stringarray_num(&incpath_user);
 444         for (i=0; i<num; i++) {
 445                 dir = stringarray_get(&incpath_user, i);
 446                 files_addquotepath(dir, false);
 447                 files_addbracketpath(dir, false);
 448         }
 449
 450         if (mode.do_stdinc) {
 451                 if (sysroot != NULL) {
 452                         t = dostrdup3(sysroot, "/", CONFIG_LOCALINCLUDE);
 453                         freestringlater(t);
 454                         dir = t;
 455                 } else {
 456                         dir = CONFIG_LOCALINCLUDE;
 457                 }
 458                 files_addquotepath(dir, true);
 459                 files_addbracketpath(dir, true);
 460
 461                 if (sysroot != NULL) {
 462                         t = dostrdup3(sysroot, "/", CONFIG_SYSTEMINCLUDE);
 463                         freestringlater(t);
 464                         dir = t;
 465                 } else {
 466                         dir = CONFIG_SYSTEMINCLUDE;
 467                 }
 468                 files_addquotepath(dir, true);
 469                 files_addbracketpath(dir, true);
 470         }
 471
 472         num = stringarray_num(&incpath_system);
 473         for (i=0; i<num; i++) {
 474                 dir = stringarray_get(&incpath_system, i);
 475                 files_addquotepath(dir, true);
 476                 files_addbracketpath(dir, true);
 477         }
 478
 479         num = stringarray_num(&incpath_late);
 480         for (i=0; i<num; i++) {
 481                 dir = stringarray_get(&incpath_late, i);
 482                 files_addquotepath(dir, false);
 483                 files_addbracketpath(dir, false);
 484         }
 485 }
 486
 487 ////////////////////////////////////////////////////////////
 488 // silly commandline stuff
 489
 490 static const char *commandline_prefix;
 491
 492 static
 493 void
 494 commandline_setprefix(const struct place *p, char *prefix)
 495 {
 496         (void)p;
 497         commandline_prefix = prefix;
 498 }
 499
 500 static
 501 void
 502 commandline_addincpath_user_withprefix(const struct place *p, char *dir)
 503 {
 504         char *s;
 505
 506         if (commandline_prefix == NULL) {
 507                 complain(NULL, "-iprefix needed");
 508                 die();
 509         }
 510         s = dostrdup3(commandline_prefix, "/", dir);
 511         freestringlater(s);
 512         commandline_addincpath_user(p, s);
 513 }
 514
 515 static
 516 void
 517 commandline_addincpath_late_withprefix(const struct place *p, char *dir)
 518 {
 519         char *s;
 520
 521         if (commandline_prefix == NULL) {
 522                 complain(NULL, "-iprefix needed");
 523                 die();
 524         }
 525         s = dostrdup3(commandline_prefix, "/", dir);
 526         freestringlater(s);
 527         commandline_addincpath_late(p, s);
 528 }
 529
 530 static
 531 void
 532 commandline_setstd(const struct place *p, char *std)
 533 {
 534         (void)p;
 535
 536         if (!strcmp(std, "krc")) {
 537                 return;
 538         }
 539         complain(NULL, "Standard %s not supported by this preprocessor", std);
 540         die();
 541 }
 542
 543 static
 544 void
 545 commandline_setlang(const struct place *p, char *lang)
 546 {
 547         (void)p;
 548
 549         if (!strcmp(lang, "c") || !strcmp(lang, "assembler-with-cpp")) {
 550                 return;
 551         }
 552         complain(NULL, "Language %s not supported by this preprocessor", lang);
 553         die();
 554 }
 555
 556 ////////////////////////////////////////////////////////////
 557 // complex modes
 558
 559 DEAD static
 560 void
 561 commandline_iremap(const struct place *p, char *str)
 562 {
 563         (void)p;
 564         /* XXX */
 565         (void)str;
 566         complain(NULL, "-iremap not supported");
 567         die();
 568 }
 569
 570 static
 571 void
 572 commandline_tabstop(const struct place *p, char *s)
 573 {
 574         char *t;
 575         unsigned long val;
 576
 577         (void)p;
 578
 579         t = strchr(s, '=');
 580         if (t == NULL) {
 581                 /* should not happen */
 582                 complain(NULL, "Invalid tabstop");
 583                 die();
 584         }
 585         t++;
 586         errno = 0;
 587         val = strtoul(t, &t, 10);
 588         if (errno || *t != '\0') {
 589                 complain(NULL, "Invalid tabstop");
 590                 die();
 591         }
 592         if (val > 64) {
 593                 complain(NULL, "Preposterously large tabstop");
 594                 die();
 595         }
 596         mode.input_tabstop = val;
 597 }
 598
 599 /*
 600  * macrolist
 601  */
 602
 603 static
 604 void
 605 commandline_dD(void)
 606 {
 607         mode.do_macrolist = true;
 608         mode.macrolist_include_stddef = false;
 609         mode.macrolist_include_expansions = true;
 610 }
 611
 612 static
 613 void
 614 commandline_dM(void)
 615 {
 616         mode.do_macrolist = true;
 617         mode.macrolist_include_stddef = true;
 618         mode.macrolist_include_expansions = true;
 619         mode.do_output = false;
 620 }
 621
 622 static
 623 void
 624 commandline_dN(void)
 625 {
 626         mode.do_macrolist = true;
 627         mode.macrolist_include_stddef = false;
 628         mode.macrolist_include_expansions = false;
 629 }
 630
 631 /*
 632  * include trace
 633  */
 634
 635 static
 636 void
 637 commandline_dI(void)
 638 {
 639         mode.do_trace = true;
 640         mode.trace_namesonly = false;
 641         mode.trace_indented = false;
 642 }
 643
 644 static
 645 void
 646 commandline_H(void)
 647 {
 648         mode.do_trace = true;
 649         mode.trace_namesonly = true;
 650         mode.trace_indented = true;
 651 }
 652
 653 /*
 654  * depend
 655  */
 656
 657 static
 658 void
 659 commandline_setdependtarget(const struct place *p, char *str)
 660 {
 661         (void)p;
 662         mode.depend_target = str;
 663         mode.depend_quote_target = false;
 664 }
 665
 666 static
 667 void
 668 commandline_setdependtarget_quoted(const struct place *p, char *str)
 669 {
 670         (void)p;
 671         mode.depend_target = str;
 672         mode.depend_quote_target = true;
 673 }
 674
 675 static
 676 void
 677 commandline_setdependoutput(const struct place *p, char *str)
 678 {
 679         (void)p;
 680         mode.depend_file = str;
 681 }
 682
 683 static
 684 void
 685 commandline_M(void)
 686 {
 687         mode.do_depend = true;
 688         mode.depend_report_system = true;
 689         mode.do_output = false;
 690 }
 691
 692 static
 693 void
 694 commandline_MM(void)
 695 {
 696         mode.do_depend = true;
 697         mode.depend_report_system = false;
 698         mode.do_output = false;
 699 }
 700
 701 static
 702 void
 703 commandline_MD(void)
 704 {
 705         mode.do_depend = true;
 706         mode.depend_report_system = true;
 707 }
 708
 709 static
 710 void
 711 commandline_MMD(void)
 712 {
 713         mode.do_depend = true;
 714         mode.depend_report_system = false;
 715 }
 716
 717 static
 718 void
 719 commandline_wall(void)
 720 {
 721         warns.nestcomment = true;
 722         warns.undef = true;
 723         warns.unused = true;
 724 }
 725
 726 static
 727 void
 728 commandline_wnoall(void)
 729 {
 730         warns.nestcomment = false;
 731         warns.undef = false;
 732         warns.unused = false;
 733 }
 734
 735 static
 736 void
 737 commandline_wnone(void)
 738 {
 739         warns.nestcomment = false;
 740         warns.endiflabels = false;
 741         warns.undef = false;
 742         warns.unused = false;
 743 }
 744
 745 ////////////////////////////////////////////////////////////
 746 // options
 747
 748 struct ignore_option {
 749         const char *string;
 750 };
 751
 752 struct flag_option {
 753         const char *string;
 754         bool *flag;
 755         bool setto;
 756 };
 757
 758 struct act_option {
 759         const char *string;
 760         void (*func)(void);
 761 };
 762
 763 struct prefix_option {
 764         const char *string;
 765         void (*func)(const struct place *, char *);
 766 };
 767
 768 struct arg_option {
 769         const char *string;
 770         void (*func)(const struct place *, char *);
 771 };
 772
 773 static const struct ignore_option ignore_options[] = {
 774         { "m32" },
 775         { "traditional" },
 776 };
 777 static const unsigned num_ignore_options = HOWMANY(ignore_options);
 778
 779 static const struct flag_option flag_options[] = {
 780         { "C",                          &mode.output_retain_comments,  true },
 781         { "CC",                         &mode.output_retain_comments,  true },
 782         { "MG",                         &mode.depend_assume_generated, true },
 783         { "MP",                         &mode.depend_issue_fakerules,  true },
 784         { "P",                          &mode.output_linenumbers,      false },
 785         { "Wcomment",                   &warns.nestcomment,    true },
 786         { "Wendif-labels",              &warns.endiflabels,    true },
 787         { "Werror",                     &mode.werror,          true },
 788         { "Wno-comment",                &warns.nestcomment,    false },
 789         { "Wno-endif-labels",           &warns.endiflabels,    false },
 790         { "Wno-error",                  &mode.werror,          false },
 791         { "Wno-undef",                  &warns.undef,          false },
 792         { "Wno-unused-macros",          &warns.unused,         false },
 793         { "Wundef",                     &warns.undef,          true },
 794         { "Wunused-macros",             &warns.unused,         true },
 795         { "fdollars-in-identifiers",    &mode.input_allow_dollars,     true },
 796         { "fno-dollars-in-identifiers", &mode.input_allow_dollars,     false },
 797         { "nostdinc",                   &mode.do_stdinc,               false },
 798         { "p",                          &mode.output_cheaplinenumbers, true },
 799         { "undef",                      &mode.do_stddef,               false },
 800 };
 801 static const unsigned num_flag_options = HOWMANY(flag_options);
 802
 803 static const struct act_option act_options[] = {
 804         { "H",         commandline_H },
 805         { "M",         commandline_M },
 806         { "MD",        commandline_MD },
 807         { "MM",        commandline_MM },
 808         { "MMD",       commandline_MMD },
 809         { "Wall",      commandline_wall },
 810         { "Wno-all",   commandline_wnoall },
 811         { "dD",        commandline_dD },
 812         { "dI",        commandline_dI },
 813         { "dM",        commandline_dM },
 814         { "dN",        commandline_dN },
 815         { "w",         commandline_wnone },
 816 };
 817 static const unsigned num_act_options = HOWMANY(act_options);
 818
 819 static const struct prefix_option prefix_options[] = {
 820         { "D",         commandline_def },
 821         { "I",         commandline_addincpath_user },
 822         { "U",         commandline_undef },
 823         { "ftabstop=", commandline_tabstop },
 824         { "std=",      commandline_setstd },
 825 };
 826 static const unsigned num_prefix_options = HOWMANY(prefix_options);
 827
 828 static const struct arg_option arg_options[] = {
 829         { "MF",          commandline_setdependoutput },
 830         { "MQ",          commandline_setdependtarget_quoted },
 831         { "MT",          commandline_setdependtarget },
 832         { "debuglog",    debuglog_open },
 833         { "idirafter",   commandline_addincpath_late },
 834         { "imacros",     commandline_addfile_nooutput },
 835         { "include",     commandline_addfile_output },
 836         { "iprefix",     commandline_setprefix },
 837         { "iquote",      commandline_addincpath_quote },
 838         { "iremap",      commandline_iremap },
 839         { "isysroot",    commandline_isysroot },
 840         { "isystem",     commandline_addincpath_system },
 841         { "iwithprefix", commandline_addincpath_late_withprefix },
 842         { "iwithprefixbefore", commandline_addincpath_user_withprefix },
 843         { "x",           commandline_setlang },
 844 };
 845 static const unsigned num_arg_options = HOWMANY(arg_options);
 846
 847 static
 848 bool
 849 check_ignore_option(const char *opt)
 850 {
 851         unsigned i;
 852         int r;
 853
 854         for (i=0; i<num_ignore_options; i++) {
 855                 r = strcmp(opt, ignore_options[i].string);
 856                 if (r == 0) {
 857                         return true;
 858                 }
 859                 if (r < 0) {
 860                         break;
 861                 }
 862         }
 863         return false;
 864 }
 865
 866 static
 867 bool
 868 check_flag_option(const char *opt)
 869 {
 870         unsigned i;
 871         int r;
 872
 873         for (i=0; i<num_flag_options; i++) {
 874                 r = strcmp(opt, flag_options[i].string);
 875                 if (r == 0) {
 876                         *flag_options[i].flag = flag_options[i].setto;
 877                         return true;
 878                 }
 879                 if (r < 0) {
 880                         break;
 881                 }
 882         }
 883         return false;
 884 }
 885
 886 static
 887 bool
 888 check_act_option(const char *opt)
 889 {
 890         unsigned i;
 891         int r;
 892
 893         for (i=0; i<num_act_options; i++) {
 894                 r = strcmp(opt, act_options[i].string);
 895                 if (r == 0) {
 896                         act_options[i].func();
 897                         return true;
 898                 }
 899                 if (r < 0) {
 900                         break;
 901                 }
 902         }
 903         return false;
 904 }
 905
 906 static
 907 bool
 908 check_prefix_option(const struct place *p, char *opt)
 909 {
 910         unsigned i, len;
 911         int r;
 912
 913         for (i=0; i<num_prefix_options; i++) {
 914                 len = strlen(prefix_options[i].string);
 915                 r = strncmp(opt, prefix_options[i].string, len);
 916                 if (r == 0) {
 917                         prefix_options[i].func(p, opt + len);
 918                         return true;
 919                 }
 920                 if (r < 0) {
 921                         break;
 922                 }
 923         }
 924         return false;
 925 }
 926
 927 static
 928 bool
 929 check_arg_option(const char *opt, const struct place *argplace, char *arg)
 930 {
 931         unsigned i;
 932         int r;
 933
 934         for (i=0; i<num_arg_options; i++) {
 935                 r = strcmp(opt, arg_options[i].string);
 936                 if (r == 0) {
 937                         if (arg == NULL) {
 938                                 complain(NULL,
 939                                          "Option -%s requires an argument",
 940                                          opt);
 941                                 die();
 942                         }
 943                         arg_options[i].func(argplace, arg);
 944                         return true;
 945                 }
 946                 if (r < 0) {
 947                         break;
 948                 }
 949         }
 950         return false;
 951 }
 952
 953 DEAD PF(2, 3) static
 954 void
 955 usage(const char *progname, const char *fmt, ...)
 956 {
 957         va_list ap;
 958
 959         fprintf(stderr, "%s: ", progname);
 960         va_start(ap, fmt);
 961         vfprintf(stderr, fmt, ap);
 962         va_end(ap);
 963         fprintf(stderr, "\n");
 964
 965         fprintf(stderr, "usage: %s [options] [infile [outfile]]\n", progname);
 966         fprintf(stderr, "Common options:\n");
 967         fprintf(stderr, "   -C               Retain comments\n");
 968         fprintf(stderr, "   -Dmacro[=def]    Predefine macro\n");
 969         fprintf(stderr, "   -Idir            Add to include path\n");
 970         fprintf(stderr, "   -M               Issue depend info\n");
 971         fprintf(stderr, "   -MD              Issue depend info and output\n");
 972         fprintf(stderr, "   -MM              -M w/o system headers\n");
 973         fprintf(stderr, "   -MMD             -MD w/o system headers\n");
 974         fprintf(stderr, "   -nostdinc        Drop default include path\n");
 975         fprintf(stderr, "   -Umacro          Undefine macro\n");
 976         fprintf(stderr, "   -undef           Undefine everything\n");
 977         fprintf(stderr, "   -Wall            Enable all warnings\n");
 978         fprintf(stderr, "   -Werror          Make warnings into errors\n");
 979         fprintf(stderr, "   -w               Disable all warnings\n");
 980         die();
 981 }
 982
 983 ////////////////////////////////////////////////////////////
 984 // exit and cleanup
 985
 986 static struct stringarray freestrings;
 987
 988 static
 989 void
 990 init(void)
 991 {
 992         stringarray_init(&freestrings);
 993
 994         incpath_init();
 995         commandline_macros_init();
 996         commandline_files_init();
 997
 998         place_init();
 999         files_init();
1000         directive_init();
1001         macros_init();
1002 }
1003
1004 static
1005 void
1006 cleanup(void)
1007 {
1008         unsigned i, num;
1009
1010         macros_cleanup();
1011         directive_cleanup();
1012         files_cleanup();
1013         place_cleanup();
1014
1015         commandline_files_cleanup();
1016         commandline_macros_cleanup();
1017         incpath_cleanup();
1018         debuglog_close();
1019
1020         num = stringarray_num(&freestrings);
1021         for (i=0; i<num; i++) {
1022                 dostrfree(stringarray_get(&freestrings, i));
1023         }
1024         stringarray_setsize(&freestrings, 0);
1025         stringarray_cleanup(&freestrings);
1026 }
1027
1028 void
1029 die(void)
1030 {
1031         cleanup();
1032         exit(EXIT_FAILURE);
1033 }
1034
1035 void
1036 freestringlater(char *s)
1037 {
1038         stringarray_add(&freestrings, s, NULL);
1039 }
1040
1041 ////////////////////////////////////////////////////////////
1042 // main
1043
1044 int
1045 main(int argc, char *argv[])
1046 {
1047         const char *progname;
1048         const char *inputfile = NULL;
1049         const char *outputfile = NULL;
1050         struct place cmdplace;
1051         int i;
1052
1053         progname = strrchr(argv[0], '/');
1054         progname = progname == NULL ? argv[0] : progname + 1;
1055         complain_init(progname);
1056
1057         init();
1058
1059         for (i=1; i<argc; i++) {
1060                 if (argv[i][0] != '-' || argv[i][1] == 0) {
1061                         break;
1062                 }
1063                 place_setcommandline(&cmdplace, i, 1);
1064                 if (check_ignore_option(argv[i]+1)) {
1065                         continue;
1066                 }
1067                 if (check_flag_option(argv[i]+1)) {
1068                         continue;
1069                 }
1070                 if (check_act_option(argv[i]+1)) {
1071                         continue;
1072                 }
1073                 if (check_prefix_option(&cmdplace, argv[i]+1)) {
1074                         continue;
1075                 }
1076                 place_setcommandline(&cmdplace, i+1, 1);
1077                 if (check_arg_option(argv[i]+1, &cmdplace, argv[i+1])) {
1078                         i++;
1079                         continue;
1080                 }
1081                 usage(progname, "Invalid option %s", argv[i]);
1082         }
1083         if (i < argc) {
1084                 inputfile = argv[i++];
1085                 if (!strcmp(inputfile, "-")) {
1086                         inputfile = NULL;
1087                 }
1088         }
1089         if (i < argc) {
1090                 outputfile = argv[i++];
1091                 if (!strcmp(outputfile, "-")) {
1092                         outputfile = NULL;
1093                 }
1094         }
1095         if (i < argc) {
1096                 usage(progname, "Extra non-option argument %s", argv[i]);
1097         }
1098
1099         mode.output_file = outputfile;
1100
1101         loadincludepath();
1102         apply_builtin_macros();
1103         apply_commandline_macros();
1104         read_commandline_files();
1105         place_setnowhere(&cmdplace);
1106         file_readabsolute(&cmdplace, inputfile);
1107
1108         cleanup();
1109         if (complain_failed()) {
1110                 return EXIT_FAILURE;
1111         }
1112         return EXIT_SUCCESS;
1113 }