Java TIRWhileStmt类代码示例

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node) {
	Name conditionVariableName = node.getCondition().getName();
	if (conditionVariableName != null) {
		Map<TIRNode, Integer> nodeAndColor = fUDDUWeb
				.getNodeAndColorForUse(conditionVariableName
						.getNodeString());
		boolean isNodeAValidKeyInNodeToColorMap = nodeAndColor != null
				&& nodeAndColor.containsKey(node);
		if (isNodeAValidKeyInNodeToColorMap
				&& isTemporaryVariable(conditionVariableName)) {
			replaceUsedTempVarByDefinition(conditionVariableName, node);
		}
	}
	caseWhileStmt(node);
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node)
{
    try
    {
        TIRWhileStmt whileStmtClone = (TIRWhileStmt) node.clone();
        WhileStmt whileStmt = new WhileStmt();
        
        whileStmt.setExpr(whileStmtClone.getCondition());
        whileStmt.setStmtList(whileStmtClone.getStmtList());
        
        fTIRToMcSAFIRTable.put(node, whileStmt);
        
        if (DEBUG) printTableEntry(node, whileStmt);
        
        caseWhileStmt(node);
    } catch (CloneNotSupportedException e)
    {
        throw new RuntimeException(e);
    }
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
public void caseWhileStmt(WhileStmt node) {
    rewriteChildren(node);
    
    if (node instanceof TIRStmt) return; //don't redo conversion        
    
    //pull out expr
    LinkedList<AssignStmt> assign = new LinkedList<AssignStmt>();
    NameExpr condition = (NameExpr)expandExpr(node.getExpr(),assign);
    
    //copy list to end of body
    for (AssignStmt a : assign){
        node.getStmtList().add(a.copy());
    }
    
    //construct transformed node
    newNode = new TransformedNode(assign);
    newNode.add(new TIRWhileStmt(condition.getName(), new TIRStatementList(node.getStmtList())));
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
public static String printNode(TIRNode node)
{
    if (node instanceof TIRAbstractAssignStmt) return ((TIRAbstractAssignStmt) node).getStructureString();
    else if (node instanceof TIRFunction) return ((TIRFunction) node).getStructureString().split("\n")[0];
    else if (node instanceof TIRIfStmt) return ((TIRIfStmt) node).getStructureString().split("\n")[0];
    else if (node instanceof TIRWhileStmt) return ((TIRWhileStmt) node).getStructureString().split("\n")[0];
    else if (node instanceof TIRForStmt) return ((TIRForStmt) node).getStructureString().split("\n")[0];
    else return null;
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node) {
	currentOutSet = copy(currentInSet);
	setInOutSet(node);
	fVisitedStmts.add(node);

	caseWhileStmt(node);

	if (DEBUG)
		printMapForNode(node);
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node)
{
    fCurrentVariablesSet = newInitialFlow();
    fCurrentVariablesSet.add(node.getCondition().getName().getID());
    fNodeToUsedVariablesMap.put(node, fCurrentVariablesSet);
    caseWhileStmt(node);
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node)
{
    Name conditionVariableName = node.getCondition().getName();
    renameConditionVariableForNode(conditionVariableName, node);
    caseWhileStmt(node);
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node) {
       String indent = node.getIndent();
       buf.append(indent + "while ");
       buf.append(node.getExpr().getPrettyPrinted());
       buf.append('\n');
       printStatements(node.getStmts());
       buf.append(indent + "end");
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
/**
 * WhileStmt: Statement ::= <Condition> WhileBlock: StatementSection;
 */
public Statement getFortran(
		FortranCodeASTGenerator fcg, 
		TIRWhileStmt node) {
	if (Debug) System.out.println("in while statement.");		
	WhileStmt stmt = new WhileStmt();
	String indent = new String();
	for (int i=0; i<fcg.indentNum; i++) {
		indent = indent + fcg.standardIndent;
	}
	stmt.setIndent(indent);
	stmt.setCondition(node.getCondition().getVarName());
	/*
	 * backup this pointer! and make fcg.stmtSecForIFWhileForBlock 
	 * point back after iterate for block.
	 */
	StatementSection backup = fcg.stmtSecForIfWhileForBlock;
	
	fcg.ifWhileForBlockNest++;
	StatementSection whileStmtSec = new StatementSection();
	fcg.stmtSecForIfWhileForBlock = whileStmtSec;
	fcg.indentNum++;
	fcg.iterateStatements(node.getStatements());
	stmt.setWhileBlock(whileStmtSec);
	fcg.indentNum--;
	fcg.ifWhileForBlockNest--;
	
	fcg.stmtSecForIfWhileForBlock = backup;
	
	return stmt;
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node) {
	HandleCaseTIRWhileStmt whileStmt = new HandleCaseTIRWhileStmt();
	if (ifWhileForBlockNest != 0) 
		stmtSecForIfWhileForBlock.addStatement(
				whileStmt.getFortran(this, node));
	else 
		subprogram.getStatementSection().addStatement(
				whileStmt.getFortran(this, node));
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
public static void handleTIRWhileStmt(TIRWhileStmt node, IRx10ASTGenerator target, StmtBlock block) {
	WhileStmt while_stmt =  new WhileStmt();
	while_stmt.setCondition(Expressions.makeIRx10Exp(node.getExpr()));
	
	System.out.println(while_stmt.getCondition().toString());
	while_stmt.setLoopBody(new LoopBody(new List<Stmt>()));
	LoopBody loop_body_block = while_stmt.getLoopBody();
	target.currentBlock.add(loop_body_block);
	buildStmtsSubAST(node.getStmts(), target);
	target.currentBlock.remove(loop_body_block);
	block.addStmt(while_stmt);
	
	System.out.println(loop_body_block.getStmts().getNumChild());
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node){
	HandleCaseTIRWhileStmt whileStmt = new HandleCaseTIRWhileStmt();
	if(this.inIfWhileForBlock==true){
		this.stmtSecForIfWhileForBlock.addStatement(whileStmt.getFortran(this, node));
	}
	else{
		this.SubProgram.getStatementSection().addStatement(whileStmt.getFortran(this, node));
	}
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node) {
	rewriteChildren(node);
	WhileStmt outputWhileStmt = (WhileStmt) getReplacementNode(node);
	fNewNode = new TransformedNode(outputWhileStmt);
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node) {
    parentForwarder.caseTIRWhileStmt(node);
}
 

import natlab.tame.tir.TIRWhileStmt; //导入依赖的package包/类
@Override
public void caseTIRWhileStmt(TIRWhileStmt node) {
    caseWhileStmt(node);
}