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 #if !OPT_DISABLE_PIC16
 232     { 0,    "--gen-banksel",        &options.gen_banksel, "enable the generation of banksel assembler directives in PIC16 port"},
 233 #endif
 234     /* End of options */
 235     { 0,    NULL }
 236 };
 237
 238 /** Table of all unsupported options and help text to display when one
 239     is used.
 240 */
 241 typedef struct {
 242     /** shortOpt as in OPTIONS. */
 243     char shortOpt;
 244     /** longOpt as in OPTIONS. */
 245     const char *longOpt;
 246     /** Message to display inside W_UNSUPPORTED_OPT when this option
 247         is used. */
 248     const char *message;
 249 } UNSUPPORTEDOPT;
 250
 251 static const UNSUPPORTEDOPT
 252 unsupportedOptTable[] = {
 253     { 'X',  NULL,       "use --xstack-loc instead" },
 254     { 'x',  NULL,       "use --xstack instead" },
 255     { 'i',  NULL,       "use --idata-loc instead" },
 256     { 'r',  NULL,       "use --xdata-loc instead" },
 257     { 's',  NULL,       "use --code-loc instead" },
 258     { 'Y',  NULL,       "use -I instead" }
 259 };
 260
 261 /** List of all default constant macros.
 262  */
 263 static const char *_baseValues[] = {
 264   "cpp", "sdcpp",
 265   "cppextraopts", "",
 266   /* Path seperator character */
 267   "sep", DIR_SEPARATOR_STRING,
 268   NULL
 269 };
 270
 271 static const char *_preCmd = "{cpp} -nostdinc -Wall -std=c99 -DSDCC=1 {cppextraopts} \"{fullsrcfilename}\" \"{cppoutfilename}\"";
 272
 273 PORT *port;
 274
 275 static PORT *_ports[] =
 276 {
 277 #if !OPT_DISABLE_MCS51
 278   &mcs51_port,
 279 #endif
 280 #if !OPT_DISABLE_GBZ80
 281   &gbz80_port,
 282 #endif
 283 #if !OPT_DISABLE_Z80
 284   &z80_port,
 285 #endif
 286 #if !OPT_DISABLE_AVR
 287   &avr_port,
 288 #endif
 289 #if !OPT_DISABLE_DS390
 290   &ds390_port,
 291 #endif
 292 #if !OPT_DISABLE_PIC
 293   &pic_port,
 294 #endif
 295 #if !OPT_DISABLE_PIC16
 296   &pic16_port,
 297 #endif
 298 #if !OPT_DISABLE_TININative
 299   &tininative_port,
 300 #endif
 301 #if !OPT_DISABLE_XA51
 302   &xa51_port,
 303 #endif
 304 #if !OPT_DISABLE_DS400
 305   &ds400_port,
 306 #endif
 307   &hc08_port,
 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   int length;
 490
 491   /* skip the initial white spaces */
 492   while (isspace(*src))
 493     src++;
 494
 495   /* skip the trailing white spaces */
 496   length = strlen(src);
 497   while (length && isspace(src[length-1]))
 498     src[--length] = '\0';
 499
 500   for (p = strtok(src, ","); p != NULL; p = strtok(NULL, ","))
 501     addSet(dest, Safe_strdup(p));
 502 }
 503
 504 /*-----------------------------------------------------------------*/
 505 /* setDefaultOptions - sets the default options                    */
 506 /*-----------------------------------------------------------------*/
 507 static void
 508 setDefaultOptions (void)
 509 {
 510   /* first the options part */
 511   options.stack_loc = 0;        /* stack pointer initialised to 0 */
 512   options.xstack_loc = 0;       /* xternal stack starts at 0 */
 513   options.code_loc = 0;         /* code starts at 0 */
 514   options.data_loc = 0;         /* JCF: By default let the linker locate data */
 515   options.xdata_loc = 0;
 516   options.idata_loc = 0x80;
 517   options.nopeep = 0;
 518   options.model = port->general.default_model;
 519   options.nostdlib = 0;
 520   options.nostdinc = 0;
 521   options.verbose = 0;
 522   options.shortis8bits = 0;
 523
 524   options.stack10bit=0;
 525
 526   /* now for the optimizations */
 527   /* turn on the everything */
 528   optimize.global_cse = 1;
 529   optimize.label1 = 1;
 530   optimize.label2 = 1;
 531   optimize.label3 = 1;
 532   optimize.label4 = 1;
 533   optimize.loopInvariant = 1;
 534   optimize.loopInduction = 1;
 535
 536   /* now for the ports */
 537   port->setDefaultOptions ();
 538 }
 539
 540 /*-----------------------------------------------------------------*/
 541 /* processFile - determines the type of file from the extension    */
 542 /*-----------------------------------------------------------------*/
 543 static void
 544 processFile (char *s)
 545 {
 546   char *fext = NULL;
 547
 548   /* get the file extension */
 549   fext = s + strlen (s);
 550   while ((fext != s) && *fext != '.')
 551     fext--;
 552
 553   /* now if no '.' then we don't know what the file type is
 554      so give a warning and return */
 555   if (fext == s)
 556     {
 557       werror (W_UNKNOWN_FEXT, s);
 558       return;
 559     }
 560
 561   /* otherwise depending on the file type */
 562   if (strcmp (fext, ".c") == 0 || strcmp (fext, ".C") == 0)
 563     {
 564       /* source file name : not if we already have a
 565          source file */
 566       if (fullSrcFileName)
 567         {
 568           werror (W_TOO_MANY_SRC, s);
 569           return;
 570         }
 571
 572       /* the only source file */
 573       fullSrcFileName = s;
 574       if (!(srcFile = fopen (fullSrcFileName, "r")))
 575         {
 576           werror (E_FILE_OPEN_ERR, s);
 577           exit (1);
 578         }
 579
 580       /* copy the file name into the buffer */
 581       strncpyz (buffer, s, sizeof(buffer));
 582
 583       /* get rid of the "."-extension */
 584
 585       /* is there a dot at all? */
 586       if (strrchr (buffer, '.') &&
 587           /* is the dot in the filename, not in the path? */
 588           (strrchr (buffer, DIR_SEPARATOR_CHAR) < strrchr (buffer, '.')))
 589         {
 590         *strrchr (buffer, '.') = '\0';
 591         }
 592
 593       /* get rid of any path information
 594          for the module name; */
 595       fext = buffer + strlen (buffer);
 596 #if NATIVE_WIN32
 597       /* do this by going backwards till we
 598          get '\' or ':' or start of buffer */
 599       while (fext != buffer &&
 600              *(fext - 1) != DIR_SEPARATOR_CHAR &&
 601              *(fext - 1) != ':')
 602         {
 603         fext--;
 604         }
 605 #else
 606       /* do this by going backwards till we
 607          get '/' or start of buffer */
 608       while (fext != buffer &&
 609              *(fext - 1) != DIR_SEPARATOR_CHAR)
 610         {
 611           fext--;
 612         }
 613 #endif
 614       moduleName = Safe_strdup ( fext );
 615       return;
 616     }
 617
 618   /* if the extention is type .rel or .r or .REL or .R
 619      addtional object file will be passed to the linker */
 620   if (strcmp (fext, ".r") == 0 || strcmp (fext, ".rel") == 0 ||
 621       strcmp (fext, ".R") == 0 || strcmp (fext, ".REL") == 0 ||
 622       strcmp (fext, port->linker.rel_ext) == 0)
 623     {
 624       addSet(&relFilesSet, Safe_strdup(s));
 625       return;
 626     }
 627
 628   /* if .lib or .LIB */
 629   if (strcmp (fext, ".lib") == 0 || strcmp (fext, ".LIB") == 0)
 630     {
 631       addSet(&libFilesSet, Safe_strdup(s));
 632       return;
 633     }
 634
 635   werror (W_UNKNOWN_FEXT, s);
 636
 637 }
 638
 639 static void
 640 _setModel (int model, const char *sz)
 641 {
 642   if (port->general.supported_models & model)
 643     options.model = model;
 644   else
 645     werror (W_UNSUPPORTED_MODEL, sz, port->target);
 646 }
 647
 648 /** Gets the string argument to this option.  If the option is '--opt'
 649     then for input of '--optxyz' or '--opt xyz' returns xyz.
 650 */
 651 static char *
 652 getStringArg(const char *szStart, char **argv, int *pi, int argc)
 653 {
 654   if (argv[*pi][strlen(szStart)])
 655     {
 656       return &argv[*pi][strlen(szStart)];
 657     }
 658   else
 659     {
 660       ++(*pi);
 661       if (*pi >= argc)
 662         {
 663           werror (E_ARGUMENT_MISSING, szStart);
 664           /* Die here rather than checking for errors later. */
 665           exit(-1);
 666         }
 667       else
 668         {
 669           return argv[*pi];
 670         }
 671     }
 672 }
 673
 674 /** Gets the integer argument to this option using the same rules as
 675     getStringArg.
 676 */
 677 static int
 678 getIntArg(const char *szStart, char **argv, int *pi, int argc)
 679 {
 680     return (int)floatFromVal(constVal(getStringArg(szStart, argv, pi, argc)));
 681 }
 682
 683 static void
 684 verifyShortOption(const char *opt)
 685 {
 686   if (strlen(opt) != 2)
 687     {
 688       werror (W_EXCESS_SHORT_OPTIONS, opt);
 689     }
 690 }
 691
 692 static bool
 693 tryHandleUnsupportedOpt(char **argv, int *pi)
 694 {
 695     if (argv[*pi][0] == '-')
 696         {
 697             const char *longOpt = "";
 698             char shortOpt = -1;
 699             int i;
 700
 701             if (argv[*pi][1] == '-')
 702                 {
 703                     /* Long option. */
 704                     longOpt = argv[*pi];
 705                 }
 706             else
 707                 {
 708                     shortOpt = argv[*pi][1];
 709                 }
 710             for (i = 0; i < LENGTH(unsupportedOptTable); i++)
 711                 {
 712                     if (unsupportedOptTable[i].shortOpt == shortOpt ||
 713                         (longOpt && unsupportedOptTable[i].longOpt && !strcmp(unsupportedOptTable[i].longOpt, longOpt))) {
 714                         /* Found an unsupported opt. */
 715                         char buffer[100];
 716                         SNPRINTF(buffer, sizeof(buffer),
 717                                  "%s%c%c",
 718                                  longOpt ? longOpt : "",
 719                                  shortOpt ? '-' : ' ', shortOpt ? shortOpt : ' ');
 720                         werror (W_UNSUPP_OPTION, buffer, unsupportedOptTable[i].message);
 721                         return 1;
 722                     }
 723                 }
 724             /* Didn't find in the table */
 725             return 0;
 726         }
 727     else
 728         {
 729             /* Not an option, so can't be unsupported :) */
 730             return 0;
 731     }
 732 }
 733
 734 static bool
 735 scanOptionsTable(const OPTION *optionsTable, char shortOpt, const char *longOpt, char **argv, int *pi)
 736 {
 737   int i;
 738   for (i = 0; optionsTable[i].shortOpt != 0 || optionsTable[i].longOpt != NULL; i++)
 739     {
 740       if (optionsTable[i].shortOpt == shortOpt ||
 741           (longOpt && optionsTable[i].longOpt &&
 742            strcmp(optionsTable[i].longOpt, longOpt) == 0))
 743         {
 744
 745           /* If it is a flag then we can handle it here */
 746           if (optionsTable[i].pparameter != NULL)
 747             {
 748               if (optionsTable[i].shortOpt == shortOpt)
 749                 {
 750                   verifyShortOption(argv[*pi]);
 751                 }
 752
 753               (*optionsTable[i].pparameter)++;
 754               return 1;
 755             }
 756           else {
 757             /* Not a flag.  Handled manually later. */
 758             return 0;
 759           }
 760         }
 761     }
 762   /* Didn't find in the table */
 763   return 0;
 764 }
 765
 766 static bool
 767 tryHandleSimpleOpt(char **argv, int *pi)
 768 {
 769     if (argv[*pi][0] == '-')
 770         {
 771             const char *longOpt = "";
 772             char shortOpt = -1;
 773
 774             if (argv[*pi][1] == '-')
 775                 {
 776                     /* Long option. */
 777                     longOpt = argv[*pi];
 778                 }
 779             else
 780                 {
 781                     shortOpt = argv[*pi][1];
 782                 }
 783
 784             if (scanOptionsTable(optionsTable, shortOpt, longOpt, argv, pi))
 785               {
 786                 return 1;
 787               }
 788             else if (port && port->poptions &&
 789                      scanOptionsTable(port->poptions, shortOpt, longOpt, argv, pi))
 790               {
 791                 return 1;
 792               }
 793             else
 794               {
 795                 return 0;
 796               }
 797         }
 798     else
 799         {
 800             /* Not an option, so can't be handled. */
 801             return 0;
 802         }
 803 }
 804
 805 /*-----------------------------------------------------------------*/
 806 /* parseCmdLine - parses the command line and sets the options     */
 807 /*-----------------------------------------------------------------*/
 808 static int
 809 parseCmdLine (int argc, char **argv)
 810 {
 811   int i;
 812
 813   /* go thru all whole command line */
 814   for (i = 1; i < argc; i++)
 815     {
 816       if (i >= argc)
 817         break;
 818
 819       if (tryHandleUnsupportedOpt(argv, &i) == TRUE)
 820           {
 821               continue;
 822           }
 823
 824       if (tryHandleSimpleOpt(argv, &i) == TRUE)
 825           {
 826               continue;
 827           }
 828
 829       /* options */
 830       if (argv[i][0] == '-' && argv[i][1] == '-')
 831         {
 832           if (strcmp (argv[i], OPTION_HELP) == 0)
 833             {
 834               printUsage ();
 835               exit (0);
 836             }
 837
 838           if (strcmp (argv[i], OPTION_STACK_8BIT) == 0)
 839             {
 840               options.stack10bit = 0;
 841               continue;
 842             }
 843
 844           if (strcmp (argv[i], OPTION_OUT_FMT_IHX) == 0)
 845             {
 846               options.out_fmt = 0;
 847               continue;
 848             }
 849
 850           if (strcmp (argv[i], OPTION_LARGE_MODEL) == 0)
 851             {
 852               _setModel (MODEL_LARGE, argv[i]);
 853               continue;
 854             }
 855
 856           if (strcmp (argv[i], OPTION_MEDIUM_MODEL) == 0)
 857             {
 858               _setModel (MODEL_MEDIUM, argv[i]);
 859               continue;
 860             }
 861
 862           if (strcmp (argv[i], OPTION_SMALL_MODEL) == 0)
 863             {
 864               _setModel (MODEL_SMALL, argv[i]);
 865               continue;
 866             }
 867
 868           if (strcmp (argv[i], OPTION_FLAT24_MODEL) == 0)
 869             {
 870               _setModel (MODEL_FLAT24, argv[i]);
 871               continue;
 872             }
 873
 874           if (strcmp (argv[i], OPTION_DUMP_ALL) == 0)
 875             {
 876               options.dump_rassgn =
 877                 options.dump_pack =
 878                 options.dump_range =
 879                 options.dump_kill =
 880                 options.dump_loop =
 881                 options.dump_gcse =
 882                 options.dump_raw = 1;
 883               continue;
 884             }
 885
 886           if (strcmp (argv[i], OPTION_PEEP_FILE) == 0)
 887             {
 888                 options.peep_file = getStringArg(OPTION_PEEP_FILE, argv, &i, argc);
 889                 continue;
 890             }
 891
 892           if (strcmp (argv[i], OPTION_LIB_PATH) == 0)
 893             {
 894                 addSet(&libPathsSet, Safe_strdup(getStringArg(OPTION_LIB_PATH, argv, &i, argc)));
 895                 continue;
 896             }
 897
 898           if (strcmp (argv[i], OPTION_VERSION) == 0)
 899             {
 900               printVersionInfo ();
 901               exit (0);
 902               continue;
 903             }
 904
 905           if (strcmp (argv[i], OPTION_CALLEE_SAVES) == 0)
 906             {
 907                 setParseWithComma(&options.calleeSavesSet, getStringArg(OPTION_CALLEE_SAVES, argv, &i, argc));
 908                 continue;
 909             }
 910
 911           if (strcmp (argv[i], OPTION_XSTACK_LOC) == 0)
 912             {
 913                 options.xstack_loc = getIntArg(OPTION_XSTACK_LOC, argv, &i, argc);
 914                 continue;
 915             }
 916
 917           if (strcmp (argv[i], OPTION_STACK_LOC) == 0)
 918             {
 919                 options.stack_loc = getIntArg(OPTION_STACK_LOC, argv, &i, argc);
 920                 continue;
 921             }
 922
 923           if (strcmp (argv[i], OPTION_XRAM_LOC) == 0)
 924             {
 925                 options.xdata_loc = getIntArg(OPTION_XRAM_LOC, argv, &i, argc);
 926                 continue;
 927             }
 928
 929           if (strcmp (argv[i], OPTION_IRAM_SIZE) == 0)
 930             {
 931                 options.iram_size = getIntArg(OPTION_IRAM_SIZE, argv, &i, argc);
 932                 continue;
 933             }
 934
 935           if (strcmp (argv[i], OPTION_XRAM_SIZE) == 0)
 936             {
 937                 options.xram_size = getIntArg(OPTION_IRAM_SIZE, argv, &i, argc);
 938                 options.xram_size_set = TRUE;
 939                 continue;
 940             }
 941
 942           if (strcmp (argv[i], OPTION_CODE_SIZE) == 0)
 943             {
 944                 options.code_size = getIntArg(OPTION_IRAM_SIZE, argv, &i, argc);
 945                 continue;
 946             }
 947
 948           if (strcmp (argv[i], OPTION_DATA_LOC) == 0)
 949             {
 950                 options.data_loc = getIntArg(OPTION_DATA_LOC, argv, &i, argc);
 951                 continue;
 952             }
 953
 954           if (strcmp (argv[i], OPTION_IDATA_LOC) == 0)
 955             {
 956                 options.idata_loc = getIntArg(OPTION_IDATA_LOC, argv, &i, argc);
 957                 continue;
 958             }
 959
 960           if (strcmp (argv[i], OPTION_CODE_LOC) == 0)
 961             {
 962                 options.code_loc = getIntArg(OPTION_CODE_LOC, argv, &i, argc);
 963                 continue;
 964             }
 965
 966           if (strcmp (argv[i], OPTION_NO_GCSE) == 0)
 967             {
 968               optimize.global_cse = 0;
 969               continue;
 970             }
 971
 972           if (strcmp (argv[i], OPTION_NO_LOOP_INV) == 0)
 973             {
 974               optimize.loopInvariant = 0;
 975               continue;
 976             }
 977
 978           if (strcmp (argv[i], OPTION_NO_LABEL_OPT) == 0)
 979             {
 980               optimize.label4 = 0;
 981               continue;
 982             }
 983
 984           if (strcmp (argv[i], OPTION_NO_LOOP_IND) == 0)
 985             {
 986               optimize.loopInduction = 0;
 987               continue;
 988             }
 989
 990           if (strcmp (argv[i], OPTION_LESS_PEDANTIC) == 0)
 991             {
 992               options.lessPedantic = 1;
 993               setErrorLogLevel(ERROR_LEVEL_WARNING);
 994               continue;
 995             }
 996
 997           if (strcmp (&argv[i][1], OPTION_SHORT_IS_8BITS) == 0)
 998             {
 999               options.shortis8bits=1;
1000               continue;
1001             }
1002
1003           if (strcmp (argv[i], OPTION_TINI_LIBID) == 0)
1004             {
1005                 options.tini_libid = getIntArg(OPTION_TINI_LIBID, argv, &i, argc);
1006                 continue;
1007             }
1008
1009           if (!port->parseOption (&argc, argv, &i))
1010             {
1011               werror (W_UNKNOWN_OPTION, argv[i]);
1012             }
1013           else
1014             {
1015               continue;
1016             }
1017         }
1018
1019       /* if preceded by  '-' then option */
1020       if (*argv[i] == '-')
1021         {
1022           switch (argv[i][1])
1023             {
1024             case 'h':
1025               verifyShortOption(argv[i]);
1026
1027               printUsage ();
1028               exit (0);
1029               break;
1030
1031             case 'm':
1032               /* Used to select the port. But this has already been done. */
1033               break;
1034
1035             case 'p':
1036               /* Used to select the processor in port. But this has
1037                * already been done. */
1038               break;
1039
1040             case 'c':
1041               verifyShortOption(argv[i]);
1042
1043               options.cc_only = 1;
1044               break;
1045
1046             case 'L':
1047                 addSet(&libPathsSet, Safe_strdup(getStringArg("-L", argv, &i, argc)));
1048                 break;
1049
1050             case 'l':
1051                 addSet(&libFilesSet, Safe_strdup(getStringArg("-l", argv, &i, argc)));
1052                 break;
1053
1054             case 'o':
1055               {
1056                 char *p;
1057
1058                 /* copy the file name into the buffer */
1059                 strncpyz(buffer, getStringArg("-o", argv, &i, argc),
1060                          sizeof(buffer));
1061                 /* point to last character */
1062                 p = buffer + strlen (buffer) - 1;
1063                 if (*p == DIR_SEPARATOR_CHAR)
1064                   {
1065                     /* only output path specified */
1066                     dstPath = Safe_strdup (buffer);
1067                     fullDstFileName = NULL;
1068                   }
1069                 else
1070                   {
1071                     fullDstFileName = Safe_strdup (buffer);
1072
1073                     /* get rid of the "."-extension */
1074
1075                     /* is there a dot at all? */
1076                     if (strrchr (buffer, '.') &&
1077                         /* is the dot in the filename, not in the path? */
1078                         (strrchr (buffer, DIR_SEPARATOR_CHAR) < strrchr (buffer, '.')))
1079                       *strrchr (buffer, '.') = '\0';
1080
1081                     dstFileName = Safe_strdup (buffer);
1082
1083                     /* strip module name to get path */
1084                     p = strrchr (buffer, DIR_SEPARATOR_CHAR);
1085                     if (p)
1086                       {
1087                         /* path with trailing / */
1088                         p[1] = '\0';
1089                         dstPath = Safe_strdup (buffer);
1090                       }
1091                   }
1092                 break;
1093               }
1094
1095             case 'W':
1096               /* pre-processer options */
1097               if (argv[i][2] == 'p')
1098                 {
1099                   setParseWithComma(&preArgvSet, getStringArg("-Wp", argv, &i, argc));
1100                 }
1101               /* linker options */
1102               else if (argv[i][2] == 'l')
1103                 {
1104                   setParseWithComma(&linkOptionsSet, getStringArg("-Wl", argv, &i, argc));
1105                 }
1106               /* assembler options */
1107               else if (argv[i][2] == 'a')
1108                 {
1109                   setParseWithComma(&asmOptionsSet, getStringArg("-Wa", argv, &i, argc));
1110                 }
1111               else
1112                 {
1113                   werror (W_UNKNOWN_OPTION, argv[i]);
1114                 }
1115               break;
1116
1117             case 'v':
1118               verifyShortOption(argv[i]);
1119
1120               printVersionInfo ();
1121               exit (0);
1122               break;
1123
1124               /* preprocessor options */
1125             case 'M':
1126               {
1127                 preProcOnly = 1;
1128                 addSet(&preArgvSet, Safe_strdup("-M"));
1129                 break;
1130               }
1131             case 'C':
1132               {
1133                 addSet(&preArgvSet, Safe_strdup("-C"));
1134                 break;
1135               }
1136
1137             case 'd':
1138             case 'D':
1139             case 'I':
1140             case 'A':
1141             case 'U':
1142               {
1143                 char sOpt = argv[i][1];
1144                 char *rest;
1145
1146                 if (argv[i][2] == ' ' || argv[i][2] == '\0')
1147                   {
1148                     i++;
1149                     if (i >= argc)
1150                       {
1151                           /* No argument. */
1152                           werror(E_ARGUMENT_MISSING, argv[i-1]);
1153                           break;
1154                       }
1155                     else
1156                       {
1157                           rest = argv[i];
1158                       }
1159                   }
1160                 else
1161                   rest = &argv[i][2];
1162
1163                 if (sOpt == 'Y')
1164                   sOpt = 'I';
1165
1166                 SNPRINTF (buffer, sizeof(buffer),
1167                   ((sOpt == 'I') ? "-%c\"%s\"": "-%c%s"), sOpt, rest);
1168                 addSet(&preArgvSet, Safe_strdup(buffer));
1169               }
1170               break;
1171
1172             default:
1173               if (!port->parseOption (&argc, argv, &i))
1174                 werror (W_UNKNOWN_OPTION, argv[i]);
1175             }
1176           continue;
1177         }
1178
1179       if (!port->parseOption (&argc, argv, &i))
1180         {
1181            /* no option must be a filename */
1182            if (options.c1mode)
1183              {
1184                 werror (W_NO_FILE_ARG_IN_C1, argv[i]);
1185              }
1186          else
1187              {
1188                 processFile (argv[i]);
1189              }
1190         }
1191     }
1192
1193   /* some sanity checks in c1 mode */
1194   if (options.c1mode)
1195     {
1196       const char *s;
1197
1198       if (fullSrcFileName)
1199         {
1200           fclose (srcFile);
1201           werror (W_NO_FILE_ARG_IN_C1, fullSrcFileName);
1202         }
1203       fullSrcFileName = NULL;
1204       for (s = setFirstItem(relFilesSet); s != NULL; s = setNextItem(relFilesSet))
1205         {
1206           werror (W_NO_FILE_ARG_IN_C1, s);
1207         }
1208       for (s = setFirstItem(libFilesSet); s != NULL; s = setNextItem(libFilesSet))
1209         {
1210           werror (W_NO_FILE_ARG_IN_C1, s);
1211         }
1212       deleteSet(&relFilesSet);
1213       deleteSet(&libFilesSet);
1214
1215         if (options.cc_only || noAssemble || preProcOnly)
1216         {
1217           werror (W_ILLEGAL_OPT_COMBINATION);
1218         }
1219       options.cc_only = noAssemble = preProcOnly = 0;
1220       if (!dstFileName)
1221         {
1222           werror (E_NEED_OPT_O_IN_C1);
1223           exit (1);
1224         }
1225     }
1226   /* if no dstFileName given with -o, we've to find one: */
1227   if (!dstFileName)
1228     {
1229       const char *s;
1230
1231       /* use the modulename from the C-source */
1232       if (fullSrcFileName)
1233         {
1234           size_t bufSize = strlen (dstPath) + strlen (moduleName) + 1;
1235
1236           dstFileName = Safe_alloc (bufSize);
1237           strncpyz (dstFileName, dstPath, bufSize);
1238           strncatz (dstFileName, moduleName, bufSize);
1239         }
1240       /* use the modulename from the first object file */
1241       else if ((s = peekSet(relFilesSet)) != NULL)
1242         {
1243           char *objectName;
1244           size_t bufSize;
1245
1246           strncpyz (buffer, s, sizeof(buffer));
1247           /* remove extension (it must be .rel) */
1248           *strrchr (buffer, '.') = '\0';
1249           /* remove path */
1250           objectName = strrchr (buffer, DIR_SEPARATOR_CHAR);
1251           if (objectName)
1252             {
1253               ++objectName;
1254             }
1255           else
1256             {
1257               objectName = buffer;
1258             }
1259           bufSize = strlen (dstPath) + strlen (objectName) + 1;
1260           dstFileName = Safe_alloc (bufSize);
1261           strncpyz (dstFileName, dstPath, bufSize);
1262           strncatz (dstFileName, objectName, bufSize);
1263         }
1264       /* else no module given: help text is displayed */
1265     }
1266
1267   /* set up external stack location if not explicitly specified */
1268   if (!options.xstack_loc)
1269     options.xstack_loc = options.xdata_loc;
1270
1271   /* if debug option is set then open the cdbFile */
1272   if (options.debug && fullSrcFileName)
1273     {
1274       SNPRINTF (scratchFileName, sizeof(scratchFileName),
1275                 "%s.adb", dstFileName); /*JCF: Nov 30, 2002*/
1276       if(debugFile->openFile(scratchFileName))
1277         debugFile->writeModule(moduleName);
1278       else
1279         werror (E_FILE_OPEN_ERR, scratchFileName);
1280     }
1281   MSVC_style(options.vc_err_style);
1282   if(options.use_stdout) dup2(STDOUT_FILENO, STDERR_FILENO);
1283
1284   return 0;
1285 }
1286
1287 /*-----------------------------------------------------------------*/
1288 /* linkEdit : - calls the linkage editor  with options             */
1289 /*-----------------------------------------------------------------*/
1290 static void
1291 linkEdit (char **envp)
1292 {
1293   FILE *lnkfile;
1294   char *segName, *c;
1295   int system_ret;
1296   const char *s;
1297
1298   /* first we need to create the <filename>.lnk file */
1299   SNPRINTF (scratchFileName, sizeof(scratchFileName),
1300             "%s.lnk", dstFileName);
1301   if (!(lnkfile = fopen (scratchFileName, "w")))
1302     {
1303       werror (E_FILE_OPEN_ERR, scratchFileName);
1304       exit (1);
1305     }
1306
1307    if (TARGET_IS_Z80 || TARGET_IS_GBZ80)
1308    {
1309           fprintf (lnkfile, "--\n-m\n-j\n-x\n-%c %s\n",
1310           (options.out_fmt ? 's' : 'i'), dstFileName);
1311    }
1312    else /*For all the other ports.  Including pics???*/
1313    {
1314           fprintf (lnkfile, "-myux%c\n", (options.out_fmt ? 's' : 'i'));
1315    }
1316
1317    if (!(TARGET_IS_Z80 || TARGET_IS_GBZ80)) /*Not for the z80, gbz80*/
1318    {
1319           /* if iram size specified */
1320           if (options.iram_size)
1321                 fprintf (lnkfile, "-a 0x%04x\n", options.iram_size);
1322
1323           /* if xram size specified */
1324           if (options.xram_size_set)
1325                 fprintf (lnkfile, "-v 0x%04x\n", options.xram_size);
1326
1327           /* if code size specified */
1328           if (options.code_size)
1329                 fprintf (lnkfile, "-w 0x%04x\n", options.code_size);
1330
1331           if (options.debug)
1332                 fprintf (lnkfile, "-z\n");
1333    }
1334
1335 #define WRITE_SEG_LOC(N, L) \
1336     segName = Safe_strdup(N); \
1337     c = strtok(segName, " \t"); \
1338     fprintf (lnkfile,"-b %s = 0x%04x\n", c, L); \
1339     if (segName) { Safe_free(segName); }
1340
1341    if (!(TARGET_IS_Z80 || TARGET_IS_GBZ80)) /*Not for the z80, gbz80*/
1342    {
1343
1344           /* code segment start */
1345           WRITE_SEG_LOC (CODE_NAME, options.code_loc);
1346
1347           /* data segment start. If zero, the linker chooses
1348       the best place for data*/
1349           if(options.data_loc){
1350                   WRITE_SEG_LOC (DATA_NAME, options.data_loc);
1351           }
1352
1353           /* xdata start */
1354           WRITE_SEG_LOC (XDATA_NAME, options.xdata_loc);
1355
1356           /* indirect data */
1357           if (IDATA_NAME) {
1358                 WRITE_SEG_LOC (IDATA_NAME, options.idata_loc);
1359           }
1360
1361           /* bit segment start */
1362           WRITE_SEG_LOC (BIT_NAME, 0);
1363
1364           /* stack start */
1365           if ( (options.stack_loc) && (options.stack_loc<0x100) ) {
1366                 WRITE_SEG_LOC ("SSEG", options.stack_loc);
1367           }
1368    }
1369    else /*For the z80, gbz80*/
1370    {
1371        WRITE_SEG_LOC ("_CODE", options.code_loc);
1372        WRITE_SEG_LOC ("_DATA", options.data_loc);
1373    }
1374
1375   /* If the port has any special linker area declarations, get 'em */
1376   if (port->extraAreas.genExtraAreaLinkOptions)
1377   {
1378         port->extraAreas.genExtraAreaLinkOptions(lnkfile);
1379   }
1380
1381   /* add the extra linker options */
1382   fputStrSet(lnkfile, linkOptionsSet);
1383
1384   /* other library paths if specified */
1385   for (s = setFirstItem(libPathsSet); s != NULL; s = setNextItem(libPathsSet))
1386     fprintf (lnkfile, "-k %s\n", s);
1387
1388   /* standard library path */
1389     if (!options.nostdlib)
1390     {
1391         if (!(TARGET_IS_Z80 || TARGET_IS_GBZ80 || TARGET_IS_HC08)) /*Not for the z80, gbz80*/
1392         {
1393             switch (options.model)
1394             {
1395                 case MODEL_SMALL:
1396                     c = "small";
1397                     break;
1398                 case MODEL_LARGE:
1399                     c = "large";
1400                     break;
1401                 case MODEL_FLAT24:
1402                     /* c = "flat24"; */
1403                     if (TARGET_IS_DS390)
1404                     {
1405                         c = "ds390";
1406                     }
1407                     else if (TARGET_IS_DS400)
1408                     {
1409                         c = "ds400";
1410                     }
1411                     else
1412                     {
1413                         fprintf(stderr,
1414                                 "Add support for your FLAT24 target in %s @ line %d\n",
1415                                 __FILE__, __LINE__);
1416                         exit(-1);
1417                     }
1418                         break;
1419                     case MODEL_PAGE0:
1420                         c = "xa51";
1421                         break;
1422                     default:
1423                         werror (W_UNKNOWN_MODEL, __FILE__, __LINE__);
1424                         c = "unknown";
1425                         break;
1426                 }
1427         }
1428         else /*for the z80, gbz80*/
1429         {
1430             if (TARGET_IS_HC08)
1431                 c = "hc08";
1432             else if (TARGET_IS_Z80)
1433                 c = "z80";
1434             else
1435                 c = "gbz80";
1436         }
1437         for (s = setFirstItem(libDirsSet); s != NULL; s = setNextItem(libDirsSet))
1438             mfprintf (lnkfile, getRuntimeVariables(), "-k %s{sep}%s\n", s, c);
1439
1440
1441       /* standard library files */
1442 #if !OPT_DISABLE_DS390
1443         if (options.model == MODEL_FLAT24)
1444         {
1445             if (TARGET_IS_DS390)
1446             {
1447                 fprintf (lnkfile, "-l %s\n", STD_DS390_LIB);
1448             }
1449             else if (TARGET_IS_DS400)
1450             {
1451                 fprintf (lnkfile, "-l %s\n", STD_DS400_LIB);
1452             }
1453             else
1454             {
1455                 fprintf(stderr,
1456                     "Add support for your FLAT24 target in %s @ line %d\n",
1457                     __FILE__, __LINE__);
1458                 exit(-1);
1459             }
1460         }
1461 #endif
1462
1463 #if !OPT_DISABLE_XA51
1464 #ifdef STD_XA51_LIB
1465         if (options.model == MODEL_PAGE0)
1466         {
1467             fprintf (lnkfile, "-l %s\n", STD_XA51_LIB);
1468         }
1469 #endif
1470 #endif
1471         if (!(TARGET_IS_Z80 || TARGET_IS_GBZ80
1472               || TARGET_IS_HC08)) /*Not for the z80, gbz80*/
1473         { /*Why the z80 port is not using the standard libraries?*/
1474             fprintf (lnkfile, "-l %s\n", STD_LIB);
1475             fprintf (lnkfile, "-l %s\n", STD_INT_LIB);
1476             fprintf (lnkfile, "-l %s\n", STD_LONG_LIB);
1477             fprintf (lnkfile, "-l %s\n", STD_FP_LIB);
1478         }
1479         else if (TARGET_IS_HC08)
1480         {
1481             fprintf (lnkfile, "-l hc08\n");
1482         }
1483         else if (TARGET_IS_Z80)
1484         {
1485             fprintf (lnkfile, "-l z80\n");
1486         }
1487         else if (TARGET_IS_GBZ80)
1488         {
1489             fprintf (lnkfile, "-l gbz80\n");
1490         }
1491     }
1492
1493   /* additional libraries if any */
1494   for (s = setFirstItem(libFilesSet); s != NULL; s = setNextItem(libFilesSet))
1495     fprintf (lnkfile, "-l %s\n", s);
1496
1497   /*For the z80 and gbz80 ports, try to find where crt0.o is...
1498   It is very important for this file to be first on the linking proccess
1499   so the areas are set in the correct order, expecially _GSINIT*/
1500   if ((TARGET_IS_Z80 || TARGET_IS_GBZ80) &&
1501       !options.no_std_crt0 && !options.nostdlib) /*For the z80, gbz80*/
1502   {
1503       char crt0path[PATH_MAX];
1504       FILE * crt0fp;
1505       for (s = setFirstItem(libDirsSet); s != NULL; s = setNextItem(libDirsSet))
1506       {
1507           sprintf (crt0path, "%s%s%s%scrt0.o",
1508              s, DIR_SEPARATOR_STRING, c, DIR_SEPARATOR_STRING);
1509
1510           crt0fp=fopen(crt0path, "r");
1511           if(crt0fp!=NULL)/*Found it!*/
1512           {
1513               fclose(crt0fp);
1514               #ifdef __CYGWIN__
1515               {
1516                  /*The CYGWIN version of the z80-gbz80 linker is getting confused with
1517                  windows paths, so convert them to the CYGWIN format*/
1518                  char posix_path[PATH_MAX];
1519                  void cygwin_conv_to_full_posix_path(char * win_path, char * posix_path);
1520                  cygwin_conv_to_full_posix_path(crt0path, posix_path);
1521                  strcpy(crt0path, posix_path);
1522               }
1523               #endif
1524               fprintf (lnkfile, "%s\n", crt0path);
1525               break;
1526           }
1527       }
1528       if(s==NULL) fprintf (stderr, "Warning: couldn't find crt0.o\n");
1529   }
1530
1531   /* put in the object files */
1532   if (fullSrcFileName)
1533     fprintf (lnkfile, "%s%s\n", dstFileName, port->linker.rel_ext);
1534
1535   fputStrSet(lnkfile, relFilesSet);
1536
1537   fprintf (lnkfile, "\n-e\n");
1538   fclose (lnkfile);
1539
1540   if (options.verbose)
1541     printf ("sdcc: Calling linker...\n");
1542
1543   /* build linker output filename */
1544
1545   /* -o option overrides default name? */
1546   if (fullDstFileName)
1547     {
1548       strncpyz (scratchFileName, fullDstFileName, sizeof(scratchFileName));
1549     }
1550   else
1551     {
1552       /* the linked file gets the name of the first modul */
1553       if (fullSrcFileName)
1554         {
1555           strncpyz (scratchFileName, dstFileName, sizeof(scratchFileName));
1556         }
1557       else
1558         {
1559           s = peekSet(relFilesSet);
1560
1561           assert(s);
1562
1563           strncpyz (scratchFileName, s, sizeof(scratchFileName));
1564           /* strip ".rel" extension */
1565           *strrchr (scratchFileName, '.') = '\0';
1566         }
1567       strncatz (scratchFileName,
1568                 options.out_fmt ? ".S19" : ".ihx",
1569                 sizeof(scratchFileName));
1570     }
1571
1572   if (port->linker.cmd)
1573     {
1574       char buffer2[PATH_MAX];
1575
1576         /* VR 030517 - gplink needs linker options to set the linker script,*/
1577         buildCmdLine (buffer2, port->linker.cmd, dstFileName, scratchFileName, NULL, linkOptionsSet);
1578
1579         buildCmdLine2 (buffer, sizeof(buffer), buffer2);
1580     }
1581   else
1582     {
1583       buildCmdLine2 (buffer, sizeof(buffer), port->linker.mcmd);
1584     }
1585
1586 /*  if (options.verbose)fprintf(stderr, "linker command line: %s\n", buffer); */
1587
1588   system_ret = my_system (buffer);
1589   /* TODO: most linker don't have a -o parameter */
1590   /* -o option overrides default name? */
1591   if (fullDstFileName)
1592     {
1593       char *p, *q;
1594       /* the linked file gets the name of the first modul */
1595       if (fullSrcFileName)
1596         {
1597           strncpyz (scratchFileName, dstFileName, sizeof(scratchFileName));
1598           p = strlen (scratchFileName) + scratchFileName;
1599         }
1600       else
1601         {
1602           s = peekSet(relFilesSet);
1603
1604           assert(s);
1605
1606           strncpyz (scratchFileName, s, sizeof(scratchFileName));
1607           /* strip ".rel" extension */
1608           p = strrchr (scratchFileName, '.');
1609           if (p)
1610             {
1611               *p = 0;
1612             }
1613         }
1614       strncatz (scratchFileName,
1615                 options.out_fmt ? ".S19" : ".ihx",
1616                 sizeof(scratchFileName));
1617       rename (scratchFileName, fullDstFileName);
1618
1619       strncpyz (buffer, fullDstFileName, sizeof(buffer));
1620       q = strrchr (buffer, '.');
1621       if (!q)
1622         {
1623           /* no extension: append new extensions */
1624           q = strlen (buffer) + buffer;
1625         }
1626
1627       *p = 0;
1628       strncatz (scratchFileName, ".map", sizeof(scratchFileName));
1629       *q = 0;
1630       strncatz(buffer, ".map", sizeof(buffer));
1631       rename (scratchFileName, buffer);
1632       *p = 0;
1633       strncatz (scratchFileName, ".mem", sizeof(scratchFileName));
1634       *q = 0;
1635       strncatz(buffer, ".mem", sizeof(buffer));
1636       rename (scratchFileName, buffer);
1637     }
1638   if (system_ret)
1639     {
1640       exit (1);
1641     }
1642 }
1643
1644 /*-----------------------------------------------------------------*/
1645 /* assemble - spawns the assembler with arguments                  */
1646 /*-----------------------------------------------------------------*/
1647 static void
1648 assemble (char **envp)
1649 {
1650     /* build assembler output filename */
1651
1652     /* -o option overrides default name? */
1653     if (options.cc_only && fullDstFileName) {
1654         strncpyz (scratchFileName, fullDstFileName, sizeof(scratchFileName));
1655     } else {
1656         /* the assembled file gets the name of the first modul */
1657         strncpyz (scratchFileName, dstFileName, sizeof(scratchFileName));
1658         strncatz (scratchFileName, port->linker.rel_ext,
1659                   sizeof(scratchFileName));
1660     }
1661
1662     if (port->assembler.do_assemble) {
1663         port->assembler.do_assemble(asmOptionsSet);
1664         return ;
1665     } else if (port->assembler.cmd) {
1666         buildCmdLine (buffer, port->assembler.cmd, dstFileName, scratchFileName,
1667                       options.debug ? port->assembler.debug_opts : port->assembler.plain_opts,
1668                       asmOptionsSet);
1669     } else {
1670         buildCmdLine2 (buffer, sizeof(buffer), port->assembler.mcmd);
1671     }
1672
1673     if (my_system (buffer)) {
1674         /* either system() or the assembler itself has reported an error
1675            perror ("Cannot exec assembler");
1676         */
1677         exit (1);
1678     }
1679     /* TODO: most assembler don't have a -o parameter */
1680     /* -o option overrides default name? */
1681     if (options.cc_only && fullDstFileName) {
1682         strncpyz (scratchFileName, dstFileName, sizeof(scratchFileName));
1683         strncatz (scratchFileName,
1684                   port->linker.rel_ext,
1685                   sizeof(scratchFileName));
1686         rename (scratchFileName, fullDstFileName);
1687     }
1688 }
1689
1690 /*-----------------------------------------------------------------*/
1691 /* preProcess - spawns the preprocessor with arguments       */
1692 /*-----------------------------------------------------------------*/
1693 static int
1694 preProcess (char **envp)
1695 {
1696   if (options.c1mode)
1697     {
1698       yyin = stdin;
1699     }
1700   else
1701     {
1702       const char *s;
1703       set *inclList = NULL;
1704
1705       /* if using external stack define the macro */
1706       if (options.useXstack)
1707         addSet(&preArgvSet, Safe_strdup("-DSDCC_USE_XSTACK"));
1708
1709       /* set the macro for stack autos  */
1710       if (options.stackAuto)
1711         addSet(&preArgvSet, Safe_strdup("-DSDCC_STACK_AUTO"));
1712
1713       /* set the macro for stack autos  */
1714       if (options.stack10bit)
1715         addSet(&preArgvSet, Safe_strdup("-DSDCC_STACK_TENBIT"));
1716
1717       /* set the macro for no overlay  */
1718       if (options.noOverlay)
1719         addSet(&preArgvSet, Safe_strdup("-DSDCC_NOOVERLAY"));
1720
1721       /* set the macro for large model  */
1722       switch (options.model)
1723         {
1724         case MODEL_LARGE:
1725           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_LARGE"));
1726           break;
1727         case MODEL_SMALL:
1728           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_SMALL"));
1729           break;
1730         case MODEL_COMPACT:
1731           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_COMPACT"));
1732           break;
1733         case MODEL_MEDIUM:
1734           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_MEDIUM"));
1735           break;
1736         case MODEL_FLAT24:
1737           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_FLAT24"));
1738           break;
1739         case MODEL_PAGE0:
1740           addSet(&preArgvSet, Safe_strdup("-DSDCC_MODEL_PAGE0"));
1741           break;
1742         default:
1743           werror (W_UNKNOWN_MODEL, __FILE__, __LINE__);
1744           break;
1745         }
1746
1747       /* add port (processor information to processor */
1748       addSet(&preArgvSet, Safe_strdup("-DSDCC_{port}"));
1749       addSet(&preArgvSet, Safe_strdup("-D__{port}"));
1750
1751       /* standard include path */
1752       if (!options.nostdinc) {
1753         inclList = appendStrSet(includeDirsSet, "-I\"", "\"");
1754         mergeSets(&preArgvSet, inclList);
1755       }
1756
1757       setMainValue("cppextraopts", (s = joinStrSet(preArgvSet)));
1758       Safe_free((void *)s);
1759       if (inclList != NULL)
1760         deleteSet(&inclList);
1761
1762       if (preProcOnly && fullDstFileName)
1763         {
1764           /* -E and -o given */
1765           setMainValue ("cppoutfilename", fullDstFileName);
1766         }
1767       else
1768         {
1769           /* Piping: set cppoutfilename to NULL, to avoid empty quotes */
1770           setMainValue ("cppoutfilename", NULL);
1771         }
1772
1773       if (options.verbose)
1774         printf ("sdcc: Calling preprocessor...\n");
1775
1776       buildCmdLine2 (buffer, sizeof(buffer), _preCmd);
1777
1778       if (preProcOnly) {
1779         if (my_system (buffer)) {
1780           exit (1);
1781         }
1782
1783         exit (0);
1784       }
1785
1786       yyin = my_popen (buffer);
1787       if (yyin == NULL) {
1788           perror ("Preproc file not found");
1789           exit (1);
1790       }
1791       addSetHead (&pipeSet, yyin);
1792     }
1793
1794   return 0;
1795 }
1796
1797 /* Set bin paths */
1798 static void
1799 setBinPaths(const char *argv0)
1800 {
1801   char *p;
1802   char buf[PATH_MAX];
1803
1804   /*
1805    * Search logic:
1806    *
1807    * 1. - $SDCCDIR/PREFIX2BIN_DIR
1808    * 2. - path(argv[0])
1809    * 3. - $PATH
1810    */
1811
1812   /* do it in reverse mode, so that addSetHead() can be used
1813      instead of slower addSet() */
1814
1815   if ((p = getBinPath(argv0)) != NULL)
1816     addSetHead(&binPathSet, Safe_strdup(p));
1817
1818   if ((p = getenv(SDCC_DIR_NAME)) != NULL) {
1819     SNPRINTF(buf, sizeof buf, "%s" PREFIX2BIN_DIR, p);
1820     addSetHead(&binPathSet, Safe_strdup(buf));
1821   }
1822
1823   if (options.printSearchDirs) {
1824     printf("programs:\n");
1825     fputStrSet(stdout, binPathSet);
1826   }
1827 }
1828
1829 /* Set system include path */
1830 static void
1831 setIncludePath(void)
1832 {
1833   char *p;
1834
1835   /*
1836    * Search logic:
1837    *
1838    * 1. - $SDCC_INCLUDE
1839    * 2. - $SDCC_HOME/PREFIX2DATA_DIR/INCLUDE_DIR_SUFFIX
1840    * 3. - path(argv[0])/BIN2DATA_DIR/INCLUDE_DIR_SUFFIX
1841    * 4. - DATADIR/INCLUDE_DIR_SUFFIX (only on *nix)
1842    */
1843
1844   includeDirsSet = appendStrSet(dataDirsSet, NULL, INCLUDE_DIR_SUFFIX);
1845
1846   if ((p = getenv(SDCC_INCLUDE_NAME)) != NULL)
1847     addSetHead(&includeDirsSet, p);
1848
1849   if (options.printSearchDirs) {
1850     printf("includedir:\n");
1851     fputStrSet(stdout, includeDirsSet);
1852   }
1853 }
1854
1855 /* Set system lib path */
1856 static void
1857 setLibPath(void)
1858 {
1859   char *p;
1860
1861   /*
1862    * Search logic:
1863    *
1864    * 1. - $SDCC_LIB
1865    * 2. - $SDCC_HOME/PREFIX2DATA_DIR/LIB_DIR_SUFFIX/<model>
1866    * 3. - path(argv[0])/BIN2DATA_DIR/LIB_DIR_SUFFIX/<model>
1867    * 4. - DATADIR/LIB_DIR_SUFFIX/<model> (only on *nix)
1868    */
1869
1870   libDirsSet = appendStrSet(dataDirsSet, NULL, LIB_DIR_SUFFIX);
1871
1872   if ((p = getenv(SDCC_LIB_NAME)) != NULL)
1873     addSetHead(&libDirsSet, p);
1874
1875   if (options.printSearchDirs) {
1876     printf("libdir:\n");
1877     fputStrSet(stdout, libDirsSet);
1878   }
1879 }
1880
1881 /* Set data path */
1882 static void
1883 setDataPaths(const char *argv0)
1884 {
1885   char *p;
1886   char buf[PATH_MAX];
1887
1888   /*
1889    * Search logic:
1890    *
1891    * 1. - $SDCC_HOME/PREFIX2DATA_DIR
1892    * 2. - path(argv[0])/BIN2DATA_DIR
1893    * 3. - DATADIR (only on *nix)
1894    */
1895
1896   if ((p = getenv(SDCC_DIR_NAME)) != NULL) {
1897     SNPRINTF(buf, sizeof buf, "%s" PREFIX2DATA_DIR, p);
1898     addSet(&dataDirsSet, Safe_strdup(buf));
1899   }
1900
1901   if ((p = getBinPath(argv0)) != NULL) {
1902     SNPRINTF(buf, sizeof buf, "%s" BIN2DATA_DIR, p);
1903     addSet(&dataDirsSet, Safe_strdup(buf));
1904   }
1905
1906 #ifdef _WIN32
1907   if (peekSet(dataDirsSet) == NULL) {
1908     /* this should never happen... */
1909     wassertl(0, "Can't get binary path");
1910   }
1911 #else
1912   addSet(&dataDirsSet, Safe_strdup(DATADIR));
1913 #endif
1914
1915   if (options.printSearchDirs) {
1916     printf("datadir:\n");
1917     fputStrSet(stdout, dataDirsSet);
1918   }
1919
1920   setIncludePath();
1921   setLibPath();
1922 }
1923
1924 static void
1925 initValues (void)
1926 {
1927   populateMainValues (_baseValues);
1928   setMainValue ("port", port->target);
1929   setMainValue ("objext", port->linker.rel_ext);
1930   setMainValue ("asmext", port->assembler.file_ext);
1931
1932   setMainValue ("dstfilename", dstFileName);
1933   setMainValue ("fullsrcfilename", fullSrcFileName ? fullSrcFileName : "fullsrcfilename");
1934
1935   if (options.cc_only && fullDstFileName)
1936     /* compile + assemble and -o given: -o specifies name of object file */
1937     {
1938       setMainValue ("objdstfilename", fullDstFileName);
1939     }
1940   else
1941     {
1942       setMainValue ("objdstfilename", "{stdobjdstfilename}");
1943     }
1944   if (fullDstFileName)
1945     /* if we're linking, -o gives the final file name */
1946     {
1947       setMainValue ("linkdstfilename", fullDstFileName);
1948     }
1949   else
1950     {
1951       setMainValue ("linkdstfilename", "{stdlinkdstfilename}");
1952     }
1953
1954 }
1955
1956 static void
1957 sig_handler (int signal)
1958 {
1959   char *sig_string;
1960
1961   switch (signal)
1962     {
1963     case SIGABRT:
1964       sig_string = "SIGABRT";
1965       break;
1966     case SIGTERM:
1967       sig_string = "SIGTERM";
1968       break;
1969     case SIGINT:
1970       sig_string = "SIGINT";
1971       break;
1972     case SIGSEGV:
1973       sig_string = "SIGSEGV";
1974       break;
1975     default:
1976       sig_string = "Unknown?";
1977       break;
1978     }
1979   fprintf (stderr, "Caught signal %d: %s\n", signal, sig_string);
1980   exit (1);
1981 }
1982
1983 /*
1984  * main routine
1985  * initialises and calls the parser
1986  */
1987
1988 int
1989 main (int argc, char **argv, char **envp)
1990 {
1991   /* turn all optimizations off by default */
1992   memset (&optimize, 0, sizeof (struct optimize));
1993
1994   /*printVersionInfo (); */
1995
1996   if (NUM_PORTS==0) {
1997     fprintf (stderr, "Build error: no ports are enabled.\n");
1998     exit (1);
1999   }
2000
2001   /* install atexit handler */
2002   atexit(rm_tmpfiles);
2003
2004   /* install signal handler;
2005      it's only purpuse is to call exit() to remove temp files */
2006   if (!getenv("SDCC_LEAVE_SIGNALS"))
2007     {
2008       signal (SIGABRT, sig_handler);
2009       signal (SIGTERM, sig_handler);
2010       signal (SIGINT , sig_handler);
2011       signal (SIGSEGV, sig_handler);
2012     }
2013
2014   /* Before parsing the command line options, do a
2015    * search for the port and processor and initialize
2016    * them if they're found. (We can't gurantee that these
2017    * will be the first options specified).
2018    */
2019
2020   _findPort (argc, argv);
2021
2022 #ifdef JAMIN_DS390
2023   if (strcmp(port->target, "mcs51") == 0) {
2024     printf("DS390 jammed in A\n");
2025           _setPort ("ds390");
2026     ds390_jammed = 1;
2027   }
2028 #endif
2029
2030   _findProcessor (argc, argv);
2031
2032   /* Initalise the port. */
2033   if (port->init)
2034     port->init ();
2035
2036   setDefaultOptions ();
2037 #ifdef JAMIN_DS390
2038   if (ds390_jammed) {
2039     options.model = MODEL_SMALL;
2040     options.stack10bit=0;
2041   }
2042 #endif
2043   parseCmdLine (argc, argv);
2044
2045   initValues ();
2046   setBinPaths(argv[0]);
2047   setDataPaths(argv[0]);
2048
2049   /* if no input then printUsage & exit */
2050   if (!options.c1mode && !fullSrcFileName && peekSet(relFilesSet) == NULL) {
2051     if (!options.printSearchDirs)
2052       printUsage();
2053
2054     exit(0);
2055   }
2056
2057   /* initMem() is expensive, but
2058      initMem() must called before port->finaliseOptions ().
2059      And the z80 port needs port->finaliseOptions(),
2060      even if we're only linking. */
2061   initMem ();
2062   port->finaliseOptions ();
2063
2064   if (fullSrcFileName || options.c1mode)
2065     {
2066       preProcess (envp);
2067
2068       initSymt ();
2069       initiCode ();
2070       initCSupport ();
2071       initBuiltIns();
2072       initPeepHole ();
2073
2074       if (options.verbose)
2075         printf ("sdcc: Generating code...\n");
2076
2077       yyparse ();
2078
2079       pclose(yyin);
2080       deleteSetItem(&pipeSet, yyin);
2081
2082       if (fatalError) {
2083         exit (1);
2084       }
2085
2086       if (port->general.do_glue != NULL)
2087         (*port->general.do_glue)();
2088       else
2089         {
2090           /* this shouldn't happen */
2091           assert(FALSE);
2092           /* in case of NDEBUG */
2093           glue();
2094         }
2095
2096       if (!options.c1mode && !noAssemble)
2097         {
2098           if (options.verbose)
2099             printf ("sdcc: Calling assembler...\n");
2100           assemble (envp);
2101         }
2102     }
2103   closeDumpFiles();
2104
2105   if (options.debug && debugFile)
2106     debugFile->closeFile();
2107
2108   if (!options.cc_only &&
2109       !fatalError &&
2110       !noAssemble &&
2111       !options.c1mode &&
2112       (fullSrcFileName || peekSet(relFilesSet) != NULL))
2113     {
2114       if (port->linker.do_link)
2115         port->linker.do_link ();
2116       else
2117         linkEdit (envp);
2118     }
2119
2120   return 0;
2121 }