idl/constExpr/Expression.java

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