git.gag.com Git - fw/sdcc/blob - src/SDCCmain.c

   1 /*-------------------------------------------------------------------------
   2   SDCCmain.c - main file
   3
   4              Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1999)
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 2, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20    In other words, you are welcome to use, share and improve this program.
  21    You are forbidden to forbid anyone else to use, share and improve
  22    what you give them.   Help stamp out software-hoarding!
  23 -------------------------------------------------------------------------*/
  24
  25 #ifdef _WIN32
  26 #include <io.h>
  27 #else
  28 #include <unistd.h>
  29 #endif
  30
  31 #include <signal.h>
  32 #include "common.h"
  33 #include <ctype.h>
  34 #include "newalloc.h"
  35 #include "SDCCerr.h"
  36 #include "BuildCmd.h"
  37 #include "MySystem.h"
  38 #include "SDCCmacro.h"
  39 #include "SDCCutil.h"
  40 #include "SDCCdebug.h"
  41 #include "SDCCargs.h"
  42
  43 #ifdef _WIN32
  44 #include <process.h>
  45 #else
  46 #include <sys/stat.h>
  47 #include <unistd.h>
  48 #endif
  49
  50 /* REMOVE ME!!! */
  51 extern int yyparse (void);
  52
  53 FILE *srcFile;                  /* source file          */
  54 char *fullSrcFileName;          /* full name for the source file; */
  55                                 /* can be NULL while c1mode or linking without compiling */
  56 char *fullDstFileName;          /* full name for the output file; */
  57                                 /* only given by -o, otherwise NULL */
  58 char *dstFileName;              /* destination file name without extension */
  59 char *dstPath = "";             /* path for the output files; */
  60                                 /* "" is equivalent with cwd */
  61 char *moduleName;               /* module name is source file without path and extension */
  62                                 /* can be NULL while linking without compiling */
  63 int currRegBank = 0;
  64 int RegBankUsed[4] = {1, 0, 0, 0}; /*JCF: Reg Bank 0 used by default*/
  65 struct optimize optimize;
  66 struct options options;
  67 int preProcOnly = 0;
  68 int noAssemble = 0;
  69 set *preArgvSet = NULL;         /* pre-processor arguments  */
  70 set *asmOptionsSet = NULL;      /* set of assembler options */
  71 set *linkOptionsSet = NULL;     /* set of linker options */
  72 set *libFilesSet = NULL;
  73 set *libPathsSet = NULL;
  74 set *relFilesSet = NULL;
  75 set *dataDirsSet = NULL;        /* list of data search directories */
  76 set *includeDirsSet = NULL;     /* list of include search directories */
  77 set *libDirsSet = NULL;         /* list of lib search directories */
  78
  79 /* uncomment JAMIN_DS390 to always override and use ds390 port
  80   for mcs51 work.  This is temporary, for compatibility testing. */
  81 /* #define JAMIN_DS390 */
  82 #ifdef JAMIN_DS390
  83 int ds390_jammed = 0;
  84 #endif
  85
  86 /* Globally accessible scratch buffer for file names. */
  87 char scratchFileName[PATH_MAX];
  88 char buffer[PATH_MAX * 2];
  89
  90 #define OPTION_HELP     "-help"
  91
  92 #define LENGTH(_a)      (sizeof(_a)/sizeof(*(_a)))
  93
  94 #define OPTION_STACK_8BIT       "--stack-8bit"
  95 #define OPTION_OUT_FMT_IHX      "--out-fmt-ihx"
  96 #define OPTION_LARGE_MODEL      "--model-large"
  97 #define OPTION_MEDIUM_MODEL     "--model-medium"
  98 #define OPTION_SMALL_MODEL      "--model-small"
  99 #define OPTION_FLAT24_MODEL     "--model-flat24"
 100 #define OPTION_DUMP_ALL         "--dumpall"
 101 #define OPTION_PEEP_FILE        "--peep-file"
 102 #define OPTION_LIB_PATH         "--lib-path"
 103 #define OPTION_XSTACK_LOC       "--xstack-loc"
 104 #define OPTION_CALLEE_SAVES     "--callee-saves"
 105 #define OPTION_STACK_LOC        "--stack-loc"
 106 #define OPTION_XRAM_LOC         "--xram-loc"
 107 #define OPTION_IRAM_SIZE        "--iram-size"
 108 #define OPTION_VERSION          "--version"
 109 #define OPTION_DATA_LOC         "--data-loc"
 110 #define OPTION_CODE_LOC         "--code-loc"
 111 #define OPTION_IDATA_LOC        "--idata-loc"
 112 #define OPTION_NO_LABEL_OPT     "--nolabelopt"
 113 #define OPTION_NO_LOOP_INV      "--noinvariant"
 114 #define OPTION_NO_LOOP_IND      "--noinduction"
 115 #define OPTION_LESS_PEDANTIC    "--less-pedantic"
 116 #define OPTION_NO_GCSE          "--nogcse"
 117 #define OPTION_SHORT_IS_8BITS   "--short-is-8bits"
 118 #define OPTION_TINI_LIBID       "--tini-libid"
 119 #define OPTION_NO_XINIT_OPT     "--no-xinit-opt"
 120 #define OPTION_XRAM_SIZE        "--xram-size"
 121 #define OPTION_CODE_SIZE        "--code-size"
 122 #define OPTION_NO_CCODE_IN_ASM  "--no-c-code-in-asm"
 123 #define OPTION_ICODE_IN_ASM     "--i-code-in-asm"
 124 #define OPTION_PRINT_SEARCH_DIRS "--print-search-dirs"
 125 #define OPTION_MSVC_ERROR_STYLE "--vc"
 126 #define OPTION_USE_STDOUT "--use-stdout"
 127
 128 static const OPTION
 129 optionsTable[] = {
 130     { 'm',  NULL,                   NULL, "Set the port to use e.g. -mz80." },
 131     { 'p',  NULL,                   NULL, "Select port specific processor e.g. -mpic14 -p16f84" },
 132     { 'd',  NULL,                   NULL, NULL },
 133     { 'D',  NULL,                   NULL, "Define macro as in -Dmacro" },
 134     { 'I',  NULL,                   NULL, "Add to the include (*.h) path, as in -Ipath" },
 135     { 'A',  NULL,                   NULL, NULL },
 136     { 'U',  NULL,                   NULL, NULL },
 137     { 'C',  NULL,                   NULL, "Preprocessor option" },
 138     { 'M',  NULL,                   NULL, "Preprocessor option" },
 139     { 'V',  NULL,                   &options.verboseExec, "Execute verbosely.  Show sub commands as they are run" },
 140     { 'S',  NULL,                   &noAssemble, "Compile only; do not assemble or link" },
 141     { 'W',  NULL,                   NULL, "Pass through options to the pre-processor (p), assembler (a) or linker (l)" },
 142     { 'L',  NULL,                   NULL, "Add the next field to the library search path" },
 143     { 'l',  NULL,                   NULL, "Include the given library in the link" },
 144     { 0,    OPTION_LARGE_MODEL,     NULL, "external data space is used" },
 145     { 0,    OPTION_MEDIUM_MODEL,    NULL, "not supported" },
 146     { 0,    OPTION_SMALL_MODEL,     NULL, "internal data space is used (default)" },
 147 #if !OPT_DISABLE_DS390
 148     { 0,    OPTION_FLAT24_MODEL,    NULL, "use the flat24 model for the ds390 (default)" },
 149 #endif
 150     { 0,    "--stack-auto",         &options.stackAuto, "Stack automatic variables" },
 151 #if !OPT_DISABLE_DS390
 152     { 0,    OPTION_STACK_8BIT,      NULL, "use the 8bit stack for the ds390 (not supported yet)" },
 153     { 0,    "--stack-10bit",        &options.stack10bit, "use the 10bit stack for ds390 (default)" },
 154 #endif
 155     { 0,    "--xstack",             &options.useXstack, "Use external stack" },
 156     { 0,    OPTION_NO_GCSE,         NULL, "Disable the GCSE optimisation" },
 157     { 0,    OPTION_NO_LABEL_OPT,    NULL, "Disable label optimisation" },
 158     { 0,    OPTION_NO_LOOP_INV,     NULL, "Disable optimisation of invariants" },
 159     { 0,    OPTION_NO_LOOP_IND,     NULL, NULL },
 160     { 0,    "--nojtbound",          &optimize.noJTabBoundary, "Don't generate boundary check for jump tables" },
 161     { 0,    "--noloopreverse",      &optimize.noLoopReverse, "Disable the loop reverse optimisation" },
 162     { 'c',  "--compile-only",       &options.cc_only, "Compile and assemble, but do not link" },
 163     { 'o',  NULL,                   NULL, "Place the output into the given path resp. file" },
 164     { 0,    "--dumpraw",            &options.dump_raw, "Dump the internal structure after the initial parse" },
 165     { 0,    "--dumpgcse",           &options.dump_gcse, NULL },
 166     { 0,    "--dumploop",           &options.dump_loop, NULL },
 167     { 0,    "--dumpdeadcode",       &options.dump_kill, NULL },
 168     { 0,    "--dumpliverange",      &options.dump_range, NULL },
 169     { 0,    "--dumpregpack",        &options.dump_pack, NULL },
 170     { 0,    "--dumpregassign",      &options.dump_rassgn, NULL },
 171     { 0,    "--dumptree",           &options.dump_tree, "dump front-end AST before generating iCode" },
 172     { 0,    OPTION_DUMP_ALL,        NULL, "Dump the internal structure at all stages" },
 173     { 0,    OPTION_XRAM_LOC,        NULL, "<nnnn> External Ram start location" },
 174     { 0,    OPTION_XRAM_SIZE,       NULL, "<nnnn> External Ram size" },
 175     { 0,    OPTION_IRAM_SIZE,       NULL, "<nnnn> Internal Ram size" },
 176     { 0,    OPTION_XSTACK_LOC,      NULL, "<nnnn> External Ram start location" },
 177     { 0,    OPTION_CODE_LOC,        NULL, "<nnnn> Code Segment Location" },
 178     { 0,    OPTION_CODE_SIZE,       NULL, "<nnnn> Code Segment size" },
 179     { 0,    OPTION_STACK_LOC,       NULL, "<nnnn> Stack pointer initial value" },
 180     { 0,    OPTION_DATA_LOC,        NULL, "<nnnn> Direct data start location" },
 181     { 0,    OPTION_IDATA_LOC,       NULL, NULL },
 182     { 0,    OPTION_PEEP_FILE,       NULL, "<file> use this extra peep-hole file" },
 183     { 0,    OPTION_LIB_PATH,        NULL, "<path> use this path to search for libraries" },
 184     { 0,    "--int-long-reent",     &options.intlong_rent, "Use reenterant calls on the int and long support functions" },
 185     { 0,    "--float-reent",        &options.float_rent, "Use reenterant calls on the float support functions" },
 186     { 0,    OPTION_OUT_FMT_IHX,     NULL, NULL },
 187     { 0,    "--out-fmt-s19",        &options.out_fmt, NULL },
 188     { 0,    "--cyclomatic",         &options.cyclomatic, NULL },
 189     { 0,    "--nooverlay",          &options.noOverlay, NULL },
 190     { 0,    "--main-return",        &options.mainreturn, "Issue a return after main()" },
 191     { 0,    "--xram-movc",          &options.xram_movc, "Use movc instead of movx to read xram (xdata)" },
 192     { 0,    "--no-peep",            &options.nopeep, "Disable the peephole assembly file optimisation" },
 193     { 0,    "--no-reg-params",      &options.noRegParams, "On some ports, disable passing some parameters in registers" },
 194     { 0,    "--peep-asm",           &options.asmpeep, NULL },
 195     { 0,    "--debug",              &options.debug, "Enable debugging symbol output" },
 196     { 'v',  OPTION_VERSION,         NULL, "Display sdcc's version" },
 197     { 'E',  "--preprocessonly",     &preProcOnly, "Preprocess only, do not compile" },
 198     { 0,    "--c1mode",             &options.c1mode, "Act in c1 mode.  The standard input is preprocessed code, the output is assembly code." },
 199     { 0,    "--help",               NULL, "Display this help" },
 200     { 0,    OPTION_CALLEE_SAVES,    NULL, "<func[,func,...]> Cause the called function to save registers insted of the caller" },
 201     { 0,    "--nostdlib",           &options.nostdlib, "Do not include the standard library directory in the search path" },
 202     { 0,    "--nostdinc",           &options.nostdinc, "Do not include the standard include directory in the search path" },
 203     { 0,    "--verbose",            &options.verbose, "Trace calls to the preprocessor, assembler, and linker" },
 204     { 0,    OPTION_LESS_PEDANTIC,   NULL, "Disable some of the more pedantic warnings" },
 205     { 0,    OPTION_SHORT_IS_8BITS,   NULL, "Make short 8bits (for old times sake)" },
 206     { 0,    "--profile",            &options.profile, "On supported ports, generate extra profiling information" },
 207     { 0,    "--fommit-frame-pointer", &options.ommitFramePtr, "Leave out the frame pointer." },
 208     { 0,    "--all-callee-saves",   &options.all_callee_saves, "callee will always save registers used" },
 209 #if !OPT_DISABLE_DS390
 210     { 0,    "--use-accelerator",    &options.useAccelerator,"generate code for  DS390 Arithmetic Accelerator"},
 211 #endif
 212     { 0,    "--stack-probe",        &options.stack_probe,"insert call to function __stack_probe at each function prologue"},
 213 #if !OPT_DISABLE_TININative
 214     { 0,    "--tini-libid",         NULL,"<nnnn> LibraryID used in -mTININative"},
 215 #endif
 216 #if !OPT_DISABLE_DS390
 217     { 0,    "--protect-sp-update",  &options.protect_sp_update,"DS390 - will disable interrupts during ESP:SP updates"},
 218 #endif
 219 #if !OPT_DISABLE_DS390 || !OPT_DISABLE_MCS51
 220     { 0,    "--parms-in-bank1",     &options.parms_in_bank1,"MCS51/DS390 - use Bank1 for parameter passing"},
 221 #endif
 222     { 0,    OPTION_NO_XINIT_OPT,    &options.noXinitOpt, "don't memcpy initialized xram from code"},
 223     { 0,    OPTION_NO_CCODE_IN_ASM, &options.noCcodeInAsm, "don't include c-code as comments in the asm file"},
 224     { 0,    OPTION_ICODE_IN_ASM,    &options.iCodeInAsm, "include i-code as comments in the asm file"},
 225     { 0,    OPTION_PRINT_SEARCH_DIRS, &options.printSearchDirs, "display the directories in the compiler's search path"},
 226     { 0,    OPTION_MSVC_ERROR_STYLE, &options.vc_err_style, "messages are compatible with Micro$oft visual studio"},
 227     { 0,    OPTION_USE_STDOUT, &options.use_stdout, "send errors to stdout instead of stderr"},
 228 #if !OPT_DISABLE_Z80 || !OPT_DISABLE_GBZ80
 229     { 0,    "--no-std-crt0", &options.no_std_crt0, "For the z80/gbz80 do not link default crt0.o"},
 230 #endif
 231     /* End of options */
 232 #if 0 /* 10jun03 !OPT_DISABLE_PIC16 */
 233     { 0,    "--no-movff",           &options.no_movff, "disable generating MOVFF opcode in PIC16 port"},
 234     { 0,    "--gen-banksel",        &options.gen_banksel, "enable the generation of banksel assembler directives in PIC16 port"},
 235 #endif
 236     { 0,    NULL }
 237 };
 238
 239 /** Table of all unsupported options and help text to display when one
 240     is used.
 241 */
 242 typedef struct {
 243     /** shortOpt as in OPTIONS. */
 244     char shortOpt;
 245     /** longOpt as in OPTIONS. */
 246     const char *longOpt;
 247     /** Message to display inside W_UNSUPPORTED_OPT when this option
 248         is used. */
 249     const char *message;
 250 } UNSUPPORTEDOPT;
 251
 252 static const UNSUPPORTEDOPT
 253 unsupportedOptTable[] = {
 254     { 'X',  NULL,       "use --xstack-loc instead" },
 255     { 'x',  NULL,       "use --xstack instead" },
 256     { 'i',  NULL,       "use --idata-loc instead" },
 257     { 'r',  NULL,       "use --xdata-loc instead" },
 258     { 's',  NULL,       "use --code-loc instead" },
 259     { 'Y',  NULL,       "use -I instead" }
 260 };
 261
 262 /** List of all default constant macros.
 263  */
 264 static const char *_baseValues[] = {
 265   "cpp", "sdcpp",
 266   "cppextraopts", "",
 267   /* Path seperator character */
 268   "sep", DIR_SEPARATOR_STRING,
 269   NULL
 270 };
 271
 272 static const char *_preCmd = "{cpp} -nostdinc -Wall -std=c99 -DSDCC=1 {cppextraopts} \"{fullsrcfilename}\" \"{cppoutfilename}\"";
 273
 274 PORT *port;
 275
 276 static PORT *_ports[] =
 277 {
 278 #if !OPT_DISABLE_MCS51
 279   &mcs51_port,
 280 #endif
 281 #if !OPT_DISABLE_GBZ80
 282   &gbz80_port,
 283 #endif
 284 #if !OPT_DISABLE_Z80
 285   &z80_port,
 286 #endif
 287 #if !OPT_DISABLE_AVR
 288   &avr_port,
 289 #endif
 290 #if !OPT_DISABLE_DS390
 291   &ds390_port,
 292 #endif
 293 #if !OPT_DISABLE_PIC
 294   &pic_port,
 295 #endif
 296 #if !OPT_DISABLE_PIC16
 297   &pic16_port,
 298 #endif
 299 #if !OPT_DISABLE_TININative
 300   &tininative_port,
 301 #endif
 302 #if !OPT_DISABLE_XA51
 303   &xa51_port,
 304 #endif
 305 #if !OPT_DISABLE_DS400
 306   &ds400_port,
 307 #endif
 308 };
 309
 310 #define NUM_PORTS (sizeof(_ports)/sizeof(_ports[0]))
 311
 312 /** Sets the port to the one given by the command line option.
 313     @param    The name minus the option (eg 'mcs51')
 314     @return     0 on success.
 315 */
 316 static void
 317 _setPort (const char *name)
 318 {
 319   int i;
 320   for (i = 0; i < NUM_PORTS; i++)
 321     {
 322       if (!strcmp (_ports[i]->target, name))
 323         {
 324           port = _ports[i];
 325           return;
 326         }
 327     }
 328   /* Error - didnt find */
 329   werror (E_UNKNOWN_TARGET, name);
 330   exit (1);
 331 }
 332
 333 /* Override the default processor with the one specified
 334  * on the command line */
 335 static void
 336 _setProcessor (char *_processor)
 337 {
 338   port->processor = _processor;
 339   fprintf(stderr,"Processor: %s\n",_processor);
 340 }
 341
 342 static void
 343 _validatePorts (void)
 344 {
 345   int i;
 346   for (i = 0; i < NUM_PORTS; i++)
 347     {
 348       if (_ports[i]->magic != PORT_MAGIC)
 349         {
 350           /* Uncomment this line to debug which port is causing the problem
 351            * (the target name is close to the beginning of the port struct
 352            * and probably can be accessed just fine). */
 353           fprintf(stderr,"%s :",_ports[i]->target);
 354           wassertl (0, "Port definition structure is incomplete");
 355         }
 356     }
 357 }
 358
 359 /* search through the command line options for the port */
 360 static void
 361 _findPort (int argc, char **argv)
 362 {
 363   _validatePorts ();
 364
 365   while (argc--)
 366     {
 367       if (!strncmp (*argv, "-m", 2))
 368         {
 369           _setPort (*argv + 2);
 370           return;
 371         }
 372       argv++;
 373     }
 374
 375   /* Use the first in the list */
 376 #if defined(DEFAULT_PORT)
 377         /* VR - 13/5/2003 DEFAULT_PORT is defined in port.h */
 378         port = &DEFAULT_PORT;
 379 #else
 380         port = _ports[0];
 381 #endif
 382
 383 }
 384
 385 /* search through the command line options for the processor */
 386 static void
 387 _findProcessor (int argc, char **argv)
 388 {
 389   while (argc--)
 390     {
 391       if (!strncmp (*argv, "-p", 2))
 392         {
 393           _setProcessor (*argv + 2);
 394           return;
 395         }
 396       argv++;
 397     }
 398
 399   /* no error if processor was not specified. */
 400 }
 401
 402 /*-----------------------------------------------------------------*/
 403 /* printVersionInfo - prints the version info        */
 404 /*-----------------------------------------------------------------*/
 405 void
 406 printVersionInfo (void)
 407 {
 408   int i;
 409
 410   fprintf (stderr,
 411            "SDCC : ");
 412   for (i = 0; i < NUM_PORTS; i++) {
 413     fprintf (stderr, "%s%s", i == 0 ? "" : "/", _ports[i]->target);
 414 #ifdef DEFAULT_PORT
 415         fprintf(stderr, "%s", (&DEFAULT_PORT == _ports[i])?"*":"");
 416 #endif
 417   }
 418
 419   fprintf (stderr, " " SDCC_VERSION_STR
 420 #ifdef SDCC_SUB_VERSION_STR
 421            "/" SDCC_SUB_VERSION_STR
 422 #endif
 423            " (" __DATE__ ")"
 424 #ifdef __CYGWIN__
 425            " (CYGWIN)\n"
 426 #elif defined __MINGW32__
 427            " (MINGW32)\n"
 428 #elif defined __DJGPP__
 429            " (DJGPP)\n"
 430 #elif defined(_MSC_VER)
 431            " (MSVC)\n"
 432 #elif defined(__BORLANDC__)
 433            " (BORLANDC)\n"
 434 #else
 435            " (UNIX) \n"
 436 #endif
 437     );
 438 }
 439
 440 static void
 441 printOptions(const OPTION *optionsTable)
 442 {
 443   int i;
 444   for (i = 0; optionsTable[i].shortOpt != 0 || optionsTable[i].longOpt != NULL; i++)
 445     {
 446       fprintf(stdout, "  %c%c  %-20s  %s\n",
 447               optionsTable[i].shortOpt !=0 ? '-' : ' ',
 448               optionsTable[i].shortOpt !=0 ? optionsTable[i].shortOpt : ' ',
 449               optionsTable[i].longOpt != NULL ? optionsTable[i].longOpt : "",
 450               optionsTable[i].help != NULL ? optionsTable[i].help : ""
 451               );
 452     }
 453 }
 454
 455 /*-----------------------------------------------------------------*/
 456 /* printUsage - prints command line syntax         */
 457 /*-----------------------------------------------------------------*/
 458 void
 459 printUsage (void)
 460 {
 461     int i;
 462     printVersionInfo();
 463     fprintf (stdout,
 464              "Usage : sdcc [options] filename\n"
 465              "Options :-\n"
 466              );
 467
 468     printOptions(optionsTable);
 469
 470     for (i = 0; i < NUM_PORTS; i++)
 471       {
 472         if (_ports[i]->poptions != NULL)
 473           {
 474             fprintf (stdout, "\nSpecial options for the %s port:\n", _ports[i]->target);
 475             printOptions (_ports[i]->poptions);
 476           }
 477       }
 478
 479     exit (0);
 480 }
 481
 482 /*-----------------------------------------------------------------*/
 483 /* setParseWithComma - separates string with comma to a set        */
 484 /*-----------------------------------------------------------------*/
 485 void
 486 setParseWithComma (set **dest, char *src)
 487 {
 488   char *p;
 489
 490   /* skip the initial white spaces */
 491   while (isspace(*src))
 492     src++;
 493
 494   for (p = strtok(src, ","); p != NULL; p = strtok(NULL, ","))
 495     addSet(dest, Safe_strdup(p));
 496 }
 497
 498 /*-----------------------------------------------------------------*/
 499 /* setDefaultOptions - sets the default options                    */
 500 /*-----------------------------------------------------------------*/
 501 static void
 502 setDefaultOptions (void)
 503 {
 504   /* first the options part */
 505   options.stack_loc = 0;        /* stack pointer initialised to 0 */
 506   options.xstack_loc = 0;       /* xternal stack starts at 0 */
 507   options.code_loc = 0;         /* code starts at 0 */
 508   options.data_loc = 0;         /* JCF: By default let the linker locate data */
 509   options.xdata_loc = 0;
 510   options.idata_loc = 0x80;
 511   options.nopeep = 0;
 512   options.model = port->general.default_model;
 513   options.nostdlib = 0;
 514   options.nostdinc = 0;
 515   options.verbose = 0;
 516   options.shortis8bits = 0;
 517
 518   options.stack10bit=0;
 519
 520   /* now for the optimizations */
 521   /* turn on the everything */
 522   optimize.global_cse = 1;
 523   optimize.label1 = 1;
 524   optimize.label2 = 1;
 525   optimize.label3 = 1;
 526   optimize.label4 = 1;
 527   optimize.loopInvariant = 1;
 528   optimize.loopInduction = 1;
 529
 530   /* now for the ports */
 531   port->setDefaultOptions ();
 532 }
 533
 534 /*-----------------------------------------------------------------*/
 535 /* processFile - determines the type of file from the extension    */
 536 /*-----------------------------------------------------------------*/
 537 static void
 538 processFile (char *s)
 539 {
 540   char *fext = NULL;
 541
 542   /* get the file extension */
 543   fext = s + strlen (s);
 544   while ((fext != s) && *fext != '.')
 545     fext--;
 546
 547   /* now if no '.' then we don't know what the file type is
 548      so give a warning and return */
 549   if (fext == s)
 550     {
 551       werror (W_UNKNOWN_FEXT, s);
 552       return;
 553     }
 554
 555   /* otherwise depending on the file type */
 556   if (strcmp (fext, ".c") == 0 || strcmp (fext, ".C") == 0)
 557     {
 558       /* source file name : not if we already have a
 559          source file */
 560       if (fullSrcFileName)
 561         {
 562           werror (W_TOO_MANY_SRC, s);
 563           return;
 564         }
 565
 566       /* the only source file */
 567       fullSrcFileName = s;
 568       if (!(srcFile = fopen (fullSrcFileName, "r")))
 569         {
 570           werror (E_FILE_OPEN_ERR, s);
 571           exit (1);
 572         }
 573
 574       /* copy the file name into the buffer */
 575       strncpyz (buffer, s, sizeof(buffer));
 576
 577       /* get rid of the "."-extension */
 578
 579       /* is there a dot at all? */
 580       if (strrchr (buffer, '.') &&
 581           /* is the dot in the filename, not in the path? */
 582           (strrchr (buffer, DIR_SEPARATOR_CHAR) < strrchr (buffer, '.')))
 583         {
 584         *strrchr (buffer, '.') = '\0';
 585         }
 586
 587       /* get rid of any path information
 588          for the module name; */
 589       fext = buffer + strlen (buffer);
 590 #if NATIVE_WIN32
 591       /* do this by going backwards till we
 592          get '\' or ':' or start of buffer */
 593       while (fext != buffer &&
 594              *(fext - 1) != DIR_SEPARATOR_CHAR &&
 595              *(fext - 1) != ':')
 596         {
 597         fext--;
 598         }
 599 #else
 600       /* do this by going backwards till we
 601          get '/' or start of buffer */
 602       while (fext != buffer &&
 603              *(fext - 1) != DIR_SEPARATOR_CHAR)
 604         {
 605           fext--;
 606         }
 607 #endif
 608       moduleName = Safe_strdup ( fext );
 609       return;
 610     }
 611
 612   /* if the extention is type .rel or .r or .REL or .R
 613      addtional object file will be passed to the linker */
 614   if (strcmp (fext, ".r") == 0 || strcmp (fext, ".rel") == 0 ||
 615       strcmp (fext, ".R") == 0 || strcmp (fext, ".REL") == 0 ||
 616       strcmp (fext, port->linker.rel_ext) == 0)
 617     {
 618       addSet(&relFilesSet, Safe_strdup(s));
 619       return;
 620     }
 621
 622   /* if .lib or .LIB */
 623   if (strcmp (fext, ".lib") == 0 || strcmp (fext, ".LIB") == 0)
 624     {
 625       addSet(&libFilesSet, Safe_strdup(s));
 626       return;
 627     }
 628
 629   werror (W_UNKNOWN_FEXT, s);
 630
 631 }
 632
 633 static void
 634 _setModel (int model, const char *sz)
 635 {
 636   if (port->general.supported_models & model)
 637     options.model = model;
 638   else
 639     werror (W_UNSUPPORTED_MODEL, sz, port->target);
 640 }
 641
 642 /** Gets the string argument to this option.  If the option is '--opt'
 643     then for input of '--optxyz' or '--opt xyz' returns xyz.
 644 */
 645 static char *
 646 getStringArg(const char *szStart, char **argv, int *pi, int argc)
 647 {
 648   if (argv[*pi][strlen(szStart)])
 649     {
 650       return &argv[*pi][strlen(szStart)];
 651     }
 652   else
 653     {
 654       ++(*pi);
 655       if (*pi >= argc)
 656         {
 657           werror (E_ARGUMENT_MISSING, szStart);
 658           /* Die here rather than checking for errors later. */
 659           exit(-1);
 660         }
 661       else
 662         {
 663           return argv[*pi];
 664         }
 665     }
 666 }
 667
 668 /** Gets the integer argument to this option using the same rules as
 669     getStringArg.
 670 */
 671 static int
 672 getIntArg(const char *szStart, char **argv, int *pi, int argc)
 673 {
 674     return (int)floatFromVal(constVal(getStringArg(szStart, argv, pi, argc)));
 675 }
 676
 677 static void
 678 verifyShortOption(const char *opt)
 679 {
 680   if (strlen(opt) != 2)
 681     {
 682       werror (W_EXCESS_SHORT_OPTIONS, opt);
 683     }
 684 }
 685
 686 static bool
 687 tryHandleUnsupportedOpt(char **argv, int *pi)
 688 {
 689     if (argv[*pi][0] == '-')
 690         {
 691             const char *longOpt = "";
 692             char shortOpt = -1;
 693             int i;
 694
 695             if (argv[*pi][1] == '-')
 696                 {
 697                     /* Long option. */
 698                     longOpt = argv[*pi];
 699                 }
 700             else
 701                 {
 702                     shortOpt = argv[*pi][1];
 703                 }
 704             for (i = 0; i < LENGTH(unsupportedOptTable); i++)
 705                 {
 706                     if (unsupportedOptTable[i].shortOpt == shortOpt ||
 707                         (longOpt && unsupportedOptTable[i].longOpt && !strcmp(unsupportedOptTable[i].longOpt, longOpt))) {
 708                         /* Found an unsupported opt. */
 709                         char buffer[100];
 710                         SNPRINTF(buffer, sizeof(buffer),
 711                                  "%s%c%c",
 712                                  longOpt ? longOpt : "",
 713                                  shortOpt ? '-' : ' ', shortOpt ? shortOpt : ' ');
 714                         werror (W_UNSUPP_OPTION, buffer, unsupportedOptTable[i].message);
 715                         return 1;
 716                     }
 717                 }
 718             /* Didn't find in the table */
 719             return 0;
 720         }
 721     else
 722         {
 723             /* Not an option, so can't be unsupported :) */
 724             return 0;
 725     }
 726 }
 727
 728 static bool
 729 scanOptionsTable(const OPTION *optionsTable, char shortOpt, const char *longOpt, char **argv, int *pi)
 730 {
 731   int i;
 732   for (i = 0; optionsTable[i].shortOpt != 0 || optionsTable[i].longOpt != NULL; i++)
 733     {
 734       if (optionsTable[i].shortOpt == shortOpt ||
 735           (longOpt && optionsTable[i].longOpt &&
 736            strcmp(optionsTable[i].longOpt, longOpt) == 0))
 737         {
 738
 739           /* If it is a flag then we can handle it here */
 740           if (optionsTable[i].pparameter != NULL)
 741             {
 742               if (optionsTable[i].shortOpt == shortOpt)
 743                 {
 744                   verifyShortOption(argv[*pi]);
 745                 }
 746
 747               (*optionsTable[i].pparameter)++;
 748               return 1;
 749             }
 750           else {
 751             /* Not a flag.  Handled manually later. */
 752             return 0;
 753           }
 754         }
 755     }
 756   /* Didn't find in the table */
 757   return 0;
 758 }
 759
 760 static bool
 761 tryHandleSimpleOpt(char **argv, int *pi)
 762 {
 763     if (argv[*pi][0] == '-')
 764         {
 765             const char *longOpt = "";
 766             char shortOpt = -1;
 767
 768             if (argv[*pi][1] == '-')
 769                 {
 770                     /* Long option. */
 771                     longOpt = argv[*pi];
 772                 }
 773             else
 774                 {
 775                     shortOpt = argv[*pi][1];
 776                 }
 777
 778             if (scanOptionsTable(optionsTable, shortOpt, longOpt, argv, pi))
 779               {
 780                 return 1;
 781               }
 782             else if (port && port->poptions &&
 783                      scanOptionsTable(port->poptions, shortOpt, longOpt, argv, pi))
 784               {
 785                 return 1;
 786               }
 787             else
 788               {
 789                 return 0;
 790               }
 791         }
 792     else
 793         {
 794             /* Not an option, so can't be handled. */
 795             return 0;
 796         }
 797 }
 798
 799 /*-----------------------------------------------------------------*/
 800 /* parseCmdLine - parses the command line and sets the options     */
 801 /*-----------------------------------------------------------------*/
 802 static int
 803 parseCmdLine (int argc, char **argv)
 804 {
 805   int i;
 806
 807   /* go thru all whole command line */
 808   for (i = 1; i < argc; i++)
 809     {
 810       if (i >= argc)
 811         break;
 812
 813       if (tryHandleUnsupportedOpt(argv, &i) == TRUE)
 814           {
 815               continue;
 816           }
 817
 818       if (tryHandleSimpleOpt(argv, &i) == TRUE)
 819           {
 820               continue;
 821           }
 822
 823       /* options */
 824       if (argv[i][0] == '-' && argv[i][1] == '-')
 825         {
 826           if (strcmp (argv[i], OPTION_HELP) == 0)
 827             {
 828               printUsage ();
 829               exit (0);
 830             }
 831
 832           if (strcmp (argv[i], OPTION_STACK_8BIT) == 0)
 833             {
 834               options.stack10bit = 0;
 835               continue;
 836             }
 837
 838           if (strcmp (argv[i], OPTION_OUT_FMT_IHX) == 0)
 839             {
 840               options.out_fmt = 0;
 841               continue;
 842             }
 843
 844           if (strcmp (argv[i], OPTION_LARGE_MODEL) == 0)
 845             {
 846               _setModel (MODEL_LARGE, argv[i]);
 847               continue;
 848             }
 849
 850           if (strcmp (argv[i], OPTION_MEDIUM_MODEL) == 0)
 851             {
 852               _setModel (MODEL_MEDIUM, argv[i]);
 853               continue;
 854             }
 855
 856           if (strcmp (argv[i], OPTION_SMALL_MODEL) == 0)
 857             {
 858               _setModel (MODEL_SMALL, argv[i]);
 859               continue;
 860             }
 861
 862           if (strcmp (argv[i], OPTION_FLAT24_MODEL) == 0)
 863             {
 864               _setModel (MODEL_FLAT24, argv[i]);
 865               continue;
 866             }
 867
 868           if (strcmp (argv[i], OPTION_DUMP_ALL) == 0)
 869             {
 870               options.dump_rassgn =
 871                 options.dump_pack =
 872                 options.dump_range =
 873                 options.dump_kill =
 874                 options.dump_loop =
 875                 options.dump_gcse =
 876                 options.dump_raw = 1;
 877               continue;
 878             }
 879
 880           if (strcmp (argv[i], OPTION_PEEP_FILE) == 0)
 881             {
 882                 options.peep_file = getStringArg(OPTION_PEEP_FILE, argv, &i, argc);
 883                 continue;
 884             }
 885
 886           if (strcmp (argv[i], OPTION_LIB_PATH) == 0)
 887             {
 888                 addSet(&libPathsSet, Safe_strdup(getStringArg(OPTION_LIB_PATH, argv, &i, argc)));
 889                 continue;
 890             }
 891
 892           if (strcmp (argv[i], OPTION_VERSION) == 0)
 893             {
 894               printVersionInfo ();
 895               exit (0);
 896               continue;
 897             }
 898
 899           if (strcmp (argv[i], OPTION_CALLEE_SAVES) == 0)
 900             {
 901                 setParseWithComma(&options.calleeSavesSet, getStringArg(OPTION_CALLEE_SAVES, argv, &i, argc));
 902                 continue;
 903             }
 904
 905           if (strcmp (argv[i], OPTION_XSTACK_LOC) == 0)
 906             {
 907                 options.xstack_loc = getIntArg(OPTION_XSTACK_LOC, argv, &i, argc);
 908                 continue;
 909             }
 910
 911           if (strcmp (argv[i], OPTION_STACK_LOC) == 0)
 912             {
 913                 options.stack_loc = getIntArg(OPTION_STACK_LOC, argv, &i, argc);
 914                 continue;
 915             }
 916
 917           if (strcmp (argv[i], OPTION_XRAM_LOC) == 0)
 918             {
 919                 options.xdata_loc = getIntArg(OPTION_XRAM_LOC, argv, &i, argc);
 920                 continue;
 921             }
 922
 923           if (strcmp (argv[i], OPTION_IRAM_SIZE) == 0)
 924             {
 925                 options.iram_size = getIntArg(OPTION_IRAM_SIZE, argv, &i, argc);
 926                 continue;
 927             }
 928
 929           if (strcmp (argv[i], OPTION_XRAM_SIZE) == 0)
 930             {
 931                 options.xram_size = getIntArg(OPTION_IRAM_SIZE, argv, &i, argc);
 932                 options.xram_size_set = TRUE;
 933                 continue;
 934             }
 935
 936           if (strcmp (argv[i], OPTION_CODE_SIZE) == 0)
 937             {
 938                 options.code_size = getIntArg(OPTION_IRAM_SIZE, argv, &i, argc);
 939                 continue;
 940             }
 941
 942           if (strcmp (argv[i], OPTION_DATA_LOC) == 0)
 943             {
 944                 options.data_loc = getIntArg(OPTION_DATA_LOC, argv, &i, argc);
 945                 continue;
 946             }
 947
 948           if (strcmp (argv[i], OPTION_IDATA_LOC) == 0)
 949             {
 950                 options.idata_loc = getIntArg(OPTION_IDATA_LOC, argv, &i, argc);
 951                 continue;
 952             }
 953
 954           if (strcmp (argv[i], OPTION_CODE_LOC) == 0)
 955             {
 956                 options.code_loc = getIntArg(OPTION_CODE_LOC, argv, &i, argc);
 957                 continue;
 958             }
 959
 960           if (strcmp (argv[i], OPTION_NO_GCSE) == 0)
 961             {
 962               optimize.global_cse = 0;
 963               continue;
 964             }
 965
 966           if (strcmp (argv[i], OPTION_NO_LOOP_INV) == 0)
 967             {
 968               optimize.loopInvariant = 0;
 969               continue;
 970             }
 971
 972           if (strcmp (argv[i], OPTION_NO_LABEL_OPT) == 0)
 973             {
 974               optimize.label4 = 0;
 975               continue;
 976             }
 977
 978           if (strcmp (argv[i], OPTION_NO_LOOP_IND) == 0)
 979             {
 980               optimize.loopInduction = 0;
 981               continue;
 982             }
 983
 984           if (strcmp (argv[i], OPTION_LESS_PEDANTIC) == 0)
 985             {
 986               options.lessPedantic = 1;
 987               setErrorLogLevel(ERROR_LEVEL_WARNING);
 988               continue;
 989             }
 990
 991           if (strcmp (&argv[i][1], OPTION_SHORT_IS_8BITS) == 0)
 992             {
 993               options.shortis8bits=1;
 994               continue;
 995             }
 996
 997           if (strcmp (argv[i], OPTION_TINI_LIBID) == 0)
 998             {
 999                 options.tini_libid = getIntArg(OPTION_TINI_LIBID, argv, &i, argc);
1000                 continue;
1001             }
1002
1003           if (!port->parseOption (&argc, argv, &i))
1004             {
1005               werror (W_UNKNOWN_OPTION, argv[i]);
1006             }
1007           else
1008             {
1009               continue;
1010             }
1011         }
1012
1013       /* if preceded by  '-' then option */
1014       if (*argv[i] == '-')
1015         {
1016           switch (argv[i][1])
1017             {
1018             case 'h':
1019               verifyShortOption(argv[i]);
1020
1021               printUsage ();
1022               exit (0);
1023               break;
1024
1025             case 'm':
1026               /* Used to select the port. But this has already been done. */
1027               break;
1028
1029             case 'p':
1030               /* Used to select the processor in port. But this has
1031                * already been done. */
1032               break;
1033
1034             case 'c':
1035               verifyShortOption(argv[i]);
1036
1037               options.cc_only = 1;
1038               break;
1039
1040             case 'L':
1041                 addSet(&libPathsSet, Safe_strdup(getStringArg("-L", argv, &i, argc)));
1042                 break;
1043
1044             case 'l':
1045                 addSet(&libFilesSet, Safe_strdup(getStringArg("-l", argv, &i, argc)));
1046                 break;
1047
1048             case 'o':
1049               {
1050                 char *p;
1051
1052                 /* copy the file name into the buffer */
1053                 strncpyz(buffer, getStringArg("-o", argv, &i, argc),
1054                          sizeof(buffer));
1055                 /* point to last character */
1056                 p = buffer + strlen (buffer) - 1;
1057                 if (*p == DIR_SEPARATOR_CHAR)
1058                   {
1059                     /* only output path specified */
1060                     dstPath = Safe_strdup (buffer);
1061                     fullDstFileName = NULL;
1062                   }
1063                 else
1064                   {
1065                     fullDstFileName = Safe_strdup (buffer);
1066
1067                     /* get rid of the "."-extension */
1068
1069                     /* is there a dot at all? */
1070                     if (strrchr (buffer, '.') &&
1071                         /* is the dot in the filename, not in the path? */
1072                         (strrchr (buffer, DIR_SEPARATOR_CHAR) < strrchr (buffer, '.')))
1073                       *strrchr (buffer, '.') = '\0';
1074
1075                     dstFileName = Safe_strdup (buffer);
1076
1077                     /* strip module name to get path */
1078                     p = strrchr (buffer, DIR_SEPARATOR_CHAR);
1079                     if (p)
1080                       {
1081                         /* path with trailing / */
1082                         p[1] = '\0';
1083                         dstPath = Safe_strdup (buffer);
1084                       }
1085                   }
1086                 break;
1087               }
1088
1089             case 'W':
1090               /* pre-processer options */
1091               if (argv[i][2] == 'p')
1092                 {
1093                   setParseWithComma(&preArgvSet, getStringArg("-Wp", argv, &i, argc));
1094                 }
1095               /* linker options */
1096               else if (argv[i][2] == 'l')
1097                 {
1098                   setParseWithComma(&linkOptionsSet, getStringArg("-Wl", argv, &i, argc));
1099                 }
1100               /* assembler options */
1101               else if (argv[i][2] == 'a')
1102                 {
1103                   setParseWithComma(&asmOptionsSet, getStringArg("-Wa", argv, &i, argc));
1104                 }
1105               else
1106                 {
1107                   werror (W_UNKNOWN_OPTION, argv[i]);
1108                 }
1109               break;
1110
1111             case 'v':
1112               verifyShortOption(argv[i]);
1113
1114               printVersionInfo ();
1115               exit (0);
1116               break;
1117
1118               /* preprocessor options */
1119             case 'M':
1120               {
1121                 preProcOnly = 1;
1122                 addSet(&preArgvSet, Safe_strdup("-M"));
1123                 break;
1124               }
1125             case 'C':
1126               {
1127                 addSet(&preArgvSet, Safe_strdup("-C"));
1128                 break;
1129               }
1130
1131             case 'd':
1132             case 'D':
1133             case 'I':
1134             case 'A':
1135             case 'U':
1136               {
1137                 char sOpt = argv[i][1];
1138                 char *rest;
1139
1140                 if (argv[i][2] == ' ' || argv[i][2] == '\0')
1141                   {
1142                     i++;
1143                     if (i >= argc)
1144                       {
1145                           /* No argument. */
1146                           werror(E_ARGUMENT_MISSING, argv[i-1]);
1147                           break;
1148                       }
1149                     else
1150                       {
1151                           rest = argv[i];
1152                       }
1153                   }
1154                 else
1155                   rest = &argv[i][2];
1156
1157                 if (sOpt == 'Y')
1158                   sOpt = 'I';
1159
1160                 SNPRINTF (buffer, sizeof(buffer),
1161                   ((sOpt == 'I') ? "-%c\"%s\"": "-%c%s"), sOpt, rest);
1162                 addSet(&preArgvSet, Safe_strdup(buffer));
1163               }
1164               break;
1165
1166             default:
1167               if (!port->parseOption (&argc, argv, &i))
1168                 werror (W_UNKNOWN_OPTION, argv[i]);
1169             }
1170           continue;
1171         }
1172
1173       if (!port->parseOption (&argc, argv, &i))
1174         {
1175            /* no option must be a filename */
1176            if (options.c1mode)
1177              {
1178                 werror (W_NO_FILE_ARG_IN_C1, argv[i]);
1179              }
1180          else
1181              {
1182                 processFile (argv[i]);
1183              }
1184         }
1185     }
1186
1187   /* some sanity checks in c1 mode */
1188   if (options.c1mode)
1189     {
1190       const char *s;
1191
1192       if (fullSrcFileName)
1193         {
1194           fclose (srcFile);
1195           werror (W_NO_FILE_ARG_IN_C1, fullSrcFileName);
1196         }
1197       fullSrcFileName = NULL;
1198       for (s = setFirstItem(relFilesSet); s != NULL; s = setNextItem(relFilesSet))
1199         {
1200           werror (W_NO_FILE_ARG_IN_C1, s);
1201         }
1202       for (s = setFirstItem(libFilesSet); s != NULL; s = setNextItem(libFilesSet))
1203         {
1204           werror (W_NO_FILE_ARG_IN_C1, s);
1205         }
1206       deleteSet(&relFilesSet);
1207       deleteSet(&libFilesSet);
1208
1209         if (options.cc_only || noAssemble || preProcOnly)
1210         {
1211           werror (W_ILLEGAL_OPT_COMBINATION);
1212         }
1213       options.cc_only = noAssemble = preProcOnly = 0;
1214       if (!dstFileName)
1215         {
1216           werror (E_NEED_OPT_O_IN_C1);
1217           exit (1);
1218         }
1219     }
1220   /* if no dstFileName given with -o, we've to find one: */
1221   if (!dstFileName)
1222     {
1223       const char *s;
1224
1225       /* use the modulename from the C-source */
1226       if (fullSrcFileName)
1227         {
1228           size_t bufSize = strlen (dstPath) + strlen (moduleName) + 1;
1229
1230           dstFileName = Safe_alloc (bufSize);
1231           strncpyz (dstFileName, dstPath, bufSize);
1232           strncatz (dstFileName, moduleName, bufSize);
1233         }
1234       /* use the modulename from the first object file */
1235       else if ((s = peekSet(relFilesSet)) != NULL)
1236         {
1237           char *objectName;
1238           size_t bufSize;
1239
1240           strncpyz (buffer, s, sizeof(buffer));
1241           /* remove extension (it must be .rel) */
1242           *strrchr (buffer, '.') = '\0';
1243           /* remove path */
1244           objectName = strrchr (buffer, DIR_SEPARATOR_CHAR);
1245           if (objectName)
1246             {
1247               ++objectName;
1248             }
1249           else
1250             {
1251               objectName = buffer;
1252             }
1253           bufSize = strlen (dstPath) + strlen (objectName) + 1;
1254           dstFileName = Safe_alloc (bufSize);
1255           strncpyz (dstFileName, dstPath, bufSize);
1256           strncatz (dstFileName, objectName, bufSize);
1257         }
1258       /* else no module given: help text is displayed */
1259     }
1260
1261   /* set up external stack location if not explicitly specified */
1262   if (!options.xstack_loc)
1263     options.xstack_loc = options.xdata_loc;
1264
1265   /* if debug option is set then open the cdbFile */
1266   if (options.debug && fullSrcFileName)
1267     {
1268       SNPRINTF (scratchFileName, sizeof(scratchFileName),
1269                 "%s.adb", dstFileName); /*JCF: Nov 30, 2002*/
1270       if(debugFile->openFile(scratchFileName))
1271         debugFile->writeModule(moduleName);
1272       else
1273         werror (E_FILE_OPEN_ERR, scratchFileName);
1274     }
1275   MSVC_style(options.vc_err_style);
1276   if(options.use_stdout) dup2(STDOUT_FILENO, STDERR_FILENO);
1277
1278   return 0;
1279 }
1280
1281 /*-----------------------------------------------------------------*/
1282 /* linkEdit : - calls the linkage editor  with options             */
1283 /*-----------------------------------------------------------------*/
1284 static void
1285 linkEdit (char **envp)
1286 {
1287   FILE *lnkfile;
1288   char *segName, *c;
1289   int system_ret;
1290   const char *s;
1291
1292   /* first we need to create the <filename>.lnk file */
1293   SNPRINTF (scratchFileName, sizeof(scratchFileName),
1294             "%s.lnk", dstFileName);
1295   if (!(lnkfile = fopen (scratchFileName, "w")))
1296     {
1297       werror (E_FILE_OPEN_ERR, scratchFileName);
1298       exit (1);
1299     }
1300
1301    if (TARGET_IS_Z80 || TARGET_IS_GBZ80)
1302    {
1303           fprintf (lnkfile, "--\n-m\n-j\n-x\n-%c %s\n",
1304           (options.out_fmt ? 's' : 'i'), dstFileName);
1305    }
1306    else /*For all the other ports.  Including pics???*/
1307    {
1308           fprintf (lnkfile, "-myux%c\n", (options.out_fmt ? 's' : 'i'));
1309    }
1310
1311    if (!(TARGET_IS_Z80 || TARGET_IS_GBZ80)) /*Not for the z80, gbz80*/
1312    {
1313           /* if iram size specified */
1314           if (options.iram_size)
1315                 fprintf (lnkfile, "-a 0x%04x\n", options.iram_size);
1316
1317           /* if xram size specified */
1318           if (options.xram_size_set)
1319                 fprintf (lnkfile, "-v 0x%04x\n", options.xram_size);
1320
1321           /* if code size specified */
1322           if (options.code_size)
1323                 fprintf (lnkfile, "-w 0x%04x\n", options.code_size);
1324
1325           if (options.debug)
1326                 fprintf (lnkfile, "-z\n");
1327    }
1328
1329 #define WRITE_SEG_LOC(N, L) \
1330     segName = Safe_strdup(N); \
1331     c = strtok(segName, " \t"); \
1332     fprintf (lnkfile,"-b %s = 0x%04x\n", c, L); \
1333     if (segName) { Safe_free(segName); }
1334
1335    if (!(TARGET_IS_Z80 || TARGET_IS_GBZ80)) /*Not for the z80, gbz80*/
1336    {
1337
1338           /* code segment start */
1339           WRITE_SEG_LOC (CODE_NAME, options.code_loc);
1340
1341           /* data segment start. If zero, the linker chooses
1342       the best place for data*/
1343           if(options.data_loc){
1344                   WRITE_SEG_LOC (DATA_NAME, options.data_loc);
1345           }
1346
1347           /* xdata start */
1348           WRITE_SEG_LOC (XDATA_NAME, options.xdata_loc);
1349
1350           /* indirect data */
1351           if (IDATA_NAME) {
1352                 WRITE_SEG_LOC (IDATA_NAME, options.idata_loc);
1353           }
1354
1355           /* bit segment start */
1356           WRITE_SEG_LOC (BIT_NAME, 0);
1357
1358           /* stack start */
1359           if ( (options.stack_loc) && (options.stack_loc<0x100) ) {
1360                 WRITE_SEG_LOC ("SSEG", options.stack_loc);
1361           }
1362    }
1363    else /*For the z80, gbz80*/
1364    {
1365        WRITE_SEG_LOC ("_CODE", options.code_loc);
1366        WRITE_SEG_LOC ("_DATA", options.data_loc);
1367    }
1368
1369   /* If the port has any special linker area declarations, get 'em */
1370   if (port->extraAreas.genExtraAreaLinkOptions)
1371   {
1372         port->extraAreas.genExtraAreaLinkOptions(lnkfile);
1373   }
1374
1375   /* add the extra linker options */
1376   fputStrSet(lnkfile, linkOptionsSet);
1377
1378   /* other library paths if specified */
1379   for (s = setFirstItem(libPathsSet); s != NULL; s = setNextItem(libPathsSet))
1380     fprintf (lnkfile, "-k %s\n", s);
1381
1382   /* standard library path */
1383     if (!options.nostdlib)
1384     {
1385         if (!(TARGET_IS_Z80 || TARGET_IS_GBZ80)) /*Not for the z80, gbz80*/
1386         {
1387             switch (options.model)
1388             {
1389                 case MODEL_SMALL:
1390                     c = "small";
1391                     break;
1392                 case MODEL_LARGE:
1393                     c = "large";
1394                     break;
1395                 case MODEL_FLAT24:
1396                     /* c = "flat24"; */
1397                     if (TARGET_IS_DS390)
1398                     {
1399                         c = "ds390";
1400                     }
1401                     else if (TARGET_IS_DS400)
1402                     {
1403                         c = "ds400";
1404                     }
1405                     else
1406                     {
1407                         fprintf(stderr,
1408                                 "Add support for your FLAT24 target in %s @ line %d\n",
1409                                 __FILE__, __LINE__);
1410                         exit(-1);
1411                     }
1412                         break;
1413                     case MODEL_PAGE0:
1414                         c = "xa51";
1415                         break;
1416                     default:
1417                         werror (W_UNKNOWN_MODEL, __FILE__, __LINE__);
1418                         c = "unknown";
1419                         break;
1420                 }
1421         }
1422         else /*for the z80, gbz80*/
1423         {
1424             if (TARGET_IS_Z80)
1425                 c = "z80";
1426             else
1427                 c = "gbz80";
1428         }
1429         for (s = setFirstItem(libDirsSet); s != NULL; s = setNextItem(libDirsSet))
1430             mfprintf (lnkfile, getRuntimeVariables(), "-k %s{sep}%s\n", s, c);
1431
1432
1433       /* standard library files */
1434 #if !OPT_DISABLE_DS390
1435         if (options.model == MODEL_FLAT24)
1436         {
1437             if (TARGET_IS_DS390)
1438             {
1439                 fprintf (lnkfile, "-l %s\n", STD_DS390_LIB);
1440             }
1441             else if (TARGET_IS_DS400)
1442             {
1443                 fprintf (lnkfile, "-l %s\n", STD_DS400_LIB);
1444             }
1445             else
1446             {
1447                 fprintf(stderr,
1448                     "Add support for your FLAT24 target in %s @ line %d\n",
1449                     __FILE__, __LINE__);
1450                 exit(-1);
1451             }
1452         }
1453 #endif
1454
1455 #if !OPT_DISABLE_XA51
1456 #ifdef STD_XA51_LIB
1457         if (options.model == MODEL_PAGE0)
1458         {
1459             fprintf (lnkfile, "-l %s\n", STD_XA51_LIB);
1460         }
1461 #endif
1462 #endif
1463         if (!(TARGET_IS_Z80 || TARGET_IS_GBZ80)) /*Not for the z80, gbz80*/
1464         { /*Why the z80 port is not using the standard libraries?*/
1465             fprintf (lnkfile, "-l %s\n", STD_LIB);
1466             fprintf (lnkfile, "-l %s\n", STD_INT_LIB);
1467             fprintf (lnkfile, "-l %s\n", STD_LONG_LIB);
1468             fprintf (lnkfile, "-l %s\n", STD_FP_LIB);
1469         }
1470         else if (TARGET_IS_Z80)
1471         {
1472             fprintf (lnkfile, "-l z80\n");
1473         }
1474         else if (TARGET_IS_GBZ80)
1475         {
1476             fprintf (lnkfile, "-l gbz80\n");
1477         }
1478     }
1479
1480   /* additional libraries if any */
1481   for (s = setFirstItem(libFilesSet); s != NULL; s = setNextItem(libFilesSet))
1482     fprintf (lnkfile, "-l %s\n", s);
1483
1484   /*For the z80 and gbz80 ports, try to find where crt0.o is...
1485   It is very important for this file to be first on the linking proccess
1486   so the areas are set in the correct order, expecially _GSINIT*/
1487   if ((TARGET_IS_Z80 || TARGET_IS_GBZ80) && !options.no_std_crt0) /*For the z80, gbz80*/
1488   {
1489       char crt0path[PATH_MAX];
1490       FILE * crt0fp;
1491       for (s = setFirstItem(libDirsSet); s != NULL; s = setNextItem(libDirsSet))
1492       {
1493           sprintf (crt0path, "%s%s%s%scrt0.o",
1494              s, DIR_SEPARATOR_STRING, c, DIR_SEPARATOR_STRING);
1495
1496           crt0fp=fopen(crt0path, "r");
1497           if(crt0fp!=NULL)/*Found it!*/
1498           {
1499               fclose(crt0fp);
1500               #ifdef __CYGWIN__
1501               {
1502                  /*The CYGWIN version of the z80-gbz80 linker is getting confused with
1503                  windows paths, so convert them to the CYGWIN format*/
1504                  char posix_path[PATH_MAX];
1505                  void cygwin_conv_to_full_posix_path(char * win_path, char * posix_path);
1506                  cygwin_conv_to_full_posix_path(crt0path, posix_path);
1507                  strcpy(crt0path, posix_path);
1508               }
1509               #endif
1510               fprintf (lnkfile, "%s\n", crt0path);
1511               break;
1512           }
1513       }
1514       if(s==NULL) fprintf (stderr, "Warning: couldn't find crt0.o\n");
1515   }
1516
1517   /* put in the object files */
1518   if (fullSrcFileName)
1519     fprintf (lnkfile, "%s%s\n", dstFileName, port->linker.rel_ext);
1520
1521   fputStrSet(lnkfile, relFilesSet);
1522
1523   fprintf (lnkfile, "\n-e\n");
1524   fclose (lnkfile);
1525
1526   if (options.verbose)
1527     printf ("sdcc: Calling linker...\n");
1528
1529   /* build linker output filename */
1530
1531   /* -o option overrides default name? */
1532   if (fullDstFileName)
1533     {
1534       strncpyz (scratchFileName, fullDstFileName, sizeof(scratchFileName));
1535     }
1536   else
1537     {
1538       /* the linked file gets the name of the first modul */
1539       if (fullSrcFileName)
1540         {
1541           strncpyz (scratchFileName, dstFileName, sizeof(scratchFileName));
1542         }
1543       else
1544         {
1545           s = peekSet(relFilesSet);
1546
1547           assert(s);
1548
1549           strncpyz (scratchFileName, s, sizeof(scratchFileName));
1550           /* strip ".rel" extension */
1551           *strrchr (scratchFileName, '.') = '\0';
1552         }
1553       strncatz (scratchFileName,
1554                 options.out_fmt ? ".S19" : ".ihx",
1555                 sizeof(scratchFileName));
1556     }
1557
1558   if (port->linker.cmd)
1559     {
1560       char buffer2[PATH_MAX];
1561
1562         /* VR 030517 - gplink needs linker options to set the linker script,*/
1563         buildCmdLine (buffer2, port->linker.cmd, dstFileName, scratchFileName, NULL, linkOptionsSet);
1564
1565         buildCmdLine2 (buffer, sizeof(buffer), buffer2);
1566     }
1567   else
1568     {
1569       buildCmdLine2 (buffer, sizeof(buffer), port->linker.mcmd);
1570     }
1571
1572 /*  if (options.verbose)fprintf(stderr, "linker command line: %s\n", buffer); */
1573
1574   system_ret = my_system (buffer);
1575   /* TODO: most linker don't have a -o parameter */
1576   /* -o option overrides default name? */
1577   if (fullDstFileName)
1578     {
1579       char *p, *q;
1580       /* the linked file gets the name of the first modul */
1581       if (fullSrcFileName)
1582         {
1583           strncpyz (scratchFileName, dstFileName, sizeof(scratchFileName));
1584           p = strlen (scratchFileName) + scratchFileName;
1585         }
1586       else
1587         {
1588           s = peekSet(relFilesSet);
1589
1590           assert(s);
1591
1592           strncpyz (scratchFileName, s, sizeof(scratchFileName));
1593           /* strip ".rel" extension */
1594           p = strrchr (scratchFileName, '.');
1595           if (p)
1596             {
1597               *p = 0;
1598             }
1599         }
1600       strncatz (scratchFileName,
1601                 options.out_fmt ? ".S19" : ".ihx",
1602                 sizeof(scratchFileName));
1603       rename (scratchFileName, fullDstFileName);
1604
1605       strncpyz (buffer, fullDstFileName, sizeof(buffer));
1606       q = strrchr (buffer, '.');
1607       if (!q)
1608         {
1609           /* no extension: append new extensions */
1610           q = strlen (buffer) + buffer;
1611         }
1612
1613       *p = 0;
1614       strncatz (scratchFileName, ".map", sizeof(scratchFileName));
1615       *q = 0;
1616       strncatz(buffer, ".map", sizeof(buffer));
1617       rename (scratchFileName, buffer);
1618       *p = 0;
1619       strncatz (scratchFileName, ".mem", sizeof(scratchFileName));
1620       *q = 0;
1621       strncatz(buffer, ".mem", sizeof(buffer));
1622       rename (scratchFileName, buffer);
1623     }
1624   if (system_ret)
1625     {
1626       exit (1);
1627     }
1628 }
1629
1630 /*-----------------------------------------------------------------*/
1631 /* assemble - spawns the assembler with arguments                  */
1632 /*-----------------------------------------------------------------*/
1633 static void
1634 assemble (char **envp)
1635 {
1636     /* build assembler output filename */
1637
1638     /* -o option overrides default name? */
1639     if (options.cc_only && fullDstFileName) {
1640         strncpyz (scratchFileName, fullDstFileName, sizeof(scratchFileName));
1641     } else {
1642         /* the assembled file gets the name of the first modul */
1643         strncpyz (scratchFileName, dstFileName, sizeof(scratchFileName));
1644         strncatz (scratchFileName, port->linker.rel_ext,
1645                   sizeof(scratchFileName));
1646     }
1647
1648     if (port->assembler.do_assemble) {
1649         port->assembler.do_assemble(asmOptionsSet);
1650         return ;
1651     } else if (port->assembler.cmd) {
1652         buildCmdLine (buffer, port->assembler.cmd, dstFileName, scratchFileName,
1653                       options.debug ? port->assembler.debug_opts : port->assembler.plain_opts,
1654                       asmOptionsSet);
1655     } else {
1656         buildCmdLine2 (buffer, sizeof(buffer), port->assembler.mcmd);
1657     }
1658
1659     if (my_system (buffer)) {
1660         /* either system() or the assembler itself has reported an error
1661            perror ("Cannot exec assembler");
1662         */
1663         exit (1);
1664     }
1665     /* TODO: most assembler don't have a -o parameter */
1666     /* -o option overrides default name? */
1667     if (options.cc_only && fullDstFileName) {
1668         strncpyz (scratchFileName, dstFileName, sizeof(scratchFileName));
1669         strncatz (scratchFileName,
1670                   port->linker.rel_ext,
1671                   sizeof(scratchFileName));
1672         rename (scratchFileName, fullDstFileName);
1673     }
1674 }
1675
1676 /*-----------------------------------------------------------------*/
1677 /* preProcess - spawns the preprocessor with arguments       */
1678 /*-----------------------------------------------------------------*/
1679 static int
1680 preProcess (char **envp)
1681 {
1682   if (options.c1mode)
1683     {
1684       yyin = stdin;
1685     }
1686   else
1687     {
1688       const char *s;
1689       set *inclList = NULL;
1690
1691       /* if using external stack define the macro */
1692       if (options.useXstack)
1693         addSet(&preArgvSet, Safe_strdup("-DSDCC_USE_XSTACK"));
1694
1695       /* set the macro for stack autos  */
1696       if (options.stackAuto)
1697         addSet(&preArgvSet, Safe_strdup("-DSDCC_STACK_AUTO"));
1698
1699       /* set the macro for stack autos  */
1700       if (options.stack10bit)
1701         addSet(&preArgvSet, Safe_strdup("-DSDCC_STACK_TENBIT"));
1702
1703       /* set the macro for no overlay  */
1704       if (options.noOverlay)
1705         addSet(&preArgvSet, Safe_strdup("-DSDCC_NOOVERLAY"));
1706
1707       /* set the macro for large model  */
1708       switch (options.model)
1709         {
1710         case MODEL_LARGE:
1711           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_LARGE"));
1712           break;
1713         case MODEL_SMALL:
1714           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_SMALL"));
1715           break;
1716         case MODEL_COMPACT:
1717           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_COMPACT"));
1718           break;
1719         case MODEL_MEDIUM:
1720           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_MEDIUM"));
1721           break;
1722         case MODEL_FLAT24:
1723           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_FLAT24"));
1724           break;
1725         case MODEL_PAGE0:
1726           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_PAGE0"));
1727           break;
1728         default:
1729           werror (W_UNKNOWN_MODEL, __FILE__, __LINE__);
1730           break;
1731         }
1732
1733       /* add port (processor information to processor */
1734       addSet(&preArgvSet, Safe_strdup("-DSDCC_{port}"));
1735       addSet(&preArgvSet, Safe_strdup("-D__{port}"));
1736
1737       /* standard include path */
1738       if (!options.nostdinc) {
1739         inclList = appendStrSet(includeDirsSet, "-I\"", "\"");
1740         mergeSets(&preArgvSet, inclList);
1741       }
1742
1743       setMainValue("cppextraopts", (s = joinStrSet(preArgvSet)));
1744       Safe_free((void *)s);
1745       if (inclList != NULL)
1746         deleteSet(&inclList);
1747
1748       if (preProcOnly && fullDstFileName)
1749         {
1750           /* -E and -o given */
1751           setMainValue ("cppoutfilename", fullDstFileName);
1752         }
1753       else
1754         {
1755           /* Piping: set cppoutfilename to NULL, to avoid empty quotes */
1756           setMainValue ("cppoutfilename", NULL);
1757         }
1758
1759       if (options.verbose)
1760         printf ("sdcc: Calling preprocessor...\n");
1761
1762       buildCmdLine2 (buffer, sizeof(buffer), _preCmd);
1763
1764       if (preProcOnly) {
1765         if (my_system (buffer)) {
1766           exit (1);
1767         }
1768
1769         exit (0);
1770       }
1771
1772       yyin = my_popen (buffer);
1773       if (yyin == NULL) {
1774           perror ("Preproc file not found");
1775           exit (1);
1776       }
1777       addSetHead (&pipeSet, yyin);
1778     }
1779
1780   return 0;
1781 }
1782
1783 /* Set bin paths */
1784 static void
1785 setBinPaths(const char *argv0)
1786 {
1787   char *p;
1788   char buf[PATH_MAX];
1789
1790   /*
1791    * Search logic:
1792    *
1793    * 1. - $SDCCDIR/PREFIX2BIN_DIR
1794    * 2. - path(argv[0])
1795    * 3. - $PATH
1796    */
1797
1798   /* do it in reverse mode, so that addSetHead() can be used
1799      instead of slower addSet() */
1800
1801   if ((p = getBinPath(argv0)) != NULL)
1802     addSetHead(&binPathSet, Safe_strdup(p));
1803
1804   if ((p = getenv(SDCC_DIR_NAME)) != NULL) {
1805     SNPRINTF(buf, sizeof buf, "%s" PREFIX2BIN_DIR, p);
1806     addSetHead(&binPathSet, Safe_strdup(buf));
1807   }
1808
1809   if (options.printSearchDirs) {
1810     printf("programs:\n");
1811     fputStrSet(stdout, binPathSet);
1812   }
1813 }
1814
1815 /* Set system include path */
1816 static void
1817 setIncludePath(void)
1818 {
1819   char *p;
1820
1821   /*
1822    * Search logic:
1823    *
1824    * 1. - $SDCC_INCLUDE
1825    * 2. - $SDCC_HOME/PREFIX2DATA_DIR/INCLUDE_DIR_SUFFIX
1826    * 3. - path(argv[0])/BIN2DATA_DIR/INCLUDE_DIR_SUFFIX
1827    * 4. - DATADIR/INCLUDE_DIR_SUFFIX (only on *nix)
1828    */
1829
1830   includeDirsSet = appendStrSet(dataDirsSet, NULL, INCLUDE_DIR_SUFFIX);
1831
1832   if ((p = getenv(SDCC_INCLUDE_NAME)) != NULL)
1833     addSetHead(&includeDirsSet, p);
1834
1835   if (options.printSearchDirs) {
1836     printf("includedir:\n");
1837     fputStrSet(stdout, includeDirsSet);
1838   }
1839 }
1840
1841 /* Set system lib path */
1842 static void
1843 setLibPath(void)
1844 {
1845   char *p;
1846
1847   /*
1848    * Search logic:
1849    *
1850    * 1. - $SDCC_LIB
1851    * 2. - $SDCC_HOME/PREFIX2DATA_DIR/LIB_DIR_SUFFIX/<model>
1852    * 3. - path(argv[0])/BIN2DATA_DIR/LIB_DIR_SUFFIX/<model>
1853    * 4. - DATADIR/LIB_DIR_SUFFIX/<model> (only on *nix)
1854    */
1855
1856   libDirsSet = appendStrSet(dataDirsSet, NULL, LIB_DIR_SUFFIX);
1857
1858   if ((p = getenv(SDCC_LIB_NAME)) != NULL)
1859     addSetHead(&libDirsSet, p);
1860
1861   if (options.printSearchDirs) {
1862     printf("libdir:\n");
1863     fputStrSet(stdout, libDirsSet);
1864   }
1865 }
1866
1867 /* Set data path */
1868 static void
1869 setDataPaths(const char *argv0)
1870 {
1871   char *p;
1872   char buf[PATH_MAX];
1873
1874   /*
1875    * Search logic:
1876    *
1877    * 1. - $SDCC_HOME/PREFIX2DATA_DIR
1878    * 2. - path(argv[0])/BIN2DATA_DIR
1879    * 3. - DATADIR (only on *nix)
1880    */
1881
1882   if ((p = getenv(SDCC_DIR_NAME)) != NULL) {
1883     SNPRINTF(buf, sizeof buf, "%s" PREFIX2DATA_DIR, p);
1884     addSet(&dataDirsSet, Safe_strdup(buf));
1885   }
1886
1887   if ((p = getBinPath(argv0)) != NULL) {
1888     SNPRINTF(buf, sizeof buf, "%s" BIN2DATA_DIR, p);
1889     addSet(&dataDirsSet, Safe_strdup(buf));
1890   }
1891
1892 #ifdef _WIN32
1893   if (peekSet(dataDirsSet) == NULL) {
1894     /* this should never happen... */
1895     wassertl(0, "Can't get binary path");
1896   }
1897 #else
1898   addSet(&dataDirsSet, Safe_strdup(DATADIR));
1899 #endif
1900
1901   if (options.printSearchDirs) {
1902     printf("datadir:\n");
1903     fputStrSet(stdout, dataDirsSet);
1904   }
1905
1906   setIncludePath();
1907   setLibPath();
1908 }
1909
1910 static void
1911 initValues (void)
1912 {
1913   populateMainValues (_baseValues);
1914   setMainValue ("port", port->target);
1915   setMainValue ("objext", port->linker.rel_ext);
1916   setMainValue ("asmext", port->assembler.file_ext);
1917
1918   setMainValue ("dstfilename", dstFileName);
1919   setMainValue ("fullsrcfilename", fullSrcFileName ? fullSrcFileName : "fullsrcfilename");
1920
1921   if (options.cc_only && fullDstFileName)
1922     /* compile + assemble and -o given: -o specifies name of object file */
1923     {
1924       setMainValue ("objdstfilename", fullDstFileName);
1925     }
1926   else
1927     {
1928       setMainValue ("objdstfilename", "{stdobjdstfilename}");
1929     }
1930   if (fullDstFileName)
1931     /* if we're linking, -o gives the final file name */
1932     {
1933       setMainValue ("linkdstfilename", fullDstFileName);
1934     }
1935   else
1936     {
1937       setMainValue ("linkdstfilename", "{stdlinkdstfilename}");
1938     }
1939
1940 }
1941
1942 static void
1943 sig_handler (int signal)
1944 {
1945   char *sig_string;
1946
1947   switch (signal)
1948     {
1949     case SIGABRT:
1950       sig_string = "SIGABRT";
1951       break;
1952     case SIGTERM:
1953       sig_string = "SIGTERM";
1954       break;
1955     case SIGINT:
1956       sig_string = "SIGINT";
1957       break;
1958     case SIGSEGV:
1959       sig_string = "SIGSEGV";
1960       break;
1961     default:
1962       sig_string = "Unknown?";
1963       break;
1964     }
1965   fprintf (stderr, "Caught signal %d: %s\n", signal, sig_string);
1966   exit (1);
1967 }
1968
1969 /*
1970  * main routine
1971  * initialises and calls the parser
1972  */
1973
1974 int
1975 main (int argc, char **argv, char **envp)
1976 {
1977   /* turn all optimizations off by default */
1978   memset (&optimize, 0, sizeof (struct optimize));
1979
1980   /*printVersionInfo (); */
1981
1982   if (NUM_PORTS==0) {
1983     fprintf (stderr, "Build error: no ports are enabled.\n");
1984     exit (1);
1985   }
1986
1987   /* install atexit handler */
1988   atexit(rm_tmpfiles);
1989
1990   /* install signal handler;
1991      it's only purpuse is to call exit() to remove temp files */
1992   if (!getenv("SDCC_LEAVE_SIGNALS"))
1993     {
1994       signal (SIGABRT, sig_handler);
1995       signal (SIGTERM, sig_handler);
1996       signal (SIGINT , sig_handler);
1997       signal (SIGSEGV, sig_handler);
1998     }
1999
2000   /* Before parsing the command line options, do a
2001    * search for the port and processor and initialize
2002    * them if they're found. (We can't gurantee that these
2003    * will be the first options specified).
2004    */
2005
2006   _findPort (argc, argv);
2007
2008 #ifdef JAMIN_DS390
2009   if (strcmp(port->target, "mcs51") == 0) {
2010     printf("DS390 jammed in A\n");
2011           _setPort ("ds390");
2012     ds390_jammed = 1;
2013   }
2014 #endif
2015
2016   _findProcessor (argc, argv);
2017
2018   /* Initalise the port. */
2019   if (port->init)
2020     port->init ();
2021
2022   setDefaultOptions ();
2023 #ifdef JAMIN_DS390
2024   if (ds390_jammed) {
2025     options.model = MODEL_SMALL;
2026     options.stack10bit=0;
2027   }
2028 #endif
2029   parseCmdLine (argc, argv);
2030
2031   initValues ();
2032   setBinPaths(argv[0]);
2033   setDataPaths(argv[0]);
2034
2035   /* if no input then printUsage & exit */
2036   if (!options.c1mode && !fullSrcFileName && peekSet(relFilesSet) == NULL) {
2037     if (!options.printSearchDirs)
2038       printUsage();
2039
2040     exit(0);
2041   }
2042
2043   /* initMem() is expensive, but
2044      initMem() must called before port->finaliseOptions ().
2045      And the z80 port needs port->finaliseOptions(),
2046      even if we're only linking. */
2047   initMem ();
2048   port->finaliseOptions ();
2049
2050   if (fullSrcFileName || options.c1mode)
2051     {
2052       preProcess (envp);
2053
2054       initSymt ();
2055       initiCode ();
2056       initCSupport ();
2057       initBuiltIns();
2058       initPeepHole ();
2059
2060       if (options.verbose)
2061         printf ("sdcc: Generating code...\n");
2062
2063       yyparse ();
2064
2065       pclose(yyin);
2066       deleteSetItem(&pipeSet, yyin);
2067
2068       if (fatalError) {
2069         exit (1);
2070       }
2071
2072       if (port->general.do_glue != NULL)
2073         (*port->general.do_glue)();
2074       else
2075         {
2076           /* this shouldn't happen */
2077           assert(FALSE);
2078           /* in case of NDEBUG */
2079           glue();
2080         }
2081
2082       if (!options.c1mode && !noAssemble)
2083         {
2084           if (options.verbose)
2085             printf ("sdcc: Calling assembler...\n");
2086           assemble (envp);
2087         }
2088     }
2089   closeDumpFiles();
2090
2091   if (options.debug && debugFile)
2092     debugFile->closeFile();
2093
2094   if (!options.cc_only &&
2095       !fatalError &&
2096       !noAssemble &&
2097       !options.c1mode &&
2098       (fullSrcFileName || peekSet(relFilesSet) != NULL))
2099     {
2100       if (port->linker.do_link)
2101         port->linker.do_link ();
2102       else
2103         linkEdit (envp);
2104     }
2105
2106   return 0;
2107 }