xdatatype.java

A framework written in Java for implementing high-level and dynamic languages, compiling them into J

        return super.isInstance(obj);
      }
  }

  public void emitIsInstance(Variable incoming,
			     Compilation comp, Target target)
  {
    gnu.kawa.reflect.InstanceOf.emitIsInstance(this, incoming, comp, target);
  }

  public String toString (Object value)
  {
    return value.toString();
  }


  public void print (Object value, Consumer out)
  {
    if (value instanceof Printable)
      ((Printable) value).print(out);
    else
      out.write(toString(value));
  }

  public boolean castable (Object value)
  {
    try
      {
        // FIXME - inefficient!
        cast(value);
        return true;
      }
    catch (Throwable ex)
      {
        return false;
      }
  }

  public Object cast (Object value)
  {
    value = KNode.atomicValue(value);
    if (value instanceof UntypedAtomic)
      {
        if (typeCode == UNTYPED_ATOMIC_TYPE_CODE)
          return value;
        return valueOf(value.toString());
      }
    if (value instanceof String)
      return valueOf(value.toString());
    switch (typeCode)
      {
      case STRING_TYPE_CODE:
        return TextUtils.asString(value);
      case UNTYPED_ATOMIC_TYPE_CODE:
        return new UntypedAtomic(TextUtils.stringValue(value));
      case ANY_URI_TYPE_CODE:
        return URIPath.makeURI(value);
      case BOOLEAN_TYPE_CODE:
        if (value instanceof Boolean)
          return (((Boolean)value).booleanValue() ? Boolean.TRUE
                  : Boolean.FALSE);
        if (value instanceof Number)
          {
            double d = ((Number) value).doubleValue();
            return d == 0.0 || Double.isNaN(d) ? Boolean.FALSE : Boolean.TRUE;
          }
        break;
      case DECIMAL_TYPE_CODE:
        // Partly duplicates Arithmetic asBigDecimal.
        if (value instanceof java.math.BigDecimal)
          return value;
        if (value instanceof gnu.math.RealNum)
          return ((gnu.math.RealNum) value).asBigDecimal();
        if (value instanceof Float || value instanceof Double)
          {
            double d = ((Number) value).doubleValue();
            /* #ifdef JAVA5 */
            // return BigDecimal.valueOf(d);
            /* #else */
            return new BigDecimal(d);
            /* #endif */
          }
        if (value instanceof Boolean)
          return cast(((Boolean)value).booleanValue() ? IntNum.one()
                      : IntNum.zero());
        break;
      case FLOAT_TYPE_CODE:
        if (value instanceof java.lang.Float)
          return value;
        if (value instanceof java.lang.Number)
          // Wrong for complex numbers with non-zero imaginary part.  FIXME.
          return makeFloat(((Number) value).floatValue());
        if (value instanceof Boolean)
          return ((Boolean)value).booleanValue() ? FLOAT_ONE : FLOAT_ZERO;
        break;
      case DOUBLE_TYPE_CODE:
        if (value instanceof java.lang.Double)
          return value;
        if (value instanceof java.lang.Number)
          // Wrong for complex numbers with non-zero imaginary part.  FIXME.
          return makeDouble(((Number) value).doubleValue());
        if (value instanceof Boolean)
          return ((Boolean)value).booleanValue() ? DOUBLE_ONE : DOUBLE_ZERO;
        break;
      case G_YEAR_TYPE_CODE:
      case G_YEAR_MONTH_TYPE_CODE:
      case G_MONTH_TYPE_CODE:
      case G_MONTH_DAY_TYPE_CODE:
      case G_DAY_TYPE_CODE:
        if (value instanceof DateTime)
          {
            int dstMask = XTimeType.components(((XTimeType) this).typeCode);
            DateTime dt = (DateTime) value;
            int srcMask = dt.components();
            if (dstMask == srcMask
                || (srcMask & DateTime.DATE_MASK) == DateTime.DATE_MASK)
              return dt.cast(dstMask);
            throw new ClassCastException();
          }
        break;
      case DATE_TYPE_CODE:
      case TIME_TYPE_CODE:
      case DATE_TIME_TYPE_CODE:
        if (value instanceof DateTime)
          {
            int mask = XTimeType.components(((XTimeType) this).typeCode);
            return ((DateTime) value).cast(mask);
          }
        break;
      case DURATION_TYPE_CODE:
        return castToDuration(value, Unit.duration);
      case YEAR_MONTH_DURATION_TYPE_CODE:
        return castToDuration(value, Unit.month);
      case DAY_TIME_DURATION_TYPE_CODE:
        return castToDuration(value, Unit.second);
      case BASE64_BINARY_TYPE_CODE:
        if (value instanceof BinaryObject)
          return new Base64Binary(((BinaryObject) value).getBytes());
      case HEX_BINARY_TYPE_CODE:
        if (value instanceof BinaryObject)
          return new HexBinary(((BinaryObject) value).getBytes());
      }
    return coerceFromObject(value);
  }

  Duration castToDuration (Object value, Unit unit)
  {
    if (value instanceof Duration)
      {
        Duration dur = (Duration) value;
        if (dur.unit() == unit)
          return dur;
        int months = dur.getTotalMonths();
        long seconds = dur.getTotalSeconds();
        int nanos = dur.getNanoSecondsOnly();
        if (unit == Unit.second)
          months = 0;
        if (unit == Unit.month)
          {
            seconds = 0;
            nanos = 0;
          }
        return Duration.make(months, seconds, nanos, unit);
      }
    return (Duration) coerceFromObject(value);
  }

  public Object coerceFromObject (Object obj)
  {
    if (! isInstance(obj))
      throw new ClassCastException("cannot cast "+obj+" to "+name);
    return obj;
  }

  public int compare(Type other)
  {
    if (this == other
        || (this == stringStringType && other == stringType)
        || (this == stringType && other == stringStringType))
      return 0;
    return implementationType.compare(other); // FIXME
  }

  public Object valueOf (String value)
  {
    switch (typeCode)
      {
      case STRING_TYPE_CODE:
        return value;
      case UNTYPED_ATOMIC_TYPE_CODE:
        return new UntypedAtomic(value);
      case ANY_URI_TYPE_CODE:
        return URIPath.makeURI(TextUtils.replaceWhitespace(value, true));
      case BOOLEAN_TYPE_CODE:
        value = value.trim();
        if (value.equals("true") || value.equals("1"))
          return Boolean.TRUE;
        if (value.equals("false") || value.equals("0"))
          return Boolean.FALSE;
        throw new IllegalArgumentException("not a valid boolean: '"+value+"'");
      case FLOAT_TYPE_CODE:
      case DOUBLE_TYPE_CODE:
        value = value.trim();
        if ("INF".equals(value)) value = "Infinity";
        else if ("-INF".equals(value)) value = "-Infinity";
        return typeCode ==  FLOAT_TYPE_CODE ? (Object) Float.valueOf(value)
          : (Object) Double.valueOf(value);
      case DECIMAL_TYPE_CODE:
        value = value.trim();
        // The BigDecimal constructor accepts an exponent.
        // So check and complain if that exists.
        for (int i = value.length();  --i >= 0; )
          {
            char ch = value.charAt(i);
            if (ch == 'e' || ch == 'E')
              throw new IllegalArgumentException("not a valid decimal: '"+value+"'");
          }
        return new java.math.BigDecimal(value);
      case DURATION_TYPE_CODE:
        return Duration.parseDuration(value);
      case YEAR_MONTH_DURATION_TYPE_CODE:
        return Duration.parseYearMonthDuration(value);
      case DAY_TIME_DURATION_TYPE_CODE:
        return Duration.parseDayTimeDuration(value);
      case BASE64_BINARY_TYPE_CODE:
        return Base64Binary.valueOf(value);
      case HEX_BINARY_TYPE_CODE:
        return HexBinary.valueOf(value);
      default:
        throw new RuntimeException("valueOf not implemented for "+name);
      }
  }

  public static Float makeFloat (float value)
  {
    /* #ifdef JAVA5 */
    // return Float.valueOf(value);
    /* #else */
    return new Float(value);
    /* #endif */
  }

  public static Double makeDouble (double value)
  {
    /* #ifdef JAVA5 */
    // return Double.valueOf(value);
    /* #else */
    return new Double(value);
    /* #endif */
  }

  public static final Double DOUBLE_ZERO = makeDouble(0);
  public static final Double DOUBLE_ONE = makeDouble(1);
  public static final Float FLOAT_ZERO = makeFloat(0);
  public static final Float FLOAT_ONE = makeFloat(1);
  public static final BigDecimal DECIMAL_ONE = BigDecimal.valueOf(1);

  public Procedure getConstructor ()
  {
    return null;
  }
}