gas/read.c

   1 /* read.c - read a source file -
   2    Copyright (C) 1986, 1987, 1990, 1991 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19
  20 #define MASK_CHAR (0xFF)        /* If your chars aren't 8 bits, you will
  21                                    change this a bit.  But then, GNU isn't
  22                                    spozed to run on your machine anyway.
  23                                    (RMS is so shortsighted sometimes.)
  24                                    */
  25
  26 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
  27 /* This is the largest known floating point */
  28 /* format (for now). It will grow when we */
  29 /* do 4361 style flonums. */
  30
  31
  32 /* Routines that read assembler source text to build spagetti in memory. */
  33 /* Another group of these functions is in the as-expr.c module */
  34
  35 #include "as.h"
  36
  37 #include "obstack.h"
  38 #include "listing.h"
  39 char *input_line_pointer;       /*->next char of source file to parse. */
  40
  41
  42 #if BITS_PER_CHAR != 8
  43 The following table is indexed by [ (char) ] and will break if
  44     a char does not have exactly 256 states (hopefully 0:255!) !
  45 #endif
  46
  47     const char /* used by is_... macros. our ctype[] */
  48     lex_type [256] = {
  49             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* @ABCDEFGHIJKLMNO */
  50             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* PQRSTUVWXYZ[\]^_ */
  51             0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,       /* _!"#$%&'()*+,-./ */
  52             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,       /* 0123456789:;<=>? */
  53             0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* @ABCDEFGHIJKLMNO */
  54             3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3,       /* PQRSTUVWXYZ[\]^_ */
  55             0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* `abcdefghijklmno */
  56             3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0,       /* pqrstuvwxyz{|}~. */
  57             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  58             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  59             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  60             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  61             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  62             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  63             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  64         };
  65
  66
  67 /*
  68  * In: a character.
  69  * Out: 1 if this character ends a line.
  70  */
  71 #define _ (0)
  72 char is_end_of_line [256] = {
  73 #ifdef CR_EOL
  74         _, _, _, _, _, _, _, _, _, _,99, _, _, 99, _, _,/* @abcdefghijklmno */
  75 #else
  76         _, _, _, _, _, _, _, _, _, _,99, _, _, _, _, _, /* @abcdefghijklmno */
  77 #endif
  78         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  79         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  80         _, _, _, _, _, _, _, _, _, _, _,99, _, _, _, _, /* 0123456789:;<=>? */
  81         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  82         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  83         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  84         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  85         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  86         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  87         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  88         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */
  89         _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _  /* */
  90     };
  91 #undef _
  92
  93 /* Functions private to this file. */
  94
  95 char line_comment_chars[1];
  96 char line_separator_chars[1];
  97
  98 static char *buffer;            /* 1st char of each buffer of lines is here. */
  99 static char *buffer_limit;      /*->1 + last char in buffer. */
 100
 101 static char *bignum_low;        /* Lowest char of bignum. */
 102 static char *bignum_limit;      /* 1st illegal address of bignum. */
 103 static char *bignum_high;       /* Highest char of bignum. */
 104 /* May point to (bignum_start-1). */
 105 /* Never >= bignum_limit. */
 106 static char *old_buffer = 0;    /* JF a hack */
 107 static char *old_input;
 108 static char *old_limit;
 109
 110 /* Variables for handling include file directory list. */
 111
 112 char **include_dirs;            /* List of pointers to directories to
 113                                    search for .include's */
 114 int include_dir_count;          /* How many are in the list */
 115 int include_dir_maxlen = 1;     /* Length of longest in list */
 116
 117 #ifndef WORKING_DOT_WORD
 118 struct broken_word *broken_words;
 119 int new_broken_words = 0;
 120 #endif
 121
 122 #ifdef __STDC__
 123
 124 static char *demand_copy_string(int *lenP);
 125 int is_it_end_of_statement(void);
 126 unsigned int next_char_of_string(void);
 127 static segT get_known_segmented_expression(expressionS *expP);
 128 static void grow_bignum(void);
 129 static void pobegin(void);
 130 void stringer(int append_zero);
 131
 132 #else /* __STDC__ */
 133
 134 static char *demand_copy_string();
 135 int is_it_end_of_statement();
 136 unsigned int next_char_of_string();
 137 static segT get_known_segmented_expression();
 138 static void grow_bignum();
 139 static void pobegin();
 140 void stringer();
 141
 142 #endif /* __STDC__ */
 143
 144 extern int listing;
 145
 146 \f
 147 void
 148     read_begin()
 149 {
 150         char *p;
 151
 152         pobegin();
 153         obj_read_begin_hook();
 154
 155         obstack_begin(&notes, 5000);
 156         obstack_begin(&cond_obstack, 960);
 157
 158 #define BIGNUM_BEGIN_SIZE (16)
 159         bignum_low = xmalloc((long)BIGNUM_BEGIN_SIZE);
 160         bignum_limit = bignum_low + BIGNUM_BEGIN_SIZE;
 161
 162         /* Use machine dependent syntax */
 163         for (p = line_separator_chars; *p; p++)
 164             is_end_of_line[*p] = 1;
 165         /* Use more.  FIXME-SOMEDAY. */
 166 }
 167 \f
 168 /* set up pseudo-op tables */
 169
 170 struct hash_control *
 171     po_hash = NULL;                     /* use before set up: NULL->address error */
 172
 173 #ifdef DONTDEF
 174 void    s_gdbline(),    s_gdblinetab();
 175 void    s_gdbbeg(),     s_gdbblock(),   s_gdbend(),     s_gdbsym();
 176 #endif
 177
 178 static const pseudo_typeS
 179     potable[] =
 180 {
 181         { "abort",      s_abort,        0       },
 182         { "align",      s_align_ptwo,   0       },
 183         { "ascii",      stringer,       0       },
 184         { "asciz",      stringer,       1       },
 185         /* block */
 186         { "byte",       cons,           1       },
 187         { "comm",       s_comm,         0       },
 188         { "data",       s_data,         0       },
 189         /* dim */
 190         { "double",     float_cons,     'd'     },
 191         /* dsect */
 192         { "eject",      listing_eject,  0       },      /* Formfeed listing */
 193         { "else",       s_else,         0       },
 194         { "end",        s_end,          0       },
 195         { "endif",      s_endif,        0       },
 196         /* endef */
 197         { "equ",        s_set,          0       },
 198         /* err */
 199         /* extend */
 200         { "extern",     s_ignore,       0       },      /* We treat all undef as ext */
 201         { "app-file",   s_app_file,     0       },
 202         { "file",       s_app_file,     0       },
 203         { "fill",       s_fill,         0       },
 204         { "float",      float_cons,     'f'     },
 205 #ifdef DONTDEF
 206         { "gdbbeg",     s_gdbbeg,       0       },
 207         { "gdbblock",   s_gdbblock,     0       },
 208         { "gdbend",     s_gdbend,       0       },
 209         { "gdbsym",     s_gdbsym,       0       },
 210         { "gdbline",    s_gdbline,      0       },
 211         { "gdblinetab",s_gdblinetab,    0       },
 212 #endif
 213         { "global",     s_globl,        0       },
 214         { "globl",      s_globl,        0       },
 215         { "hword",      cons,           2       },
 216         { "if", s_if,           0       },
 217         { "ifdef",      s_ifdef,        0       },
 218         { "ifeqs",      s_ifeqs,        0       },
 219         { "ifndef",     s_ifdef,        1       },
 220         { "ifnes",      s_ifeqs,        1       },
 221         { "ifnotdef",   s_ifdef,        1       },
 222         { "include",    s_include,      0       },
 223         { "int",        cons,           4       },
 224         { "lcomm",      s_lcomm,        0       },
 225         { "lflags",     listing_flags,  0       },      /* Listing flags */
 226         { "list",       listing_list,   1       },      /* Turn listing on */
 227         { "long",       cons,           4       },
 228         { "lsym",       s_lsym,         0       },
 229         { "nolist",     listing_list,   0       },      /* Turn listing off */
 230         { "octa",       big_cons,       16      },
 231         { "org",        s_org,          0       },
 232         { "psize", listing_psize,     0       },   /* set paper size */
 233         /* print */
 234         { "quad",       big_cons,       8       },
 235         { "sbttl",      listing_title,  1       },      /* Subtitle of listing */
 236         /* scl */
 237         /* sect */
 238         { "set",        s_set,          0       },
 239         { "short",      cons,           2       },
 240         { "single",     float_cons,     'f'     },
 241         /* size */
 242         { "space",      s_space,        0       },
 243         /* tag */
 244         { "text",       s_text,         0       },
 245         { "title",      listing_title,  0       },      /* Listing title */
 246         /* type */
 247         /* use */
 248         /* val */
 249         { "word",       cons,           2       },
 250         { NULL} /* end sentinel */
 251 };
 252
 253 static void pobegin() {
 254         char *errtxt;           /* error text */
 255         const pseudo_typeS * pop;
 256
 257         po_hash = hash_new();
 258
 259         /* Do the target-specific pseudo ops. */
 260         for (pop = md_pseudo_table; pop->poc_name; pop++) {
 261                 errtxt = hash_insert(po_hash, pop->poc_name, (char *)pop);
 262                 if (errtxt && *errtxt) {
 263                         as_fatal("error constructing md pseudo-op table");
 264                 } /* on error */
 265         } /* for each op */
 266
 267         /* Now object specific.  Skip any that were in the target table. */
 268         for (pop=obj_pseudo_table; pop->poc_name; pop++) {
 269                 errtxt = hash_insert (po_hash, pop->poc_name, (char *)pop);
 270                 if (errtxt && *errtxt) {
 271                         if (!strcmp (errtxt, "exists")) {
 272 #ifdef DIE_ON_OVERRIDES
 273                                 as_fatal("pseudo op \".%s\" overridden.\n", pop->poc_name);
 274 #endif /* DIE_ON_OVERRIDES */
 275                                 continue;       /* OK if target table overrides. */
 276                         } else {
 277                                 as_fatal("error constructing obj pseudo-op table");
 278                         } /* if overridden */
 279                 } /* on error */
 280         } /* for each op */
 281
 282         /* Now portable ones.  Skip any that we've seen already. */
 283         for (pop=potable; pop->poc_name; pop++) {
 284                 errtxt = hash_insert (po_hash, pop->poc_name, (char *)pop);
 285                 if (errtxt && *errtxt) {
 286                         if (!strcmp (errtxt, "exists")) {
 287 #ifdef DIE_ON_OVERRIDES
 288                                 as_fatal("pseudo op \".%s\" overridden.\n", pop->poc_name);
 289 #endif /* DIE_ON_OVERRIDES */
 290                                 continue;       /* OK if target table overrides. */
 291                         } else {
 292                                 as_fatal("error constructing obj pseudo-op table");
 293                         } /* if overridden */
 294                 } /* on error */
 295         } /* for each op */
 296
 297         return;
 298 } /* pobegin() */
 299 \f
 300 #define HANDLE_CONDITIONAL_ASSEMBLY()   \
 301     if (ignore_input ())                                        \
 302 {                                                       \
 303                                                             while (! is_end_of_line[*input_line_pointer++])     \
 304                                                                 if (input_line_pointer == buffer_limit)         \
 305                                                                     break;                                      \
 306                                                                         continue;                                               \
 307                                                                     }
 308
 309
 310 /*      read_a_source_file()
 311  *
 312  * We read the file, putting things into a web that
 313  * represents what we have been reading.
 314  */
 315 void read_a_source_file(name)
 316 char *name;
 317 {
 318         register char c;
 319         register char * s;      /* string of symbol, '\0' appended */
 320         register int temp;
 321         /* register struct frag * fragP; JF unused */   /* a frag we just made */
 322         pseudo_typeS    *pop;
 323 #ifdef DONTDEF
 324         void gdb_block_beg();
 325         void gdb_block_position();
 326         void gdb_block_end();
 327         void gdb_symbols_fixup();
 328 #endif
 329
 330         buffer = input_scrub_new_file(name);
 331
 332         listing_file(name);
 333         listing_newline("");
 334
 335         while ((buffer_limit = input_scrub_next_buffer(&input_line_pointer)) != 0) { /* We have another line to parse. */
 336                 know(buffer_limit[-1] == '\n'); /* Must have a sentinel. */
 337         contin: /* JF this goto is my fault I admit it.  Someone brave please re-write
 338                    the whole input section here?  Pleeze??? */
 339                 while (input_line_pointer < buffer_limit) {                     /* We have more of this buffer to parse. */
 340
 341                         /*
 342                          * We now have input_line_pointer->1st char of next line.
 343                          * If input_line_pointer [-1] == '\n' then we just
 344                          * scanned another line: so bump line counters.
 345                          */
 346                         if (input_line_pointer[-1] == '\n') {
 347                                 bump_line_counters();
 348                         } /* just passed a newline */
 349
 350
 351
 352                         /*
 353                          * We are at the begining of a line, or similar place.
 354                          * We expect a well-formed assembler statement.
 355                          * A "symbol-name:" is a statement.
 356                          *
 357                          * Depending on what compiler is used, the order of these tests
 358                          * may vary to catch most common case 1st.
 359                          * Each test is independent of all other tests at the (top) level.
 360                          * PLEASE make a compiler that doesn't use this assembler.
 361                          * It is crufty to waste a compiler's time encoding things for this
 362                          * assembler, which then wastes more time decoding it.
 363                          * (And communicating via (linear) files is silly!
 364                          * If you must pass stuff, please pass a tree!)
 365                          */
 366                         if ((c = *input_line_pointer++) == '\t' || c == ' ' || c=='\f' || c == 0) {
 367                                 c = *input_line_pointer++;
 368                         }
 369                         know(c != ' '); /* No further leading whitespace. */
 370                         LISTING_NEWLINE();
 371                         /*
 372                          * C is the 1st significant character.
 373                          * Input_line_pointer points after that character.
 374                          */
 375                         if (is_name_beginner(c)) {                      /* want user-defined label or pseudo/opcode */
 376                                 HANDLE_CONDITIONAL_ASSEMBLY();
 377
 378                                 s = --input_line_pointer;
 379                                 c = get_symbol_end(); /* name's delimiter */
 380                                 /*
 381                                  * C is character after symbol.
 382                                  * That character's place in the input line is now '\0'.
 383                                  * S points to the beginning of the symbol.
 384                                  *   [In case of pseudo-op, s->'.'.]
 385                                  * Input_line_pointer->'\0' where c was.
 386                                  */
 387                                 if (c == ':') {
 388                                         colon(s);       /* user-defined label */
 389                                         * input_line_pointer ++ = ':'; /* Put ':' back for error messages' sake. */
 390                                         /* Input_line_pointer->after ':'. */
 391                                         SKIP_WHITESPACE();
 392
 393
 394                                 } else if (c == '=' || input_line_pointer[1] == '=') { /* JF deal with FOO=BAR */
 395                                         equals(s);
 396                                         demand_empty_rest_of_line();
 397                                 } else {                /* expect pseudo-op or machine instruction */
 398                                         if (*s == '.') {
 399                                                 /*
 400                                                  * PSEUDO - OP.
 401                                                  *
 402                                                  * WARNING: c has next char, which may be end-of-line.
 403                                                  * We lookup the pseudo-op table with s+1 because we
 404                                                  * already know that the pseudo-op begins with a '.'.
 405                                                  */
 406
 407                                                 pop = (pseudo_typeS *) hash_find(po_hash, s+1);
 408
 409                                                 /* Print the error msg now, while we still can */
 410                                                 if (!pop) {
 411                                                         as_bad("Unknown pseudo-op:  `%s'",s);
 412                                                         *input_line_pointer = c;
 413                                                         s_ignore(0);
 414                                                         break;
 415                                                 }
 416
 417                                                 /* Put it back for error messages etc. */
 418                                                 *input_line_pointer = c;
 419                                                 /* The following skip of whitespace is compulsory. */
 420                                                 /* A well shaped space is sometimes all that separates keyword from operands. */
 421                                                 if (c == ' ' || c == '\t') {
 422                                                         input_line_pointer++;
 423                                                 } /* Skip seperator after keyword. */
 424                                                 /*
 425                                                  * Input_line is restored.
 426                                                  * Input_line_pointer->1st non-blank char
 427                                                  * after pseudo-operation.
 428                                                  */
 429                                                 if (!pop) {
 430                                                         ignore_rest_of_line();
 431                                                         break;
 432                                                 } else {
 433                                                         (*pop->poc_handler)(pop->poc_val);
 434                                                 } /* if we have one */
 435                                         } else {                /* machine instruction */
 436                                                 /* WARNING: c has char, which may be end-of-line. */
 437                                                 /* Also: input_line_pointer->`\0` where c was. */
 438                                                 * input_line_pointer = c;
 439                                                 while (!is_end_of_line[*input_line_pointer]) {
 440                                                         input_line_pointer++;
 441                                                 }
 442                                                 c = *input_line_pointer;
 443                                                 *input_line_pointer = '\0';
 444                                                 md_assemble(s); /* Assemble 1 instruction. */
 445                                                 *input_line_pointer++ = c;
 446                                                 /* We resume loop AFTER the end-of-line from this instruction */
 447                                         } /* if (*s=='.') */
 448
 449                                 } /* if c==':' */
 450                                 continue;
 451                         } /* if (is_name_beginner(c) */
 452
 453
 454                         if (is_end_of_line [c]) {
 455                                 continue;
 456                         } /* empty statement */
 457
 458
 459                         if (isdigit(c)) { /* local label  ("4:") */
 460                                 HANDLE_CONDITIONAL_ASSEMBLY ();
 461
 462                                 temp = c - '0';
 463 #ifdef LOCAL_LABELS_DOLLAR
 464                                 if (*input_line_pointer=='$')
 465                                     input_line_pointer++;
 466 #endif
 467                                 if (* input_line_pointer ++ == ':')
 468                                     {
 469                                             local_colon (temp);
 470                                     }
 471                                 else
 472                                     {
 473                                             as_bad("Spurious digit %d.", temp);
 474                                             input_line_pointer -- ;
 475                                             ignore_rest_of_line();
 476                                     }
 477                                 continue;
 478                         } /* local label  ("4:") */
 479
 480                         if (c && strchr(line_comment_chars,c)) { /* Its a comment.  Better say APP or NO_APP */
 481                                 char *ends;
 482                                 char *new_buf;
 483                                 char *new_tmp;
 484                                 int new_length;
 485                                 char *tmp_buf = 0;
 486                                 extern char *scrub_string,*scrub_last_string;
 487
 488                                 bump_line_counters();
 489                                 s=input_line_pointer;
 490                                 if (strncmp(s,"APP\n",4))
 491                                     continue;   /* We ignore it */
 492                                 s+=4;
 493
 494                                 ends=strstr(s,"#NO_APP\n");
 495
 496                                 if (!ends) {
 497                                         int tmp_len;
 498                                         int num;
 499
 500                                         /* The end of the #APP wasn't in this buffer.  We
 501                                            keep reading in buffers until we find the #NO_APP
 502                                            that goes with this #APP  There is one.  The specs
 503                                            guarentee it. . . */
 504                                         tmp_len=buffer_limit-s;
 505                                         tmp_buf=xmalloc(tmp_len);
 506                                         bcopy(s,tmp_buf,tmp_len);
 507                                         do {
 508                                                 new_tmp = input_scrub_next_buffer(&buffer);
 509                                                 if (!new_tmp)
 510                                                     break;
 511                                                 else
 512                                                     buffer_limit = new_tmp;
 513                                                 input_line_pointer = buffer;
 514                                                 ends = strstr(buffer,"#NO_APP\n");
 515                                                 if (ends)
 516                                                     num=ends-buffer;
 517                                                 else
 518                                                     num=buffer_limit-buffer;
 519
 520                                                 tmp_buf = xrealloc(tmp_buf, tmp_len + num);
 521                                                 bcopy(buffer,tmp_buf+tmp_len,num);
 522                                                 tmp_len+=num;
 523                                         } while(!ends);
 524
 525                                         input_line_pointer= ends ? ends+8 : NULL;
 526
 527                                         s=tmp_buf;
 528                                         ends=s+tmp_len;
 529
 530                                 } else {
 531                                         input_line_pointer=ends+8;
 532                                 }
 533                                 new_buf=xmalloc(100);
 534                                 new_length=100;
 535                                 new_tmp=new_buf;
 536
 537                                 scrub_string=s;
 538                                 scrub_last_string = ends;
 539                                 for(;;) {
 540                                         int ch;
 541
 542                                         ch = do_scrub_next_char(scrub_from_string, scrub_to_string);
 543                                         if (ch==EOF) break;
 544                                         *new_tmp++=ch;
 545                                         if (new_tmp==new_buf+new_length) {
 546                                                 new_buf=xrealloc(new_buf,new_length+100);
 547                                                 new_tmp=new_buf+new_length;
 548                                                 new_length+=100;
 549                                         }
 550                                 }
 551
 552                                 if (tmp_buf)
 553                                     free(tmp_buf);
 554                                 old_buffer=buffer;
 555                                 old_input=input_line_pointer;
 556                                 old_limit=buffer_limit;
 557                                 buffer=new_buf;
 558                                 input_line_pointer=new_buf;
 559                                 buffer_limit=new_tmp;
 560                                 continue;
 561                         }
 562
 563                         HANDLE_CONDITIONAL_ASSEMBLY();
 564
 565                         /* as_warn("Junk character %d.",c);  Now done by ignore_rest */
 566                         input_line_pointer--;           /* Report unknown char as ignored. */
 567                         ignore_rest_of_line();
 568                 }                       /* while (input_line_pointer<buffer_limit) */
 569                 if (old_buffer) {
 570                         bump_line_counters();
 571                         if (old_input != 0) {
 572                                 buffer=old_buffer;
 573                                 input_line_pointer=old_input;
 574                                 buffer_limit=old_limit;
 575                                 old_buffer = 0;
 576                                 goto contin;
 577                         }
 578                 }
 579         } /* while (more buffers to scan) */
 580         input_scrub_close();    /* Close the input file */
 581
 582 } /* read_a_source_file() */
 583
 584 void s_abort() {
 585         as_fatal(".abort detected.  Abandoning ship.");
 586 } /* s_abort() */
 587
 588 /* For machines where ".align 4" means align to a 4 byte boundary. */
 589 void s_align_bytes(arg)
 590 int arg;
 591 {
 592         register unsigned int temp;
 593         register long temp_fill;
 594         unsigned int i = 0;
 595         unsigned long max_alignment = 1 << 15;
 596
 597         if (is_end_of_line[*input_line_pointer])
 598             temp = arg;         /* Default value from pseudo-op table */
 599         else
 600             temp = get_absolute_expression ();
 601
 602         if (temp > max_alignment) {
 603                 as_bad("Alignment too large: %d. assumed.", temp = max_alignment);
 604         }
 605
 606         /*
 607          * For the sparc, `.align (1<<n)' actually means `.align n'
 608          * so we have to convert it.
 609          */
 610         if (temp != 0) {
 611                 for (i = 0; (temp & 1) == 0; temp >>= 1, ++i)
 612                     ;
 613         }
 614         if (temp != 1)
 615             as_bad("Alignment not a power of 2");
 616
 617         temp = i;
 618         if (*input_line_pointer == ',') {
 619                 input_line_pointer ++;
 620                 temp_fill = get_absolute_expression ();
 621         } else {
 622                 temp_fill = 0;
 623         }
 624         /* Only make a frag if we HAVE to. . . */
 625         if (temp && ! need_pass_2)
 626             frag_align(temp, (int)temp_fill);
 627
 628         demand_empty_rest_of_line();
 629 } /* s_align_bytes() */
 630
 631 /* For machines where ".align 4" means align to 2**4 boundary. */
 632 void s_align_ptwo() {
 633         register int temp;
 634         register long temp_fill;
 635         long max_alignment = 15;
 636
 637         temp = get_absolute_expression ();
 638         if (temp > max_alignment)
 639             as_bad("Alignment too large: %d. assumed.", temp = max_alignment);
 640         else if (temp < 0) {
 641                 as_bad("Alignment negative. 0 assumed.");
 642                 temp = 0;
 643         }
 644         if (*input_line_pointer == ',') {
 645                 input_line_pointer ++;
 646                 temp_fill = get_absolute_expression ();
 647         } else
 648             temp_fill = 0;
 649         /* Only make a frag if we HAVE to. . . */
 650         if (temp && ! need_pass_2)
 651             frag_align (temp, (int)temp_fill);
 652
 653         record_alignment(now_seg, temp);
 654
 655         demand_empty_rest_of_line();
 656 } /* s_align_ptwo() */
 657
 658 void s_comm() {
 659         register char *name;
 660         register char c;
 661         register char *p;
 662         register int temp;
 663         register symbolS *      symbolP;
 664
 665         name = input_line_pointer;
 666         c = get_symbol_end();
 667         /* just after name is now '\0' */
 668         p = input_line_pointer;
 669         *p = c;
 670         SKIP_WHITESPACE();
 671         if (*input_line_pointer != ',') {
 672                 as_bad("Expected comma after symbol-name: rest of line ignored.");
 673                 ignore_rest_of_line();
 674                 return;
 675         }
 676         input_line_pointer ++; /* skip ',' */
 677         if ((temp = get_absolute_expression()) < 0) {
 678                 as_warn(".COMMon length (%d.) <0! Ignored.", temp);
 679                 ignore_rest_of_line();
 680                 return;
 681         }
 682         *p = 0;
 683         symbolP = symbol_find_or_make(name);
 684         *p = c;
 685         if (S_IS_DEFINED(symbolP)) {
 686                 as_bad("Ignoring attempt to re-define symbol");
 687                 ignore_rest_of_line();
 688                 return;
 689         }
 690         if (S_GET_VALUE(symbolP)) {
 691                 if (S_GET_VALUE(symbolP) != temp)
 692                     as_bad("Length of .comm \"%s\" is already %d. Not changed to %d.",
 693                            S_GET_NAME(symbolP),
 694                            S_GET_VALUE(symbolP),
 695                            temp);
 696         } else {
 697                 S_SET_VALUE(symbolP, temp);
 698                 S_SET_EXTERNAL(symbolP);
 699         }
 700 #ifdef VMS
 701         if (!temp)
 702             symbolP->sy_other = const_flag;
 703 #endif
 704         know(symbolP->sy_frag == &zero_address_frag);
 705         demand_empty_rest_of_line();
 706 } /* s_comm() */
 707
 708 void
 709     s_data()
 710 {
 711         register int temp;
 712
 713         temp = get_absolute_expression ();
 714 #ifdef MANY_SEGMENTS
 715         subseg_new (SEG_E1, (subsegT)temp);
 716 #else
 717         subseg_new (SEG_DATA, (subsegT)temp);
 718 #endif
 719
 720 #ifdef VMS
 721         const_flag = 0;
 722 #endif
 723         demand_empty_rest_of_line();
 724 }
 725
 726 void s_app_file() {
 727         register char *s;
 728         int length;
 729
 730         /* Some assemblers tolerate immediately following '"' */
 731         if ((s = demand_copy_string(&length)) != 0) {
 732                 new_logical_line(s, -1);
 733                 demand_empty_rest_of_line();
 734         }
 735 #ifdef OBJ_COFF
 736         c_dot_file_symbol(s);
 737 #endif /* OBJ_COFF */
 738 } /* s_app_file() */
 739
 740 void s_fill() {
 741         long temp_repeat;
 742         long temp_size;
 743         register long temp_fill;
 744         char *p;
 745
 746         if (get_absolute_expression_and_terminator(& temp_repeat) != ',') {
 747                 input_line_pointer --; /* Backup over what was not a ','. */
 748                 as_bad("Expect comma after rep-size in .fill:");
 749                 ignore_rest_of_line();
 750                 return;
 751         }
 752         if (get_absolute_expression_and_terminator(& temp_size) != ',') {
 753                 input_line_pointer --; /* Backup over what was not a ','. */
 754                 as_bad("Expected comma after size in .fill");
 755                 ignore_rest_of_line();
 756                 return;
 757         }
 758         /*
 759          * This is to be compatible with BSD 4.2 AS, not for any rational reason.
 760          */
 761 #define BSD_FILL_SIZE_CROCK_8 (8)
 762         if (temp_size > BSD_FILL_SIZE_CROCK_8) {
 763                 as_bad(".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8);
 764                 temp_size = BSD_FILL_SIZE_CROCK_8 ;
 765         } if (temp_size < 0) {
 766                 as_warn("Size negative: .fill ignored.");
 767                 temp_size = 0;
 768         } else if (temp_repeat <= 0) {
 769                 as_warn("Repeat < 0, .fill ignored");
 770                 temp_size = 0;
 771         }
 772         temp_fill = get_absolute_expression ();
 773         if (temp_size && !need_pass_2) {
 774                 p = frag_var(rs_fill, (int)temp_size, (int)temp_size, (relax_substateT)0, (symbolS *)0, temp_repeat, (char *)0);
 775                 bzero (p, (int)temp_size);
 776                 /*
 777                  * The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX flavoured AS.
 778                  * The following bizzare behaviour is to be compatible with above.
 779                  * I guess they tried to take up to 8 bytes from a 4-byte expression
 780                  * and they forgot to sign extend. Un*x Sux.
 781                  */
 782 #define BSD_FILL_SIZE_CROCK_4 (4)
 783                 md_number_to_chars (p, temp_fill, temp_size > BSD_FILL_SIZE_CROCK_4 ? BSD_FILL_SIZE_CROCK_4 : (int)temp_size);
 784                 /*
 785                  * Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
 786                  * but emits no error message because it seems a legal thing to do.
 787                  * It is a degenerate case of .fill but could be emitted by a compiler.
 788                  */
 789         }
 790         demand_empty_rest_of_line();
 791 }
 792
 793 #ifdef DONTDEF
 794 void
 795     s_gdbbeg()
 796 {
 797         register int temp;
 798
 799         temp = get_absolute_expression ();
 800         if (temp < 0)
 801             as_warn("Block number <0. Ignored.");
 802         else if (flagseen ['G'])
 803             gdb_block_beg ((long) temp, frag_now, (long)(obstack_next_free(& frags) - frag_now->fr_literal));
 804         demand_empty_rest_of_line ();
 805 }
 806
 807 void
 808     s_gdbblock()
 809 {
 810         register int position;
 811         int temp;
 812
 813         if (get_absolute_expression_and_terminator (&temp) != ',') {
 814                 as_bad("expected comma before position in .gdbblock");
 815                 --input_line_pointer;
 816                 ignore_rest_of_line ();
 817                 return;
 818         }
 819         position = get_absolute_expression ();
 820         if (flagseen ['G'])
 821             gdb_block_position ((long) temp, (long) position);
 822         demand_empty_rest_of_line ();
 823 }
 824
 825 void
 826     s_gdbend()
 827 {
 828         register int temp;
 829
 830         temp = get_absolute_expression ();
 831         if (temp < 0)
 832             as_warn("Block number <0. Ignored.");
 833         else if (flagseen ['G'])
 834             gdb_block_end ((long) temp, frag_now, (long)(obstack_next_free(& frags) - frag_now->fr_literal));
 835         demand_empty_rest_of_line ();
 836 }
 837
 838 void
 839     s_gdbsym()
 840 {
 841         register char *name,
 842         *p;
 843         register char c;
 844         register symbolS *      symbolP;
 845         register int temp;
 846
 847         name = input_line_pointer;
 848         c = get_symbol_end();
 849         p = input_line_pointer;
 850         symbolP = symbol_find_or_make(name);
 851         *p = c;
 852         SKIP_WHITESPACE();
 853         if (* input_line_pointer != ',') {
 854                 as_bad("Expected comma after name");
 855                 ignore_rest_of_line();
 856                 return;
 857         }
 858         input_line_pointer ++;
 859         if ((temp = get_absolute_expression ()) < 0) {
 860                 as_bad("Bad GDB symbol file offset (%d.) <0! Ignored.", temp);
 861                 ignore_rest_of_line();
 862                 return;
 863         }
 864         if (flagseen ['G'])
 865             gdb_symbols_fixup (symbolP, (long)temp);
 866         demand_empty_rest_of_line ();
 867 }
 868
 869 void
 870     s_gdbline()
 871 {
 872         int file_number,
 873         lineno;
 874
 875         if (get_absolute_expression_and_terminator(&file_number) != ',') {
 876                 as_bad("expected comman after filenum in .gdbline");
 877                 ignore_rest_of_line();
 878                 return;
 879         }
 880         lineno=get_absolute_expression();
 881         if (flagseen['G'])
 882             gdb_line(file_number,lineno);
 883         demand_empty_rest_of_line();
 884 }
 885
 886
 887 void
 888     s_gdblinetab()
 889 {
 890         int file_number,
 891         offset;
 892
 893         if (get_absolute_expression_and_terminator(&file_number) != ',') {
 894                 as_bad("expected comma after filenum in .gdblinetab");
 895                 ignore_rest_of_line();
 896                 return;
 897         }
 898         offset=get_absolute_expression();
 899         if (flagseen['G'])
 900             gdb_line_tab(file_number,offset);
 901         demand_empty_rest_of_line();
 902 }
 903 #endif
 904
 905 void s_globl() {
 906         register char *name;
 907         register int c;
 908         register symbolS *      symbolP;
 909
 910         do {
 911                 name = input_line_pointer;
 912                 c = get_symbol_end();
 913                 symbolP = symbol_find_or_make(name);
 914                 * input_line_pointer = c;
 915                 SKIP_WHITESPACE();
 916                 S_SET_EXTERNAL(symbolP);
 917                 if (c==',') {
 918                         input_line_pointer++;
 919                         SKIP_WHITESPACE();
 920                         if (*input_line_pointer=='\n')
 921                             c='\n';
 922                 }
 923         } while(c==',');
 924         demand_empty_rest_of_line();
 925 } /* s_globl() */
 926
 927 void s_lcomm(needs_align)
 928 int needs_align;        /* 1 if this was a ".bss" directive, which may require
 929                          *      a 3rd argument (alignment).
 930                          * 0 if it was an ".lcomm" (2 args only)
 931                          */
 932 {
 933         register char *name;
 934         register char c;
 935         register char *p;
 936         register int temp;
 937         register symbolS *      symbolP;
 938         const int max_alignment = 15;
 939         int align = 0;
 940
 941         name = input_line_pointer;
 942         c = get_symbol_end();
 943         p = input_line_pointer;
 944         *p = c;
 945         SKIP_WHITESPACE();
 946         if (*input_line_pointer != ',') {
 947                 as_bad("Expected comma after name");
 948                 ignore_rest_of_line();
 949                 return;
 950         }
 951
 952         ++input_line_pointer;
 953
 954         if (*input_line_pointer == '\n') {
 955                 as_bad("Missing size expression");
 956                 return;
 957         }
 958
 959         if ((temp = get_absolute_expression ()) < 0) {
 960                 as_warn("BSS length (%d.) <0! Ignored.", temp);
 961                 ignore_rest_of_line();
 962                 return;
 963         }
 964
 965         if (needs_align) {
 966                 align = 0;
 967                 SKIP_WHITESPACE();
 968                 if (*input_line_pointer != ',') {
 969                         as_bad("Expected comma after size");
 970                         ignore_rest_of_line();
 971                         return;
 972                 }
 973                 input_line_pointer++;
 974                 SKIP_WHITESPACE();
 975                 if (*input_line_pointer == '\n') {
 976                         as_bad("Missing alignment");
 977                         return;
 978                 }
 979                 align = get_absolute_expression ();
 980                 if (align > max_alignment){
 981                         align = max_alignment;
 982                         as_warn("Alignment too large: %d. assumed.", align);
 983                 } else if (align < 0) {
 984                         align = 0;
 985                         as_warn("Alignment negative. 0 assumed.");
 986                 }
 987 #ifdef MANY_SEGMENTS
 988 #define SEG_BSS SEG_E2
 989                 record_alignment(SEG_E2, align);
 990 #else
 991                 record_alignment(SEG_BSS, align);
 992 #endif
 993         } /* if needs align */
 994
 995         *p = 0;
 996         symbolP = symbol_find_or_make(name);
 997         *p = c;
 998
 999         if (
1000 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1001             S_GET_OTHER(symbolP) == 0 &&
1002             S_GET_DESC(symbolP)  == 0 &&
1003 #endif /* OBJ_AOUT or OBJ_BOUT */
1004             (((S_GET_SEGMENT(symbolP) == SEG_BSS) && (S_GET_VALUE(symbolP) == local_bss_counter))
1005              || (!S_IS_DEFINED(symbolP) && S_GET_VALUE(symbolP) == 0))) {
1006                 if (needs_align){
1007                         /* Align */
1008                         align = ~ ((~0) << align);      /* Convert to a mask */
1009                         local_bss_counter =
1010                             (local_bss_counter + align) & (~align);
1011                 }
1012
1013                 S_SET_VALUE(symbolP,local_bss_counter);
1014                 S_SET_SEGMENT(symbolP, SEG_BSS);
1015 #ifdef OBJ_COFF
1016                 /* The symbol may already have been created with a preceding
1017                  * ".globl" directive -- be careful not to step on storage
1018                  * class in that case.  Otherwise, set it to static.
1019                  */
1020                 if (S_GET_STORAGE_CLASS(symbolP) != C_EXT){
1021                         S_SET_STORAGE_CLASS(symbolP, C_STAT);
1022                 }
1023 #endif /* OBJ_COFF */
1024                 symbolP->sy_frag  = & bss_address_frag;
1025                 local_bss_counter += temp;
1026         } else {
1027                 as_bad("Ignoring attempt to re-define symbol from %d. to %d.",
1028                        S_GET_VALUE(symbolP), local_bss_counter);
1029         }
1030         demand_empty_rest_of_line();
1031
1032         return;
1033 } /* s_lcomm() */
1034
1035 void
1036     s_long()
1037 {
1038         cons(4);
1039 }
1040
1041 void
1042     s_int()
1043 {
1044         cons(4);
1045 }
1046
1047 void s_lsym() {
1048         register char *name;
1049         register char c;
1050         register char *p;
1051         register segT segment;
1052         expressionS exp;
1053         register symbolS *symbolP;
1054
1055         /* we permit ANY defined expression: BSD4.2 demands constants */
1056         name = input_line_pointer;
1057         c = get_symbol_end();
1058         p = input_line_pointer;
1059         *p = c;
1060         SKIP_WHITESPACE();
1061         if (* input_line_pointer != ',') {
1062                 *p = 0;
1063                 as_bad("Expected comma after name \"%s\"", name);
1064                 *p = c;
1065                 ignore_rest_of_line();
1066                 return;
1067         }
1068         input_line_pointer ++;
1069         segment = expression(& exp);
1070         if (segment != SEG_ABSOLUTE
1071 #ifdef MANY_SEGMENTS
1072             && ! ( segment >= SEG_E0 && segment <= SEG_UNKNOWN)
1073 #else
1074             && segment != SEG_DATA
1075             && segment != SEG_TEXT
1076             && segment != SEG_BSS
1077 #endif
1078             && segment != SEG_REGISTER) {
1079                 as_bad("Bad expression: %s", segment_name(segment));
1080                 ignore_rest_of_line();
1081                 return;
1082         }
1083         *p = 0;
1084         symbolP = symbol_find_or_make(name);
1085
1086         /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0
1087            && symbolP->sy_desc == 0) out of this test
1088            because coff doesn't have those fields, and I
1089            can't see when they'd ever be tripped.  I don't
1090            think I understand why they were here so I may
1091            have introduced a bug. As recently as 1.37 didn't
1092            have this test anyway.  xoxorich. */
1093
1094         if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN
1095             && S_GET_VALUE(symbolP) == 0) {
1096                 /* The name might be an undefined .global symbol; be
1097                    sure to keep the "external" bit. */
1098                 S_SET_SEGMENT(symbolP, segment);
1099                 S_SET_VALUE(symbolP, (valueT)(exp.X_add_number));
1100         } else {
1101                 as_bad("Symbol %s already defined", name);
1102         }
1103         *p = c;
1104         demand_empty_rest_of_line();
1105 } /* s_lsym() */
1106
1107 void s_org() {
1108         register segT segment;
1109         expressionS exp;
1110         register long temp_fill;
1111         register char *p;
1112         /*
1113          * Don't believe the documentation of BSD 4.2 AS.
1114          * There is no such thing as a sub-segment-relative origin.
1115          * Any absolute origin is given a warning, then assumed to be segment-relative.
1116          * Any segmented origin expression ("foo+42") had better be in the right
1117          * segment or the .org is ignored.
1118          *
1119          * BSD 4.2 AS warns if you try to .org backwards. We cannot because we
1120          * never know sub-segment sizes when we are reading code.
1121          * BSD will crash trying to emit -ve numbers of filler bytes in certain
1122          * .orgs. We don't crash, but see as-write for that code.
1123          */
1124         /*
1125          * Don't make frag if need_pass_2==1.
1126          */
1127         segment = get_known_segmented_expression(&exp);
1128         if (*input_line_pointer == ',') {
1129                 input_line_pointer ++;
1130                 temp_fill = get_absolute_expression ();
1131         } else
1132             temp_fill = 0;
1133         if (! need_pass_2) {
1134                 if (segment != now_seg && segment != SEG_ABSOLUTE)
1135                     as_bad("Invalid segment \"%s\". Segment \"%s\" assumed.",
1136                            segment_name(segment), segment_name(now_seg));
1137                 p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp . X_add_symbol,
1138                               exp . X_add_number, (char *)0);
1139                 * p = temp_fill;
1140         } /* if (ok to make frag) */
1141         demand_empty_rest_of_line();
1142 } /* s_org() */
1143
1144 void s_set() {
1145         register char *name;
1146         register char delim;
1147         register char *end_name;
1148         register symbolS *symbolP;
1149
1150         /*
1151          * Especial apologies for the random logic:
1152          * this just grew, and could be parsed much more simply!
1153          * Dean in haste.
1154          */
1155         name = input_line_pointer;
1156         delim = get_symbol_end();
1157         end_name = input_line_pointer;
1158         *end_name = delim;
1159         SKIP_WHITESPACE();
1160
1161         if (*input_line_pointer != ',') {
1162                 *end_name = 0;
1163                 as_bad("Expected comma after name \"%s\"", name);
1164                 *end_name = delim;
1165                 ignore_rest_of_line();
1166                 return;
1167         }
1168
1169         input_line_pointer ++;
1170         *end_name = 0;
1171
1172         if (name[0]=='.' && name[1]=='\0') {
1173                 /* Turn '. = mumble' into a .org mumble */
1174                 register segT segment;
1175                 expressionS exp;
1176                 register char *ptr;
1177
1178                 segment = get_known_segmented_expression(& exp);
1179
1180                 if (!need_pass_2) {
1181                         if (segment != now_seg && segment != SEG_ABSOLUTE)
1182                             as_bad("Invalid segment \"%s\". Segment \"%s\" assumed.",
1183                                    segment_name(segment),
1184                                    segment_name (now_seg));
1185                         ptr = frag_var(rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
1186                                        exp.X_add_number, (char *)0);
1187                         *ptr= 0;
1188                 } /* if (ok to make frag) */
1189
1190                 *end_name = delim;
1191                 return;
1192         }
1193
1194         if ((symbolP = symbol_find(name)) == NULL
1195             && (symbolP = md_undefined_symbol(name)) == NULL) {
1196                 symbolP = symbol_new(name,
1197                                      SEG_UNKNOWN,
1198                                      0,
1199                                      &zero_address_frag);
1200 #ifdef OBJ_COFF
1201                 /* "set" symbols are local unless otherwise specified. */
1202                 SF_SET_LOCAL(symbolP);
1203 #endif /* OBJ_COFF */
1204
1205         } /* make a new symbol */
1206
1207         symbol_table_insert(symbolP);
1208
1209         *end_name = delim;
1210         pseudo_set(symbolP);
1211         demand_empty_rest_of_line();
1212 } /* s_set() */
1213
1214 void s_space() {
1215         long temp_repeat;
1216         register long temp_fill;
1217         register char *p;
1218
1219         /* Just like .fill, but temp_size = 1 */
1220         if (get_absolute_expression_and_terminator(& temp_repeat) == ',') {
1221                 temp_fill = get_absolute_expression ();
1222         } else {
1223                 input_line_pointer --; /* Backup over what was not a ','. */
1224                 temp_fill = 0;
1225         }
1226         if (temp_repeat <= 0) {
1227                 as_warn("Repeat < 0, .space ignored");
1228                 ignore_rest_of_line();
1229                 return;
1230         }
1231         if (! need_pass_2) {
1232                 p = frag_var (rs_fill, 1, 1, (relax_substateT)0, (symbolS *)0,
1233                               temp_repeat, (char *)0);
1234                 * p = temp_fill;
1235         }
1236         demand_empty_rest_of_line();
1237 } /* s_space() */
1238
1239 void
1240     s_text()
1241 {
1242         register int temp;
1243
1244         temp = get_absolute_expression ();
1245 #ifdef MANY_SEGMENTS
1246         subseg_new (SEG_E0, (subsegT)temp);
1247 #else
1248         subseg_new (SEG_TEXT, (subsegT)temp);
1249 #endif
1250         demand_empty_rest_of_line();
1251 } /* s_text() */
1252
1253 \f
1254 /*(JF was static, but can't be if machine dependent pseudo-ops are to use it */
1255
1256 void demand_empty_rest_of_line() {
1257         SKIP_WHITESPACE();
1258         if (is_end_of_line [*input_line_pointer]) {
1259                 input_line_pointer++;
1260         } else {
1261                 ignore_rest_of_line();
1262         }
1263         /* Return having already swallowed end-of-line. */
1264 } /* Return pointing just after end-of-line. */
1265
1266 void
1267     ignore_rest_of_line()               /* For suspect lines: gives warning. */
1268 {
1269         if (! is_end_of_line [* input_line_pointer])
1270             {
1271                     if (isprint(*input_line_pointer))
1272                         as_bad("Rest of line ignored. First ignored character is `%c'.",
1273                                *input_line_pointer);
1274                     else
1275                         as_bad("Rest of line ignored. First ignored character valued 0x%x.",
1276                                *input_line_pointer);
1277                     while (input_line_pointer < buffer_limit
1278                            && ! is_end_of_line [* input_line_pointer])
1279                         {
1280                                 input_line_pointer ++;
1281                         }
1282             }
1283         input_line_pointer ++;  /* Return pointing just after end-of-line. */
1284         know(is_end_of_line [input_line_pointer [-1]]);
1285 }
1286
1287 /*
1288  *                      pseudo_set()
1289  *
1290  * In:  Pointer to a symbol.
1291  *      Input_line_pointer->expression.
1292  *
1293  * Out: Input_line_pointer->just after any whitespace after expression.
1294  *      Tried to set symbol to value of expression.
1295  *      Will change symbols type, value, and frag;
1296  *      May set need_pass_2 == 1.
1297  */
1298 void
1299     pseudo_set (symbolP)
1300 symbolS *       symbolP;
1301 {
1302         expressionS     exp;
1303         register segT   segment;
1304 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1305         int ext;
1306 #endif /* OBJ_AOUT or OBJ_BOUT */
1307
1308         know(symbolP);          /* NULL pointer is logic error. */
1309 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1310         ext=S_IS_EXTERNAL(symbolP);
1311 #endif /* OBJ_AOUT or OBJ_BOUT */
1312
1313         if ((segment = expression(& exp)) == SEG_ABSENT)
1314             {
1315                     as_bad("Missing expression: absolute 0 assumed");
1316                     exp . X_seg         = SEG_ABSOLUTE;
1317                     exp . X_add_number  = 0;
1318             }
1319
1320         switch (segment)
1321             {
1322             case SEG_BIG:
1323                     as_bad("%s number invalid. Absolute 0 assumed.",
1324                            exp . X_add_number > 0 ? "Bignum" : "Floating-Point");
1325                     S_SET_SEGMENT(symbolP, SEG_ABSOLUTE);
1326 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1327                     ext ? S_SET_EXTERNAL(symbolP) :
1328                         S_CLEAR_EXTERNAL(symbolP);
1329 #endif /* OBJ_AOUT or OBJ_BOUT */
1330                     S_SET_VALUE(symbolP, 0);
1331                     symbolP->sy_frag = & zero_address_frag;
1332                     break;
1333
1334             case SEG_ABSENT:
1335                     as_warn("No expression:  Using absolute 0");
1336                     S_SET_SEGMENT(symbolP, SEG_ABSOLUTE);
1337 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1338                     ext ? S_SET_EXTERNAL(symbolP) :
1339                         S_CLEAR_EXTERNAL(symbolP);
1340 #endif /* OBJ_AOUT or OBJ_BOUT */
1341                     S_SET_VALUE(symbolP, 0);
1342                     symbolP->sy_frag = & zero_address_frag;
1343                     break;
1344
1345             case SEG_DIFFERENCE:
1346                     if (exp.X_add_symbol && exp.X_subtract_symbol
1347                         && (S_GET_SEGMENT(exp.X_add_symbol) ==
1348                             S_GET_SEGMENT(exp.X_subtract_symbol))) {
1349                             if (exp.X_add_symbol->sy_frag != exp.X_subtract_symbol->sy_frag) {
1350                                     as_bad("Unknown expression: symbols %s and %s are in different frags.",
1351                                            S_GET_NAME(exp.X_add_symbol), S_GET_NAME(exp.X_subtract_symbol));
1352                                     need_pass_2++;
1353                             }
1354                             exp.X_add_number+=S_GET_VALUE(exp.X_add_symbol) -
1355                                 S_GET_VALUE(exp.X_subtract_symbol);
1356                     } else
1357                         as_bad("Complex expression. Absolute segment assumed.");
1358             case SEG_ABSOLUTE:
1359                     S_SET_SEGMENT(symbolP, SEG_ABSOLUTE);
1360 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1361                     ext ? S_SET_EXTERNAL(symbolP) :
1362                         S_CLEAR_EXTERNAL(symbolP);
1363 #endif /* OBJ_AOUT or OBJ_BOUT */
1364                     S_SET_VALUE(symbolP, exp.X_add_number);
1365                     symbolP->sy_frag = & zero_address_frag;
1366                     break;
1367
1368             default:
1369 #ifdef MANY_SEGMENTS
1370                     S_SET_SEGMENT(symbolP, segment);
1371 #else
1372                     switch(segment) {
1373                     case SEG_DATA:      S_SET_SEGMENT(symbolP, SEG_DATA); break;
1374                     case SEG_TEXT:      S_SET_SEGMENT(symbolP, SEG_TEXT); break;
1375                     case SEG_BSS:       S_SET_SEGMENT(symbolP, SEG_BSS); break;
1376                     default:    as_fatal("failed sanity check.");
1377                     }   /* switch on segment */
1378 #endif
1379 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1380                     if (ext) {
1381                             S_SET_EXTERNAL(symbolP);
1382                     } else {
1383                             S_CLEAR_EXTERNAL(symbolP);
1384                     }   /* if external */
1385 #endif /* OBJ_AOUT or OBJ_BOUT */
1386
1387                     S_SET_VALUE(symbolP, exp.X_add_number + S_GET_VALUE(exp.X_add_symbol));
1388                     symbolP->sy_frag = exp . X_add_symbol->sy_frag;
1389                     break;
1390
1391             case SEG_PASS1:             /* Not an error. Just try another pass. */
1392                     symbolP->sy_forward=exp.X_add_symbol;
1393                     as_bad("Unknown expression");
1394                     know(need_pass_2 == 1);
1395                     break;
1396
1397             case SEG_UNKNOWN:
1398                     symbolP->sy_forward=exp.X_add_symbol;
1399                     /* as_warn("unknown symbol"); */
1400                     /* need_pass_2 = 1; */
1401                     break;
1402
1403
1404
1405             }
1406 }
1407 \f
1408 /*
1409  *                      cons()
1410  *
1411  * CONStruct more frag of .bytes, or .words etc.
1412  * Should need_pass_2 be 1 then emit no frag(s).
1413  * This understands EXPRESSIONS, as opposed to big_cons().
1414  *
1415  * Bug (?)
1416  *
1417  * This has a split personality. We use expression() to read the
1418  * value. We can detect if the value won't fit in a byte or word.
1419  * But we can't detect if expression() discarded significant digits
1420  * in the case of a long. Not worth the crocks required to fix it.
1421  */
1422
1423 /* worker to do .byte etc statements */
1424 /* clobbers input_line_pointer, checks */
1425 /* end-of-line. */
1426 void cons(nbytes)
1427 register unsigned int nbytes;   /* 1=.byte, 2=.word, 4=.long */
1428 {
1429         register char c;
1430         register long mask;     /* High-order bits we will left-truncate, */
1431         /* but includes sign bit also. */
1432         register long get;      /* what we get */
1433         register long use;      /* get after truncation. */
1434         register long unmask;   /* what bits we will store */
1435         register char * p;
1436         register segT           segment;
1437         expressionS     exp;
1438
1439         /*
1440          * Input_line_pointer->1st char after pseudo-op-code and could legally
1441          * be a end-of-line. (Or, less legally an eof - which we cope with.)
1442          */
1443         /* JF << of >= number of bits in the object is undefined.  In particular
1444            SPARC (Sun 4) has problems */
1445
1446         if (nbytes>=sizeof(long)) {
1447                 mask = 0;
1448         } else {
1449                 mask = ~0 << (BITS_PER_CHAR * nbytes); /* Don't store these bits. */
1450         } /* bigger than a long */
1451
1452         unmask = ~mask;         /* Do store these bits. */
1453
1454 #ifdef NEVER
1455         "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
1456         mask = ~ (unmask >> 1); /* Includes sign bit now. */
1457 #endif
1458
1459         /*
1460          * The following awkward logic is to parse ZERO or more expressions,
1461          * comma seperated. Recall an expression includes its leading &
1462          * trailing blanks. We fake a leading ',' if there is (supposed to
1463          * be) a 1st expression, and keep demanding 1 expression for each ','.
1464          */
1465         if (is_it_end_of_statement()) {
1466                 c = 0;                  /* Skip loop. */
1467                 input_line_pointer++;   /* Matches end-of-loop 'correction'. */
1468         } else {
1469                 c = ',';
1470         } /* if the end else fake it */
1471
1472         /* Do loop. */
1473         while (c == ',') {
1474 #ifdef WANT_BITFIELDS
1475                 unsigned int bits_available = BITS_PER_CHAR * nbytes;
1476                 /* used for error messages and rescanning */
1477                 char *hold = input_line_pointer;
1478 #endif /* WANT_BITFIELDS */
1479
1480                 /* At least scan over the expression. */
1481                 segment = expression(&exp);
1482
1483 #ifdef WANT_BITFIELDS
1484                 /* Some other assemblers, (eg, asm960), allow
1485                    bitfields after ".byte" as w:x,y:z, where w and
1486                    y are bitwidths and x and y are values.  They
1487                    then pack them all together. We do a little
1488                    better in that we allow them in words, longs,
1489                    etc. and we'll pack them in target byte order
1490                    for you.
1491
1492                    The rules are: pack least significat bit first,
1493                    if a field doesn't entirely fit, put it in the
1494                    next unit.  Overflowing the bitfield is
1495                    explicitly *not* even a warning.  The bitwidth
1496                    should be considered a "mask".
1497
1498                    FIXME-SOMEDAY: If this is considered generally
1499                    useful, this logic should probably be reworked.
1500                    xoxorich. */
1501
1502                 if (*input_line_pointer == ':') { /* bitfields */
1503                         long value = 0;
1504
1505                         for (;;) {
1506                                 unsigned long width;
1507
1508                                 if (*input_line_pointer != ':') {
1509                                         input_line_pointer = hold;
1510                                         break;
1511                                 } /* next piece is not a bitfield */
1512
1513                                 /* In the general case, we can't allow
1514                                    full expressions with symbol
1515                                    differences and such.  The relocation
1516                                    entries for symbols not defined in this
1517                                    assembly would require arbitrary field
1518                                    widths, positions, and masks which most
1519                                    of our current object formats don't
1520                                    support.
1521
1522                                    In the specific case where a symbol
1523                                    *is* defined in this assembly, we
1524                                    *could* build fixups and track it, but
1525                                    this could lead to confusion for the
1526                                    backends.  I'm lazy. I'll take any
1527                                    SEG_ABSOLUTE. I think that means that
1528                                    you can use a previous .set or
1529                                    .equ type symbol.  xoxorich. */
1530
1531                                 if (segment == SEG_ABSENT) {
1532                                         as_warn("Using a bit field width of zero.");
1533                                         exp.X_add_number = 0;
1534                                         segment = SEG_ABSOLUTE;
1535                                 } /* implied zero width bitfield */
1536
1537                                 if (segment != SEG_ABSOLUTE) {
1538                                         *input_line_pointer = '\0';
1539                                         as_bad("Field width \"%s\" too complex for a bitfield.\n", hold);
1540                                         *input_line_pointer = ':';
1541                                         demand_empty_rest_of_line();
1542                                         return;
1543                                 } /* too complex */
1544
1545                                 if ((width = exp.X_add_number) > (BITS_PER_CHAR * nbytes)) {
1546                                         as_warn("Field width %d too big to fit in %d bytes: truncated to %d bits.",
1547                                                 width, nbytes, (BITS_PER_CHAR * nbytes));
1548                                         width = BITS_PER_CHAR * nbytes;
1549                                 } /* too big */
1550
1551                                 if (width > bits_available) {
1552                                         /* FIXME-SOMEDAY: backing up and
1553                                            reparsing is wasteful */
1554                                         input_line_pointer = hold;
1555                                         exp.X_add_number = value;
1556                                         break;
1557                                 } /* won't fit */
1558
1559                                 hold = ++input_line_pointer; /* skip ':' */
1560
1561                                 if ((segment = expression(&exp)) != SEG_ABSOLUTE) {
1562                                         char cache = *input_line_pointer;
1563
1564                                         *input_line_pointer = '\0';
1565                                         as_bad("Field value \"%s\" too complex for a bitfield.\n", hold);
1566                                         *input_line_pointer = cache;
1567                                         demand_empty_rest_of_line();
1568                                         return;
1569                                 } /* too complex */
1570
1571                                 value |= (~(-1 << width) & exp.X_add_number)
1572                                     << ((BITS_PER_CHAR * nbytes) - bits_available);
1573
1574                                 if ((bits_available -= width) == 0
1575                                     || is_it_end_of_statement()
1576                                     || *input_line_pointer != ',') {
1577                                         break;
1578                                 } /* all the bitfields we're gonna get */
1579
1580                                 hold = ++input_line_pointer;
1581                                 segment = expression(&exp);
1582                         } /* forever loop */
1583
1584                         exp.X_add_number = value;
1585                         segment = SEG_ABSOLUTE;
1586                 }       /* if looks like a bitfield */
1587 #endif /* WANT_BITFIELDS */
1588
1589                 if (!need_pass_2) { /* Still worthwhile making frags. */
1590
1591                         /* Don't call this if we are going to junk this pass anyway! */
1592                         know(segment != SEG_PASS1);
1593
1594                         if (segment == SEG_DIFFERENCE && exp.X_add_symbol == NULL) {
1595                                 as_bad("Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.",
1596                                        S_GET_NAME(exp.X_subtract_symbol),
1597                                        segment_name(S_GET_SEGMENT(exp.X_subtract_symbol)));
1598                                 segment = SEG_ABSOLUTE;
1599                                 /* Leave exp . X_add_number alone. */
1600                         }
1601                         p = frag_more(nbytes);
1602                         switch (segment) {
1603                         case SEG_BIG:
1604                                 as_bad("%s number invalid. Absolute 0 assumed.",
1605                                        exp . X_add_number > 0 ? "Bignum" : "Floating-Point");
1606                                 md_number_to_chars (p, (long)0, nbytes);
1607                                 break;
1608
1609                         case SEG_ABSENT:
1610                                 as_warn("0 assumed for missing expression");
1611                                 exp . X_add_number = 0;
1612                                 know(exp . X_add_symbol == NULL);
1613                                 /* fall into SEG_ABSOLUTE */
1614                         case SEG_ABSOLUTE:
1615                                 get = exp . X_add_number;
1616                                 use = get & unmask;
1617                                 if ((get & mask) && (get & mask) != mask)
1618                                     {           /* Leading bits contain both 0s & 1s. */
1619                                             as_warn("Value 0x%x truncated to 0x%x.", get, use);
1620                                     }
1621                                 md_number_to_chars (p, use, nbytes); /* put bytes in right order. */
1622                                 break;
1623
1624                         case SEG_DIFFERENCE:
1625 #ifndef WORKING_DOT_WORD
1626                                 if (nbytes==2) {
1627                                         struct broken_word *x;
1628
1629                                         x=(struct broken_word *)xmalloc(sizeof(struct broken_word));
1630                                         x->next_broken_word=broken_words;
1631                                         broken_words=x;
1632                                         x->frag=frag_now;
1633                                         x->word_goes_here=p;
1634                                         x->dispfrag=0;
1635                                         x->add=exp.X_add_symbol;
1636                                         x->sub=exp.X_subtract_symbol;
1637                                         x->addnum=exp.X_add_number;
1638                                         x->added=0;
1639                                         new_broken_words++;
1640                                         break;
1641                                 }
1642                                 /* Else Fall through into. . . */
1643 #endif
1644                         default:
1645                         case SEG_UNKNOWN:
1646 #ifdef TC_NS32K
1647                                 fix_new_ns32k (frag_now, p - frag_now->fr_literal, nbytes,
1648                                                exp . X_add_symbol, exp . X_subtract_symbol,
1649                                                exp . X_add_number, 0, 0, 2, 0, 0);
1650 #else
1651                                 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
1652                                          exp . X_add_symbol, exp . X_subtract_symbol,
1653                                          exp . X_add_number, 0, RELOC_32);
1654 #endif /* TC_NS32K */
1655                                 break;
1656                         } /* switch(segment) */
1657                 } /* if (!need_pass_2) */
1658                 c = *input_line_pointer++;
1659         } /* while(c==',') */
1660         input_line_pointer--;   /* Put terminator back into stream. */
1661         demand_empty_rest_of_line();
1662 } /* cons() */
1663 \f
1664 /*
1665  *                      big_cons()
1666  *
1667  * CONStruct more frag(s) of .quads, or .octa etc.
1668  * Makes 0 or more new frags.
1669  * If need_pass_2 == 1, generate no frag.
1670  * This understands only bignums, not expressions. Cons() understands
1671  * expressions.
1672  *
1673  * Constants recognised are '0...'(octal) '0x...'(hex) '...'(decimal).
1674  *
1675  * This creates objects with struct obstack_control objs, destroying
1676  * any context objs held about a partially completed object. Beware!
1677  *
1678  *
1679  * I think it sucks to have 2 different types of integers, with 2
1680  * routines to read them, store them etc.
1681  * It would be nicer to permit bignums in expressions and only
1682  * complain if the result overflowed. However, due to "efficiency"...
1683  */
1684 /* worker to do .quad etc statements */
1685 /* clobbers input_line_pointer, checks */
1686 /* end-of-line. */
1687 /* 8=.quad 16=.octa ... */
1688
1689 void big_cons(nbytes)
1690 register int nbytes;
1691 {
1692         register char c;        /* input_line_pointer->c. */
1693         register int radix;
1694         register long length;   /* Number of chars in an object. */
1695         register int digit;     /* Value of 1 digit. */
1696         register int carry;     /* For multi-precision arithmetic. */
1697         register int work;      /* For multi-precision arithmetic. */
1698         register char * p;      /* For multi-precision arithmetic. */
1699
1700         extern char hex_value[];        /* In hex_value.c. */
1701
1702         /*
1703          * The following awkward logic is to parse ZERO or more strings,
1704          * comma seperated. Recall an expression includes its leading &
1705          * trailing blanks. We fake a leading ',' if there is (supposed to
1706          * be) a 1st expression, and keep demanding 1 expression for each ','.
1707          */
1708         if (is_it_end_of_statement())
1709             {
1710                     c = 0;                      /* Skip loop. */
1711             }
1712         else
1713             {
1714                     c = ',';                    /* Do loop. */
1715                     -- input_line_pointer;
1716             }
1717         while (c == ',')
1718             {
1719                     ++ input_line_pointer;
1720                     SKIP_WHITESPACE();
1721                     c = * input_line_pointer;
1722                     /* C contains 1st non-blank character of what we hope is a number. */
1723                     if (c == '0')
1724                         {
1725                                 c = * ++ input_line_pointer;
1726                                 if (c == 'x' || c=='X')
1727                                     {
1728                                             c = * ++ input_line_pointer;
1729                                             radix = 16;
1730                                     }
1731                                 else
1732                                     {
1733                                             radix = 8;
1734                                     }
1735                         }
1736                     else
1737                         {
1738                                 radix = 10;
1739                         }
1740                     /*
1741                      * This feature (?) is here to stop people worrying about
1742                      * mysterious zero constants: which is what they get when
1743                      * they completely omit digits.
1744                      */
1745                     if (hex_value[c] >= radix) {
1746                             as_bad("Missing digits. 0 assumed.");
1747                     }
1748                     bignum_high = bignum_low - 1; /* Start constant with 0 chars. */
1749                     for(;   (digit = hex_value [c]) < radix;   c = * ++ input_line_pointer)
1750                         {
1751                                 /* Multiply existing number by radix, then add digit. */
1752                                 carry = digit;
1753                                 for (p=bignum_low;   p <= bignum_high;   p++)
1754                                     {
1755                                             work = (*p & MASK_CHAR) * radix + carry;
1756                                             *p = work & MASK_CHAR;
1757                                             carry = work >> BITS_PER_CHAR;
1758                                     }
1759                                 if (carry)
1760                                     {
1761                                             grow_bignum();
1762                                             * bignum_high = carry & MASK_CHAR;
1763                                             know((carry & ~ MASK_CHAR) == 0);
1764                                     }
1765                         }
1766                     length = bignum_high - bignum_low + 1;
1767                     if (length > nbytes)
1768                         {
1769                                 as_warn("Most significant bits truncated in integer constant.");
1770                         }
1771                     else
1772                         {
1773                                 register long leading_zeroes;
1774
1775                                 for(leading_zeroes = nbytes - length;
1776                                     leading_zeroes;
1777                                     leading_zeroes --)
1778                                     {
1779                                             grow_bignum();
1780                                             * bignum_high = 0;
1781                                     }
1782                         }
1783                     if (! need_pass_2)
1784                         {
1785                                 p = frag_more (nbytes);
1786                                 bcopy (bignum_low, p, (int)nbytes);
1787                         }
1788                     /* C contains character after number. */
1789                     SKIP_WHITESPACE();
1790                     c = * input_line_pointer;
1791                     /* C contains 1st non-blank character after number. */
1792             }
1793         demand_empty_rest_of_line();
1794 } /* big_cons() */
1795
1796 /* Extend bignum by 1 char. */
1797 static void grow_bignum() {
1798         register long length;
1799
1800         bignum_high ++;
1801         if (bignum_high >= bignum_limit)
1802             {
1803                     length = bignum_limit - bignum_low;
1804                     bignum_low = xrealloc(bignum_low, length + length);
1805                     bignum_high = bignum_low + length;
1806                     bignum_limit = bignum_low + length + length;
1807             }
1808 } /* grow_bignum(); */
1809 \f
1810 /*
1811  *                      float_cons()
1812  *
1813  * CONStruct some more frag chars of .floats .ffloats etc.
1814  * Makes 0 or more new frags.
1815  * If need_pass_2 == 1, no frags are emitted.
1816  * This understands only floating literals, not expressions. Sorry.
1817  *
1818  * A floating constant is defined by atof_generic(), except it is preceded
1819  * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
1820  * reading, I decided to be incompatible. This always tries to give you
1821  * rounded bits to the precision of the pseudo-op. Former AS did premature
1822  * truncatation, restored noisy bits instead of trailing 0s AND gave you
1823  * a choice of 2 flavours of noise according to which of 2 floating-point
1824  * scanners you directed AS to use.
1825  *
1826  * In:  input_line_pointer->whitespace before, or '0' of flonum.
1827  *
1828  */
1829
1830 void    /* JF was static, but can't be if VAX.C is goning to use it */
1831     float_cons(float_type)              /* Worker to do .float etc statements. */
1832 /* Clobbers input_line-pointer, checks end-of-line. */
1833 register int float_type;        /* 'f':.ffloat ... 'F':.float ... */
1834 {
1835         register char * p;
1836         register char c;
1837         int length;     /* Number of chars in an object. */
1838         register char * err;    /* Error from scanning floating literal. */
1839         char temp [MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
1840
1841         /*
1842          * The following awkward logic is to parse ZERO or more strings,
1843          * comma seperated. Recall an expression includes its leading &
1844          * trailing blanks. We fake a leading ',' if there is (supposed to
1845          * be) a 1st expression, and keep demanding 1 expression for each ','.
1846          */
1847         if (is_it_end_of_statement())
1848             {
1849                     c = 0;                      /* Skip loop. */
1850                     ++ input_line_pointer;      /*->past termintor. */
1851             }
1852         else
1853             {
1854                     c = ',';                    /* Do loop. */
1855             }
1856         while (c == ',')
1857             {
1858                     /* input_line_pointer->1st char of a flonum (we hope!). */
1859                     SKIP_WHITESPACE();
1860                     /* Skip any 0{letter} that may be present. Don't even check if the
1861                      * letter is legal. Someone may invent a "z" format and this routine
1862                      * has no use for such information. Lusers beware: you get
1863                      * diagnostics if your input is ill-conditioned.
1864                      */
1865
1866                     if (input_line_pointer[0]=='0' && isalpha(input_line_pointer[1]))
1867                         input_line_pointer+=2;
1868
1869                     err = md_atof (float_type, temp, &length);
1870                     know(length <=  MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
1871                     know(length > 0);
1872                     if (* err)
1873                         {
1874                                 as_bad("Bad floating literal: %s", err);
1875                                 ignore_rest_of_line();
1876                                 /* Input_line_pointer->just after end-of-line. */
1877                                 c = 0;          /* Break out of loop. */
1878                         }
1879                     else
1880                         {
1881                                 if (! need_pass_2)
1882                                     {
1883                                             p = frag_more (length);
1884                                             bcopy (temp, p, length);
1885                                     }
1886                                 SKIP_WHITESPACE();
1887                                 c = * input_line_pointer ++;
1888                                 /* C contains 1st non-white character after number. */
1889                                 /* input_line_pointer->just after terminator (c). */
1890                         }
1891             }
1892         -- input_line_pointer;          /*->terminator (is not ','). */
1893         demand_empty_rest_of_line();
1894 }                               /* float_cons() */
1895 \f
1896 /*
1897  *                      stringer()
1898  *
1899  * We read 0 or more ',' seperated, double-quoted strings.
1900  *
1901  * Caller should have checked need_pass_2 is FALSE because we don't check it.
1902  */
1903
1904
1905 void stringer(append_zero )             /* Worker to do .ascii etc statements. */
1906 /* Checks end-of-line. */
1907 register int append_zero;       /* 0: don't append '\0', else 1 */
1908 {
1909         /* register char *      p; JF unused */
1910         /* register int length; JF unused */    /* Length of string we read, excluding */
1911         /* trailing '\0' implied by closing quote. */
1912         /* register char *      where; JF unused */
1913         /* register fragS *     fragP; JF unused */
1914         register unsigned int c;
1915
1916         /*
1917          * The following awkward logic is to parse ZERO or more strings,
1918          * comma seperated. Recall a string expression includes spaces
1919          * before the opening '\"' and spaces after the closing '\"'.
1920          * We fake a leading ',' if there is (supposed to be)
1921          * a 1st, expression. We keep demanding expressions for each
1922          * ','.
1923          */
1924         if (is_it_end_of_statement())
1925             {
1926                     c = 0; /* Skip loop. */
1927                     ++ input_line_pointer; /* Compensate for end of loop. */
1928             }
1929         else
1930             {
1931                     c = ','; /* Do loop. */
1932             }
1933         while (c == ',' || c == '<' || c == '"' ) {
1934                 SKIP_WHITESPACE();
1935                 switch (*input_line_pointer) {
1936                 case  '\"':
1937                         ++input_line_pointer; /*->1st char of string. */
1938                         while (is_a_char(c = next_char_of_string())) {
1939                                 FRAG_APPEND_1_CHAR(c);
1940                         }
1941                         if (append_zero) {
1942                                 FRAG_APPEND_1_CHAR(0);
1943                         }
1944                         know(input_line_pointer [-1] == '\"');
1945                         break;
1946                 case '<':
1947                         input_line_pointer++;
1948                         c =get_single_number();
1949                         FRAG_APPEND_1_CHAR(c);
1950                         if(*input_line_pointer != '>') {
1951                                 as_bad("Expected <nn>");
1952                         }
1953                         input_line_pointer++;
1954                         break;
1955                 case ',':
1956                         input_line_pointer++;
1957                         break;
1958                 }
1959                 SKIP_WHITESPACE();
1960                 c = *input_line_pointer;
1961         }
1962
1963         demand_empty_rest_of_line();
1964 } /* stringer() */
1965 \f
1966 /* FIXME-SOMEDAY: I had trouble here on characters with the
1967    high bits set.  We'll probably also have trouble with
1968    multibyte chars, wide chars, etc.  Also be careful about
1969    returning values bigger than 1 byte.  xoxorich. */
1970
1971 unsigned int next_char_of_string() {
1972         register unsigned int c;
1973
1974         c = *input_line_pointer++ & CHAR_MASK;
1975         switch (c) {
1976         case '\"':
1977                 c = NOT_A_CHAR;
1978                 break;
1979
1980         case '\\':
1981                 switch (c = *input_line_pointer++) {
1982                 case 'b':
1983                         c = '\b';
1984                         break;
1985
1986                 case 'f':
1987                         c = '\f';
1988                         break;
1989
1990                 case 'n':
1991                         c = '\n';
1992                         break;
1993
1994                 case 'r':
1995                         c = '\r';
1996                         break;
1997
1998                 case 't':
1999                         c = '\t';
2000                         break;
2001
2002 #ifdef BACKSLASH_V
2003                 case 'v':
2004                         c = '\013';
2005                         break;
2006 #endif
2007
2008                 case '\\':
2009                 case '"':
2010                         break;          /* As itself. */
2011
2012                 case '0':
2013                 case '1':
2014                 case '2':
2015                 case '3':
2016                 case '4':
2017                 case '5':
2018                 case '6':
2019                 case '7':
2020                 case '8':
2021                 case '9': {
2022                         long number;
2023
2024                         for (number = 0; isdigit(c); c = *input_line_pointer++) {
2025                                 number = number * 8 + c - '0';
2026                         }
2027                         c = number & 0xff;
2028                 }
2029                         --input_line_pointer;
2030                         break;
2031
2032                 case '\n':
2033                         /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
2034                         as_warn("Unterminated string: Newline inserted.");
2035                         c = '\n';
2036                         break;
2037
2038                 default:
2039
2040 #ifdef ONLY_STANDARD_ESCAPES
2041                         as_bad("Bad escaped character in string, '?' assumed");
2042                         c = '?';
2043 #endif /* ONLY_STANDARD_ESCAPES */
2044
2045                         break;
2046                 } /* switch on escaped char */
2047                 break;
2048
2049         default:
2050                 break;
2051         } /* switch on char */
2052         return(c);
2053 } /* next_char_of_string() */
2054 \f
2055 static segT
2056     get_segmented_expression (expP)
2057 register expressionS *  expP;
2058 {
2059         register segT           retval;
2060
2061         if ((retval = expression(expP)) == SEG_PASS1 || retval == SEG_ABSENT || retval == SEG_BIG)
2062             {
2063                     as_bad("Expected address expression: absolute 0 assumed");
2064                     retval = expP->X_seg = SEG_ABSOLUTE;
2065                     expP->X_add_number   = 0;
2066                     expP->X_add_symbol   = expP->X_subtract_symbol = 0;
2067             }
2068         return (retval);                /* SEG_ ABSOLUTE,UNKNOWN,DATA,TEXT,BSS */
2069 }
2070
2071 static segT get_known_segmented_expression(expP)
2072 register expressionS *expP;
2073 {
2074         register segT           retval;
2075         register char * name1;
2076         register char * name2;
2077
2078         if ((retval = get_segmented_expression (expP)) == SEG_UNKNOWN)
2079             {
2080                     name1 = expP->X_add_symbol ? S_GET_NAME(expP->X_add_symbol) : "";
2081                     name2 = expP->X_subtract_symbol ?
2082                         S_GET_NAME(expP->X_subtract_symbol) :
2083                             "";
2084                     if (name1 && name2)
2085                         {
2086                                 as_warn("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.",
2087                                         name1, name2);
2088                         }
2089                     else
2090                         {
2091                                 as_warn("Symbol \"%s\" undefined: absolute 0 assumed.",
2092                                         name1 ? name1 : name2);
2093                         }
2094                     retval = expP->X_seg = SEG_ABSOLUTE;
2095                     expP->X_add_number   = 0;
2096                     expP->X_add_symbol   = expP->X_subtract_symbol = NULL;
2097             }
2098 #ifndef MANY_SEGMENTS
2099         know(retval == SEG_ABSOLUTE || retval == SEG_DATA || retval == SEG_TEXT || retval == SEG_BSS || retval == SEG_DIFFERENCE);
2100 #endif
2101         return (retval);
2102
2103 }                               /* get_known_segmented_expression() */
2104
2105
2106
2107 /* static */ long /* JF was static, but can't be if the MD pseudos are to use it */
2108     get_absolute_expression ()
2109 {
2110         expressionS     exp;
2111         register segT s;
2112
2113         if ((s = expression(& exp)) != SEG_ABSOLUTE)
2114             {
2115                     if (s != SEG_ABSENT)
2116                         {
2117                                 as_bad("Bad Absolute Expression, absolute 0 assumed.");
2118                         }
2119                     exp . X_add_number = 0;
2120             }
2121         return (exp . X_add_number);
2122 }
2123
2124 char /* return terminator */
2125     get_absolute_expression_and_terminator(val_pointer)
2126 long *          val_pointer; /* return value of expression */
2127 {
2128         * val_pointer = get_absolute_expression ();
2129         return (* input_line_pointer ++);
2130 }
2131 \f
2132 /*
2133  *                      demand_copy_C_string()
2134  *
2135  * Like demand_copy_string, but return NULL if the string contains any '\0's.
2136  * Give a warning if that happens.
2137  */
2138 char *
2139     demand_copy_C_string (len_pointer)
2140 int *   len_pointer;
2141 {
2142         register char * s;
2143
2144         if ((s = demand_copy_string(len_pointer)) != 0)
2145             {
2146                     register int len;
2147
2148                     for (len = * len_pointer;
2149                          len > 0;
2150                          len--)
2151                         {
2152                                 if (* s == 0)
2153                                     {
2154                                             s = 0;
2155                                             len = 1;
2156                                             * len_pointer = 0;
2157                                             as_bad("This string may not contain \'\\0\'");
2158                                     }
2159                         }
2160             }
2161         return (s);
2162 }
2163 \f
2164 /*
2165  *                      demand_copy_string()
2166  *
2167  * Demand string, but return a safe (=private) copy of the string.
2168  * Return NULL if we can't read a string here.
2169  */
2170 static char *demand_copy_string(lenP)
2171 int *lenP;
2172 {
2173         register unsigned int c;
2174         register int len;
2175         char *retval;
2176
2177         len = 0;
2178         SKIP_WHITESPACE();
2179         if (*input_line_pointer == '\"') {
2180                 input_line_pointer++;   /* Skip opening quote. */
2181
2182                 while (is_a_char(c = next_char_of_string())) {
2183                         obstack_1grow(&notes, c);
2184                         len ++;
2185                 }
2186                 /* JF this next line is so demand_copy_C_string will return a null
2187                    termanated string. */
2188                 obstack_1grow(&notes,'\0');
2189                 retval=obstack_finish(&notes);
2190         } else {
2191                 as_warn("Missing string");
2192                 retval = NULL;
2193                 ignore_rest_of_line();
2194         }
2195         *lenP = len;
2196         return(retval);
2197 } /* demand_copy_string() */
2198 \f
2199 /*
2200  *              is_it_end_of_statement()
2201  *
2202  * In:  Input_line_pointer->next character.
2203  *
2204  * Do:  Skip input_line_pointer over all whitespace.
2205  *
2206  * Out: 1 if input_line_pointer->end-of-line.
2207  */
2208 int is_it_end_of_statement() {
2209         SKIP_WHITESPACE();
2210         return (is_end_of_line [* input_line_pointer]);
2211 } /* is_it_end_of_statement() */
2212
2213 void equals(sym_name)
2214 char *sym_name;
2215 {
2216         register symbolS *symbolP; /* symbol we are working with */
2217
2218         input_line_pointer++;
2219         if (*input_line_pointer=='=')
2220             input_line_pointer++;
2221
2222         while(*input_line_pointer==' ' || *input_line_pointer=='\t')
2223             input_line_pointer++;
2224
2225         if (sym_name[0]=='.' && sym_name[1]=='\0') {
2226                 /* Turn '. = mumble' into a .org mumble */
2227                 register segT segment;
2228                 expressionS exp;
2229                 register char *p;
2230
2231                 segment = get_known_segmented_expression(& exp);
2232                 if (! need_pass_2) {
2233                         if (segment != now_seg && segment != SEG_ABSOLUTE)
2234                             as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
2235                                     segment_name(segment),
2236                                     segment_name(now_seg));
2237                         p = frag_var(rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
2238                                      exp.X_add_number, (char *)0);
2239                         * p = 0;
2240                 } /* if (ok to make frag) */
2241         } else {
2242                 symbolP=symbol_find_or_make(sym_name);
2243                 pseudo_set(symbolP);
2244         }
2245 } /* equals() */
2246
2247 /* .include -- include a file at this point. */
2248
2249 /* ARGSUSED */
2250 void s_include(arg)
2251 int arg;
2252 {
2253         char *newbuf;
2254         char *filename;
2255         int i;
2256         FILE *try;
2257         char *path;
2258
2259         filename = demand_copy_string(&i);
2260         demand_empty_rest_of_line();
2261         path = xmalloc(i + include_dir_maxlen + 5 /* slop */);
2262         for (i = 0; i < include_dir_count; i++) {
2263                 strcpy(path, include_dirs[i]);
2264                 strcat(path, "/");
2265                 strcat(path, filename);
2266                 if (0 != (try = fopen(path, "r")))
2267                     {
2268                             fclose (try);
2269                             goto gotit;
2270                     }
2271         }
2272         free(path);
2273         path = filename;
2274  gotit:
2275         /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY. */
2276         newbuf = input_scrub_include_file (path, input_line_pointer);
2277         buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2278 } /* s_include() */
2279
2280 void add_include_dir(path)
2281 char *path;
2282 {
2283         int i;
2284
2285         if (include_dir_count == 0)
2286             {
2287                     include_dirs = (char **)xmalloc (2 * sizeof (*include_dirs));
2288                     include_dirs[0] = ".";      /* Current dir */
2289                     include_dir_count = 2;
2290             }
2291         else
2292             {
2293                     include_dir_count++;
2294                     include_dirs = (char **) realloc(include_dirs,
2295                                                      include_dir_count*sizeof (*include_dirs));
2296             }
2297
2298         include_dirs[include_dir_count-1] = path;       /* New one */
2299
2300         i = strlen (path);
2301         if (i > include_dir_maxlen)
2302             include_dir_maxlen = i;
2303 } /* add_include_dir() */
2304
2305 void s_ignore(arg)
2306 int arg;
2307 {
2308         extern char is_end_of_line[];
2309
2310         while (!is_end_of_line[*input_line_pointer]) {
2311                 ++input_line_pointer;
2312         }
2313         ++input_line_pointer;
2314
2315         return;
2316 } /* s_ignore() */
2317
2318 /*
2319  * Local Variables:
2320  * comment-column: 0
2321  * fill-column: 131
2322  * End:
2323  */
2324
2325 /* end of read.c */