nasm.c

   1 /* The Netwide Assembler main program module
   2  *
   3  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   4  * Julian Hall. All rights reserved. The software is
   5  * redistributable under the licence given in the file "Licence"
   6  * distributed in the NASM archive.
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdarg.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <ctype.h>
  14
  15 #include "nasm.h"
  16 #include "nasmlib.h"
  17 #include "preproc.h"
  18 #include "parser.h"
  19 #include "assemble.h"
  20 #include "labels.h"
  21 #include "outform.h"
  22 #include "listing.h"
  23
  24 static void report_error (int, char *, ...);
  25 static void parse_cmdline (int, char **);
  26 static void assemble_file (char *);
  27 static int getkw (char *buf, char **value);
  28 static void register_output_formats(void);
  29 static void usage(void);
  30
  31 static char *obuf;
  32 static char inname[FILENAME_MAX];
  33 static char outname[FILENAME_MAX];
  34 static char listname[FILENAME_MAX];
  35 static char realout[FILENAME_MAX];
  36 static int lineno;                     /* for error reporting */
  37 static int lineinc;                    /* set by [LINE] or [ONELINE] */
  38 static int globallineno;               /* for forward-reference tracking */
  39 static int pass;
  40 static struct ofmt *ofmt = NULL;
  41
  42 static FILE *ofile = NULL;
  43 static int sb = 16;                    /* by default */
  44
  45 static int use_stdout = FALSE;         /* by default, errors to stderr */
  46
  47 static long current_seg;
  48 static struct RAA *offsets;
  49 static long abs_offset;
  50
  51 static struct SAA *forwrefs;           /* keep track of forward references */
  52 static int forwline;
  53
  54 static Preproc *preproc;
  55 static int preprocess_only;
  56
  57 /* used by error function to report location */
  58 static char currentfile[FILENAME_MAX];
  59
  60 /*
  61  * Which of the suppressible warnings are suppressed. Entry zero
  62  * doesn't do anything. Initial defaults are given here.
  63  */
  64 static char suppressed[1+ERR_WARN_MAX] = {
  65     0, FALSE, TRUE
  66 };
  67
  68 /*
  69  * The option names for the suppressible warnings. As before, entry
  70  * zero does nothing.
  71  */
  72 static char *suppressed_names[1+ERR_WARN_MAX] = {
  73     NULL, "macro-params", "orphan-labels"
  74 };
  75
  76 /*
  77  * The explanations for the suppressible warnings. As before, entry
  78  * zero does nothing.
  79  */
  80 static char *suppressed_what[1+ERR_WARN_MAX] = {
  81     NULL, "macro calls with wrong no. of params",
  82     "labels alone on lines without trailing `:'"
  83 };
  84
  85 /*
  86  * This is a null preprocessor which just copies lines from input
  87  * to output. It's used when someone explicitly requests that NASM
  88  * not preprocess their source file.
  89  */
  90
  91 static void no_pp_reset (char *, efunc, ListGen *);
  92 static char *no_pp_getline (void);
  93 static void no_pp_cleanup (void);
  94 static Preproc no_pp = {
  95     no_pp_reset,
  96     no_pp_getline,
  97     no_pp_cleanup
  98 };
  99
 100 /*
 101  * get/set current offset...
 102  */
 103 #define get_curr_ofs (current_seg==NO_SEG?abs_offset:\
 104                       raa_read(offsets,current_seg))
 105 #define set_curr_ofs(x) (current_seg==NO_SEG?(void)(abs_offset=(x)):\
 106                          (void)(offsets=raa_write(offsets,current_seg,(x))))
 107
 108 static int want_usage;
 109 static int terminate_after_phase;
 110
 111 int main(int argc, char **argv) {
 112     want_usage = terminate_after_phase = FALSE;
 113
 114     nasm_set_malloc_error (report_error);
 115     offsets = raa_init();
 116     forwrefs = saa_init ((long)sizeof(int));
 117
 118     preproc = &nasmpp;
 119     preprocess_only = FALSE;
 120
 121     seg_init();
 122
 123     register_output_formats();
 124
 125     parse_cmdline(argc, argv);
 126
 127     if (terminate_after_phase) {
 128         if (want_usage)
 129             usage();
 130         return 1;
 131     }
 132
 133     if (preprocess_only) {
 134         char *line;
 135
 136         if (*outname) {
 137             ofile = fopen(outname, "w");
 138             if (!ofile)
 139                 report_error (ERR_FATAL | ERR_NOFILE,
 140                               "unable to open output file `%s'", outname);
 141         } else
 142             ofile = NULL;
 143         preproc->reset (inname, report_error, &nasmlist);
 144         strcpy(currentfile,inname);
 145         lineno = 0;
 146         lineinc = 1;
 147         while ( (line = preproc->getline()) ) {
 148             lineno += lineinc;
 149             if (ofile) {
 150                 fputs(line, ofile);
 151                 fputc('\n', ofile);
 152             } else
 153                 puts(line);
 154             nasm_free (line);
 155         }
 156         preproc->cleanup();
 157         if (ofile)
 158             fclose(ofile);
 159         if (ofile && terminate_after_phase)
 160             remove(outname);
 161     } else {
 162         /*
 163          * We must call ofmt->filename _anyway_, even if the user
 164          * has specified their own output file, because some
 165          * formats (eg OBJ and COFF) use ofmt->filename to find out
 166          * the name of the input file and then put that inside the
 167          * file.
 168          */
 169         ofmt->filename (inname, realout, report_error);
 170         if (!*outname) {
 171             strcpy(outname, realout);
 172         }
 173
 174         ofile = fopen(outname, "wb");
 175         if (!ofile) {
 176             report_error (ERR_FATAL | ERR_NOFILE,
 177                           "unable to open output file `%s'", outname);
 178         }
 179         /*
 180          * We must call init_labels() before ofmt->init() since
 181          * some object formats will want to define labels in their
 182          * init routines. (eg OS/2 defines the FLAT group)
 183          */
 184         init_labels ();
 185         ofmt->init (ofile, report_error, define_label);
 186         assemble_file (inname);
 187         if (!terminate_after_phase) {
 188             ofmt->cleanup ();
 189             cleanup_labels ();
 190         }
 191         /*
 192          * We had an fclose on the output file here, but we
 193          * actually do that in all the object file drivers as well,
 194          * so we're leaving out the one here.
 195          *     fclose (ofile);
 196          */
 197         if (terminate_after_phase) {
 198             remove(outname);
 199             if (listname[0])
 200                 remove(listname);
 201         }
 202     }
 203
 204     if (want_usage)
 205         usage();
 206     raa_free (offsets);
 207     saa_free (forwrefs);
 208
 209     if (terminate_after_phase)
 210         return 1;
 211     else
 212         return 0;
 213 }
 214
 215 static int process_arg (char *p, char *q) {
 216     char *param;
 217     int i;
 218     int advance = 0;
 219
 220     if (!p || !p[0])
 221         return 0;
 222
 223     if (p[0]=='-') {
 224         switch (p[1]) {
 225           case 's':
 226             use_stdout = TRUE;
 227             break;
 228           case 'o':                    /* these parameters take values */
 229           case 'f':
 230           case 'p':
 231           case 'd':
 232           case 'i':
 233           case 'l':
 234             if (p[2])                  /* the parameter's in the option */
 235                 param = p+2;
 236             else if (!q) {
 237                 report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
 238                               "option `-%c' requires an argument",
 239                               p[1]);
 240                 break;
 241             } else
 242                 advance = 1, param = q;
 243             if (p[1]=='o') {           /* output file */
 244                 strcpy (outname, param);
 245             } else if (p[1]=='f') {    /* output format */
 246                 ofmt = ofmt_find(param);
 247                 if (!ofmt) {
 248                     report_error (ERR_FATAL | ERR_NOFILE | ERR_USAGE,
 249                                   "unrecognised output format `%s'",
 250                                   param);
 251                 }
 252             } else if (p[1]=='p') {    /* pre-include */
 253                 pp_pre_include (param);
 254             } else if (p[1]=='d') {    /* pre-define */
 255                 pp_pre_define (param);
 256             } else if (p[1]=='i') {    /* include search path */
 257                 pp_include_path (param);
 258             } else if (p[1]=='l') {    /* listing file */
 259                 strcpy (listname, param);
 260             }
 261             break;
 262           case 'h':
 263             fprintf(use_stdout ? stdout : stderr,
 264                     "usage: nasm [-o outfile] [-f format] [-l listfile]"
 265                     " [options...] filename\n");
 266             fprintf(use_stdout ? stdout : stderr,
 267                     "    or nasm -r   for version info\n\n");
 268             fprintf(use_stdout ? stdout : stderr,
 269                     "    -e means preprocess only; "
 270                     "-a means don't preprocess\n");
 271             fprintf(use_stdout ? stdout : stderr,
 272                     "    -s means send errors to stdout not stderr\n");
 273             fprintf(use_stdout ? stdout : stderr,
 274                     "    -i<path> adds a pathname to the include file"
 275                     " path\n    -p<file> pre-includes a file;"
 276                     " -d<macro>[=<value] pre-defines a macro\n");
 277             fprintf(use_stdout ? stdout : stderr,
 278                     "    -w+foo enables warnings about foo; "
 279                     "-w-foo disables them\n  where foo can be:\n");
 280             for (i=1; i<=ERR_WARN_MAX; i++)
 281                 fprintf(use_stdout ? stdout : stderr,
 282                         "    %-16s%s (default %s)\n",
 283                         suppressed_names[i], suppressed_what[i],
 284                         suppressed[i] ? "off" : "on");
 285             fprintf(use_stdout ? stdout : stderr,
 286                     "\nvalid output formats for -f are"
 287                     " (`*' denotes default):\n");
 288             ofmt_list(ofmt, use_stdout ? stdout : stderr);
 289             exit (0);                  /* never need usage message here */
 290             break;
 291           case 'r':
 292             fprintf(use_stdout ? stdout : stderr,
 293                     "NASM version %s\n", NASM_VER);
 294             exit (0);                  /* never need usage message here */
 295             break;
 296           case 'e':                    /* preprocess only */
 297             preprocess_only = TRUE;
 298             break;
 299           case 'a':                    /* assemble only - don't preprocess */
 300             preproc = &no_pp;
 301             break;
 302           case 'w':
 303             if (p[2] != '+' && p[2] != '-') {
 304                 report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
 305                               "invalid option to `-w'");
 306             } else {
 307                 for (i=1; i<=ERR_WARN_MAX; i++)
 308                     if (!nasm_stricmp(p+3, suppressed_names[i]))
 309                         break;
 310                 if (i <= ERR_WARN_MAX)
 311                     suppressed[i] = (p[2] == '-');
 312                 else
 313                     report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
 314                                   "invalid option to `-w'");
 315             }
 316             break;
 317           default:
 318             report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
 319                           "unrecognised option `-%c'",
 320                           p[1]);
 321             break;
 322         }
 323     } else {
 324         if (*inname) {
 325             report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
 326                           "more than one input file specified");
 327         } else
 328             strcpy(inname, p);
 329     }
 330
 331     return advance;
 332 }
 333
 334 static void parse_cmdline(int argc, char **argv) {
 335     char *envreal, *envcopy, *p, *q, *arg, *prevarg;
 336     char separator = ' ';
 337
 338     *inname = *outname = *listname = '\0';
 339
 340     /*
 341      * First, process the NASM environment variable.
 342      */
 343     envreal = getenv("NASM");
 344     arg = NULL;
 345     if (envreal) {
 346         envcopy = nasm_strdup(envreal);
 347         p = envcopy;
 348         if (*p && *p != '-')
 349             separator = *p++;
 350         while (*p) {
 351             q = p;
 352             while (*p && *p != separator) p++;
 353             while (*p == separator) *p++ = '\0';
 354             prevarg = arg;
 355             arg = q;
 356             if (process_arg (prevarg, arg))
 357                 arg = NULL;
 358         }
 359         nasm_free (envcopy);
 360     }
 361     if (arg)
 362         process_arg (arg, NULL);
 363
 364     /*
 365      * Now process the actual command line.
 366      */
 367     while (--argc) {
 368         int i;
 369         argv++;
 370         i = process_arg (argv[0], argc > 1 ? argv[1] : NULL);
 371         argv += i, argc -= i;
 372     }
 373
 374     if (!*inname)
 375         report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
 376                       "no input file specified");
 377 }
 378
 379 static void assemble_file (char *fname) {
 380     char *value, *p, *line;
 381     insn output_ins;
 382     int i, rn_error;
 383     long seg;
 384
 385     /* pass one */
 386     pass = 1;
 387     current_seg = ofmt->section(NULL, pass, &sb);
 388     preproc->reset(fname, report_error, &nasmlist);
 389     strcpy(currentfile,fname);
 390     lineno = 0;
 391     lineinc = 1;
 392     globallineno = 0;
 393     while ( (line = preproc->getline()) ) {
 394         lineno += lineinc;
 395         globallineno++;
 396
 397         if (line[0] == '%') {
 398             int ln, li;
 399             char buf[FILENAME_MAX];
 400
 401             /*
 402              * This will be a line number directive. They come
 403              * straight from the preprocessor, so we'll subject
 404              * them to only minimal error checking.
 405              */
 406             if (strncmp(line, "%line", 5)) {
 407                 if (preproc == &no_pp)
 408                     report_error (ERR_WARNING, "unknown `%%' directive in "
 409                                   " preprocessed source");
 410             } else if (sscanf(line, "%%line %d+%d %s", &ln, &li, buf) != 3) {
 411                 report_error (ERR_WARNING, "bogus line number directive in"
 412                               " preprocessed source");
 413             } else {
 414                 lineno = ln - li;
 415                 lineinc = li;
 416                 strncpy (currentfile, buf, FILENAME_MAX-1);
 417                 currentfile[FILENAME_MAX-1] = '\0';
 418             }
 419             continue;
 420         }
 421
 422         /* here we parse our directives; this is not handled by the 'real'
 423          * parser. */
 424         if ( (i = getkw (line, &value)) ) {
 425             switch (i) {
 426               case 1:          /* [SEGMENT n] */
 427                 seg = ofmt->section (value, pass, &sb);
 428                 if (seg == NO_SEG) {
 429                     report_error (ERR_NONFATAL,
 430                                   "segment name `%s' not recognised",
 431                                   value);
 432                 } else {
 433                     current_seg = seg;
 434                 }
 435                 break;
 436               case 2:          /* [EXTERN label] */
 437                 if (*value == '$')
 438                     value++;           /* skip initial $ if present */
 439                 declare_as_global (value, report_error);
 440                 define_label (value, seg_alloc(), 0L, ofmt, report_error);
 441                 break;
 442               case 3:          /* [BITS bits] */
 443                 switch (atoi(value)) {
 444                   case 16:
 445                   case 32:
 446                     sb = atoi(value);
 447                     break;
 448                   default:
 449                     report_error(ERR_NONFATAL,
 450                                  "`%s' is not a valid argument to [BITS]",
 451                                  value);
 452                     break;
 453                 }
 454                 break;
 455               case 4:          /* [GLOBAL symbol] */
 456                 if (*value == '$')
 457                     value++;           /* skip initial $ if present */
 458                 declare_as_global (value, report_error);
 459                 break;
 460               case 5:          /* [COMMON symbol size] */
 461                 p = value;
 462                 while (*p && !isspace(*p))
 463                     p++;
 464                 if (*p) {
 465                     long size;
 466
 467                     while (*p && isspace(*p))
 468                         *p++ = '\0';
 469                     size = readnum (p, &rn_error);
 470                     if (rn_error)
 471                         report_error (ERR_NONFATAL, "invalid size specified"
 472                                       " in COMMON declaration");
 473                     else
 474                         define_common (value, seg_alloc(), size,
 475                                        ofmt, report_error);
 476                 } else
 477                     report_error (ERR_NONFATAL, "no size specified in"
 478                                   " COMMON declaration");
 479                 break;
 480               case 6:                  /* [ABSOLUTE address] */
 481                 current_seg = NO_SEG;
 482                 abs_offset = readnum(value, &rn_error);
 483                 if (rn_error) {
 484                     report_error (ERR_NONFATAL, "invalid address specified"
 485                                   " for ABSOLUTE directive");
 486                     abs_offset = 0x100;/* don't go near zero in case of / */
 487                 }
 488                 break;
 489               default:
 490                 if (!ofmt->directive (line+1, value, 1))
 491                     report_error (ERR_NONFATAL, "unrecognised directive [%s]",
 492                                   line+1);
 493                 break;
 494             }
 495         } else {
 496             long offs = get_curr_ofs;
 497             parse_line (current_seg, offs, lookup_label,
 498                         1, line, &output_ins, ofmt, report_error);
 499             if (output_ins.forw_ref)
 500                 *(int *)saa_wstruct(forwrefs) = globallineno;
 501
 502             /*
 503              * Hack to prevent phase error in the code
 504              *   rol ax,x
 505              *   x equ 1
 506              *
 507              * We rule that the presence of a forward reference
 508              * cancels out the UNITY property of the number 1. This
 509              * isn't _strictly_ necessary in pass one, since the
 510              * problem occurs in pass two, but for the sake of
 511              * having the passes as near to identical as we can
 512              * manage, we do it like this.
 513              */
 514             if (output_ins.forw_ref) {
 515                 int i;
 516                 for (i=0; i<output_ins.operands; i++)
 517                     output_ins.oprs[i].type &= ~ONENESS;
 518             }
 519
 520             if (output_ins.opcode == I_EQU) {
 521                 /*
 522                  * Special `..' EQUs get processed in pass two,
 523                  * except `..@' macro-processor EQUs which are done
 524                  * in the normal place.
 525                  */
 526                 if (!output_ins.label)
 527                     report_error (ERR_NONFATAL,
 528                                   "EQU not preceded by label");
 529                 else if (output_ins.label[0] != '.' ||
 530                          output_ins.label[1] != '.' ||
 531                          output_ins.label[2] == '@') {
 532                     if (output_ins.operands == 1 &&
 533                         (output_ins.oprs[0].type & IMMEDIATE) &&
 534                         output_ins.oprs[0].wrt == NO_SEG) {
 535                         define_label (output_ins.label,
 536                                       output_ins.oprs[0].segment,
 537                                       output_ins.oprs[0].offset,
 538                                       ofmt, report_error);
 539                     } else if (output_ins.operands == 2 &&
 540                                (output_ins.oprs[0].type & IMMEDIATE) &&
 541                                (output_ins.oprs[0].type & COLON) &&
 542                                output_ins.oprs[0].segment == NO_SEG &&
 543                                output_ins.oprs[0].wrt == NO_SEG &&
 544                                (output_ins.oprs[1].type & IMMEDIATE) &&
 545                                output_ins.oprs[1].segment == NO_SEG &&
 546                                output_ins.oprs[1].wrt == NO_SEG) {
 547                         define_label (output_ins.label,
 548                                       output_ins.oprs[0].offset | SEG_ABS,
 549                                       output_ins.oprs[1].offset,
 550                                       ofmt, report_error);
 551                     } else
 552                         report_error(ERR_NONFATAL, "bad syntax for EQU");
 553                 }
 554             } else {
 555                 if (output_ins.label)
 556                     define_label (output_ins.label,
 557                                   current_seg, offs,
 558                                   ofmt, report_error);
 559                 offs += insn_size (current_seg, offs, sb,
 560                                    &output_ins, report_error);
 561                 set_curr_ofs (offs);
 562             }
 563             cleanup_insn (&output_ins);
 564         }
 565         nasm_free (line);
 566     }
 567     preproc->cleanup();
 568
 569     if (terminate_after_phase) {
 570         fclose(ofile);
 571         remove(outname);
 572         if (want_usage)
 573             usage();
 574         exit (1);
 575     }
 576
 577     /* pass two */
 578     pass = 2;
 579     saa_rewind (forwrefs);
 580     if (*listname)
 581         nasmlist.init(listname, report_error);
 582     {
 583         int *p = saa_rstruct (forwrefs);
 584         if (p)
 585             forwline = *p;
 586         else
 587             forwline = -1;
 588     }
 589     current_seg = ofmt->section(NULL, pass, &sb);
 590     raa_free (offsets);
 591     offsets = raa_init();
 592     preproc->reset(fname, report_error, &nasmlist);
 593     strcpy(currentfile,fname);
 594     lineno = 0;
 595     lineinc = 1;
 596     globallineno = 0;
 597     while ( (line = preproc->getline()) ) {
 598         lineno += lineinc;
 599         globallineno++;
 600
 601         if (line[0] == '%') {
 602             int ln, li;
 603             char buf[FILENAME_MAX];
 604
 605             /*
 606              * This will be a line number directive. They come
 607              * straight from the preprocessor, so we'll subject
 608              * them to only minimal error checking.
 609              */
 610             if (!strncmp(line, "%line", 5) &&
 611                 sscanf(line, "%%line %d+%d %s", &ln, &li, buf) == 3) {
 612                 lineno = ln - li;
 613                 lineinc = li;
 614                 strncpy (currentfile, buf, FILENAME_MAX-1);
 615                 currentfile[FILENAME_MAX-1] = '\0';
 616             }
 617             continue;
 618         }
 619
 620         /* here we parse our directives; this is not handled by
 621          * the 'real' parser. */
 622
 623         if ( (i = getkw (line, &value)) ) {
 624             switch (i) {
 625               case 1:          /* [SEGMENT n] */
 626                 seg = ofmt->section (value, pass, &sb);
 627                 if (seg == NO_SEG) {
 628                     report_error (ERR_PANIC,
 629                                   "invalid segment name on pass two");
 630                 } else
 631                     current_seg = seg;
 632                 break;
 633               case 2:          /* [EXTERN label] */
 634                 break;
 635               case 3:          /* [BITS bits] */
 636                 switch (atoi(value)) {
 637                   case 16:
 638                   case 32:
 639                     sb = atoi(value);
 640                     break;
 641                   default:
 642                     report_error(ERR_PANIC,
 643                                  "invalid [BITS] value on pass two",
 644                                  value);
 645                     break;
 646                 }
 647                 break;
 648               case 4:                  /* [GLOBAL symbol] */
 649                 break;
 650               case 5:                  /* [COMMON symbol size] */
 651                 break;
 652               case 6:                  /* [ABSOLUTE addr] */
 653                 current_seg = NO_SEG;
 654                 abs_offset = readnum(value, &rn_error);
 655                 if (rn_error)
 656                     report_error (ERR_PANIC, "invalid ABSOLUTE address "
 657                                   "in pass two");
 658                 break;
 659               default:
 660                 if (!ofmt->directive (line+1, value, 2))
 661                     report_error (ERR_PANIC, "invalid directive on pass two");
 662                 break;
 663             }
 664         } else {
 665             long offs = get_curr_ofs;
 666             parse_line (current_seg, offs, lookup_label, 2,
 667                         line, &output_ins, ofmt, report_error);
 668             if (globallineno == forwline) {
 669                 int *p = saa_rstruct (forwrefs);
 670                 if (p)
 671                     forwline = *p;
 672                 else
 673                     forwline = -1;
 674                 output_ins.forw_ref = TRUE;
 675             } else
 676                 output_ins.forw_ref = FALSE;
 677
 678             /*
 679              * Hack to prevent phase error in the code
 680              *   rol ax,x
 681              *   x equ 1
 682              */
 683             if (output_ins.forw_ref) {
 684                 int i;
 685                 for (i=0; i<output_ins.operands; i++)
 686                     output_ins.oprs[i].type &= ~ONENESS;
 687             }
 688
 689             obuf = line;
 690             if (output_ins.label)
 691                 define_label_stub (output_ins.label, report_error);
 692             if (output_ins.opcode == I_EQU) {
 693                 /*
 694                  * Special `..' EQUs get processed here, except
 695                  * `..@' macro processor EQUs which are done above.
 696                  */
 697                 if (output_ins.label[0] == '.' &&
 698                     output_ins.label[1] == '.' &&
 699                     output_ins.label[2] != '@') {
 700                     if (output_ins.operands == 1 &&
 701                         (output_ins.oprs[0].type & IMMEDIATE)) {
 702                         define_label (output_ins.label,
 703                                       output_ins.oprs[0].segment,
 704                                       output_ins.oprs[0].offset,
 705                                       ofmt, report_error);
 706                     } else if (output_ins.operands == 2 &&
 707                                (output_ins.oprs[0].type & IMMEDIATE) &&
 708                                (output_ins.oprs[0].type & COLON) &&
 709                                output_ins.oprs[0].segment == NO_SEG &&
 710                                (output_ins.oprs[1].type & IMMEDIATE) &&
 711                                output_ins.oprs[1].segment == NO_SEG) {
 712                         define_label (output_ins.label,
 713                                       output_ins.oprs[0].offset | SEG_ABS,
 714                                       output_ins.oprs[1].offset,
 715                                       ofmt, report_error);
 716                     } else
 717                         report_error(ERR_NONFATAL, "bad syntax for EQU");
 718                 }
 719             }
 720             offs += assemble (current_seg, offs, sb,
 721                               &output_ins, ofmt, report_error, &nasmlist);
 722             cleanup_insn (&output_ins);
 723             set_curr_ofs (offs);
 724         }
 725         nasm_free (line);
 726     }
 727     preproc->cleanup();
 728     nasmlist.cleanup();
 729 }
 730
 731 static int getkw (char *buf, char **value) {
 732     char *p, *q;
 733
 734     if (*buf!='[')
 735         return 0;
 736     p = buf;
 737     while (*p && *p != ']') p++;
 738     if (!*p)
 739         return 0;
 740     q = p++;
 741     while (*p && *p != ';') {
 742         if (!isspace(*p))
 743             return 0;
 744         p++;
 745     }
 746     q[1] = '\0';
 747
 748     p = buf+1;
 749     while (*buf && *buf!=' ' && *buf!=']' && *buf!='\t')
 750         buf++;
 751     if (*buf==']') {
 752         *buf = '\0';
 753         *value = buf;
 754     } else {
 755         *buf++ = '\0';
 756         while (isspace(*buf)) buf++;   /* beppu - skip leading whitespace */
 757         *value = buf;
 758         while (*buf!=']') buf++;
 759         *buf++ = '\0';
 760     }
 761     for (q=p; *q; q++)
 762         *q = tolower(*q);
 763     if (!strcmp(p, "segment") || !strcmp(p, "section"))
 764         return 1;
 765     if (!strcmp(p, "extern"))
 766         return 2;
 767     if (!strcmp(p, "bits"))
 768         return 3;
 769     if (!strcmp(p, "global"))
 770         return 4;
 771     if (!strcmp(p, "common"))
 772         return 5;
 773     if (!strcmp(p, "absolute"))
 774         return 6;
 775     return -1;
 776 }
 777
 778 static void report_error (int severity, char *fmt, ...) {
 779     va_list ap;
 780
 781     /*
 782      * See if it's a suppressed warning.
 783      */
 784     if ((severity & ERR_MASK) == ERR_WARNING &&
 785         (severity & ERR_WARN_MASK) != 0 &&
 786         suppressed[ (severity & ERR_WARN_MASK) >> ERR_WARN_SHR ])
 787         return;                        /* and bail out if so */
 788
 789     if (severity & ERR_NOFILE)
 790         fputs ("nasm: ", use_stdout ? stdout : stderr);
 791     else
 792         fprintf (use_stdout ? stdout : stderr, "%s:%d: ", currentfile,
 793                  lineno + (severity & ERR_OFFBY1 ? lineinc : 0));
 794
 795     if ( (severity & ERR_MASK) == ERR_WARNING)
 796         fputs ("warning: ", use_stdout ? stdout : stderr);
 797     else if ( (severity & ERR_MASK) == ERR_PANIC)
 798         fputs ("panic: ", use_stdout ? stdout : stderr);
 799
 800     va_start (ap, fmt);
 801     vfprintf (use_stdout ? stdout : stderr, fmt, ap);
 802     fputc ('\n', use_stdout ? stdout : stderr);
 803
 804     if (severity & ERR_USAGE)
 805         want_usage = TRUE;
 806
 807     switch (severity & ERR_MASK) {
 808       case ERR_WARNING:
 809         /* no further action, by definition */
 810         break;
 811       case ERR_NONFATAL:
 812         terminate_after_phase = TRUE;
 813         break;
 814       case ERR_FATAL:
 815         if (ofile) {
 816             fclose(ofile);
 817             remove(outname);
 818         }
 819         if (want_usage)
 820             usage();
 821         exit(1);                       /* instantly die */
 822         break;                         /* placate silly compilers */
 823       case ERR_PANIC:
 824         abort();                       /* halt, catch fire, and dump core */
 825         break;
 826     }
 827 }
 828
 829 static void usage(void) {
 830     fputs("type `nasm -h' for help\n", use_stdout ? stdout : stderr);
 831 }
 832
 833 static void register_output_formats(void) {
 834     /* Flat-form binary format */
 835 #ifdef OF_BIN
 836     extern struct ofmt of_bin;
 837 #endif
 838     /* Unix formats: a.out, COFF, ELF */
 839 #ifdef OF_AOUT
 840     extern struct ofmt of_aout;
 841 #endif
 842 #ifdef OF_COFF
 843     extern struct ofmt of_coff;
 844 #endif
 845 #ifdef OF_ELF
 846     extern struct ofmt of_elf;
 847 #endif
 848     /* Linux strange format: as86 */
 849 #ifdef OF_AS86
 850     extern struct ofmt of_as86;
 851 #endif
 852     /* DOS and DOS-ish formats: OBJ, OS/2, Win32 */
 853 #ifdef OF_OBJ
 854     extern struct ofmt of_obj;
 855 #endif
 856 #ifdef OF_WIN32
 857     extern struct ofmt of_win32;
 858 #endif
 859 #ifdef OF_OS2
 860     extern struct ofmt of_os2;
 861 #endif
 862 #ifdef OF_RDF
 863     extern struct ofmt of_rdf;
 864 #endif
 865 #ifdef OF_DBG     /* debug format must be included specifically */
 866     extern struct ofmt of_dbg;
 867 #endif
 868
 869 #ifdef OF_BIN
 870     ofmt_register (&of_bin);
 871 #endif
 872 #ifdef OF_AOUT
 873     ofmt_register (&of_aout);
 874 #endif
 875 #ifdef OF_COFF
 876     ofmt_register (&of_coff);
 877 #endif
 878 #ifdef OF_ELF
 879     ofmt_register (&of_elf);
 880 #endif
 881 #ifdef OF_AS86
 882     ofmt_register (&of_as86);
 883 #endif
 884 #ifdef OF_OBJ
 885     ofmt_register (&of_obj);
 886 #endif
 887 #ifdef OF_WIN32
 888     ofmt_register (&of_win32);
 889 #endif
 890 #ifdef OF_OS2
 891     ofmt_register (&of_os2);
 892 #endif
 893 #ifdef OF_RDF
 894     ofmt_register (&of_rdf);
 895 #endif
 896 #ifdef OF_DBG
 897     ofmt_register (&of_dbg);
 898 #endif
 899     /*
 900      * set the default format
 901      */
 902     ofmt = &OF_DEFAULT;
 903 }
 904
 905 #define BUF_DELTA 512
 906
 907 static FILE *no_pp_fp;
 908 static efunc no_pp_err;
 909
 910 static void no_pp_reset (char *file, efunc error, ListGen *listgen) {
 911     no_pp_err = error;
 912     no_pp_fp = fopen(file, "r");
 913     if (!no_pp_fp)
 914         no_pp_err (ERR_FATAL | ERR_NOFILE,
 915                    "unable to open input file `%s'", file);
 916     (void) listgen;                    /* placate compilers */
 917 }
 918
 919 static char *no_pp_getline (void) {
 920     char *buffer, *p, *q;
 921     int bufsize;
 922
 923     bufsize = BUF_DELTA;
 924     buffer = nasm_malloc(BUF_DELTA);
 925     p = buffer;
 926     while (1) {
 927         q = fgets(p, bufsize-(p-buffer), no_pp_fp);
 928         if (!q)
 929             break;
 930         p += strlen(p);
 931         if (p > buffer && p[-1] == '\n')
 932             break;
 933         if (p-buffer > bufsize-10) {
 934             bufsize += BUF_DELTA;
 935             buffer = nasm_realloc(buffer, bufsize);
 936         }
 937     }
 938
 939     if (!q && p == buffer) {
 940         nasm_free (buffer);
 941         return NULL;
 942     }
 943
 944     /*
 945      * Play safe: remove CRs as well as LFs, if any of either are
 946      * present at the end of the line.
 947      */
 948     while (p > buffer && (p[-1] == '\n' || p[-1] == '\r'))
 949         *--p = '\0';
 950
 951     /*
 952      * Handle spurious ^Z, which may be inserted into source files
 953      * by some file transfer utilities.
 954      */
 955     buffer[strcspn(buffer, "\032")] = '\0';
 956
 957     return buffer;
 958 }
 959
 960 static void no_pp_cleanup (void) {
 961     fclose(no_pp_fp);
 962 }