Mercurial > jdk8-mips64-public > corba / file revision

 /*

  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the LICENSE file that accompanied this code.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 /*

  * COMPONENT_NAME: idl.parser

  *

  * ORIGINS: 27

  *

  * Licensed Materials - Property of IBM

  * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999

  * RMI-IIOP v1.0

  *

  */

 package com.sun.tools.corba.se.idl.constExpr;

 // NOTES:

 import java.math.BigInteger;

 public abstract class Expression

 {

   /**

    * Compute the value of this expression.

    **/

   public abstract Object evaluate () throws EvaluationException;

   /**

    * Set the value of this expression.

    **/

   public void value (Object value)

   {

     _value = value;

   }

   /**

    * Get the value of this expression.

    **/

   public Object value ()

   {

     return _value;

   }

   /**

    * Set the representation of this expression.

    **/

   public void rep (String rep)

   {

     _rep = rep;

   }

   /**

    * Get the representation of this expression.

    **/

   public String rep ()

   {

     return _rep;

   }

   /**

    * Set the target type of this expression.

    **/

   public void type (String type)

   {

     _type = type;

   }

   /**

    * Get the target type of this expression.

    **/

   public String type ()

   {

     return _type;

   }

   /**

    * Return the default computation type for the given target type.

    **/

   protected static String defaultType (String targetType)

   {

     return (targetType == null) ? new String ("") : targetType;

   } // defaultType

   // BigInteger is a multi-precision number whose representation contains

   // a signum (sign-number = 1, -1) and a magnitude.  To support "long long",

   // all integer expressions are now performed over BigInteger and stored as

   // such.  During the evaluation of an integer expression, the signum of its

   // value may toggle, which may cause the value of an expression to conflict

   // with its target type: [Case 1] If the resulting value is negative

   // (signum=-1) and the target type is unsigned; or [Case 2] if the resulting

   // value is positive (signum=1) and greater than 2**(target-type-length - 1),

   // and the target type is signed, then the resulting value will be out of

   // range.  However, this value is correct and must be coerced to the target

   // type.  E.G., After appying "not" to a BigInteger, the result is

   // a BigInteger that represents its 2's-complement (~5 => -6 in a byte-space).

   // In this example, the signum toggles and the magnatude is 6.  If the target

   // type of this value were unsigned short, it must be coerced to a positive

   // number whose bits truly represent -6 in 2's-complement (250 in a byte-space).

   //

   // Also, floating types may now be intialized with any integer expression.

   // The result must be coerced to Double.

   //

   // Use the following routines to coerce this expression's value to its

   // "target" type.

   /**

    * Coerces a number to the target type of this expression.

    * @param  obj  The number to coerce.

    * @return  the value of number coerced to the (target) type of

    *  this expression.

    **/

   public Object coerceToTarget (Object obj)

   {

     if (obj instanceof BigInteger)

     {

       if (type ().indexOf ("unsigned") >= 0)

         return toUnsignedTarget ((BigInteger)obj);

       else

         return toSignedTarget ((BigInteger)obj);

     }

     return obj;

   } // coerceToTarget

   /**

    * Coerces an integral value (BigInteger) to its corresponding unsigned

    * representation, if the target type of this expression is unsigned.

    * @param b The BigInteger to be coerced.

    * @return the value of an integral type coerced to its corresponding

    *  unsigned integral type, if the target type of this expression is

    *  unsigned.

    **/

   protected BigInteger toUnsignedTarget (BigInteger b)

   {

     if (type ().equals ("unsigned short")) // target type of this expression

     {

       if (b != null && b.compareTo (zero) < 0) // error if value < min = -(2**(l-1)).

         return b.add (twoPow16);

     }

     else if (type ().equals ("unsigned long"))

     {

       if (b != null && b.compareTo (zero) < 0)

         return b.add (twoPow32);

     }

     else if (type ().equals ("unsigned long long"))

     {

       if (b != null && b.compareTo (zero) < 0)

         return b.add (twoPow64);

     }

     return b;

   } // toUnsignedTarget

   /**

    * Coerces an integral value (BigInteger) to its corresponding signed

    * representation, if the target type of this expression is signed.

    * @param  b  The BigInteger to be coerced.

    * @return  the value of an integral type coerced to its corresponding

    *  signed integral type, if the target type of this expression is

    *  signed.

    **/

   protected BigInteger toSignedTarget (BigInteger b)

   {

     if (type ().equals ("short"))

     {

       if (b != null && b.compareTo (sMax) > 0)

         return b.subtract (twoPow16);

     }

     else if (type ().equals ("long"))

     {

       if (b != null && b.compareTo (lMax) > 0)

         return b.subtract (twoPow32);

     }

     else if (type ().equals ("long long"))

     {

       if (b != null && b.compareTo (llMax) > 0)

         return b.subtract (twoPow64);

     }

     return b;

   } // toSignedTarget

   /**

    * Return the unsigned value of a BigInteger.

    **/

   protected BigInteger toUnsigned (BigInteger b)

   {

     if (b != null && b.signum () == -1)

       if (type ().equals ("short"))

         return b.add (twoPow16);

       else if (type ().equals ("long"))

         return b.add (twoPow32);

       else if (type ().equals ("long long"))

         return b.add (twoPow64);

     return b;

   }

   // Integral-type boundaries.

   public static final BigInteger negOne = BigInteger.valueOf (-1);

   public static final BigInteger zero   = BigInteger.valueOf (0);

   public static final BigInteger one    = BigInteger.valueOf (1);

   public static final BigInteger two    = BigInteger.valueOf (2);

   public static final BigInteger twoPow15 = two.pow (15);

   public static final BigInteger twoPow16 = two.pow (16);

   public static final BigInteger twoPow31 = two.pow (31);

   public static final BigInteger twoPow32 = two.pow (32);

   public static final BigInteger twoPow63 = two.pow (63);

   public static final BigInteger twoPow64 = two.pow (64);

   public static final BigInteger sMax = BigInteger.valueOf (Short.MAX_VALUE);

   public static final BigInteger sMin = BigInteger.valueOf (Short.MAX_VALUE);

   public static final BigInteger usMax = sMax.multiply (two).add (one);

   public static final BigInteger usMin = zero;

   public static final BigInteger lMax = BigInteger.valueOf (Integer.MAX_VALUE);

   public static final BigInteger lMin = BigInteger.valueOf (Integer.MAX_VALUE);

   public static final BigInteger ulMax = lMax.multiply (two).add (one);

   public static final BigInteger ulMin = zero;

   public static final BigInteger llMax = BigInteger.valueOf (Long.MAX_VALUE);

   public static final BigInteger llMin = BigInteger.valueOf (Long.MIN_VALUE);

   public static final BigInteger ullMax = llMax.multiply (two).add (one);

   public static final BigInteger ullMin = zero;

   /**

    * Value of this expression: Boolean, Char, Byte, BigInteger, Double,

    * String, Expression, ConstEntry.

    **/

   private Object _value = null;

   /**

    * String representation of this expression.

    **/

   private String _rep   = null;

   /**

    * Computation type of this (sub)expression = Target type for now.

    **/

   private String _type  = null;

 } // abstract class Expression