Update Yasm to 1.2.0 (Yasm Part 1/3)

third_party/yasm/patched-yasm/libyasm/expr.c

 /*
  * Expression handling
  *
  *  Copyright (C) 2001-2007  Michael Urman, Peter Johnson
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include "util.h"
-/*@unused@*/ RCSID("$Id: expr.c 2130 2008-10-07 05:38:11Z peter $");
 
 #include "libyasm-stdint.h"
 #include "coretype.h"
 #include "bitvect.h"
 
 #include "errwarn.h"
 #include "intnum.h"
 #include "floatnum.h"
 #include "expr.h"
 #include "symrec.h"
@@ skipping 489 matching lines @@
 }
 
 /* Check for and simplify identities.  Returns new number of expr terms.
  * Sets e->op = EXPR_IDENT if numterms ends up being 1.
  * Uses numterms parameter instead of e->numterms for basis of "new" number
  * of terms.
  * Assumes int_term is *only* integer term in e.
  * NOTE: Really designed to only be used by expr_level_op().
  */
 static int
-expr_simplify_identity(yasm_expr *e, int numterms, int int_term,
+expr_simplify_identity(yasm_expr *e, int numterms, int *int_term,
                        int simplify_reg_mul)
 {
     int i;
     int save_numterms;
 
     /* Don't do this step if it's 1*REG.  Save and restore numterms so
      * yasm_expr__contains() works correctly.
      */
     save_numterms = e->numterms;
     e->numterms = numterms;
     if (simplify_reg_mul || e->op != YASM_EXPR_MUL
-        || !yasm_intnum_is_pos1(e->terms[int_term].data.intn)
+        || !yasm_intnum_is_pos1(e->terms[*int_term].data.intn)
         || !yasm_expr__contains(e, YASM_EXPR_REG)) {
         /* Check for simple identities that delete the intnum.
          * Don't delete if the intnum is the only thing in the expn.
          */
-        if ((int_term == 0 && numterms > 1 &&
+        if ((*int_term == 0 && numterms > 1 &&
              expr_can_destroy_int_left(e->op, e->terms[0].data.intn)) ||
-            (int_term > 0 &&
-             expr_can_destroy_int_right(e->op, e->terms[int_term].data.intn))) {
+            (*int_term > 0 &&
+             expr_can_destroy_int_right(e->op,
+                                        e->terms[*int_term].data.intn))) {
             /* Delete the intnum */
-            yasm_intnum_destroy(e->terms[int_term].data.intn);
+            yasm_intnum_destroy(e->terms[*int_term].data.intn);
 
             /* Slide everything to its right over by 1 */
-            if (int_term != numterms-1) /* if it wasn't last.. */
-                memmove(&e->terms[int_term], &e->terms[int_term+1],
-                        (numterms-1-int_term)*sizeof(yasm_expr__item));
+            if (*int_term != numterms-1) /* if it wasn't last.. */
+                memmove(&e->terms[*int_term], &e->terms[*int_term+1],
+                        (numterms-1-*int_term)*sizeof(yasm_expr__item));
 
             /* Update numterms */
             numterms--;
-            int_term = -1;      /* no longer an int term */
+            *int_term = -1;     /* no longer an int term */
         }
     }
     e->numterms = save_numterms;
 
     /* Check for simple identites that delete everything BUT the intnum.
      * Don't bother if the intnum is the only thing in the expn.
      */
-    if (numterms > 1 && int_term != -1 &&
-        expr_is_constant(e->op, e->terms[int_term].data.intn)) {
+    if (numterms > 1 && *int_term != -1 &&
+        expr_is_constant(e->op, e->terms[*int_term].data.intn)) {
         /* Loop through, deleting everything but the integer term */
         for (i=0; i<e->numterms; i++)
-            if (i != int_term)
+            if (i != *int_term)
                 expr_delete_term(&e->terms[i], 1);
 
         /* Move integer term to the first term (if not already there) */
-        if (int_term != 0)
-            e->terms[0] = e->terms[int_term];   /* structure copy */
+        if (*int_term != 0)
+            e->terms[0] = e->terms[*int_term];  /* structure copy */
 
         /* Set numterms to 1 */
         numterms = 1;
     }
 
     /* Compute NOT, NEG, and LNOT on single intnum. */
-    if (numterms == 1 && int_term == 0 &&
+    if (numterms == 1 && *int_term == 0 &&
         (e->op == YASM_EXPR_NOT || e->op == YASM_EXPR_NEG ||
          e->op == YASM_EXPR_LNOT))
         yasm_intnum_calc(e->terms[0].data.intn, e->op, NULL);
 
     /* Change expression to IDENT if possible. */
     if (numterms == 1)
         e->op = YASM_EXPR_IDENT;
 
     /* Return the updated numterms */
     return numterms;
@@ skipping 87 matching lines @@
                 /* copy term if it changed places */
                 e->terms[o++] = e->terms[i];
             } else
                 o++;
         }
 
         if (simplify_ident) {
             int new_fold_numterms;
             /* Simplify identities and make IDENT if possible. */
             new_fold_numterms =
-                expr_simplify_identity(e, fold_numterms, first_int_term,
+                expr_simplify_identity(e, fold_numterms, &first_int_term,
                                        simplify_reg_mul);
             level_numterms -= fold_numterms-new_fold_numterms;
             fold_numterms = new_fold_numterms;
         }
         if (fold_numterms == 1)
             e->op = YASM_EXPR_IDENT;
     }
 
     /* Only level operators that allow more than two operand terms.
      * Also don't bother leveling if it's not necessary to bring up any terms.
@@ skipping 70 matching lines @@
             if (i == first_int_term)
                 first_int_term = o;
             o--;
         } else
             o--;
     }
 
     /* Simplify identities, make IDENT if possible, and save to e->numterms. */
     if (simplify_ident && first_int_term != -1) {
         e->numterms = expr_simplify_identity(e, level_numterms,
-                                             first_int_term, simplify_reg_mul);
+                                             &first_int_term, simplify_reg_mul);
     } else {
         e->numterms = level_numterms;
         if (level_numterms == 1)
             e->op = YASM_EXPR_IDENT;
     }
 
     return e;
 }
 /*@=mustfree@*/
 
@@ skipping 704 matching lines @@
                     /* either sum of idents (?!) or substract of idents */
                     return NULL;
                 }
                 seen = 1;
             }
         }
     }
     /* exactly one offset */
     return segment;
 }