gas/gasp.c

   1 /* gasp.c - Gnu assembler preprocessor main program.
   2    Copyright (C) 1994, 95, 96, 97, 98, 99, 2000
   3    Free Software Foundation, Inc.
   4
   5    Written by Steve and Judy Chamberlain of Cygnus Support,
   6       sac@cygnus.com
   7
   8    This file is part of GASP, the GNU Assembler Preprocessor.
   9
  10    GASP is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2, or (at your option)
  13    any later version.
  14
  15    GASP is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with GASP; see the file COPYING.  If not, write to the Free
  22    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA. */
  24
  25 /*
  26
  27 This program translates the input macros and stuff into a form
  28 suitable for gas to consume.
  29
  30
  31   gasp [-sdhau] [-c char] [-o <outfile>] <infile>*
  32
  33   -s copy source to output
  34   -c <char> comments are started with <char> instead of !
  35   -u allow unreasonable stuff
  36   -p print line numbers
  37   -d print debugging stats
  38   -s semi colons start comments
  39   -a use alternate syntax
  40      Pseudo ops can start with or without a .
  41      Labels have to be in first column.
  42   -I specify include dir
  43     Macro arg parameters subsituted by name, don't need the &.
  44      String can start with ' too.
  45      Strings can be surrounded by <..>
  46      A %<exp> in a string evaluates the expression
  47      Literal char in a string with !
  48
  49
  50 */
  51
  52 #include "config.h"
  53
  54 #include <stdio.h>
  55 #include <string.h>
  56 #include <getopt.h>
  57 #include <ctype.h>
  58
  59 #ifdef HAVE_STDLIB_H
  60 #include <stdlib.h>
  61 #endif
  62
  63 #ifdef NEED_MALLOC_DECLARATION
  64 extern char *malloc ();
  65 #endif
  66
  67 #include "ansidecl.h"
  68 #include "libiberty.h"
  69 #include "sb.h"
  70 #include "macro.h"
  71 #include "asintl.h"
  72
  73 char *program_version = "1.2";
  74
  75 /* This is normally declared in as.h, but we don't include that.  We
  76    need the function because other files linked with gasp.c might call
  77    it.  */
  78 extern void as_abort PARAMS ((const char *, int, const char *));
  79
  80 /* The default obstack chunk size.  If we set this to zero, the
  81    obstack code will use whatever will fit in a 4096 byte block.  This
  82    is used by the hash table code used by macro.c.  */
  83 int chunksize = 0;
  84
  85 #define MAX_INCLUDES 30         /* Maximum include depth */
  86 #define MAX_REASONABLE 1000     /* Maximum number of expansions */
  87
  88 int unreasonable;               /* -u on command line */
  89 int stats;                      /* -d on command line */
  90 int print_line_number;          /* -p flag on command line */
  91 int copysource;                 /* -c flag on command line */
  92 int warnings;                   /* Number of WARNINGs generated so far. */
  93 int errors;                     /* Number of ERRORs generated so far. */
  94 int fatals;                     /* Number of fatal ERRORs generated so far (either 0 or 1). */
  95 int alternate = 0;              /* -a on command line */
  96 int mri = 0;                    /* -M on command line */
  97 char comment_char = '!';
  98 int radix = 10;                 /* Default radix */
  99
 100 int had_end; /* Seen .END */
 101
 102 /* The output stream */
 103 FILE *outfile;
 104
 105 /* the attributes of each character are stored as a bit pattern
 106    chartype, which gives us quick tests. */
 107
 108
 109 #define FIRSTBIT 1
 110 #define NEXTBIT  2
 111 #define SEPBIT   4
 112 #define WHITEBIT 8
 113 #define COMMENTBIT 16
 114 #define BASEBIT  32
 115 #define ISCOMMENTCHAR(x) (chartype[(unsigned char)(x)] & COMMENTBIT)
 116 #define ISFIRSTCHAR(x)  (chartype[(unsigned char)(x)] & FIRSTBIT)
 117 #define ISNEXTCHAR(x)   (chartype[(unsigned char)(x)] & NEXTBIT)
 118 #define ISSEP(x)        (chartype[(unsigned char)(x)] & SEPBIT)
 119 #define ISWHITE(x)      (chartype[(unsigned char)(x)] & WHITEBIT)
 120 #define ISBASE(x)       (chartype[(unsigned char)(x)] & BASEBIT)
 121 static char chartype[256];
 122
 123
 124 /* Conditional assembly uses the `ifstack'.  Each aif pushes another
 125    entry onto the stack, and sets the on flag if it should.  The aelse
 126    sets hadelse, and toggles on.  An aend pops a level.  We limit to
 127    100 levels of nesting, not because we're facists pigs with read
 128    only minds, but because more than 100 levels of nesting is probably
 129    a bug in the user's macro structure.  */
 130
 131 #define IFNESTING 100
 132 struct
 133   {
 134     int on;                     /* is the level being output */
 135     int hadelse;                /* has an aelse been seen */
 136   }
 137 ifstack[IFNESTING];
 138 int ifi;
 139
 140 /* The final and intermediate results of expression evaluation are kept in
 141    exp_t's.  Note that a symbol is not an sb, but a pointer into the input
 142    line.  It must be coped somewhere safe before the next line is read in. */
 143
 144 typedef struct
 145   {
 146     char *name;
 147     int len;
 148   }
 149 symbol;
 150
 151 typedef struct
 152   {
 153     int value;                  /* constant part */
 154     symbol add_symbol;          /* name part */
 155     symbol sub_symbol;          /* name part */
 156   }
 157 exp_t;
 158
 159
 160 /* Hashing is done in a pretty standard way.  A hash_table has a
 161    pointer to a vector of pointers to hash_entrys, and the size of the
 162    vector.  A hash_entry contains a union of all the info we like to
 163    store in hash table.  If there is a hash collision, hash_entries
 164    with the same hash are kept in a chain. */
 165
 166 /* What the data in a hash_entry means */
 167 typedef enum
 168   {
 169     hash_integer,               /* name->integer mapping */
 170     hash_string,                /* name->string mapping */
 171     hash_macro,                 /* name is a macro */
 172     hash_formal                 /* name is a formal argument */
 173   } hash_type;
 174
 175 typedef struct hs
 176   {
 177     sb key;                     /* symbol name */
 178     hash_type type;             /* symbol meaning */
 179     union
 180       {
 181         sb s;
 182         int i;
 183         struct macro_struct *m;
 184         struct formal_struct *f;
 185       } value;
 186     struct hs *next;            /* next hash_entry with same hash key */
 187   } hash_entry;
 188
 189 typedef struct
 190   {
 191     hash_entry **table;
 192     int size;
 193   } hash_table;
 194
 195
 196 /* Structures used to store macros.
 197
 198    Each macro knows its name and included text.  It gets built with a
 199    list of formal arguments, and also keeps a hash table which points
 200    into the list to speed up formal search.  Each formal knows its
 201    name and its default value.  Each time the macro is expanded, the
 202    formals get the actual values attatched to them. */
 203
 204 /* describe the formal arguments to a macro */
 205
 206 typedef struct formal_struct
 207   {
 208     struct formal_struct *next; /* next formal in list */
 209     sb name;                    /* name of the formal */
 210     sb def;                     /* the default value */
 211     sb actual;                  /* the actual argument (changed on each expansion) */
 212     int index;                  /* the index of the formal 0..formal_count-1 */
 213   }
 214 formal_entry;
 215
 216 /* describe the macro. */
 217
 218 typedef struct macro_struct
 219   {
 220     sb sub;                     /* substitution text. */
 221     int formal_count;           /* number of formal args. */
 222     formal_entry *formals;      /* pointer to list of formal_structs */
 223     hash_table formal_hash;     /* hash table of formals. */
 224   }
 225 macro_entry;
 226
 227 /* how we nest files and expand macros etc.
 228
 229    we keep a stack of of include_stack structs.  each include file
 230    pushes a new level onto the stack.  we keep an sb with a pushback
 231    too.  unget chars are pushed onto the pushback sb, getchars first
 232    checks the pushback sb before reading from the input stream.
 233
 234    small things are expanded by adding the text of the item onto the
 235    pushback sb.  larger items are grown by pushing a new level and
 236    allocating the entire pushback buf for the item.  each time
 237    something like a macro is expanded, the stack index is changed. we
 238    can then perform an exitm by popping all entries off the stack with
 239    the same stack index.  if we're being reasonable, we can detect
 240    recusive expansion by checking the index is reasonably small.
 241  */
 242
 243 typedef enum
 244   {
 245     include_file, include_repeat, include_while, include_macro
 246   } include_type;
 247
 248 struct include_stack
 249   {
 250     sb pushback;                /* current pushback stream */
 251     int pushback_index;         /* next char to read from stream */
 252     FILE *handle;               /* open file */
 253     sb name;                    /* name of file */
 254     int linecount;              /* number of lines read so far */
 255     include_type type;
 256     int index;                  /* index of this layer */
 257   }
 258 include_stack[MAX_INCLUDES];
 259
 260 struct include_stack *sp;
 261 #define isp (sp - include_stack)
 262
 263 /* Include file list */
 264
 265 typedef struct include_path
 266 {
 267   struct include_path *next;
 268   sb path;
 269 }  include_path;
 270
 271 include_path *paths_head;
 272 include_path *paths_tail;
 273
 274
 275 static void quit PARAMS ((void));
 276 static void hash_new_table PARAMS ((int, hash_table *));
 277 static int hash PARAMS ((sb *));
 278 static hash_entry *hash_create PARAMS ((hash_table *, sb *));
 279 static void hash_add_to_string_table PARAMS ((hash_table *, sb *, sb *, int));
 280 static void hash_add_to_int_table PARAMS ((hash_table *, sb *, int));
 281 static hash_entry *hash_lookup PARAMS ((hash_table *, sb *));
 282 static void checkconst PARAMS ((int, exp_t *));
 283 static int sb_strtol PARAMS ((int, sb *, int, int *));
 284 static int level_0 PARAMS ((int, sb *, exp_t *));
 285 static int level_1 PARAMS ((int, sb *, exp_t *));
 286 static int level_2 PARAMS ((int, sb *, exp_t *));
 287 static int level_3 PARAMS ((int, sb *, exp_t *));
 288 static int level_4 PARAMS ((int, sb *, exp_t *));
 289 static int level_5 PARAMS ((int, sb *, exp_t *));
 290 static int exp_parse PARAMS ((int, sb *, exp_t *));
 291 static void exp_string PARAMS ((exp_t *, sb *));
 292 static int exp_get_abs PARAMS ((const char *, int, sb *, int *));
 293 #if 0
 294 static void strip_comments PARAMS ((sb *));
 295 #endif
 296 static void unget PARAMS ((int));
 297 static void include_buf PARAMS ((sb *, sb *, include_type, int));
 298 static void include_print_where_line PARAMS ((FILE *));
 299 static void include_print_line PARAMS ((FILE *));
 300 static int get_line PARAMS ((sb *));
 301 static int grab_label PARAMS ((sb *, sb *));
 302 static void change_base PARAMS ((int, sb *, sb *));
 303 static void do_end PARAMS ((sb *));
 304 static void do_assign PARAMS ((int, int, sb *));
 305 static void do_radix PARAMS ((sb *));
 306 static int get_opsize PARAMS ((int, sb *, int *));
 307 static int eol PARAMS ((int, sb *));
 308 static void do_data PARAMS ((int, sb *, int));
 309 static void do_datab PARAMS ((int, sb *));
 310 static void do_align PARAMS ((int, sb *));
 311 static void do_res PARAMS ((int, sb *, int));
 312 static void do_export PARAMS ((sb *));
 313 static void do_print PARAMS ((int, sb *));
 314 static void do_heading PARAMS ((int, sb *));
 315 static void do_page PARAMS ((void));
 316 static void do_form PARAMS ((int, sb *));
 317 static int get_any_string PARAMS ((int, sb *, sb *, int, int));
 318 static int skip_openp PARAMS ((int, sb *));
 319 static int skip_closep PARAMS ((int, sb *));
 320 static int dolen PARAMS ((int, sb *, sb *));
 321 static int doinstr PARAMS ((int, sb *, sb *));
 322 static int dosubstr PARAMS ((int, sb *, sb *));
 323 static void process_assigns PARAMS ((int, sb *, sb *));
 324 static int get_and_process PARAMS ((int, sb *, sb *));
 325 static void process_file PARAMS ((void));
 326 static void free_old_entry PARAMS ((hash_entry *));
 327 static void do_assigna PARAMS ((int, sb *));
 328 static void do_assignc PARAMS ((int, sb *));
 329 static void do_reg PARAMS ((int, sb *));
 330 static int condass_lookup_name PARAMS ((sb *, int, sb *, int));
 331 static int whatcond PARAMS ((int, sb *, int *));
 332 static int istrue PARAMS ((int, sb *));
 333 static void do_aif PARAMS ((int, sb *));
 334 static void do_aelse PARAMS ((void));
 335 static void do_aendi PARAMS ((void));
 336 static int condass_on PARAMS ((void));
 337 static void do_if PARAMS ((int, sb *, int));
 338 static int get_mri_string PARAMS ((int, sb *, sb *, int));
 339 static void do_ifc PARAMS ((int, sb *, int));
 340 static void do_aendr PARAMS ((void));
 341 static void do_awhile PARAMS ((int, sb *));
 342 static void do_aendw PARAMS ((void));
 343 static void do_exitm PARAMS ((void));
 344 static void do_arepeat PARAMS ((int, sb *));
 345 static void do_endm PARAMS ((void));
 346 static void do_irp PARAMS ((int, sb *, int));
 347 static void do_local PARAMS ((int, sb *));
 348 static void do_macro PARAMS ((int, sb *));
 349 static int macro_op PARAMS ((int, sb *));
 350 static int getstring PARAMS ((int, sb *, sb *));
 351 static void do_sdata PARAMS ((int, sb *, int));
 352 static void do_sdatab PARAMS ((int, sb *));
 353 static int new_file PARAMS ((const char *));
 354 static void do_include PARAMS ((int, sb *));
 355 static void include_pop PARAMS ((void));
 356 static int get PARAMS ((void));
 357 static int linecount PARAMS ((void));
 358 static int include_next_index PARAMS ((void));
 359 static void chartype_init PARAMS ((void));
 360 static int process_pseudo_op PARAMS ((int, sb *, sb *));
 361 static void add_keyword PARAMS ((const char *, int));
 362 static void process_init PARAMS ((void));
 363 static void do_define PARAMS ((const char *));
 364 static void show_usage PARAMS ((FILE *, int));
 365 static void show_help PARAMS ((void));
 366
 367 #define FATAL(x) \
 368   do { include_print_where_line (stderr); fprintf x ; fatals++; quit(); } while(0)
 369 #define ERROR(x) \
 370   do { include_print_where_line (stderr); fprintf x; errors++; } while(0)
 371 #define WARNING(x) \
 372   do { include_print_where_line (stderr); fprintf x; warnings++;} while(0)
 373
 374
 375
 376 /* exit the program and return the right ERROR code. */
 377 static void
 378 quit ()
 379 {
 380   int exitcode;
 381   if (fatals + errors)
 382     exitcode = 1;
 383   else
 384     exitcode = 0;
 385
 386   if (stats)
 387     {
 388       int i;
 389       for (i = 0; i < sb_max_power_two; i++)
 390         {
 391           fprintf (stderr, "strings size %8d : %d\n", 1<<i, string_count[i]);
 392         }
 393     }
 394   exit (exitcode);
 395 }
 396
 397 /* hash table maintenance. */
 398
 399 /* build a new hash table with size buckets, and fill in the info at ptr. */
 400
 401 static void
 402 hash_new_table (size, ptr)
 403      int size;
 404      hash_table *ptr;
 405 {
 406   int i;
 407   ptr->size = size;
 408   ptr->table = (hash_entry **) xmalloc (size * (sizeof (hash_entry *)));
 409   /* Fill with null-pointer, not zero-bit-pattern.  */
 410   for (i = 0; i < size; i++)
 411     ptr->table[i] = 0;
 412 }
 413
 414 /* calculate and return the hash value of the sb at key. */
 415
 416 static int
 417 hash (key)
 418      sb *key;
 419 {
 420   int k = 0x1234;
 421   int i;
 422   char *p = key->ptr;
 423   for (i = 0; i < key->len; i++)
 424     {
 425       k ^= (k << 2) ^ *p;
 426       p++;
 427     }
 428   return k & 0xf0fff;
 429 }
 430
 431 /* lookup key in hash_table tab, if present, then return it, otherwise
 432    build a new one and fill it with hash_integer. */
 433
 434 static
 435 hash_entry *
 436 hash_create (tab, key)
 437      hash_table *tab;
 438      sb *key;
 439 {
 440   int k = hash (key) % tab->size;
 441   hash_entry *p;
 442   hash_entry **table = tab->table;
 443
 444   p = table[k];
 445
 446   while (1)
 447     {
 448       if (!p)
 449         {
 450           hash_entry *n = (hash_entry *) xmalloc (sizeof (hash_entry));
 451           n->next = table[k];
 452           sb_new (&n->key);
 453           sb_add_sb (&n->key, key);
 454           table[k] = n;
 455           n->type = hash_integer;
 456           return n;
 457         }
 458       if (strncmp (table[k]->key.ptr, key->ptr, key->len) == 0)
 459         {
 460           return p;
 461         }
 462       p = p->next;
 463     }
 464 }
 465
 466 /* add sb name with key into hash_table tab.  if replacing old value
 467    and again, then ERROR. */
 468
 469 static
 470 void
 471 hash_add_to_string_table (tab, key, name, again)
 472      hash_table *tab;
 473      sb *key;
 474      sb *name;
 475      int again;
 476 {
 477   hash_entry *ptr = hash_create (tab, key);
 478   if (ptr->type == hash_integer)
 479     {
 480       sb_new (&ptr->value.s);
 481     }
 482   if (ptr->value.s.len)
 483     {
 484       if (!again)
 485         ERROR ((stderr, _("redefinition not allowed\n")));
 486     }
 487
 488   ptr->type = hash_string;
 489   sb_reset (&ptr->value.s);
 490
 491   sb_add_sb (&ptr->value.s, name);
 492 }
 493
 494 /* add integer name to hash_table tab with sb key. */
 495
 496 static
 497 void
 498 hash_add_to_int_table (tab, key, name)
 499      hash_table *tab;
 500      sb *key;
 501      int name;
 502 {
 503   hash_entry *ptr = hash_create (tab, key);
 504   ptr->value.i = name;
 505 }
 506
 507 /* lookup sb key in hash_table tab.  if found return hash_entry result,
 508    else 0. */
 509
 510 static
 511 hash_entry *
 512 hash_lookup (tab, key)
 513      hash_table *tab;
 514      sb *key;
 515 {
 516   int k = hash (key) % tab->size;
 517   hash_entry **table = tab->table;
 518   hash_entry *p = table[k];
 519   while (p)
 520     {
 521       if (p->key.len == key->len
 522           && strncmp (p->key.ptr, key->ptr, key->len) == 0)
 523         return p;
 524       p = p->next;
 525     }
 526   return 0;
 527 }
 528
 529
 530 /* expressions
 531
 532    are handled in a really simple recursive decent way. each bit of
 533    the machine takes an index into an sb and a pointer to an exp_t,
 534    modifies the *exp_t and returns the index of the first character
 535    past the part of the expression parsed.
 536
 537  expression precedence:
 538   ( )
 539  unary + - ~
 540   * /
 541   + -
 542   &
 543   | ~
 544
 545 */
 546
 547
 548 /* make sure that the exp_t at term is constant, if not the give the op ERROR. */
 549
 550 static
 551 void
 552 checkconst (op, term)
 553      int op;
 554      exp_t *term;
 555 {
 556   if (term->add_symbol.len
 557       || term->sub_symbol.len)
 558     {
 559       ERROR ((stderr, _("the %c operator cannot take non-absolute arguments.\n"), op));
 560     }
 561 }
 562
 563 /* turn the number in string at idx into a number of base,
 564    fill in ptr and return the index of the first character not in the
 565    number. */
 566
 567 static
 568 int
 569 sb_strtol (idx, string, base, ptr)
 570      int idx;
 571      sb *string;
 572      int base;
 573      int *ptr;
 574 {
 575   int value = 0;
 576   idx = sb_skip_white (idx, string);
 577
 578   while (idx < string->len)
 579     {
 580       int ch = string->ptr[idx];
 581       int dig = 0;
 582       if (isdigit (ch))
 583         dig = ch - '0';
 584       else if (ch >= 'a' && ch <= 'f')
 585         dig = ch - 'a' + 10;
 586       else if (ch >= 'A' && ch <= 'F')
 587         dig = ch - 'A' + 10;
 588       else
 589         break;
 590
 591       if (dig >= base)
 592         break;
 593
 594       value = value * base + dig;
 595       idx++;
 596     }
 597   *ptr = value;
 598   return idx;
 599 }
 600
 601 static int
 602 level_0 (idx, string, lhs)
 603      int idx;
 604      sb *string;
 605      exp_t *lhs;
 606 {
 607   lhs->add_symbol.len = 0;
 608   lhs->add_symbol.name = 0;
 609
 610   lhs->sub_symbol.len = 0;
 611   lhs->sub_symbol.name = 0;
 612
 613   idx = sb_skip_white (idx, string);
 614
 615   lhs->value = 0;
 616
 617   if (isdigit ((unsigned char) string->ptr[idx]))
 618     {
 619       idx = sb_strtol (idx, string, 10, &lhs->value);
 620     }
 621   else if (ISFIRSTCHAR (string->ptr[idx]))
 622     {
 623       int len = 0;
 624       lhs->add_symbol.name = string->ptr + idx;
 625       while (idx < string->len && ISNEXTCHAR (string->ptr[idx]))
 626         {
 627           idx++;
 628           len++;
 629         }
 630       lhs->add_symbol.len = len;
 631     }
 632   else if (string->ptr[idx] == '"')
 633     {
 634       sb acc;
 635       sb_new (&acc);
 636       ERROR ((stderr, _("string where expression expected.\n")));
 637       idx = getstring (idx, string, &acc);
 638       sb_kill (&acc);
 639     }
 640   else
 641     {
 642       ERROR ((stderr, _("can't find primary in expression.\n")));
 643       idx++;
 644     }
 645   return sb_skip_white (idx, string);
 646 }
 647
 648
 649
 650 static int
 651 level_1 (idx, string, lhs)
 652      int idx;
 653      sb *string;
 654      exp_t *lhs;
 655 {
 656   idx = sb_skip_white (idx, string);
 657
 658   switch (string->ptr[idx])
 659     {
 660     case '+':
 661       idx = level_1 (idx + 1, string, lhs);
 662       break;
 663     case '~':
 664       idx = level_1 (idx + 1, string, lhs);
 665       checkconst ('~', lhs);
 666       lhs->value = ~lhs->value;
 667       break;
 668     case '-':
 669       {
 670         symbol t;
 671         idx = level_1 (idx + 1, string, lhs);
 672         lhs->value = -lhs->value;
 673         t = lhs->add_symbol;
 674         lhs->add_symbol = lhs->sub_symbol;
 675         lhs->sub_symbol = t;
 676         break;
 677       }
 678     case '(':
 679       idx++;
 680       idx = level_5 (sb_skip_white (idx, string), string, lhs);
 681       if (string->ptr[idx] != ')')
 682         ERROR ((stderr, _("misplaced closing parens.\n")));
 683       else
 684         idx++;
 685       break;
 686     default:
 687       idx = level_0 (idx, string, lhs);
 688       break;
 689     }
 690   return sb_skip_white (idx, string);
 691 }
 692
 693 static int
 694 level_2 (idx, string, lhs)
 695      int idx;
 696      sb *string;
 697      exp_t *lhs;
 698 {
 699   exp_t rhs;
 700
 701   idx = level_1 (idx, string, lhs);
 702
 703   while (idx < string->len && (string->ptr[idx] == '*'
 704                                || string->ptr[idx] == '/'))
 705     {
 706       char op = string->ptr[idx++];
 707       idx = level_1 (idx, string, &rhs);
 708       switch (op)
 709         {
 710         case '*':
 711           checkconst ('*', lhs);
 712           checkconst ('*', &rhs);
 713           lhs->value *= rhs.value;
 714           break;
 715         case '/':
 716           checkconst ('/', lhs);
 717           checkconst ('/', &rhs);
 718           if (rhs.value == 0)
 719             ERROR ((stderr, _("attempt to divide by zero.\n")));
 720           else
 721             lhs->value /= rhs.value;
 722           break;
 723         }
 724     }
 725   return sb_skip_white (idx, string);
 726 }
 727
 728
 729 static int
 730 level_3 (idx, string, lhs)
 731      int idx;
 732      sb *string;
 733      exp_t *lhs;
 734 {
 735   exp_t rhs;
 736
 737   idx = level_2 (idx, string, lhs);
 738
 739   while (idx < string->len
 740          && (string->ptr[idx] == '+'
 741              || string->ptr[idx] == '-'))
 742     {
 743       char op = string->ptr[idx++];
 744       idx = level_2 (idx, string, &rhs);
 745       switch (op)
 746         {
 747         case '+':
 748           lhs->value += rhs.value;
 749           if (lhs->add_symbol.name && rhs.add_symbol.name)
 750             {
 751               ERROR ((stderr, _("can't add two relocatable expressions\n")));
 752             }
 753           /* change nn+symbol to symbol + nn */
 754           if (rhs.add_symbol.name)
 755             {
 756               lhs->add_symbol = rhs.add_symbol;
 757             }
 758           break;
 759         case '-':
 760           lhs->value -= rhs.value;
 761           lhs->sub_symbol = rhs.add_symbol;
 762           break;
 763         }
 764     }
 765   return sb_skip_white (idx, string);
 766 }
 767
 768 static int
 769 level_4 (idx, string, lhs)
 770      int idx;
 771      sb *string;
 772      exp_t *lhs;
 773 {
 774   exp_t rhs;
 775
 776   idx = level_3 (idx, string, lhs);
 777
 778   while (idx < string->len &&
 779          string->ptr[idx] == '&')
 780     {
 781       char op = string->ptr[idx++];
 782       idx = level_3 (idx, string, &rhs);
 783       switch (op)
 784         {
 785         case '&':
 786           checkconst ('&', lhs);
 787           checkconst ('&', &rhs);
 788           lhs->value &= rhs.value;
 789           break;
 790         }
 791     }
 792   return sb_skip_white (idx, string);
 793 }
 794
 795 static int
 796 level_5 (idx, string, lhs)
 797      int idx;
 798      sb *string;
 799      exp_t *lhs;
 800 {
 801   exp_t rhs;
 802
 803   idx = level_4 (idx, string, lhs);
 804
 805   while (idx < string->len
 806          && (string->ptr[idx] == '|' || string->ptr[idx] == '~'))
 807     {
 808       char op = string->ptr[idx++];
 809       idx = level_4 (idx, string, &rhs);
 810       switch (op)
 811         {
 812         case '|':
 813           checkconst ('|', lhs);
 814           checkconst ('|', &rhs);
 815           lhs->value |= rhs.value;
 816           break;
 817         case '~':
 818           checkconst ('~', lhs);
 819           checkconst ('~', &rhs);
 820           lhs->value ^= rhs.value;
 821           break;
 822         }
 823     }
 824   return sb_skip_white (idx, string);
 825 }
 826
 827
 828 /* parse the expression at offset idx into string, fill up res with
 829    the result. return the index of the first char past the expression.
 830    */
 831
 832 static int
 833 exp_parse (idx, string, res)
 834      int idx;
 835      sb *string;
 836      exp_t *res;
 837 {
 838   return level_5 (sb_skip_white (idx, string), string, res);
 839 }
 840
 841
 842 /* turn the expression at exp into text and glue it onto the end of
 843    string. */
 844
 845 static void
 846 exp_string (exp, string)
 847      exp_t *exp;
 848      sb *string;
 849 {
 850   int np = 0;
 851   int ad = 0;
 852   sb_reset (string);
 853
 854   if (exp->add_symbol.len)
 855     {
 856       sb_add_buffer (string, exp->add_symbol.name, exp->add_symbol.len);
 857       np = 1;
 858       ad = 1;
 859     }
 860   if (exp->value)
 861     {
 862       char buf[20];
 863       if (np)
 864         sb_add_char (string, '+');
 865       sprintf (buf, "%d", exp->value);
 866       sb_add_string (string, buf);
 867       np = 1;
 868       ad = 1;
 869     }
 870   if (exp->sub_symbol.len)
 871     {
 872       sb_add_char (string, '-');
 873       sb_add_buffer (string, exp->add_symbol.name, exp->add_symbol.len);
 874       np = 0;
 875       ad = 1;
 876     }
 877
 878   if (!ad)
 879     sb_add_char (string, '0');
 880 }
 881
 882
 883 /* parse the expression at offset idx into sb in, return the value in val.
 884    if the expression is not constant, give ERROR emsg.  returns the index
 885    of the first character past the end of the expression. */
 886
 887 static int
 888 exp_get_abs (emsg, idx, in, val)
 889      const char *emsg;
 890      int idx;
 891      sb *in;
 892      int *val;
 893 {
 894   exp_t res;
 895   idx = exp_parse (idx, in, &res);
 896   if (res.add_symbol.len || res.sub_symbol.len)
 897     ERROR ((stderr, "%s", emsg));
 898   *val = res.value;
 899   return idx;
 900 }
 901
 902
 903 sb label; /* current label parsed from line */
 904 hash_table assign_hash_table;   /* hash table for all assigned variables */
 905 hash_table keyword_hash_table;  /* hash table for keyword */
 906 hash_table vars;  /* hash table for  eq variables */
 907
 908 #define in_comment ';'
 909
 910 #if 0
 911 static void
 912 strip_comments (out)
 913      sb *out;
 914 {
 915   char *s = out->ptr;
 916   int i = 0;
 917   for (i = 0; i < out->len; i++)
 918     {
 919       if (ISCOMMENTCHAR(s[i]))
 920         {
 921           out->len = i;
 922           return;
 923         }
 924     }
 925 }
 926 #endif
 927
 928 /* push back character ch so that it can be read again. */
 929
 930 static void
 931 unget (ch)
 932      int ch;
 933 {
 934   if (ch == '\n')
 935     {
 936       sp->linecount--;
 937     }
 938   if (sp->pushback_index)
 939     sp->pushback_index--;
 940   else
 941     sb_add_char (&sp->pushback, ch);
 942 }
 943
 944 /* push the sb ptr onto the include stack, with the given name, type and index. */
 945
 946 static
 947 void
 948 include_buf (name, ptr, type, index)
 949      sb *name;
 950      sb *ptr;
 951      include_type type;
 952      int index;
 953 {
 954   sp++;
 955   if (sp - include_stack >= MAX_INCLUDES)
 956     FATAL ((stderr, _("unreasonable nesting.\n")));
 957   sb_new (&sp->name);
 958   sb_add_sb (&sp->name, name);
 959   sp->handle = 0;
 960   sp->linecount = 1;
 961   sp->pushback_index = 0;
 962   sp->type = type;
 963   sp->index = index;
 964   sb_new (&sp->pushback);
 965   sb_add_sb (&sp->pushback, ptr);
 966 }
 967
 968
 969 /* used in ERROR messages, print info on where the include stack is onto file. */
 970 static
 971 void
 972 include_print_where_line (file)
 973      FILE *file;
 974 {
 975   struct include_stack *p = include_stack + 1;
 976
 977   while (p <= sp)
 978     {
 979       fprintf (file, "%s:%d ", sb_name (&p->name), p->linecount - 1);
 980       p++;
 981     }
 982 }
 983
 984 /* used in listings, print the line number onto file. */
 985 static void
 986 include_print_line (file)
 987      FILE *file;
 988 {
 989   int n;
 990   struct include_stack *p = include_stack + 1;
 991
 992   n = fprintf (file, "%4d", p->linecount);
 993   p++;
 994   while (p <= sp)
 995     {
 996       n += fprintf (file, ".%d", p->linecount);
 997       p++;
 998     }
 999   while (n < 8 * 3)
1000     {
1001       fprintf (file, " ");
1002       n++;
1003     }
1004 }
1005
1006
1007 /* read a line from the top of the include stack into sb in. */
1008
1009 static int
1010 get_line (in)
1011      sb *in;
1012 {
1013   int online = 0;
1014   int more = 1;
1015
1016   if (copysource)
1017     {
1018       putc (comment_char, outfile);
1019       if (print_line_number)
1020         include_print_line (outfile);
1021     }
1022
1023   while (1)
1024     {
1025       int ch = get ();
1026
1027       while (ch == '\r')
1028         ch = get ();
1029
1030       if (ch == EOF)
1031         {
1032           if (online)
1033             {
1034               WARNING ((stderr, _("End of file not at start of line.\n")));
1035               if (copysource)
1036                 putc ('\n', outfile);
1037               ch = '\n';
1038             }
1039           else
1040             more = 0;
1041           break;
1042         }
1043
1044       if (copysource)
1045         {
1046           putc (ch, outfile);
1047         }
1048
1049       if (ch == '\n')
1050         {
1051           ch = get ();
1052           online = 0;
1053           if (ch == '+')
1054             {
1055               /* continued line */
1056               if (copysource)
1057                 {
1058                   putc (comment_char, outfile);
1059                   putc ('+', outfile);
1060                 }
1061               ch = get ();
1062             }
1063           else
1064             {
1065               if (ch != EOF)
1066                 unget (ch);
1067               break;
1068             }
1069         }
1070       else
1071         {
1072           sb_add_char (in, ch);
1073         }
1074       online++;
1075     }
1076
1077   return more;
1078 }
1079
1080 /* find a label from sb in and put it in out. */
1081
1082 static int
1083 grab_label (in, out)
1084      sb *in;
1085      sb *out;
1086 {
1087   int i = 0;
1088   sb_reset (out);
1089   if (ISFIRSTCHAR (in->ptr[i]) || in->ptr[i] == '\\')
1090     {
1091       sb_add_char (out, in->ptr[i]);
1092       i++;
1093       while ((ISNEXTCHAR (in->ptr[i])
1094               || in->ptr[i] == '\\'
1095               || in->ptr[i] == '&')
1096              && i < in->len)
1097         {
1098           sb_add_char (out, in->ptr[i]);
1099           i++;
1100         }
1101     }
1102   return i;
1103 }
1104
1105 /* find all strange base stuff and turn into decimal. also
1106    find all the other numbers and convert them from the default radix */
1107
1108 static void
1109 change_base (idx, in, out)
1110      int idx;
1111      sb *in;
1112      sb *out;
1113 {
1114   char buffer[20];
1115
1116   while (idx < in->len)
1117     {
1118       if (in->ptr[idx] == '\\'
1119           && idx + 1 < in->len
1120           && in->ptr[idx + 1] == '(')
1121         {
1122           idx += 2;
1123           while (idx < in->len
1124                  && in->ptr[idx] != ')')
1125             {
1126               sb_add_char (out, in->ptr[idx]);
1127               idx++;
1128             }
1129           if (idx < in->len)
1130             idx++;
1131         }
1132       else if (idx < in->len - 1 && in->ptr[idx + 1] == '\'' && ! mri)
1133         {
1134           int base;
1135           int value;
1136           switch (in->ptr[idx])
1137             {
1138             case 'b':
1139             case 'B':
1140               base = 2;
1141               break;
1142             case 'q':
1143             case 'Q':
1144               base = 8;
1145               break;
1146             case 'h':
1147             case 'H':
1148               base = 16;
1149               break;
1150             case 'd':
1151             case 'D':
1152               base = 10;
1153               break;
1154             default:
1155               ERROR ((stderr, _("Illegal base character %c.\n"), in->ptr[idx]));
1156               base = 10;
1157               break;
1158             }
1159
1160           idx = sb_strtol (idx + 2, in, base, &value);
1161           sprintf (buffer, "%d", value);
1162           sb_add_string (out, buffer);
1163         }
1164       else if (ISFIRSTCHAR (in->ptr[idx]))
1165         {
1166           /* copy entire names through quickly */
1167           sb_add_char (out, in->ptr[idx]);
1168           idx++;
1169           while (idx < in->len && ISNEXTCHAR (in->ptr[idx]))
1170             {
1171               sb_add_char (out, in->ptr[idx]);
1172               idx++;
1173             }
1174         }
1175       else if (isdigit ((unsigned char) in->ptr[idx]))
1176         {
1177           int value;
1178           /* all numbers must start with a digit, let's chew it and
1179              spit out decimal */
1180           idx = sb_strtol (idx, in, radix, &value);
1181           sprintf (buffer, "%d", value);
1182           sb_add_string (out, buffer);
1183
1184           /* skip all undigsested letters */
1185           while (idx < in->len && ISNEXTCHAR (in->ptr[idx]))
1186             {
1187               sb_add_char (out, in->ptr[idx]);
1188               idx++;
1189             }
1190         }
1191       else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'')
1192         {
1193           char tchar = in->ptr[idx];
1194           /* copy entire names through quickly */
1195           sb_add_char (out, in->ptr[idx]);
1196           idx++;
1197           while (idx < in->len && in->ptr[idx] != tchar)
1198             {
1199               sb_add_char (out, in->ptr[idx]);
1200               idx++;
1201             }
1202         }
1203       else
1204         {
1205           /* nothing special, just pass it through */
1206           sb_add_char (out, in->ptr[idx]);
1207           idx++;
1208         }
1209     }
1210
1211 }
1212
1213 /* .end */
1214 static void
1215 do_end (in)
1216      sb *in;
1217 {
1218   had_end = 1;
1219   if (mri)
1220     fprintf (outfile, "%s\n", sb_name (in));
1221 }
1222
1223 /* .assign */
1224
1225 static void
1226 do_assign (again, idx, in)
1227      int again;
1228      int idx;
1229      sb *in;
1230 {
1231   /* stick label in symbol table with following value */
1232   exp_t e;
1233   sb acc;
1234
1235   sb_new (&acc);
1236   idx = exp_parse (idx, in, &e);
1237   exp_string (&e, &acc);
1238   hash_add_to_string_table (&assign_hash_table, &label, &acc, again);
1239   sb_kill (&acc);
1240 }
1241
1242
1243 /* .radix [b|q|d|h] */
1244
1245 static
1246 void
1247 do_radix (ptr)
1248      sb *ptr;
1249 {
1250   int idx = sb_skip_white (0, ptr);
1251   switch (ptr->ptr[idx])
1252     {
1253     case 'B':
1254     case 'b':
1255       radix = 2;
1256       break;
1257     case 'q':
1258     case 'Q':
1259       radix = 8;
1260       break;
1261     case 'd':
1262     case 'D':
1263       radix = 10;
1264       break;
1265     case 'h':
1266     case 'H':
1267       radix = 16;
1268       break;
1269     default:
1270       ERROR ((stderr, _("radix is %c must be one of b, q, d or h"), radix));
1271     }
1272 }
1273
1274
1275 /* Parse off a .b, .w or .l */
1276
1277 static int
1278 get_opsize (idx, in, size)
1279      int idx;
1280      sb *in;
1281      int *size;
1282 {
1283   *size = 4;
1284   if (in->ptr[idx] == '.')
1285     {
1286       idx++;
1287     }
1288   switch (in->ptr[idx])
1289     {
1290     case 'b':
1291     case 'B':
1292       *size = 1;
1293       break;
1294     case 'w':
1295     case 'W':
1296       *size = 2;
1297       break;
1298     case 'l':
1299     case 'L':
1300       *size = 4;
1301       break;
1302     case ' ':
1303     case '\t':
1304       break;
1305     default:
1306       ERROR ((stderr, _("size must be one of b, w or l, is %c.\n"), in->ptr[idx]));
1307       break;
1308     }
1309   idx++;
1310
1311   return idx;
1312 }
1313
1314 static
1315 int eol(idx, line)
1316      int idx;
1317      sb *line;
1318 {
1319   idx = sb_skip_white (idx, line);
1320   if (idx < line->len
1321       && ISCOMMENTCHAR(line->ptr[idx]))
1322     return 1;
1323   if (idx >= line->len)
1324     return 1;
1325   return 0;
1326 }
1327
1328 /* .data [.b|.w|.l] <data>*
1329     or d[bwl] <data>* */
1330
1331 static void
1332 do_data (idx, in, size)
1333      int idx;
1334      sb *in;
1335      int size;
1336 {
1337   int opsize = 4;
1338   char *opname = ".yikes!";
1339   sb acc;
1340   sb_new (&acc);
1341
1342   if (!size)
1343     {
1344       idx = get_opsize (idx, in, &opsize);
1345     }
1346   else {
1347     opsize = size;
1348   }
1349   switch (opsize)
1350     {
1351     case 4:
1352       opname = ".long";
1353       break;
1354     case 2:
1355       opname = ".short";
1356       break;
1357     case 1:
1358       opname = ".byte";
1359       break;
1360     }
1361
1362
1363   fprintf (outfile, "%s\t", opname);
1364
1365   idx =   sb_skip_white (idx, in);
1366
1367   if (alternate
1368       && idx < in->len
1369       && in->ptr[idx] == '"')
1370     {
1371       int i;
1372       idx = getstring (idx, in, &acc);
1373       for (i = 0; i < acc.len; i++)
1374         {
1375           if (i)
1376             fprintf(outfile,",");
1377           fprintf (outfile, "%d", acc.ptr[i]);
1378         }
1379     }
1380   else
1381     {
1382       while (!eol (idx, in))
1383         {
1384           exp_t e;
1385           idx = exp_parse (idx, in, &e);
1386           exp_string (&e, &acc);
1387           sb_add_char (&acc, 0);
1388           fprintf (outfile, "%s", acc.ptr);
1389           if (idx < in->len && in->ptr[idx] == ',')
1390             {
1391               fprintf (outfile, ",");
1392               idx++;
1393             }
1394         }
1395     }
1396   sb_kill (&acc);
1397   sb_print_at (outfile, idx, in);
1398   fprintf (outfile, "\n");
1399 }
1400
1401 /* .datab [.b|.w|.l] <repeat>,<fill> */
1402
1403 static void
1404 do_datab (idx, in)
1405      int idx;
1406      sb *in;
1407 {
1408   int opsize;
1409   int repeat;
1410   int fill;
1411
1412   idx = get_opsize (idx, in, &opsize);
1413
1414   idx = exp_get_abs (_("datab repeat must be constant.\n"), idx, in, &repeat);
1415   idx = sb_skip_comma (idx, in);
1416   idx = exp_get_abs (_("datab data must be absolute.\n"), idx, in, &fill);
1417
1418   fprintf (outfile, ".fill\t%d,%d,%d\n", repeat, opsize, fill);
1419 }
1420
1421 /* .align <size> */
1422
1423 static void
1424 do_align (idx, in)
1425      int idx;
1426      sb *in;
1427 {
1428   int al, have_fill, fill;
1429
1430   idx = exp_get_abs (_("align needs absolute expression.\n"), idx, in, &al);
1431   idx = sb_skip_white (idx, in);
1432   have_fill = 0;
1433   fill = 0;
1434   if (! eol (idx, in))
1435     {
1436       idx = sb_skip_comma (idx, in);
1437       idx = exp_get_abs (_(".align needs absolute fill value.\n"), idx, in,
1438                          &fill);
1439       have_fill = 1;
1440     }
1441
1442   if (al != 1
1443       && al != 2
1444       && al != 4)
1445     WARNING ((stderr, _("alignment must be one of 1, 2 or 4.\n")));
1446
1447   fprintf (outfile, ".align     %d", al);
1448   if (have_fill)
1449     fprintf (outfile, ",%d", fill);
1450   fprintf (outfile, "\n");
1451 }
1452
1453 /* .res[.b|.w|.l] <size> */
1454
1455 static void
1456 do_res (idx, in, type)
1457      int idx;
1458      sb *in;
1459      int type;
1460 {
1461   int size = 4;
1462   int count = 0;
1463
1464   idx = get_opsize (idx, in, &size);
1465   while (!eol(idx, in))
1466     {
1467       idx = sb_skip_white (idx, in);
1468       if (in->ptr[idx] == ',')
1469         idx++;
1470       idx = exp_get_abs (_("res needs absolute expression for fill count.\n"), idx, in, &count);
1471
1472       if (type == 'c' || type == 'z')
1473         count++;
1474
1475       fprintf (outfile, ".space %d\n", count * size);
1476     }
1477 }
1478
1479
1480 /* .export */
1481
1482 static void
1483 do_export (in)
1484      sb *in;
1485 {
1486   fprintf (outfile, ".global    %s\n", sb_name (in));
1487 }
1488
1489 /* .print [list] [nolist] */
1490
1491 static void
1492 do_print (idx, in)
1493      int idx;
1494      sb *in;
1495 {
1496   idx = sb_skip_white (idx, in);
1497   while (idx < in->len)
1498     {
1499       if (strncasecmp (in->ptr + idx, "LIST", 4) == 0)
1500         {
1501           fprintf (outfile, ".list\n");
1502           idx += 4;
1503         }
1504       else if (strncasecmp (in->ptr + idx, "NOLIST", 6) == 0)
1505         {
1506           fprintf (outfile, ".nolist\n");
1507           idx += 6;
1508         }
1509       idx++;
1510     }
1511 }
1512
1513 /* .head */
1514 static void
1515 do_heading (idx, in)
1516      int idx;
1517      sb *in;
1518 {
1519   sb head;
1520   sb_new (&head);
1521   idx = getstring (idx, in, &head);
1522   fprintf (outfile, ".title     \"%s\"\n", sb_name (&head));
1523   sb_kill (&head);
1524 }
1525
1526 /* .page */
1527
1528 static void
1529 do_page ()
1530 {
1531   fprintf (outfile, ".eject\n");
1532 }
1533
1534 /* .form [lin=<value>] [col=<value>] */
1535 static void
1536 do_form (idx, in)
1537      int idx;
1538      sb *in;
1539 {
1540   int lines = 60;
1541   int columns = 132;
1542   idx = sb_skip_white (idx, in);
1543
1544   while (idx < in->len)
1545     {
1546
1547       if (strncasecmp (in->ptr + idx, "LIN=", 4) == 0)
1548         {
1549           idx += 4;
1550           idx = exp_get_abs (_("form LIN= needs absolute expresssion.\n"), idx, in, &lines);
1551         }
1552
1553       if (strncasecmp (in->ptr + idx, _("COL="), 4) == 0)
1554         {
1555           idx += 4;
1556           idx = exp_get_abs (_("form COL= needs absolute expresssion.\n"), idx, in, &columns);
1557         }
1558
1559       idx++;
1560     }
1561   fprintf (outfile, ".psize %d,%d\n", lines, columns);
1562
1563 }
1564
1565
1566 /* Fetch string from the input stream,
1567    rules:
1568     'Bxyx<whitespace>   -> return 'Bxyza
1569     %<char>             -> return string of decimal value of x
1570     "<string>"          -> return string
1571     xyx<whitespace>     -> return xyz
1572 */
1573 static int
1574 get_any_string (idx, in, out, expand, pretend_quoted)
1575      int idx;
1576      sb *in;
1577      sb *out;
1578      int expand;
1579      int pretend_quoted;
1580 {
1581   sb_reset (out);
1582   idx = sb_skip_white (idx, in);
1583
1584   if (idx < in->len)
1585     {
1586       if (in->len > 2 && in->ptr[idx+1] == '\'' && ISBASE (in->ptr[idx]))
1587         {
1588           while (!ISSEP (in->ptr[idx]))
1589             sb_add_char (out, in->ptr[idx++]);
1590         }
1591       else if (in->ptr[idx] == '%'
1592                && alternate
1593                && expand)
1594         {
1595           int val;
1596           char buf[20];
1597           /* Turns the next expression into a string */
1598           idx = exp_get_abs (_("% operator needs absolute expression"),
1599                              idx + 1,
1600                              in,
1601                              &val);
1602           sprintf(buf, "%d", val);
1603           sb_add_string (out, buf);
1604         }
1605       else if (in->ptr[idx] == '"'
1606                || in->ptr[idx] == '<'
1607                || (alternate && in->ptr[idx] == '\''))
1608         {
1609           if (alternate && expand)
1610             {
1611               /* Keep the quotes */
1612               sb_add_char (out,  '\"');
1613
1614               idx =  getstring (idx, in, out);
1615               sb_add_char (out,  '\"');
1616
1617             }
1618           else {
1619             idx = getstring (idx, in, out);
1620           }
1621         }
1622       else
1623         {
1624           while (idx < in->len
1625                  && (in->ptr[idx] == '"'
1626                      || in->ptr[idx] == '\''
1627                      || pretend_quoted
1628                      || !ISSEP (in->ptr[idx])))
1629             {
1630               if (in->ptr[idx] == '"'
1631                   || in->ptr[idx] == '\'')
1632                 {
1633                   char tchar = in->ptr[idx];
1634                   sb_add_char (out, in->ptr[idx++]);
1635                   while (idx < in->len
1636                          && in->ptr[idx] != tchar)
1637                     sb_add_char (out, in->ptr[idx++]);
1638                   if (idx == in->len)
1639                     return idx;
1640                 }
1641               sb_add_char (out, in->ptr[idx++]);
1642             }
1643         }
1644     }
1645
1646   return idx;
1647 }
1648
1649
1650 /* skip along sb in starting at idx, suck off whitespace a ( and more
1651    whitespace.  return the idx of the next char */
1652
1653 static int
1654 skip_openp (idx, in)
1655      int idx;
1656      sb *in;
1657 {
1658   idx = sb_skip_white (idx, in);
1659   if (in->ptr[idx] != '(')
1660     ERROR ((stderr, _("misplaced ( .\n")));
1661   idx = sb_skip_white (idx + 1, in);
1662   return idx;
1663 }
1664
1665 /* skip along sb in starting at idx, suck off whitespace a ) and more
1666    whitespace.  return the idx of the next char */
1667
1668 static int
1669 skip_closep (idx, in)
1670      int idx;
1671      sb *in;
1672 {
1673   idx = sb_skip_white (idx, in);
1674   if (in->ptr[idx] != ')')
1675     ERROR ((stderr, _("misplaced ).\n")));
1676   idx = sb_skip_white (idx + 1, in);
1677   return idx;
1678 }
1679
1680 /* .len */
1681
1682 static int
1683 dolen (idx, in, out)
1684      int idx;
1685      sb *in;
1686      sb *out;
1687 {
1688
1689   sb stringout;
1690   char buffer[10];
1691
1692   sb_new (&stringout);
1693   idx = skip_openp (idx, in);
1694   idx = get_and_process (idx, in, &stringout);
1695   idx = skip_closep (idx, in);
1696   sprintf (buffer, "%d", stringout.len);
1697   sb_add_string (out, buffer);
1698
1699   sb_kill (&stringout);
1700   return idx;
1701 }
1702
1703
1704 /* .instr */
1705
1706 static
1707 int
1708 doinstr (idx, in, out)
1709      int idx;
1710      sb *in;
1711      sb *out;
1712 {
1713   sb string;
1714   sb search;
1715   int i;
1716   int start;
1717   int res;
1718   char buffer[10];
1719
1720   sb_new (&string);
1721   sb_new (&search);
1722   idx = skip_openp (idx, in);
1723   idx = get_and_process (idx, in, &string);
1724   idx = sb_skip_comma (idx, in);
1725   idx = get_and_process (idx, in, &search);
1726   idx = sb_skip_comma (idx, in);
1727   if (isdigit ((unsigned char) in->ptr[idx]))
1728     {
1729       idx = exp_get_abs (_(".instr needs absolute expresson.\n"), idx, in, &start);
1730     }
1731   else
1732     {
1733       start = 0;
1734     }
1735   idx = skip_closep (idx, in);
1736   res = -1;
1737   for (i = start; i < string.len; i++)
1738     {
1739       if (strncmp (string.ptr + i, search.ptr, search.len) == 0)
1740         {
1741           res = i;
1742           break;
1743         }
1744     }
1745   sprintf (buffer, "%d", res);
1746   sb_add_string (out, buffer);
1747   sb_kill (&string);
1748   sb_kill (&search);
1749   return idx;
1750 }
1751
1752
1753 static int
1754 dosubstr (idx, in, out)
1755      int idx;
1756      sb *in;
1757      sb *out;
1758 {
1759   sb string;
1760   int pos;
1761   int len;
1762   sb_new (&string);
1763
1764   idx = skip_openp (idx, in);
1765   idx = get_and_process (idx, in, &string);
1766   idx = sb_skip_comma (idx, in);
1767   idx = exp_get_abs (_("need absolute position.\n"), idx, in, &pos);
1768   idx = sb_skip_comma (idx, in);
1769   idx = exp_get_abs (_("need absolute length.\n"), idx, in, &len);
1770   idx = skip_closep (idx, in);
1771
1772
1773   if (len < 0 || pos < 0 ||
1774       pos > string.len
1775       || pos + len > string.len)
1776     {
1777       sb_add_string (out, " ");
1778     }
1779   else
1780     {
1781       sb_add_char (out, '"');
1782       while (len > 0)
1783         {
1784           sb_add_char (out, string.ptr[pos++]);
1785           len--;
1786         }
1787       sb_add_char (out, '"');
1788     }
1789   sb_kill(&string);
1790   return idx;
1791 }
1792
1793 /* scan line, change tokens in the hash table to their replacements */
1794 static void
1795 process_assigns (idx, in, buf)
1796      int idx;
1797      sb *in;
1798      sb *buf;
1799 {
1800   while (idx < in->len)
1801     {
1802       hash_entry *ptr;
1803       if (in->ptr[idx] == '\\'
1804           && idx + 1 < in->len
1805           && in->ptr[idx + 1] == '(')
1806         {
1807           do
1808             {
1809               sb_add_char (buf, in->ptr[idx]);
1810               idx++;
1811             }
1812           while (idx < in->len && in->ptr[idx - 1] != ')');
1813         }
1814       else if (in->ptr[idx] == '\\'
1815           && idx + 1 < in->len
1816           && in->ptr[idx + 1] == '&')
1817         {
1818           idx = condass_lookup_name (in, idx + 2, buf, 1);
1819         }
1820       else if (in->ptr[idx] == '\\'
1821                && idx + 1 < in->len
1822                && in->ptr[idx + 1] == '$')
1823         {
1824           idx = condass_lookup_name (in, idx + 2, buf, 0);
1825         }
1826       else if (idx + 3 < in->len
1827                && in->ptr[idx] == '.'
1828                && toupper ((unsigned char) in->ptr[idx + 1]) == 'L'
1829                && toupper ((unsigned char) in->ptr[idx + 2]) == 'E'
1830                && toupper ((unsigned char) in->ptr[idx + 3]) == 'N')
1831         idx = dolen (idx + 4, in, buf);
1832       else if (idx + 6 < in->len
1833                && in->ptr[idx] == '.'
1834                && toupper ((unsigned char) in->ptr[idx + 1]) == 'I'
1835                && toupper ((unsigned char) in->ptr[idx + 2]) == 'N'
1836                && toupper ((unsigned char) in->ptr[idx + 3]) == 'S'
1837                && toupper ((unsigned char) in->ptr[idx + 4]) == 'T'
1838                && toupper ((unsigned char) in->ptr[idx + 5]) == 'R')
1839         idx = doinstr (idx + 6, in, buf);
1840       else if (idx + 7 < in->len
1841                && in->ptr[idx] == '.'
1842                && toupper ((unsigned char) in->ptr[idx + 1]) == 'S'
1843                && toupper ((unsigned char) in->ptr[idx + 2]) == 'U'
1844                && toupper ((unsigned char) in->ptr[idx + 3]) == 'B'
1845                && toupper ((unsigned char) in->ptr[idx + 4]) == 'S'
1846                && toupper ((unsigned char) in->ptr[idx + 5]) == 'T'
1847                && toupper ((unsigned char) in->ptr[idx + 6]) == 'R')
1848         idx = dosubstr (idx + 7, in, buf);
1849       else if (ISFIRSTCHAR (in->ptr[idx]))
1850         {
1851           /* may be a simple name subsitution, see if we have a word */
1852           sb acc;
1853           int cur = idx + 1;
1854           while (cur < in->len
1855                  && (ISNEXTCHAR (in->ptr[cur])))
1856             cur++;
1857
1858           sb_new (&acc);
1859           sb_add_buffer (&acc, in->ptr + idx, cur - idx);
1860           ptr = hash_lookup (&assign_hash_table, &acc);
1861           if (ptr)
1862             {
1863               /* Found a definition for it */
1864               sb_add_sb (buf, &ptr->value.s);
1865             }
1866           else
1867             {
1868               /* No definition, just copy the word */
1869               sb_add_sb (buf, &acc);
1870             }
1871           sb_kill (&acc);
1872           idx = cur;
1873         }
1874       else
1875         {
1876           sb_add_char (buf, in->ptr[idx++]);
1877         }
1878     }
1879 }
1880
1881 static int
1882 get_and_process (idx, in, out)
1883      int idx;
1884      sb *in;
1885      sb *out;
1886 {
1887   sb t;
1888   sb_new (&t);
1889   idx = get_any_string (idx, in, &t, 1, 0);
1890   process_assigns (0, &t, out);
1891   sb_kill (&t);
1892   return idx;
1893 }
1894
1895 static
1896 void
1897 process_file ()
1898 {
1899   sb line;
1900   sb t1, t2;
1901   sb acc;
1902   sb label_in;
1903   int more;
1904
1905   sb_new (&line);
1906   sb_new (&t1);
1907   sb_new (&t2);
1908   sb_new(&acc);
1909   sb_new (&label_in);
1910   sb_reset (&line);
1911   more = get_line (&line);
1912   while (more)
1913     {
1914       /* Find any label and pseudo op that we're intested in */
1915       int l;
1916       if (line.len == 0)
1917         {
1918           if (condass_on ())
1919             fprintf (outfile, "\n");
1920         }
1921       else if (mri
1922                && (line.ptr[0] == '*'
1923                    || line.ptr[0] == '!'))
1924         {
1925           /* MRI line comment.  */
1926           fprintf (outfile, "%s", sb_name (&line));
1927         }
1928       else
1929         {
1930           l = grab_label (&line, &label_in);
1931           sb_reset (&label);
1932
1933           if (line.ptr[l] == ':')
1934             l++;
1935           while (ISWHITE (line.ptr[l]) && l < line.len)
1936             l++;
1937
1938           if (label_in.len)
1939             {
1940               int do_assigns;
1941
1942               /* Munge the label, unless this is EQU or ASSIGN.  */
1943               do_assigns = 1;
1944               if (l < line.len
1945                   && (line.ptr[l] == '.' || alternate || mri))
1946                 {
1947                   int lx = l;
1948
1949                   if (line.ptr[lx] == '.')
1950                     ++lx;
1951                   if (lx + 3 <= line.len
1952                       && strncasecmp ("EQU", line.ptr + lx, 3) == 0
1953                       && (lx + 3 == line.len
1954                           || ! ISFIRSTCHAR (line.ptr[lx + 3])))
1955                     do_assigns = 0;
1956                   else if (lx + 6 <= line.len
1957                            && strncasecmp ("ASSIGN", line.ptr + lx, 6) == 0
1958                            && (lx + 6 == line.len
1959                                || ! ISFIRSTCHAR (line.ptr[lx + 6])))
1960                     do_assigns = 0;
1961                 }
1962
1963               if (do_assigns)
1964                 process_assigns (0, &label_in, &label);
1965               else
1966                 sb_add_sb (&label, &label_in);
1967             }
1968
1969           if (l < line.len)
1970             {
1971               if (process_pseudo_op (l, &line, &acc))
1972                 {
1973
1974
1975
1976                 }
1977               else if (condass_on ())
1978                 {
1979                   if (macro_op (l, &line))
1980                     {
1981
1982
1983                     }
1984                   else
1985                     {
1986                       {
1987                         if (label.len)
1988                           {
1989                             fprintf (outfile, "%s:\t", sb_name (&label));
1990                           }
1991                         else
1992                           fprintf (outfile, "\t");
1993                         sb_reset(&t1);
1994                         process_assigns (l, &line, &t1);
1995                         sb_reset (&t2);
1996                         change_base (0, &t1, &t2);
1997                         fprintf (outfile, "%s\n", sb_name (&t2));
1998                       }
1999                     }
2000                 }
2001             }
2002           else {
2003             /* Only a label on this line */
2004             if (label.len && condass_on())
2005               {
2006                 fprintf (outfile, "%s:\n", sb_name (&label));
2007               }
2008           }
2009         }
2010
2011       if (had_end)
2012         break;
2013       sb_reset (&line);
2014       more = get_line (&line);
2015     }
2016
2017   if (!had_end && !mri)
2018     WARNING ((stderr, _("END missing from end of file.\n")));
2019 }
2020
2021
2022
2023
2024
2025 static void
2026 free_old_entry (ptr)
2027      hash_entry *ptr;
2028 {
2029   if (ptr)
2030     {
2031       if (ptr->type == hash_string)
2032         sb_kill(&ptr->value.s);
2033     }
2034 }
2035
2036 /* name: .ASSIGNA <value> */
2037
2038 static void
2039 do_assigna (idx, in)
2040      int idx;
2041      sb *in;
2042 {
2043   sb tmp;
2044   int val;
2045   sb_new (&tmp);
2046
2047   process_assigns (idx, in, &tmp);
2048   idx = exp_get_abs (_(".ASSIGNA needs constant expression argument.\n"), 0, &tmp, &val);
2049
2050   if (!label.len)
2051     {
2052       ERROR ((stderr, _(".ASSIGNA without label.\n")));
2053     }
2054   else
2055     {
2056       hash_entry *ptr = hash_create (&vars, &label);
2057       free_old_entry (ptr);
2058       ptr->type = hash_integer;
2059       ptr->value.i = val;
2060     }
2061   sb_kill (&tmp);
2062 }
2063
2064 /* name: .ASSIGNC <string> */
2065
2066 static void
2067 do_assignc (idx, in)
2068      int idx;
2069      sb *in;
2070 {
2071   sb acc;
2072   sb_new (&acc);
2073   idx = getstring (idx, in, &acc);
2074
2075   if (!label.len)
2076     {
2077       ERROR ((stderr, _(".ASSIGNS without label.\n")));
2078     }
2079   else
2080     {
2081       hash_entry *ptr = hash_create (&vars, &label);
2082       free_old_entry (ptr);
2083       ptr->type = hash_string;
2084       sb_new (&ptr->value.s);
2085       sb_add_sb (&ptr->value.s, &acc);
2086     }
2087   sb_kill (&acc);
2088 }
2089
2090
2091 /* name: .REG (reg) */
2092
2093 static void
2094 do_reg (idx, in)
2095      int idx;
2096      sb *in;
2097 {
2098   /* remove reg stuff from inside parens */
2099   sb what;
2100   if (!mri)
2101     idx = skip_openp (idx, in);
2102   else
2103     idx = sb_skip_white (idx, in);
2104   sb_new (&what);
2105   while (idx < in->len
2106          && (mri
2107              ? ! eol (idx, in)
2108              : in->ptr[idx] != ')'))
2109     {
2110       sb_add_char (&what, in->ptr[idx]);
2111       idx++;
2112     }
2113   hash_add_to_string_table (&assign_hash_table, &label, &what, 1);
2114   sb_kill (&what);
2115 }
2116
2117
2118 static int
2119 condass_lookup_name (inbuf, idx, out, warn)
2120      sb *inbuf;
2121      int idx;
2122      sb *out;
2123      int warn;
2124 {
2125   hash_entry *ptr;
2126   sb condass_acc;
2127   sb_new (&condass_acc);
2128
2129   while (idx < inbuf->len
2130          && ISNEXTCHAR (inbuf->ptr[idx]))
2131     {
2132       sb_add_char (&condass_acc, inbuf->ptr[idx++]);
2133     }
2134
2135   if (inbuf->ptr[idx] == '\'')
2136     idx++;
2137   ptr = hash_lookup (&vars, &condass_acc);
2138
2139
2140   if (!ptr)
2141     {
2142       if (warn)
2143         {
2144           WARNING ((stderr, _("Can't find preprocessor variable %s.\n"), sb_name (&condass_acc)));
2145         }
2146       else
2147         {
2148           sb_add_string (out, "0");
2149         }
2150     }
2151   else
2152     {
2153       if (ptr->type == hash_integer)
2154         {
2155           char buffer[30];
2156           sprintf (buffer, "%d", ptr->value.i);
2157           sb_add_string (out, buffer);
2158         }
2159       else
2160         {
2161           sb_add_sb (out, &ptr->value.s);
2162         }
2163     }
2164   sb_kill (&condass_acc);
2165   return idx;
2166 }
2167
2168 #define EQ 1
2169 #define NE 2
2170 #define GE 3
2171 #define LT 4
2172 #define LE 5
2173 #define GT 6
2174 #define NEVER 7
2175
2176 static int
2177 whatcond (idx, in, val)
2178      int idx;
2179      sb *in;
2180      int *val;
2181 {
2182   int cond;
2183
2184   idx = sb_skip_white (idx, in);
2185   cond = NEVER;
2186   if (idx + 1 < in->len)
2187     {
2188       char *p;
2189       char a, b;
2190
2191       p = in->ptr + idx;
2192       a = toupper ((unsigned char) p[0]);
2193       b = toupper ((unsigned char) p[1]);
2194       if (a == 'E' && b == 'Q')
2195         cond = EQ;
2196       else if (a == 'N' && b == 'E')
2197         cond = NE;
2198       else if (a == 'L' && b == 'T')
2199         cond = LT;
2200       else if (a == 'L' && b == 'E')
2201         cond = LE;
2202       else if (a == 'G' && b == 'T')
2203         cond = GT;
2204       else if (a == 'G' && b == 'E')
2205         cond = GE;
2206     }
2207   if (cond == NEVER)
2208     {
2209       ERROR ((stderr, _("Comparison operator must be one of EQ, NE, LT, LE, GT or GE.\n")));
2210       cond = NEVER;
2211     }
2212   idx = sb_skip_white (idx + 2, in);
2213   *val = cond;
2214   return idx;
2215 }
2216
2217 static int
2218 istrue (idx, in)
2219      int idx;
2220      sb *in;
2221 {
2222   int res;
2223   sb acc_a;
2224   sb cond;
2225   sb acc_b;
2226   sb_new (&acc_a);
2227   sb_new (&cond);
2228   sb_new (&acc_b);
2229   idx = sb_skip_white (idx, in);
2230
2231   if (in->ptr[idx] == '"')
2232     {
2233       int cond;
2234       int same;
2235       /* This is a string comparision */
2236       idx = getstring (idx, in, &acc_a);
2237       idx = whatcond (idx, in, &cond);
2238       idx = getstring (idx, in, &acc_b);
2239       same = acc_a.len == acc_b.len && (strncmp (acc_a.ptr, acc_b.ptr, acc_a.len) == 0);
2240
2241       if (cond != EQ && cond != NE)
2242         {
2243           ERROR ((stderr, _("Comparison operator for strings must be EQ or NE\n")));
2244           res = 0;
2245         }
2246       else
2247         res = (cond != EQ) ^ same;
2248     }
2249   else
2250     /* This is a numeric expression */
2251     {
2252       int vala;
2253       int valb;
2254       int cond;
2255       idx = exp_get_abs (_("Conditional operator must have absolute operands.\n"), idx, in, &vala);
2256       idx = whatcond (idx, in, &cond);
2257       idx = sb_skip_white (idx, in);
2258       if (in->ptr[idx] == '"')
2259         {
2260           WARNING ((stderr, _("String compared against expression.\n")));
2261           res = 0;
2262         }
2263       else
2264         {
2265           idx = exp_get_abs (_("Conditional operator must have absolute operands.\n"), idx, in, &valb);
2266           switch (cond)
2267             {
2268             default:
2269               res = 42;
2270               break;
2271             case EQ:
2272               res = vala == valb;
2273               break;
2274             case NE:
2275               res = vala != valb;
2276               break;
2277             case LT:
2278               res = vala < valb;
2279               break;
2280             case LE:
2281               res = vala <= valb;
2282               break;
2283             case GT:
2284               res = vala > valb;
2285               break;
2286             case GE:
2287               res = vala >= valb;
2288               break;
2289             case NEVER:
2290               res = 0;
2291               break;
2292             }
2293         }
2294     }
2295
2296   sb_kill (&acc_a);
2297   sb_kill (&cond);
2298   sb_kill (&acc_b);
2299   return res;
2300 }
2301
2302 /* .AIF */
2303 static void
2304 do_aif (idx, in)
2305      int idx;
2306      sb *in;
2307 {
2308   if (ifi >= IFNESTING)
2309     {
2310       FATAL ((stderr, _("AIF nesting unreasonable.\n")));
2311     }
2312   ifi++;
2313   ifstack[ifi].on = ifstack[ifi-1].on ? istrue (idx, in) : 0;
2314   ifstack[ifi].hadelse = 0;
2315 }
2316
2317
2318 /* .AELSE */
2319 static void
2320 do_aelse ()
2321 {
2322   ifstack[ifi].on = ifstack[ifi-1].on ? !ifstack[ifi].on : 0;
2323   if (ifstack[ifi].hadelse)
2324     {
2325       ERROR ((stderr, _("Multiple AELSEs in AIF.\n")));
2326     }
2327   ifstack[ifi].hadelse = 1;
2328 }
2329
2330
2331 /* .AENDI */
2332 static void
2333 do_aendi ()
2334 {
2335   if (ifi != 0)
2336     {
2337       ifi--;
2338     }
2339   else
2340     {
2341       ERROR ((stderr, _("AENDI without AIF.\n")));
2342     }
2343 }
2344
2345 static int
2346 condass_on ()
2347 {
2348   return ifstack[ifi].on;
2349 }
2350
2351 /* MRI IFEQ, IFNE, IFLT, IFLE, IFGE, IFGT.  */
2352
2353 static void
2354 do_if (idx, in, cond)
2355      int idx;
2356      sb *in;
2357      int cond;
2358 {
2359   int val;
2360   int res;
2361
2362   if (ifi >= IFNESTING)
2363     {
2364       FATAL ((stderr, _("IF nesting unreasonable.\n")));
2365     }
2366
2367   idx = exp_get_abs (_("Conditional operator must have absolute operands.\n"),
2368                      idx, in, &val);
2369   switch (cond)
2370     {
2371     default:
2372     case EQ: res = val == 0; break;
2373     case NE: res = val != 0; break;
2374     case LT: res = val <  0; break;
2375     case LE: res = val <= 0; break;
2376     case GE: res = val >= 0; break;
2377     case GT: res = val >  0; break;
2378     }
2379
2380   ifi++;
2381   ifstack[ifi].on = ifstack[ifi-1].on ? res: 0;
2382   ifstack[ifi].hadelse = 0;
2383 }
2384
2385 /* Get a string for the MRI IFC or IFNC pseudo-ops.  */
2386
2387 static int
2388 get_mri_string (idx, in, val, terminator)
2389      int idx;
2390      sb *in;
2391      sb *val;
2392      int terminator;
2393 {
2394   idx = sb_skip_white (idx, in);
2395
2396   if (idx < in->len
2397       && in->ptr[idx] == '\'')
2398     {
2399       sb_add_char (val, '\'');
2400       for (++idx; idx < in->len; ++idx)
2401         {
2402           sb_add_char (val, in->ptr[idx]);
2403           if (in->ptr[idx] == '\'')
2404             {
2405               ++idx;
2406               if (idx >= in->len
2407                   || in->ptr[idx] != '\'')
2408                 break;
2409             }
2410         }
2411       idx = sb_skip_white (idx, in);
2412     }
2413   else
2414     {
2415       int i;
2416
2417       while (idx < in->len
2418              && in->ptr[idx] != terminator)
2419         {
2420           sb_add_char (val, in->ptr[idx]);
2421           ++idx;
2422         }
2423       i = val->len - 1;
2424       while (i >= 0 && ISWHITE (val->ptr[i]))
2425         --i;
2426       val->len = i + 1;
2427     }
2428
2429   return idx;
2430 }
2431
2432 /* MRI IFC, IFNC.  */
2433
2434 static void
2435 do_ifc (idx, in, ifnc)
2436      int idx;
2437      sb *in;
2438      int ifnc;
2439 {
2440   sb first;
2441   sb second;
2442   int res;
2443
2444   if (ifi >= IFNESTING)
2445     {
2446       FATAL ((stderr, _("IF nesting unreasonable.\n")));
2447     }
2448
2449   sb_new (&first);
2450   sb_new (&second);
2451
2452   idx = get_mri_string (idx, in, &first, ',');
2453
2454   if (idx >= in->len || in->ptr[idx] != ',')
2455     {
2456       ERROR ((stderr, _("Bad format for IF or IFNC.\n")));
2457       return;
2458     }
2459
2460   idx = get_mri_string (idx + 1, in, &second, ';');
2461
2462   res = (first.len == second.len
2463          && strncmp (first.ptr, second.ptr, first.len) == 0);
2464   res ^= ifnc;
2465
2466   ifi++;
2467   ifstack[ifi].on = ifstack[ifi-1].on ? res : 0;
2468   ifstack[ifi].hadelse = 0;
2469 }
2470
2471 /* .ENDR */
2472 static void
2473 do_aendr ()
2474 {
2475   if (!mri)
2476     ERROR ((stderr, _("AENDR without a AREPEAT.\n")));
2477   else
2478     ERROR ((stderr, _("ENDR without a REPT.\n")));
2479 }
2480
2481 /* .AWHILE */
2482
2483 static
2484 void
2485 do_awhile (idx, in)
2486      int idx;
2487      sb *in;
2488 {
2489   int line = linecount ();
2490   sb exp;
2491   sb sub;
2492   int doit;
2493
2494   sb_new (&sub);
2495   sb_new (&exp);
2496
2497   process_assigns (idx, in, &exp);
2498   doit = istrue (0, &exp);
2499
2500   if (! buffer_and_nest ("AWHILE", "AENDW", &sub, get_line))
2501     FATAL ((stderr, _("AWHILE without a AENDW at %d.\n"), line - 1));
2502
2503   /* Turn
2504         .AWHILE exp
2505              foo
2506         .AENDW
2507      into
2508         foo
2509         .AWHILE exp
2510         foo
2511         .ENDW
2512    */
2513
2514   if (doit)
2515     {
2516       int index = include_next_index ();
2517
2518       sb copy;
2519       sb_new (&copy);
2520       sb_add_sb (&copy, &sub);
2521       sb_add_sb (&copy, in);
2522       sb_add_string (&copy, "\n");
2523       sb_add_sb (&copy, &sub);
2524       sb_add_string (&copy, "\t.AENDW\n");
2525       /* Push another WHILE */
2526       include_buf (&exp, &copy, include_while, index);
2527       sb_kill (&copy);
2528     }
2529   sb_kill (&exp);
2530   sb_kill (&sub);
2531 }
2532
2533
2534 /* .AENDW */
2535
2536 static void
2537 do_aendw ()
2538 {
2539   ERROR ((stderr, _("AENDW without a AENDW.\n")));
2540 }
2541
2542
2543 /* .EXITM
2544
2545    Pop things off the include stack until the type and index changes */
2546
2547 static void
2548 do_exitm ()
2549 {
2550   include_type type = sp->type;
2551   if (type == include_repeat
2552       || type == include_while
2553       || type == include_macro)
2554     {
2555       int index = sp->index;
2556       include_pop ();
2557       while (sp->index == index
2558              && sp->type == type)
2559         {
2560           include_pop ();
2561         }
2562     }
2563 }
2564
2565 /* .AREPEAT */
2566
2567 static void
2568 do_arepeat (idx, in)
2569      int idx;
2570      sb *in;
2571 {
2572   int line = linecount ();
2573   sb exp;                       /* buffer with expression in it */
2574   sb copy;                      /* expanded repeat block */
2575   sb sub;                       /* contents of AREPEAT */
2576   int rc;
2577   int ret;
2578   char buffer[30];
2579
2580   sb_new (&exp);
2581   sb_new (&copy);
2582   sb_new (&sub);
2583   process_assigns (idx, in, &exp);
2584   idx = exp_get_abs (_("AREPEAT must have absolute operand.\n"), 0, &exp, &rc);
2585   if (!mri)
2586     ret = buffer_and_nest ("AREPEAT", "AENDR", &sub, get_line);
2587   else
2588     ret = buffer_and_nest ("REPT", "ENDR", &sub, get_line);
2589   if (! ret)
2590     FATAL ((stderr, _("AREPEAT without a AENDR at %d.\n"), line - 1));
2591   if (rc > 0)
2592     {
2593       /* Push back the text following the repeat, and another repeat block
2594          so
2595          .AREPEAT 20
2596          foo
2597          .AENDR
2598          gets turned into
2599          foo
2600          .AREPEAT 19
2601          foo
2602          .AENDR
2603          */
2604       int index = include_next_index ();
2605       sb_add_sb (&copy, &sub);
2606       if (rc > 1)
2607         {
2608           if (!mri)
2609             sprintf (buffer, "\t.AREPEAT        %d\n", rc - 1);
2610           else
2611             sprintf (buffer, "\tREPT    %d\n", rc - 1);
2612           sb_add_string (&copy, buffer);
2613           sb_add_sb (&copy, &sub);
2614           if (!mri)
2615             sb_add_string (&copy, "     .AENDR\n");
2616           else
2617             sb_add_string (&copy, "     ENDR\n");
2618         }
2619
2620       include_buf (&exp, &copy, include_repeat, index);
2621     }
2622   sb_kill (&exp);
2623   sb_kill (&sub);
2624   sb_kill (&copy);
2625 }
2626
2627 /* .ENDM */
2628
2629 static void
2630 do_endm ()
2631 {
2632   ERROR ((stderr, _(".ENDM without a matching .MACRO.\n")));
2633 }
2634
2635 /* MRI IRP pseudo-op.  */
2636
2637 static void
2638 do_irp (idx, in, irpc)
2639      int idx;
2640      sb *in;
2641      int irpc;
2642 {
2643   const char *err;
2644   sb out;
2645
2646   sb_new (&out);
2647
2648   err = expand_irp (irpc, idx, in, &out, get_line, comment_char);
2649   if (err != NULL)
2650     ERROR ((stderr, "%s\n", err));
2651
2652   fprintf (outfile, "%s", sb_terminate (&out));
2653
2654   sb_kill (&out);
2655 }
2656
2657 /* MACRO PROCESSING */
2658
2659 /* Parse off LOCAL n1, n2,... Invent a label name for it */
2660 static
2661 void
2662 do_local (idx, line)
2663      int idx ATTRIBUTE_UNUSED;
2664      sb *line ATTRIBUTE_UNUSED;
2665 {
2666   ERROR ((stderr, _("LOCAL outside of MACRO")));
2667 }
2668
2669 static void
2670 do_macro (idx, in)
2671      int idx;
2672      sb *in;
2673 {
2674   const char *err;
2675   int line = linecount ();
2676
2677   err = define_macro (idx, in, &label, get_line, (const char **) NULL);
2678   if (err != NULL)
2679     ERROR ((stderr, _("macro at line %d: %s\n"), line - 1, err));
2680 }
2681
2682 static int
2683 macro_op (idx, in)
2684      int idx;
2685      sb *in;
2686 {
2687   const char *err;
2688   sb out;
2689   sb name;
2690
2691   if (! macro_defined)
2692     return 0;
2693
2694   sb_terminate (in);
2695   if (! check_macro (in->ptr + idx, &out, comment_char, &err))
2696     return 0;
2697
2698   if (err != NULL)
2699     ERROR ((stderr, "%s\n", err));
2700
2701   sb_new (&name);
2702   sb_add_string (&name, _("macro expansion"));
2703
2704   include_buf (&name, &out, include_macro, include_next_index ());
2705
2706   sb_kill (&name);
2707   sb_kill (&out);
2708
2709   return 1;
2710 }
2711
2712 /* STRING HANDLING */
2713
2714 static int
2715 getstring (idx, in, acc)
2716      int idx;
2717      sb *in;
2718      sb *acc;
2719 {
2720   idx = sb_skip_white (idx, in);
2721
2722   while (idx < in->len
2723          && (in->ptr[idx] == '"'
2724              || in->ptr[idx] == '<'
2725              || (in->ptr[idx] == '\'' && alternate)))
2726     {
2727       if (in->ptr[idx] == '<')
2728         {
2729           if (alternate || mri)
2730             {
2731               int nest = 0;
2732               idx++;
2733               while ((in->ptr[idx] != '>' || nest)
2734                      && idx < in->len)
2735                 {
2736                   if (in->ptr[idx] == '!')
2737                     {
2738                       idx++  ;
2739                       sb_add_char (acc, in->ptr[idx++]);
2740                     }
2741                   else {
2742                     if (in->ptr[idx] == '>')
2743                       nest--;
2744                     if (in->ptr[idx] == '<')
2745                       nest++;
2746                     sb_add_char (acc, in->ptr[idx++]);
2747                   }
2748                 }
2749               idx++;
2750             }
2751           else {
2752             int code;
2753             idx++;
2754             idx = exp_get_abs (_("Character code in string must be absolute expression.\n"),
2755                                idx, in, &code);
2756             sb_add_char (acc, code);
2757
2758             if (in->ptr[idx] != '>')
2759               ERROR ((stderr, _("Missing > for character code.\n")));
2760             idx++;
2761           }
2762         }
2763       else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'')
2764         {
2765           char tchar = in->ptr[idx];
2766           idx++;
2767           while (idx < in->len)
2768             {
2769               if (alternate && in->ptr[idx] == '!')
2770                 {
2771                   idx++  ;
2772                   sb_add_char (acc, in->ptr[idx++]);
2773                 }
2774               else {
2775                 if (in->ptr[idx] == tchar)
2776                   {
2777                     idx++;
2778                     if (idx >= in->len || in->ptr[idx] != tchar)
2779                       break;
2780                   }
2781                 sb_add_char (acc, in->ptr[idx]);
2782                 idx++;
2783               }
2784             }
2785         }
2786     }
2787
2788   return idx;
2789 }
2790
2791 /* .SDATA[C|Z] <string> */
2792
2793 static
2794 void
2795 do_sdata (idx, in, type)
2796      int idx;
2797      sb *in;
2798      int type;
2799 {
2800   int nc = 0;
2801   int pidx = -1;
2802   sb acc;
2803   sb_new (&acc);
2804   fprintf (outfile, ".byte\t");
2805
2806   while (!eol (idx, in))
2807     {
2808       int i;
2809       sb_reset (&acc);
2810       idx = sb_skip_white (idx, in);
2811       while (!eol (idx, in))
2812         {
2813           pidx = idx = get_any_string (idx, in, &acc, 0, 1);
2814           if (type == 'c')
2815             {
2816               if (acc.len > 255)
2817                 {
2818                   ERROR ((stderr, _("string for SDATAC longer than 255 characters (%d).\n"), acc.len));
2819                 }
2820               fprintf (outfile, "%d", acc.len);
2821               nc = 1;
2822             }
2823
2824           for (i = 0; i < acc.len; i++)
2825             {
2826               if (nc)
2827                 {
2828                   fprintf (outfile, ",");
2829                 }
2830               fprintf (outfile, "%d", acc.ptr[i]);
2831               nc = 1;
2832             }
2833
2834           if (type == 'z')
2835             {
2836               if (nc)
2837                 fprintf (outfile, ",");
2838               fprintf (outfile, "0");
2839             }
2840           idx = sb_skip_comma (idx, in);
2841           if (idx == pidx) break;
2842         }
2843       if (!alternate && in->ptr[idx] != ',' && idx != in->len)
2844         {
2845           fprintf (outfile, "\n");
2846           ERROR ((stderr, _("illegal character in SDATA line (0x%x).\n"), in->ptr[idx]));
2847           break;
2848         }
2849       idx++;
2850     }
2851   sb_kill (&acc);
2852   fprintf (outfile, "\n");
2853 }
2854
2855 /* .SDATAB <count> <string> */
2856
2857 static void
2858 do_sdatab (idx, in)
2859      int idx;
2860      sb *in;
2861 {
2862   int repeat;
2863   int i;
2864   sb acc;
2865   sb_new (&acc);
2866
2867   idx = exp_get_abs (_("Must have absolute SDATAB repeat count.\n"), idx, in, &repeat);
2868   if (repeat <= 0)
2869     {
2870       ERROR ((stderr, _("Must have positive SDATAB repeat count (%d).\n"), repeat));
2871       repeat = 1;
2872     }
2873
2874   idx = sb_skip_comma (idx, in);
2875   idx = getstring (idx, in, &acc);
2876
2877   for (i = 0; i < repeat; i++)
2878     {
2879       if (i)
2880         fprintf (outfile, "\t");
2881       fprintf (outfile, ".byte\t");
2882       sb_print (outfile, &acc);
2883       fprintf (outfile, "\n");
2884     }
2885   sb_kill (&acc);
2886
2887 }
2888
2889 static int
2890 new_file (name)
2891      const char *name;
2892 {
2893   FILE *newone = fopen (name, "r");
2894   if (!newone)
2895     return 0;
2896
2897   if (isp == MAX_INCLUDES)
2898     FATAL ((stderr, _("Unreasonable include depth (%ld).\n"), (long) isp));
2899
2900   sp++;
2901   sp->handle = newone;
2902
2903   sb_new (&sp->name);
2904   sb_add_string (&sp->name, name);
2905
2906   sp->linecount = 1;
2907   sp->pushback_index = 0;
2908   sp->type = include_file;
2909   sp->index = 0;
2910   sb_new (&sp->pushback);
2911   return 1;
2912 }
2913
2914 static void
2915 do_include (idx, in)
2916      int idx;
2917      sb *in;
2918 {
2919   sb t;
2920   sb cat;
2921   include_path *includes;
2922
2923   sb_new (&t);
2924   sb_new (&cat);
2925
2926   if (! mri)
2927     idx = getstring (idx, in, &t);
2928   else
2929     {
2930       idx = sb_skip_white (idx, in);
2931       while (idx < in->len && ! ISWHITE (in->ptr[idx]))
2932         {
2933           sb_add_char (&t, in->ptr[idx]);
2934           ++idx;
2935         }
2936     }
2937
2938   for (includes = paths_head; includes; includes = includes->next)
2939     {
2940       sb_reset (&cat);
2941       sb_add_sb (&cat, &includes->path);
2942       sb_add_char (&cat, '/');
2943       sb_add_sb (&cat, &t);
2944       if (new_file (sb_name (&cat)))
2945         {
2946           break;
2947         }
2948     }
2949   if (!includes)
2950     {
2951       if (! new_file (sb_name (&t)))
2952         FATAL ((stderr, _("Can't open include file `%s'.\n"), sb_name (&t)));
2953     }
2954   sb_kill (&cat);
2955   sb_kill (&t);
2956 }
2957
2958 static void
2959 include_pop ()
2960 {
2961   if (sp != include_stack)
2962     {
2963       if (sp->handle)
2964         fclose (sp->handle);
2965       sp--;
2966     }
2967 }
2968
2969 /* Get the next character from the include stack.  If there's anything
2970    in the pushback buffer, take that first.  If we're at eof, pop from
2971    the stack and try again.  Keep the linecount up to date. */
2972
2973 static int
2974 get ()
2975 {
2976   int r;
2977
2978   if (sp->pushback.len != sp->pushback_index)
2979     {
2980       r = (char) (sp->pushback.ptr[sp->pushback_index++]);
2981       /* When they've all gone, reset the pointer */
2982       if (sp->pushback_index == sp->pushback.len)
2983         {
2984           sp->pushback.len = 0;
2985           sp->pushback_index = 0;
2986         }
2987     }
2988   else if (sp->handle)
2989     {
2990       r = getc (sp->handle);
2991     }
2992   else
2993     r = EOF;
2994
2995   if (r == EOF && isp)
2996     {
2997       include_pop ();
2998       r = get ();
2999       while (r == EOF && isp)
3000         {
3001           include_pop ();
3002           r = get ();
3003         }
3004       return r;
3005     }
3006   if (r == '\n')
3007     {
3008       sp->linecount++;
3009     }
3010
3011   return r;
3012 }
3013
3014 static int
3015 linecount ()
3016 {
3017   return sp->linecount;
3018 }
3019
3020 static int
3021 include_next_index ()
3022 {
3023   static int index;
3024   if (!unreasonable
3025       && index > MAX_REASONABLE)
3026     FATAL ((stderr, _("Unreasonable expansion (-u turns off check).\n")));
3027   return ++index;
3028 }
3029
3030
3031 /* Initialize the chartype vector. */
3032
3033 static void
3034 chartype_init ()
3035 {
3036   int x;
3037   for (x = 0; x < 256; x++)
3038     {
3039       if (isalpha (x) || x == '_' || x == '$')
3040         chartype[x] |= FIRSTBIT;
3041
3042       if (mri && x == '.')
3043         chartype[x] |= FIRSTBIT;
3044
3045       if (isdigit (x) || isalpha (x) || x == '_' || x == '$')
3046         chartype[x] |= NEXTBIT;
3047
3048       if (x == ' ' || x == '\t' || x == ',' || x == '"' || x == ';'
3049           || x == '"' || x == '<' || x == '>' || x == ')' || x == '(')
3050         chartype[x] |= SEPBIT;
3051
3052       if (x == 'b' || x == 'B'
3053           || x == 'q' || x == 'Q'
3054           || x == 'h' || x == 'H'
3055           || x == 'd' || x == 'D')
3056         chartype [x] |= BASEBIT;
3057
3058       if (x == ' ' || x == '\t')
3059         chartype[x] |= WHITEBIT;
3060
3061       if (x == comment_char)
3062         chartype[x] |= COMMENTBIT;
3063     }
3064 }
3065
3066
3067
3068 /* What to do with all the keywords */
3069 #define PROCESS         0x1000  /* Run substitution over the line */
3070 #define LAB             0x2000  /* Spit out the label */
3071
3072 #define K_EQU           (PROCESS|1)
3073 #define K_ASSIGN        (PROCESS|2)
3074 #define K_REG           (PROCESS|3)
3075 #define K_ORG           (PROCESS|4)
3076 #define K_RADIX         (PROCESS|5)
3077 #define K_DATA          (LAB|PROCESS|6)
3078 #define K_DATAB         (LAB|PROCESS|7)
3079 #define K_SDATA         (LAB|PROCESS|8)
3080 #define K_SDATAB        (LAB|PROCESS|9)
3081 #define K_SDATAC        (LAB|PROCESS|10)
3082 #define K_SDATAZ        (LAB|PROCESS|11)
3083 #define K_RES           (LAB|PROCESS|12)
3084 #define K_SRES          (LAB|PROCESS|13)
3085 #define K_SRESC         (LAB|PROCESS|14)
3086 #define K_SRESZ         (LAB|PROCESS|15)
3087 #define K_EXPORT        (LAB|PROCESS|16)
3088 #define K_GLOBAL        (LAB|PROCESS|17)
3089 #define K_PRINT         (LAB|PROCESS|19)
3090 #define K_FORM          (LAB|PROCESS|20)
3091 #define K_HEADING       (LAB|PROCESS|21)
3092 #define K_PAGE          (LAB|PROCESS|22)
3093 #define K_IMPORT        (LAB|PROCESS|23)
3094 #define K_PROGRAM       (LAB|PROCESS|24)
3095 #define K_END           (PROCESS|25)
3096 #define K_INCLUDE       (PROCESS|26)
3097 #define K_IGNORED       (PROCESS|27)
3098 #define K_ASSIGNA       (PROCESS|28)
3099 #define K_ASSIGNC       (29)
3100 #define K_AIF           (PROCESS|30)
3101 #define K_AELSE         (PROCESS|31)
3102 #define K_AENDI         (PROCESS|32)
3103 #define K_AREPEAT       (PROCESS|33)
3104 #define K_AENDR         (PROCESS|34)
3105 #define K_AWHILE        (35)
3106 #define K_AENDW         (PROCESS|36)
3107 #define K_EXITM         (37)
3108 #define K_MACRO         (PROCESS|38)
3109 #define K_ENDM          (39)
3110 #define K_ALIGN         (PROCESS|LAB|40)
3111 #define K_ALTERNATE     (41)
3112 #define K_DB            (LAB|PROCESS|42)
3113 #define K_DW            (LAB|PROCESS|43)
3114 #define K_DL            (LAB|PROCESS|44)
3115 #define K_LOCAL         (45)
3116 #define K_IFEQ          (PROCESS|46)
3117 #define K_IFNE          (PROCESS|47)
3118 #define K_IFLT          (PROCESS|48)
3119 #define K_IFLE          (PROCESS|49)
3120 #define K_IFGE          (PROCESS|50)
3121 #define K_IFGT          (PROCESS|51)
3122 #define K_IFC           (PROCESS|52)
3123 #define K_IFNC          (PROCESS|53)
3124 #define K_IRP           (PROCESS|54)
3125 #define K_IRPC          (PROCESS|55)
3126
3127
3128 struct keyword
3129 {
3130   char *name;
3131   int code;
3132   int extra;
3133 };
3134
3135 static struct keyword kinfo[] =
3136 {
3137   { "EQU", K_EQU, 0 },
3138   { "ALTERNATE", K_ALTERNATE, 0 },
3139   { "ASSIGN", K_ASSIGN, 0 },
3140   { "REG", K_REG, 0 },
3141   { "ORG", K_ORG, 0 },
3142   { "RADIX", K_RADIX, 0 },
3143   { "DATA", K_DATA, 0 },
3144   { "DB", K_DB, 0 },
3145   { "DW", K_DW, 0 },
3146   { "DL", K_DL, 0 },
3147   { "DATAB", K_DATAB, 0 },
3148   { "SDATA", K_SDATA, 0 },
3149   { "SDATAB", K_SDATAB, 0 },
3150   { "SDATAZ", K_SDATAZ, 0 },
3151   { "SDATAC", K_SDATAC, 0 },
3152   { "RES", K_RES, 0 },
3153   { "SRES", K_SRES, 0 },
3154   { "SRESC", K_SRESC, 0 },
3155   { "SRESZ", K_SRESZ, 0 },
3156   { "EXPORT", K_EXPORT, 0 },
3157   { "GLOBAL", K_GLOBAL, 0 },
3158   { "PRINT", K_PRINT, 0 },
3159   { "FORM", K_FORM, 0 },
3160   { "HEADING", K_HEADING, 0 },
3161   { "PAGE", K_PAGE, 0 },
3162   { "PROGRAM", K_IGNORED, 0 },
3163   { "END", K_END, 0 },
3164   { "INCLUDE", K_INCLUDE, 0 },
3165   { "ASSIGNA", K_ASSIGNA, 0 },
3166   { "ASSIGNC", K_ASSIGNC, 0 },
3167   { "AIF", K_AIF, 0 },
3168   { "AELSE", K_AELSE, 0 },
3169   { "AENDI", K_AENDI, 0 },
3170   { "AREPEAT", K_AREPEAT, 0 },
3171   { "AENDR", K_AENDR, 0 },
3172   { "EXITM", K_EXITM, 0 },
3173   { "MACRO", K_MACRO, 0 },
3174   { "ENDM", K_ENDM, 0 },
3175   { "AWHILE", K_AWHILE, 0 },
3176   { "ALIGN", K_ALIGN, 0 },
3177   { "AENDW", K_AENDW, 0 },
3178   { "ALTERNATE", K_ALTERNATE, 0 },
3179   { "LOCAL", K_LOCAL, 0 },
3180   { NULL, 0, 0 }
3181 };
3182
3183 /* Although the conditional operators are handled by gas, we need to
3184    handle them here as well, in case they are used in a recursive
3185    macro to end the recursion.  */
3186
3187 static struct keyword mrikinfo[] =
3188 {
3189   { "IFEQ", K_IFEQ, 0 },
3190   { "IFNE", K_IFNE, 0 },
3191   { "IFLT", K_IFLT, 0 },
3192   { "IFLE", K_IFLE, 0 },
3193   { "IFGE", K_IFGE, 0 },
3194   { "IFGT", K_IFGT, 0 },
3195   { "IFC", K_IFC, 0 },
3196   { "IFNC", K_IFNC, 0 },
3197   { "ELSEC", K_AELSE, 0 },
3198   { "ENDC", K_AENDI, 0 },
3199   { "MEXIT", K_EXITM, 0 },
3200   { "REPT", K_AREPEAT, 0 },
3201   { "IRP", K_IRP, 0 },
3202   { "IRPC", K_IRPC, 0 },
3203   { "ENDR", K_AENDR, 0 },
3204   { NULL, 0, 0 }
3205 };
3206
3207 /* Look for a pseudo op on the line. If one's there then call
3208    its handler. */
3209
3210 static int
3211 process_pseudo_op (idx, line, acc)
3212      int idx;
3213      sb *line;
3214      sb *acc;
3215 {
3216   int oidx = idx;
3217
3218   if (line->ptr[idx] == '.' || alternate || mri)
3219     {
3220       /* Scan forward and find pseudo name */
3221       char *in;
3222       hash_entry *ptr;
3223
3224       char *s;
3225       char *e;
3226       if (line->ptr[idx] == '.')
3227         idx++;
3228       in = line->ptr + idx;
3229       s = in;
3230       e = s;
3231       sb_reset (acc);
3232
3233       while (idx < line->len && *e && ISFIRSTCHAR (*e))
3234         {
3235           sb_add_char (acc, *e);
3236           e++;
3237           idx++;
3238         }
3239
3240       ptr = hash_lookup (&keyword_hash_table, acc);
3241
3242       if (!ptr)
3243         {
3244 #if 0
3245           /* This one causes lots of pain when trying to preprocess
3246              ordinary code */
3247           WARNING ((stderr, _("Unrecognised pseudo op `%s'.\n"), sb_name (acc)));
3248 #endif
3249           return 0;
3250         }
3251       if (ptr->value.i & LAB)
3252         {                       /* output the label */
3253           if (label.len)
3254             {
3255               fprintf (outfile, "%s:\t", sb_name (&label));
3256             }
3257           else
3258             fprintf (outfile, "\t");
3259         }
3260
3261       if (mri && ptr->value.i == K_END)
3262         {
3263           sb t;
3264
3265           sb_new (&t);
3266           sb_add_buffer (&t, line->ptr + oidx, idx - oidx);
3267           fprintf (outfile, "\t%s", sb_name (&t));
3268           sb_kill (&t);
3269         }
3270
3271       if (ptr->value.i & PROCESS)
3272         {
3273           /* Polish the rest of the line before handling the pseudo op */
3274 #if 0
3275           strip_comments(line);
3276 #endif
3277           sb_reset (acc);
3278           process_assigns (idx, line, acc);
3279           sb_reset(line);
3280           change_base (0, acc, line);
3281           idx = 0;
3282         }
3283       if (!condass_on ())
3284         {
3285           switch (ptr->value.i)
3286             {
3287             case K_AIF:
3288               do_aif (idx, line);
3289               break;
3290             case K_AELSE:
3291               do_aelse ();
3292               break;
3293             case K_AENDI:
3294               do_aendi ();
3295               break;
3296             }
3297           return 1;
3298         }
3299       else
3300         {
3301           switch (ptr->value.i)
3302             {
3303             case K_ALTERNATE:
3304               alternate = 1;
3305               macro_init (1, mri, 0, exp_get_abs);
3306               return 1;
3307             case K_AELSE:
3308               do_aelse ();
3309               return 1;
3310             case K_AENDI:
3311               do_aendi ();
3312               return 1;
3313             case K_ORG:
3314               ERROR ((stderr, _("ORG command not allowed.\n")));
3315               break;
3316             case K_RADIX:
3317               do_radix (line);
3318               return 1;
3319             case K_DB:
3320               do_data (idx, line, 1);
3321               return 1;
3322             case K_DW:
3323               do_data (idx, line, 2);
3324               return 1;
3325             case K_DL:
3326               do_data (idx, line, 4);
3327               return 1;
3328             case K_DATA:
3329               do_data (idx, line, 0);
3330               return 1;
3331             case K_DATAB:
3332               do_datab (idx, line);
3333               return 1;
3334             case K_SDATA:
3335               do_sdata (idx, line, 0);
3336               return 1;
3337             case K_SDATAB:
3338               do_sdatab (idx, line);
3339               return 1;
3340             case K_SDATAC:
3341               do_sdata (idx, line, 'c');
3342               return 1;
3343             case K_SDATAZ:
3344               do_sdata (idx, line, 'z');
3345               return 1;
3346             case K_ASSIGN:
3347               do_assign (0, 0, line);
3348               return 1;
3349             case K_AIF:
3350               do_aif (idx, line);
3351               return 1;
3352             case K_AREPEAT:
3353               do_arepeat (idx, line);
3354               return 1;
3355             case K_AENDW:
3356               do_aendw ();
3357               return 1;
3358             case K_AWHILE:
3359               do_awhile (idx, line);
3360               return 1;
3361             case K_AENDR:
3362               do_aendr ();
3363               return 1;
3364             case K_EQU:
3365               do_assign (1, idx, line);
3366               return 1;
3367             case K_ALIGN:
3368               do_align (idx, line);
3369               return 1;
3370             case K_RES:
3371               do_res (idx, line, 0);
3372               return 1;
3373             case K_SRES:
3374               do_res (idx, line, 's');
3375               return 1;
3376             case K_INCLUDE:
3377               do_include (idx, line);
3378               return 1;
3379             case K_LOCAL:
3380               do_local (idx, line);
3381               return 1;
3382             case K_MACRO:
3383               do_macro (idx, line);
3384               return 1;
3385             case K_ENDM:
3386               do_endm ();
3387               return 1;
3388             case K_SRESC:
3389               do_res (idx, line, 'c');
3390               return 1;
3391             case K_PRINT:
3392               do_print (idx, line);
3393               return 1;
3394             case K_FORM:
3395               do_form (idx, line);
3396               return 1;
3397             case K_HEADING:
3398               do_heading (idx, line);
3399               return 1;
3400             case K_PAGE:
3401               do_page ();
3402               return 1;
3403             case K_GLOBAL:
3404             case K_EXPORT:
3405               do_export (line);
3406               return 1;
3407             case K_IMPORT:
3408               return 1;
3409             case K_SRESZ:
3410               do_res (idx, line, 'z');
3411               return 1;
3412             case K_IGNORED:
3413               return 1;
3414             case K_END:
3415               do_end (line);
3416               return 1;
3417             case K_ASSIGNA:
3418               do_assigna (idx, line);
3419               return 1;
3420             case K_ASSIGNC:
3421               do_assignc (idx, line);
3422               return 1;
3423             case K_EXITM:
3424               do_exitm ();
3425               return 1;
3426             case K_REG:
3427               do_reg (idx, line);
3428               return 1;
3429             case K_IFEQ:
3430               do_if (idx, line, EQ);
3431               return 1;
3432             case K_IFNE:
3433               do_if (idx, line, NE);
3434               return 1;
3435             case K_IFLT:
3436               do_if (idx, line, LT);
3437               return 1;
3438             case K_IFLE:
3439               do_if (idx, line, LE);
3440               return 1;
3441             case K_IFGE:
3442               do_if (idx, line, GE);
3443               return 1;
3444             case K_IFGT:
3445               do_if (idx, line, GT);
3446               return 1;
3447             case K_IFC:
3448               do_ifc (idx, line, 0);
3449               return 1;
3450             case K_IFNC:
3451               do_ifc (idx, line, 1);
3452               return 1;
3453             case K_IRP:
3454               do_irp (idx, line, 0);
3455               return 1;
3456             case K_IRPC:
3457               do_irp (idx, line, 1);
3458               return 1;
3459             }
3460         }
3461     }
3462   return 0;
3463 }
3464
3465
3466
3467 /* Add a keyword to the hash table.  */
3468
3469 static void
3470 add_keyword (name, code)
3471      const char *name;
3472      int code;
3473 {
3474   sb label;
3475   int j;
3476
3477   sb_new (&label);
3478   sb_add_string (&label, name);
3479
3480   hash_add_to_int_table (&keyword_hash_table, &label, code);
3481
3482   sb_reset (&label);
3483   for (j = 0; name[j]; j++)
3484     sb_add_char (&label, name[j] - 'A' + 'a');
3485   hash_add_to_int_table (&keyword_hash_table, &label, code);
3486
3487   sb_kill (&label);
3488 }
3489
3490 /* Build the keyword hash table - put each keyword in the table twice,
3491    once upper and once lower case.*/
3492
3493 static void
3494 process_init ()
3495 {
3496   int i;
3497
3498   for (i = 0; kinfo[i].name; i++)
3499     add_keyword (kinfo[i].name, kinfo[i].code);
3500
3501   if (mri)
3502     {
3503       for (i = 0; mrikinfo[i].name; i++)
3504         add_keyword (mrikinfo[i].name, mrikinfo[i].code);
3505     }
3506 }
3507
3508
3509 static void
3510 do_define (string)
3511      const char *string;
3512 {
3513   sb label;
3514   int res = 1;
3515   hash_entry *ptr;
3516   sb_new (&label);
3517
3518
3519   while (*string)
3520     {
3521       if (*string == '=')
3522         {
3523           sb value;
3524           sb_new (&value);
3525           string++;
3526           while (*string)
3527             {
3528               sb_add_char (&value, *string);
3529               string++;
3530             }
3531           exp_get_abs (_("Invalid expression on command line.\n"), 0, &value, &res);
3532           sb_kill (&value);
3533           break;
3534         }
3535       sb_add_char (&label, *string);
3536
3537       string ++;
3538     }
3539
3540   ptr = hash_create (&vars, &label);
3541   free_old_entry (ptr);
3542   ptr->type = hash_integer;
3543   ptr->value.i = res;
3544   sb_kill (&label);
3545 }
3546 char *program_name;
3547
3548 /* The list of long options.  */
3549 static struct option long_options[] =
3550 {
3551   { "alternate", no_argument, 0, 'a' },
3552   { "include", required_argument, 0, 'I' },
3553   { "commentchar", required_argument, 0, 'c' },
3554   { "copysource", no_argument, 0, 's' },
3555   { "debug", no_argument, 0, 'd' },
3556   { "help", no_argument, 0, 'h' },
3557   { "mri", no_argument, 0, 'M' },
3558   { "output", required_argument, 0, 'o' },
3559   { "print", no_argument, 0, 'p' },
3560   { "unreasonable", no_argument, 0, 'u' },
3561   { "version", no_argument, 0, 'v' },
3562   { "define", required_argument, 0, 'd' },
3563   { NULL, no_argument, 0, 0 }
3564 };
3565
3566 /* Show a usage message and exit.  */
3567 static void
3568 show_usage (file, status)
3569      FILE *file;
3570      int status;
3571 {
3572   fprintf (file, _("\
3573 Usage: %s \n\
3574   [-a]      [--alternate]         enter alternate macro mode\n\
3575   [-c char] [--commentchar char]  change the comment character from !\n\
3576   [-d]      [--debug]             print some debugging info\n\
3577   [-h]      [--help]              print this message\n\
3578   [-M]      [--mri]               enter MRI compatibility mode\n\
3579   [-o out]  [--output out]        set the output file\n\
3580   [-p]      [--print]             print line numbers\n"), program_name);
3581   fprintf (file, _("\
3582   [-s]      [--copysource]        copy source through as comments \n\
3583   [-u]      [--unreasonable]      allow unreasonable nesting\n\
3584   [-v]      [--version]           print the program version\n\
3585   [-Dname=value]                  create preprocessor variable called name, with value\n\
3586   [-Ipath]                        add to include path list\n\
3587   [in-file]\n"));
3588   if (status == 0)
3589     printf (_("\nReport bugs to bug-gnu-utils@gnu.org\n"));
3590   exit (status);
3591 }
3592
3593 /* Display a help message and exit.  */
3594 static void
3595 show_help ()
3596 {
3597   printf (_("%s: Gnu Assembler Macro Preprocessor\n"),
3598           program_name);
3599   show_usage (stdout, 0);
3600 }
3601
3602 int
3603 main (argc, argv)
3604      int argc;
3605      char **argv;
3606 {
3607   int opt;
3608   char *out_name = 0;
3609   sp = include_stack;
3610
3611   ifstack[0].on = 1;
3612   ifi = 0;
3613
3614 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3615   setlocale (LC_MESSAGES, "");
3616 #endif
3617   bindtextdomain (PACKAGE, LOCALEDIR);
3618   textdomain (PACKAGE);
3619
3620   program_name = argv[0];
3621   xmalloc_set_program_name (program_name);
3622
3623   hash_new_table (101, &keyword_hash_table);
3624   hash_new_table (101, &assign_hash_table);
3625   hash_new_table (101, &vars);
3626
3627   sb_new (&label);
3628
3629   while ((opt = getopt_long (argc, argv, "I:sdhavc:upo:D:M", long_options,
3630                              (int *) NULL))
3631          != EOF)
3632     {
3633       switch (opt)
3634         {
3635         case 'o':
3636           out_name = optarg;
3637           break;
3638         case 'u':
3639           unreasonable = 1;
3640           break;
3641         case 'I':
3642           {
3643             include_path *p = (include_path *) xmalloc (sizeof (include_path));
3644             p->next = NULL;
3645             sb_new (&p->path);
3646             sb_add_string (&p->path, optarg);
3647             if (paths_tail)
3648               paths_tail->next = p;
3649             else
3650               paths_head = p;
3651             paths_tail = p;
3652           }
3653           break;
3654         case 'p':
3655           print_line_number = 1;
3656           break;
3657         case 'c':
3658           comment_char = optarg[0];
3659           break;
3660         case 'a':
3661           alternate = 1;
3662           break;
3663         case 's':
3664           copysource = 1;
3665           break;
3666         case 'd':
3667           stats = 1;
3668           break;
3669         case 'D':
3670           do_define (optarg);
3671           break;
3672         case 'M':
3673           mri = 1;
3674           comment_char = ';';
3675           break;
3676         case 'h':
3677           show_help ();
3678           /*NOTREACHED*/
3679         case 'v':
3680           /* This output is intended to follow the GNU standards document.  */
3681           printf (_("GNU assembler pre-processor %s\n"), program_version);
3682           printf (_("Copyright 1996 Free Software Foundation, Inc.\n"));
3683           printf (_("\
3684 This program is free software; you may redistribute it under the terms of\n\
3685 the GNU General Public License.  This program has absolutely no warranty.\n"));
3686           exit (0);
3687           /*NOTREACHED*/
3688         case 0:
3689           break;
3690         default:
3691           show_usage (stderr, 1);
3692           /*NOTREACHED*/
3693         }
3694     }
3695
3696   process_init ();
3697
3698   macro_init (alternate, mri, 0, exp_get_abs);
3699
3700   if (out_name) {
3701     outfile = fopen (out_name, "w");
3702     if (!outfile)
3703       {
3704         fprintf (stderr, _("%s: Can't open output file `%s'.\n"),
3705                  program_name, out_name);
3706         exit (1);
3707       }
3708   }
3709   else  {
3710     outfile = stdout;
3711   }
3712
3713   chartype_init ();
3714   if (!outfile)
3715     outfile = stdout;
3716
3717   /* Process all the input files */
3718
3719   while (optind < argc)
3720     {
3721       if (new_file (argv[optind]))
3722         {
3723           process_file ();
3724         }
3725       else
3726         {
3727           fprintf (stderr, _("%s: Can't open input file `%s'.\n"),
3728                    program_name, argv[optind]);
3729           exit (1);
3730         }
3731       optind++;
3732     }
3733
3734   quit ();
3735   return 0;
3736 }
3737
3738 /* This function is used because an abort in some of the other files
3739    may be compiled into as_abort because they include as.h.  */
3740
3741 void
3742 as_abort (file, line, fn)
3743      const char *file, *fn;
3744      int line;
3745 {
3746   fprintf (stderr, _("Internal error, aborting at %s line %d"), file, line);
3747   if (fn)
3748     fprintf (stderr, " in %s", fn);
3749   fprintf (stderr, _("\nPlease report this bug.\n"));
3750   exit (1);
3751 }