home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Atari / Gnu / gassrc04.zoo / read.c < prev    next >
C/C++ Source or Header  |  1993-03-02  |  56KB  |  2,098 lines
  1. /* read.c - read a source file -
  2.    Copyright (C) 1986,1987 Free Software Foundation, Inc.
  3.  
  4. This file is part of GAS, the GNU Assembler.
  5.  
  6. GAS is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GAS is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GAS; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #define MASK_CHAR (0xFF)    /* If your chars aren't 8 bits, you will
  21.                    change this a bit.  But then, GNU isn't
  22.                    spozed to run on your machine anyway.
  23.                    (RMS is so shortsighted sometimes.)
  24.                  */
  25.  
  26. #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
  27.                 /* This is the largest known floating point */
  28.                 /* format (for now). It will grow when we */
  29.                 /* do 4361 style flonums. */
  30.  
  31.  
  32. /* Routines that read assembler source text to build spagetti in memory. */
  33. /* Another group of these functions is in the as-expr.c module */
  34.  
  35. #include <ctype.h>
  36. #include <sys/types.h>
  37. #include <sys/stat.h>
  38. #include "as.h"
  39. #include "read.h"
  40. #include "md.h"
  41. #include "hash.h"
  42. #include "obstack.h"
  43. #include "frags.h"
  44. #include "flonum.h"
  45. #include "struc-symbol.h"
  46. #include "expr.h"
  47. #include "symbols.h"
  48.  
  49. #ifdef SPARC
  50. #include "sparc.h"
  51. #define OTHER_ALIGN
  52. #endif
  53. #ifdef I860
  54. #include "i860.h"
  55. #endif
  56.  
  57. char *    input_line_pointer;    /* -> next char of source file to parse. */
  58.  
  59.  
  60. #if BITS_PER_CHAR != 8
  61. The following table is indexed by [ (char) ] and will break if
  62. a char does not have exactly 256 states (hopefully 0:255!) !
  63. #endif
  64.  
  65. const char                /* used by is_... macros. our ctype[] */
  66. lex_type [256] = {
  67.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* @ABCDEFGHIJKLMNO */
  68.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* PQRSTUVWXYZ[\]^_ */
  69.   0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,       /* _!"#$%&'()*+,-./ */
  70.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,       /* 0123456789:;<=>? */
  71.   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* @ABCDEFGHIJKLMNO */
  72.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3,       /* PQRSTUVWXYZ[\]^_ */
  73.   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* `abcdefghijklmno */
  74.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0,       /* pqrstuvwxyz{|}~. */
  75.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  76.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  77.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  78.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  79.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  80.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  81.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
  82. };
  83.  
  84.  
  85. /*
  86.  * In: a character.
  87.  * Out: TRUE if this character ends a line.
  88.  */
  89. #define _ (0)
  90. const char is_end_of_line [256] = {
  91.  _, _, _, _, _, _, _, _, _, _,99, _, _, _, _, _, /* @abcdefghijklmno */
  92.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  93.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  94.  _, _, _, _, _, _, _, _, _, _, _,99, _, _, _, _, /* 0123456789:;<=>? */
  95.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  96.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  97.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  98.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  99.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  100.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  101.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  102.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  103.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _  /*                  */
  104. };
  105. #undef _
  106.  
  107.                 /* Functions private to this file. */
  108. void            equals();
  109. void            big_cons();
  110. void            cons();
  111. static char*        demand_copy_C_string();
  112. static char*        demand_copy_string();
  113. void            demand_empty_rest_of_line();
  114. void            float_cons();
  115. long int        get_absolute_expression();
  116. static char        get_absolute_expression_and_terminator();
  117. static segT        get_known_segmented_expression();
  118. void            ignore_rest_of_line();
  119. static int        is_it_end_of_statement();
  120. static void        pobegin();
  121. static void        pseudo_set();
  122. static void        stab();
  123. static void        stringer();
  124.  
  125. extern char line_comment_chars[];
  126.  
  127. static char *    buffer_limit;    /* -> 1 + last char in buffer. */
  128.  
  129. static char *    bignum_low;    /* Lowest char of bignum. */
  130. static char *    bignum_limit;    /* 1st illegal address of bignum. */
  131. static char *    bignum_high;    /* Highest char of bignum. */
  132.                 /* May point to (bignum_start-1). */
  133.                 /* Never >= bignum_limit. */
  134. static char *old_buffer = 0;    /* JF a hack */
  135. static char *old_input;
  136. static char *old_limit;
  137.  
  138. #ifndef WORKING_DOT_WORD
  139. struct broken_word *broken_words;
  140. int new_broken_words = 0;
  141. #endif
  142.  
  143. static void grow_bignum ();
  144. static int next_char_of_string ();
  145.  
  146. void
  147. read_begin()
  148. {
  149.   pobegin();
  150.   obstack_begin( ¬es, 5000 );
  151. #define BIGNUM_BEGIN_SIZE (16)
  152.   bignum_low = xmalloc((long)BIGNUM_BEGIN_SIZE);
  153.   bignum_limit = bignum_low + BIGNUM_BEGIN_SIZE;
  154. }
  155.  
  156. /* set up pseudo-op tables */
  157.  
  158. static struct hash_control *
  159. po_hash = NULL;            /* use before set up: NULL-> address error */
  160.  
  161.  
  162. void    s_abort(),    s_align(),    s_comm(),    s_data();
  163. void    s_desc(),    s_even(),    s_file(),    s_fill();
  164. void    s_globl(),    s_lcomm(),    s_line(),    s_lsym();
  165. void    s_org(),    s_set(),    s_space(),    s_text();
  166. #ifdef VMS
  167. char const_flag = 0;
  168. void s_const();
  169. #endif
  170.  
  171. #ifdef DONTDEF
  172. void    s_gdbline(),    s_gdblinetab();
  173. void    s_gdbbeg(),    s_gdbblock(),    s_gdbend(),    s_gdbsym();
  174. #endif
  175.  
  176. void    stringer();
  177. void    cons();
  178. void    float_cons();
  179. void    big_cons();
  180. void    stab();
  181.  
  182. static const pseudo_typeS
  183. potable[] =
  184. {
  185.   { "abort",    s_abort,    0    },
  186.   { "align",    s_align,    0    },
  187.   { "ascii",    stringer,    0    },
  188.   { "asciz",    stringer,    1    },
  189.   { "byte",    cons,        1    },
  190.   { "comm",    s_comm,        0    },
  191. #ifdef VMS
  192.   { "const",    s_const,    0    },
  193. #endif
  194.   { "data",    s_data,        0    },
  195.   { "desc",    s_desc,        0    },
  196.   { "double",    float_cons,    'd'    },
  197.   { "file",    s_file,        0    },
  198.   { "fill",    s_fill,        0    },
  199.   { "float",    float_cons,    'f'    },
  200. #ifdef DONTDEF
  201.   { "gdbbeg",    s_gdbbeg,    0    },
  202.   { "gdbblock",    s_gdbblock,    0    },
  203.   { "gdbend",    s_gdbend,    0    },
  204.   { "gdbsym",    s_gdbsym,    0    },
  205.   { "gdbline",    s_gdbline,    0    },
  206.   { "gdblinetab",s_gdblinetab,    0    },
  207. #endif
  208.   { "globl",    s_globl,    0    },
  209.   { "int",    cons,        4    },
  210.   { "lcomm",    s_lcomm,    0    },
  211.   { "line",    s_line,        0    },
  212.   { "long",    cons,        4    },
  213.   { "lsym",    s_lsym,        0    },
  214.   { "octa",    big_cons,    16    },
  215.   { "org",    s_org,        0    },
  216.   { "quad",    big_cons,    8    },
  217.   { "set",    s_set,        0    },
  218.   { "short",    cons,        2    },
  219.   { "single",    float_cons,    'f'    },
  220.   { "space",    s_space,    0    },
  221.   { "stabd",    stab,        'd'    },
  222.   { "stabn",    stab,        'n'    },
  223.   { "stabs",    stab,        's'    },
  224.   { "text",    s_text,        0    },
  225. #ifndef SPARC
  226.   { "word",    cons,        2    },
  227. #endif
  228.   { NULL}    /* end sentinel */
  229. };
  230.  
  231. static void
  232. pobegin()
  233. {
  234.   char *    errtxt;        /* error text */
  235.   const pseudo_typeS * pop;
  236.  
  237.   po_hash = hash_new();
  238.   errtxt = "";            /* OK so far */
  239.   for (pop=potable; pop->poc_name && !*errtxt; pop++)
  240.     {
  241.       errtxt = hash_insert (po_hash, pop->poc_name, (char *)pop);
  242.     }
  243.  
  244.   for(pop=md_pseudo_table; pop->poc_name && !*errtxt; pop++)
  245.       errtxt = hash_insert (po_hash, pop->poc_name, (char *)pop);
  246.  
  247.   if (*errtxt)
  248.     {
  249.       as_fatal ("error constructing pseudo-op table");
  250.     }
  251. }                /* pobegin() */
  252.  
  253. /*            read_a_source_file()
  254.  *
  255.  * File has already been opened, and will be closed by our caller.
  256.  *
  257.  * We read the file, putting things into a web that
  258.  * represents what we have been reading.
  259.  */
  260. void
  261. read_a_source_file (buffer)
  262.      char *    buffer;        /* 1st character of each buffer of lines is here. */
  263. {
  264.   register char        c;
  265.   register char *    s;    /* string of symbol, '\0' appended */
  266.   register int        temp;
  267.   /* register struct frag * fragP; JF unused */    /* a frag we just made */
  268.   pseudo_typeS    *pop;
  269. #ifdef DONTDEF
  270.   void gdb_block_beg();
  271.   void gdb_block_position();
  272.   void gdb_block_end();
  273.   void gdb_symbols_fixup();
  274. #endif
  275.  
  276.   subseg_new (SEG_TEXT, 0);
  277.   while ( buffer_limit = input_scrub_next_buffer (&buffer) )
  278.     {                /* We have another line to parse. */
  279.       know( buffer_limit [-1] == '\n' ); /* Must have a sentinel. */
  280.       input_line_pointer = buffer;
  281.  contin:    /* JF this goto is my fault I admit it.  Someone brave please re-write
  282.            the whole input section here?  Pleeze??? */
  283.       while ( input_line_pointer < buffer_limit )
  284.     {            /* We have more of this buffer to parse. */
  285.       /*
  286.        * We now have input_line_pointer -> 1st char of next line.
  287.        * If input_line_pointer [-1] == '\n' then we just
  288.        * scanned another line: so bump line counters.
  289.        */
  290.       if (input_line_pointer [-1] == '\n')
  291.         {
  292.           bump_line_counters ();
  293.         }
  294.       /*
  295.        * We are at the begining of a line, or similar place.
  296.        * We expect a well-formed assembler statement.
  297.        * A "symbol-name:" is a statement.
  298.        *
  299.        * Depending on what compiler is used, the order of these tests
  300.        * may vary to catch most common case 1st.
  301.        * Each test is independent of all other tests at the (top) level.
  302.        * PLEASE make a compiler that doesn't use this assembler.
  303.        * It is crufty to waste a compiler's time encoding things for this
  304.        * assembler, which then wastes more time decoding it.
  305.        * (And communicating via (linear) files is silly!
  306.        * If you must pass stuff, please pass a tree!)
  307.        */
  308.       if ( (c= * input_line_pointer ++) == '\t' || c == ' ' || c=='\f')
  309.         {
  310.           c = * input_line_pointer ++;
  311.         }
  312.       know( c != ' ' );    /* No further leading whitespace. */
  313.       /*
  314.        * C is the 1st significant character.
  315.        * Input_line_pointer points after that character.
  316.        */
  317.       if ( is_name_beginner(c) )
  318.         {            /* want user-defined label or pseudo/opcode */
  319.           s = -- input_line_pointer;
  320.           c = get_symbol_end(); /* name's delimiter */
  321.           /*
  322.            * C is character after symbol.
  323.            * That character's place in the input line is now '\0'.
  324.            * S points to the beginning of the symbol.
  325.            *   [In case of pseudo-op, s -> '.'.]
  326.            * Input_line_pointer -> '\0' where c was.
  327.            */
  328.           if ( c == ':' )
  329.         {
  330.           colon(s);    /* user-defined label */
  331.           * input_line_pointer ++ = ':'; /* Put ':' back for error messages' sake. */
  332.                 /* Input_line_pointer -> after ':'. */
  333.           SKIP_WHITESPACE();
  334.         }
  335.           else if(c=='=' || input_line_pointer[1]=='=')        /* JF deal with FOO=BAR */
  336.             {
  337.           equals(s);
  338.           demand_empty_rest_of_line();
  339.         }
  340.           else
  341.         {        /* expect pseudo-op or machine instruction */
  342.           if ( *s=='.' )
  343.             {
  344.               /*
  345.                * PSEUDO - OP.
  346.                *
  347.                * WARNING: c has next char, which may be end-of-line.
  348.                * We lookup the pseudo-op table with s+1 because we
  349.                * already know that the pseudo-op begins with a '.'.
  350.                */
  351.  
  352.               pop= (pseudo_typeS *) hash_find (po_hash, s+1);
  353.  
  354.               /* Print the error msg now, while we still can */
  355.               if(!pop)
  356.               as_bad("Unknown pseudo-op:  '%s'",s);
  357.  
  358.                 /* Put it back for error messages etc. */
  359.               * input_line_pointer = c;
  360.                 /* The following skip of whitespace is compulsory. */
  361.                 /* A well shaped space is sometimes all that seperates keyword from operands. */
  362.               if ( c == ' ' || c == '\t' )
  363.             {    /* Skip seperator after keyword. */
  364.               input_line_pointer ++;
  365.             }
  366.               /*
  367.                * Input_line is restored.
  368.                * Input_line_pointer -> 1st non-blank char
  369.                * after pseudo-operation.
  370.                */
  371.                 if(!pop) {
  372.               ignore_rest_of_line();
  373.               break;
  374.             }
  375.             else
  376.               (*pop->poc_handler)(pop->poc_val);
  377.             }
  378.           else
  379.             {        /* machine instruction */
  380.               /* WARNING: c has char, which may be end-of-line. */
  381.               /* Also: input_line_pointer -> `\0` where c was. */
  382.               * input_line_pointer = c;
  383.               while ( ! is_end_of_line [* input_line_pointer] )
  384.             {
  385.               input_line_pointer ++;
  386.             }
  387.               c = * input_line_pointer;
  388.               * input_line_pointer = '\0';
  389.               md_assemble (s);    /* Assemble 1 instruction. */
  390.               * input_line_pointer ++ = c;
  391.               /* We resume loop AFTER the end-of-line from this instruction */
  392.             }        /* if (*s=='.') */
  393.         }        /* if c==':' */
  394.           continue;
  395.         }            /* if (is_name_beginner(c) */
  396.  
  397.  
  398.       if ( is_end_of_line [c] )
  399.         {            /* empty statement */
  400.           continue;
  401.         }
  402.  
  403.       if ( isdigit(c) )
  404.         {            /* local label  ("4:") */
  405.           temp = c - '0';
  406. #ifdef SUN_ASM_SYNTAX
  407.           if( *input_line_pointer=='$')
  408.         input_line_pointer++;
  409. #endif
  410.           if ( * input_line_pointer ++ == ':' )
  411.         {
  412.           local_colon (temp);
  413.         }
  414.           else
  415.         {
  416.           as_bad( "Spurious digit %d.", temp);
  417.           input_line_pointer -- ;
  418.           ignore_rest_of_line();
  419.         }
  420.           continue;
  421.         }
  422.       if(c && index(line_comment_chars,c)) {    /* Its a comment.  Better say APP or NO_APP */
  423.         char *ends;
  424.         char *strstr();
  425.         char    *new_buf;
  426.         char    *new_tmp;
  427.         int    new_length;
  428.         char    *tmp_buf = 0;
  429.         extern char *scrub_string,*scrub_last_string;
  430.         int    scrub_from_string();
  431.         void    scrub_to_string();
  432.  
  433.         bump_line_counters();
  434.         s=input_line_pointer;
  435.         if(strncmp(s,"APP\n",4))
  436.             continue;    /* We ignore it */
  437.         s+=4;
  438.  
  439.         ends=strstr(s,"#NO_APP\n");
  440.  
  441.         if(!ends) {
  442.             int    tmp_len;
  443.             int    num;
  444.  
  445.             /* The end of the #APP wasn't in this buffer.  We
  446.                keep reading in buffers until we find the #NO_APP
  447.                that goes with this #APP  There is one.  The specs
  448.                 guarentee it. . .*/
  449.             tmp_len=buffer_limit-s;
  450.             tmp_buf=xmalloc(tmp_len);
  451.             bcopy(s,tmp_buf,tmp_len);
  452.             do {
  453.                 new_tmp = input_scrub_next_buffer(&buffer);
  454.                 if(!new_tmp)
  455.                     break;
  456.                 else
  457.                     buffer_limit = new_tmp;
  458.                 input_line_pointer = buffer;
  459.                 ends = strstr(buffer,"#NO_APP\n");
  460.                 if(ends)
  461.                     num=ends-buffer;
  462.                 else
  463.                     num=buffer_limit-buffer;
  464.  
  465.                 tmp_buf=xrealloc(tmp_buf,tmp_len+num);
  466.                 bcopy(buffer,tmp_buf+tmp_len,num);
  467.                 tmp_len+=num;
  468.             } while(!ends);
  469.  
  470.             input_line_pointer= ends ? ends+8 : NULL;
  471.  
  472.             s=tmp_buf;
  473.             ends=s+tmp_len;
  474.  
  475.         } else {
  476.             input_line_pointer=ends+8;
  477.         }
  478.         new_buf=xmalloc(100);
  479.         new_length=100;
  480.         new_tmp=new_buf;
  481.  
  482.         scrub_string=s;
  483.         scrub_last_string = ends;
  484.         for(;;) {
  485.             int ch;
  486.  
  487.             ch=do_scrub_next_char(scrub_from_string,scrub_to_string);
  488.             if(ch==EOF) break;
  489.             *new_tmp++=ch;
  490.             if(new_tmp==new_buf+new_length) {
  491.                 new_buf=xrealloc(new_buf,new_length+100);
  492.                 new_tmp=new_buf+new_length;
  493.                 new_length+=100;
  494.             }
  495.         }
  496.  
  497.         if(tmp_buf)
  498.             free(tmp_buf);
  499.         old_buffer=buffer;
  500.         old_input=input_line_pointer;
  501.         old_limit=buffer_limit;
  502.         buffer=new_buf;
  503.         input_line_pointer=new_buf;
  504.         buffer_limit=new_tmp;
  505.         continue;
  506.       }
  507.  
  508.       as_bad("Junk character %d.",c);
  509.       ignore_rest_of_line();
  510.     }            /* while (input_line_pointer<buffer_limit )*/
  511.     if(old_buffer) {
  512.         bump_line_counters();
  513.         if(old_input == 0)
  514.             return;
  515.         buffer=old_buffer;
  516.         input_line_pointer=old_input;
  517.         buffer_limit=old_limit;
  518.         old_buffer = 0;
  519.         goto contin;
  520.     }
  521.     }                /* while (more bufrers to scan) */
  522. }                /* read_a_source_file() */
  523.  
  524. void
  525. s_abort()
  526. {
  527.     as_fatal(".abort detected.  Abandoning ship.");
  528. }
  529.  
  530. #ifdef OTHER_ALIGN
  531. static void
  532. s_align()
  533. {
  534.     register unsigned int temp;
  535.     register long int temp_fill;
  536.     unsigned int i;
  537.  
  538.     temp = get_absolute_expression ();
  539. #define MAX_ALIGNMENT (1 << 15)
  540.     if ( temp > MAX_ALIGNMENT ) {
  541.     as_bad("Alignment too large: %d. assumed.", temp = MAX_ALIGNMENT);
  542.     }
  543.  
  544.     /*
  545.      * For the sparc, `.align (1<<n)' actually means `.align n'
  546.      * so we have to convert it.
  547.      */
  548.     if (temp != 0) {
  549.     for (i = 0; (temp & 1) == 0; temp >>= 1, ++i)
  550.         ;
  551.     }
  552.     if (temp != 1)
  553.     as_bad("Alignment not a power of 2");
  554.  
  555.     temp = i;
  556.     if (*input_line_pointer == ',') {
  557.     input_line_pointer ++;
  558.     temp_fill = get_absolute_expression ();
  559.     } else {
  560.     temp_fill = 0;
  561.     }
  562.     /* Only make a frag if we HAVE to. . . */
  563.     if (temp && ! need_pass_2)
  564.     frag_align (temp, (int)temp_fill);
  565.  
  566.     demand_empty_rest_of_line();
  567. }
  568. #else
  569.  
  570. void
  571. s_align()
  572. {
  573.     register int temp;
  574.     register long int temp_fill;
  575.  
  576.     temp = get_absolute_expression ();
  577. #define MAX_ALIGNMENT (15)
  578.     if ( temp > MAX_ALIGNMENT )
  579.         as_bad("Alignment too large: %d. assumed.", temp = MAX_ALIGNMENT);
  580.     else if ( temp < 0 ) {
  581.         as_bad("Alignment negative. 0 assumed.");
  582.         temp = 0;
  583.     }
  584.     if ( *input_line_pointer == ',' ) {
  585.         input_line_pointer ++;
  586.         temp_fill = get_absolute_expression ();
  587.     } else
  588.         temp_fill = 0;
  589.     /* Only make a frag if we HAVE to. . . */
  590.     if ( temp && ! need_pass_2 )
  591.         frag_align (temp, (int)temp_fill);
  592.     demand_empty_rest_of_line();
  593. }
  594. #endif
  595.  
  596. void
  597. s_comm()
  598. {
  599.     register char *name;
  600.     register char c;
  601.     register char *p;
  602.     register int temp;
  603.     register symbolS *    symbolP;
  604.  
  605.     name = input_line_pointer;
  606.     c = get_symbol_end();
  607.     /* just after name is now '\0' */
  608.     p = input_line_pointer;
  609.     *p = c;
  610.     SKIP_WHITESPACE();
  611.     if ( * input_line_pointer != ',' ) {
  612.         as_bad("Expected comma after symbol-name");
  613.         ignore_rest_of_line();
  614.         return;
  615.     }
  616.     input_line_pointer ++; /* skip ',' */
  617.     if ( (temp = get_absolute_expression ()) < 0 ) {
  618.         as_warn(".COMMon length (%d.) <0! Ignored.", temp);
  619.         ignore_rest_of_line();
  620.         return;
  621.     }
  622.     *p = 0;
  623.     symbolP = symbol_find_or_make (name);
  624.     *p = c;
  625.     if (   (symbolP -> sy_type & N_TYPE) != N_UNDF ||
  626.  symbolP -> sy_other != 0 || symbolP -> sy_desc != 0) {
  627.         as_warn( "Ignoring attempt to re-define symbol");
  628.         ignore_rest_of_line();
  629.         return;
  630.     }
  631.     if (symbolP -> sy_value) {
  632.         if (symbolP -> sy_value != temp)
  633.             as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.",
  634.  symbolP -> sy_name, symbolP -> sy_value, temp);
  635.     } else {
  636.         symbolP -> sy_value = temp;
  637.         symbolP -> sy_type |= N_EXT;
  638.     }
  639. #ifdef VMS
  640.     if(!temp)
  641.         symbolP->sy_other = const_flag;
  642. #endif
  643.     know( symbolP -> sy_frag == &zero_address_frag );
  644.     demand_empty_rest_of_line();
  645. }
  646.  
  647. #ifdef VMS
  648. void
  649. s_const()
  650. {
  651.     register int temp;
  652.  
  653.     temp = get_absolute_expression ();
  654.     subseg_new (SEG_DATA, (subsegT)temp);
  655.     const_flag = 1;
  656.     demand_empty_rest_of_line();
  657. }
  658. #endif
  659.  
  660. void
  661. s_data()
  662. {
  663.     register int temp;
  664.  
  665.     temp = get_absolute_expression ();
  666.     subseg_new (SEG_DATA, (subsegT)temp);
  667. #ifdef VMS
  668.     const_flag = 0;
  669. #endif
  670.     demand_empty_rest_of_line();
  671. }
  672.  
  673. void
  674. s_desc()
  675. {
  676.     register char *name;
  677.     register char c;
  678.     register char *p;
  679.     register symbolS *    symbolP;
  680.     register int temp;
  681.  
  682.     /*
  683.      * Frob invented at RMS' request. Set the n_desc of a symbol.
  684.      */
  685.     name = input_line_pointer;
  686.     c = get_symbol_end();
  687.     p = input_line_pointer;
  688.     symbolP = symbol_table_lookup (name);
  689.     * p = c;
  690.     SKIP_WHITESPACE();
  691.     if ( * input_line_pointer != ',' ) {
  692.         *p = 0;
  693.         as_bad("Expected comma after name \"%s\"", name);
  694.         *p = c;
  695.         ignore_rest_of_line();
  696.     } else {
  697.         input_line_pointer ++;
  698.         temp = get_absolute_expression ();
  699.         *p = 0;
  700.         symbolP = symbol_find_or_make (name);
  701.         *p = c;
  702.         symbolP -> sy_desc = temp;
  703.     }
  704.     demand_empty_rest_of_line();
  705. }
  706.  
  707. void
  708. s_file()
  709. {
  710.     register char *s;
  711.     int    length;
  712.  
  713.     /* Some assemblers tolerate immediately following '"' */
  714.     if ( s = demand_copy_string( & length ) ) {
  715.         new_logical_line (s, -1);
  716.         demand_empty_rest_of_line();
  717.     }
  718. }
  719.  
  720. void
  721. s_fill()
  722. {
  723.     long int temp_repeat;
  724.     long int temp_size;
  725.     register long int temp_fill;
  726.     char    *p;
  727.  
  728.     if ( get_absolute_expression_and_terminator(& temp_repeat) != ',' ) {
  729.         input_line_pointer --; /* Backup over what was not a ','. */
  730.         as_warn("Expect comma after rep-size in .fill");
  731.         ignore_rest_of_line();
  732.         return;
  733.     }
  734.     if ( get_absolute_expression_and_terminator( & temp_size) != ',' ) {
  735.           input_line_pointer --; /* Backup over what was not a ','. */
  736.           as_warn("Expected comma after size in .fill");
  737.           ignore_rest_of_line();
  738.           return;
  739.     }
  740.     /*
  741.      * This is to be compatible with BSD 4.2 AS, not for any rational reason.
  742.      */
  743. #define BSD_FILL_SIZE_CROCK_8 (8)
  744.     if ( temp_size > BSD_FILL_SIZE_CROCK_8 ) {
  745.         as_bad(".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8);
  746.         temp_size = BSD_FILL_SIZE_CROCK_8 ;
  747.     } if ( temp_size < 0 ) {
  748.         as_warn("Size negative: .fill ignored.");
  749.         temp_size = 0;
  750.     } else if ( temp_repeat <= 0 ) {
  751.         as_warn("Repeat < 0, .fill ignored");
  752.         temp_size = 0;
  753.     }
  754.     temp_fill = get_absolute_expression ();
  755.     if ( temp_size && !need_pass_2 ) {
  756.         p = frag_var (rs_fill, (int)temp_size, (int)temp_size, (relax_substateT)0, (symbolS *)0, temp_repeat, (char *)0);
  757.         bzero (p, (int)temp_size);
  758. /*
  759.  * The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX flavoured AS.
  760.  * The following bizzare behaviour is to be compatible with above.
  761.  * I guess they tried to take up to 8 bytes from a 4-byte expression
  762.  * and they forgot to sign extend. Un*x Sux.
  763.  */
  764. #define BSD_FILL_SIZE_CROCK_4 (4)
  765.         md_number_to_chars (p, temp_fill, temp_size > BSD_FILL_SIZE_CROCK_4 ? BSD_FILL_SIZE_CROCK_4 : (int)temp_size);
  766. /*
  767.  * Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
  768.  * but emits no error message because it seems a legal thing to do.
  769.  * It is a degenerate case of .fill but could be emitted by a compiler.
  770.  */
  771.     }
  772.     demand_empty_rest_of_line();
  773. }
  774.  
  775. #ifdef DONTDEF
  776. void
  777. s_gdbbeg()
  778. {
  779.     register int temp;
  780.  
  781.     temp = get_absolute_expression ();
  782.     if (temp < 0)
  783.         as_warn( "Block number <0. Ignored." );
  784.     else if (flagseen ['G'])
  785.         gdb_block_beg ( (long int) temp, frag_now, (long int)(obstack_next_free(& frags) - frag_now -> fr_literal));
  786.     demand_empty_rest_of_line ();
  787. }
  788.  
  789. void
  790. s_gdbblock()
  791. {
  792.     register int    position;
  793.     int    temp;
  794.  
  795.     if (get_absolute_expression_and_terminator (&temp) != ',') {
  796.         as_warn( "expected comma before position in .gdbblock");
  797.         --input_line_pointer;
  798.         ignore_rest_of_line ();
  799.         return;
  800.     }
  801.     position = get_absolute_expression ();
  802.     if (flagseen ['G'])
  803.         gdb_block_position ((long int) temp, (long int) position);
  804.     demand_empty_rest_of_line ();
  805. }
  806.  
  807. void
  808. s_gdbend()
  809. {
  810.     register int temp;
  811.  
  812.     temp = get_absolute_expression ();
  813.     if (temp < 0)
  814.         as_warn( "Block number <0. Ignored." );
  815.     else if (flagseen ['G'])
  816.         gdb_block_end ( (long int) temp, frag_now, (long int)(obstack_next_free(& frags) - frag_now -> fr_literal));
  817.     demand_empty_rest_of_line ();
  818. }
  819.  
  820. void
  821. s_gdbsym()
  822. {
  823.     register char *name,
  824.             *p;
  825.     register char c;
  826.     register symbolS *    symbolP;
  827.     register int temp;
  828.  
  829.     name = input_line_pointer;
  830.     c = get_symbol_end();
  831.     p = input_line_pointer;
  832.     symbolP = symbol_find_or_make (name);
  833.     *p = c;
  834.     SKIP_WHITESPACE();
  835.     if ( * input_line_pointer != ',' ) {
  836.         as_warn("Expected comma after name");
  837.         ignore_rest_of_line();
  838.         return;
  839.     }
  840.     input_line_pointer ++;
  841.     if ( (temp = get_absolute_expression ()) < 0 ) {
  842.         as_warn("Bad GDB symbol file offset (%d.) <0! Ignored.", temp);
  843.         ignore_rest_of_line();
  844.         return;
  845.     }
  846.     if (flagseen ['G'])
  847.         gdb_symbols_fixup (symbolP, (long int)temp);
  848.     demand_empty_rest_of_line ();
  849. }
  850.  
  851. void
  852. s_gdbline()
  853. {
  854.     int    file_number,
  855.         lineno;
  856.  
  857.     if(get_absolute_expression_and_terminator(&file_number) != ',') {
  858.         as_warn("expected comman after filenum in .gdbline");
  859.         ignore_rest_of_line();
  860.         return;
  861.     }
  862.     lineno=get_absolute_expression();
  863.     if(flagseen['G'])
  864.         gdb_line(file_number,lineno);
  865.     demand_empty_rest_of_line();
  866. }
  867.  
  868.  
  869. void
  870. s_gdblinetab()
  871. {
  872.     int    file_number,
  873.         offset;
  874.  
  875.     if(get_absolute_expression_and_terminator(&file_number) != ',') {
  876.         as_warn("expected comman after filenum in .gdblinetab");
  877.         ignore_rest_of_line();
  878.         return;
  879.     }
  880.     offset=get_absolute_expression();
  881.     if(flagseen['G'])
  882.         gdb_line_tab(file_number,offset);
  883.     demand_empty_rest_of_line();
  884. }
  885. #endif    
  886.  
  887. void
  888. s_globl()
  889. {
  890.     register char *name;
  891.     register int c;
  892.     register symbolS *    symbolP;
  893.  
  894.     do {
  895.         name = input_line_pointer;
  896.         c = get_symbol_end();
  897.         symbolP = symbol_find_or_make (name);
  898.         * input_line_pointer = c;
  899.         SKIP_WHITESPACE();
  900.         symbolP -> sy_type |= N_EXT;
  901.         if(c==',') {
  902.             input_line_pointer++;
  903.             SKIP_WHITESPACE();
  904.             if(*input_line_pointer=='\n')
  905.                 c='\n';
  906.         }
  907.     } while(c==',');
  908.     demand_empty_rest_of_line();
  909. }
  910.  
  911. void
  912. s_lcomm()
  913. {
  914.     register char *name;
  915.     register char c;
  916.     register char *p;
  917.     register int temp;
  918.     register symbolS *    symbolP;
  919.  
  920.     name = input_line_pointer;
  921.     c = get_symbol_end();
  922.     p = input_line_pointer;
  923.     *p = c;
  924.     SKIP_WHITESPACE();
  925.     if ( * input_line_pointer != ',' ) {
  926.         as_warn("Expected comma after name");
  927.         ignore_rest_of_line();
  928.         return;
  929.     }
  930.     input_line_pointer ++;
  931.     if ( (temp = get_absolute_expression ()) < 0 ) {
  932.         as_warn("BSS length (%d.) <0! Ignored.", temp);
  933.         ignore_rest_of_line();
  934.         return;
  935.     }
  936.     *p = 0;
  937.     symbolP = symbol_find_or_make (name);
  938.     *p = c;
  939.     if (   symbolP -> sy_other == 0
  940.         && symbolP -> sy_desc  == 0
  941.         && (   (   symbolP -> sy_type  == N_BSS
  942.         && symbolP -> sy_value == local_bss_counter)
  943.         || (   (symbolP -> sy_type & N_TYPE) == N_UNDF
  944.         && symbolP -> sy_value == 0))) {
  945.         symbolP -> sy_value = local_bss_counter;
  946.         symbolP -> sy_type  = N_BSS;
  947.         symbolP -> sy_frag  = & bss_address_frag;
  948.         local_bss_counter += temp;
  949.     } else
  950.         as_warn( "Ignoring attempt to re-define symbol from %d. to %d.",
  951.  symbolP -> sy_value, local_bss_counter );
  952.     demand_empty_rest_of_line();
  953. }
  954.  
  955. void
  956. s_line()
  957. {
  958.     /* Assume delimiter is part of expression. */
  959.     /* BSD4.2 as fails with delightful bug, so we */
  960.     /* are not being incompatible here. */
  961.     new_logical_line ((char *)NULL, (int)(get_absolute_expression ()));
  962.     demand_empty_rest_of_line();
  963. }
  964.  
  965. void
  966. s_long()
  967. {
  968.     cons(4);
  969. }
  970.  
  971. void
  972. s_int()
  973. {
  974.     cons(4);
  975. }
  976.  
  977. void
  978. s_lsym()
  979. {
  980.     register char *name;
  981.     register char c;
  982.     register char *p;
  983.     register segT segment;
  984.     expressionS exp;
  985.     register symbolS *symbolP;
  986.  
  987.     /* we permit ANY expression: BSD4.2 demands constants */
  988.     name = input_line_pointer;
  989.     c = get_symbol_end();
  990.     p = input_line_pointer;
  991.     *p = c;
  992.     SKIP_WHITESPACE();
  993.     if ( * input_line_pointer != ',' ) {
  994.         *p = 0;
  995.         as_warn("Expected comma after name \"%s\"", name);
  996.         *p = c;
  997.         ignore_rest_of_line();
  998.         return;
  999.     }
  1000.     input_line_pointer ++;
  1001.     segment = expression (& exp);
  1002.     if (   segment != SEG_ABSOLUTE && segment != SEG_DATA &&
  1003.  segment != SEG_TEXT && segment != SEG_BSS) {
  1004.         as_bad("Bad expression: %s", seg_name [(int)segment]);
  1005.         ignore_rest_of_line();
  1006.         return;
  1007.     }
  1008.  know(   segment == SEG_ABSOLUTE || segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS );
  1009.     *p = 0;
  1010.     symbolP = symbol_new (name,(unsigned char)(seg_N_TYPE [(int) segment]),
  1011.  0, 0, (valueT)(exp . X_add_number), & zero_address_frag);
  1012.     *p = c;
  1013.     demand_empty_rest_of_line();
  1014. }
  1015.  
  1016. void
  1017. s_org()
  1018. {
  1019.     register segT segment;
  1020.     expressionS exp;
  1021.     register long int temp_fill;
  1022.     register char *p;
  1023. /*
  1024.  * Don't believe the documentation of BSD 4.2 AS.
  1025.  * There is no such thing as a sub-segment-relative origin.
  1026.  * Any absolute origin is given a warning, then assumed to be segment-relative.
  1027.  * Any segmented origin expression ("foo+42") had better be in the right
  1028.  * segment or the .org is ignored.
  1029.  *
  1030.  * BSD 4.2 AS warns if you try to .org backwards. We cannot because we
  1031.  * never know sub-segment sizes when we are reading code.
  1032.  * BSD will crash trying to emit -ve numbers of filler bytes in certain
  1033.  * .orgs. We don't crash, but see as-write for that code.
  1034.  */
  1035. /*
  1036.  * Don't make frag if need_pass_2==TRUE.
  1037.  */
  1038.     segment = get_known_segmented_expression(& exp);
  1039.     if ( *input_line_pointer == ',' ) {
  1040.         input_line_pointer ++;
  1041.         temp_fill = get_absolute_expression ();
  1042.     } else
  1043.         temp_fill = 0;
  1044.     if ( ! need_pass_2 ) {
  1045.         if (segment != now_seg && segment != SEG_ABSOLUTE)
  1046.             as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  1047.  seg_name [(int) segment], seg_name [(int) now_seg]);
  1048.         p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp . X_add_symbol,
  1049.  exp . X_add_number, (char *)0);
  1050.         * p = temp_fill;
  1051.     } /* if (ok to make frag) */
  1052.     demand_empty_rest_of_line();
  1053. }
  1054.  
  1055. void
  1056. s_set()
  1057. {
  1058.     register char *name;
  1059.     register char delim;
  1060.     register char *end_name;
  1061.     register symbolS *symbolP;
  1062.  
  1063.     /*
  1064.      * Especial apologies for the random logic:
  1065.      * this just grew, and could be parsed much more simply!
  1066.      * Dean in haste.
  1067.      */
  1068.     name = input_line_pointer;
  1069.     delim = get_symbol_end();
  1070.     end_name = input_line_pointer;
  1071.     *end_name = delim;
  1072.     SKIP_WHITESPACE();
  1073.     if ( * input_line_pointer != ',' ) {
  1074.         *end_name = 0;
  1075.         as_warn("Expected comma after name \"%s\"", name);
  1076.         *end_name = delim;
  1077.         ignore_rest_of_line();
  1078.         return;
  1079.     }
  1080.     input_line_pointer ++;
  1081.     *end_name = 0;
  1082.     if(name[0]=='.' && name[1]=='\0') {
  1083.       /* Turn '. = mumble' into a .org mumble */
  1084.       register segT segment;
  1085.       expressionS exp;
  1086.       register char *ptr;
  1087.  
  1088.       segment = get_known_segmented_expression(& exp);
  1089.       if ( ! need_pass_2 ) {
  1090.         if (segment != now_seg && segment != SEG_ABSOLUTE)
  1091.           as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  1092.               seg_name [(int) segment], seg_name [(int) now_seg]);
  1093.         ptr = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
  1094.               exp.X_add_number, (char *)0);
  1095.         *ptr= 0;
  1096.       } /* if (ok to make frag) */
  1097.       *end_name = delim;
  1098.       return;
  1099.     }
  1100.     symbolP = symbol_find_or_make (name);
  1101.     *end_name = delim;
  1102.     pseudo_set (symbolP);
  1103.     demand_empty_rest_of_line ();
  1104. }
  1105.  
  1106. void
  1107. s_space()
  1108. {
  1109.     long int temp_repeat;
  1110.     register long int temp_fill;
  1111.     register char *p;
  1112.  
  1113.     /* Just like .fill, but temp_size = 1 */
  1114.     if ( get_absolute_expression_and_terminator( & temp_repeat) == ',' ) {
  1115.         temp_fill = get_absolute_expression ();
  1116.     } else {
  1117.         input_line_pointer --; /* Backup over what was not a ','. */
  1118.         temp_fill = 0;
  1119.     }
  1120.     if ( temp_repeat <= 0 ) {
  1121.         as_warn("Repeat < 0, .space ignored");
  1122.         ignore_rest_of_line();
  1123.         return;
  1124.     }
  1125.     if ( ! need_pass_2 ) {
  1126.         p = frag_var (rs_fill, 1, 1, (relax_substateT)0, (symbolS *)0,
  1127.  temp_repeat, (char *)0);
  1128.         * p = temp_fill;
  1129.     }
  1130.     demand_empty_rest_of_line();
  1131. }
  1132.  
  1133. void
  1134. s_text()
  1135. {
  1136.     register int temp;
  1137.  
  1138.     temp = get_absolute_expression ();
  1139.     subseg_new (SEG_TEXT, (subsegT)temp);
  1140.     demand_empty_rest_of_line();
  1141. }
  1142.  
  1143.  
  1144. /*( JF was static, but can't be if machine dependent pseudo-ops are to use it */
  1145.  
  1146. void
  1147. demand_empty_rest_of_line()
  1148. {
  1149.   SKIP_WHITESPACE();
  1150.   if ( is_end_of_line [* input_line_pointer] )
  1151.     {
  1152.       input_line_pointer ++;
  1153.     }
  1154.   else
  1155.     {
  1156.       ignore_rest_of_line();
  1157.     }
  1158.                 /* Return having already swallowed end-of-line. */
  1159. }                /* Return pointing just after end-of-line. */
  1160.  
  1161.  
  1162. void
  1163. ignore_rest_of_line()        /* For suspect lines: gives warning. */
  1164. {
  1165.   if ( ! is_end_of_line [* input_line_pointer])
  1166.     {
  1167.       as_warn("Rest of line ignored. 1st junk character valued %d (%c)."
  1168.           , * input_line_pointer, *input_line_pointer);
  1169.       while (   input_line_pointer < buffer_limit
  1170.          && ! is_end_of_line [* input_line_pointer] )
  1171.     {
  1172.       input_line_pointer ++;
  1173.     }
  1174.     }
  1175.   input_line_pointer ++;    /* Return pointing just after end-of-line. */
  1176.   know( is_end_of_line [input_line_pointer [-1]] );
  1177. }
  1178.  
  1179. /*
  1180.  *            stab()
  1181.  *
  1182.  * Handle .stabX directives, which used to be open-coded.
  1183.  * So much creeping featurism overloaded the semantics that we decided
  1184.  * to put all .stabX thinking in one place. Here.
  1185.  *
  1186.  * We try to make any .stabX directive legal. Other people's AS will often
  1187.  * do assembly-time consistency checks: eg assigning meaning to n_type bits
  1188.  * and "protecting" you from setting them to certain values. (They also zero
  1189.  * certain bits before emitting symbols. Tut tut.)
  1190.  *
  1191.  * If an expression is not absolute we either gripe or use the relocation
  1192.  * information. Other people's assemblers silently forget information they
  1193.  * don't need and invent information they need that you didn't supply.
  1194.  *
  1195.  * .stabX directives always make a symbol table entry. It may be junk if
  1196.  * the rest of your .stabX directive is malformed.
  1197.  */
  1198. static void
  1199. stab (what)
  1200. int what;
  1201. {
  1202.   register symbolS *    symbolP;
  1203.   register char *    string;
  1204.        int        saved_type;
  1205.          int        length;
  1206.          int        goof;    /* TRUE if we have aborted. */
  1207.        long int    longint;
  1208.  
  1209. /*
  1210.  * Enter with input_line_pointer pointing past .stabX and any following
  1211.  * whitespace.
  1212.  */
  1213.     goof = FALSE; /* JF who forgot this?? */
  1214.     if (what == 's') {
  1215.         string = demand_copy_C_string (& length);
  1216.         SKIP_WHITESPACE();
  1217.         if (* input_line_pointer == ',')
  1218.             input_line_pointer ++;
  1219.         else {
  1220.             as_warn( "I need a comma after symbol's name" );
  1221.             goof = TRUE;
  1222.         }
  1223.     } else
  1224.         string = "";
  1225.  
  1226. /*
  1227.  * Input_line_pointer->after ','.  String -> symbol name.
  1228.  */
  1229.     if (! goof) {
  1230.         symbolP = symbol_new (string, 0,0,0,0,(struct frag *)0);
  1231.         switch (what) {
  1232.         case 'd':
  1233.             symbolP->sy_name = NULL; /* .stabd feature. */
  1234.             symbolP->sy_value = obstack_next_free(& frags) - frag_now->fr_literal;
  1235.             symbolP->sy_frag = frag_now;
  1236.             break;
  1237.  
  1238.         case 'n':
  1239.             symbolP->sy_frag = &zero_address_frag;
  1240.             break;
  1241.  
  1242.         case 's':
  1243.             symbolP->sy_frag = & zero_address_frag;
  1244.             break;
  1245.  
  1246.         default:
  1247.             BAD_CASE( what );
  1248.             break;
  1249.         }
  1250.         if (get_absolute_expression_and_terminator (& longint) == ',')
  1251.             symbolP->sy_type = saved_type = longint;
  1252.         else {
  1253.             as_warn( "I want a comma after the n_type expression" );
  1254.             goof = TRUE;
  1255.             input_line_pointer --; /* Backup over a non-',' char. */
  1256.         }
  1257.     }
  1258.     if (! goof) {
  1259.         if (get_absolute_expression_and_terminator (& longint) == ',')
  1260.             symbolP->sy_other = longint;
  1261.         else {
  1262.             as_warn( "I want a comma after the n_other expression" );
  1263.             goof = TRUE;
  1264.             input_line_pointer --; /* Backup over a non-',' char. */
  1265.         }
  1266.     }
  1267.     if (! goof) {
  1268.         symbolP->sy_desc = get_absolute_expression ();
  1269.         if (what == 's' || what == 'n') {
  1270.             if (* input_line_pointer != ',') {
  1271.                 as_warn( "I want a comma after the n_desc expression" );
  1272.                 goof = TRUE;
  1273.             } else {
  1274.                 input_line_pointer ++;
  1275.             }
  1276.         }
  1277.     }
  1278.     if ((! goof) && (what=='s' || what=='n')) {
  1279.         pseudo_set (symbolP);
  1280.         symbolP->sy_type = saved_type;
  1281.     }
  1282.     if (goof)
  1283.         ignore_rest_of_line ();
  1284.     else
  1285.         demand_empty_rest_of_line ();
  1286. }
  1287.  
  1288. /*
  1289.  *            pseudo_set()
  1290.  *
  1291.  * In:    Pointer to a symbol.
  1292.  *    Input_line_pointer -> expression.
  1293.  *
  1294.  * Out:    Input_line_pointer -> just after any whitespace after expression.
  1295.  *    Tried to set symbol to value of expression.
  1296.  *    Will change sy_type, sy_value, sy_frag;
  1297.  *    May set need_pass_2 == TRUE.
  1298.  */
  1299. static void
  1300. pseudo_set (symbolP)
  1301.      symbolS *    symbolP;
  1302. {
  1303.   expressionS    exp;
  1304.   register segT    segment;
  1305.   int ext;
  1306.  
  1307.   know( symbolP );        /* NULL pointer is logic error. */
  1308.   ext=(symbolP->sy_type&N_EXT);
  1309.   if ((segment = expression( & exp )) == SEG_NONE)
  1310.     {
  1311.       as_warn( "Missing expression: absolute 0 assumed" );
  1312.       exp . X_seg        = SEG_ABSOLUTE;
  1313.       exp . X_add_number    = 0;
  1314.     }
  1315.   switch (segment)
  1316.     {
  1317.     case SEG_BIG:
  1318.       as_warn( "%s number illegal. Absolute 0 assumed.",
  1319.           exp . X_add_number > 0 ? "Bignum" : "Floating-Point" );
  1320.       symbolP -> sy_type = N_ABS | ext;
  1321.       symbolP -> sy_value = 0;
  1322.       symbolP -> sy_frag = & zero_address_frag;
  1323.       break;
  1324.  
  1325.     case SEG_NONE:
  1326.       as_warn("No expression:  Using absolute 0");
  1327.       symbolP -> sy_type = N_ABS | ext;
  1328.       symbolP -> sy_value = 0;
  1329.       symbolP -> sy_frag = & zero_address_frag;
  1330.       break;
  1331.  
  1332.     case SEG_DIFFERENCE:
  1333.       if (exp.X_add_symbol && exp.X_subtract_symbol
  1334.           &&    (exp.X_add_symbol->sy_type & N_TYPE)
  1335.          == (exp.X_subtract_symbol->sy_type & N_TYPE)) {
  1336.     if(exp.X_add_symbol->sy_frag != exp.X_subtract_symbol->sy_frag) {
  1337.       as_bad("Unknown expression: symbols %s and %s are in different frags.",exp.X_add_symbol->sy_name, exp.X_subtract_symbol->sy_name);
  1338.       need_pass_2++;
  1339.     }
  1340.     exp.X_add_number+=exp.X_add_symbol->sy_value - exp.X_subtract_symbol->sy_value;
  1341.       } else
  1342.     as_warn( "Complex expression. Absolute segment assumed." );
  1343.     case SEG_ABSOLUTE:
  1344.       symbolP -> sy_type = N_ABS | ext;
  1345.       symbolP -> sy_value = exp . X_add_number;
  1346.       symbolP -> sy_frag = & zero_address_frag;
  1347.       break;
  1348.  
  1349.     case SEG_DATA:
  1350.     case SEG_TEXT:
  1351.     case SEG_BSS:
  1352.       symbolP -> sy_type = seg_N_TYPE [(int) segment] | ext;
  1353.       symbolP -> sy_value= exp . X_add_number + exp . X_add_symbol -> sy_value;
  1354.       symbolP -> sy_frag = exp . X_add_symbol -> sy_frag;
  1355.       break;
  1356.       
  1357.     case SEG_PASS1:        /* Not an error. Just try another pass. */
  1358.       symbolP->sy_forward=exp.X_add_symbol;
  1359.       as_warn("Unknown expression");
  1360.       know( need_pass_2 == TRUE );
  1361.       break;
  1362.       
  1363.     case SEG_UNKNOWN:
  1364.       symbolP->sy_forward=exp.X_add_symbol;
  1365.       /* as_warn("unknown symbol"); */
  1366.       /* need_pass_2 = TRUE; */
  1367.       break;
  1368.       
  1369.     default:
  1370.       BAD_CASE( segment );
  1371.       break;
  1372.     }
  1373. }
  1374.  
  1375. /*
  1376.  *            cons()
  1377.  *
  1378.  * CONStruct more frag of .bytes, or .words etc.
  1379.  * Should need_pass_2 be TRUE then emit no frag(s).
  1380.  * This understands EXPRESSIONS, as opposed to big_cons().
  1381.  *
  1382.  * Bug (?)
  1383.  *
  1384.  * This has a split personality. We use expression() to read the
  1385.  * value. We can detect if the value won't fit in a byte or word.
  1386.  * But we can't detect if expression() discarded significant digits
  1387.  * in the case of a long. Not worth the crocks required to fix it.
  1388.  */
  1389. void
  1390. cons(nbytes)            /* worker to do .byte etc statements */
  1391.                 /* clobbers input_line_pointer, checks */
  1392.                 /* end-of-line. */
  1393.      register int    nbytes;    /* 1=.byte, 2=.word, 4=.long */
  1394. {
  1395.   register char        c;
  1396.   register long int    mask;    /* High-order bits we will left-truncate, */
  1397.                 /* but includes sign bit also. */
  1398.   register long int     get;    /* what we get */
  1399.   register long int    use;    /* get after truncation. */
  1400.   register long int    unmask;    /* what bits we will store */
  1401.   register char *    p;
  1402.   register segT        segment;
  1403.            expressionS    exp;
  1404. #ifdef NS32K
  1405.   void fix_new_ns32k();
  1406. #else
  1407.   void    fix_new();
  1408. #endif
  1409.  
  1410.   /*
  1411.    * Input_line_pointer -> 1st char after pseudo-op-code and could legally
  1412.    * be a end-of-line. (Or, less legally an eof - which we cope with.)
  1413.    */
  1414.   /* JF << of >= number of bits in the object is undefined.  In particular
  1415.      SPARC (Sun 4) has problems */
  1416.   if(nbytes>=sizeof(long int))
  1417.     mask = 0;
  1418.   else 
  1419.     mask = ~0 << (BITS_PER_CHAR * nbytes); /* Don't store these bits. */
  1420.   unmask = ~ mask;        /* Do store these bits. */
  1421. #ifdef NEVER
  1422.   "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
  1423.   mask = ~ (unmask >> 1);    /* Includes sign bit now. */
  1424. #endif
  1425.   /*
  1426.    * The following awkward logic is to parse ZERO or more expressions,
  1427.    * comma seperated. Recall an expression includes its leading &
  1428.    * trailing blanks. We fake a leading ',' if there is (supposed to
  1429.    * be) a 1st expression, and keep demanding 1 expression for each ','.
  1430.    */
  1431.   if (is_it_end_of_statement())
  1432.     {
  1433.       c = 0;            /* Skip loop. */
  1434.       input_line_pointer ++;    /* Matches end-of-loop 'correction'. */
  1435.     }
  1436.   else
  1437.       c = ',';            /* Do loop. */
  1438.   while ( c == ','  )
  1439.     {
  1440.       segment = expression( &exp ); /* At least scan over the expression. */
  1441.       if ( ! need_pass_2 )
  1442.     {            /* Still worthwhile making frags. */
  1443.  
  1444.       /* Don't call this if we are going to junk this pass anyway! */
  1445.       know( segment != SEG_PASS1 );
  1446.  
  1447.       if ( segment == SEG_DIFFERENCE && exp . X_add_symbol == NULL )
  1448.         {
  1449.           as_warn( "Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.",
  1450.               exp . X_subtract_symbol -> sy_name,
  1451.               seg_name [(int) N_TYPE_seg [exp . X_subtract_symbol -> sy_type & N_TYPE]]);
  1452.           segment = SEG_ABSOLUTE;
  1453.           /* Leave exp . X_add_number alone. */
  1454.         }
  1455.       p = frag_more (nbytes);
  1456.       switch (segment)
  1457.         {
  1458.         case SEG_BIG:
  1459.           as_warn( "%s number illegal. Absolute 0 assumed.",
  1460.               exp . X_add_number > 0 ? "Bignum" : "Floating-Point");
  1461.           md_number_to_chars (p, (long)0, nbytes);
  1462.           break;
  1463.  
  1464.         case SEG_NONE:
  1465.           as_warn( "0 assumed for missing expression" );
  1466.           exp . X_add_number = 0;
  1467.           know( exp . X_add_symbol == NULL );
  1468.           /* fall into SEG_ABSOLUTE */
  1469.         case SEG_ABSOLUTE:
  1470.           get = exp . X_add_number;
  1471.           use = get & unmask;
  1472.           if ( (get & mask) && (get & mask) != mask )
  1473.         {        /* Leading bits contain both 0s & 1s. */
  1474.           as_warn("Value x%x truncated to x%x.", get, use);
  1475.         }
  1476.           md_number_to_chars (p, use, nbytes); /* put bytes in right order. */
  1477.           break;
  1478.  
  1479.         case SEG_DIFFERENCE:
  1480. #ifndef WORKING_DOT_WORD
  1481.           if(nbytes==2) {
  1482.         struct broken_word *x;
  1483.  
  1484.         x=(struct broken_word *)xmalloc(sizeof(struct broken_word));
  1485.         x->next_broken_word=broken_words;
  1486.         broken_words=x;
  1487.         x->frag=frag_now;
  1488.         x->word_goes_here=p;
  1489.         x->dispfrag=0;
  1490.         x->add=exp.X_add_symbol;
  1491.         x->sub=exp.X_subtract_symbol;
  1492.         x->addnum=exp.X_add_number;
  1493.         x->added=0;
  1494.         new_broken_words++;
  1495.         break;
  1496.           }
  1497.           /* Else Fall through into. . . */
  1498. #endif
  1499.         case SEG_BSS:
  1500.         case SEG_UNKNOWN:
  1501.         case SEG_TEXT:
  1502.         case SEG_DATA:
  1503. #if defined(SPARC) || defined(I860)
  1504.           fix_new (frag_now, p - frag_now -> fr_literal, nbytes,
  1505.                exp . X_add_symbol, exp . X_subtract_symbol,
  1506.                exp . X_add_number, 0, RELOC_32);
  1507. #endif
  1508. #ifdef NS32K
  1509.           fix_new_ns32k (frag_now, p - frag_now -> fr_literal, nbytes,
  1510.                exp . X_add_symbol, exp . X_subtract_symbol,
  1511.                exp . X_add_number, 0, 0, 2, 0, 0);
  1512. #endif
  1513. #if !defined(SPARC) && !defined(NS32K) && !defined(I860)
  1514.           fix_new (frag_now, p - frag_now -> fr_literal, nbytes,
  1515.                exp . X_add_symbol, exp . X_subtract_symbol,
  1516.                exp . X_add_number, 0);
  1517. #endif
  1518.           break;
  1519.  
  1520.         default:
  1521.           BAD_CASE( segment );
  1522.           break;
  1523.         }            /* switch(segment) */
  1524.     }            /* if(!need_pass_2) */
  1525.       c = * input_line_pointer ++;
  1526.     }                /* while(c==',') */
  1527.   input_line_pointer --;    /* Put terminator back into stream. */
  1528.   demand_empty_rest_of_line();
  1529. }                /* cons() */
  1530.  
  1531. /*
  1532.  *            big_cons()
  1533.  *
  1534.  * CONStruct more frag(s) of .quads, or .octa etc.
  1535.  * Makes 0 or more new frags.
  1536.  * If need_pass_2 == TRUE, generate no frag.
  1537.  * This understands only bignums, not expressions. Cons() understands
  1538.  * expressions.
  1539.  *
  1540.  * Constants recognised are '0...'(octal) '0x...'(hex) '...'(decimal).
  1541.  *
  1542.  * This creates objects with struct obstack_control objs, destroying
  1543.  * any context objs held about a partially completed object. Beware!
  1544.  *
  1545.  *
  1546.  * I think it sucks to have 2 different types of integers, with 2
  1547.  * routines to read them, store them etc.
  1548.  * It would be nicer to permit bignums in expressions and only
  1549.  * complain if the result overflowed. However, due to "efficiency"...
  1550.  */
  1551. void
  1552. big_cons(nbytes)        /* worker to do .quad etc statements */
  1553.                 /* clobbers input_line_pointer, checks */
  1554.                 /* end-of-line. */
  1555.      register int    nbytes;    /* 8=.quad 16=.octa ... */
  1556. {
  1557.   register char        c;    /* input_line_pointer -> c. */
  1558.   register int        radix;
  1559.   register long int    length;    /* Number of chars in an object. */
  1560.   register int        digit;    /* Value of 1 digit. */
  1561.   register int        carry;    /* For multi-precision arithmetic. */
  1562.   register int        work;    /* For multi-precision arithmetic. */
  1563.   register char *    p;    /* For multi-precision arithmetic. */
  1564.  
  1565.   extern char hex_value[];    /* In hex_value.c. */
  1566.  
  1567.   /*
  1568.    * The following awkward logic is to parse ZERO or more strings,
  1569.    * comma seperated. Recall an expression includes its leading &
  1570.    * trailing blanks. We fake a leading ',' if there is (supposed to
  1571.    * be) a 1st expression, and keep demanding 1 expression for each ','.
  1572.    */
  1573.   if (is_it_end_of_statement())
  1574.     {
  1575.       c = 0;            /* Skip loop. */
  1576.     }
  1577.   else
  1578.     {
  1579.       c = ',';            /* Do loop. */
  1580.       -- input_line_pointer;
  1581.     }
  1582.   while (c == ',')
  1583.     {
  1584.       ++ input_line_pointer;
  1585.       SKIP_WHITESPACE();
  1586.       c = * input_line_pointer;
  1587.       /* C contains 1st non-blank character of what we hope is a number. */
  1588.       if (c == '0')
  1589.     {
  1590.       c = * ++ input_line_pointer;
  1591.       if (c == 'x' || c=='X')
  1592.         {
  1593.           c = * ++ input_line_pointer;
  1594.           radix = 16;
  1595.         }
  1596.       else
  1597.         {
  1598.           radix = 8;
  1599.         }
  1600.     }
  1601.       else
  1602.     {
  1603.       radix = 10;
  1604.     }
  1605.       /*
  1606.        * This feature (?) is here to stop people worrying about
  1607.        * mysterious zero constants: which is what they get when
  1608.        * they completely omit digits.
  1609.        */
  1610.       if (hex_value[c] >= radix)
  1611.     {
  1612.       as_warn( "Missing digits. 0 assumed." );
  1613.     }
  1614.       bignum_high = bignum_low - 1; /* Start constant with 0 chars. */
  1615.       for(   ;   (digit = hex_value [c]) < radix;   c = * ++ input_line_pointer)
  1616.     {
  1617.       /* Multiply existing number by radix, then add digit. */
  1618.       carry = digit;
  1619.       for (p=bignum_low;   p <= bignum_high;   p++)
  1620.         {
  1621.           work = (*p & MASK_CHAR) * radix + carry;
  1622.           *p = work & MASK_CHAR;
  1623.           carry = work >> BITS_PER_CHAR;
  1624.         }
  1625.       if (carry)
  1626.         {
  1627.           grow_bignum();
  1628.           * bignum_high = carry & MASK_CHAR;
  1629.           know( (carry & ~ MASK_CHAR) == 0);
  1630.         }
  1631.     }
  1632.       length = bignum_high - bignum_low + 1;
  1633.       if (length > nbytes)
  1634.     {
  1635.       as_warn( "Most significant bits truncated in integer constant." );
  1636.     }
  1637.       else
  1638.     {
  1639.       register long int    leading_zeroes;
  1640.  
  1641.       for(leading_zeroes = nbytes - length;
  1642.           leading_zeroes;
  1643.           leading_zeroes --)
  1644.         {
  1645.           grow_bignum();
  1646.           * bignum_high = 0;
  1647.         }
  1648.     }
  1649.       if (! need_pass_2)
  1650.     {
  1651.       p = frag_more (nbytes);
  1652.       bcopy (bignum_low, p, (int)nbytes);
  1653.     }
  1654.       /* C contains character after number. */
  1655.       SKIP_WHITESPACE();
  1656.       c = * input_line_pointer;
  1657.       /* C contains 1st non-blank character after number. */
  1658.     }
  1659.   demand_empty_rest_of_line();
  1660. }                /* big_cons() */
  1661.  
  1662. static void
  1663. grow_bignum()            /* Extend bignum by 1 char. */
  1664. {
  1665.   register long int    length;
  1666.  
  1667.   bignum_high ++;
  1668.   if (bignum_high >= bignum_limit)
  1669.     {
  1670.       length = bignum_limit - bignum_low;
  1671.       bignum_low = xrealloc (bignum_low, length + length);
  1672.       bignum_high = bignum_low + length;
  1673.       bignum_limit = bignum_low + length + length;
  1674.     }
  1675. }                /* grow_bignum(); */
  1676.  
  1677. /*
  1678.  *            float_cons()
  1679.  *
  1680.  * CONStruct some more frag chars of .floats .ffloats etc.
  1681.  * Makes 0 or more new frags.
  1682.  * If need_pass_2 == TRUE, no frags are emitted.
  1683.  * This understands only floating literals, not expressions. Sorry.
  1684.  *
  1685.  * A floating constant is defined by atof_generic(), except it is preceded
  1686.  * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
  1687.  * reading, I decided to be incompatible. This always tries to give you
  1688.  * rounded bits to the precision of the pseudo-op. Former AS did premature
  1689.  * truncatation, restored noisy bits instead of trailing 0s AND gave you
  1690.  * a choice of 2 flavours of noise according to which of 2 floating-point
  1691.  * scanners you directed AS to use.
  1692.  *
  1693.  * In:    input_line_pointer -> whitespace before, or '0' of flonum.
  1694.  *
  1695.  */
  1696.  
  1697. void    /* JF was static, but can't be if VAX.C is goning to use it */
  1698. float_cons(float_type)        /* Worker to do .float etc statements. */
  1699.                 /* Clobbers input_line-pointer, checks end-of-line. */
  1700.      register float_type;    /* 'f':.ffloat ... 'F':.float ... */
  1701. {
  1702.   register char *    p;
  1703.   register char        c;
  1704.   int    length;    /* Number of chars in an object. */
  1705.   register char *    err;    /* Error from scanning floating literal. */
  1706.   char        temp [MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
  1707.  
  1708.   /*
  1709.    * The following awkward logic is to parse ZERO or more strings,
  1710.    * comma seperated. Recall an expression includes its leading &
  1711.    * trailing blanks. We fake a leading ',' if there is (supposed to
  1712.    * be) a 1st expression, and keep demanding 1 expression for each ','.
  1713.    */
  1714.   if (is_it_end_of_statement())
  1715.     {
  1716.       c = 0;            /* Skip loop. */
  1717.       ++ input_line_pointer;    /* -> past termintor. */
  1718.     }
  1719.   else
  1720.     {
  1721.       c = ',';            /* Do loop. */
  1722.     }
  1723.   while (c == ',')
  1724.     {
  1725.       /* input_line_pointer -> 1st char of a flonum (we hope!). */
  1726.       SKIP_WHITESPACE();
  1727.       /* Skip any 0{letter} that may be present. Don't even check if the
  1728.        * letter is legal. Someone may invent a "z" format and this routine
  1729.        * has no use for such information. Lusers beware: you get
  1730.        * diagnostics if your input is ill-conditioned.
  1731.        */
  1732.  
  1733.       if(input_line_pointer[0]=='0' && isalpha(input_line_pointer[1]))
  1734.       input_line_pointer+=2;
  1735.  
  1736.       err = md_atof (float_type, temp, &length);
  1737.       know( length <=  MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
  1738.       know( length > 0 );
  1739.       if (* err)
  1740.     {
  1741.       as_warn( "Bad floating literal: %s", err);
  1742.       ignore_rest_of_line();
  1743.       /* Input_line_pointer -> just after end-of-line. */
  1744.       c = 0;        /* Break out of loop. */
  1745.     }
  1746.       else
  1747.     {
  1748.       if ( ! need_pass_2)
  1749.         {
  1750.           p = frag_more (length);
  1751.           bcopy (temp, p, length);
  1752.         }
  1753.       SKIP_WHITESPACE();
  1754.       c = * input_line_pointer ++;
  1755.       /* C contains 1st non-white character after number. */
  1756.       /* input_line_pointer -> just after terminator (c). */
  1757.     }
  1758.     }
  1759.   -- input_line_pointer;        /* -> terminator (is not ','). */
  1760.   demand_empty_rest_of_line();
  1761. }                /* float_cons() */
  1762.  
  1763. /*
  1764.  *            stringer()
  1765.  *
  1766.  * We read 0 or more ',' seperated, double-quoted strings.
  1767.  *
  1768.  * Caller should have checked need_pass_2 is FALSE because we don't check it.
  1769.  */
  1770. static void
  1771. stringer(append_zero)        /* Worker to do .ascii etc statements. */
  1772.                 /* Checks end-of-line. */
  1773.      register int append_zero;    /* 0: don't append '\0', else 1 */
  1774. {
  1775.   /* register char *    p; JF unused */
  1776.   /* register int        length; JF unused */    /* Length of string we read, excluding */
  1777.                 /* trailing '\0' implied by closing quote. */
  1778.   /* register char *    where; JF unused */
  1779.   /* register fragS *    fragP; JF unused */
  1780.   register int c;
  1781.  
  1782.   /*
  1783.    * The following awkward logic is to parse ZERO or more strings,
  1784.    * comma seperated. Recall a string expression includes spaces
  1785.    * before the opening '\"' and spaces after the closing '\"'.
  1786.    * We fake a leading ',' if there is (supposed to be)
  1787.    * a 1st, expression. We keep demanding expressions for each
  1788.    * ','.
  1789.    */
  1790.   if (is_it_end_of_statement())
  1791.     {
  1792.       c = 0;            /* Skip loop. */
  1793.       ++ input_line_pointer;    /* Compensate for end of loop. */
  1794.     }
  1795.   else
  1796.     {
  1797.       c = ',';            /* Do loop. */
  1798.     }
  1799.   for (   ;   c == ',';   c = *input_line_pointer ++)
  1800.     {
  1801.       SKIP_WHITESPACE();
  1802.       if (* input_line_pointer == '\"')
  1803.     {
  1804.       ++ input_line_pointer; /* -> 1st char of string. */
  1805.       while ( (c = next_char_of_string()) >= 0)
  1806.         {
  1807.           FRAG_APPEND_1_CHAR( c );
  1808.         }
  1809.       if (append_zero)
  1810.         {
  1811.           FRAG_APPEND_1_CHAR( 0 );
  1812.         }
  1813.       know( input_line_pointer [-1] == '\"' );
  1814.     }
  1815.       else
  1816.     {
  1817.       as_warn( "Expected \"-ed string" );
  1818.     }
  1819.       SKIP_WHITESPACE();
  1820.     }
  1821.   -- input_line_pointer;
  1822.   demand_empty_rest_of_line();
  1823. }                /* stringer() */
  1824.  
  1825. static int
  1826. next_char_of_string ()
  1827. {
  1828.   register int c;
  1829.  
  1830.   c = * input_line_pointer ++;
  1831.   switch (c)
  1832.     {
  1833.     case '\"':
  1834.       c = -1;
  1835.       break;
  1836.  
  1837.     case '\\':
  1838.       switch (c = * input_line_pointer ++)
  1839.     {
  1840.     case 'b':
  1841.       c = '\b';
  1842.       break;
  1843.  
  1844.     case 'f':
  1845.       c = '\f';
  1846.       break;
  1847.  
  1848.     case 'n':
  1849.       c = '\n';
  1850.       break;
  1851.  
  1852.     case 'r':
  1853.       c = '\r';
  1854.       break;
  1855.  
  1856.     case 't':
  1857.       c = '\t';
  1858.       break;
  1859.  
  1860.     case '\\':
  1861.     case '"':
  1862.       break;        /* As itself. */
  1863.  
  1864.     case '0':
  1865.     case '1':
  1866.     case '2':
  1867.     case '3':
  1868.     case '4':
  1869.     case '5':
  1870.     case '6':
  1871.     case '7':
  1872.     case '8':
  1873.     case '9':
  1874.       {
  1875.         long int number;
  1876.  
  1877.         for (number = 0;   isdigit(c);   c = * input_line_pointer ++)
  1878.           {
  1879.         number = number * 8 + c - '0';
  1880.           }
  1881.         c = number;
  1882.       }
  1883.       -- input_line_pointer;
  1884.       break;
  1885.  
  1886.     case '\n':
  1887. /*      as_fatal( "Unterminated string - use app!" ); */
  1888. /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
  1889.       c = '\n';
  1890.       break;
  1891.  
  1892.     default:
  1893.       as_warn( "Bad escaped character in string, '?' assumed" );
  1894.       c = '?';
  1895.       break;
  1896.     }
  1897.       break;
  1898.  
  1899.     default:
  1900.       break;
  1901.     }
  1902.   return (c);
  1903. }
  1904.  
  1905. static segT
  1906. get_segmented_expression ( expP )
  1907.      register expressionS *    expP;
  1908. {
  1909.   register segT        retval;
  1910.  
  1911.   if ( (retval = expression( expP )) == SEG_PASS1 || retval == SEG_NONE || retval == SEG_BIG )
  1912.     {
  1913.       as_warn("Expected address expression: absolute 0 assumed");
  1914.       retval = expP -> X_seg = SEG_ABSOLUTE;
  1915.       expP -> X_add_number   = 0;
  1916.       expP -> X_add_symbol   = expP -> X_subtract_symbol = 0;
  1917.     }
  1918.   return (retval);        /* SEG_ ABSOLUTE,UNKNOWN,DATA,TEXT,BSS */
  1919. }
  1920.  
  1921. static segT
  1922. get_known_segmented_expression ( expP )
  1923.      register expressionS *    expP;
  1924. {
  1925.   register segT        retval;
  1926.   register char *    name1;
  1927.   register char *    name2;
  1928.  
  1929.   if (   (retval = get_segmented_expression (expP)) == SEG_UNKNOWN
  1930.       )
  1931.     {
  1932.       name1 = expP -> X_add_symbol ? expP -> X_add_symbol -> sy_name : "";
  1933.       name2 = expP -> X_subtract_symbol ? expP -> X_subtract_symbol -> sy_name : "";
  1934.       if ( name1 && name2 )
  1935.     {
  1936.       as_warn("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.",
  1937.           name1, name2);
  1938.     }
  1939.       else
  1940.     {
  1941.       as_warn("Symbol \"%s\" undefined: absolute 0 assumed.",
  1942.           name1 ? name1 : name2);
  1943.     }
  1944.       retval = expP -> X_seg = SEG_ABSOLUTE;
  1945.       expP -> X_add_number   = 0;
  1946.       expP -> X_add_symbol   = expP -> X_subtract_symbol = NULL;
  1947.     }
  1948.  know(   retval == SEG_ABSOLUTE || retval == SEG_DATA || retval == SEG_TEXT || retval == SEG_BSS || retval == SEG_DIFFERENCE );
  1949.   return (retval);
  1950. }                /* get_known_segmented_expression() */
  1951.  
  1952.  
  1953.  
  1954. /* static */ long int /* JF was static, but can't be if the MD pseudos are to use it */
  1955. get_absolute_expression ()
  1956. {
  1957.   expressionS    exp;
  1958.   register segT s;
  1959.  
  1960.   if ( (s = expression(& exp)) != SEG_ABSOLUTE )
  1961.     {
  1962.       if ( s != SEG_NONE )
  1963.     {
  1964.       as_warn( "Bad Absolute Expression, absolute 0 assumed.");
  1965.     }
  1966.       exp . X_add_number = 0;
  1967.     }
  1968.   return (exp . X_add_number);
  1969. }
  1970.  
  1971. static char            /* return terminator */
  1972. get_absolute_expression_and_terminator( val_pointer)
  1973.      long int *        val_pointer; /* return value of expression */
  1974. {
  1975.   * val_pointer = get_absolute_expression ();
  1976.   return ( * input_line_pointer ++ );
  1977. }
  1978.  
  1979. /*
  1980.  *            demand_copy_C_string()
  1981.  *
  1982.  * Like demand_copy_string, but return NULL if the string contains any '\0's.
  1983.  * Give a warning if that happens.
  1984.  */
  1985. static char *
  1986. demand_copy_C_string (len_pointer)
  1987.      int *    len_pointer;
  1988. {
  1989.   register char *    s;
  1990.  
  1991.   if (s = demand_copy_string (len_pointer))
  1992.     {
  1993.       register int    len;
  1994.  
  1995.       for (len = * len_pointer;
  1996.        len > 0;
  1997.        len--)
  1998.     {
  1999.       if (* s == 0)
  2000.         {
  2001.           s = 0;
  2002.           len = 1;
  2003.           * len_pointer = 0;
  2004.           as_warn( "This string may not contain \'\\0\'" );
  2005.         }
  2006.     }
  2007.     }
  2008.   return (s);
  2009. }
  2010.  
  2011. /*
  2012.  *            demand_copy_string()
  2013.  *
  2014.  * Demand string, but return a safe (=private) copy of the string.
  2015.  * Return NULL if we can't read a string here.
  2016.  */
  2017. static char *
  2018. demand_copy_string (lenP)
  2019.      int *    lenP;
  2020. {
  2021.   register int        c;
  2022.   register int        len;
  2023.        char *    retval;
  2024.  
  2025.   len = 0;
  2026.   SKIP_WHITESPACE();
  2027.   if (* input_line_pointer == '\"')
  2028.     {
  2029.       input_line_pointer ++;    /* Skip opening quote. */
  2030.       while ( (c = next_char_of_string()) >= 0 ) {
  2031.       obstack_1grow ( ¬es, c );
  2032.       len ++;
  2033.     }
  2034.       /* JF this next line is so demand_copy_C_string will return a null
  2035.          termanated string. */
  2036.       obstack_1grow(¬es,'\0');
  2037.       retval=obstack_finish( ¬es);
  2038.   } else {
  2039.       as_warn( "Missing string" );
  2040.       retval = NULL;
  2041.       ignore_rest_of_line ();
  2042.     }
  2043.   * lenP = len;
  2044.   return (retval);
  2045. }
  2046.  
  2047. /*
  2048.  *        is_it_end_of_statement()
  2049.  *
  2050.  * In:    Input_line_pointer -> next character.
  2051.  *
  2052.  * Do:    Skip input_line_pointer over all whitespace.
  2053.  *
  2054.  * Out:    TRUE if input_line_pointer -> end-of-line.
  2055.  */
  2056. static int
  2057. is_it_end_of_statement()
  2058. {
  2059.   SKIP_WHITESPACE();
  2060.   return (is_end_of_line [* input_line_pointer]);
  2061. }
  2062.  
  2063. void
  2064. equals(sym_name)
  2065. char *sym_name;
  2066. {
  2067.   register struct symbol * symbolP; /* symbol we are working with */
  2068.  
  2069.   input_line_pointer++;
  2070.   if(*input_line_pointer=='=')
  2071.     input_line_pointer++;
  2072.  
  2073.   while(*input_line_pointer==' ' || *input_line_pointer=='\t')
  2074.     input_line_pointer++;
  2075.  
  2076.   if(sym_name[0]=='.' && sym_name[1]=='\0') {
  2077.     /* Turn '. = mumble' into a .org mumble */
  2078.     register segT segment;
  2079.     expressionS exp;
  2080.     register char *p;
  2081.  
  2082.     segment = get_known_segmented_expression(& exp);
  2083.     if ( ! need_pass_2 ) {
  2084.       if (segment != now_seg && segment != SEG_ABSOLUTE)
  2085.         as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  2086.                 seg_name [(int) segment], seg_name [(int) now_seg]);
  2087.       p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
  2088.                     exp.X_add_number, (char *)0);
  2089.       * p = 0;
  2090.     } /* if (ok to make frag) */
  2091.   } else {
  2092.     symbolP=symbol_find_or_make(sym_name);
  2093.     pseudo_set(symbolP);
  2094.   }
  2095. }
  2096.  
  2097. /* end: read.c */
  2098.