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         }
1825     }
1826 #endif
1827    if (!needs_align)
1828      {
1829        /* FIXME. This needs to be machine independent. */
1830        if (temp >= 8)
1831          align = 3;
1832        else if (temp >= 4)
1833          align = 2;
1834        else if (temp >= 2)
1835          align = 1;
1836        else
1837          align = 0;
1838
1839        record_alignment(bss_seg, align);
1840      }
1841
1842   if (needs_align)
1843     {
1844       align = 0;
1845       SKIP_WHITESPACE ();
1846       if (*input_line_pointer != ',')
1847         {
1848           as_bad ("Expected comma after size");
1849           ignore_rest_of_line ();
1850           return;
1851         }
1852       input_line_pointer++;
1853       SKIP_WHITESPACE ();
1854       if (*input_line_pointer == '\n')
1855         {
1856           as_bad ("Missing alignment");
1857           return;
1858         }
1859       align = get_absolute_expression ();
1860       if (align > max_alignment)
1861         {
1862           align = max_alignment;
1863           as_warn ("Alignment too large: %d. assumed.", align);
1864         }
1865       else if (align < 0)
1866         {
1867           align = 0;
1868           as_warn ("Alignment negative. 0 assumed.");
1869         }
1870       record_alignment (bss_seg, align);
1871     }                           /* if needs align */
1872   else
1873     {
1874       /* Assume some objects may require alignment on some systems.  */
1875 #ifdef TC_ALPHA
1876       if (temp > 1)
1877         {
1878           align = ffs (temp) - 1;
1879           if (temp % (1 << align))
1880             abort ();
1881         }
1882 #endif
1883     }
1884
1885   *p = 0;
1886   symbolP = symbol_find_or_make (name);
1887   *p = c;
1888
1889   if (
1890 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
1891        S_GET_OTHER (symbolP) == 0 &&
1892        S_GET_DESC (symbolP) == 0 &&
1893 #endif /* OBJ_AOUT or OBJ_BOUT */
1894        (S_GET_SEGMENT (symbolP) == bss_seg
1895         || (!S_IS_DEFINED (symbolP) && S_GET_VALUE (symbolP) == 0)))
1896     {
1897       char *pfrag;
1898
1899       subseg_set (bss_seg, 1);
1900
1901       if (align)
1902         frag_align (align, 0);
1903                                         /* detach from old frag */
1904       if (S_GET_SEGMENT (symbolP) == bss_seg)
1905         symbolP->sy_frag->fr_symbol = NULL;
1906
1907       symbolP->sy_frag = frag_now;
1908       pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
1909                         temp, (char *)0);
1910       *pfrag = 0;
1911
1912       S_SET_SEGMENT (symbolP, bss_seg);
1913
1914 #ifdef OBJ_COFF
1915       /* The symbol may already have been created with a preceding
1916          ".globl" directive -- be careful not to step on storage class
1917          in that case.  Otherwise, set it to static. */
1918       if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
1919         {
1920           S_SET_STORAGE_CLASS (symbolP, C_STAT);
1921         }
1922 #endif /* OBJ_COFF */
1923
1924 #ifdef S_SET_SIZE
1925       S_SET_SIZE (symbolP, temp);
1926 #endif
1927     }
1928   else
1929     as_bad ("Ignoring attempt to re-define symbol `%s'.",
1930             S_GET_NAME (symbolP));
1931
1932   subseg_set (current_seg, current_subseg);
1933
1934   demand_empty_rest_of_line ();
1935 }                               /* s_lcomm() */
1936
1937 void
1938 s_lsym (ignore)
1939      int ignore;
1940 {
1941   register char *name;
1942   register char c;
1943   register char *p;
1944   expressionS exp;
1945   register symbolS *symbolP;
1946
1947   /* we permit ANY defined expression: BSD4.2 demands constants */
1948   name = input_line_pointer;
1949   c = get_symbol_end ();
1950   p = input_line_pointer;
1951   *p = c;
1952   SKIP_WHITESPACE ();
1953   if (*input_line_pointer != ',')
1954     {
1955       *p = 0;
1956       as_bad ("Expected comma after name \"%s\"", name);
1957       *p = c;
1958       ignore_rest_of_line ();
1959       return;
1960     }
1961   input_line_pointer++;
1962   expression (&exp);
1963   if (exp.X_op != O_constant
1964       && exp.X_op != O_register)
1965     {
1966       as_bad ("bad expression");
1967       ignore_rest_of_line ();
1968       return;
1969     }
1970   *p = 0;
1971   symbolP = symbol_find_or_make (name);
1972
1973   /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
1974      symbolP->sy_desc == 0) out of this test because coff doesn't have
1975      those fields, and I can't see when they'd ever be tripped.  I
1976      don't think I understand why they were here so I may have
1977      introduced a bug. As recently as 1.37 didn't have this test
1978      anyway.  xoxorich. */
1979
1980   if (S_GET_SEGMENT (symbolP) == undefined_section
1981       && S_GET_VALUE (symbolP) == 0)
1982     {
1983       /* The name might be an undefined .global symbol; be sure to
1984          keep the "external" bit. */
1985       S_SET_SEGMENT (symbolP,
1986                      (exp.X_op == O_constant
1987                       ? absolute_section
1988                       : reg_section));
1989       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
1990     }
1991   else
1992     {
1993       as_bad ("Symbol %s already defined", name);
1994     }
1995   *p = c;
1996   demand_empty_rest_of_line ();
1997 }                               /* s_lsym() */
1998
1999 /* Read a line into an sb.  */
2000
2001 static int
2002 get_line_sb (line)
2003      sb *line;
2004 {
2005   if (input_line_pointer[-1] == '\n')
2006     bump_line_counters ();
2007
2008   if (input_line_pointer >= buffer_limit)
2009     {
2010       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2011       if (buffer_limit == 0)
2012         return 0;
2013     }
2014
2015   while (! is_end_of_line[(unsigned char) *input_line_pointer])
2016     sb_add_char (line, *input_line_pointer++);
2017   while (input_line_pointer < buffer_limit
2018          && is_end_of_line[(unsigned char) *input_line_pointer])
2019     {
2020       if (input_line_pointer[-1] == '\n')
2021         bump_line_counters ();
2022       ++input_line_pointer;
2023     }
2024   return 1;
2025 }
2026
2027 /* Define a macro.  This is an interface to macro.c, which is shared
2028    between gas and gasp.  */
2029
2030 void
2031 s_macro (ignore)
2032      int ignore;
2033 {
2034   char *file;
2035   unsigned int line;
2036   sb s;
2037   sb label;
2038   const char *err;
2039
2040   as_where (&file, &line);
2041
2042   sb_new (&s);
2043   while (! is_end_of_line[(unsigned char) *input_line_pointer])
2044     sb_add_char (&s, *input_line_pointer++);
2045
2046   sb_new (&label);
2047   if (line_label != NULL)
2048     sb_add_string (&label, S_GET_NAME (line_label));
2049
2050   err = define_macro (0, &s, &label, get_line_sb);
2051   if (err != NULL)
2052     as_bad_where (file, line, "%s", err);
2053   else
2054     {
2055       if (line_label != NULL)
2056         {
2057           S_SET_SEGMENT (line_label, undefined_section);
2058           S_SET_VALUE (line_label, 0);
2059           line_label->sy_frag = &zero_address_frag;
2060         }
2061     }
2062
2063   sb_kill (&s);
2064 }
2065
2066 /* Handle the .mexit pseudo-op, which immediately exits a macro
2067    expansion.  */
2068
2069 void
2070 s_mexit (ignore)
2071      int ignore;
2072 {
2073   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2074 }
2075
2076 /* Switch in and out of MRI mode.  */
2077
2078 void
2079 s_mri (ignore)
2080      int ignore;
2081 {
2082   int on, old_flag;
2083
2084   on = get_absolute_expression ();
2085   old_flag = flag_mri;
2086   if (on != 0)
2087     {
2088       flag_mri = 1;
2089 #ifdef TC_M68K
2090       flag_m68k_mri = 1;
2091 #endif
2092     }
2093   else
2094     {
2095       flag_mri = 0;
2096       flag_m68k_mri = 0;
2097     }
2098
2099 #ifdef MRI_MODE_CHANGE
2100   if (on != old_flag)
2101     MRI_MODE_CHANGE (on);
2102 #endif
2103
2104   demand_empty_rest_of_line ();
2105 }
2106
2107 /* Handle changing the location counter.  */
2108
2109 static void
2110 do_org (segment, exp, fill)
2111      segT segment;
2112      expressionS *exp;
2113      int fill;
2114 {
2115   if (segment != now_seg && segment != absolute_section)
2116     as_bad ("invalid segment \"%s\"; segment \"%s\" assumed",
2117             segment_name (segment), segment_name (now_seg));
2118
2119   if (now_seg == absolute_section)
2120     {
2121       if (fill != 0)
2122         as_warn ("ignoring fill value in absolute section");
2123       if (exp->X_op != O_constant)
2124         {
2125           as_bad ("only constant offsets supported in absolute section");
2126           exp->X_add_number = 0;
2127         }
2128       abs_section_offset = exp->X_add_number;
2129     }
2130   else
2131     {
2132       char *p;
2133
2134       p = frag_var (rs_org, 1, 1, (relax_substateT) 0, exp->X_add_symbol,
2135                     exp->X_add_number, (char *) NULL);
2136       *p = fill;
2137     }
2138 }
2139
2140 void
2141 s_org (ignore)
2142      int ignore;
2143 {
2144   register segT segment;
2145   expressionS exp;
2146   register long temp_fill;
2147
2148   /* The m68k MRI assembler has a different meaning for .org.  It
2149      means to create an absolute section at a given address.  We can't
2150      support that--use a linker script instead.  */
2151   if (flag_m68k_mri)
2152     {
2153       as_bad ("MRI style ORG pseudo-op not supported");
2154       ignore_rest_of_line ();
2155       return;
2156     }
2157
2158   /* Don't believe the documentation of BSD 4.2 AS.  There is no such
2159      thing as a sub-segment-relative origin.  Any absolute origin is
2160      given a warning, then assumed to be segment-relative.  Any
2161      segmented origin expression ("foo+42") had better be in the right
2162      segment or the .org is ignored.
2163
2164      BSD 4.2 AS warns if you try to .org backwards. We cannot because
2165      we never know sub-segment sizes when we are reading code.  BSD
2166      will crash trying to emit negative numbers of filler bytes in
2167      certain .orgs. We don't crash, but see as-write for that code.
2168
2169      Don't make frag if need_pass_2==1.  */
2170   segment = get_known_segmented_expression (&exp);
2171   if (*input_line_pointer == ',')
2172     {
2173       input_line_pointer++;
2174       temp_fill = get_absolute_expression ();
2175     }
2176   else
2177     temp_fill = 0;
2178
2179   if (!need_pass_2)
2180     do_org (segment, &exp, temp_fill);
2181
2182   demand_empty_rest_of_line ();
2183 }                               /* s_org() */
2184
2185 /* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
2186    called by the obj-format routine which handles section changing
2187    when in MRI mode.  It will create a new section, and return it.  It
2188    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
2189    'M' (mixed), or 'R' (romable).  If BFD_ASSEMBLER is defined, the
2190    flags will be set in the section.  */
2191
2192 void
2193 s_mri_sect (type)
2194      char *type;
2195 {
2196 #ifdef TC_M68K
2197
2198   char *name;
2199   char c;
2200   segT seg;
2201
2202   SKIP_WHITESPACE ();
2203
2204   name = input_line_pointer;
2205   if (! isdigit ((unsigned char) *name))
2206     c = get_symbol_end ();
2207   else
2208     {
2209       do
2210         {
2211           ++input_line_pointer;
2212         }
2213       while (isdigit ((unsigned char) *input_line_pointer));
2214       c = *input_line_pointer;
2215       *input_line_pointer = '\0';
2216     }
2217
2218   name = xstrdup (name);
2219
2220   *input_line_pointer = c;
2221
2222   seg = subseg_new (name, 0);
2223
2224   if (*input_line_pointer == ',')
2225     {
2226       int align;
2227
2228       ++input_line_pointer;
2229       align = get_absolute_expression ();
2230       record_alignment (seg, align);
2231     }
2232
2233   *type = 'C';
2234   if (*input_line_pointer == ',')
2235     {
2236       c = *++input_line_pointer;
2237       c = toupper ((unsigned char) c);
2238       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
2239         *type = c;
2240       else
2241         as_bad ("unrecognized section type");
2242       ++input_line_pointer;
2243
2244 #ifdef BFD_ASSEMBLER
2245       {
2246         flagword flags;
2247
2248         flags = SEC_NO_FLAGS;
2249         if (*type == 'C')
2250           flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
2251         else if (*type == 'D' || *type == 'M')
2252           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
2253         else if (*type == 'R')
2254           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
2255         if (flags != SEC_NO_FLAGS)
2256           {
2257             if (! bfd_set_section_flags (stdoutput, seg, flags))
2258               as_warn ("error setting flags for \"%s\": %s",
2259                        bfd_section_name (stdoutput, seg),
2260                        bfd_errmsg (bfd_get_error ()));
2261           }
2262       }
2263 #endif
2264     }
2265
2266   /* Ignore the HP type.  */
2267   if (*input_line_pointer == ',')
2268     input_line_pointer += 2;
2269
2270   demand_empty_rest_of_line ();
2271
2272 #else /* ! TC_M68K */
2273 #ifdef TC_I960
2274
2275   char *name;
2276   char c;
2277   segT seg;
2278
2279   SKIP_WHITESPACE ();
2280
2281   name = input_line_pointer;
2282   c = get_symbol_end ();
2283
2284   name = xstrdup (name);
2285
2286   *input_line_pointer = c;
2287
2288   seg = subseg_new (name, 0);
2289
2290   if (*input_line_pointer != ',')
2291     *type = 'C';
2292   else
2293     {
2294       char *sectype;
2295
2296       ++input_line_pointer;
2297       SKIP_WHITESPACE ();
2298       sectype = input_line_pointer;
2299       c = get_symbol_end ();
2300       if (*sectype == '\0')
2301         *type = 'C';
2302       else if (strcasecmp (sectype, "text") == 0)
2303         *type = 'C';
2304       else if (strcasecmp (sectype, "data") == 0)
2305         *type = 'D';
2306       else if (strcasecmp (sectype, "romdata") == 0)
2307         *type = 'R';
2308       else
2309         as_warn ("unrecognized section type `%s'", sectype);
2310       *input_line_pointer = c;
2311     }
2312
2313   if (*input_line_pointer == ',')
2314     {
2315       char *seccmd;
2316
2317       ++input_line_pointer;
2318       SKIP_WHITESPACE ();
2319       seccmd = input_line_pointer;
2320       c = get_symbol_end ();
2321       if (strcasecmp (seccmd, "absolute") == 0)
2322         {
2323           as_bad ("absolute sections are not supported");
2324           *input_line_pointer = c;
2325           ignore_rest_of_line ();
2326           return;
2327         }
2328       else if (strcasecmp (seccmd, "align") == 0)
2329         {
2330           int align;
2331
2332           *input_line_pointer = c;
2333           align = get_absolute_expression ();
2334           record_alignment (seg, align);
2335         }
2336       else
2337         {
2338           as_warn ("unrecognized section command `%s'", seccmd);
2339           *input_line_pointer = c;
2340         }
2341     }
2342
2343   demand_empty_rest_of_line ();
2344
2345 #else /* ! TC_I960 */
2346   /* The MRI assembler seems to use different forms of .sect for
2347      different targets.  */
2348   abort ();
2349 #endif /* ! TC_I960 */
2350 #endif /* ! TC_M68K */
2351 }
2352
2353 /* Handle the .print pseudo-op.  */
2354
2355 void
2356 s_print (ignore)
2357      int ignore;
2358 {
2359   char *s;
2360   int len;
2361
2362   s = demand_copy_C_string (&len);
2363   printf ("%s\n", s);
2364   demand_empty_rest_of_line ();
2365 }
2366
2367 /* Handle the .purgem pseudo-op.  */
2368
2369 void
2370 s_purgem (ignore)
2371      int ignore;
2372 {
2373   if (is_it_end_of_statement ())
2374     {
2375       demand_empty_rest_of_line ();
2376       return;
2377     }
2378
2379   do
2380     {
2381       char *name;
2382       char c;
2383
2384       SKIP_WHITESPACE ();
2385       name = input_line_pointer;
2386       c = get_symbol_end ();
2387       delete_macro (name);
2388       *input_line_pointer = c;
2389       SKIP_WHITESPACE ();
2390     }
2391   while (*input_line_pointer++ == ',');
2392
2393   --input_line_pointer;
2394   demand_empty_rest_of_line ();
2395 }
2396
2397 /* Handle the .rept pseudo-op.  */
2398
2399 void
2400 s_rept (ignore)
2401      int ignore;
2402 {
2403   int count;
2404   sb one;
2405   sb many;
2406
2407   count = get_absolute_expression ();
2408
2409   sb_new (&one);
2410   if (! buffer_and_nest ("REPT", "ENDR", &one, get_line_sb))
2411     {
2412       as_bad ("rept without endr");
2413       return;
2414     }
2415
2416   sb_new (&many);
2417   while (count-- > 0)
2418     sb_add_sb (&many, &one);
2419
2420   sb_kill (&one);
2421
2422   input_scrub_include_sb (&many, input_line_pointer);
2423   sb_kill (&many);
2424   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
2425 }
2426
2427 void
2428 s_set (ignore)
2429      int ignore;
2430 {
2431   register char *name;
2432   register char delim;
2433   register char *end_name;
2434   register symbolS *symbolP;
2435
2436   /*
2437    * Especial apologies for the random logic:
2438    * this just grew, and could be parsed much more simply!
2439    * Dean in haste.
2440    */
2441   name = input_line_pointer;
2442   delim = get_symbol_end ();
2443   end_name = input_line_pointer;
2444   *end_name = delim;
2445   SKIP_WHITESPACE ();
2446
2447   if (*input_line_pointer != ',')
2448     {
2449       *end_name = 0;
2450       as_bad ("Expected comma after name \"%s\"", name);
2451       *end_name = delim;
2452       ignore_rest_of_line ();
2453       return;
2454     }
2455
2456   input_line_pointer++;
2457   *end_name = 0;
2458
2459   if (name[0] == '.' && name[1] == '\0')
2460     {
2461       /* Turn '. = mumble' into a .org mumble */
2462       register segT segment;
2463       expressionS exp;
2464
2465       segment = get_known_segmented_expression (&exp);
2466
2467       if (!need_pass_2)
2468         do_org (segment, &exp, 0);
2469
2470       *end_name = delim;
2471       return;
2472     }
2473
2474   if ((symbolP = symbol_find (name)) == NULL
2475       && (symbolP = md_undefined_symbol (name)) == NULL)
2476     {
2477       symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2478 #ifdef OBJ_COFF
2479       /* "set" symbols are local unless otherwise specified. */
2480       SF_SET_LOCAL (symbolP);
2481 #endif /* OBJ_COFF */
2482
2483     }                           /* make a new symbol */
2484
2485   symbol_table_insert (symbolP);
2486
2487   *end_name = delim;
2488   pseudo_set (symbolP);
2489   demand_empty_rest_of_line ();
2490 }                               /* s_set() */
2491
2492 void
2493 s_space (mult)
2494      int mult;
2495 {
2496   expressionS exp;
2497   expressionS val;
2498   char *p = 0;
2499   char *stop = NULL;
2500   char stopc;
2501
2502 #ifdef md_flush_pending_output
2503   md_flush_pending_output ();
2504 #endif
2505
2506   if (flag_mri)
2507     stop = mri_comment_field (&stopc);
2508
2509   expression (&exp);
2510
2511   SKIP_WHITESPACE ();
2512   if (*input_line_pointer == ',')
2513     {
2514       ++input_line_pointer;
2515       expression (&val);
2516     }
2517   else
2518     {
2519       val.X_op = O_constant;
2520       val.X_add_number = 0;
2521     }
2522
2523   if (val.X_op != O_constant
2524       || val.X_add_number < - 0x80
2525       || val.X_add_number > 0xff
2526       || (mult != 0 && mult != 1 && val.X_add_number != 0))
2527     {
2528       if (exp.X_op != O_constant)
2529         as_bad ("Unsupported variable size or fill value");
2530       else
2531         {
2532           offsetT i;
2533
2534           if (mult == 0)
2535             mult = 1;
2536           for (i = 0; i < exp.X_add_number; i++)
2537             emit_expr (&val, mult);
2538         }
2539     }
2540   else
2541     {
2542       if (exp.X_op == O_constant)
2543         {
2544           long repeat;
2545
2546           repeat = exp.X_add_number;
2547           if (mult)
2548             repeat *= mult;
2549           if (repeat <= 0)
2550             {
2551               if (! flag_mri || repeat < 0)
2552                 as_warn (".space repeat count is %s, ignored",
2553                          repeat ? "negative" : "zero");
2554               goto getout;
2555             }
2556
2557           /* If we are in the absolute section, just bump the offset.  */
2558           if (now_seg == absolute_section)
2559             {
2560               abs_section_offset += repeat;
2561               goto getout;
2562             }
2563
2564           /* If we are secretly in an MRI common section, then
2565              creating space just increases the size of the common
2566              symbol.  */
2567           if (mri_common_symbol != NULL)
2568             {
2569               S_SET_VALUE (mri_common_symbol,
2570                            S_GET_VALUE (mri_common_symbol) + repeat);
2571               goto getout;
2572             }
2573
2574           if (!need_pass_2)
2575             p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
2576                           repeat, (char *) 0);
2577         }
2578       else
2579         {
2580           if (now_seg == absolute_section)
2581             {
2582               as_bad ("space allocation too complex in absolute section");
2583               subseg_set (text_section, 0);
2584             }
2585           if (mri_common_symbol != NULL)
2586             {
2587               as_bad ("space allocation too complex in common section");
2588               mri_common_symbol = NULL;
2589             }
2590           if (!need_pass_2)
2591             p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
2592                           make_expr_symbol (&exp), 0L, (char *) 0);
2593         }
2594
2595       if (p)
2596         *p = val.X_add_number;
2597     }
2598
2599  getout:
2600   if (flag_mri)
2601     mri_comment_end (stop, stopc);
2602
2603   demand_empty_rest_of_line ();
2604 }
2605
2606 /* This is like s_space, but the value is a floating point number with
2607    the given precision.  This is for the MRI dcb.s pseudo-op and
2608    friends.  */
2609
2610 void
2611 s_float_space (float_type)
2612      int float_type;
2613 {
2614   offsetT count;
2615   int flen;
2616   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
2617   char *stop = NULL;
2618   char stopc;
2619
2620   if (flag_mri)
2621     stop = mri_comment_field (&stopc);
2622
2623   count = get_absolute_expression ();
2624
2625   SKIP_WHITESPACE ();
2626   if (*input_line_pointer != ',')
2627     {
2628       as_bad ("missing value");
2629       if (flag_mri)
2630         mri_comment_end (stop, stopc);
2631       ignore_rest_of_line ();
2632       return;
2633     }
2634
2635   ++input_line_pointer;
2636
2637   SKIP_WHITESPACE ();
2638
2639   /* Skip any 0{letter} that may be present.  Don't even check if the
2640    * letter is legal.  */
2641   if (input_line_pointer[0] == '0' && isalpha (input_line_pointer[1]))
2642     input_line_pointer += 2;
2643
2644   /* Accept :xxxx, where the x's are hex digits, for a floating point
2645      with the exact digits specified.  */
2646   if (input_line_pointer[0] == ':')
2647     {
2648       flen = hex_float (float_type, temp);
2649       if (flen < 0)
2650         {
2651           if (flag_mri)
2652             mri_comment_end (stop, stopc);
2653           ignore_rest_of_line ();
2654           return;
2655         }
2656     }
2657   else
2658     {
2659       char *err;
2660
2661       err = md_atof (float_type, temp, &flen);
2662       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
2663       know (flen > 0);
2664       if (err)
2665         {
2666           as_bad ("Bad floating literal: %s", err);
2667           if (flag_mri)
2668             mri_comment_end (stop, stopc);
2669           ignore_rest_of_line ();
2670           return;
2671         }
2672     }
2673
2674   while (--count >= 0)
2675     {
2676       char *p;
2677
2678       p = frag_more (flen);
2679       memcpy (p, temp, (unsigned int) flen);
2680     }
2681
2682   if (flag_mri)
2683     mri_comment_end (stop, stopc);
2684
2685   demand_empty_rest_of_line ();
2686 }
2687
2688 /* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
2689
2690 void
2691 s_struct (ignore)
2692      int ignore;
2693 {
2694   char *stop = NULL;
2695   char stopc;
2696
2697   if (flag_mri)
2698     stop = mri_comment_field (&stopc);
2699   abs_section_offset = get_absolute_expression ();
2700   subseg_set (absolute_section, 0);
2701   if (flag_mri)
2702     mri_comment_end (stop, stopc);
2703   demand_empty_rest_of_line ();
2704 }
2705
2706 void
2707 s_text (ignore)
2708      int ignore;
2709 {
2710   register int temp;
2711
2712   temp = get_absolute_expression ();
2713   subseg_set (text_section, (subsegT) temp);
2714   demand_empty_rest_of_line ();
2715 #ifdef OBJ_VMS
2716   const_flag &= ~IN_DEFAULT_SECTION;
2717 #endif
2718 }                               /* s_text() */
2719 \f
2720
2721 void
2722 demand_empty_rest_of_line ()
2723 {
2724   SKIP_WHITESPACE ();
2725   if (is_end_of_line[(unsigned char) *input_line_pointer])
2726     {
2727       input_line_pointer++;
2728     }
2729   else
2730     {
2731       ignore_rest_of_line ();
2732     }
2733   /* Return having already swallowed end-of-line. */
2734 }                               /* Return pointing just after end-of-line. */
2735
2736 void
2737 ignore_rest_of_line ()          /* For suspect lines: gives warning. */
2738 {
2739   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2740     {
2741       if (isprint (*input_line_pointer))
2742         as_bad ("Rest of line ignored. First ignored character is `%c'.",
2743                 *input_line_pointer);
2744       else
2745         as_bad ("Rest of line ignored. First ignored character valued 0x%x.",
2746                 *input_line_pointer);
2747       while (input_line_pointer < buffer_limit
2748              && !is_end_of_line[(unsigned char) *input_line_pointer])
2749         {
2750           input_line_pointer++;
2751         }
2752     }
2753   input_line_pointer++;         /* Return pointing just after end-of-line. */
2754   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
2755 }
2756
2757 /*
2758  *                      pseudo_set()
2759  *
2760  * In:  Pointer to a symbol.
2761  *      Input_line_pointer->expression.
2762  *
2763  * Out: Input_line_pointer->just after any whitespace after expression.
2764  *      Tried to set symbol to value of expression.
2765  *      Will change symbols type, value, and frag;
2766  */
2767 void
2768 pseudo_set (symbolP)
2769      symbolS *symbolP;
2770 {
2771   expressionS exp;
2772 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2773   int ext;
2774 #endif /* OBJ_AOUT or OBJ_BOUT */
2775
2776   know (symbolP);               /* NULL pointer is logic error. */
2777 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2778   ext = S_IS_EXTERNAL (symbolP);
2779 #endif /* OBJ_AOUT or OBJ_BOUT */
2780
2781   (void) expression (&exp);
2782
2783   if (exp.X_op == O_illegal)
2784     as_bad ("illegal expression; zero assumed");
2785   else if (exp.X_op == O_absent)
2786     as_bad ("missing expression; zero assumed");
2787   else if (exp.X_op == O_big)
2788     as_bad ("%s number invalid; zero assumed",
2789             exp.X_add_number > 0 ? "bignum" : "floating point");
2790   else if (exp.X_op == O_subtract
2791            && (S_GET_SEGMENT (exp.X_add_symbol)
2792                == S_GET_SEGMENT (exp.X_op_symbol))
2793            && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
2794            && exp.X_add_symbol->sy_frag == exp.X_op_symbol->sy_frag)
2795     {
2796       exp.X_op = O_constant;
2797       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
2798                           - S_GET_VALUE (exp.X_op_symbol));
2799     }
2800
2801   switch (exp.X_op)
2802     {
2803     case O_illegal:
2804     case O_absent:
2805     case O_big:
2806       exp.X_add_number = 0;
2807       /* Fall through.  */
2808     case O_constant:
2809       S_SET_SEGMENT (symbolP, absolute_section);
2810 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2811       if (ext)
2812         S_SET_EXTERNAL (symbolP);
2813       else
2814         S_CLEAR_EXTERNAL (symbolP);
2815 #endif /* OBJ_AOUT or OBJ_BOUT */
2816       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2817       symbolP->sy_frag = &zero_address_frag;
2818       break;
2819
2820     case O_register:
2821       S_SET_SEGMENT (symbolP, reg_section);
2822       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
2823       symbolP->sy_frag = &zero_address_frag;
2824       break;
2825
2826     case O_symbol:
2827       if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
2828           || exp.X_add_number != 0)
2829         symbolP->sy_value = exp;
2830       else
2831         {
2832           symbolS *s = exp.X_add_symbol;
2833
2834           S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
2835 #if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
2836           if (ext)
2837             S_SET_EXTERNAL (symbolP);
2838           else
2839             S_CLEAR_EXTERNAL (symbolP);
2840 #endif /* OBJ_AOUT or OBJ_BOUT */
2841           S_SET_VALUE (symbolP,
2842                        exp.X_add_number + S_GET_VALUE (s));
2843           symbolP->sy_frag = s->sy_frag;
2844           copy_symbol_attributes (symbolP, s);
2845         }
2846       break;
2847
2848     default:
2849       /* The value is some complex expression.
2850          FIXME: Should we set the segment to anything?  */
2851       symbolP->sy_value = exp;
2852       break;
2853     }
2854 }
2855 \f
2856 /*
2857  *                      cons()
2858  *
2859  * CONStruct more frag of .bytes, or .words etc.
2860  * Should need_pass_2 be 1 then emit no frag(s).
2861  * This understands EXPRESSIONS.
2862  *
2863  * Bug (?)
2864  *
2865  * This has a split personality. We use expression() to read the
2866  * value. We can detect if the value won't fit in a byte or word.
2867  * But we can't detect if expression() discarded significant digits
2868  * in the case of a long. Not worth the crocks required to fix it.
2869  */
2870
2871 /* Select a parser for cons expressions.  */
2872
2873 /* Some targets need to parse the expression in various fancy ways.
2874    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
2875    (for example, the HPPA does this).  Otherwise, you can define
2876    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
2877    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
2878    are defined, which is the normal case, then only simple expressions
2879    are permitted.  */
2880
2881 static void
2882 parse_mri_cons PARAMS ((expressionS *exp, unsigned int nbytes));
2883
2884 #ifndef TC_PARSE_CONS_EXPRESSION
2885 #ifdef BITFIELD_CONS_EXPRESSIONS
2886 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
2887 static void
2888 parse_bitfield_cons PARAMS ((expressionS *exp, unsigned int nbytes));
2889 #endif
2890 #ifdef REPEAT_CONS_EXPRESSIONS
2891 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
2892 static void
2893 parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
2894 #endif
2895
2896 /* If we haven't gotten one yet, just call expression.  */
2897 #ifndef TC_PARSE_CONS_EXPRESSION
2898 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
2899 #endif
2900 #endif
2901
2902 /* worker to do .byte etc statements */
2903 /* clobbers input_line_pointer, checks */
2904 /* end-of-line. */
2905 static void
2906 cons_worker (nbytes, rva)
2907      register int nbytes;       /* 1=.byte, 2=.word, 4=.long */
2908      int rva;
2909 {
2910   int c;
2911   expressionS exp;
2912   char *stop = NULL;
2913   char stopc;
2914
2915 #ifdef md_flush_pending_output
2916   md_flush_pending_output ();
2917 #endif
2918
2919   if (flag_mri)
2920     stop = mri_comment_field (&stopc);
2921
2922   if (is_it_end_of_statement ())
2923     {
2924       if (flag_mri)
2925         mri_comment_end (stop, stopc);
2926       demand_empty_rest_of_line ();
2927       return;
2928     }
2929
2930   c = 0;
2931   do
2932     {
2933       if (flag_m68k_mri)
2934         parse_mri_cons (&exp, (unsigned int) nbytes);
2935       else
2936         TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
2937
2938       if (rva)
2939         {
2940           if (exp.X_op == O_symbol)
2941             exp.X_op = O_symbol_rva;
2942           else
2943             as_fatal ("rva without symbol");
2944         }
2945       emit_expr (&exp, (unsigned int) nbytes);
2946       ++c;
2947     }
2948   while (*input_line_pointer++ == ',');
2949
2950   /* In MRI mode, after an odd number of bytes, we must align to an
2951      even word boundary, unless the next instruction is a dc.b, ds.b
2952      or dcb.b.  */
2953   if (flag_mri && nbytes == 1 && (c & 1) != 0)
2954     mri_pending_align = 1;
2955
2956   input_line_pointer--;         /* Put terminator back into stream. */
2957
2958   if (flag_mri)
2959     mri_comment_end (stop, stopc);
2960
2961   demand_empty_rest_of_line ();
2962 }
2963
2964
2965 void
2966 cons (size)
2967      int size;
2968 {
2969   cons_worker (size, 0);
2970 }
2971
2972 void
2973 s_rva (size)
2974      int size;
2975 {
2976   cons_worker (size, 1);
2977 }
2978
2979
2980 /* Put the contents of expression EXP into the object file using
2981    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
2982
2983 void
2984 emit_expr (exp, nbytes)
2985      expressionS *exp;
2986      unsigned int nbytes;
2987 {
2988   operatorT op;
2989   register char *p;
2990   valueT extra_digit = 0;
2991
2992   /* Don't do anything if we are going to make another pass.  */
2993   if (need_pass_2)
2994     return;
2995
2996   op = exp->X_op;
2997
2998   /* Allow `.word 0' in the absolute section.  */
2999   if (now_seg == absolute_section)
3000     {
3001       if (op != O_constant || exp->X_add_number != 0)
3002         as_bad ("attempt to store value in absolute section");
3003       abs_section_offset += nbytes;
3004       return;
3005     }
3006
3007   /* Handle a negative bignum.  */
3008   if (op == O_uminus
3009       && exp->X_add_number == 0
3010       && exp->X_add_symbol->sy_value.X_op == O_big
3011       && exp->X_add_symbol->sy_value.X_add_number > 0)
3012     {
3013       int i;
3014       unsigned long carry;
3015
3016       exp = &exp->X_add_symbol->sy_value;
3017
3018       /* Negate the bignum: one's complement each digit and add 1.  */
3019       carry = 1;
3020       for (i = 0; i < exp->X_add_number; i++)
3021         {
3022           unsigned long next;
3023
3024           next = (((~ (generic_bignum[i] & LITTLENUM_MASK))
3025                    & LITTLENUM_MASK)
3026                   + carry);
3027           generic_bignum[i] = next & LITTLENUM_MASK;
3028           carry = next >> LITTLENUM_NUMBER_OF_BITS;
3029         }
3030
3031       /* We can ignore any carry out, because it will be handled by
3032          extra_digit if it is needed.  */
3033
3034       extra_digit = (valueT) -1;
3035       op = O_big;
3036     }
3037
3038   if (op == O_absent || op == O_illegal)
3039     {
3040       as_warn ("zero assumed for missing expression");
3041       exp->X_add_number = 0;
3042       op = O_constant;
3043     }
3044   else if (op == O_big && exp->X_add_number <= 0)
3045     {
3046       as_bad ("floating point number invalid; zero assumed");
3047       exp->X_add_number = 0;
3048       op = O_constant;
3049     }
3050   else if (op == O_register)
3051     {
3052       as_warn ("register value used as expression");
3053       op = O_constant;
3054     }
3055
3056   p = frag_more ((int) nbytes);
3057
3058 #ifndef WORKING_DOT_WORD
3059   /* If we have the difference of two symbols in a word, save it on
3060      the broken_words list.  See the code in write.c.  */
3061   if (op == O_subtract && nbytes == 2)
3062     {
3063       struct broken_word *x;
3064
3065       x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
3066       x->next_broken_word = broken_words;
3067       broken_words = x;
3068       x->frag = frag_now;
3069       x->word_goes_here = p;
3070       x->dispfrag = 0;
3071       x->add = exp->X_add_symbol;
3072       x->sub = exp->X_op_symbol;
3073       x->addnum = exp->X_add_number;
3074       x->added = 0;
3075       new_broken_words++;
3076       return;
3077     }
3078 #endif
3079
3080   /* If we have an integer, but the number of bytes is too large to
3081      pass to md_number_to_chars, handle it as a bignum.  */
3082   if (op == O_constant && nbytes > sizeof (valueT))
3083     {
3084       valueT val;
3085       int gencnt;
3086
3087       if (! exp->X_unsigned && exp->X_add_number < 0)
3088         extra_digit = (valueT) -1;
3089       val = (valueT) exp->X_add_number;
3090       gencnt = 0;
3091       do
3092         {
3093           generic_bignum[gencnt] = val & LITTLENUM_MASK;
3094           val >>= LITTLENUM_NUMBER_OF_BITS;
3095           ++gencnt;
3096         }
3097       while (val != 0);
3098       op = exp->X_op = O_big;
3099       exp->X_add_number = gencnt;
3100     }
3101
3102   if (op == O_constant)
3103     {
3104       register valueT get;
3105       register valueT use;
3106       register valueT mask;
3107       register valueT unmask;
3108
3109       /* JF << of >= number of bits in the object is undefined.  In
3110          particular SPARC (Sun 4) has problems */
3111       if (nbytes >= sizeof (valueT))
3112         mask = 0;
3113       else
3114         mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes); /* Don't store these bits. */
3115
3116       unmask = ~mask;           /* Do store these bits. */
3117
3118 #ifdef NEVER
3119       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
3120       mask = ~(unmask >> 1);    /* Includes sign bit now. */
3121 #endif
3122
3123       get = exp->X_add_number;
3124       use = get & unmask;
3125       if ((get & mask) != 0 && (get & mask) != mask)
3126         {               /* Leading bits contain both 0s & 1s. */
3127           as_warn ("Value 0x%lx truncated to 0x%lx.", get, use);
3128         }
3129       /* put bytes in right order. */
3130       md_number_to_chars (p, use, (int) nbytes);
3131     }
3132   else if (op == O_big)
3133     {
3134       int size;
3135       LITTLENUM_TYPE *nums;
3136
3137       know (nbytes % CHARS_PER_LITTLENUM == 0);
3138
3139       size = exp->X_add_number * CHARS_PER_LITTLENUM;
3140       if (nbytes < size)
3141         {
3142           as_warn ("Bignum truncated to %d bytes", nbytes);
3143           size = nbytes;
3144         }
3145
3146       if (target_big_endian)
3147         {
3148           while (nbytes > size)
3149             {
3150               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3151               nbytes -= CHARS_PER_LITTLENUM;
3152               p += CHARS_PER_LITTLENUM;
3153             }
3154
3155           nums = generic_bignum + size / CHARS_PER_LITTLENUM;
3156           while (size > 0)
3157             {
3158               --nums;
3159               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3160               size -= CHARS_PER_LITTLENUM;
3161               p += CHARS_PER_LITTLENUM;
3162             }
3163         }
3164       else
3165         {
3166           nums = generic_bignum;
3167           while (size > 0)
3168             {
3169               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
3170               ++nums;
3171               size -= CHARS_PER_LITTLENUM;
3172               p += CHARS_PER_LITTLENUM;
3173               nbytes -= CHARS_PER_LITTLENUM;
3174             }
3175
3176           while (nbytes > 0)
3177             {
3178               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
3179               nbytes -= CHARS_PER_LITTLENUM;
3180               p += CHARS_PER_LITTLENUM;
3181             }
3182         }
3183     }
3184   else
3185     {
3186       memset (p, 0, nbytes);
3187
3188       /* Now we need to generate a fixS to record the symbol value.
3189          This is easy for BFD.  For other targets it can be more
3190          complex.  For very complex cases (currently, the HPPA and
3191          NS32K), you can define TC_CONS_FIX_NEW to do whatever you
3192          want.  For simpler cases, you can define TC_CONS_RELOC to be
3193          the name of the reloc code that should be stored in the fixS.
3194          If neither is defined, the code uses NO_RELOC if it is
3195          defined, and otherwise uses 0.  */
3196
3197 #ifdef BFD_ASSEMBLER
3198 #ifdef TC_CONS_FIX_NEW
3199       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3200 #else
3201       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3202                    /* @@ Should look at CPU word size.  */
3203                    nbytes == 2 ? BFD_RELOC_16
3204                       : nbytes == 8 ? BFD_RELOC_64
3205                       : BFD_RELOC_32);
3206 #endif
3207 #else
3208 #ifdef TC_CONS_FIX_NEW
3209       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
3210 #else
3211       /* Figure out which reloc number to use.  Use TC_CONS_RELOC if
3212          it is defined, otherwise use NO_RELOC if it is defined,
3213          otherwise use 0.  */
3214 #ifndef TC_CONS_RELOC
3215 #ifdef NO_RELOC
3216 #define TC_CONS_RELOC NO_RELOC
3217 #else
3218 #define TC_CONS_RELOC 0
3219 #endif
3220 #endif
3221       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
3222                    TC_CONS_RELOC);
3223 #endif /* TC_CONS_FIX_NEW */
3224 #endif /* BFD_ASSEMBLER */
3225     }
3226 }
3227 \f
3228 #ifdef BITFIELD_CONS_EXPRESSIONS
3229
3230 /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
3231    w:x,y:z, where w and y are bitwidths and x and y are values.  They
3232    then pack them all together. We do a little better in that we allow
3233    them in words, longs, etc. and we'll pack them in target byte order
3234    for you.
3235
3236    The rules are: pack least significat bit first, if a field doesn't
3237    entirely fit, put it in the next unit.  Overflowing the bitfield is
3238    explicitly *not* even a warning.  The bitwidth should be considered
3239    a "mask".
3240
3241    To use this function the tc-XXX.h file should define
3242    BITFIELD_CONS_EXPRESSIONS.  */
3243
3244 static void
3245 parse_bitfield_cons (exp, nbytes)
3246      expressionS *exp;
3247      unsigned int nbytes;
3248 {
3249   unsigned int bits_available = BITS_PER_CHAR * nbytes;
3250   char *hold = input_line_pointer;
3251
3252   (void) expression (exp);
3253
3254   if (*input_line_pointer == ':')
3255     {                   /* bitfields */
3256       long value = 0;
3257
3258       for (;;)
3259         {
3260           unsigned long width;
3261
3262           if (*input_line_pointer != ':')
3263             {
3264               input_line_pointer = hold;
3265               break;
3266             }                   /* next piece is not a bitfield */
3267
3268           /* In the general case, we can't allow
3269              full expressions with symbol
3270              differences and such.  The relocation
3271              entries for symbols not defined in this
3272              assembly would require arbitrary field
3273              widths, positions, and masks which most
3274              of our current object formats don't
3275              support.
3276
3277              In the specific case where a symbol
3278              *is* defined in this assembly, we
3279              *could* build fixups and track it, but
3280              this could lead to confusion for the
3281              backends.  I'm lazy. I'll take any
3282              SEG_ABSOLUTE. I think that means that
3283              you can use a previous .set or
3284              .equ type symbol.  xoxorich. */
3285
3286           if (exp->X_op == O_absent)
3287             {
3288               as_warn ("using a bit field width of zero");
3289               exp->X_add_number = 0;
3290               exp->X_op = O_constant;
3291             }                   /* implied zero width bitfield */
3292
3293           if (exp->X_op != O_constant)
3294             {
3295               *input_line_pointer = '\0';
3296               as_bad ("field width \"%s\" too complex for a bitfield", hold);
3297               *input_line_pointer = ':';
3298               demand_empty_rest_of_line ();
3299               return;
3300             }                   /* too complex */
3301
3302           if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
3303             {
3304               as_warn ("field width %lu too big to fit in %d bytes: truncated to %d bits",
3305                        width, nbytes, (BITS_PER_CHAR * nbytes));
3306               width = BITS_PER_CHAR * nbytes;
3307             }                   /* too big */
3308
3309           if (width > bits_available)
3310             {
3311               /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
3312               input_line_pointer = hold;
3313               exp->X_add_number = value;
3314               break;
3315             }                   /* won't fit */
3316
3317           hold = ++input_line_pointer; /* skip ':' */
3318
3319           (void) expression (exp);
3320           if (exp->X_op != O_constant)
3321             {
3322               char cache = *input_line_pointer;
3323
3324               *input_line_pointer = '\0';
3325               as_bad ("field value \"%s\" too complex for a bitfield", hold);
3326               *input_line_pointer = cache;
3327               demand_empty_rest_of_line ();
3328               return;
3329             }                   /* too complex */
3330
3331           value |= ((~(-1 << width) & exp->X_add_number)
3332                     << ((BITS_PER_CHAR * nbytes) - bits_available));
3333
3334           if ((bits_available -= width) == 0
3335               || is_it_end_of_statement ()
3336               || *input_line_pointer != ',')
3337             {
3338               break;
3339             }                   /* all the bitfields we're gonna get */
3340
3341           hold = ++input_line_pointer;
3342           (void) expression (exp);
3343         }                       /* forever loop */
3344
3345       exp->X_add_number = value;
3346       exp->X_op = O_constant;
3347       exp->X_unsigned = 1;
3348     }                           /* if looks like a bitfield */
3349 }                               /* parse_bitfield_cons() */
3350
3351 #endif /* BITFIELD_CONS_EXPRESSIONS */
3352 \f
3353 /* Handle an MRI style string expression.  */
3354
3355 static void
3356 parse_mri_cons (exp, nbytes)
3357      expressionS *exp;
3358      unsigned int nbytes;
3359 {
3360   if (*input_line_pointer != '\''
3361       && (input_line_pointer[1] != '\''
3362           || (*input_line_pointer != 'A'
3363               && *input_line_pointer != 'E')))
3364     TC_PARSE_CONS_EXPRESSION (exp, nbytes);
3365   else
3366     {
3367       int scan = 0;
3368       unsigned int result = 0;
3369
3370       /* An MRI style string.  Cut into as many bytes as will fit into
3371          a nbyte chunk, left justify if necessary, and separate with
3372          commas so we can try again later.  */
3373       if (*input_line_pointer == 'A')
3374         ++input_line_pointer;
3375       else if (*input_line_pointer == 'E')
3376         {
3377           as_bad ("EBCDIC constants are not supported");
3378           ++input_line_pointer;
3379         }
3380
3381       input_line_pointer++;
3382       for (scan = 0; scan < nbytes; scan++)
3383         {
3384           if (*input_line_pointer == '\'')
3385             {
3386               if (input_line_pointer[1] == '\'')
3387                 {
3388                   input_line_pointer++;
3389                 }
3390               else
3391                 break;
3392             }
3393           result = (result << 8) | (*input_line_pointer++);
3394         }
3395
3396       /* Left justify */
3397       while (scan < nbytes)
3398         {
3399           result <<= 8;
3400           scan++;
3401         }
3402       /* Create correct expression */
3403       exp->X_op = O_constant;
3404       exp->X_add_number = result;
3405       /* Fake it so that we can read the next char too */
3406       if (input_line_pointer[0] != '\'' ||
3407           (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
3408         {
3409           input_line_pointer -= 2;
3410           input_line_pointer[0] = ',';
3411           input_line_pointer[1] = '\'';
3412         }
3413       else
3414         input_line_pointer++;
3415     }
3416 }
3417 \f
3418 #ifdef REPEAT_CONS_EXPRESSIONS
3419
3420 /* Parse a repeat expression for cons.  This is used by the MIPS
3421    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
3422    object file COUNT times.
3423
3424    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
3425
3426 static void
3427 parse_repeat_cons (exp, nbytes)
3428      expressionS *exp;
3429      unsigned int nbytes;
3430 {
3431   expressionS count;
3432   register int i;
3433
3434   expression (exp);
3435
3436   if (*input_line_pointer != ':')
3437     {
3438       /* No repeat count.  */
3439       return;
3440     }
3441
3442   ++input_line_pointer;
3443   expression (&count);
3444   if (count.X_op != O_constant
3445       || count.X_add_number <= 0)
3446     {
3447       as_warn ("Unresolvable or nonpositive repeat count; using 1");
3448       return;
3449     }
3450
3451   /* The cons function is going to output this expression once.  So we
3452      output it count - 1 times.  */
3453   for (i = count.X_add_number - 1; i > 0; i--)
3454     emit_expr (exp, nbytes);
3455 }
3456
3457 #endif /* REPEAT_CONS_EXPRESSIONS */
3458 \f
3459 /* Parse a floating point number represented as a hex constant.  This
3460    permits users to specify the exact bits they want in the floating
3461    point number.  */
3462
3463 static int
3464 hex_float (float_type, bytes)
3465      int float_type;
3466      char *bytes;
3467 {
3468   int length;
3469   int i;
3470
3471   switch (float_type)
3472     {
3473     case 'f':
3474     case 'F':
3475     case 's':
3476     case 'S':
3477       length = 4;
3478       break;
3479
3480     case 'd':
3481     case 'D':
3482     case 'r':
3483     case 'R':
3484       length = 8;
3485       break;
3486
3487     case 'x':
3488     case 'X':
3489       length = 12;
3490       break;
3491
3492     case 'p':
3493     case 'P':
3494       length = 12;
3495       break;
3496
3497     default:
3498       as_bad ("Unknown floating type type '%c'", float_type);
3499       return -1;
3500     }
3501
3502   /* It would be nice if we could go through expression to parse the
3503      hex constant, but if we get a bignum it's a pain to sort it into
3504      the buffer correctly.  */
3505   i = 0;
3506   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
3507     {
3508       int d;
3509
3510       /* The MRI assembler accepts arbitrary underscores strewn about
3511          through the hex constant, so we ignore them as well. */
3512       if (*input_line_pointer == '_')
3513         {
3514           ++input_line_pointer;
3515           continue;
3516         }
3517
3518       if (i >= length)
3519         {
3520           as_warn ("Floating point constant too large");
3521           return -1;
3522         }
3523       d = hex_value (*input_line_pointer) << 4;
3524       ++input_line_pointer;
3525       while (*input_line_pointer == '_')
3526         ++input_line_pointer;
3527       if (hex_p (*input_line_pointer))
3528         {
3529           d += hex_value (*input_line_pointer);
3530           ++input_line_pointer;
3531         }
3532       if (target_big_endian)
3533         bytes[i] = d;
3534       else
3535         bytes[length - i - 1] = d;
3536       ++i;
3537     }
3538
3539   if (i < length)
3540     {
3541       if (target_big_endian)
3542         memset (bytes + i, 0, length - i);
3543       else
3544         memset (bytes, 0, length - i);
3545     }
3546
3547   return length;
3548 }
3549
3550 /*
3551  *                      float_cons()
3552  *
3553  * CONStruct some more frag chars of .floats .ffloats etc.
3554  * Makes 0 or more new frags.
3555  * If need_pass_2 == 1, no frags are emitted.
3556  * This understands only floating literals, not expressions. Sorry.
3557  *
3558  * A floating constant is defined by atof_generic(), except it is preceded
3559  * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
3560  * reading, I decided to be incompatible. This always tries to give you
3561  * rounded bits to the precision of the pseudo-op. Former AS did premature
3562  * truncatation, restored noisy bits instead of trailing 0s AND gave you
3563  * a choice of 2 flavours of noise according to which of 2 floating-point
3564  * scanners you directed AS to use.
3565  *
3566  * In:  input_line_pointer->whitespace before, or '0' of flonum.
3567  *
3568  */
3569
3570 void
3571 float_cons (float_type)
3572      /* Clobbers input_line-pointer, checks end-of-line. */
3573      register int float_type;   /* 'f':.ffloat ... 'F':.float ... */
3574 {
3575   register char *p;
3576   int length;                   /* Number of chars in an object. */
3577   register char *err;           /* Error from scanning floating literal. */
3578   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
3579
3580   if (is_it_end_of_statement ())
3581     {
3582       demand_empty_rest_of_line ();
3583       return;
3584     }
3585
3586   do
3587     {
3588       /* input_line_pointer->1st char of a flonum (we hope!). */
3589       SKIP_WHITESPACE ();
3590
3591       /* Skip any 0{letter} that may be present. Don't even check if the
3592        * letter is legal. Someone may invent a "z" format and this routine
3593        * has no use for such information. Lusers beware: you get
3594        * diagnostics if your input is ill-conditioned.
3595        */
3596       if (input_line_pointer[0] == '0' && isalpha (input_line_pointer[1]))
3597         input_line_pointer += 2;
3598
3599       /* Accept :xxxx, where the x's are hex digits, for a floating
3600          point with the exact digits specified.  */
3601       if (input_line_pointer[0] == ':')
3602         {
3603           ++input_line_pointer;
3604           length = hex_float (float_type, temp);
3605           if (length < 0)
3606             {
3607               ignore_rest_of_line ();
3608               return;
3609             }
3610         }
3611       else
3612         {
3613           err = md_atof (float_type, temp, &length);
3614           know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
3615           know (length > 0);
3616           if (err)
3617             {
3618               as_bad ("Bad floating literal: %s", err);
3619               ignore_rest_of_line ();
3620               return;
3621             }
3622         }
3623
3624       if (!need_pass_2)
3625         {
3626           int count;
3627
3628           count = 1;
3629
3630 #ifdef REPEAT_CONS_EXPRESSIONS
3631           if (*input_line_pointer == ':')
3632             {
3633               expressionS count_exp;
3634
3635               ++input_line_pointer;
3636               expression (&count_exp);
3637               if (count_exp.X_op != O_constant
3638                   || count_exp.X_add_number <= 0)
3639                 {
3640                   as_warn ("unresolvable or nonpositive repeat count; using 1");
3641                 }
3642               else
3643                 count = count_exp.X_add_number;
3644             }
3645 #endif
3646
3647           while (--count >= 0)
3648             {
3649               p = frag_more (length);
3650               memcpy (p, temp, (unsigned int) length);
3651             }
3652         }
3653       SKIP_WHITESPACE ();
3654     }
3655   while (*input_line_pointer++ == ',');
3656
3657   --input_line_pointer;         /* Put terminator back into stream.  */
3658   demand_empty_rest_of_line ();
3659 }                               /* float_cons() */
3660 \f
3661 /*
3662  *                      stringer()
3663  *
3664  * We read 0 or more ',' seperated, double-quoted strings.
3665  *
3666  * Caller should have checked need_pass_2 is FALSE because we don't check it.
3667  */
3668
3669
3670 void
3671 stringer (append_zero)          /* Worker to do .ascii etc statements. */
3672      /* Checks end-of-line. */
3673      register int append_zero;  /* 0: don't append '\0', else 1 */
3674 {
3675   register unsigned int c;
3676
3677 #ifdef md_flush_pending_output
3678   md_flush_pending_output ();
3679 #endif
3680
3681   /*
3682    * The following awkward logic is to parse ZERO or more strings,
3683    * comma seperated. Recall a string expression includes spaces
3684    * before the opening '\"' and spaces after the closing '\"'.
3685    * We fake a leading ',' if there is (supposed to be)
3686    * a 1st, expression. We keep demanding expressions for each
3687    * ','.
3688    */
3689   if (is_it_end_of_statement ())
3690     {
3691       c = 0;                    /* Skip loop. */
3692       ++input_line_pointer;     /* Compensate for end of loop. */
3693     }
3694   else
3695     {
3696       c = ',';                  /* Do loop. */
3697     }
3698   while (c == ',' || c == '<' || c == '"')
3699     {
3700       SKIP_WHITESPACE ();
3701       switch (*input_line_pointer)
3702         {
3703         case '\"':
3704           ++input_line_pointer; /*->1st char of string. */
3705           while (is_a_char (c = next_char_of_string ()))
3706             {
3707               FRAG_APPEND_1_CHAR (c);
3708             }
3709           if (append_zero)
3710             {
3711               FRAG_APPEND_1_CHAR (0);
3712             }
3713           know (input_line_pointer[-1] == '\"');
3714           break;
3715         case '<':
3716           input_line_pointer++;
3717           c = get_single_number ();
3718           FRAG_APPEND_1_CHAR (c);
3719           if (*input_line_pointer != '>')
3720             {
3721               as_bad ("Expected <nn>");
3722             }
3723           input_line_pointer++;
3724           break;
3725         case ',':
3726           input_line_pointer++;
3727           break;
3728         }
3729       SKIP_WHITESPACE ();
3730       c = *input_line_pointer;
3731     }
3732
3733   demand_empty_rest_of_line ();
3734 }                               /* stringer() */
3735 \f
3736 /* FIXME-SOMEDAY: I had trouble here on characters with the
3737     high bits set.  We'll probably also have trouble with
3738     multibyte chars, wide chars, etc.  Also be careful about
3739     returning values bigger than 1 byte.  xoxorich. */
3740
3741 unsigned int
3742 next_char_of_string ()
3743 {
3744   register unsigned int c;
3745
3746   c = *input_line_pointer++ & CHAR_MASK;
3747   switch (c)
3748     {
3749     case '\"':
3750       c = NOT_A_CHAR;
3751       break;
3752
3753 #ifndef NO_STRING_ESCAPES
3754     case '\\':
3755       switch (c = *input_line_pointer++)
3756         {
3757         case 'b':
3758           c = '\b';
3759           break;
3760
3761         case 'f':
3762           c = '\f';
3763           break;
3764
3765         case 'n':
3766           c = '\n';
3767           break;
3768
3769         case 'r':
3770           c = '\r';
3771           break;
3772
3773         case 't':
3774           c = '\t';
3775           break;
3776
3777         case 'v':
3778           c = '\013';
3779           break;
3780
3781         case '\\':
3782         case '"':
3783           break;                /* As itself. */
3784
3785         case '0':
3786         case '1':
3787         case '2':
3788         case '3':
3789         case '4':
3790         case '5':
3791         case '6':
3792         case '7':
3793         case '8':
3794         case '9':
3795           {
3796             long number;
3797             int i;
3798
3799             for (i = 0, number = 0; isdigit (c) && i < 3; c = *input_line_pointer++, i++)
3800               {
3801                 number = number * 8 + c - '0';
3802               }
3803             c = number & 0xff;
3804           }
3805           --input_line_pointer;
3806           break;
3807
3808         case 'x':
3809         case 'X':
3810           {
3811             long number;
3812
3813             number = 0;
3814             c = *input_line_pointer++;
3815             while (isxdigit (c))
3816               {
3817                 if (isdigit (c))
3818                   number = number * 16 + c - '0';
3819                 else if (isupper (c))
3820                   number = number * 16 + c - 'A' + 10;
3821                 else
3822                   number = number * 16 + c - 'a' + 10;
3823                 c = *input_line_pointer++;
3824               }
3825             c = number & 0xff;
3826             --input_line_pointer;
3827           }
3828           break;
3829
3830         case '\n':
3831           /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
3832           as_warn ("Unterminated string: Newline inserted.");
3833           c = '\n';
3834           break;
3835
3836         default:
3837
3838 #ifdef ONLY_STANDARD_ESCAPES
3839           as_bad ("Bad escaped character in string, '?' assumed");
3840           c = '?';
3841 #endif /* ONLY_STANDARD_ESCAPES */
3842
3843           break;
3844         }                       /* switch on escaped char */
3845       break;
3846 #endif /* ! defined (NO_STRING_ESCAPES) */
3847
3848     default:
3849       break;
3850     }                           /* switch on char */
3851   return (c);
3852 }                               /* next_char_of_string() */
3853 \f
3854 static segT
3855 get_segmented_expression (expP)
3856      register expressionS *expP;
3857 {
3858   register segT retval;
3859
3860   retval = expression (expP);
3861   if (expP->X_op == O_illegal
3862       || expP->X_op == O_absent
3863       || expP->X_op == O_big)
3864     {
3865       as_bad ("expected address expression; zero assumed");
3866       expP->X_op = O_constant;
3867       expP->X_add_number = 0;
3868       retval = absolute_section;
3869     }
3870   return retval;
3871 }
3872
3873 static segT
3874 get_known_segmented_expression (expP)
3875      register expressionS *expP;
3876 {
3877   register segT retval;
3878
3879   if ((retval = get_segmented_expression (expP)) == undefined_section)
3880     {
3881       /* There is no easy way to extract the undefined symbol from the
3882          expression.  */
3883       if (expP->X_add_symbol != NULL
3884           && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
3885         as_warn ("symbol \"%s\" undefined; zero assumed",
3886                  S_GET_NAME (expP->X_add_symbol));
3887       else
3888         as_warn ("some symbol undefined; zero assumed");
3889       retval = absolute_section;
3890       expP->X_op = O_constant;
3891       expP->X_add_number = 0;
3892     }
3893   know (retval == absolute_section || SEG_NORMAL (retval));
3894   return (retval);
3895 }                               /* get_known_segmented_expression() */
3896
3897 offsetT
3898 get_absolute_expression ()
3899 {
3900   expressionS exp;
3901
3902   expression (&exp);
3903   if (exp.X_op != O_constant)
3904     {
3905       if (exp.X_op != O_absent)
3906         as_bad ("bad or irreducible absolute expression; zero assumed");
3907       exp.X_add_number = 0;
3908     }
3909   return exp.X_add_number;
3910 }
3911
3912 char                            /* return terminator */
3913 get_absolute_expression_and_terminator (val_pointer)
3914      long *val_pointer;         /* return value of expression */
3915 {
3916   /* FIXME: val_pointer should probably be offsetT *.  */
3917   *val_pointer = (long) get_absolute_expression ();
3918   return (*input_line_pointer++);
3919 }
3920 \f
3921 /*
3922  *                      demand_copy_C_string()
3923  *
3924  * Like demand_copy_string, but return NULL if the string contains any '\0's.
3925  * Give a warning if that happens.
3926  */
3927 char *
3928 demand_copy_C_string (len_pointer)
3929      int *len_pointer;
3930 {
3931   register char *s;
3932
3933   if ((s = demand_copy_string (len_pointer)) != 0)
3934     {
3935       register int len;
3936
3937       for (len = *len_pointer; len > 0; len--)
3938         {
3939           if (*s == 0)
3940             {
3941               s = 0;
3942               len = 1;
3943               *len_pointer = 0;
3944               as_bad ("This string may not contain \'\\0\'");
3945             }
3946         }
3947     }
3948   return s;
3949 }
3950 \f
3951 /*
3952  *                      demand_copy_string()
3953  *
3954  * Demand string, but return a safe (=private) copy of the string.
3955  * Return NULL if we can't read a string here.
3956  */
3957 char *
3958 demand_copy_string (lenP)
3959      int *lenP;
3960 {
3961   register unsigned int c;
3962   register int len;
3963   char *retval;
3964
3965   len = 0;
3966   SKIP_WHITESPACE ();
3967   if (*input_line_pointer == '\"')
3968     {
3969       input_line_pointer++;     /* Skip opening quote. */
3970
3971       while (is_a_char (c = next_char_of_string ()))
3972         {
3973           obstack_1grow (&notes, c);
3974           len++;
3975         }
3976       /* JF this next line is so demand_copy_C_string will return a
3977          null terminated string. */
3978       obstack_1grow (&notes, '\0');
3979       retval = obstack_finish (&notes);
3980     }
3981   else
3982     {
3983       as_warn ("Missing string");
3984       retval = NULL;
3985       ignore_rest_of_line ();
3986     }
3987   *lenP = len;
3988   return (retval);
3989 }                               /* demand_copy_string() */
3990 \f
3991 /*
3992  *              is_it_end_of_statement()
3993  *
3994  * In:  Input_line_pointer->next character.
3995  *
3996  * Do:  Skip input_line_pointer over all whitespace.
3997  *
3998  * Out: 1 if input_line_pointer->end-of-line.
3999 */
4000 int
4001 is_it_end_of_statement ()
4002 {
4003   SKIP_WHITESPACE ();
4004   return (is_end_of_line[(unsigned char) *input_line_pointer]);
4005 }                               /* is_it_end_of_statement() */
4006
4007 void
4008 equals (sym_name)
4009      char *sym_name;
4010 {
4011   register symbolS *symbolP;    /* symbol we are working with */
4012   char *stop;
4013   char stopc;
4014
4015   input_line_pointer++;
4016   if (*input_line_pointer == '=')
4017     input_line_pointer++;
4018
4019   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
4020     input_line_pointer++;
4021
4022   if (flag_mri)
4023     stop = mri_comment_field (&stopc);
4024
4025   if (sym_name[0] == '.' && sym_name[1] == '\0')
4026     {
4027       /* Turn '. = mumble' into a .org mumble */
4028       register segT segment;
4029       expressionS exp;
4030
4031       segment = get_known_segmented_expression (&exp);
4032       if (!need_pass_2)
4033         do_org (segment, &exp, 0);
4034     }
4035   else
4036     {
4037       symbolP = symbol_find_or_make (sym_name);
4038       pseudo_set (symbolP);
4039     }
4040
4041   if (flag_mri)
4042     mri_comment_end (stop, stopc);
4043 }                               /* equals() */
4044
4045 /* .include -- include a file at this point. */
4046
4047 /* ARGSUSED */
4048 void
4049 s_include (arg)
4050      int arg;
4051 {
4052   char *newbuf;
4053   char *filename;
4054   int i;
4055   FILE *try;
4056   char *path;
4057
4058   if (! flag_m68k_mri)
4059     filename = demand_copy_string (&i);
4060   else
4061     {
4062       SKIP_WHITESPACE ();
4063       i = 0;
4064       while (! is_end_of_line[(unsigned char) *input_line_pointer]
4065              && *input_line_pointer != ' '
4066              && *input_line_pointer != '\t')
4067         {
4068           obstack_1grow (&notes, *input_line_pointer);
4069           ++input_line_pointer;
4070           ++i;
4071         }
4072       obstack_1grow (&notes, '\0');
4073       filename = obstack_finish (&notes);
4074       while (! is_end_of_line[(unsigned char) *input_line_pointer])
4075         ++input_line_pointer;
4076     }
4077   demand_empty_rest_of_line ();
4078   path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
4079   for (i = 0; i < include_dir_count; i++)
4080     {
4081       strcpy (path, include_dirs[i]);
4082       strcat (path, "/");
4083       strcat (path, filename);
4084       if (0 != (try = fopen (path, "r")))
4085         {
4086           fclose (try);
4087           goto gotit;
4088         }
4089     }
4090   free (path);
4091   path = filename;
4092 gotit:
4093   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY. */
4094   newbuf = input_scrub_include_file (path, input_line_pointer);
4095   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
4096 }                               /* s_include() */
4097
4098 void
4099 add_include_dir (path)
4100      char *path;
4101 {
4102   int i;
4103
4104   if (include_dir_count == 0)
4105     {
4106       include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
4107       include_dirs[0] = ".";    /* Current dir */
4108       include_dir_count = 2;
4109     }
4110   else
4111     {
4112       include_dir_count++;
4113       include_dirs = (char **) realloc (include_dirs,
4114                                 include_dir_count * sizeof (*include_dirs));
4115     }
4116
4117   include_dirs[include_dir_count - 1] = path;   /* New one */
4118
4119   i = strlen (path);
4120   if (i > include_dir_maxlen)
4121     include_dir_maxlen = i;
4122 }                               /* add_include_dir() */
4123
4124 void
4125 s_ignore (arg)
4126      int arg;
4127 {
4128   while (!is_end_of_line[(unsigned char) *input_line_pointer])
4129     {
4130       ++input_line_pointer;
4131     }
4132   ++input_line_pointer;
4133 }
4134
4135
4136 void
4137 read_print_statistics (file)
4138      FILE *file;
4139 {
4140   hash_print_statistics (file, "pseudo-op table", po_hash);
4141 }
4142
4143 /* end of read.c */