com.ibm.wala.cast.java.loader.JavaSourceLoaderImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of com.ibm.wala.cast.java Show documentation
Show all versions of com.ibm.wala.cast.java Show documentation
T. J. Watson Libraries for Analysis
The newest version!
/*
* Copyright (c) 2002 - 2006 IBM Corporation.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*/
/*
* Created on Aug 22, 2005
*/
package com.ibm.wala.cast.java.loader;
import com.ibm.wala.cast.ir.ssa.AssignInstruction;
import com.ibm.wala.cast.ir.ssa.AstAssertInstruction;
import com.ibm.wala.cast.ir.ssa.AstEchoInstruction;
import com.ibm.wala.cast.ir.ssa.AstGlobalRead;
import com.ibm.wala.cast.ir.ssa.AstGlobalWrite;
import com.ibm.wala.cast.ir.ssa.AstIsDefinedInstruction;
import com.ibm.wala.cast.ir.ssa.AstLexicalAccess.Access;
import com.ibm.wala.cast.ir.ssa.AstLexicalRead;
import com.ibm.wala.cast.ir.ssa.AstLexicalWrite;
import com.ibm.wala.cast.ir.ssa.AstPropertyRead;
import com.ibm.wala.cast.ir.ssa.AstPropertyWrite;
import com.ibm.wala.cast.ir.ssa.AstYieldInstruction;
import com.ibm.wala.cast.ir.translator.AstTranslator;
import com.ibm.wala.cast.ir.translator.AstTranslator.AstLexicalInformation;
import com.ibm.wala.cast.java.ssa.AstJavaInstructionFactory;
import com.ibm.wala.cast.java.ssa.AstJavaInvokeInstruction;
import com.ibm.wala.cast.java.ssa.AstJavaNewEnclosingInstruction;
import com.ibm.wala.cast.java.ssa.EnclosingObjectReference;
import com.ibm.wala.cast.java.translator.SourceModuleTranslator;
import com.ibm.wala.cast.loader.AstClass;
import com.ibm.wala.cast.loader.AstField;
import com.ibm.wala.cast.loader.AstMethod;
import com.ibm.wala.cast.loader.AstMethod.DebuggingInformation;
import com.ibm.wala.cast.tree.CAstAnnotation;
import com.ibm.wala.cast.tree.CAstEntity;
import com.ibm.wala.cast.tree.CAstQualifier;
import com.ibm.wala.cast.tree.CAstSourcePositionMap;
import com.ibm.wala.cast.tree.CAstType;
import com.ibm.wala.cast.tree.CAstType.Function;
import com.ibm.wala.cfg.AbstractCFG;
import com.ibm.wala.cfg.IBasicBlock;
import com.ibm.wala.classLoader.CallSiteReference;
import com.ibm.wala.classLoader.ClassLoaderImpl;
import com.ibm.wala.classLoader.IClass;
import com.ibm.wala.classLoader.IClassLoader;
import com.ibm.wala.classLoader.JavaLanguage.JavaInstructionFactory;
import com.ibm.wala.classLoader.Language;
import com.ibm.wala.classLoader.Module;
import com.ibm.wala.classLoader.ModuleEntry;
import com.ibm.wala.classLoader.NewSiteReference;
import com.ibm.wala.core.util.strings.Atom;
import com.ibm.wala.ipa.cha.IClassHierarchy;
import com.ibm.wala.shrike.shrikeCT.AnnotationsReader.ConstantElementValue;
import com.ibm.wala.shrike.shrikeCT.AnnotationsReader.ElementValue;
import com.ibm.wala.shrike.shrikeCT.ClassConstants;
import com.ibm.wala.ssa.SSAInstruction;
import com.ibm.wala.ssa.SymbolTable;
import com.ibm.wala.types.ClassLoaderReference;
import com.ibm.wala.types.Descriptor;
import com.ibm.wala.types.FieldReference;
import com.ibm.wala.types.MethodReference;
import com.ibm.wala.types.Selector;
import com.ibm.wala.types.TypeName;
import com.ibm.wala.types.TypeReference;
import com.ibm.wala.types.annotations.Annotation;
import com.ibm.wala.util.collections.HashMapFactory;
import com.ibm.wala.util.collections.HashSetFactory;
import com.ibm.wala.util.debug.Assertions;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/** A {@link ClassLoaderImpl} that processes source file entities in the compile-time classpath. */
public abstract class JavaSourceLoaderImpl extends ClassLoaderImpl {
public Map fTypeMap = HashMapFactory.make();
/* BEGIN Custom change: Common superclass is optional */
private final boolean
existsCommonSuperclass; // extension to deal with X10 that has no common superclass
/* END Custom change: Common superclass is optional */
/**
* WALA representation of a Java class residing in a source file
*
* @author rfuhrer
*/
public class JavaClass extends AstClass {
protected final IClass enclosingClass;
protected final Collection superTypeNames;
private final Collection annotations;
public JavaClass(
String typeName,
Collection superTypeNames,
CAstSourcePositionMap.Position position,
Collection qualifiers,
JavaSourceLoaderImpl loader,
IClass enclosingClass,
Collection annotations) {
super(
position,
TypeName.string2TypeName(typeName),
loader,
(short) mapToInt(qualifiers),
new HashMap<>(),
new HashMap<>());
this.superTypeNames = superTypeNames;
this.enclosingClass = enclosingClass;
this.annotations = annotations;
}
@Override
public Collection getAnnotations() {
return annotations;
}
@Override
public IClassHierarchy getClassHierarchy() {
return cha;
}
@Override
public IClass getSuperclass() {
boolean excludedSupertype = false;
for (TypeName name : superTypeNames) {
IClass domoType = lookupClass(name);
if (domoType != null && !domoType.isInterface()) {
return domoType;
}
if (domoType == null
&& getClassHierarchy()
.getScope()
.getExclusions()
.contains(name.toString().substring(1))) {
excludedSupertype = true;
}
}
// The following test allows the root class to reside in source; without
// it, the assertion requires all classes represented by a JavaClass to
// have a superclass.
/* BEGIN Custom change: Common superclass is optional */
// Is no longer true in new X10 - no common object super class
if (existsCommonSuperclass
&& !getName().equals(JavaSourceLoaderImpl.this.getLanguage().getRootType().getName())
&& !excludedSupertype) {
/* END Custom change: Common superclass is optional */
Assertions.UNREACHABLE("Cannot find super class for " + this + " in " + superTypeNames);
}
if (excludedSupertype) {
System.err.println(
"Not tracking calls through excluded superclass of "
+ getName()
+ " extends "
+ superTypeNames);
}
return null;
}
@Override
public Collection getDirectInterfaces() {
List result = new ArrayList<>();
for (TypeName name : superTypeNames) {
IClass domoType = lookupClass(name);
if (domoType != null && domoType.isInterface()) {
result.add(domoType);
}
if (domoType == null
&& !getClassHierarchy()
.getScope()
.getExclusions()
.contains(name.toString().substring(1))) {
assert false : "Failed to find non-excluded interface: " + name;
}
}
return result;
}
protected void addMethod(
CAstEntity methodEntity,
IClass owner,
AbstractCFG cfg,
SymbolTable symtab,
boolean hasCatchBlock,
Map, TypeReference[]> caughtTypes,
boolean hasMonitorOp,
AstLexicalInformation lexicalInfo,
DebuggingInformation debugInfo) {
declaredMethods.put(
Util.methodEntityToSelector(methodEntity),
new ConcreteJavaMethod(
methodEntity,
owner,
cfg,
symtab,
hasCatchBlock,
caughtTypes,
hasMonitorOp,
lexicalInfo,
debugInfo));
}
protected void addMethod(CAstEntity methodEntity, IClass owner) {
declaredMethods.put(
Util.methodEntityToSelector(methodEntity), new AbstractJavaMethod(methodEntity, owner));
}
protected void addField(CAstEntity fieldEntity) {
declaredFields.put(
Util.fieldEntityToAtom(fieldEntity),
new JavaField(
fieldEntity,
JavaSourceLoaderImpl.this,
this,
JavaSourceLoaderImpl.this.getAnnotations(fieldEntity)));
}
public IClass getEnclosingClass() {
return enclosingClass;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder(" getAnnotations(CAstEntity e) {
Collection annotations = e.getAnnotations();
if (annotations == null || annotations.isEmpty()) {
return null;
} else {
Collection result = HashSetFactory.make();
for (CAstAnnotation ca : annotations) {
TypeName walaTypeName = toWALATypeName(ca.getType());
TypeReference ref = TypeReference.findOrCreate(getReference(), walaTypeName);
if (ca.getArguments() == null || ca.getArguments().isEmpty()) {
result.add(Annotation.make(ref));
} else {
Map args = HashMapFactory.make();
for (Map.Entry a : ca.getArguments().entrySet()) {
args.put(a.getKey(), new ConstantElementValue(a.getValue()));
}
result.add(Annotation.makeWithNamed(ref, args));
}
}
return result;
}
}
/**
* WALA representation of a field on a Java type that resides in a source file
*
* @author rfuhrer
*/
protected static class JavaField extends AstField {
protected JavaField(
CAstEntity fieldEntity,
IClassLoader loader,
IClass declaringClass,
Collection annotations) {
super(
FieldReference.findOrCreate(
declaringClass.getReference(),
Atom.findOrCreateUnicodeAtom(fieldEntity.getName()),
TypeReference.findOrCreate(
loader.getReference(),
TypeName.string2TypeName(fieldEntity.getType().getName()))),
fieldEntity.getQualifiers(),
declaringClass,
declaringClass.getClassHierarchy(),
annotations);
}
}
/**
* Generic DOMO representation of a method on a Java type that resides in a source file
*
* @author rfuhrer
*/
protected abstract class JavaEntityMethod extends AstMethod {
private final TypeReference[] parameterTypes;
private final TypeReference[] exceptionTypes;
public JavaEntityMethod(
CAstEntity methodEntity,
IClass owner,
AbstractCFG cfg,
SymbolTable symtab,
boolean hasCatchBlock,
Map, TypeReference[]> caughtTypes,
boolean hasMonitorOp,
AstLexicalInformation lexicalInfo,
DebuggingInformation debugInfo) {
super(
owner,
methodEntity.getQualifiers(),
cfg,
symtab,
MethodReference.findOrCreate(
owner.getReference(), Util.methodEntityToSelector(methodEntity)),
hasCatchBlock,
caughtTypes,
hasMonitorOp,
lexicalInfo,
debugInfo,
JavaSourceLoaderImpl.this.getAnnotations(methodEntity));
this.parameterTypes = computeParameterTypes(methodEntity);
this.exceptionTypes = computeExceptionTypes(methodEntity);
}
public JavaEntityMethod(CAstEntity methodEntity, IClass owner) {
super(
owner,
methodEntity.getQualifiers(),
MethodReference.findOrCreate(
owner.getReference(), Util.methodEntityToSelector(methodEntity)),
JavaSourceLoaderImpl.this.getAnnotations(methodEntity));
this.parameterTypes = computeParameterTypes(methodEntity);
this.exceptionTypes = computeExceptionTypes(methodEntity);
}
public int getMaxLocals() {
Assertions.UNREACHABLE("AbstractJavaMethod.getMaxLocals() called");
return 0;
}
public int getMaxStackHeight() {
Assertions.UNREACHABLE("AbstractJavaMethod.getMaxStackHeight() called");
return 0;
}
@Override
public TypeReference getParameterType(int i) {
return parameterTypes[i];
}
protected TypeReference[] computeParameterTypes(CAstEntity methodEntity) {
TypeReference[] types;
CAstType.Function type = (Function) methodEntity.getType();
int argCount = type.getArgumentTypes().size();
if (isStatic()) {
types = new TypeReference[argCount];
for (int i = 0; i < argCount; i++) {
types[i] =
TypeReference.findOrCreate(
JavaSourceLoaderImpl.this.getReference(),
type.getArgumentTypes().get(i).getName());
}
} else {
types = new TypeReference[argCount + 1];
types[0] = cls.getReference();
for (int i = 0; i < argCount; i++) {
types[i + 1] =
TypeReference.findOrCreate(
JavaSourceLoaderImpl.this.getReference(),
type.getArgumentTypes().get(i).getName());
}
}
return types;
}
@Override
public TypeReference[] getDeclaredExceptions() {
return exceptionTypes;
}
protected TypeReference[] computeExceptionTypes(CAstEntity methodEntity) {
CAstType.Function fType = (Function) methodEntity.getType();
Collection exceptionTypes = fType.getExceptionTypes();
TypeReference[] result = new TypeReference[exceptionTypes.size()];
int i = 0;
for (CAstType type : exceptionTypes) {
result[i] =
TypeReference.findOrCreate(JavaSourceLoaderImpl.this.getReference(), type.getName());
++i;
}
return result;
}
@Override
public String toString() {
return "';
}
}
/**
* DOMO representation of an abstract (body-less) method on a Java type that resides in a source
* file
*
* @author rfuhrer
*/
protected class AbstractJavaMethod extends JavaEntityMethod {
public AbstractJavaMethod(CAstEntity methodEntity, IClass owner) {
super(methodEntity, owner);
}
@Override
public String getLocalVariableName(int bcIndex, int localNumber) {
Assertions.UNREACHABLE("AbstractJavaMethod.getLocalVariableName() called");
return null;
}
@Override
public boolean hasLocalVariableTable() {
Assertions.UNREACHABLE("AbstractJavaMethod.hasLocalVariableTable() called");
return false;
}
@Override
public LexicalParent[] getParents() {
return new LexicalParent[0];
}
@Override
public IClassHierarchy getClassHierarchy() {
return cha;
}
}
/**
* DOMO representation of a concrete method (which has a body) on a Java type that resides in a
* source file
*
* @author rfuhrer
*/
public class ConcreteJavaMethod extends JavaEntityMethod {
public ConcreteJavaMethod(
CAstEntity methodEntity,
IClass owner,
AbstractCFG cfg,
SymbolTable symtab,
boolean hasCatchBlock,
Map, TypeReference[]> caughtTypes,
boolean hasMonitorOp,
AstLexicalInformation lexicalInfo,
DebuggingInformation debugInfo) {
super(
methodEntity,
owner,
cfg,
symtab,
hasCatchBlock,
caughtTypes,
hasMonitorOp,
lexicalInfo,
debugInfo);
}
@Override
public IClassHierarchy getClassHierarchy() {
return cha;
}
@Override
public String getLocalVariableName(int bcIndex, int localNumber) {
return null;
}
@Override
public boolean hasLocalVariableTable() {
return false;
}
@Override
public LexicalParent[] getParents() {
if (AstTranslator.DEBUG_LEXICAL) {
System.err.println(("resolving parents of " + this));
}
if (lexicalInfo() == null) {
if (AstTranslator.DEBUG_LEXICAL) System.err.println("no info");
return new LexicalParent[0];
}
final String[] parents = lexicalInfo().getScopingParents();
if (parents == null) {
if (AstTranslator.DEBUG_LEXICAL) System.err.println("no parents");
return new LexicalParent[0];
}
LexicalParent result[] = new LexicalParent[parents.length];
for (int i = 0; i < parents.length; i++) {
int lastLeftParen = parents[i].lastIndexOf('(');
int lastQ = parents[i].lastIndexOf('/', lastLeftParen);
String typeName = parents[i].substring(0, lastQ);
final IClass cls = lookupClass(TypeName.string2TypeName(typeName));
String sig = parents[i].substring(lastQ);
int nameEnd = sig.indexOf('(');
String nameStr = sig.substring(1, nameEnd);
Atom name = Atom.findOrCreateUnicodeAtom(nameStr);
String descStr = sig.substring(nameEnd);
Descriptor desc = Descriptor.findOrCreateUTF8(Language.JAVA, descStr);
final Selector sel = new Selector(name, desc);
if (AstTranslator.DEBUG_LEXICAL)
System.err.println(("get " + typeName + ", " + nameStr + ", " + descStr));
final int hack = i;
result[i] =
new LexicalParent() {
@Override
public String getName() {
return parents[hack];
}
@Override
public AstMethod getMethod() {
return (AstMethod) cls.getMethod(sel);
}
};
if (AstTranslator.DEBUG_LEXICAL)
System.err.println(("parent " + result[i].getName() + " is " + result[i].getMethod()));
}
return result;
}
}
public static int mapToInt(Collection qualifiers) {
int result = 0;
for (CAstQualifier q : qualifiers) {
if (q == CAstQualifier.PUBLIC) result |= ClassConstants.ACC_PUBLIC;
if (q == CAstQualifier.PROTECTED) result |= ClassConstants.ACC_PROTECTED;
if (q == CAstQualifier.PRIVATE) result |= ClassConstants.ACC_PRIVATE;
if (q == CAstQualifier.STATIC) result |= ClassConstants.ACC_STATIC;
if (q == CAstQualifier.FINAL) result |= ClassConstants.ACC_FINAL;
if (q == CAstQualifier.SYNCHRONIZED) result |= ClassConstants.ACC_SYNCHRONIZED;
if (q == CAstQualifier.TRANSIENT) result |= ClassConstants.ACC_TRANSIENT;
if (q == CAstQualifier.NATIVE) result |= ClassConstants.ACC_NATIVE;
if (q == CAstQualifier.INTERFACE) result |= ClassConstants.ACC_INTERFACE;
if (q == CAstQualifier.ABSTRACT) result |= ClassConstants.ACC_ABSTRACT;
if (q == CAstQualifier.VOLATILE) result |= ClassConstants.ACC_VOLATILE;
if (q == CAstQualifier.STRICTFP) result |= ClassConstants.ACC_STRICT;
}
return result;
}
/* BEGIN Custom change: Common superclass is optional */
public JavaSourceLoaderImpl(
boolean existsCommonSuperClass,
ClassLoaderReference loaderRef,
IClassLoader parent,
IClassHierarchy cha) {
super(
loaderRef,
cha.getScope().getArrayClassLoader(),
parent,
cha.getScope().getExclusions(),
cha);
this.existsCommonSuperclass = existsCommonSuperClass;
}
public JavaSourceLoaderImpl(
ClassLoaderReference loaderRef, IClassLoader parent, IClassHierarchy cha) {
// standard case: we have a common super class
this(true, loaderRef, parent, cha);
}
/* END Custom change: Common superclass is optional */
public IClassHierarchy getClassHierarchy() {
return cha;
}
@Override
protected void loadAllSources(Set modules) {
getTranslator().loadAllSources(modules);
}
protected abstract SourceModuleTranslator getTranslator();
/* BEGIN Custom change: Optional deletion of fTypeMap */
public static volatile boolean deleteTypeMapAfterInit = true;
/* END Custom change: Optional deletion of fTypeMap */
@Override
public void init(List modules) throws IOException {
super.init(modules);
/* BEGIN Custom change: Optional deletion of fTypeMap */
if (deleteTypeMapAfterInit) {
fTypeMap = null;
}
/* END Custom change: Optional deletion of fTypeMap */
}
public void defineFunction(
CAstEntity n,
IClass owner,
AbstractCFG cfg,
SymbolTable symtab,
boolean hasCatchBlock,
Map, TypeReference[]> caughtTypes,
boolean hasMonitorOp,
AstLexicalInformation lexicalInfo,
DebuggingInformation debugInfo) {
((JavaClass) owner)
.addMethod(
n,
owner,
cfg,
symtab,
hasCatchBlock,
caughtTypes,
hasMonitorOp,
lexicalInfo,
debugInfo);
}
public void defineAbstractFunction(CAstEntity n, IClass owner) {
((JavaClass) owner).addMethod(n, owner);
}
public void defineField(CAstEntity n, IClass owner) {
((JavaClass) owner).addField(n);
}
protected static TypeName toWALATypeName(CAstType type) {
return TypeName.string2TypeName(type.getName());
}
public IClass defineType(CAstEntity type, String typeName, CAstEntity owner) {
Collection superTypeNames = new ArrayList<>();
for (CAstType superType : type.getType().getSupertypes()) {
superTypeNames.add(toWALATypeName(superType));
}
JavaClass javaClass =
new JavaClass(
typeName,
superTypeNames,
type.getPosition(),
type.getQualifiers(),
this,
(owner != null) ? (JavaClass) fTypeMap.get(owner) : (JavaClass) null,
getAnnotations(type));
if (getParent().lookupClass(javaClass.getName()) != null) {
return null;
}
fTypeMap.put(type, javaClass);
loadedClasses.put(javaClass.getName(), javaClass);
return javaClass;
}
@Override
public String toString() {
return "Java Source Loader (classes " + loadedClasses.values() + ')';
}
public static class InstructionFactory extends JavaInstructionFactory
implements AstJavaInstructionFactory {
@Override
public com.ibm.wala.cast.java.ssa.EnclosingObjectReference EnclosingObjectReference(
int iindex, int lval, TypeReference type) {
return new EnclosingObjectReference(iindex, lval, type);
}
@Override
public AstJavaNewEnclosingInstruction JavaNewEnclosingInstruction(
int iindex, int result, NewSiteReference site, int enclosing) {
return new AstJavaNewEnclosingInstruction(iindex, result, site, enclosing);
}
@Override
public AstJavaInvokeInstruction JavaInvokeInstruction(
int iindex, int result[], int[] params, int exception, CallSiteReference site) {
return result == null
? new AstJavaInvokeInstruction(iindex, params, exception, site)
: new AstJavaInvokeInstruction(iindex, result[0], params, exception, site);
}
@Override
public AstAssertInstruction AssertInstruction(
int iindex, int value, boolean fromSpecification) {
return new AstAssertInstruction(iindex, value, fromSpecification);
}
@Override
public com.ibm.wala.cast.ir.ssa.AssignInstruction AssignInstruction(
int iindex, int result, int val) {
return new AssignInstruction(iindex, result, val);
}
@Override
public com.ibm.wala.cast.ir.ssa.EachElementGetInstruction EachElementGetInstruction(
int iindex, int value, int objectRef, int propRef) {
throw new UnsupportedOperationException();
}
@Override
public com.ibm.wala.cast.ir.ssa.EachElementHasNextInstruction EachElementHasNextInstruction(
int iindex, int value, int objectRef, int propRef) {
throw new UnsupportedOperationException();
}
@Override
public AstEchoInstruction EchoInstruction(int iindex, int[] rvals) {
throw new UnsupportedOperationException();
}
@Override
public AstGlobalRead GlobalRead(int iindex, int lhs, FieldReference global) {
throw new UnsupportedOperationException();
}
@Override
public AstGlobalWrite GlobalWrite(int iindex, FieldReference global, int rhs) {
throw new UnsupportedOperationException();
}
@Override
public AstIsDefinedInstruction IsDefinedInstruction(
int iindex, int lval, int rval, int fieldVal, FieldReference fieldRef) {
throw new UnsupportedOperationException();
}
@Override
public AstIsDefinedInstruction IsDefinedInstruction(
int iindex, int lval, int rval, FieldReference fieldRef) {
throw new UnsupportedOperationException();
}
@Override
public AstIsDefinedInstruction IsDefinedInstruction(
int iindex, int lval, int rval, int fieldVal) {
return new AstIsDefinedInstruction(iindex, lval, rval, fieldVal);
}
@Override
public AstIsDefinedInstruction IsDefinedInstruction(int iindex, int lval, int rval) {
throw new UnsupportedOperationException();
}
@Override
public AstLexicalRead LexicalRead(int iindex, Access[] accesses) {
return new AstLexicalRead(iindex, accesses);
}
@Override
public AstLexicalRead LexicalRead(int iindex, Access access) {
return new AstLexicalRead(iindex, access);
}
@Override
public AstLexicalRead LexicalRead(
int iindex, int lhs, String definer, String globalName, TypeReference type) {
return new AstLexicalRead(iindex, lhs, definer, globalName, type);
}
@Override
public AstLexicalWrite LexicalWrite(int iindex, Access[] accesses) {
return new AstLexicalWrite(iindex, accesses);
}
@Override
public AstLexicalWrite LexicalWrite(int iindex, Access access) {
return new AstLexicalWrite(iindex, access);
}
@Override
public AstLexicalWrite LexicalWrite(
int iindex, String definer, String globalName, TypeReference type, int rhs) {
return new AstLexicalWrite(iindex, definer, globalName, type, rhs);
}
@Override
public AstYieldInstruction YieldInstruction(int iindex, int[] rvals) {
return new AstYieldInstruction(iindex, rvals);
}
@Override
public AstPropertyRead PropertyRead(int iindex, int result, int objectRef, int memberRef) {
assert false;
return null;
}
@Override
public AstPropertyWrite PropertyWrite(int iindex, int objectRef, int memberRef, int value) {
assert false;
return null;
}
}
protected static final InstructionFactory insts = new InstructionFactory();
@Override
public InstructionFactory getInstructionFactory() {
return insts;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy