public void injectDeclAsStm(ABlockStmIR block, AVarDeclIR decl) { ABlockStmIR wrappingBlock = new ABlockStmIR(); wrappingBlock.getLocalDefs().add(decl); block.getStatements().add(wrappingBlock); }
public void caseALetDefExpIR(ALetDefExpIR node) throws AnalysisException { SStmIR enclosingStm = transAssistant.getEnclosingStm(node, "let def expression"); SExpIR exp = node.getExp(); transAssistant.replaceNodeWith(node, exp); ABlockStmIR topBlock = new ABlockStmIR(); ABlockStmIR current = topBlock; for (AVarDeclIR local : node.getLocalDefs()) { ABlockStmIR tmp = new ABlockStmIR(); tmp.getLocalDefs().add(local.clone()); current.getStatements().add(tmp); current = tmp; } transAssistant.replaceNodeWith(enclosingStm, topBlock); topBlock.getStatements().add(enclosingStm); exp.apply(this); topBlock.apply(this); topBlock.setScoped(transAssistant.getInfo().getStmAssistant().isScoped(topBlock)); }
if (block.getLocalDefs().size() <= 1) for (; i < block.getLocalDefs().size(); i++) AVarDeclIR currentDef = block.getLocalDefs().get(i); for (; i < block.getLocalDefs().size(); i++) currentDef = block.getLocalDefs().get(i); defsToLift.add(currentDef); block.getLocalDefs().removeAll(defsToLift); LinkedList<SStmIR> statementsToLift = block.getStatements(); ABlockStmIR liftedBlock = new ABlockStmIR(); liftedBlock.setScoped(block.getScoped()); liftedBlock.setLocalDefs(defsToLift); liftedBlock.setStatements(statementsToLift); block.getStatements().clear(); block.getStatements().add(liftedBlock); ABlockStmIR block = new ABlockStmIR(); block.getStatements().add(elsePart);
/** * Returns a deep clone of this {@link ABlockStmIR} node. * @return a deep clone of this {@link ABlockStmIR} node */ public ABlockStmIR clone() { return new ABlockStmIR( _sourceNode, _tag, _metaData, _scoped, cloneList(_localDefs), cloneList(_statements) ); }
/** * Creates a new tree field only constructor {@code ABlockStmIR TAG=block} node with the given nodes as children. * @deprecated This method should not be used, use AstFactory instead. * The basic child nodes are removed from their previous parents. * @param scoped_ the {@link Boolean} node for the {@code scoped} child of this {@link ABlockStmIR} node * @param localDefs_ the {@link NodeList} node for the {@code localDefs} child of this {@link ABlockStmIR} node * @param statements_ the {@link NodeList} node for the {@code statements} child of this {@link ABlockStmIR} node */ public ABlockStmIR(Boolean scoped_, List<? extends AVarDeclIR> localDefs_, List<? extends SStmIR> statements_) { super(null,null,null); this.setScoped(scoped_); this.setLocalDefs(localDefs_); this.setStatements(statements_); }
public ABlockStmIR wrap(SStmIR stm) { ABlockStmIR block = new ABlockStmIR(); block.getStatements().add(stm); return block; } }
private boolean singleBlockWrapsBlock(ABlockStmIR node) { return node.getLocalDefs().isEmpty() && node.getStatements().size() == 1 && node.getStatements().get(0) instanceof ABlockStmIR; }
public ABlockStmIR wrap(AVarDeclIR decl) { ABlockStmIR block = new ABlockStmIR(); block.getLocalDefs().add(decl); return block; }
for (int i = 0; i < node.getLocalDefs().size(); i++) AVarDeclIR dec = node.getLocalDefs().get(i); stms.addAll(patternHandlingBlock.getStatements()); stms.addAll(node.getStatements()); node.setStatements(stms); List<PatternInfo> patternInfo = extractFromLocalDefs(node.getLocalDefs()); List<DeclBlockPair> declBlockPairs = consPatternHandlingBlocksSeparate(node.getLocalDefs(), patternInfo); ABlockStmIR block = new ABlockStmIR(); block.getStatements().add(currentDeclBlockPair.getBlock()); block.getStatements().add(stm); } else enc.getStatements().addFirst(currentDeclBlockPair.getBlock()); for(AVarDeclIR dcl : node.getLocalDefs()) for (SStmIR stm : node.getStatements())
@Override public void caseANonDeterministicBlockStmIR(ANonDeterministicBlockStmIR node) throws AnalysisException { super.caseANonDeterministicBlockStmIR(node); ABlockStmIR block = new ABlockStmIR(); block.setScoped(false); block.setTag(node.getTag()); block.setSourceNode(node.getSourceNode()); if(!node.getStatements().isEmpty()) { // Just use the first statement block.getStatements().add(node.getStatements().getFirst().clone()); } else { log.error("nondeterministic statement block did not contain any statements: " + node); } assist.replaceNodeWith(node, block); } }
private void add(ABlockStmIR block, AMetaStmIR as) { if (as != null) { block.getStatements().add(as); } }
node.setStatement(new ABlockStmIR()); outerBlock.getStatements().add(node.getStatement()); outerBlock.setScoped(transAssistant.getInfo().getStmAssistant().isScoped(outerBlock));
ABlockStmIR newBody = new ABlockStmIR(); newBody.getStatements().add(patternHandlingBlock); newBody.getStatements().add(oldBody); newBody.apply(this); } else
public static String getBlockSimpleBlockString(ABlockStmIR node) { StringBuilder sb = new StringBuilder(); sb.append("{\n"); for (AVarDeclIR d : node.getLocalDefs()) { sb.append(d); sb.append("\n"); } sb.append("\n"); sb.append(getSimpleBlockString(node)); sb.append("}"); return sb.toString(); } }
@Override public void caseACompSetExpIR(ACompSetExpIR node) throws AnalysisException { SStmIR enclosingStm = transAssistant.getEnclosingStm(node, "set comprehension"); SExpIR first = node.getFirst(); SExpIR predicate = node.getPredicate(); STypeIR type = node.getType(); ITempVarGen tempVarNameGen = transAssistant.getInfo().getTempVarNameGen(); String var = tempVarNameGen.nextVarName(prefixes.setComp()); ComplexCompStrategy strategy = consSetCompStrategy(first, predicate, type, tempVarNameGen, var); List<SMultipleBindIR> bindings = filterBindList(node, node.getBindings()); ABlockStmIR block = transAssistant.consComplexCompIterationBlock(bindings, tempVarNameGen, strategy, iteVarPrefixes); if (block.getStatements().isEmpty()) { // In case the block has no statements the result of the set comprehension is the empty set AEnumSetExpIR emptySet = new AEnumSetExpIR(); emptySet.setType(type.clone()); // Replace the set comprehension with the empty set transAssistant.replaceNodeWith(node, emptySet); } else { replaceCompWithTransformation(enclosingStm, block, type, var, node); } block.apply(this); }
@Override public void caseABlockStmIR(ABlockStmIR node) throws org.overture.codegen.ir.analysis.AnalysisException { for (SStmIR s : new LinkedList<>(node.getStatements())) { s.apply(this); } if (node.parent() instanceof ABlockStmIR && isEmpty(node)) { /** * Only remove empty blocks from blocks, otherwise we can get into a situation where we destroy the tree. * For example, 'if exp then () else ()' */ node.parent().removeChild(node); return; } if (singleBlockWrapsBlock(node)) { SStmIR enclosedStm = node.getStatements().get(0); if (node.parent() != null) { node.parent().replaceChild(node, enclosedStm); } } }
public ABlockStmIR consIterationBlock(List<SPatternIR> ids, SExpIR set, ITempVarGen tempGen, IIterationStrategy strategy, IterationVarPrefixes iteVarPrefixes) throws AnalysisException { ABlockStmIR outerBlock = new ABlockStmIR(); consIterationBlock(outerBlock, ids, set, tempGen, strategy, iteVarPrefixes); return outerBlock; }
protected void handleLogicExp(SBoolBinaryExpIR node, SStmIR enclosingStm, SStmIR checkBlock, String resultName) throws AnalysisException { AVarDeclIR andResultDecl = transAssistant.consBoolVarDecl(resultName, false); ABlockStmIR declBlock = new ABlockStmIR(); declBlock.getLocalDefs().add(andResultDecl); ABlockStmIR replacementBlock = new ABlockStmIR(); transAssistant.replaceNodeWith(enclosingStm, replacementBlock); transAssistant.replaceNodeWith(node, transAssistant.consBoolCheck(resultName, false)); replacementBlock.getStatements().add(declBlock); replacementBlock.getStatements().add(checkBlock); replacementBlock.getStatements().add(enclosingStm); replacementBlock.apply(this); }
private void addAssert(AAssignToExpStmIR node, AMetaStmIR assertStm) { ABlockStmIR replStm = new ABlockStmIR(); getJmlGen().getJavaGen().getTransAssistant().replaceNodeWith(node, replStm); replStm.getStatements().add(node); replStm.getStatements().add(assertStm); }