1 /*
   2  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 /*
  26  * COMPONENT_NAME: idl.parser
  27  *
  28  * ORIGINS: 27
  29  *
  30  * Licensed Materials - Property of IBM
  31  * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999
  32  * RMI-IIOP v1.0
  33  *
  34  */
  35 
  36 package com.sun.tools.corba.se.idl.constExpr;
  37 
  38 // NOTES:
  39 
  40 import java.math.BigInteger;
  41 
  42 public abstract class Expression
  43 {
  44   /**
  45    * Compute the value of this expression.
  46    **/
  47   public abstract Object evaluate () throws EvaluationException;
  48 
  49   /**
  50    * Set the value of this expression.
  51    **/
  52   public void value (Object value)
  53   {
  54     _value = value;
  55   }
  56   /**
  57    * Get the value of this expression.
  58    **/
  59   public Object value ()
  60   {
  61     return _value;
  62   }
  63 
  64   /**
  65    * Set the representation of this expression.
  66    **/
  67   public void rep (String rep)
  68   {
  69     _rep = rep;
  70   }
  71   /**
  72    * Get the representation of this expression.
  73    **/
  74   public String rep ()
  75   {
  76     return _rep;
  77   }
  78 
  79   /**
  80    * Set the target type of this expression.
  81    **/
  82   public void type (String type)
  83   {
  84     _type = type;
  85   }
  86   /**
  87    * Get the target type of this expression.
  88    **/
  89   public String type ()
  90   {
  91     return _type;
  92   }
  93 
  94   /**
  95    * Return the default computation type for the given target type.
  96    **/
  97   protected static String defaultType (String targetType)
  98   {
  99     return (targetType == null) ? new String ("") : targetType;
 100   } // defaultType
 101 
 102   // BigInteger is a multi-precision number whose representation contains
 103   // a signum (sign-number = 1, -1) and a magnitude.  To support "long long",
 104   // all integer expressions are now performed over BigInteger and stored as
 105   // such.  During the evaluation of an integer expression, the signum of its
 106   // value may toggle, which may cause the value of an expression to conflict
 107   // with its target type: [Case 1] If the resulting value is negative
 108   // (signum=-1) and the target type is unsigned; or [Case 2] if the resulting
 109   // value is positive (signum=1) and greater than 2**(target-type-length - 1),
 110   // and the target type is signed, then the resulting value will be out of
 111   // range.  However, this value is correct and must be coerced to the target
 112   // type.  E.G., After appying "not" to a BigInteger, the result is
 113   // a BigInteger that represents its 2's-complement (~5 => -6 in a byte-space).
 114   // In this example, the signum toggles and the magnatude is 6.  If the target
 115   // type of this value were unsigned short, it must be coerced to a positive
 116   // number whose bits truly represent -6 in 2's-complement (250 in a byte-space).
 117   //
 118   // Also, floating types may now be intialized with any integer expression.
 119   // The result must be coerced to Double.
 120   //
 121   // Use the following routines to coerce this expression's value to its
 122   // "target" type.
 123 
 124   /**
 125    * Coerces a number to the target type of this expression.
 126    * @param  obj  The number to coerce.
 127    * @return  the value of number coerced to the (target) type of
 128    *  this expression.
 129    **/
 130   public Object coerceToTarget (Object obj)
 131   {
 132     if (obj instanceof BigInteger)
 133     {
 134       if (type ().indexOf ("unsigned") >= 0)
 135         return toUnsignedTarget ((BigInteger)obj);
 136       else
 137         return toSignedTarget ((BigInteger)obj);
 138     }
 139     return obj;
 140   } // coerceToTarget
 141 
 142   /**
 143    * Coerces an integral value (BigInteger) to its corresponding unsigned
 144    * representation, if the target type of this expression is unsigned.
 145    * @param b The BigInteger to be coerced.
 146    * @return the value of an integral type coerced to its corresponding
 147    *  unsigned integral type, if the target type of this expression is
 148    *  unsigned.
 149    **/
 150   protected BigInteger toUnsignedTarget (BigInteger b)
 151   {
 152     if (type ().equals ("unsigned short")) // target type of this expression
 153     {
 154       if (b != null && b.compareTo (zero) < 0) // error if value < min = -(2**(l-1)).
 155         return b.add (twoPow16);
 156     }
 157     else if (type ().equals ("unsigned long"))
 158     {
 159       if (b != null && b.compareTo (zero) < 0)
 160         return b.add (twoPow32);
 161     }
 162     else if (type ().equals ("unsigned long long"))
 163     {
 164       if (b != null && b.compareTo (zero) < 0)
 165         return b.add (twoPow64);
 166     }
 167     return b;
 168   } // toUnsignedTarget
 169 
 170   /**
 171    * Coerces an integral value (BigInteger) to its corresponding signed
 172    * representation, if the target type of this expression is signed.
 173    * @param  b  The BigInteger to be coerced.
 174    * @return  the value of an integral type coerced to its corresponding
 175    *  signed integral type, if the target type of this expression is
 176    *  signed.
 177    **/
 178   protected BigInteger toSignedTarget (BigInteger b)
 179   {
 180     if (type ().equals ("short"))
 181     {
 182       if (b != null && b.compareTo (sMax) > 0)
 183         return b.subtract (twoPow16);
 184     }
 185     else if (type ().equals ("long"))
 186     {
 187       if (b != null && b.compareTo (lMax) > 0)
 188         return b.subtract (twoPow32);
 189     }
 190     else if (type ().equals ("long long"))
 191     {
 192       if (b != null && b.compareTo (llMax) > 0)
 193         return b.subtract (twoPow64);
 194     }
 195     return b;
 196   } // toSignedTarget
 197 
 198   /**
 199    * Return the unsigned value of a BigInteger.
 200    **/
 201   protected BigInteger toUnsigned (BigInteger b)
 202   {
 203     if (b != null && b.signum () == -1)
 204       if (type ().equals ("short"))
 205         return b.add (twoPow16);
 206       else if (type ().equals ("long"))
 207         return b.add (twoPow32);
 208       else if (type ().equals ("long long"))
 209         return b.add (twoPow64);
 210     return b;
 211   }
 212 
 213   // Integral-type boundaries.
 214 
 215   public static final BigInteger negOne = BigInteger.valueOf (-1);
 216   public static final BigInteger zero   = BigInteger.valueOf (0);
 217   public static final BigInteger one    = BigInteger.valueOf (1);
 218   public static final BigInteger two    = BigInteger.valueOf (2);
 219 
 220   public static final BigInteger twoPow15 = two.pow (15);
 221   public static final BigInteger twoPow16 = two.pow (16);
 222   public static final BigInteger twoPow31 = two.pow (31);
 223   public static final BigInteger twoPow32 = two.pow (32);
 224   public static final BigInteger twoPow63 = two.pow (63);
 225   public static final BigInteger twoPow64 = two.pow (64);
 226 
 227   public static final BigInteger sMax = BigInteger.valueOf (Short.MAX_VALUE);
 228   public static final BigInteger sMin = BigInteger.valueOf (Short.MAX_VALUE);
 229 
 230   public static final BigInteger usMax = sMax.multiply (two).add (one);
 231   public static final BigInteger usMin = zero;
 232 
 233   public static final BigInteger lMax = BigInteger.valueOf (Integer.MAX_VALUE);
 234   public static final BigInteger lMin = BigInteger.valueOf (Integer.MAX_VALUE);
 235 
 236   public static final BigInteger ulMax = lMax.multiply (two).add (one);
 237   public static final BigInteger ulMin = zero;
 238 
 239   public static final BigInteger llMax = BigInteger.valueOf (Long.MAX_VALUE);
 240   public static final BigInteger llMin = BigInteger.valueOf (Long.MIN_VALUE);
 241 
 242   public static final BigInteger ullMax = llMax.multiply (two).add (one);
 243   public static final BigInteger ullMin = zero;
 244 
 245   /**
 246    * Value of this expression: Boolean, Char, Byte, BigInteger, Double,
 247    * String, Expression, ConstEntry.
 248    **/
 249   private Object _value = null;
 250   /**
 251    * String representation of this expression.
 252    **/
 253   private String _rep   = null;
 254   /**
 255    * Computation type of this (sub)expression = Target type for now.
 256    **/
 257   private String _type  = null;
 258 } // abstract class Expression