Java Options类代码示例

import natlab.options.Options; //导入依赖的package包/类
public static void modify(Options options) {
  Joiner joiner = Joiner.on(PATH_SEPARATOR);
  if (!options.set_matlab_path().isEmpty()){
    setMatlabPath(joiner.join(options.set_matlab_path()));
  }
  if (!options.set_natlab_path().isEmpty()) {
    setNatlabPath(joiner.join(options.set_natlab_path()));
  }
  if (!options.add_natlab_path().isEmpty()) {
    setNatlabPath(joiner.join(
        Arrays.asList(getNatlabPath(), joiner.join(options.add_natlab_path()))));
  }
  if (!options.add_matlab_path().isEmpty()) {
    setMatlabPath(joiner.join(
        Arrays.asList(getMatlabPath(), joiner.join(options.add_matlab_path()))));
  }
}
 

import natlab.options.Options; //导入依赖的package包/类
public static void main(Options options) throws IOException {
	Project project = Project.at(Paths.get(options.files().get(0)));
	List<LintAnalysis> analyses = getAllAnalyses(project);
	Lint lint = Lint.create(project, analyses);
	registerBuiltinListeners(lint);
	lint.runAnalyses();
	lint.writeReport(ReportGenerators.plain(), System.out);
	project.write();
}
 

import natlab.options.Options; //导入依赖的package包/类
public FlowAnalysisTestTool( String[] args, Class<? extends StructuralAnalysis> analysisType )
    throws NoSuchMethodException, InstantiationException, IllegalAccessException,
           InvocationTargetException, FileNotFoundException, Exception
{

    //Generate the AST
    CompilationUnits cu = new CompilationUnits();
    Options opt = new Options();
    opt.parse( args );
    
    if( opt.files().size() == 0 ){
        throw new Exception( "No files provided" );
    }
    for( Object o : opt.files() ){
        String fName = (String) o;
        ArrayList<CompilationProblem> errList = new ArrayList<CompilationProblem>();
        if( !opt.natlab() ){
            //translate from matlab
            Reader source = Parse.translateFile( fName, errList ).getReader();
            if( source == null )
                throw new Exception( "Error translating file "+ fName +":\n" + 
                    errList.stream().map(Object::toString).collect(Collectors.joining("\n")));
            Program prog = Parse.parseNatlabFile( fName, source, errList );
            if( prog == null )
                throw new Exception( "Error parsing file "+ fName +":\n" +
                    errList.stream().map(Object::toString).collect(Collectors.joining("\n")));
            cu.addProgram( prog );
        }
        else{
            cu.addProgram( parseFile( fName ) );
        }
    }
    
    //create the analysis
    analysis = analysisType.getConstructor( ASTNode.class ).newInstance(cu);
    this.ast = cu;
}
 

import natlab.options.Options; //导入依赖的package包/类
public static NatlabServer create(Options options) {
  int port = SERVER_PORT;
  if (options.sp().length() > 0) {
    port = Integer.parseInt(options.sp());
  }
  return new NatlabServer(port, options.quiet(), options.natlab(), !options.noheart());
}
 

import natlab.options.Options; //导入依赖的package包/类
/**
 * builds a file environment by reading the information from an options object.
 * Throws an unsupported operations exception if the options are malformed (i.e. 
 * no main file supplied)
 */
public FileEnvironment(Options options,BuiltinQuery query){
	this.query = query;
	
	//parse main file
	String main = "";
	if (options.main() != null && options.main().length() > 0){
		main = options.main();
	} else {
		List<String> list = options.files();
		if (list != null && list.size() > 0){
			main = list.get(0);
		}
	}
	if (main.length() == 0) throw new UnsupportedOperationException("no main file provided");
	this.main = GenericFile.create(main);
	if (this.main == null || !this.main.exists()){
		throw new UnsupportedOperationException("file "+main+" not found");
	}
	this.pwd = this.main.getParent();
	this.pwdHandler = FolderHandler.getFolderHandler(this.pwd);

	
	//get path
	@SuppressWarnings("unchecked")
	List<String> paths = (List<String>)options.lp();
	if (paths == null || paths.size() == 0){
         this.natlabPath = MatlabPath.getNatlabPath();
         this.matlabPath = MatlabPath.getMatlabPath();
	} else {
	  this.natlabPath = new MatlabPath(paths.stream()
	      .collect(Collectors.joining(StandardSystemProperty.PATH_SEPARATOR.value())));
	}
	this.folderHandlers = getFolderHandlers();
}
 

import natlab.options.Options; //导入依赖的package包/类
public static NatlabServer create(Options options) {
  int port = SERVER_PORT;
  if (options.sp().length() > 0) {
    port = Integer.parseInt(options.sp());
  }
  return new NatlabServer(port, options.quiet(), options.matlab(), !options.noheart());
}
 

import natlab.options.Options; //导入依赖的package包/类
/**
 * builds a file environment by reading the information from an options object.
 * Throws an unsupported operations exception if the options are malformed (i.e. 
 * no main file supplied)
 */
public FileEnvironment(Options options,BuiltinQuery query){
	this.query = query;
	
	//parse main file
	String main = "";
	if (options.main() != null && options.main().length() > 0){
		main = options.main();
	} else {
		List<String> list = options.getFiles();
		if (list != null && list.size() > 0){
			main = list.get(0);
		}
	}
	if (main.length() == 0) throw new UnsupportedOperationException("no main file provided");
	this.main = GenericFile.create(main);
	if (this.main == null || !this.main.exists()){
		throw new UnsupportedOperationException("file "+main+" not found");
	}
	this.pwd = this.main.getParent();
	this.pwdHandler = FolderHandler.getFolderHandler(this.pwd);

	
	//get path
	@SuppressWarnings("unchecked")
	List<String> paths = (List<String>)options.lp();
	if (paths == null || paths.size() == 0){
         this.natlabPath = MatlabPath.getNatlabPath();
         this.matlabPath = MatlabPath.getMatlabPath();
	} else {
	  this.natlabPath =
	      new MatlabPath(Joiner.on(System.getProperty("path.separator")).join(paths));
	}
	this.folderHandlers = getFolderHandlers();
}
 

import natlab.options.Options; //导入依赖的package包/类
public FlowAnalysisTestTool( String[] args, Class<? extends StructuralAnalysis> analysisType )
    throws NoSuchMethodException, InstantiationException, IllegalAccessException,
           InvocationTargetException, FileNotFoundException, Exception
{

    //Generate the AST
    CompilationUnits cu = new CompilationUnits();
    Options opt = new Options();
    opt.parse( args );
    
    if( opt.getFiles().size() == 0 ){
        throw new Exception( "No files provided" );
    }
    for( Object o : opt.getFiles() ){
        String fName = (String) o;
        ArrayList<CompilationProblem> errList = new ArrayList<CompilationProblem>();
        if( opt.matlab() ){
            //translate from matlab
            Reader source = Parse.translateFile( fName, errList );
            if( source == null )
                throw new Exception( "Error translating file "+ fName +":\n" + CompilationProblem.toStringAll( errList ) );
            Program prog = Parse.parseNatlabFile( fName, source, errList );
            if( prog == null )
                throw new Exception( "Error parsing file "+ fName +":\n" + CompilationProblem.toStringAll( errList ) );
            cu.addProgram( prog );
        }
        else{
            cu.addProgram( parseFile( fName ) );
        }
    }
    
    //create the analysis
    analysis = analysisType.getConstructor( ASTNode.class ).newInstance(cu);
    this.ast = cu;
}
 

import natlab.options.Options; //导入依赖的package包/类
private static void log(Options options, String message) {
	if (!options.quiet()) {
		System.err.println(message);
	}
}
 

import natlab.options.Options; //导入依赖的package包/类
/**
 * the entry point coming from natlab.Main - uses the options object to select the proper behavior
 */
public static void main(Options options){
	//** parse args ********
	FileEnvironment fileEnvironment = new FileEnvironment(options); //get path/files
	boolean inline = options.inline(); //get inline
	boolean outputToFile = false; //output TODO

	//arguments - TODO for now just parse them as inputs
	String args = "double"; //start with the default
	if (options.arguments() != null && options.arguments().length() > 0){
		args = options.arguments();
	}
	CP classProp = ClassPropTool.parse(args);
	List<CP> classPropList = new LinkedList<CP>();
	if (classProp instanceof CPChain){
		classPropList = ((CPChain)classProp).asList();
	} else if (classProp instanceof CPBuiltin){
		classPropList.add(classProp);
	} else {
		throw new UnsupportedOperationException("Arguments have to be a list of builtin classes");
	}
	List<PrimitiveClassReference> inputClasses = new LinkedList<PrimitiveClassReference>();
	for (CP element : classPropList){
		if (element instanceof CPBuiltin){
			inputClasses.add(PrimitiveClassReference.valueOf(((CPBuiltin)element).toString().toUpperCase()));
		} else {
			throw new UnsupportedOperationException(
					"Arguments have to be list of builtin classes, received "+element);
		}
	}
	
	
	//** build callgraph *******		
	ArrayList<AggrValue<SimpleMatrixValue>> list = new ArrayList<AggrValue<SimpleMatrixValue>>(inputClasses.size());
	for (PrimitiveClassReference ref : inputClasses){
		list.add(new SimpleMatrixValue(null, ref));
	}
	
	
	Callgraph<SimpleMatrixValue> callgraph = new Callgraph<SimpleMatrixValue>(
			fileEnvironment,
			Args.<AggrValue<SimpleMatrixValue>>newInstance(list),
			new SimpleMatrixValueFactory());
	
	
	//** output info ***********
	System.out.println(callgraph.prettyPrint());
	
}
 

import natlab.options.Options; //导入依赖的package包/类
/**
 * compiles matlab files into fortran, using the Options as argument.
 * This is basically the entry point for mc4.
 * @param options A Natlab Options object defines the command line arguments to Mc4
 */
public static void main(Options options){
       //object that resolves function names to files      
    long t = System.currentTimeMillis();
       //System.out.println("time "+(System.currentTimeMillis() - t));
       //System.exit(0);
       
    //collect all needed matlab files
    SimpleFunctionCollection functions = new SimpleFunctionCollection(new FileEnvironment(options));
    allRefs.addAll(functions.getAllFunctionBuiltinReferences());
    //System.out.println(functions);
    
    
    //test intraprocedural class analysis
    try{
    ValueAnalysis<AggrValue<SimpleMatrixValue>> analysis = new ValueAnalysis<AggrValue<SimpleMatrixValue>>(
            functions,
            Args.<AggrValue<SimpleMatrixValue>>newInstance(new SimpleMatrixValue(PrimitiveClassReference.DOUBLE)),
            new SimpleMatrixValueFactory());
       System.out.println(analysis);
       //System.out.println(analysis.getPrettyPrinted());
       //print code
       for (int i = 0; i < analysis.getNodeList().size(); i++){
       	System.out.println(analysis.getNodeList().get(i).getAnalysis().getTree().getPrettyPrinted());        	
       }
       System.out.println("**********************************************************************");
       for (int i = 0; i < analysis.getNodeList().size(); i++){
       	System.out.println(ValueAnalysisPrinter.prettyPrint(
       			analysis.getNodeList().get(i).getAnalysis()));        	
       }

       
       //System.out.println(ValueAnalysisPrinter.prettyPrint(analysis.getMainNode().getAnalysis()));
    //System.exit(0);
    } catch (StackOverflowError e){
        System.err.println("stackoverflow in "+functions.getMain().name);
        e.printStackTrace();
        System.exit(0);
    }
    System.out.println("=> finished "+functions.getMain().name);
    
    
    //FlowAnalysisTestTool test = new FlowAnalysisTestTool(classAnalysis);
    //System.out.println(test.run(true,true));
}
 

import natlab.options.Options; //导入依赖的package包/类
/**
 * the entry point coming from natlab.Main - uses the options object to select the proper behavior
 */
public static void main(Options options){
	//** parse args ********
	FileEnvironment fileEnvironment = new FileEnvironment(options); //get path/files
	boolean inline = options.inline(); //get inline
	boolean outputToFile = false; //output TODO

	//arguments - TODO for now just parse them as inputs
	String args = "double"; //start with the default
	if (options.arguments() != null && options.arguments().length() > 0){
		args = options.arguments();
	}
	CP classProp = ClassPropTool.parse(args);
	List<CP> classPropList = new LinkedList<CP>();
	if (classProp instanceof CPChain){
		classPropList = ((CPChain)classProp).asList();
	} else if (classProp instanceof CPBuiltin){
		classPropList.add(classProp);
	} else {
		throw new UnsupportedOperationException("Arguments have to be a list of builtin classes");
	}
	List<PrimitiveClassReference> inputClasses = new LinkedList<PrimitiveClassReference>();
	for (CP element : classPropList){
		if (element instanceof CPBuiltin){
			inputClasses.add(PrimitiveClassReference.valueOf(((CPBuiltin)element).toString().toUpperCase()));
		} else {
			throw new UnsupportedOperationException(
					"Arguments have to be list of builtin classes, received "+element);
		}
	}
	
	
	//** build callgraph *******		
	ArrayList<AggrValue<SimpleMatrixValue>> list = new ArrayList<AggrValue<SimpleMatrixValue>>(inputClasses.size());
	for (PrimitiveClassReference ref : inputClasses){
		list.add(new SimpleMatrixValue(ref));
	}
	
	
	Callgraph<SimpleMatrixValue> callgraph = new Callgraph<SimpleMatrixValue>(
			fileEnvironment,
			Args.<AggrValue<SimpleMatrixValue>>newInstance(list),
			new SimpleMatrixValueFactory());
	
	
	//** output info ***********
	System.out.println(callgraph.prettyPrint());
	
}