---

CompilationManager.java

package edu.ksu.cis.bandera.jjjc;

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Bandera, a Java(TM) analysis and transformation toolkit           *
 * Copyright (C) 1999, 2000   Robby (robby@cis.ksu.edu)              *
 * All rights reserved.                                              *
 *                                                                   *
 * This work was done as a project in the SAnToS Laboratory,         *
 * Department of Computing and Information Sciences, Kansas State    *
 * University, USA (http://www.cis.ksu.edu/santos).                  *
 * It is understood that any modification not identified as such is  *
 * not covered by the preceding statement.                           *
 *                                                                   *
 * This work is free software; you can redistribute it and/or        *
 * modify it under the terms of the GNU Library General Public       *
 * License as published by the Free Software Foundation; either      *
 * version 2 of the License, or (at your option) any later version.  *
 *                                                                   *
 * This work is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *
 * Library General Public License for more details.                  *
 *                                                                   *
 * You should have received a copy of the GNU Library General Public *
 * License along with this toolkit; if not, write to the             *
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,      *
 * Boston, MA  02111-1307, USA.                                      *
 *                                                                   *
 * Java is a trademark of Sun Microsystems, Inc.                     *
 *                                                                   *
 * To submit a bug report, send a comment, or get the latest news on *
 * this project and other SAnToS projects, please visit the web-site *
 *                http://www.cis.ksu.edu/santos                      *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
import java.io.*;
import java.util.*;
import ca.mcgill.sable.soot.*;
import ca.mcgill.sable.soot.jimple.*;
import edu.ksu.cis.bandera.specification.assertion.*;
import edu.ksu.cis.bandera.specification.predicate.*;
import edu.ksu.cis.bandera.specification.datastructure.*;
import edu.ksu.cis.bandera.jjjc.node.*;
import edu.ksu.cis.bandera.annotation.*;
import edu.ksu.cis.bandera.jjjc.lexer.*;
import edu.ksu.cis.bandera.jjjc.parser.*;
import edu.ksu.cis.bandera.jjjc.doc.*;
import ca.mcgill.sable.laleh.java.astfix.*;
import edu.ksu.cis.bandera.jjjc.exception.*;
import edu.ksu.cis.bandera.jjjc.symboltable.*;
import edu.ksu.cis.bandera.jjjc.codegenerator.*;
import edu.ksu.cis.bandera.jjjc.symboltable.Package;
import edu.ksu.cis.bandera.specification.predicate.datastructure.*;
import edu.ksu.cis.bandera.jjjc.analysis.*;
import edu.ksu.cis.bandera.jjjc.unicodepreprocessor.*;
import edu.ksu.cis.bandera.specification.assertion.datastructure.*;
import edu.ksu.cis.bandera.specification.predicate.datastructure.*;
import edu.ksu.cis.bandera.bofa.*;

public class CompilationManager {
    private static Hashtable fileTable;
    private static Hashtable symTable;
    private static Hashtable compiledClasses = new Hashtable();
    private static Hashtable exceptions = new Hashtable();
    private static Hashtable compiledFiles;
    private static AnnotationManager am;
    private static SootClassManager scm;
    private static boolean isRecompile;
    private static String[] includedPackagesOrTypes;
    private static String classpath;
    private static String filename;
    private static String[] lastIncluded;
    private static String lastClasspath;
    private static String lastFilename;
    private static Hashtable modifiedMethodTable = new Hashtable();
    private static Vector quantifiers = new Vector();
    private static Hashtable quantifierTable = new Hashtable();
    private static Vector syncTransformed = new Vector();
    private static Hashtable docComments;
    private static String mainClassQualifiedName;
    private static java.lang.String mainClassSimpleName;
    private static java.util.Hashtable fieldForQuantifiers;
    private static Vector docTriples;
    private static boolean doBSL = true;
/**
 * 
 */
private CompilationManager() {
    compiledFiles = new Hashtable();
}
/**
 * 
 * @param dt edu.ksu.cis.bandera.jjjc.javadoc.DocTriple
 */
public static void addDocTriple(DocTriple dt) {
    docTriples.add(dt);
}
/**
 * 
 * @param sf ca.mcgill.sable.soot.SootField
 */
public static void addFieldForQuantifier(SootField sf) {
    fieldForQuantifiers.put(sf.getName(), sf);
}
/**
 * 
 * @return edu.ksu.cis.bandera.jjjc.symboltable.SymbolTable
 * @param className edu.ksu.cis.bandera.jjjc.symboltable.Name
 */
public static SymbolTable buildSymbolTable(Name className) throws CompilerException {
    ClassOrInterfaceType classOrInterfaceType = Package.getClassOrInterfaceType(className);

    if (!classOrInterfaceType.isLoaded()) {
        if (classOrInterfaceType.getPath() == null) {
            return new SymbolTable(className);
        } else
            return buildSymbolTable(classOrInterfaceType.getPath());
    }
    return classOrInterfaceType.getSymbolTable();
}
/**
 * 
 * @return edu.ksu.cis.bandera.jjjc.symboltable.SymbolTable
 * @param filename java.lang.String
 */
public static SymbolTable buildSymbolTable(String filename) throws CompilerException {
    try {
        filename = new File(filename).getCanonicalPath();
    } catch (Exception e) {
    }
    if (getSymbolTable(filename) != null) {
        return getSymbolTable(filename);
    }
    SymbolTable symbolTable = new SymbolTable(filename);
    symTable.put(filename, symbolTable);
    return symbolTable;
}
/**
 * 
 */
public static void compile() throws CompilerException
{
    if (filename == null)
    {
        throw new CompilerException("Filename must be set first");
    } else
        if (classpath == null)
        {
            throw new CompilerException("Classpath must be set first");
        } else
            if (includedPackagesOrTypes == null)
            {
                throw new CompilerException("Included packages or types must be set first");
            }
    System.setProperty("user.dir", edu.ksu.cis.bandera.bui.BUI.originalUserDir);
    mainClassQualifiedName = null;
    mainClassSimpleName = new File(filename).getName();
    mainClassSimpleName = mainClassSimpleName.substring(0, mainClassSimpleName.indexOf("."));
    fieldForQuantifiers = new Hashtable();
    isRecompile = false;
    if (("" + lastFilename).equals("" + filename) && ("" + lastClasspath).equals("" + classpath))
    {
        if (lastIncluded != null)
        {
            if (lastIncluded.length == includedPackagesOrTypes.length)
            {
                boolean f = true;
                for (int i = 0; i < includedPackagesOrTypes.length; i++)
                {
                    if (!(lastIncluded[i]).equals(includedPackagesOrTypes[i]))
                    {
                        f = false;
                        break;
                    }
                }
                if (f)
                    isRecompile = true;
            }
        }
    }
    if (isRecompile)
    {
        if (compiledFiles.size() == 0)
            isRecompile = false;
        for (Enumeration e = compiledFiles.keys(); e.hasMoreElements();)
        {
            String filename = (String) e.nextElement();
            long lastModified = ((Long) compiledFiles.get(filename)).longValue();
            long currentLastModified = new File(filename).lastModified();
            if (lastModified != currentLastModified)
            {
                isRecompile = false;
            }
        }
    }
    am = new AnnotationManager();
    scm = new SootClassManager();
    exceptions = new Hashtable();
    compiledClasses = new Hashtable();
    symTable = new Hashtable();
    compiledFiles = new Hashtable();
    docTriples = new Vector();
    if (!isRecompile)
    {
        fileTable = new Hashtable();
        lastFilename = filename;
        lastClasspath = classpath;
        lastIncluded = includedPackagesOrTypes;
        syncTransformed = new Vector();
        docComments = new Hashtable();
    }
    JIJCCodeGenerator codeGenerator = null;
    try
    {
        Package.setClassPath(classpath);
        codeGenerator = compile(filename);
        int numClasses = 1;
        Object[] temp = scm.getClasses().toArray();
        while (numClasses != temp.length)
        {
            for (int i = 0; i < temp.length; i++)
            {
                SootClass sc = (SootClass) temp[i];
                String className = sc.getName().trim();
                Name qName = new Name(className);
                if (isCompile(includedPackagesOrTypes, qName) && (compiledClasses.get(className) == null))
                {
                    String filename = null;
                    ClassOrInterfaceType type = Package.getClassOrInterfaceType(qName);
                    if (type.getPath() == null)
                        continue;
                    for (Enumeration e = type.getContainingPackage().getPaths(); e.hasMoreElements();)
                    {
                        try
                        {
                            String packagePath = (String) e.nextElement();
                            if (packagePath.equals(""))
                            {
                                filename = qName.getLastIdentifier().toString().trim() + ".java";
                            } else
                            {
                                filename = packagePath + File.separator + qName.getLastIdentifier().toString().trim() + ".java";
                            }
                        } catch (Exception ex)
                        {
                        }
                    }
                    if ((filename != null) && (compiledClasses.get(filename) == null))
                    {
                        codeGenerator = compile(filename);
                    }
                }
            }
            numClasses = temp.length;
            temp = scm.getClasses().toArray();
        }

        if (mainClassQualifiedName == null) {
            throw new CompilerException("Cannot find the main class '" + mainClassSimpleName + "'");
        }

        // print all the classes
        System.out.println("");
        System.out.println("");
        System.out.println("Compiled Classes:");
        System.out.println("=================");
        for (Enumeration e = compiledClasses.elements(); e.hasMoreElements();)
        {
            SootClass sc = (SootClass) e.nextElement();
            System.out.println(sc.getName());
        }

        // invoke bsl
        if (doBSL) {
            AssertionSet.reset();
            PredicateSet.reset();
            for (Iterator i = docTriples.iterator(); i.hasNext();) {
                DocTriple dt = (DocTriple) i.next();
                AssertionExtractor.extract(dt.sc, dt.sm, dt.tags);
                PredicateExtractor.extract(dt.sc, dt.sm, dt.tags);
            }   
        }

        // invoke BOFA patch (robbyjo)
        //if (isRecompile) (robby)
        {
            try { BOFA.reset(); } catch (Exception e)
            { System.out.println("BOFA is already reset."); }
            try { BOFA.analyze(); } catch (Exception e)
            {
                System.out.println("BOFA Failed! "+e.getMessage());
            }

        }
    } catch (CompilerException e)
    {
        Vector exceptions = (codeGenerator != null) ? codeGenerator.getExceptions() : new Vector();
        exceptions.addElement(e);
        CompilationManager.exceptions.put(filename, exceptions);
    }
}
/**
* @return edu.ksu.cis.bandera.jjjc.JIJCCodeGenerator
* @param filename java.lang.String
*/
private static JIJCCodeGenerator compile(String filename) throws CompilerException {
    File file = new File(filename);
    filename = file.getAbsolutePath();
    
    System.out.println("Compiling: " + filename);

    System.out.println("Parsing...");
    Start ast = null;
    try {
        ast = parseFile(filename);
        compiledFiles.put(filename, new Long(file.lastModified()));
    } catch (Exception e) {
        throw new AnalysisException(e.toString());
    }

    System.out.println("Building symbol table...");
    SymbolTable symbolTable = buildSymbolTable(filename);
    
    if (mainClassQualifiedName == null) {
        String dotSimpleName = "." + mainClassSimpleName;
        for (Enumeration e = symbolTable.getDeclaredTypes(); e.hasMoreElements();) {
            ClassOrInterfaceType type = (ClassOrInterfaceType) e.nextElement();
            String typeName = type.getFullyQualifiedName();
            if (typeName.endsWith(dotSimpleName) || typeName.equals(mainClassSimpleName)) {
                mainClassQualifiedName = typeName;
                if (!type.getMethods(new Name("main")).hasMoreElements()) {
                    throw new CompilerException("Main Java file should contain a main method");
                }
            }
        }
    }

    JIJCCodeGenerator codeGenerator = new JIJCCodeGenerator(symbolTable, scm, am, docComments);
    System.out.println("Generating code...");
    try {
        ast.apply(codeGenerator);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("------------------------");
    System.out.println("Finished\n");
    Vector classes = codeGenerator.getCompiledClasses();
    for (int i = 0; i < classes.size(); i++) {
        compiledClasses.put(classes.elementAt(i), scm.getClass((String) classes.elementAt(i)));
    }
    if (codeGenerator.getExceptions().elements().hasMoreElements()) {
        exceptions.put(filename, codeGenerator.getExceptions());
    }
    System.gc();
    return codeGenerator;
}
/**
 * 
 * @param filename java.lang.String
 * @param classpath java.lang.String
 * @param includedPackagesOrTypes java.lang.String[]
 */
public void compile(String filename, String classpath, String[] includedPackagesOrTypes) throws CompilerException {
    setFilename(filename);
    setClasspath(classpath);
    setIncludedPackagesOrTypes(includedPackagesOrTypes);
    compile();
}
/**
 * 
 * @return edu.ksu.cis.bandera.annotation.AnnotationManager
 */
public static AnnotationManager getAnnotationManager() {
    return am;
}
/**
 * 
 * @return edu.ksu.cis.bandera.jjjc.node.Node
 * @param filename java.lang.String
 */
public static Node getAST(String filename) {
    return (Node) fileTable.get(filename);
}
public static String getClasspath() {
    return classpath;
}
/**
 * 
 * @return java.util.Hashtable
 */
public static Hashtable getCompiledClasses() {
    return compiledClasses;
}
/**
 * 
 * @return java.util.Hashtable
 */
public static Hashtable getExceptions() {
    return exceptions;
}
/**
 * 
 * @return ca.mcgill.sable.soot.SootField
 * @param name java.lang.String
 */
public static SootField getFieldForQuantifier(String name) {
    return (SootField) fieldForQuantifiers.get(name);
}
/**
 * 
 * @return ca.mcgill.sable.soot.SootClass
 */
public static SootClass getMainSootClass() {
    return scm.getClass(mainClassQualifiedName);
}
/**
 * 
 * @return java.util.Hashtable
 */
public static java.util.Hashtable getModifiedMethodTable() {
    return modifiedMethodTable;
}
/**
 * 
 * @return edu.ksu.cis.bandera.specification.datastructure.QuantifiedVariable
 * @param name java.lang.String
 */
public static QuantifiedVariable getQuantifier(String name) {
    return (QuantifiedVariable) quantifierTable.get(name);
}
/**
 * 
 * @return java.util.Vector
 */
public static java.util.Vector getQuantifiers() {
    return quantifiers;
}
/**
 * 
 * @return ca.mcgill.sable.soot.SootClassManager
 */
public static SootClassManager getSootClassManager() {
    return scm;
}
/**
 * 
 * @return edu.ksu.cis.bandera.jjjc.symboltable.SymbolTable
 * @param filename java.lang.String
 */
public static SymbolTable getSymbolTable(String filename) {
    return (SymbolTable) symTable.get(filename);
}
/**
* 
* @return boolean
* @param name java.lang.String
*/
private static boolean isCompile(String packageNames[], Name qName) {
    boolean compile = false;
    if (qName.toString().equals("Bandera")) return false;
    if (qName.isSimpleName()) {
        compile = true;
    } else
        if (packageNames != null) {
            String name = qName.toString().trim();
            String sName = qName.getSuperName().toString().trim();
            for (int j = 0; j < packageNames.length; j++) {
                String packageName = packageNames[j];
                if ((packageName != null) && (name.equals(packageName) || sName.equals(packageName))) {
                    compile = true;
                    j = packageNames.length;
                }
            }
        }
    return compile;
}
/**
 * 
 * @return boolean
 */
public static boolean isDoBSL() {
    return doBSL;
}
/**
 * 
 * @return boolean
 * @param node edu.ksu.cis.bandera.jjjc.node.Node
 */
public static boolean isSynchTransformed(Node node) {
    return syncTransformed.contains(node);
}
/**
* 
* @param args java.lang.String[]
*/
public static void main(String args[]) {
    String classPath;
    String javaFileName;
    if (args.length < 2) {
        System.out.println("usage:");
        System.out.println("  java CompilationManager <classpath> <main java file> [packages]");
        return;
    }
    classPath = args[0];
    javaFileName = args[1];

    String[] packageNames = new String[args.length - 1];
    packageNames[0] = "";
    
    for (int i = 0; i < packageNames.length - 1; i++) {
        packageNames[i + 1] = args[i + 2];
    }

    setClasspath(classPath);
    setFilename(javaFileName);
    setIncludedPackagesOrTypes(packageNames);
    try {
        compile();
    } catch (Exception e) {
        System.out.println(e);
    }
    for (Enumeration e = compiledClasses.elements(); e.hasMoreElements();) {
        SootClass sc = (SootClass) e.nextElement();
        try {
            sc.printTo(new StoredBody(Jimple.v()), new PrintWriter(new FileWriter(sc.getName() + ".jimple"), true));
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }
    System.exit(0);
}
/**
 * 
 * @return edu.ksu.cis.bandera.jjjc.node.Start
 * @param filename java.lang.String
 */
public static Start parseFile(String filename) throws Exception {
    filename = new File(filename).getCanonicalPath();
    if (fileTable.get(filename) != null)
        return (Start) fileTable.get(filename);
    FileReader fr = new FileReader(filename);
    UnicodePreprocessor preprocessor = new UnicodePreprocessor(
            new PushbackReader(new BufferedReader(fr, 8192), 1024));
    Lexer lexer = new Lexer(new PushbackReader(preprocessor, 1024));
    JJCParser parser = new JJCParser(lexer);
    Start ast = parser.parse();
    fr.close();
    Hashtable table = ((AnalysisAdapter) parser.ignoredTokens).getIn();
    for (Enumeration e = table.keys(); e.hasMoreElements();) {
        Object key = e.nextElement();
        Object value = table.get(key);
        if (value.toString().indexOf("/**") >= 0) {
            docComments.put(key, value);
        }
    }
    fileTable.put(filename, ast);
    ast.apply(new edu.ksu.cis.bandera.jjjc.ast.SynchronizedMethodTransformer(syncTransformed, docComments));
    return ast;
}
/**
 * 
 */
public static void reset() {
    compiledClasses = new Hashtable();
    exceptions = new Hashtable();
    CompilationManager.setFilename(null);
    CompilationManager.setClasspath(null);
    CompilationManager.setIncludedPackagesOrTypes(null);
}
/**
 * 
 * @param classpath java.lang.String
 */
public static void setClasspath(String classpath) {
    CompilationManager.classpath = classpath;
}
/**
 * 
 * @param newDoBSL boolean
 */
public static void setDoBSL(boolean newDoBSL) {
    doBSL = newDoBSL;
}
/**
 * 
 * @param filename java.lang.String
 */
public static void setFilename(String filename) {
    CompilationManager.filename = filename;
}
/**
 * 
 * @param includedPackagesOrTypes java.lang.String[]
 */
public static void setIncludedPackagesOrTypes(String[] includedPackagesOrTypes) {
    if (CompilationManager.includedPackagesOrTypes == includedPackagesOrTypes) return;
    if ((CompilationManager.includedPackagesOrTypes != null) &&
            (includedPackagesOrTypes != null)) {
        if (CompilationManager.includedPackagesOrTypes.length == includedPackagesOrTypes.length) {
            boolean f = true;
            for (int i = 0; i < includedPackagesOrTypes.length; i++) {
                if (!("" + CompilationManager.includedPackagesOrTypes[i]).equals("" + includedPackagesOrTypes[i])) {
                    f = false;
                    break;
                }
            }
            if (f) return;
        }
    }
    CompilationManager.includedPackagesOrTypes = includedPackagesOrTypes;
    isRecompile = false;
}
/**
 * 
 * @param newModifiedMethodTable java.util.Hashtable
 */
public static void setModifiedMethodTable(java.util.Hashtable newModifiedMethodTable) {
    modifiedMethodTable = newModifiedMethodTable;
}
/**
 * 
 * @param newQuantifiers java.util.Vector
 */
public static void setQuantifiers(java.util.Vector newQuantifiers) {
    quantifiers = newQuantifiers;
    quantifierTable = new Hashtable();
    for (Iterator i = quantifiers.iterator(); i.hasNext();) {
        QuantifiedVariable qv = (QuantifiedVariable) i.next();
        quantifierTable.put(qv.getName(), qv);
    }
}
}

---