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