home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / cctools / as / expr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-06  |  39.2 KB  |  1,331 lines
  1. /* expr.c -operands, expressions-
  2.    Copyright (C) 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. /*
  21.  * This is really a branch office of as-read.c. I split it out to clearly
  22.  * distinguish the world of expressions from the world of statements.
  23.  * (It also gives smaller files to re-compile.)
  24.  * Here, "operand"s are of expressions, not instructions.
  25.  */
  26.  
  27. #include <ctype.h>
  28. #include <string.h>
  29. #include "stuff/round.h"
  30. #include "as.h"
  31. #include "flonum.h"
  32. #include "struc-symbol.h"
  33. #include "expr.h"
  34. #include "read.h"
  35. #include "obstack.h"
  36. #include "symbols.h"
  37. #include "hex_value.h"
  38. #include "md.h"
  39. #include "messages.h"
  40. #include "sections.h"
  41.  
  42. char *seg_name[] = {
  43.     "absolute",
  44.     "section",
  45.     "difference",
  46.     "unknown",
  47.     "absent",
  48.     "bignum/flonum",
  49. };
  50.  
  51. #ifdef SUSPECT
  52. static int seg_N_TYPE[] = {
  53.     N_ABS,    /* absolute */
  54.     N_SECT,    /* section */
  55.     -1,        /* difference */
  56.     N_UNDF,    /* unknown */
  57.     -1,        /* absent */
  58.     -1        /* bignum/flonum */
  59. };
  60. #endif
  61.  
  62. segT N_TYPE_seg[] =
  63. {
  64.  /* N_UNDF == 0,     N_ABS == 2 */
  65.     SEG_UNKNOWN, -1, SEG_ABSOLUTE, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  66.  /* N_SECT == 0xe */
  67.     SEG_SECT, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
  68. };
  69.  
  70. /*
  71.  * SEG_BIG expressions encode either a floating point number or an integer
  72.  * larger than 32 bits in this manner:
  73.  *   For a floating point number:
  74.  *    X_add_number is < 0
  75.  *         The result is in the global variable generic_floating_point_number.
  76.  *        The value in X_add_number is -'c' where c is the character that
  77.  *        introduced the constant.  e.g. "0f6.9" will have  -'f' as a
  78.  *        X_add_number value.
  79.  *   For an integer larger than 32 bits:
  80.  *    X_add_number > 0
  81.  *        The result is in the global variable generic_bignum.
  82.  *        The value in X_add_number is a count of how many littlenums it
  83.  *        took to represent the bignum.
  84.  */
  85.  
  86. /* LITTLENUM_TYPE    generic_buffer [6];    JF this is a hack */
  87. /* Seems atof_machine can backscan through generic_bignum and hit whatever
  88.    happens to be loaded before it in memory.  And its way too complicated
  89.    for me to fix right.  Thus a hack.  JF:  Just make generic_bignum bigger,
  90.    and never write into the early words, thus they'll always be zero.
  91.    I hate Dean's floating-point code.  Bleh.
  92.  */
  93. LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6] = { 0 };
  94.  
  95. FLONUM_TYPE generic_floating_point_number = {
  96.     &generic_bignum[6],                    /* low (JF: Was 0) */
  97.     &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1],/* high JF: (added +6) */
  98.     0,                          /* leader */
  99.     0,                          /* exponent */
  100.     0                          /* sign */
  101. };
  102.  
  103. /*
  104.  * The type operatorT is for the types of operators in expressions.
  105.  */
  106. typedef enum {
  107.     O_illegal,            /* (0)  what we get for illegal op */
  108.  
  109.     O_multiply,            /* (1)  *  Ordered by rank*/
  110.     O_divide,            /* (2)  /  */
  111.     O_modulus,            /* (3)  %  */
  112.  
  113.     O_add,            /* (4)  +  */
  114.     O_subtract,            /* (5)  -  */
  115.  
  116.     O_right_shift,        /* (6)  >> */
  117.     O_left_shift,        /* (7)  << */
  118.  
  119.     O_less_than,        /* (8)  <  */
  120.     O_greater_than,        /* (9)  >  */
  121.     O_less_than_or_equal,    /* (10) <= */
  122.     O_greater_than_or_equal,    /* (11) >= */
  123.  
  124.     O_equal,            /* (12) == */
  125.     O_not_equal,        /* (13) != */ /* or <> */
  126.  
  127.     O_bit_and,            /* (14) &  */
  128.  
  129.     O_bit_exclusive_or,        /* (15) ^  */
  130.  
  131.     O_bit_inclusive_or,        /* (16) |  */
  132.     O_bit_or_not,        /* (17) !  */
  133.     two_char_operator        /* (18) encoding for two char operator */
  134. } operatorT;
  135.  
  136. /*
  137.  * op_size is indexed by an operatorT and tells the size of the operator
  138.  * which is used to advance the input_line_pointer over the operator.
  139.  */
  140. static int op_size [] =
  141.     { 0, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1 };
  142.  
  143. /*
  144.  * op_rank is indexed by an operatorT and tells the rank of the operator.
  145.  *
  146.  *    Rank    Examples
  147.  *    8    * / %
  148.  *    7    + -
  149.  *    6    >> <<
  150.  *    5    < > <= >=
  151.  *    4    == !=
  152.  *    3    &
  153.  *    2    ^
  154.  *    1    | !
  155.  *    0    operand, (expression)
  156.  */
  157. typedef char operator_rankT;
  158. static operator_rankT op_rank [] =
  159.     { 0, 8, 8, 8, 7, 7, 6, 6, 5, 5, 5, 5, 4, 4, 3, 2, 1, 1 };
  160.  
  161. /*
  162.  * op_encoding is indexed by a an ASCII character and maps it to an operator.
  163.  */
  164. #define __ O_illegal
  165. static const operatorT op_encoding [256] = {
  166.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
  167.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
  168.  
  169.     __, two_char_operator, __, __, __, O_modulus, O_bit_and, __,
  170.     __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
  171.     __, __, __, __, __, __, __, __,
  172.     __, __, __, __, two_char_operator, two_char_operator, two_char_operator, __,
  173.     __, __, __, __, __, __, __, __,
  174.     __, __, __, __, __, __, __, __,
  175.     __, __, __, __, __, __, __, __,
  176.     __, __, __, __, __, __, O_bit_exclusive_or, __,
  177.     __, __, __, __, __, __, __, __,
  178.     __, __, __, __, __, __, __, __,
  179.     __, __, __, __, __, __, __, __,
  180.     __, __, __, __, O_bit_inclusive_or, __, __, __,
  181.  
  182.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
  183.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
  184.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
  185.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
  186.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
  187.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
  188.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
  189.     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
  190. };
  191.  
  192. static segT expr(
  193.     operator_rankT rank,
  194.     expressionS *resultP);
  195.  
  196. static segT operand(
  197.     expressionS *expressionP);
  198.  
  199. static void clean_up_expression(
  200.     expressionS *expressionP);
  201.  
  202. static segT expr_part(
  203.     struct symbol **symbol_1_PP,
  204.     struct symbol *symbol_2_P);
  205.  
  206. static operatorT two_char_op_encoding(
  207.     char first_op_char);
  208.  
  209. segT    /* Return resultP -> X_seg */
  210. expression(
  211. expressionS *resultP) /* deliver result here */
  212. {
  213.     segT segment;
  214.  
  215.     segment = expr(0, resultP);
  216.  
  217. /* what about caller's that just want to ignore this and print the're own
  218.    error message? ok I guess */
  219.     if(segment == SEG_DIFFSECT &&
  220.        resultP->X_add_symbol == NULL &&
  221.        (resultP->X_subtract_symbol->sy_type & N_TYPE) != N_UNDF){
  222.         as_warn("Subtracting symbol \"%s\"(segment\"%s\") is too "
  223.             "hard. Absolute segment assumed.",
  224.             resultP->X_subtract_symbol->sy_name,
  225.             seg_name[(int)N_TYPE_seg[
  226.             resultP->X_subtract_symbol->sy_type & N_TYPE]]);
  227.         segment = SEG_ABSOLUTE;
  228.         /* Leave exp .X_add_number alone. */
  229.     }
  230.     return(segment);
  231. }
  232.  
  233. /* Expression parser. */
  234.  
  235. /*
  236.  * We allow an empty expression, and just assume (absolute,0) silently.
  237.  * Unary operators and parenthetical expressions are treated as operands.
  238.  * As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
  239.  *
  240.  * Most expressions are either register (which does not even reach here)
  241.  * or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
  242.  *
  243.  * After expr(RANK,resultP) input_line_pointer -> operator of rank <= RANK.
  244.  * Also, we have consumed any leading or trailing spaces (operand does that)
  245.  * and done all intervening operators.
  246.  */
  247. static
  248. segT    /* Return resultP -> X_seg */
  249. expr(
  250. operator_rankT    rank, /* larger # is higher rank */
  251. expressionS *resultP) /* deliver result here */
  252. {
  253.     expressionS    right;
  254.     operatorT    op_left;
  255.     char    c_left;    /* 1st operator character. */
  256.     operatorT    op_right;
  257.     char    c_right;
  258.  
  259.     know(rank >= 0);
  260.  
  261.     (void)operand(resultP);
  262.     know(*input_line_pointer != ' '); /* Operand() gobbles spaces. */
  263.  
  264.     c_left = *input_line_pointer; /* Potential operator character. */
  265.     op_left = (operatorT)op_encoding[(int)c_left];
  266.     if(op_left == two_char_operator)
  267.         op_left = two_char_op_encoding(c_left);
  268.  
  269.     while(op_left != O_illegal && op_rank[op_left] > rank){
  270.  
  271.         input_line_pointer += op_size[op_left];
  272.         /* -> after 1st character of operator. */
  273.  
  274.         if(SEG_NONE == expr(op_rank[op_left], &right)){
  275.         as_warn("Missing operand value assumed absolute 0.");
  276.         resultP->X_add_number        = 0;
  277.         resultP->X_subtract_symbol    = NULL;
  278.         resultP->X_add_symbol        = NULL;
  279.         resultP->X_seg            = SEG_ABSOLUTE;
  280.         }
  281.         know(*input_line_pointer != ' ');
  282.  
  283.         c_right = *input_line_pointer;
  284.         op_right = (operatorT)op_encoding[(int)c_right];
  285.         if(op_right == two_char_operator)
  286.         op_right = two_char_op_encoding(c_right);
  287.  
  288.         /* -> after 1st character of operator. */
  289.         know(op_right == 0 || op_rank [op_right] <= op_rank[op_left]);
  290.  
  291.         /* input_line_pointer -> after right-hand quantity. */
  292.         /* left-hand quantity in resultP */
  293.         /* right-hand quantity in right. */
  294.         /* operator in op_left. */
  295.  
  296.         /*
  297.          * Operations are not supported on bignums or floating-point
  298.          * operands.
  299.          */
  300.         if(resultP->X_seg == SEG_BIG){
  301.         as_warn("Left operand of %c is a %s integer 0 assumed",
  302.             c_left, resultP->X_add_number > 0 ? "bignum" :
  303.             "float");
  304.         resultP->X_seg = SEG_ABSOLUTE;
  305.         resultP->X_add_symbol = 0;
  306.         resultP->X_subtract_symbol = 0;
  307.         resultP->X_add_number = 0;
  308.         }
  309.         if(right.X_seg == SEG_BIG){
  310.         as_warn("Right operand of %c is a %s integer 0 assumed",
  311.             c_left, right.X_add_number > 0 ? "bignum" :
  312.             "float");
  313.         right.X_seg = SEG_ABSOLUTE;
  314.         right.X_add_symbol = 0;
  315.         right.X_subtract_symbol = 0;
  316.         right.X_add_number = 0;
  317.         }
  318.         if(op_left == O_subtract){
  319.         /*
  320.          * Convert - into + by exchanging symbols and negating
  321.          * number. I know -infinity can't be negated in 2's
  322.          * complement: but then it can't be subtracted either.
  323.          * This trick does not cause any further inaccuracy.
  324.          */
  325.         struct symbol *symbolP;
  326.  
  327.         right.X_add_number      = - right.X_add_number;
  328.         symbolP                 = right.X_add_symbol;
  329.         right.X_add_symbol        = right.X_subtract_symbol;
  330.         right.X_subtract_symbol = symbolP;
  331.         if(symbolP){
  332. /* This is not used, as it drops in to the next if */
  333.             right.X_seg        = SEG_DIFFSECT;
  334.         }
  335.         op_left = O_add;
  336.         }
  337.         if(op_left == O_add){
  338.         segT seg1;
  339.         segT seg2;
  340.         
  341. /* not SEG_NONE and not SEG_BIG */
  342.         know(resultP->X_seg == SEG_SECT ||
  343.              resultP->X_seg == SEG_UNKNOWN ||
  344.              resultP->X_seg == SEG_DIFFSECT ||
  345.              resultP->X_seg == SEG_ABSOLUTE);
  346. /* not SEG_NONE and not SEG_BIG */
  347.         know(right.X_seg == SEG_SECT ||
  348.              right.X_seg == SEG_UNKNOWN ||
  349.              right.X_seg == SEG_DIFFSECT ||
  350.              right.X_seg == SEG_ABSOLUTE);
  351.         
  352.         clean_up_expression(&right);
  353.         clean_up_expression(resultP);
  354.  
  355. /* could this just return -1 instead of SEG_PASS1? and tested in the below if
  356. statement */
  357.         seg1 = expr_part(&resultP->X_add_symbol,
  358.                  right.X_add_symbol);
  359.         seg2 = expr_part(&resultP->X_subtract_symbol,
  360.                  right.X_subtract_symbol);
  361.         if(seg1 == -1 || seg2 == -1){
  362.             as_warn("Can't relocate expression. Absolute 0 assumed.");
  363.             resultP->X_seg        = SEG_ABSOLUTE;
  364.             resultP->X_add_number = 0;
  365.         }
  366.         else{
  367.             if(seg2 == SEG_ABSOLUTE){
  368.             resultP->X_seg = seg1;
  369.             }
  370.             else{
  371. /* also know seg2 != -1 (SEG_PASS1) */
  372.             know(seg2 != SEG_ABSOLUTE);
  373. /* seg2 is for the subtract symbols, since seg2 != SEG_ABSOLUTE as would be
  374. returned when there is no subtract symbols then expr_part() must have
  375. combined a symbol into resultP->X_subtract_symbol that is either undefined
  376. or defined in a section. */
  377.             know(resultP->X_subtract_symbol);
  378.             /*
  379.              * If we are not to use the new incompatible features
  380.              * then "symbol1 - symbol2" must both be in the same
  381.              * section and will turn out as absolute.
  382.              */
  383.             if(!flagseen['k']){
  384.                 if(seg1 != SEG_UNKNOWN &&
  385.                    seg1 != SEG_ABSOLUTE &&
  386.                    seg2 != SEG_UNKNOWN &&
  387.                    seg1 != seg2 &&
  388.                    resultP->X_add_symbol->sy_other !=
  389.                    resultP->X_subtract_symbol->sy_other){
  390.                 know(seg1 == SEG_SECT);
  391.                 know(seg2 == SEG_SECT);
  392.                 know(resultP->X_add_symbol);
  393.                 know(resultP->X_subtract_symbol);
  394.                 as_warn("Expression too complex: "
  395.                        "forgetting %s - %s",
  396.                        resultP->X_add_symbol->sy_name,
  397.                        resultP->X_subtract_symbol->sy_name);
  398.                 resultP->X_seg = SEG_ABSOLUTE;
  399.                 /* Clean_up_expression() will do the rest */
  400.                 }
  401.                 else{
  402. /* this can result in returning an expression that is NULL - symbol and the
  403. caller must deal with this being illegal.  maybe this should be put in
  404. expression() routine (not a macro).  Note the code in cons() */
  405.                 resultP->X_seg = SEG_DIFFSECT;
  406.                 }    /* If relocation too complex. */
  407.             }
  408.             else{
  409.                 resultP->X_seg = SEG_DIFFSECT;
  410.             }
  411.  
  412.             }        /* If seg2 == SEG_ABSOLUTE. */
  413.         }        /* If need pass 2. */
  414.         resultP->X_add_number += right.X_add_number;
  415.         clean_up_expression(resultP);
  416.         }
  417.         else{    /* Not +. */
  418.         if(resultP->X_seg == SEG_UNKNOWN ||
  419.            right.X_seg == SEG_UNKNOWN){
  420.             as_warn("Can't relocate expression. Absolute 0 assumed.");
  421.             resultP->X_seg        = SEG_ABSOLUTE;
  422.             resultP->X_add_number = 0;
  423.         }
  424.         else{
  425.             /*
  426.              * Will be SEG_ABSOLUTE. (or error)
  427.              */
  428.             try_to_make_absolute(resultP);
  429.             try_to_make_absolute(&right);
  430.             resultP->X_subtract_symbol = NULL;
  431.             resultP->X_add_symbol = NULL;
  432.             if(resultP->X_seg != SEG_ABSOLUTE ||
  433.                right.X_seg != SEG_ABSOLUTE){
  434.             as_warn("Relocation error. Absolute 0 assumed");
  435.             resultP->X_seg        = SEG_ABSOLUTE;
  436.             resultP->X_add_number = 0;
  437.             }
  438.             else{
  439.             /*
  440.              * Both are absolute so perform the operation
  441.              * on the constants.
  442.              */
  443.             switch(op_left){
  444.             case O_bit_inclusive_or:
  445.                 resultP->X_add_number |= right.X_add_number;
  446.                 break;
  447.               
  448.             case O_modulus:
  449.                 if(right.X_add_number){
  450.                 resultP->X_add_number %=
  451.                     right.X_add_number;
  452.                 }
  453.                 else{
  454.                 as_warn("Division by 0. 0 assumed.");
  455.                 resultP->X_add_number = 0;
  456.                 }
  457.                 break;
  458.               
  459.             case O_bit_and:
  460.                 resultP->X_add_number &= right.X_add_number;
  461.                 break;
  462.               
  463.             case O_multiply:
  464.                 resultP->X_add_number *= right.X_add_number;
  465.                 break;
  466.               
  467.             case O_divide:
  468.                 if(right.X_add_number){
  469.                 resultP->X_add_number /=
  470.                     right.X_add_number;
  471.                 }
  472.                 else{
  473.                 as_warn("Division by 0. 0 assumed.");
  474.                 resultP->X_add_number = 0;
  475.                 }
  476.                 break;
  477.               
  478.             case O_left_shift:
  479.                 resultP->X_add_number <<=
  480.                 right.X_add_number;
  481.                 break;
  482.               
  483.             case O_right_shift:
  484.                 resultP->X_add_number >>=
  485.                 right.X_add_number;
  486.                 break;
  487.               
  488.             case O_bit_exclusive_or:
  489.                 resultP->X_add_number ^= right.X_add_number;
  490.                 break;
  491.               
  492.             case O_bit_or_not:
  493.                 resultP->X_add_number |=
  494.                 ~right.X_add_number;
  495.                 break;
  496.  
  497.             case O_less_than:
  498.                 resultP->X_add_number =
  499.                    (resultP->X_add_number <
  500.                   right.X_add_number);
  501.                 break;
  502.               
  503.             case O_greater_than:
  504.                 resultP->X_add_number =
  505.                    (resultP->X_add_number >
  506.                   right.X_add_number);
  507.                 break;
  508.               
  509.             case O_less_than_or_equal:
  510.                 resultP->X_add_number =
  511.                    (resultP->X_add_number <=
  512.                   right.X_add_number);
  513.                 break;
  514.               
  515.             case O_greater_than_or_equal:
  516.                 resultP->X_add_number =
  517.                    (resultP->X_add_number >=
  518.                   right.X_add_number);
  519.                 break;
  520.               
  521.             case O_equal:
  522.                 resultP->X_add_number =
  523.                    (resultP->X_add_number ==
  524.                   right.X_add_number);
  525.                 break;
  526.               
  527.             case O_not_equal:
  528.                 resultP->X_add_number =
  529.                    (resultP->X_add_number !=
  530.                   right.X_add_number);
  531.                 break;
  532.               
  533.             default:
  534.                 BAD_CASE( op_left );
  535.                 break;
  536.             }    /* switch(op_left) */
  537.             }
  538.         }        /* If we have to force need_pass_2 */
  539.         }         /* If operator was + */
  540.         op_left = op_right;
  541.     }            /* While next operator is >= this rank */
  542.     return(resultP->X_seg);
  543. }
  544.  
  545. /*
  546.  * Summary of operand().
  547.  *
  548.  * in:    Input_line_pointer points to 1st char of operand, which may
  549.  *    be a space.
  550.  *
  551.  * out:    A expressionS. X_seg determines how to understand the rest of the
  552.  *    expressionS.
  553.  *    The operand may have been empty: in this case X_seg == SEG_NONE.
  554.  *    Input_line_pointer -> (next non-blank) char after operand.
  555.  *
  556.  */
  557. static
  558. segT
  559. operand(
  560. expressionS *expressionP)
  561. {
  562.     char c, q;
  563.     char *name;    /* points to name of symbol */
  564.     struct symbol *symbolP; /* Points to symbol */
  565.  
  566.  
  567.     SKIP_WHITESPACE();    /* Leading whitespace is part of operand. */
  568.     c = *input_line_pointer++;/* Input_line_pointer -> past char in c. */
  569.  
  570.     if(isdigit(c)){
  571.         valueT number;    /* offset or (absolute) value */
  572.         int digit;        /* value of next digit in current radix */
  573.                 /* invented for humans only, hope */
  574.                 /* optimising compiler flushes it! */
  575.         int radix;        /* 8, 10 or 16 */
  576.                 /* 0 means we saw start of a floating- */
  577.                 /* point constant. */
  578.         int maxdig;        /* Highest permitted digit value. */
  579.         int    too_many_digits;/* If we see >= this number of */
  580.                 /* digits, assume it is a bignum. */
  581.         char *digit_2;    /* -> 2nd digit of number. */
  582.         int    small;        /* TRUE if fits in 32 bits. */
  583.         int    force_bignum;    /* TRUE if number is 0xb...  */
  584.  
  585.         force_bignum = FALSE;
  586.         /*
  587.          * These two initiaizations are to shut up compiler warning as the
  588.          * may be used with out being set.  There used only if radix != 0
  589.          * when the number is not a floating-point number.
  590.          */
  591.         maxdig = 0;
  592.         too_many_digits = 0;
  593.  
  594.         if(c == '0'){ /* non-decimal radix */
  595.         c = *input_line_pointer++;
  596.         if(c == 'x' || c=='X'){
  597.             c = *input_line_pointer++; /* read past "0x" or "0X" */
  598.             maxdig = 16;
  599.             radix = 16;
  600.             too_many_digits = 9;
  601.         }
  602.         /*
  603.          * If we have "0b" and some hex digits then treat it as a hex
  604.          * number and return a bignum.   This is for hex immediate
  605.          * bit-patterns for floating-point immediate constants.
  606.          */
  607.         else if((c == 'b' || c == 'B') &&
  608.             (*input_line_pointer != '\0') &&
  609.             strchr("0123456789abcdefABCDEF",
  610.                    *input_line_pointer) != NULL){
  611.             force_bignum = TRUE;
  612.             c = *input_line_pointer++; /* read past "0b" or "0B" */
  613.             maxdig = 16;
  614.             radix = 16;
  615.             too_many_digits = 9;
  616.         }
  617.         else{
  618.             /*
  619.              * If it says '0f' and the line ends or it DOESN'T look like
  620.              * a floating point #, its a local label ref.
  621.              */
  622.             if(c == 'f' &&
  623.                (*input_line_pointer == '\0' ||
  624.             (strchr("+-.0123456789", *input_line_pointer) == NULL &&
  625.              strchr(md_EXP_CHARS, *input_line_pointer) == NULL) )){
  626.             maxdig = 10;
  627.             radix = 10;
  628.             too_many_digits = 11;
  629.             c = '0';
  630.             input_line_pointer -= 2;
  631.             }
  632.             else if(c != '\0' && strchr(md_FLT_CHARS, c) != NULL){
  633.             radix = 0;/* Start of floating-point constant. */
  634.                   /* input_line_pointer -> 1st char of number */
  635.             expressionP->X_add_number =
  636.                 - (isupper(c) ? tolower(c) : c);
  637.             }
  638.             else{    /* By elimination, assume octal radix. */
  639.             radix = 8;
  640.             maxdig = 10;    /* Un*x sux. Compatibility. */
  641.             too_many_digits = 11;
  642.             }
  643.         }
  644.         /* c == char after "0" or "0x" or "0X" or "0e" etc.*/
  645.         }
  646.         else{
  647.         maxdig = 10;
  648.         radix = 10;
  649.         too_many_digits = 11;
  650.         }
  651.         if(radix != 0){ /* Fixed-point integer constant. */
  652.                 /* May be bignum, or may fit in 32 bits. */
  653.         /*
  654.          * Most numbers fit into 32 bits, and we want this case to be
  655.          * fast.  So we pretend it will fit into 32 bits. If, after
  656.          * making up a 32 bit number, we realize that we have scanned
  657.          * more digits than comfortably fit into 32 bits, we re-scan the
  658.          * digits coding them into a bignum.  For decimal and octal
  659.          * numbers we are conservative: some numbers may be assumed
  660.          * bignums when in fact they do fit into 32 bits.  Numbers of
  661.          * any radix can have excess leading zeros: we strive to
  662.          * recognise this and cast them back into 32 bits.  We must
  663.          * check that the bignum really is more than 32 bits, and
  664.          * change it back to a 32-bit number if it fits.  The number we
  665.          * are looking for is expected to be positive, but if it fits
  666.          * into 32 bits as an unsigned number, we let it be a 32-bit
  667.          * number. The cavalier approach is for speed in ordinary cases.
  668.          */
  669.         digit_2 = input_line_pointer;
  670.         for(number = 0;
  671.             (digit = hex_value[(int)c]) < maxdig;
  672.             c = *input_line_pointer++){
  673.             number = number * radix + digit;
  674.         }
  675.         /* c contains character after number. */
  676.         /* Input_line_pointer -> char after c. */
  677.         small = input_line_pointer - digit_2 < too_many_digits;
  678.         if(force_bignum == TRUE)
  679.               small = FALSE;
  680.         if(small == FALSE){
  681.             /*
  682.              * Manufacture a bignum.
  683.              */
  684.             /* -> high order littlenum of the bignum. */
  685.             LITTLENUM_TYPE *leader;
  686.             /* -> littlenum we are frobbing now. */
  687.             LITTLENUM_TYPE *pointer;
  688.             long carry;
  689.  
  690.             leader = generic_bignum;
  691.             generic_bignum [0] = 0;
  692.             /* We could just use digit_2, but lets be mnemonic. */
  693.             input_line_pointer = --digit_2; /* -> 1st digit. */
  694.             c = *input_line_pointer++;
  695.             for( ;
  696.             (carry = hex_value[(int)c]) < maxdig;
  697.             c = * input_line_pointer++){
  698.             for(pointer = generic_bignum;
  699.                 pointer <= leader;
  700.                 pointer++){
  701.                 long work;
  702.  
  703.                 work = carry + radix * *pointer;
  704.                 *pointer = work & LITTLENUM_MASK;
  705.                 carry = work >> LITTLENUM_NUMBER_OF_BITS;
  706.             }
  707.             if(carry){
  708.                 if(leader < generic_bignum +
  709.                     SIZE_OF_LARGE_NUMBER - 1){
  710.                     /* Room to grow a longer bignum. */
  711.                 *++leader = carry;
  712.                 }
  713.             }
  714.             }
  715.             /* Again, C is char after number, */
  716.             /* input_line_pointer -> after C. */
  717.             /* know(BITS_PER_INT == 32); */
  718.             know(LITTLENUM_NUMBER_OF_BITS == 16);
  719.             /* Hence the constant "2" in the next line. */
  720.             if(leader < generic_bignum + 2 && force_bignum == FALSE)
  721.             {        /* Will fit into 32 bits. */
  722.             number = ((generic_bignum[1] & LITTLENUM_MASK) <<
  723.                    LITTLENUM_NUMBER_OF_BITS) |
  724.                     (generic_bignum[0] & LITTLENUM_MASK);
  725.             small = TRUE;
  726.             }
  727.             else{
  728.             /* Number of littlenums in the bignum. */
  729.             number = leader - generic_bignum + 1;
  730.             }
  731.         }
  732.         if(small){
  733.             /*
  734.              * Here with number, in correct radix. c is the next char.
  735.              * Note that unlike Un*x, we allow "011f" "0x9f" to both
  736.              * mean the same as the (conventional) "9f". This is simply
  737.              * easier than checking for strict canonical form.
  738.              */
  739.             if(number < 10){
  740.             if(c == 'b'){
  741.                 /*
  742.                  * Backward ref to local label.
  743.                  * Because it is backward, expect it to be DEFINED.
  744.                  */
  745.                 /*
  746.                  * Construct a local label.
  747.                  */
  748.                 name = local_label_name((int)number, 0);
  749.                 symbolP = symbol_table_lookup(name);
  750.                 if((symbolP != NULL) &&
  751.                    (symbolP->sy_type & N_TYPE) != N_UNDF){
  752.                 /* Expected path: symbol defined. */
  753.                 /* Local labels are never absolute. Don't waste
  754.                    time checking absoluteness. */
  755.                 know((symbolP->sy_type & N_TYPE) == N_SECT);
  756.                 expressionP->X_add_symbol = symbolP;
  757.                 expressionP->X_add_number = 0;
  758.                 expressionP->X_seg        = SEG_SECT;
  759.                 }
  760.                 else{ /* Either not seen or not defined. */
  761.                 as_warn("Backw. ref to unknown label \"%d:\", 0"
  762.                     " assumed.", number);
  763.                 expressionP->X_add_number = 0;
  764.                 expressionP->X_seg        = SEG_ABSOLUTE;
  765.                 }
  766.             }
  767.             else if(c == 'f'){
  768.                 /*
  769.                  * Forward reference. Expect symbol to be
  770.                  * undefined or unknown. Undefined: seen it
  771.                  * before. Unknown: never seen it in this pass.
  772.                  * Construct a local label name, then an
  773.                  * undefined symbol.  Don't create a XSEG frag
  774.                  * for it: caller may do that.
  775.                  * Just return it as never seen before.
  776.                  */
  777.                 name = local_label_name((int)number, 1);
  778.                 symbolP = symbol_table_lookup(name);
  779.                 if(symbolP != NULL){
  780.                 /* We have no need to check symbol
  781.                    properties. */
  782.                 know((symbolP->sy_type & N_TYPE) == N_UNDF ||
  783.                      (symbolP->sy_type & N_TYPE) == N_SECT);
  784.                 }
  785.                 else{
  786.                 symbolP = symbol_new(name, N_UNDF, 0,0,0,
  787.                              &zero_address_frag);
  788.                 symbol_table_insert(symbolP);
  789.                 }
  790.                 expressionP->X_add_symbol      = symbolP;
  791.                 expressionP->X_seg             = SEG_UNKNOWN;
  792.                 expressionP->X_subtract_symbol = NULL;
  793.                 expressionP->X_add_number      = 0;
  794.             }
  795.             else{    /* Really a number, not a local label. */
  796.                 expressionP->X_add_number = number;
  797.                 expressionP->X_seg        = SEG_ABSOLUTE;
  798.                 input_line_pointer--; /* restore following char */
  799.                 }
  800.             }
  801.             else{ /* a number >= 10 */
  802.             expressionP->X_add_number = number;
  803.             expressionP->X_seg        = SEG_ABSOLUTE;
  804.             input_line_pointer--; /* restore following char */
  805.             }
  806.         } /* not a small number encode returning a bignum */
  807.         else{
  808.             expressionP->X_add_number = number;
  809.             expressionP->X_seg = SEG_BIG;
  810.             input_line_pointer--; /* -> char following number. */
  811.         } /* if (small) */
  812.         } /* (If integer constant) */
  813.         else{ /* input_line_pointer -> floating-point constant. */
  814.  
  815.         int error_code;
  816.  
  817.         error_code = atof_generic(&input_line_pointer, ".", md_EXP_CHARS,
  818.                       &generic_floating_point_number);
  819.  
  820.         if(error_code){
  821.             if(error_code == ERROR_EXPONENT_OVERFLOW){
  822.             as_warn("Bad floating-point constant: exponent "
  823.                 "overflow, probably assembling junk" );
  824.             }
  825.             else{          
  826.             as_warn("Bad floating-point constant: unknown error "
  827.                 "code=%d.", error_code);
  828.             }
  829.         }
  830.         expressionP->X_seg = SEG_BIG;
  831.         /* input_line_pointer -> just after constant, */
  832.         /* which may point to whitespace. */
  833.         know(expressionP->X_add_number < 0);
  834.         /* < 0 means "floating point". */
  835.         }            /* if (not floating-point constant) */
  836.     }
  837.     else if(c == '.' && !is_part_of_name(*input_line_pointer)){
  838.         /*
  839.          JF:  '.' is pseudo symbol with value of current location in current
  840.          segment. . .
  841.          */
  842.         symbolP = symbol_new("L0\001",
  843.                  N_SECT,
  844.                      frchain_now->frch_nsect,
  845.                  0,
  846.                  (valueT)(obstack_next_free(&frags) -
  847.                       frag_now->fr_literal),
  848.                      frag_now);
  849.         expressionP->X_add_number = 0;
  850.         expressionP->X_add_symbol = symbolP;
  851.         expressionP->X_seg = SEG_SECT;
  852.     }
  853.     /* here if did not begin with a digit */
  854.     else if(is_name_beginner(c) || c == '"'){
  855.         /*
  856.          * Identifier begins here.
  857.          * This is kludged for speed, so code is repeated.
  858.          */
  859.         q = c;
  860.         if(q == '"')
  861.         name = input_line_pointer-- ;
  862.         else
  863.         name =  -- input_line_pointer;
  864.         c = get_symbol_end();
  865.         symbolP = symbol_table_lookup(name);
  866.         if(symbolP != NULL){
  867.         /*
  868.          * If we have an absolute symbol, then we know it's value now.
  869.          */
  870.         segT seg;
  871.  
  872.         seg = N_TYPE_seg[(int)symbolP->sy_type & N_TYPE];
  873.         expressionP->X_seg = seg;
  874.         if(seg == SEG_ABSOLUTE){
  875.             expressionP->X_add_number = symbolP->sy_value;
  876.         }
  877.         else{
  878.             expressionP->X_add_number = 0;
  879.             expressionP->X_add_symbol = symbolP;
  880.         }
  881.         }
  882.         else{
  883.         symbolP = symbol_new(name, N_UNDF, 0,0,0, &zero_address_frag);
  884.         expressionP->X_add_symbol  = symbolP;
  885.         expressionP->X_add_number  = 0;
  886.         expressionP->X_seg         = SEG_UNKNOWN;
  887.         symbol_table_insert(symbolP);
  888.         }
  889.         *input_line_pointer = c;
  890.         if(q == '"')
  891.         input_line_pointer[-1] = '"';
  892.         expressionP->X_subtract_symbol = NULL;
  893.     }
  894.     /* didn't begin with digit & not a name */
  895.     else if (c == '('){
  896.         (void)expression(expressionP);
  897.         /* Expression() will pass trailing whitespace */
  898.         if(*input_line_pointer++ != ')'){
  899.         as_warn("Missing ')' assumed");
  900.         input_line_pointer--;
  901.         }
  902.         /* here with input_line_pointer -> char after "(...)" */
  903.     }
  904.     /* unary operator: hope for SEG_ABSOLUTE */
  905.     else if(c == '~' || c == '-' || c == '!'){
  906.         switch(operand(expressionP)){
  907.         case SEG_ABSOLUTE:
  908.         /* input_line_pointer -> char after operand */
  909.         if(c == '-' ){
  910.            /*
  911.             * Notice: '-' may  overflow: no warning is given. This is
  912.             * compatible with other people's assemblers.
  913.             */
  914.             expressionP->X_add_number = - expressionP->X_add_number;
  915.         }
  916.         else if(c == '!'){
  917.             expressionP->X_add_number = ! expressionP->X_add_number;
  918.         }
  919.         else{
  920.             expressionP->X_add_number = ~ expressionP->X_add_number;
  921.         }
  922.         break;
  923.         case SEG_SECT:
  924.         case SEG_UNKNOWN:
  925.         if(c == '-'){        /* JF I hope this hack works */
  926.             expressionP->X_subtract_symbol = expressionP->X_add_symbol;
  927.             expressionP->X_add_symbol = 0;
  928.             expressionP->X_seg = SEG_DIFFSECT;
  929.             break;
  930.         }
  931.         default: /* unary on non-absolute is unsuported */
  932.         as_warn("Unary operator %c ignored because bad operand follows",
  933.             c);
  934.         break;
  935.         /* Expression undisturbed from operand(). */
  936.         }
  937.     }
  938.     /*
  939.      * Warning: to conform to other people's assemblers NO ESCAPEMENT is
  940.      * permitted for a single quote.  The next character, parity errors and
  941.      * all, is taken as the value of the operand. VERY KINKY.
  942.      */
  943.     else if(c == '\''){
  944.         expressionP->X_add_number = *input_line_pointer++;
  945.         expressionP->X_seg        = SEG_ABSOLUTE;
  946.     }
  947.     /* can't imagine any other kind of operand */
  948.       else{
  949.         expressionP->X_seg = SEG_NONE;
  950.         input_line_pointer--;
  951.     }
  952.     /*
  953.      * It is more 'efficient' to clean up the expressions when they are
  954.      * created.  Doing it here saves lines of code.
  955.      */
  956.     clean_up_expression(expressionP);
  957.     SKIP_WHITESPACE();        /* -> 1st char after operand. */
  958.     know(*input_line_pointer != ' ');
  959.     return(expressionP->X_seg);
  960. }
  961.  
  962. /* Internal. Simplify a struct expression for use by expr() */
  963.  
  964. /*
  965.  * In:    address of a expressionS.
  966.  *    The X_seg field of the expressionS may only take certain values.
  967.  *    Now, we permit SEG_NONE to make code smaller & faster.
  968.  *    Elsewise we waste time special-case testing. Sigh.
  969.  * Out:    expressionS may have been modified:
  970.  *    'foo-foo' symbol references cancelled to 0,
  971.  *        which changes X_seg from SEG_DIFFSECT to SEG_ABSOLUTE;
  972.  *    Unused fields zeroed to help expr().
  973.  */
  974. static
  975. void
  976. clean_up_expression(
  977. expressionS *expressionP)
  978. {
  979.     switch(expressionP->X_seg){
  980.     case SEG_NONE:
  981.         expressionP->X_add_symbol        = NULL;
  982.         expressionP->X_subtract_symbol    = NULL;
  983.         expressionP->X_add_number        = 0;
  984.         break;
  985.  
  986.     case SEG_BIG:
  987.     case SEG_ABSOLUTE:
  988.         expressionP->X_subtract_symbol    = NULL;
  989.         expressionP->X_add_symbol        = NULL;
  990.         break;
  991.  
  992.     case SEG_SECT:
  993.     case SEG_UNKNOWN:
  994.         expressionP->X_subtract_symbol    = NULL;
  995.         break;
  996.  
  997.     case SEG_DIFFSECT:
  998.         /*
  999.          * It does not hurt to 'cancel' NULL==NULL
  1000.          * when comparing symbols for 'eq'ness.
  1001.          * It is faster to re-cancel them to NULL
  1002.          * than to check for this special case.
  1003.          */
  1004.         if(expressionP->X_subtract_symbol == expressionP->X_add_symbol){
  1005.         expressionP->X_subtract_symbol    = NULL;
  1006.         expressionP->X_add_symbol    = NULL;
  1007.         expressionP->X_seg        = SEG_ABSOLUTE;
  1008.         }
  1009.         break;
  1010.  
  1011.     default:
  1012.         BAD_CASE(expressionP->X_seg);
  1013.         break;
  1014.     }
  1015. }
  1016.  
  1017. /*
  1018.  *            expr_part ()
  1019.  *
  1020.  * Internal. Made a function because this code is used in 2 places.
  1021.  * Generate error or correct X_?????_symbol of expressionS.
  1022.  */
  1023.  
  1024. /*
  1025. Combine and subsume symbol2 into symbol1 where the symbols come from
  1026.     expression's add or subtract symbols.
  1027. The combining always occurs even if it would be an error.
  1028. Either symbol maybe NULL which means there is no symbol.
  1029.     In that case symbol1 is set to the non NULL symbol.
  1030.     If both are NULL then SEG_ABSOLUTE is returned.
  1031. Either symbol maybe undefined.
  1032. The only combinations that are not errors are when one symbol does not exist.
  1033.     if one symbol is undefined and the other doesn't exist SEG_UNKNOWN is
  1034.      returned.
  1035. For errant combinations symbol1 is set to NULL and SEG_ABSOLUTE (or -1
  1036.     (SEG_PASS1) when one of the symbols is undefined and the other exists)
  1037.  
  1038.  * symbol_1 += symbol_2 ... well ... sort of.
  1039.  * symbol_1 -= symbol_2 ... well ... sort of.
  1040.  */
  1041.  
  1042. static
  1043. segT
  1044. expr_part(
  1045. struct symbol **symbol_1_PP,
  1046. struct symbol *symbol_2_P)
  1047. {
  1048.     segT return_value;
  1049.  
  1050. /* The symbols can't be N_ABS as they are in expressions and whould just have
  1051.    their value copied into the X_add_number part. */
  1052.     know( (*symbol_1_PP)                   == NULL   ||
  1053.          ((*symbol_1_PP)->sy_type & N_TYPE) == N_SECT ||
  1054.          ((*symbol_1_PP)->sy_type & N_TYPE) == N_UNDF);
  1055.  
  1056.     know( symbol_2_P                     == NULL   ||
  1057.          (symbol_2_P->sy_type & N_TYPE) == N_SECT ||
  1058.          (symbol_2_P->sy_type & N_TYPE) == N_UNDF);
  1059.  
  1060.     /* check to see if there is a symbol1 */
  1061.     if(*symbol_1_PP != NULL){
  1062.         /* there is a symbol1 */
  1063.  
  1064.         /* check to see if symbol1 is undefined */
  1065.         if(((*symbol_1_PP)->sy_type & N_TYPE) == N_UNDF){
  1066.         /* symbol1 is undefined */
  1067.  
  1068.         /* check to see if there is a symbol2 */
  1069.         if(symbol_2_P != NULL){
  1070.             /* symbol1 is undefined and there is a symbol2 */
  1071.             *symbol_1_PP = NULL;
  1072.             return_value = -1;
  1073.         }
  1074.         else{
  1075.             /* symbol1 is undefined and there is no symbol2 */
  1076.             return_value = SEG_UNKNOWN;
  1077.         }
  1078.         }
  1079.         else{
  1080.         /* there is a defined symbol1 */
  1081.  
  1082.         /* check to see if there is a symbol2 */
  1083.         if(symbol_2_P != NULL){
  1084.             /* there is a symbol2 */
  1085.  
  1086.             /* check to see if symbol2 is undefined */
  1087.             if((symbol_2_P->sy_type & N_TYPE) == N_UNDF){
  1088.             /* symbol2 is undefined and symbol1 is defined */
  1089.             *symbol_1_PP = NULL;
  1090.             return_value = -1;
  1091.             }
  1092.             else{
  1093.             /* symbol1 is defined and symbol2 is defined */
  1094.             /* + {symbol1} + {symbol2}  or */
  1095.             /* - {symbol1} - {symbol2} */
  1096.             as_warn("Expression too complex, 2 symbols forgotten: "
  1097.                 "\"%s\" \"%s\"", (*symbol_1_PP)->sy_name,
  1098.                 symbol_2_P->sy_name);
  1099.             *symbol_1_PP = NULL;
  1100.             return_value = SEG_ABSOLUTE;
  1101.             }
  1102.         }
  1103.         else{
  1104.             /* symbol1 is defined and there is no symbol2 */
  1105.             return_value = N_TYPE_seg[(*symbol_1_PP)->sy_type & N_TYPE];
  1106.         }
  1107.         }
  1108.     }
  1109.     else{
  1110.         /* there is no symbol1 */
  1111.  
  1112.         /* check to see if there is a symbol2 */
  1113.         if(symbol_2_P != NULL){
  1114.         /* symbol2 is defined and there is no symbol1 */
  1115.         *symbol_1_PP = symbol_2_P;
  1116.         return_value = N_TYPE_seg[(symbol_2_P)->sy_type & N_TYPE];
  1117.         }
  1118.         else{
  1119.         /* there is no symbol1 or symbol2 */
  1120. /* ??? why not SEG_UNKNOWN or SEG_NONE */
  1121.         return_value = SEG_ABSOLUTE;
  1122.         }
  1123.     }
  1124.  
  1125.     know(return_value == SEG_ABSOLUTE ||
  1126.          return_value == SEG_SECT      ||
  1127.          return_value == SEG_UNKNOWN  ||
  1128.          return_value == -1);
  1129.     know((*symbol_1_PP) == NULL ||
  1130.          ((*symbol_1_PP)->sy_type & N_TYPE) ==
  1131.         seg_N_TYPE[(int)return_value]);
  1132.  
  1133.     return(return_value);
  1134. }
  1135.  
  1136. /*
  1137.  *  DJA -- Here we make a last ditch effort to turn expressions into
  1138.  *    absolutes.  This is particularly useful for doing arithemtic
  1139.  *    on already declared labels, for example in going through the
  1140.  *    following table the moveq can really be evaluated.
  1141.  *
  1142.  *    start:    .word    1
  1143.  *        .word    2
  1144.  *        .word    3
  1145.  *    end:
  1146.  *        lea    start,a0
  1147.  *        moveq    #((end-start) / 2) + 1,d0
  1148.  *    loop:    cmpw    d1,a0@+
  1149.  *        dbra    d0,loop
  1150.  */
  1151. segT /* Return expressionP->X_seg. */
  1152. try_to_make_absolute(
  1153. expressionS *expressionP) /* Deliver result here. */
  1154. {
  1155.     symbolS *add_symbol;
  1156.     symbolS *subtract_symbol;
  1157.  
  1158.     if(expressionP->X_seg == SEG_DIFFSECT){
  1159.  
  1160.         add_symbol = expressionP->X_add_symbol;
  1161.         if(add_symbol == NULL)
  1162.         goto giveup;
  1163.         if((add_symbol->sy_type & N_TYPE) != N_SECT)
  1164.         goto giveup;
  1165.  
  1166.         subtract_symbol = expressionP->X_subtract_symbol;
  1167.         if(subtract_symbol == NULL)
  1168.         goto giveup;
  1169.         if((subtract_symbol->sy_type & N_TYPE) != N_SECT)
  1170.         goto giveup;
  1171.  
  1172.         if(add_symbol->sy_frag == subtract_symbol->sy_frag){
  1173.         if(add_symbol->sy_frag != NULL &&
  1174.            expressionP->X_add_number +
  1175.            (int)add_symbol->sy_value -
  1176.            (int)subtract_symbol->sy_value >= 0){
  1177.             expressionP->X_add_number += add_symbol->sy_value -
  1178.                              subtract_symbol->sy_value;
  1179.             expressionP->X_seg = SEG_ABSOLUTE;
  1180.             expressionP->X_add_symbol = NULL;
  1181.             expressionP->X_subtract_symbol = NULL;
  1182.  
  1183.         }
  1184.         }
  1185.         else{
  1186.         /*
  1187.          * This logic works only if the chain of frags can't later be
  1188.          * separated by scattered loading.  To make sure that this can't
  1189.          * happen we would have to make sure all symbols associated with
  1190.          * frags in the chain are of the Lx form and the -L flag is not
  1191.          * see so they will not appear in the output (if they are not in
  1192.          * the output then the link editor can't separate the chain of
  1193.          * frags by scattered loading).  Since this code does not make
  1194.          * sure of this it is broken.  But this is a known bug in the
  1195.          * NeXT 3.2 and earilier releases so this code is if'ed
  1196.          * !flagseen['k'] which will make it compatable with 3.2 and
  1197.          * previous releases.
  1198.          */
  1199.         if(!flagseen['k']){
  1200.             /*
  1201.              * Try to see if the chain of frags between the subtract
  1202.              * symbol and the add symbol is made up of only rs_fill and
  1203.              * rs_align frags and then calculate the difference.  This
  1204.              * will always work on RISC machines since they won't have
  1205.              * any machine dependent frags of variable length in the
  1206.              * chain.
  1207.              */
  1208.             unsigned long size, fail;
  1209.             struct frag *frag;
  1210.  
  1211.             if(add_symbol->sy_frag != NULL &&
  1212.                subtract_symbol->sy_frag != NULL){
  1213.             fail = 0;
  1214.             size = 0;
  1215.             frag = subtract_symbol->sy_frag;
  1216.             while(!fail && frag != NULL &&
  1217.                   frag != add_symbol->sy_frag){
  1218.                 if(frag->fr_type == rs_align)
  1219.                 size = round(size + frag->fr_fix,
  1220.                          1 << frag->fr_offset);
  1221.                 else if(frag->fr_type == rs_fill)
  1222.                 size += frag->fr_fix +
  1223.                     frag->fr_var * frag->fr_offset;
  1224.                 else
  1225.                 fail = 1;
  1226.                 frag = frag->fr_next;
  1227.             }
  1228.  
  1229.             if(!fail && frag == add_symbol->sy_frag){
  1230.                 expressionP->X_add_number = size +
  1231.                 add_symbol->sy_value -
  1232.                 subtract_symbol->sy_value;
  1233.                 expressionP->X_seg = SEG_ABSOLUTE;
  1234.                 expressionP->X_add_symbol = NULL;
  1235.                 expressionP->X_subtract_symbol = NULL;
  1236.             }
  1237.             }
  1238.         }
  1239.         }
  1240.     }
  1241. giveup:
  1242.  
  1243.     return(expressionP->X_seg);
  1244. }
  1245.  
  1246. /*
  1247.  * two_char_op_encoding() return the operator type for two character operators.
  1248.  * The first_op_char is part of a two character operator and this routine is
  1249.  * then used to determine the operator type looking at the second character.
  1250.  */
  1251. static
  1252. operatorT
  1253. two_char_op_encoding(
  1254. char first_op_char)
  1255. {
  1256.     char second_op_char;
  1257.  
  1258.     second_op_char = input_line_pointer[1];
  1259.     switch(first_op_char){
  1260.     case '<':
  1261.         if(second_op_char == '<')
  1262.         return(O_left_shift);
  1263.         if(second_op_char == '=')
  1264.         return(O_less_than_or_equal);
  1265.         if(second_op_char == '>')
  1266.         return(O_not_equal);
  1267.         return(O_less_than);
  1268.     case '>':
  1269.         if(second_op_char == '>')
  1270.         return(O_right_shift);
  1271.         if(second_op_char == '=')
  1272.         return(O_greater_than_or_equal);
  1273.         return(O_greater_than);
  1274.     case '=':
  1275.         if(second_op_char == '=')
  1276.         return(O_equal);
  1277.         return(O_illegal);
  1278.     case '!':
  1279.         if(second_op_char == '=')
  1280.         return(O_not_equal);
  1281.         return O_not_equal;
  1282.     default:
  1283.         BAD_CASE(first_op_char);
  1284.         return O_illegal;
  1285.     }
  1286. }
  1287.  
  1288. /*
  1289.  *            get_symbol_end()
  1290.  *
  1291.  * This lives here because it belongs equally in expr.c & read.c.
  1292.  * Expr.c is just a branch office read.c anyway, and putting it
  1293.  * here lessens the crowd at read.c.
  1294.  *
  1295.  * Assume input_line_pointer is at start of symbol name.
  1296.  * Advance input_line_pointer past symbol name.
  1297.  * Turn that character into a '\0', returning its former value.
  1298.  * This allows a string compare (RMS wants symbol names to be strings)
  1299.  * of the symbol name.
  1300.  * There will always be a char following symbol name, because all good
  1301.  * lines end in end-of-line.
  1302.  */
  1303. char
  1304. get_symbol_end(
  1305. void)
  1306. {
  1307.     register char c;
  1308.  
  1309.     /*
  1310.      * Symbol names are allowed to have surrounding ""s so that names can
  1311.      * have any characters in them (including spacesi, colons, etc).  This
  1312.      * is done so names like "[Foo bar:fuz:]" can be used as symbol names.
  1313.      */
  1314.     if(*input_line_pointer == '"'){
  1315.         input_line_pointer++;
  1316.         do{
  1317.         c = *input_line_pointer++ ;
  1318.         }while(c != '"' && c != '\0' && c != '\n');
  1319.         if(c == '"'){
  1320.         *(input_line_pointer - 1) = 0;
  1321.         c = *input_line_pointer++;
  1322.         }
  1323.     }
  1324.     else{
  1325.         while(is_part_of_name(c = *input_line_pointer++))
  1326.         ;
  1327.     }
  1328.     *--input_line_pointer = 0;
  1329.     return(c);
  1330. }
  1331.