com.hazelcast.shaded.org.codehaus.janino.UnitCompiler Maven / Gradle / Ivy
/*
* Janino - An embedded Java[TM] compiler
*
* Copyright (c) 2001-2019 Arno Unkrig. All rights reserved.
* Copyright (c) 2015-2016 TIBCO Software Inc. All rights reserved. // CHECKSTYLE:OFF CHECKSTYLE:ON
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.hazelcast.shaded.org.codehaus.janino;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedMap;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import com.hazelcast.shaded.org.codehaus.commons.compiler.CompileException;
import com.hazelcast.shaded.org.codehaus.commons.compiler.ErrorHandler;
import com.hazelcast.shaded.org.codehaus.commons.compiler.InternalCompilerException;
import com.hazelcast.shaded.org.codehaus.commons.compiler.Location;
import com.hazelcast.shaded.org.codehaus.commons.compiler.WarningHandler;
import com.hazelcast.shaded.org.codehaus.commons.compiler.util.Numbers;
import com.hazelcast.shaded.org.codehaus.commons.compiler.util.SystemProperties;
import com.hazelcast.shaded.org.codehaus.commons.compiler.util.iterator.Iterables;
import com.hazelcast.shaded.org.codehaus.commons.nullanalysis.Nullable;
import com.hazelcast.shaded.org.codehaus.janino.CodeContext.BasicBlock;
import com.hazelcast.shaded.org.codehaus.janino.CodeContext.Inserter;
import com.hazelcast.shaded.org.codehaus.janino.CodeContext.Offset;
import com.hazelcast.shaded.org.codehaus.janino.IClass.IAnnotation;
import com.hazelcast.shaded.org.codehaus.janino.IClass.IConstructor;
import com.hazelcast.shaded.org.codehaus.janino.IClass.IField;
import com.hazelcast.shaded.org.codehaus.janino.IClass.IInvocable;
import com.hazelcast.shaded.org.codehaus.janino.IClass.IMethod;
import com.hazelcast.shaded.org.codehaus.janino.Java.AbstractClassDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.AbstractCompilationUnit;
import com.hazelcast.shaded.org.codehaus.janino.Java.AbstractCompilationUnit.ImportDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.AbstractCompilationUnit.SingleStaticImportDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.AbstractCompilationUnit.SingleTypeImportDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.AbstractCompilationUnit.StaticImportOnDemandDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.AbstractCompilationUnit.TypeImportOnDemandDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.AbstractTypeDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.AccessModifier;
import com.hazelcast.shaded.org.codehaus.janino.Java.AlternateConstructorInvocation;
import com.hazelcast.shaded.org.codehaus.janino.Java.AmbiguousName;
import com.hazelcast.shaded.org.codehaus.janino.Java.Annotation;
import com.hazelcast.shaded.org.codehaus.janino.Java.AnnotationTypeDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.AnonymousClassDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.ArrayAccessExpression;
import com.hazelcast.shaded.org.codehaus.janino.Java.ArrayCreationReference;
import com.hazelcast.shaded.org.codehaus.janino.Java.ArrayInitializer;
import com.hazelcast.shaded.org.codehaus.janino.Java.ArrayInitializerOrRvalue;
import com.hazelcast.shaded.org.codehaus.janino.Java.ArrayLength;
import com.hazelcast.shaded.org.codehaus.janino.Java.ArrayType;
import com.hazelcast.shaded.org.codehaus.janino.Java.AssertStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.Assignment;
import com.hazelcast.shaded.org.codehaus.janino.Java.Atom;
import com.hazelcast.shaded.org.codehaus.janino.Java.BinaryOperation;
import com.hazelcast.shaded.org.codehaus.janino.Java.Block;
import com.hazelcast.shaded.org.codehaus.janino.Java.BlockStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.BooleanLiteral;
import com.hazelcast.shaded.org.codehaus.janino.Java.BooleanRvalue;
import com.hazelcast.shaded.org.codehaus.janino.Java.BreakStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.BreakableStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.Cast;
import com.hazelcast.shaded.org.codehaus.janino.Java.CatchClause;
import com.hazelcast.shaded.org.codehaus.janino.Java.CatchParameter;
import com.hazelcast.shaded.org.codehaus.janino.Java.CharacterLiteral;
import com.hazelcast.shaded.org.codehaus.janino.Java.ClassInstanceCreationReference;
import com.hazelcast.shaded.org.codehaus.janino.Java.ClassLiteral;
import com.hazelcast.shaded.org.codehaus.janino.Java.CompilationUnit;
import com.hazelcast.shaded.org.codehaus.janino.Java.ConditionalExpression;
import com.hazelcast.shaded.org.codehaus.janino.Java.ConstructorDeclarator;
import com.hazelcast.shaded.org.codehaus.janino.Java.ConstructorInvocation;
import com.hazelcast.shaded.org.codehaus.janino.Java.ContinuableStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.ContinueStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.Crement;
import com.hazelcast.shaded.org.codehaus.janino.Java.DoStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.DocCommentable;
import com.hazelcast.shaded.org.codehaus.janino.Java.ElementValue;
import com.hazelcast.shaded.org.codehaus.janino.Java.ElementValueArrayInitializer;
import com.hazelcast.shaded.org.codehaus.janino.Java.ElementValuePair;
import com.hazelcast.shaded.org.codehaus.janino.Java.EmptyStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.EnclosingScopeOfTypeDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.EnumConstant;
import com.hazelcast.shaded.org.codehaus.janino.Java.EnumDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.ExpressionStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.FieldAccess;
import com.hazelcast.shaded.org.codehaus.janino.Java.FieldAccessExpression;
import com.hazelcast.shaded.org.codehaus.janino.Java.FieldDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.FieldDeclarationOrInitializer;
import com.hazelcast.shaded.org.codehaus.janino.Java.FloatingPointLiteral;
import com.hazelcast.shaded.org.codehaus.janino.Java.ForEachStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.ForStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.FunctionDeclarator;
import com.hazelcast.shaded.org.codehaus.janino.Java.FunctionDeclarator.FormalParameter;
import com.hazelcast.shaded.org.codehaus.janino.Java.FunctionDeclarator.FormalParameters;
import com.hazelcast.shaded.org.codehaus.janino.Java.IfStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.Initializer;
import com.hazelcast.shaded.org.codehaus.janino.Java.InnerClassDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.Instanceof;
import com.hazelcast.shaded.org.codehaus.janino.Java.IntegerLiteral;
import com.hazelcast.shaded.org.codehaus.janino.Java.InterfaceDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.Invocation;
import com.hazelcast.shaded.org.codehaus.janino.Java.LabeledStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.LambdaExpression;
import com.hazelcast.shaded.org.codehaus.janino.Java.Literal;
import com.hazelcast.shaded.org.codehaus.janino.Java.LocalClassDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.LocalClassDeclarationStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.LocalVariable;
import com.hazelcast.shaded.org.codehaus.janino.Java.LocalVariableAccess;
import com.hazelcast.shaded.org.codehaus.janino.Java.LocalVariableDeclarationStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.LocalVariableSlot;
import com.hazelcast.shaded.org.codehaus.janino.Java.Locatable;
import com.hazelcast.shaded.org.codehaus.janino.Java.Located;
import com.hazelcast.shaded.org.codehaus.janino.Java.Lvalue;
import com.hazelcast.shaded.org.codehaus.janino.Java.MarkerAnnotation;
import com.hazelcast.shaded.org.codehaus.janino.Java.MemberAnnotationTypeDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.MemberClassDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.MemberEnumDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.MemberInterfaceDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.MemberTypeDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.MethodDeclarator;
import com.hazelcast.shaded.org.codehaus.janino.Java.MethodInvocation;
import com.hazelcast.shaded.org.codehaus.janino.Java.MethodReference;
import com.hazelcast.shaded.org.codehaus.janino.Java.Modifier;
import com.hazelcast.shaded.org.codehaus.janino.Java.ModularCompilationUnit;
import com.hazelcast.shaded.org.codehaus.janino.Java.NamedClassDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.NamedTypeDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.NewAnonymousClassInstance;
import com.hazelcast.shaded.org.codehaus.janino.Java.NewArray;
import com.hazelcast.shaded.org.codehaus.janino.Java.NewClassInstance;
import com.hazelcast.shaded.org.codehaus.janino.Java.NewInitializedArray;
import com.hazelcast.shaded.org.codehaus.janino.Java.NormalAnnotation;
import com.hazelcast.shaded.org.codehaus.janino.Java.NullLiteral;
import com.hazelcast.shaded.org.codehaus.janino.Java.Package;
import com.hazelcast.shaded.org.codehaus.janino.Java.PackageDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.PackageMemberAnnotationTypeDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.PackageMemberClassDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.PackageMemberEnumDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.PackageMemberInterfaceDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.PackageMemberTypeDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.Padder;
import com.hazelcast.shaded.org.codehaus.janino.Java.ParameterAccess;
import com.hazelcast.shaded.org.codehaus.janino.Java.ParenthesizedExpression;
import com.hazelcast.shaded.org.codehaus.janino.Java.Primitive;
import com.hazelcast.shaded.org.codehaus.janino.Java.PrimitiveType;
import com.hazelcast.shaded.org.codehaus.janino.Java.QualifiedThisReference;
import com.hazelcast.shaded.org.codehaus.janino.Java.ReferenceType;
import com.hazelcast.shaded.org.codehaus.janino.Java.ReturnStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.Rvalue;
import com.hazelcast.shaded.org.codehaus.janino.Java.RvalueMemberType;
import com.hazelcast.shaded.org.codehaus.janino.Java.Scope;
import com.hazelcast.shaded.org.codehaus.janino.Java.SimpleConstant;
import com.hazelcast.shaded.org.codehaus.janino.Java.SimpleType;
import com.hazelcast.shaded.org.codehaus.janino.Java.SingleElementAnnotation;
import com.hazelcast.shaded.org.codehaus.janino.Java.Statement;
import com.hazelcast.shaded.org.codehaus.janino.Java.StringLiteral;
import com.hazelcast.shaded.org.codehaus.janino.Java.SuperConstructorInvocation;
import com.hazelcast.shaded.org.codehaus.janino.Java.SuperclassFieldAccessExpression;
import com.hazelcast.shaded.org.codehaus.janino.Java.SuperclassMethodInvocation;
import com.hazelcast.shaded.org.codehaus.janino.Java.SwitchStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.SwitchStatement.SwitchBlockStatementGroup;
import com.hazelcast.shaded.org.codehaus.janino.Java.SynchronizedStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.ThisReference;
import com.hazelcast.shaded.org.codehaus.janino.Java.ThrowStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.TryStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.TryStatement.LocalVariableDeclaratorResource;
import com.hazelcast.shaded.org.codehaus.janino.Java.TryStatement.VariableAccessResource;
import com.hazelcast.shaded.org.codehaus.janino.Java.Type;
import com.hazelcast.shaded.org.codehaus.janino.Java.TypeArgument;
import com.hazelcast.shaded.org.codehaus.janino.Java.TypeBodyDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.TypeDeclaration;
import com.hazelcast.shaded.org.codehaus.janino.Java.TypeParameter;
import com.hazelcast.shaded.org.codehaus.janino.Java.UnaryOperation;
import com.hazelcast.shaded.org.codehaus.janino.Java.VariableDeclarator;
import com.hazelcast.shaded.org.codehaus.janino.Java.WhileStatement;
import com.hazelcast.shaded.org.codehaus.janino.Java.Wildcard;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.AbstractCompilationUnitVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.AnnotationVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.ArrayInitializerOrRvalueVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.AtomVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.BlockStatementVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.ElementValueVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.FunctionDeclaratorVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.ImportVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.LvalueVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.RvalueVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.TryStatementResourceVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.TypeDeclarationVisitor;
import com.hazelcast.shaded.org.codehaus.janino.Visitor.TypeVisitor;
import com.hazelcast.shaded.org.codehaus.janino.util.Annotatable;
import com.hazelcast.shaded.org.codehaus.janino.util.ClassFile;
import com.hazelcast.shaded.org.codehaus.janino.util.ClassFile.ClassFileException;
import com.hazelcast.shaded.org.codehaus.janino.util.ClassFile.StackMapTableAttribute;
import com.hazelcast.shaded.org.codehaus.janino.util.ClassFile.StackMapTableAttribute.ObjectVariableInfo;
import com.hazelcast.shaded.org.codehaus.janino.util.ClassFile.StackMapTableAttribute.VerificationTypeInfo;
/**
* This class actually implements the Java compiler. It is associated with exactly one compilation unit which it
* compiles.
*/
public
class UnitCompiler {
private static final Logger LOGGER = Logger.getLogger(UnitCompiler.class.getName());
private static final int defaultTargetVersion = SystemProperties.getIntegerClassProperty(UnitCompiler.class, "defaultTargetVersion", -1);
/**
* This constant determines the number of operands up to which the
*
* a.concat(b).concat(c)
*
*
* strategy is used to implement string concatenation. For more operands, the
*
*
* new StringBuilder(a).append(b).append(c).append(d).toString()
*
* strategy is chosen.
*
* A very good article from
* Tom Gibara analyzes the impact of this decision and recommends a value of three.
*
*/
private static final int STRING_CONCAT_LIMIT = 3;
/**
* Special value for the orientation parameter of the {@link #compileBoolean(Java.Rvalue,
* CodeContext.Offset, boolean)} methods, indicating that the code should be generated such that execution branches
* if the value on top of the operand stack is TRUE.
*/
public static final boolean JUMP_IF_TRUE = true;
/**
* Special value for the orientation parameter of the {@link #compileBoolean(Java.Rvalue,
* CodeContext.Offset, boolean)} methods, indicating that the code should be generated such that execution branches
* if the value on top of the operand stack is FALSE.
*/
public static final boolean JUMP_IF_FALSE = false;
private static final Pattern LOOKS_LIKE_TYPE_PARAMETER = Pattern.compile("\\p{javaUpperCase}+");
private EnumSet options = EnumSet.noneOf(JaninoOption.class);
/**
* Java version to compile for.
*/
private int targetVersion = -1;
public
UnitCompiler(AbstractCompilationUnit abstractCompilationUnit, IClassLoader iClassLoader) {
this.abstractCompilationUnit = abstractCompilationUnit;
this.iClassLoader = iClassLoader;
}
/**
* @return A reference to the currently effective compilation options; changes to it take
* effect immediately
*/
public EnumSet
options() { return this.options; }
/**
* Sets the options for all future compilations.
*/
public UnitCompiler
options(EnumSet options) {
this.options = options;
return this;
}
/**
* Generates class files that target a specified release of the virtual machine, in analogy with JAVAC's {@code
* -target} command line option.
* By default, Java 6 .class files are generated.
*/
public void
setTargetVersion(int version) { this.targetVersion = version; }
/**
* @return The {@link AbstractCompilationUnit} that this {@link UnitCompiler} compiles
*/
public AbstractCompilationUnit
getAbstractCompilationUnit() { return this.abstractCompilationUnit; }
/**
* Generates a set of {@link ClassFile} objects which represent the classes and interfaces declared in the
* compilation unit.
*
* @param generatedClassFiles Adds generated {@link ClassFile}s to this {@link Collection}
*/
public void
compileUnit(
boolean debugSource,
boolean debugLines,
boolean debugVars,
final Collection generatedClassFiles
) throws CompileException {
this.compileUnit(
debugSource,
debugLines,
debugVars,
new ClassFileConsumer() { @Override public void consume(ClassFile classFile) { generatedClassFiles.add(classFile); }
});
}
/**
* Generates a set of {@link ClassFile} objects which represent the classes and interfaces declared in the
* compilation unit.
*
* @param storesClassFiles Consumes each generated {@link ClassFile}
*/
public void
compileUnit(boolean debugSource, boolean debugLines, boolean debugVars, ClassFileConsumer storesClassFiles)
throws CompileException {
this.debugSource = debugSource;
this.debugLines = debugLines;
this.debugVars = debugVars;
if (this.storesClassFiles != null) {
throw new IllegalStateException("\"UnitCompiler.compileUnit()\" is not reentrant");
}
this.storesClassFiles = storesClassFiles;
try {
this.abstractCompilationUnit.accept(new AbstractCompilationUnitVisitor() {
@Override @Nullable public Void visitCompilationUnit(CompilationUnit cu) throws CompileException { UnitCompiler.this.compile2(cu); return null; }
@Override @Nullable public Void visitModularCompilationUnit(ModularCompilationUnit mcu) throws CompileException { UnitCompiler.this.compile2(mcu); return null; }
});
if (this.compileErrorCount > 0) {
throw new CompileException((
this.compileErrorCount
+ " error(s) while compiling unit \""
+ this.abstractCompilationUnit.fileName
+ "\""
), null);
}
} finally {
this.storesClassFiles = null;
}
}
public
interface ClassFileConsumer {
void consume(ClassFile classFile) throws IOException;
}
/**
* Compiles an (ordinary, not modular) compilation unit
*/
private void
compile2(CompilationUnit cu) throws CompileException {
for (PackageMemberTypeDeclaration pmtd : cu.packageMemberTypeDeclarations) {
try {
this.compile(pmtd);
} catch (ClassFileException cfe) {
throw new CompileException(cfe.getMessage(), pmtd.getLocation(), cfe);
} catch (RuntimeException re) {
throw new InternalCompilerException((
"Compiling \""
+ pmtd
+ "\" in "
+ pmtd.getLocation()
+ ": "
+ re.getMessage()
), re);
}
}
}
private void
compile2(ModularCompilationUnit mcu) throws CompileException {
this.compileError("Compilation of modular compilation unit not implemented");
}
// ------------ TypeDeclaration.compile() -------------
private void
compile(TypeDeclaration td) throws CompileException {
td.accept(new TypeDeclarationVisitor() {
@Override @Nullable public Void visitAnonymousClassDeclaration(AnonymousClassDeclaration acd) throws CompileException { UnitCompiler.this.compile2(acd); return null; }
@Override @Nullable public Void visitLocalClassDeclaration(LocalClassDeclaration lcd) throws CompileException { UnitCompiler.this.compile2(lcd); return null; }
@Override @Nullable public Void visitPackageMemberClassDeclaration(PackageMemberClassDeclaration pmcd) throws CompileException { UnitCompiler.this.compile2(pmcd); return null; }
@Override @Nullable public Void visitMemberInterfaceDeclaration(MemberInterfaceDeclaration mid) throws CompileException { UnitCompiler.this.compile2(mid); return null; }
@Override @Nullable public Void visitPackageMemberInterfaceDeclaration(PackageMemberInterfaceDeclaration pmid) throws CompileException { UnitCompiler.this.compile2(pmid); return null; }
@Override @Nullable public Void visitMemberClassDeclaration(MemberClassDeclaration mcd) throws CompileException { UnitCompiler.this.compile2((InnerClassDeclaration) mcd); return null; }
@Override @Nullable public Void visitMemberEnumDeclaration(MemberEnumDeclaration med) throws CompileException { UnitCompiler.this.compile2((InnerClassDeclaration) med); return null; }
@Override @Nullable public Void visitPackageMemberEnumDeclaration(PackageMemberEnumDeclaration pmed) throws CompileException { UnitCompiler.this.compile2(pmed); return null; }
@Override @Nullable public Void visitPackageMemberAnnotationTypeDeclaration(PackageMemberAnnotationTypeDeclaration pmatd) throws CompileException { UnitCompiler.this.compile2(pmatd); return null; }
@Override @Nullable public Void visitEnumConstant(EnumConstant ec) throws CompileException { UnitCompiler.this.compileError("Compilation of enum constant NYI", ec.getLocation()); return null; }
@Override @Nullable public Void visitMemberAnnotationTypeDeclaration(MemberAnnotationTypeDeclaration matd) throws CompileException { UnitCompiler.this.compileError("Compilation of member annotation type declaration NYI", matd.getLocation()); return null; }
});
}
/**
* Compiles a top-level class or enum declaration.
*/
private void
compile2(PackageMemberClassDeclaration pmcd) throws CompileException {
this.checkForConflictWithSingleTypeImport(pmcd.getName(), pmcd.getLocation());
this.checkForNameConflictWithAnotherPackageMemberTypeDeclaration(pmcd);
this.compile2((NamedClassDeclaration) pmcd);
}
/**
* Compiles a top-level interface or annotation type declaration.
*/
private void
compile2(PackageMemberInterfaceDeclaration pmid) throws CompileException {
this.checkForConflictWithSingleTypeImport(pmid.getName(), pmid.getLocation());
this.checkForNameConflictWithAnotherPackageMemberTypeDeclaration(pmid);
this.compile2((InterfaceDeclaration) pmid);
}
/**
* @see JLS8, section 7.6, "Top Level Type Declarations"
*/
private void
checkForNameConflictWithAnotherPackageMemberTypeDeclaration(PackageMemberTypeDeclaration pmtd)
throws CompileException {
CompilationUnit declaringCompilationUnit = pmtd.getDeclaringCompilationUnit();
String name = pmtd.getName();
PackageMemberTypeDeclaration otherPmtd = declaringCompilationUnit.getPackageMemberTypeDeclaration(
name
);
if (otherPmtd != null && otherPmtd != pmtd) {
this.compileError(
"Redeclaration of type \"" + name + "\", previously declared in " + otherPmtd.getLocation()
,
pmtd.getLocation()
);
}
}
/**
* @see JLS8, section 7.6, "Top Level Type Declarations"
*/
private void
checkForConflictWithSingleTypeImport(String name, Location location) throws CompileException {
String[] ss = this.getSingleTypeImport(name, location);
if (ss != null) {
this.compileError((
"Package member type declaration \""
+ name
+ "\" conflicts with single-type-import \""
+ Java.join(ss, ".")
+ "\""
), location);
}
}
private void
compile2(AbstractClassDeclaration cd) throws CompileException {
IClass iClass = this.resolve(cd);
// Check that all methods of the non-abstract class are implemented.
if (!(cd instanceof NamedClassDeclaration && ((NamedClassDeclaration) cd).isAbstract())) {
IMethod[] ms = iClass.getIMethods();
for (IMethod base : ms) {
if (base.isAbstract()) {
if ("".equals(base.getName())) continue;
IMethod override = iClass.findIMethod(base.getName(), base.getParameterTypes());
if (
override == null // It wasn't overridden
|| override.isAbstract() // It was overridden with an abstract method
// The override does not provide a covariant return type
|| !base.getReturnType().isAssignableFrom(override.getReturnType())
) {
this.compileError(
"Non-abstract class \"" + iClass + "\" must implement method \"" + base + "\"",
cd.getLocation()
);
}
}
}
}
short accessFlags = this.accessFlags(cd.getModifiers());
if (cd instanceof PackageMemberTypeDeclaration) accessFlags |= Mod.SUPER;
if (cd instanceof EnumDeclaration) accessFlags |= Mod.ENUM;
// Create "ClassFile" object.
ClassFile cf = this.newClassFile(accessFlags, iClass, iClass.getSuperclass(), iClass.getInterfaces());
// Add class annotations with retention != SOURCE.
this.compileAnnotations(cd.getAnnotations(), cf, cf);
if (cd.getEnclosingScope() instanceof Block) {
// Add an "InnerClasses" attribute entry for this anonymous class declaration on the class file (JLS8,
// section 4.7.6, "The InnerClasses Attribute").
short innerClassInfoIndex = cf.addConstantClassInfo(iClass.getDescriptor());
short innerNameIndex = (
this instanceof NamedTypeDeclaration
? cf.addConstantUtf8Info(((NamedTypeDeclaration) this).getName())
: (short) 0
);
assert cd.getAnnotations().length == 0 : "NYI";
cf.addInnerClassesAttributeEntry(new ClassFile.InnerClassesAttribute.Entry(
innerClassInfoIndex, // innerClassInfoIndex
(short) 0, // outerClassInfoIndex
innerNameIndex, // innerNameIndex
accessFlags // innerClassAccessFlags
));
} else
if (cd.getEnclosingScope() instanceof TypeDeclaration) {
// Add an "InnerClasses" attribute entry for this nested class declaration on the class file (JLS8,
// section 4.7.6, "The InnerClasses Attribute").
short innerClassInfoIndex = cf.addConstantClassInfo(iClass.getDescriptor());
short outerClassInfoIndex = cf.addConstantClassInfo(
this.resolve(((TypeDeclaration) cd.getEnclosingScope())).getDescriptor()
);
short innerNameIndex = cf.addConstantUtf8Info(((MemberTypeDeclaration) cd).getName());
cf.addInnerClassesAttributeEntry(new ClassFile.InnerClassesAttribute.Entry(
innerClassInfoIndex, // innerClassInfoIndex
outerClassInfoIndex, // outerClassInfoIndex
innerNameIndex, // innerNameIndex
accessFlags // innerClassAccessFlags
));
}
// Set the "SourceFile" attribute (JVMS8, section 4.7.10, "The SourceFile Attribute") on this class file.
if (this.debugSource) {
String sourceFileName;
{
String s = cd.getLocation().getFileName();
if (s != null) {
sourceFileName = new File(s).getName();
} else if (cd instanceof NamedTypeDeclaration) {
sourceFileName = ((NamedTypeDeclaration) cd).getName() + ".java";
} else {
sourceFileName = "ANONYMOUS.java";
}
}
cf.addSourceFileAttribute(sourceFileName);
}
// Add a "Deprecated" attribute (JVMS8, section 4.7.15, "The Deprecated Attribute") on this class file.
if (cd instanceof DocCommentable && ((DocCommentable) cd).hasDeprecatedDocTag()) {
cf.addDeprecatedAttribute();
}
List classInitializationStatements = new ArrayList<>();
if (cd instanceof EnumDeclaration) {
EnumDeclaration ed = (EnumDeclaration) cd;
// Create field and static initializer for each enum constant.
for (EnumConstant ec : ed.getConstants()) {
// E = new E(, [ optional-constructor-args ]);
VariableDeclarator variableDeclarator = new VariableDeclarator(
ec.getLocation(), // location
ec.name, // name
0, // brackets
new NewClassInstance( // initializer
ec.getLocation(), // location
null, // qualification
iClass, // iClass
ec.arguments != null ? ec.arguments : new Rvalue[0] // arguments
)
);
FieldDeclaration fd = new FieldDeclaration(
ec.getLocation(), // location
ec.getDocComment(), // docComment
UnitCompiler.accessModifiers(ec.getLocation(), "public", "static", "final"), // modifiers
new SimpleType(ec.getLocation(), iClass), // type
new VariableDeclarator[] { variableDeclarator } // variableDeclarators
);
fd.setDeclaringType(ed);
classInitializationStatements.add(fd);
this.addFields(fd, cf);
}
// Create the synthetic "ENUM$VALUES" field:
//
// private static final E[] ENUM$VALUES = new E[];
Location loc = ed.getLocation();
IClass enumIClass = this.resolve(ed);
FieldDeclaration fd = new FieldDeclaration(
loc, // location
null, // docComment
UnitCompiler.accessModifiers(loc, "private", "static", "final"), // modifiers
new SimpleType(loc, enumIClass), // type
new VariableDeclarator[] { // variableDeclarators)
new VariableDeclarator(
loc, // location
"ENUM$VALUES", // name
1, // brackets
new NewArray( // initializer
loc, // location
new SimpleType(loc, enumIClass), // type
new Rvalue[] { // dimExprs
new IntegerLiteral(loc, String.valueOf(ed.getConstants().size())),
},
0 // dims
)
)
}
);
((AbstractClassDeclaration) ed).addFieldDeclaration(fd);
}
// Process static initializers (a.k.a. class initializers).
for (BlockStatement fdoi : cd.fieldDeclarationsAndInitializers) {
if (
(fdoi instanceof FieldDeclaration && ((FieldDeclaration) fdoi).isStatic())
|| (fdoi instanceof Initializer && ((Initializer) fdoi).isStatic())
) classInitializationStatements.add(fdoi);
}
if (cd instanceof EnumDeclaration) {
EnumDeclaration ed = (EnumDeclaration) cd;
IClass enumIClass = this.resolve(ed);
// Initialize the elements of the synthetic "ENUM$VALUES" field:
//
// E.ENUM$VALUES[0] = E.;
// E.ENUM$VALUES[1] = E.;
// ...
int index = 0;
for (EnumConstant ec : ed.getConstants()) {
classInitializationStatements.add(
new ExpressionStatement(
new Assignment(
ec.getLocation(), // location
new ArrayAccessExpression( // lhs
ec.getLocation(), // location
new FieldAccessExpression( // lhs
ec.getLocation(),
new SimpleType(ec.getLocation(), enumIClass),
"ENUM$VALUES"
),
new IntegerLiteral(ec.getLocation(), String.valueOf(index++)) // rhs
),
"=", // operator
new FieldAccessExpression( // rhs
ec.getLocation(),
new SimpleType(ec.getLocation(), enumIClass),
ec.name
)
)
)
);
}
}
// Create class initialization method.
this.maybeCreateInitMethod(cd, cf, classInitializationStatements);
// Generate and compile the "magic" ENUM methods "E[] values()" and "E valueOf(String)".
if (cd instanceof EnumDeclaration) {
EnumDeclaration ed = (EnumDeclaration) cd;
// public static E[] values() {
// E[] tmp = new T[];
// System.arraycopy(T.ENUM$VALUES, 0, tmp, 0, );
// return tmp;
// }
Location loc = ed.getLocation();
int numberOfEnumConstants = ed.getConstants().size();
IClass enumIClass = this.resolve(ed);
// tmp = new T[];
VariableDeclarator vd = new VariableDeclarator(
loc, // location
"tmp", // name
0, // brackets
new NewArray( // optionalinitializer
loc, // location
new SimpleType(loc, enumIClass), // type
new Rvalue[] { // dimExprs
new IntegerLiteral(loc, String.valueOf(numberOfEnumConstants))
},
0 // dims
)
);
// E[] tmp = new E[];
LocalVariableDeclarationStatement lvds = new LocalVariableDeclarationStatement(
loc,
new Modifier[0],
new SimpleType(loc, this.iClassLoader.getArrayIClass(enumIClass)),
new VariableDeclarator[] { vd }
);
// public static E[] values() {
// E[] tmp = new T[];
// System.arraycopy(T.ENUM$VALUES, 0, tmp, 0, );
// return tmp;
// }
{
MethodDeclarator md = new MethodDeclarator(
loc, // location
null, // docComment
UnitCompiler.accessModifiers(loc, "public", "static"), // modifiers
null, // typeParameters
new ArrayType(new SimpleType(loc, enumIClass)), // type
"values", // name
new FormalParameters(loc), // parameters
new Type[0], // thrownExceptions
null, // defaultValue
Arrays.asList( // statements
// E[] tmp = new E[];
lvds,
// System.arraycopy(E.ENUM$VALUES, 0, tmp, 0, );
new ExpressionStatement(new MethodInvocation(
loc, // location
new SimpleType(loc, this.iClassLoader.TYPE_java_lang_System), // target
"arraycopy", // methodName
new Rvalue[] { // arguments
new FieldAccessExpression(loc, new SimpleType(loc, enumIClass), "ENUM$VALUES"), // Argument #1: E.ENUM$VALUES
new IntegerLiteral(loc, "0"), // Argument #2: 0
new LocalVariableAccess(loc, this.getLocalVariable(lvds, vd)), // Argument #3: tmp
new IntegerLiteral(loc, "0"), // Argument #4: 0
new IntegerLiteral(loc, String.valueOf(numberOfEnumConstants)), // Argument #5:
}
)),
// return tmp;
new ReturnStatement(loc, new LocalVariableAccess(loc, this.getLocalVariable(lvds, vd)))
)
);
md.setDeclaringType(ed);
this.compile(md, cf);
}
// public static E valueOf(String s) {
// return (E) Enum.valueOf(E.class, s);
// }
FormalParameter fp = new FormalParameter(
loc, // location
new Modifier[0], // modifiers
new SimpleType(loc, this.iClassLoader.TYPE_java_lang_String), // type
"s" // name
);
{
MethodDeclarator md = new MethodDeclarator(
loc, // location
null, // docComment
UnitCompiler.accessModifiers(loc, "public", "static"), // modifiers
null, // typeParameters
new SimpleType(loc, enumIClass), // type
"valueOf", // name
new FormalParameters( // formalParameters
loc, // location
new FormalParameter[] { fp }, // parameters
false // variableArity
),
new Type[0], // thrownExceptions,
null, // defaultValue
Arrays.asList( // statements
// return (E) Enum.valueOf(E.class, s);
new ReturnStatement(loc, new Cast(
loc, // location
new SimpleType(loc, enumIClass), // targetType
new MethodInvocation( // value
loc, // location
new SimpleType(loc, this.iClassLoader.TYPE_java_lang_Enum), // target
"valueOf", // methodName
new Rvalue[] { // arguments
new ClassLiteral(loc, new SimpleType(loc, enumIClass)),
new ParameterAccess(loc, fp)
}
)
))
)
);
md.setEnclosingScope(ed);
this.compile(md, cf);
}
}
// Compile declared methods.
this.compileDeclaredMethods(cd, cf);
// Compile declared constructors.
// As a side effect of compiling methods and constructors, synthetic "class-dollar" methods (which implement
// class literals) are generated on-the fly. We need to note how many we have here so we can compile the
// extras.
final int declaredMethodCount = cd.getMethodDeclarations().size();
{
ConstructorDeclarator[] ctords = cd.getConstructors();
int syntheticFieldCount = cd.syntheticFields.size();
int methodInfoCount = cf.methodInfos.size();
for (ConstructorDeclarator ctord : ctords) this.compile(ctord, cf);
if (syntheticFieldCount != cd.syntheticFields.size()) {
// New synthetic fields were created while the constructors were compiled -- need to re-compile all
// constructors!
syntheticFieldCount = cd.syntheticFields.size();
while (cf.methodInfos.size() > methodInfoCount) cf.methodInfos.remove(methodInfoCount);
for (ConstructorDeclarator ctord : ctords) {
// Clear the cached IConstructor -- necessary because the synthetic constructor parameters have
// changed!
ctord.iConstructor = null;
this.compile(ctord, cf);
}
// Re-compilation of the constructors cannot possibly create even more synthetic fields!
assert syntheticFieldCount == cd.syntheticFields.size();
}
}
// A side effect of this call may create synthetic functions to access protected parent variables.
this.compileDeclaredMemberTypes(cd, cf);
// Compile the aforementioned extras.
this.compileDeclaredMethods(cd, cf, declaredMethodCount);
// For every method look for bridge methods that need to be supplied. This is used to correctly dispatch into
// covariant return types from existing code.
for (IMethod base : iClass.getIMethods()) {
if (!base.isStatic() && base.getAccess() != Access.PRIVATE) {
IMethod override = iClass.findIMethod(base.getName(), base.getParameterTypes());
// If we overrode the method but with a DIFFERENT return type.
if (
override != null
&& base.getReturnType() != override.getReturnType()
) {
try {
this.generateBridgeMethod(cf, iClass, base, override);
} catch (RuntimeException re) {
throw new InternalCompilerException(cd.getLocation(), (
"Generating bridge method from \""
+ base
+ "\" to \""
+ override
+ "\": "
+ re.getMessage()
), re);
}
}
}
}
// Add class and instance variables as (static and non-static) fields.
for (FieldDeclaration fd : Iterables.filterByClass(
cd.getVariableDeclaratorsAndInitializers(),
FieldDeclaration.class
)) this.addFields(fd, cf);
// Synthetic fields.
for (IField f : cd.getSyntheticFields().values()) {
cf.addFieldInfo(
Mod.PACKAGE, // accessFlags
f.getName(), // fieldName
UnitCompiler.rawTypeOf(f.getType()).getDescriptor(), // fieldTypeFD
null // constantValue
);
}
// Add the generated class file to a thread-local store.
this.addClassFile(cf);
}
/**
* Adds the given {@link ClassFile} to the result set.
*/
private void
addClassFile(ClassFile cf) {
assert this.storesClassFiles != null;
try {
this.storesClassFiles.consume(cf);
} catch (IOException ioe) {
throw new InternalCompilerException(cf.getThisClassName(), ioe);
}
}
/**
* Creates and adds {@link ClassFile.FieldInfo}s to the cf for all fields declared by the fd.
*/
private void
addFields(FieldDeclaration fd, ClassFile cf) throws CompileException {
for (VariableDeclarator vd : fd.variableDeclarators) {
Type type = fd.type;
for (int i = 0; i < vd.brackets; ++i) type = new ArrayType(type);
Object ocv = ( // Optional constant value
fd.isFinal() && vd.initializer instanceof Rvalue
? this.constantAssignmentConversion(
vd.initializer, // locatable
this.getConstantValue((Rvalue) vd.initializer), // value
this.getRawType(type) // targetType
)
: UnitCompiler.NOT_CONSTANT
);
short accessFlags = this.accessFlags(fd.modifiers);
ClassFile.FieldInfo fi;
if (fd.isPrivate()) {
// To make the private field accessible for enclosing types, enclosed types and types enclosed by the
// same type, it is modified as follows:
// + Access is changed from PRIVATE to PACKAGE
accessFlags = UnitCompiler.changeAccessibility(accessFlags, Mod.PACKAGE);
fi = cf.addFieldInfo(
accessFlags, // accessFlags
vd.name, // fieldName
this.getRawType(type).getDescriptor(), // fieldTypeFD
ocv == UnitCompiler.NOT_CONSTANT ? null : ocv // constantValue
);
} else
{
fi = cf.addFieldInfo(
( // accessFlags
fd.getDeclaringType() instanceof InterfaceDeclaration
? (short) (Mod.PUBLIC | Mod.STATIC | Mod.FINAL)
: accessFlags
),
vd.name, // fieldName
this.getRawType(type).getDescriptor(), // fieldTypeFD
ocv == UnitCompiler.NOT_CONSTANT ? null : ocv // constantValue
);
}
// Add field annotations with retention != SOURCE.
this.compileAnnotations(fd.getAnnotations(), fi, cf);
// Add "Deprecated" attribute (JVMS 4.7.10).
if (fd.hasDeprecatedDocTag()) {
fi.addAttribute(new ClassFile.DeprecatedAttribute(cf.addConstantUtf8Info("Deprecated")));
}
}
}
private void
compile2(AnonymousClassDeclaration acd) throws CompileException {
// For classes that enclose surrounding scopes, trawl their field initializers looking for synthetic fields.
// this.fakeCompileVariableDeclaratorsAndInitializers(acd);
this.compile2((InnerClassDeclaration) acd);
}
private void
compile2(LocalClassDeclaration lcd) throws CompileException {
// For classes that enclose surrounding scopes, trawl their field initializers looking for synthetic fields.
this.fakeCompileVariableDeclaratorsAndInitializers(lcd);
this.compile2((InnerClassDeclaration) lcd);
}
private void
compile2(InnerClassDeclaration icd) throws CompileException {
// Define a synthetic "this$n" field if there is an enclosing instance, where "n" designates the number of
// enclosing instances minus one.
{
List ocs = UnitCompiler.getOuterClasses(icd);
final int nesting = ocs.size();
if (nesting >= 2) {
TypeDeclaration immediatelyEnclosingOuterClassDeclaration = (TypeDeclaration) ocs.get(1);
icd.defineSyntheticField(new SimpleIField(
this.resolve(icd),
"this$" + (nesting - 2),
this.resolve(immediatelyEnclosingOuterClassDeclaration)
));
}
}
this.compile2((AbstractClassDeclaration) icd);
}
private void
fakeCompileVariableDeclaratorsAndInitializers(AbstractClassDeclaration cd) throws CompileException {
// Compilation of field declarations can create synthetic variables, so we must not use an iterator.
List fdais = cd.fieldDeclarationsAndInitializers;
for (int i = 0; i < fdais.size(); i++) {
BlockStatement fdoi = (BlockStatement) fdais.get(i);
this.fakeCompile(fdoi);
}
}
private void
compile2(InterfaceDeclaration id) throws CompileException {
final IClass iClass = this.resolve(id);
// Determine extended interfaces.
IClass[] rawInterfaces = UnitCompiler.rawTypesOf((id.interfaces = this.getTypes(id.extendedTypes)));
short accessFlags = this.accessFlags(id.getModifiers());
accessFlags |= Mod.INTERFACE;
accessFlags |= Mod.ABSTRACT;
if (id instanceof AnnotationTypeDeclaration) accessFlags |= Mod.ANNOTATION;
if (id instanceof MemberInterfaceDeclaration) accessFlags |= Mod.STATIC;
ClassFile cf = this.newClassFile(
accessFlags,
iClass,
this.iClassLoader.TYPE_java_lang_Object,
rawInterfaces
);
// Add interface annotations with retention != SOURCE.
this.compileAnnotations(id.getAnnotations(), cf, cf);
// Set "SourceFile" attribute.
if (this.debugSource) {
String sourceFileName;
{
String s = id.getLocation().getFileName();
if (s != null) {
sourceFileName = new File(s).getName();
} else {
sourceFileName = id.getName() + ".java";
}
}
cf.addSourceFileAttribute(sourceFileName);
}
// Add "Deprecated" attribute (JVMS 4.7.10).
if (id.hasDeprecatedDocTag()) cf.addDeprecatedAttribute();
// Interface initialization method.
if (!id.constantDeclarations.isEmpty()) {
List statements = new ArrayList<>();
statements.addAll(id.constantDeclarations);
this.maybeCreateInitMethod(id, cf, statements);
}
this.compileDeclaredMethods(id, cf);
// Class variables.
for (FieldDeclaration constantDeclaration : id.constantDeclarations) this.addFields(constantDeclaration, cf);
this.compileDeclaredMemberTypes(id, cf);
// Add the generated class file to a thread-local store.
this.addClassFile(cf);
}
/**
* @param superclass {@code null} for {@link Object}, {@link Object} for interfaces
*/
private ClassFile
newClassFile(
short accessFlags,
IClass iClass,
@Nullable IClass superclass,
IClass[] interfaces
) throws CompileException {
ClassFile result = new ClassFile(
accessFlags, // accessFlags
iClass.getDescriptor(), // thisClassFD
superclass != null ? superclass.getDescriptor() : null, // superclassFD
IClass.getDescriptors(interfaces) // interfaceFDs
);
int v = this.getTargetVersion();
if (v < 6) throw new CompileException("Cannot generate version " + v + " .class files", Location.NOWHERE);
result.setVersion((short) (44 + v), ClassFile.MINOR_VERSION_JDK_1_6);
return result;
}
/**
* Converts and adds the annotations to the target.
*/
private void
compileAnnotations(Annotation[] annotations, Annotatable target, final ClassFile cf) throws CompileException {
final Set seenAnnotations = new HashSet<>();
ANNOTATIONS: for (final Annotation a : annotations) {
final Type annotationType = a.getType();
final IClass annotationIClass = this.getRawType(annotationType);
final IAnnotation[] annotationAnnotations = annotationIClass.getIAnnotations();
// Check for duplicate annotations.
if (!seenAnnotations.add(annotationIClass)) {
this.compileError("Duplicate annotation \"" + annotationIClass + "\"", annotationType.getLocation());
}
// Determine the retention.
boolean runtimeVisible = false;
for (IAnnotation aa : annotationAnnotations) {
if (aa.getAnnotationType() != this.iClassLoader.TYPE_java_lang_annotation_Retention) continue;
Object rev = aa.getElementValue("value");
String retention = ((IField) rev).getName();
if ("SOURCE".equals(retention)) {
continue ANNOTATIONS;
} else
if ("CLASS".equals(retention)) {
runtimeVisible = false;
break;
} else
if ("RUNTIME".equals(retention)) {
runtimeVisible = true;
break;
} else
{
throw new AssertionError(retention);
}
}
// Compile the annotation's element-value-pairs.
final Map evps = new HashMap<>();
a.accept(new AnnotationVisitor() {
@Override @Nullable public Void
visitSingleElementAnnotation(SingleElementAnnotation sea) throws CompileException {
IMethod[] definitions = annotationIClass.getDeclaredIMethods("value");
assert definitions.length == 1;
boolean isArray = definitions[0].getReturnType().isArray();
evps.put(
cf.addConstantUtf8Info("value"),
UnitCompiler.this.compileElementValue(sea.elementValue, cf, isArray)
);
return null;
}
@Override @Nullable public Void
visitNormalAnnotation(NormalAnnotation na) throws CompileException {
for (ElementValuePair evp : na.elementValuePairs) {
IMethod[] definitions = annotationIClass.getDeclaredIMethods(evp.identifier);
assert definitions.length == 1;
boolean isArray = definitions[0].getReturnType().isArray();
evps.put(
cf.addConstantUtf8Info(evp.identifier),
UnitCompiler.this.compileElementValue(evp.elementValue, cf, isArray)
);
}
return null;
}
@Override @Nullable public Void
visitMarkerAnnotation(MarkerAnnotation ma) {
;
return null;
}
});
// Add the annotation to the target (class/interface, method or field).
target.addAnnotationsAttributeEntry(runtimeVisible, annotationIClass.getDescriptor(), evps);
}
}
private ClassFile.ElementValue
compileElementValue(ElementValue elementValue, final ClassFile cf, boolean compileAsArray) throws CompileException {
ClassFile.ElementValue
result = (ClassFile.ElementValue) elementValue.accept(
new ElementValueVisitor() {
@Override public ClassFile.ElementValue
visitRvalue(Rvalue rv) throws CompileException {
// Enum constant?
ENUM_CONSTANT:
if (rv instanceof AmbiguousName) {
Rvalue enumConstant = UnitCompiler.this.reclassify((AmbiguousName) rv).toRvalue();
if (!(enumConstant instanceof FieldAccess)) break ENUM_CONSTANT; // Not a field access.
FieldAccess enumConstantFieldAccess = (FieldAccess) enumConstant;
Type enumType = enumConstantFieldAccess.lhs.toType();
if (enumType == null) break ENUM_CONSTANT; // LHS is not a type.
IClass enumIClass = UnitCompiler.this.findTypeByName(rv.getLocation(), enumType.toString());
if (enumIClass == null) {
UnitCompiler.this.compileError(
"Cannot find enum \"" + enumType + "\"",
enumType.getLocation()
);
break ENUM_CONSTANT;
}
if (enumIClass.getSuperclass() == UnitCompiler.this.iClassLoader.TYPE_java_lang_Enum) {
return new ClassFile.EnumConstValue(
cf.addConstantUtf8Info(enumIClass.getDescriptor()), // typeNameIndex
cf.addConstantUtf8Info(enumConstantFieldAccess.field.getName()) // constNameIndex
);
}
// We have a constant, but it is not an ENUM constant, so fall through.
}
// Class literal?
if (rv instanceof ClassLiteral) {
return new ClassFile.ClassElementValue(cf.addConstantUtf8Info(
UnitCompiler.this.getRawType(((ClassLiteral) rv).type).getDescriptor()
));
}
// Constant value?
Object cv = UnitCompiler.this.getConstantValue(rv);
if (cv == UnitCompiler.NOT_CONSTANT) {
throw new CompileException(
"\"" + rv + "\" is not a constant expression",
rv.getLocation()
);
}
if (cv == null) {
throw new CompileException(
"Null literal not allowed as element value",
rv.getLocation()
);
}
if (cv instanceof Boolean) { return new ClassFile.BooleanElementValue(cf.addConstantIntegerInfo((Boolean) cv ? 1 : 0)); }
if (cv instanceof Byte) { return new ClassFile.ByteElementValue(cf.addConstantIntegerInfo((Byte) cv)); }
if (cv instanceof Short) { return new ClassFile.ShortElementValue(cf.addConstantIntegerInfo((Short) cv)); }
if (cv instanceof Integer) { return new ClassFile.IntElementValue(cf.addConstantIntegerInfo((Integer) cv)); }
if (cv instanceof Long) { return new ClassFile.LongElementValue(cf.addConstantLongInfo((Long) cv)); }
if (cv instanceof Float) { return new ClassFile.FloatElementValue(cf.addConstantFloatInfo((Float) cv)); }
if (cv instanceof Double) { return new ClassFile.DoubleElementValue(cf.addConstantDoubleInfo((Double) cv)); }
if (cv instanceof Character) { return new ClassFile.CharElementValue(cf.addConstantIntegerInfo((Character) cv)); }
if (cv instanceof String) { return new ClassFile.StringElementValue(cf.addConstantUtf8Info((String) cv)); }
throw new AssertionError(cv);
}
@Override public ClassFile.ElementValue
visitAnnotation(Annotation a) throws CompileException {
final IClass annotationIClass = UnitCompiler.this.getRawType(a.getType());
short annotationTypeIndex = cf.addConstantUtf8Info(annotationIClass.getDescriptor());
final Map evps = new HashMap<>();
a.accept(new AnnotationVisitor() {
@Override @Nullable public Void
visitMarkerAnnotation(MarkerAnnotation ma) {
;
return null;
}
@Override @Nullable public Void
visitSingleElementAnnotation(SingleElementAnnotation sea) throws CompileException {
IMethod[] definitions = annotationIClass.getDeclaredIMethods("value");
assert definitions.length == 1;
boolean expectArray = definitions[0].getReturnType().isArray();
evps.put(
cf.addConstantUtf8Info("value"),
UnitCompiler.this.compileElementValue(sea.elementValue, cf, expectArray)
);
return null;
}
@Override @Nullable public Void
visitNormalAnnotation(NormalAnnotation na) throws CompileException {
for (ElementValuePair evp : na.elementValuePairs) {
IMethod[] definitions = annotationIClass.getDeclaredIMethods(evp.identifier);
assert definitions.length == 1;
boolean expectArray = Descriptor.isArrayReference(definitions[0].getDescriptor().returnFd);
evps.put(
cf.addConstantUtf8Info(evp.identifier),
UnitCompiler.this.compileElementValue(evp.elementValue, cf, expectArray)
);
}
return null;
}
});
return new ClassFile.Annotation(annotationTypeIndex, evps);
}
@Override public ClassFile.ElementValue
visitElementValueArrayInitializer(ElementValueArrayInitializer evai) throws CompileException {
ClassFile.ElementValue[]
evs = new ClassFile.ElementValue[evai.elementValues.length];
for (int i = 0; i < evai.elementValues.length; i++) {
evs[i] = UnitCompiler.this.compileElementValue(evai.elementValues[i], cf, false);
}
return new ClassFile.ArrayElementValue(evs);
}
}
);
if (compileAsArray && result instanceof ClassFile.ConstantElementValue) {
ClassFile.ElementValue[] arrayValues = new ClassFile.ElementValue[1];
arrayValues[0] = result;
result = new ClassFile.ArrayElementValue(arrayValues);
}
assert result != null;
return result;
}
/**
* Creates class/interface initialization method iff there is any initialization code.
*
* @param td The type declaration
* @param cf The class file into which to put the method
* @param statements The statements for the method (possibly empty)
*/
private void
maybeCreateInitMethod(
TypeDeclaration td,
ClassFile cf,
List statements
) throws CompileException {
// Create class/interface initialization method iff there is any initialization code.
if (this.generatesCode2(statements)) {
MethodDeclarator md = new MethodDeclarator(
td.getLocation(), // location
null, // docComment
UnitCompiler.accessModifiers(td.getLocation(), "static", "public"), // modifiers
null, // typeParameters
new PrimitiveType(td.getLocation(), Primitive.VOID), // type
"", // name
new FormalParameters(td.getLocation()), // formalParameters
new ReferenceType[0], // thrownExceptions
null, // defaultValue
statements // statements
);
md.setDeclaringType(td);
this.compile(md, cf);
}
}
/**
* Compiles all of the types for this declaration
*
* NB: as a side effect this will fill in the synthetic field map
*
*/
private void
compileDeclaredMemberTypes(TypeDeclaration decl, ClassFile cf) throws CompileException {
for (MemberTypeDeclaration mtd : decl.getMemberTypeDeclarations()) {
this.compile(mtd);
// Add InnerClasses attribute entry for member type declaration.
short innerClassInfoIndex = cf.addConstantClassInfo(this.resolve(mtd).getDescriptor());
short outerClassInfoIndex = cf.addConstantClassInfo(this.resolve(decl).getDescriptor());
short innerNameIndex = cf.addConstantUtf8Info(mtd.getName());
cf.addInnerClassesAttributeEntry(new ClassFile.InnerClassesAttribute.Entry(
innerClassInfoIndex, // innerClassInfoIndex
outerClassInfoIndex, // outerClassInfoIndex
innerNameIndex, // innerNameIndex
this.accessFlags(mtd.getModifiers()) // innerClassAccessFlags
));
}
}
/**
* Compiles all of the methods for this declaration
*
* NB: as a side effect this will fill in the synthetic field map
*
startPos.
*
* @param startPos Starting parameter to fill in
*/
private void
compileDeclaredMethods(TypeDeclaration typeDeclaration, ClassFile cf, int startPos) throws CompileException {
// Notice that as a side effect of compiling methods, synthetic "class-dollar" methods (which implement class
// literals) are generated on-the fly. Hence, we must not use an Iterator here.
for (int i = startPos; i < typeDeclaration.getMethodDeclarations().size(); ++i) {
MethodDeclarator md = (MethodDeclarator) typeDeclaration.getMethodDeclarations().get(i);
IMethod m = this.toIMethod(md);
boolean overrides = this.overridesMethodFromSupertype(m, this.resolve(md.getDeclaringType()));
boolean hasOverrideAnnotation = this.hasAnnotation(md, this.iClassLoader.TYPE_java_lang_Override);
if (overrides && !hasOverrideAnnotation && !(typeDeclaration instanceof InterfaceDeclaration)) {
this.warning("MO", "Missing @Override", md.getLocation());
} else
if (!overrides && hasOverrideAnnotation) {
this.compileError("Method does not override a method declared in a supertype", md.getLocation());
}
this.compile(md, cf);
}
}
private boolean
hasAnnotation(FunctionDeclarator fd, IClass annotationType) throws CompileException {
for (Annotation a : Iterables.filterByClass(fd.getModifiers(), Annotation.class)) {
if (this.getType(a.getType()) == annotationType) return true;
}
return false;
}
private boolean
overridesMethodFromSupertype(IMethod m, IClass type) throws CompileException {
// Check whether it overrides a method declared in the superclass (or any of its supertypes).
{
IClass superclass = type.getSuperclass();
if (superclass != null && this.overridesMethod(m, superclass)) return true;
}
// Check whether it overrides a method declared in an interface (or any of its superinterfaces).
IClass[] ifs = type.getInterfaces();
for (IClass i : ifs) {
if (this.overridesMethod(m, i)) return true;
}
// Special handling for interfaces that don't extend other interfaces: JLS7 dictates that these stem from
// 'Object', but 'getSuperclass()' returns NULL for interfaces.
if (ifs.length == 0 && type.isInterface()) {
return this.overridesMethod(m, this.iClassLoader.TYPE_java_lang_Object);
}
return false;
}
/**
* @return Whether method overrides a method of type or any of its supertypes
*/
private boolean
overridesMethod(IMethod method, IClass type) throws CompileException {
// Check whether it overrides a method declared in THIS type.
IMethod[] ms = type.getDeclaredIMethods(method.getName());
for (IMethod m : ms) {
if (Arrays.equals(method.getParameterTypes(), m.getParameterTypes())) return true;
}
// Check whether it overrides a method declared in a supertype.
return this.overridesMethodFromSupertype(method, type);
}
/**
* Generates and compiles a bridge method with signature base that delegates to override.
*/
private void
generateBridgeMethod(ClassFile cf, IClass declaringIClass, IMethod base, IMethod override) throws CompileException {
if (
!base.getReturnType().isAssignableFrom(override.getReturnType())
|| override.getReturnType() == IClass.VOID
) {
this.compileError(
"The return type of \""
+ override
+ "\" is incompatible with that of \""
+ base
+ "\""
);
return;
}
ClassFile.MethodInfo mi = cf.addMethodInfo(
(short) (Mod.PUBLIC | Mod.SYNTHETIC), // accessFlags
base.getName(),
base.getDescriptor()
);
// Add "Exceptions" attribute (JVMS 4.7.4).
IClass[] thrownExceptions = base.getThrownExceptions();
if (thrownExceptions.length > 0) {
final short eani = cf.addConstantUtf8Info("Exceptions");
short[] tecciis = new short[thrownExceptions.length];
for (int i = 0; i < thrownExceptions.length; ++i) {
tecciis[i] = cf.addConstantClassInfo(thrownExceptions[i].getDescriptor());
}
mi.addAttribute(new ClassFile.ExceptionsAttribute(eani, tecciis));
}
final CodeContext codeContext = new CodeContext(mi.getClassFile());
final CodeContext savedCodeContext = this.replaceCodeContext(codeContext);
try {
codeContext.saveLocalVariables();
// Allocate all our local variables.
this.allocateLocalVariableSlotAndMarkAsInitialized(override.getDeclaringIClass(), "this");
IClass[] paramTypes = override.getParameterTypes();
LocalVariableSlot[] locals = new LocalVariableSlot[paramTypes.length];
for (int i = 0; i < paramTypes.length; ++i) {
locals[i] = this.allocateLocalVariableSlotAndMarkAsInitialized(paramTypes[i], "param" + i);
}
this.load(Located.NOWHERE, declaringIClass, 0);
for (LocalVariableSlot l : locals) this.load(Located.NOWHERE, l.getType(), l.getSlotIndex());
this.invokeMethod(Located.NOWHERE, override);
this.xreturn(Located.NOWHERE, base.getReturnType());
} finally {
this.replaceCodeContext(savedCodeContext);
}
// Generate Code attribute and add to the MethodInfo.
mi.addAttribute(codeContext.newCodeAttribute(
1 + override.getParameterTypes().length, // initialLocalsCount
false, // debugLines
false // debugVars
));
}
/**
* @return Whether this statement can complete normally (JLS7 14.1)
*/
private boolean
compile(BlockStatement bs) throws CompileException {
try {
Boolean result = (Boolean) bs.accept(new BlockStatementVisitor() {
@Override public Boolean visitInitializer(Initializer i) throws CompileException { return UnitCompiler.this.compile2(i); }
@Override public Boolean visitFieldDeclaration(FieldDeclaration fd) throws CompileException { return UnitCompiler.this.compile2(fd); }
@Override public Boolean visitLabeledStatement(LabeledStatement ls) throws CompileException { return UnitCompiler.this.compile2(ls); }
@Override public Boolean visitBlock(Block b) throws CompileException { return UnitCompiler.this.compile2(b); }
@Override public Boolean visitExpressionStatement(ExpressionStatement es) throws CompileException { return UnitCompiler.this.compile2(es); }
@Override public Boolean visitIfStatement(IfStatement is) throws CompileException { return UnitCompiler.this.compile2(is); }
@Override public Boolean visitForStatement(ForStatement fs) throws CompileException { return UnitCompiler.this.compile2(fs); }
@Override public Boolean visitForEachStatement(ForEachStatement fes) throws CompileException { return UnitCompiler.this.compile2(fes); }
@Override public Boolean visitWhileStatement(WhileStatement ws) throws CompileException { return UnitCompiler.this.compile2(ws); }
@Override public Boolean visitTryStatement(TryStatement ts) throws CompileException { return UnitCompiler.this.compile2(ts); }
@Override public Boolean visitSwitchStatement(SwitchStatement ss) throws CompileException { return UnitCompiler.this.compile2(ss); }
@Override public Boolean visitSynchronizedStatement(SynchronizedStatement ss) throws CompileException { return UnitCompiler.this.compile2(ss); }
@Override public Boolean visitDoStatement(DoStatement ds) throws CompileException { return UnitCompiler.this.compile2(ds); }
@Override public Boolean visitLocalVariableDeclarationStatement(LocalVariableDeclarationStatement lvds) throws CompileException { return UnitCompiler.this.compile2(lvds); }
@Override public Boolean visitReturnStatement(ReturnStatement rs) throws CompileException { return UnitCompiler.this.compile2(rs); }
@Override public Boolean visitThrowStatement(ThrowStatement ts) throws CompileException { return UnitCompiler.this.compile2(ts); }
@Override public Boolean visitBreakStatement(BreakStatement bs) throws CompileException { return UnitCompiler.this.compile2(bs); }
@Override public Boolean visitContinueStatement(ContinueStatement cs) throws CompileException { return UnitCompiler.this.compile2(cs); }
@Override public Boolean visitAssertStatement(AssertStatement as) throws CompileException { return UnitCompiler.this.compile2(as); }
@Override public Boolean visitEmptyStatement(EmptyStatement es) { return UnitCompiler.this.compile2(es); }
@Override public Boolean visitLocalClassDeclarationStatement(LocalClassDeclarationStatement lcds) throws CompileException { return UnitCompiler.this.compile2(lcds); }
@Override public Boolean visitAlternateConstructorInvocation(AlternateConstructorInvocation aci) throws CompileException { return UnitCompiler.this.compile2(aci); }
@Override public Boolean visitSuperConstructorInvocation(SuperConstructorInvocation sci) throws CompileException { return UnitCompiler.this.compile2(sci); }
});
assert result != null;
return result;
} catch (RuntimeException re) {
throw new RuntimeException(bs.getLocation().toString(), re);
}
}
/**
* Called to check whether the given {@link BlockStatement} compiles or not.
* Updates the stack map of the current inserter.
*
* @return Whether the block statement can complete normally
*/
private boolean
fakeCompile(BlockStatement bs) throws CompileException {
Offset from = this.getCodeContext().newOffset();
boolean ccn = this.compile(bs);
Offset to = this.getCodeContext().newOffset();
this.getCodeContext().removeCode(from, to);
return ccn;
}
private CodeContext
getCodeContext() {
assert this.codeContext != null;
return this.codeContext;
}
private boolean
compile2(Initializer i) throws CompileException {
this.buildLocalVariableMap(i.block, new HashMap());
return this.compile(i.block);
}
private boolean
compile2(Block b) throws CompileException {
this.getCodeContext().saveLocalVariables();
try {
return this.compileStatements(b.statements);
} finally {
this.getCodeContext().restoreLocalVariables();
}
}
private boolean
compileStatements(List statements) throws CompileException {
boolean previousStatementCanCompleteNormally = true;
for (BlockStatement bs : statements) {
if (!previousStatementCanCompleteNormally && this.generatesCode(bs)) {
this.compileError("Statement is unreachable", bs.getLocation());
break;
}
try {
previousStatementCanCompleteNormally = this.compile(bs);
} catch (RuntimeException re) {
throw new RuntimeException(bs.getLocation().toString(), re);
} catch (AssertionError ae) {
throw new InternalCompilerException(bs.getLocation(), null, ae);
}
}
return previousStatementCanCompleteNormally;
}
private boolean
compile2(DoStatement ds) throws CompileException {
Object cvc = this.getConstantValue(ds.condition);
if (cvc != UnitCompiler.NOT_CONSTANT) {
if (Boolean.TRUE.equals(cvc)) {
this.warning("DSTC", (
"Condition of DO statement is always TRUE; "
+ "the proper way of declaring an unconditional loop is \"for (;;)\""
), ds.getLocation());
return this.compileUnconditionalLoop(ds, ds.body, null);
} else
{
this.warning("DSNR", "DO statement never repeats", ds.getLocation());
}
}
final CodeContext.Offset bodyOffset = this.getCodeContext().newBasicBlock();
// Compile body.
ds.whereToContinue = null;
if (!this.compile(ds.body) && ds.whereToContinue == null) {
this.warning("DSNTC", "\"do\" statement never tests its condition", ds.getLocation());
Offset wtb = ds.whereToBreak;
if (wtb == null) return false;
wtb.set();
ds.whereToBreak = null;
return true;
}
if (ds.whereToContinue != null) {
ds.whereToContinue.set();
ds.whereToContinue = null;
}
// Compile condition.
this.compileBoolean(ds.condition, bodyOffset, UnitCompiler.JUMP_IF_TRUE);
if (ds.whereToBreak != null) {
ds.whereToBreak.set();
ds.whereToBreak = null;
}
return true;
}
private boolean
compile2(ForStatement fs) throws CompileException {
this.getCodeContext().saveLocalVariables();
try {
BlockStatement oi = fs.init;
Rvalue[] ou = fs.update;
Rvalue oc = fs.condition;
// Compile initializer.
if (oi != null) this.compile(oi);
if (oc == null) {
return this.compileUnconditionalLoop(fs, fs.body, ou);
}
Object cvc = this.getConstantValue(oc);
if (cvc != UnitCompiler.NOT_CONSTANT) {
if (Boolean.TRUE.equals(cvc)) {
this.warning("FSTC", (
"Condition of FOR statement is always TRUE; "
+ "the proper way of declaring an unconditional loop is \"for (;;)\""
), fs.getLocation());
return this.compileUnconditionalLoop(fs, fs.body, ou);
} else
{
this.warning("FSNR", "FOR statement never repeats", fs.getLocation());
}
}
CodeContext.Offset toCondition = this.getCodeContext().new BasicBlock();
StackMap smBeforeBody = this.codeContext.currentInserter().getStackMap();
this.gotO(fs, toCondition);
// Compile body.
fs.whereToContinue = null;
this.codeContext.currentInserter().setStackMap(smBeforeBody);
final CodeContext.Offset bodyOffset = this.getCodeContext().newBasicBlock();
boolean bodyCcn = this.compile(fs.body);
if (fs.whereToContinue != null) fs.whereToContinue.set();
// Compile update.
if (ou != null) {
if (!bodyCcn && fs.whereToContinue == null) {
this.warning("FUUR", "For update is unreachable", fs.getLocation());
} else
{
for (Rvalue rv : ou) this.compile(rv);
}
}
fs.whereToContinue = null;
// Compile condition.
toCondition.set();
this.compileBoolean(oc, bodyOffset, UnitCompiler.JUMP_IF_TRUE);
} finally {
this.getCodeContext().restoreLocalVariables();
}
if (fs.whereToBreak != null) {
fs.whereToBreak.set();
fs.whereToBreak = null;
}
return true;
}
private boolean
compile2(ForEachStatement fes) throws CompileException {
IType expressionType = this.getType(fes.expression);
if (UnitCompiler.isArray(expressionType)) {
this.getCodeContext().saveLocalVariables();
try {
StackMap beforeStatement = this.getCodeContext().currentInserter().getStackMap();
// Allocate the local variable for the current element.
LocalVariable elementLv = this.getLocalVariable(fes.currentElement, false);
elementLv.setSlot(this.allocateLocalVariableSlot(elementLv.type, fes.currentElement.name));
// Compile initializer.
this.compileGetValue(fes.expression);
short expressionLv = this.getCodeContext().allocateLocalVariable((short) 1);
this.store(fes.expression, expressionType, expressionLv);
this.consT(fes, 0);
LocalVariable indexLv = this.allocateLocalVariable(false /*finaL*/, IClass.INT);
this.store(fes, indexLv);
StackMap beforeBody = this.getCodeContext().currentInserter().getStackMap();
CodeContext.Offset toCondition = this.getCodeContext().new BasicBlock();
this.gotO(fes, toCondition);
// Get the next array element.
this.codeContext.currentInserter().setStackMap(beforeBody);
fes.whereToContinue = null;
final CodeContext.Offset bodyOffset = this.getCodeContext().newBasicBlock();
this.load(fes, expressionType, expressionLv);
this.load(fes, indexLv);
IType componentType = UnitCompiler.getComponentType(expressionType);
assert componentType != null;
this.xaload(fes.currentElement, componentType);
this.assignmentConversion(fes.currentElement, componentType, elementLv.type, null);
this.store(fes, elementLv);
// Compile the body.
boolean bodyCcn = this.compile(fes.body);
if (fes.whereToContinue != null) fes.whereToContinue.set();
// Compile update.
if (!bodyCcn && fes.whereToContinue == null) {
this.warning("FUUR", "For update is unreachable", fes.getLocation());
} else {
this.iinc(fes, indexLv, "++");
}
fes.whereToContinue = null;
// Compile condition.
toCondition.set();
this.load(fes, indexLv);
this.load(fes, expressionType, expressionLv);
this.arraylength(fes);
this.if_icmpxx(fes, UnitCompiler.LT, bodyOffset);
this.getCodeContext().currentInserter().setStackMap(beforeStatement);
} finally {
this.getCodeContext().restoreLocalVariables();
}
if (fes.whereToBreak != null) {
fes.whereToBreak.set();
fes.whereToBreak = null;
}
} else
if (UnitCompiler.isAssignableFrom(this.iClassLoader.TYPE_java_lang_Iterable, expressionType)) {
this.getCodeContext().saveLocalVariables();
try {
StackMap beforeStatement = this.getCodeContext().currentInserter().getStackMap();
// Compile initializer.
this.compileGetValue(fes.expression);
this.invokeMethod(fes.expression, this.iClassLoader.METH_java_lang_Iterable__iterator);
LocalVariable iteratorLv = this.allocateLocalVariable(false /*finaL*/, this.iClassLoader.TYPE_java_util_Iterator);
this.store(fes, iteratorLv);
CodeContext.Offset toCondition = this.getCodeContext().new BasicBlock();
StackMap smBeforeBody = this.codeContext.currentInserter().getStackMap();
this.gotO(fes, toCondition);
// Compile the body.
this.codeContext.currentInserter().setStackMap(smBeforeBody);
// Allocate the local variable for the current element.
LocalVariable elementLv = this.getLocalVariable(fes.currentElement, false);
elementLv.setSlot(this.allocateLocalVariableSlot(elementLv.type, fes.currentElement.name));
fes.whereToContinue = null;
final CodeContext.Offset bodyOffset = this.getCodeContext().newBasicBlock();
this.load(fes, iteratorLv);
this.invokeMethod(fes.expression, this.iClassLoader.METH_java_util_Iterator__next);
IClass boxedType = this.isBoxingConvertible(elementLv.type);
if (boxedType != null) {
// Fix for Issue #155.
this.checkcast(fes.currentElement, boxedType);
this.unboxingConversion(fes.currentElement, boxedType, (IClass) elementLv.type);
} else
if (this.tryAssignmentConversion(
fes.currentElement,
this.iClassLoader.TYPE_java_lang_Object,
elementLv.type,
null
)) {
;
} else
if (this.tryNarrowingReferenceConversion(
fes.currentElement,
this.iClassLoader.TYPE_java_lang_Object,
elementLv.type
)) {
;
} else
{
throw new InternalCompilerException(fes.getLocation(), "Don't know how to convert to " + elementLv.type);
}
this.store(fes, elementLv);
boolean bodyCcn = this.compile(fes.body);
if (fes.whereToContinue != null) fes.whereToContinue.set();
// Compile update.
if (!bodyCcn && fes.whereToContinue == null) {
this.warning("FUUR", "For update is unreachable", fes.getLocation());
}
fes.whereToContinue = null;
// Compile condition.
toCondition.set();
this.load(fes, iteratorLv);
this.invokeMethod(fes.expression, this.iClassLoader.METH_java_util_Iterator__hasNext);
this.ifxx(fes, UnitCompiler.NE, bodyOffset);
this.getCodeContext().currentInserter().setStackMap(beforeStatement);
} finally {
this.getCodeContext().restoreLocalVariables();
}
if (fes.whereToBreak != null) {
fes.whereToBreak.set();
fes.whereToBreak = null;
}
} else
{
this.compileError("Cannot iterate over \"" + expressionType + "\"", fes.expression.getLocation());
}
return true;
}
private LocalVariable
allocateLocalVariable(boolean finaL, IType localVariableType) {
LocalVariable result = new LocalVariable(finaL, localVariableType);
result.setSlot(this.allocateLocalVariableSlot(localVariableType, null));
return result;
}
private LocalVariable
allocateLocalVariableAndMarkAsInitialized(boolean finaL, IType localVariableType) {
LocalVariable result = new LocalVariable(finaL, localVariableType);
result.setSlot(this.allocateLocalVariableSlotAndMarkAsInitialized(localVariableType, null));
return result;
}
private boolean
compile2(WhileStatement ws) throws CompileException {
Object cvc = this.getConstantValue(ws.condition);
if (cvc != UnitCompiler.NOT_CONSTANT) {
if (Boolean.TRUE.equals(cvc)) {
this.warning("WSTC", (
"Condition of WHILE statement is always TRUE; "
+ "the proper way of declaring an unconditional loop is \"for (;;)\""
), ws.getLocation());
return this.compileUnconditionalLoop(ws, ws.body, null);
} else
{
this.warning("WSNR", "WHILE statement never repeats", ws.getLocation());
}
}
// GOTO condition.
Offset wtc = this.getCodeContext().new BasicBlock();
this.gotO(ws, wtc);
final CodeContext.Offset bodyOffset = this.getCodeContext().newBasicBlock();
Inserter bodyInserter = this.codeContext.newInserter();
wtc.set();
ws.whereToContinue = null;
// Compile the condition first.
// This is necessary because the condition may modify the stack map, e.g.
// String line;
// while ((line = bufferedReader.readLine()) != null) {
// System.out.println(line);
// }
this.compileBoolean(ws.condition, bodyOffset, UnitCompiler.JUMP_IF_TRUE);
// Now compile the body.
try {
StackMap smBeforeBody = this.codeContext.currentInserter().getStackMap();
this.codeContext.pushInserter(bodyInserter);
this.codeContext.currentInserter().setStackMap(smBeforeBody);
this.compile(ws.body); // Return value (CCN) is ignored.
if (ws.whereToContinue != null) {
ws.whereToContinue.set();
ws.whereToContinue = null;
}
} finally {
this.codeContext.popInserter();
}
if (ws.whereToBreak != null) {
ws.whereToBreak.set();
ws.whereToBreak = null;
}
return true;
}
private boolean
compileUnconditionalLoop(ContinuableStatement cs, BlockStatement body, @Nullable Rvalue[] update)
throws CompileException {
if (update != null) return this.compileUnconditionalLoopWithUpdate(cs, body, update);
// Compile body.
Offset wtc = (cs.whereToContinue = this.getCodeContext().newBasicBlock());
if (this.compile(body)) this.gotO(cs, wtc);
cs.whereToContinue = null;
Offset wtb = cs.whereToBreak;
if (wtb == null) return false;
wtb.set();
cs.whereToBreak = null;
return true;
}
private boolean
compileUnconditionalLoopWithUpdate(ContinuableStatement cs, BlockStatement body, Rvalue[] update)
throws CompileException {
// Compile body.
cs.whereToContinue = null;
final CodeContext.Offset bodyOffset = this.getCodeContext().newBasicBlock();
boolean bodyCcn = this.compile(body);
// Compile the "update".
if (cs.whereToContinue != null) cs.whereToContinue.set();
if (!bodyCcn && cs.whereToContinue == null) {
this.warning("LUUR", "Loop update is unreachable", update[0].getLocation());
} else
{
for (Rvalue rv : update) this.compile(rv);
this.gotO(cs, bodyOffset);
this.getCodeContext().currentInserter().setStackMap(null);
}
cs.whereToContinue = null;
Offset wtb = cs.whereToBreak;
if (wtb == null) return false;
wtb.set();
cs.whereToBreak = null;
return true;
}
private boolean
compile2(LabeledStatement ls) throws CompileException {
boolean canCompleteNormally = this.compile(ls.body);
Offset wtb = ls.whereToBreak;
if (wtb == null) return canCompleteNormally;
if (!canCompleteNormally) this.getCodeContext().currentInserter().setStackMap(wtb.getStackMap());
wtb.set();
ls.whereToBreak = null;
return true;
}
private enum SwitchKind { INT, ENUM, STRING }
private boolean
compile2(SwitchStatement ss) throws CompileException {
SwitchKind kind;
short ssvLvIndex = -1; // Only relevant if kind == STRING.
StackMap smBeforeSwitch = this.codeContext.currentInserter().getStackMap();
// Determine SWITCH kind.
IType switchExpressionType = this.getType(ss.condition);
if (this.iClassLoader.TYPE_java_lang_String == switchExpressionType) {
kind = SwitchKind.STRING;
} else
if (UnitCompiler.isAssignableFrom(this.iClassLoader.TYPE_java_lang_Enum, switchExpressionType)) {
kind = SwitchKind.ENUM;
} else
{
kind = SwitchKind.INT;
}
// Prepare the map of case labels to code offsets.
TreeMap caseLabelMap = new TreeMap<>();
CodeContext.Offset defaultLabelOffset = null;
CodeContext.Offset[] sbsgOffsets = new CodeContext.Offset[ss.sbsgs.size()];
for (int i = 0; i < ss.sbsgs.size(); ++i) {
SwitchBlockStatementGroup sbsg = (SwitchBlockStatementGroup) ss.sbsgs.get(i);
sbsgOffsets[i] = this.getCodeContext().new BasicBlock();
for (Rvalue caseLabel : sbsg.caseLabels) {
Integer civ;
switch (kind) {
case ENUM:
CIV: {
if (!(caseLabel instanceof AmbiguousName)) {
this.compileError("Case label must be an enum constant", caseLabel.getLocation());
civ = 99;
break;
}
String[] identifiers = ((AmbiguousName) caseLabel).identifiers;
if (identifiers.length != 1) {
this.compileError("Case label must be a plain enum constant", caseLabel.getLocation());
civ = 99;
break;
}
String constantName = identifiers[0];
int ordinal = 0;
for (IField f : UnitCompiler.rawTypeOf(switchExpressionType).getDeclaredIFields()) {
if (f.getAccess() != Access.PUBLIC || !f.isStatic()) continue;
if (f.getName().equals(constantName)) {
civ = ordinal;
break CIV;
}
ordinal++;
}
this.compileError("Unknown enum constant \"" + constantName + "\"", caseLabel.getLocation());
civ = 99;
}
// Store in case label map.
if (caseLabelMap.containsKey(civ)) {
this.compileError("Duplicate \"case\" switch label value", caseLabel.getLocation());
}
caseLabelMap.put(civ, sbsgOffsets[i]);
break;
case INT:
{
// Verify that case label value is a constant.
Object cv = this.getConstantValue(caseLabel);
if (cv == UnitCompiler.NOT_CONSTANT) {
this.compileError(
"Value of 'case' label does not pose a constant value",
caseLabel.getLocation()
);
civ = 99;
break;
}
// Convert char, byte, short, int to "Integer".
if (cv instanceof Integer) {
civ = (Integer) cv;
} else
if (cv instanceof Number) {
civ = Integer.valueOf(((Number) cv).intValue());
} else
if (cv instanceof Character) {
civ = Integer.valueOf(((Character) cv).charValue());
} else {
this.compileError(
"Value of case label must be a char, byte, short or int constant",
caseLabel.getLocation()
);
civ = Integer.valueOf(99);
}
}
// Store in case label map.
if (caseLabelMap.containsKey(civ)) {
this.compileError("Duplicate \"case\" switch label value", caseLabel.getLocation());
}
caseLabelMap.put(civ, sbsgOffsets[i]);
break;
case STRING:
{
// Verify that the case label value is a string constant.
Object cv = this.getConstantValue(caseLabel);
if (!(cv instanceof String)) {
this.compileError(
"Value of 'case' label is not a string constant",
caseLabel.getLocation()
);
civ = 99;
break;
}
// Use the string constant's hash code as the SWITCH key.
civ = cv.hashCode();
}
// Store in case label map.
if (!caseLabelMap.containsKey(civ)) {
caseLabelMap.put(civ, this.getCodeContext().new BasicBlock());
}
break;
default:
throw new AssertionError(kind);
}
}
if (sbsg.hasDefaultLabel) {
if (defaultLabelOffset != null) {
this.compileError("Duplicate \"default\" switch label", sbsg.getLocation());
}
defaultLabelOffset = sbsgOffsets[i];
}
}
if (defaultLabelOffset == null) defaultLabelOffset = this.getWhereToBreak(ss);
// Compute the condition.
this.compileGetValue(ss.condition);
// Postprocess the condition.
switch (kind) {
case STRING:
// Store the string value in a (hidden) local variable, because after we do the SWITCH
// on the string's hash code, we need to check for string equality with the CASE
// labels.
this.dup(ss);
ssvLvIndex = this.getCodeContext().allocateLocalVariable((short) 1);
this.store(
ss, // locatable
this.iClassLoader.TYPE_java_lang_String, // lvType
ssvLvIndex // lvIndex
);
this.invokeMethod(ss, this.iClassLoader.METH_java_lang_String__hashCode);
break;
case ENUM:
this.invokeMethod(ss, this.iClassLoader.METH_java_lang_Enum__ordinal);
break;
case INT:
this.assignmentConversion(
ss, // locatable
switchExpressionType, // sourceType
IClass.INT, // targetType
null // constantValue
);
break;
default:
throw new AssertionError(kind);
}
// Generate TABLESWITCH or LOOKUPSWITCH instruction.
if (caseLabelMap.isEmpty()) {
// Special case: SWITCH statement without CASE labels (but maybe a DEFAULT label).
this.pop(ss, IClass.INT);
} else
if (
(Integer) caseLabelMap.firstKey() + caseLabelMap.size() // Beware of INT overflow!
>= (Integer) caseLabelMap.lastKey() - caseLabelMap.size()
) {
// The case label values are strictly consecutive or almost consecutive (at most 50%
// 'gaps'), so let's use a TABLESWITCH.
this.tableswitch(ss, caseLabelMap, defaultLabelOffset);
} else
{
// The case label values are not 'consecutive enough', so use a LOOKUPSWITCH.
this.lookupswitch(ss, caseLabelMap, defaultLabelOffset);
}
if (kind == SwitchKind.STRING) {
// For STRING SWITCH, we must generate extra code that checks for string equality --
// the strings' hash codes are not globally unique (as, e.g. MD5).
StackMap smBeforeSbsg = this.codeContext.currentInserter().getStackMap();
for (Entry e : caseLabelMap.entrySet()) {
final Integer caseHashCode = (Integer) e.getKey();
final CodeContext.Offset offset = (CodeContext.Offset) e.getValue();
offset.set();
Set caseLabelValues = new HashSet<>();
for (int i = 0; i < ss.sbsgs.size(); i++) {
SwitchBlockStatementGroup sbsg = (SwitchBlockStatementGroup) ss.sbsgs.get(i);
this.codeContext.currentInserter().setStackMap(smBeforeSbsg);
for (Rvalue caseLabel : sbsg.caseLabels) {
String cv = (String) this.getConstantValue(caseLabel);
assert cv != null;
if (!caseLabelValues.add(cv)) {
this.compileError(
"Duplicate case label \"" + cv + "\"",
caseLabel.getLocation()
);
}
if (cv.hashCode() != caseHashCode) continue;
this.load(sbsg, this.iClassLoader.TYPE_java_lang_String, ssvLvIndex);
this.consT(caseLabel, cv);
this.invokeMethod(caseLabel, this.iClassLoader.METH_java_lang_String__equals__java_lang_Object);
this.ifxx(sbsg, UnitCompiler.NE, sbsgOffsets[i]);
}
}
this.gotO(ss, defaultLabelOffset);
}
}
// Compile statement groups.
boolean canCompleteNormally = true;
for (int i = 0; i < ss.sbsgs.size(); ++i) {
SwitchBlockStatementGroup sbsg = (SwitchBlockStatementGroup) ss.sbsgs.get(i);
sbsgOffsets[i].set();
this.codeContext.currentInserter().setStackMap(smBeforeSwitch);
canCompleteNormally = true;
for (BlockStatement bs : sbsg.blockStatements) {
if (!canCompleteNormally) {
this.compileError("Statement is unreachable", bs.getLocation());
break;
}
canCompleteNormally = this.compile(bs);
}
}
Offset wtb = ss.whereToBreak;
if (wtb == null) return canCompleteNormally;
if (!canCompleteNormally) this.codeContext.currentInserter().setStackMap(wtb.getStackMap());
wtb.set();
ss.whereToBreak = null;
return true;
}
private boolean
compile2(BreakStatement bs) throws CompileException {
// Find the broken statement.
BreakableStatement brokenStatement = null;
if (bs.label == null) {
for (
Scope s = bs.getEnclosingScope();
s instanceof Statement || s instanceof CatchClause;
s = s.getEnclosingScope()
) {
if (s instanceof BreakableStatement) {
brokenStatement = (BreakableStatement) s;
break;
}
}
if (brokenStatement == null) {
this.compileError("\"break\" statement is not enclosed by a breakable statement", bs.getLocation());
return false;
}
} else {
for (
Scope s = bs.getEnclosingScope();
s instanceof Statement || s instanceof CatchClause;
s = s.getEnclosingScope()
) {
if (s instanceof LabeledStatement) {
LabeledStatement ls = (LabeledStatement) s;
if (ls.label.equals(bs.label)) {
brokenStatement = ls;
break;
}
}
}
if (brokenStatement == null) {
this.compileError((
"Statement \"break "
+ bs.label
+ "\" is not enclosed by a breakable statement with label \""
+ bs.label
+ "\""
), bs.getLocation());
return false;
}
}
this.leaveStatements(
bs.getEnclosingScope(), // from
brokenStatement.getEnclosingScope() // to
);
this.gotO(bs, this.getWhereToBreak(brokenStatement));
return false;
}
private boolean
compile2(ContinueStatement cs) throws CompileException {
// Find the continued statement.
ContinuableStatement continuedStatement = null;
if (cs.label == null) {
for (
Scope s = cs.getEnclosingScope();
s instanceof Statement || s instanceof CatchClause;
s = s.getEnclosingScope()
) {
if (s instanceof ContinuableStatement) {
continuedStatement = (ContinuableStatement) s;
break;
}
}
if (continuedStatement == null) {
this.compileError(
"\"continue\" statement is not enclosed by a continuable statement",
cs.getLocation()
);
return false;
}
} else {
for (
Scope s = cs.getEnclosingScope();
s instanceof Statement || s instanceof CatchClause;
s = s.getEnclosingScope()
) {
if (s instanceof LabeledStatement) {
LabeledStatement ls = (LabeledStatement) s;
if (ls.label.equals(cs.label)) {
Statement st = ls.body;
while (st instanceof LabeledStatement) st = ((LabeledStatement) st).body;
if (!(st instanceof ContinuableStatement)) {
this.compileError("Labeled statement is not continuable", st.getLocation());
return false;
}
continuedStatement = (ContinuableStatement) st;
break;
}
}
}
if (continuedStatement == null) {
this.compileError((
"Statement \"continue "
+ cs.label
+ "\" is not enclosed by a continuable statement with label \""
+ cs.label
+ "\""
), cs.getLocation());
return false;
}
}
Offset wtc = continuedStatement.whereToContinue;
if (wtc == null) {
wtc = (continuedStatement.whereToContinue = this.getCodeContext().new BasicBlock());
}
this.leaveStatements(
cs.getEnclosingScope(), // from
continuedStatement.getEnclosingScope() // to
);
this.gotO(cs, wtc);
return false;
}
private boolean
compile2(AssertStatement as) throws CompileException {
// assert expression1;
// if (!expression1) throw new AssertionError();
// assert expression1 : expression2;
// if (!expression1) throw new AssertionError(expression2);
CodeContext.Offset end = this.getCodeContext().new BasicBlock();
try {
this.compileBoolean(as.expression1, end, UnitCompiler.JUMP_IF_TRUE);
this.neW(as, this.iClassLoader.TYPE_java_lang_AssertionError);
this.dup(as);
Rvalue[] arguments = (
as.expression2 == null
? new Rvalue[0]
: new Rvalue[] { as.expression2 }
);
this.invokeConstructor(
as, // locatable
as, // scope
null, // enclosingInstance
this.iClassLoader.TYPE_java_lang_AssertionError, // targetClass
arguments // arguments
);
this.getCodeContext().popUninitializedVariableOperand();
this.getCodeContext().pushObjectOperand(Descriptor.JAVA_LANG_ASSERTIONERROR);
this.athrow(as);
} finally {
end.setBasicBlock();
}
return true;
}
@SuppressWarnings("static-method") private boolean
compile2(EmptyStatement es) { return true; }
private boolean
compile2(ExpressionStatement ee) throws CompileException {
try {
this.compile(ee.rvalue);
} catch (InternalCompilerException ice) {
throw new InternalCompilerException(ee.rvalue.getLocation(), null, ice);
}
return true;
}
private boolean
compile2(FieldDeclaration fd) throws CompileException {
final IClass declaringIClass = this.resolve(fd.getDeclaringType());
for (VariableDeclarator vd : fd.variableDeclarators) {
ArrayInitializerOrRvalue initializer = this.getNonConstantFinalInitializer(fd, vd);
if (initializer == null) continue;
// TODO: Compile annotations on fields.
// assert fd.modifiers.annotations.length == 0 : fd.getLocation();
try {
this.addLineNumberOffset(vd);
if (!declaringIClass.isInterface() && !fd.isStatic()) this.load(vd, declaringIClass, 0);
IClass fieldType = this.getRawType(fd.type);
this.compile(initializer, UnitCompiler.this.iClassLoader.getArrayIClass(fieldType, vd.brackets));
// No need to check accessibility here.
;
// TODO: Compile annotations on fields.
// assert fd.modifiers.annotations.length == 0;
IField iField = declaringIClass.getDeclaredIField(vd.name);
assert iField != null : fd.getDeclaringType() + " has no field " + vd.name;
this.putfield(fd, iField);
} catch (InternalCompilerException ice) {
throw new InternalCompilerException(initializer.getLocation(), null, ice);
}
}
return true;
}
private boolean
compile2(IfStatement is) throws CompileException {
final BlockStatement ts = is.thenStatement;
final BlockStatement es = is.elseStatement != null ? is.elseStatement : new EmptyStatement(ts.getLocation());
Object cv = this.getConstantValue(is.condition);
if (cv instanceof Boolean) {
// Constant condition.
this.fakeCompile(is.condition);
BlockStatement seeingStatement, blindStatement;
if (((Boolean) cv).booleanValue()) {
seeingStatement = ts;
blindStatement = es;
} else {
seeingStatement = es;
blindStatement = ts;
}
// Compile the seeing statement.
final CodeContext.Inserter ins = this.getCodeContext().newInserter();
StackMap smBeforeSeeingStatement = this.codeContext.currentInserter().getStackMap();
boolean ssccn = this.compile(seeingStatement);
Offset afterSeeingStatement = this.codeContext.newOffset();
// Fake-compile the blind statement.
this.codeContext.currentInserter().setStackMap(smBeforeSeeingStatement);
boolean bsccn = this.fakeCompile(blindStatement);
afterSeeingStatement.setStackMap(); // Merge stack maps after seeing and after blind statements.
if (ssccn) return true;
if (!bsccn) return false;
// Hm... the "seeing statement" cannot complete normally, but the "blind statement" can. Things are getting
// complicated here! The robust solution is to compile the constant-condition-IF statement as a
// non-constant-condition-IF statement. As an optimization, iff the IF-statement is enclosed ONLY by blocks,
// then the remaining bytecode can be written to a "fake" code context, i.e. be thrown away.
// Compile constant-condition-IF statement as non-constant-condition-IF statement.
CodeContext.Offset off = this.getCodeContext().newBasicBlock();
this.getCodeContext().pushInserter(ins);
try {
this.consT(is, Boolean.FALSE);
this.ifxx(is, UnitCompiler.NE, off);
} finally {
this.getCodeContext().popInserter();
}
// Now return "ccn=true" so that the following statements are not reported as "unreachable".
return true;
}
// Non-constant condition.
if (this.generatesCode(ts)) {
if (this.generatesCode(es)) {
// if () else
CodeContext.Offset eso = this.getCodeContext().new BasicBlock();
CodeContext.Offset end = this.getCodeContext().new BasicBlock();
this.compileBoolean(is.condition, eso, UnitCompiler.JUMP_IF_FALSE);
// Compile "then" statement.
boolean tsccn = this.compile(ts);
if (tsccn) {
this.gotO(is, end);
}
// Compile "else" statment.
eso.setBasicBlock();
boolean esccn = this.compile(es);
if (!tsccn && !esccn) return false;
end.setBasicBlock();
return tsccn || esccn;
} else {
// if () else ;
CodeContext.Offset end = this.getCodeContext().new BasicBlock();
this.compileBoolean(is.condition, end, UnitCompiler.JUMP_IF_FALSE);
this.compile(ts);
end.setBasicBlock();
return true;
}
} else {
if (this.generatesCode(es)) {
// if () ; else
CodeContext.Offset end = this.getCodeContext().new BasicBlock();
this.compileBoolean(is.condition, end, UnitCompiler.JUMP_IF_TRUE);
this.compile(es);
end.setBasicBlock();
return true;
} else {
// if () ; else ;
IType conditionType = this.compileGetValue(is.condition);
if (conditionType != IClass.BOOLEAN) this.compileError("Not a boolean expression", is.getLocation());
this.pop(is, conditionType);
return true;
}
}
}
private boolean
compile2(LocalClassDeclarationStatement lcds) throws CompileException {
// Check for redefinition.
LocalClassDeclaration otherLcd = UnitCompiler.findLocalClassDeclaration(lcds, lcds.lcd.name);
if (otherLcd != null && otherLcd != lcds.lcd) {
this.compileError(
"Redeclaration of local class \""
+ lcds.lcd.name
+ "\"; previously declared in "
+ otherLcd.getLocation()
);
}
this.compile(lcds.lcd);
return true;
}
/**
* Finds a local class declared in any block enclosing the given block statement.
*/
@Nullable private static LocalClassDeclaration
findLocalClassDeclaration(Scope s, String name) {
if (s instanceof CompilationUnit) return null;
for (;;) {
Scope es = s.getEnclosingScope();
if (es instanceof CompilationUnit) break;
if (
s instanceof BlockStatement
&& (es instanceof Block || es instanceof FunctionDeclarator)
) {
BlockStatement bs = (BlockStatement) s;
List statements = (
es instanceof BlockStatement
? ((Block) es).statements
: ((FunctionDeclarator) es).statements
);
if (statements != null) {
for (BlockStatement bs2 : statements) {
if (bs2 instanceof LocalClassDeclarationStatement) {
LocalClassDeclarationStatement lcds = ((LocalClassDeclarationStatement) bs2);
if (lcds.lcd.name.equals(name)) return lcds.lcd;
}
if (bs2 == bs) break;
}
}
}
s = es;
}
return null;
}
private boolean
compile2(LocalVariableDeclarationStatement lvds) throws CompileException {
// Ignore annotations here.
for (VariableDeclarator vd : lvds.variableDeclarators) {
try {
LocalVariable lv = this.getLocalVariable(lvds, vd);
lv.setSlot(this.allocateLocalVariableSlot(lv.type, vd.name));
ArrayInitializerOrRvalue initializer = vd.initializer;
if (initializer != null) {
this.compile(initializer, lv.type);
this.store(lvds, lv);
}
} catch (RuntimeException re) {
throw new RuntimeException(vd.getLocation().toString(), re);
}
}
return true;
}
private void
compile(final ArrayInitializerOrRvalue aiorv, final IType arrayType) throws CompileException {
aiorv.accept(new ArrayInitializerOrRvalueVisitor() {
@Override @Nullable public Void
visitArrayInitializer(ArrayInitializer ai) throws CompileException {
UnitCompiler.this.compileGetValue(ai, arrayType);
return null;
}
@Override @Nullable public Void
visitRvalue(Rvalue rhs) throws CompileException {
UnitCompiler.this.assignmentConversion(
aiorv, // locatable
UnitCompiler.this.compileGetValue(rhs), // sourceType
arrayType, // targetType
UnitCompiler.this.getConstantValue(rhs) // constantValue
);
return null;
}
});
}
private VerificationTypeInfo
verificationTypeInfo(@Nullable IType type) {
if (type == null) return ClassFile.StackMapTableAttribute.NULL_VARIABLE_INFO; // TODO Is that the right thing to do?
String fd = UnitCompiler.rawTypeOf(type).getDescriptor();
if (
Descriptor.BOOLEAN.equals(fd)
|| Descriptor.BYTE.equals(fd)
|| Descriptor.CHAR.equals(fd)
|| Descriptor.INT.equals(fd)
|| Descriptor.SHORT.equals(fd)
) return ClassFile.StackMapTableAttribute.INTEGER_VARIABLE_INFO;
if (Descriptor.LONG.equals(fd)) return ClassFile.StackMapTableAttribute.LONG_VARIABLE_INFO;
if (Descriptor.FLOAT.equals(fd)) return ClassFile.StackMapTableAttribute.FLOAT_VARIABLE_INFO;
if (Descriptor.DOUBLE.equals(fd)) return ClassFile.StackMapTableAttribute.DOUBLE_VARIABLE_INFO;
if (
Descriptor.isClassOrInterfaceReference(fd)
|| Descriptor.isArrayReference(fd)
) return new ObjectVariableInfo(this.getCodeContext().getClassFile().addConstantClassInfo(fd), fd);
throw new InternalCompilerException("Cannot make VerificationTypeInfo from \"" + fd + "\"");
}
/**
* @return The {@link LocalVariable} corresponding with the local variable declaration/declarator
*/
public LocalVariable
getLocalVariable(LocalVariableDeclarationStatement lvds, VariableDeclarator vd) throws CompileException {
if (vd.localVariable != null) return vd.localVariable;
// Determine variable type.
Type variableType = lvds.type;
for (int k = 0; k < vd.brackets; ++k) variableType = new ArrayType(variableType);
// Ignore "lvds.modifiers.annotations".
return (vd.localVariable = new LocalVariable(
lvds.isFinal(), // finaL
this.getType(variableType) // type
));
}
private boolean
compile2(ReturnStatement rs) throws CompileException {
// Determine enclosing block, function and compilation Unit.
FunctionDeclarator enclosingFunction = null;
{
Scope s = rs.getEnclosingScope();
while (s instanceof Statement || s instanceof CatchClause) s = s.getEnclosingScope();
enclosingFunction = (FunctionDeclarator) s;
}
Rvalue orv = rs.returnValue;
IType returnType = this.getReturnType(enclosingFunction);
if (returnType == IClass.VOID) {
if (orv != null) this.compileError("Method must not return a value", rs.getLocation());
this.leaveStatements(
rs.getEnclosingScope(), // from
enclosingFunction // to
);
this.returN(rs);
return false;
}
if (orv == null) {
this.compileError("Method must return a value", rs.getLocation());
return false;
}
IType type = this.compileGetValue(orv);
this.assignmentConversion(
rs, // locatable
type, // sourceType
returnType, // targetType
this.getConstantValue(orv) // constantValue
);
this.leaveStatements(
rs.getEnclosingScope(), // from
enclosingFunction // to
);
this.xreturn(rs, returnType);
return false;
}
private boolean
compile2(SynchronizedStatement ss) throws CompileException {
// Evaluate monitor object expression.
if (!UnitCompiler.isAssignableFrom(this.iClassLoader.TYPE_java_lang_Object, this.compileGetValue(ss.expression))) {
this.compileError(
"Monitor object of \"synchronized\" statement is not a subclass of \"Object\"",
ss.getLocation()
);
}
this.getCodeContext().saveLocalVariables();
boolean canCompleteNormally = false;
try {
// Allocate a local variable for the monitor object.
ss.monitorLvIndex = this.getCodeContext().allocateLocalVariable((short) 1);
// Store the monitor object.
this.dup(ss);
this.store(ss, this.iClassLoader.TYPE_java_lang_Object, ss.monitorLvIndex);
// Create lock on the monitor object.
this.monitorenter(ss);
// Compile the statement body.
final CodeContext.Offset monitorExitOffset = this.getCodeContext().new BasicBlock();
final CodeContext.Offset beginningOfBody = this.getCodeContext().newOffset();
StackMap smBeforeBody = this.codeContext.currentInserter().getStackMap();
canCompleteNormally = this.compile(ss.body);
if (canCompleteNormally) {
this.gotO(ss, monitorExitOffset);
}
StackMap save = this.codeContext.currentInserter().getStackMap();
try {
this.codeContext.currentInserter().setStackMap(smBeforeBody);
this.getCodeContext().pushObjectOperand(Descriptor.JAVA_LANG_THROWABLE);
// Generate the exception handler.
CodeContext.Offset here = this.getCodeContext().newBasicBlock();
this.getCodeContext().addExceptionTableEntry(
beginningOfBody, // startPC
here, // endPC
here, // handlerPC
null // catchTypeFD
);
this.leave(ss);
this.athrow(ss);
} finally {
this.codeContext.currentInserter().setStackMap(save);
}
// Unlock monitor object.
if (canCompleteNormally) {
monitorExitOffset.set();
this.leave(ss);
}
} finally {
this.getCodeContext().restoreLocalVariables();
}
return canCompleteNormally;
}
private boolean
compile2(ThrowStatement ts) throws CompileException {
IType expressionType = this.compileGetValue(ts.expression);
this.checkThrownException(
ts, // locatable
expressionType, // type
ts.getEnclosingScope() // scope
);
this.athrow(ts);
return false;
}
/**
* Interface for delayed code generation.
*/
interface Compilable2 { boolean compile() throws CompileException; }
private boolean
compile2(final TryStatement ts) throws CompileException {
return this.compileTryCatchFinallyWithResources(
ts, // tryStatement
ts.resources, // resources
new Compilable2() { // compileBody
@Override public boolean
compile() throws CompileException { return UnitCompiler.this.compile(ts.body); }
},
ts.finallY // finallY
);
}
/**
* Generates code for a TRY statement with (possibly zero) resources and an (optional) FINALLY clause.
*
* @return Whether the code can complete normally
*/
private boolean
compileTryCatchFinallyWithResources(
final TryStatement ts,
List resources,
final Compilable2 compileBody,
@Nullable final Block finallY
) throws CompileException {
// Short-circuit for zero resources.
if (resources.isEmpty()) {
return this.compileTryCatchFinally(ts, compileBody, finallY);
}
// Prepare recursion for all declared resources.
TryStatement.Resource firstResource = (TryStatement.Resource) resources.get(0);
final List followingResources = resources.subList(1, resources.size());
final Location loc = firstResource.getLocation();
final IClass tt = this.iClassLoader.TYPE_java_lang_Throwable;
this.getCodeContext().saveLocalVariables();
try {
LocalVariable
identifier = (LocalVariable) firstResource.accept(
new TryStatementResourceVisitor() {
@Override @Nullable public LocalVariable
visitLocalVariableDeclaratorResource(LocalVariableDeclaratorResource lvdr) throws CompileException {
// final {VariableModifierNoFinal} R Identifier = Expression
IType lvType = UnitCompiler.this.getType(lvdr.type);
LocalVariable result = UnitCompiler.this.allocateLocalVariable(true /*finaL*/, lvType);
ArrayInitializerOrRvalue initializer = lvdr.variableDeclarator.initializer;
assert initializer != null;
UnitCompiler.this.compile(initializer, lvType);
UnitCompiler.this.store(ts, result);
return result;
}
@Override @Nullable public LocalVariable
visitVariableAccessResource(VariableAccessResource var) throws CompileException {
// Expression
if (
!UnitCompiler.this.options.contains(
JaninoOption.EXPRESSIONS_IN_TRY_WITH_RESOURCES_ALLOWED
)
&& !(var.variableAccess instanceof AmbiguousName)
&& !(var.variableAccess instanceof FieldAccessExpression)
&& !(var.variableAccess instanceof SuperclassFieldAccessExpression)
) {
throw new CompileException(
var.variableAccess.getClass().getSimpleName() + " rvalue not allowed as a resource",
var.getLocation()
);
}
LocalVariable result = UnitCompiler.this.allocateLocalVariable(
true, // finaL
UnitCompiler.this.compileGetValue(var.variableAccess) // localVariableType
);
UnitCompiler.this.store(ts, result);
return result;
}
}
);
assert identifier != null;
// Throwable #primaryExc = null;
LocalVariable primaryExc = this.allocateLocalVariable(true /*finaL*/, tt);
this.consT(ts, (Object) null);
this.store(ts, primaryExc);
CatchParameter suppressedException = new CatchParameter(
loc, // location
false, // finaL
new Type[] { new SimpleType(loc, tt) }, // types
"___" // name
);
// Generate the FINALLY clause for the TRY-with-resources statement; see JLS9 14.20.3.1.
// if (Identifier != null) {
// if (#primaryExc != null) {
// try {
// Identifier.close();
// } catch (Throwable #suppressedExc) {
// // Only iff Java >= 7:
// #primaryExc.addSuppressed(#suppressedExc);
// }
// } else {
// Identifier.close();
// }
// }
BlockStatement afterClose = (
this.iClassLoader.METH_java_lang_Throwable__addSuppressed == null
? new EmptyStatement(loc)
: new ExpressionStatement(
new MethodInvocation(
loc, // location
new LocalVariableAccess(loc, primaryExc), // target
"addSuppressed", // methodName
new Rvalue[] { // arguments
new LocalVariableAccess(loc, this.getLocalVariable(suppressedException)),
}
)
)
);
BlockStatement f = new IfStatement(
loc, // location
new BinaryOperation( // condition
loc, // location
new LocalVariableAccess(loc, identifier), // lhs
"!=", // operator
new NullLiteral(loc) // rhs
),
new IfStatement( // thenStatement
loc, // location
new BinaryOperation( // condition
loc, // location
new LocalVariableAccess(loc, primaryExc), // lhs
"!=", // operator
new NullLiteral(loc) // rhs
),
new TryStatement( // thenStatement
loc, // location
new ExpressionStatement( // body
new MethodInvocation(loc, new LocalVariableAccess(loc, identifier), "close", new Rvalue[0])
),
Collections.singletonList(new CatchClause( // catchClauses
loc, // location
suppressedException, // caughtException
afterClose // body
))
),
new ExpressionStatement( // elseStatement
new MethodInvocation(loc, new LocalVariableAccess(loc, identifier), "close", new Rvalue[0])
)
)
);
f.setEnclosingScope(ts);
// Recurse with one resource less.
return this.compileTryCatchFinally(
ts, // tryStatement
new Compilable2() { // compileBody
@Override public boolean
compile() throws CompileException {
return UnitCompiler.this.compileTryCatchFinallyWithResources(
ts,
followingResources,
compileBody,
finallY
);
}
},
f // finallY
);
} finally {
this.getCodeContext().restoreLocalVariables();
}
}
/**
* Generates code for a TRY statement without resources, but with an (optional) FINALLY clause.
*
* @return Whether the code can complete normally
*/
private boolean
compileTryCatchFinally(
final TryStatement ts,
final Compilable2 compileBody,
@Nullable final BlockStatement finallY
) throws CompileException {
if (finallY == null) {
final CodeContext.Offset beginningOfBody = this.getCodeContext().newOffset();
final CodeContext.Offset afterStatement = this.getCodeContext().new BasicBlock();
boolean canCompleteNormally = this.compileTryCatch(ts, compileBody, beginningOfBody, afterStatement);
afterStatement.set();
return canCompleteNormally;
}
// Compile a TRY statement *with* a FINALLY clause.
final CodeContext.Offset afterStatement = this.getCodeContext().new BasicBlock();
boolean canCompleteNormally;
this.getCodeContext().saveLocalVariables();
try {
StackMap smBeforeBody = this.getCodeContext().currentInserter().getStackMap();
final CodeContext.Offset beginningOfBody = this.getCodeContext().newOffset();
canCompleteNormally = this.compileTryCatch(ts, compileBody, beginningOfBody, afterStatement);
StackMap smAfterBody = this.getCodeContext().currentInserter().getStackMap();
// Generate the "catch (any) {" clause that invokes the FINALLY subroutine.
this.getCodeContext().saveLocalVariables();
try {
this.getCodeContext().currentInserter().setStackMap(smBeforeBody);
// Push the exception on the operand stack.
this.getCodeContext().pushObjectOperand(Descriptor.JAVA_LANG_THROWABLE);
CodeContext.Offset here = this.getCodeContext().newBasicBlock();
this.getCodeContext().addExceptionTableEntry(
beginningOfBody, // startPC
here, // endPC
here, // handlerPC
null // catchTypeFD
);
// Save the exception object in an anonymous local variable.
short evi = this.getCodeContext().allocateLocalVariable((short) 1);
this.store(
finallY, // locatable
this.iClassLoader.TYPE_java_lang_Throwable, // lvType
evi // lvIndex
);
if (this.compile(finallY)) {
this.load(
finallY, // locatable
this.iClassLoader.TYPE_java_lang_Throwable, // type
evi // index
);
this.athrow(finallY);
}
this.getCodeContext().currentInserter().setStackMap(smAfterBody);
} finally {
// The exception object local variable allocated above MUST NOT BE RELEASED until after the FINALLY
// block is compiled, for otherwise you get
// java.lang.VerifyError: ... Accessing value from uninitialized register 7
this.getCodeContext().restoreLocalVariables();
}
} finally {
this.getCodeContext().restoreLocalVariables();
}
afterStatement.set();
if (canCompleteNormally) canCompleteNormally = UnitCompiler.this.compile(finallY);
return canCompleteNormally;
}
/**
* Generates code for a TRY statement without resources and without a FINALLY clause.
*
* @return Whether the code can complete normally
*/
private boolean
compileTryCatch(
TryStatement tryStatement,
Compilable2 compileBody,
final CodeContext.Offset beginningOfBody,
final CodeContext.Offset afterStatement
) throws CompileException {
// Initialize all catch clauses as "unreachable" only to check later that they ARE indeed reachable.
for (CatchClause catchClause : tryStatement.catchClauses) {
catchClause.reachable = false;
for (Type t : catchClause.catchParameter.types) {
IType caughtExceptionType = this.getType(t);
catchClause.reachable |= (
// Superclass or subclass of "java.lang.Error"?
UnitCompiler.isAssignableFrom(this.iClassLoader.TYPE_java_lang_Error, caughtExceptionType)
|| UnitCompiler.isAssignableFrom(caughtExceptionType, this.iClassLoader.TYPE_java_lang_Error)
// Superclass or subclass of "java.lang.RuntimeException"?
|| UnitCompiler.isAssignableFrom(this.iClassLoader.TYPE_java_lang_RuntimeException, caughtExceptionType)
|| UnitCompiler.isAssignableFrom(caughtExceptionType, this.iClassLoader.TYPE_java_lang_RuntimeException)
);
}
}
StackMap smBeforeBody = this.getCodeContext().currentInserter().getStackMap();
boolean bodyCcn = compileBody.compile();
CodeContext.Offset afterBody = this.getCodeContext().newOffset();
StackMap smAfterBody = this.getCodeContext().currentInserter().getStackMap();
if (bodyCcn) {
this.gotO(tryStatement, afterStatement);
}
boolean catchCcn = false; // "At least one catch clause can complete normally"
if (beginningOfBody.offset != afterBody.offset) { // Avoid zero-length exception table entries.
for (int i = 0; i < tryStatement.catchClauses.size(); ++i) {
this.getCodeContext().currentInserter().setStackMap(smBeforeBody);
this.getCodeContext().saveLocalVariables();
try {
CatchClause catchClause = (CatchClause) tryStatement.catchClauses.get(i);
if (catchClause.catchParameter.types.length != 1) {
throw UnitCompiler.compileException(catchClause, "Multi-type CATCH parameter NYI");
}
IClass caughtExceptionType = this.getRawType(catchClause.catchParameter.types[0]);
// Verify that the CATCH clause is reachable.
if (!catchClause.reachable) {
this.compileError("Catch clause is unreachable", catchClause.getLocation());
}
// Push the exception on the operand stack.
this.getCodeContext().pushObjectOperand(caughtExceptionType.getDescriptor());
// Allocate the "exception variable".
LocalVariableSlot
exceptionVarSlot = this.allocateLocalVariableSlot(caughtExceptionType, catchClause.catchParameter.name);
// Kludge: Treat the exception variable like a local variable of the catch clause body.
this.getLocalVariable(catchClause.catchParameter).setSlot(exceptionVarSlot);
this.getCodeContext().addExceptionTableEntry(
beginningOfBody, // startPC
afterBody, // endPC
this.getCodeContext().newBasicBlock(), // handlerPC
caughtExceptionType.getDescriptor() // catchTypeFD
);
this.store(
catchClause, // locatable
caughtExceptionType, // lvType
exceptionVarSlot.getSlotIndex() // lvIndex
);
if (this.compile(catchClause.body)) {
if (tryStatement.finallY == null || this.compile(tryStatement.finallY)) {
catchCcn = true;
this.gotO(catchClause, afterStatement);
afterStatement.setStackMap();
}
}
} finally {
this.getCodeContext().restoreLocalVariables();
}
}
}
this.getCodeContext().currentInserter().setStackMap(smAfterBody);
return bodyCcn | catchCcn;
}
// ------------ FunctionDeclarator.compile() -------------
private void
compile(FunctionDeclarator fd, final ClassFile classFile) throws CompileException {
try {
this.compile2(fd, classFile);
} catch (ClassFileException cfe) {
throw new ClassFileException("Compiling \"" + fd + "\": " + cfe.getMessage(), cfe);
} catch (RuntimeException re) {
throw new InternalCompilerException(fd.getLocation(), "Compiling \"" + fd + "\"", re);
}
}
private void
compile2(FunctionDeclarator fd, final ClassFile classFile) throws CompileException {
ClassFile.MethodInfo mi;
if (this.getTargetVersion() < 8 && fd instanceof MethodDeclarator && ((MethodDeclarator) fd).isDefault()) {
this.compileError((
""
+ "Default interface methods only available for target version 8+. "
+ "Either use \"setTargetVersion(8)\", or \"-DdefaultTargetVersion=8\"."
), fd.getLocation());
}
if (fd.getAccess() == Access.PRIVATE) {
if (
fd instanceof MethodDeclarator
&& !((MethodDeclarator) fd).isStatic()
&& !(fd.getDeclaringType() instanceof InterfaceDeclaration)
) {
// To make the non-static private method invocable for enclosing types, enclosed types and types
// enclosed by the same type, it is modified as follows:
// + Access is changed from PRIVATE to PACKAGE
// + The name is appended with "$"
// + It is made static
// + A parameter of type "declaring class" is prepended to the signature
short accessFlags = UnitCompiler.changeAccessibility(this.accessFlags(fd.getModifiers()), Mod.PACKAGE);
accessFlags |= Mod.STATIC;
mi = classFile.addMethodInfo(
accessFlags, // accessFlags
fd.name + '$', // methodName
( // methodMd
this.toIMethod((MethodDeclarator) fd)
.getDescriptor()
.prependParameter(this.resolve(fd.getDeclaringType()).getDescriptor())
)
);
} else
{
// TODO: Compile annotations on functions.
// assert fd.modifiers.annotations.length == 0 : "NYI";
short accessFlags = this.accessFlags(fd.getModifiers());
// To make the static private class method or private constructor invocable for enclosing types,
// enclosed types and types enclosed by the same type, it is modified as follows:
// + Access is changed from PRIVATE to PACKAGE
if (!(fd.getDeclaringType() instanceof InterfaceDeclaration)) {
accessFlags = UnitCompiler.changeAccessibility(accessFlags, Mod.PACKAGE);
}
if (fd.formalParameters.variableArity) accessFlags |= Mod.VARARGS;
mi = classFile.addMethodInfo(
accessFlags, // accessFlags
fd.name, // methodName
this.toIInvocable(fd).getDescriptor() // methodMD
);
}
} else {
// Non-PRIVATE function.
short accessFlags = this.accessFlags(fd.getModifiers());
if (fd.formalParameters.variableArity) accessFlags |= Mod.VARARGS;
if (fd.getDeclaringType() instanceof InterfaceDeclaration) {
accessFlags |= Mod.PUBLIC;
if (Mod.isStatic(accessFlags) && !"".equals(fd.name)) {
if (this.getTargetVersion() < 8) {
this.compileError("Static interface methods only available for target version 8+", fd.getLocation());
}
} else
if (fd instanceof MethodDeclarator && ((MethodDeclarator) fd).isDefault()) {
if (this.getTargetVersion() < 8) {
this.compileError("Default methods only available for target version 8+", fd.getLocation());
}
} else
{
accessFlags |= Mod.ABSTRACT;
}
}
mi = classFile.addMethodInfo(
accessFlags, // accessFlags
fd.name, // methodName
this.toIInvocable(fd).getDescriptor() // methodMD
);
}
// Add method annotations with retention != SOURCE.
this.compileAnnotations(fd.getAnnotations(), mi, classFile);
// Add "Exceptions" attribute (JVMS 4.7.4).
{
if (fd.thrownExceptions.length > 0) {
final short eani = classFile.addConstantUtf8Info("Exceptions");
List tecciis = new ArrayList<>(); // new short[fd.thrownExceptions.length];
for (int i = 0; i < fd.thrownExceptions.length; ++i) {
final Type te = fd.thrownExceptions[i];
if (te instanceof ReferenceType) {
ReferenceType rt = (ReferenceType) te;
// Don't include thrown exceptions that are parameterized, e.g.
// void meth() throws EX {...}
// , because we don't generate "Signature" attributes for methods, and "throws Throwable"
// would cause compilation problems when the class is loaded later, e.g. by ClassFileIClass.
if (
rt.identifiers.length == 1
&& UnitCompiler.LOOKS_LIKE_TYPE_PARAMETER.matcher(rt.identifiers[0]).matches()
) continue;
}
tecciis.add(classFile.addConstantClassInfo(this.getRawType(te).getDescriptor()));
}
short[] sa = new short[tecciis.size()];
for (int i = 0; i < tecciis.size(); i++) sa[i] = (Short) tecciis.get(i);
mi.addAttribute(new ClassFile.ExceptionsAttribute(eani, sa));
}
}
// Add "Deprecated" attribute (JVMS 4.7.10)
if (fd.hasDeprecatedDocTag()) {
mi.addAttribute(new ClassFile.DeprecatedAttribute(classFile.addConstantUtf8Info("Deprecated")));
}
// Add "AnnotationDefault" attribute (JVMS8 4.7.22)
if (fd instanceof MethodDeclarator) {
ElementValue defaultValue = ((MethodDeclarator) fd).defaultValue;
if (defaultValue != null) {
mi.addAttribute(
new ClassFile.AnnotationDefaultAttribute(
classFile.addConstantUtf8Info("AnnotationDefault"),
UnitCompiler.this.compileElementValue(defaultValue, classFile, fd.type instanceof ArrayType)
)
);
}
}
if (fd.getDeclaringType() instanceof InterfaceDeclaration) {
MethodDeclarator md = (MethodDeclarator) fd;
if (md.getAccess() == Access.PRIVATE && this.getTargetVersion() < 9) {
this.compileError("Private interface methods only available for target version 9+", fd.getLocation());
return;
}
if (md.isStrictfp() && !md.isDefault() && !md.isStatic()) {
this.compileError(
"Modifier strictfp only allowed for interface default methods and static interface methods",
fd.getLocation()
);
return;
}
}
if (
(
fd.getDeclaringType() instanceof InterfaceDeclaration
&& !((MethodDeclarator) fd).isStatic()
&& ((MethodDeclarator) fd).getAccess() != Access.PRIVATE
)
|| (fd instanceof MethodDeclarator && ((MethodDeclarator) fd).isAbstract())
|| (fd instanceof MethodDeclarator && ((MethodDeclarator) fd).isNative())
) {
if (((MethodDeclarator) fd).isDefault()) {
if (!(fd.getDeclaringType() instanceof InterfaceDeclaration)) {
this.compileError("Only interface method declarations may have the \"default\" modifier", fd.getLocation());
} else
if (((MethodDeclarator) fd).isStatic()) {
this.compileError("Static interface method declarations must not have the \"default\" modifier", fd.getLocation());
} else
if (fd.statements == null) {
this.compileError("Default method declarations must have a body", fd.getLocation());
}
} else {
if (fd.statements != null) this.compileError("Method must not declare a body", fd.getLocation());
return;
}
}
// Create CodeContext.
final CodeContext codeContext = new CodeContext(mi.getClassFile());
CodeContext savedCodeContext = this.replaceCodeContext(codeContext);
try {
this.getCodeContext().saveLocalVariables();
if (fd instanceof MethodDeclarator) {
MethodDeclarator md = (MethodDeclarator) fd;
if (!md.isStatic()) {
// Define special parameter "this".
this.allocateLocalVariableSlotAndMarkAsInitialized(this.resolve(fd.getDeclaringType()), "this");
}
}
if (fd instanceof ConstructorDeclarator) {
// Define special parameter "unititialized this".
{
IClass rawThisType = this.resolve(fd.getDeclaringType());
LocalVariableSlot result = this.getCodeContext().allocateLocalVariable(
(short) 1,
"this",
rawThisType
);
this.updateLocalVariableInCurrentStackMap(
result.getSlotIndex(),
StackMapTableAttribute.UNINITIALIZED_THIS_VARIABLE_INFO
);
}
ConstructorDeclarator constructorDeclarator = (ConstructorDeclarator) fd;
if (fd.getDeclaringType() instanceof EnumDeclaration) {
// Define special constructor parameters "String $name" and "int $ordinal" for enums.
LocalVariable lv1 = this.allocateLocalVariableAndMarkAsInitialized(true /*finaL*/, this.iClassLoader.TYPE_java_lang_String);
constructorDeclarator.syntheticParameters.put("$name", lv1);
LocalVariable lv2 = this.allocateLocalVariableAndMarkAsInitialized(true /*finaL*/, IClass.INT);
constructorDeclarator.syntheticParameters.put("$ordinal", lv2);
}
// Define synthetic parameters for inner classes ("this$...", "val$...").
for (IField sf : constructorDeclarator.getDeclaringClass().syntheticFields.values()) {
LocalVariable lv = this.allocateLocalVariableAndMarkAsInitialized(true /*finaL*/, sf.getType());
constructorDeclarator.syntheticParameters.put(sf.getName(), lv);
}
}
this.buildLocalVariableMap(fd);
this.codeContext.newOffset();
// Compile the constructor preamble.
if (fd instanceof ConstructorDeclarator) {
ConstructorDeclarator cd = (ConstructorDeclarator) fd;
ConstructorInvocation ci = cd.constructorInvocation;
if (ci != null) {
if (ci instanceof SuperConstructorInvocation) {
this.assignSyntheticParametersToSyntheticFields(cd);
}
this.compile(ci);
// Object initialization is complete; change the verification type info of "this" from
// "uninitializedThis" to "object".
this.updateLocalVariableInCurrentStackMap((short) 0, this.verificationTypeInfo(this.resolve(fd.getDeclaringType())));
if (ci instanceof SuperConstructorInvocation) {
this.initializeInstanceVariablesAndInvokeInstanceInitializers(cd);
}
} else {
// Determine qualification for superconstructor invocation.
IClass superclass = this.resolve(cd.getDeclaringClass()).getSuperclass();
if (superclass == null) {
throw new CompileException("\"" + cd + "\" has no superclass", cd.getLocation());
}
IClass outerClassOfSuperclass = superclass.getOuterIClass();
QualifiedThisReference qualification = null;
if (outerClassOfSuperclass != null) {
qualification = new QualifiedThisReference(
cd.getLocation(), // location
new SimpleType(cd.getLocation(), outerClassOfSuperclass) // qualification
);
}
// Initialize "this.this$0" and friends.
this.assignSyntheticParametersToSyntheticFields(cd);
// Invoke the superconstructor.
Rvalue[] arguments;
if (fd.getDeclaringType() instanceof EnumDeclaration) {
LocalVariableAccess nameAccess = new LocalVariableAccess(
cd.getLocation(),
(LocalVariable) cd.syntheticParameters.get("$name")
);
assert nameAccess != null;
LocalVariableAccess ordinalAccess = new LocalVariableAccess(
cd.getLocation(),
(LocalVariable) cd.syntheticParameters.get("$ordinal")
);
assert ordinalAccess != null;
arguments = new Rvalue[] { nameAccess, ordinalAccess };
} else {
arguments = new Rvalue[0];
}
SuperConstructorInvocation sci = new SuperConstructorInvocation(
cd.getLocation(), // location
qualification, // qualification
arguments // arguments
);
sci.setEnclosingScope(fd);
this.compile(sci);
// Object initialization is complete; change the verification type info of "this" from
// "uninitializedThis" to "object".
this.updateLocalVariableInCurrentStackMap((short) 0, this.verificationTypeInfo(this.resolve(fd.getDeclaringType())));
// Initialize "this.x = y".
this.initializeInstanceVariablesAndInvokeInstanceInitializers(cd);
}
}
// Compile the function body.
List oss = fd.statements;
if (oss == null) {
this.compileError("Method must have a body", fd.getLocation());
return;
}
if (this.compileStatements(oss)) {
if (this.getReturnType(fd) != IClass.VOID) {
this.compileError("Method must return a value", fd.getLocation());
}
this.returN(fd);
}
} finally {
this.getCodeContext().restoreLocalVariables();
this.replaceCodeContext(savedCodeContext);
}
// Don't continue code attribute generation if we had compile errors.
if (this.compileErrorCount > 0) return;
// Fix up and reallocate as needed.
codeContext.fixUpAndRelocate();
if (this.debugVars) {
UnitCompiler.makeLocalVariableNames(codeContext, mi);
}
// Add the code context as a code attribute to the MethodInfo.
boolean hasThis = (Boolean) fd.accept(new FunctionDeclaratorVisitor() {
@Override @Nullable public Boolean
visitConstructorDeclarator(ConstructorDeclarator cd) { return true; }
@Override @Nullable public Boolean
visitMethodDeclarator(MethodDeclarator md) { return !md.isStatic(); }
});
try {
mi.addAttribute(codeContext.newCodeAttribute((
(hasThis ? 1 : 0)
+ (fd instanceof ConstructorDeclarator ? ((ConstructorDeclarator) fd).syntheticParameters.size() : 0)
+ fd.formalParameters.parameters.length
), this.debugLines, this.debugVars));
} catch (Error e) {
throw new InternalCompilerException(fd.getLocation(), null, e);
}
}
private int getTargetVersion() {
if (this.targetVersion == -1) {
this.targetVersion = UnitCompiler.defaultTargetVersion;
if (this.targetVersion == -1) {
// // System property Description Example values
// // ------------------------------------------------------------------------------------------------
// // java.vm.specification.version Java Virtual Machine specification version "1.8", "11"
// // java.specification.version Java Runtime Environment specification version "1.8", "11"
// // java.version Java Runtime Environment version "1.8.0_45", "11-ea"
// // java.class.version Java class format version number "52.0", "55.0"
// String jsv = System.getProperty("java.specification.version");
// jsv = jsv.substring(jsv.indexOf('.') + 1);
// this.targetVersion = Integer.parseInt(jsv);
// Because the generation of the StackMapTable attribute is still experimental, we still produce
// only Java 6 .class files by default:
this.targetVersion = 6;
}
}
return this.targetVersion;
}
/**
* Makes the variable name and class name Constant Pool names used by local variables.
*/
private static void
makeLocalVariableNames(final CodeContext cc, final ClassFile.MethodInfo mi) {
ClassFile cf = mi.getClassFile();
cf.addConstantUtf8Info("LocalVariableTable");
for (LocalVariableSlot slot : cc.getAllLocalVars()) {
String localVariableName = slot.getName();
if (localVariableName != null) {
String typeName = UnitCompiler.rawTypeOf(slot.getType()).getDescriptor();
cf.addConstantUtf8Info(typeName);
cf.addConstantUtf8Info(localVariableName);
}
}
}
private void
buildLocalVariableMap(FunctionDeclarator fd) throws CompileException {
Map localVars = new HashMap<>();
// Add function parameters.
for (int i = 0; i < fd.formalParameters.parameters.length; ++i) {
FormalParameter fp = fd.formalParameters.parameters[i];
LocalVariable lv = this.getLocalVariable(
fp,
i == fd.formalParameters.parameters.length - 1 && fd.formalParameters.variableArity
);
lv.setSlot(this.allocateLocalVariableSlotAndMarkAsInitialized(lv.type, fp.name));
if (localVars.put(fp.name, lv) != null) {
this.compileError("Redefinition of parameter \"" + fp.name + "\"", fd.getLocation());
}
}
fd.localVariables = localVars;
if (fd instanceof ConstructorDeclarator) {
ConstructorDeclarator cd = (ConstructorDeclarator) fd;
ConstructorInvocation ci = cd.constructorInvocation;
if (ci != null) {
UnitCompiler.buildLocalVariableMap(ci, localVars);
}
}
if (fd.statements != null) {
for (BlockStatement bs : fd.statements) localVars = this.buildLocalVariableMap(bs, localVars);
}
}
private LocalVariableSlot
allocateLocalVariableSlot(IType localVariableType, @Nullable String localVariableName) {
LocalVariableSlot result = this.getCodeContext().allocateLocalVariable(
Descriptor.size(UnitCompiler.rawTypeOf(localVariableType).getDescriptor()),
localVariableName,
localVariableType
);
return result;
}
private LocalVariableSlot
allocateLocalVariableSlotAndMarkAsInitialized(IType localVariableType, @Nullable String localVariableName) {
LocalVariableSlot result = this.allocateLocalVariableSlot(localVariableType, localVariableName);
this.updateLocalVariableInCurrentStackMap(result.getSlotIndex(), this.verificationTypeInfo(localVariableType));
return result;
}
/**
* Computes and fills in the 'local variable map' for the given blockStatement.
*/
private Map
buildLocalVariableMap(BlockStatement blockStatement, final Map localVars)
throws CompileException {
Map result = (Map) blockStatement.accept(
new BlockStatementVisitor, CompileException>() {
// Basic statements that use the default handlers.
@Override public Map visitAlternateConstructorInvocation(AlternateConstructorInvocation aci) { UnitCompiler.buildLocalVariableMap(aci, localVars); return localVars; }
@Override public Map visitBreakStatement(BreakStatement bs) { UnitCompiler.buildLocalVariableMap(bs, localVars); return localVars; }
@Override public Map visitContinueStatement(ContinueStatement cs) { UnitCompiler.buildLocalVariableMap(cs, localVars); return localVars; }
@Override public Map visitAssertStatement(AssertStatement as) { UnitCompiler.buildLocalVariableMap(as, localVars); return localVars; }
@Override public Map visitEmptyStatement(EmptyStatement es) { UnitCompiler.buildLocalVariableMap(es, localVars); return localVars; }
@Override public Map visitExpressionStatement(ExpressionStatement es) { UnitCompiler.buildLocalVariableMap(es, localVars); return localVars; }
@Override public Map visitFieldDeclaration(FieldDeclaration fd) { UnitCompiler.buildLocalVariableMap(fd, localVars); return localVars; }
@Override public Map visitReturnStatement(ReturnStatement rs) { UnitCompiler.buildLocalVariableMap(rs, localVars); return localVars; }
@Override public Map visitSuperConstructorInvocation(SuperConstructorInvocation sci) { UnitCompiler.buildLocalVariableMap(sci, localVars); return localVars; }
@Override public Map visitThrowStatement(ThrowStatement ts) { UnitCompiler.buildLocalVariableMap(ts, localVars); return localVars; }
@Override public Map visitLocalClassDeclarationStatement(LocalClassDeclarationStatement lcds) { UnitCompiler.buildLocalVariableMap(lcds, localVars); return localVars; }
// More complicated statements with specialized handlers, but don't add new variables in this scope.
@Override public Map visitBlock(Block b) throws CompileException { UnitCompiler.this.buildLocalVariableMap(b, localVars); return localVars; }
@Override public Map visitDoStatement(DoStatement ds) throws CompileException { UnitCompiler.this.buildLocalVariableMap(ds, localVars); return localVars; }
@Override public Map visitForStatement(ForStatement fs) throws CompileException { UnitCompiler.this.buildLocalVariableMap(fs, localVars); return localVars; }
@Override public Map visitForEachStatement(ForEachStatement fes) throws CompileException { UnitCompiler.this.buildLocalVariableMap(fes, localVars); return localVars; }
@Override public Map visitIfStatement(IfStatement is) throws CompileException { UnitCompiler.this.buildLocalVariableMap(is, localVars); return localVars; }
@Override public Map visitInitializer(Initializer i) throws CompileException { UnitCompiler.this.buildLocalVariableMap(i, localVars); return localVars; }
@Override public Map visitSwitchStatement(SwitchStatement ss) throws CompileException { UnitCompiler.this.buildLocalVariableMap(ss, localVars); return localVars; }
@Override public Map visitSynchronizedStatement(SynchronizedStatement ss) throws CompileException { UnitCompiler.this.buildLocalVariableMap(ss, localVars); return localVars; }
@Override public Map visitTryStatement(TryStatement ts) throws CompileException { UnitCompiler.this.buildLocalVariableMap(ts, localVars); return localVars; }
@Override public Map visitWhileStatement(WhileStatement ws) throws CompileException { UnitCompiler.this.buildLocalVariableMap(ws, localVars); return localVars; }
// More complicated statements with specialized handlers, that can add variables in this scope.
@Override public Map visitLabeledStatement(LabeledStatement ls) throws CompileException { return UnitCompiler.this.buildLocalVariableMap(ls, localVars); }
@Override public Map visitLocalVariableDeclarationStatement(LocalVariableDeclarationStatement lvds) throws CompileException { return UnitCompiler.this.buildLocalVariableMap(lvds, localVars); }
}
);
assert result != null;
return result;
}
// Default handlers.
private static Map
buildLocalVariableMap(Statement s, final Map localVars) {
return (s.localVariables = localVars);
}
private static Map
buildLocalVariableMap(ConstructorInvocation ci, final Map localVars) {
return (ci.localVariables = localVars);
}
// Specialized handlers.
private void
buildLocalVariableMap(Block block, Map localVars) throws CompileException {
block.localVariables = localVars;
for (BlockStatement bs : block.statements) localVars = this.buildLocalVariableMap(bs, localVars);
}
private void
buildLocalVariableMap(DoStatement ds, final Map localVars) throws CompileException {
ds.localVariables = localVars;
this.buildLocalVariableMap(ds.body, localVars);
}
private void
buildLocalVariableMap(ForStatement fs, final Map localVars)
throws CompileException {
Map inner = localVars;
if (fs.init != null) {
inner = this.buildLocalVariableMap(fs.init, localVars);
}
fs.localVariables = inner;
this.buildLocalVariableMap(fs.body, inner);
}
private void
buildLocalVariableMap(ForEachStatement fes, final Map localVars)
throws CompileException {
Map vars = new HashMap<>();
vars.putAll(localVars);
LocalVariable elementLv = this.getLocalVariable(fes.currentElement, false);
vars.put(fes.currentElement.name, elementLv);
fes.localVariables = vars;
this.buildLocalVariableMap(fes.body, vars);
}
private void
buildLocalVariableMap(IfStatement is, final Map localVars) throws CompileException {
is.localVariables = localVars;
this.buildLocalVariableMap(is.thenStatement, localVars);
if (is.elseStatement != null) {
this.buildLocalVariableMap(is.elseStatement, localVars);
}
}
private void
buildLocalVariableMap(Initializer i, final Map localVars) throws CompileException {
this.buildLocalVariableMap(i.block, localVars);
}
private void
buildLocalVariableMap(SwitchStatement ss, final Map localVars)
throws CompileException {
ss.localVariables = localVars;
Map vars = localVars;
for (SwitchBlockStatementGroup sbsg : ss.sbsgs) {
for (BlockStatement bs : sbsg.blockStatements) vars = this.buildLocalVariableMap(bs, vars);
}
}
private void
buildLocalVariableMap(SynchronizedStatement ss, final Map localVars)
throws CompileException {
ss.localVariables = localVars;
this.buildLocalVariableMap(ss.body, localVars);
}
private void
buildLocalVariableMap(TryStatement ts, final Map localVars)
throws CompileException {
ts.localVariables = localVars;
this.buildLocalVariableMap(ts.body, localVars);
for (CatchClause cc : ts.catchClauses) this.buildLocalVariableMap(cc, localVars);
if (ts.finallY != null) {
this.buildLocalVariableMap(ts.finallY, localVars);
}
}
private void
buildLocalVariableMap(WhileStatement ws, final Map localVars)
throws CompileException {
ws.localVariables = localVars;
this.buildLocalVariableMap(ws.body, localVars);
}
private Map
buildLocalVariableMap(LabeledStatement ls, final Map localVars)
throws CompileException {
ls.localVariables = localVars;
return this.buildLocalVariableMap((BlockStatement) ls.body, localVars);
}
private Map
buildLocalVariableMap(LocalVariableDeclarationStatement lvds, final Map localVars)
throws CompileException {
Map newVars = new HashMap<>();
newVars.putAll(localVars);
for (VariableDeclarator vd : lvds.variableDeclarators) {
LocalVariable lv = this.getLocalVariable(lvds, vd);
if (newVars.put(vd.name, lv) != null) {
this.compileError("Redefinition of local variable \"" + vd.name + "\" ", vd.getLocation());
}
}
lvds.localVariables = newVars;
return newVars;
}
/**
* Adds the given localVars to the 'local variable map' of the given catchClause.
*/
protected void
buildLocalVariableMap(CatchClause catchClause, Map localVars) throws CompileException {
Map vars = new HashMap<>();
vars.putAll(localVars);
LocalVariable lv = this.getLocalVariable(catchClause.catchParameter);
vars.put(catchClause.catchParameter.name, lv);
this.buildLocalVariableMap(catchClause.body, vars);
}
/**
* @return The {@link LocalVariable} corresponding with the parameter
*/
public LocalVariable
getLocalVariable(FormalParameter parameter) throws CompileException {
return this.getLocalVariable(parameter, false);
}
/**
* @param isVariableArityParameter Whether the parameter is the last parameter of a 'variable arity'
* (a.k.a. 'varargs') method declaration
* @return The {@link LocalVariable} corresponding with the parameter
*/
public LocalVariable
getLocalVariable(FormalParameter parameter, boolean isVariableArityParameter) throws CompileException {
if (parameter.localVariable != null) return parameter.localVariable;
assert parameter.type != null;
IType parameterType = this.getType(parameter.type);
if (isVariableArityParameter) {
parameterType = this.iClassLoader.getArrayIClass(UnitCompiler.rawTypeOf(parameterType));
}
return (parameter.localVariable = new LocalVariable(parameter.isFinal(), parameterType));
}
/**
* @return The {@link LocalVariable} corresponding with the parameter
*/
public LocalVariable
getLocalVariable(CatchParameter parameter) throws CompileException {
if (parameter.localVariable != null) return parameter.localVariable;
if (parameter.types.length != 1) {
throw UnitCompiler.compileException(parameter, "Multi-type CATCH parameters NYI");
}
IType parameterType = this.getType(parameter.types[0]);
return (parameter.localVariable = new LocalVariable(parameter.finaL, parameterType));
}
// ------------------ Rvalue.compile() ----------------
/**
* Called to check whether the given {@link Rvalue} compiles or not.
*/
private void
fakeCompile(Rvalue rv) throws CompileException {
final Offset from = this.getCodeContext().newOffset();
StackMap savedStackMap = this.getCodeContext().currentInserter().getStackMap();
this.compileContext(rv);
this.compileGet(rv);
Offset to = this.getCodeContext().newOffset();
this.getCodeContext().removeCode(from, to.next);
this.getCodeContext().currentInserter().setStackMap(savedStackMap);
}
/**
* Some {@link Rvalue}s compile more efficiently when their value is not needed, e.g. "i++".
*/
private void
compile(Rvalue rv) throws CompileException {
rv.accept(new RvalueVisitor() {
@Override @Nullable public Void
visitLvalue(Lvalue lv) throws CompileException {
lv.accept(new LvalueVisitor() {
@Override @Nullable public Void visitAmbiguousName(AmbiguousName an) throws CompileException { UnitCompiler.this.compile2(an); return null; }
@Override @Nullable public Void visitArrayAccessExpression(ArrayAccessExpression aae) throws CompileException { UnitCompiler.this.compile2(aae); return null; }
@Override @Nullable public Void visitFieldAccess(FieldAccess fa) throws CompileException { UnitCompiler.this.compile2(fa); return null; }
@Override @Nullable public Void visitFieldAccessExpression(FieldAccessExpression fae) throws CompileException { UnitCompiler.this.compile2(fae); return null; }
@Override @Nullable public Void visitSuperclassFieldAccessExpression(SuperclassFieldAccessExpression scfae) throws CompileException { UnitCompiler.this.compile2(scfae); return null; }
@Override @Nullable public Void visitLocalVariableAccess(LocalVariableAccess lva) throws CompileException { UnitCompiler.this.compile2(lva); return null; }
@Override @Nullable public Void visitParenthesizedExpression(ParenthesizedExpression pe) throws CompileException { UnitCompiler.this.compile2(pe); return null; }
});
return null;
}
@Override @Nullable public Void visitArrayLength(ArrayLength al) throws CompileException { UnitCompiler.this.compile2(al); return null; }
@Override @Nullable public Void visitAssignment(Assignment a) throws CompileException { UnitCompiler.this.compile2(a); return null; }
@Override @Nullable public Void visitUnaryOperation(UnaryOperation uo) throws CompileException { UnitCompiler.this.compile2(uo); return null; }
@Override @Nullable public Void visitBinaryOperation(BinaryOperation bo) throws CompileException { UnitCompiler.this.compile2(bo); return null; }
@Override @Nullable public Void visitCast(Cast c) throws CompileException { UnitCompiler.this.compile2(c); return null; }
@Override @Nullable public Void visitClassLiteral(ClassLiteral cl) throws CompileException { UnitCompiler.this.compile2(cl); return null; }
@Override @Nullable public Void visitConditionalExpression(ConditionalExpression ce) throws CompileException { UnitCompiler.this.compile2(ce); return null; }
@Override @Nullable public Void visitCrement(Crement c) throws CompileException { UnitCompiler.this.compile2(c); return null; }
@Override @Nullable public Void visitInstanceof(Instanceof io) throws CompileException { UnitCompiler.this.compile2(io); return null; }
@Override @Nullable public Void visitMethodInvocation(MethodInvocation mi) throws CompileException { UnitCompiler.this.compile2(mi); return null; }
@Override @Nullable public Void visitSuperclassMethodInvocation(SuperclassMethodInvocation smi) throws CompileException { UnitCompiler.this.compile2(smi); return null; }
@Override @Nullable public Void visitIntegerLiteral(IntegerLiteral il) throws CompileException { UnitCompiler.this.compile2(il); return null; }
@Override @Nullable public Void visitFloatingPointLiteral(FloatingPointLiteral fpl) throws CompileException { UnitCompiler.this.compile2(fpl); return null; }
@Override @Nullable public Void visitBooleanLiteral(BooleanLiteral bl) throws CompileException { UnitCompiler.this.compile2(bl); return null; }
@Override @Nullable public Void visitCharacterLiteral(CharacterLiteral cl) throws CompileException { UnitCompiler.this.compile2(cl); return null; }
@Override @Nullable public Void visitStringLiteral(StringLiteral sl) throws CompileException { UnitCompiler.this.compile2(sl); return null; }
@Override @Nullable public Void visitNullLiteral(NullLiteral nl) throws CompileException { UnitCompiler.this.compile2(nl); return null; }
@Override @Nullable public Void visitSimpleConstant(SimpleConstant sl) throws CompileException { UnitCompiler.this.compile2(sl); return null; }
@Override @Nullable public Void visitNewAnonymousClassInstance(NewAnonymousClassInstance naci) throws CompileException { UnitCompiler.this.compile2(naci); return null; }
@Override @Nullable public Void visitNewArray(NewArray na) throws CompileException { UnitCompiler.this.compile2(na); return null; }
@Override @Nullable public Void visitNewInitializedArray(NewInitializedArray nia) throws CompileException { UnitCompiler.this.compile2(nia); return null; }
@Override @Nullable public Void visitNewClassInstance(NewClassInstance nci) throws CompileException { UnitCompiler.this.compile2(nci); return null; }
@Override @Nullable public Void visitParameterAccess(ParameterAccess pa) throws CompileException { UnitCompiler.this.compile2(pa); return null; }
@Override @Nullable public Void visitQualifiedThisReference(QualifiedThisReference qtr) throws CompileException { UnitCompiler.this.compile2(qtr); return null; }
@Override @Nullable public Void visitThisReference(ThisReference tr) throws CompileException { UnitCompiler.this.compile2(tr); return null; }
@Override @Nullable public Void visitLambdaExpression(LambdaExpression le) throws CompileException { UnitCompiler.this.compile2(le); return null; }
@Override @Nullable public Void visitMethodReference(MethodReference mr) throws CompileException { UnitCompiler.this.compile2(mr); return null; }
@Override @Nullable public Void visitInstanceCreationReference(ClassInstanceCreationReference cicr) throws CompileException { UnitCompiler.this.compile2(cicr); return null; }
@Override @Nullable public Void visitArrayCreationReference(ArrayCreationReference acr) throws CompileException { UnitCompiler.this.compile2(acr); return null; }
});
}
private void
compile2(Rvalue rv) throws CompileException {
this.pop(rv, this.compileGetValue(rv));
}
private void
compile2(Assignment a) throws CompileException {
// "Simple" assignment ("=")?
if (a.operator == "=") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.compileContext(a.lhs);
this.assignmentConversion(
a, // locatable
this.compileGetValue(a.rhs), // sourceType
this.getType(a.lhs), // targetType
this.getConstantValue(a.rhs) // constantValue
);
this.compileSet(a.lhs);
return;
}
// Implement "|= ^= &= *= /= %= += -= <<= >>= >>>=".
// Compile LHS context.
int lhsCs = this.compileContext(a.lhs);
// Duplicate the LHS context.
this.dupn(a.lhs, lhsCs);
// Convert RHS value to LHS type (JLS7 15.26.2).
IType lhsType = this.compileGet(a.lhs);
IType resultType = this.compileArithmeticBinaryOperation(
a, // locatable
lhsType, // lhsType
a.operator.substring( // operator
0,
a.operator.length() - 1
).intern(), /* <= IMPORTANT!
*/
a.rhs // rhs
);
if (
!this.tryIdentityConversion(resultType, lhsType)
&& !this.tryNarrowingPrimitiveConversion(a, resultType, lhsType)
&& !this.tryBoxingConversion(a, resultType, lhsType) // Java 5
) this.compileError("Operand types unsuitable for \"" + a.operator + "\"", a.getLocation());
// Assign converted RHS value to LHS.
this.compileSet(a.lhs);
}
private void
compile2(Crement c) throws CompileException {
// Optimized crement of "int" local variable.
{
LocalVariable lv = this.isIntLv(c);
if (lv != null) {
this.iinc(c, lv, c.operator);
return;
}
}
// Compile operand context.
int operandCs = this.compileContext(c.operand);
// DUP operand context.
this.dupn(c, operandCs);
// Get operand value.
IType type = this.compileGet(c.operand);
{
// Apply "unary numeric promotion".
IClass promotedType = this.unaryNumericPromotion(c, type);
// Crement.
this.consT(c, promotedType, 1);
if (c.operator == "++") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.add(c);
} else
if (c.operator == "--") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.sub(c);
} else {
this.compileError("Unexpected operator \"" + c.operator + "\"", c.getLocation());
}
this.reverseUnaryNumericPromotion(c, promotedType, type);
}
// Set operand.
this.compileSet(c.operand);
}
private void
compile2(ParenthesizedExpression pe) throws CompileException {
this.compile(pe.value);
}
private boolean
compile2(AlternateConstructorInvocation aci) throws CompileException {
ConstructorDeclarator declaringConstructor = (ConstructorDeclarator) aci.getEnclosingScope();
IClass declaringIClass = this.resolve(declaringConstructor.getDeclaringClass());
this.load(aci, declaringIClass, 0);
if (declaringIClass.getOuterIClass() != null) this.load(aci, declaringIClass.getOuterIClass(), 1);
this.invokeConstructor(
aci, // locatable
declaringConstructor, // scope
(Rvalue) null, // enclosingInstance
declaringIClass, // targetClass
aci.arguments // arguments
);
return true;
}
private boolean
compile2(SuperConstructorInvocation sci) throws CompileException {
ConstructorDeclarator declaringConstructor = (ConstructorDeclarator) sci.getEnclosingScope();
AbstractClassDeclaration declaringClass = declaringConstructor.getDeclaringClass();
IClass declaringIClass = this.resolve(declaringClass);
IClass superclass = declaringIClass.getSuperclass();
this.load(sci, declaringIClass, 0);
// // Fix up the operand stack entry: The loaded object is still unitializied!
// this.getCodeContext().popObjectOperand();
// this.getCodeContext().pushUninitializedThisOperand();
if (superclass == null) throw new CompileException("Class has no superclass", sci.getLocation());
Rvalue enclosingInstance;
if (sci.qualification != null) {
enclosingInstance = sci.qualification;
} else {
IClass outerIClassOfSuperclass = superclass.getOuterIClass();
if (outerIClassOfSuperclass == null) {
enclosingInstance = null;
} else {
enclosingInstance = new QualifiedThisReference(
sci.getLocation(), // location
new SimpleType(sci.getLocation(), outerIClassOfSuperclass) // qualification
);
enclosingInstance.setEnclosingScope(sci);
}
}
this.invokeConstructor(
sci, // locatable
declaringConstructor, // scope
enclosingInstance, // enclosingInstance
superclass, // targetClass
sci.arguments // arguments
);
return true;
}
/**
* Compiles an {@link Rvalue} and branches, depending on the value.
*
* Many {@link Rvalue}s compile more efficiently when their value is the condition for a branch, thus
* this method generally produces more efficient bytecode than {@link #compile(Rvalue)} followed by {@link
* #branch(Locatable, int, Offset)}.
*
*
* Notice that if rv is a constant, then either dst is never branched to, or it is
* unconditionally branched to; "Unexamined code" errors may result during bytecode validation.
*
*
* @param rv The value that determines whether to branch or not
* @param dst Where to jump
* @param orientation {@link #JUMP_IF_TRUE} or {@link #JUMP_IF_FALSE}
*/
private void
compileBoolean(Rvalue rv, final CodeContext.Offset dst, final boolean orientation) throws CompileException {
rv.accept(new RvalueVisitor() {
@Override @Nullable public Void
visitLvalue(Lvalue lv) throws CompileException {
lv.accept(new LvalueVisitor() {
@Override @Nullable public Void visitAmbiguousName(AmbiguousName an) throws CompileException { UnitCompiler.this.compileBoolean2(an, dst, orientation); return null; }
@Override @Nullable public Void visitArrayAccessExpression(ArrayAccessExpression aae) throws CompileException { UnitCompiler.this.compileBoolean2(aae, dst, orientation); return null; }
@Override @Nullable public Void visitFieldAccess(FieldAccess fa) throws CompileException { UnitCompiler.this.compileBoolean2(fa, dst, orientation); return null; }
@Override @Nullable public Void visitFieldAccessExpression(FieldAccessExpression fae) throws CompileException { UnitCompiler.this.compileBoolean2(fae, dst, orientation); return null; }
@Override @Nullable public Void visitSuperclassFieldAccessExpression(SuperclassFieldAccessExpression scfae) throws CompileException { UnitCompiler.this.compileBoolean2(scfae, dst, orientation); return null; }
@Override @Nullable public Void visitLocalVariableAccess(LocalVariableAccess lva) throws CompileException { UnitCompiler.this.compileBoolean2(lva, dst, orientation); return null; }
@Override @Nullable public Void visitParenthesizedExpression(ParenthesizedExpression pe) throws CompileException { UnitCompiler.this.compileBoolean2(pe, dst, orientation); return null; }
});
return null;
}
@Override @Nullable public Void visitArrayLength(ArrayLength al) throws CompileException { UnitCompiler.this.compileBoolean2(al, dst, orientation); return null; }
@Override @Nullable public Void visitAssignment(Assignment a) throws CompileException { UnitCompiler.this.compileBoolean2(a, dst, orientation); return null; }
@Override @Nullable public Void visitUnaryOperation(UnaryOperation uo) throws CompileException { UnitCompiler.this.compileBoolean2(uo, dst, orientation); return null; }
@Override @Nullable public Void visitBinaryOperation(BinaryOperation bo) throws CompileException { UnitCompiler.this.compileBoolean2(bo, dst, orientation); return null; }
@Override @Nullable public Void visitCast(Cast c) throws CompileException { UnitCompiler.this.compileBoolean2(c, dst, orientation); return null; }
@Override @Nullable public Void visitClassLiteral(ClassLiteral cl) throws CompileException { UnitCompiler.this.compileBoolean2(cl, dst, orientation); return null; }
@Override @Nullable public Void visitConditionalExpression(ConditionalExpression ce) throws CompileException { UnitCompiler.this.compileBoolean2(ce, dst, orientation); return null; }
@Override @Nullable public Void visitCrement(Crement c) throws CompileException { UnitCompiler.this.compileBoolean2(c, dst, orientation); return null; }
@Override @Nullable public Void visitInstanceof(Instanceof io) throws CompileException { UnitCompiler.this.compileBoolean2(io, dst, orientation); return null; }
@Override @Nullable public Void visitMethodInvocation(MethodInvocation mi) throws CompileException { UnitCompiler.this.compileBoolean2(mi, dst, orientation); return null; }
@Override @Nullable public Void visitSuperclassMethodInvocation(SuperclassMethodInvocation smi) throws CompileException { UnitCompiler.this.compileBoolean2(smi, dst, orientation); return null; }
@Override @Nullable public Void visitIntegerLiteral(IntegerLiteral il) throws CompileException { UnitCompiler.this.compileBoolean2(il, dst, orientation); return null; }
@Override @Nullable public Void visitFloatingPointLiteral(FloatingPointLiteral fpl) throws CompileException { UnitCompiler.this.compileBoolean2(fpl, dst, orientation); return null; }
@Override @Nullable public Void visitBooleanLiteral(BooleanLiteral bl) throws CompileException { UnitCompiler.this.compileBoolean2(bl, dst, orientation); return null; }
@Override @Nullable public Void visitCharacterLiteral(CharacterLiteral cl) throws CompileException { UnitCompiler.this.compileBoolean2(cl, dst, orientation); return null; }
@Override @Nullable public Void visitStringLiteral(StringLiteral sl) throws CompileException { UnitCompiler.this.compileBoolean2(sl, dst, orientation); return null; }
@Override @Nullable public Void visitNullLiteral(NullLiteral nl) throws CompileException { UnitCompiler.this.compileBoolean2(nl, dst, orientation); return null; }
@Override @Nullable public Void visitSimpleConstant(SimpleConstant sl) throws CompileException { UnitCompiler.this.compileBoolean2(sl, dst, orientation); return null; }
@Override @Nullable public Void visitNewAnonymousClassInstance(NewAnonymousClassInstance naci) throws CompileException { UnitCompiler.this.compileBoolean2(naci, dst, orientation); return null; }
@Override @Nullable public Void visitNewArray(NewArray na) throws CompileException { UnitCompiler.this.compileBoolean2(na, dst, orientation); return null; }
@Override @Nullable public Void visitNewInitializedArray(NewInitializedArray nia) throws CompileException { UnitCompiler.this.compileBoolean2(nia, dst, orientation); return null; }
@Override @Nullable public Void visitNewClassInstance(NewClassInstance nci) throws CompileException { UnitCompiler.this.compileBoolean2(nci, dst, orientation); return null; }
@Override @Nullable public Void visitParameterAccess(ParameterAccess pa) throws CompileException { UnitCompiler.this.compileBoolean2(pa, dst, orientation); return null; }
@Override @Nullable public Void visitQualifiedThisReference(QualifiedThisReference qtr) throws CompileException { UnitCompiler.this.compileBoolean2(qtr, dst, orientation); return null; }
@Override @Nullable public Void visitThisReference(ThisReference tr) throws CompileException { UnitCompiler.this.compileBoolean2(tr, dst, orientation); return null; }
@Override @Nullable public Void visitLambdaExpression(LambdaExpression le) throws CompileException { UnitCompiler.this.compileBoolean2(le, dst, orientation); return null; }
@Override @Nullable public Void visitMethodReference(MethodReference mr) throws CompileException { UnitCompiler.this.compileBoolean2(mr, dst, orientation); return null; }
@Override @Nullable public Void visitInstanceCreationReference(ClassInstanceCreationReference cicr) throws CompileException { UnitCompiler.this.compileBoolean2(cicr, dst, orientation); return null; }
@Override @Nullable public Void visitArrayCreationReference(ArrayCreationReference acr) throws CompileException { UnitCompiler.this.compileBoolean2(acr, dst, orientation); return null; }
});
}
/**
* @param dst Where to jump
* @param orientation {@link #JUMP_IF_TRUE} or {@link #JUMP_IF_FALSE}
*/
private void
compileBoolean2(Rvalue rv, CodeContext.Offset dst, boolean orientation) throws CompileException {
IType type = this.compileGetValue(rv);
IClassLoader icl = this.iClassLoader;
if (type == icl.TYPE_java_lang_Boolean) {
this.unboxingConversion(rv, icl.TYPE_java_lang_Boolean, IClass.BOOLEAN);
} else
if (type != IClass.BOOLEAN) {
this.compileError("Not a boolean expression", rv.getLocation());
}
this.ifxx(rv, orientation == UnitCompiler.JUMP_IF_TRUE ? UnitCompiler.NE : UnitCompiler.EQ, dst);
}
/**
* @param dst Where to jump
* @param orientation {@link #JUMP_IF_TRUE} or {@link #JUMP_IF_FALSE}
*/
private void
compileBoolean2(UnaryOperation ue, CodeContext.Offset dst, boolean orientation) throws CompileException {
if (ue.operator == "!") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.compileBoolean(ue.operand, dst, !orientation);
return;
}
this.compileError("Boolean expression expected", ue.getLocation());
}
/**
* @param dst Where to jump
* @param orientation {@link #JUMP_IF_TRUE} or {@link #JUMP_IF_FALSE}
*/
private void
compileBoolean2(BinaryOperation bo, CodeContext.Offset dst, boolean orientation) throws CompileException {
if (bo.operator == "|" || bo.operator == "^" || bo.operator == "&") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.compileBoolean2((Rvalue) bo, dst, orientation);
return;
}
if (bo.operator == "||" || bo.operator == "&&") { // SUPPRESS CHECKSTYLE StringLiteralEquality
Object lhsCv = this.getConstantValue(bo.lhs);
if (lhsCv instanceof Boolean) {
if (((Boolean) lhsCv).booleanValue() ^ bo.operator == "||") { // SUPPRESS CHECKSTYLE StringLiteralEquality
// "true && a", "false || a"
this.compileBoolean(
bo.rhs,
dst,
orientation
);
} else {
// "false && a", "true || a"
this.compileBoolean(
bo.lhs,
dst,
orientation
);
this.fakeCompile(bo.rhs);
}
return;
}
Object rhsCv = this.getConstantValue(bo.rhs);
if (rhsCv instanceof Boolean) {
if (((Boolean) rhsCv).booleanValue() ^ bo.operator == "||") { // SUPPRESS CHECKSTYLE StringLiteralEquality
// "a && true", "a || false"
this.compileBoolean(
bo.lhs,
dst,
orientation
);
} else {
// "a && false", "a || true"
// Compile the LHS ("a"), and discard the result.
this.pop(bo.lhs, this.compileGetValue(bo.lhs));
// Compile the RHS and branch conditionally (although the RHS is a constant). This prevents
// trouble with "unreachable code".
this.compileBoolean(
bo.rhs,
dst,
orientation
);
}
return;
}
// SUPPRESS CHECKSTYLE StringLiteralEquality
if (bo.operator == "||" ^ orientation == UnitCompiler.JUMP_IF_FALSE) {
this.compileBoolean(bo.lhs, dst, orientation);
this.compileBoolean(bo.rhs, dst, orientation);
} else {
CodeContext.Offset end = this.getCodeContext().new BasicBlock();
this.compileBoolean(bo.lhs, end, !orientation);
this.compileBoolean(bo.rhs, dst, orientation);
end.set();
}
return;
}
COMPARISON:
{
final int opIdx = (
bo.operator == "==" ? UnitCompiler.EQ : // SUPPRESS CHECKSTYLE StringLiteralEquality
bo.operator == "!=" ? UnitCompiler.NE : // SUPPRESS CHECKSTYLE StringLiteralEquality
bo.operator == "<" ? UnitCompiler.LT : // SUPPRESS CHECKSTYLE StringLiteralEquality
bo.operator == ">=" ? UnitCompiler.GE : // SUPPRESS CHECKSTYLE StringLiteralEquality
bo.operator == ">" ? UnitCompiler.GT : // SUPPRESS CHECKSTYLE StringLiteralEquality
bo.operator == "<=" ? UnitCompiler.LE : // SUPPRESS CHECKSTYLE StringLiteralEquality
Integer.MIN_VALUE
);
if (opIdx == Integer.MIN_VALUE) break COMPARISON;
// Comparison with "null".
{
boolean lhsIsNull = this.getConstantValue(bo.lhs) == null;
boolean rhsIsNull = this.getConstantValue(bo.rhs) == null;
if (lhsIsNull || rhsIsNull) {
if (bo.operator != "==" && bo.operator != "!=") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.compileError(
"Operator \"" + bo.operator + "\" not allowed on operand \"null\"",
bo.getLocation()
);
}
if (!lhsIsNull) {
// x == null
IType lhsType = this.compileGetValue(bo.lhs);
if (UnitCompiler.rawTypeOf(lhsType).isPrimitive()) {
this.compileError(
"Cannot compare primitive type \"" + lhsType.toString() + "\" with \"null\"",
bo.getLocation()
);
}
} else
if (!rhsIsNull) {
// null == x
IType rhsType = this.compileGetValue(bo.rhs);
if (UnitCompiler.rawTypeOf(rhsType).isPrimitive()) {
this.compileError(
"Cannot compare \"null\" with primitive type \"" + rhsType.toString() + "\"",
bo.getLocation()
);
}
} else
{
// null == null
this.consT(bo, (Object) null);
}
switch (orientation == UnitCompiler.JUMP_IF_FALSE ? opIdx ^ 1 : opIdx) {
case EQ:
this.ifnull(bo, dst);
break;
case NE:
this.ifnonnull(bo, dst);
break;
default:
throw new AssertionError(opIdx);
}
return;
}
}
IType lhsType = this.compileGetValue(bo.lhs);
IType rhsType = this.getType(bo.rhs);
// 15.20.1 Numerical comparison.
if (
UnitCompiler.rawTypeOf(this.getUnboxedType(lhsType)).isPrimitiveNumeric()
&& UnitCompiler.rawTypeOf(this.getUnboxedType(rhsType)).isPrimitiveNumeric()
&& !(
(bo.operator == "==" || bo.operator == "!=") // SUPPRESS CHECKSTYLE StringLiteralEquality
&& !UnitCompiler.rawTypeOf(lhsType).isPrimitive()
&& !UnitCompiler.rawTypeOf(rhsType).isPrimitive()
)
) {
IClass
promotedType = this.binaryNumericPromotionType(bo, this.getUnboxedType(lhsType), this.getUnboxedType(rhsType));
this.numericPromotion(bo.lhs, this.convertToPrimitiveNumericType(bo.lhs, lhsType), promotedType);
this.compileGetValue(bo.rhs);
this.numericPromotion(bo.rhs, this.convertToPrimitiveNumericType(bo.rhs, rhsType), promotedType);
this.ifNumeric(bo, opIdx, dst, orientation);
return;
}
// JLS7 15.21.2 Boolean Equality Operators == and !=.
if (
(lhsType == IClass.BOOLEAN && this.getUnboxedType(rhsType) == IClass.BOOLEAN)
|| (rhsType == IClass.BOOLEAN && this.getUnboxedType(lhsType) == IClass.BOOLEAN)
) {
if (bo.operator != "==" && bo.operator != "!=") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.compileError(
"Operator \"" + bo.operator + "\" not allowed on boolean operands",
bo.getLocation()
);
}
IClassLoader icl = this.iClassLoader;
// Unbox LHS if necessary.
if (lhsType == icl.TYPE_java_lang_Boolean) {
this.unboxingConversion(bo, icl.TYPE_java_lang_Boolean, IClass.BOOLEAN);
}
this.compileGetValue(bo.rhs);
// Unbox RHS if necessary.
if (rhsType == icl.TYPE_java_lang_Boolean) {
this.unboxingConversion(bo, icl.TYPE_java_lang_Boolean, IClass.BOOLEAN);
}
this.if_icmpxx(bo, orientation == UnitCompiler.JUMP_IF_FALSE ? opIdx ^ 1 : opIdx, dst);
return;
}
// Reference comparison.
// Note: Comparison with "null" is already handled above.
if (!UnitCompiler.rawTypeOf(lhsType).isPrimitive() && !UnitCompiler.rawTypeOf(rhsType).isPrimitive()) {
if (bo.operator != "==" && bo.operator != "!=") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.compileError("Operator \"" + bo.operator + "\" not allowed on reference operands", bo.getLocation());
}
if (
!this.isCastReferenceConvertible(lhsType, rhsType)
|| !this.isCastReferenceConvertible(rhsType, lhsType)
) this.compileError("Incomparable types \"" + lhsType + "\" and \"" + rhsType + "\"", bo.getLocation());
this.compileGetValue(bo.rhs);
this.if_acmpxx(bo, orientation == UnitCompiler.JUMP_IF_FALSE ? opIdx ^ 1 : opIdx, dst);
return;
}
this.compileError("Cannot compare types \"" + lhsType + "\" and \"" + rhsType + "\"", bo.getLocation());
}
this.compileError("Boolean expression expected", bo.getLocation());
}
/**
* @param dst Where to jump
* @param orientation {@link #JUMP_IF_TRUE} or {@link #JUMP_IF_FALSE}
*/
private void
compileBoolean2(ParenthesizedExpression pe, CodeContext.Offset dst, boolean orientation) throws CompileException {
this.compileBoolean(pe.value, dst, orientation);
}
/**
* Generates code that determines the context of the {@link Rvalue} and puts it on the operand stack. Most
* expressions do not have a "context", but some do. E.g. for "x[y]", the context is "x, y". The bottom line is
* that for statements like "x[y] += 3" the context is only evaluated once.
*
* @return The number of operands that is pushed on the operand stack (0, 1 or 2)
*/
private int
compileContext(Rvalue rv) throws CompileException {
Integer result = (Integer) rv.accept(new RvalueVisitor() {
@Override @Nullable public Integer
visitLvalue(Lvalue lv) throws CompileException {
return (Integer) lv.accept(new LvalueVisitor() {
@Override public Integer visitAmbiguousName(AmbiguousName an) throws CompileException { return UnitCompiler.this.compileContext2(an); }
@Override public Integer visitArrayAccessExpression(ArrayAccessExpression aae) throws CompileException { return UnitCompiler.this.compileContext2(aae); }
@Override public Integer visitFieldAccess(FieldAccess fa) throws CompileException { return UnitCompiler.this.compileContext2(fa); }
@Override public Integer visitFieldAccessExpression(FieldAccessExpression fae) throws CompileException { return UnitCompiler.this.compileContext2(fae); }
@Override public Integer visitSuperclassFieldAccessExpression(SuperclassFieldAccessExpression scfae) throws CompileException { return UnitCompiler.this.compileContext2(scfae); }
@Override public Integer visitLocalVariableAccess(LocalVariableAccess lva) { return UnitCompiler.this.compileContext2(lva); }
@Override public Integer visitParenthesizedExpression(ParenthesizedExpression pe) throws CompileException { return UnitCompiler.this.compileContext2(pe); }
});
}
@Override public Integer visitArrayLength(ArrayLength al) throws CompileException { return UnitCompiler.this.compileContext2(al); }
@Override public Integer visitAssignment(Assignment a) { return UnitCompiler.this.compileContext2(a); }
@Override public Integer visitUnaryOperation(UnaryOperation uo) { return UnitCompiler.this.compileContext2(uo); }
@Override public Integer visitBinaryOperation(BinaryOperation bo) { return UnitCompiler.this.compileContext2(bo); }
@Override public Integer visitCast(Cast c) { return UnitCompiler.this.compileContext2(c); }
@Override public Integer visitClassLiteral(ClassLiteral cl) { return UnitCompiler.this.compileContext2(cl); }
@Override public Integer visitConditionalExpression(ConditionalExpression ce) { return UnitCompiler.this.compileContext2(ce); }
@Override public Integer visitCrement(Crement c) { return UnitCompiler.this.compileContext2(c); }
@Override public Integer visitInstanceof(Instanceof io) { return UnitCompiler.this.compileContext2(io); }
@Override public Integer visitMethodInvocation(MethodInvocation mi) { return UnitCompiler.this.compileContext2(mi); }
@Override public Integer visitSuperclassMethodInvocation(SuperclassMethodInvocation smi) { return UnitCompiler.this.compileContext2(smi); }
@Override public Integer visitIntegerLiteral(IntegerLiteral il) { return UnitCompiler.this.compileContext2(il); }
@Override public Integer visitFloatingPointLiteral(FloatingPointLiteral fpl) { return UnitCompiler.this.compileContext2(fpl); }
@Override public Integer visitBooleanLiteral(BooleanLiteral bl) { return UnitCompiler.this.compileContext2(bl); }
@Override public Integer visitCharacterLiteral(CharacterLiteral cl) { return UnitCompiler.this.compileContext2(cl); }
@Override public Integer visitStringLiteral(StringLiteral sl) { return UnitCompiler.this.compileContext2(sl); }
@Override public Integer visitNullLiteral(NullLiteral nl) { return UnitCompiler.this.compileContext2(nl); }
@Override public Integer visitSimpleConstant(SimpleConstant sl) { return UnitCompiler.this.compileContext2(sl); }
@Override public Integer visitNewAnonymousClassInstance(NewAnonymousClassInstance naci) { return UnitCompiler.this.compileContext2(naci); }
@Override public Integer visitNewArray(NewArray na) { return UnitCompiler.this.compileContext2(na); }
@Override public Integer visitNewInitializedArray(NewInitializedArray nia) { return UnitCompiler.this.compileContext2(nia); }
@Override public Integer visitNewClassInstance(NewClassInstance nci) { return UnitCompiler.this.compileContext2(nci); }
@Override public Integer visitParameterAccess(ParameterAccess pa) { return UnitCompiler.this.compileContext2(pa); }
@Override public Integer visitQualifiedThisReference(QualifiedThisReference qtr) { return UnitCompiler.this.compileContext2(qtr); }
@Override public Integer visitThisReference(ThisReference tr) { return UnitCompiler.this.compileContext2(tr); }
@Override public Integer visitLambdaExpression(LambdaExpression le) { return UnitCompiler.this.compileContext2(le); }
@Override public Integer visitMethodReference(MethodReference mr) { return UnitCompiler.this.compileContext2(mr); }
@Override public Integer visitInstanceCreationReference(ClassInstanceCreationReference cicr) { return UnitCompiler.this.compileContext2(cicr); }
@Override public Integer visitArrayCreationReference(ArrayCreationReference acr) { return UnitCompiler.this.compileContext2(acr); }
});
assert result != null;
return result;
}
@SuppressWarnings("static-method") private int
compileContext2(Rvalue rv) { return 0; }
private int
compileContext2(AmbiguousName an) throws CompileException {
return this.compileContext(this.toRvalueOrCompileException(this.reclassify(an)));
}
private int
compileContext2(FieldAccess fa) throws CompileException {
if (fa.field.isStatic()) {
Rvalue rv = fa.lhs.toRvalue();
if (rv != null) {
this.warning(
"CNSFA",
"Left-hand side of static field access should be a type, not an rvalue",
fa.lhs.getLocation()
);
// JLS7 15.11.1.3.1.1:
this.pop(fa.lhs, this.compileGetValue(rv));
}
return 0;
} else {
this.compileGetValue(this.toRvalueOrCompileException(fa.lhs));
return 1;
}
}
private int
compileContext2(ArrayLength al) throws CompileException {
if (!UnitCompiler.rawTypeOf(this.compileGetValue(al.lhs)).isArray()) {
this.compileError("Cannot determine length of non-array type", al.getLocation());
}
return 1;
}
/**
* Array access expression; see JLS7 15.13 / JLS8+ 15.10.3.
*/
private int
compileContext2(ArrayAccessExpression aae) throws CompileException {
IType lhsType = this.compileGetValue(aae.lhs);
if (!UnitCompiler.rawTypeOf(lhsType).isArray()) {
this.compileError(
"Subscript not allowed on non-array type \"" + lhsType.toString() + "\"",
aae.getLocation()
);
}
IType indexType = this.compileGetValue(aae.index);
if (this.unaryNumericPromotion(aae.index, indexType) != IClass.INT) {
this.compileError(
"Index expression of type \"" + indexType + "\" cannot be promoted to \"int\"",
aae.getLocation()
);
}
return 2;
}
private int
compileContext2(FieldAccessExpression fae) throws CompileException {
return this.compileContext(this.determineValue(fae));
}
private int
compileContext2(SuperclassFieldAccessExpression scfae) throws CompileException {
return this.compileContext(this.determineValue(scfae));
}
private int
compileContext2(ParenthesizedExpression pe) throws CompileException {
return this.compileContext(pe.value);
}
/**
* Generates code that determines the value of the {@link Rvalue} and puts it on the operand stack. This method
* relies on that the "context" of the {@link Rvalue} is on top of the operand stack (see {@link
* #compileContext(Rvalue)}).
*
* @return The type of the {@link Rvalue}
*/
private IType
compileGet(Rvalue rv) throws CompileException {
IType result = (IType) rv.accept(new RvalueVisitor() {
@Override @Nullable public IType
visitLvalue(Lvalue lv) throws CompileException {
return (IType) lv.accept(new LvalueVisitor() {
@Override public IType visitAmbiguousName(AmbiguousName an) throws CompileException { return UnitCompiler.this.compileGet2(an); }
@Override public IType visitArrayAccessExpression(ArrayAccessExpression aae) throws CompileException { return UnitCompiler.this.compileGet2(aae); }
@Override public IType visitFieldAccess(FieldAccess fa) throws CompileException { return UnitCompiler.this.compileGet2(fa); }
@Override public IType visitFieldAccessExpression(FieldAccessExpression fae) throws CompileException { return UnitCompiler.this.compileGet2(fae); }
@Override public IType visitSuperclassFieldAccessExpression(SuperclassFieldAccessExpression scfae) throws CompileException { return UnitCompiler.this.compileGet2(scfae); }
@Override public IType visitLocalVariableAccess(LocalVariableAccess lva) { return UnitCompiler.this.compileGet2(lva); }
@Override public IType visitParenthesizedExpression(ParenthesizedExpression pe) throws CompileException { return UnitCompiler.this.compileGet2(pe); }
});
}
@Override public IType visitArrayLength(ArrayLength al) { return UnitCompiler.this.compileGet2(al); }
@Override public IType visitAssignment(Assignment a) throws CompileException { return UnitCompiler.this.compileGet2(a); }
@Override public IType visitUnaryOperation(UnaryOperation uo) throws CompileException { return UnitCompiler.this.compileGet2(uo); }
@Override public IType visitBinaryOperation(BinaryOperation bo) throws CompileException { return UnitCompiler.this.compileGet2(bo); }
@Override public IType visitCast(Cast c) throws CompileException { return UnitCompiler.this.compileGet2(c); }
@Override public IType visitClassLiteral(ClassLiteral cl) throws CompileException { return UnitCompiler.this.compileGet2(cl); }
@Override public IType visitConditionalExpression(ConditionalExpression ce) throws CompileException { return UnitCompiler.this.compileGet2(ce); }
@Override public IType visitCrement(Crement c) throws CompileException { return UnitCompiler.this.compileGet2(c); }
@Override public IType visitInstanceof(Instanceof io) throws CompileException { return UnitCompiler.this.compileGet2(io); }
@Override public IType visitMethodInvocation(MethodInvocation mi) throws CompileException { return UnitCompiler.this.compileGet2(mi); }
@Override public IType visitSuperclassMethodInvocation(SuperclassMethodInvocation smi) throws CompileException { return UnitCompiler.this.compileGet2(smi); }
@Override public IType visitIntegerLiteral(IntegerLiteral il) throws CompileException { return UnitCompiler.this.compileGet2(il); }
@Override public IType visitFloatingPointLiteral(FloatingPointLiteral fpl) throws CompileException { return UnitCompiler.this.compileGet2(fpl); }
@Override public IType visitBooleanLiteral(BooleanLiteral bl) throws CompileException { return UnitCompiler.this.compileGet2(bl); }
@Override public IType visitCharacterLiteral(CharacterLiteral cl) throws CompileException { return UnitCompiler.this.compileGet2(cl); }
@Override public IType visitStringLiteral(StringLiteral sl) throws CompileException { return UnitCompiler.this.compileGet2(sl); }
@Override public IType visitNullLiteral(NullLiteral nl) throws CompileException { return UnitCompiler.this.compileGet2(nl); }
@Override public IType visitSimpleConstant(SimpleConstant sl) throws CompileException { return UnitCompiler.this.compileGet2(sl); }
@Override public IType visitNewAnonymousClassInstance(NewAnonymousClassInstance naci) throws CompileException { return UnitCompiler.this.compileGet2(naci); }
@Override public IType visitNewArray(NewArray na) throws CompileException { return UnitCompiler.this.compileGet2(na); }
@Override public IType visitNewInitializedArray(NewInitializedArray nia) throws CompileException { return UnitCompiler.this.compileGet2(nia); }
@Override public IType visitNewClassInstance(NewClassInstance nci) throws CompileException { return UnitCompiler.this.compileGet2(nci); }
@Override public IType visitParameterAccess(ParameterAccess pa) throws CompileException { return UnitCompiler.this.compileGet2(pa); }
@Override public IType visitQualifiedThisReference(QualifiedThisReference qtr) throws CompileException { return UnitCompiler.this.compileGet2(qtr); }
@Override public IType visitThisReference(ThisReference tr) throws CompileException { return UnitCompiler.this.compileGet2(tr); }
@Override public IType visitLambdaExpression(LambdaExpression le) throws CompileException { return UnitCompiler.this.compileGet2(le); }
@Override public IType visitMethodReference(MethodReference mr) throws CompileException { return UnitCompiler.this.compileGet2(mr); }
@Override public IType visitInstanceCreationReference(ClassInstanceCreationReference cicr) throws CompileException { return UnitCompiler.this.compileGet2(cicr); }
@Override public IType visitArrayCreationReference(ArrayCreationReference acr) throws CompileException { return UnitCompiler.this.compileGet2(acr); }
});
assert result != null;
return result;
}
private IClass
compileGet2(BooleanRvalue brv) throws CompileException {
CodeContext.Offset isTrue = this.getCodeContext().new BasicBlock();
isTrue.setStackMap(this.getCodeContext().currentInserter().getStackMap());
this.compileBoolean(brv, isTrue, UnitCompiler.JUMP_IF_TRUE);
this.consT(brv, 0);
CodeContext.Offset end = this.getCodeContext().new BasicBlock();
this.gotO(brv, end);
isTrue.setBasicBlock();
this.consT(brv, 1);
end.set();
return IClass.BOOLEAN;
}
private IType
compileGet2(AmbiguousName an) throws CompileException {
return this.compileGet(this.toRvalueOrCompileException(this.reclassify(an)));
}
private IType
compileGet2(LocalVariableAccess lva) { return this.load(lva, lva.localVariable); }
private IType
compileGet2(FieldAccess fa) throws CompileException {
this.checkAccessible(fa.field, fa.getEnclosingScope(), fa.getLocation());
this.getfield(fa, fa.field);
return fa.field.getType();
}
private IClass
compileGet2(ArrayLength al) {
this.arraylength(al);
return IClass.INT;
}
private IClass
compileGet2(ThisReference tr) throws CompileException {
final IClass currentIClass = this.getIClass(tr);
this.referenceThis(tr, currentIClass);
return currentIClass;
}
@SuppressWarnings("static-method") private IClass
compileGet2(LambdaExpression le) throws CompileException {
throw UnitCompiler.compileException(le, "Compilation of lambda expression NYI");
}
@SuppressWarnings("static-method") private IClass
compileGet2(MethodReference mr) throws CompileException {
throw UnitCompiler.compileException(mr, "Compilation of method reference NYI");
}
@SuppressWarnings("static-method") private IClass
compileGet2(ClassInstanceCreationReference cicr) throws CompileException {
throw UnitCompiler.compileException(cicr, "Compilation of class instance creation reference NYI");
}
@SuppressWarnings("static-method") private IClass
compileGet2(ArrayCreationReference acr) throws CompileException {
throw UnitCompiler.compileException(acr, "Compilation of array creation reference NYI");
}
private IType
compileGet2(QualifiedThisReference qtr) throws CompileException {
this.referenceThis(
qtr, // locatable
this.getDeclaringClass(qtr), // declaringClass
this.getDeclaringTypeBodyDeclaration(qtr), // declaringTypeBodyDeclaration
this.getTargetIType(qtr) // targetIClass
);
return this.getTargetIType(qtr);
}
private IClass
compileGet2(ClassLiteral cl) throws CompileException {
IType type = this.getType(cl.type);
if (type instanceof IParameterizedType) {
this.compileError("LHS of class literal must not be a parameterized type", cl.getLocation());
}
assert type instanceof IClass;
IClass iClass = (IClass) type;
if (iClass.isPrimitive()) {
// Primitive class literal.
IClass wrapperIClass = (
iClass == IClass.VOID ? this.iClassLoader.TYPE_java_lang_Void :
iClass == IClass.BYTE ? this.iClassLoader.TYPE_java_lang_Byte :
iClass == IClass.CHAR ? this.iClassLoader.TYPE_java_lang_Character :
iClass == IClass.DOUBLE ? this.iClassLoader.TYPE_java_lang_Double :
iClass == IClass.FLOAT ? this.iClassLoader.TYPE_java_lang_Float :
iClass == IClass.INT ? this.iClassLoader.TYPE_java_lang_Integer :
iClass == IClass.LONG ? this.iClassLoader.TYPE_java_lang_Long :
iClass == IClass.SHORT ? this.iClassLoader.TYPE_java_lang_Short :
iClass == IClass.BOOLEAN ? this.iClassLoader.TYPE_java_lang_Boolean :
null
);
assert wrapperIClass != null;
this.getfield(cl, wrapperIClass, "TYPE", this.iClassLoader.TYPE_java_lang_Class, true);
} else {
// Non-primitive class literal.
this.consT(cl, iClass);
}
return this.iClassLoader.TYPE_java_lang_Class;
}
private IType
compileGet2(Assignment a) throws CompileException {
if (a.operator == "=") { // SUPPRESS CHECKSTYLE StringLiteralEquality
// Compile LHS context.
int lhsCs = this.compileContext(a.lhs);
// Convert RHS value to LHS type.
IType lhsType = this.getType(a.lhs);
IType rhsType = this.compileGetValue(a.rhs);
this.assignmentConversion(a, rhsType, lhsType, this.getConstantValue(a.rhs));
// Duplicate RHS value below LHS context.
this.dupxx(a, lhsCs);
// Set LHS.
this.compileSet(a.lhs);
return lhsType;
}
// Implement "|= ^= &= *= /= %= += -= <<= >>= >>>=".
int lhsCs = this.compileContext(a.lhs);
this.dupn(a, lhsCs);
IType lhsType = this.compileGet(a.lhs);
IType resultType = this.compileArithmeticBinaryOperation(
a, // locatable
lhsType, // lhsType
a.operator.substring( // operator
0,
a.operator.length() - 1
).intern(), /* <= IMPORTANT! */
a.rhs // rhs
);
// Convert the result to LHS type (JLS7 15.26.2).
if (
!this.tryIdentityConversion(resultType, lhsType)
&& !this.tryNarrowingPrimitiveConversion(a, resultType, lhsType)
) throw new InternalCompilerException(a.getLocation(), "SNO: \"" + a.operator + "\" reconversion failed");
this.dupx(a);
this.compileSet(a.lhs);
return lhsType;
}
private IType
compileGet2(ConditionalExpression ce) throws CompileException {
IType expressionType = this.getType2(ce);
IType mhsType = this.getType(ce.mhs);
IType rhsType = this.getType(ce.rhs);
{
Object lhsCv = this.getConstantValue(ce.lhs);
if (lhsCv instanceof Boolean) {
// LHS is a constant expression.
if (((Boolean) lhsCv).booleanValue()) {
this.compileGetValue(ce.mhs);
this.castConversion(ce.mhs, mhsType, expressionType, UnitCompiler.NOT_CONSTANT);
} else {
this.compileGetValue(ce.rhs);
this.castConversion(ce.rhs, rhsType, expressionType, UnitCompiler.NOT_CONSTANT);
}
return expressionType;
}
}
// Non-constant LHS.
{
final CodeContext.Offset toEnd = this.getCodeContext().new BasicBlock();
final CodeContext.Offset toRhs = this.getCodeContext().new BasicBlock();
StackMap sm = this.getCodeContext().currentInserter().getStackMap();
this.compileBoolean(ce.lhs, toRhs, UnitCompiler.JUMP_IF_FALSE);
this.compileGetValue(ce.mhs);
this.assignmentConversion(ce.mhs, mhsType, expressionType, UnitCompiler.NOT_CONSTANT);
this.gotO(ce, toEnd);
this.getCodeContext().currentInserter().setStackMap(sm);
toRhs.setBasicBlock();
this.compileGetValue(ce.rhs);
this.assignmentConversion(ce.mhs, rhsType, expressionType, UnitCompiler.NOT_CONSTANT);
toEnd.set();
}
return expressionType;
}
private IType
commonSupertype(IType t1, IType t2) throws CompileException {
if (UnitCompiler.isAssignableFrom(t2, t1)) return t2;
return this.commonSupertype2(t1, t2);
}
private IType
commonSupertype2(IType t1, IType t2) throws CompileException {
if (UnitCompiler.isAssignableFrom(t1, t2)) return t1;
{
IClass sc = UnitCompiler.rawTypeOf(t1).getSuperclass();
if (sc != null) {
IType result = this.commonSupertype2(sc, t2);
if (result != this.iClassLoader.TYPE_java_lang_Object) return result;
}
}
for (IType i : UnitCompiler.getInterfaces(t1)) {
IType result = this.commonSupertype2(i, t2);
if (result != this.iClassLoader.TYPE_java_lang_Object) return result;
}
return this.iClassLoader.TYPE_java_lang_Object;
}
@Nullable private static Byte
isByteConstant(@Nullable Object o) {
if (o instanceof Integer) {
int v = (Integer) o;
return v >= Byte.MIN_VALUE && v <= Byte.MAX_VALUE ? Byte.valueOf((byte) v) : null;
}
return null;
}
private IType
compileGet2(Crement c) throws CompileException {
// Optimized crement of "int" local variable.
LocalVariable lv = this.isIntLv(c);
if (lv != null) {
if (!c.pre) this.load(c, lv);
this.iinc(c, lv, c.operator);
if (c.pre) this.load(c, lv);
return IClass.INT;
}
// Compile operand context.
int operandCs = this.compileContext(c.operand);
// DUP operand context.
this.dupn(c, operandCs);
// Get operand value.
IType type = this.compileGet(c.operand);
// If postincrement: DUPX the operand value.
if (!c.pre) this.dupxx(c, operandCs);
{
// Apply "unary numeric promotion".
IClass promotedType = this.unaryNumericPromotion(c, type);
// Crement.
this.consT(c, promotedType, 1);
if (c.operator == "++") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.add(c);
} else
if (c.operator == "--") { // SUPPRESS CHECKSTYLE StringLiteralEquality
this.sub(c);
} else {
this.compileError("Unexpected operator \"" + c.operator + "\"", c.getLocation());
}
this.reverseUnaryNumericPromotion(c, promotedType, type);
}
// If preincrement: DUPX the cremented operand value.
if (c.pre) this.dupxx(c, operandCs);
// Set operand.
this.compileSet(c.operand);
return type;
}
private IType
compileGet2(ArrayAccessExpression aae) throws CompileException {
IType lhsComponentType = this.getType(aae);
this.xaload(aae, lhsComponentType);
return lhsComponentType;
}
private IType
compileGet2(FieldAccessExpression fae) throws CompileException {
return this.compileGet(this.determineValue(fae));
}
private IType
compileGet2(SuperclassFieldAccessExpression scfae) throws CompileException {
return this.compileGet(this.determineValue(scfae));
}
private IClass
compileGet2(UnaryOperation uo) throws CompileException {
if (uo.operator == "!") { // SUPPRESS CHECKSTYLE StringLiteralEquality
return this.compileGet2((BooleanRvalue) uo);
}
if (uo.operator == "+") { // SUPPRESS CHECKSTYLE StringLiteralEquality
return this.unaryNumericPromotion(
uo,
this.convertToPrimitiveNumericType(uo, this.compileGetValue(uo.operand))
);
}
if (uo.operator == "-") { // SUPPRESS CHECKSTYLE StringLiteralEquality
{
Object ncv = this.getConstantValue2(uo);
if (ncv != UnitCompiler.NOT_CONSTANT) {
return this.unaryNumericPromotion(uo, this.consT(uo, ncv));
}
}
IClass promotedType = this.unaryNumericPromotion(
uo,
this.convertToPrimitiveNumericType(uo, this.compileGetValue(uo.operand))
);
this.neg(uo, promotedType);
return promotedType;
}
if (uo.operator == "~") { // SUPPRESS CHECKSTYLE StringLiteralEquality
IType operandType = this.compileGetValue(uo.operand);
IClass promotedType = this.unaryNumericPromotion(uo, operandType);
if (promotedType == IClass.INT) {
this.consT(uo, -1);
this.xor(uo, Opcode.IXOR);
return IClass.INT;
}
if (promotedType == IClass.LONG) {
this.consT(uo, -1L);
this.xor(uo, Opcode.LXOR);
return IClass.LONG;
}
this.compileError("Operator \"~\" not applicable to type \"" + promotedType + "\"", uo.getLocation());
}
this.compileError("Unexpected operator \"" + uo.operator + "\"", uo.getLocation());
return this.iClassLoader.TYPE_java_lang_Object;
}
private IClass
compileGet2(Instanceof io) throws CompileException {
IType lhsType = this.compileGetValue(io.lhs);
IType rhsType = this.getType(io.rhs);
if (rhsType instanceof IParameterizedType) {
this.compileError("Cannot check against parameterized type", io.getLocation());
return IClass.BOOLEAN;
}
if (
UnitCompiler.isInterface(lhsType) || UnitCompiler.isInterface(rhsType)
// We cannot precompute the result from type information as the value might be null, but we should detect
// when the instanceof is statically impossible.
|| UnitCompiler.isAssignableFrom(lhsType, rhsType)
|| UnitCompiler.isAssignableFrom(rhsType, lhsType)
) {
this.instanceoF(io, rhsType);
} else {
this.compileError("\"" + lhsType + "\" can never be an instance of \"" + rhsType + "\"", io.getLocation());
}
return IClass.BOOLEAN;
}
@Nullable private static IType
getComponentType(IType expressionType) { return UnitCompiler.rawTypeOf(expressionType).getComponentType(); }
private static boolean
isPrimitive(IType type) { return UnitCompiler.rawTypeOf(type).isPrimitive(); }
@Nullable private static IType
getSuperclass(IType type) throws CompileException { return UnitCompiler.rawTypeOf(type).getSuperclass(); }
private static boolean
isInterface(IType type) { return UnitCompiler.rawTypeOf(type).isInterface(); }
private static IType[]
getInterfaces(IType t1) throws CompileException {
IClass[] rawInterfaces = UnitCompiler.rawTypeOf(t1).getInterfaces();
IType[] result = new IType[rawInterfaces.length];
for (int i = 0; i < result.length; i++) result[i] = rawInterfaces[i];
return result;
}
private static boolean
isArray(IType type) { return UnitCompiler.rawTypeOf(type).isArray(); }
private static boolean
isAssignableFrom(IType targetType, IType sourceType) throws CompileException {
return UnitCompiler.rawTypeOf(targetType).isAssignableFrom(UnitCompiler.rawTypeOf(sourceType));
}
private IType
compileGet2(BinaryOperation bo) throws CompileException {
if (
bo.operator == "||" // SUPPRESS CHECKSTYLE StringLiteralEquality
|| bo.operator == "&&" // SUPPRESS CHECKSTYLE StringLiteralEquality
|| bo.operator == "==" // SUPPRESS CHECKSTYLE StringLiteralEquality
|| bo.operator == "!=" // SUPPRESS CHECKSTYLE StringLiteralEquality
|| bo.operator == "<" // SUPPRESS CHECKSTYLE StringLiteralEquality
|| bo.operator == ">" // SUPPRESS CHECKSTYLE StringLiteralEquality
|| bo.operator == "<=" // SUPPRESS CHECKSTYLE StringLiteralEquality
|| bo.operator == ">=" // SUPPRESS CHECKSTYLE StringLiteralEquality
) {
// Eventually calls "compileBoolean()".
return this.compileGet2((BooleanRvalue) bo);
}
// Implements "| ^ & * / % + - << >> >>>".
return this.compileArithmeticOperation(
bo, // locatable
null, // type
bo.unrollLeftAssociation(), // operands
bo.operator // operator
);
}
private IType
compileGet2(Cast c) throws CompileException {
// JLS7 5.5 Casting Conversion.
IType tt = this.getType(c.targetType);
IType vt = this.compileGetValue(c.value);
if (this.tryCastConversion(c, vt, tt, this.getConstantValue2(c.value))) return tt;
// JAVAC obviously also permits 'boxing conversion followed by widening reference conversion' and 'unboxing
// conversion followed by widening primitive conversion', although these are not described in JLS7 5.5. For the
// sake of compatibility, we implement them.
// See also http://jira.codehaus.org/browse/JANINO-153
{
IClass boxedType = this.isBoxingConvertible(vt);
if (boxedType != null && this.isWideningReferenceConvertible(boxedType, tt)) {
this.boxingConversion(c, vt, boxedType);
return tt;
}
IClass unboxedType = this.isUnboxingConvertible(vt);
if (unboxedType != null && this.isWideningPrimitiveConvertible(unboxedType, tt)) {
this.unboxingConversion(c, vt, unboxedType);
this.tryWideningPrimitiveConversion(c, unboxedType, tt);
return tt;
}
}
this.compileError("Cannot cast \"" + vt + "\" to \"" + tt + "\"", c.getLocation());
return tt;
}
private IType
compileGet2(ParenthesizedExpression pe) throws CompileException {
return this.compileGet(pe.value);
}
private IClass
compileGet2(MethodInvocation mi) throws CompileException {
IClass.IMethod iMethod = this.findIMethod(mi);
// Compute the objectref for an instance method.
Atom ot = mi.target;
if (ot == null) {
// JLS7 6.5.7.1, 15.12.4.1.1.1
TypeBodyDeclaration scopeTbd;
AbstractTypeDeclaration scopeTypeDeclaration;
{
Scope s;
for (
s = mi.getEnclosingScope();
!(s instanceof TypeBodyDeclaration);
s = s.getEnclosingScope()
);
scopeTbd = (TypeBodyDeclaration) s;
if (!(s instanceof AbstractTypeDeclaration)) s = s.getEnclosingScope();
scopeTypeDeclaration = (AbstractTypeDeclaration) s;
}
if (iMethod.isStatic()) {
this.warning(
"IASM",
"Implicit access to static method \"" + iMethod.toString() + "\"",
mi.getLocation()
);
// JLS7 15.12.4.1.1.1.1
;
} else {
this.warning(
"IANSM",
"Implicit access to non-static method \"" + iMethod.toString() + "\"",
mi.getLocation()
);
// JLS7 15.12.4.1.1.1.2
if (UnitCompiler.isStaticContext(scopeTbd)) {
this.compileError(
"Instance method \"" + iMethod.toString() + "\" cannot be invoked in static context",
mi.getLocation()
);
}
this.referenceThis(
mi, // locatable
scopeTypeDeclaration, // declaringType
scopeTbd, // declaringTypeBodyDeclaration
iMethod.getDeclaringIClass() // targetIClass
);
}
} else {
// 6.5.7.2
if (this.isType(ot)) {
// The target is a type; thus the method must be static.
// JLS9 15.12.4.1.2:
this.getType(this.toTypeOrCompileException(ot));
if (!iMethod.isStatic()) {
this.compileError(
"Instance method \"" + mi.methodName + "\" cannot be invoked in static context",
mi.getLocation()
);
}
} else
{
// The target is an rvalue.
Rvalue rot = this.toRvalueOrCompileException(ot);
if (iMethod.isStatic()) {
// JLS9 15.12.4.1.3.1 and .4.1:
if (!UnitCompiler.mayHaveSideEffects(rot)) {
// The rvalue is guaranteed to have no side effects, so we can save the code to evaluate it
// and then discard the result.
;
} else {
// Evaluate the target expression and then discard the result.
this.pop(ot, this.compileGetValue(rot));
}
} else {
// JLS9 15.12.4.1.3.2 and .4.2
this.compileGetValue(rot);
if (this.getCodeContext().peekNullOperand()) {
this.compileError("Method invocation target is always null");
this.getCodeContext().popOperand();
this.getCodeContext().pushObjectOperand(iMethod.getDeclaringIClass().getDescriptor());
}
}
}
}
// Evaluate method parameters (JLS7 15.12.4.2).
// If this method is vararg, rewritten all args starting from lastParamIndex to the end as if they were elements
// of an array.
IClass[] parameterTypes = iMethod.getParameterTypes();
Rvalue[] adjustedArgs = null;
final int actualSize = mi.arguments.length;
if (iMethod.isVarargs() && iMethod.argsNeedAdjust()) {
adjustedArgs = new Rvalue[parameterTypes.length];
Rvalue[] lastArgs = new Rvalue[actualSize - parameterTypes.length + 1];
final Location loc = mi.getLocation();
if (lastArgs.length > 0) {
for (int i = 0, j = parameterTypes.length - 1; i < lastArgs.length; ++i, ++j) {
lastArgs[i] = mi.arguments[j];
}
}
for (int i = parameterTypes.length - 2; i >= 0; --i) {
adjustedArgs[i] = mi.arguments[i];
}
adjustedArgs[adjustedArgs.length - 1] = new NewInitializedArray(
loc, // location
parameterTypes[parameterTypes.length - 1], // arrayIClass
new ArrayInitializer(loc, lastArgs) // arrayInitializer
);
} else {
adjustedArgs = mi.arguments;
}
for (int i = 0; i < adjustedArgs.length; ++i) {
this.assignmentConversion(
mi, // location
this.compileGetValue(adjustedArgs[i]), // sourceType
parameterTypes[i], // targetType
this.getConstantValue(adjustedArgs[i]) // constantValue
);
}
// Invoke!
this.checkAccessible(iMethod, mi.getEnclosingScope(), mi.getLocation());
if (!iMethod.getDeclaringIClass().isInterface() && !iMethod.isStatic() && iMethod.getAccess() == Access.PRIVATE) {
// In order to make a non-static private method invocable for enclosing types, enclosed types and types
// enclosed by the same type, "compile(FunctionDeclarator)" modifies it on-the-fly as follows:
// + Access is changed from PRIVATE to PACKAGE
// + The name is appended with "$"
// + It is made static
// + A parameter of type "declaring class" is prepended to the signature
// Hence, the invocation of such a method must be modified accordingly.
this.invoke(
mi, // locatable
Opcode.INVOKESTATIC, // opcode
iMethod.getDeclaringIClass(), // declaringIClass
iMethod.getName() + '$', // methodName
iMethod.getDescriptor().prependParameter( // methodMd
iMethod.getDeclaringIClass().getDescriptor()
),
false // useInterfaceMethodref
);
} else
{
this.invokeMethod(mi, iMethod);
}
return iMethod.getReturnType();
}
private static boolean
isStaticContext(TypeBodyDeclaration tbd) {
if (tbd instanceof FieldDeclaration) return ((FieldDeclaration) tbd).isStatic() || ((FieldDeclaration) tbd).getDeclaringType() instanceof InterfaceDeclaration;
if (tbd instanceof MethodDeclarator) return ((MethodDeclarator) tbd).isStatic();
if (tbd instanceof Initializer) return ((Initializer) tbd).isStatic();
if (tbd instanceof MemberClassDeclaration) return ((MemberClassDeclaration) tbd).isStatic();
return false;
}
private static boolean
mayHaveSideEffects(ArrayInitializerOrRvalue... arrayInitializersOrRvalues) {
for (ArrayInitializerOrRvalue aiorv : arrayInitializersOrRvalues) {
if (UnitCompiler.mayHaveSideEffects(aiorv)) return true;
}
return false;
}
private static boolean
mayHaveSideEffects(ArrayInitializerOrRvalue arrayInitializerOrRvalue) {
Boolean result = (Boolean) arrayInitializerOrRvalue.accept(UnitCompiler.MAY_HAVE_SIDE_EFFECTS_VISITOR);
assert result != null;
return result;
}
private static final ArrayInitializerOrRvalueVisitor
MAY_HAVE_SIDE_EFFECTS_VISITOR = new ArrayInitializerOrRvalueVisitor() {
@Override @Nullable public Boolean visitRvalue(Rvalue rvalue) { return (Boolean) rvalue.accept(this.rvalueVisitor); }
@Override @Nullable public Boolean visitArrayInitializer(ArrayInitializer ai) { return UnitCompiler.mayHaveSideEffects(ai.values); }
final LvalueVisitor
lvalueVisitor = new LvalueVisitor() {
@Override @Nullable public Boolean visitAmbiguousName(AmbiguousName an) { return false; }
@Override @Nullable public Boolean visitArrayAccessExpression(ArrayAccessExpression aae) { return UnitCompiler.mayHaveSideEffects(aae.lhs, aae.index); }
@Override @Nullable public Boolean visitFieldAccess(FieldAccess fa) { return false; }
@Override @Nullable public Boolean visitFieldAccessExpression(FieldAccessExpression fae) { return false; }
@Override @Nullable public Boolean visitSuperclassFieldAccessExpression(SuperclassFieldAccessExpression scfae) { return false; }
@Override @Nullable public Boolean visitLocalVariableAccess(LocalVariableAccess lva) { return false; }
@Override @Nullable public Boolean visitParenthesizedExpression(ParenthesizedExpression pe) { return UnitCompiler.mayHaveSideEffects(pe.value); }
};
final RvalueVisitor
rvalueVisitor = new RvalueVisitor() {
@SuppressWarnings("unqualified-field-access") @Override @Nullable public Boolean
visitLvalue(Lvalue lv) { return (Boolean) lv.accept(lvalueVisitor); }
@Override @Nullable public Boolean visitArrayLength(ArrayLength al) { return UnitCompiler.mayHaveSideEffects(al.lhs); }
@Override @Nullable public Boolean visitAssignment(Assignment a) { return true; }
@Override @Nullable public Boolean visitUnaryOperation(UnaryOperation uo) { return UnitCompiler.mayHaveSideEffects(uo.operand); }
@Override @Nullable public Boolean visitBinaryOperation(BinaryOperation bo) { return UnitCompiler.mayHaveSideEffects(bo.lhs, bo.rhs); }
@Override @Nullable public Boolean visitCast(Cast c) { return UnitCompiler.mayHaveSideEffects(c.value); }
@Override @Nullable public Boolean visitClassLiteral(ClassLiteral cl) { return false; }
@Override @Nullable public Boolean visitConditionalExpression(ConditionalExpression ce) { return UnitCompiler.mayHaveSideEffects(ce.lhs, ce.mhs, ce.rhs); }
@Override @Nullable public Boolean visitCrement(Crement c) { return true; }
@Override @Nullable public Boolean visitInstanceof(Instanceof io) { return false; }
@Override @Nullable public Boolean visitMethodInvocation(MethodInvocation mi) { return true; }
@Override @Nullable public Boolean visitSuperclassMethodInvocation(SuperclassMethodInvocation smi) { return true; }
@Override @Nullable public Boolean visitIntegerLiteral(IntegerLiteral il) { return false; }
@Override @Nullable public Boolean visitFloatingPointLiteral(FloatingPointLiteral fpl) { return false; }
@Override @Nullable public Boolean visitBooleanLiteral(BooleanLiteral bl) { return false; }
@Override @Nullable public Boolean visitCharacterLiteral(CharacterLiteral cl) { return false; }
@Override @Nullable public Boolean visitStringLiteral(StringLiteral sl) { return false; }
@Override @Nullable public Boolean visitNullLiteral(NullLiteral nl) { return false; }
@Override @Nullable public Boolean visitSimpleConstant(SimpleConstant sl) { return false; }
@Override @Nullable public Boolean visitNewAnonymousClassInstance(NewAnonymousClassInstance naci) { return true; }
@Override @Nullable public Boolean visitNewArray(NewArray na) { return UnitCompiler.mayHaveSideEffects(na.dimExprs); }
@Override @Nullable public Boolean visitNewInitializedArray(NewInitializedArray nia) { return UnitCompiler.mayHaveSideEffects(nia.arrayInitializer); }
@Override @Nullable public Boolean visitNewClassInstance(NewClassInstance nci) { return true; }
@Override @Nullable public Boolean visitParameterAccess(ParameterAccess pa) { return false; }
@Override @Nullable public Boolean visitQualifiedThisReference(QualifiedThisReference qtr) { return false; }
@Override @Nullable public Boolean visitThisReference(ThisReference tr) { return false; }
@Override @Nullable public Boolean visitLambdaExpression(LambdaExpression le) { return true; }
@Override @Nullable public Boolean visitMethodReference(MethodReference mr) { return true; }
@Override @Nullable public Boolean visitInstanceCreationReference(ClassInstanceCreationReference cicr) { return true; }
@Override @Nullable public Boolean visitArrayCreationReference(ArrayCreationReference acr) { return false; }
};
};
private IClass
compileGet2(SuperclassMethodInvocation scmi) throws CompileException {
final IClass.IMethod iMethod = this.findIMethod(scmi);
Scope s;
for (
s = scmi.getEnclosingScope();
s instanceof Statement || s instanceof CatchClause;
s = s.getEnclosingScope()
);
FunctionDeclarator fd = s instanceof FunctionDeclarator ? (FunctionDeclarator) s : null;
if (fd == null) {
this.compileError("Cannot invoke superclass method in non-method scope", scmi.getLocation());
return IClass.INT;
}
if (fd instanceof MethodDeclarator && ((MethodDeclarator) fd).isStatic()) {
this.compileError("Cannot invoke superclass method in static context", scmi.getLocation());
}
this.load(scmi, this.resolve(fd.getDeclaringType()), 0);
// Evaluate method parameters.
// TODO: adjust args
IClass[] parameterTypes = iMethod.getParameterTypes();
for (int i = 0; i < scmi.arguments.length; ++i) {
this.assignmentConversion(
scmi, // locatable
this.compileGetValue(scmi.arguments[i]), // sourceType
parameterTypes[i], // targetType
this.getConstantValue(scmi.arguments[i]) // constantValue
);
}
// Invoke!
this.invoke(
scmi, // locatable
Opcode.INVOKESPECIAL, // opcode
iMethod.getDeclaringIClass(), // declaringIClass
iMethod.getName(), // methodName
iMethod.getDescriptor(), // methodMd
false // useInterfaceMethodref
);
return iMethod.getReturnType();
}
private IType
compileGet2(NewClassInstance nci) throws CompileException {
IType iType;
if (nci.iType != null) {
iType = nci.iType;
} else {
assert nci.type != null;
iType = (nci.iType = this.getType(nci.type));
}
IClass rawType = UnitCompiler.rawTypeOf(iType);
if (rawType.isInterface()) {
this.compileError("Cannot instantiate \"" + iType + "\"", nci.getLocation());
}
this.checkAccessible(rawType, nci.getEnclosingScope(), nci.getLocation());
if (rawType.isAbstract()) {
this.compileError("Cannot instantiate abstract \"" + iType + "\"", nci.getLocation());
}
// Determine the enclosing instance for the new object.
Rvalue enclosingInstance;
if (nci.qualification != null) {
if (rawType.getOuterIClass() == null) {
this.compileError("Static member class cannot be instantiated with qualified NEW");
}
// Enclosing instance defined by qualification (JLS7 15.9.2.BL1.B3.B2).
enclosingInstance = nci.qualification;
} else {
Scope s = nci.getEnclosingScope();
for (; !(s instanceof TypeBodyDeclaration); s = s.getEnclosingScope());
TypeBodyDeclaration enclosingTypeBodyDeclaration = (TypeBodyDeclaration) s;
TypeDeclaration enclosingTypeDeclaration = (TypeDeclaration) s.getEnclosingScope();
if (
!(enclosingTypeDeclaration instanceof AbstractClassDeclaration)
|| (
enclosingTypeBodyDeclaration instanceof MemberClassDeclaration
&& ((MemberClassDeclaration) enclosingTypeBodyDeclaration).isStatic()
)
|| (
enclosingTypeBodyDeclaration instanceof PackageMemberClassDeclaration
&& ((PackageMemberClassDeclaration) enclosingTypeBodyDeclaration).isStatic()
)
) {
// No enclosing instance in
// + interface method declaration or
// + static type body declaration (here: method or initializer or field declarator)
// context (JLS7 15.9.2.BL1.B3.B1.B1).
if (rawType.getOuterIClass() != null) {
this.compileError((
"Instantiation of \""
+ (nci.type != null ? nci.type.toString() : String.valueOf(nci.iType))
+ "\" requires an enclosing instance"
), nci.getLocation());
}
enclosingInstance = null;
} else
{
// Determine the type of the enclosing instance for the new object.
IClass outerIClass = rawType.getDeclaringIClass();
if (outerIClass == null) {
// No enclosing instance needed for a top-level class object.
enclosingInstance = null;
} else {
// Find an appropriate enclosing instance for the new inner class object among the enclosing
// instances of the current object (JLS7 15.9.2.BL1.B3.B1.B2).
enclosingInstance = new QualifiedThisReference(
nci.getLocation(), // location
new SimpleType( // qualification
nci.getLocation(),
outerIClass
)
);
enclosingInstance.setEnclosingScope(nci.getEnclosingScope());
}
}
}
this.neW(nci, iType);
this.dup(nci);
this.invokeConstructor(
nci, // l
nci.getEnclosingScope(), // scope
enclosingInstance, // enclosingInstance
iType, // targetClass
nci.arguments // arguments
);
this.getCodeContext().popUninitializedVariableOperand();
this.getCodeContext().pushObjectOperand(rawType.getDescriptor());
return iType;
}
private IClass
compileGet2(NewAnonymousClassInstance naci) throws CompileException {
AnonymousClassDeclaration acd = naci.anonymousClassDeclaration;
// Find constructors of superclass.
IClass sc = this.resolve(acd).getSuperclass();
assert sc != null;
IClass.IConstructor[] superclassIConstructors = sc.getDeclaredIConstructors();
if (superclassIConstructors.length == 0) {
throw new InternalCompilerException(naci.getLocation(), "SNO: Superclass has no constructors");
}
// Determine the most specific constructor of the superclass.
IClass.IConstructor superclassIConstructor = (IClass.IConstructor) this.findMostSpecificIInvocable(
naci, // locatable
superclassIConstructors, // iInvocables
naci.arguments, // arguments
acd // contextScope
);
Location loc = naci.getLocation();
Rvalue qualification = naci.qualification;
// Determine the formal parameters of the anonymous constructor.
IClass[] scpts = superclassIConstructor.getParameterTypes();
FormalParameters parameters;
{
List l = new ArrayList<>();
// Pass the enclosing instance of the base class as parameter #1.
if (qualification != null) l.add(new FormalParameter(
loc, // location
UnitCompiler.accessModifiers(loc, "final"), // modifiers
new SimpleType(loc, this.getType(qualification)), // type
"this$base" // name
));
for (int i = 0; i < scpts.length; ++i) l.add(new FormalParameter(
loc, // location
UnitCompiler.accessModifiers(loc, "final"), // modifiers
new SimpleType(loc, scpts[i]), // type
"p" + i // name
));
parameters = new FormalParameters(
loc,
(FormalParameter[]) l.toArray(new FormalParameter[l.size()]),
false
);
}
// Determine the declared exceptions of the anonymous constructor.
Type[] thrownExceptions;
{
IClass[] tes = superclassIConstructor.getThrownExceptions();
thrownExceptions = new Type[tes.length];
for (int i = 0; i < tes.length; ++i) thrownExceptions[i] = new SimpleType(loc, tes[i]);
}
// The anonymous constructor merely invokes the constructor of its superclass.
int j = 0;
Rvalue qualificationAccess;
if (qualification == null) {
qualificationAccess = null;
} else
{
qualificationAccess = new ParameterAccess(loc, parameters.parameters[j++]);
}
Rvalue[] parameterAccesses = new Rvalue[scpts.length];
for (int i = 0; i < scpts.length; ++i) {
parameterAccesses[i] = new ParameterAccess(loc, parameters.parameters[j++]);
}
// Generate the anonymous constructor for the anonymous class (JLS7 15.9.5.1).
acd.addConstructor(new ConstructorDeclarator(
loc, // location
null, // docComment
new Modifier[0], // modifiers
parameters, // parameters
thrownExceptions, // thrownExceptions
new SuperConstructorInvocation( // constructorInvocation
loc, // location
qualificationAccess, // qualification
parameterAccesses // arguments
),
Collections.emptyList() // statements
));
// Compile the anonymous class.
final IClass iClass = this.resolve(naci.anonymousClassDeclaration);
try {
this.compile(acd);
// Instantiate the anonymous class.
IClass anonymousIClass = this.resolve(acd);
this.neW(naci, anonymousIClass);
// TODO: adjust argument (for varargs case ?)
// Invoke the anonymous constructor.
this.dup(naci);
Rvalue[] arguments2;
if (qualification == null) {
arguments2 = naci.arguments;
} else {
arguments2 = new Rvalue[naci.arguments.length + 1];
arguments2[0] = qualification;
System.arraycopy(naci.arguments, 0, arguments2, 1, naci.arguments.length);
}
// Adjust if needed.
// TODO: Not doing this now because we don't need vararg-anonymous class (yet).
// Rvalue[] adjustedArgs = null;
// final int paramsTypeLength = iConstructor.getParameterTypes().length;
// if (argsNeedAdjusting[0]) {
// adjustedArgs = new Rvalue[paramsTypeLength];
// }
// Notice: The enclosing instance of the anonymous class is "this", not the qualification of the
// NewAnonymousClassInstance.
Scope s;
for (s = naci.getEnclosingScope(); !(s instanceof TypeBodyDeclaration); s = s.getEnclosingScope());
ThisReference oei;
if (UnitCompiler.isStaticContext((TypeBodyDeclaration) s)) {
oei = null;
} else
{
oei = new ThisReference(loc);
oei.setEnclosingScope(naci.getEnclosingScope());
}
this.invokeConstructor(
naci, // locatable
naci.getEnclosingScope(), // scope
oei, // enclosingInstance
iClass, // targetClass
arguments2 // arguments
);
this.getCodeContext().popUninitializedVariableOperand();
this.getCodeContext().pushObjectOperand(iClass.getDescriptor());
} finally {
// Remove the synthetic constructor that was temporarily added. This is necessary because this NACI
// expression (and all other expressions) are sometimes compiled more than once (see "fakeCompile()"), and
// we'd end up with TWO synthetic constructors. See JANINO-143.
acd.constructors.remove(acd.constructors.size() - 1);
}
return iClass;
}
private IType
compileGet2(ParameterAccess pa) throws CompileException {
LocalVariable lv = this.getLocalVariable(pa.formalParameter);
this.load(pa, lv);
return lv.type;
}
private IClass
compileGet2(NewArray na) throws CompileException {
for (Rvalue dimExpr : na.dimExprs) {
IType dimType = this.compileGetValue(dimExpr);
if (dimType != IClass.INT && this.unaryNumericPromotion(
na, // locatable
dimType // type
) != IClass.INT) this.compileError("Invalid array size expression type", na.getLocation());
}
return this.newArray(
na, // locatable
na.dimExprs.length, // dimExprCount
na.dims, // dims
this.getType(na.type) // componentType
);
}
private IType
compileGet2(NewInitializedArray nia) throws CompileException {
IType at = this.getType2(nia);
this.compileGetValue(nia.arrayInitializer, at);
return at;
}
private void
compileGetValue(ArrayInitializer ai, IType arrayType) throws CompileException {
if (!(arrayType instanceof IClass) || !((IClass) arrayType).isArray()) {
this.compileError("Array initializer not allowed for non-array type \"" + arrayType.toString() + "\"");
}
IClass componentType = ((IClass) arrayType).getComponentType();
assert componentType != null;
this.consT(ai, Integer.valueOf(ai.values.length));
this.newArray(
ai, // locatable
1, // dimExprCount
0, // dims
componentType // componentType
);
for (int index = 0; index < ai.values.length; index++) {
ArrayInitializerOrRvalue componentInitializer = ai.values[index];
this.dup(componentInitializer);
this.consT(ai, index);
this.compile(componentInitializer, componentType);
this.arraystore(componentInitializer, componentType);
}
}
private IClass
compileGet2(Literal l) throws CompileException {
return this.consT(l, this.getConstantValue(l));
}
private IClass
compileGet2(SimpleConstant sl) throws CompileException {
return this.consT(sl, sl.value);
}
/**
* Convenience function that calls {@link #compileContext(Rvalue)} and {@link #compileGet(Rvalue)}.
*
* @return The type of the Rvalue
*/
private IType
compileGetValue(Rvalue rv) throws CompileException {
Object cv = this.getConstantValue(rv);
if (cv != UnitCompiler.NOT_CONSTANT) {
this.fakeCompile(rv); // To check that, e.g., "a" compiles in "true || a".
this.consT(rv, cv);
return this.getType(rv);
}
try {
this.compileContext(rv);
return this.compileGet(rv);
} catch (RuntimeException re) {
throw new InternalCompilerException(rv.getLocation(), "Compiling \"" + rv + "\"", re);
}
}
// -------------------- Rvalue.getConstantValue() -----------------
/**
* Special return value for the {@link #getConstantValue(Java.Rvalue)} method family indicating that the given
* {@link Java.Rvalue} does not evaluate to a constant value.
*/
public static final Object NOT_CONSTANT = IClass.NOT_CONSTANT;
/**
* Attempts to evaluate as a constant expression. The result is one of the following: {@link Boolean}, {@link
* Byte}, {@link Short}, {@link Integer}, {@link Long}, {@link Float}, {@link Double}, {@link Character}, {@link
* String}, {@code null} (representing the {@code null} literal.
*
* This method cannot be STATIC, because the constant value may refer to a constant declaration in this
* compilation unit.
*
*
* @return {@link #NOT_CONSTANT} iff the rvalue is not a constant value
*/
@Nullable public final Object
getConstantValue(ArrayInitializerOrRvalue rv) throws CompileException {
return rv.accept(new ArrayInitializerOrRvalueVisitor() {
@Override @Nullable public Object
visitArrayInitializer(ArrayInitializer ai) { return UnitCompiler.NOT_CONSTANT; }
@Override @Nullable public Object
visitRvalue(Rvalue rvalue) throws CompileException { return UnitCompiler.this.getConstantValue(rvalue); }
});
}
/**
* Attempts to evaluate as a constant expression. The result is one of the following: {@link Boolean}, {@link
* Byte}, {@link Short}, {@link Integer}, {@link Long}, {@link Float}, {@link Double}, {@link Character}, {@link
* String}, {@code null} (representing the {@code null} literal.
*
* This method cannot be STATIC, because the constant value may refer to a constant declaration in this
* compilation unit.
*
*
* @return {@link #NOT_CONSTANT} iff the rvalue is not a constant value
*/
@Nullable public final Object
getConstantValue(Rvalue rv) throws CompileException {
if (rv.constantValue != Rvalue.CONSTANT_VALUE_UNKNOWN) return rv.constantValue;
return (rv.constantValue = rv.accept(new RvalueVisitor() {
@Override @Nullable public Object
visitLvalue(Lvalue lv) throws CompileException {
return lv.accept(new LvalueVisitor() {
@Override @Nullable public Object visitAmbiguousName(AmbiguousName an) throws CompileException { return UnitCompiler.this.getConstantValue2(an); }
@Override @Nullable public Object visitArrayAccessExpression(ArrayAccessExpression aae) { return UnitCompiler.this.getConstantValue2(aae); }
@Override @Nullable public Object visitFieldAccess(FieldAccess fa) throws CompileException { return UnitCompiler.this.getConstantValue2(fa); }
@Override @Nullable public Object visitFieldAccessExpression(FieldAccessExpression fae) { return UnitCompiler.this.getConstantValue2(fae); }
@Override @Nullable public Object visitSuperclassFieldAccessExpression(SuperclassFieldAccessExpression scfae) { return UnitCompiler.this.getConstantValue2(scfae); }
@Override @Nullable public Object visitLocalVariableAccess(LocalVariableAccess lva) throws CompileException { return UnitCompiler.this.getConstantValue2(lva); }
@Override @Nullable public Object visitParenthesizedExpression(ParenthesizedExpression pe) throws CompileException { return UnitCompiler.this.getConstantValue2(pe); }
});
}
@Override @Nullable public Object visitArrayLength(ArrayLength al) { return UnitCompiler.this.getConstantValue2(al); }
@Override @Nullable public Object visitAssignment(Assignment a) { return UnitCompiler.this.getConstantValue2(a); }
@Override @Nullable public Object visitUnaryOperation(UnaryOperation uo) throws CompileException { return UnitCompiler.this.getConstantValue2(uo); }
@Override @Nullable public Object visitBinaryOperation(BinaryOperation bo) throws CompileException { return UnitCompiler.this.getConstantValue2(bo); }
@Override @Nullable public Object visitCast(Cast c) throws CompileException { return UnitCompiler.this.getConstantValue2(c); }
@Override @Nullable public Object visitClassLiteral(ClassLiteral cl) { return UnitCompiler.this.getConstantValue2(cl); }
@Override @Nullable public Object visitConditionalExpression(ConditionalExpression ce) throws CompileException { return UnitCompiler.this.getConstantValue2(ce); }
@Override @Nullable public Object visitCrement(Crement c) { return UnitCompiler.this.getConstantValue2(c); }
@Override @Nullable public Object visitInstanceof(Instanceof io) { return UnitCompiler.this.getConstantValue2(io); }
@Override @Nullable public Object visitMethodInvocation(MethodInvocation mi) { return UnitCompiler.this.getConstantValue2(mi); }
@Override @Nullable public Object visitSuperclassMethodInvocation(SuperclassMethodInvocation smi) { return UnitCompiler.this.getConstantValue2(smi); }
@Override @Nullable public Object visitIntegerLiteral(IntegerLiteral il) throws CompileException { return UnitCompiler.this.getConstantValue2(il); }
@Override @Nullable public Object visitFloatingPointLiteral(FloatingPointLiteral fpl) throws CompileException { return UnitCompiler.this.getConstantValue2(fpl); }
@Override @Nullable public Object visitBooleanLiteral(BooleanLiteral bl) { return UnitCompiler.this.getConstantValue2(bl); }
@Override @Nullable public Object visitCharacterLiteral(CharacterLiteral cl) throws CompileException { return UnitCompiler.this.getConstantValue2(cl); }
@Override @Nullable public Object visitStringLiteral(StringLiteral sl) throws CompileException { return UnitCompiler.this.getConstantValue2(sl); }
@Override @Nullable public Object visitNullLiteral(NullLiteral nl) { return UnitCompiler.this.getConstantValue2(nl); }
@Override @Nullable public Object visitSimpleConstant(SimpleConstant sl) { return UnitCompiler.this.getConstantValue2(sl); }
@Override @Nullable public Object visitNewAnonymousClassInstance(NewAnonymousClassInstance naci) { return UnitCompiler.this.getConstantValue2(naci); }
@Override @Nullable public Object visitNewArray(NewArray na) { return UnitCompiler.this.getConstantValue2(na); }
@Override @Nullable public Object visitNewInitializedArray(NewInitializedArray nia) { return UnitCompiler.this.getConstantValue2(nia); }
@Override @Nullable public Object visitNewClassInstance(NewClassInstance nci) { return UnitCompiler.this.getConstantValue2(nci); }
@Override @Nullable public Object visitParameterAccess(ParameterAccess pa) { return UnitCompiler.this.getConstantValue2(pa); }
@Override @Nullable public Object visitQualifiedThisReference(QualifiedThisReference qtr) { return UnitCompiler.this.getConstantValue2(qtr); }
@Override @Nullable public Object visitThisReference(ThisReference tr) { return UnitCompiler.this.getConstantValue2(tr); }
@Override @Nullable public Object visitLambdaExpression(LambdaExpression le) { return UnitCompiler.this.getConstantValue2(le); }
@Override @Nullable public Object visitMethodReference(MethodReference mr) { return UnitCompiler.this.getConstantValue2(mr); }
@Override @Nullable public Object visitInstanceCreationReference(ClassInstanceCreationReference cicr) { return UnitCompiler.this.getConstantValue2(cicr); }
@Override @Nullable public Object visitArrayCreationReference(ArrayCreationReference acr) { return UnitCompiler.this.getConstantValue2(acr); }
}));
}
@SuppressWarnings("static-method")
@Nullable private Object
getConstantValue2(Rvalue rv) { return UnitCompiler.NOT_CONSTANT; }
@Nullable private Object
getConstantValue2(AmbiguousName an) throws CompileException {
return this.getConstantValue(this.toRvalueOrCompileException(this.reclassify(an)));
}
@SuppressWarnings("static-method")
@Nullable private Object
getConstantValue2(FieldAccess fa) throws CompileException {
return fa.field.getConstantValue();
}
@Nullable private Object
getConstantValue2(UnaryOperation uo) throws CompileException {
if (uo.operator == "+") { // SUPPRESS CHECKSTYLE StringLiteralEquality
return this.getConstantValue(uo.operand);
}
if (uo.operator == "-") { // SUPPRESS CHECKSTYLE StringLiteralEquality
// Handle the super special cases "-2147483648" and "-9223372036854775808L" (JLS9 3.10.1).
if (uo.operand instanceof IntegerLiteral) {
String v = ((Literal) uo.operand).value;
if (UnitCompiler.TWO_E_31_INTEGER.matcher(v).matches()) return Integer.valueOf(Integer.MIN_VALUE);
if (UnitCompiler.TWO_E_63_LONG.matcher(v).matches()) return Long.valueOf(Long.MIN_VALUE);
}
Object cv = this.getConstantValue(uo.operand);
if (cv == UnitCompiler.NOT_CONSTANT) return UnitCompiler.NOT_CONSTANT;
// SUPPRESS CHECKSTYLE DOT__SELECTOR|L_PAREN__METH_INVOCATION:6
if (cv instanceof Byte) return Byte .valueOf((byte) -((Byte) cv));
if (cv instanceof Short) return Short .valueOf((short) -((Short) cv));
if (cv instanceof Integer) return Integer.valueOf( -((Integer) cv));
if (cv instanceof Long) return Long .valueOf( -((Long) cv));
if (cv instanceof Float) return Float .valueOf( -((Float) cv));
if (cv instanceof Double) return Double .valueOf( -((Double) cv));
return UnitCompiler.NOT_CONSTANT;
}
if (uo.operator == "!") { // SUPPRESS CHECKSTYLE StringLiteralEquality
Object cv = this.getConstantValue(uo.operand);
return (
cv == Boolean.TRUE ? Boolean.FALSE :
cv == Boolean.FALSE ? Boolean.TRUE :
UnitCompiler.NOT_CONSTANT
);
}
return UnitCompiler.NOT_CONSTANT;
}
/**
* 2147483648 is the special value that can not be stored in an INT, but its negated value
* (-2147483648) can.
*/
private static final Pattern
TWO_E_31_INTEGER = Pattern.compile("2_*1_*4_*7_*4_*8_*3_*6_*4_*8");
/**
* 9223372036854775808 is the special value that can not be stored in a LONG, but its negated
* value (-9223372036854775808) can.
*/
private static final Pattern
TWO_E_63_LONG = Pattern.compile("9_*2_*2_*3_*3_*7_*2_*0_*3_*6_*8_*5_*4_*7_*7_*5_*8_*0_*8[lL]");
@Nullable private Object
getConstantValue2(ConditionalExpression ce) throws CompileException {
Object lhsCv = this.getConstantValue(ce.lhs);
if (!(lhsCv instanceof Boolean)) return UnitCompiler.NOT_CONSTANT;
IType ceType = this.getType2(ce);
if (!UnitCompiler.isPrimitive(ceType) && ceType != this.iClassLoader.TYPE_java_lang_String) return UnitCompiler.NOT_CONSTANT;
if (((Boolean) lhsCv).booleanValue()) {
this.fakeCompile(ce.rhs);
return this.getConstantValue(ce.mhs);
} else {
this.fakeCompile(ce.mhs);
return this.getConstantValue(ce.rhs);
}
}
@Nullable private Object
getConstantValue2(BinaryOperation bo) throws CompileException {
// "|", "^", "&", "*", "/", "%", "+", "-", "==", "!=".
if (
// SUPPRESS CHECKSTYLE StringLiteralEquality:10
bo.operator == "|"
|| bo.operator == "^"
|| bo.operator == "&"
|| bo.operator == "*"
|| bo.operator == "/"
|| bo.operator == "%"
|| bo.operator == "+"
|| bo.operator == "-"
|| bo.operator == "=="
|| bo.operator == "!="
) {
// Unroll the constant operands.
List © 2015 - 2024 Weber Informatics LLC | Privacy Policy