home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0400 / CCE_0457.ZIP / CCE_0457 / GASSRC03.ZOO / read.c < prev    next >
C/C++ Source or Header  |  1992-05-02  |  56KB  |  2,104 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. #ifdef CANON
  1121.     if ( temp_repeat == 0 ) {
  1122.         ignore_rest_of_line();
  1123.         return;
  1124.     }
  1125. #endif CANON
  1126.     if ( temp_repeat <= 0 ) {
  1127.         as_warn("Repeat < 0, .space ignored");
  1128.         ignore_rest_of_line();
  1129.         return;
  1130.     }
  1131.     if ( ! need_pass_2 ) {
  1132.         p = frag_var (rs_fill, 1, 1, (relax_substateT)0, (symbolS *)0,
  1133.  temp_repeat, (char *)0);
  1134.         * p = temp_fill;
  1135.     }
  1136.     demand_empty_rest_of_line();
  1137. }
  1138.  
  1139. void
  1140. s_text()
  1141. {
  1142.     register int temp;
  1143.  
  1144.     temp = get_absolute_expression ();
  1145.     subseg_new (SEG_TEXT, (subsegT)temp);
  1146.     demand_empty_rest_of_line();
  1147. }
  1148.  
  1149.  
  1150. /*( JF was static, but can't be if machine dependent pseudo-ops are to use it */
  1151.  
  1152. void
  1153. demand_empty_rest_of_line()
  1154. {
  1155.   SKIP_WHITESPACE();
  1156.   if ( is_end_of_line [* input_line_pointer] )
  1157.     {
  1158.       input_line_pointer ++;
  1159.     }
  1160.   else
  1161.     {
  1162.       ignore_rest_of_line();
  1163.     }
  1164.                 /* Return having already swallowed end-of-line. */
  1165. }                /* Return pointing just after end-of-line. */
  1166.  
  1167.  
  1168. void
  1169. ignore_rest_of_line()        /* For suspect lines: gives warning. */
  1170. {
  1171.   if ( ! is_end_of_line [* input_line_pointer])
  1172.     {
  1173.       as_warn("Rest of line ignored. 1st junk character valued %d (%c)."
  1174.           , * input_line_pointer, *input_line_pointer);
  1175.       while (   input_line_pointer < buffer_limit
  1176.          && ! is_end_of_line [* input_line_pointer] )
  1177.     {
  1178.       input_line_pointer ++;
  1179.     }
  1180.     }
  1181.   input_line_pointer ++;    /* Return pointing just after end-of-line. */
  1182.   know( is_end_of_line [input_line_pointer [-1]] );
  1183. }
  1184.  
  1185. /*
  1186.  *            stab()
  1187.  *
  1188.  * Handle .stabX directives, which used to be open-coded.
  1189.  * So much creeping featurism overloaded the semantics that we decided
  1190.  * to put all .stabX thinking in one place. Here.
  1191.  *
  1192.  * We try to make any .stabX directive legal. Other people's AS will often
  1193.  * do assembly-time consistency checks: eg assigning meaning to n_type bits
  1194.  * and "protecting" you from setting them to certain values. (They also zero
  1195.  * certain bits before emitting symbols. Tut tut.)
  1196.  *
  1197.  * If an expression is not absolute we either gripe or use the relocation
  1198.  * information. Other people's assemblers silently forget information they
  1199.  * don't need and invent information they need that you didn't supply.
  1200.  *
  1201.  * .stabX directives always make a symbol table entry. It may be junk if
  1202.  * the rest of your .stabX directive is malformed.
  1203.  */
  1204. static void
  1205. stab (what)
  1206. int what;
  1207. {
  1208.   register symbolS *    symbolP;
  1209.   register char *    string;
  1210.        int        saved_type;
  1211.          int        length;
  1212.          int        goof;    /* TRUE if we have aborted. */
  1213.        long int    longint;
  1214.  
  1215. /*
  1216.  * Enter with input_line_pointer pointing past .stabX and any following
  1217.  * whitespace.
  1218.  */
  1219.     goof = FALSE; /* JF who forgot this?? */
  1220.     if (what == 's') {
  1221.         string = demand_copy_C_string (& length);
  1222.         SKIP_WHITESPACE();
  1223.         if (* input_line_pointer == ',')
  1224.             input_line_pointer ++;
  1225.         else {
  1226.             as_warn( "I need a comma after symbol's name" );
  1227.             goof = TRUE;
  1228.         }
  1229.     } else
  1230.         string = "";
  1231.  
  1232. /*
  1233.  * Input_line_pointer->after ','.  String -> symbol name.
  1234.  */
  1235.     if (! goof) {
  1236.         symbolP = symbol_new (string, 0,0,0,0,(struct frag *)0);
  1237.         switch (what) {
  1238.         case 'd':
  1239.             symbolP->sy_name = NULL; /* .stabd feature. */
  1240.             symbolP->sy_value = obstack_next_free(& frags) - frag_now->fr_literal;
  1241.             symbolP->sy_frag = frag_now;
  1242.             break;
  1243.  
  1244.         case 'n':
  1245.             symbolP->sy_frag = &zero_address_frag;
  1246.             break;
  1247.  
  1248.         case 's':
  1249.             symbolP->sy_frag = & zero_address_frag;
  1250.             break;
  1251.  
  1252.         default:
  1253.             BAD_CASE( what );
  1254.             break;
  1255.         }
  1256.         if (get_absolute_expression_and_terminator (& longint) == ',')
  1257.             symbolP->sy_type = saved_type = longint;
  1258.         else {
  1259.             as_warn( "I want a comma after the n_type expression" );
  1260.             goof = TRUE;
  1261.             input_line_pointer --; /* Backup over a non-',' char. */
  1262.         }
  1263.     }
  1264.     if (! goof) {
  1265.         if (get_absolute_expression_and_terminator (& longint) == ',')
  1266.             symbolP->sy_other = longint;
  1267.         else {
  1268.             as_warn( "I want a comma after the n_other expression" );
  1269.             goof = TRUE;
  1270.             input_line_pointer --; /* Backup over a non-',' char. */
  1271.         }
  1272.     }
  1273.     if (! goof) {
  1274.         symbolP->sy_desc = get_absolute_expression ();
  1275.         if (what == 's' || what == 'n') {
  1276.             if (* input_line_pointer != ',') {
  1277.                 as_warn( "I want a comma after the n_desc expression" );
  1278.                 goof = TRUE;
  1279.             } else {
  1280.                 input_line_pointer ++;
  1281.             }
  1282.         }
  1283.     }
  1284.     if ((! goof) && (what=='s' || what=='n')) {
  1285.         pseudo_set (symbolP);
  1286.         symbolP->sy_type = saved_type;
  1287.     }
  1288.     if (goof)
  1289.         ignore_rest_of_line ();
  1290.     else
  1291.         demand_empty_rest_of_line ();
  1292. }
  1293.  
  1294. /*
  1295.  *            pseudo_set()
  1296.  *
  1297.  * In:    Pointer to a symbol.
  1298.  *    Input_line_pointer -> expression.
  1299.  *
  1300.  * Out:    Input_line_pointer -> just after any whitespace after expression.
  1301.  *    Tried to set symbol to value of expression.
  1302.  *    Will change sy_type, sy_value, sy_frag;
  1303.  *    May set need_pass_2 == TRUE.
  1304.  */
  1305. static void
  1306. pseudo_set (symbolP)
  1307.      symbolS *    symbolP;
  1308. {
  1309.   expressionS    exp;
  1310.   register segT    segment;
  1311.   int ext;
  1312.  
  1313.   know( symbolP );        /* NULL pointer is logic error. */
  1314.   ext=(symbolP->sy_type&N_EXT);
  1315.   if ((segment = expression( & exp )) == SEG_NONE)
  1316.     {
  1317.       as_warn( "Missing expression: absolute 0 assumed" );
  1318.       exp . X_seg        = SEG_ABSOLUTE;
  1319.       exp . X_add_number    = 0;
  1320.     }
  1321.   switch (segment)
  1322.     {
  1323.     case SEG_BIG:
  1324.       as_warn( "%s number illegal. Absolute 0 assumed.",
  1325.           exp . X_add_number > 0 ? "Bignum" : "Floating-Point" );
  1326.       symbolP -> sy_type = N_ABS | ext;
  1327.       symbolP -> sy_value = 0;
  1328.       symbolP -> sy_frag = & zero_address_frag;
  1329.       break;
  1330.  
  1331.     case SEG_NONE:
  1332.       as_warn("No expression:  Using absolute 0");
  1333.       symbolP -> sy_type = N_ABS | ext;
  1334.       symbolP -> sy_value = 0;
  1335.       symbolP -> sy_frag = & zero_address_frag;
  1336.       break;
  1337.  
  1338.     case SEG_DIFFERENCE:
  1339.       if (exp.X_add_symbol && exp.X_subtract_symbol
  1340.           &&    (exp.X_add_symbol->sy_type & N_TYPE)
  1341.          == (exp.X_subtract_symbol->sy_type & N_TYPE)) {
  1342.     if(exp.X_add_symbol->sy_frag != exp.X_subtract_symbol->sy_frag) {
  1343.       as_bad("Unknown expression: symbols %s and %s are in different frags.",exp.X_add_symbol->sy_name, exp.X_subtract_symbol->sy_name);
  1344.       need_pass_2++;
  1345.     }
  1346.     exp.X_add_number+=exp.X_add_symbol->sy_value - exp.X_subtract_symbol->sy_value;
  1347.       } else
  1348.     as_warn( "Complex expression. Absolute segment assumed." );
  1349.     case SEG_ABSOLUTE:
  1350.       symbolP -> sy_type = N_ABS | ext;
  1351.       symbolP -> sy_value = exp . X_add_number;
  1352.       symbolP -> sy_frag = & zero_address_frag;
  1353.       break;
  1354.  
  1355.     case SEG_DATA:
  1356.     case SEG_TEXT:
  1357.     case SEG_BSS:
  1358.       symbolP -> sy_type = seg_N_TYPE [(int) segment] | ext;
  1359.       symbolP -> sy_value= exp . X_add_number + exp . X_add_symbol -> sy_value;
  1360.       symbolP -> sy_frag = exp . X_add_symbol -> sy_frag;
  1361.       break;
  1362.       
  1363.     case SEG_PASS1:        /* Not an error. Just try another pass. */
  1364.       symbolP->sy_forward=exp.X_add_symbol;
  1365.       as_warn("Unknown expression");
  1366.       know( need_pass_2 == TRUE );
  1367.       break;
  1368.       
  1369.     case SEG_UNKNOWN:
  1370.       symbolP->sy_forward=exp.X_add_symbol;
  1371.       /* as_warn("unknown symbol"); */
  1372.       /* need_pass_2 = TRUE; */
  1373.       break;
  1374.       
  1375.     default:
  1376.       BAD_CASE( segment );
  1377.       break;
  1378.     }
  1379. }
  1380.  
  1381. /*
  1382.  *            cons()
  1383.  *
  1384.  * CONStruct more frag of .bytes, or .words etc.
  1385.  * Should need_pass_2 be TRUE then emit no frag(s).
  1386.  * This understands EXPRESSIONS, as opposed to big_cons().
  1387.  *
  1388.  * Bug (?)
  1389.  *
  1390.  * This has a split personality. We use expression() to read the
  1391.  * value. We can detect if the value won't fit in a byte or word.
  1392.  * But we can't detect if expression() discarded significant digits
  1393.  * in the case of a long. Not worth the crocks required to fix it.
  1394.  */
  1395. void
  1396. cons(nbytes)            /* worker to do .byte etc statements */
  1397.                 /* clobbers input_line_pointer, checks */
  1398.                 /* end-of-line. */
  1399.      register int    nbytes;    /* 1=.byte, 2=.word, 4=.long */
  1400. {
  1401.   register char        c;
  1402.   register long int    mask;    /* High-order bits we will left-truncate, */
  1403.                 /* but includes sign bit also. */
  1404.   register long int     get;    /* what we get */
  1405.   register long int    use;    /* get after truncation. */
  1406.   register long int    unmask;    /* what bits we will store */
  1407.   register char *    p;
  1408.   register segT        segment;
  1409.            expressionS    exp;
  1410. #ifdef NS32K
  1411.   void fix_new_ns32k();
  1412. #else
  1413.   void    fix_new();
  1414. #endif
  1415.  
  1416.   /*
  1417.    * Input_line_pointer -> 1st char after pseudo-op-code and could legally
  1418.    * be a end-of-line. (Or, less legally an eof - which we cope with.)
  1419.    */
  1420.   /* JF << of >= number of bits in the object is undefined.  In particular
  1421.      SPARC (Sun 4) has problems */
  1422.   if(nbytes>=sizeof(long int))
  1423.     mask = 0;
  1424.   else 
  1425.     mask = ~0 << (BITS_PER_CHAR * nbytes); /* Don't store these bits. */
  1426.   unmask = ~ mask;        /* Do store these bits. */
  1427. #ifdef NEVER
  1428.   "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
  1429.   mask = ~ (unmask >> 1);    /* Includes sign bit now. */
  1430. #endif
  1431.   /*
  1432.    * The following awkward logic is to parse ZERO or more expressions,
  1433.    * comma seperated. Recall an expression includes its leading &
  1434.    * trailing blanks. We fake a leading ',' if there is (supposed to
  1435.    * be) a 1st expression, and keep demanding 1 expression for each ','.
  1436.    */
  1437.   if (is_it_end_of_statement())
  1438.     {
  1439.       c = 0;            /* Skip loop. */
  1440.       input_line_pointer ++;    /* Matches end-of-loop 'correction'. */
  1441.     }
  1442.   else
  1443.       c = ',';            /* Do loop. */
  1444.   while ( c == ','  )
  1445.     {
  1446.       segment = expression( &exp ); /* At least scan over the expression. */
  1447.       if ( ! need_pass_2 )
  1448.     {            /* Still worthwhile making frags. */
  1449.  
  1450.       /* Don't call this if we are going to junk this pass anyway! */
  1451.       know( segment != SEG_PASS1 );
  1452.  
  1453.       if ( segment == SEG_DIFFERENCE && exp . X_add_symbol == NULL )
  1454.         {
  1455.           as_warn( "Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.",
  1456.               exp . X_subtract_symbol -> sy_name,
  1457.               seg_name [(int) N_TYPE_seg [exp . X_subtract_symbol -> sy_type & N_TYPE]]);
  1458.           segment = SEG_ABSOLUTE;
  1459.           /* Leave exp . X_add_number alone. */
  1460.         }
  1461.       p = frag_more (nbytes);
  1462.       switch (segment)
  1463.         {
  1464.         case SEG_BIG:
  1465.           as_warn( "%s number illegal. Absolute 0 assumed.",
  1466.               exp . X_add_number > 0 ? "Bignum" : "Floating-Point");
  1467.           md_number_to_chars (p, (long)0, nbytes);
  1468.           break;
  1469.  
  1470.         case SEG_NONE:
  1471.           as_warn( "0 assumed for missing expression" );
  1472.           exp . X_add_number = 0;
  1473.           know( exp . X_add_symbol == NULL );
  1474.           /* fall into SEG_ABSOLUTE */
  1475.         case SEG_ABSOLUTE:
  1476.           get = exp . X_add_number;
  1477.           use = get & unmask;
  1478.           if ( (get & mask) && (get & mask) != mask )
  1479.         {        /* Leading bits contain both 0s & 1s. */
  1480.           as_warn("Value x%x truncated to x%x.", get, use);
  1481.         }
  1482.           md_number_to_chars (p, use, nbytes); /* put bytes in right order. */
  1483.           break;
  1484.  
  1485.         case SEG_DIFFERENCE:
  1486. #ifndef WORKING_DOT_WORD
  1487.           if(nbytes==2) {
  1488.         struct broken_word *x;
  1489.  
  1490.         x=(struct broken_word *)xmalloc(sizeof(struct broken_word));
  1491.         x->next_broken_word=broken_words;
  1492.         broken_words=x;
  1493.         x->frag=frag_now;
  1494.         x->word_goes_here=p;
  1495.         x->dispfrag=0;
  1496.         x->add=exp.X_add_symbol;
  1497.         x->sub=exp.X_subtract_symbol;
  1498.         x->addnum=exp.X_add_number;
  1499.         x->added=0;
  1500.         new_broken_words++;
  1501.         break;
  1502.           }
  1503.           /* Else Fall through into. . . */
  1504. #endif
  1505.         case SEG_BSS:
  1506.         case SEG_UNKNOWN:
  1507.         case SEG_TEXT:
  1508.         case SEG_DATA:
  1509. #if defined(SPARC) || defined(I860)
  1510.           fix_new (frag_now, p - frag_now -> fr_literal, nbytes,
  1511.                exp . X_add_symbol, exp . X_subtract_symbol,
  1512.                exp . X_add_number, 0, RELOC_32);
  1513. #endif
  1514. #ifdef NS32K
  1515.           fix_new_ns32k (frag_now, p - frag_now -> fr_literal, nbytes,
  1516.                exp . X_add_symbol, exp . X_subtract_symbol,
  1517.                exp . X_add_number, 0, 0, 2, 0, 0);
  1518. #endif
  1519. #if !defined(SPARC) && !defined(NS32K) && !defined(I860)
  1520.           fix_new (frag_now, p - frag_now -> fr_literal, nbytes,
  1521.                exp . X_add_symbol, exp . X_subtract_symbol,
  1522.                exp . X_add_number, 0);
  1523. #endif
  1524.           break;
  1525.  
  1526.         default:
  1527.           BAD_CASE( segment );
  1528.           break;
  1529.         }            /* switch(segment) */
  1530.     }            /* if(!need_pass_2) */
  1531.       c = * input_line_pointer ++;
  1532.     }                /* while(c==',') */
  1533.   input_line_pointer --;    /* Put terminator back into stream. */
  1534.   demand_empty_rest_of_line();
  1535. }                /* cons() */
  1536.  
  1537. /*
  1538.  *            big_cons()
  1539.  *
  1540.  * CONStruct more frag(s) of .quads, or .octa etc.
  1541.  * Makes 0 or more new frags.
  1542.  * If need_pass_2 == TRUE, generate no frag.
  1543.  * This understands only bignums, not expressions. Cons() understands
  1544.  * expressions.
  1545.  *
  1546.  * Constants recognised are '0...'(octal) '0x...'(hex) '...'(decimal).
  1547.  *
  1548.  * This creates objects with struct obstack_control objs, destroying
  1549.  * any context objs held about a partially completed object. Beware!
  1550.  *
  1551.  *
  1552.  * I think it sucks to have 2 different types of integers, with 2
  1553.  * routines to read them, store them etc.
  1554.  * It would be nicer to permit bignums in expressions and only
  1555.  * complain if the result overflowed. However, due to "efficiency"...
  1556.  */
  1557. void
  1558. big_cons(nbytes)        /* worker to do .quad etc statements */
  1559.                 /* clobbers input_line_pointer, checks */
  1560.                 /* end-of-line. */
  1561.      register int    nbytes;    /* 8=.quad 16=.octa ... */
  1562. {
  1563.   register char        c;    /* input_line_pointer -> c. */
  1564.   register int        radix;
  1565.   register long int    length;    /* Number of chars in an object. */
  1566.   register int        digit;    /* Value of 1 digit. */
  1567.   register int        carry;    /* For multi-precision arithmetic. */
  1568.   register int        work;    /* For multi-precision arithmetic. */
  1569.   register char *    p;    /* For multi-precision arithmetic. */
  1570.  
  1571.   extern char hex_value[];    /* In hex_value.c. */
  1572.  
  1573.   /*
  1574.    * The following awkward logic is to parse ZERO or more strings,
  1575.    * comma seperated. Recall an expression includes its leading &
  1576.    * trailing blanks. We fake a leading ',' if there is (supposed to
  1577.    * be) a 1st expression, and keep demanding 1 expression for each ','.
  1578.    */
  1579.   if (is_it_end_of_statement())
  1580.     {
  1581.       c = 0;            /* Skip loop. */
  1582.     }
  1583.   else
  1584.     {
  1585.       c = ',';            /* Do loop. */
  1586.       -- input_line_pointer;
  1587.     }
  1588.   while (c == ',')
  1589.     {
  1590.       ++ input_line_pointer;
  1591.       SKIP_WHITESPACE();
  1592.       c = * input_line_pointer;
  1593.       /* C contains 1st non-blank character of what we hope is a number. */
  1594.       if (c == '0')
  1595.     {
  1596.       c = * ++ input_line_pointer;
  1597.       if (c == 'x' || c=='X')
  1598.         {
  1599.           c = * ++ input_line_pointer;
  1600.           radix = 16;
  1601.         }
  1602.       else
  1603.         {
  1604.           radix = 8;
  1605.         }
  1606.     }
  1607.       else
  1608.     {
  1609.       radix = 10;
  1610.     }
  1611.       /*
  1612.        * This feature (?) is here to stop people worrying about
  1613.        * mysterious zero constants: which is what they get when
  1614.        * they completely omit digits.
  1615.        */
  1616.       if (hex_value[c] >= radix)
  1617.     {
  1618.       as_warn( "Missing digits. 0 assumed." );
  1619.     }
  1620.       bignum_high = bignum_low - 1; /* Start constant with 0 chars. */
  1621.       for(   ;   (digit = hex_value [c]) < radix;   c = * ++ input_line_pointer)
  1622.     {
  1623.       /* Multiply existing number by radix, then add digit. */
  1624.       carry = digit;
  1625.       for (p=bignum_low;   p <= bignum_high;   p++)
  1626.         {
  1627.           work = (*p & MASK_CHAR) * radix + carry;
  1628.           *p = work & MASK_CHAR;
  1629.           carry = work >> BITS_PER_CHAR;
  1630.         }
  1631.       if (carry)
  1632.         {
  1633.           grow_bignum();
  1634.           * bignum_high = carry & MASK_CHAR;
  1635.           know( (carry & ~ MASK_CHAR) == 0);
  1636.         }
  1637.     }
  1638.       length = bignum_high - bignum_low + 1;
  1639.       if (length > nbytes)
  1640.     {
  1641.       as_warn( "Most significant bits truncated in integer constant." );
  1642.     }
  1643.       else
  1644.     {
  1645.       register long int    leading_zeroes;
  1646.  
  1647.       for(leading_zeroes = nbytes - length;
  1648.           leading_zeroes;
  1649.           leading_zeroes --)
  1650.         {
  1651.           grow_bignum();
  1652.           * bignum_high = 0;
  1653.         }
  1654.     }
  1655.       if (! need_pass_2)
  1656.     {
  1657.       p = frag_more (nbytes);
  1658.       bcopy (bignum_low, p, (int)nbytes);
  1659.     }
  1660.       /* C contains character after number. */
  1661.       SKIP_WHITESPACE();
  1662.       c = * input_line_pointer;
  1663.       /* C contains 1st non-blank character after number. */
  1664.     }
  1665.   demand_empty_rest_of_line();
  1666. }                /* big_cons() */
  1667.  
  1668. static void
  1669. grow_bignum()            /* Extend bignum by 1 char. */
  1670. {
  1671.   register long int    length;
  1672.  
  1673.   bignum_high ++;
  1674.   if (bignum_high >= bignum_limit)
  1675.     {
  1676.       length = bignum_limit - bignum_low;
  1677.       bignum_low = xrealloc (bignum_low, length + length);
  1678.       bignum_high = bignum_low + length;
  1679.       bignum_limit = bignum_low + length + length;
  1680.     }
  1681. }                /* grow_bignum(); */
  1682.  
  1683. /*
  1684.  *            float_cons()
  1685.  *
  1686.  * CONStruct some more frag chars of .floats .ffloats etc.
  1687.  * Makes 0 or more new frags.
  1688.  * If need_pass_2 == TRUE, no frags are emitted.
  1689.  * This understands only floating literals, not expressions. Sorry.
  1690.  *
  1691.  * A floating constant is defined by atof_generic(), except it is preceded
  1692.  * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
  1693.  * reading, I decided to be incompatible. This always tries to give you
  1694.  * rounded bits to the precision of the pseudo-op. Former AS did premature
  1695.  * truncatation, restored noisy bits instead of trailing 0s AND gave you
  1696.  * a choice of 2 flavours of noise according to which of 2 floating-point
  1697.  * scanners you directed AS to use.
  1698.  *
  1699.  * In:    input_line_pointer -> whitespace before, or '0' of flonum.
  1700.  *
  1701.  */
  1702.  
  1703. void    /* JF was static, but can't be if VAX.C is goning to use it */
  1704. float_cons(float_type)        /* Worker to do .float etc statements. */
  1705.                 /* Clobbers input_line-pointer, checks end-of-line. */
  1706.      register float_type;    /* 'f':.ffloat ... 'F':.float ... */
  1707. {
  1708.   register char *    p;
  1709.   register char        c;
  1710.   int    length;    /* Number of chars in an object. */
  1711.   register char *    err;    /* Error from scanning floating literal. */
  1712.   char        temp [MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
  1713.  
  1714.   /*
  1715.    * The following awkward logic is to parse ZERO or more strings,
  1716.    * comma seperated. Recall an expression includes its leading &
  1717.    * trailing blanks. We fake a leading ',' if there is (supposed to
  1718.    * be) a 1st expression, and keep demanding 1 expression for each ','.
  1719.    */
  1720.   if (is_it_end_of_statement())
  1721.     {
  1722.       c = 0;            /* Skip loop. */
  1723.       ++ input_line_pointer;    /* -> past termintor. */
  1724.     }
  1725.   else
  1726.     {
  1727.       c = ',';            /* Do loop. */
  1728.     }
  1729.   while (c == ',')
  1730.     {
  1731.       /* input_line_pointer -> 1st char of a flonum (we hope!). */
  1732.       SKIP_WHITESPACE();
  1733.       /* Skip any 0{letter} that may be present. Don't even check if the
  1734.        * letter is legal. Someone may invent a "z" format and this routine
  1735.        * has no use for such information. Lusers beware: you get
  1736.        * diagnostics if your input is ill-conditioned.
  1737.        */
  1738.  
  1739.       if(input_line_pointer[0]=='0' && isalpha(input_line_pointer[1]))
  1740.       input_line_pointer+=2;
  1741.  
  1742.       err = md_atof (float_type, temp, &length);
  1743.       know( length <=  MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
  1744.       know( length > 0 );
  1745.       if (* err)
  1746.     {
  1747.       as_warn( "Bad floating literal: %s", err);
  1748.       ignore_rest_of_line();
  1749.       /* Input_line_pointer -> just after end-of-line. */
  1750.       c = 0;        /* Break out of loop. */
  1751.     }
  1752.       else
  1753.     {
  1754.       if ( ! need_pass_2)
  1755.         {
  1756.           p = frag_more (length);
  1757.           bcopy (temp, p, length);
  1758.         }
  1759.       SKIP_WHITESPACE();
  1760.       c = * input_line_pointer ++;
  1761.       /* C contains 1st non-white character after number. */
  1762.       /* input_line_pointer -> just after terminator (c). */
  1763.     }
  1764.     }
  1765.   -- input_line_pointer;        /* -> terminator (is not ','). */
  1766.   demand_empty_rest_of_line();
  1767. }                /* float_cons() */
  1768.  
  1769. /*
  1770.  *            stringer()
  1771.  *
  1772.  * We read 0 or more ',' seperated, double-quoted strings.
  1773.  *
  1774.  * Caller should have checked need_pass_2 is FALSE because we don't check it.
  1775.  */
  1776. static void
  1777. stringer(append_zero)        /* Worker to do .ascii etc statements. */
  1778.                 /* Checks end-of-line. */
  1779.      register int append_zero;    /* 0: don't append '\0', else 1 */
  1780. {
  1781.   /* register char *    p; JF unused */
  1782.   /* register int        length; JF unused */    /* Length of string we read, excluding */
  1783.                 /* trailing '\0' implied by closing quote. */
  1784.   /* register char *    where; JF unused */
  1785.   /* register fragS *    fragP; JF unused */
  1786.   register int c;
  1787.  
  1788.   /*
  1789.    * The following awkward logic is to parse ZERO or more strings,
  1790.    * comma seperated. Recall a string expression includes spaces
  1791.    * before the opening '\"' and spaces after the closing '\"'.
  1792.    * We fake a leading ',' if there is (supposed to be)
  1793.    * a 1st, expression. We keep demanding expressions for each
  1794.    * ','.
  1795.    */
  1796.   if (is_it_end_of_statement())
  1797.     {
  1798.       c = 0;            /* Skip loop. */
  1799.       ++ input_line_pointer;    /* Compensate for end of loop. */
  1800.     }
  1801.   else
  1802.     {
  1803.       c = ',';            /* Do loop. */
  1804.     }
  1805.   for (   ;   c == ',';   c = *input_line_pointer ++)
  1806.     {
  1807.       SKIP_WHITESPACE();
  1808.       if (* input_line_pointer == '\"')
  1809.     {
  1810.       ++ input_line_pointer; /* -> 1st char of string. */
  1811.       while ( (c = next_char_of_string()) >= 0)
  1812.         {
  1813.           FRAG_APPEND_1_CHAR( c );
  1814.         }
  1815.       if (append_zero)
  1816.         {
  1817.           FRAG_APPEND_1_CHAR( 0 );
  1818.         }
  1819.       know( input_line_pointer [-1] == '\"' );
  1820.     }
  1821.       else
  1822.     {
  1823.       as_warn( "Expected \"-ed string" );
  1824.     }
  1825.       SKIP_WHITESPACE();
  1826.     }
  1827.   -- input_line_pointer;
  1828.   demand_empty_rest_of_line();
  1829. }                /* stringer() */
  1830.  
  1831. static int
  1832. next_char_of_string ()
  1833. {
  1834.   register int c;
  1835.  
  1836.   c = * input_line_pointer ++;
  1837.   switch (c)
  1838.     {
  1839.     case '\"':
  1840.       c = -1;
  1841.       break;
  1842.  
  1843.     case '\\':
  1844.       switch (c = * input_line_pointer ++)
  1845.     {
  1846.     case 'b':
  1847.       c = '\b';
  1848.       break;
  1849.  
  1850.     case 'f':
  1851.       c = '\f';
  1852.       break;
  1853.  
  1854.     case 'n':
  1855.       c = '\n';
  1856.       break;
  1857.  
  1858.     case 'r':
  1859.       c = '\r';
  1860.       break;
  1861.  
  1862.     case 't':
  1863.       c = '\t';
  1864.       break;
  1865.  
  1866.     case '\\':
  1867.     case '"':
  1868.       break;        /* As itself. */
  1869.  
  1870.     case '0':
  1871.     case '1':
  1872.     case '2':
  1873.     case '3':
  1874.     case '4':
  1875.     case '5':
  1876.     case '6':
  1877.     case '7':
  1878.     case '8':
  1879.     case '9':
  1880.       {
  1881.         long int number;
  1882.  
  1883.         for (number = 0;   isdigit(c);   c = * input_line_pointer ++)
  1884.           {
  1885.         number = number * 8 + c - '0';
  1886.           }
  1887.         c = number;
  1888.       }
  1889.       -- input_line_pointer;
  1890.       break;
  1891.  
  1892.     case '\n':
  1893. /*      as_fatal( "Unterminated string - use app!" ); */
  1894. /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
  1895.       c = '\n';
  1896.       break;
  1897.  
  1898.     default:
  1899.       as_warn( "Bad escaped character in string, '?' assumed" );
  1900.       c = '?';
  1901.       break;
  1902.     }
  1903.       break;
  1904.  
  1905.     default:
  1906.       break;
  1907.     }
  1908.   return (c);
  1909. }
  1910.  
  1911. static segT
  1912. get_segmented_expression ( expP )
  1913.      register expressionS *    expP;
  1914. {
  1915.   register segT        retval;
  1916.  
  1917.   if ( (retval = expression( expP )) == SEG_PASS1 || retval == SEG_NONE || retval == SEG_BIG )
  1918.     {
  1919.       as_warn("Expected address expression: absolute 0 assumed");
  1920.       retval = expP -> X_seg = SEG_ABSOLUTE;
  1921.       expP -> X_add_number   = 0;
  1922.       expP -> X_add_symbol   = expP -> X_subtract_symbol = 0;
  1923.     }
  1924.   return (retval);        /* SEG_ ABSOLUTE,UNKNOWN,DATA,TEXT,BSS */
  1925. }
  1926.  
  1927. static segT
  1928. get_known_segmented_expression ( expP )
  1929.      register expressionS *    expP;
  1930. {
  1931.   register segT        retval;
  1932.   register char *    name1;
  1933.   register char *    name2;
  1934.  
  1935.   if (   (retval = get_segmented_expression (expP)) == SEG_UNKNOWN
  1936.       )
  1937.     {
  1938.       name1 = expP -> X_add_symbol ? expP -> X_add_symbol -> sy_name : "";
  1939.       name2 = expP -> X_subtract_symbol ? expP -> X_subtract_symbol -> sy_name : "";
  1940.       if ( name1 && name2 )
  1941.     {
  1942.       as_warn("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.",
  1943.           name1, name2);
  1944.     }
  1945.       else
  1946.     {
  1947.       as_warn("Symbol \"%s\" undefined: absolute 0 assumed.",
  1948.           name1 ? name1 : name2);
  1949.     }
  1950.       retval = expP -> X_seg = SEG_ABSOLUTE;
  1951.       expP -> X_add_number   = 0;
  1952.       expP -> X_add_symbol   = expP -> X_subtract_symbol = NULL;
  1953.     }
  1954.  know(   retval == SEG_ABSOLUTE || retval == SEG_DATA || retval == SEG_TEXT || retval == SEG_BSS || retval == SEG_DIFFERENCE );
  1955.   return (retval);
  1956. }                /* get_known_segmented_expression() */
  1957.  
  1958.  
  1959.  
  1960. /* static */ long int /* JF was static, but can't be if the MD pseudos are to use it */
  1961. get_absolute_expression ()
  1962. {
  1963.   expressionS    exp;
  1964.   register segT s;
  1965.  
  1966.   if ( (s = expression(& exp)) != SEG_ABSOLUTE )
  1967.     {
  1968.       if ( s != SEG_NONE )
  1969.     {
  1970.       as_warn( "Bad Absolute Expression, absolute 0 assumed.");
  1971.     }
  1972.       exp . X_add_number = 0;
  1973.     }
  1974.   return (exp . X_add_number);
  1975. }
  1976.  
  1977. static char            /* return terminator */
  1978. get_absolute_expression_and_terminator( val_pointer)
  1979.      long int *        val_pointer; /* return value of expression */
  1980. {
  1981.   * val_pointer = get_absolute_expression ();
  1982.   return ( * input_line_pointer ++ );
  1983. }
  1984.  
  1985. /*
  1986.  *            demand_copy_C_string()
  1987.  *
  1988.  * Like demand_copy_string, but return NULL if the string contains any '\0's.
  1989.  * Give a warning if that happens.
  1990.  */
  1991. static char *
  1992. demand_copy_C_string (len_pointer)
  1993.      int *    len_pointer;
  1994. {
  1995.   register char *    s;
  1996.  
  1997.   if (s = demand_copy_string (len_pointer))
  1998.     {
  1999.       register int    len;
  2000.  
  2001.       for (len = * len_pointer;
  2002.        len > 0;
  2003.        len--)
  2004.     {
  2005.       if (* s == 0)
  2006.         {
  2007.           s = 0;
  2008.           len = 1;
  2009.           * len_pointer = 0;
  2010.           as_warn( "This string may not contain \'\\0\'" );
  2011.         }
  2012.     }
  2013.     }
  2014.   return (s);
  2015. }
  2016.  
  2017. /*
  2018.  *            demand_copy_string()
  2019.  *
  2020.  * Demand string, but return a safe (=private) copy of the string.
  2021.  * Return NULL if we can't read a string here.
  2022.  */
  2023. static char *
  2024. demand_copy_string (lenP)
  2025.      int *    lenP;
  2026. {
  2027.   register int        c;
  2028.   register int        len;
  2029.        char *    retval;
  2030.  
  2031.   len = 0;
  2032.   SKIP_WHITESPACE();
  2033.   if (* input_line_pointer == '\"')
  2034.     {
  2035.       input_line_pointer ++;    /* Skip opening quote. */
  2036.       while ( (c = next_char_of_string()) >= 0 ) {
  2037.       obstack_1grow ( ¬es, c );
  2038.       len ++;
  2039.     }
  2040.       /* JF this next line is so demand_copy_C_string will return a null
  2041.          termanated string. */
  2042.       obstack_1grow(¬es,'\0');
  2043.       retval=obstack_finish( ¬es);
  2044.   } else {
  2045.       as_warn( "Missing string" );
  2046.       retval = NULL;
  2047.       ignore_rest_of_line ();
  2048.     }
  2049.   * lenP = len;
  2050.   return (retval);
  2051. }
  2052.  
  2053. /*
  2054.  *        is_it_end_of_statement()
  2055.  *
  2056.  * In:    Input_line_pointer -> next character.
  2057.  *
  2058.  * Do:    Skip input_line_pointer over all whitespace.
  2059.  *
  2060.  * Out:    TRUE if input_line_pointer -> end-of-line.
  2061.  */
  2062. static int
  2063. is_it_end_of_statement()
  2064. {
  2065.   SKIP_WHITESPACE();
  2066.   return (is_end_of_line [* input_line_pointer]);
  2067. }
  2068.  
  2069. void
  2070. equals(sym_name)
  2071. char *sym_name;
  2072. {
  2073.   register struct symbol * symbolP; /* symbol we are working with */
  2074.  
  2075.   input_line_pointer++;
  2076.   if(*input_line_pointer=='=')
  2077.     input_line_pointer++;
  2078.  
  2079.   while(*input_line_pointer==' ' || *input_line_pointer=='\t')
  2080.     input_line_pointer++;
  2081.  
  2082.   if(sym_name[0]=='.' && sym_name[1]=='\0') {
  2083.     /* Turn '. = mumble' into a .org mumble */
  2084.     register segT segment;
  2085.     expressionS exp;
  2086.     register char *p;
  2087.  
  2088.     segment = get_known_segmented_expression(& exp);
  2089.     if ( ! need_pass_2 ) {
  2090.       if (segment != now_seg && segment != SEG_ABSOLUTE)
  2091.         as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  2092.                 seg_name [(int) segment], seg_name [(int) now_seg]);
  2093.       p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
  2094.                     exp.X_add_number, (char *)0);
  2095.       * p = 0;
  2096.     } /* if (ok to make frag) */
  2097.   } else {
  2098.     symbolP=symbol_find_or_make(sym_name);
  2099.     pseudo_set(symbolP);
  2100.   }
  2101. }
  2102.  
  2103. /* end: read.c */
  2104.