gas/read.c

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