com.tangosol.dev.compiler.java.MinusExpression Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of coherence Show documentation
Show all versions of coherence Show documentation
Oracle Coherence Community Edition
/*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
package com.tangosol.dev.compiler.java;
import com.tangosol.dev.assembler.CodeAttribute;
import com.tangosol.dev.assembler.Dconst;
import com.tangosol.dev.assembler.Dneg;
import com.tangosol.dev.assembler.Fconst;
import com.tangosol.dev.assembler.Fneg;
import com.tangosol.dev.assembler.Iconst;
import com.tangosol.dev.assembler.Ineg;
import com.tangosol.dev.assembler.Lconst;
import com.tangosol.dev.assembler.Lneg;
import com.tangosol.dev.compiler.CompilerException;
import com.tangosol.dev.compiler.Context;
import com.tangosol.util.ErrorList;
import java.util.Map;
/**
* The unary minus (-) expression.
*
* @version 1.00, 10/05/98
* @author Cameron Purdy
*/
public class MinusExpression extends UnaryExpression
{
// ----- construction ---------------------------------------------------
/**
* Construct a MinusExpression.
*
* @param operator the operator token
* @param expr the sub-expression
*/
public MinusExpression(Token operator, Expression expr)
{
super(operator, expr);
}
// ----- code generation ------------------------------------------------
/**
* Perform semantic checks, parse tree re-organization, name binding,
* and optimizations.
*
* @param ctx the compiler context
* @param setUVars the set of potentially unassigned variables
* @param setFVars the set of potentially assigned final variables
* @param mapThrown the set of potentially thrown checked exceptions
* @param errlist the error list
*
* @return the resulting language element (typically this)
*
* @exception CompilerException thrown if an error occurs that should
* stop the compilation process
*/
protected Element precompile(Context ctx, DualSet setUVars, DualSet setFVars, Map mapThrown, ErrorList errlist)
throws CompilerException
{
// get the sub-expression
Expression expr = getExpression();
// pre-compile the sub-expression
expr = (Expression) expr.precompile(ctx, setUVars, setFVars, mapThrown, errlist);
// sub-expression must be numeric
if (expr.checkNumeric(errlist))
{
// numeric promotion is applied to the sub-expression
expr = expr.promoteNumeric();
// store the sub-expression
setExpression(expr);
// the result type is the type of the sub-expression
setType(expr.getType());
}
return this;
}
/**
* Perform final optimizations and code generation.
*
* @param ctx the compiler context
* @param code the assembler code attribute to compile to
* @param fReached true if this language element is reached (JLS 14.19)
* @param errlist the error list to log errors to
*
* @return true if the element can complete normally (JLS 14.1)
*
* @exception CompilerException thrown if an error occurs that should
* stop the compilation process
*/
protected boolean compile(Context ctx, CodeAttribute code, boolean fReached, ErrorList errlist)
throws CompilerException
{
Expression expr = getExpression();
char chType = expr.getType().getTypeString().charAt(0);
if (!ctx.isDebug() && expr.isConstant())
{
// get the constant value of the sub-expression
Object oVal = expr.getValue();
// produce code to load the negated value of the sub-expression
switch (chType)
{
case 'I':
{
int n = ((Number) oVal).intValue();
code.add(new Iconst(-n));
}
break;
case 'J':
{
long l = ((Number) oVal).longValue();
code.add(new Lconst(-l));
}
break;
case 'F':
{
float fl = ((Number) oVal).floatValue();
code.add(new Fconst(-fl));
}
break;
case 'D':
{
double dfl = ((Number) oVal).doubleValue();
code.add(new Dconst(-dfl));
}
break;
default:
// assert
throw new IllegalStateException("Illegal Type=" + chType);
}
}
else
{
// compile the sub-expression
expr.compile(ctx, code, fReached, errlist);
// negate the result
switch (chType)
{
case 'I':
code.add(new Ineg());
break;
case 'J':
code.add(new Lneg());
break;
case 'F':
code.add(new Fneg());
break;
case 'D':
code.add(new Dneg());
break;
default:
// assert
throw new IllegalStateException("Illegal Type=" + chType);
}
}
// normal completion possible if reachable
return fReached;
}
// ----- Expression methods ---------------------------------------------
/**
* Determine if the expression has a constant value.
*
* @return true if the expression results in a constant value
*/
public boolean isConstant()
{
return getExpression().isConstant();
}
/**
* Determine the constant value of the expression.
*
* @return the constant value of the expression
*/
public Object getValue()
{
Expression expr = getExpression();
char chType = expr.getType().getTypeString().charAt(0);
Object oVal = expr.getValue();
switch (chType)
{
case 'I':
return Integer.valueOf(-((Number) oVal). intValue());
case 'J':
return makeLong (-((Number) oVal). longValue());
case 'F':
return new Float (-((Number) oVal). floatValue());
case 'D':
return new Double (-((Number) oVal).doubleValue());
default:
// assert
throw new IllegalStateException("Illegal Type=" + chType);
}
}
// ----- data members ---------------------------------------------------
/**
* The class name.
*/
private static final String CLASS = "MinusExpression";
}