gas/read.c

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