gas/read.c

   1 /* read.c - read a source file -
   2    Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 1996
   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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 #include "sb.h"
  46 #include "macro.h"
  47 #include "libiberty.h"
  48 #include "obstack.h"
  49 #include "listing.h"
  50
  51 #ifndef TC_START_LABEL
  52 #define TC_START_LABEL(x,y) (x==':')
  53 #endif
  54
  55 /* The NOP_OPCODE is for the alignment fill value.
  56  * fill it a nop instruction so that the disassembler does not choke
  57  * on it
  58  */
  59 #ifndef NOP_OPCODE
  60 #define NOP_OPCODE 0x00
  61 #endif
  62
  63 char *input_line_pointer;       /*->next char of source file to parse. */
  64
  65 int generate_asm_lineno = 0;    /* flag to generate line stab for .s file */
  66
  67 #if BITS_PER_CHAR != 8
  68 /*  The following table is indexed by[(char)] and will break if
  69     a char does not have exactly 256 states (hopefully 0:255!)!  */
  70 die horribly;
  71 #endif
  72
  73 #ifndef LEX_AT
  74 /* The m88k unfortunately uses @ as a label beginner.  */
  75 #define LEX_AT 0
  76 #endif
  77
  78 #ifndef LEX_BR
  79 /* The RS/6000 assembler uses {,},[,] as parts of symbol names.  */
  80 #define LEX_BR 0
  81 #endif
  82
  83 #ifndef LEX_PCT
  84 /* The Delta 68k assembler permits % inside label names.  */
  85 #define LEX_PCT 0
  86 #endif
  87
  88 #ifndef LEX_QM
  89 /* The PowerPC Windows NT assemblers permits ? inside label names.  */
  90 #define LEX_QM 0
  91 #endif
  92
  93 #ifndef LEX_DOLLAR
  94 /* The a29k assembler does not permits labels to start with $.  */
  95 #define LEX_DOLLAR 3
  96 #endif
  97
  98 /* used by is_... macros. our ctype[] */
  99 char lex_type[256] =
 100 {
 101   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* @ABCDEFGHIJKLMNO */
 102   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* PQRSTUVWXYZ[\]^_ */
 103   0, 0, 0, 0, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
 104   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM,  /* 0123456789:;<=>? */
 105   LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,  /* @ABCDEFGHIJKLMNO */
 106   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
 107   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* `abcdefghijklmno */
 108   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 0, /* pqrstuvwxyz{|}~. */
 109   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 110   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 111   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 112   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 113   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 114   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 115   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 116 };
 117
 118
 119 /*
 120  * In: a character.
 121  * Out: 1 if this character ends a line.
 122  */
 123 #define _ (0)
 124 char is_end_of_line[256] =
 125 {
 126 #ifdef CR_EOL
 127   _, _, _, _, _, _, _, _, _, _, 99, _, _, 99, _, _,     /* @abcdefghijklmno */
 128 #else
 129   _, _, _, _, _, _, _, _, _, _, 99, _, _, _, _, _,      /* @abcdefghijklmno */
 130 #endif
 131   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 132 #ifdef TC_HPPA
 133   _,99, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* _!"#$%&'()*+,-./ */
 134   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* 0123456789:;<=>? */
 135 #else
 136   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 137   _, _, _, _, _, _, _, _, _, _, _, 99, _, _, _, _,      /* 0123456789:;<=>? */
 138 #endif
 139   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 140   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 141   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 142   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 143   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 144   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 145   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 146   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 147   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,       /* */
 148 };
 149 #undef _
 150
 151 /* Functions private to this file. */
 152
 153 static char *buffer;    /* 1st char of each buffer of lines is here. */
 154 static char *buffer_limit;      /*->1 + last char in buffer. */
 155
 156 #ifdef TARGET_BYTES_BIG_ENDIAN
 157 /* Hack to deal with tc-*.h defining TARGET_BYTES_BIG_ENDIAN to empty
 158    instead of to 0 or 1.  */
 159 #if 5 - TARGET_BYTES_BIG_ENDIAN - 5 == 10
 160 #undef  TARGET_BYTES_BIG_ENDIAN
 161 #define TARGET_BYTES_BIG_ENDIAN 1
 162 #endif
 163 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
 164 #else
 165 int target_big_endian /* = 0 */;
 166 #endif
 167
 168 static char *old_buffer;        /* JF a hack */
 169 static char *old_input;
 170 static char *old_limit;
 171
 172 /* Variables for handling include file directory list. */
 173
 174 char **include_dirs;    /* List of pointers to directories to
 175                            search for .include's */
 176 int include_dir_count;  /* How many are in the list */
 177 int include_dir_maxlen = 1;/* Length of longest in list */
 178
 179 #ifndef WORKING_DOT_WORD
 180 struct broken_word *broken_words;
 181 int new_broken_words;
 182 #endif
 183
 184 /* The current offset into the absolute section.  We don't try to
 185    build frags in the absolute section, since no data can be stored
 186    there.  We just keep track of the current offset.  */
 187 addressT abs_section_offset;
 188
 189 /* If this line had an MRI style label, it is stored in this variable.
 190    This is used by some of the MRI pseudo-ops.  */
 191 symbolS *line_label;
 192
 193 /* This global variable is used to support MRI common sections.  We
 194    translate such sections into a common symbol.  This variable is
 195    non-NULL when we are in an MRI common section.  */
 196 symbolS *mri_common_symbol;
 197
 198 /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
 199    need to align to an even byte boundary unless the next pseudo-op is
 200    dc.b, ds.b, or dcb.b.  This variable is set to 1 if an alignment
 201    may be needed.  */
 202 static int mri_pending_align;
 203
 204 static int scrub_from_string PARAMS ((char **));
 205 static void do_align PARAMS ((int, char *, int));
 206 static int hex_float PARAMS ((int, char *));
 207 static void do_org PARAMS ((segT, expressionS *, int));
 208 char *demand_copy_string PARAMS ((int *lenP));
 209 int is_it_end_of_statement PARAMS ((void));
 210 static segT get_segmented_expression PARAMS ((expressionS *expP));
 211 static segT get_known_segmented_expression PARAMS ((expressionS * expP));
 212 static void pobegin PARAMS ((void));
 213 static int get_line_sb PARAMS ((sb *));
 214 \f
 215
 216 void
 217 read_begin ()
 218 {
 219   const char *p;
 220
 221   pobegin ();
 222   obj_read_begin_hook ();
 223
 224   /* Something close -- but not too close -- to a multiple of 1024.
 225      The debugging malloc I'm using has 24 bytes of overhead.  */
 226   obstack_begin (&notes, chunksize);
 227   obstack_begin (&cond_obstack, chunksize);
 228
 229   /* Use machine dependent syntax */
 230   for (p = line_separator_chars; *p; p++)
 231     is_end_of_line[(unsigned char) *p] = 1;
 232   /* Use more.  FIXME-SOMEDAY. */
 233
 234   if (flag_mri)
 235     lex_type['?'] = 3;
 236 }
 237 \f
 238 /* set up pseudo-op tables */
 239
 240 static struct hash_control *po_hash;
 241
 242 static const pseudo_typeS potable[] =
 243 {
 244   {"abort", s_abort, 0},
 245   {"align", s_align_ptwo, 0},
 246   {"ascii", stringer, 0},
 247   {"asciz", stringer, 1},
 248   {"balign", s_align_bytes, 0},
 249   {"balignw", s_align_bytes, -2},
 250   {"balignl", s_align_bytes, -4},
 251 /* block */
 252   {"byte", cons, 1},
 253   {"comm", s_comm, 0},
 254   {"common", s_mri_common, 0},
 255   {"common.s", s_mri_common, 1},
 256   {"data", s_data, 0},
 257   {"dc", cons, 2},
 258   {"dc.b", cons, 1},
 259   {"dc.d", float_cons, 'd'},
 260   {"dc.l", cons, 4},
 261   {"dc.s", float_cons, 'f'},
 262   {"dc.w", cons, 2},
 263   {"dc.x", float_cons, 'x'},
 264   {"dcb", s_space, 2},
 265   {"dcb.b", s_space, 1},
 266   {"dcb.d", s_float_space, 'd'},
 267   {"dcb.l", s_space, 4},
 268   {"dcb.s", s_float_space, 'f'},
 269   {"dcb.w", s_space, 2},
 270   {"dcb.x", s_float_space, 'x'},
 271   {"ds", s_space, 2},
 272   {"ds.b", s_space, 1},
 273   {"ds.d", s_space, 8},
 274   {"ds.l", s_space, 4},
 275   {"ds.p", s_space, 12},
 276   {"ds.s", s_space, 4},
 277   {"ds.w", s_space, 2},
 278   {"ds.x", s_space, 12},
 279   {"debug", s_ignore, 0},
 280 #ifdef S_SET_DESC
 281   {"desc", s_desc, 0},
 282 #endif
 283 /* dim */
 284   {"double", float_cons, 'd'},
 285 /* dsect */
 286   {"eject", listing_eject, 0},  /* Formfeed listing */
 287   {"else", s_else, 0},
 288   {"elsec", s_else, 0},
 289   {"end", s_end, 0},
 290   {"endc", s_endif, 0},
 291   {"endif", s_endif, 0},
 292 /* endef */
 293   {"equ", s_set, 0},
 294   {"err", s_err, 0},
 295   {"exitm", s_mexit, 0},
 296 /* extend */
 297   {"extern", s_ignore, 0},      /* We treat all undef as ext */
 298   {"appfile", s_app_file, 1},
 299   {"appline", s_app_line, 0},
 300   {"fail", s_fail, 0},
 301   {"file", s_app_file, 0},
 302   {"fill", s_fill, 0},
 303   {"float", float_cons, 'f'},
 304   {"format", s_ignore, 0},
 305   {"global", s_globl, 0},
 306   {"globl", s_globl, 0},
 307   {"hword", cons, 2},
 308   {"if", s_if, (int) O_ne},
 309   {"ifc", s_ifc, 0},
 310   {"ifdef", s_ifdef, 0},
 311   {"ifeq", s_if, (int) O_eq},
 312   {"ifeqs", s_ifeqs, 0},
 313   {"ifge", s_if, (int) O_ge},
 314   {"ifgt", s_if, (int) O_gt},
 315   {"ifle", s_if, (int) O_le},
 316   {"iflt", s_if, (int) O_lt},
 317   {"ifnc", s_ifc, 1},
 318   {"ifndef", s_ifdef, 1},
 319   {"ifne", s_if, (int) O_ne},
 320   {"ifnes", s_ifeqs, 1},
 321   {"ifnotdef", s_ifdef, 1},
 322   {"include", s_include, 0},
 323   {"int", cons, 4},
 324   {"irp", s_irp, 0},
 325   {"irep", s_irp, 0},
 326   {"irpc", s_irp, 1},
 327   {"irepc", s_irp, 1},
 328   {"lcomm", s_lcomm, 0},
 329   {"lflags", listing_flags, 0}, /* Listing flags */
 330   {"linkonce", s_linkonce, 0},
 331   {"list", listing_list, 1},    /* Turn listing on */
 332   {"llen", listing_psize, 1},
 333   {"long", cons, 4},
 334   {"lsym", s_lsym, 0},
 335   {"macro", s_macro, 0},
 336   {"mexit", s_mexit, 0},
 337   {"mri", s_mri, 0},
 338   {".mri", s_mri, 0},   /* Special case so .mri works in MRI mode.  */
 339   {"name", s_ignore, 0},
 340   {"noformat", s_ignore, 0},
 341   {"nolist", listing_list, 0},  /* Turn listing off */
 342   {"nopage", listing_nopage, 0},
 343   {"octa", cons, 16},
 344   {"offset", s_struct, 0},
 345   {"org", s_org, 0},
 346   {"p2align", s_align_ptwo, 0},
 347   {"p2alignw", s_align_ptwo, -2},
 348   {"p2alignl", s_align_ptwo, -4},
 349   {"page", listing_eject, 0},
 350   {"plen", listing_psize, 0},
 351   {"print", s_print, 0},
 352   {"psize", listing_psize, 0},  /* set paper size */
 353   {"purgem", s_purgem, 0},
 354   {"quad", cons, 8},
 355   {"rep", s_rept, 0},
 356   {"rept", s_rept, 0},
 357   {"rva", s_rva, 4},
 358   {"sbttl", listing_title, 1},  /* Subtitle of listing */
 359 /* scl */
 360 /* sect */
 361   {"set", s_set, 0},
 362   {"short", cons, 2},
 363   {"single", float_cons, 'f'},
 364 /* size */
 365   {"space", s_space, 0},
 366   {"skip", s_space, 0},
 367   {"spc", s_ignore, 0},
 368   {"stabd", s_stab, 'd'},
 369   {"stabn", s_stab, 'n'},
 370   {"stabs", s_stab, 's'},
 371   {"string", stringer, 1},
 372   {"struct", s_struct, 0},
 373 /* tag */
 374   {"text", s_text, 0},
 375
 376   /* This is for gcc to use.  It's only just been added (2/94), so gcc
 377      won't be able to use it for a while -- probably a year or more.
 378      But once this has been released, check with gcc maintainers
 379      before deleting it or even changing the spelling.  */
 380   {"this_GCC_requires_the_GNU_assembler", s_ignore, 0},
 381   /* If we're folding case -- done for some targets, not necessarily
 382      all -- the above string in an input file will be converted to
 383      this one.  Match it either way...  */
 384   {"this_gcc_requires_the_gnu_assembler", s_ignore, 0},
 385
 386   {"title", listing_title, 0},  /* Listing title */
 387   {"ttl", listing_title, 0},
 388 /* type */
 389 /* use */
 390 /* val */
 391   {"xcom", s_comm, 0},
 392   {"xdef", s_globl, 0},
 393   {"xref", s_ignore, 0},
 394   {"xstabs", s_xstab, 's'},
 395   {"word", cons, 2},
 396   {"zero", s_space, 0},
 397   {NULL}                        /* end sentinel */
 398 };
 399
 400 static int pop_override_ok = 0;
 401 static const char *pop_table_name;
 402
 403 void
 404 pop_insert (table)
 405      const pseudo_typeS *table;
 406 {
 407   const char *errtxt;
 408   const pseudo_typeS *pop;
 409   for (pop = table; pop->poc_name; pop++)
 410     {
 411       errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
 412       if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
 413         as_fatal ("error constructing %s pseudo-op table: %s", pop_table_name,
 414                   errtxt);
 415     }
 416 }
 417
 418 #ifndef md_pop_insert
 419 #define md_pop_insert()         pop_insert(md_pseudo_table)
 420 #endif
 421
 422 #ifndef obj_pop_insert
 423 #define obj_pop_insert()        pop_insert(obj_pseudo_table)
 424 #endif
 425
 426 static void
 427 pobegin ()
 428 {
 429   po_hash = hash_new ();
 430
 431   /* Do the target-specific pseudo ops. */
 432   pop_table_name = "md";
 433   md_pop_insert ();
 434
 435   /* Now object specific.  Skip any that were in the target table. */
 436   pop_table_name = "obj";
 437   pop_override_ok = 1;
 438   obj_pop_insert ();
 439
 440   /* Now portable ones.  Skip any that we've seen already. */
 441   pop_table_name = "standard";
 442   pop_insert (potable);
 443 }
 444 \f
 445 #define HANDLE_CONDITIONAL_ASSEMBLY()                                   \
 446   if (ignore_input ())                                                  \
 447     {                                                                   \
 448       while (! is_end_of_line[(unsigned char) *input_line_pointer++])   \
 449         if (input_line_pointer == buffer_limit)                         \
 450           break;                                                        \
 451       continue;                                                         \
 452     }
 453
 454
 455 /* This function is used when scrubbing the characters between #APP
 456    and #NO_APP.  */
 457
 458 static char *scrub_string;
 459 static char *scrub_string_end;
 460
 461 static int
 462 scrub_from_string (from)
 463      char **from;
 464 {
 465   int size;
 466
 467   *from = scrub_string;
 468   size = scrub_string_end - scrub_string;
 469   scrub_string = scrub_string_end;
 470   return size;
 471 }
 472
 473 /*      read_a_source_file()
 474  *
 475  * We read the file, putting things into a web that
 476  * represents what we have been reading.
 477  */
 478 void
 479 read_a_source_file (name)
 480      char *name;
 481 {
 482   register char c;
 483   register char *s;             /* string of symbol, '\0' appended */
 484   register int temp;
 485   pseudo_typeS *pop;
 486
 487   buffer = input_scrub_new_file (name);
 488
 489   listing_file (name);
 490   listing_newline ("");
 491
 492   while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
 493     {                           /* We have another line to parse. */
 494       know (buffer_limit[-1] == '\n');  /* Must have a sentinel. */
 495     contin:                     /* JF this goto is my fault I admit it.
 496                                    Someone brave please re-write the whole
 497                                    input section here?  Pleeze???  */
 498       while (input_line_pointer < buffer_limit)
 499         {
 500           /* We have more of this buffer to parse. */
 501
 502           /*
 503            * We now have input_line_pointer->1st char of next line.
 504            * If input_line_pointer [-1] == '\n' then we just
 505            * scanned another line: so bump line counters.
 506            */
 507           if (is_end_of_line[(unsigned char) input_line_pointer[-1]])
 508             {
 509 #ifdef md_start_line_hook
 510               md_start_line_hook ();
 511 #endif
 512
 513               if (input_line_pointer[-1] == '\n')
 514                 bump_line_counters ();
 515
 516               line_label = NULL;
 517
 518               if (flag_m68k_mri
 519 #ifdef LABELS_WITHOUT_COLONS
 520                   || 1
 521 #endif
 522                   )
 523                 {
 524                   /* Text at the start of a line must be a label, we
 525                      run down and stick a colon in.  */
 526                   if (is_name_beginner (*input_line_pointer))
 527                     {
 528                       char *line_start = input_line_pointer;
 529                       char c;
 530
 531                       HANDLE_CONDITIONAL_ASSEMBLY ();
 532
 533                       c = get_symbol_end ();
 534
 535                       /* In MRI mode, the EQU pseudoop must be
 536                          handled specially.  */
 537                       if (flag_m68k_mri)
 538                         {
 539                           char *rest = input_line_pointer + 1;
 540
 541                           if (*rest == ':')
 542                             ++rest;
 543                           if (*rest == ' ' || *rest == '\t')
 544                             ++rest;
 545                           if ((strncasecmp (rest, "EQU", 3) == 0
 546                                || strncasecmp (rest, "SET", 3) == 0)
 547                               && (rest[3] == ' ' || rest[3] == '\t'))
 548                             {
 549                               input_line_pointer = rest + 3;
 550                               equals (line_start);
 551                               continue;
 552                             }
 553                         }
 554
 555                       line_label = colon (line_start);
 556
 557                       *input_line_pointer = c;
 558                       if (c == ':')
 559                         input_line_pointer++;
 560                     }
 561                 }
 562             }
 563
 564           /*
 565            * We are at the begining of a line, or similar place.
 566            * We expect a well-formed assembler statement.
 567            * A "symbol-name:" is a statement.
 568            *
 569            * Depending on what compiler is used, the order of these tests
 570            * may vary to catch most common case 1st.
 571            * Each test is independent of all other tests at the (top) level.
 572            * PLEASE make a compiler that doesn't use this assembler.
 573            * It is crufty to waste a compiler's time encoding things for this
 574            * assembler, which then wastes more time decoding it.
 575            * (And communicating via (linear) files is silly!
 576            * If you must pass stuff, please pass a tree!)
 577            */
 578           if ((c = *input_line_pointer++) == '\t'
 579               || c == ' '
 580               || c == '\f'
 581               || c == 0)
 582             {
 583               c = *input_line_pointer++;
 584             }
 585           know (c != ' ');      /* No further leading whitespace. */
 586           LISTING_NEWLINE ();
 587           /*
 588            * C is the 1st significant character.
 589            * Input_line_pointer points after that character.
 590            */
 591           if (is_name_beginner (c))
 592             {
 593               /* want user-defined label or pseudo/opcode */
 594               HANDLE_CONDITIONAL_ASSEMBLY ();
 595
 596               s = --input_line_pointer;
 597               c = get_symbol_end ();    /* name's delimiter */
 598               /*
 599                * C is character after symbol.
 600                * That character's place in the input line is now '\0'.
 601                * S points to the beginning of the symbol.
 602                *   [In case of pseudo-op, s->'.'.]
 603                * Input_line_pointer->'\0' where c was.
 604                */
 605               if (TC_START_LABEL(c, input_line_pointer))
 606                 {
 607                   if (flag_m68k_mri)
 608                     {
 609                       char *rest = input_line_pointer + 1;
 610
 611                       /* In MRI mode, \tsym: set 0 is permitted.  */
 612
 613                       if (*rest == ':')
 614                         ++rest;
 615                       if (*rest == ' ' || *rest == '\t')
 616                         ++rest;
 617                       if ((strncasecmp (rest, "EQU", 3) == 0
 618                            || strncasecmp (rest, "SET", 3) == 0)
 619                           && (rest[3] == ' ' || rest[3] == '\t'))
 620                         {
 621                           input_line_pointer = rest + 3;
 622                           equals (s);
 623                           continue;
 624                         }
 625                     }
 626
 627                   line_label = colon (s);       /* user-defined label */
 628                   *input_line_pointer++ = ':';  /* Put ':' back for error messages' sake. */
 629                   /* Input_line_pointer->after ':'. */
 630                   SKIP_WHITESPACE ();
 631
 632
 633                 }
 634               else if (c == '='
 635                        || (input_line_pointer[1] == '='
 636 #ifdef TC_EQUAL_IN_INSN
 637                            && ! TC_EQUAL_IN_INSN (c, input_line_pointer)
 638 #endif
 639                            ))
 640                 {
 641                   equals (s);
 642                   demand_empty_rest_of_line ();
 643                 }
 644               else
 645                 {               /* expect pseudo-op or machine instruction */
 646                   pop = NULL;
 647
 648 #define IGNORE_OPCODE_CASE
 649 #ifdef IGNORE_OPCODE_CASE
 650                   {
 651                     char *s2 = s;
 652                     while (*s2)
 653                       {
 654                         if (isupper (*s2))
 655                           *s2 = tolower (*s2);
 656                         s2++;
 657                       }
 658                   }
 659 #endif
 660
 661                   if (flag_m68k_mri
 662 #ifdef NO_PSEUDO_DOT
 663                       || 1
 664 #endif
 665                       )
 666                     {
 667                       /* The MRI assembler and the m88k use pseudo-ops
 668                          without a period.  */
 669                       pop = (pseudo_typeS *) hash_find (po_hash, s);
 670                       if (pop != NULL && pop->poc_handler == NULL)
 671                         pop = NULL;
 672                     }
 673
 674                   if (pop != NULL
 675                       || (! flag_m68k_mri && *s == '.'))
 676                     {
 677                       /*
 678                        * PSEUDO - OP.
 679                        *
 680                        * WARNING: c has next char, which may be end-of-line.
 681                        * We lookup the pseudo-op table with s+1 because we
 682                        * already know that the pseudo-op begins with a '.'.
 683                        */
 684
 685                       if (pop == NULL)
 686                         pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
 687
 688                       /* In MRI mode, we may need to insert an
 689                          automatic alignment directive.  What a hack
 690                          this is.  */
 691                       if (mri_pending_align
 692                           && (pop == NULL
 693                               || ! ((pop->poc_handler == cons
 694                                      && pop->poc_val == 1)
 695                                     || (pop->poc_handler == s_space
 696                                         && pop->poc_val == 1))))
 697                         {
 698                           do_align (1, (char *) NULL, 0);
 699                           mri_pending_align = 0;
 700                         }
 701
 702                       /* Print the error msg now, while we still can */
 703                       if (pop == NULL)
 704                         {
 705                           as_bad ("Unknown pseudo-op:  `%s'", s);
 706                           *input_line_pointer = c;
 707                           s_ignore (0);
 708                           continue;
 709                         }
 710
 711                       /* Put it back for error messages etc. */
 712                       *input_line_pointer = c;
 713                       /* The following skip of whitespace is compulsory.
 714                          A well shaped space is sometimes all that separates
 715                          keyword from operands. */
 716                       if (c == ' ' || c == '\t')
 717                         input_line_pointer++;
 718                       /*
 719                        * Input_line is restored.
 720                        * Input_line_pointer->1st non-blank char
 721                        * after pseudo-operation.
 722                        */
 723                       (*pop->poc_handler) (pop->poc_val);
 724
 725                       /* If that was .end, just get out now.  */
 726                       if (pop->poc_handler == s_end)
 727                         goto quit;
 728                     }
 729                   else
 730                     {           /* machine instruction */
 731                       int inquote = 0;
 732
 733                       if (mri_pending_align)
 734                         {
 735                           do_align (1, (char *) NULL, 0);
 736                           mri_pending_align = 0;
 737                         }
 738
 739                       /* WARNING: c has char, which may be end-of-line. */
 740                       /* Also: input_line_pointer->`\0` where c was. */
 741                       *input_line_pointer = c;
 742                       while (!is_end_of_line[(unsigned char) *input_line_pointer]
 743                              || inquote
 744 #ifdef TC_EOL_IN_INSN
 745                              || TC_EOL_IN_INSN (input_line_pointer)
 746 #endif
 747                              )
 748                         {
 749                           if (flag_m68k_mri && *input_line_pointer == '\'')
 750                             inquote = ! inquote;
 751                           input_line_pointer++;
 752                         }
 753
 754                       c = *input_line_pointer;
 755                       *input_line_pointer = '\0';
 756
 757 #ifdef OBJ_GENERATE_ASM_LINENO
 758                       if (generate_asm_lineno == 0)
 759                         {
 760                           if (ecoff_no_current_file ())
 761                             generate_asm_lineno = 1;
 762                         }
 763                       if (generate_asm_lineno == 1)
 764                         {
 765                           unsigned int lineno;
 766                           char *s;
 767
 768                           as_where (&s, &lineno);
 769                           OBJ_GENERATE_ASM_LINENO (s, lineno);
 770                         }
 771 #endif
 772
 773                       if (macro_defined)
 774                         {
 775                           sb out;
 776                           const char *err;
 777
 778                           if (check_macro (s, &out, '\0', &err))
 779                             {
 780                               if (err != NULL)
 781                                 as_bad (err);
 782                               *input_line_pointer++ = c;
 783                               input_scrub_include_sb (&out,
 784                                                       input_line_pointer);
 785                               sb_kill (&out);
 786                               buffer_limit =
 787                                 input_scrub_next_buffer (&input_line_pointer);
 788                               continue;
 789                             }
 790                         }
 791
 792                       md_assemble (s);  /* Assemble 1 instruction. */
 793
 794                       *input_line_pointer++ = c;
 795
 796                       /* We resume loop AFTER the end-of-line from
 797                          this instruction. */
 798                     }           /* if (*s=='.') */
 799                 }               /* if c==':' */
 800               continue;
 801             }                   /* if (is_name_beginner(c) */
 802
 803
 804           /* Empty statement?  */
 805           if (is_end_of_line[(unsigned char) c])
 806             continue;
 807
 808           if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB)
 809               && isdigit (c))
 810             {
 811               /* local label  ("4:") */
 812               char *backup = input_line_pointer;
 813
 814               HANDLE_CONDITIONAL_ASSEMBLY ();
 815
 816               temp = c - '0';
 817
 818               while (isdigit (*input_line_pointer))
 819                 {
 820                   temp = (temp * 10) + *input_line_pointer - '0';
 821                   ++input_line_pointer;
 822                 }               /* read the whole number */
 823
 824               if (LOCAL_LABELS_DOLLAR
 825                   && *input_line_pointer == '$'
 826                   && *(input_line_pointer + 1) == ':')
 827                 {
 828                   input_line_pointer += 2;
 829
 830                   if (dollar_label_defined (temp))
 831                     {
 832                       as_fatal ("label \"%d$\" redefined", temp);
 833                     }
 834
 835                   define_dollar_label (temp);
 836                   colon (dollar_label_name (temp, 0));
 837                   continue;
 838                 }
 839
 840               if (LOCAL_LABELS_FB
 841                   && *input_line_pointer++ == ':')
 842                 {
 843                   fb_label_instance_inc (temp);
 844                   colon (fb_label_name (temp, 0));
 845                   continue;
 846                 }
 847
 848               input_line_pointer = backup;
 849             }                   /* local label  ("4:") */
 850
 851           if (c && strchr (line_comment_chars, c))
 852             {                   /* Its a comment.  Better say APP or NO_APP */
 853               char *ends;
 854               char *new_buf;
 855               char *new_tmp;
 856               unsigned int new_length;
 857               char *tmp_buf = 0;
 858
 859               bump_line_counters ();
 860               s = input_line_pointer;
 861               if (strncmp (s, "APP\n", 4))
 862                 continue;       /* We ignore it */
 863               s += 4;
 864
 865               ends = strstr (s, "#NO_APP\n");
 866
 867               if (!ends)
 868                 {
 869                   unsigned int tmp_len;
 870                   unsigned int num;
 871
 872                   /* The end of the #APP wasn't in this buffer.  We
 873                      keep reading in buffers until we find the #NO_APP
 874                      that goes with this #APP  There is one.  The specs
 875                      guarentee it. . . */
 876                   tmp_len = buffer_limit - s;
 877                   tmp_buf = xmalloc (tmp_len + 1);
 878                   memcpy (tmp_buf, s, tmp_len);
 879                   do
 880                     {
 881                       new_tmp = input_scrub_next_buffer (&buffer);
 882                       if (!new_tmp)
 883                         break;
 884                       else
 885                         buffer_limit = new_tmp;
 886                       input_line_pointer = buffer;
 887                       ends = strstr (buffer, "#NO_APP\n");
 888                       if (ends)
 889                         num = ends - buffer;
 890                       else
 891                         num = buffer_limit - buffer;
 892
 893                       tmp_buf = xrealloc (tmp_buf, tmp_len + num);
 894                       memcpy (tmp_buf + tmp_len, buffer, num);
 895                       tmp_len += num;
 896                     }
 897                   while (!ends);
 898
 899                   input_line_pointer = ends ? ends + 8 : NULL;
 900
 901                   s = tmp_buf;
 902                   ends = s + tmp_len;
 903
 904                 }
 905               else
 906                 {
 907                   input_line_pointer = ends + 8;
 908                 }
 909
 910               scrub_string = s;
 911               scrub_string_end = ends;
 912
 913               new_length = ends - s;
 914               new_buf = (char *) xmalloc (new_length);
 915               new_tmp = new_buf;
 916               for (;;)
 917                 {
 918                   int space;
 919                   int size;
 920
 921                   space = (new_buf + new_length) - new_tmp;
 922                   size = do_scrub_chars (scrub_from_string, new_tmp, space);
 923
 924                   if (size < space)
 925                     {
 926                       new_tmp += size;
 927                       break;
 928                     }
 929
 930                   new_buf = xrealloc (new_buf, new_length + 100);
 931                   new_tmp = new_buf + new_length;
 932                   new_length += 100;
 933                 }
 934
 935               if (tmp_buf)
 936                 free (tmp_buf);
 937               old_buffer = buffer;
 938               old_input = input_line_pointer;
 939               old_limit = buffer_limit;
 940               buffer = new_buf;
 941               input_line_pointer = new_buf;
 942               buffer_limit = new_tmp;
 943               continue;
 944             }
 945
 946           HANDLE_CONDITIONAL_ASSEMBLY ();
 947
 948 #ifdef tc_unrecognized_line
 949           if (tc_unrecognized_line (c))
 950             continue;
 951 #endif
 952
 953           /* as_warn("Junk character %d.",c);  Now done by ignore_rest */
 954           input_line_pointer--; /* Report unknown char as ignored. */
 955           ignore_rest_of_line ();
 956         }                       /* while (input_line_pointer<buffer_limit) */
 957
 958 #ifdef md_after_pass_hook
 959       md_after_pass_hook ();
 960 #endif
 961
 962       if (old_buffer)
 963         {
 964           free (buffer);
 965           bump_line_counters ();
 966           if (old_input != 0)
 967             {
 968               buffer = old_buffer;
 969               input_line_pointer = old_input;
 970               buffer_limit = old_limit;
 971               old_buffer = 0;
 972               goto contin;
 973             }
 974         }
 975     }                           /* while (more buffers to scan) */
 976
 977  quit:
 978   input_scrub_close ();         /* Close the input file */
 979 }
 980
 981 /* For most MRI pseudo-ops, the line actually ends at the first
 982    nonquoted space.  This function looks for that point, stuffs a null
 983    in, and sets *STOPCP to the character that used to be there, and
 984    returns the location.
 985
 986    Until I hear otherwise, I am going to assume that this is only true
 987    for the m68k MRI assembler.  */
 988
 989 char *
 990 mri_comment_field (stopcp)
 991      char *stopcp;
 992 {
 993 #ifdef TC_M68K
 994
 995   char *s;
 996   int inquote = 0;
 997
 998   know (flag_m68k_mri);
 999
1000   for (s = input_line_pointer;
1001        ((! is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
1002         || inquote);
1003        s++)
1004     {
1005       if (*s == '\'')
1006         inquote = ! inquote;
1007     }
1008   *stopcp = *s;
1009   *s = '\0';
1010   return s;
1011
1012 #else
1013
1014   char *s;
1015
1016   for (s = input_line_pointer; ! is_end_of_line[(unsigned char) *s]; s++)
1017     ;
1018   *stopcp = *s;
1019   *s = '\0';
1020   return s;
1021
1022 #endif
1023
1024 }
1025
1026 /* Skip to the end of an MRI comment field.  */
1027
1028 void
1029 mri_comment_end (stop, stopc)
1030      char *stop;
1031      int stopc;
1032 {
1033   know (flag_mri);
1034
1035   input_line_pointer = stop;
1036   *stop = stopc;
1037   while (! is_end_of_line[(unsigned char) *input_line_pointer])
1038     ++input_line_pointer;
1039 }
1040
1041 void
1042 s_abort (ignore)
1043      int ignore;
1044 {
1045   as_fatal (".abort detected.  Abandoning ship.");
1046 }
1047
1048 /* Guts of .align directive.  */
1049 static void
1050 do_align (n, fill, len)
1051      int n;
1052      char *fill;
1053      int len;
1054 {
1055 #ifdef md_do_align
1056   md_do_align (n, fill, len, just_record_alignment);
1057 #endif
1058   if (!fill)
1059     {
1060       /* @@ Fix this right for BFD!  */
1061       static char zero;
1062       static char nop_opcode = NOP_OPCODE;
1063
1064       if (now_seg != data_section && now_seg != bss_section)
1065         {
1066           fill = &nop_opcode;
1067         }
1068       else
1069         {
1070           fill = &zero;
1071         }
1072       len = 1;
1073     }
1074
1075   /* Only make a frag if we HAVE to. . . */
1076   if (n && !need_pass_2)
1077     {
1078       if (len <= 1)
1079         frag_align (n, *fill);
1080       else
1081         frag_align_pattern (n, fill, len);
1082     }
1083
1084 #ifdef md_do_align
1085  just_record_alignment:
1086 #endif
1087
1088   record_alignment (now_seg, n);
1089 }
1090
1091 /* For machines where ".align 4" means align to a 4 byte boundary. */
1092 void
1093 s_align_bytes (arg)
1094      int arg;
1095 {
1096   register unsigned int temp;
1097   char temp_fill;
1098   unsigned int i = 0;
1099   unsigned long max_alignment = 1 << 15;
1100   char *stop = NULL;
1101   char stopc;
1102
1103   if (flag_mri)
1104     stop = mri_comment_field (&stopc);
1105
1106   if (is_end_of_line[(unsigned char) *input_line_pointer])
1107     {
1108       if (arg < 0)
1109         temp = 0;
1110       else
1111         temp = arg;     /* Default value from pseudo-op table */
1112     }
1113   else
1114     temp = get_absolute_expression ();
1115
1116   if (temp > max_alignment)
1117     {
1118       as_bad ("Alignment too large: %d. assumed.", temp = max_alignment);
1119     }
1120
1121   /* For the sparc, `.align (1<<n)' actually means `.align n' so we
1122      have to convert it.  */
1123   if (temp != 0)
1124     {
1125       for (i = 0; (temp & 1) == 0; temp >>= 1, ++i)
1126         ;
1127     }
1128   if (temp != 1)
1129     as_bad ("Alignment not a power of 2");
1130
1131   temp = i;
1132   if (*input_line_pointer == ',')
1133     {
1134       offsetT fillval;
1135       int len;
1136
1137       input_line_pointer++;
1138       fillval = get_absolute_expression ();
1139       if (arg >= 0)
1140         len = 1;
1141       else
1142         len = - arg;
1143       if (len <= 1)
1144         {
1145           temp_fill = fillval;
1146           do_align (temp, &temp_fill, len);
1147         }
1148       else
1149         {
1150           char ab[16];
1151
1152           if (len > sizeof ab)
1153             abort ();
1154           md_number_to_chars (ab, fillval, len);
1155           do_align (temp, ab, len);
1156         }
1157     }
1158   else
1159     {
1160       if (arg < 0)
1161         as_warn ("expected fill pattern missing");
1162       do_align (temp, (char *) NULL, 0);
1163     }
1164
1165   if (flag_mri)
1166     mri_comment_end (stop, stopc);
1167
1168   demand_empty_rest_of_line ();
1169 }
1170
1171 /* For machines where ".align 4" means align to 2**4 boundary. */
1172 void
1173 s_align_ptwo (arg)
1174      int arg;
1175 {
1176   register int temp;
1177   char temp_fill;
1178   long max_alignment = 15;
1179   char *stop = NULL;
1180   char stopc;
1181
1182   if (flag_mri)
1183     stop = mri_comment_field (&stopc);
1184
1185   temp = get_absolute_expression ();
1186   if (temp > max_alignment)
1187     as_bad ("Alignment too large: %d. assumed.", temp = max_alignment);
1188   else if (temp < 0)
1189     {
1190       as_bad ("Alignment negative. 0 assumed.");
1191       temp = 0;
1192     }
1193   if (*input_line_pointer == ',')
1194     {
1195       offsetT fillval;
1196       int len;
1197
1198       input_line_pointer++;
1199       fillval = get_absolute_expression ();
1200       if (arg >= 0)
1201         len = 1;
1202       else
1203         len = - arg;
1204       if (len <= 1)
1205         {
1206           temp_fill = fillval;
1207           do_align (temp, &temp_fill, len);
1208         }
1209       else
1210         {
1211           char ab[16];
1212
1213           if (len > sizeof ab)
1214             abort ();
1215           md_number_to_chars (ab, fillval, len);
1216           do_align (temp, ab, len);
1217         }
1218     }
1219   else
1220     {
1221       if (arg < 0)
1222         as_warn ("expected fill pattern missing");
1223       do_align (temp, (char *) NULL, 0);
1224     }
1225
1226   if (flag_mri)
1227     mri_comment_end (stop, stopc);
1228
1229   demand_empty_rest_of_line ();
1230 }
1231
1232 void
1233 s_comm (ignore)
1234      int ignore;
1235 {
1236   register char *name;
1237   register char c;
1238   register char *p;
1239   offsetT temp;
1240   register symbolS *symbolP;
1241   char *stop = NULL;
1242   char stopc;
1243
1244   if (flag_mri)
1245     stop = mri_comment_field (&stopc);
1246
1247   name = input_line_pointer;
1248   c = get_symbol_end ();
1249   /* just after name is now '\0' */
1250   p = input_line_pointer;
1251   *p = c;
1252   SKIP_WHITESPACE ();
1253   if (*input_line_pointer != ',')
1254     {
1255       as_bad ("Expected comma after symbol-name: rest of line ignored.");
1256       if (flag_mri)
1257         mri_comment_end (stop, stopc);
1258       ignore_rest_of_line ();
1259       return;
1260     }
1261   input_line_pointer++;         /* skip ',' */
1262   if ((temp = get_absolute_expression ()) < 0)
1263     {
1264       as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp);
1265       if (flag_mri)
1266         mri_comment_end (stop, stopc);
1267       ignore_rest_of_line ();
1268       return;
1269     }
1270   *p = 0;
1271   symbolP = symbol_find_or_make (name);
1272   *p = c;
1273   if (S_IS_DEFINED (symbolP))
1274     {
1275       as_bad ("Ignoring attempt to re-define symbol `%s'.",
1276               S_GET_NAME (symbolP));
1277       if (flag_mri)
1278         mri_comment_end (stop, stopc);
1279       ignore_rest_of_line ();
1280       return;
1281     }
1282   if (S_GET_VALUE (symbolP))
1283     {
1284       if (S_GET_VALUE (symbolP) != (valueT) temp)
1285         as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
1286                 S_GET_NAME (symbolP),
1287                 (long) S_GET_VALUE (symbolP),
1288                 (long) temp);
1289     }
1290   else
1291     {
1292       S_SET_VALUE (symbolP, (valueT) temp);
1293       S_SET_EXTERNAL (symbolP);
1294     }
1295 #ifdef OBJ_VMS
1296   {
1297     extern int flag_one;
1298     if ( (!temp) || !flag_one)
1299       S_GET_OTHER(symbolP) = const_flag;
1300   }
1301 #endif /* not OBJ_VMS */
1302   know (symbolP->sy_frag == &zero_address_frag);
1303
1304   if (flag_mri)
1305     mri_comment_end (stop, stopc);
1306
1307   demand_empty_rest_of_line ();
1308 }                               /* s_comm() */
1309
1310 /* The MRI COMMON pseudo-op.  We handle this by creating a common
1311    symbol with the appropriate name.  We make s_space do the right
1312    thing by increasing the size.  */
1313
1314 void
1315 s_mri_common (small)
1316      int small;
1317 {
1318   char *name;
1319   char c;
1320   char *alc = NULL;
1321   symbolS *sym;
1322   offsetT align;
1323   char *stop = NULL;
1324   char stopc;
1325
1326   if (! flag_mri)
1327     {
1328       s_comm (0);
1329       return;
1330     }
1331
1332   stop = mri_comment_field (&stopc);
1333
1334   SKIP_WHITESPACE ();
1335
1336   name = input_line_pointer;
1337   if (! isdigit ((unsigned char) *name))
1338     c = get_symbol_end ();
1339   else
1340     {
1341       do
1342         {
1343           ++input_line_pointer;
1344         }
1345       while (isdigit ((unsigned char) *input_line_pointer));
1346       c = *input_line_pointer;
1347       *input_line_pointer = '\0';
1348
1349       if (line_label != NULL)
1350         {
1351           alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
1352                                   + (input_line_pointer - name)
1353                                   + 1);
1354           sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
1355           name = alc;
1356         }
1357     }
1358
1359   sym = symbol_find_or_make (name);
1360   *input_line_pointer = c;
1361   if (alc != NULL)
1362     free (alc);
1363
1364   if (*input_line_pointer != ',')
1365     align = 0;
1366   else
1367     {
1368       ++input_line_pointer;
1369       align = get_absolute_expression ();
1370     }
1371
1372   if (S_IS_DEFINED (sym))
1373     {
1374 #if defined (S_IS_COMMON) || defined (BFD_ASSEMBLER)
1375       if (! S_IS_COMMON (sym))
1376 #endif
1377         {
1378           as_bad ("attempt to re-define symbol `%s'", S_GET_NAME (sym));
1379           mri_comment_end (stop, stopc);
1380           ignore_rest_of_line ();
1381           return;
1382         }
1383     }
1384
1385   S_SET_EXTERNAL (sym);
1386   mri_common_symbol = sym;
1387
1388 #ifdef S_SET_ALIGN
1389   if (align != 0)
1390     S_SET_ALIGN (sym, align);
1391 #endif
1392
1393   if (line_label != NULL)
1394     {
1395       line_label->sy_value.X_op = O_symbol;
1396       line_label->sy_value.X_add_symbol = sym;
1397       line_label->sy_value.X_add_number = S_GET_VALUE (sym);
1398       line_label->sy_frag = &zero_address_frag;
1399       S_SET_SEGMENT (line_label, expr_section);
1400     }
1401
1402   /* FIXME: We just ignore the small argument, which distinguishes
1403      COMMON and COMMON.S.  I don't know what we can do about it.  */
1404
1405   /* Ignore the type and hptype.  */
1406   if (*input_line_pointer == ',')
1407     input_line_pointer += 2;
1408   if (*input_line_pointer == ',')
1409     input_line_pointer += 2;
1410
1411   mri_comment_end (stop, stopc);
1412
1413   demand_empty_rest_of_line ();
1414 }
1415
1416 void
1417 s_data (ignore)
1418      int ignore;
1419 {
1420   segT section;
1421   register int temp;
1422
1423   temp = get_absolute_expression ();
1424   if (flag_readonly_data_in_text)
1425     {
1426       section = text_section;
1427       temp += 1000;
1428     }
1429   else
1430     section = data_section;
1431
1432   subseg_set (section, (subsegT) temp);
1433
1434 #ifdef OBJ_VMS
1435   const_flag = 0;
1436 #endif
1437   demand_empty_rest_of_line ();
1438 }
1439
1440 /* Handle the .appfile pseudo-op.  This is automatically generated by
1441    do_scrub_chars when a preprocessor # line comment is seen with a
1442    file name.  This default definition may be overridden by the object
1443    or CPU specific pseudo-ops.  This function is also the default
1444    definition for .file; the APPFILE argument is 1 for .appfile, 0 for
1445    .file.  */
1446
1447 void
1448 s_app_file (appfile)
1449      int appfile;
1450 {
1451   register char *s;
1452   int length;
1453
1454   /* Some assemblers tolerate immediately following '"' */
1455   if ((s = demand_copy_string (&length)) != 0)
1456     {
1457       /* If this is a fake .appfile, a fake newline was inserted into
1458          the buffer.  Passing -2 to new_logical_line tells it to
1459          account for it.  */
1460       new_logical_line (s, appfile ? -2 : -1);
1461
1462       /* In MRI mode, the preprocessor may have inserted an extraneous
1463          backquote.  */
1464       if (flag_m68k_mri
1465           && *input_line_pointer == '\''
1466           && is_end_of_line[(unsigned char) input_line_pointer[1]])
1467         ++input_line_pointer;
1468
1469       demand_empty_rest_of_line ();
1470 #ifdef LISTING
1471       if (listing)
1472         listing_source_file (s);
1473 #endif
1474     }
1475 #ifdef obj_app_file
1476   obj_app_file (s);
1477 #endif
1478 }
1479
1480 /* Handle the .appline pseudo-op.  This is automatically generated by
1481    do_scrub_chars when a preprocessor # line comment is seen.  This
1482    default definition may be overridden by the object or CPU specific
1483    pseudo-ops.  */
1484
1485 void
1486 s_app_line (ignore)
1487      int ignore;
1488 {
1489   int l;
1490
1491   /* The given number is that of the next line.  */
1492   l = get_absolute_expression () - 1;
1493   if (l < 0)
1494     /* Some of the back ends can't deal with non-positive line numbers.
1495        Besides, it's silly.  */
1496     as_warn ("Line numbers must be positive; line number %d rejected.", l+1);
1497   else
1498     {
1499       new_logical_line ((char *) NULL, l);
1500 #ifdef LISTING
1501       if (listing)
1502         listing_source_line (l);
1503 #endif
1504     }
1505   demand_empty_rest_of_line ();
1506 }
1507
1508 /* Handle the .end pseudo-op.  Actually, the real work is done in
1509    read_a_source_file.  */
1510
1511 void
1512 s_end (ignore)
1513      int ignore;
1514 {
1515   if (flag_mri)
1516     {
1517       /* The MRI assembler permits the start symbol to follow .end,
1518          but we don't support that.  */
1519       SKIP_WHITESPACE ();
1520       if (! is_end_of_line[(unsigned char) *input_line_pointer]
1521           && *input_line_pointer != '*'
1522           && *input_line_pointer != '!')
1523         as_warn ("start address not supported");
1524     }
1525 }
1526
1527 /* Handle the .err pseudo-op.  */
1528
1529 void
1530 s_err (ignore)
1531      int ignore;
1532 {
1533   as_bad (".err encountered");
1534   demand_empty_rest_of_line ();
1535 }
1536
1537 /* Handle the MRI fail pseudo-op.  */
1538
1539 void
1540 s_fail (ignore)
1541      int ignore;
1542 {
1543   offsetT temp;
1544   char *stop = NULL;
1545   char stopc;
1546
1547   if (flag_mri)
1548     stop = mri_comment_field (&stopc);
1549
1550   temp = get_absolute_expression ();
1551   if (temp >= 500)
1552     as_warn (".fail %ld encountered", (long) temp);
1553   else
1554     as_bad (".fail %ld encountered", (long) temp);
1555
1556   if (flag_mri)
1557     mri_comment_end (stop, stopc);
1558
1559   demand_empty_rest_of_line ();
1560 }
1561
1562 void
1563 s_fill (ignore)
1564      int ignore;
1565 {
1566   long temp_repeat = 0;
1567   long temp_size = 1;
1568   register long temp_fill = 0;
1569   char *p;
1570
1571 #ifdef md_flush_pending_output
1572   md_flush_pending_output ();
1573 #endif
1574
1575   temp_repeat = get_absolute_expression ();
1576   if (*input_line_pointer == ',')
1577     {
1578       input_line_pointer++;
1579       temp_size = get_absolute_expression ();
1580       if (*input_line_pointer == ',')
1581         {
1582           input_line_pointer++;
1583           temp_fill = get_absolute_expression ();
1584         }
1585     }
1586   /* This is to be compatible with BSD 4.2 AS, not for any rational reason.  */
1587 #define BSD_FILL_SIZE_CROCK_8 (8)
1588   if (temp_size > BSD_FILL_SIZE_CROCK_8)
1589     {
1590       as_warn (".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8);
1591       temp_size = BSD_FILL_SIZE_CROCK_8;
1592     }
1593   if (temp_size < 0)
1594     {
1595       as_warn ("Size negative: .fill ignored.");
1596       temp_size = 0;
1597     }
1598   else if (temp_repeat <= 0)
1599     {
1600       as_warn ("Repeat < 0, .fill ignored");
1601       temp_size = 0;
1602     }
1603
1604   if (temp_size && !need_pass_2)
1605     {
1606       p = frag_var (rs_fill, (int) temp_size, (int) temp_size, (relax_substateT) 0, (symbolS *) 0, temp_repeat, (char *) 0);
1607       memset (p, 0, (unsigned int) temp_size);
1608       /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
1609        * flavoured AS.  The following bizzare behaviour is to be
1610        * compatible with above.  I guess they tried to take up to 8
1611        * bytes from a 4-byte expression and they forgot to sign
1612        * extend. Un*x Sux. */
1613 #define BSD_FILL_SIZE_CROCK_4 (4)
1614       md_number_to_chars (p, (valueT) temp_fill,
1615                           (temp_size > BSD_FILL_SIZE_CROCK_4
1616                            ? BSD_FILL_SIZE_CROCK_4
1617                            : (int) temp_size));
1618       /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
1619        * but emits no error message because it seems a legal thing to do.
1620        * It is a degenerate case of .fill but could be emitted by a compiler.
1621        */
1622     }
1623   demand_empty_rest_of_line ();
1624 }
1625
1626 void
1627 s_globl (ignore)
1628      int ignore;
1629 {
1630   char *name;
1631   int c;
1632   symbolS *symbolP;
1633   char *stop = NULL;
1634   char stopc;
1635
1636   if (flag_mri)
1637     stop = mri_comment_field (&stopc);
1638
1639   do
1640     {
1641       name = input_line_pointer;
1642       c = get_symbol_end ();
1643       symbolP = symbol_find_or_make (name);
1644       *input_line_pointer = c;
1645       SKIP_WHITESPACE ();
1646       S_SET_EXTERNAL (symbolP);
1647       if (c == ',')
1648         {
1649           input_line_pointer++;
1650           SKIP_WHITESPACE ();
1651           if (*input_line_pointer == '\n')
1652             c = '\n';
1653         }
1654     }
1655   while (c == ',');
1656
1657   if (flag_mri)
1658     mri_comment_end (stop, stopc);
1659
1660   demand_empty_rest_of_line ();
1661 }
1662
1663 /* Handle the MRI IRP and IRPC pseudo-ops.  */
1664
1665 void
1666 s_irp (irpc)
1667      int irpc;
1668 {
1669   char *file;
1670   unsigned int line;
1671   sb s;
1672   const char *err;
1673   sb out;
1674
1675   as_where (&file, &line);
1676
1677   sb_new (&s);
1678   while (! is_end_of_line[(unsigned char) *input_line_pointer])
1679     sb_add_char (&s, *input_line_pointer++);
1680
1681   sb_new (&out);
1682
1683   err = expand_irp (irpc, 0, &s, &out, get_line_sb, '\0');
1684   if (err != NULL)
1685     as_bad_where (file, line, "%s", err);
1686
1687   sb_kill (&s);
1688
1689   input_scrub_include_sb (&out, input_line_pointer);
1690   sb_kill (&out);
1691   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
1692 }
1693
1694 /* Handle the .linkonce pseudo-op.  This tells the assembler to mark
1695    the section to only be linked once.  However, this is not supported
1696    by most object file formats.  This takes an optional argument,
1697    which is what to do about duplicates.  */
1698
1699 void
1700 s_linkonce (ignore)
1701      int ignore;
1702 {
1703   enum linkonce_type type;
1704
1705   SKIP_WHITESPACE ();
1706
1707   type = LINKONCE_DISCARD;
1708
1709   if (! is_end_of_line[(unsigned char) *input_line_pointer])
1710     {
1711       char *s;
1712       char c;
1713
1714       s = input_line_pointer;
1715       c = get_symbol_end ();
1716       if (strcasecmp (s, "discard") == 0)
1717         type = LINKONCE_DISCARD;
1718       else if (strcasecmp (s, "one_only") == 0)
1719         type = LINKONCE_ONE_ONLY;
1720       else if (strcasecmp (s, "same_size") == 0)
1721         type = LINKONCE_SAME_SIZE;
1722       else if (strcasecmp (s, "same_contents") == 0)
1723         type = LINKONCE_SAME_CONTENTS;
1724       else
1725         as_warn ("unrecognized .linkonce type `%s'", s);
1726
1727       *input_line_pointer = c;
1728     }
1729
1730 #ifdef obj_handle_link_once
1731   obj_handle_link_once (type);
1732 #else /* ! defined (obj_handle_link_once) */
1733 #ifdef BFD_ASSEMBLER
1734   {
1735     flagword flags;
1736
1737     if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
1738       as_warn (".linkonce is not supported for this object file format");
1739
1740     flags = bfd_get_section_flags (stdoutput, now_seg);
1741     flags |= SEC_LINK_ONCE;
1742     switch (type)
1743       {
1744       default:
1745         abort ();
1746       case LINKONCE_DISCARD:
1747         flags |= SEC_LINK_DUPLICATES_DISCARD;
1748         break;
1749       case LINKONCE_ONE_ONLY:
1750         flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
1751         break;
1752       case LINKONCE_SAME_SIZE:
1753         flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
1754         break;
1755       case LINKONCE_SAME_CONTENTS:
1756         flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
1757         break;
1758       }
1759     if (! bfd_set_section_flags (stdoutput, now_seg, flags))
1760       as_bad ("bfd_set_section_flags: %s",
1761               bfd_errmsg (bfd_get_error ()));
1762   }
1763 #else /* ! defined (BFD_ASSEMBLER) */
1764   as_warn (".linkonce is not supported for this object file format");
1765 #endif /* ! defined (BFD_ASSEMBLER) */
1766 #endif /* ! defined (obj_handle_link_once) */
1767
1768   demand_empty_rest_of_line ();
1769 }
1770
1771 void
1772 s_lcomm (needs_align)
1773      /* 1 if this was a ".bss" directive, which may require a 3rd argument
1774         (alignment); 0 if it was an ".lcomm" (2 args only)  */
1775      int needs_align;
1776 {
1777   register char *name;
1778   register char c;
1779   register char *p;
1780   register int temp;
1781   register symbolS *symbolP;
1782   segT current_seg = now_seg;
1783   subsegT current_subseg = now_subseg;
1784   const int max_alignment = 15;
1785   int align = 0;
1786   segT bss_seg = bss_section;
1787
1788   name = input_line_pointer;
1789   c = get_symbol_end ();
1790   p = input_line_pointer;
1791   *p = c;
1792   SKIP_WHITESPACE ();
1793
1794   /* Accept an optional comma after the name.  The comma used to be
1795      required, but Irix 5 cc does not generate it.  */
1796   if (*input_line_pointer == ',')
1797     {
1798       ++input_line_pointer;
1799       SKIP_WHITESPACE ();
1800     }
1801
1802   if (*input_line_pointer == '\n')
1803     {
1804       as_bad ("Missing size expression");
1805       return;
1806     }
1807
1808   if ((temp = get_absolute_expression ()) < 0)
1809     {
1810       as_warn ("BSS length (%d.) <0! Ignored.", temp);
1811       ignore_rest_of_line ();
1812       return;
1813     }
1814
1815 #if defined (TC_MIPS) || defined (TC_ALPHA)
1816   if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
1817       || OUTPUT_FLAVOR == bfd_target_elf_flavour)
1818     {
1819       /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss.  */
1820       if (temp <= bfd_get_gp_size (stdoutput))
1821         {
1822           bss_seg = subseg_new (".sbss", 1);
1823           seg_info (bss_seg)->bss = 1;
1824 #ifdef BFD_ASSEMBLER
1825           if (! bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
1826             as_warn ("error setting flags for \".sbss\": %s",
1827                      bfd_errmsg (bfd_get_error ()));
1828 #endif
1829         }
1830     }
1831 #endif
1832    if (!needs_align)
1833      {
1834        /* FIXME. This needs to be machine independent. */
1835        if (temp >= 8)
1836          align = 3;
1837        else if (temp >= 4)
1838          align = 2;
1839        else if (temp >= 2)
1840          align = 1;
1841        else
1842          align = 0;
1843
1844        record_alignment(bss_seg, align);
1845      }
1846
1847   if (needs_align)
1848     {
1849       align = 0;
1850       SKIP_WHITESPACE ();
1851       if (*input_line_pointer != ',')
1852         {
1853           as_bad ("Expected comma after size");
1854           ignore_rest_of_line ();
1855           return;
1856         }
1857       input_line_pointer++;
1858       SKIP_WHITESPACE ();
1859       if (*input_line_pointer == '\n')
1860         {
1861           as_bad ("Missing alignment");
1862           return;
1863         }
1864       align = get_absolute_expression ();
1865       if (align > max_alignment)
1866         {
1867           align = max_alignment;
1868           as_warn ("Alignment too large: %d. assumed.", align);
1869         }
1870       else if (align < 0)
1871         {
1872           align = 0;
1873           as_warn ("Alignment negative. 0 assumed.");
1874         }
1875       record_alignment (bss_seg, align);
1876     }                           /* if needs align */
1877   else
1878     {
1879       /* Assume some objects may require alignment on some systems.  */
1880 #ifdef TC_ALPHA
1881       if (temp > 1)
1882         {
1883           align = ffs (temp) - 1;
1884           if (temp % (1 << align))
1885             abort ();
1886         }
1887 #endif
1888     }
1889
1890   *p = 0;
1891   symbolP = symbol_find_or_make (name);
1892   *p = c;
1893
1894   if (
1895 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1896        S_GET_OTHER (symbolP) == 0 &&
1897        S_GET_DESC (symbolP) == 0 &&
1898 #endif /* OBJ_AOUT or OBJ_BOUT */
1899        (S_GET_SEGMENT (symbolP) == bss_seg
1900         || (!S_IS_DEFINED (symbolP) && S_GET_VALUE (symbolP) == 0)))
1901     {
1902       char *pfrag;
1903
1904       subseg_set (bss_seg, 1);
1905
1906       if (align)
1907         frag_align (align, 0);
1908                                         /* detach from old frag */
1909       if (S_GET_SEGMENT (symbolP) == bss_seg)
1910         symbolP->sy_frag->fr_symbol = NULL;
1911
1912       symbolP->sy_frag = frag_now;
1913       pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
1914                         temp, (char *)0);
1915       *pfrag = 0;
1916
1917       S_SET_SEGMENT (symbolP, bss_seg);
1918
1919 #ifdef OBJ_COFF
1920       /* The symbol may already have been created with a preceding
1921          ".globl" directive -- be careful not to step on storage class
1922          in that case.  Otherwise, set it to static. */
1923       if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
1924         {
1925           S_SET_STORAGE_CLASS (symbolP, C_STAT);
1926         }
1927 #endif /* OBJ_COFF */
1928
1929 #ifdef S_SET_SIZE
1930       S_SET_SIZE (symbolP, temp);
1931 #endif
1932     }
1933   else
1934     as_bad ("Ignoring attempt to re-define symbol `%s'.",
1935             S_GET_NAME (symbolP));
1936
1937   subseg_set (current_seg, current_subseg);
1938
1939   demand_empty_rest_of_line ();
1940 }                               /* s_lcomm() */
1941
1942 void
1943 s_lsym (ignore)
1944      int ignore;
1945 {
1946   register char *name;
1947   register char c;
1948   register char *p;
1949   expressionS exp;
1950   register symbolS *symbolP;
1951
1952   /* we permit ANY defined expression: BSD4.2 demands constants */
1953   name = input_line_pointer;
1954   c = get_symbol_end ();
1955   p = input_line_pointer;
1956   *p = c;
1957   SKIP_WHITESPACE ();
1958   if (*input_line_pointer != ',')
1959     {
1960       *p = 0;
1961       as_bad ("Expected comma after name \"%s\"", name);
1962       *p = c;
1963       ignore_rest_of_line ();
1964       return;
1965     }
1966   input_line_pointer++;
1967   expression (&exp);
1968   if (exp.X_op != O_constant
1969       && exp.X_op != O_register)
1970     {
1971       as_bad ("bad expression");
1972       ignore_rest_of_line ();
1973       return;
1974     }
1975   *p = 0;
1976   symbolP = symbol_find_or_make (name);
1977
1978   /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
1979      symbolP->sy_desc == 0) out of this test because coff doesn't have
1980      those fields, and I can't see when they'd ever be tripped.  I
1981      don't think I understand why they were here so I may have
1982      introduced a bug. As recently as 1.37 didn't have this test
1983      anyway.  xoxorich. */
1984
1985   if (S_GET_SEGMENT (symbolP) == undefined_section
1986       && S_GET_VALUE (symbolP) == 0)
1987     {
1988       /* The name might be an undefined .global symbol; be sure to
1989          keep the "external" bit. */
1990       S_SET_SEGMENT (symbolP,
1991                      (exp.X_op == O_constant
1992                       ? absolute_section
1993                       : reg_section));
1994       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
1995     }
1996   else
1997     {
1998       as_bad ("Symbol %s already defined", name);
1999     }
2000   *p = c;
2001   demand_empty_rest_of_line ();
2002 }                               /* s_lsym() */
2003
2004 /* Read a line into an sb.  */
2005
2006 static int
2007 get_line_sb (line)
2008      sb *line;
2009 {
2010   if (input_line_pointer[-1] == '\n')
2011     bump_line_counters ();
2012
2013   if (input_line_pointer >= buffer_limit)
2014     {
2015       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2016       if (buffer_limit == 0)
2017         return 0;
2018     }
2019
2020   while (! is_end_of_line[(unsigned char) *input_line_pointer])
2021     sb_add_char (line, *input_line_pointer++);
2022   while (input_line_pointer < buffer_limit
2023          && is_end_of_line[(unsigned char) *input_line_pointer])
2024     {
2025       if (input_line_pointer[-1] == '\n')
2026         bump_line_counters ();
2027       ++input_line_pointer;
2028     }
2029   return 1;
2030 }
2031
2032 /* Define a macro.  This is an interface to macro.c, which is shared
2033    between gas and gasp.  */
2034
2035 void
2036 s_macro (ignore)
2037      int ignore;
2038 {
2039   char *file;
2040   unsigned int line;
2041   sb s;
2042   sb label;
2043   const char *err;
2044
2045   as_where (&file, &line);
2046
2047   sb_new (&s);
2048   while (! is_end_of_line[(unsigned char) *input_line_pointer])
2049     sb_add_char (&s, *input_line_pointer++);
2050
2051   sb_new (&label);
2052   if (line_label != NULL)
2053     sb_add_string (&label, S_GET_NAME (line_label));
2054
2055   err = define_macro (0, &s, &label, get_line_sb);
2056   if (err != NULL)
2057     as_bad_where (file, line, "%s", err);
2058   else
2059     {
2060       if (line_label != NULL)
2061         {
2062           S_SET_SEGMENT (line_label, undefined_section);
2063           S_SET_VALUE (line_label, 0);
2064           line_label->sy_frag = &zero_address_frag;
2065         }
2066     }
2067
2068   sb_kill (&s);
2069 }
2070
2071 /* Handle the .mexit pseudo-op, which immediately exits a macro
2072    expansion.  */
2073
2074 void
2075 s_mexit (ignore)
2076      int ignore;
2077 {
2078   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2079 }
2080
2081 /* Switch in and out of MRI mode.  */
2082
2083 void
2084 s_mri (ignore)
2085      int ignore;
2086 {
2087   int on, old_flag;
2088
2089   on = get_absolute_expression ();
2090   old_flag = flag_mri;
2091   if (on != 0)
2092     {
2093       flag_mri = 1;
2094 #ifdef TC_M68K
2095       flag_m68k_mri = 1;
2096 #endif
2097     }
2098   else
2099     {
2100       flag_mri = 0;
2101       flag_m68k_mri = 0;
2102     }
2103
2104 #ifdef MRI_MODE_CHANGE
2105   if (on != old_flag)
2106     MRI_MODE_CHANGE (on);
2107 #endif
2108
2109   demand_empty_rest_of_line ();
2110 }
2111
2112 /* Handle changing the location counter.  */
2113
2114 static void
2115 do_org (segment, exp, fill)
2116      segT segment;
2117      expressionS *exp;
2118      int fill;
2119 {
2120   if (segment != now_seg && segment != absolute_section)
2121     as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
2122             segment_name (segment), segment_name (now_seg));
2123
2124   if (now_seg == absolute_section)
2125     {
2126       if (fill != 0)
2127         as_warn ("ignoring fill value in absolute section");
2128       if (exp->X_op != O_constant)
2129         {
2130           as_bad ("only constant offsets supported in absolute section");
2131           exp->X_add_number = 0;
2132         }
2133       abs_section_offset = exp->X_add_number;
2134     }
2135   else
2136     {
2137       char *p;
2138
2139       p = frag_var (rs_org, 1, 1, (relax_substateT) 0, exp->X_add_symbol,
2140                     exp->X_add_number, (char *) NULL);
2141       *p = fill;
2142     }
2143 }
2144
2145 void
2146 s_org (ignore)
2147      int ignore;
2148 {
2149   register segT segment;
2150   expressionS exp;
2151   register long temp_fill;
2152
2153   /* The m68k MRI assembler has a different meaning for .org.  It
2154      means to create an absolute section at a given address.  We can't
2155      support that--use a linker script instead.  */
2156   if (flag_m68k_mri)
2157     {
2158       as_bad ("MRI style ORG pseudo-op not supported");
2159       ignore_rest_of_line ();
2160       return;
2161     }
2162
2163   /* Don't believe the documentation of BSD 4.2 AS.  There is no such
2164      thing as a sub-segment-relative origin.  Any absolute origin is
2165      given a warning, then assumed to be segment-relative.  Any
2166      segmented origin expression ("foo+42") had better be in the right
2167      segment or the .org is ignored.
2168
2169      BSD 4.2 AS warns if you try to .org backwards. We cannot because
2170      we never know sub-segment sizes when we are reading code.  BSD
2171      will crash trying to emit negative numbers of filler bytes in
2172      certain .orgs. We don't crash, but see as-write for that code.
2173
2174      Don't make frag if need_pass_2==1.  */
2175   segment = get_known_segmented_expression (&exp);
2176   if (*input_line_pointer == ',')
2177     {
2178       input_line_pointer++;
2179       temp_fill = get_absolute_expression ();
2180     }
2181   else
2182     temp_fill = 0;
2183
2184   if (!need_pass_2)
2185     do_org (segment, &exp, temp_fill);
2186
2187   demand_empty_rest_of_line ();
2188 }                               /* s_org() */
2189
2190 /* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
2191    called by the obj-format routine which handles section changing
2192    when in MRI mode.  It will create a new section, and return it.  It
2193    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2194    'M' (mixed), or 'R' (romable).  If BFD_ASSEMBLER is defined, the
2195    flags will be set in the section.  */
2196
2197 void
2198 s_mri_sect (type)
2199      char *type;
2200 {
2201 #ifdef TC_M68K
2202
2203   char *name;
2204   char c;
2205   segT seg;
2206
2207   SKIP_WHITESPACE ();
2208
2209   name = input_line_pointer;
2210   if (! isdigit ((unsigned char) *name))
2211     c = get_symbol_end ();
2212   else
2213     {
2214       do
2215         {
2216           ++input_line_pointer;
2217         }
2218       while (isdigit ((unsigned char) *input_line_pointer));
2219       c = *input_line_pointer;
2220       *input_line_pointer = '\0';
2221     }
2222
2223   name = xstrdup (name);
2224
2225   *input_line_pointer = c;
2226
2227   seg = subseg_new (name, 0);
2228
2229   if (*input_line_pointer == ',')
2230     {
2231       int align;
2232
2233       ++input_line_pointer;
2234       align = get_absolute_expression ();
2235       record_alignment (seg, align);
2236     }
2237
2238   *type = 'C';
2239   if (*input_line_pointer == ',')
2240     {
2241       c = *++input_line_pointer;
2242       c = toupper ((unsigned char) c);
2243       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2244         *type = c;
2245       else
2246         as_bad ("unrecognized section type");
2247       ++input_line_pointer;
2248
2249 #ifdef BFD_ASSEMBLER
2250       {
2251         flagword flags;
2252
2253         flags = SEC_NO_FLAGS;
2254         if (*type == 'C')
2255           flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2256         else if (*type == 'D' || *type == 'M')
2257           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2258         else if (*type == 'R')
2259           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2260         if (flags != SEC_NO_FLAGS)
2261           {
2262             if (! bfd_set_section_flags (stdoutput, seg, flags))
2263               as_warn ("error setting flags for \"%s\": %s",
2264                        bfd_section_name (stdoutput, seg),
2265                        bfd_errmsg (bfd_get_error ()));
2266           }
2267       }
2268 #endif
2269     }
2270
2271   /* Ignore the HP type.  */
2272   if (*input_line_pointer == ',')
2273     input_line_pointer += 2;
2274
2275   demand_empty_rest_of_line ();
2276
2277 #else /* ! TC_M68K */
2278 #ifdef TC_I960
2279
2280   char *name;
2281   char c;
2282   segT seg;
2283
2284   SKIP_WHITESPACE ();
2285
2286   name = input_line_pointer;
2287   c = get_symbol_end ();
2288
2289   name = xstrdup (name);
2290
2291   *input_line_pointer = c;
2292
2293   seg = subseg_new (name, 0);
2294
2295   if (*input_line_pointer != ',')
2296     *type = 'C';
2297   else
2298     {
2299       char *sectype;
2300
2301       ++input_line_pointer;
2302       SKIP_WHITESPACE ();
2303       sectype = input_line_pointer;
2304       c = get_symbol_end ();
2305       if (*sectype == '\0')
2306         *type = 'C';
2307       else if (strcasecmp (sectype, "text") == 0)
2308         *type = 'C';
2309       else if (strcasecmp (sectype, "data") == 0)
2310         *type = 'D';
2311       else if (strcasecmp (sectype, "romdata") == 0)
2312         *type = 'R';
2313       else
2314         as_warn ("unrecognized section type `%s'", sectype);
2315       *input_line_pointer = c;
2316     }
2317
2318   if (*input_line_pointer == ',')
2319     {
2320       char *seccmd;
2321
2322       ++input_line_pointer;
2323       SKIP_WHITESPACE ();
2324       seccmd = input_line_pointer;
2325       c = get_symbol_end ();
2326       if (strcasecmp (seccmd, "absolute") == 0)
2327         {
2328           as_bad ("absolute sections are not supported");
2329           *input_line_pointer = c;
2330           ignore_rest_of_line ();
2331           return;
2332         }
2333       else if (strcasecmp (seccmd, "align") == 0)
2334         {
2335           int align;
2336
2337           *input_line_pointer = c;
2338           align = get_absolute_expression ();
2339           record_alignment (seg, align);
2340         }
2341       else
2342         {
2343           as_warn ("unrecognized section command `%s'", seccmd);
2344           *input_line_pointer = c;
2345         }
2346     }
2347
2348   demand_empty_rest_of_line ();
2349
2350 #else /* ! TC_I960 */
2351   /* The MRI assembler seems to use different forms of .sect for
2352      different targets.  */
2353   abort ();
2354 #endif /* ! TC_I960 */
2355 #endif /* ! TC_M68K */
2356 }
2357
2358 /* Handle the .print pseudo-op.  */
2359
2360 void
2361 s_print (ignore)
2362      int ignore;
2363 {
2364   char *s;
2365   int len;
2366
2367   s = demand_copy_C_string (&len);
2368   printf ("%s\n", s);
2369   demand_empty_rest_of_line ();
2370 }
2371
2372 /* Handle the .purgem pseudo-op.  */
2373
2374 void
2375 s_purgem (ignore)
2376      int ignore;
2377 {
2378   if (is_it_end_of_statement ())
2379     {
2380       demand_empty_rest_of_line ();
2381       return;
2382     }
2383
2384   do
2385     {
2386       char *name;
2387       char c;
2388
2389       SKIP_WHITESPACE ();
2390       name = input_line_pointer;
2391       c = get_symbol_end ();
2392       delete_macro (name);
2393       *input_line_pointer = c;
2394       SKIP_WHITESPACE ();
2395     }
2396   while (*input_line_pointer++ == ',');
2397
2398   --input_line_pointer;
2399   demand_empty_rest_of_line ();
2400 }
2401
2402 /* Handle the .rept pseudo-op.  */
2403
2404 void
2405 s_rept (ignore)
2406      int ignore;
2407 {
2408   int count;
2409   sb one;
2410   sb many;
2411
2412   count = get_absolute_expression ();
2413
2414   sb_new (&one);
2415   if (! buffer_and_nest ("REPT", "ENDR", &one, get_line_sb))
2416     {
2417       as_bad ("rept without endr");
2418       return;
2419     }
2420
2421   sb_new (&many);
2422   while (count-- > 0)
2423     sb_add_sb (&many, &one);
2424
2425   sb_kill (&one);
2426
2427   input_scrub_include_sb (&many, input_line_pointer);
2428   sb_kill (&many);
2429   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2430 }
2431
2432 void
2433 s_set (ignore)
2434      int ignore;
2435 {
2436   register char *name;
2437   register char delim;
2438   register char *end_name;
2439   register symbolS *symbolP;
2440
2441   /*
2442    * Especial apologies for the random logic:
2443    * this just grew, and could be parsed much more simply!
2444    * Dean in haste.
2445    */
2446   name = input_line_pointer;
2447   delim = get_symbol_end ();
2448   end_name = input_line_pointer;
2449   *end_name = delim;
2450   SKIP_WHITESPACE ();
2451
2452   if (*input_line_pointer != ',')
2453     {
2454       *end_name = 0;
2455       as_bad ("Expected comma after name \"%s\"", name);
2456       *end_name = delim;
2457       ignore_rest_of_line ();
2458       return;
2459     }
2460
2461   input_line_pointer++;
2462   *end_name = 0;
2463
2464   if (name[0] == '.' && name[1] == '\0')
2465     {
2466       /* Turn '. = mumble' into a .org mumble */
2467       register segT segment;
2468       expressionS exp;
2469
2470       segment = get_known_segmented_expression (&exp);
2471
2472       if (!need_pass_2)
2473         do_org (segment, &exp, 0);
2474
2475       *end_name = delim;
2476       return;
2477     }
2478
2479   if ((symbolP = symbol_find (name)) == NULL
2480       && (symbolP = md_undefined_symbol (name)) == NULL)
2481     {
2482       symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2483 #ifdef OBJ_COFF
2484       /* "set" symbols are local unless otherwise specified. */
2485       SF_SET_LOCAL (symbolP);
2486 #endif /* OBJ_COFF */
2487
2488     }                           /* make a new symbol */
2489
2490   symbol_table_insert (symbolP);
2491
2492   *end_name = delim;
2493   pseudo_set (symbolP);
2494   demand_empty_rest_of_line ();
2495 }                               /* s_set() */
2496
2497 void
2498 s_space (mult)
2499      int mult;
2500 {
2501   expressionS exp;
2502   expressionS val;
2503   char *p = 0;
2504   char *stop = NULL;
2505   char stopc;
2506
2507 #ifdef md_flush_pending_output
2508   md_flush_pending_output ();
2509 #endif
2510
2511   if (flag_mri)
2512     stop = mri_comment_field (&stopc);
2513
2514   expression (&exp);
2515
2516   SKIP_WHITESPACE ();
2517   if (*input_line_pointer == ',')
2518     {
2519       ++input_line_pointer;
2520       expression (&val);
2521     }
2522   else
2523     {
2524       val.X_op = O_constant;
2525       val.X_add_number = 0;
2526     }
2527
2528   if (val.X_op != O_constant
2529       || val.X_add_number < - 0x80
2530       || val.X_add_number > 0xff
2531       || (mult != 0 && mult != 1 && val.X_add_number != 0))
2532     {
2533       if (exp.X_op != O_constant)
2534         as_bad ("Unsupported variable size or fill value");
2535       else
2536         {
2537           offsetT i;
2538
2539           if (mult == 0)
2540             mult = 1;
2541           for (i = 0; i < exp.X_add_number; i++)
2542             emit_expr (&val, mult);
2543         }
2544     }
2545   else
2546     {
2547       if (exp.X_op == O_constant)
2548         {
2549           long repeat;
2550
2551           repeat = exp.X_add_number;
2552           if (mult)
2553             repeat *= mult;
2554           if (repeat <= 0)
2555             {
2556               if (! flag_mri || repeat < 0)
2557                 as_warn (".space repeat count is %s, ignored",
2558                          repeat ? "negative" : "zero");
2559               goto getout;
2560             }
2561
2562           /* If we are in the absolute section, just bump the offset.  */
2563           if (now_seg == absolute_section)
2564             {
2565               abs_section_offset += repeat;
2566               goto getout;
2567             }
2568
2569           /* If we are secretly in an MRI common section, then
2570              creating space just increases the size of the common
2571              symbol.  */
2572           if (mri_common_symbol != NULL)
2573             {
2574               S_SET_VALUE (mri_common_symbol,
2575                            S_GET_VALUE (mri_common_symbol) + repeat);
2576               goto getout;
2577             }
2578
2579           if (!need_pass_2)
2580             p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
2581                           repeat, (char *) 0);
2582         }
2583       else
2584         {
2585           if (now_seg == absolute_section)
2586             {
2587               as_bad ("space allocation too complex in absolute section");
2588               subseg_set (text_section, 0);
2589             }
2590           if (mri_common_symbol != NULL)
2591             {
2592               as_bad ("space allocation too complex in common section");
2593               mri_common_symbol = NULL;
2594             }
2595           if (!need_pass_2)
2596             p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
2597                           make_expr_symbol (&exp), 0L, (char *) 0);
2598         }
2599
2600       if (p)
2601         *p = val.X_add_number;
2602     }
2603
2604  getout:
2605   if (flag_mri)
2606     mri_comment_end (stop, stopc);
2607
2608   demand_empty_rest_of_line ();
2609 }
2610
2611 /* This is like s_space, but the value is a floating point number with
2612    the given precision.  This is for the MRI dcb.s pseudo-op and
2613    friends.  */
2614
2615 void
2616 s_float_space (float_type)
2617      int float_type;
2618 {
2619   offsetT count;
2620   int flen;
2621   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
2622   char *stop = NULL;
2623   char stopc;
2624
2625   if (flag_mri)
2626     stop = mri_comment_field (&stopc);
2627
2628   count = get_absolute_expression ();
2629
2630   SKIP_WHITESPACE ();
2631   if (*input_line_pointer != ',')
2632     {
2633       as_bad ("missing value");
2634       if (flag_mri)
2635         mri_comment_end (stop, stopc);
2636       ignore_rest_of_line ();
2637       return;
2638     }
2639
2640   ++input_line_pointer;
2641
2642   SKIP_WHITESPACE ();
2643
2644   /* Skip any 0{letter} that may be present.  Don't even check if the
2645    * letter is legal.  */
2646   if (input_line_pointer[0] == '0' && isalpha (input_line_pointer[1]))
2647     input_line_pointer += 2;
2648
2649   /* Accept :xxxx, where the x's are hex digits, for a floating point
2650      with the exact digits specified.  */
2651   if (input_line_pointer[0] == ':')
2652     {
2653       flen = hex_float (float_type, temp);
2654       if (flen < 0)
2655         {
2656           if (flag_mri)
2657             mri_comment_end (stop, stopc);
2658           ignore_rest_of_line ();
2659           return;
2660         }
2661     }
2662   else
2663     {
2664       char *err;
2665
2666       err = md_atof (float_type, temp, &flen);
2667       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
2668       know (flen > 0);
2669       if (err)
2670         {
2671           as_bad ("Bad floating literal: %s", err);
2672           if (flag_mri)
2673             mri_comment_end (stop, stopc);
2674           ignore_rest_of_line ();
2675           return;
2676         }
2677     }
2678
2679   while (--count >= 0)
2680     {
2681       char *p;
2682
2683       p = frag_more (flen);
2684       memcpy (p, temp, (unsigned int) flen);
2685     }
2686
2687   if (flag_mri)
2688     mri_comment_end (stop, stopc);
2689
2690   demand_empty_rest_of_line ();
2691 }
2692
2693 /* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
2694
2695 void
2696 s_struct (ignore)
2697      int ignore;
2698 {
2699   char *stop = NULL;
2700   char stopc;
2701
2702   if (flag_mri)
2703     stop = mri_comment_field (&stopc);
2704   abs_section_offset = get_absolute_expression ();
2705   subseg_set (absolute_section, 0);
2706   if (flag_mri)
2707     mri_comment_end (stop, stopc);
2708   demand_empty_rest_of_line ();
2709 }
2710
2711 void
2712 s_text (ignore)
2713      int ignore;
2714 {
2715   register int temp;
2716
2717   temp = get_absolute_expression ();
2718   subseg_set (text_section, (subsegT) temp);
2719   demand_empty_rest_of_line ();
2720 #ifdef OBJ_VMS
2721   const_flag &= ~IN_DEFAULT_SECTION;
2722 #endif
2723 }                               /* s_text() */
2724 \f
2725
2726 void
2727 demand_empty_rest_of_line ()
2728 {
2729   SKIP_WHITESPACE ();
2730   if (is_end_of_line[(unsigned char) *input_line_pointer])
2731     {
2732       input_line_pointer++;
2733     }
2734   else
2735     {
2736       ignore_rest_of_line ();
2737     }
2738   /* Return having already swallowed end-of-line. */
2739 }                               /* Return pointing just after end-of-line. */
2740
2741 void
2742 ignore_rest_of_line ()          /* For suspect lines: gives warning. */
2743 {
2744   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2745     {
2746       if (isprint (*input_line_pointer))
2747         as_bad ("Rest of line ignored. First ignored character is `%c'.",
2748                 *input_line_pointer);
2749       else
2750         as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2751                 *input_line_pointer);
2752       while (input_line_pointer < buffer_limit
2753              && !is_end_of_line[(unsigned char) *input_line_pointer])
2754         {
2755           input_line_pointer++;
2756         }
2757     }
2758   input_line_pointer++;         /* Return pointing just after end-of-line. */
2759   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
2760 }
2761
2762 /*
2763  *                      pseudo_set()
2764  *
2765  * In:  Pointer to a symbol.
2766  *      Input_line_pointer->expression.
2767  *
2768  * Out: Input_line_pointer->just after any whitespace after expression.
2769  *      Tried to set symbol to value of expression.
2770  *      Will change symbols type, value, and frag;
2771  */
2772 void
2773 pseudo_set (symbolP)
2774      symbolS *symbolP;
2775 {
2776   expressionS exp;
2777 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2778   int ext;
2779 #endif /* OBJ_AOUT or OBJ_BOUT */
2780
2781   know (symbolP);               /* NULL pointer is logic error. */
2782 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2783   ext = S_IS_EXTERNAL (symbolP);
2784 #endif /* OBJ_AOUT or OBJ_BOUT */
2785
2786   (void) expression (&exp);
2787
2788   if (exp.X_op == O_illegal)
2789     as_bad ("illegal expression; zero assumed");
2790   else if (exp.X_op == O_absent)
2791     as_bad ("missing expression; zero assumed");
2792   else if (exp.X_op == O_big)
2793     as_bad ("%s number invalid; zero assumed",
2794             exp.X_add_number > 0 ? "bignum" : "floating point");
2795   else if (exp.X_op == O_subtract
2796            && (S_GET_SEGMENT (exp.X_add_symbol)
2797                == S_GET_SEGMENT (exp.X_op_symbol))
2798            && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
2799            && exp.X_add_symbol->sy_frag == exp.X_op_symbol->sy_frag)
2800     {
2801       exp.X_op = O_constant;
2802       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
2803                           - S_GET_VALUE (exp.X_op_symbol));
2804     }
2805
2806   switch (exp.X_op)
2807     {
2808     case O_illegal:
2809     case O_absent:
2810     case O_big:
2811       exp.X_add_number = 0;
2812       /* Fall through.  */
2813     case O_constant:
2814       S_SET_SEGMENT (symbolP, absolute_section);
2815 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2816       if (ext)
2817         S_SET_EXTERNAL (symbolP);
2818       else
2819         S_CLEAR_EXTERNAL (symbolP);
2820 #endif /* OBJ_AOUT or OBJ_BOUT */
2821       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2822       symbolP->sy_frag = &zero_address_frag;
2823       break;
2824
2825     case O_register:
2826       S_SET_SEGMENT (symbolP, reg_section);
2827       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2828       symbolP->sy_frag = &zero_address_frag;
2829       break;
2830
2831     case O_symbol:
2832       if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
2833           || exp.X_add_number != 0)
2834         symbolP->sy_value = exp;
2835       else
2836         {
2837           symbolS *s = exp.X_add_symbol;
2838
2839           S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
2840 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2841           if (ext)
2842             S_SET_EXTERNAL (symbolP);
2843           else
2844             S_CLEAR_EXTERNAL (symbolP);
2845 #endif /* OBJ_AOUT or OBJ_BOUT */
2846           S_SET_VALUE (symbolP,
2847                        exp.X_add_number + S_GET_VALUE (s));
2848           symbolP->sy_frag = s->sy_frag;
2849           copy_symbol_attributes (symbolP, s);
2850         }
2851       break;
2852
2853     default:
2854       /* The value is some complex expression.
2855          FIXME: Should we set the segment to anything?  */
2856       symbolP->sy_value = exp;
2857       break;
2858     }
2859 }
2860 \f
2861 /*
2862  *                      cons()
2863  *
2864  * CONStruct more frag of .bytes, or .words etc.
2865  * Should need_pass_2 be 1 then emit no frag(s).
2866  * This understands EXPRESSIONS.
2867  *
2868  * Bug (?)
2869  *
2870  * This has a split personality. We use expression() to read the
2871  * value. We can detect if the value won't fit in a byte or word.
2872  * But we can't detect if expression() discarded significant digits
2873  * in the case of a long. Not worth the crocks required to fix it.
2874  */
2875
2876 /* Select a parser for cons expressions.  */
2877
2878 /* Some targets need to parse the expression in various fancy ways.
2879    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
2880    (for example, the HPPA does this).  Otherwise, you can define
2881    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
2882    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
2883    are defined, which is the normal case, then only simple expressions
2884    are permitted.  */
2885
2886 static void
2887 parse_mri_cons PARAMS ((expressionS *exp, unsigned int nbytes));
2888
2889 #ifndef TC_PARSE_CONS_EXPRESSION
2890 #ifdef BITFIELD_CONS_EXPRESSIONS
2891 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
2892 static void
2893 parse_bitfield_cons PARAMS ((expressionS *exp, unsigned int nbytes));
2894 #endif
2895 #ifdef REPEAT_CONS_EXPRESSIONS
2896 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
2897 static void
2898 parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
2899 #endif
2900
2901 /* If we haven't gotten one yet, just call expression.  */
2902 #ifndef TC_PARSE_CONS_EXPRESSION
2903 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
2904 #endif
2905 #endif
2906
2907 /* worker to do .byte etc statements */
2908 /* clobbers input_line_pointer, checks */
2909 /* end-of-line. */
2910 static void
2911 cons_worker (nbytes, rva)
2912      register int nbytes;       /* 1=.byte, 2=.word, 4=.long */
2913      int rva;
2914 {
2915   int c;
2916   expressionS exp;
2917   char *stop = NULL;
2918   char stopc;
2919
2920 #ifdef md_flush_pending_output
2921   md_flush_pending_output ();
2922 #endif
2923
2924   if (flag_mri)
2925     stop = mri_comment_field (&stopc);
2926
2927   if (is_it_end_of_statement ())
2928     {
2929       if (flag_mri)
2930         mri_comment_end (stop, stopc);
2931       demand_empty_rest_of_line ();
2932       return;
2933     }
2934
2935   c = 0;
2936   do
2937     {
2938       if (flag_m68k_mri)
2939         parse_mri_cons (&exp, (unsigned int) nbytes);
2940       else
2941         TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
2942
2943       if (rva)
2944         {
2945           if (exp.X_op == O_symbol)
2946             exp.X_op = O_symbol_rva;
2947           else
2948             as_fatal ("rva without symbol");
2949         }
2950       emit_expr (&exp, (unsigned int) nbytes);
2951       ++c;
2952     }
2953   while (*input_line_pointer++ == ',');
2954
2955   /* In MRI mode, after an odd number of bytes, we must align to an
2956      even word boundary, unless the next instruction is a dc.b, ds.b
2957      or dcb.b.  */
2958   if (flag_mri && nbytes == 1 && (c & 1) != 0)
2959     mri_pending_align = 1;
2960
2961   input_line_pointer--;         /* Put terminator back into stream. */
2962
2963   if (flag_mri)
2964     mri_comment_end (stop, stopc);
2965
2966   demand_empty_rest_of_line ();
2967 }
2968
2969
2970 void
2971 cons (size)
2972      int size;
2973 {
2974   cons_worker (size, 0);
2975 }
2976
2977 void
2978 s_rva (size)
2979      int size;
2980 {
2981   cons_worker (size, 1);
2982 }
2983
2984
2985 /* Put the contents of expression EXP into the object file using
2986    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
2987
2988 void
2989 emit_expr (exp, nbytes)
2990      expressionS *exp;
2991      unsigned int nbytes;
2992 {
2993   operatorT op;
2994   register char *p;
2995   valueT extra_digit = 0;
2996
2997   /* Don't do anything if we are going to make another pass.  */
2998   if (need_pass_2)
2999     return;
3000
3001   op = exp->X_op;
3002
3003   /* Allow `.word 0' in the absolute section.  */
3004   if (now_seg == absolute_section)
3005     {
3006       if (op != O_constant || exp->X_add_number != 0)
3007         as_bad ("attempt to store value in absolute section");
3008       abs_section_offset += nbytes;
3009       return;
3010     }
3011
3012   /* Handle a negative bignum.  */
3013   if (op == O_uminus
3014       && exp->X_add_number == 0
3015       && exp->X_add_symbol->sy_value.X_op == O_big
3016       && exp->X_add_symbol->sy_value.X_add_number > 0)
3017     {
3018       int i;
3019       unsigned long carry;
3020
3021       exp = &exp->X_add_symbol->sy_value;
3022
3023       /* Negate the bignum: one's complement each digit and add 1.  */
3024       carry = 1;
3025       for (i = 0; i < exp->X_add_number; i++)
3026         {
3027           unsigned long next;
3028
3029           next = (((~ (generic_bignum[i] & LITTLENUM_MASK))
3030                    & LITTLENUM_MASK)
3031                   + carry);
3032           generic_bignum[i] = next & LITTLENUM_MASK;
3033           carry = next >> LITTLENUM_NUMBER_OF_BITS;
3034         }
3035
3036       /* We can ignore any carry out, because it will be handled by
3037          extra_digit if it is needed.  */
3038
3039       extra_digit = (valueT) -1;
3040       op = O_big;
3041     }
3042
3043   if (op == O_absent || op == O_illegal)
3044     {
3045       as_warn ("zero assumed for missing expression");
3046       exp->X_add_number = 0;
3047       op = O_constant;
3048     }
3049   else if (op == O_big && exp->X_add_number <= 0)
3050     {
3051       as_bad ("floating point number invalid; zero assumed");
3052       exp->X_add_number = 0;
3053       op = O_constant;
3054     }
3055   else if (op == O_register)
3056     {
3057       as_warn ("register value used as expression");
3058       op = O_constant;
3059     }
3060
3061   p = frag_more ((int) nbytes);
3062
3063 #ifndef WORKING_DOT_WORD
3064   /* If we have the difference of two symbols in a word, save it on
3065      the broken_words list.  See the code in write.c.  */
3066   if (op == O_subtract && nbytes == 2)
3067     {
3068       struct broken_word *x;
3069
3070       x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3071       x->next_broken_word = broken_words;
3072       broken_words = x;
3073       x->frag = frag_now;
3074       x->word_goes_here = p;
3075       x->dispfrag = 0;
3076       x->add = exp->X_add_symbol;
3077       x->sub = exp->X_op_symbol;
3078       x->addnum = exp->X_add_number;
3079       x->added = 0;
3080       new_broken_words++;
3081       return;
3082     }
3083 #endif
3084
3085   /* If we have an integer, but the number of bytes is too large to
3086      pass to md_number_to_chars, handle it as a bignum.  */
3087   if (op == O_constant && nbytes > sizeof (valueT))
3088     {
3089       valueT val;
3090       int gencnt;
3091
3092       if (! exp->X_unsigned && exp->X_add_number < 0)
3093         extra_digit = (valueT) -1;
3094       val = (valueT) exp->X_add_number;
3095       gencnt = 0;
3096       do
3097         {
3098           generic_bignum[gencnt] = val & LITTLENUM_MASK;
3099           val >>= LITTLENUM_NUMBER_OF_BITS;
3100           ++gencnt;
3101         }
3102       while (val != 0);
3103       op = exp->X_op = O_big;
3104       exp->X_add_number = gencnt;
3105     }
3106
3107   if (op == O_constant)
3108     {
3109       register valueT get;
3110       register valueT use;
3111       register valueT mask;
3112       register valueT unmask;
3113
3114       /* JF << of >= number of bits in the object is undefined.  In
3115          particular SPARC (Sun 4) has problems */
3116       if (nbytes >= sizeof (valueT))
3117         mask = 0;
3118       else
3119         mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes); /* Don't store these bits. */
3120
3121       unmask = ~mask;           /* Do store these bits. */
3122
3123 #ifdef NEVER
3124       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3125       mask = ~(unmask >> 1);    /* Includes sign bit now. */
3126 #endif
3127
3128       get = exp->X_add_number;
3129       use = get & unmask;
3130       if ((get & mask) != 0 && (get & mask) != mask)
3131         {               /* Leading bits contain both 0s & 1s. */
3132           as_warn ("Value 0x%lx truncated to 0x%lx.", get, use);
3133         }
3134       /* put bytes in right order. */
3135       md_number_to_chars (p, use, (int) nbytes);
3136     }
3137   else if (op == O_big)
3138     {
3139       int size;
3140       LITTLENUM_TYPE *nums;
3141
3142       know (nbytes % CHARS_PER_LITTLENUM == 0);
3143
3144       size = exp->X_add_number * CHARS_PER_LITTLENUM;
3145       if (nbytes < size)
3146         {
3147           as_warn ("Bignum truncated to %d bytes", nbytes);
3148           size = nbytes;
3149         }
3150
3151       if (target_big_endian)
3152         {
3153           while (nbytes > size)
3154             {
3155               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3156               nbytes -= CHARS_PER_LITTLENUM;
3157               p += CHARS_PER_LITTLENUM;
3158             }
3159
3160           nums = generic_bignum + size / CHARS_PER_LITTLENUM;
3161           while (size > 0)
3162             {
3163               --nums;
3164               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3165               size -= CHARS_PER_LITTLENUM;
3166               p += CHARS_PER_LITTLENUM;
3167             }
3168         }
3169       else
3170         {
3171           nums = generic_bignum;
3172           while (size > 0)
3173             {
3174               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3175               ++nums;
3176               size -= CHARS_PER_LITTLENUM;
3177               p += CHARS_PER_LITTLENUM;
3178               nbytes -= CHARS_PER_LITTLENUM;
3179             }
3180
3181           while (nbytes > 0)
3182             {
3183               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3184               nbytes -= CHARS_PER_LITTLENUM;
3185               p += CHARS_PER_LITTLENUM;
3186             }
3187         }
3188     }
3189   else
3190     {
3191       memset (p, 0, nbytes);
3192
3193       /* Now we need to generate a fixS to record the symbol value.
3194          This is easy for BFD.  For other targets it can be more
3195          complex.  For very complex cases (currently, the HPPA and
3196          NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3197          want.  For simpler cases, you can define TC_CONS_RELOC to be
3198          the name of the reloc code that should be stored in the fixS.
3199          If neither is defined, the code uses NO_RELOC if it is
3200          defined, and otherwise uses 0.  */
3201
3202 #ifdef BFD_ASSEMBLER
3203 #ifdef TC_CONS_FIX_NEW
3204       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3205 #else
3206       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3207                    /* @@ Should look at CPU word size.  */
3208                    nbytes == 2 ? BFD_RELOC_16
3209                       : nbytes == 8 ? BFD_RELOC_64
3210                       : BFD_RELOC_32);
3211 #endif
3212 #else
3213 #ifdef TC_CONS_FIX_NEW
3214       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3215 #else
3216       /* Figure out which reloc number to use.  Use TC_CONS_RELOC if
3217          it is defined, otherwise use NO_RELOC if it is defined,
3218          otherwise use 0.  */
3219 #ifndef TC_CONS_RELOC
3220 #ifdef NO_RELOC
3221 #define TC_CONS_RELOC NO_RELOC
3222 #else
3223 #define TC_CONS_RELOC 0
3224 #endif
3225 #endif
3226       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3227                    TC_CONS_RELOC);
3228 #endif /* TC_CONS_FIX_NEW */
3229 #endif /* BFD_ASSEMBLER */
3230     }
3231 }
3232 \f
3233 #ifdef BITFIELD_CONS_EXPRESSIONS
3234
3235 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3236    w:x,y:z, where w and y are bitwidths and x and y are values.  They
3237    then pack them all together. We do a little better in that we allow
3238    them in words, longs, etc. and we'll pack them in target byte order
3239    for you.
3240
3241    The rules are: pack least significat bit first, if a field doesn't
3242    entirely fit, put it in the next unit.  Overflowing the bitfield is
3243    explicitly *not* even a warning.  The bitwidth should be considered
3244    a "mask".
3245
3246    To use this function the tc-XXX.h file should define
3247    BITFIELD_CONS_EXPRESSIONS.  */
3248
3249 static void
3250 parse_bitfield_cons (exp, nbytes)
3251      expressionS *exp;
3252      unsigned int nbytes;
3253 {
3254   unsigned int bits_available = BITS_PER_CHAR * nbytes;
3255   char *hold = input_line_pointer;
3256
3257   (void) expression (exp);
3258
3259   if (*input_line_pointer == ':')
3260     {                   /* bitfields */
3261       long value = 0;
3262
3263       for (;;)
3264         {
3265           unsigned long width;
3266
3267           if (*input_line_pointer != ':')
3268             {
3269               input_line_pointer = hold;
3270               break;
3271             }                   /* next piece is not a bitfield */
3272
3273           /* In the general case, we can't allow
3274              full expressions with symbol
3275              differences and such.  The relocation
3276              entries for symbols not defined in this
3277              assembly would require arbitrary field
3278              widths, positions, and masks which most
3279              of our current object formats don't
3280              support.
3281
3282              In the specific case where a symbol
3283              *is* defined in this assembly, we
3284              *could* build fixups and track it, but
3285              this could lead to confusion for the
3286              backends.  I'm lazy. I'll take any
3287              SEG_ABSOLUTE. I think that means that
3288              you can use a previous .set or
3289              .equ type symbol.  xoxorich. */
3290
3291           if (exp->X_op == O_absent)
3292             {
3293               as_warn ("using a bit field width of zero");
3294               exp->X_add_number = 0;
3295               exp->X_op = O_constant;
3296             }                   /* implied zero width bitfield */
3297
3298           if (exp->X_op != O_constant)
3299             {
3300               *input_line_pointer = '\0';
3301               as_bad ("field width \"%s\" too complex for a bitfield", hold);
3302               *input_line_pointer = ':';
3303               demand_empty_rest_of_line ();
3304               return;
3305             }                   /* too complex */
3306
3307           if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3308             {
3309               as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3310                        width, nbytes, (BITS_PER_CHAR * nbytes));
3311               width = BITS_PER_CHAR * nbytes;
3312             }                   /* too big */
3313
3314           if (width > bits_available)
3315             {
3316               /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
3317               input_line_pointer = hold;
3318               exp->X_add_number = value;
3319               break;
3320             }                   /* won't fit */
3321
3322           hold = ++input_line_pointer; /* skip ':' */
3323
3324           (void) expression (exp);
3325           if (exp->X_op != O_constant)
3326             {
3327               char cache = *input_line_pointer;
3328
3329               *input_line_pointer = '\0';
3330               as_bad ("field value \"%s\" too complex for a bitfield", hold);
3331               *input_line_pointer = cache;
3332               demand_empty_rest_of_line ();
3333               return;
3334             }                   /* too complex */
3335
3336           value |= ((~(-1 << width) & exp->X_add_number)
3337                     << ((BITS_PER_CHAR * nbytes) - bits_available));
3338
3339           if ((bits_available -= width) == 0
3340               || is_it_end_of_statement ()
3341               || *input_line_pointer != ',')
3342             {
3343               break;
3344             }                   /* all the bitfields we're gonna get */
3345
3346           hold = ++input_line_pointer;
3347           (void) expression (exp);
3348         }                       /* forever loop */
3349
3350       exp->X_add_number = value;
3351       exp->X_op = O_constant;
3352       exp->X_unsigned = 1;
3353     }                           /* if looks like a bitfield */
3354 }                               /* parse_bitfield_cons() */
3355
3356 #endif /* BITFIELD_CONS_EXPRESSIONS */
3357 \f
3358 /* Handle an MRI style string expression.  */
3359
3360 static void
3361 parse_mri_cons (exp, nbytes)
3362      expressionS *exp;
3363      unsigned int nbytes;
3364 {
3365   if (*input_line_pointer != '\''
3366       && (input_line_pointer[1] != '\''
3367           || (*input_line_pointer != 'A'
3368               && *input_line_pointer != 'E')))
3369     TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3370   else
3371     {
3372       int scan = 0;
3373       unsigned int result = 0;
3374
3375       /* An MRI style string.  Cut into as many bytes as will fit into
3376          a nbyte chunk, left justify if necessary, and separate with
3377          commas so we can try again later.  */
3378       if (*input_line_pointer == 'A')
3379         ++input_line_pointer;
3380       else if (*input_line_pointer == 'E')
3381         {
3382           as_bad ("EBCDIC constants are not supported");
3383           ++input_line_pointer;
3384         }
3385
3386       input_line_pointer++;
3387       for (scan = 0; scan < nbytes; scan++)
3388         {
3389           if (*input_line_pointer == '\'')
3390             {
3391               if (input_line_pointer[1] == '\'')
3392                 {
3393                   input_line_pointer++;
3394                 }
3395               else
3396                 break;
3397             }
3398           result = (result << 8) | (*input_line_pointer++);
3399         }
3400
3401       /* Left justify */
3402       while (scan < nbytes)
3403         {
3404           result <<= 8;
3405           scan++;
3406         }
3407       /* Create correct expression */
3408       exp->X_op = O_constant;
3409       exp->X_add_number = result;
3410       /* Fake it so that we can read the next char too */
3411       if (input_line_pointer[0] != '\'' ||
3412           (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3413         {
3414           input_line_pointer -= 2;
3415           input_line_pointer[0] = ',';
3416           input_line_pointer[1] = '\'';
3417         }
3418       else
3419         input_line_pointer++;
3420     }
3421 }
3422 \f
3423 #ifdef REPEAT_CONS_EXPRESSIONS
3424
3425 /* Parse a repeat expression for cons.  This is used by the MIPS
3426    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
3427    object file COUNT times.
3428
3429    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
3430
3431 static void
3432 parse_repeat_cons (exp, nbytes)
3433      expressionS *exp;
3434      unsigned int nbytes;
3435 {
3436   expressionS count;
3437   register int i;
3438
3439   expression (exp);
3440
3441   if (*input_line_pointer != ':')
3442     {
3443       /* No repeat count.  */
3444       return;
3445     }
3446
3447   ++input_line_pointer;
3448   expression (&count);
3449   if (count.X_op != O_constant
3450       || count.X_add_number <= 0)
3451     {
3452       as_warn ("Unresolvable or nonpositive repeat count; using 1");
3453       return;
3454     }
3455
3456   /* The cons function is going to output this expression once.  So we
3457      output it count - 1 times.  */
3458   for (i = count.X_add_number - 1; i > 0; i--)
3459     emit_expr (exp, nbytes);
3460 }
3461
3462 #endif /* REPEAT_CONS_EXPRESSIONS */
3463 \f
3464 /* Parse a floating point number represented as a hex constant.  This
3465    permits users to specify the exact bits they want in the floating
3466    point number.  */
3467
3468 static int
3469 hex_float (float_type, bytes)
3470      int float_type;
3471      char *bytes;
3472 {
3473   int length;
3474   int i;
3475
3476   switch (float_type)
3477     {
3478     case 'f':
3479     case 'F':
3480     case 's':
3481     case 'S':
3482       length = 4;
3483       break;
3484
3485     case 'd':
3486     case 'D':
3487     case 'r':
3488     case 'R':
3489       length = 8;
3490       break;
3491
3492     case 'x':
3493     case 'X':
3494       length = 12;
3495       break;
3496
3497     case 'p':
3498     case 'P':
3499       length = 12;
3500       break;
3501
3502     default:
3503       as_bad ("Unknown floating type type '%c'", float_type);
3504       return -1;
3505     }
3506
3507   /* It would be nice if we could go through expression to parse the
3508      hex constant, but if we get a bignum it's a pain to sort it into
3509      the buffer correctly.  */
3510   i = 0;
3511   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
3512     {
3513       int d;
3514
3515       /* The MRI assembler accepts arbitrary underscores strewn about
3516          through the hex constant, so we ignore them as well. */
3517       if (*input_line_pointer == '_')
3518         {
3519           ++input_line_pointer;
3520           continue;
3521         }
3522
3523       if (i >= length)
3524         {
3525           as_warn ("Floating point constant too large");
3526           return -1;
3527         }
3528       d = hex_value (*input_line_pointer) << 4;
3529       ++input_line_pointer;
3530       while (*input_line_pointer == '_')
3531         ++input_line_pointer;
3532       if (hex_p (*input_line_pointer))
3533         {
3534           d += hex_value (*input_line_pointer);
3535           ++input_line_pointer;
3536         }
3537       if (target_big_endian)
3538         bytes[i] = d;
3539       else
3540         bytes[length - i - 1] = d;
3541       ++i;
3542     }
3543
3544   if (i < length)
3545     {
3546       if (target_big_endian)
3547         memset (bytes + i, 0, length - i);
3548       else
3549         memset (bytes, 0, length - i);
3550     }
3551
3552   return length;
3553 }
3554
3555 /*
3556  *                      float_cons()
3557  *
3558  * CONStruct some more frag chars of .floats .ffloats etc.
3559  * Makes 0 or more new frags.
3560  * If need_pass_2 == 1, no frags are emitted.
3561  * This understands only floating literals, not expressions. Sorry.
3562  *
3563  * A floating constant is defined by atof_generic(), except it is preceded
3564  * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3565  * reading, I decided to be incompatible. This always tries to give you
3566  * rounded bits to the precision of the pseudo-op. Former AS did premature
3567  * truncatation, restored noisy bits instead of trailing 0s AND gave you
3568  * a choice of 2 flavours of noise according to which of 2 floating-point
3569  * scanners you directed AS to use.
3570  *
3571  * In:  input_line_pointer->whitespace before, or '0' of flonum.
3572  *
3573  */
3574
3575 void
3576 float_cons (float_type)
3577      /* Clobbers input_line-pointer, checks end-of-line. */
3578      register int float_type;   /* 'f':.ffloat ... 'F':.float ... */
3579 {
3580   register char *p;
3581   int length;                   /* Number of chars in an object. */
3582   register char *err;           /* Error from scanning floating literal. */
3583   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3584
3585   if (is_it_end_of_statement ())
3586     {
3587       demand_empty_rest_of_line ();
3588       return;
3589     }
3590
3591   do
3592     {
3593       /* input_line_pointer->1st char of a flonum (we hope!). */
3594       SKIP_WHITESPACE ();
3595
3596       /* Skip any 0{letter} that may be present. Don't even check if the
3597        * letter is legal. Someone may invent a "z" format and this routine
3598        * has no use for such information. Lusers beware: you get
3599        * diagnostics if your input is ill-conditioned.
3600        */
3601       if (input_line_pointer[0] == '0' && isalpha (input_line_pointer[1]))
3602         input_line_pointer += 2;
3603
3604       /* Accept :xxxx, where the x's are hex digits, for a floating
3605          point with the exact digits specified.  */
3606       if (input_line_pointer[0] == ':')
3607         {
3608           ++input_line_pointer;
3609           length = hex_float (float_type, temp);
3610           if (length < 0)
3611             {
3612               ignore_rest_of_line ();
3613               return;
3614             }
3615         }
3616       else
3617         {
3618           err = md_atof (float_type, temp, &length);
3619           know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3620           know (length > 0);
3621           if (err)
3622             {
3623               as_bad ("Bad floating literal: %s", err);
3624               ignore_rest_of_line ();
3625               return;
3626             }
3627         }
3628
3629       if (!need_pass_2)
3630         {
3631           int count;
3632
3633           count = 1;
3634
3635 #ifdef REPEAT_CONS_EXPRESSIONS
3636           if (*input_line_pointer == ':')
3637             {
3638               expressionS count_exp;
3639
3640               ++input_line_pointer;
3641               expression (&count_exp);
3642               if (count_exp.X_op != O_constant
3643                   || count_exp.X_add_number <= 0)
3644                 {
3645                   as_warn ("unresolvable or nonpositive repeat count; using 1");
3646                 }
3647               else
3648                 count = count_exp.X_add_number;
3649             }
3650 #endif
3651
3652           while (--count >= 0)
3653             {
3654               p = frag_more (length);
3655               memcpy (p, temp, (unsigned int) length);
3656             }
3657         }
3658       SKIP_WHITESPACE ();
3659     }
3660   while (*input_line_pointer++ == ',');
3661
3662   --input_line_pointer;         /* Put terminator back into stream.  */
3663   demand_empty_rest_of_line ();
3664 }                               /* float_cons() */
3665 \f
3666 /*
3667  *                      stringer()
3668  *
3669  * We read 0 or more ',' seperated, double-quoted strings.
3670  *
3671  * Caller should have checked need_pass_2 is FALSE because we don't check it.
3672  */
3673
3674
3675 void
3676 stringer (append_zero)          /* Worker to do .ascii etc statements. */
3677      /* Checks end-of-line. */
3678      register int append_zero;  /* 0: don't append '\0', else 1 */
3679 {
3680   register unsigned int c;
3681
3682 #ifdef md_flush_pending_output
3683   md_flush_pending_output ();
3684 #endif
3685
3686   /*
3687    * The following awkward logic is to parse ZERO or more strings,
3688    * comma seperated. Recall a string expression includes spaces
3689    * before the opening '\"' and spaces after the closing '\"'.
3690    * We fake a leading ',' if there is (supposed to be)
3691    * a 1st, expression. We keep demanding expressions for each
3692    * ','.
3693    */
3694   if (is_it_end_of_statement ())
3695     {
3696       c = 0;                    /* Skip loop. */
3697       ++input_line_pointer;     /* Compensate for end of loop. */
3698     }
3699   else
3700     {
3701       c = ',';                  /* Do loop. */
3702     }
3703   while (c == ',' || c == '<' || c == '"')
3704     {
3705       SKIP_WHITESPACE ();
3706       switch (*input_line_pointer)
3707         {
3708         case '\"':
3709           ++input_line_pointer; /*->1st char of string. */
3710           while (is_a_char (c = next_char_of_string ()))
3711             {
3712               FRAG_APPEND_1_CHAR (c);
3713             }
3714           if (append_zero)
3715             {
3716               FRAG_APPEND_1_CHAR (0);
3717             }
3718           know (input_line_pointer[-1] == '\"');
3719           break;
3720         case '<':
3721           input_line_pointer++;
3722           c = get_single_number ();
3723           FRAG_APPEND_1_CHAR (c);
3724           if (*input_line_pointer != '>')
3725             {
3726               as_bad ("Expected <nn>");
3727             }
3728           input_line_pointer++;
3729           break;
3730         case ',':
3731           input_line_pointer++;
3732           break;
3733         }
3734       SKIP_WHITESPACE ();
3735       c = *input_line_pointer;
3736     }
3737
3738   demand_empty_rest_of_line ();
3739 }                               /* stringer() */
3740 \f
3741 /* FIXME-SOMEDAY: I had trouble here on characters with the
3742     high bits set.  We'll probably also have trouble with
3743     multibyte chars, wide chars, etc.  Also be careful about
3744     returning values bigger than 1 byte.  xoxorich. */
3745
3746 unsigned int
3747 next_char_of_string ()
3748 {
3749   register unsigned int c;
3750
3751   c = *input_line_pointer++ & CHAR_MASK;
3752   switch (c)
3753     {
3754     case '\"':
3755       c = NOT_A_CHAR;
3756       break;
3757
3758 #ifndef NO_STRING_ESCAPES
3759     case '\\':
3760       switch (c = *input_line_pointer++)
3761         {
3762         case 'b':
3763           c = '\b';
3764           break;
3765
3766         case 'f':
3767           c = '\f';
3768           break;
3769
3770         case 'n':
3771           c = '\n';
3772           break;
3773
3774         case 'r':
3775           c = '\r';
3776           break;
3777
3778         case 't':
3779           c = '\t';
3780           break;
3781
3782         case 'v':
3783           c = '\013';
3784           break;
3785
3786         case '\\':
3787         case '"':
3788           break;                /* As itself. */
3789
3790         case '0':
3791         case '1':
3792         case '2':
3793         case '3':
3794         case '4':
3795         case '5':
3796         case '6':
3797         case '7':
3798         case '8':
3799         case '9':
3800           {
3801             long number;
3802             int i;
3803
3804             for (i = 0, number = 0; isdigit (c) && i < 3; c = *input_line_pointer++, i++)
3805               {
3806                 number = number * 8 + c - '0';
3807               }
3808             c = number & 0xff;
3809           }
3810           --input_line_pointer;
3811           break;
3812
3813         case 'x':
3814         case 'X':
3815           {
3816             long number;
3817
3818             number = 0;
3819             c = *input_line_pointer++;
3820             while (isxdigit (c))
3821               {
3822                 if (isdigit (c))
3823                   number = number * 16 + c - '0';
3824                 else if (isupper (c))
3825                   number = number * 16 + c - 'A' + 10;
3826                 else
3827                   number = number * 16 + c - 'a' + 10;
3828                 c = *input_line_pointer++;
3829               }
3830             c = number & 0xff;
3831             --input_line_pointer;
3832           }
3833           break;
3834
3835         case '\n':
3836           /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
3837           as_warn ("Unterminated string: Newline inserted.");
3838           c = '\n';
3839           break;
3840
3841         default:
3842
3843 #ifdef ONLY_STANDARD_ESCAPES
3844           as_bad ("Bad escaped character in string, '?' assumed");
3845           c = '?';
3846 #endif /* ONLY_STANDARD_ESCAPES */
3847
3848           break;
3849         }                       /* switch on escaped char */
3850       break;
3851 #endif /* ! defined (NO_STRING_ESCAPES) */
3852
3853     default:
3854       break;
3855     }                           /* switch on char */
3856   return (c);
3857 }                               /* next_char_of_string() */
3858 \f
3859 static segT
3860 get_segmented_expression (expP)
3861      register expressionS *expP;
3862 {
3863   register segT retval;
3864
3865   retval = expression (expP);
3866   if (expP->X_op == O_illegal
3867       || expP->X_op == O_absent
3868       || expP->X_op == O_big)
3869     {
3870       as_bad ("expected address expression; zero assumed");
3871       expP->X_op = O_constant;
3872       expP->X_add_number = 0;
3873       retval = absolute_section;
3874     }
3875   return retval;
3876 }
3877
3878 static segT
3879 get_known_segmented_expression (expP)
3880      register expressionS *expP;
3881 {
3882   register segT retval;
3883
3884   if ((retval = get_segmented_expression (expP)) == undefined_section)
3885     {
3886       /* There is no easy way to extract the undefined symbol from the
3887          expression.  */
3888       if (expP->X_add_symbol != NULL
3889           && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
3890         as_warn ("symbol \"%s\" undefined; zero assumed",
3891                  S_GET_NAME (expP->X_add_symbol));
3892       else
3893         as_warn ("some symbol undefined; zero assumed");
3894       retval = absolute_section;
3895       expP->X_op = O_constant;
3896       expP->X_add_number = 0;
3897     }
3898   know (retval == absolute_section || SEG_NORMAL (retval));
3899   return (retval);
3900 }                               /* get_known_segmented_expression() */
3901
3902 offsetT
3903 get_absolute_expression ()
3904 {
3905   expressionS exp;
3906
3907   expression (&exp);
3908   if (exp.X_op != O_constant)
3909     {
3910       if (exp.X_op != O_absent)
3911         as_bad ("bad or irreducible absolute expression; zero assumed");
3912       exp.X_add_number = 0;
3913     }
3914   return exp.X_add_number;
3915 }
3916
3917 char                            /* return terminator */
3918 get_absolute_expression_and_terminator (val_pointer)
3919      long *val_pointer;         /* return value of expression */
3920 {
3921   /* FIXME: val_pointer should probably be offsetT *.  */
3922   *val_pointer = (long) get_absolute_expression ();
3923   return (*input_line_pointer++);
3924 }
3925 \f
3926 /*
3927  *                      demand_copy_C_string()
3928  *
3929  * Like demand_copy_string, but return NULL if the string contains any '\0's.
3930  * Give a warning if that happens.
3931  */
3932 char *
3933 demand_copy_C_string (len_pointer)
3934      int *len_pointer;
3935 {
3936   register char *s;
3937
3938   if ((s = demand_copy_string (len_pointer)) != 0)
3939     {
3940       register int len;
3941
3942       for (len = *len_pointer; len > 0; len--)
3943         {
3944           if (*s == 0)
3945             {
3946               s = 0;
3947               len = 1;
3948               *len_pointer = 0;
3949               as_bad ("This string may not contain \'\\0\'");
3950             }
3951         }
3952     }
3953   return s;
3954 }
3955 \f
3956 /*
3957  *                      demand_copy_string()
3958  *
3959  * Demand string, but return a safe (=private) copy of the string.
3960  * Return NULL if we can't read a string here.
3961  */
3962 char *
3963 demand_copy_string (lenP)
3964      int *lenP;
3965 {
3966   register unsigned int c;
3967   register int len;
3968   char *retval;
3969
3970   len = 0;
3971   SKIP_WHITESPACE ();
3972   if (*input_line_pointer == '\"')
3973     {
3974       input_line_pointer++;     /* Skip opening quote. */
3975
3976       while (is_a_char (c = next_char_of_string ()))
3977         {
3978           obstack_1grow (&notes, c);
3979           len++;
3980         }
3981       /* JF this next line is so demand_copy_C_string will return a
3982          null terminated string. */
3983       obstack_1grow (&notes, '\0');
3984       retval = obstack_finish (&notes);
3985     }
3986   else
3987     {
3988       as_warn ("Missing string");
3989       retval = NULL;
3990       ignore_rest_of_line ();
3991     }
3992   *lenP = len;
3993   return (retval);
3994 }                               /* demand_copy_string() */
3995 \f
3996 /*
3997  *              is_it_end_of_statement()
3998  *
3999  * In:  Input_line_pointer->next character.
4000  *
4001  * Do:  Skip input_line_pointer over all whitespace.
4002  *
4003  * Out: 1 if input_line_pointer->end-of-line.
4004 */
4005 int
4006 is_it_end_of_statement ()
4007 {
4008   SKIP_WHITESPACE ();
4009   return (is_end_of_line[(unsigned char) *input_line_pointer]);
4010 }                               /* is_it_end_of_statement() */
4011
4012 void
4013 equals (sym_name)
4014      char *sym_name;
4015 {
4016   register symbolS *symbolP;    /* symbol we are working with */
4017   char *stop;
4018   char stopc;
4019
4020   input_line_pointer++;
4021   if (*input_line_pointer == '=')
4022     input_line_pointer++;
4023
4024   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4025     input_line_pointer++;
4026
4027   if (flag_mri)
4028     stop = mri_comment_field (&stopc);
4029
4030   if (sym_name[0] == '.' && sym_name[1] == '\0')
4031     {
4032       /* Turn '. = mumble' into a .org mumble */
4033       register segT segment;
4034       expressionS exp;
4035
4036       segment = get_known_segmented_expression (&exp);
4037       if (!need_pass_2)
4038         do_org (segment, &exp, 0);
4039     }
4040   else
4041     {
4042       symbolP = symbol_find_or_make (sym_name);
4043       pseudo_set (symbolP);
4044     }
4045
4046   if (flag_mri)
4047     mri_comment_end (stop, stopc);
4048 }                               /* equals() */
4049
4050 /* .include -- include a file at this point. */
4051
4052 /* ARGSUSED */
4053 void
4054 s_include (arg)
4055      int arg;
4056 {
4057   char *newbuf;
4058   char *filename;
4059   int i;
4060   FILE *try;
4061   char *path;
4062
4063   if (! flag_m68k_mri)
4064     filename = demand_copy_string (&i);
4065   else
4066     {
4067       SKIP_WHITESPACE ();
4068       i = 0;
4069       while (! is_end_of_line[(unsigned char) *input_line_pointer]
4070              && *input_line_pointer != ' '
4071              && *input_line_pointer != '\t')
4072         {
4073           obstack_1grow (&notes, *input_line_pointer);
4074           ++input_line_pointer;
4075           ++i;
4076         }
4077       obstack_1grow (&notes, '\0');
4078       filename = obstack_finish (&notes);
4079       while (! is_end_of_line[(unsigned char) *input_line_pointer])
4080         ++input_line_pointer;
4081     }
4082   demand_empty_rest_of_line ();
4083   path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
4084   for (i = 0; i < include_dir_count; i++)
4085     {
4086       strcpy (path, include_dirs[i]);
4087       strcat (path, "/");
4088       strcat (path, filename);
4089       if (0 != (try = fopen (path, "r")))
4090         {
4091           fclose (try);
4092           goto gotit;
4093         }
4094     }
4095   free (path);
4096   path = filename;
4097 gotit:
4098   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY. */
4099   newbuf = input_scrub_include_file (path, input_line_pointer);
4100   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
4101 }                               /* s_include() */
4102
4103 void
4104 add_include_dir (path)
4105      char *path;
4106 {
4107   int i;
4108
4109   if (include_dir_count == 0)
4110     {
4111       include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
4112       include_dirs[0] = ".";    /* Current dir */
4113       include_dir_count = 2;
4114     }
4115   else
4116     {
4117       include_dir_count++;
4118       include_dirs = (char **) realloc (include_dirs,
4119                                 include_dir_count * sizeof (*include_dirs));
4120     }
4121
4122   include_dirs[include_dir_count - 1] = path;   /* New one */
4123
4124   i = strlen (path);
4125   if (i > include_dir_maxlen)
4126     include_dir_maxlen = i;
4127 }                               /* add_include_dir() */
4128
4129 void
4130 s_ignore (arg)
4131      int arg;
4132 {
4133   while (!is_end_of_line[(unsigned char) *input_line_pointer])
4134     {
4135       ++input_line_pointer;
4136     }
4137   ++input_line_pointer;
4138 }
4139
4140
4141 void
4142 read_print_statistics (file)
4143      FILE *file;
4144 {
4145   hash_print_statistics (file, "pseudo-op table", po_hash);
4146 }
4147
4148 /* end of read.c */