gas/read.c

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