---

BOFA.java

package edu.ksu.cis.bandera.bofa;

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Bandera, a Java(TM) analysis and transformation toolkit           *
 * Copyright (C) 1998, 1999                                          *
 * John Hatcliff (hatcliff@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 ca.mcgill.sable.soot.*;
import ca.mcgill.sable.soot.baf.*;
import ca.mcgill.sable.soot.jimple.*;
import ca.mcgill.sable.util.*;

import edu.ksu.cis.bandera.annotation.*;
import edu.ksu.cis.bandera.jjjc.CompilationManager;
import edu.ksu.cis.bandera.jjjc.exception.CompilerException;
import edu.ksu.cis.bandera.util.*;

import java.io.*;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import java.net.URL;

import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.PatternLayout;
import org.apache.log4j.FileAppender;

/*
 * BOFA.java
 * $Id: BOFA.java,v 1.2 2002/02/01 04:08:44 robby Exp $
 */

/**
 * The main class of Bandera Object Flow Analysis.  It needs to be used along
 * with JJJC of Bandera to do Object Flow Analysis.  It can be used
 * independently if soot support is available.  It serves as a stub for
 * executing independent of Bandera.  It can be invoked from the command prompt.
 *
 * @author <a href="http://www.cis.ksu.edu/~hatcliff">John Hatcliff</a>
 * @author 
 * <a href="http://www.cis.ksu.edu/~rvprasad">Venkatesh Prasad Ranganath</a>  
 *
 * @version $Name:  $($Revision: 1.2 $)
 */
public class BOFA
{
    /**
     * Indicates whether the Jimple files of the analyzed class should be dumped
     * or not.
     *
     */
    private static boolean dump = false;

    /**
     * Class in the code from where the analysis will commence.
     *
     */
    private static SootClass rootSootClass;

    /**
     * Method in the rootSootClass from where the analysis will commence.
     *
     */
    private static SootMethod rootSootMethod;

    /**
     * Collection of classes to be analyzed.  
     *
     * This should include all classes which can be reached from the given
     * classes.
     *
     */
    private static Collection storedClasses = null;

    /**
     * <code>SootClassManager</code> object managing the classes to be analyzed.
     *
     */
    static SootClassManager sootClassManager = null;

    /**
     * Central registry of callbacks.  Such callbacks are used to alter the flow
     * graph.  
     *
     * One possible way is to add callbacks to hook the <code>run</code> method
     * as a result of <code>start</code> method call.  This relation is not
     * evident in the Java source code but rather in the native code.
     *
     */
    static CallBackRegistry callbackReg = new CallBackRegistry();

    /*
     * Initializes the logging API used in BOFA.
     */
    static {
        try {
            URL t = callbackReg.getClass().getClassLoader()
                .getResource("edu/ksu/cis/bandera/bofa/log4j.properties");
            PropertyConfigurator.configure(t);
        } catch (Exception  e) {
            System.out.println("##########################################" + 
                               "############################");
            System.out.println("Failed to initialize log4j.");
            e.printStackTrace();
            System.out.println("##########################################" + 
                               "############################");
        } // end of try-catch
    }   

    /**
     * Analyzes the classes that are available through JJJC.
     *
     * It is assumed that the <code>sootClassManager</code> and the
     * <code>storedClasses</code> has been initialized by a prior call to
     * <code>compile</code> or <code>analyze(SootClassManager, Collection</code>
     * was called.  If that is not the case, the available classes from the
     * <code>edu.ksu.cis.bandera.jjjc.CompilationManager</code> are used to
     * analyze.
     *
     * @exception ClassesNotCompiledException if there are no compiled classes
     * to be analyzed.
     * @see #analyze(SootClassManager, Collection) analyze
     * @see #compile compile
     */
    public static void analyze()
    {
        SootClass sc;

        if (sootClassManager == null)
            sootClassManager = CompilationManager.getSootClassManager();
        if (storedClasses == null)
            storedClasses = Util.convert("ca.mcgill.sable.util.VectorList", 
                                         CompilationManager.getCompiledClasses()
                                         .values());
        if (storedClasses == null || storedClasses.size() == 0) {
            System.out.println("You need to compile before you do Flow Analysis"
                               + storedClasses + " ******** " + 
                               storedClasses.size());
            class ClassesNotCompiledException extends RuntimeException 
            {
                ClassesNotCompiledException() {}
            }
            throw new ClassesNotCompiledException();
        }

        System.out.println("Running BOFA...");

        // What if there is more than one main method?
        // What if there is no main method?
        for (Iterator e = storedClasses.iterator(); e.hasNext();) {
            sc = (SootClass) e.next();      
            if (sc.declaresMethod("main")) {
                rootSootClass = sc;
                rootSootMethod = sc.getMethod("main");
                break;
            }
        }
        /* 
         * we are at present interested in only the run method defined by
         * classes extending Thread.  We may include stuff for analysing start()
         * and stop() methods of Applets. 
         */
        callbackReg.regVInvoke(new VInvokeCallBack());
        FA.init(sootClassManager, rootSootClass, rootSootMethod);
        FA.run();
    }
    /** 
     * Analyzes the loaded classes.
     *
     * This interface can be used analyze a set of classes which are
     * "jimplified" using <i>soot</i> directly.
     *
     * @param sootClassManager the class manager managing the classes to be
     * analyzed. 
     * @param storedClasses a collection of compiled
     * classes(<code>SootClass</code>) provided for analysis. 
     *
     * @see #analyze() analyze
     */
    public static void analyze(SootClassManager sootClassManager, 
                               Collection storedClasses)
    {
        BOFA.storedClasses = storedClasses;
        BOFA.sootClassManager = sootClassManager;
        analyze();
    }
    /**
     * Compiles the given java classes using JJJC.
     *
     * @param classPath the classpath required to compile java files.
     * @param classNames the names of the Java files which need to be compiled.
     * @param packageNames the names of the packages needed during compilation.
     */
    public static void compile(String classPath, LinkedList classNames,
                                  LinkedList packageNames)
    {
        String[] packages = new String[packageNames.size()];
        SootClass sc;
        int j = 0;

        System.out.println("Adding relevant classes...");
        for (Iterator i = packageNames.iterator(); i.hasNext(); j++) {
            packages[j] = (String) i.next();
        }

            CompilationManager.setClasspath(classPath);
            CompilationManager.setIncludedPackagesOrTypes(packages);
            try {
                for (Iterator i = classNames.iterator(); i.hasNext();) {
                    CompilationManager.setFilename((String)i.next());
                    CompilationManager.compile();
                    CompilationManager.compile();
                }
            } catch (Exception e) {
            }
            Hashtable exceptions = CompilationManager.getExceptions();
            if (exceptions.size() > 0) {
                System.out.println("Compilation failed:");
                for (Enumeration e = exceptions.keys(); e.hasMoreElements();) {
                    Object filename = e.nextElement();
                    System.out.println("- " + filename);
                    Vector es = (Vector) exceptions.get(filename);
                    for (java.util.Iterator i = es.iterator(); i.hasNext();) {
                        System.out.println("  * " + i.next());
                    }
                }
            }
            storedClasses =
                Util.convert("ca.mcgill.sable.util.VectorList", 
                             CompilationManager.getCompiledClasses().values());
            sootClassManager = CompilationManager.getSootClassManager();
    }
    /**
     * Outputs the Jimple representation of all classes available through the
     * class manager.
     *
     * @param outputPath the location where the jimple representation should be
     * written. 
     *
     * @exception RuntimeException if the jimple files could not be created or 
     * written. 
     */
    static void dumpFile(String outputPath)
    {
        StoredBody bd = new StoredBody(Jimple.v());
        String className;
        File jimpFile;
        FileOutputStream jimpOut;
        SootClass sc;
        for (Iterator e = storedClasses.iterator(); e.hasNext();) {
            sc = (SootClass) e.next();
            className = sc.getName();
            try {
                jimpFile = new File(outputPath + File.separator + className + 
                                    ".original.jimple");
                jimpOut = new FileOutputStream(jimpFile);
                sc.printTo(bd, new PrintWriter(jimpOut, true));
            } catch (IOException ex) {
                throw new RuntimeException("Could not dump jimple file (" +
                                            className + ")");
            }
        }
    }
    /**
     * Entry point to BOFA in stand alone mode.  
     *
     * Currently nothing is displayed after the analysis.  It provides an
     * assurance of whether the analysis went along fine or failed.
     *
     * @param args is the command line arguments.
     */
    public static void main(String[] args)
    {
        LinkedList packageNames = new LinkedList();
        LinkedList classNames = new LinkedList();
        String classPath = ".";
        String outputPath = ".";
        if (args.length == 0)
            printUsage();

        // command line processor
        try {
            for (int i = 0; i < args.length; i++) {
                if (args[i].equals("--help")) {
                    printUsage();
                } else if (args[i].equals("--dump")) {
                    dump = true;
                } else if (args[i].equals("--package")) {
                    i++;
                    while ((i < args.length) && (!args[i].startsWith("--"))) {
                        packageNames.addLast(args[i].trim());
                        i++;
                    }
                    i--;
                } else if (args[i].equals("--classpath")) {
                    i++;
                    if (i < args.length) {
                        classPath = args[i];
                    } else {
                        printUsage();
                    }
                } else if (args[i].equals("--outputdir")) {
                    i++;
                    if (i < args.length) {
                        outputPath = args[i];
                    } else {
                        printUsage();
                    }
                } else if (args[i].equals("--source")) {
                    i++;
                    while ((i < args.length) && (!args[i].startsWith("--"))) {
                        classNames.addLast(args[i].trim());
                        i++;
                    }
                    i--;
                } else {
                    System.out.println("Error parsing argument: " + args[i]);
                    printUsage();
                }
            }
        } catch (Exception ex) {
            System.out.println("Error in parsing arguments (" + ex + ")");
            printUsage();
        }

        // adding relevant classes
        compile(classPath, classNames, packageNames);

        if (dump)
            dumpFile(outputPath);

        // invoke flow analyzer
        analyze();
    }  
    /**
     * Safe exit in case of wrong usage in command line mode.
     */
    static void printUsage()
    {
        System.out.println("Wrong usage");
        System.out.println("java edu.ksu.cis.bandera.bofa.BOFA --source " + 
                           "<source> [--dump] [--classpath <path>] " + 
                           "[--package <package>] [--outpurdir <dir>]");
        System.exit(0);
    }
    /**
     * Resets the complete Analysis engine.  All collected data are destroyed.
     *
     */
    public static void reset() {
        rootSootClass = null;
        rootSootMethod = null;
        sootClassManager = null;
        storedClasses = null;
        FA.reset();
    }
}

---