jdk8-mips64-public/corba: src/share/classes/com/sun/tools/corba/se/idl/constExpr/Expression.java@f90b3e014e83 (annotated)

src/share/classes/com/sun/tools/corba/se/idl/constExpr/Expression.java@f90b3e014e83 (annotated)

src/share/classes/com/sun/tools/corba/se/idl/constExpr/Expression.java

Tue, 28 Dec 2010 15:52:36 -0800

author: ohair
date: Tue, 28 Dec 2010 15:52:36 -0800
changeset 240: f90b3e014e83
parent 158: 91006f157c46
child 748: 6845b95cba6b
permissions: -rw-r--r--

6962318: Update copyright year
Reviewed-by: xdono

 /*
  * 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

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/tools/corba/se/idl/constExpr/Expression.java@f90b3e014e83 (annotated)

src/share/classes/com/sun/tools/corba/se/idl/constExpr/Expression.java