git.sur5r.net Git - cc65/blob - src/cc65/main.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                  main.c                                   */
   4 /*                                                                           */
   5 /*                             cc65 main program                             */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2000-2015, Ullrich von Bassewitz                                      */
  10 /*                Roemerstrasse 52                                           */
  11 /*                D-70794 Filderstadt                                        */
  12 /* EMail:         uz@cc65.org                                                */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <stdlib.h>
  39 #include <errno.h>
  40
  41 /* common */
  42 #include "abend.h"
  43 #include "chartype.h"
  44 #include "cmdline.h"
  45 #include "cpu.h"
  46 #include "debugflag.h"
  47 #include "fname.h"
  48 #include "mmodel.h"
  49 #include "print.h"
  50 #include "segnames.h"
  51 #include "strbuf.h"
  52 #include "target.h"
  53 #include "tgttrans.h"
  54 #include "version.h"
  55 #include "xmalloc.h"
  56
  57 /* cc65 */
  58 #include "asmcode.h"
  59 #include "compile.h"
  60 #include "codeopt.h"
  61 #include "error.h"
  62 #include "global.h"
  63 #include "incpath.h"
  64 #include "input.h"
  65 #include "macrotab.h"
  66 #include "output.h"
  67 #include "scanner.h"
  68 #include "segments.h"
  69 #include "standard.h"
  70
  71
  72
  73 /*****************************************************************************/
  74 /*                                   Code                                    */
  75 /*****************************************************************************/
  76
  77
  78
  79 static void Usage (void)
  80 /* Print usage information to stderr */
  81 {
  82     printf ("Usage: %s [options] file\n"
  83             "Short options:\n"
  84             "  -Cl\t\t\t\tMake local variables static\n"
  85             "  -Dsym[=defn]\t\t\tDefine a symbol\n"
  86             "  -E\t\t\t\tStop after the preprocessing stage\n"
  87             "  -I dir\t\t\tSet an include directory search path\n"
  88             "  -O\t\t\t\tOptimize code\n"
  89             "  -Oi\t\t\t\tOptimize code, inline more code\n"
  90             "  -Or\t\t\t\tEnable register variables\n"
  91             "  -Os\t\t\t\tInline some known functions\n"
  92             "  -T\t\t\t\tInclude source as comment\n"
  93             "  -V\t\t\t\tPrint the compiler version number\n"
  94             "  -W warning[,...]\t\tSuppress warnings\n"
  95             "  -d\t\t\t\tDebug mode\n"
  96             "  -g\t\t\t\tAdd debug info to object file\n"
  97             "  -h\t\t\t\tHelp (this text)\n"
  98             "  -j\t\t\t\tDefault characters are signed\n"
  99             "  -mm model\t\t\tSet the memory model\n"
 100             "  -o name\t\t\tName the output file\n"
 101             "  -r\t\t\t\tEnable register variables\n"
 102             "  -t sys\t\t\tSet the target system\n"
 103             "  -v\t\t\t\tIncrease verbosity\n"
 104             "\n"
 105             "Long options:\n"
 106             "  --add-source\t\t\tInclude source as comment\n"
 107             "  --all-cdecl\t\t\tMake functions default to __cdecl__\n"
 108             "  --bss-name seg\t\tSet the name of the BSS segment\n"
 109             "  --check-stack\t\t\tGenerate stack overflow checks\n"
 110             "  --code-name seg\t\tSet the name of the CODE segment\n"
 111             "  --codesize x\t\t\tAccept larger code by factor x\n"
 112             "  --cpu type\t\t\tSet cpu type (6502, 65c02)\n"
 113             "  --create-dep name\t\tCreate a make dependency file\n"
 114             "  --create-full-dep name\tCreate a full make dependency file\n"
 115             "  --data-name seg\t\tSet the name of the DATA segment\n"
 116             "  --debug\t\t\tDebug mode\n"
 117             "  --debug-info\t\t\tAdd debug info to object file\n"
 118             "  --debug-opt name\t\tDebug optimization steps\n"
 119             "  --dep-target target\t\tUse this dependency target\n"
 120             "  --disable-opt name\t\tDisable an optimization step\n"
 121             "  --enable-opt name\t\tEnable an optimization step\n"
 122             "  --help\t\t\tHelp (this text)\n"
 123             "  --include-dir dir\t\tSet an include directory search path\n"
 124             "  --list-opt-steps\t\tList all optimizer steps and exit\n"
 125             "  --list-warnings\t\tList available warning types for -W\n"
 126             "  --local-strings\t\tEmit string literals immediately\n"
 127             "  --memory-model model\t\tSet the memory model\n"
 128             "  --register-space b\t\tSet space available for register variables\n"
 129             "  --register-vars\t\tEnable register variables\n"
 130             "  --rodata-name seg\t\tSet the name of the RODATA segment\n"
 131             "  --signed-chars\t\tDefault characters are signed\n"
 132             "  --standard std\t\tLanguage standard (c89, c99, cc65)\n"
 133             "  --static-locals\t\tMake local variables static\n"
 134             "  --target sys\t\t\tSet the target system\n"
 135             "  --verbose\t\t\tIncrease verbosity\n"
 136             "  --version\t\t\tPrint the compiler version number\n"
 137             "  --writable-strings\t\tMake string literals writable\n",
 138             ProgName);
 139 }
 140
 141
 142
 143 static void cbmsys (const char* sys)
 144 /* Define a CBM system */
 145 {
 146     DefineNumericMacro ("__CBM__", 1);
 147     DefineNumericMacro (sys, 1);
 148 }
 149
 150
 151
 152 static void SetSys (const char* Sys)
 153 /* Define a target system */
 154 {
 155     switch (Target = FindTarget (Sys)) {
 156
 157         case TGT_NONE:
 158             break;
 159
 160         case TGT_MODULE:
 161             AbEnd ("Cannot use `module' as a target for the compiler");
 162             break;
 163
 164         case TGT_ATARI5200:
 165             DefineNumericMacro ("__ATARI5200__", 1);
 166             break;
 167
 168         case TGT_ATARI:
 169             DefineNumericMacro ("__ATARI__", 1);
 170             break;
 171
 172         case TGT_ATARIXL:
 173             DefineNumericMacro ("__ATARI__", 1);
 174             DefineNumericMacro ("__ATARIXL__", 1);
 175             break;
 176
 177         case TGT_C16:
 178             cbmsys ("__C16__");
 179             break;
 180
 181         case TGT_C64:
 182             cbmsys ("__C64__");
 183             break;
 184
 185         case TGT_VIC20:
 186             cbmsys ("__VIC20__");
 187             break;
 188
 189         case TGT_C128:
 190             cbmsys ("__C128__");
 191             break;
 192
 193         case TGT_PLUS4:
 194             cbmsys ("__C16__");
 195             DefineNumericMacro ("__PLUS4__", 1);
 196             break;
 197
 198         case TGT_CBM510:
 199             cbmsys ("__CBM510__");
 200             break;
 201
 202         case TGT_CBM610:
 203             cbmsys ("__CBM610__");
 204             break;
 205
 206         case TGT_PET:
 207             cbmsys ("__PET__");
 208             break;
 209
 210         case TGT_BBC:
 211             DefineNumericMacro ("__BBC__", 1);
 212             break;
 213
 214         case TGT_APPLE2:
 215             DefineNumericMacro ("__APPLE2__", 1);
 216             break;
 217
 218         case TGT_APPLE2ENH:
 219             DefineNumericMacro ("__APPLE2__", 1);
 220             DefineNumericMacro ("__APPLE2ENH__", 1);
 221             break;
 222
 223         case TGT_GEOS_CBM:
 224             /* Do not handle as a CBM system */
 225             DefineNumericMacro ("__GEOS__", 1);
 226             DefineNumericMacro ("__GEOS_CBM__", 1);
 227             break;
 228
 229         case TGT_GEOS_APPLE:
 230             DefineNumericMacro ("__GEOS__", 1);
 231             DefineNumericMacro ("__GEOS_APPLE__", 1);
 232             break;
 233
 234         case TGT_LUNIX:
 235             DefineNumericMacro ("__LUNIX__", 1);
 236             break;
 237
 238         case TGT_ATMOS:
 239             DefineNumericMacro ("__ATMOS__", 1);
 240             break;
 241
 242         case TGT_NES:
 243             DefineNumericMacro ("__NES__", 1);
 244             break;
 245
 246         case TGT_SUPERVISION:
 247             DefineNumericMacro ("__SUPERVISION__", 1);
 248             break;
 249
 250         case TGT_LYNX:
 251             DefineNumericMacro ("__LYNX__", 1);
 252             break;
 253
 254         case TGT_SIM6502:
 255             DefineNumericMacro ("__SIM6502__", 1);
 256             break;
 257
 258         case TGT_SIM65C02:
 259             DefineNumericMacro ("__SIM65C02__", 1);
 260             break;
 261
 262         case TGT_OSIC1P:
 263             DefineNumericMacro ("__OSIC1P__", 1);
 264             break;
 265
 266         default:
 267             AbEnd ("Unknown target system type %d", Target);
 268     }
 269
 270     /* Initialize the translation tables for the target system */
 271     TgtTranslateInit ();
 272 }
 273
 274
 275
 276 static void FileNameOption (const char* Opt, const char* Arg, StrBuf* Name)
 277 /* Handle an option that remembers a file name for later */
 278 {
 279     /* Cannot have the option twice */
 280     if (SB_NotEmpty (Name)) {
 281         AbEnd ("Cannot use option `%s' twice", Opt);
 282     }
 283     /* Remember the file name for later */
 284     SB_CopyStr (Name, Arg);
 285     SB_Terminate (Name);
 286 }
 287
 288
 289
 290 static void DefineSym (const char* Def)
 291 /* Define a symbol on the command line */
 292 {
 293     const char* P = Def;
 294
 295     /* The symbol must start with a character or underline */
 296     if (Def [0] != '_' && !IsAlpha (Def [0])) {
 297         InvDef (Def);
 298     }
 299
 300     /* Check the symbol name */
 301     while (IsAlNum (*P) || *P == '_') {
 302         ++P;
 303     }
 304
 305     /* Do we have a value given? */
 306     if (*P != '=') {
 307         if (*P != '\0') {
 308             InvDef (Def);
 309         }
 310         /* No value given. Define the macro with the value 1 */
 311         DefineNumericMacro (Def, 1);
 312     } else {
 313         /* We have a value, P points to the '=' character. Since the argument
 314         ** is const, create a copy and replace the '=' in the copy by a zero
 315         ** terminator.
 316         */
 317         char* Q;
 318         unsigned Len = strlen (Def)+1;
 319         char* S = (char*) xmalloc (Len);
 320         memcpy (S, Def, Len);
 321         Q = S + (P - Def);
 322         *Q++ = '\0';
 323
 324         /* Define this as a macro */
 325         DefineTextMacro (S, Q);
 326
 327         /* Release the allocated memory */
 328         xfree (S);
 329     }
 330 }
 331
 332
 333
 334 static void CheckSegName (const char* Seg)
 335 /* Abort if the given name is not a valid segment name */
 336 {
 337     /* Print an error and abort if the name is not ok */
 338     if (!ValidSegName (Seg)) {
 339         AbEnd ("Segment name `%s' is invalid", Seg);
 340     }
 341 }
 342
 343
 344
 345 static void OptAddSource (const char* Opt attribute ((unused)),
 346                           const char* Arg attribute ((unused)))
 347 /* Add source lines as comments in generated assembler file */
 348 {
 349     AddSource = 1;
 350 }
 351
 352
 353
 354 static void OptAllCDecl (const char* Opt attribute ((unused)),
 355                          const char* Arg attribute ((unused)))
 356 /* Make functions default to cdecl instead of fastcall. */
 357 {
 358     AutoCDecl = 1;
 359 }
 360
 361
 362
 363 static void OptBssName (const char* Opt attribute ((unused)), const char* Arg)
 364 /* Handle the --bss-name option */
 365 {
 366     /* Check for a valid name */
 367     CheckSegName (Arg);
 368
 369     /* Set the name */
 370     SetSegName (SEG_BSS, Arg);
 371 }
 372
 373
 374
 375 static void OptCheckStack (const char* Opt attribute ((unused)),
 376                            const char* Arg attribute ((unused)))
 377 /* Handle the --check-stack option */
 378 {
 379     IS_Set (&CheckStack, 1);
 380 }
 381
 382
 383
 384 static void OptCodeName (const char* Opt attribute ((unused)), const char* Arg)
 385 /* Handle the --code-name option */
 386 {
 387     /* Check for a valid name */
 388     CheckSegName (Arg);
 389
 390     /* Set the name */
 391     SetSegName (SEG_CODE, Arg);
 392 }
 393
 394
 395
 396 static void OptCodeSize (const char* Opt, const char* Arg)
 397 /* Handle the --codesize option */
 398 {
 399     unsigned Factor;
 400     char     BoundsCheck;
 401
 402     /* Numeric argument expected */
 403     if (sscanf (Arg, "%u%c", &Factor, &BoundsCheck) != 1 ||
 404         Factor < 10 || Factor > 1000) {
 405         AbEnd ("Argument for %s is invalid", Opt);
 406     }
 407     IS_Set (&CodeSizeFactor, Factor);
 408 }
 409
 410
 411
 412 static void OptCreateDep (const char* Opt, const char* Arg)
 413 /* Handle the --create-dep option */
 414 {
 415     FileNameOption (Opt, Arg, &DepName);
 416 }
 417
 418
 419
 420 static void OptCreateFullDep (const char* Opt attribute ((unused)),
 421                               const char* Arg)
 422 /* Handle the --create-full-dep option */
 423 {
 424     FileNameOption (Opt, Arg, &FullDepName);
 425 }
 426
 427
 428
 429 static void OptCPU (const char* Opt, const char* Arg)
 430 /* Handle the --cpu option */
 431 {
 432     /* Find the CPU from the given name */
 433     CPU = FindCPU (Arg);
 434     if (CPU != CPU_6502 && CPU != CPU_6502X && CPU != CPU_65SC02 &&
 435         CPU != CPU_65C02 && CPU != CPU_65816 && CPU != CPU_HUC6280) {
 436         AbEnd ("Invalid argument for %s: `%s'", Opt, Arg);
 437     }
 438 }
 439
 440
 441
 442 static void OptDataName (const char* Opt attribute ((unused)), const char* Arg)
 443 /* Handle the --data-name option */
 444 {
 445     /* Check for a valid name */
 446     CheckSegName (Arg);
 447
 448     /* Set the name */
 449     SetSegName (SEG_DATA, Arg);
 450 }
 451
 452
 453
 454 static void OptDebug (const char* Opt attribute ((unused)),
 455                       const char* Arg attribute ((unused)))
 456 /* Compiler debug mode */
 457 {
 458     ++Debug;
 459 }
 460
 461
 462
 463 static void OptDebugInfo (const char* Opt attribute ((unused)),
 464                           const char* Arg attribute ((unused)))
 465 /* Add debug info to the object file */
 466 {
 467     DebugInfo = 1;
 468 }
 469
 470
 471
 472 static void OptDebugOpt (const char* Opt attribute ((unused)), const char* Arg)
 473 /* Debug optimization steps */
 474 {
 475     char Buf [128];
 476     char* Line;
 477
 478     /* Open the file */
 479     FILE* F = fopen (Arg, "r");
 480     if (F == 0) {
 481         AbEnd ("Cannot open `%s': %s", Arg, strerror (errno));
 482     }
 483
 484     /* Read line by line, ignore empty lines and switch optimization
 485     ** steps on/off.
 486     */
 487     while (fgets (Buf, sizeof (Buf), F) != 0) {
 488
 489         /* Remove trailing control chars. This will also remove the
 490         ** trailing newline.
 491         */
 492         unsigned Len = strlen (Buf);
 493         while (Len > 0 && IsControl (Buf[Len-1])) {
 494             --Len;
 495         }
 496         Buf[Len] = '\0';
 497
 498         /* Get a pointer to the buffer and remove leading white space */
 499         Line = Buf;
 500         while (IsBlank (*Line)) {
 501             ++Line;
 502         }
 503
 504         /* Check the first character and enable/disable the step or
 505         ** ignore the line
 506         */
 507         switch (*Line) {
 508
 509             case '\0':
 510             case '#':
 511             case ';':
 512                 /* Empty or comment line */
 513                 continue;
 514
 515             case '-':
 516                 DisableOpt (Line+1);
 517                 break;
 518
 519             case '+':
 520                 ++Line;
 521                 /* FALLTHROUGH */
 522
 523             default:
 524                 EnableOpt (Line);
 525                 break;
 526
 527         }
 528
 529     }
 530
 531     /* Close the file, no error check here since we were just reading and
 532     ** this is only a debug function.
 533     */
 534     (void) fclose (F);
 535 }
 536
 537
 538
 539 static void OptDebugOptOutput (const char* Opt attribute ((unused)),
 540                                const char* Arg attribute ((unused)))
 541 /* Output optimization steps */
 542 {
 543     DebugOptOutput = 1;
 544 }
 545
 546
 547
 548 static void OptDepTarget (const char* Opt attribute ((unused)), const char* Arg)
 549 /* Handle the --dep-target option */
 550 {
 551     FileNameOption (Opt, Arg, &DepTarget);
 552 }
 553
 554
 555
 556 static void OptDisableOpt (const char* Opt attribute ((unused)), const char* Arg)
 557 /* Disable an optimization step */
 558 {
 559     DisableOpt (Arg);
 560 }
 561
 562
 563
 564 static void OptEnableOpt (const char* Opt attribute ((unused)), const char* Arg)
 565 /* Enable an optimization step */
 566 {
 567     EnableOpt (Arg);
 568 }
 569
 570
 571
 572 static void OptHelp (const char* Opt attribute ((unused)),
 573                      const char* Arg attribute ((unused)))
 574 /* Print usage information and exit */
 575 {
 576     Usage ();
 577     exit (EXIT_SUCCESS);
 578 }
 579
 580
 581
 582 static void OptIncludeDir (const char* Opt attribute ((unused)), const char* Arg)
 583 /* Add an include search path */
 584 {
 585     AddSearchPath (SysIncSearchPath, Arg);
 586     AddSearchPath (UsrIncSearchPath, Arg);
 587 }
 588
 589
 590
 591 static void OptListOptSteps (const char* Opt attribute ((unused)),
 592                              const char* Arg attribute ((unused)))
 593 /* List all optimizer steps */
 594 {
 595     /* List the optimizer steps */
 596     ListOptSteps (stdout);
 597
 598     /* Terminate */
 599     exit (EXIT_SUCCESS);
 600 }
 601
 602
 603
 604 static void OptListWarnings (const char* Opt attribute ((unused)),
 605                              const char* Arg attribute ((unused)))
 606 /* List all warning types */
 607 {
 608     /* List the warnings */
 609     ListWarnings (stdout);
 610
 611     /* Terminate */
 612     exit (EXIT_SUCCESS);
 613 }
 614
 615
 616
 617 static void OptLocalStrings (const char* Opt attribute ((unused)),
 618                              const char* Arg attribute ((unused)))
 619 /* Emit string literals immediately */
 620 {
 621     IS_Set (&LocalStrings, 1);
 622 }
 623
 624
 625
 626 static void OptMemoryModel (const char* Opt, const char* Arg)
 627 /* Set the memory model */
 628 {
 629     mmodel_t M;
 630
 631     /* Check the current memory model */
 632     if (MemoryModel != MMODEL_UNKNOWN) {
 633         AbEnd ("Cannot use option `%s' twice", Opt);
 634     }
 635
 636     /* Translate the memory model name and check it */
 637     M = FindMemoryModel (Arg);
 638     if (M == MMODEL_UNKNOWN) {
 639         AbEnd ("Unknown memory model: %s", Arg);
 640     } else if (M == MMODEL_HUGE) {
 641         AbEnd ("Unsupported memory model: %s", Arg);
 642     }
 643
 644     /* Set the memory model */
 645     SetMemoryModel (M);
 646 }
 647
 648
 649
 650 static void OptRegisterSpace (const char* Opt, const char* Arg)
 651 /* Handle the --register-space option */
 652 {
 653     /* Numeric argument expected */
 654     if (sscanf (Arg, "%u", &RegisterSpace) != 1 || RegisterSpace > 256) {
 655         AbEnd ("Argument for option %s is invalid", Opt);
 656     }
 657 }
 658
 659
 660
 661 static void OptRegisterVars (const char* Opt attribute ((unused)),
 662                              const char* Arg attribute ((unused)))
 663 /* Handle the --register-vars option */
 664 {
 665     IS_Set (&EnableRegVars, 1);
 666 }
 667
 668
 669
 670 static void OptRodataName (const char* Opt attribute ((unused)), const char* Arg)
 671 /* Handle the --rodata-name option */
 672 {
 673     /* Check for a valid name */
 674     CheckSegName (Arg);
 675
 676     /* Set the name */
 677     SetSegName (SEG_RODATA, Arg);
 678 }
 679
 680
 681
 682 static void OptSignedChars (const char* Opt attribute ((unused)),
 683                             const char* Arg attribute ((unused)))
 684 /* Make default characters signed */
 685 {
 686     IS_Set (&SignedChars, 1);
 687 }
 688
 689
 690
 691 static void OptStandard (const char* Opt, const char* Arg)
 692 /* Handle the --standard option */
 693 {
 694     /* Find the standard from the given name */
 695     standard_t Std = FindStandard (Arg);
 696     if (Std == STD_UNKNOWN) {
 697         AbEnd ("Invalid argument for %s: `%s'", Opt, Arg);
 698     } else if (IS_Get (&Standard) != STD_UNKNOWN) {
 699         AbEnd ("Option %s given more than once", Opt);
 700     } else {
 701         IS_Set (&Standard, Std);
 702     }
 703 }
 704
 705
 706
 707 static void OptStaticLocals (const char* Opt attribute ((unused)),
 708                              const char* Arg attribute ((unused)))
 709 /* Place local variables in static storage */
 710 {
 711     IS_Set (&StaticLocals, 1);
 712 }
 713
 714
 715
 716 static void OptTarget (const char* Opt attribute ((unused)), const char* Arg)
 717 /* Set the target system */
 718 {
 719     SetSys (Arg);
 720 }
 721
 722
 723
 724 static void OptVerbose (const char* Opt attribute ((unused)),
 725                         const char* Arg attribute ((unused)))
 726 /* Increase verbosity */
 727 {
 728     ++Verbosity;
 729 }
 730
 731
 732
 733 static void OptVersion (const char* Opt attribute ((unused)),
 734                         const char* Arg attribute ((unused)))
 735 /* Print the compiler version */
 736 {
 737     fprintf (stderr, "cc65 V%s\n", GetVersionAsString ());
 738     exit (EXIT_SUCCESS);
 739 }
 740
 741
 742
 743 static void OptWarning (const char* Opt attribute ((unused)), const char* Arg)
 744 /* Handle the -W option */
 745 {
 746     StrBuf W = AUTO_STRBUF_INITIALIZER;
 747
 748     /* Arg is a list of suboptions, separated by commas */
 749     while (Arg) {
 750
 751         const char* Pos;
 752         int         Enabled = 1;
 753         IntStack*   S;
 754
 755         /* The suboption may be prefixed with '-' or '+' */
 756         if (*Arg == '-') {
 757             Enabled = 0;
 758             ++Arg;
 759         } else if (*Arg == '+') {
 760             /* This is the default */
 761             ++Arg;
 762         }
 763
 764         /* Get the next suboption */
 765         Pos = strchr (Arg, ',');
 766         if (Pos) {
 767             SB_CopyBuf (&W, Arg, Pos - Arg);
 768             Arg = Pos + 1;
 769         } else {
 770             SB_CopyStr (&W, Arg);
 771             Arg = 0;
 772         }
 773         SB_Terminate (&W);
 774
 775         /* Search for the warning */
 776         S = FindWarning (SB_GetConstBuf (&W));
 777         if (S == 0) {
 778             InvArg (Opt, SB_GetConstBuf (&W));
 779         }
 780         IS_Set (S, Enabled);
 781     }
 782
 783     /* Free allocated memory */
 784     SB_Done (&W);
 785 }
 786
 787
 788
 789 static void OptWritableStrings (const char* Opt attribute ((unused)),
 790                                 const char* Arg attribute ((unused)))
 791 /* Make string literals writable */
 792 {
 793     IS_Set (&WritableStrings, 1);
 794 }
 795
 796
 797
 798 int main (int argc, char* argv[])
 799 {
 800     /* Program long options */
 801     static const LongOpt OptTab[] = {
 802         { "--add-source",       0,      OptAddSource            },
 803         { "--all-cdecl",        0,      OptAllCDecl             },
 804         { "--bss-name",         1,      OptBssName              },
 805         { "--check-stack",      0,      OptCheckStack           },
 806         { "--code-name",        1,      OptCodeName             },
 807         { "--codesize",         1,      OptCodeSize             },
 808         { "--cpu",              1,      OptCPU                  },
 809         { "--create-dep",       1,      OptCreateDep            },
 810         { "--create-full-dep",  1,      OptCreateFullDep        },
 811         { "--data-name",        1,      OptDataName             },
 812         { "--debug",            0,      OptDebug                },
 813         { "--debug-info",       0,      OptDebugInfo            },
 814         { "--debug-opt",        1,      OptDebugOpt             },
 815         { "--debug-opt-output", 0,      OptDebugOptOutput       },
 816         { "--dep-target",       1,      OptDepTarget            },
 817         { "--disable-opt",      1,      OptDisableOpt           },
 818         { "--enable-opt",       1,      OptEnableOpt            },
 819         { "--help",             0,      OptHelp                 },
 820         { "--include-dir",      1,      OptIncludeDir           },
 821         { "--list-opt-steps",   0,      OptListOptSteps         },
 822         { "--list-warnings",    0,      OptListWarnings         },
 823         { "--local-strings",    0,      OptLocalStrings         },
 824         { "--memory-model",     1,      OptMemoryModel          },
 825         { "--register-space",   1,      OptRegisterSpace        },
 826         { "--register-vars",    0,      OptRegisterVars         },
 827         { "--rodata-name",      1,      OptRodataName           },
 828         { "--signed-chars",     0,      OptSignedChars          },
 829         { "--standard",         1,      OptStandard             },
 830         { "--static-locals",    0,      OptStaticLocals         },
 831         { "--target",           1,      OptTarget               },
 832         { "--verbose",          0,      OptVerbose              },
 833         { "--version",          0,      OptVersion              },
 834         { "--writable-strings", 0,      OptWritableStrings      },
 835     };
 836
 837     unsigned I;
 838
 839     /* Initialize the input file name */
 840     const char* InputFile  = 0;
 841
 842     /* Initialize the cmdline module */
 843     InitCmdLine (&argc, &argv, "cc65");
 844
 845     /* Initialize the default segment names */
 846     InitSegNames ();
 847
 848     /* Initialize the include search paths */
 849     InitIncludePaths ();
 850
 851     /* Parse the command line */
 852     I = 1;
 853     while (I < ArgCount) {
 854
 855         const char* P;
 856
 857         /* Get the argument */
 858         const char* Arg = ArgVec[I];
 859
 860         /* Check for an option */
 861         if (Arg[0] == '-') {
 862
 863             switch (Arg[1]) {
 864
 865                 case '-':
 866                     LongOption (&I, OptTab, sizeof(OptTab)/sizeof(OptTab[0]));
 867                     break;
 868
 869                 case 'd':
 870                     OptDebug (Arg, 0);
 871                     break;
 872
 873                 case 'h':
 874                 case '?':
 875                     OptHelp (Arg, 0);
 876                     break;
 877
 878                 case 'g':
 879                     OptDebugInfo (Arg, 0);
 880                     break;
 881
 882                 case 'j':
 883                     OptSignedChars (Arg, 0);
 884                     break;
 885
 886                 case 'o':
 887                     SetOutputName (GetArg (&I, 2));
 888                     break;
 889
 890                 case 'r':
 891                     OptRegisterVars (Arg, 0);
 892                     break;
 893
 894                 case 't':
 895                     OptTarget (Arg, GetArg (&I, 2));
 896                     break;
 897
 898                 case 'u':
 899                     OptCreateDep (Arg, 0);
 900                     break;
 901
 902                 case 'v':
 903                     OptVerbose (Arg, 0);
 904                     break;
 905
 906                 case 'C':
 907                     P = Arg + 2;
 908                     while (*P) {
 909                         switch (*P++) {
 910                             case 'l':
 911                                 OptStaticLocals (Arg, 0);
 912                                 break;
 913                             default:
 914                                 UnknownOption (Arg);
 915                                 break;
 916                         }
 917                     }
 918                     break;
 919
 920                 case 'D':
 921                     DefineSym (GetArg (&I, 2));
 922                     break;
 923
 924                 case 'E':
 925                     PreprocessOnly = 1;
 926                     break;
 927
 928                 case 'I':
 929                     OptIncludeDir (Arg, GetArg (&I, 2));
 930                     break;
 931
 932                 case 'O':
 933                     IS_Set (&Optimize, 1);
 934                     P = Arg + 2;
 935                     while (*P) {
 936                         switch (*P++) {
 937                             case 'i':
 938                                 IS_Set (&CodeSizeFactor, 200);
 939                                 break;
 940                             case 'r':
 941                                 IS_Set (&EnableRegVars, 1);
 942                                 break;
 943                             case 's':
 944                                 IS_Set (&InlineStdFuncs, 1);
 945                                 break;
 946                         }
 947                     }
 948                     break;
 949
 950                 case 'T':
 951                     OptAddSource (Arg, 0);
 952                     break;
 953
 954                 case 'V':
 955                     OptVersion (Arg, 0);
 956                     break;
 957
 958                 case 'W':
 959                     OptWarning (Arg, GetArg (&I, 2));
 960                     break;
 961
 962                 default:
 963                     UnknownOption (Arg);
 964                     break;
 965             }
 966         } else {
 967             if (InputFile) {
 968                 fprintf (stderr, "additional file specs ignored\n");
 969             } else {
 970                 InputFile = Arg;
 971             }
 972         }
 973
 974         /* Next argument */
 975         ++I;
 976     }
 977
 978     /* Did we have a file spec on the command line? */
 979     if (InputFile == 0) {
 980         AbEnd ("No input files");
 981     }
 982
 983     /* Add the default include search paths. */
 984     FinishIncludePaths ();
 985
 986     /* Create the output file name if it was not explicitly given */
 987     MakeDefaultOutputName (InputFile);
 988
 989     /* If no CPU given, use the default CPU for the target */
 990     if (CPU == CPU_UNKNOWN) {
 991         if (Target != TGT_UNKNOWN) {
 992             CPU = GetTargetProperties (Target)->DefaultCPU;
 993         } else {
 994             CPU = CPU_6502;
 995         }
 996     }
 997
 998     /* If no memory model was given, use the default */
 999     if (MemoryModel == MMODEL_UNKNOWN) {
1000         SetMemoryModel (MMODEL_NEAR);
1001     }
1002
1003     /* If no language standard was given, use the default one */
1004     if (IS_Get (&Standard) == STD_UNKNOWN) {
1005         IS_Set (&Standard, STD_DEFAULT);
1006     }
1007
1008     /* Go! */
1009     Compile (InputFile);
1010
1011     /* Create the output file if we didn't had any errors */
1012     if (PreprocessOnly == 0 && (ErrorCount == 0 || Debug)) {
1013
1014         /* Emit literals, externals, do cleanup and optimizations */
1015         FinishCompile ();
1016
1017         /* Open the file */
1018         OpenOutputFile ();
1019
1020         /* Write the output to the file */
1021         WriteAsmOutput ();
1022         Print (stdout, 1, "Wrote output to `%s'\n", OutputFilename);
1023
1024         /* Close the file, check for errors */
1025         CloseOutputFile ();
1026
1027         /* Create dependencies if requested */
1028         CreateDependencies ();
1029     }
1030
1031     /* Return an apropriate exit code */
1032     return (ErrorCount > 0)? EXIT_FAILURE : EXIT_SUCCESS;
1033 }