J2JS Package Documentation

+ * For details please refer to the plugin description. + * + * @author Wolfgang Kuehn + */ +public class J2JSCompiler { + + public static J2JSCompiler compiler; + + public static int errorCount = 0; + + private File basedir; + private File cacheFile; + + List assemblies = new ArrayList(); + + private List classpath = new ArrayList(); + + public FileManager fileManager; + + public boolean optimize = true; + public boolean failOnError = true; + private boolean compression = true; + + private String singleEntryPoint; + private String targetPlatform; + public int reductionLevel = 5; + + private int junkSizeInKiloBytes = Integer.MAX_VALUE; + + private boolean generateLineNumbers = false; + + public int compileCount = 0; + public JavaScriptGenerator generator; + + private Log logger; + + // Begin main + public static void main(String argv[]) throws Exception { + if ( argv == null || argv.length != 4 ) { + StringBuffer sb = new StringBuffer(); + sb.append("Usage: java "); + sb.append(J2JSCompiler.class.getName()); + sb.append(" "); + System.out.print(sb.toString()); + return; + } + + File basedir = new File(argv[0]); + String classpathElements = argv[1]; + String entryPointClassName = argv[2]; + + Assembly assembly = new Assembly(); + assembly.setEntryPointClassName(entryPointClassName); + + assembly.setTargetLocation(new File(basedir, argv[3])); + + J2JSCompiler compiler = new J2JSCompiler(); + compiler.setBasedir(basedir); + compiler.addClasspathElements(classpathElements); + compiler.addAssembly(assembly); + compiler.setGenerateLineNumbers(true); + compiler.execute(); + } + // End main + + /** + * Create new compiler with the current directory as basedir. + */ + public J2JSCompiler() { + setBasedir(new File(System.getProperty("user.dir"))); + setTargetPlatform("web"); + } + + public void execute() throws Exception { + if (logger == null) { + setLogger(new Log()); + } + + for (Assembly assembly : assemblies) { + execute(assembly); + } + } + + private boolean isMavenExecution() { + return System.getProperty("localRepository") != null; + } + + public void execute(Assembly assembly) throws Exception { + J2JSCompiler.compiler = this; + + logger.info("Entry point is " + assembly.getEntryPointClassName() + "#main(java.lang.String[])void"); + + if (classpath == null) { + throw new RuntimeException("Field classPath must be set"); + } + + if (assembly.getEntryPointClassName() == null) { + throw new RuntimeException("Field assembly.entryPointClassName must be set"); + } + + if (cacheFile == null) { + setCacheFile(new File(basedir, "target/j2js.cache")); + } + + if (assembly.getTargetLocation() == null) { + throw new RuntimeException("Field assembly.targetLocation must be set"); + //assembly.setTargetLocation(new File(basedir, "target/classes/assemblies/" + assembly.getEntryPointClassName().replaceAll("\\.", "/"))); + } + + logger.info("Creating assembly " + assembly.getTargetLocation()); + + fileManager = new FileManager(classpath); + Project project = Project.createSingleton(getCacheFile()); + assembly.setProject(project); + generator = new JavaScriptGenerator(project); + + errorCount = 0; + + assembly.addEntryPoint(assembly.getEntryPointClassName() + "#main(java.lang.String[])void"); + + for (String memberSignature : assembly.entryPoints) { + assembly.taint(memberSignature); + } + + long startTime = System.currentTimeMillis(); + + // Used by the JavaScript JVM. The static code analyser would miss these. + + String[] signatures = Utils.getProperty("j2js.preTaintedSignatures").split(";"); + for (int i=0; i 0) { + logger.error("There " + timesName("was|were", errorCount, "error|errors") + "."); + } + } + + private String timesName(String verb, int count, String noun) { + String[] verbs = verb.split("\\|"); + String[] nouns = noun.split("\\|"); + int index = (count==1?0:1); + return verbs[index] + " " + count + " " + nouns[index]; + } + + public void setCompression(boolean isCompression) { + this.compression = isCompression; + } + + public boolean isCompression() { + return compression; + } + + + /** + * For debugging. Internal use only. + */ + public void setSingleEntryPoint(String signature) { + singleEntryPoint = signature; + } + + /** + * @see #setSingleEntryPoint(String) + */ + public String getSingleEntryPoint() { + return singleEntryPoint; + } + + /** + * Sets one of the target platforms "web" or "javascript". + * + * @param targetPlatform optional; default is "web" + */ + public void setTargetPlatform(String targetPlatform) { + targetPlatform = targetPlatform.toLowerCase(); + if ("web".equals(targetPlatform) || "javascript".equals(targetPlatform)) { + this.targetPlatform = targetPlatform; + } else { + throw new IllegalArgumentException("Target platform must be web or javascript"); + } + } + + /** + * @see #setTargetPlatform(String) + */ + public String getTargetPlatform() { + return targetPlatform; + } + + public List getClasspath() { + return classpath; + } + + /** + * @param classpathElements (optional) additional class path elements + */ + public void addClasspathElements(List classpathElements) { + classpath.addAll(classpathElements); + } + + /** + * @param classpathElement (optional) additional class path element + */ + public void addClasspathElement(File classpathElement) { + classpath.add(classpathElement); + } + + /** + * Semicolon- or whitespace-separated list of class path elements. + * + * @param classPathElements (optional) additional class path elements + * @see #setClasspathElements(List) + */ + public void addClasspathElements(String classPathElements) { + String[] array = classPathElements.split("(;|,)"); + for (String path : array) { + path = path.trim(); + if (path.length() > 0) { + addClasspathElement(Utils.resolve(basedir, path)); + } + } + } + + public void setClasspathElements(List classpathElements) { + for (Object part : classpathElements) { + addClasspathElements((String) part); + } + } + + public void setFailOnError(boolean flag) { + failOnError = flag; + } + + public boolean isFailOnError() { + return failOnError; + } + + public File getCacheFile() { + return cacheFile; + } + + public void setCacheFile(File theCacheFile) { + cacheFile = theCacheFile; + } + + public List getAssemblies() { + return assemblies; + } + + public void setAssemlies(List assemblies) { + this.assemblies = assemblies; + } + + public void setGenerateLineNumbers(boolean theGenerateLineNumbers) { + generateLineNumbers = theGenerateLineNumbers; + } + + public boolean isGenerateLineNumbers() { + return generateLineNumbers; + } + + public void setJunkSizeInKiloBytes(int junkSizeInKiloBytes) { + if (junkSizeInKiloBytes < 1) { + throw new RuntimeException("Junk size must be greater than zero."); + } + this.junkSizeInKiloBytes = junkSizeInKiloBytes; + } + + public int getJunkSizeInKiloBytes() { + return junkSizeInKiloBytes; + } + + /** + * @return Returns the logger. + */ + public Log getLogger() { + return logger; + } + + /** + * Sets the logger. + */ + public void setLogger(Log logger) { + this.logger = logger; + Log.logger = logger; + } + + public void setBasedir(File basedir) { + this.basedir = basedir; + } + + public File getBasedir() { + return basedir; + } + + public void addAssembly(Assembly assembly) { + assemblies.add(assembly); + } + +} diff --git a/src/main/java/com/j2js/LineNumberCursor.java b/src/main/java/com/j2js/LineNumberCursor.java new file mode 100644 index 0000000..465736a --- /dev/null +++ b/src/main/java/com/j2js/LineNumberCursor.java @@ -0,0 +1,76 @@ +package com.j2js; + +import java.util.Arrays; +import java.util.Comparator; + +import org.apache.bcel.classfile.Code; +import org.apache.bcel.classfile.LineNumber; +import org.apache.bcel.classfile.LineNumberTable; + +import com.j2js.dom.ASTNode; + +public class LineNumberCursor { + + private class LineNumberComparator implements Comparator { + + public int compare(LineNumber arg0, LineNumber arg1) { + return arg0.getStartPC() - arg1.getStartPC(); + } + + } + + private LineNumber[] lineNumbers = null; + private int index = 0; + private int markedLineNumber = -1; + private int length; + + public LineNumberCursor(Code code) { + if (code == null) return; + LineNumberTable table = code.getLineNumberTable(); + if (table == null) return; + lineNumbers = table.getLineNumberTable(); + length = lineNumbers.length; + // TODO: Is table already ordered? + Arrays.sort(lineNumbers, new LineNumberComparator()); + } + + public boolean hasLineNumbers() { + return lineNumbers != null; + } + + public int getLineNumber(ASTNode node) { + if (!hasLineNumbers()) return -1; + + while (node.getBeginIndex() == Integer.MAX_VALUE && node.getPreviousSibling() != null) { + node = node.getPreviousSibling(); + } + + int pc = node.getBeginIndex(); + L: if (pc > lineNumbers[index].getStartPC()) { + do { + if (index+1 == length) break L; + index ++; + } while (pc >= lineNumbers[index].getStartPC()); + index --; + } else if (pc < lineNumbers[index].getStartPC()) { + do { + if (index == 0) break L; + index --; + } while (pc <= lineNumbers[index].getStartPC()); + index ++; + } + + return lineNumbers[index].getLineNumber(); + } + + public int getAndMarkLineNumber(ASTNode node) { + if (!hasLineNumbers()) return -1; + + int lineNumber = getLineNumber(node); + if (lineNumber == markedLineNumber) return -1; + + markedLineNumber = lineNumber; + return lineNumber; + } + +} diff --git a/src/main/java/com/j2js/Log.java b/src/main/java/com/j2js/Log.java new file mode 100644 index 0000000..4d54886 --- /dev/null +++ b/src/main/java/com/j2js/Log.java @@ -0,0 +1,132 @@ +/* + * Copyright 2005 by Wolfgang Kuehn + * Created on 04.10.2005 + */ +package com.j2js; + + +/** + * @author wolfgang + */ +public class Log { + + public static Log logger; + + public static Log getLogger() { + return logger; + } + + private int state = INFO; + + /** + * @return Returns the state. + */ + public int getState() { + return state; + } + + /** + * @param state The state to set. + */ + public void setState(int state) { + this.state = state; + } + + public static final int DEBUG = 3; + public static final int INFO = 2; + public static final int WARN = 1; + public static final int ERROR = 0; + + public void debug(CharSequence arg0, Throwable arg1) { + if (isDebugEnabled()) { + System.out.println("[DEBUG] " + arg0); + arg1.printStackTrace(); + } + } + + public void debug(CharSequence arg0) { + if (isDebugEnabled()) { + System.out.println("[DEBUG] " + arg0); + } + } + + public void debug(Throwable arg0) { + if (isDebugEnabled()) { + arg0.printStackTrace(); + } + } + + public void error(CharSequence arg0, Throwable arg1) { + if (isErrorEnabled()) { + System.out.println("[ERROR] " + arg0); + arg1.printStackTrace(); + } + } + + public void error(CharSequence arg0) { + if (isErrorEnabled()) { + System.out.println("[ERROR] " + arg0); + } + } + + public void error(Throwable arg0) { + if (isErrorEnabled()) { + arg0.printStackTrace(); + } + } + + public void info(CharSequence arg0, Throwable arg1) { + if (isInfoEnabled()) { + System.out.println("[INFO] " + arg0); + arg1.printStackTrace(); + } + } + + public void info(CharSequence arg0) { + if (isInfoEnabled()) { + System.out.println("[INFO] " + arg0); + } + } + + public void info(Throwable arg0) { + if (isInfoEnabled()) { + arg0.printStackTrace(); + } + } + + public boolean isDebugEnabled() { + return state >= DEBUG; + } + + public boolean isErrorEnabled() { + return state >= ERROR; + } + + public boolean isInfoEnabled() { + return state >= INFO; + } + + public boolean isWarnEnabled() { + return state >= WARN; + } + + public void warn(CharSequence arg0, Throwable arg1) { + if (isWarnEnabled()) { + System.out.println("[WARNING] " + arg0); + arg1.printStackTrace(); + } + } + + public void warn(CharSequence arg0) { + if (isWarnEnabled()) { + System.out.println("[WARNING] " + arg0); + } + } + + public void warn(Throwable arg0) { + if (isWarnEnabled()) { + arg0.printStackTrace(); + } + } + +} diff --git a/src/main/java/com/j2js/OperandState.java b/src/main/java/com/j2js/OperandState.java new file mode 100644 index 0000000..8e248ed --- /dev/null +++ b/src/main/java/com/j2js/OperandState.java @@ -0,0 +1,38 @@ +/* + * Created on 20.10.2004 + * + * To change the template for this generated file go to + * Window - Preferences - Java - Code Generation - Code and Comments + */ +package com.j2js; + +import com.j2js.dom.ASTNode; + +/** + * @author kuehn + * + * To change the template for this generated type comment go to + * Window - Preferences - Java - Code Generation - Code and Comments + */ +public class OperandState { + + int code; + int beginIndex; + int endIndex; + + ASTNode stmt; + + OperandState(int theCode) { + code = theCode; + } + + OperandState(int theCode, int theBeginIndex, ASTNode theStmt) { + code = theCode; + beginIndex = theBeginIndex; + stmt = theStmt; + } + + public String toString() { + return "State: " + code + " " + stmt; + } +} diff --git a/src/main/java/com/j2js/Optimizer.java b/src/main/java/com/j2js/Optimizer.java new file mode 100644 index 0000000..b34ec3e --- /dev/null +++ b/src/main/java/com/j2js/Optimizer.java @@ -0,0 +1,324 @@ +package com.j2js; + +import java.util.Iterator; +import java.util.List; + +import org.apache.bcel.generic.Type; + +import com.j2js.dom.ASTNode; +import com.j2js.dom.Assignable; +import com.j2js.dom.Assignment; +import com.j2js.dom.Block; +import com.j2js.dom.Expression; +import com.j2js.dom.FieldAccess; +import com.j2js.dom.InfixExpression; +import com.j2js.dom.MethodDeclaration; +import com.j2js.dom.NumberLiteral; +import com.j2js.dom.PStarExpression; +import com.j2js.dom.PostfixExpression; +import com.j2js.dom.PrefixExpression; +import com.j2js.dom.VariableBinding; +import com.j2js.dom.VariableDeclaration; + +public class Optimizer { + + private MethodDeclaration methodDecl; + private List tempDecls; + + public Optimizer(MethodDeclaration theMethodDecl, List theTempDecls) { + methodDecl = theMethodDecl; + tempDecls = theTempDecls; + } + + public static Expression negate(Expression expr) { + PrefixExpression pe = new PrefixExpression(); + pe.setOperator(PrefixExpression.NOT); + pe.setOperand(expr); + return pe; + } + + /** + * Simplifies the (possibly negated) expression. + */ + public static Expression simplifyBooleanExpression(Expression expr, boolean negate) { + if (expr instanceof PrefixExpression) { + PrefixExpression pe = (PrefixExpression) expr; + if (pe.getOperator() != PrefixExpression.NOT) return expr; + return simplifyBooleanExpression((Expression) pe.getOperand(), !negate); + } + + if (expr instanceof InfixExpression && expr.getTypeBinding() == Type.BOOLEAN) { + InfixExpression in = (InfixExpression) expr; + InfixExpression.Operator op = in.getOperator(); + if (negate) { + op = op.getComplement(); + if (op != InfixExpression.Operator.CONDITIONAL_AND && op != InfixExpression.Operator.CONDITIONAL_OR) + negate = false; + } + InfixExpression out = new InfixExpression(op); + out.widen(in); + out.setOperands(simplifyBooleanExpression(in.getLeftOperand(), negate), simplifyBooleanExpression(in.getRightOperand(), negate)); + return out; + } + + if (negate) { + PrefixExpression pe = new PrefixExpression(); + pe.setOperator(PrefixExpression.NOT); + pe.setOperand(expr); + return pe; + } + + return expr; + } + + private boolean representSameAssignables(Assignable a, Assignable b) { + if (!(a instanceof FieldAccess && b instanceof FieldAccess)) return false; + FieldAccess faa = (FieldAccess) a; + FieldAccess fab = (FieldAccess) b; + if (!faa.getName().equals(fab.getName())) return false; + if (faa.getExpression() instanceof VariableBinding && fab.getExpression() instanceof VariableBinding ) { + VariableBinding vba = (VariableBinding) faa.getExpression(); + VariableBinding vbb = (VariableBinding) fab.getExpression(); + return vba.getVariableDeclaration() == vbb.getVariableDeclaration(); + } + return false; + } + + /** + * Reduces occurences of + * temp = x; + * y = temp; + * to + * y = x; + */ +// private ASTNode bar1(ASTNode child, ASTNode next) { +// if (child instanceof Assignment && next instanceof Assignment) { +// Assignment a1 = (Assignment) child; +// Assignment a2 = (Assignment) next; +// if (a1.getLeftHandSide().equals(a2.getRightHandSide())) { +// a2.setRightHandSide(a1.getRightHandSide()); +// child.getParentBlock().removeChild(child); +// return next; +// } +// } +// return child; +// } + + private VariableBinding fetchVariableBinding(Expression expr, VariableDeclaration decl) { + ASTNode child = expr.getFirstChild(); + while (child != null) { + if (child instanceof VariableBinding && ((VariableBinding) child).getVariableDeclaration() == decl) + return (VariableBinding) child; + VariableBinding vb = fetchVariableBinding((Expression) child, decl); + if (vb != null) return vb; + child = child.getNextSibling(); + } + return null; + } + + /** + * If the specified expression corresponds to + * xy + 1 or xy - (-1), + * returns the INCREMENT operator. If the specified expression corresponds to + * xy - 1 or xy + (-1), + * returns the DECREMENT operator. Otherwise, null is returned. + * @param expr + * @return + */ + private PStarExpression.Operator getOp(InfixExpression expr) { + NumberLiteral nl; + if (expr.getRightOperand() instanceof NumberLiteral) { + nl = (NumberLiteral) expr.getRightOperand(); + } else return null; + + PStarExpression.Operator op; + if (expr.getOperator() == InfixExpression.Operator.PLUS) { + op = PStarExpression.INCREMENT; + } else if (expr.getOperator() == InfixExpression.Operator.MINUS) { + op = PStarExpression.DECREMENT; + } else { + return null; + } + + if (NumberLiteral.isOne(nl)) { + // We are ok. + } else if (NumberLiteral.isMinusOne(nl)) { + op = op.complement(); + } else { + return null; + } + return op; + } + + /** + * Reduces + * vb = x.y; (1) + * x.y = vb + 1; (2) + * ... + * expr(vb); + * to incremental form + * expr(x.y++); + * Likewise decrement. + */ + private boolean reduceXCrement(VariableDeclaration decl) { + Assignment a1 = null; + Assignment a2 = null; + VariableBinding vb1 = null; + VariableBinding vb2 = null; + + Assignable fa1 = null; + Assignable fa2 = null; + + InfixExpression sum = null; + + + Iterator iter = decl.vbs.iterator(); + + while (iter.hasNext()) { + VariableBinding vb = (VariableBinding) iter.next(); + + if (vb.getParentNode() instanceof Assignment) { + Assignment a = (Assignment) vb.getParentNode(); + if (a.getLeftHandSide() == vb && a.getRightHandSide() instanceof Assignable) { + vb1 = vb; + a1 = a; + fa1 = (Assignable) a.getRightHandSide(); + continue; + } + } + + if (vb.getParentNode() instanceof InfixExpression) { + InfixExpression infix = (InfixExpression) vb.getParentNode(); + if (infix.getParentNode() instanceof Assignment) { + Assignment a = (Assignment) infix.getParentNode(); + if (a.getLeftHandSide() instanceof Assignable) { + vb2 = vb; + fa2 = (Assignable) a.getLeftHandSide(); + a2 = a; + sum = infix; + continue; + } + } + } + } + + if (a1 == null || a2 == null) return false; + if (!fa1.isSame(fa2)) return false; + + PStarExpression.Operator operator = getOp(sum); + if (operator == null) return false; + + PStarExpression p = new PostfixExpression(); + p.setOperand((Expression) fa1); + p.setOperator(operator); + + decl.vbs.remove(vb1); + decl.vbs.remove(vb2); + VariableBinding vb = decl.vbs.get(0); + vb.getParentBlock().replaceChild(p, vb); + + Block b = a1.getParentBlock(); + b.removeChild(a1); + b.removeChild(a2); + return true; + } + + /** + * Reduces + * vb = x.y op z; (3) + * x.y = vb; (4) + * ... + * expr(vb); + * to incremental form + * expr(x.y op= z) or expr(++x.y); + * Likewise decrement. + */ + private boolean reduceYCrement(VariableDeclaration decl) { + Assignment a1 = null; + Assignment a2 = null; + VariableBinding vb1 = null; + VariableBinding vb2 = null; + + Assignable fa1 = null; + Assignable fa2 = null; + + InfixExpression infixExpr = null; + + Iterator iter = decl.vbs.iterator(); + + while (iter.hasNext()) { + VariableBinding vb = (VariableBinding) iter.next(); + + if (!(vb.getParentNode() instanceof Assignment)) continue; + + Assignment a = (Assignment) vb.getParentNode(); + if (a.getRightHandSide() == vb && a.getLeftHandSide() instanceof Assignable) { + vb2 = vb; + a2 = a; + fa2 = (Assignable) a.getLeftHandSide(); + continue; + } + + if (a.getLeftHandSide() == vb && a.getRightHandSide() instanceof InfixExpression) { + InfixExpression infix = (InfixExpression) a.getRightHandSide(); + if (!(infix.getLeftOperand() instanceof Assignable)) continue; + vb1 = vb; + a1 = a; + fa1 = (Assignable) infix.getLeftOperand(); + infixExpr = infix; + continue; + } + } + + if (a1 == null || a2 == null) return false; + if (!fa1.isSame(fa2)) return false; + + decl.vbs.remove(vb1); + decl.vbs.remove(vb2); + VariableBinding vb = decl.vbs.get(0); + Expression replacement = null; + + PStarExpression.Operator operator = getOp(infixExpr); + if (operator != null) { + PrefixExpression p = new PrefixExpression(); + p.setOperand((Expression) fa1); + p.setOperator(operator); + replacement = p; + } else { + InfixExpression.Operator op = infixExpr.getOperator(); + Assignment.Operator opp = Assignment.Operator.lookup(op.toString() + '='); + Assignment a = new Assignment(opp); + a.setLeftHandSide((Expression) fa2); + a.setRightHandSide(infixExpr.getRightOperand()); + replacement = a; + } + + vb.getParentBlock().replaceChild(replacement, vb); + + Block b = a1.getParentBlock(); + b.removeChild(a1); + b.removeChild(a2); + return true; + } + + public void optimize() { + if (false) return; + // Review this code. For example j2js.fa(obj, name)++ is illegal! + + Iterator iter = tempDecls.iterator(); + while (iter.hasNext()) { + VariableDeclaration decl = (VariableDeclaration) iter.next(); + int count = decl.vbs.size(); + if (count == 3) { + if (reduceXCrement(decl)) { + iter.remove(); + methodDecl.removeLocalVariable(decl.getName()); + } else if (reduceYCrement(decl)) { + iter.remove(); + methodDecl.removeLocalVariable(decl.getName()); + } + } + } + } + +} diff --git a/src/main/java/com/j2js/ParseException.java b/src/main/java/com/j2js/ParseException.java new file mode 100644 index 0000000..e039d00 --- /dev/null +++ b/src/main/java/com/j2js/ParseException.java @@ -0,0 +1,25 @@ +package com.j2js; + +import com.j2js.dom.ASTNode; + +/** + * @author kuehn + */ +public class ParseException extends RuntimeException { + + private ASTNode astNode; + + public ParseException(String msg, ASTNode node) { + super(msg); + astNode = node; + } + + public ParseException(Throwable cause, ASTNode node) { + super(cause); + astNode = node; + } + + public ASTNode getAstNode() { + return astNode; + } +} diff --git a/src/main/java/com/j2js/Parser.java b/src/main/java/com/j2js/Parser.java new file mode 100644 index 0000000..7f2e6b4 --- /dev/null +++ b/src/main/java/com/j2js/Parser.java @@ -0,0 +1,204 @@ +package com.j2js; + +import com.j2js.J2JSCompiler; + +import java.io.IOException; +import java.lang.reflect.Modifier; + +import com.j2js.Pass1; +import com.j2js.ParseException; + +import org.apache.bcel.classfile.Attribute; +import org.apache.bcel.classfile.AttributeReader; +import org.apache.bcel.classfile.ClassParser; +import org.apache.bcel.classfile.JavaClass; +import org.apache.bcel.classfile.ConstantPool; +import org.apache.bcel.classfile.Method; +import org.apache.bcel.classfile.Field; +import org.apache.bcel.generic.ObjectType; +import org.apache.bcel.generic.Type; + +import com.j2js.assembly.ClassUnit; +import com.j2js.assembly.Project; +import com.j2js.assembly.Signature; +import com.j2js.dom.*; + +/** + * @author wolfgang + */ +public class Parser { + + public static String getResourcePath(String name) { + name = name.replace('.', '/') + ".class"; + java.net.URL url = Parser.class.getClassLoader().getResource(name); + if (url == null) throw new RuntimeException("Resource not found: " + name); + return url.getPath(); + } + + private JavaClass jc; + private ClassUnit fileUnit; + + public Parser(ClassUnit theFileUnit) { + fileUnit = theFileUnit; + fileUnit.annotations = null; + + AttributeReader r = new AnnotationReader(fileUnit); + Attribute.addAttributeReader("RuntimeVisibleAnnotations", r); + + try { + ClassParser cp = new ClassParser(fileUnit.getClassFile().openInputStream(), fileUnit.getName()); + jc = cp.parse(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public TypeDeclaration parse() { + +// Attribute[] attributes = jc.getAttributes(); +// for (int i=0; i", "(java/lang/String)V;"); + ClassInstanceCreation cic = new ClassInstanceCreation(methodDecl, binding); + cic.addArgument(new StringLiteral("Unresolved decompilation problem")); + throwStmt.setExpression(cic); + body.appendChild(throwStmt); + methodDecl.setBody(body); + + } + + // Remove from body last expressionless return statement. + if (J2JSCompiler.compiler.optimize && methodDecl.getBody().getLastChild() instanceof ReturnStatement) { + ReturnStatement ret = (ReturnStatement) methodDecl.getBody().getLastChild(); + if (ret.getExpression() == null) { + methodDecl.getBody().removeChild(ret); + } + } + + Pass1.dump(methodDecl.getBody(), "Body of " + methodDecl.toString()); + +// if (typeDecl.getClassName().equals("java.lang.String")) { +// if (methodDecl.isInstanceConstructor()) { +// +// } +// } + + return; + } + + public ConstantPool getConstantPool() { + return jc.getConstantPool(); + } + + public String toString() { + return jc.getClassName(); + } + +} diff --git a/src/main/java/com/j2js/Pass1.java b/src/main/java/com/j2js/Pass1.java new file mode 100644 index 0000000..d658164 --- /dev/null +++ b/src/main/java/com/j2js/Pass1.java @@ -0,0 +1,2233 @@ +package com.j2js; + +import org.apache.bcel.Constants; +//import org.apache.bcel.classfile.*; +import org.apache.bcel.classfile.ClassFormatException; +import org.apache.bcel.classfile.CodeException; +import org.apache.bcel.classfile.Constant; +import org.apache.bcel.classfile.ConstantClass; +import org.apache.bcel.classfile.ConstantCP; +import org.apache.bcel.classfile.ConstantDouble; +import org.apache.bcel.classfile.ConstantFieldref; +import org.apache.bcel.classfile.ConstantInteger; +import org.apache.bcel.classfile.ConstantFloat; +import org.apache.bcel.classfile.ConstantLong; +import org.apache.bcel.classfile.ConstantNameAndType; +import org.apache.bcel.classfile.ConstantString; +import org.apache.bcel.classfile.ConstantUtf8; +import org.apache.bcel.classfile.JavaClass; +import org.apache.bcel.classfile.Code; +import org.apache.bcel.classfile.Method; +import org.apache.bcel.classfile.ConstantPool; +import org.apache.bcel.classfile.Utility; + +import org.apache.bcel.generic.BasicType; +import org.apache.bcel.generic.InstructionHandle; +import org.apache.bcel.generic.InstructionTargeter; +import org.apache.bcel.generic.ObjectType; +import org.apache.bcel.generic.Type; +import org.apache.bcel.util.ByteSequence; + +import com.j2js.cfg.ControlFlowGraph; +import com.j2js.cfg.Node; +import com.j2js.cfg.SwitchEdge; +import com.j2js.cfg.TryHeaderNode; +import com.j2js.dom.*; +import com.j2js.visitors.SimpleGenerator; +import com.j2js.assembly.Project; +import com.j2js.assembly.Signature; + +import org.apache.bcel.generic.InstructionList; + +import com.j2js.J2JSCompiler; + +import java.io.*; +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Iterator; +import java.util.Map; +import java.util.TreeMap; + +public class Pass1 { + + private ConstantPool constantPool; + + private ByteSequence bytes; + private static ASTNode currentNode; + + private ASTNodeStack stack; + + private Code code; + private MethodDeclaration methodDecl; + // The currently parsed method. + private Method method; + + private List tryStatements = new ArrayList(); + private ControlFlowGraph graph = new ControlFlowGraph(tryStatements); + + // Not used anymore. + private int depth; + + private static Log logger = Log.getLogger(); + + + /* + * The `WIDE' instruction is used in the byte code to allow 16-bit wide + * indices for local variables. This opcode may precede one of + * iload, fload, aload, lload, dload, istore, fstore, astore, lstore, dstore, ret or iinc. + * The opcode immediately following takes an extra byte which is combined with + * the following byte to form a 16-bit value. + * In case of iinc, the default two 8 bit operants are widened to two 16 bit aperants accordingly. + */ + private boolean wide = false; + + public static ASTNode getCurrentNode() { + return currentNode; + } + + public Pass1(JavaClass jc) { + constantPool = jc.getConstantPool(); + } + + private CatchClause createCatchClause(TryStatement tryStmt, ExceptionHandler handle) { + CatchClause cStmt = new CatchClause(handle.getHandlerPC()); + VariableDeclaration decl = new VariableDeclaration(VariableDeclaration.LOCAL_PARAMETER); + decl.setName("_EX_"); + decl.setType(handle.getCatchType(constantPool)); + cStmt.setException(decl); + tryStmt.addCatchStatement(cStmt); + return cStmt; + } + + private void makeTryFrames() { + for (int i=0; i handleIterator = handlers.iterator(); + + ExceptionHandler handle = handleIterator.hasNext()?handleIterator.next():null; + while (handle != null) { + boolean hasFinally = false; + int start = handle.getStartPC(); + int end = handle.getEndPC(); + + TryStatement tryStmt = new TryStatement(); + tryStmt.header = (TryHeaderNode) graph.createNode(TryHeaderNode.class); + tryStmt.header.tryStmt = tryStmt; + + Block tryBlock = new Block(start, end); + tryStmt.setTryBlock(tryBlock); + + //tryStmt.setBeginIndex(start); + + tryStatements.add(tryStmt); + + CatchClause cStmt = null; + + // Collect all non-default handlers. The range of each handler is from the 'store'-instruction to the beginning of the next handler. + while (handle != null && !handle.isDefault() && handle.getStartPC()==start && handle.getEndPC()==end) { + if (cStmt!=null) { + cStmt.setEndIndex(handle.getHandlerPC()-1); + } + cStmt = createCatchClause(tryStmt, handle); + handle = handleIterator.hasNext()?handleIterator.next():null; + } + + int foo = -1; + if (handle != null && handle.isDefault() && handle.getStartPC()==start) { + // Collect first default handler. + hasFinally = true; + if (cStmt!=null) { + cStmt.setEndIndex(handle.getHandlerPC()-1); + tryStmt.setEndIndex(handle.getHandlerPC()-1); + // Warning: We only set a lower bound for the end index. The correct index is set later + // when the finally statement is analysed. + } + cStmt = createCatchClause(tryStmt, handle); + foo = handle.getHandlerPC(); + handle = handleIterator.hasNext()?handleIterator.next():null; + } + + // Last catch stmt has no endIndex, yet! + + while (handle != null && handle.isDefault() && (handle.getHandlerPC()==foo)) { + // Skip all remaining default handlers. + throw new RuntimeException("remaining default handlers"); + //handle = handleIterator.hasNext()?handleIterator.next():null; + } + + Block catches = tryStmt.getCatchStatements(); + if (catches.getChildCount() == 0) { + throw new ParseException("A try clause must have at least one (possibly default) catch clause", tryStmt); + } + cStmt = (CatchClause) catches.getChildAt(0); + tryBlock.setEndIndex(cStmt.getBeginIndex()-1); + cStmt = (CatchClause) catches.getLastChild(); + if (cStmt.getEndIndex() == Integer.MIN_VALUE) { + cStmt.setEndIndex(cStmt.getBeginIndex()+1); + } + tryStmt.setEndIndex(cStmt.getEndIndex()); + + if (hasFinally) { + // Can't say yet where finally block is located. + } + + if (logger.isDebugEnabled()) { + dump(tryStmt, "Try"); + } + } + } + + /** + * Dumps instructions and exeption table. + */ + private void dumpCode() { + InstructionList il = new InstructionList(code.getCode()); + InstructionHandle[] handles = il.getInstructionHandles(); + + for (InstructionHandle handle : handles) { + System.out.println(handle.toString(true)); + InstructionTargeter[] targeters = handle.getTargeters(); + if (targeters != null) { + for (InstructionTargeter targeter : handle.getTargeters()) { + System.out.println(" Targeter: " + targeter.toString() + " " + targeter.getClass()); + } + } + } + + for (CodeException ce : code.getExceptionTable()) { + String exceptionType; + if (ce.getCatchType() > 0) { + Constant constant = constantPool.getConstant(ce.getCatchType()); + exceptionType = Pass1.constantToString(constant, constantPool); + } else { + exceptionType = "Default"; + } + System.out.println(ce.toString() + " " + exceptionType); + } + } + + public void parse(Method theMethod, MethodDeclaration theMethodDecl) throws IOException { + method = theMethod; + methodDecl = theMethodDecl; + + code = method.getCode(); + + if (logger.isDebugEnabled()) { + dumpCode(); + } + + Block.TAG = 0; + + compileCodeException(); + + bytes = new ByteSequence(code.getCode()); + + graph.createNode(0); + + makeTryFrames(); + + parseStatement(); + + try { + Optimizer optimizer = new Optimizer(methodDecl, tempDecls); + optimizer.optimize(); + } catch (Error e) { + J2JSCompiler.errorCount++; + if (logger.isDebugEnabled()) { + logger.debug("In Expression Optimizer:\n" + e + "\n" + Utils.stackTraceToString(e)); + } else { + logger.error("In Expression Optimizer:\n " + e); + } + } + + Block block; + if (J2JSCompiler.compiler.reductionLevel == 0) { + block = graph.reduceDumb(); + } else { + block = graph.reduce(); + } + + methodDecl.setBody(block); + + } + + private boolean isProcedure(ASTNode stmt) { + if (stmt instanceof MethodInvocation) { + MethodInvocation mi = (MethodInvocation) stmt; + return mi.getTypeBinding().equals(Type.VOID); + } + return false; + } + + Node cNode; + Node lastCurrentNode; + + private void setCurrentNode(Node theNode) { + if (cNode == theNode) return; + cNode = theNode; + if (cNode != null && cNode != lastCurrentNode) { + logger.debug("Switched to " + cNode); + lastCurrentNode = cNode; + } + } + + private void joinNodes(Node node) { + Collection nodes = node.preds(); + Iterator iter = nodes.iterator(); + while (iter.hasNext()) { + Node n = (Node) iter.next(); + if (n.stack.size() == 0) iter.remove(); + } + if (nodes.size() > 0) { + mergeStacks(nodes, node.stack); + } + } + + /** + * Selects a single node as currently active node. + */ + private void selectActiveNode(int pc) { + // Find all nodes currently active at pc. + List activeNodes = new ArrayList(); + for (Node node : graph.getNodes()) { + if (node.getCurrentPc() == pc) { + activeNodes.add(node); + } + } + + if (activeNodes.size() == 0) { + // No active node: Create one. + Node node = graph.createNode(pc); + setCurrentNode(node); + return; + } + + if (activeNodes.size() == 1) { + // Return single active node. + Node node = activeNodes.get(0); + setCurrentNode(node); + return; + } + + // Multiple nodes. Select the one starting at pc. + + Node node = graph.getNode(pc); + if (node == null) throw new RuntimeException("No node found at " + pc); + + setCurrentNode(node); + + // Add edges from all other active nodes to the selected node. + activeNodes.remove(node); + for (Node n : activeNodes) { + graph.addEdge(n, node); + } + } + + /** + * If the stack of the specified node is [s0, s1, ..., sn], then [t1=s1; ... tn=sn} is + * appended to its block, and the stack is replaced by [t1, t2, ..., tn]. + */ + private void expressionsToVariables(Node node, boolean clone) { + if (node.stack.size() == 0) return; + + logger.debug("expressionsToVariables ..."); + + for (int i=0; i 0) { + + int pc = bytes.getIndex(); + //Logger.getLogger().finer("@" + pc); + + if (cNode != null) { + cNode.setCurrentPc(pc); + } + + selectActiveNode(pc); + + if (cNode.getInitialPc() == pc) { + joinNodes(cNode); + } + + stack = cNode.stack; + + ASTNode stmt = parseInstruction(); + //InstructionHandle handle = il.findHandle(stmt.getBeginIndex()); + //System.out.println(">>>" + handle); + + if (stmt instanceof NoOperation) continue; + + depth += stmt.getStackDelta(); + + if (stmt instanceof VariableBinding) { + depth = depth; + } + + logger.debug(" -> " + stmt + " @ " + + methodDecl.getLineNumberCursor().getLineNumber(stmt) + + ", depth:" + depth + ", delta:" + stmt.getStackDelta()); + + if (stmt instanceof JumpSubRoutine) { + JumpSubRoutine jsr = (JumpSubRoutine) stmt; + cNode.block.setEndIndex(jsr.getEndIndex()); + + Node finallyNode = graph.getNode(jsr.getTargetIndex()); + + if (finallyNode == null) { + // Found finally clause. + finallyNode = graph.createNode(jsr.getTargetIndex()); + // Generate dummy expression for the astore instruction of the finally block. + finallyNode.stack = new ASTNodeStack(new Expression()); + + //finallyNode.jsrCallers.add(cNode); + } + finallyNode.jsrCallers.add(cNode); + if (cNode.preds().size() == 1 && finallyNode.preds().size() == 0 && cNode.getPred() instanceof TryHeaderNode) { + // Current node must be the default handler. + // TODO: This only works if default handler is a single node!! + TryHeaderNode tryHeaderNode = (TryHeaderNode) cNode.getPred(); + // Attach finally to its try header node. + tryHeaderNode.setFinallyNode(finallyNode); + } + + } else if (stmt instanceof ConditionalBranch) { + ConditionalBranch cond = (ConditionalBranch) stmt; + + if (bytes.getIndex() == cond.getTargetIndex()) { + // This is a conditional branch with an empty body, i.e. not a branch at all. We ignore it. + } else { + Node elseNode = graph.getOrCreateNode(bytes.getIndex()); + + Node ifNode; + if (cond.getTargetIndex() <= pc) { + Node[] nodes = graph.getOrSplitNodeAt(cNode, cond.getTargetIndex()); + cNode = nodes[0]; + ifNode = nodes[1]; + } else { + ifNode = graph.getOrCreateNode(cond.getTargetIndex()); + } + + BooleanExpression be = new BooleanExpression(cond.getExpression()); + + graph.addIfElseEdge(cNode, ifNode, elseNode, be); + expressionsToVariables(cNode, false); + cNode = null; + } + } else if (stmt instanceof Jump) { + int targetPc = ((Jump) stmt).getTargetIndex(); + Node targetNode; + + if (targetPc <= pc) { + // Backward jump. + Node[] nodes = graph.getOrSplitNodeAt(cNode, targetPc); + cNode = nodes[0]; + targetNode = nodes[1]; + } else { + targetNode = graph.getOrCreateNode(targetPc); + } + graph.addEdge(cNode, targetNode); + cNode = null; + } else if (stmt instanceof SynchronizedBlock || isProcedure(stmt)) { + cNode.block.appendChild(stmt); + } else if (stmt instanceof Assignment) { + expressionsToVariables(cNode, true); + cNode.block.appendChild(stmt); + } else if (stmt instanceof ThrowStatement || stmt instanceof ReturnStatement) { + cNode.block.appendChild(stmt); + cNode.close(); + cNode = null; + } else { + stack.push(stmt); + } + } + + } + + + void dump(Collection nodes) { + if (!logger.isDebugEnabled()) return; + + Iterator iter = nodes.iterator(); + while (iter.hasNext()) { + Node node = (Node) iter.next(); + dump(node.stack, node.toString()); + } + } + + public static void dump(ASTNode node, String msg) { + if (!logger.isDebugEnabled()) return; + + ByteArrayOutputStream ba = new ByteArrayOutputStream(); + PrintStream out = new PrintStream(ba); + out.println(msg); + SimpleGenerator generator = new SimpleGenerator(out); + generator.visit(node); + out.close(); + try { + ba.close(); + } catch (IOException e) { + throw new RuntimeException(e); + } + logger.debug(ba.toString()); + } + + static void dump(List list, String msg) { + if (!logger.isDebugEnabled()) return; + + StringBuffer sb = new StringBuffer(); + sb.append("Begin dumping " + msg + "...\n"); + for (int i=0; i tempDecls = new ArrayList(); + + private Expression[] duplicate(Expression e) { + if (e instanceof NumberLiteral || e instanceof ThisExpression || e instanceof StringLiteral) { + // Refered values will never change nor will they have side effects, + // so we do not need to create an intermediate variable. + return new Expression[] {e, (Expression) e.clone()}; + } + + if (e instanceof VariableBinding && ((VariableBinding) e).isTemporary()) { + VariableBinding vb1 = (VariableBinding) e; + VariableBinding vb2 = (VariableBinding) vb1.clone(); + return new VariableBinding[] {vb1, vb2}; + } + + Assignment a = new Assignment(Assignment.Operator.ASSIGN); + a.setRange(bytes.getIndex(), bytes.getIndex()); + VariableBinding vb1 = methodDecl.createAnonymousVariableBinding(e.getTypeBinding(), true); + VariableBinding vb2 = (VariableBinding) vb1.clone(); + VariableBinding vb3 = (VariableBinding) vb1.clone(); + tempDecls.add(vb1.getVariableDeclaration()); + vb1.getVariableDeclaration().setParentNode(methodDecl); + a.setLeftHandSide(vb1); + a.setRightHandSide(e); + cNode.block.appendChild(a); + return new VariableBinding[] {vb2, vb3}; + } + + /** + * Creates a new case group at the specified pc if it does not yet exist. + * + * @param header the switch header + * @param switchEdges all currently existing switch edges + * @param startPc the pc at which the case group starts + * @return the switch edge to the case group. + */ + private SwitchEdge getOrCreateCaseGroup(Node header, Map switchEdges, int startPc) { + SwitchEdge switchEdge = switchEdges.get(startPc); + if (switchEdge == null) { + Node caseGroupNode = graph.createNode(startPc); + switchEdge = (SwitchEdge) graph.addEdge(header, caseGroupNode, SwitchEdge.class); + switchEdges.put(startPc, switchEdge); + } + + return switchEdge; + } + + private int readUnsigned() throws IOException { + int index; + if (wide) { + index = bytes.readUnsignedShort(); + wide = false; // Clear flag + } else { + index = bytes.readUnsignedByte(); + } + return index; + } + + private int readSigned() throws IOException { + int index; + if (wide) { + index = bytes.readShort(); + wide = false; // Clear flag + } else { + index = bytes.readByte(); + } + return index; + } + + private void dup1() { + Expression[] value1 = duplicate(stack.pop()); + stack.push(value1[0]); + stack.push(value1[1]); + } + + private void dup2() { + Expression[] value1 = duplicate(stack.pop()); + Expression[] value2 = duplicate(stack.pop()); + stack.push(value2[0]); + stack.push(value1[0]); + stack.push(value2[1]); + stack.push(value1[1]); + } + + private ASTNode parseInstruction() throws IOException { + int currentIndex = bytes.getIndex(); + short opcode = (short) bytes.readUnsignedByte(); + + InstructionType instructionType = Const.instructionTypes[opcode]; + + Form form = selectForm(instructionType); + + int opStackDelta = form.getOpStackDelta(); + + ASTNode instruction = null; + + logger.debug(currentIndex + " " + instructionType.getName() + "[" + opcode + "] "); + + switch (opcode) { + /* + * Switches have variable length arguments. + */ + case Const.TABLESWITCH : + // Format: tableswitch, padding(byte), padding(byte), padding(byte), default(int), low(int), high(int) + // Operand stack: ..., index(int) -> ... + case Const.LOOKUPSWITCH : { + // Format: lookupswitch, padding(byte), padding(byte), padding(byte), default(int), npairs(int) + // Operand stack: ..., key() -> ... + Node switchNode = graph.createNode(currentIndex); + switchNode.isSwitchHeader = true; + graph.addEdge(cNode, switchNode); + cNode = null; + + int defaultOffset; + int npairs; + int offset; + int remainder = bytes.getIndex() % 4; + int noPadBytes = (remainder == 0) ? 0 : 4 - remainder; + + // Skip (0-3) padding bytes, i.e., the following bytes are 4-byte-aligned. + for (int i = 0; i < noPadBytes; i++) { + byte b; + + if ((b = bytes.readByte()) != 0) { + logger.warn("Padding byte != 0 in " + instructionType.getName() + ":" + b); + } + } + + defaultOffset = bytes.readInt(); + + int low = 0; + if (opcode==Const.LOOKUPSWITCH) { + npairs = bytes.readInt(); + offset = bytes.getIndex() - 8 - noPadBytes - 1; + } else { + low = bytes.readInt(); + int high = bytes.readInt(); + npairs = high - low + 1; + offset = bytes.getIndex() - 12 - noPadBytes - 1; + } + + defaultOffset += offset; + + switchNode.switchExpression = stack.pop(); + + TreeMap caseGroups = new TreeMap(); + + // Add all cases. + for (int i = 0; i < npairs; i++) { + int key; + if (opcode==Const.LOOKUPSWITCH) { + key = bytes.readInt(); + } else { + key = low + i; + } + + SwitchEdge switchEdge = getOrCreateCaseGroup(switchNode, caseGroups, offset + bytes.readInt()); + switchEdge.expressions.add(NumberLiteral.create(new Integer(key))); + } + + Node defaultNode = graph.createNode(defaultOffset); + graph.addEdge(switchNode, defaultNode); + //getOrCreateCaseGroup(switchNode, caseGroups, defaultOffset); + + instruction = new NoOperation(); + break; + } + + case Const.CHECKCAST : { + // Format: checkcast, index(short) + // Operand stack: ..., objectref() -> ..., objectref(object) + CastExpression cast = new CastExpression(); + int index = bytes.readUnsignedShort(); + ConstantClass c = (ConstantClass) constantPool.getConstant(index); + ObjectType type = new ObjectType(c.getBytes(constantPool).replace('/', '.')); + cast.setTypeBinding(type); + cast.setExpression(stack.pop()); + instruction = cast; + break; + } + + + case Const.INSTANCEOF : { + // Format: instanceof, index(short) + // Operand stack: ..., objectref() -> ..., result(int) + int index = bytes.readUnsignedShort(); + InstanceofExpression ex = new InstanceofExpression(); + Expression objectref = stack.pop(); + ex.setLeftOperand(objectref); + ConstantClass c = (ConstantClass) constantPool.getConstant(index); + ObjectType type = new ObjectType(c.getBytes(constantPool).replace('/', '.')); + ex.setRightOperand(type); + ex.widen(objectref); + instruction = ex; + break; + } + + + case Const.ACONST_NULL : + // Format: aconst_null + // Operand stack: ... -> ..., null(object) + instruction = new NullLiteral(); + break; + + case Const.JSR : { + // Format: jsr, branch(short) + // Operand stack: ... -> ..., address(returnAddress) + instruction = new JumpSubRoutine(currentIndex + bytes.readShort()); + opStackDelta = 0; + break; + } + + case Const.JSR_W : { + // Format: jsr_w, branch(int) + // Operand stack: ... -> ..., address() + instruction = new JumpSubRoutine(currentIndex + bytes.readInt()); + break; + } + + case Const.IFEQ : + // Format: ifeq, branch(short) + // Operand stack: ..., value() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.EQUALS, NumberLiteral.create(0)); + break; + case Const.IFNE : + // Format: ifne, branch(short) + // Operand stack: ..., value() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.NOT_EQUALS, NumberLiteral.create(0)); + break; + case Const.IFGE : + // Format: ifge, branch(short) + // Operand stack: ..., value() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.GREATER_EQUALS, NumberLiteral.create(0)); + break; + case Const.IFGT : + // Format: ifgt, branch(short) + // Operand stack: ..., value() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.GREATER, NumberLiteral.create(0)); + break; + case Const.IFLE : + // Format: ifle, branch(short) + // Operand stack: ..., value() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.LESS_EQUALS, NumberLiteral.create(0)); + break; + case Const.IFLT : + // Format: iflt, branch(short) + // Operand stack: ..., value() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.LESS, NumberLiteral.create(0)); + break; + case Const.IFNONNULL : + // Format: ifnonnull, branch(short) + // Operand stack: ..., value() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.NOT_EQUALS, new NullLiteral()); + break; + case Const.IFNULL : + // Format: ifnull, branch(short) + // Operand stack: ..., value() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.EQUALS, new NullLiteral()); + break; + + case Const.IF_ACMPEQ : + // Format: if_acmpeq, branch(short) + // Operand stack: ..., value1(), value2() -> ... + case Const.IF_ICMPEQ : + // Format: if_icmpeq, branch(short) + // Operand stack: ..., value1(), value2() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.EQUALS); + break; + case Const.IF_ACMPNE : + // Format: if_acmpne, branch(short) + // Operand stack: ..., value1(), value2() -> ... + case Const.IF_ICMPNE : + // Format: if_icmpne, branch(short) + // Operand stack: ..., value1(), value2() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.NOT_EQUALS); + break; + case Const.IF_ICMPGE : + // Format: if_icmpge, branch(short) + // Operand stack: ..., value1(), value2() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.GREATER_EQUALS); + break; + case Const.IF_ICMPGT : + // Format: if_icmpgt, branch(short) + // Operand stack: ..., value1(), value2() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.GREATER); + break; + case Const.IF_ICMPLE : + // Format: if_icmple, branch(short) + // Operand stack: ..., value1(), value2() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.LESS_EQUALS); + break; + case Const.IF_ICMPLT : + // Format: if_icmplt, branch(short) + // Operand stack: ..., value1(), value2() -> ... + instruction = createConditional(currentIndex, InfixExpression.Operator.LESS); + break; + + case Const.LCMP : + // Format: lcmp + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.FCMPL : + // Format: fcmpl + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.FCMPG : + // Format: fcmpg + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.DCMPL : + // Format: dcmpl + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.DCMPG : { + // Format: dcmpg + // Operand stack: ..., value1(), value2() -> ..., result(int) + MethodBinding binding = MethodBinding.lookup("javascript.Utils", "cmp", "(DDI)I"); + MethodInvocation mi = new MethodInvocation(methodDecl, binding); + + Expression value2 = stack.pop(); + mi.addArgument(stack.pop()); + mi.addArgument(value2); + + int gORl = 0; + if (instructionType.getName().endsWith("g")) gORl = 1; + else if (instructionType.getName().endsWith("l")) gORl = -1; + mi.addArgument(NumberLiteral.create(gORl)); + + instruction = mi; + + break; + } + + case Const.GOTO : { + // Format: goto, branch(short) + // Operand stack: ... -> ... + instruction = new Jump(currentIndex + bytes.readShort()); + break; + } + + case Const.GOTO_W : { + // Format: goto_w, branch(int) + // Operand stack: ... -> ... + instruction = new Jump(currentIndex + bytes.readInt()); + break; + } + + case Const.NEW: { + // Format: new, index(short) + // Operand stack: ... -> ..., objectref(object) + ConstantClass c = (ConstantClass) constantPool.getConstant(bytes.readUnsignedShort()); + ObjectType type = new ObjectType(c.getBytes(constantPool).replace('/', '.')); + + instruction = new ClassInstanceCreation(type); + } + break; + + /** + * Create new array with component type being primitiv. + */ + case Const.NEWARRAY: { + // Format: newarray, atype(byte) + // Operand stack: ..., count(int) -> ..., arrayref(object) + + String componentSignature = BasicType.getType(bytes.readByte()).getSignature(); + + // Create a new array with components of type componentType. + List dimensions = new ArrayList(); + dimensions.add(stack.pop()); + ArrayCreation ac = new ArrayCreation(methodDecl, new ObjectType("[" + componentSignature), dimensions); + instruction = ac; + break; + } + + /* + * Create new array of reference of non-primitiv type. + */ + case Const.ANEWARRAY: { + // Format: anewarray, index(short) + // Operand stack: ..., count(int) -> ..., arrayref(object) + + ConstantClass c = (ConstantClass) constantPool.getConstant(bytes.readUnsignedShort()); + String componentSignature = c.getBytes(constantPool).replace('/', '.'); + Type arrayType; + if (componentSignature.startsWith("[")) { + arrayType = new ObjectType("[" + componentSignature); + } else { + arrayType = new ObjectType("[L" + componentSignature + ";"); + } + + // Create a new array with components of type componentType. + List dimensions = new ArrayList(); + dimensions.add(stack.pop()); + ArrayCreation ac = new ArrayCreation(methodDecl, arrayType, dimensions); + instruction = ac; + break; + } + + /* + * Multidimensional array of references. + */ + case Const.MULTIANEWARRAY : { + // Format: multianewarray, index(short), dimension N(byte) + // Operand stack: ..., count1(), ...(), countN() -> ..., arrayref(object) + + ConstantClass c = (ConstantClass) constantPool.getConstant(bytes.readUnsignedShort()); + ObjectType arrayType = new ObjectType(c.getBytes(constantPool).replace('/', '.')); + + // Create a new multidimensional array of the array type arrayType. + // The array type must be an array class type of dimensionality greater than or equal to dimensions. + + int dimCount = bytes.readUnsignedByte(); + opStackDelta = 1 - dimCount; + List dimensions = new ArrayList(); + for (int i=0; i ... + case Const.PUTFIELD : { + // Format: putfield, index(short) + // Operand stack: ..., objectref(), value() -> ... + Assignment a = new Assignment(Assignment.Operator.ASSIGN); + Expression rhs = stack.pop(); + + int index = bytes.readUnsignedShort(); + ConstantFieldref fieldRef = (ConstantFieldref) constantPool.getConstant(index, Constants.CONSTANT_Fieldref); + + FieldAccess fa = new FieldWrite(); + fa.setName(getFieldName(fieldRef)); + fa.setType(new ObjectType(fieldRef.getClass(constantPool))); + fa.initialize(methodDecl); + + if (opcode==Const.PUTFIELD) { + fa.setExpression(stack.pop()); + } + + a.setLeftHandSide(fa); + a.setRightHandSide(rhs); + + instruction = a; + break; + } + + case Const.GETFIELD : { + // Format: getfield, index(short) + // Operand stack: ..., objectref() -> ..., value() + int index = bytes.readUnsignedShort(); + ConstantFieldref fieldRef = (ConstantFieldref) constantPool.getConstant(index, Constants.CONSTANT_Fieldref); + + Expression ex = stack.pop(); + FieldAccess fa = new FieldRead(); + fa.setType(new ObjectType(fieldRef.getClass(constantPool))); + fa.setName(getFieldName(fieldRef)); + fa.setExpression(ex); + fa.initialize(methodDecl); + instruction = fa; + break; + } + + case Const.GETSTATIC : { + // Format: getstatic, index(short) + // Operand stack: ... -> ..., value() + int index = bytes.readUnsignedShort(); + ConstantFieldref fieldRef = (ConstantFieldref) constantPool.getConstant(index, Constants.CONSTANT_Fieldref); + + FieldAccess fa = new FieldRead(); + fa.setType(new ObjectType(fieldRef.getClass(constantPool))); + fa.setName(getFieldName(fieldRef)); + fa.initialize(methodDecl); + //Name e = new Name(fieldRef.getClass(constantPool)); + //fa.setExpression(e); + instruction = fa; + break; + } + + case Const.DUP : { + // Format: dup + // Operand stack: ..., value(cat1) -> ..., value(cat1), value(cat1) + dup1(); + instruction = stack.pop(); + break; + } + + case Const.DUP2 : + // (0) Format: dup2 + // (0) Operand stack: ..., value2(cat1), value1(cat1) -> ..., value2(cat1), value1(cat1), value2(cat1), value1(cat1) + // (1) Format: dup2 + // (1) Operand stack: ..., value(cat2) -> ..., value(cat2), value(cat2) + if (form.getIndex() == 0) { + dup2(); + instruction = stack.pop(); + } else { + dup1(); + instruction = stack.pop(); + } + break; + + case Const.DUP_X1 : { + // Format: dup_x1 + // Operand stack: ..., value2(cat1), value1(cat1) -> ..., value1(cat1), value2(cat1), value1(cat1) + dup1(); + stack.rotate(2); + instruction = stack.pop(); + break; + } + + case Const.DUP_X2 : { + // (0) Format: dup_x2 + // (0) Operand stack: ..., value3(cat1), value2(cat1), value1(cat1) -> ..., value1(cat1), value3(cat1), value2(cat1), value1(cat1) + // (1) Format: dup_x2 + // (1) Operand stack: ..., value2(cat2), value1(cat1) -> ..., value1(cat1), value2(cat2), value1(cat1) + if (form.getIndex()==0) { + dup1(); + stack.rotate(3); + } else { + dup1(); + stack.rotate(2); + } + instruction = stack.pop(); + break; + } + + case Const.DUP2_X1 : + // (0) Format: dup2_x1 + // (0) Operand stack: ..., value3(cat1), value2(cat1), value1(cat1) -> ..., value2(cat1), value1(cat1), value3(cat1), value2(cat1), value1(cat1) + // (1) Format: dup2_x1 + // (1) Operand stack: ..., value2(cat1), value1(cat2) -> ..., value1(cat2), value2(cat1), value1(cat2) + if (form.getIndex()==0) { + dup2(); + stack.rotate(4); + stack.rotate(4); + } else { + dup1(); + stack.rotate(2); + } + instruction = stack.pop(); + break; + + case Const.DUP2_X2 : + // (0) Format: dup2_x2 + // (0) Operand stack: ..., value4(cat1), value3(cat1), value2(cat1), value1(cat1) -> ..., value2(cat1), value1(cat1), value4(cat1), value3(cat1), value2(cat1), value1(cat1) + // (1) Format: dup2_x2 + // (1) Operand stack: ..., value3(cat1), value2(cat1), value1(cat2) -> ..., value1(cat2), value3(cat1), value2(cat1), value1(cat2) + // (2) Format: dup2_x2 + // (2) Operand stack: ..., value3(cat2), value2(cat1), value1(cat1) -> ..., value2(cat1), value1(cat1), value3(cat2), value2(cat1), value1(cat1) + // (3) Format: dup2_x2 + // (3) Operand stack: ..., value2(cat2), value1(cat2) -> ..., value1(cat2), value2(cat2), value1(cat2) + if (form.getIndex()==0) { + dup2(); + stack.rotate(5); + stack.rotate(5); + } else if (form.getIndex()==1) { + dup1(); + stack.rotate(3); + } else if (form.getIndex()==2) { + dup2(); + stack.rotate(4); + stack.rotate(4); + } else { + dup1(); + stack.rotate(2); + } + + instruction = stack.pop(); + break; + + case Const.SWAP : { + // Format: swap + // Operand stack: ..., value2(cat1), value1(cat1) -> ..., value1(cat1), value2(cat1) + stack.rotate(1); + instruction = new NoOperation(); + break; + } + + case Const.I2S : + // Format: i2s + // Operand stack: ..., value() -> ..., result(short) + case Const.I2F : + // Format: i2f + // Operand stack: ..., value() -> ..., result(float) + case Const.L2I : + // Format: l2i + // Operand stack: ..., value() -> ..., result(int) + case Const.F2I : + // Format: f2i + // Operand stack: ..., value(float) -> ..., result(int) + case Const.F2L : + // Format: f2l + // Operand stack: ..., value() -> ..., result(long) + case Const.L2F : + // Format: l2f + // Operand stack: ..., value() -> ..., result(float) + case Const.L2D : + // Format: l2d + // Operand stack: ..., value() -> ..., result(double) + case Const.D2I : + // Format: d2i + // Operand stack: ..., value() -> ..., result(int) + case Const.D2L : + // Format: d2l + // Operand stack: ..., value() -> ..., result(long) + case Const.D2F : + // Format: d2f + // Operand stack: ..., value() -> ..., result(float) + case Const.I2B : + // Format: i2b + // Operand stack: ..., value() -> ..., result(byte) + case Const.I2C : + // Format: i2c + // Operand stack: ..., value() -> ..., result(byte) + // Operation i2f may result in a loss of precision because values of type float have only 24 significand bits. + // Operation l2d may lose precision because values of type double have only 53 significand bits + instruction = new PrimitiveCast(opcode, stack.pop(), form.getResultType()); + break; + + case Const.I2L : + // Format: i2l + // Operand stack: ..., value() -> ..., result(long) + stack.peek().setTypeBinding(Type.LONG); + instruction = new NoOperation(); + break; + case Const.I2D : + // Format: i2d + // Operand stack: ..., value() -> ..., result(double) + case Const.F2D : + // Format: f2d + // Operand stack: ..., value() -> ..., result(double) + // Widening preserves the numeric value exactly, see VM Spec2, Section 2.6.2. + // For operation f2d there may be a rounding related to value set conversion. + stack.peek().setTypeBinding(Type.DOUBLE); + instruction = new NoOperation(); + break; + + case Const.INEG: + // Format: ineg + // Operand stack: ..., value() -> ..., result(int) + case Const.LNEG: + // Format: lneg + // Operand stack: ..., value() -> ..., result(long) + case Const.FNEG: + // Format: fneg + // Operand stack: ..., value() -> ..., result(float) + case Const.DNEG: + // Format: dneg + // Operand stack: ..., value() -> ..., result(double) + instruction = createPrefix(PrefixExpression.MINUS, stack.pop(), form.getResultType()); + break; + + case Const.ISHR : + // Format: ishr + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LSHR : + // Format: lshr + // Operand stack: ..., value1(), value2() -> ..., result(long) + instruction = createInfixRightLeft(InfixExpression.Operator.RIGHT_SHIFT_SIGNED, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.ISHL : + // Format: ishl + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LSHL : + // Format: lshl + // Operand stack: ..., value1(), value2() -> ..., result(long) + instruction = createInfixRightLeft(InfixExpression.Operator.LEFT_SHIFT, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.IUSHR : + // Format: iushr + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LUSHR : + // Format: lushr + // Operand stack: ..., value1(), value2() -> ..., result(long) + instruction = createInfixRightLeft(InfixExpression.Operator.RIGHT_SHIFT_UNSIGNED, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.IADD : + // Format: iadd + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LADD : + // Format: ladd + // Operand stack: ..., value1(), value2() -> ..., result(long) + case Const.FADD : + // Format: fadd + // Operand stack: ..., value1(), value2() -> ..., result(float) + case Const.DADD : + // Format: dadd + // Operand stack: ..., value1(double), value2(double) -> ..., result(double) + instruction = createInfixRightLeft(InfixExpression.Operator.PLUS, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.ISUB : + // Format: isub + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LSUB : + // Format: lsub + // Operand stack: ..., value1(), value2() -> ..., result(long) + case Const.FSUB : + // Format: fsub + // Operand stack: ..., value1(), value2() -> ..., result(float) + case Const.DSUB : + // Format: dsub + // Operand stack: ..., value1(double), value2(double) -> ..., result(double) + instruction = createInfixRightLeft(InfixExpression.Operator.MINUS, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.IMUL : + // Format: imul + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LMUL : + // Format: lmul + // Operand stack: ..., value1(), value2() -> ..., result(long) + case Const.FMUL : + // Format: fmul + // Operand stack: ..., value1(), value2() -> ..., result(float) + case Const.DMUL : + // Format: dmul + // Operand stack: ..., value1(), value2() -> ..., result(double) + instruction = createInfixRightLeft(InfixExpression.Operator.TIMES, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.IDIV : + // Format: idiv + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LDIV : + // Format: ldiv + // Operand stack: ..., value1(), value2() -> ..., result(long) + case Const.FDIV : + // Format: fdiv + // Operand stack: ..., value1(), value2() -> ..., result(float) + case Const.DDIV : + // Format: ddiv + // Operand stack: ..., value1(), value2() -> ..., result(double) + instruction = createInfixRightLeft(InfixExpression.Operator.DIVIDE, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.IREM : + // Format: irem + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LREM : + // Format: lrem + // Operand stack: ..., value1(), value2() -> ..., result(long) + case Const.FREM : + // Format: frem + // Operand stack: ..., value1(), value2() -> ..., result(float) + case Const.DREM : + // Format: drem + // Operand stack: ..., value1(), value2() -> ..., result(double) + instruction = createInfixRightLeft(InfixExpression.Operator.REMAINDER, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.IXOR : + // Format: ixor + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LXOR : + // Format: lxor + // Operand stack: ..., value1(), value2() -> ..., result(long) + instruction = createInfixRightLeft(InfixExpression.Operator.XOR, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.IAND : + // Format: iand + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LAND : + // Format: land + // Operand stack: ..., value1(), value2() -> ..., result(long) + instruction = createInfixRightLeft(InfixExpression.Operator.AND, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.IOR : + // Format: ior + // Operand stack: ..., value1(), value2() -> ..., result(int) + case Const.LOR : + // Format: lor + // Operand stack: ..., value1(), value2() -> ..., result(long) + instruction = createInfixRightLeft(InfixExpression.Operator.OR, stack.pop(), stack.pop(), form.getResultType()); + break; + + case Const.IINC : { + // Format: iinc, index(byte), const(int) + // Operand stack: ... -> ... + boolean isWide = wide; + int index = readUnsigned(); + // Reset wide flag. + wide = isWide; + int constByte = readSigned(); + + VariableBinding reference = createVariableBinding(index, Type.INT, true); + reference.setField(false); + +// if (stack.peek() instanceof VariableBinding) { +// if (reference.isSame(reference) && Math.abs(constByte) == 1) { +// stack.pop(); +// PostfixExpression pe = new PostfixExpression(); +// pe.setOperator(constByte==1?PStarExpression.INCREMENT:PStarExpression.DECREMENT); +// pe.setOperand(reference); +// instruction = pe; +// break; +// } +// } + + Assignment assign = new Assignment(Assignment.Operator.PLUS_ASSIGN); + assign.setLeftHandSide(reference); + assign.setRightHandSide(NumberLiteral.create(new Integer(constByte))); + instruction = assign; + break; + } + + case Const.ARRAYLENGTH : { + // Format: arraylength + // Operand stack: ..., arrayref() -> ..., length(int) + Expression arrayRef = stack.pop(); + FieldAccess access = new FieldRead(); + access.setExpression(arrayRef); + access.setName("length"); + //access.initialize(methodDecl); + instruction = access; + break; + } + + /* + * Remember wide byte which is used to form a 16-bit address in + * the following instruction. Relies on that the method is + * called again with the following opcode. + */ + case Const.WIDE : + // Format: wide + // Operand stack: ... -> ... + wide = true; + return new NoOperation(); + + case Const.ILOAD_0 : + // Format: iload_0 + // Operand stack: ... -> ..., value(int) + case Const.ILOAD_1 : + // Format: iload_1 + // Operand stack: ... -> ..., value(int) + case Const.ILOAD_2 : + // Format: iload_2 + // Operand stack: ... -> ..., value(int) + case Const.ILOAD_3 : { + // Format: iload_3 + // Operand stack: ... -> ..., value(int) + VariableBinding reference = createVariableBinding(opcode - Const.ILOAD_0, Type.INT, false); + reference.setField(false); + instruction = reference; + break; + } + + case Const.LLOAD_0 : + // Format: lload_0 + // Operand stack: ... -> ..., value(long) + case Const.LLOAD_1 : + // Format: lload_1 + // Operand stack: ... -> ..., value(long) + case Const.LLOAD_2 : + // Format: lload_2 + // Operand stack: ... -> ..., value(long) + case Const.LLOAD_3 : { + // Format: lload_3 + // Operand stack: ... -> ..., value(long) + VariableBinding reference = createVariableBinding(opcode - Const.LLOAD_0, Type.LONG, false); + reference.setField(false); + instruction = reference; + break; + } + + case Const.FLOAD_0 : + // Format: fload_0 + // Operand stack: ... -> ..., value(float) + case Const.FLOAD_1 : + // Format: fload_1 + // Operand stack: ... -> ..., value(float) + case Const.FLOAD_2 : + // Format: fload_2 + // Operand stack: ... -> ..., value(float) + case Const.FLOAD_3 : { + // Format: fload_3 + // Operand stack: ... -> ..., value(float) + VariableBinding reference = createVariableBinding(opcode - Const.FLOAD_0, Type.FLOAT, false); + reference.setField(false); + instruction = reference; + break; + } + + case Const.DLOAD_0 : + // Format: dload_0 + // Operand stack: ... -> ..., value(double) + case Const.DLOAD_1 : + // Format: dload_1 + // Operand stack: ... -> ..., value(double) + case Const.DLOAD_2 : + // Format: dload_2 + // Operand stack: ... -> ..., value(double) + case Const.DLOAD_3 : { + // Format: dload_3 + // Operand stack: ... -> ..., value(double) + VariableBinding reference = createVariableBinding(opcode - Const.DLOAD_0, Type.DOUBLE, false); + reference.setField(false); + instruction = reference; + break; + } + + case Const.ALOAD_0 : + // Format: aload_0 + // Operand stack: ... -> ..., objectref(object) + case Const.ALOAD_1 : + // Format: aload_1 + // Operand stack: ... -> ..., objectref(object) + case Const.ALOAD_2 : + // Format: aload_2 + // Operand stack: ... -> ..., objectref(object) + case Const.ALOAD_3 : { + // Format: aload_3 + // Operand stack: ... -> ..., objectref(object) + if (opcode == Const.ALOAD_0 && !Modifier.isStatic(methodDecl.getAccess())) { + ThisExpression reference = new ThisExpression(); + instruction = reference; + } else { + VariableBinding reference = createVariableBinding(opcode - Const.ALOAD_0, Type.OBJECT, false); + reference.setField(true); + instruction = reference; + } + break; + } + + case Const.ILOAD : + // Format: iload, index(byte) + // Operand stack: ... -> ..., value(int) + case Const.LLOAD : + // Format: lload, index(byte) + // Operand stack: ... -> ..., value(long) + case Const.FLOAD : + // Format: fload, index(byte) + // Operand stack: ... -> ..., value(float) + case Const.DLOAD : { + // Format: dload, index(byte) + // Operand stack: ... -> ..., value(double) + VariableBinding reference = createVariableBinding(readUnsigned(), form.getResultType(), false); + reference.setField(false); + instruction = reference; + break; + } + + case Const.ALOAD : { + // Format: aload, index(byte) + // Operand stack: ... -> ..., objectref(object) + VariableBinding reference = createVariableBinding(readUnsigned(), Type.OBJECT, false); + reference.setField(true); + instruction = reference; + break; + } + + case Const.BALOAD : + // Format: baload + // Operand stack: ..., arrayref(), index() -> ..., value(int) + case Const.CALOAD : + // Format: caload + // Operand stack: ..., arrayref(), index() -> ..., value(int) + case Const.SALOAD : + // Format: saload + // Operand stack: ..., arrayref(), index() -> ..., value(short) + case Const.IALOAD : + // Format: iaload + // Operand stack: ..., arrayref(), index() -> ..., value(int) + case Const.LALOAD : + // Format: laload + // Operand stack: ..., arrayref(), index() -> ..., value(long) + case Const.FALOAD : + // Format: faload + // Operand stack: ..., arrayref(), index() -> ..., value(float) + case Const.DALOAD : + // Format: daload + // Operand stack: ..., arrayref(), index() -> ..., value(double) + case Const.AALOAD : { + // Format: aaload + // Operand stack: ..., arrayref(), index() -> ..., objectref(object) + Expression index = stack.pop(); + Expression arrayRef = stack.pop(); + ArrayAccess aa; + aa = new ArrayAccess(); + aa.setTypeBinding(form.getResultType()); + aa.setArray(arrayRef); + aa.setIndex(index); + + instruction = aa; + break; + } + + case Const.BASTORE : + // Format: bastore + // Operand stack: ..., arrayref(), index(), value() -> ... + case Const.CASTORE : + // Format: castore + // Operand stack: ..., arrayref(), index(), value() -> ... + case Const.SASTORE : + // Format: sastore + // Operand stack: ..., array(), index(), value() -> ... + case Const.IASTORE : + // Format: iastore + // Operand stack: ..., arrayref(), index(), value() -> ... + case Const.LASTORE : + // Format: lastore + // Operand stack: ..., arrayref(), index(), value() -> ... + case Const.FASTORE : + // Format: fastore + // Operand stack: ..., arrayref(), index(), value() -> ... + case Const.DASTORE : + // Format: dastore + // Operand stack: ..., arrayref(), index(), value() -> ... + case Const.AASTORE : { + // Format: aastore + // Operand stack: ..., arrayref(), index(), value() -> ... + Expression value = stack.pop(); + Expression index = stack.pop(); + Expression arrayRef = stack.pop(); + if (arrayRef instanceof ArrayCreation) { + ArrayCreation ac = (ArrayCreation) arrayRef; + if (ac.getInitializer() == null) { + ac.setInitializer(new ArrayInitializer()); + } + ac.getInitializer().getExpressions().add(value); + instruction = new NoOperation(); + break; + } + Assignment a = new Assignment(Assignment.Operator.ASSIGN); + + ArrayAccess aa; + aa = new ArrayAccess(); + aa.setArray(arrayRef); + aa.setIndex(index); + + a.setLeftHandSide(aa); + a.setRightHandSide(value); + instruction = a; + break; + } + + + case Const.DSTORE : + // Format: dstore, index(byte) + // Operand stack: ..., value(double) -> ... + case Const.DSTORE_0 : + // Format: dstore_0 + // Operand stack: ..., value(double) -> ... + case Const.DSTORE_1 : + // Format: dstore_1 + // Operand stack: ..., value(double) -> ... + case Const.DSTORE_2 : + // Format: dstore_2 + // Operand stack: ..., value(double) -> ... + case Const.DSTORE_3 : { + // Format: dstore_3 + // Operand stack: ..., value(double) -> ... + int index; + if (opcode == Const.DSTORE) { + index = readUnsigned(); + } else { + index = opcode - Const.DSTORE_0; + } + Assignment a = new Assignment(Assignment.Operator.ASSIGN); + VariableBinding reference = createVariableBinding(index, Type.DOUBLE, true); + reference.setField(false); + a.setLeftHandSide(reference); + a.setRightHandSide(stack.pop()); + instruction = a; + break; + } + + case Const.FSTORE : + // Format: fstore, index(byte) + // Operand stack: ..., value() -> ... + case Const.FSTORE_0 : + // Format: fstore_0 + // Operand stack: ..., value(float) -> ... + case Const.FSTORE_1 : + // Format: fstore_1 + // Operand stack: ..., value(float) -> ... + case Const.FSTORE_2 : + // Format: fstore_2 + // Operand stack: ..., value(float) -> ... + case Const.FSTORE_3 : { + // Format: fstore_3 + // Operand stack: ..., value(float) -> ... + int index; + if (opcode == Const.FSTORE) { + index = readUnsigned(); + } else { + index = opcode - Const.FSTORE_0; + } + Assignment a = new Assignment(Assignment.Operator.ASSIGN); + VariableBinding reference = createVariableBinding(index, Type.FLOAT, true); + reference.setField(false); + a.setLeftHandSide(reference); + a.setRightHandSide(stack.pop()); + instruction = a; + break; + } + + case Const.ISTORE : + // Format: istore, index(byte) + // Operand stack: ..., value() -> ... + case Const.ISTORE_0 : + // Format: istore_0 + // Operand stack: ..., value() -> ... + case Const.ISTORE_1 : + // Format: istore_1 + // Operand stack: ..., value() -> ... + case Const.ISTORE_2 : + // Format: istore_2 + // Operand stack: ..., value() -> ... + case Const.ISTORE_3 : { + // Format: istore_3 + // Operand stack: ..., value() -> ... + int index; + if (opcode == Const.ISTORE) { + index = readUnsigned(); + } else { + index = opcode - Const.ISTORE_0; + } + Assignment a = new Assignment(Assignment.Operator.ASSIGN); + VariableBinding reference = createVariableBinding(index, Type.INT, true); + reference.setField(false); + a.setLeftHandSide(reference); + a.setRightHandSide(stack.pop()); + instruction = a; + break; + } + + case Const.LSTORE : + // Format: lstore, index(byte) + // Operand stack: ..., value() -> ... + case Const.LSTORE_0 : + // Format: lstore_0 + // Operand stack: ..., value() -> ... + case Const.LSTORE_1 : + // Format: lstore_1 + // Operand stack: ..., value() -> ... + case Const.LSTORE_2 : + // Format: lstore_2 + // Operand stack: ..., value() -> ... + case Const.LSTORE_3 : { + // Format: lstore_3 + // Operand stack: ..., value() -> ... + int index; + if (opcode == Const.LSTORE) { + index = readUnsigned(); + } else { + index = opcode - Const.LSTORE_0; + } + Assignment a = new Assignment(Assignment.Operator.ASSIGN); + VariableBinding reference = createVariableBinding(index, Type.LONG, true); + reference.setField(false); + a.setLeftHandSide(reference); + a.setRightHandSide(stack.pop()); + instruction = a; + break; + } + + case Const.ASTORE : + // Format: astore, index(byte) + // Operand stack: ..., objectref() -> ... + case Const.ASTORE_0 : + // Format: astore_0 + // Operand stack: ..., objectref() -> ... + case Const.ASTORE_1 : + // Format: astore_1 + // Operand stack: ..., objectref() -> ... + case Const.ASTORE_2 : + // Format: astore_2 + // Operand stack: ..., objectref() -> ... + case Const.ASTORE_3 : { + // Format: astore_3 + // Operand stack: ..., objectref() -> ... + + Assignment a = new Assignment(Assignment.Operator.ASSIGN); + int index; + if (opcode==Const.ASTORE) { + index = readUnsigned(); + } else { + index = (opcode - Const.ASTORE_0); + } + VariableBinding reference = createVariableBinding(index, Type.OBJECT, true); + a.setLeftHandSide(reference); + + // This may be the first instruction of an exception handler. + // It will store the implied exception. This exception is pushed onto the + // stack by makeTryFrames(). However, if the handler is unreachable, the + // Java Compiler may not generate an exception handler, and the stack is therefore + // empty. + // TODO: Refactor this Class by using org.apache.bcel.generic.InstructionList() + // and having two passes, not just one! + if (stack.size() > 0) { + a.setRightHandSide(stack.pop()); + } + instruction = a; + break; + } + + case Const.ATHROW: { + // Format: athrow + // Operand stack: ..., objectref() -> ..., objectref(object) + ThrowStatement throwStmt = new ThrowStatement(); + throwStmt.setExpression(stack.pop()); + instruction = throwStmt; + break; + } + + case Const.ICONST_M1 : + // Format: iconst_m1 + // Operand stack: ... -> ..., i(int) + case Const.ICONST_0 : + // Format: iconst_0 + // Operand stack: ... -> ..., i(int) + case Const.ICONST_1 : + // Format: iconst_1 + // Operand stack: ... -> ..., i(int) + case Const.ICONST_2 : + // Format: iconst_2 + // Operand stack: ... -> ..., i(int) + case Const.ICONST_3 : + // Format: iconst_3 + // Operand stack: ... -> ..., i(int) + case Const.ICONST_4 : + // Format: iconst_4 + // Operand stack: ... -> ..., i(int) + case Const.ICONST_5 : + // Format: iconst_5 + // Operand stack: ... -> ..., i(int) + instruction = NumberLiteral.create(new Integer(-1 + opcode - Const.ICONST_M1)); + break; + + case Const.LCONST_0 : + // Format: lconst_0 + // Operand stack: ... -> ..., l(long) + case Const.LCONST_1 : + // Format: lconst_1 + // Operand stack: ... -> ..., l(long) + // Push the long constant 0 or 1 onto the operand stack. + instruction = NumberLiteral.create(new Long(opcode - Const.LCONST_0)); + break; + + case Const.FCONST_0 : + // Format: fconst_0 + // Operand stack: ... -> ..., f(float) + case Const.FCONST_1 : + // Format: fconst_1 + // Operand stack: ... -> ..., f(float) + case Const.FCONST_2 : + // Format: fconst_2 + // Operand stack: ... -> ..., f(float) + // Push the float constant 0.0, 1.0 or 2.0 onto the operand stack. + instruction = NumberLiteral.create(new Float(opcode - Const.FCONST_0)); + break; + + case Const.DCONST_0 : + // Format: dconst_0 + // Operand stack: ... -> ..., d(double) + case Const.DCONST_1 : + // Format: dconst_1 + // Operand stack: ... -> ..., d(double) + // Push the double constant 0.0 or 1.0 onto the operand stack. + instruction = NumberLiteral.create(new Double(opcode - Const.DCONST_0)); + break; + + case Const.BIPUSH : { + // Format: bipush, byte(byte) + // Operand stack: ... -> ..., value(int) + NumberLiteral literal = NumberLiteral.create(new Byte(bytes.readByte())); + instruction = literal; + break; + } + + case Const.SIPUSH : { + // Format: sipush + // Operand stack: ... -> ..., value(short) + NumberLiteral il = NumberLiteral.create(new Short(bytes.readShort())); + instruction = il; + break; + } + + case Const.LDC : + // Format: ldc, index(byte) + // Operand stack: ... -> ..., value(cat1) + case Const.LDC_W : + // Format: ldc_w + // Operand stack: ... -> ..., value(cat1) + case Const.LDC2_W : { + // Format: ldc2_w + // Operand stack: ... -> ..., value(cat1) + int index; + if (opcode == Const.LDC) { + index = bytes.readUnsignedByte(); + } else { + index = bytes.readUnsignedShort(); + } + Constant constant = constantPool.getConstant(index); + + if (opcode==Const.LDC2_W && (constant.getTag()!=Constants.CONSTANT_Double && constant.getTag()!=Constants.CONSTANT_Long)) + throw new RuntimeException("LDC2_W must load long or double"); + + if (constant.getTag() == Constants.CONSTANT_Integer) { + instruction = NumberLiteral.create(new Integer(((ConstantInteger) constant).getBytes())); + } else if (constant.getTag() == Constants.CONSTANT_Float) { + instruction = NumberLiteral.create(new Float(((ConstantFloat) constant).getBytes())); + } else if (constant.getTag() == Constants.CONSTANT_Long) { + instruction = NumberLiteral.create(new Long(((ConstantLong) constant).getBytes())); + } else if (constant.getTag() == Constants.CONSTANT_Double) { + instruction = NumberLiteral.create(new Double(((ConstantDouble) constant).getBytes())); + } else if (constant.getTag() == Constants.CONSTANT_Utf8) { + instruction = new StringLiteral(((ConstantUtf8) constant).getBytes()); + } else if (constant.getTag() == Constants.CONSTANT_String) { + int k = ((ConstantString) constant).getStringIndex(); + constant = constantPool.getConstant(k, Constants.CONSTANT_Utf8); + instruction = new StringLiteral(((ConstantUtf8) constant).getBytes()); + } else if (constant.getTag() == Constants.CONSTANT_Class) { + Signature signature = Project.getSingleton().getSignature(((ConstantClass) constant).getBytes(constantPool)); + instruction = new ClassLiteral(signature); + } else { + throw new RuntimeException("Cannot handle constant tag: " + constant.getTag()); + } + break; + } + + + case Const.RET: { + // Format: ret, index(byte) + // Operand stack: ... -> ... + int index = readUnsigned(); + ReturnStatement r = new ReturnStatement(currentIndex, currentIndex); + r.setExpression(createVariableBinding(index, Type.INT, false)); + instruction = r; + break; + } + + case Const.RETURN: + // Format: return + // Operand stack: ... -> ... + case Const.IRETURN: + // Format: ireturn + // Operand stack: ..., value() -> ... + case Const.FRETURN: + // Format: freturn + // Operand stack: ..., value() -> ... + case Const.LRETURN: + // Format: lreturn + // Operand stack: ..., value() -> ... + case Const.DRETURN: + // Format: dreturn + // Operand stack: ..., value(double) -> ... + case Const.ARETURN: { + // Format: areturn + // Operand stack: ..., objectref() -> ... + ReturnStatement r = new ReturnStatement(currentIndex, currentIndex); + if (opcode != Const.RETURN) { + r.setExpression(stack.pop()); + } + instruction = r; + break; + } + + case Const.POP : + // Format: pop + // Operand stack: ..., value(cat1) -> ... + case Const.POP2: { + // (0) Format: pop2 + // (0) Operand stack: ..., value(cat2) -> ... + // (1) Format: pop2 + // (1) Operand stack: ..., value2(cat1), value1(cat1) -> ... + + if (opcode == Const.POP2 && form.getIndex() == 1) { + throw new UnsupportedOperationException("InstructionType " + instructionType.getName() + " not supported"); + } + + //instruction = stack.pop(); + // TODO: Which is correct? + // Node is probably an invokation of a method with unused result. + ASTNode a = stack.pop(); + if (!(a instanceof VariableBinding)) { + // Can't have binding on stack! TODO: VariableBinding must not be an ASTNode, + // because it has no location. + cNode.block.appendChild(a); + } + instruction = new NoOperation(); + break; + } + + case Const.NOP : + // Format: nop + // Operand stack: ... -> ... + return new NoOperation(); + + case Const.XXXUNUSEDXXX : + // Format: xxxunusedxxx + // Operand stack: ... -> ... + logger.info("Byte code contains unused operation (Ignored)"); + return new NoOperation(); + + case Const.INVOKEINTERFACE : + // Format: invokeinterface, index(short), count(byte), 0(byte) + // Operand stack: ..., objectref(), arg1(), ...(), argN() -> ... + case Const.INVOKESPECIAL : + // Format: invokespecial + // Operand stack: ..., objectref(), arg1(), ...(), argN() -> ... + case Const.INVOKEVIRTUAL : + // Format: invokevirtual + // Operand stack: ..., objectref(), arg1(), ...(), argN() -> ... + case Const.INVOKESTATIC : { + // Format: invokestatic, index(short) + // Operand stack: ..., arg1(), ...(), argN() -> ... + int index = bytes.readUnsignedShort(); + MethodBinding methodBinding = MethodBinding.lookup(index, constantPool); + MethodInvocation invocation = new MethodInvocation(methodDecl, methodBinding); + + //Processor.getLogger().finer(method.getName() + "->" + invocation.binding); + + int nArgs = methodBinding.getParameterTypes().length; + int kk = stack.size() - nArgs; + for (int i=0; i 0 && stack.peek() instanceof ClassInstanceCreation && methodBinding.getName().equals("")) { +// ClassInstanceCreation cic = (ClassInstanceCreation) stack.pop(); +// List args = invocation.getArguments(); +// for (int i=0; i ... + SynchronizedBlock sb = new SynchronizedBlock(); + sb.monitor = stack.pop(); + sb.widen(sb.monitor); + sb.setEndIndex(currentIndex); + instruction = sb; + break; + } + case Const.MONITOREXIT : + // Format: monitorexit + // Operand stack: ..., objectref() -> ... + instruction = new NoOperation(); + instruction.widen(stack.pop()); + instruction.setEndIndex(currentIndex); + break; + + default : + throw new UnsupportedOperationException("InstructionType " + instructionType.getName() + " not supported"); + //break; + } + + if (opcode!=Const.WIDE && wide) throw new RuntimeException("Expected wide operation"); + + instruction.setStackDelta(opStackDelta); + if (opcode < Const.DUP || opcode > Const.DUP2_X2) { + instruction.leftWiden(currentIndex); + instruction.rightWiden(bytes.getIndex()-1); + } + currentNode = instruction; + return instruction; + } + + ConditionalBranch createConditional(int currentIndex, InfixExpression.Operator operator) throws IOException { + ConditionalBranch c = new ConditionalBranch(currentIndex + bytes.readShort()); + InfixExpression be = new InfixExpression(operator); + Expression rightOperand = stack.pop(); + be.setOperands(stack.pop(),rightOperand); + c.setExpression(be); + return c; + } + + ConditionalBranch createConditional(int currentIndex, InfixExpression.Operator operator, + Expression rightOperand) throws IOException { + ConditionalBranch c = new ConditionalBranch(currentIndex + bytes.readShort()); + Expression leftOperand = stack.pop(); + + if (leftOperand.getTypeBinding()!=null && leftOperand.getTypeBinding()==Type.BOOLEAN) { + if (operator == InfixExpression.Operator.EQUALS && NumberLiteral.isZero(rightOperand)) { + c.setExpression(Optimizer.negate(leftOperand)); + } else { + c.setExpression(leftOperand); + } + } else { + InfixExpression be = new InfixExpression(operator); + be.setOperands(leftOperand, rightOperand); + c.setExpression(be); + } + + return c; + } + + private String getFieldName(ConstantFieldref fieldRef) { + ConstantNameAndType nameAndType = (ConstantNameAndType) constantPool.getConstant(fieldRef.getNameAndTypeIndex()); + return nameAndType.getName(constantPool); + } + + public static String constantToString(Constant c, ConstantPool constantPool) throws ClassFormatException { + String str; + byte tag = c.getTag(); + + switch (tag) { + case Constants.CONSTANT_Class : + str = Utility.compactClassName(((ConstantClass) c).getBytes(constantPool), false); + break; + + case Constants.CONSTANT_String : + str = "\"" + Utils.escape(((ConstantString) c).getBytes(constantPool)) + "\""; + break; + + case Constants.CONSTANT_Utf8 : + str = ((ConstantUtf8) c).getBytes(); + break; + case Constants.CONSTANT_Double : + str = "" + ((ConstantDouble) c).getBytes(); + break; + case Constants.CONSTANT_Float : + str = "" + ((ConstantFloat) c).getBytes(); + break; + case Constants.CONSTANT_Long : + str = "" + ((ConstantLong) c).getBytes(); + break; + case Constants.CONSTANT_Integer : + str = "" + ((ConstantInteger) c).getBytes(); + break; + + case Constants.CONSTANT_NameAndType : + str = ((ConstantNameAndType) c).getName(constantPool); + break; + + case Constants.CONSTANT_InterfaceMethodref : + case Constants.CONSTANT_Methodref : + case Constants.CONSTANT_Fieldref : + str = ((ConstantCP) c).getClass(constantPool); + break; + + default : // Never reached + throw new RuntimeException("Unknown constant type " + tag); + } + + return str; + } + +} diff --git a/src/main/java/com/j2js/Utils.java b/src/main/java/com/j2js/Utils.java new file mode 100644 index 0000000..84f4347 --- /dev/null +++ b/src/main/java/com/j2js/Utils.java @@ -0,0 +1,160 @@ +package com.j2js; + +import com.j2js.J2JSCompiler; + +import java.io.File; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.text.DateFormat; +import java.util.Date; +import java.util.Properties; + + +import org.apache.bcel.generic.ArrayType; +import org.apache.bcel.generic.BasicType; +import org.apache.bcel.generic.ObjectType; +import org.apache.bcel.generic.Type; + +import com.j2js.dom.ASTNode; +import com.j2js.dom.MethodDeclaration; + +/** + * @author j2js.com + */ +public final class Utils { + + private static final String propertiesFile = "j2js.properties"; + private static final Properties properties; + + static { + properties = new Properties(); + try { + properties.load(Utils.class.getClassLoader().getResourceAsStream(propertiesFile)); + } catch (Exception e) { + J2JSCompiler.errorCount++; + Log.getLogger().error("Could not read from classpath: " + propertiesFile); + throw new RuntimeException(e); + } + } + + private Utils() {} + + public static String generateExceptionMessage(MethodDeclaration methodDecl, ASTNode node) { + String msg = null; + if (node != null) { + int line = methodDecl.getLineNumberCursor().getLineNumber(node); + if (line != -1) { + msg = "Error near line " + line; + } + } + if (msg == null) { + msg = "Error"; + } + + msg += " in " + methodDecl.getMethodBinding(); + + return msg; + } + + public static RuntimeException generateException(Throwable e, MethodDeclaration methodDecl, ASTNode node) { + String msg = generateExceptionMessage(methodDecl, node); + J2JSCompiler.errorCount++; + Log.getLogger().error(msg); + return new RuntimeException(msg, e); + } + + public static String stackTraceToString(Throwable e) { + StringWriter sw = new StringWriter(); + PrintWriter writer = new PrintWriter(sw); + e.printStackTrace(writer); + writer.close(); + return sw.getBuffer().toString(); + } + + public static String currentTimeStamp() { + return DateFormat.getDateTimeInstance().format(new Date()); + } + + public static String getVersion() { + return (String) properties.get("j2js.version"); + } + + public static String getProperty(String key) { + return (String) properties.get(key); + } + + public static String getSignature(Type type) { + String signature; + + if (type instanceof ArrayType) { + ArrayType aType = (ArrayType) type; + signature = getSignature(aType.getBasicType()); + for (int i = 0; i declaredMembers; + + // The super class. + private ClassUnit superUnit; + + // All interfaces implemented by this unit. + private Collection interfaces; + + // All derived classes. + private Collection subUnits; + + public boolean isInterface = false; + + public boolean isConstructorTainted = false; + + public Map[] annotations; + + private Project project; + + // Transient fields start here. + private transient boolean isResolved = false; + + // The class file of this unit. + private transient FileObject classFile; + + public ClassUnit() { + } + + public ClassUnit(Project theProject, Signature theSignature) { + project = theProject; + + interfaces = new HashSet(); + declaredMembers = new HashMap(); + subUnits = new HashSet(); + lastCompiled = -1; + setSignature(theSignature); + } + + /** + * Reset all fields filled by compilation. + */ + void clear() { + // Do not remove registered subunits! + lastCompiled = -1; + removeInterfaces(); + setSuperUnit(null); + declaredMembers.clear(); + } + + /** + * Returns true if this unit is up to date. + */ + public boolean isUpToDate() { + return lastCompiled >= getLastModified(); + } + + public Collection getInterfaces() { + return interfaces; + } + + public void addInterface(ClassUnit interfaceUnit) { + interfaces.add(interfaceUnit); + //interfaceUnit.addSubUnit(this); + } + + private void removeInterfaces() { + Iterator iter = interfaces.iterator(); + while (iter.hasNext()) { + ClassUnit interfaceUnit = (ClassUnit) iter.next(); + interfaceUnit.removeSubUnit(this); + iter.remove(); + } + } + + public void addSubUnit(ClassUnit subUnit) { + if (subUnit == null) throw new NullPointerException(); + subUnits.add(subUnit); + } + + public void removeSubUnit(ClassUnit subUnit) { + if (subUnit == null) throw new NullPointerException(); + subUnits.remove(subUnit); + } + + public Collection getSubUnits() { + return subUnits; + } + + /** + * Returns the declared member with the specified signature. + */ + public MemberUnit getDeclaredMember(String signature) { + if (signature == null) throw new NullPointerException(); + return declaredMembers.get(signature); + } + + /** + * Returns all types to which this class can be converted, i.e., the collection of + * all supertypes and implemented interfaces and the class itself. + */ + public Collection getSupertypes() { + TypeCollector collector = new TypeCollector(); + project.visitSuperTypes(this, collector); + return collector.collectedTypes; + } + + /** + * Returns a member object that reflects the specified public member method of the class + * or interface represented by this Class object. + */ +// public MemberUnit getMember(String signature) { +// if (signature == null) throw new NullPointerException(); +// +// ClassUnit clazz = this; +// do { +// MemberUnit member = clazz.getDeclaredMember(signature); +// if (member != null) return member; +// clazz = clazz.getSuperUnit(); +// } while (clazz != null); +// +// return null; +// } + + public Collection getMembers(String signature) { + if (signature == null) throw new NullPointerException(); + ArrayList list = new ArrayList(); + + for (ClassUnit clazz : getSupertypes()) { + MemberUnit member = clazz.getDeclaredMember(signature); + if (member != null) list.add(member); + } + + return list; + } + + public Collection getDeclaredMembers() { + if (!isResolved) throw new RuntimeException("Class is not yet resolved: " + getName()); + return declaredMembers.values(); + } + + public void addMemberUnit(MemberUnit unit) { + declaredMembers.put(unit.getSignature().toString(), unit); + } + + public ClassUnit getSuperUnit() { + return superUnit; + } + + public void setSuperUnit(ClassUnit theSuperUnit) { + if (superUnit != null) { + superUnit.removeSubUnit(this); + } + superUnit = theSuperUnit; + if (superUnit != null) { + superUnit.addSubUnit(this); + } + } + + public void write(int depth, Writer writer) throws IOException { + if (!isTainted()) return; + + Log.getLogger().debug(getIndent(depth) + this); + + if (getData() != null) { + writer.write(getData()); + } else { + // TODO: Is it correct to return so soon? + return; + } + + if (interfaces.size() > 0) { + //Logger.getLogger().info("Class + " + this.getName() + " has interfaces: "); + + writer.write("_T.interfaces = ["); + int i = 0; + for (ClassUnit interFace : interfaces) { + //Logger.getLogger().info(">>>" + interFace.getName()); + if (i++ > 0) writer.write(", "); + writer.write(String.valueOf(interFace.getSignature().getId())); + } + writer.write("];\n"); + } + + if (annotations != null) { + writer.write("_T.annotations = "); + Serializer serializer = new Serializer(writer); + serializer.serialize(annotations); + writer.write(";\n"); + } + + for (MemberUnit member : getDeclaredMembers()) { + if (member.isTainted()) { + member.write(depth + 1, writer); + if (member instanceof ProcedureUnit) { + project.currentGeneratedMethods++; + writer.flush(); + } + } + } + + for (ClassUnit child : getSubUnits()) { + // TODO Interface: Interfaces must not extend java.lang.Object! + //if (!child.isInterface) { + child.write(depth + 1, writer); + //} + } + } + + void setSignature(Signature theSignature) { + super.setSignature(theSignature); + } + + public FileObject getClassFile() { + if (classFile == null) { + classFile = J2JSCompiler.compiler.fileManager.getFileForInput( + getSignature().toString().replaceAll("\\.", "/") + ".class"); + } + return classFile; + } + + public void setLastCompiled(long theLastCompiled) { + lastCompiled = theLastCompiled; + } + + public boolean isResolved() { + return isResolved; + } + + public void setSuperTainted() { + ClassUnit clazz = this; + do { + clazz.setTainted(); + clazz = clazz.getSuperUnit(); + } while (clazz != null); + + for (ClassUnit i : interfaces) { + i.setSuperTainted(); + } + } + + public void setResolved(boolean theIsResolved) { + isResolved = theIsResolved; + } + public String getName() { + return getSignature().className(); + } + + public Project getProject() { + return project; + } + +} diff --git a/src/main/java/com/j2js/assembly/ConstructorUnit.java b/src/main/java/com/j2js/assembly/ConstructorUnit.java new file mode 100644 index 0000000..4e4a3a5 --- /dev/null +++ b/src/main/java/com/j2js/assembly/ConstructorUnit.java @@ -0,0 +1,14 @@ +package com.j2js.assembly; + +/** + * ConstructorUnit provides information about, and access to, a single constructor for a class. + * + * @author wolle + */ +public class ConstructorUnit extends ProcedureUnit { + + public ConstructorUnit(Signature theSignature, ClassUnit theDeclaringClazz) { + super(theSignature, theDeclaringClazz); + } + +} diff --git a/src/main/java/com/j2js/assembly/FieldUnit.java b/src/main/java/com/j2js/assembly/FieldUnit.java new file mode 100644 index 0000000..5f5f297 --- /dev/null +++ b/src/main/java/com/j2js/assembly/FieldUnit.java @@ -0,0 +1,21 @@ +package com.j2js.assembly; + +import java.io.IOException; +import java.io.Writer; + +/** + * A FieldUnit provides information about, and dynamic access to, a single field of a class or an interface. + * + * @author wolle + */ +public class FieldUnit extends MemberUnit { + + public FieldUnit(Signature theSignature, ClassUnit theDeclaringClazz) { + super(theSignature, theDeclaringClazz); + } + + void write(int depth, Writer writer) throws IOException { + return; + } + +} diff --git a/src/main/java/com/j2js/assembly/JavaScriptCompressor.java b/src/main/java/com/j2js/assembly/JavaScriptCompressor.java new file mode 100644 index 0000000..fbf449e --- /dev/null +++ b/src/main/java/com/j2js/assembly/JavaScriptCompressor.java @@ -0,0 +1,69 @@ +package com.j2js.assembly; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; + +public class JavaScriptCompressor { + + private int CODE = 0; + private int LINECOMMENT = 1; + private int MULTILINECOMMENT = 2; + private int STRING = 3; + + public String compress(InputStream input) throws FileNotFoundException, IOException { + BufferedReader reader = new BufferedReader(new InputStreamReader(input)); + StringBuffer buffer = new StringBuffer(); + int state = CODE; + char c; + char lastC = 0; + + do { + int i = reader.read(); + if (i == -1) break; + c = (char) i; + + if (state == LINECOMMENT) { + if (c == '\n') { + state = CODE; + buffer.append(c); + } // else ignore character. + } else if (state == MULTILINECOMMENT) { + if (c == '/' && lastC == '*') { + state = CODE; + } // else ignore character. + } else if (state == STRING) { + if (c == '"') { + state = CODE; + } + buffer.append(c); + } else if (c == '/' && lastC == c) { + state = LINECOMMENT; + buffer.deleteCharAt(buffer.length()-1); + } else if (c == '*' && lastC == '/') { + state = MULTILINECOMMENT; + buffer.deleteCharAt(buffer.length()-1); + } else if (c == '"') { + state = STRING; + buffer.append(c); + } else { + int length = buffer.length(); + if (length > 0 && Character.isWhitespace(c) && Character.isWhitespace(buffer.charAt(length-1))) { + + } else { + buffer.append(c); + } + } + lastC = c; + } while (true); + + reader.close(); + + return buffer.toString(); + } + +} diff --git a/src/main/java/com/j2js/assembly/JunkWriter.java b/src/main/java/com/j2js/assembly/JunkWriter.java new file mode 100644 index 0000000..740d590 --- /dev/null +++ b/src/main/java/com/j2js/assembly/JunkWriter.java @@ -0,0 +1,81 @@ +package com.j2js.assembly; + +import com.j2js.J2JSCompiler; + +import java.io.File; +import java.io.FileWriter; +import java.io.FilterWriter; +import java.io.IOException; +import java.io.StringWriter; + +import com.j2js.Log; + +public class JunkWriter extends FilterWriter { + + private File assembly; + private int junkCount = 0; + private int sizeOfCurrentJunk; + private int sizeOfAllJunks = 0; + + public JunkWriter(File assembly) throws IOException { + super(new StringWriter()); + this.assembly = assembly; + startNewJunk(); + } + + private void startNewJunk() throws IOException { + sizeOfAllJunks += sizeOfCurrentJunk; + + if (junkCount > 0) { + write("j2js.loadScript(" + sizeOfAllJunks + ");"); + out.flush(); + out.close(); + } + + Log logger = Log.getLogger(); + String newJunkName = (junkCount + 1) + ".js"; + logger.info("Creating assembly " + newJunkName); + out = new FileWriter(new File(assembly, newJunkName)); + sizeOfCurrentJunk = 0; + junkCount++; + } + + @Override + public void write(char[] cbuf, int off, int len) throws IOException { + super.write(cbuf, off, len); + sizeOfCurrentJunk += len; + } + + @Override + public void write(int c) throws IOException { + super.write(c); + sizeOfCurrentJunk++; + } + + @Override + public void write(String str, int off, int len) throws IOException { + super.write(str, off, len); + sizeOfCurrentJunk += len; + } + + @Override + public void flush() throws IOException { + super.flush(); + if (sizeOfCurrentJunk/1024 > J2JSCompiler.compiler.getJunkSizeInKiloBytes()) { + startNewJunk(); + } + } + + @Override + public void close() throws IOException { + sizeOfAllJunks += sizeOfCurrentJunk; + // Set to 0 in case super.close() calls flush(). + sizeOfCurrentJunk = 0; + super.close(); + } + + public int getSize() { + return sizeOfAllJunks; + } + +} diff --git a/src/main/java/com/j2js/assembly/MemberUnit.java b/src/main/java/com/j2js/assembly/MemberUnit.java new file mode 100644 index 0000000..1bbe86d --- /dev/null +++ b/src/main/java/com/j2js/assembly/MemberUnit.java @@ -0,0 +1,32 @@ +package com.j2js.assembly; + +/** + * The MemberUnit class is the base class for Field, Method and Constructor objects. + * + * @author wolle + */ +public abstract class MemberUnit extends Unit { + + // The class to which this method belongs. + ClassUnit declaringClass; + + MemberUnit(Signature theSignature, ClassUnit theDeclaringClazz) { + setSignature(theSignature); + declaringClass = theDeclaringClazz; + declaringClass.addMemberUnit(this); + } + + public ClassUnit getDeclaringClass() { + return declaringClass; + } + + public Signature getAbsoluteSignature() { + Signature s = Project.getSingleton().getSignature(declaringClass.toString(), getSignature().toString()); + return s; + } + + public String toString() { + return declaringClass.getName() + "#" + super.toString(); + } + +} diff --git a/src/main/java/com/j2js/assembly/MethodUnit.java b/src/main/java/com/j2js/assembly/MethodUnit.java new file mode 100644 index 0000000..6e85ab9 --- /dev/null +++ b/src/main/java/com/j2js/assembly/MethodUnit.java @@ -0,0 +1,14 @@ +package com.j2js.assembly; + +/** + * A MethodUnit provides information about, and access to, a single method on a class or interface. + * + * @author wolle + */ +public class MethodUnit extends ProcedureUnit { + + public MethodUnit(Signature theSignature, ClassUnit theDeclaringClazz) { + super(theSignature, theDeclaringClazz); + } + +} diff --git a/src/main/java/com/j2js/assembly/ProcedureUnit.java b/src/main/java/com/j2js/assembly/ProcedureUnit.java new file mode 100644 index 0000000..c3b01a5 --- /dev/null +++ b/src/main/java/com/j2js/assembly/ProcedureUnit.java @@ -0,0 +1,51 @@ +package com.j2js.assembly; + +import java.io.IOException; +import java.io.Writer; +import java.util.Collection; +import java.util.HashSet; +import java.util.Iterator; + +import com.j2js.Log; + +public abstract class ProcedureUnit extends MemberUnit { + + // Set of all member signatures targeted by this method. + private Collection targetSignatures = new HashSet(); + + public ProcedureUnit(Signature theSignature, ClassUnit theDeclaringClazz) { + super(theSignature, theDeclaringClazz); + } + + public void addTarget(Signature targetSignature) { + if (!targetSignature.toString().contains("#")) { + throw new IllegalArgumentException("Signature must be field or method: " + targetSignature); + } + //Logger.getLogger().info("Adding " + this + " -> " + targetSignature); + targetSignatures.add(targetSignature); + } + + public void removeTargets() { + Iterator iter = targetSignatures.iterator(); + while (iter.hasNext()) { + iter.next(); + iter.remove(); + } + } + + void write(int depth, Writer writer) throws IOException { + if (getData() == null) return; + Log.getLogger().debug(getIndent(depth) + getSignature()); + writer.write(getData()); + } + + public String getData() { + if (!declaringClass.isResolved()) throw new RuntimeException("Class must be resolved"); + return super.getData(); + } + + public Collection getTargetSignatures() { + return targetSignatures; + } + +} diff --git a/src/main/java/com/j2js/assembly/Project.java b/src/main/java/com/j2js/assembly/Project.java new file mode 100644 index 0000000..2b1a07e --- /dev/null +++ b/src/main/java/com/j2js/assembly/Project.java @@ -0,0 +1,330 @@ +package com.j2js.assembly; + +import com.j2js.J2JSCompiler; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.Serializable; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Stack; + +import org.apache.bcel.generic.ArrayType; +import org.apache.bcel.generic.ObjectType; +import org.apache.bcel.generic.ReferenceType; +import org.apache.bcel.generic.Type; + +import com.j2js.Log; +import com.j2js.Utils; +import com.j2js.dom.ArrayCreation; +import com.j2js.dom.FieldAccess; +import com.j2js.dom.MethodBinding; +import com.j2js.dom.MethodDeclaration; +import com.j2js.dom.MethodInvocation; +import com.j2js.dom.TypeDeclaration; + +public class Project implements Serializable { + + static final long serialVersionUID = 0; + + private static Project singleton; + + // All managed classes mapped by class name. + private Map classesByName; + private ClassUnit javaLangObject; + private boolean compressed; + private boolean generateLineNumbers; + private Map signatures; + + private transient Stack ids; + private transient int currentId; + private transient int currentIndex; + + public transient int currentGeneratedMethods; + + public static Project getSingleton() { + if (singleton == null) throw new NullPointerException(); + return singleton; + } + + public static Project createSingleton(File cacheFile) { + + if (cacheFile != null && cacheFile.exists()) { + Log.getLogger().info("Using cache " + cacheFile); + try { + read(cacheFile); + } catch (Exception e) { + Log.getLogger().warn("Could not read cache:\n" + e.getMessage()); + } + } + + if (singleton == null || + singleton.compressed != J2JSCompiler.compiler.isCompression() || + singleton.generateLineNumbers != J2JSCompiler.compiler.isGenerateLineNumbers()) { + // Cache does not exist, could not be read, or compression does not match. + singleton = new Project(); + singleton.clear(); + } + + return singleton; + } + + private static void read(File file) throws Exception { + FileInputStream fis = new FileInputStream(file); + ObjectInputStream ois = new ObjectInputStream(fis); + singleton = (Project) ois.readObject(); + ois.close(); + } + + public static void write() throws IOException { + File file = J2JSCompiler.compiler.getCacheFile(); + if (file.exists() && !file.canWrite()) { + throw new IOException("Cannot write " + file); + } + FileOutputStream fos = new FileOutputStream(file); + ObjectOutputStream oos = new ObjectOutputStream(fos); + oos.writeObject(singleton); + oos.close(); + } + + public Signature getArraySignature(Type type) { + String signatureString = type.getSignature(); + /* Examples: + * L[java.lang.Integer;; -> [java.lang.Integer; + * L[I; -> [I + */ + if (!signatureString.startsWith("L") || !signatureString.endsWith(";")) { + throw new RuntimeException("Not a class signature: " + signatureString); + } + signatureString = signatureString.substring(1, signatureString.length()-1); + return getSignature(signatureString); + } + + /** + * All request for a signature delegate to this method. + */ + public Signature getSignature(String signatureString) { + if (signatureString.endsWith(";")) { + //throw new RuntimeException("Invalid signature: " + signatureString); + } + signatureString = signatureString.replaceAll("/", "."); + + Signature signature = signatures.get(signatureString); + if (signature == null) { + signature = new Signature(signatureString, getUniqueId()); + signatures.put(signatureString, signature); + } + + return signature; + } + + public Signature getSignature(String className, String relativeSignature) { + return getSignature(className + '#' + relativeSignature); + } + + public Signature getSignature(FieldAccess fa) { + return getSignature(fa.getType().getClassName(), fa.getName()); + } + + private int getUniqueId() { + if (ids == null) { + ids = new Stack(); + for (Signature signature : signatures.values()) { + ids.add(signature.getId()); + } + Collections.sort(ids); + } + + while (currentIndex(); + javaLangObject = null; + + signatures = new HashMap(); + ids = null; + currentId = 0; + currentIndex = 0; + compressed = J2JSCompiler.compiler.isCompression(); + generateLineNumbers = J2JSCompiler.compiler.isGenerateLineNumbers(); + } + + public void remove(ClassUnit clazz) { + classesByName.remove(clazz); + } + + void visitSuperTypes(ClassUnit clazz, TypeVisitor visitor) { + visitor.visit(clazz); + ClassUnit superClass = clazz.getSuperUnit(); + if (superClass != null) { + visitSuperTypes(superClass, visitor); + } + + for (ClassUnit interfaceUnit : clazz.getInterfaces()) { + visitor.visit(interfaceUnit); + visitSuperTypes(interfaceUnit, visitor); + } + } + + public ClassUnit getJavaLangObject() { + return javaLangObject; + } + + public ClassUnit getClassUnit(String className) { + ClassUnit clazz = classesByName.get(className); + if (clazz != null) return clazz; + + throw new RuntimeException("No such unit: " + className); + } + + public ClassUnit getClassUnit(ReferenceType type) { + String signature; + if (type instanceof ArrayType) { + ArrayType aType = (ArrayType) type; + signature = Utils.getSignature(aType.getBasicType()); + for (int i = 0; i getClasses() { + return classesByName.values(); + } + + public void resolve(ClassUnit clazz) { + if (clazz.isResolved()) return; + + if (clazz.getName().startsWith("[")) { + // This is an array type and not a class. + clazz.setSuperUnit(getJavaLangObject()); + //clazz.setTainted(); + clazz.setResolved(true); + // We need a member (and we chose length) in addReference(..) to taint the class. + new FieldUnit(getSignature("length"), clazz); + + TypeDeclaration typeDecl = new TypeDeclaration(new ObjectType(clazz.getName()), 0); + typeDecl.setSuperType(Type.OBJECT); + typeDecl.visit(J2JSCompiler.compiler.generator); + } else { + TypeResolver resolver = new TypeResolver(this, J2JSCompiler.compiler.generator); + visitSuperTypes(clazz, resolver); + } + } + +} diff --git a/src/main/java/com/j2js/assembly/Serializer.java b/src/main/java/com/j2js/assembly/Serializer.java new file mode 100644 index 0000000..2611e8c --- /dev/null +++ b/src/main/java/com/j2js/assembly/Serializer.java @@ -0,0 +1,153 @@ +package com.j2js.assembly; + +import java.util.List; +import java.io.IOException; +import java.io.NotSerializableException; +import java.io.Writer; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Map; + +public class Serializer { + private Writer writer; + private SimpleDateFormat dateFormatter = new SimpleDateFormat("dd.MM.yyyy"); + + /** Creates a new instance of Serializer */ + public Serializer(Writer theWriter) { + writer = theWriter; + } + + public void serialize(Object object) throws NotSerializableException { + try { + this.serializeInternal(object); + } catch (IOException e) { + throw new NotSerializableException(e.getMessage()); + } + } + + private void serializeInternal(Object object) throws IOException { + if (object==null) { + writer.write("null"); + } else if (object instanceof String) { + quote((String)object); + } else if (object instanceof Number) { + numberToString((Number) object); + } else if (object instanceof Map) { + serializeMap((Map) object); + } else if (object instanceof List) { + serializeArray((List) object); + } else if (object.getClass().isArray()) { + serializeArray((Object[]) object);// && object.getClass().getComponentType().equals(Double.TYPE) double[]) object); + } else if (object instanceof Boolean) { + writer.write(((Boolean)object).toString()); + } else if (object instanceof Date) { + quote(dateFormatter.format((Date) object)); + } else { + throw serializeError("Unknown object type " + object.getClass().toString()); + } + } + + private void serializeArray(List list) throws IOException { + String sep = ""; + + writer.write('['); + for (Object o : list) { + writer.write(sep); + sep = ","; + this.serializeInternal(o); + } + writer.write(']'); + } + + private void serializeArray(Object[] array) throws IOException { + String sep = ""; + + writer.write('['); + for (int i=0; i map) throws IOException { + String sep = ""; + + writer.write('{'); + for (String key : map.keySet()) { + writer.write(sep); + sep = ","; + Object value = map.get(key); + if (key.matches("\\w*")) { + writer.write(key); + } else { + writer.write("\"" + key + "\""); + } + + writer.write(':'); + this.serializeInternal(value); + } + writer.write('}'); + } + + /** + * Stream a numeric value. + * @exception NotSerializableException If number is infinite or not a number. + * @param n A Number + * @return A String. + */ + private void numberToString(Number n) throws IOException { + if (n instanceof Double && (((Double) n).isInfinite() || ((Double) n).isNaN())) { + throw serializeError("Can only serialize finite numbers"); + } + if (n instanceof Float && (((Float) n).isInfinite() || ((Float) n).isNaN())) { + throw serializeError("Can only serialize finite numbers"); + } + + writer.write(n.toString().toLowerCase()); + } + + private void numberToString(double n) throws IOException { + writer.write(String.valueOf(n)); + } + + /** + * Stream a string in double quotes " with the following backslash replacements: + * " -> \" + * \ -> \\ + * @param string A String + */ + private void quote(String s) throws IOException { + if (s == null) { + writer.write("null"); + return; + } + writer.write('"'); + int l = s.length(); + for (int i=0; i java.lang.Integer + * L[I; -> [I + */ +// public String getClassName() { +// if (!signatureString.startsWith("L") || !signatureString.endsWith(";")) { +// throw new RuntimeException("Not a class signature: " + signatureString); +// } +// return signatureString.substring(1, signatureString.length()-1); +// } + + public int hashCode() { + return signatureString.hashCode(); + } + + public boolean equals(Object obj) { + if (obj instanceof Signature) { + return signatureString.equals(((Signature) obj).signatureString); + } + return false; + } + + public String toString() { + return signatureString; + } + + public boolean isClass() { + return signatureString.indexOf('#') == -1; + } + + public boolean isArrayType() { + return isClass() && signatureString.startsWith("["); + } + + public boolean isConstructor() { + return signatureString.startsWith(""); + } + + public boolean isMethod() { + return !isConstructor() && signatureString.indexOf('(') != -1; + } + + public boolean isField() { + return !isClass() && signatureString.indexOf('(') == -1; + } + + public String className() { + String array[] = signatureString.split("#"); + //if (array[0].startsWith("[")) array[0] = array[0].substring(1); + return array[0]; + } + + public String relativeSignature() { + String array[] = signatureString.split("#"); + if (array.length != 2) { + throw new RuntimeException("Not a method signature: " + this); + } + return array[1]; + } + + /** + * Returns the relative signature. + */ + public Signature relative() { + return Project.getSingleton().getSignature(relativeSignature()); + } + + public int getId() { + return id; + } + + public String getCommentedId() { + StringBuffer sb = new StringBuffer(); + sb.append(String.valueOf(getId())); + if (!J2JSCompiler.compiler.isCompression()) { + sb.append(" /*"); + sb.append(toString()); + sb.append("*/"); + } + return sb.toString(); + } +} diff --git a/src/main/java/com/j2js/assembly/TypeCollector.java b/src/main/java/com/j2js/assembly/TypeCollector.java new file mode 100644 index 0000000..0b61561 --- /dev/null +++ b/src/main/java/com/j2js/assembly/TypeCollector.java @@ -0,0 +1,13 @@ +package com.j2js.assembly; + +import java.util.Collection; +import java.util.HashSet; + +public class TypeCollector implements TypeVisitor { + + Collection collectedTypes = new HashSet(); + + public void visit(ClassUnit clazz) { + collectedTypes.add(clazz); + } +} diff --git a/src/main/java/com/j2js/assembly/TypeResolver.java b/src/main/java/com/j2js/assembly/TypeResolver.java new file mode 100644 index 0000000..95cdf59 --- /dev/null +++ b/src/main/java/com/j2js/assembly/TypeResolver.java @@ -0,0 +1,77 @@ +package com.j2js.assembly; + +import com.j2js.J2JSCompiler; + +import com.j2js.Log; +import com.j2js.Parser; +import com.j2js.dom.TypeDeclaration; +import com.j2js.visitors.JavaScriptGenerator; + +public class TypeResolver implements TypeVisitor { + + private JavaScriptGenerator generator; + private Project project; + + public TypeResolver(Project theProject, JavaScriptGenerator theGenerator) { + project = theProject; + generator = theGenerator; + } + + public void visit(ClassUnit clazz) { + if (clazz.isResolved()) return; + + Log logger = Log.getLogger(); + + if (clazz.getSignature().toString().startsWith("[")) { + // Class is an array class without class file: Do nothing. + } else if (!clazz.isUpToDate()) { + clazz.clear(); + try { + compile(clazz); + J2JSCompiler.compiler.compileCount++; + } catch (RuntimeException ex) { + J2JSCompiler.errorCount++; + logger.error(ex.toString()); + //ex.printStackTrace(); + if (J2JSCompiler.compiler.failOnError) { + throw ex; + } + } + } else { + logger.debug("Up to date: " + clazz); + } + + clazz.setResolved(true); + } + + /** + * Compiles the unit. + */ + private void compile(ClassUnit classUnit) { + + if (classUnit.getClassFile() == null) { + Log.getLogger().warn("Cannot read " + classUnit.getClassFile()); + return; + } + + Log.getLogger().info("Cross-Compiling " + classUnit); + + TypeDeclaration typeDecl = parse(classUnit); + + // TODO + //if (!Modifier.isInterface(typeDecl.getAccess())) { + typeDecl.visit(generator); + //} + + // Set not current date but date of last modification. This is + // independent of system clock. + classUnit.setLastCompiled(classUnit.getLastModified()); + } + + private TypeDeclaration parse(ClassUnit classUnit) { + Parser parser = new Parser(classUnit); + TypeDeclaration typeDecl = parser.parse(); + + return typeDecl; + } +} diff --git a/src/main/java/com/j2js/assembly/TypeVisitor.java b/src/main/java/com/j2js/assembly/TypeVisitor.java new file mode 100644 index 0000000..f7b7865 --- /dev/null +++ b/src/main/java/com/j2js/assembly/TypeVisitor.java @@ -0,0 +1,5 @@ +package com.j2js.assembly; + +public interface TypeVisitor { + public void visit(ClassUnit clazz); +} diff --git a/src/main/java/com/j2js/assembly/Unit.java b/src/main/java/com/j2js/assembly/Unit.java new file mode 100644 index 0000000..7d406c1 --- /dev/null +++ b/src/main/java/com/j2js/assembly/Unit.java @@ -0,0 +1,62 @@ +package com.j2js.assembly; + +import java.io.IOException; +import java.io.Serializable; +import java.io.Writer; + +import com.j2js.Log; + + +public abstract class Unit implements Serializable { + + private Signature signature; + + private String data; + + private transient boolean isTainted = false; + private static transient String[] indentPerDepth = new String[10]; + + public Unit() { + } + + abstract void write(int depth, Writer writer) throws IOException; + + String getIndent(int depth) { + String indent = indentPerDepth[depth]; + if (indent == null) { + indent = ""; + for (int i=0; i uaArgs = new ArrayList(); + + @XmlElement(name = "devModeWebSocketURL", required = true) + public URI devModeWebSocketURL; + + @XmlElement(name = "devModeHttpURL", required = true) + public URI devModeHttpURL; + + public void write(OutputStream os) { + try { + JAXBContext context = JAXBContext.newInstance(Configuration.class); + Marshaller m = context.createMarshaller(); + m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); + m.marshal(this, os); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + public static Configuration read() { + File file = new File(System.getProperty("user.home") + "/.m2/j2js.xml"); + InputStream is = null; + try { + is = new FileInputStream(file); + } catch (FileNotFoundException e) { + throw new RuntimeException("Could not read file " + file); + } + System.out.println("Reading j2js configuration from " + file); + return Configuration.read(is); + } + + public static Configuration read(InputStream inStream) { + JAXBContext context; + try { + context = JAXBContext.newInstance(Configuration.class); + Unmarshaller um = context.createUnmarshaller(); + return (Configuration) um.unmarshal(inStream); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + +// public ApplicationConfiguration getApplicationConfiguration(String applicationName) { +// if ( applicationName == null ) { +// throw new NullPointerException("applicationName cannot be null."); +// } +// +// for (ApplicationConfiguration applConfig : applications) { +// if ( applicationName.equals(applConfig.applicationName) ) { +// return applConfig; +// } +// } +// +// return null; +// } +} diff --git a/src/main/java/com/j2js/cfg/ConditionalEdge.java b/src/main/java/com/j2js/cfg/ConditionalEdge.java new file mode 100644 index 0000000..87a2800 --- /dev/null +++ b/src/main/java/com/j2js/cfg/ConditionalEdge.java @@ -0,0 +1,29 @@ +package com.j2js.cfg; + +import com.j2js.dom.BooleanExpression; + +public class ConditionalEdge extends Edge { + + private BooleanExpression expression; + private boolean negate = false; + + ConditionalEdge(Graph graph, Node theSource, Node theTarget) { + super(graph, theSource, theTarget); + } + + public BooleanExpression getBooleanExpression() { + return expression; + } + + public void setBooleanExpression(BooleanExpression expr) { + expression = expr; + } + + public boolean isNegate() { + return negate; + } + + public void setNegate(boolean theNegate) { + negate = theNegate; + } +} diff --git a/src/main/java/com/j2js/cfg/ControlFlowGraph.java b/src/main/java/com/j2js/cfg/ControlFlowGraph.java new file mode 100644 index 0000000..a9fee23 --- /dev/null +++ b/src/main/java/com/j2js/cfg/ControlFlowGraph.java @@ -0,0 +1,387 @@ +package com.j2js.cfg; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.SortedMap; +import java.util.TreeMap; + +import com.j2js.ASTNodeStack; +import com.j2js.cfg.transformation.Transformation; +import com.j2js.dom.ASTNode; +import com.j2js.dom.Block; +import com.j2js.dom.BooleanExpression; +import com.j2js.dom.InfixExpression; +import com.j2js.dom.TryStatement; + +/** + * Instances of this class represent a Control Flow Graph CFG. + */ +public class ControlFlowGraph extends Graph { + + // Ordering is only used by method getNodeAt(). + private SortedMap nodesByPc = new TreeMap(); + + // The single entry point of control. + private Node sourceNode; + + private List tryStatements; + + public ControlFlowGraph(List theTryStatements) { + tryStatements = theTryStatements; + } + + /** + * Returns the try statement which contains the specified node. + */ + private TryStatement selectTryStatement(Node node) { + int pc = node.getInitialPc(); + for (int i=0; i= block.getBeginIndex() && pc <= block.getEndIndex()) return tryStmt; + } + return null; + } + + + public Node createNode(int pc) { + return createNode(pc, Node.class); + } + + public Node getOrCreateNode(int pc) { + Node node = getNode(pc); + if (node == null) { + node = createNode(pc, Node.class); + } + return node; + } + + public Node createNode(int pc, Class nodeClass) { + if (pc < 0) throw new RuntimeException("Program counter may not be negative"); + + Node node = super.createNode(nodeClass); + node.setInitialPc(pc); + if (nodesByPc.put(node.getInitialPc(), node) != null) { + throw new RuntimeException("Node already exists: " + node); + } + + if (pc == 0) sourceNode = node; + + return node; + } + + /** + * Returns the largest (w.r. to its initial pc) node closest to the specified pc. + */ + public Node getNodeAt(int pc) { + int minPcDelta = Integer.MAX_VALUE; + Node node = null; + for (Node n : getNodes()) { + if (n.getInitialPc() <= pc && pc-n.getInitialPc() < minPcDelta) { + minPcDelta = pc-n.getInitialPc(); + node = n; + if (minPcDelta == 0) return node; + } + } + + if (node == null) { + throw new RuntimeException("No node at pc " + pc); + } + + return node; + } + + /** + * Splits a node at the given pc value into two nodes nodeA and nodeB. + * nodeB will start at pc and will have the outbound edges of the original node, and an + * extra edge is added from nodeA to nodeB. + */ + public Node split(Node node, int pc) { + if (node.block.getBeginIndex() >= pc) throw new RuntimeException("Block must contain program counter"); + + Node nodeB = createNode(pc); + + // Reroot all outbound edges at nodeB. + for (Edge edge : new ArrayList(node.getOutEdges())) { + edge.reroot(nodeB); + } + + addEdge(node, nodeB); + + // Transfer code starting at pc to nodeB. + ASTNode astNode = node.block.getFirstChild(); + while (astNode != null) { + if (astNode.getBeginIndex() >= pc) { + node.setCurrentPc(astNode.getBeginIndex()-1); + nodeB.block.appendChildren(astNode, node.block.getLastChild()); + break; + } + astNode = astNode.getNextSibling(); + } + + // Transfer stack to nodeB. + nodeB.stack = node.stack; + node.stack = new ASTNodeStack(); + + return nodeB; + } + + public Node[] getOrSplitNodeAt(Node currentNode, int pc) { + Node targetNode = getNodeAt(pc); + if (targetNode.getInitialPc() != pc) { + // No node starts at target pc. We have to split the node. + Node nodeB = split(targetNode, pc); + if (targetNode == currentNode) { + currentNode = nodeB; + } + targetNode = nodeB; + } + return new Node[]{currentNode, targetNode}; + } + + /** + * Redirect all incoming edges for try bodys to its try header. + */ + private void processTrys() { + for (int i=0; i(tryNode.getInEdges())) { + int pc = edge.source.getInitialPc(); + if (pc >= stmt.getBeginIndex() && pc <= stmt.getEndIndex()) continue; + if (edge.source == header) continue; + edge.redirect(header); + } + } + } + + /** + * Reroots all local edges exiting a try body at the corresponding try header. + */ + private void processTrys2() { + for (Node node: nodesByPc.values()) { + TryStatement sourceTry = selectTryStatement(node); + if (sourceTry == null) continue; + + for (Edge edge : node.getOutEdges()) { + if (edge.target.getInEdges().size() != 1) { + continue; + } + TryStatement targetTry = selectTryStatement(edge.target); + if (targetTry == null || targetTry != sourceTry) { + edge.reroot(sourceTry.header); + } + } + } + } + + /** + * Reroot the fall through successor directly at the try header. + */ + private void processTrys1() { + for (int i=0; i finallyNode.getInitialPc()) { + removeInEdges(node); + addEdge(header, node); + node.setDomParent(header); + } + } + } + } + + public Node getSource() { + return sourceNode; + } + + public Node getNode(int pc) { + return nodesByPc.get(pc); + } + + /** + * Finds the set of all successors of the specified predecessor which are not dominated by it. + * Each node in this set is then marked as a global target of the predecessor. + * If the predecessor is a branch, then a newly created node will function as the referer. + */ + private void markGlobalTargets(Node predecessor) { + for (Edge edge : predecessor.getOutEdges()) { + Node target = edge.target; + if (target.getDomParent() == predecessor) + continue; + + if (predecessor.isBranch()) { + Node node = createNode(Node.class); + edge.redirect(node); + node.setDomParent(predecessor); + edge = addEdge(node, target); + } + } + } + + /** + * For each node in tree, mark global targets. + */ + void visitToMark(Node node) { + // Be concurrent safe. + for (Node child : new ArrayList(node.getDomChildren())) { + visitToMark(child); + } + + markGlobalTargets(node); + } + + /** + * Recursively (depth first) traverses the dominator tree rooted at the specified node and post-processes + * all possible reductions. + */ + void visit(Node node) { + + // Be concurrent safe. + for (Node child : new ArrayList(node.getDomChildren())) { + visit(child); + } + + do { + Transformation t = Transformation.select(this, node); + if (t == null) break; + node = t.apply(); + dump("After transformation"); + } while (true); + + if (node.getDomChildren().size() > 0) { + throw new RuntimeException("Could not reduce graph at " + node); + } + } + + public void replaceNode(Node node, Node newNode) { + + super.replaceNode(node, newNode); + + if (newNode != null) { + nodesByPc.put(node.getInitialPc(), newNode); + } else { + nodesByPc.remove(node.getInitialPc()); + } + + if (node == sourceNode) { + if (newNode == null) { + throw new RuntimeException("Cannot remove source node " + sourceNode); + } + sourceNode = newNode; + } + } + + public Block reduce() { + processTrys(); + processTrys2(); + + dump("Before Shortcuts"); + processShortcuts(); + + DominatorTree builder = new DominatorTree(this); + builder.build(); + + processTrys1(); + + visitToMark(getSource()); + dump("Begin reduce"); + + visit(getSource()); + + if (size() != 1) { + throw new RuntimeException("Could not reduce graph"); + } + + Block block = new Block(); + + rollOut(getSource(), block); + + return block; + } + + /** + * Performs an OR or AND shortcut on two branches A and B by replacing them with new node A&B or A|B. + */ + boolean performAndOrShortcut(Node a, Node b) { + if (b.getInEdges().size() != 1) return false; + if (b.block.getChildCount() > 0) { + // Node b is not a mere conditional. + return false; + } + + + ConditionalEdge aToC; + ConditionalEdge bToC; + boolean isOR = true; + + while(true) { + aToC = a.getConditionalEdge(isOR); + bToC = b.getConditionalEdge(isOR); + if (bToC.target == aToC.target) break; + if (!isOR) return false; + isOR = false; + } + + if (aToC.target.getInEdges().size() != 2) return false; + + ConditionalEdge bToD = b.getConditionalEdge(!isOR); + ConditionalEdge aToB = a.getConditionalEdge(!isOR); + + aToB.redirect(bToD.target); + removeEdge(bToC); + removeEdge(bToD); + removeNode(b); + + InfixExpression infix = new InfixExpression( + isOR?InfixExpression.Operator.CONDITIONAL_OR:InfixExpression.Operator.CONDITIONAL_AND); + // Note that the order aToC, then bToC is important. + infix.setOperands( + aToC.getBooleanExpression().getExpression(), + bToC.getBooleanExpression().getExpression()); + + BooleanExpression be = new BooleanExpression(infix); + aToC.setBooleanExpression(be); + aToB.setBooleanExpression(be); + + logger.debug("Created shortcut and removed " + b); + + return true; + } + + public void processShortcuts() { + Collection branches = new HashSet(); + for (Node node : getNodes()) { + if (node.isBranch()) branches.add(node); + } + + L: while (true) { + Iterator iter = branches.iterator(); + while (iter.hasNext()) { + Node branch = iter.next(); + for (Node node: branch.succs()) { + if (node.isBranch() && performAndOrShortcut(branch, node)) { + branches.remove(node); + continue L; + } + } + } + break L; + } + + } +} diff --git a/src/main/java/com/j2js/cfg/DominatorTree.java b/src/main/java/com/j2js/cfg/DominatorTree.java new file mode 100644 index 0000000..c1e96d1 --- /dev/null +++ b/src/main/java/com/j2js/cfg/DominatorTree.java @@ -0,0 +1,233 @@ +package com.j2js.cfg; + +import java.util.*; + +import com.j2js.Log; + +/** + * Class to build the dominator tree of a given control flow graph. + * The algorithm is according Purdum-Moore, which isn't as fast as Lengauer-Tarjan, but a lot simpler. + */ +public class DominatorTree { + + private ControlFlowGraph graph; + + public DominatorTree(ControlFlowGraph theGraph) { + graph = theGraph; + } + + /** + * Sets the pre-order index of a node. + */ + private void visit(Node node, Collection visited) { + // Establish preorder index. + node.setPreOrderIndex(visited.size()); + visited.add(node); + + for (Node succ : node.succs()) { + if (! visited.contains(succ)) { + visit(succ, visited); + } + } + + } + + /** + * Builds the dominator tree and store it in the respective nodes. + * It will remove all unreachable nodes on the way! + */ + public void build() { + + // Construct list of nodes in pre-order order. + ArrayList preOrder = new ArrayList(); + + visit(graph.getSource(), preOrder); + + // Remove unreachable nodes. + for (Node node : new ArrayList(graph.getNodes())) { + if (!preOrder.contains(node)) { + Log.getLogger().warn("Unreachable code detected and removed"); + //Logger.getLogger().info("Removed " + node); + graph.removeInEdges(node); + graph.removeOutEdges(node); + graph.removeNode(node); + } else if (node.getPreOrderIndex() == -1) { + throw new RuntimeException("Pre-order not set for " + node); + } + } + + + int size = graph.size(); // The number of vertices in the cfg + + Map snkPreds = new HashMap(); // The predacessor vertices from the sink + + + // Determine the predacessors of the cfg's sink node + //insertEdgesToSink(graph, snkPreds, reverse); + + // Get the index of the root + int rootIndex = graph.getSource().getPreOrderIndex(); + + if (rootIndex < 0 || rootIndex >= size) throw new RuntimeException("Root index out of range"); + + // Bit matrix indicating the dominators of each node. + // If bit j of dom[i] is set, then node j dominates node i. + BitSet[] domMatrix = new BitSet[size]; + + // Initially, all the bits in the dominance matrix are set, except + // for the root node. The root node is initialized to have itself + // as an immediate dominator. + for (int i = 0; i < size; i++) { + BitSet domVector = new BitSet(size); + + if (i == rootIndex) { + // Only root dominates root. + domVector.set(rootIndex); + } + else { + // Assume that all nodes dominate non-root node i. + domVector.set(0, size); + } + + domMatrix[i] = domVector; + } + + // Did the dominator bit vector array change? + boolean changed; + + do { + changed = false; + + // Fetch all nodes in pre-order. + Iterator nodes = preOrder.iterator(); + + // Compute the dominators of each node in the cfg. We iterate + // over every node in the cfg. The dominators of a node N are + // found by taking the intersection of the dominator bit vectors + // of each predacessor of N and unioning that with N. This + // process is repeated until no changes are made to any dominator + // bit vector. + + while (nodes.hasNext()) { + Node node = (Node) nodes.next(); + + int i = node.getPreOrderIndex(); + + if (i < 0 || i >= size) throw new RuntimeException("Unreachable node " + node); + + // We already know the dominators of the root, keep looking + if (i == rootIndex) { + continue; + } + + BitSet oldSet = domMatrix[i]; + + // domVector := intersection of dom(pred) for all pred(node). + BitSet domVector = new BitSet(size); + domVector.or(oldSet); + + + Collection preds = node.preds(); + + Iterator e = preds.iterator(); + + // Find the intersection of the dominators of node's + // predacessors. + while (e.hasNext()) { + Node pred = (Node) e.next(); + + int j = pred.getPreOrderIndex(); + if (j == -1) throw new RuntimeException("Unreachable node " + pred); + + domVector.and(domMatrix[j]); + } + + // Don't forget to account for the sink node if node is a + // leaf node. Appearantly, there are not edges between + // leaf nodes and the sink node! + preds = (Collection) snkPreds.get(node); + + if (preds != null) { + e = preds.iterator(); + + while (e.hasNext()) { + Node pred = (Node) e.next(); + + int j = pred.getPreOrderIndex(); + + domVector.and(domMatrix[j]); + } + } + + // Include yourself in your dominators?! + domVector.set(i); + + // If the set changed, set the changed bit. + if (!domVector.equals(oldSet)) { + changed = true; + domMatrix[i] = domVector; + } + } + } while (changed); + + // Once we have the predacessor bit vectors all squared away, we can + // determine which vertices dominate which vertices. + + // Initialize each node's (post)dominator parent and children + for (Node node : graph.getNodes()) { + node.setDomParent(null); + node.getDomChildren().clear(); + } + + // A node's immediate dominator is its closest dominator. So, we + // start with the dominators, dom(b), of a node, b. To find the + // imediate dominator of b, we remove all nodes from dom(b) that + // dominate any node in dom(b). + + for (Node node : graph.getNodes()) { + int i = node.getPreOrderIndex(); + + if (i < 0 || i >= size) throw new RuntimeException("Unreachable node " + node); + + if (i == rootIndex) { + continue; + } + + // Find the immediate dominator + // idom := dom(node) - dom(dom(node)) - node + BitSet domVector = domMatrix[i]; + + BitSet idom = new BitSet(size); + idom.or(domVector); + idom.clear(i); + + for (int j = 0; j < size; j++) { + if (i != j && domVector.get(j)) { + // idom = idom - (domMatrix[j] - {j}) + BitSet b = new BitSet(size); + // Complement of domMatrix[j]. + b.or(domMatrix[j]); b.flip(0, size); + b.set(j); + idom.and(b); + } + } + + Node parent = null; + + // A node should only have one immediate dominator. + for (int j = 0; j < size; j++) { + if (idom.get(j)) { + Node p = preOrder.get(j); + if (parent != null) + throw new RuntimeException(node + " has more than one immediate dominator: " + parent + " and " + p); + parent = p; + } + } + + if (parent == null) + throw new RuntimeException(node + " has 0 immediate dominators"); + + node.setDomParent(parent); + } + } +} diff --git a/src/main/java/com/j2js/cfg/Edge.java b/src/main/java/com/j2js/cfg/Edge.java new file mode 100644 index 0000000..6c961c3 --- /dev/null +++ b/src/main/java/com/j2js/cfg/Edge.java @@ -0,0 +1,78 @@ +/* + * Copyright 2005 by Wolfgang Kuehn + * Created on 12.11.2005 + */ +package com.j2js.cfg; + +/** + * @author wolfgang + */ +public class Edge { + + private Graph graph; + public Node source; + public Node target; + public EdgeType type; + private Node orgSource; + + Edge(Graph theGraph, Node theSource, Node theTarget) { + graph = theGraph; + source = theSource; + target = theTarget; + } + + public boolean equals(Object other) { + if (other == null || !(other instanceof Edge)) return false; + Edge otherEdge = (Edge) other; + return source.getId().equals(otherEdge.source.getId()) && target.getId().equals(otherEdge.target.getId()); + } + + /** + * Replace the target of this edge. + */ + public void reroot(Node newSource) { + source.outEdges.remove(this); + newSource.outEdges.add(this); + source = newSource; + } + + /** + * Replace the target of this edge. + */ + public void redirect(Node newTarget) { + target.inEdges.remove(this); + newTarget.inEdges.add(this); + target = newTarget; + } + + /** + * Returns true if this edge is a backward (i.e. loop) edge. + */ + public boolean isBackEdge() { + return target.isDomAncestor(source); + } + + public boolean isGlobal() { + return orgSource != null; + } + + public String toString() { + String s = getClass().getName(); + // Extract unqualified class name. + s = s.substring(s.lastIndexOf('.')+1); + return s + " " + source.getId() + " -> " + target.getId(); + } + + public Node getOrgSource() { + if (orgSource == null) { + return source; + } + return orgSource; + } + + public void setOrgSource(Node theOrgSource) { + orgSource = theOrgSource; + } + + +} diff --git a/src/main/java/com/j2js/cfg/EdgeCollections.java b/src/main/java/com/j2js/cfg/EdgeCollections.java new file mode 100644 index 0000000..3849ff8 --- /dev/null +++ b/src/main/java/com/j2js/cfg/EdgeCollections.java @@ -0,0 +1,17 @@ +package com.j2js.cfg; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Set; + +public class EdgeCollections { + + public static Set getSources(Collection edges) { + HashSet sources = new HashSet(); + for (Edge edge : edges) { + sources.add(edge.source); + } + return sources; + } + +} diff --git a/src/main/java/com/j2js/cfg/EdgeType.java b/src/main/java/com/j2js/cfg/EdgeType.java new file mode 100644 index 0000000..99a7e9c --- /dev/null +++ b/src/main/java/com/j2js/cfg/EdgeType.java @@ -0,0 +1,17 @@ +package com.j2js.cfg; + +public class EdgeType { + public static EdgeType FINALLY = new EdgeType("Finally"); + public static EdgeType CATCH = new EdgeType("Catch"); + public static EdgeType TRYBODY = new EdgeType("TryBody"); + + private String name; + + private EdgeType(String theName) { + name = theName; + } + + public String toString() { + return name; + } +} diff --git a/src/main/java/com/j2js/cfg/Graph.java b/src/main/java/com/j2js/cfg/Graph.java new file mode 100644 index 0000000..e482505 --- /dev/null +++ b/src/main/java/com/j2js/cfg/Graph.java @@ -0,0 +1,286 @@ +package com.j2js.cfg; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +import com.j2js.Log; +import com.j2js.cfg.Node; + +import com.j2js.dom.Block; +import com.j2js.dom.BooleanExpression; +import com.j2js.dom.BreakStatement; +import com.j2js.dom.IfStatement; + +public abstract class Graph { + + private Map nodes = new HashMap(); + + int nodeIdSequence = 0; + + Log logger = Log.getLogger(); + + public Graph() { + } + + public Node getNodeById(String id) { + return nodes.get(id); + } + + public Node createNode(Class nodeClass) { + return createNode(nodeClass, Integer.toString(nodeIdSequence++, 26)); + } + + public Node createNode(Class nodeClass, String id) { + Node node; + try { + Constructor constructor = nodeClass.getConstructor(new Class[]{Graph.class}); + node = (Node) constructor.newInstance(new Object[] {this}); + } catch (InstantiationException e) { + throw new RuntimeException(e); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } catch (InvocationTargetException e) { + throw new RuntimeException(e); + } + node.id = id; + nodes.put(id, node); + return node; + } + + /** + * Returns true if node set A is contained in node set B. + */ + public boolean isContained(Set nodesA, Node[] nodesB) { + Set foo = new HashSet(Arrays.asList(nodesB)); + return foo.containsAll(nodesA); + } + + /** + * Redirects all inbound edges of a node to another node. + */ + public void replaceAsTarget(Node oldTarget, Node newTarget) { + for (Edge edge : new ArrayList(oldTarget.getInEdges())) { + edge.redirect(newTarget); + } + } + + public Edge removeEdge(Node source, Node target) { + Edge edge = getEdge(source, target); + return removeEdge(edge); + } + + public Edge removeEdge(Edge edge) { + edge.source.getOutEdges().remove(edge); + edge.target.getInEdges().remove(edge); + return edge; + } + +// public void replaceNodes(Node header, List nodes, Node newNode) { +// replaceNodes(header, (Node[]) nodes.toArray(new Node[nodes.size()]), newNode); +// } + + public String getEdgeId(Node source, Node target) { + return source.getId() + "->" + target.getId(); + } + + public void addIfElseEdge(Node source, Node ifTarget, Node elseTarget, BooleanExpression be) { + ConditionalEdge ifEdge = (ConditionalEdge) addEdge(source, ifTarget, ConditionalEdge.class); + ifEdge.setBooleanExpression(be); + ConditionalEdge elseEdge = (ConditionalEdge) addEdge(source, elseTarget, ConditionalEdge.class); + elseEdge.setBooleanExpression(be); + elseEdge.setNegate(true); + } + + public Edge addEdge(Node source, Node target) { + return addEdge(source, target, Edge.class); + } + + public Edge addEdge(Node source, Node target, Class clazz) { + Edge edge = getEdge(source, target); + if (edge != null) { + // TODO: Why not allow adding multiple edges? This is possible + // anyway through reroot or redirect! + throw new RuntimeException("Edge already exists"); + } + if (clazz.equals(Edge.class)) { + edge = new Edge(this, source, target); + } else if (clazz.equals(SwitchEdge.class)) { + edge = new SwitchEdge(this, source, target); + } else if (clazz.equals(ConditionalEdge.class)) { + edge = new ConditionalEdge(this, source, target); + } else { + throw new RuntimeException("Illegal edge class " + clazz); + } + source.addEdge(edge); + if (source != target) { + target.addEdge(edge); + } + return edge; + } + + public Edge getEdge(Node source, Node target) { + for (Edge edge : source.getOutEdges()) { + if (edge.target == target) return edge; + } + return null; + } + + public void removeNode(Node node) { + replaceNode(node, null); + } + + public Set removeOutEdges(Node node) { + Set outEdges = new HashSet(node.outEdges); + Iterator iter = outEdges.iterator(); + while (iter.hasNext()) { + Edge edge = (Edge) iter.next(); + removeEdge(edge); + } + + return outEdges; + } + + /** + * Removes all in-edges to the specified node. + * + * @return the set of removed in-edges + */ + public Set removeInEdges(Node node) { + Set inEdges = new HashSet(node.inEdges); + Iterator iter = inEdges.iterator(); + while (iter.hasNext()) { + Edge edge = iter.next(); + removeEdge(edge); + } + + return inEdges; + } + + public Set removeSelfEdges(Node node) { + Set selfEdges = new HashSet(); + + for (Edge edge: new HashSet(node.outEdges)) { + if (edge.target != node) continue; + removeEdge(edge); + selfEdges.add(edge); + } + + return selfEdges; + } + + public void rerootGlobalOutEdges(Node node, Node newSource) { + Edge[] edges = node.getOutEdgesArray(); + for (int i=0; i(oldNode.getDomChildren())) { + child.setDomParent(newNode); + } + } + + if (oldNode.inEdges.size() > 0 || oldNode.outEdges.size() > 0) + throw new RuntimeException("Cannot replace node with edges"); + + oldNode.setDomParent(null); + } + + public Collection getNodes() { + return nodes.values(); + } + + public int size() { + return getNodes().size(); + } + + public Block reduceDumb() { + Block block = new Block(); + + for (Node node : getNodes()) { + block.appendChild(node.block); + + if (node.isBranch()) { + IfStatement ifStmt = new IfStatement(); + ConditionalEdge cEdge = node.getConditionalEdge(true); + ifStmt.setExpression(cEdge.getBooleanExpression().getExpression()); + ifStmt.setIfBlock(new Block()); + Block targetBlock = cEdge.target.block; + ifStmt.getIfBlock().appendChild(new BreakStatement(targetBlock)); + ifStmt.setElseBlock(new Block()); + targetBlock = node.getConditionalEdge(false).target.block; + ifStmt.getElseBlock().appendChild(new BreakStatement(targetBlock)); + block.appendChild(ifStmt); + } else { + for (Edge e : node.getOutEdges()) { + BreakStatement bStmt = new BreakStatement(e.target.block); + node.block.appendChild(bStmt); + } + } + } + return block; + } + + boolean isTarget(Node n, Set edgeSet) { + Iterator iter = edgeSet.iterator(); + while (iter.hasNext()) { + Edge e = (Edge) iter.next(); + if (n == e.target) return true; + } + return false; + } + + public void rollOut(Node node, Block targetBlock) { + if (node.trans != null) { + node.trans.rollOut(targetBlock); + } else { + targetBlock.appendChildren(node.block); + } + } + + public void dump(String msg) { + StringBuffer sb = new StringBuffer(); + sb.append(msg + " ...\n"); + for (Node node : getNodes()) { + sb.append(node.describe() + "\n"); + //dump(node.block, "Block"); + } + sb.append("... " + msg); + logger.debug(sb.toString()); + } +} diff --git a/src/main/java/com/j2js/cfg/Node.java b/src/main/java/com/j2js/cfg/Node.java new file mode 100644 index 0000000..4ba115e --- /dev/null +++ b/src/main/java/com/j2js/cfg/Node.java @@ -0,0 +1,334 @@ +/* + * Copyright 2005 by Wolfgang Kuehn + * Created on 12.11.2005 + */ +package com.j2js.cfg; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.Set; + +import com.j2js.ASTNodeStack; +import com.j2js.cfg.transformation.Transformation; +import com.j2js.dom.Block; +import com.j2js.dom.Expression; +import com.j2js.dom.IfStatement; + +/** + * @author wolfgang + */ +public class Node { + + public class Reference { + public Node source; + public boolean isBackward = false; + } + + public static int NON_HEADER = 0; + public static int REDUCIBLE = 1; + public static int IRREDUCIBLE = 2; + + String id; + + Set inEdges = new LinkedHashSet(); + Set outEdges = new LinkedHashSet(); + Graph graph; + private int currentPc = -1; + private int initialPc = -1; + public ASTNodeStack stack = new ASTNodeStack(); + public Block block = new Block(); + public boolean closed = false; + + protected int preOrderIndex = -1; + + private Node domParent; // Block that (immediately) dominates this Block + private Set domChildren = new HashSet(); // Blocks that this Block dominates + + IfStatement ifStmt; + public Expression switchExpression; + + public Transformation trans; + public Collection jsrCallers = new HashSet(); + + public boolean isSwitchHeader = false; + + public Node(Graph theGraph, int pc) { + this(theGraph); + setInitialPc(pc); + } + + public Node(Graph theGraph) { + graph = theGraph; + } + + public int getComplexity() { + Node node = this; + int complexity = 0; + while (node.trans != null) { + complexity++; + node = node.trans.header; + } + return complexity; + } + + /** + * @return Returns the pc. + */ + public int getCurrentPc() { + return currentPc; + } + /** + * @param pc The pc to set. + */ + public void setCurrentPc(int pc) { + currentPc = pc; + } + + public void close() { + closed = true; + } + + public void addEdge(Edge e) { + if (e.source == this) { + if (!outEdges.add(e)) { + throw new RuntimeException("\n" + this + "\nalready bound to " + e); + } + } + + if (e.target == this) { + if (!inEdges.add(e)) { + throw new RuntimeException("" + this + " already bound to " + e); + } + } + } + + public String toString() { + String s = getClass().getName(); + // Same as getClass().getSimpleName() in JDK 5.0. + s = s.replaceFirst(".*\\.", ""); + + s += " " + id + "[" + initialPc + ", " + currentPc + "]"; + //if (preOrderIndex >= 0) s += " preIndex=" + preOrderIndex; + if (domParent != null) s += " dominated by " + domParent.id; + if (isLoopHeader()) s += " LH"; + return s; + } + + public String describe() { + String s = toString(); + Iterator iter = outEdges.iterator(); + while (iter.hasNext()) { + Edge e = (Edge) iter.next(); + s += "\n\t" + e; + } + return s; + } + + + /** + * @return Returns the inEdges. + */ + public Set getInEdges() { + return inEdges; + } + + public Edge getSelfEdge() { + Iterator iterator = inEdges.iterator(); + while (iterator.hasNext()) { + Edge edge = (Edge) iterator.next(); + if (edge.source == this) return edge; + } + return null; + } + +// public Set getGlobalInEdges() { +// HashSet set = new HashSet(); +// Iterator iterator = inEdges.iterator(); +// while (iterator.hasNext()) { +// Edge edge = (Edge) iterator.next(); +// if (edge.global) set.add(edge); +// } +// return set; +// } + +// public Set getForewardOutEdges() { +// HashSet set = new HashSet(); +// Iterator iterator = outEdges.iterator(); +// while (iterator.hasNext()) { +// Edge edge = (Edge) iterator.next(); +// if (!edge.isBackEdge()) set.add(edge); +// } +// return set; +// } + + /** + * @return Returns the outEdges. + */ + public Set getOutEdges() { + return outEdges; + } + + public Edge[] getOutEdgesArray() { + return outEdges.toArray(new Edge[outEdges.size()]); + } + + public Edge[] getInEdgesArray() { + return inEdges.toArray(new Edge[inEdges.size()]); + } + + public int getPreOrderIndex() { + return preOrderIndex; + } + + public void setPreOrderIndex(int thePreOrderIndex) { + preOrderIndex = thePreOrderIndex; + } + + public Set succs() { + Set list = new LinkedHashSet(); + Edge[] edges = getOutEdgesArray(); + for (int i=edges.length-1; i>=0; i--) { + list.add(edges[i].target); + } + return list; + } + + public Set preds() { + Set list = new LinkedHashSet(); + Iterator iter = inEdges.iterator(); + while (iter.hasNext()) { + Edge e = (Edge) iter.next(); + list.add(e.source); + } + return list; + } + + public Node getPred() { + int count = inEdges.size(); + if (count != 1) throw new RuntimeException("Requested unique predecessor, found " + count); + return inEdges.iterator().next().source; + } + + public Node getSucc() { + return getOutEdge().target; + } + + public Edge getLocalOutEdgeOrNull() { + Edge outEdge = null; + Iterator iter = outEdges.iterator(); + while (iter.hasNext()) { + Edge edge = (Edge) iter.next(); + if (outEdge != null) new RuntimeException("Found multiple local out-edges"); + outEdge = edge; + } + return outEdge; + } + + public Edge getOutEdge() { + int count = outEdges.size(); + if (count != 1) throw new RuntimeException("Requested unique successor, found " + count); + return outEdges.iterator().next(); + } + + /** + * Return true if this node is equal to or dominates the specified node. + */ + public boolean isDomAncestor(Node node) { + do { + if (node == null) return false; + if (node == this) return true; + node = node.getDomParent(); + } while (true); + } + + public Set getDomChildren() { + return domChildren; + } + + public Node getDomChild() { + if (domChildren.size() != 1) throw new RuntimeException("Node must have single child"); + return getDomChildren().iterator().next(); + } + + public Node getDomParent() { + return domParent; + } + + public void setDomParent(Node newDomParent) { + // If this Block already had a dominator specified, remove + // it from its dominator's children. + if (domParent != null) { + domParent.domChildren.remove(this); + } + + domParent = newDomParent; + + // Add this Block to its new dominator's children. + if (domParent != null) { + domParent.domChildren.add(this); + } + } + + public boolean isBranch() { + Edge[] edges = getOutEdgesArray(); + if (edges.length != 2) return false; + if (edges[0] instanceof ConditionalEdge && edges[1] instanceof ConditionalEdge) return true; + if ((edges[0] instanceof ConditionalEdge) || (edges[1] instanceof ConditionalEdge)) + throw new RuntimeException("Node must not have mixed edges"); + return false; + } + + /** + * Returns either the true or false edge. + */ + public ConditionalEdge getConditionalEdge(boolean trueFalse) { + if (!isBranch()) throw new RuntimeException("Node must be a branch"); + Iterator iter = outEdges.iterator(); + Edge edge = iter.next(); + if (!trueFalse) edge = iter.next(); + return (ConditionalEdge) edge; + } + + public String getId() { + return id; + } + + public int getInitialPc() { + return initialPc; + } + + public Graph getGraph() { + return graph; + } + + public void setInitialPc(int theInitialPc) { + initialPc = theInitialPc; + currentPc = theInitialPc; + } + + public boolean isLoopHeader() { + Iterator iter = inEdges.iterator(); + while (iter.hasNext()) { + Edge edge = (Edge) iter.next(); + if (edge.isBackEdge()) return true; + } + return false; + } + + public boolean hasSelfEdges() { + Iterator iter = outEdges.iterator(); + while (iter.hasNext()) { + Edge edge = (Edge) iter.next(); + if (edge.target == this) return true; + } + return false; + } + +// public void replaceEdge(Edge oldEdge, Edge newEdge) { +// source.outEdges.remove(this); +// newSource.outEdges.add(this); +// source = newSource; +// } +} diff --git a/src/main/java/com/j2js/cfg/SwitchEdge.java b/src/main/java/com/j2js/cfg/SwitchEdge.java new file mode 100644 index 0000000..ce58a82 --- /dev/null +++ b/src/main/java/com/j2js/cfg/SwitchEdge.java @@ -0,0 +1,14 @@ +package com.j2js.cfg; + +import java.util.ArrayList; +import java.util.List; + +import com.j2js.dom.NumberLiteral; + +public class SwitchEdge extends Edge { + public List expressions = new ArrayList(); + + SwitchEdge(Graph graph, Node theSource, Node theTarget) { + super(graph, theSource, theTarget); + } +} diff --git a/src/main/java/com/j2js/cfg/TryHeaderNode.java b/src/main/java/com/j2js/cfg/TryHeaderNode.java new file mode 100644 index 0000000..e1d74d0 --- /dev/null +++ b/src/main/java/com/j2js/cfg/TryHeaderNode.java @@ -0,0 +1,74 @@ +package com.j2js.cfg; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import com.j2js.dom.TryStatement; + +public class TryHeaderNode extends Node { + + public TryStatement tryStmt; + + public TryHeaderNode(Graph theGraph) { + super(theGraph); + } + + public void setTryBody(Node theTryBody) { + Edge edge = graph.addEdge(this, theTryBody); + edge.type = EdgeType.TRYBODY; + } + + public void setFinallyNode(Node theFinallyNode) { + Edge edge = graph.addEdge(this, theFinallyNode); + edge.type = EdgeType.FINALLY; + //finallyNode = theFinallyNode; + } + + public void addCatchNode(Node node) { + Edge edge = graph.addEdge(this, node); + edge.type = EdgeType.CATCH; + //catchNodes.add(node); + } + + public Node getSuccessor() { + Iterator iter = outEdges.iterator(); + while (iter.hasNext()) { + Edge edge = (Edge) iter.next(); + if (edge.type == null) return edge.target; + } + return null; + } + + public Node getTryBody() { + Iterator iter = outEdges.iterator(); + while (iter.hasNext()) { + Edge edge = (Edge) iter.next(); + if (edge.type == EdgeType.TRYBODY) return edge.target; + } + throw new RuntimeException(); + } + + public Node getFinallyNode() { + Iterator iter = outEdges.iterator(); + while (iter.hasNext()) { + Edge edge = (Edge) iter.next(); + if (edge.type == EdgeType.FINALLY) return edge.target; + } + return null; + } + + public List getCatchNodes() { + List catchNodes = new ArrayList(); + for (Edge edge : outEdges) { + if (edge.type == EdgeType.CATCH) catchNodes.add(edge.target); + } + + return catchNodes; + } + + public TryStatement getTryStatement() { + return tryStmt; + } + +} diff --git a/src/main/java/com/j2js/cfg/WrapperNode.java b/src/main/java/com/j2js/cfg/WrapperNode.java new file mode 100644 index 0000000..90f7ef0 --- /dev/null +++ b/src/main/java/com/j2js/cfg/WrapperNode.java @@ -0,0 +1,11 @@ +package com.j2js.cfg; + +public class WrapperNode extends Node{ + + Node node; + + public WrapperNode(Graph theGraph) { + super(theGraph); + } + +} diff --git a/src/main/java/com/j2js/cfg/transformation/Loop.java b/src/main/java/com/j2js/cfg/transformation/Loop.java new file mode 100644 index 0000000..fa298d3 --- /dev/null +++ b/src/main/java/com/j2js/cfg/transformation/Loop.java @@ -0,0 +1,47 @@ +package com.j2js.cfg.transformation; + +import java.util.Iterator; +import java.util.Set; + +import com.j2js.cfg.Edge; +import com.j2js.dom.Block; +import com.j2js.dom.BooleanLiteral; +import com.j2js.dom.WhileStatement; + + +public class Loop extends Transformation { + + private Set selfEdges; + + public boolean applies_() { + return header.hasSelfEdges(); + } + + public void apply_() { + // Remove self edges. + selfEdges = graph.removeSelfEdges(header); + } + + void rollOut_(Block block) { + WhileStatement loopStmt = new WhileStatement(); + Block loopBody = new Block(); + loopStmt.setBlock(loopBody); + loopStmt.setExpression(new BooleanLiteral(true)); + + block.appendChild(loopStmt); + + Iterator iter = selfEdges.iterator(); + while (iter.hasNext()) { + Edge edge = (Edge) iter.next(); + if (!edge.isGlobal()) continue; + loopStmt.isLabeled(); + produceJump(edge, loopStmt); + } + + graph.rollOut(header, loopBody); + } + + public String toString() { + return super.toString() + "(" + header + ")"; + } +} diff --git a/src/main/java/com/j2js/cfg/transformation/Merge.java b/src/main/java/com/j2js/cfg/transformation/Merge.java new file mode 100644 index 0000000..27f0068 --- /dev/null +++ b/src/main/java/com/j2js/cfg/transformation/Merge.java @@ -0,0 +1,77 @@ +package com.j2js.cfg.transformation; + +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + +import com.j2js.cfg.ControlFlowGraph; +import com.j2js.cfg.Edge; +import com.j2js.cfg.EdgeCollections; +import com.j2js.cfg.Node; +import com.j2js.dom.Block; + +/** + * @author wolfgang + */ +public class Merge extends Transformation { + + private Node tail; + private Set inEdgesForTail; + + public Merge() { + } + + public Merge(ControlFlowGraph theGraph) { + graph = theGraph; + } + + public boolean applies_() { + HashSet headerSet = new HashSet(); + headerSet.add(header); + + for (Node child : header.getDomChildren()) { + if (EdgeCollections.getSources(child.getInEdges()).equals(headerSet)) { + tail = child; + return true; + } + } + + return false; + } + + public void apply_() { + // Remove all in-edges to Tail. + inEdgesForTail = graph.removeInEdges(tail); + + // Reroot all out-edges from Tail. + graph.rerootOutEdges(tail, newNode, false); + + //Remove Tail. + graph.removeNode(tail); + } + + void rollOut_(Block block) { + Block labeledBlock = block; + + Iterator iter = inEdgesForTail.iterator(); + while (iter.hasNext()) { + Edge edge = (Edge) iter.next(); + if (!edge.isGlobal()) continue; + + if (labeledBlock == block) { + labeledBlock = new Block(); + block.appendChild(labeledBlock); + } + + produceJump(edge, labeledBlock); + } + + graph.rollOut(header, labeledBlock); + graph.rollOut(tail, block); + block.appendChildren(newNode.block); + } + + public String toString() { + return super.toString() + "(" + header + ", " + tail + ")"; + } +} diff --git a/src/main/java/com/j2js/cfg/transformation/Switch.java b/src/main/java/com/j2js/cfg/transformation/Switch.java new file mode 100644 index 0000000..d581bd3 --- /dev/null +++ b/src/main/java/com/j2js/cfg/transformation/Switch.java @@ -0,0 +1,83 @@ +package com.j2js.cfg.transformation; + +import java.util.ArrayList; +import java.util.List; + +import com.j2js.cfg.Edge; +import com.j2js.cfg.Node; +import com.j2js.cfg.SwitchEdge; +import com.j2js.dom.Block; +import com.j2js.dom.NumberLiteral; +import com.j2js.dom.SwitchCase; +import com.j2js.dom.SwitchStatement; + +/** + */ +public class Switch extends Transformation { + + private List caseGroups = new ArrayList(); + private List> caseGroupExpressions = new ArrayList>(); + + public boolean applies_() { + return header.isSwitchHeader; + } + + private void removeFallThroughEdgesl() { + Edge prevPotentialFallThroughEdge = null; + + for (Edge e : header.getOutEdges()) { + if (!(e instanceof SwitchEdge)) continue; + + SwitchEdge edge = (SwitchEdge) e; + Node caseGroup = edge.target; + + if (prevPotentialFallThroughEdge != null && prevPotentialFallThroughEdge.target == caseGroup) { + // This is a fall through edge. + graph.removeEdge(prevPotentialFallThroughEdge); + } + + prevPotentialFallThroughEdge = caseGroup.getLocalOutEdgeOrNull(); + } + } + + void apply_() { + removeFallThroughEdgesl(); + + for (Edge e : new ArrayList(header.getOutEdges())) { + if (!(e instanceof SwitchEdge)) continue; + + SwitchEdge edge = (SwitchEdge) e; + Node caseGroup = edge.target; + caseGroups.add(caseGroup); + caseGroupExpressions.add(edge.expressions); + graph.rerootOutEdges(caseGroup, newNode, true); + graph.removeOutEdges(caseGroup); + graph.removeInEdges(caseGroup); + graph.removeNode(caseGroup); + } + } + + void rollOut_(Block block) { + SwitchStatement switchStmt = new SwitchStatement(); + switchStmt.setExpression(header.switchExpression); + + for (int i=0; i " + newNode); + return newNode; + } + + public boolean applies(Node node) { + graph = (ControlFlowGraph) node.getGraph(); + header = node; + return applies_(); + } + + abstract boolean applies_(); + abstract void apply_(); + abstract void rollOut_(Block block); + + public void rollOut(Block block) { + rollOut_(block); + block.appendChildren(newNode.block); + } + + void produceJump(Edge edge, Block labeledBlock) { + Node referer = edge.getOrgSource(); + Block breakBlock; + if (edge instanceof ConditionalEdge) { + ConditionalEdge condEdge = (ConditionalEdge) edge; + BooleanExpression condExpr = condEdge.getBooleanExpression(); + Expression expr = Optimizer.simplifyBooleanExpression(condExpr.getExpression(), condEdge.isNegate()); + IfStatement ifStmt = new IfStatement(); + ifStmt.setExpression(expr); + referer.block.appendChild(ifStmt); + Block ifBlock = new Block(); + ifStmt.setIfBlock(ifBlock); + breakBlock = ifBlock; + } else { + breakBlock = referer.block; + } + + if (edge.isBackEdge()) { + breakBlock.appendChild(new ContinueStatement(labeledBlock)); + } else { + breakBlock.appendChild(new BreakStatement(labeledBlock)); + } + } + + public String toString() { + return getClass().getName(); + } +} diff --git a/src/main/java/com/j2js/cfg/transformation/Try.java b/src/main/java/com/j2js/cfg/transformation/Try.java new file mode 100644 index 0000000..4ad7779 --- /dev/null +++ b/src/main/java/com/j2js/cfg/transformation/Try.java @@ -0,0 +1,77 @@ +package com.j2js.cfg.transformation; + +import java.util.Iterator; +import java.util.List; + +import com.j2js.cfg.Node; +import com.j2js.cfg.TryHeaderNode; +import com.j2js.dom.Block; +import com.j2js.dom.CatchClause; +import com.j2js.dom.TryStatement; + +public class Try extends Transformation { + + private Node tryBodyNode; + private List catchNodes; + private Node finallyNode; + + boolean applies_() { + return header instanceof TryHeaderNode; + } + + void apply_() { + TryHeaderNode head = (TryHeaderNode) header; + catchNodes = head.getCatchNodes(); + + for (Node catchNode : head.getCatchNodes()) { + graph.rerootOutEdges(catchNode, newNode, false); + graph.removeInEdges(catchNode); + graph.removeNode(catchNode); + } + + tryBodyNode = head.getTryBody(); + graph.rerootOutEdges(tryBodyNode, newNode, false); + graph.removeInEdges(tryBodyNode); + graph.removeNode(tryBodyNode); + + finallyNode = head.getFinallyNode(); + if (finallyNode != null) { + Block b = finallyNode.block; + // Remove return address. + b.removeChild(b.getFirstChild()); + // Remove return statement. + b.removeChild(b.getLastChild()); + graph.rerootOutEdges(finallyNode, newNode, false); + graph.removeInEdges(finallyNode); + graph.removeNode(finallyNode); + } + + } + + void rollOut_(Block block) { + TryHeaderNode head = (TryHeaderNode) header; + + TryStatement stmt = head.getTryStatement(); + block.appendChild(stmt); + + graph.rollOut(tryBodyNode, stmt.getTryBlock()); + + if (finallyNode != null) { + stmt.setFinallyBlock(new Block()); + graph.rollOut(finallyNode, stmt.getFinallyBlock()); + } + + CatchClause cc = (CatchClause) stmt.getCatchStatements().getFirstChild(); + Iterator iter = catchNodes.iterator(); + while (iter.hasNext()) { + Node catchNode = (Node) iter.next(); + graph.rollOut(catchNode, cc); + cc = (CatchClause) cc.getNextSibling(); + } + } + + public String toString() { + return super.toString() + "(" + header + ")"; + } + +} diff --git a/src/main/java/com/j2js/dom/ASTNode.java b/src/main/java/com/j2js/dom/ASTNode.java new file mode 100644 index 0000000..630a1b9 --- /dev/null +++ b/src/main/java/com/j2js/dom/ASTNode.java @@ -0,0 +1,200 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/* + * Statement.java + * + * Created on 21. Mai 2004, 11:45 + */ + +/** + * + * @author kuehn + */ +public class ASTNode { + + public static final int BEFORE = 0; + public static final int AFTER = 1; + public static final int SAME = 2; + public static final int CONTAINS = 3; + public static final int ISCONTAINED = 4; + + int beginIndex = Integer.MAX_VALUE; + int endIndex = Integer.MIN_VALUE; + private ASTNode parent = null; + private ASTNode previousSibling = null; + private ASTNode nextSibling = null; + + private int stackDelta = 0; + + public ASTNode() { + super(); + } + + public ASTNode(int theBeginIndex, int theEndIndex) { + setRange(theBeginIndex, theEndIndex); + } + + /** + * @return Returns the stackDelta. + */ + public int getStackDelta() { + return stackDelta; + } + + /** + * @param theStackDelta The stackDelta to set. + */ + public void setStackDelta(int theStackDelta) { + stackDelta = theStackDelta; + } + + public void widen(ASTNode node) { + leftWiden(node.beginIndex); + rightWiden(node.endIndex); + } + + public void leftWiden(int targetBeginIndex) { + if (targetBeginIndex < beginIndex) beginIndex = targetBeginIndex; + } + + public void rightWiden(int targetEndIndex) { + if (targetEndIndex > endIndex) endIndex = targetEndIndex; + } + + public void setRange(int theBeginIndex, int theEndIndex) { + setBeginIndex(theBeginIndex); + setEndIndex(theEndIndex); + } + +// private void checkRange() { +// if (endIndex!=Integer.MIN_VALUE && beginIndex!=Integer.MAX_VALUE && endIndex" + endIndex); +// } +// } + + /** Getter for property beginIndex. + * @return Value of property beginIndex. + */ + public int getBeginIndex() { + return beginIndex; + } + + /** Setter for property beginIndex. + * @param theBeginIndex New value of property beginIndex. + */ + public void setBeginIndex(int theBeginIndex) { + beginIndex = theBeginIndex; + } + + /** Getter for property endIndex. + * @return Value of property endIndex. + */ + public int getEndIndex() { + return endIndex; + } + + /** Setter for property endIndex. + * @param endIndex New value of property endIndex. + */ + public void setEndIndex(int theEndIndex) { + endIndex = theEndIndex; + } + + public boolean isRightSiblingOf(ASTNode leftSibling) { + for (ASTNode node=this; node!=null; node=node.getPreviousSibling()) { + if (node == leftSibling) { + return true; + } + } + return false; + } + + public ASTNode rightMostSibling() { + for (ASTNode node=this;;) { + if (node.getNextSibling() == null) { + return node; + } + node = node.getNextSibling(); + } + } + + public boolean isAncestorOf(ASTNode node) { + do { + node = node.getParentNode(); + if (node == this) { + return true; + } + } while (node != null); + + return false; + } + + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(getClass().getSimpleName()); + if (getBeginIndex() != Integer.MAX_VALUE) { + sb.append("["); + sb.append(getBeginIndex()); + sb.append(", "); + sb.append(getEndIndex()); + sb.append("]"); + } + return sb.toString(); + } + + /** + * @return Returns the parent. + */ + public ASTNode getParentNode() { + return parent; + } + + public Block getParentBlock() { + return (Block) parent; + } + + public Block getLogicalParentBlock() { + if (parent != null && parent.parent instanceof IfStatement) { + return (Block) parent.parent; + } + return (Block) parent; + } + + /** + * @param theParent The parent to set. + */ + public void setParentNode(ASTNode theParent) { + parent = theParent; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the nextSibling. + */ + public ASTNode getNextSibling() { + return nextSibling; + } + /** + * @param theNextSibling The nextSibling to set. + */ + public void setNextSibling(ASTNode theNextSibling) { + nextSibling = theNextSibling; + } + /** + * @return Returns the previousSibling. + */ + public ASTNode getPreviousSibling() { + return previousSibling; + } + /** + * @param thePreviousSibling The previousSibling to set. + */ + public void setPreviousSibling(ASTNode thePreviousSibling) { + previousSibling = thePreviousSibling; + } +} diff --git a/src/main/java/com/j2js/dom/ArrayAccess.java b/src/main/java/com/j2js/dom/ArrayAccess.java new file mode 100644 index 0000000..8f1aef2 --- /dev/null +++ b/src/main/java/com/j2js/dom/ArrayAccess.java @@ -0,0 +1,54 @@ +/* + * Created on Oct 31, 2004 + */ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class ArrayAccess extends Expression implements Assignable { + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public boolean isSame(Object obj) { + if (!(obj instanceof ArrayAccess)) return false; + ArrayAccess other = (ArrayAccess) obj; + if (getArray() instanceof VariableBinding && other.getArray() instanceof VariableBinding) { + VariableBinding vba = (VariableBinding) getArray(); + VariableBinding vbb = (VariableBinding) other.getArray(); + return vba.getVariableDeclaration() == vbb.getVariableDeclaration(); + } + return false; + } + + /** + * @return Returns the array. + */ + public Expression getArray() { + return (Expression) getChildAt(0); + } + /** + * @param array The array to set. + */ + public void setArray(Expression array) { + widen(array); + setChildAt(0, array); + } + /** + * @return Returns the index. + */ + public Expression getIndex() { + return (Expression) getChildAt(1); + } + /** + * @param index The index to set. + */ + public void setIndex(Expression index) { + widen(index); + setChildAt(1, index); + } +} diff --git a/src/main/java/com/j2js/dom/ArrayCreation.java b/src/main/java/com/j2js/dom/ArrayCreation.java new file mode 100644 index 0000000..35a881d --- /dev/null +++ b/src/main/java/com/j2js/dom/ArrayCreation.java @@ -0,0 +1,50 @@ +package com.j2js.dom; + +import java.util.List; + +import org.apache.bcel.generic.Type; + +import com.j2js.assembly.Project; +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class ArrayCreation extends Expression { + + private List dimensions; + private ArrayInitializer initializer; + + public ArrayCreation(MethodDeclaration methodDecl, Type theType, List theDimensions) { + type = theType; + dimensions = theDimensions; + for (ASTNode dimension : dimensions) { + this.widen(dimension); + } + Project.getSingleton().addReference(methodDecl, this); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the initializer. + */ + public ArrayInitializer getInitializer() { + return initializer; + } + /** + * @param theInitializer The initializer to set. + */ + public void setInitializer(ArrayInitializer theInitializer) { + initializer = theInitializer; + } + /** + * @return Returns the dimensions. + */ + public List getDimensions() { + return dimensions; + } + +} diff --git a/src/main/java/com/j2js/dom/ArrayInitializer.java b/src/main/java/com/j2js/dom/ArrayInitializer.java new file mode 100644 index 0000000..b151a07 --- /dev/null +++ b/src/main/java/com/j2js/dom/ArrayInitializer.java @@ -0,0 +1,24 @@ +package com.j2js.dom; + +import java.util.List; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class ArrayInitializer extends Expression { + + private List expressions = new java.util.ArrayList(); + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the expressions. + */ + public List getExpressions() { + return expressions; + } +} diff --git a/src/main/java/com/j2js/dom/Assignable.java b/src/main/java/com/j2js/dom/Assignable.java new file mode 100644 index 0000000..a60a0ba --- /dev/null +++ b/src/main/java/com/j2js/dom/Assignable.java @@ -0,0 +1,17 @@ +/* + * Copyright 2005 by Wolfgang Kuehn + * Created on 16.10.2005 + */ +package com.j2js.dom; + +/** + * Tagging interface for all node types which are legal assignment targets. + */ +public interface Assignable { + + /** + * Returns true if the specified Assignable corresponds to this Assignable. + */ + public boolean isSame(Object obj); + +} diff --git a/src/main/java/com/j2js/dom/Assignment.java b/src/main/java/com/j2js/dom/Assignment.java new file mode 100644 index 0000000..df54d30 --- /dev/null +++ b/src/main/java/com/j2js/dom/Assignment.java @@ -0,0 +1,96 @@ +package com.j2js.dom; + +import java.util.HashMap; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author kuehn + */ +public class Assignment extends Expression { + + static public class Operator { + + static private HashMap opsByToken = new HashMap(); + + static public Operator lookup(String token) { + return opsByToken.get(token); + } + + static public Operator ASSIGN = new Operator("="); + static public Operator PLUS_ASSIGN = new Operator("+="); + static public Operator MINUS_ASSIGN = new Operator("-="); + static public Operator TIMES_ASSIGN = new Operator("*="); + static public Operator DIVIDE_ASSIGN = new Operator("/="); + static public Operator BIT_AND_ASSIGN = new Operator("&="); + static public Operator BIT_OR_ASSIGN = new Operator("|="); + static public Operator BIT_XOR_ASSIGN = new Operator("^="); + static public Operator REMAINDER_ASSIGN = new Operator("%="); + static public Operator LEFT_SHIFT_ASSIGN = new Operator("<<="); + static public Operator RIGHT_SHIFT_SIGNED_ASSIGN = new Operator(">>="); + static public Operator RIGHT_SHIFT_UNSIGNED_ASSIGN = new Operator(">>>="); + + private String token; + + Operator(String theToken) { + token = theToken; + opsByToken.put(theToken, this); + } + + public String toString() { + return token; + } + } + + private Operator operator; + + public Assignment(Operator theOperator) { + super(); + operator = theOperator; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @param rightHandSide The rightHandSide to set. + */ + public void setRightHandSide(Expression rightHandSide) { + widen(rightHandSide); + setChildAt(1, rightHandSide); + } + + /** + * @return Returns the rightHandSide. + */ + public Expression getRightHandSide() { + return (Expression) getChildAt(1); + } + + /** + * @param leftHandSide The leftHandSide to set. + */ + public void setLeftHandSide(Expression leftHandSide) { + setChildAt(0, leftHandSide); + } + + /** + * @return Returns the leftHandSide. + */ + public Expression getLeftHandSide() { + return (Expression) getChildAt(0); + } + /** + * @return Returns the operator. + */ + public Operator getOperator() { + return operator; + } + /** + * @param theOerator The operator to set. + */ + public void setOperator(Operator theOperator) { + operator = theOperator; + } +} diff --git a/src/main/java/com/j2js/dom/Block.java b/src/main/java/com/j2js/dom/Block.java new file mode 100644 index 0000000..cd68d02 --- /dev/null +++ b/src/main/java/com/j2js/dom/Block.java @@ -0,0 +1,356 @@ +package com.j2js.dom; + +import com.j2js.Log; +import com.j2js.visitors.AbstractVisitor; +import org.w3c.dom.DOMException; + +/* + * Block.java + * + * Created on 21. Mai 2004, 11:38 + */ +public class Block extends ASTNode { + + public static int TAG = 0; + + private String label; + + private ASTNode firstChild = null; + private ASTNode lastChild = null; + private int childCount = 0; + + public Block() { + super(); + } + + public Block(int theBeginIndex) { + setBeginIndex(theBeginIndex); + } + + public Block(int theBeginIndex, int theEndIndex) { + this(theBeginIndex); + setRange(theBeginIndex, theEndIndex); + } + +// public Block getFooBlock() { +// Block block = this; +// while (block!=null) { +// if (!block.getClass().equals(Block.class)) { +// return block; +// } +// block = block.getParentBlock(); +// } +// return this; +// } + + public int getTargetPc() { + if (lastChild instanceof Jump) { + return ((Jump) lastChild).getTargetIndex(); + } + return Integer.MAX_VALUE; + } + + public int getTargetIndex() { + return beginIndex; + } + + public void setBeginIndex(int theBeginIndex) { + super.setBeginIndex(theBeginIndex); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public void appendChildren(ASTNode begin, ASTNode end) { + if (begin == null || end == null) { + throw new RuntimeException("Illegal null parameters"); + } + if (begin.getParentBlock() != null) + (begin.getParentBlock()).removeChildren(begin, end); + + if (firstChild == null) { + setFirstChildInternal(begin); + } else { + ASTNode prev = getLastChild(); + prev.setNextSibling(begin); + begin.setPreviousSibling(prev); + } + setLastChildInternal(end); + + ASTNode node = begin; + while (node != null) { + node.setParentNode(this); + childCount++; + if (node == end) break; + node = node.getNextSibling(); + } + } + + /** + * Appends all children of the specified block to this block. + * @param sourceBlock + */ + public void appendChildren(Block sourceBlock) { + if (sourceBlock.getChildCount() > 0) { + appendChildren(sourceBlock.getFirstChild(), sourceBlock.getLastChild()); + } + } + + /** + * Sets the specified node at the index. Returns the replaced node, or null if the index + * was equal to the cild count. + */ + public ASTNode setChildAt(int index, ASTNode newChild) { + if (index == childCount) { + appendChild(newChild); + return null; + } else if (index < 0 || index > childCount) { + throw new RuntimeException("Index " + index + " out of range [0, " + childCount + "]"); + } + + return replaceChild(newChild, getChildAt(index)); + } + + public ASTNode getChildAt(int index) { + if (childCount == 0) { + throw new RuntimeException("Requested child at index " + index + ", but block has no children"); + } + if (index < 0 || index >= childCount) { + throw new RuntimeException("Index " + index + " out of range [0, " + (childCount-1) + "]"); + } + + if (index == childCount-1) { + return getLastChild(); + } + + ASTNode node = getFirstChild(); + int i = 0; + while (i < index) { + i++; + node = node.getNextSibling(); + } + + return node; + } + + public ASTNode appendChild(ASTNode newChild) { + Log.getLogger().debug("Appending " + newChild + " to " + this); + + unlink(newChild); + + if (firstChild == null) { + newChild.setPreviousSibling(null); + setFirstChildInternal(newChild); + } else { + ASTNode prev = getLastChild(); + prev.setNextSibling(newChild); + newChild.setPreviousSibling(prev); + } + setLastChildInternal(newChild); + newChild.setParentNode(this); + childCount++; + + return newChild; + } + + public ASTNode replaceChild(ASTNode newChild, ASTNode oldChild) { + Log.getLogger().debug("Replacing " + oldChild + " by " + newChild + " in " + this); + if (oldChild.getParentNode() != this) { + throw new DOMException(DOMException.NOT_FOUND_ERR, "Node " + oldChild + " is not a child of " + this); + } + unlink(newChild); + if (oldChild.getPreviousSibling() != null) { + oldChild.getPreviousSibling().setNextSibling(newChild); + } + if (oldChild.getNextSibling() != null) { + oldChild.getNextSibling().setPreviousSibling(newChild); + } + newChild.setPreviousSibling(oldChild.getPreviousSibling()); + newChild.setNextSibling(oldChild.getNextSibling()); + newChild.setParentNode(this); + if (getFirstChild() == oldChild) { + setFirstChildInternal(newChild); + } + if (getLastChild() == oldChild) { + setLastChildInternal(newChild); + } + oldChild.setPreviousSibling(null); + oldChild.setNextSibling(null); + oldChild.setParentNode(null); + return oldChild; + } + + public ASTNode removeChild(ASTNode oldChild) { + Log.getLogger().debug("Removing " + oldChild + " from " + this); + removeChildren(oldChild, oldChild); + + oldChild.setPreviousSibling(null); + oldChild.setNextSibling(null); + return oldChild; + } + + /** + * Removes all children from begin to end inclusively. + */ + private void removeChildren(ASTNode begin, ASTNode end) { + if (begin == null || end == null) throw new RuntimeException("Illegal null parameters"); + ASTNode node = begin; + while (node!= null) { + if (node.getParentNode() != this) { + throw new DOMException(DOMException.NOT_FOUND_ERR, "Node " + node + " is not a child of " + this); + } + node.setParentNode(null); + childCount--; + if (node == end) break; + node = node.getNextSibling(); + } + + + if (node != end) { + throw new RuntimeException("Node " + end + " is not a right-sibling of " + begin); + } + + if (begin.getPreviousSibling() != null) { + begin.getPreviousSibling().setNextSibling(end.getNextSibling()); + } + if (end.getNextSibling() != null) { + end.getNextSibling().setPreviousSibling(begin.getPreviousSibling()); + } + if (getFirstChild() == begin) { + setFirstChildInternal(end.getNextSibling()); + } + if (getLastChild() == end) { + setLastChildInternal(begin.getPreviousSibling()); + } + } + + public void removeChildren() { + if (getFirstChild() != null) { + removeChildren(getFirstChild(), getLastChild()); + } + } + + public int getChildCount() { + return childCount; + } + + /** + * Inserts the node newChild after the existing child node refChild. + * If refChild is null, insert newChild at the beginning of the list of children. + * + * @param newChild The node to insert + * @param refChild The reference node, i.e., the node before which the new node must be inserted + * @return + */ +// public ASTNode insertAfter(ASTNode newChild, ASTNode refChild) { +// if (refChild == null) { +// refChild = getFirstChild(); +// } else { +// refChild = refChild.getNextSibling(); +// } +// return insertBefore(newChild, refChild); +// } + + /** + * Inserts the node newChild before the existing child node refChild. + * If refChild is null, insert newChild at the end of the list of children. + * + * @param newChild The node to insert + * @param refChild The reference node, i.e., the node before which the new node must be inserted + * @return + */ + public ASTNode insertBefore(ASTNode newChild, ASTNode refChild) { + if (refChild == null) { + return appendChild(newChild); + } + + Log.getLogger().debug("Inserting " + newChild + " before " + refChild + " in " + this); + + if (refChild.getParentNode() != this) { + throw new DOMException(DOMException.NOT_FOUND_ERR, "Reference " + refChild + " is not a child of " + this); + } + + unlink(newChild); + + if (refChild.getPreviousSibling() != null) { + refChild.getPreviousSibling().setNextSibling(newChild); + } + newChild.setPreviousSibling(refChild.getPreviousSibling()); + newChild.setNextSibling(refChild); + newChild.setParentNode(this); + childCount++; + + refChild.setPreviousSibling(newChild); + + if (getFirstChild() == refChild) { + setFirstChildInternal(newChild); + } + + return newChild; + } + + public void addStatements(java.util.List statements) { + for (int i=0; i "; + if (target != null) { + Exception e = new Exception(); + if (target == this) { + s += "self"; + } else if (e.getStackTrace().length>20) { + s += "..."; + } else { + s += "" + target.toString(); + } + } else { + s += "null"; + } + return s; + } + /** + * @return Returns the target. + */ + public ASTNode getTarget() { + return target; + } + /** + * @param theTarget The target to set. + */ + public void setTarget(ASTNode theTarget) { + target = theTarget; + if (theTarget != null) targetIndex = theTarget.getBeginIndex(); + } +} diff --git a/src/main/java/com/j2js/dom/BreakStatement.java b/src/main/java/com/j2js/dom/BreakStatement.java new file mode 100644 index 0000000..d9b4c46 --- /dev/null +++ b/src/main/java/com/j2js/dom/BreakStatement.java @@ -0,0 +1,19 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +public class BreakStatement extends LabeledJump { + + public BreakStatement(String theLabel) { + super(theLabel); + } + + public BreakStatement(Block block) { + super(block); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + +} diff --git a/src/main/java/com/j2js/dom/CastExpression.java b/src/main/java/com/j2js/dom/CastExpression.java new file mode 100644 index 0000000..16afe3b --- /dev/null +++ b/src/main/java/com/j2js/dom/CastExpression.java @@ -0,0 +1,31 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author kuehn + */ +public class CastExpression extends Expression { + + private Expression expression; + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @param theExpression The expression to set. + */ + public void setExpression(Expression theExpression) { + widen(theExpression); + expression = theExpression; + } + + /** + * @return Returns the expression. + */ + public Expression getExpression() { + return expression; + } + +} diff --git a/src/main/java/com/j2js/dom/CatchClause.java b/src/main/java/com/j2js/dom/CatchClause.java new file mode 100644 index 0000000..963857d --- /dev/null +++ b/src/main/java/com/j2js/dom/CatchClause.java @@ -0,0 +1,45 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + + +/* + * CatchStatement.java + * + * Created on 22. Mai 2004, 22:49 + */ + +/** + * + * @author kuehn + */ +public class CatchClause extends Block { + + private VariableDeclaration exception; + + /** Creates a new instance of CatchStatement */ + //public CatchStatement() { + //} + + public CatchClause(int theBeginIndex) { + super(theBeginIndex); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the exception. + */ + public VariableDeclaration getException() { + return exception; + } + + /** + * @param theException The exception to set. + */ + public void setException(VariableDeclaration theException) { + exception = theException; + } +} diff --git a/src/main/java/com/j2js/dom/ClassInstanceCreation.java b/src/main/java/com/j2js/dom/ClassInstanceCreation.java new file mode 100644 index 0000000..1529fa4 --- /dev/null +++ b/src/main/java/com/j2js/dom/ClassInstanceCreation.java @@ -0,0 +1,24 @@ +package com.j2js.dom; + +import org.apache.bcel.generic.ObjectType; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class ClassInstanceCreation extends MethodInvocation { + + public ClassInstanceCreation(ObjectType theType) { + type = theType; + } + + public ClassInstanceCreation(MethodDeclaration methodDecl, MethodBinding methodBinding) { + super(methodDecl, methodBinding); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + +} diff --git a/src/main/java/com/j2js/dom/ClassLiteral.java b/src/main/java/com/j2js/dom/ClassLiteral.java new file mode 100644 index 0000000..29221aa --- /dev/null +++ b/src/main/java/com/j2js/dom/ClassLiteral.java @@ -0,0 +1,22 @@ +package com.j2js.dom; + +import com.j2js.assembly.Signature; +import com.j2js.visitors.AbstractVisitor; + +public class ClassLiteral extends Expression { + + private Signature signature; + + public ClassLiteral(Signature theSignature) { + signature = theSignature; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public Signature getSignature() { + return signature; + } + +} diff --git a/src/main/java/com/j2js/dom/ConditionalBranch.java b/src/main/java/com/j2js/dom/ConditionalBranch.java new file mode 100644 index 0000000..b747329 --- /dev/null +++ b/src/main/java/com/j2js/dom/ConditionalBranch.java @@ -0,0 +1,41 @@ +/* + * Created on Feb 13, 2005 + */ +package com.j2js.dom; + +/** + * Copyright by Wolfgang Kuehn 2005 + */ +public class ConditionalBranch extends Branch { + + private Expression expression; + + public ConditionalBranch(int targetIndex) { + super(targetIndex); + } + + /** + * This constructor is for testing purposes only!! + */ + public ConditionalBranch(int theBeginIndex, int theEndIndex, int targetIndex) { + super(targetIndex); + setExpression(new Expression(theBeginIndex, theEndIndex)); + } + + /** + * @return Returns the condition. + */ + public Expression getExpression() { + return expression; + } + + /** + * @param condition The condition to set. + */ + public void setExpression(Expression theExpression) { + expression = theExpression; + widen(theExpression); + appendChild(theExpression); + } + +} diff --git a/src/main/java/com/j2js/dom/ConditionalExpression.java b/src/main/java/com/j2js/dom/ConditionalExpression.java new file mode 100644 index 0000000..175d1c9 --- /dev/null +++ b/src/main/java/com/j2js/dom/ConditionalExpression.java @@ -0,0 +1,61 @@ +/* + * Created on Sep 10, 2005 + */ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class ConditionalExpression extends Expression { + + private Expression conditionExpression = null; + private Expression thenExpression = null; + private Expression elseExpression = null; + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the conditionExpression. + */ + public Expression getConditionExpression() { + return conditionExpression; + } + /** + * @param theConditionExpression The conditionExpression to set. + */ + public void setConditionExpression(Expression theConditionExpression) { + widen(theConditionExpression); + conditionExpression = theConditionExpression; + } + /** + * @return Returns the elseExpression. + */ + public Expression getElseExpression() { + return elseExpression; + } + /** + * @param theElseExpression The elseExpression to set. + */ + public void setElseExpression(Expression theElseExpression) { + widen(theElseExpression); + elseExpression = theElseExpression; + } + /** + * @return Returns the thenExpression. + */ + public Expression getThenExpression() { + return thenExpression; + } + /** + * @param theThenExpression The thenExpression to set. + */ + public void setThenExpression(Expression theThenExpression) { + widen(theThenExpression); + thenExpression = theThenExpression; + } + +} diff --git a/src/main/java/com/j2js/dom/ContinueStatement.java b/src/main/java/com/j2js/dom/ContinueStatement.java new file mode 100644 index 0000000..a28ede9 --- /dev/null +++ b/src/main/java/com/j2js/dom/ContinueStatement.java @@ -0,0 +1,16 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +public class ContinueStatement extends LabeledJump { + + public ContinueStatement(Block block) { + super(block); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + +} + diff --git a/src/main/java/com/j2js/dom/DoStatement.java b/src/main/java/com/j2js/dom/DoStatement.java new file mode 100644 index 0000000..b3bb863 --- /dev/null +++ b/src/main/java/com/j2js/dom/DoStatement.java @@ -0,0 +1,32 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/* + * DoStatement.java + * + * Created on 21. Mai 2004, 17:30 + */ + +/** + * + * @author kuehn + */ +public class DoStatement extends LoopStatement { + + public DoStatement() { + super(); + } + + public DoStatement(int theBeginIndex) { + super(theBeginIndex); + } + + public DoStatement(int theBeginIndex, int theEndIndex) { + super(theBeginIndex, theEndIndex); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } +} diff --git a/src/main/java/com/j2js/dom/Expression.java b/src/main/java/com/j2js/dom/Expression.java new file mode 100644 index 0000000..032bbf0 --- /dev/null +++ b/src/main/java/com/j2js/dom/Expression.java @@ -0,0 +1,52 @@ +package com.j2js.dom; + +import org.apache.bcel.generic.Type; + +import com.j2js.Form; + +/** + * Copyright by Wolfgang Kuehn 2005 + * Created on Feb 17, 2005 + */ +public class Expression extends Block implements Cloneable { + + Type type = Type.UNKNOWN; + + public Expression() { + super(); + } + + public Expression(int theBeginIndex, int theEndIndex) { + super(theBeginIndex, theEndIndex); + } + + public Object clone() { + if (getChildCount() > 0) throw new RuntimeException("Cannot clone expression with children"); + ASTNode node; + try { + node = (ASTNode) super.clone(); + } catch (CloneNotSupportedException e) { + return null; + } + node.setParentNode(null); + node.setPreviousSibling(null); + node.setNextSibling(null); + return node; + } + + public Type getTypeBinding() { + return type; + } + + public void setTypeBinding(Type theType) { + type = theType; + } + + public int getCategory() { + if (getTypeBinding().getType() == Type.LONG.getType()) return Form.CATEGORY2; + if (getTypeBinding().getType() == Type.DOUBLE.getType()) return Form.CATEGORY2; + return Form.CATEGORY1; + //return getTypeBinding().getType() == Type.LONG.getType() || getTypeBinding().getType() == Type.DOUBLE.getType()?Form.CATEGORY2:Form.CATEGORY1; + } + +} diff --git a/src/main/java/com/j2js/dom/FieldAccess.java b/src/main/java/com/j2js/dom/FieldAccess.java new file mode 100644 index 0000000..08cb5a7 --- /dev/null +++ b/src/main/java/com/j2js/dom/FieldAccess.java @@ -0,0 +1,85 @@ +package com.j2js.dom; + +import org.apache.bcel.generic.ObjectType; + +import com.j2js.assembly.Project; +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public abstract class FieldAccess extends Expression { + + private String name; + private ObjectType type; + //private MethodDeclaration methodDecl; + + public FieldAccess() { + } + + public void initialize(MethodDeclaration methodDecl) { + Project.getSingleton().addReference(methodDecl, this); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + +// if (!faa.getName().equals(fab.getName())) return false; +// + public boolean isSame(Object obj) { + if (!(obj instanceof FieldAccess)) return false; + FieldAccess other = (FieldAccess) obj; + if (!name.equals(other.name)) return false; + if (getExpression() instanceof VariableBinding && other.getExpression() instanceof VariableBinding) { + VariableBinding vba = (VariableBinding) getExpression(); + VariableBinding vbb = (VariableBinding) other.getExpression(); + return vba.getVariableDeclaration() == vbb.getVariableDeclaration(); + } + return false; + } + + /** + * @return Returns the expression. + */ + public Expression getExpression() { + return (Expression) getFirstChild(); + } + + /** + * @param expression The expression to set. + */ + public void setExpression(Expression expression) { + widen(expression); + removeChildren(); + appendChild(expression); + } + + /** + * @return Returns the name. + */ + public String getName() { + return name; + } + + /** + * @param theName The name to set. + */ + public void setName(String theName) { + name = theName; + } + + public String toString() { + return super.toString() + " " + name; + } + + public ObjectType getType() { + return type; + } + + public void setType(ObjectType theType) { + if (type != null) throw new RuntimeException("Type is already set"); + type = theType; + } + +} diff --git a/src/main/java/com/j2js/dom/FieldRead.java b/src/main/java/com/j2js/dom/FieldRead.java new file mode 100644 index 0000000..8e01ed9 --- /dev/null +++ b/src/main/java/com/j2js/dom/FieldRead.java @@ -0,0 +1,14 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +public class FieldRead extends FieldAccess { + + public FieldRead() { + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + +} diff --git a/src/main/java/com/j2js/dom/FieldWrite.java b/src/main/java/com/j2js/dom/FieldWrite.java new file mode 100644 index 0000000..27de586 --- /dev/null +++ b/src/main/java/com/j2js/dom/FieldWrite.java @@ -0,0 +1,14 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +public class FieldWrite extends FieldAccess implements Assignable { + + public FieldWrite() { + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + +} diff --git a/src/main/java/com/j2js/dom/Goto.java b/src/main/java/com/j2js/dom/Goto.java new file mode 100644 index 0000000..0fd9f0e --- /dev/null +++ b/src/main/java/com/j2js/dom/Goto.java @@ -0,0 +1,13 @@ +/* + * Copyright 2005 by Wolfgang Kuehn + * Created on 12.11.2005 + */ +package com.j2js.dom; + +/** + * @author wolfgang + */ +public class Goto extends ASTNode { + + +} diff --git a/src/main/java/com/j2js/dom/IfStatement.java b/src/main/java/com/j2js/dom/IfStatement.java new file mode 100644 index 0000000..3b2f62e --- /dev/null +++ b/src/main/java/com/j2js/dom/IfStatement.java @@ -0,0 +1,46 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author kuehn + */ +public class IfStatement extends Block { + + public IfStatement() { + super(); + } + + public Expression getExpression() { + return (Expression) getChildAt(0); + } + + public void setExpression(Expression expression) { + widen(expression); + setChildAt(0, expression); + } + + public Block getIfBlock() { + return (Block) getChildAt(1); + } + + public void setIfBlock(Block block) { + widen(block); + setChildAt(1, block); + } + + public Block getElseBlock() { + if (getChildCount() < 3) return null; + return (Block) getChildAt(2); + } + + public void setElseBlock(Block block) { + widen(block); + setChildAt(2, block); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + +} diff --git a/src/main/java/com/j2js/dom/InfixExpression.java b/src/main/java/com/j2js/dom/InfixExpression.java new file mode 100644 index 0000000..473097d --- /dev/null +++ b/src/main/java/com/j2js/dom/InfixExpression.java @@ -0,0 +1,111 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author kuehn + */ +public class InfixExpression extends Expression { + + static public class Operator { + static public Operator CONDITIONAL_AND = new Operator("&&"); + static public Operator CONDITIONAL_OR = new Operator("||"); + static public Operator PLUS = new Operator("+"); + static public Operator MINUS = new Operator("-"); + static public Operator TIMES = new Operator("*"); + static public Operator DIVIDE = new Operator("/"); + static public Operator REMAINDER = new Operator("%"); + static public Operator XOR = new Operator("^"); + static public Operator AND = new Operator("&"); + static public Operator OR = new Operator("|"); + static public Operator EQUALS = new Operator("=="); + static public Operator NOT_EQUALS = new Operator("!="); + static public Operator GREATER_EQUALS = new Operator(">="); + static public Operator GREATER = new Operator(">"); + static public Operator LESS_EQUALS = new Operator("<="); + static public Operator LESS = new Operator("<"); + static public Operator RIGHT_SHIFT_SIGNED = new Operator(">>"); + static public Operator LEFT_SHIFT = new Operator("<<"); + static public Operator RIGHT_SHIFT_UNSIGNED = new Operator(">>>"); + + static { + EQUALS.complement = NOT_EQUALS; + NOT_EQUALS.complement = EQUALS; + GREATER_EQUALS.complement = LESS; + GREATER.complement = LESS_EQUALS; + LESS_EQUALS.complement = GREATER; + LESS.complement = GREATER_EQUALS; + CONDITIONAL_AND.complement = CONDITIONAL_OR; + CONDITIONAL_OR.complement = CONDITIONAL_AND; + } + + private String token; + private Operator complement; + + Operator(String theToken) { + token = theToken; + } + + public String toString() { + return token; + } + + /** + * @return Returns the complement. + */ + public Operator getComplement() { + return complement; + } + } + + private Operator operator; + + public InfixExpression(Operator op) { + super(); + operator = op; + if (operator.getComplement() != null) type = org.apache.bcel.generic.Type.BOOLEAN; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the leftOperand. + */ + public Expression getLeftOperand() { + return (Expression) getChildAt(0); + } + + /** + * @param leftOperand The leftOperand to set. + */ + public void setOperands(Expression leftOperand, Expression rightOperand) { + widen(leftOperand); + widen(rightOperand); + removeChildren(); + appendChild(leftOperand); + appendChild(rightOperand); + } + + /** + * @return Returns the rightOperand. + */ + public Expression getRightOperand() { + return (Expression) getChildAt(1); + } + + /** + * @return Returns the operator. + */ + public Operator getOperator() { + return operator; + } + + /** + * @param theOperator The operator to set. + */ + public void setOperator(Operator theOperator) { + operator = theOperator; + } +} diff --git a/src/main/java/com/j2js/dom/InstanceofExpression.java b/src/main/java/com/j2js/dom/InstanceofExpression.java new file mode 100644 index 0000000..777ce1e --- /dev/null +++ b/src/main/java/com/j2js/dom/InstanceofExpression.java @@ -0,0 +1,31 @@ +package com.j2js.dom; + +import org.apache.bcel.generic.Type; + +import com.j2js.visitors.AbstractVisitor; + +/** + * Copyright by Wolfgang Kuehn 2005 + * Created on Feb 27, 2005 + */ +public class InstanceofExpression extends Expression { + private Expression leftOperand; + private Type rightOperand; + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public Expression getLeftOperand() { + return leftOperand; + } + public void setLeftOperand(Expression theLeftOperand) { + leftOperand = theLeftOperand; + } + public Type getRightOperand() { + return rightOperand; + } + public void setRightOperand(Type theRightOperand) { + rightOperand = theRightOperand; + } +} diff --git a/src/main/java/com/j2js/dom/Jump.java b/src/main/java/com/j2js/dom/Jump.java new file mode 100644 index 0000000..35cbaf0 --- /dev/null +++ b/src/main/java/com/j2js/dom/Jump.java @@ -0,0 +1,20 @@ +package com.j2js.dom; + +/** + * @author wolfgang + */ +public class Jump extends Branch { + + public Jump() { + super(); + } + + public Jump(int targetIndex) { + super(targetIndex); + } + +// public Jump(int beginIndex, int endIndex, int targetIndex) { +// this(targetIndex); +// setRange(beginIndex, endIndex); +// } +} diff --git a/src/main/java/com/j2js/dom/JumpSubRoutine.java b/src/main/java/com/j2js/dom/JumpSubRoutine.java new file mode 100644 index 0000000..25c9102 --- /dev/null +++ b/src/main/java/com/j2js/dom/JumpSubRoutine.java @@ -0,0 +1,12 @@ +package com.j2js.dom; + +/** + * @author wolfgang + */ +public class JumpSubRoutine extends Branch { + + public JumpSubRoutine(int targetIndex) { + super(targetIndex); + } + +} diff --git a/src/main/java/com/j2js/dom/LabeledJump.java b/src/main/java/com/j2js/dom/LabeledJump.java new file mode 100644 index 0000000..cb89347 --- /dev/null +++ b/src/main/java/com/j2js/dom/LabeledJump.java @@ -0,0 +1,20 @@ +package com.j2js.dom; + +abstract public class LabeledJump extends Jump { + + String label; + + public LabeledJump(String newLabel) { + super(); + label = newLabel; + } + + public LabeledJump(Block block) { + super(); + label = block.setLabeled(); + } + + public String getLabel() { + return label; + } +} diff --git a/src/main/java/com/j2js/dom/LoopStatement.java b/src/main/java/com/j2js/dom/LoopStatement.java new file mode 100644 index 0000000..548d0be --- /dev/null +++ b/src/main/java/com/j2js/dom/LoopStatement.java @@ -0,0 +1,44 @@ +package com.j2js.dom; + +/* + * LoopStatement.java + * + * Created on 21. Mai 2004, 16:51 + */ + +/** + * + * @author kuehn + */ +public class LoopStatement extends Block { + + public LoopStatement() { + super(); + } + + public LoopStatement(int theBeginIndex) { + super(theBeginIndex); + } + + public LoopStatement(int theBeginIndex, int theEndIndex) { + super(theBeginIndex, theEndIndex); + } + + public Expression getExpression() { + return (Expression) getChildAt(1); + } + + public void setExpression(Expression expression) { + widen(expression); + setChildAt(1, expression); + } + + public Block getBlock() { + return (Block) getChildAt(0); + } + + public void setBlock(Block block) { + widen(block); + setChildAt(0, block); + } +} diff --git a/src/main/java/com/j2js/dom/MethodBinding.java b/src/main/java/com/j2js/dom/MethodBinding.java new file mode 100644 index 0000000..d074c0e --- /dev/null +++ b/src/main/java/com/j2js/dom/MethodBinding.java @@ -0,0 +1,120 @@ +/* + * Created on 29.01.2006 + * Copyright Wolfgang Kuehn 2005 + */ +package com.j2js.dom; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.bcel.Constants; +import org.apache.bcel.classfile.ConstantCP; +import org.apache.bcel.classfile.ConstantNameAndType; +import org.apache.bcel.classfile.ConstantPool; +import org.apache.bcel.generic.ObjectType; +import org.apache.bcel.generic.Type; + +import com.j2js.Utils; + +/** + * @author kuehn + */ +public class MethodBinding { + + private static Map methodBindingsByKey = new HashMap(); + + public static MethodBinding lookup(int index, ConstantPool constantPool) { + ConstantCP methodRef = (ConstantCP) constantPool.getConstant(index); + ConstantNameAndType nameAndType = (ConstantNameAndType) + constantPool.getConstant(methodRef.getNameAndTypeIndex(), Constants.CONSTANT_NameAndType); + + String name = nameAndType.getName(constantPool); + String signature = nameAndType.getSignature(constantPool); + + return lookup(methodRef.getClass(constantPool), name, signature); + } + + public static MethodBinding lookup(String className, String name, String signature) { + String key = className + "#" + name + signature; + + MethodBinding binding = methodBindingsByKey.get(key); + if (binding != null) return binding; + + binding = new MethodBinding(); + binding.declaringClass = new ObjectType(className); + binding.name = name; + binding.parameterTypes = Type.getArgumentTypes(signature); + binding.returnType = Type.getReturnType(signature); + binding.signature = signature; + + methodBindingsByKey.put(key, binding); + + return binding; + } + + private ObjectType declaringClass; + private String name; + private Type[] parameterTypes; + private Type returnType; + private String signature; + + private MethodBinding() { + } + + /** + * Returns the type binding representing the class or interface that declares this method or constructor. + */ + public ObjectType getDeclaringClass() { + return declaringClass; + } + + /** + * Returns the name of the method declared in this binding. + */ + public String getName() { + return name; + } + + /** + * Returns a list of type bindings representing the formal parameter types, in declaration order, of this method or constructor. + */ + public Type[] getParameterTypes() { + return parameterTypes; + } + + /** + * Returns the binding for the return type of this method. + */ + public Type getReturnType() { + return returnType; + } + + /** + * Returns whether this binding is for a constructor or a method. + */ + public boolean isConstructor() { + return "".equals(name); + } + + public String getSignature() { + return signature; + } + + public String toString() { + return getDeclaringClass().getClassName() + "#" + getRelativeSignature(); + } + + public String getRelativeSignature() { + String signature = getName() + "("; + String sep = ""; + for (int i = 0; i < getParameterTypes().length; i++) { + Type type = getParameterTypes()[i]; + signature += sep + Utils.getSignature(type); + sep = ","; + } + signature += ")"; + signature += Utils.getSignature(returnType); + return signature; + } + +} diff --git a/src/main/java/com/j2js/dom/MethodDeclaration.java b/src/main/java/com/j2js/dom/MethodDeclaration.java new file mode 100644 index 0000000..b79efc3 --- /dev/null +++ b/src/main/java/com/j2js/dom/MethodDeclaration.java @@ -0,0 +1,134 @@ +package com.j2js.dom; + +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map; + +import org.apache.bcel.classfile.Code; +import org.apache.bcel.generic.Type; + +import com.j2js.LineNumberCursor; +import com.j2js.assembly.Project; +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class MethodDeclaration extends ASTNode { + + private String tempPrefix = "_"; + private Block block; + private Map parameters = new LinkedHashMap(); + private Map localVariables = new HashMap(); + private int accessFlags; + private Code code; + private MethodBinding methodBinding; + private LineNumberCursor lineNumberCursor; + + public MethodDeclaration(MethodBinding theMethodBinding, int theAccessFlags, Code theCode) { + methodBinding = theMethodBinding; + accessFlags = theAccessFlags; + code = theCode; + lineNumberCursor = new LineNumberCursor(code); + Project.getSingleton().getOrCreateProcedureUnit(methodBinding); + } + + public int getAccess() { + return accessFlags; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public boolean isInstanceConstructor() { + return methodBinding.getName().equals(""); + } + + /** + * @return Returns the block. + */ + public Block getBody() { + return block; + } + + /** + * @param theBlock The block to set. + */ + public void setBody(Block theBlock) { + block = theBlock; + theBlock.setParentNode(this); + } + + public VariableBinding createVariableBinding(String name, Type type, boolean isWrite) { + if (type == null) throw new NullPointerException(); + + VariableDeclaration decl = getParameter(name); + if (decl == null) { + decl = getLocalVariable(name); + } + if (decl == null) { + decl = new VariableDeclaration(!isWrite); + decl.setName(name); + decl.setType(type); + addLocalVariable(decl); + } + + VariableBinding binding = new VariableBinding(decl); + + return binding; + } + + private int vbCount = 0; + public VariableBinding createAnonymousVariableBinding(Type type, boolean isWrite) { + String name = tempPrefix + (vbCount++); + VariableBinding vb = createVariableBinding(name, type, isWrite); + vb.setTemporary(true); + return vb; + } + + public void addParameter(VariableDeclaration variableDecl) { + parameters.put(variableDecl.getName(), variableDecl); + } + + public Collection getParameters() { + return parameters.values(); + } + + public VariableDeclaration getParameter(String name) { + return parameters.get(name); + } + + public void addLocalVariable(VariableDeclaration variableDecl) { + localVariables.put(variableDecl.getName(), variableDecl); + } + + public void removeLocalVariable(String name) { + localVariables.remove(name); + } + + public Collection getLocalVariables() { + return localVariables.values(); + } + + public VariableDeclaration getLocalVariable(String name) { + return localVariables.get(name); + } + + public MethodBinding getMethodBinding() { + return methodBinding; + } + + public String toString() { + return methodBinding.toString(); + } + + public Code getCode() { + return code; + } + + public LineNumberCursor getLineNumberCursor() { + return lineNumberCursor; + } +} diff --git a/src/main/java/com/j2js/dom/MethodInvocation.java b/src/main/java/com/j2js/dom/MethodInvocation.java new file mode 100644 index 0000000..d3e8e2e --- /dev/null +++ b/src/main/java/com/j2js/dom/MethodInvocation.java @@ -0,0 +1,118 @@ +package com.j2js.dom; + +import java.util.List; + +import org.apache.bcel.generic.Type; + +import com.j2js.ASTNodeStack; +import com.j2js.assembly.Project; +import com.j2js.visitors.AbstractVisitor; + +/** + * @author kuehn + */ +public class MethodInvocation extends Expression { + + private Expression expression; + private MethodDeclaration methodDecl; + + /** + * Special handling for superclass, private, and instance initialization method invocations. + */ + public boolean isSpecial = false; + private MethodBinding methodBinding; + + public MethodInvocation() { + } + + public MethodInvocation(MethodDeclaration theMethodDecl) { + methodDecl = theMethodDecl; + } + + public MethodInvocation(MethodDeclaration theMethodDecl, MethodBinding theMethodBinding) { + methodDecl = theMethodDecl; + setMethodBinding(theMethodBinding); + } + + public Type getTypeBinding() { + if (methodBinding == null) return super.getTypeBinding(); + return methodBinding.getReturnType(); + } + + /** + * Returns true if this method invocation applies to a super class of the specified class. + */ + public boolean isSuper(String currentClassName) { + if (!isSpecial) return false; + // Use resolved class unless + // 1) the resolved method is not an instance initialization method, + if (methodBinding.isConstructor()) return false; + // 2) and the class of the resolved method is a superclass of the current class and + String name = methodBinding.getDeclaringClass().getClassName(); + if (currentClassName.equals(name)) return false; + + // TODO: The resolved class is different from the current class, but this does not imply that + // the resolved class is a superclass! Problem: How do we get this information without loading + // the class hierarchy? + return true; + } + + /** + * @return Returns the arguments. + */ + public List getArguments() { + ASTNodeStack stack = new ASTNodeStack(); + ASTNode node = getFirstChild(); + if (expression != null) { + node = node.getNextSibling(); + } + + while (node != null) { + stack.add(node); + node = node.getNextSibling(); + } + + return stack; + + } + + /** + * @param arguments The arguments to set. + */ + public void addArgument(Expression argument) { + widen(argument); + appendChild(argument); + } + + /** + * @return Returns the expression. + */ + public Expression getExpression() { + return expression; + } + + /** + * @param expression The expression to set. + */ + public void setExpression(Expression targetExpression) { + if (expression != null) { + throw new RuntimeException("Expression is already set"); + } + expression = targetExpression; + widen(expression); + insertBefore(expression, getFirstChild()); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public MethodBinding getMethodBinding() { + return methodBinding; + } + + public void setMethodBinding(MethodBinding theMethodBinding) { + methodBinding = theMethodBinding; + Project.getSingleton().addReference(methodDecl, this); + } +} diff --git a/src/main/java/com/j2js/dom/Name.java b/src/main/java/com/j2js/dom/Name.java new file mode 100644 index 0000000..87d5911 --- /dev/null +++ b/src/main/java/com/j2js/dom/Name.java @@ -0,0 +1,39 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * Copyright by Wolfgang Kuehn 2005 + * Created on Feb 20, 2005 + */ +public class Name extends Expression { + + private String identifier; + + public Name(String newIdentifier) { + //super(); + identifier = newIdentifier; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public boolean equals(Object obj) { + if (!(obj instanceof Name)) return false; + return identifier.equals(((Name) obj).identifier); + } + + /** + * @return Returns the identifier. + */ + public String getIdentifier() { + return identifier; + } + /** + * @param theIdentifier The identifier to set. + */ + public void setIdentifier(String theIdentifier) { + identifier = theIdentifier; + } +} diff --git a/src/main/java/com/j2js/dom/NoOperation.java b/src/main/java/com/j2js/dom/NoOperation.java new file mode 100644 index 0000000..02a9700 --- /dev/null +++ b/src/main/java/com/j2js/dom/NoOperation.java @@ -0,0 +1,11 @@ +/* + * Created on Oct 31, 2004 + */ +package com.j2js.dom; + +/** + * @author wolfgang + */ +public class NoOperation extends ASTNode { + // Tagging class. +} diff --git a/src/main/java/com/j2js/dom/NullLiteral.java b/src/main/java/com/j2js/dom/NullLiteral.java new file mode 100644 index 0000000..bb27e0d --- /dev/null +++ b/src/main/java/com/j2js/dom/NullLiteral.java @@ -0,0 +1,13 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class NullLiteral extends Expression { + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } +} diff --git a/src/main/java/com/j2js/dom/NumberLiteral.java b/src/main/java/com/j2js/dom/NumberLiteral.java new file mode 100644 index 0000000..8667c80 --- /dev/null +++ b/src/main/java/com/j2js/dom/NumberLiteral.java @@ -0,0 +1,91 @@ +package com.j2js.dom; + +import org.apache.bcel.generic.Type; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class NumberLiteral extends Expression { + + public static Number ZERO = new Integer(0); + public static Number ONE = new Integer(1); + public static Number MINUS_ONE = new Integer(-1); + + private Number value; + + public static boolean isZero(Expression expr) { + if (expr == null || !(expr instanceof NumberLiteral)) return false; + return ((NumberLiteral) expr).getValue().equals(ZERO); + } + + public static boolean isOne(Expression expr) { + if (expr == null || !(expr instanceof NumberLiteral)) return false; + return ((NumberLiteral) expr).getValue().equals(ONE); + } + + public static boolean isMinusOne(Expression expr) { + if (expr == null || !(expr instanceof NumberLiteral)) return false; + return ((NumberLiteral) expr).getValue().equals(MINUS_ONE); + } + + private NumberLiteral(Number theValue) { + value = theValue; + if (theValue instanceof Integer) { + type = Type.INT; + } else if (theValue instanceof Byte) { + type = Type.BYTE; + } else if (theValue instanceof Float) { + type = Type.FLOAT; + } else if (theValue instanceof Double) { + type = Type.DOUBLE; + } else if (theValue instanceof Long) { + type = Type.LONG; + } else if (theValue instanceof Short) { + type = Type.SHORT; + } else + // TODO: Other types + throw new RuntimeException("Type not supported: " + theValue.getClass()); + } + + public static NumberLiteral create(int i) { + Number value; + if (i == 0) value = ZERO; + else if (i == 1) value = ONE; + else value = new Integer(i); + return new NumberLiteral(value); + } + + public static NumberLiteral create(Number value) { + if (value instanceof Integer) { + Integer i = (Integer) value; + if (i.intValue()==0) value = ZERO; + else if (i.intValue()==1) value = ONE; + } + return new NumberLiteral(value); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the value. + */ + public Number getValue() { + return value; + } + + /** + * @param theValue The value to set. + */ + public void setValue(Number theValue) { + value = theValue; + } + + public String toString() { + return super.toString() + " value " + value; + } + +} diff --git a/src/main/java/com/j2js/dom/PStarExpression.java b/src/main/java/com/j2js/dom/PStarExpression.java new file mode 100644 index 0000000..a773e49 --- /dev/null +++ b/src/main/java/com/j2js/dom/PStarExpression.java @@ -0,0 +1,71 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * Class representing the union of pre- and post-fix expression. + * @author kuehn + */ +public class PStarExpression extends Expression { + + // Operators common to both pre- and post-fix expression. + static public Operator INCREMENT = new Operator("++"); + static public Operator DECREMENT = new Operator("--"); + + static public class Operator { + + private String token; + + Operator(String theToken) { + token = theToken; + } + + public String toString() { + return token; + } + + public Operator complement() { + if (this == PStarExpression.INCREMENT) return PStarExpression.DECREMENT; + else if (this == PStarExpression.DECREMENT) return PStarExpression.INCREMENT; + else throw new RuntimeException("Operation not supported for " + this); + } + + } + + private ASTNode operand; + private Operator operator; + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the operand. + */ + public ASTNode getOperand() { + return operand; + } + + /** + * @param leftOperand The leftOperand to set. + */ + public void setOperand(ASTNode theOperand) { + widen(theOperand); + operand = theOperand; + } + + /** + * @return Returns the operator. + */ + public Operator getOperator() { + return operator; + } + + /** + * @param theOperator The operator to set. + */ + public void setOperator(Operator theOperator) { + operator = theOperator; + } +} + diff --git a/src/main/java/com/j2js/dom/Pop.java b/src/main/java/com/j2js/dom/Pop.java new file mode 100644 index 0000000..fb26f17 --- /dev/null +++ b/src/main/java/com/j2js/dom/Pop.java @@ -0,0 +1,15 @@ +/* + * Copyright 2005 by Wolfgang Kuehn + * Created on 19.10.2005 + */ +package com.j2js.dom; + +/** + * @author wolfgang + */ +public class Pop extends Expression { + + public Pop(Expression e) { + //setRange(-1,-1); + } +} diff --git a/src/main/java/com/j2js/dom/PostfixExpression.java b/src/main/java/com/j2js/dom/PostfixExpression.java new file mode 100644 index 0000000..9a336c3 --- /dev/null +++ b/src/main/java/com/j2js/dom/PostfixExpression.java @@ -0,0 +1,18 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * Tagging class for a postfix expression. + * @author kuehn + */ +public class PostfixExpression extends PStarExpression { + + public PostfixExpression() { + super(); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } +} diff --git a/src/main/java/com/j2js/dom/PrefixExpression.java b/src/main/java/com/j2js/dom/PrefixExpression.java new file mode 100644 index 0000000..9f59b27 --- /dev/null +++ b/src/main/java/com/j2js/dom/PrefixExpression.java @@ -0,0 +1,25 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * Tagging class for a prefix expression. + * @author kuehn + */ +public class PrefixExpression extends PStarExpression { + + static public Operator NOT = new Operator("!"); +// static public Operator INCREMENT = new Operator("++"); +// static public Operator DECREMENT = new Operator("--"); + static public Operator MINUS = new Operator("-"); + static public Operator PLUS = new Operator("+"); + static public Operator COMPLEMENT = new Operator("~"); + + public PrefixExpression() { + super(); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } +} \ No newline at end of file diff --git a/src/main/java/com/j2js/dom/PrimitiveCast.java b/src/main/java/com/j2js/dom/PrimitiveCast.java new file mode 100644 index 0000000..f7bef0c --- /dev/null +++ b/src/main/java/com/j2js/dom/PrimitiveCast.java @@ -0,0 +1,25 @@ +package com.j2js.dom; + +import org.apache.bcel.generic.Type; + +import com.j2js.visitors.AbstractVisitor; + +public class PrimitiveCast extends Expression { + public int castType = 0; + public Expression expression; + + public PrimitiveCast(int theCastType, Expression expr, Type typeBinding) { + super(); + type = typeBinding; + castType = theCastType; + expression = expr; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public Expression getExpression() { + return expression; + } +} diff --git a/src/main/java/com/j2js/dom/Push.java b/src/main/java/com/j2js/dom/Push.java new file mode 100644 index 0000000..0abf448 --- /dev/null +++ b/src/main/java/com/j2js/dom/Push.java @@ -0,0 +1,16 @@ +/* + * Copyright 2005 by Wolfgang Kuehn + * Created on 19.10.2005 + */ +package com.j2js.dom; + +/** + * @author wolfgang + */ +public class Push extends Expression { + + public Push(Expression e) { + widen(e); + } + +} diff --git a/src/main/java/com/j2js/dom/ReturnStatement.java b/src/main/java/com/j2js/dom/ReturnStatement.java new file mode 100644 index 0000000..a4007af --- /dev/null +++ b/src/main/java/com/j2js/dom/ReturnStatement.java @@ -0,0 +1,44 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/* + * Created on Sep 12, 2004 + * + * To change the template for this generated file go to + * Window - Preferences - Java - Code Generation - Code and Comments + */ + +/** + * @author wolfgang + * + * To change the template for this generated type comment go to + * Window - Preferences - Java - Code Generation - Code and Comments + */ +public class ReturnStatement extends ASTNode { + + private Expression expression; + + public ReturnStatement(int theBeginIndex, int theEndIndex) { + setRange(theBeginIndex, theEndIndex); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @param theExpression The expression to set. + */ + public void setExpression(Expression theExpression) { + widen(theExpression); + expression = theExpression; + } + + /** + * @return Returns the expression. + */ + public Expression getExpression() { + return expression; + } +} diff --git a/src/main/java/com/j2js/dom/StringLiteral.java b/src/main/java/com/j2js/dom/StringLiteral.java new file mode 100644 index 0000000..ec41551 --- /dev/null +++ b/src/main/java/com/j2js/dom/StringLiteral.java @@ -0,0 +1,37 @@ +package com.j2js.dom; + +import org.apache.bcel.generic.Type; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class StringLiteral extends Expression { + + private String value; + + public StringLiteral(String theValue) { + value = theValue; + type = Type.STRING; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the value. + */ + public String getValue() { + return value; + } + + /** + * @param theValue The value to set. + */ + public void setValue(String theValue) { + value = theValue; + } + +} diff --git a/src/main/java/com/j2js/dom/SwitchCase.java b/src/main/java/com/j2js/dom/SwitchCase.java new file mode 100644 index 0000000..c0e0528 --- /dev/null +++ b/src/main/java/com/j2js/dom/SwitchCase.java @@ -0,0 +1,38 @@ +/* + * Created on Oct 24, 2004 + */ +package com.j2js.dom; + +import java.util.List; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class SwitchCase extends Block { + + private List expressions; + + public SwitchCase(int theBeginIndex) { + super(theBeginIndex); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the expression. + */ + public List getExpressions() { + return expressions; + } + /** + * @param expression The expression to set. + */ + public void setExpressions(List theExpressions) { + expressions = theExpressions; + } + +} diff --git a/src/main/java/com/j2js/dom/SwitchStatement.java b/src/main/java/com/j2js/dom/SwitchStatement.java new file mode 100644 index 0000000..e49334c --- /dev/null +++ b/src/main/java/com/j2js/dom/SwitchStatement.java @@ -0,0 +1,40 @@ +/* + * Created on Oct 24, 2004 + */ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class SwitchStatement extends Block { + + private Expression expression; + + public SwitchStatement() { + super(); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public SwitchCase getDefault() { + return (SwitchCase) getLastChild(); + } + + /** + * @return Returns the expression. + */ + public Expression getExpression() { + return expression; + } + /** + * @param theExpression The expression to set. + */ + public void setExpression(Expression theExpression) { + widen(theExpression); + expression = theExpression; + } +} diff --git a/src/main/java/com/j2js/dom/SynchronizedBlock.java b/src/main/java/com/j2js/dom/SynchronizedBlock.java new file mode 100644 index 0000000..aeba418 --- /dev/null +++ b/src/main/java/com/j2js/dom/SynchronizedBlock.java @@ -0,0 +1,18 @@ +/* + * Copyright 2005 by Wolfgang Kuehn + * Created on 18.10.2005 + */ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class SynchronizedBlock extends Block { + public Expression monitor; + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } +} diff --git a/src/main/java/com/j2js/dom/ThisExpression.java b/src/main/java/com/j2js/dom/ThisExpression.java new file mode 100644 index 0000000..05d3e82 --- /dev/null +++ b/src/main/java/com/j2js/dom/ThisExpression.java @@ -0,0 +1,27 @@ +package com.j2js.dom; + +import org.apache.bcel.generic.Type; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author kuehn + */ +public class ThisExpression extends VariableBinding { + + private static VariableDeclaration vd; + + static { + vd = new VariableDeclaration(VariableDeclaration.NON_LOCAL); + vd.setName("this"); + vd.setType(Type.OBJECT); + } + + public ThisExpression() { + super(vd); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } +} diff --git a/src/main/java/com/j2js/dom/ThrowStatement.java b/src/main/java/com/j2js/dom/ThrowStatement.java new file mode 100644 index 0000000..dc179cb --- /dev/null +++ b/src/main/java/com/j2js/dom/ThrowStatement.java @@ -0,0 +1,27 @@ +package com.j2js.dom; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class ThrowStatement extends Block { + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the expression. + */ + public Expression getExpression() { + return (Expression) getFirstChild(); + } + /** + * @param expression The expression to set. + */ + public void setExpression(Expression expression) { + widen(expression); + appendChild(expression); + } +} diff --git a/src/main/java/com/j2js/dom/TryStatement.java b/src/main/java/com/j2js/dom/TryStatement.java new file mode 100644 index 0000000..79b0c47 --- /dev/null +++ b/src/main/java/com/j2js/dom/TryStatement.java @@ -0,0 +1,68 @@ +package com.j2js.dom; + +import com.j2js.cfg.TryHeaderNode; +import com.j2js.visitors.AbstractVisitor; + +/** + * TryStatement.java + * + * Created on 21. Mai 2004, 17:33 + * @author kuehn + */ +public class TryStatement extends Block { + + public TryHeaderNode header; + + /** Creates a new instance of TryStatement */ + public TryStatement() { + super(); + } + + public void addCatchStatement(CatchClause catchStatement) { + if (getChildCount() < 2) throw new RuntimeException("Illegal DOM state"); + ((Block) getChildAt(1)).appendChild(catchStatement); + } + + public Block getCatchStatements() { + return (Block) getChildAt(1); + } + + /** Getter for property finallyBlock. + * @return Value of property finallyBlock. + */ + public Block getFinallyBlock() { + if (getChildCount() < 3) return null; + return (Block) getChildAt(2); + } + + /** Setter for property finallyBlock. + * @param finallyBlock New value of property finallyBlock. + */ + public void setFinallyBlock(Block finallyBlock) { + setChildAt(2, finallyBlock); + } + + /** + * @return Returns the tryBlock. + */ + public Block getTryBlock() { + return (Block) getChildAt(0); + } + + /** + * @param tryBlock The tryBlock to set. + */ + public void setTryBlock(Block tryBlock) { + setChildAt(0, tryBlock); + setChildAt(1, new Block()); + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public String toString() { + return super.toString(); + } + +} diff --git a/src/main/java/com/j2js/dom/TypeDeclaration.java b/src/main/java/com/j2js/dom/TypeDeclaration.java new file mode 100644 index 0000000..823d6f4 --- /dev/null +++ b/src/main/java/com/j2js/dom/TypeDeclaration.java @@ -0,0 +1,121 @@ +/* + * Created on 22.10.2004 + */ +package com.j2js.dom; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.bcel.generic.ObjectType; + +import com.j2js.assembly.Project; +import com.j2js.visitors.AbstractVisitor; + + +/** + * @author kuehn + */ +public class TypeDeclaration extends ASTNode { + + private ObjectType type; + private ObjectType superType; + + private ArrayList methods = new ArrayList(); + //private MethodDeclaration initializer; + private List fields = new ArrayList(); + private int accessFlags; + //private String superClassName; + + public TypeDeclaration(ObjectType theType, int theAccessFlags) { + type = theType; + accessFlags = theAccessFlags; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + /** + * @return Returns the methods. + */ + public MethodDeclaration[] getMethods() { + MethodDeclaration[] a = new MethodDeclaration[methods.size()]; + return methods.toArray(a); + } + + public int getAccess() { + return accessFlags; + } + + /** + * @param methods The methods to set. + */ + public void addMethod(MethodDeclaration method) { + method.setParentNode(this); + methods.add(method); + } + + /** + * @return Returns the name. + */ + public ObjectType getType() { + return type; + } + + /** + * @return Returns the package portion of this types name. + */ + public String getPackageName() { + String name = type.getClassName(); + int index = name.lastIndexOf('.'); + if (index != -1) + return name.substring(0, index); + else + return name; + } + + public String getClassName() { + return type.getClassName(); + } + + public String getUnQualifiedName() { + String name = type.getClassName(); + int index = name.lastIndexOf('.'); + if (index != -1) + return name.substring(index+1); + else + return name; + } + + /** + * @return Returns the fields. + */ + public List getFields() { + return fields; + } + /** + * @param fields The fields to set. + */ + public void addField(VariableDeclaration field) { + fields.add(field); + Project.getSingleton().getOrCreateFieldUnit(type, field.getName()); + } + /** + * @return Returns the superClassName. + */ + public ObjectType getSuperType() { + return superType; + } + + /** + * Sets the super type. + */ + public void setSuperType(ObjectType newSuperType) { + superType = newSuperType; + } + + public String toString() { + return type.getClassName(); + } + +} diff --git a/src/main/java/com/j2js/dom/VariableBinding.java b/src/main/java/com/j2js/dom/VariableBinding.java new file mode 100644 index 0000000..c8ef7d3 --- /dev/null +++ b/src/main/java/com/j2js/dom/VariableBinding.java @@ -0,0 +1,83 @@ +package com.j2js.dom; + +import org.apache.bcel.generic.Type; + +import com.j2js.visitors.AbstractVisitor; + +/** + * @author wolfgang + */ +public class VariableBinding extends Expression implements Assignable { + private boolean field; + private VariableDeclaration decl; + private boolean isTemporary = false; + + public static boolean isBoolean(Expression expr) { + if (expr == null || !(expr instanceof VariableBinding)) return false; + if (((VariableBinding) expr).getVariableDeclaration().getType() != Type.BOOLEAN) return false; + return true; + } + + public VariableBinding(VariableDeclaration theDecl) { + super(); + decl = theDecl; + decl.vbs.add(this); + setTypeBinding(theDecl.getType()); + } + + public Object clone() { + // TODO: Make cloning explicit. + VariableBinding other = (VariableBinding) super.clone(); + decl.vbs.add(other); + return other; + } + + public void visit(AbstractVisitor visitor) { + visitor.visit(this); + } + + public boolean isSame(Object other) { + if (other == null || !(other instanceof VariableBinding)) return false; + return decl == ((VariableBinding) other).decl; + } + + /** + * @return Returns the name. + */ + public String getName() { + return decl.getName(); + } + + /** + * @return Returns the field. + */ + public boolean isField() { + return field; + } + + /** + * @param theField The field to set. + */ + public void setField(boolean theField) { + field = theField; + } + + /** + * @return Returns the decl. + */ + public VariableDeclaration getVariableDeclaration() { + return decl; + } + + public String toString() { + return super.toString() + ' ' + decl.getName(); + } + + public boolean isTemporary() { + return isTemporary; + } + + public void setTemporary(boolean isTemporary) { + this.isTemporary = isTemporary; + } +} diff --git a/src/main/java/com/j2js/dom/VariableDeclaration.java b/src/main/java/com/j2js/dom/VariableDeclaration.java new file mode 100644 index 0000000..20cddb9 --- /dev/null +++ b/src/main/java/com/j2js/dom/VariableDeclaration.java @@ -0,0 +1,111 @@ +package com.j2js.dom; + +import com.j2js.J2JSCompiler; + +import java.util.List; +import java.util.ArrayList; + +import com.j2js.visitors.AbstractVisitor; + +import org.apache.bcel.classfile.LocalVariable; +import org.apache.bcel.classfile.Method; +import org.apache.bcel.generic.Type; + +/** + * @author wolfgang + */ +public class VariableDeclaration extends ASTNode { + public static int LOCAL = 0; + public static int NON_LOCAL = 1; + public static int LOCAL_PARAMETER = 2; + + private String name; + private Type type; + private int modifiers; + private int location; + private boolean isInitialized; + public List vbs = new ArrayList(); + + public static String getLocalVariableName(Method method, int slot, int pc) { + if (false && method.getLocalVariableTable() != null) { + // TODO: Use source variable name as comment only. + LocalVariable[] table = method.getLocalVariableTable().getLocalVariableTable(); + LocalVariable lvar = null; + for (int i=0; i + + + J2JS Package Documentation + + + + + + + + + +

+ +

+        aload         // Load object reference.
+        dup           // Duplicate object reference.
+        getfield      // Fetch field oldValue.
+        delta         // Can be any value, could even be an expression.
+        add/sub       // Increment/decrement value.
+                      // Stack: ref newValue
+        dup_x1        // Duplicate top and put it on third position.
+                      // Stack: newValue ref newValue.
+        putfield      // Store field value.
+                      // Stack: newValue

+ + Reduction: + ++field, --field, or (field = field + delta), if delta not equal to constant +/-1. +

+ +

+        aload         // Load object reference.
+        dup           // Duplicate object reference.
+        getfield      // Fetch field value.
+                      // Stack: ref oldValue
+        dup_x1        // Duplicate top and put it on third position.
+                      // Stack: oldValue ref oldValue
+        const         // Must be constant +/-1.
+        add/sub       // Increment/decrement value.
+                      // Stack: oldValue ref newValue
+        putfield      // Store field value.
+                      // Stack: oldValue.

+ + Reduction: + field++ or field--. +

+ +

+        iinc(delta)   // Increment variable.
+        load          // Load variable.
+                      // Stack: newValue

+ +

+        load          // Load variable. 
+        delta         // Any expression.
+        add           // Increment.
+        dup           // Stack: newValue newValue
+        store         // Store to variable.
+                      // Stack: newValue

+ +

+	 load          // Load variable.
+	 iinc(delta)   // Increment variable.
+	 // Stack: oldValue

+ +

+ Note that we could match the pattern [load, iinc, load] + with either (E) [i++, i] or (C) [i, ++i]. + Of these obviously equivalent alternatives we choose (E). +

+ +

+ In Java, a try statement has the following structure: +

+               try Block Catch* (Catch | Finally)
+

+ +

+ + A try block with finally clause has the following structure: + +

+    TryCatchFinally:
+        tryBlock 
+        Handler  // 0..n times
+        DefaultHandler
+        B Finally 
+        A jsr(B) 
+

+ + Each time the control flow exits the try block or one of the non-default handlers, + a jsr(B) is prepended. If the try block or one of the non-default + handlers are exited by default (fall-through), then a goto(A) is appended at the end of the block. + +

+ There must be at least one handler. All handlers are non-default. Typically, goreth is a goto(A), + but this must not be the case. +

+    TryCatchFinally:
+        tryBlock goreth  
+        Handler goreth  // 0..n
+        Handler
+        A
+

+ +

+    DefaultHandler: (Any Exception)
+        astore_exception jsr(B) aload_exception athrow
+

+ +

+    Handler:
+        astore_exception catchBlock
+

+ +

+    Finally:
+        astore_address finallyBlock ret
+

+ +

+ The store operations in the handlers save the exception to a local variable, whereas the store + operation at the beginning of the subroutine saves the return address to local variable. +

+ For each catch block, a codeException(BeginPC, EndPC, HandlerPC) is recorded, + where HandlerPC = begin(Default?Handler) and +

BeginPC = begin(tryBlock), EndPC = begin(first Handler)-1, i.e. including the goto(A) + for each non-default handler, or both +
+ BeginPC = begin(tryBlock), EndPC = end(last Handler) and +
+ BeginPC = A = begin(Tail), EndPC = end(Tail) for the default handler. +

+ +

+ Note that from the byte code we cannot deduce the end of the last catch clause in the + absense of a finally clause. This is also manifested by the equivalence of the following + two Java code fracments: +

+    foo: {
+        try {
+           A;
+           break foo;
+        } catch(e) {
+           B;
+        }
+        C;
+    }
+    
+    foo: {
+        try {
+           A;
+           break foo;
+        } catch(e) {
+           B;
+           C;
+        }
+    }
+

Document Object Model

Example

Supported Primitive Types

Furthermore the following datatypes are supported

Advanced Usage

Tips and Tricks

Generic J2JS Automation Client

Not Found