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