idlcomp/main.cc

   1 // Entry point for the interface compiler
   2 //
   3 // This software is copyright (c) 2006 Scott Wood <scott@buserror.net>.
   4 //
   5 // This software is provided 'as-is', without any express or implied warranty.
   6 // In no event will the authors or contributors be held liable for any damages
   7 // arising from the use of this software.
   8 //
   9 // Permission is hereby granted to everyone, free of charge, to use, copy,
  10 // modify, prepare derivative works of, publish, distribute, perform,
  11 // sublicense, and/or sell copies of the Software, provided that the above
  12 // copyright notice and disclaimer of warranty be included in all copies or
  13 // substantial portions of this software.
  14 //
  15 // The idlc program implements two main functions.  One is to turn
  16 // .idl files into binary type descriptions.  The other is to turn
  17 // those type descriptions into language-specific stubs (though a
  18 // compiler/interpreter could also just read the binary types
  19 // directly, as the ORB does).
  20 //
  21 // For the former function, it is necessary to do the work in multiple
  22 // passes, as not all information is available the first time through due
  23 // to the absence of forward declarations.  The passes are as follows:
  24 //
  25 //   1: Parse the input text, and determine which symbols exist in
  26 //      which namespaces.  At this point, no non-namespace-qualified
  27 //      symbol lookups will be done (though namespace-qualified lookups
  28 //      are done, such as to check for duplicate symbols).
  29 //
  30 //      Objects will be created for each entity (Interface, Struct,
  31 //      Datum, Alias, etc.), but any reference to another entity will be
  32 //      stored as a StrList, not as an object pointer.  This must be the
  33 //      case even if a lookup during this pass would have found
  34 //      something, as on the second pass it might find a "closer"
  35 //      matching symbol added later.
  36 //
  37 //      The StrList will later be looked up with only the entity
  38 //      containing the reference as context, so namespace search rules
  39 //      must not depend on anything else.
  40 //
  41 //      This is the only pass that involves actually reading and
  42 //      parsing the input file(s).
  43 //
  44 //   2: Look up the namespace names of using namespace.* statements.
  45 //      These are the only lookups where order of the statements in the
  46 //      file matters, and it alters the result of a lookup, so it must be
  47 //      completed before chain lookups are done.
  48 //
  49 //   3: Look up the symbol names recorded in pass 1 for aliases, and
  50 //      typedefs, and const datum initializers and types. This is done
  51 //      before the rest of the lookups, so there will always be a
  52 //      complete chain to follow in subsequent passes.
  53 //
  54 //      This is done by calling the virtual lookup_chain() method on
  55 //      the root namespace, which recursively calls it on all of its
  56 //      contents.
  57 //
  58 //   4: Look up other symbol names recorded in pass 1.  At this point,
  59 //      unresolved alias chains may still exist and must be handled,
  60 //      though they should be fixed during this phase so that they do not
  61 //      appear in phase 4.  Typedefs will remain fully chained, as the
  62 //      chain is semantically meaningful and must be preserved in the
  63 //      output.
  64 //
  65 //      Const datum initializers are looked up in this pass despite being
  66 //      chains, since aliases aren't resolved in pass 2, and it's
  67 //      (slightly) easier to do the lookup in pass 3 and resolve the
  68 //      chain in pass 4 than to store a Symbol reference in pass 2,
  69 //      get the concerete sym in pass 3, and still have to either
  70 //      concrete-ize other Datums' initializers or wait until pass 4
  71 //      to resolve the chain.
  72 //
  73 //      This is done by calling the virtual lookup_misc() method on the
  74 //      root namespace, which recursively calls it on all of its
  75 //      contents.  Upon receiving this call, each entity object should
  76 //      call lookup_sym() or lookup_type() on the various StrLists it has
  77 //      stored, but should not do anything with the object pointer
  78 //      until pass 4 (unless the object was satisfactorily initialized
  79 //      in pass 1).
  80 //
  81 //   5: Perform any remaining semantic analysis, now that all references
  82 //      to other entities have been looked up.
  83 //
  84 //      This is done by calling the virtual final_analysis() method on
  85 //      the root namespace, which recursively calls it on all of its
  86 //      contents.
  87 //
  88 //   6: Generate output.
  89 //      This is done by calling the virtual output() method on
  90 //      the root namespace, which recursively calls it on all of its
  91 //      contents.
  92 //
  93 // All circular dependencies must be contained within the set of files
  94 // passed to the compiler in one invocation.  Supporting circular
  95 // dependencies over multiple invocations of the compiler would require
  96 // explicitly running only certain passes, then compiling the other
  97 // batch, and then finishing the original batch.  It could be done with
  98 // some pain (intermediate states would need to be serialized), but I
  99 // only want to do it if there's a real need.  Circular dependencies
 100 // ought to be isolated fairly locally...
 101
 102 #include <climits>
 103 #include <cstdio>
 104 #include <cstdarg>
 105 #include <cstring>
 106 #include <cstdlib>
 107 #include <cerrno>
 108
 109 #include <idlc.h>
 110 #include <lang.h>
 111 #include <targets.h>
 112 #include <util.h>
 113
 114 int num_err;
 115 unsigned int enum_pos;
 116 bool no_output;
 117 bool server_stubs;
 118 bool makedep;
 119 int current_pass;
 120 int traversal;
 121 Con *yylval_con;
 122 String **yylval_string;
 123
 124 UserNameSpaceRef toplevel, cdl_toplevel;
 125 UserNameSpace *output_ns;
 126 NameSpaceRef cur_nspace;
 127 const char *cmdname, *output_dir, *cur_input_file = "<none>", *output_ns_name;
 128
 129 list<const char *> inputs;
 130 list<NameSpaceRef> nspace_stack;
 131 Language *first_lang, *output_lang;
 132 Interface *System_Object;
 133 Struct *System_VStruct;
 134 AutoReleasePool autorelease_pool;
 135
 136 void print_usage()
 137 {
 138         fprintf(stderr,
 139 "Usage: %s [options] [<input(s)>]\n\n"
 140 "Options are:\n"
 141 "-d (--debug)           Print parser debugging information.\n"
 142 "-h (--help)            Print this help screen.\n"
 143 "-i DIR (--include=DIR) Look in DIR for resolving external type definitions.\n"
 144 "                       Multiple include directories can be specified, and\n"
 145 "                       will be mounted at the --namespace specified when\n"
 146 "                       they were created.\n"
 147 "-l LANG (--lang=LANG)  Generate stubs for this language.\n"
 148 "-M (--makedep)         Output dependency information for make.\n"
 149 "-n (--no-output)       Do not produce output; only check for errors.\n"
 150 "-o DIR (--output=DIR)  Generate output in DIR.\n"
 151 "-r (--server)          Generate server stubs according to the input CDL files.\n"
 152 "-s NS (--namespace=NS) Input files constitute the given namespace.\n"
 153 "-t TARGET (--target=T) Generate stubs for the specified target architecture.\n"
 154 "                       By default, the current architecture is targeted.\n"
 155 "--show-languages       List languages for which stub generation is supported.\n"
 156 "--show-targets         List supported target architectures.\n"
 157 "If a language is specified, language-specific stubs for the output --namespace\n"
 158 "will be placed in the specified output directory.  All inputs must be specified\n"
 159 "as --includes (including all components of the output namespace and anything\n"
 160 "referenced by them).  No non-option inputs may be specified.\n\n"
 161 "If a language is not specified, inputs are treated as IDL source\n"
 162 "files, and are compiled into the specified output directory, as\n"
 163 "the specified output --namespace.\n\n",
 164 cmdname);
 165 }
 166
 167 static void set_lang(const char *lang)
 168 {
 169         if (output_lang) {
 170                 fprintf(stderr, "Only one language may be specified.\n");
 171                 throw UserError();
 172         }
 173
 174         for (Language *l = first_lang; l; l = l->next) {
 175                 if (!strcasecmp(l->name, lang)) {
 176                         output_lang = l;
 177                         return;
 178                 }
 179         }
 180
 181         fprintf(stderr, "Unsupported language \"%s\".\n", lang);
 182         throw UserError();
 183 }
 184
 185 static void set_target(const char *targ)
 186 {
 187         if (target != &targets[0]) {
 188                 fprintf(stderr, "Only one target architecture may be specified.\n");
 189                 throw UserError();
 190         }
 191
 192         for (int i = 1; i <= max_target; i++) {
 193                 if (!strcasecmp(targ, targets[i].name)) {
 194                         target = &targets[i];
 195                         return;
 196                 }
 197         }
 198
 199         fprintf(stderr, "Unsupported target \"%s\".\n", targ);
 200         throw UserError();
 201 }
 202
 203 // Returns true if the argument is consumed.
 204 static bool shortopt(char c, const char *arg)
 205 {
 206         switch (c) {
 207                 case 'd':
 208                         idl_debug = 1;
 209                         cdl_debug = 1;
 210                         break;
 211
 212                 case 'h':
 213                         print_usage();
 214                         exit(0);
 215
 216                 case 'i':
 217                         if (!arg) {
 218                                 fprintf(stderr, "The -i option requires an argument.\n");
 219                                 throw UserError();
 220                         }
 221
 222                         UserNameSpace::declare_import(arg);
 223                         return true;
 224
 225                 case 'M':
 226                         makedep = true;
 227                         break;
 228
 229                 case 'n':
 230                         no_output = true;
 231                         break;
 232
 233                 case 'l':
 234                         if (!arg) {
 235                                 fprintf(stderr, "The -l option requires an argument.\n");
 236                                 throw UserError();
 237                         }
 238
 239                         set_lang(arg);
 240                         return true;
 241
 242                 case 'o':
 243                         if (output_dir) {
 244                                 fprintf(stderr, "Only one output directory may be specified.\n");
 245                                 throw UserError();
 246                         }
 247
 248                         if (!arg) {
 249                                 fprintf(stderr, "The -o option requires an argument.\n");
 250                                 throw UserError();
 251                         }
 252
 253                         output_dir = arg;
 254                         return true;
 255
 256                 case 'r':
 257                         server_stubs = true;
 258                         break;
 259
 260                 case 's':
 261                         if (output_ns_name) {
 262                                 fprintf(stderr, "Only one output namespace may be specified.\n");
 263                                 throw UserError();
 264                         }
 265
 266                         output_ns_name = arg;
 267                         return true;
 268
 269                 case 't':
 270                         if (!arg) {
 271                                 fprintf(stderr, "The -t option requires an argument.\n");
 272                                 throw UserError();
 273                         }
 274
 275                         set_target(arg);
 276                         return true;
 277
 278                 default:
 279                         fprintf(stderr, "%s: unknown option %c\n", cmdname, c);
 280                         throw UserError();
 281         }
 282
 283         return false;
 284 }
 285
 286 static void longopt(const char *s, const char *arg)
 287 {
 288         if (!strcmp(s, "help")) {
 289                 print_usage();
 290                 exit(0);
 291         } else if (!strcmp(s, "debug")) {
 292                 idl_debug = 1;
 293                 cdl_debug = 1;
 294         } else if (!strcmp(s, "include")) {
 295                 if (!arg) {
 296                         fprintf(stderr, "The --include option requires an argument.\n");
 297                         throw UserError();
 298                 }
 299
 300                 UserNameSpace::declare_import(arg);
 301         } else if (!strcmp(s, "makedep")) {
 302                 makedep = true;
 303         } else if (!strcmp(s, "no-output")) {
 304                 no_output = true;
 305         } else if (!strcmp(s, "output")) {
 306                 if (output_dir) {
 307                         fprintf(stderr, "Only one output directory may be specified.\n");
 308                         throw UserError();
 309                 }
 310
 311                 if (!arg) {
 312                         fprintf(stderr, "The --output option requires an argument.\n");
 313                         throw UserError();
 314                 }
 315
 316                 output_dir = arg;
 317         } else if (!strcmp(s, "namespace")) {
 318                 if (output_ns_name) {
 319                         fprintf(stderr, "Only one output namespace may be specified.\n");
 320                         throw UserError();
 321                 }
 322
 323                 if (!arg) {
 324                         fprintf(stderr, "The --namespace option requires an argument.\n");
 325                         throw UserError();
 326                 }
 327
 328                 output_ns_name = arg;
 329         } else if (!strcmp(s, "language")) {
 330                 if (!arg) {
 331                         fprintf(stderr, "The --language option requires an argument.\n");
 332                         throw UserError();
 333                 }
 334
 335                 set_lang(arg);
 336         } else if (!strcmp(s, "target")) {
 337                 if (!arg) {
 338                         fprintf(stderr, "The --target option requires an argument.\n");
 339                         throw UserError();
 340                 }
 341
 342                 set_target(arg);
 343         } else if (!strcmp(s, "show-languages")) {
 344                 printf("Supported language bindings:\n");
 345                 for (Language *l = first_lang; l; l = l->next)
 346                         printf("   %s\n", l->name);
 347                 printf("\n");
 348                 exit(0);
 349         } else if (!strcmp(s, "show-targets")) {
 350                 printf("Supported target architectures:\n");
 351                 for (int i = 1; i <= max_target; i++)
 352                         printf("   %s\n", targets[i].name);
 353                 printf("\n");
 354                 exit(0);
 355         } else if (!strcmp(s, "server")) {
 356                 server_stubs = true;
 357         } else {
 358                 fprintf(stderr, "%s: unknown option \"%s\"\n", cmdname, s);
 359                 throw UserError();
 360         }
 361 }
 362
 363 static int global_argc;
 364 static const char **global_argv;
 365 static int got_dashdash;
 366
 367 static void process_args(void)
 368 {
 369         int i;
 370         size_t j;
 371         char *s;
 372
 373         for (i = 1; i < global_argc; i++) {
 374                 if (global_argv[i][0] == '-' && global_argv[i][1] && !got_dashdash) {
 375                         const char *opt = global_argv[i];
 376
 377                         if (opt[1] == '-') {
 378                                 if (!opt[2]) {
 379                                         got_dashdash = 1;
 380                                 } else {
 381                                         s = strchr(&opt[2], '=');
 382
 383                                         if (!s)
 384                                                 longopt(&opt[2], NULL);
 385                                         else {
 386                                                 *s=0;
 387                                                 longopt(&opt[2], s+1);
 388                                         }
 389                                 }
 390                         } else for (j = 1; j < strlen(opt); j++) {
 391                                 if (shortopt(opt[j], global_argv[i + 1]))
 392                                         i++;
 393                         }
 394                 } else {
 395                         inputs.push_back(global_argv[i]);
 396                 }
 397         }
 398 }
 399
 400 // Provide automatic closing of a file handle upon exception
 401 struct FileHolder {
 402         FILE *f;
 403
 404         FileHolder()
 405         {
 406                 f = NULL;
 407         }
 408
 409         ~FileHolder()
 410         {
 411                 if (f)
 412                         fclose(f);
 413         }
 414 };
 415
 416 void parse_inputs(bool cdl)
 417 {
 418         for (list<const char *>::iterator i = inputs.begin();
 419              i != inputs.end(); ++i)
 420         {
 421                 FileHolder fh;
 422                 cur_input_file = *i;
 423
 424                 curline = 1;
 425
 426                 if (strcmp(cur_input_file, "-")) {
 427                         yyin = fh.f = fopen(cur_input_file, "r");
 428                         if (!yyin) {
 429                                 fprintf(stderr, "Cannot open input file \"%s\": %s\n",
 430                                         cur_input_file, strerror(errno));
 431                                 throw UserError();
 432                         }
 433                 } else {
 434                         yyin = stdin;
 435                         cur_input_file = "stdin";
 436                 }
 437
 438                 if (cdl) {
 439                         cur_nspace = cdl_toplevel;
 440                         setup_cdlparse();
 441
 442                         if (cdl_parse())
 443                                 throw UserError();
 444                 } else {
 445                         cur_nspace = output_ns;
 446                         setup_idlparse();
 447
 448                         if (idl_parse())
 449                                 throw UserError();
 450                 }
 451
 452                 if (finish_lex() || num_err)
 453                         throw UserError();
 454         }
 455
 456         cur_input_file = "<none>";
 457         curline = 0;
 458
 459         if (!nspace_stack.empty())
 460                 BUG();
 461 }
 462
 463 static void init_output_ns()
 464 {
 465         StrList *strl;
 466
 467         try {
 468                 String *str = new String(output_ns_name);
 469                 strl = new StrList(str);
 470         }
 471
 472         catch (InvalidArgument) {
 473                 fprintf(stderr, "Output namespace \"%s\" is not vaild.\n",
 474                         output_ns_name);
 475                 throw UserError();
 476         }
 477
 478         cur_nspace = toplevel;
 479         NameSpace *new_ns = add_nspace(strl, false);
 480
 481         if (!new_ns)
 482                 BUG();
 483
 484         NameSpace *conflict = check_for_imports(new_ns);
 485         if (conflict) {
 486                 fprintf(stderr, "Output namespace \"%s\" conflicts"
 487                                 " with \"%s\" at \"%s\".\n",
 488                         output_ns_name, conflict->get_fq_name()->flatten()->c_str(),
 489                         conflict->get_path()->c_str());
 490
 491                 throw UserError();
 492         }
 493
 494         if (!new_ns)
 495                 BUG();
 496         output_ns = dynamic_cast<UserNameSpace *>(new_ns);
 497         if (!output_ns)
 498                 BUG();
 499 }
 500
 501 void lookup_system_object()
 502 {
 503         try {
 504                 StrList *sl = new StrList;
 505
 506                 sl->push_back(new String(""));
 507                 sl->push_back(new String("System"));
 508                 sl->push_back(new String("Object"));
 509
 510                 Symbol *sym = lookup_sym(toplevel, sl, toplevel);
 511                 System_Object = dynamic_cast<Interface *>(sym);
 512         }
 513
 514         catch (UserError) {
 515                 yyerrorf("Could not find System.Object.");
 516                 yyerrorf("Be sure to include the file or directory containing "
 517                          "the System namespace.");
 518
 519                 throw UserError();
 520         }
 521
 522         if (!System_Object) {
 523                 yyerrorf("System.Object is not an interface.");
 524                 throw UserError();
 525         }
 526 }
 527
 528 void lookup_system_vstruct()
 529 {
 530         try {
 531                 StrList *sl = new StrList();
 532
 533                 sl->push_back(new String(""));
 534                 sl->push_back(new String("System"));
 535                 sl->push_back(new String("VStruct"));
 536
 537                 Symbol *sym = lookup_sym(toplevel, sl, toplevel);
 538                 System_VStruct = dynamic_cast<Struct *>(sym);
 539         }
 540
 541         catch (UserError) {
 542                 yyerrorf("Could not find System.VStruct.");
 543                 yyerrorf("Be sure to include the file or directory containing "
 544                          "the System namespace.");
 545
 546                 throw UserError();
 547         }
 548
 549         if (!System_VStruct) {
 550                 yyerrorf("System.VStruct is not a struct.");
 551                 throw UserError();
 552         }
 553
 554         if (!System_VStruct->is_virtual()) {
 555                 yyerrorf("System.VStruct is not virtual.");
 556                 throw UserError();
 557         }
 558 }
 559
 560 void normal_output()
 561 {
 562         if (inputs.empty()) {
 563                 fprintf(stderr, "No inputs given.\n");
 564                 print_usage();
 565                 throw UserError();
 566         }
 567
 568         if (makedep) {
 569                 fprintf(stderr, "Dependency generation is only supported "
 570                                 "when generating language output.\n");
 571                 throw UserError();
 572         }
 573
 574         if (!no_output && !output_dir) {
 575                 fprintf(stderr, "An output directory must be specified "
 576                                 "when not using -n.\n");
 577                 throw UserError();
 578         }
 579
 580         if (!output_ns_name) {
 581                 fprintf(stderr, "An output namespace must be specified.\n");
 582                 throw UserError();
 583         }
 584
 585         if (!no_output && output_dir)
 586                 makepath(output_dir);
 587
 588         init_output_ns();
 589
 590         current_pass = 1;
 591         autorelease_pool.clean();
 592
 593         parse_inputs(false);
 594
 595         current_pass = 2;
 596         autorelease_pool.clean();
 597
 598         lookup_system_object();
 599         lookup_system_vstruct();
 600         output_ns->lookup_imports();
 601
 602         current_pass = 3;
 603         autorelease_pool.clean();
 604
 605         output_ns->lookup_chain();
 606         if (num_err)
 607                 throw UserError();
 608
 609         current_pass = 4;
 610         autorelease_pool.clean();
 611
 612         output_ns->lookup_misc();
 613         if (num_err)
 614                 throw UserError();
 615
 616         current_pass = 5;
 617         autorelease_pool.clean();
 618
 619         output_ns->final_analysis();
 620         if (num_err)
 621                 throw UserError();
 622
 623         current_pass = 6;
 624         autorelease_pool.clean();
 625
 626         if (!no_output)
 627                 output_ns->output(output_dir);
 628
 629         autorelease_pool.clean();
 630 }
 631
 632 void language_output()
 633 {
 634         if (server_stubs) {
 635                 if (inputs.empty()) {
 636                         fprintf(stderr, "No inputs given.\n");
 637                         print_usage();
 638                         throw UserError();
 639                 }
 640         } else {
 641                 if (!inputs.empty()) {
 642                         fprintf(stderr, "Inputs may not be specified when generating "
 643                                         "language-specific client output.\n"
 644                                         "Use --include to specify input namespaces.\n");
 645                         throw UserError();
 646                 }
 647
 648                 if (!output_ns_name) {
 649                         fprintf(stderr, "An output namespace must be specified.\n");
 650                         throw UserError();
 651                 }
 652
 653                 if (makedep) {
 654                         fprintf(stderr, "Dependency information is currently only supported "
 655                                         "for server stubs.\n");
 656                         throw UserError();
 657                 }
 658         }
 659
 660         if (no_output) {
 661                 fprintf(stderr, "-n may not be used when generating "
 662                                 "language-specific output.\n");
 663                 throw UserError();
 664         }
 665
 666         if (!output_dir) {
 667                 fprintf(stderr, "An output directory must be specified when "
 668                                 "generating language-specific output.\n");
 669                 throw UserError();
 670         }
 671
 672         if (!makedep && target == &targets[0]) {
 673                 fprintf(stderr, "Target detection not yet implemented.\n"
 674                                 "Please specify a target architecture.\n");
 675                         throw UserError();
 676         }
 677
 678         if (!makedep)
 679                 makepath(output_dir);
 680
 681         if (server_stubs) {
 682                 current_pass = INT_MAX;
 683                 lookup_system_object();
 684                 lookup_system_vstruct();
 685                 parse_inputs(true);
 686                 autorelease_pool.clean();
 687                 output_lang->output_server(cdl_toplevel, output_dir);
 688         } else {
 689                 StrList *output_ns_strl;
 690                 try {
 691                         String *output_ns_str = new String(output_ns_name);
 692                         output_ns_strl = new StrList(output_ns_str);
 693                 }
 694
 695                 catch (InvalidArgument) {
 696                         fprintf(stderr, "Output namespace \"%s\" is not vaild.\n",
 697                                 output_ns_name);
 698                         throw UserError();
 699                 }
 700
 701                 cur_nspace = toplevel;
 702                 current_pass = INT_MAX;
 703                 lookup_system_object();
 704                 lookup_system_vstruct();
 705
 706                 Symbol *sym = lookup_sym(toplevel, output_ns_strl, toplevel);
 707                 output_ns = dynamic_cast<UserNameSpace *>(sym);
 708                 if (!output_ns) {
 709                         fprintf(stderr, "Output namespace \"%s\" is not a pure namespace.\n",
 710                                 output_ns_name);
 711                         throw UserError();
 712                 }
 713
 714                 output_ns->import_all_recursive();
 715                 autorelease_pool.clean();
 716                 output_lang->output_root(output_ns, output_dir);
 717         }
 718
 719         autorelease_pool.clean();
 720 }
 721
 722 int run_idlc(int argc, const char **argv)
 723 {
 724         global_argc = argc;
 725         global_argv = argv;
 726         cmdname = argv[0];
 727
 728         toplevel = new UserNameSpace();
 729         cdl_toplevel = new UserNameSpace();
 730
 731         try {
 732                 process_args();
 733
 734                 if (output_lang)
 735                         language_output();
 736                 else {
 737                         if (server_stubs) {
 738                                 fprintf(stderr, "The -r (--server) option may only be used "
 739                                                 "with the -l (--lang) option.\n");
 740
 741                                 throw UserError();
 742                         }
 743
 744                         normal_output();
 745                 }
 746         }
 747
 748         catch (InternalError &e) {
 749                 fprintf(stderr, "Internal idlc error at %s:%d\n",
 750                         e.file, e.line);
 751                 return 1;
 752         }
 753
 754         catch (InvalidArgument) {
 755                 fprintf(stderr, "Internal idlc error: Uncaught InvalidArgument\n");
 756                 return 1;
 757         }
 758
 759         catch (SymbolNotFound) {
 760                 fprintf(stderr, "Internal idlc error: Uncaught SymbolNotFound\n");
 761                 return 1;
 762         }
 763
 764         catch (DuplicateSymbol) {
 765                 fprintf(stderr, "Internal idlc error: Uncaught DuplicateSymbol\n");
 766                 return 1;
 767         }
 768
 769         catch (UserError) {
 770                 // An error message has already been displayed.
 771                 num_err++;
 772         }
 773
 774         catch (...) {
 775                 fprintf(stderr, "%s:%d: Internal error: Uncaught Exception\n",
 776                         cur_input_file, curline);
 777                 return 1;
 778         }
 779
 780         if (num_err)
 781                 return 1;
 782
 783         return 0;
 784 }
 785
 786 int main(int argc, const char **argv)
 787 {
 788         int ret = run_idlc(argc, argv);
 789         autorelease_pool.clean();
 790         return ret;
 791 }
 792
 793 extern "C" int yywrap()
 794 {
 795         return 1;
 796 }
 797
 798 extern char *yytext;
 799
 800 void idl_error(char *s)
 801 {
 802         if (strlen(yytext))
 803                 fprintf(stderr, "%s:%d: %s at \"%s\".\n", cur_input_file, curline, s, yytext);
 804         else
 805                 fprintf(stderr, "%s:%d: %s at end of input.\n", cur_input_file, curline, s);
 806
 807         num_err++;
 808 }
 809
 810 void yyerrorf(const char *s, ...)
 811 {
 812         va_list va;
 813         va_start(va, s);
 814         fprintf(stderr, "%s:%d: ", cur_input_file, curline);
 815         vfprintf(stderr, s, va);
 816         fprintf(stderr, "\n");
 817         va_end(va);
 818
 819         num_err++;
 820 }
 821
 822 void yyerrorfl(const char *file, int line, const char *s, ...)
 823 {
 824         va_list va;
 825         va_start(va, s);
 826         fprintf(stderr, "%s:%d: ", file, line);
 827         vfprintf(stderr, s, va);
 828         fprintf(stderr, "\n");
 829         va_end(va);
 830
 831         num_err++;
 832 }
 833
 834 int idl_lex()
 835 {
 836         return yylex();
 837 }