public AClassTypeIR consClassType(String classTypeName) { AClassTypeIR classType = new AClassTypeIR(); classType.setName(classTypeName); return classType; }
protected String getInvokedModule(SStmIR stm) { if (stm instanceof APlainCallStmIR) { APlainCallStmIR call = (APlainCallStmIR) stm; STypeIR type = call.getClassType(); if (type instanceof AClassTypeIR) { return ((AClassTypeIR) type).getName(); } } return traceEnclosingClass; }
/** * Creates a new complete constructor {@code AClassTypeIR} 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 types_ the {@link NodeList} node for the {@code types} child of this {@link AClassTypeIR} node * @param name_ the {@link String} node for the {@code name} child of this {@link AClassTypeIR} node */ public AClassTypeIR(SourceNode sourceNode_, Object tag_, List<? extends ClonableString> metaData_, Boolean optional_, ANamedTypeDeclIR namedInvType_, List<? extends STypeIR> types_, String name_) { super(sourceNode_,tag_,metaData_,optional_,namedInvType_); this.setTypes(types_); this.setName(name_); }
/** * Returns a deep clone of this {@link AClassTypeIR} node. * @return a deep clone of this {@link AClassTypeIR} node */ public AClassTypeIR clone() { return new AClassTypeIR( _sourceNode, _tag, _metaData, _optional, cloneNode(_namedInvType), cloneList(_types), _name ); }
innerclassType = new AClassTypeIR(); innerclassType.setName(enclosingClass.getName() + "_sentinel"); history.setSentinelType(innerclassType); } else left.setSentinelType(innerclassType.clone()); left.setHistype(hop.toString().substring(1)); left.setOpsname(nextOpName); lastHistoryExp.setSentinelType(innerclassType.clone()); lastHistoryExp.setHistype(hop.toString().substring(1)); lastHistoryExp.setOpsname(lastOpName);
@Override public void caseAIdentifierVarExpIR(AIdentifierVarExpIR node) throws AnalysisException { INode var = AssistantBase.getVdmNode(node); if(var instanceof AVariableExp) { PDefinition def = ((AVariableExp) var).getVardef(); if(def instanceof ARenamedDefinition) { ARenamedDefinition renamedDef = (ARenamedDefinition) def; AClassTypeIR definingClass = new AClassTypeIR(); definingClass.setName(renamedDef.getDef().getName().getModule()); definingClass.setSourceNode(node.getSourceNode()); AExplicitVarExpIR expVar = new AExplicitVarExpIR(); expVar.setName(renamedDef.getDef().getName().getName()); expVar.setType(node.getType().clone()); expVar.setIsLambda(node.getIsLambda()); expVar.setIsLocal(node.getIsLocal()); expVar.setMetaData(node.getMetaData()); expVar.setTag(node.getTag()); expVar.setSourceNode(node.getSourceNode()); expVar.setClassType(definingClass); assist.replaceNodeWith(node, expVar); } } }
/** * Called by the {@link AClassTypeIR} node from {@link AClassTypeIR#apply(IIsaAnalysis)}. * @param node the calling {@link AClassTypeIR} node */ public void caseAClassTypeIR(AClassTypeIR node) throws AnalysisException { _visitedNodes.add(node); inAClassTypeIR(node); if(node.getNamedInvType() != null && !_visitedNodes.contains(node.getNamedInvType())) { node.getNamedInvType().apply(this); } { List<STypeIR> copy = new ArrayList<STypeIR>(node.getTypes()); for( STypeIR e : copy) { if(!_visitedNodes.contains(e)) { e.apply(this); } } } outAClassTypeIR(node); }
protected ABlockStmIR consDecl(String classTypeName, String varName, SExpIR... args) { ATypeNameIR typeName = getTransAssist().consTypeNameForClass(classTypeName); AClassTypeIR classType = getTransAssist().consClassType(classTypeName); ANewExpIR newExp = new ANewExpIR(); newExp.setName(typeName); newExp.setType(classType); for (SExpIR arg : args) { newExp.getArgs().add(arg); } return getTransAssist().wrap(getTransAssist().consDecl(varName, classType.clone(), newExp)); }
/** * Called by the {@link AHistoryExpIR} node from {@link AHistoryExpIR#apply(IIsaAnalysis)}. * @param node the calling {@link AHistoryExpIR} node */ public void caseAHistoryExpIR(AHistoryExpIR node) throws AnalysisException { _visitedNodes.add(node); inAHistoryExpIR(node); if(node.getType() != null && !_visitedNodes.contains(node.getType())) { node.getType().apply(this); } if(node.getSentinelType() != null && !_visitedNodes.contains(node.getSentinelType())) { node.getSentinelType().apply(this); } outAHistoryExpIR(node); }
private AMethodDeclIR consGetInstanceMethod(String name) AClassTypeIR quoteClassType = new AClassTypeIR(); quoteClassType.setName(name); nullCompare.setRight(info.getExpAssistant().consNullExp()); AIdentifierVarExpIR instanceId = transAssistant.getInfo().getExpAssistant().consIdVar(INSTANCE_FIELD, quoteClassType.clone()); methodType.setResult(quoteClassType.clone());
String moduleName = rd.getDef().getName().getModule(); AClassTypeIR definingClass = new AClassTypeIR(); definingClass.setName(moduleName); definingClass.setSourceNode(node.getSourceNode());
@Override public void caseAExplicitVarExpIR(AExplicitVarExpIR node) throws AnalysisException { String pack = javaGen.getJavaSettings().getJavaRootPackage(); if (JavaCodeGenUtil.isValidJavaPackage(pack)) { STypeIR type = node.getClassType(); if (type instanceof AClassTypeIR) { AClassTypeIR classType = (AClassTypeIR) type; classType.setName(pack + "." + classType.getName()); } else { log.error("Expected type of explicit variable to be a class type at this point. Got: " + type); } } }
/** * Called by the {@link AClassTypeIR} node from {@link AClassTypeIR#apply(IAnalysis)}. * @param node the calling {@link AClassTypeIR} node */ public void caseAClassTypeIR(AClassTypeIR node) throws AnalysisException { _visitedNodes.add(node); inAClassTypeIR(node); if(node.getNamedInvType() != null && !_visitedNodes.contains(node.getNamedInvType())) { node.getNamedInvType().apply(this); } { List<STypeIR> copy = new ArrayList<STypeIR>(node.getTypes()); for( STypeIR e : copy) { if(!_visitedNodes.contains(e)) { e.apply(this); } } } outAClassTypeIR(node); }
/** * Creates a deep clone of this {@link AClassTypeIR} node while putting all * old node-new node relations in the map {@code oldToNewMap}. * @param oldToNewMap the map filled with the old node-new node relation * @return a deep clone of this {@link AClassTypeIR} node */ public AClassTypeIR clone(Map<INode,INode> oldToNewMap) { AClassTypeIR node = new AClassTypeIR( _sourceNode, _tag, _metaData, _optional, cloneNode(_namedInvType, oldToNewMap), cloneList(_types, oldToNewMap), _name ); oldToNewMap.put(this, node); return node; }
/** * Creates a new tree field only constructor {@code AClassTypeIR TAG=class} 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 types_ the {@link NodeList} node for the {@code types} child of this {@link AClassTypeIR} node * @param name_ the {@link String} node for the {@code name} child of this {@link AClassTypeIR} node */ public AClassTypeIR(Boolean optional_, ANamedTypeDeclIR namedInvType_, List<? extends STypeIR> types_, String name_) { super(null,null,null,optional_,namedInvType_); this.setTypes(types_); this.setName(name_); }
classArg.setType(classType.clone());
/** * Called by the {@link AHistoryExpIR} node from {@link AHistoryExpIR#apply(IAnalysis)}. * @param node the calling {@link AHistoryExpIR} node */ public void caseAHistoryExpIR(AHistoryExpIR node) throws AnalysisException { _visitedNodes.add(node); inAHistoryExpIR(node); if(node.getType() != null && !_visitedNodes.contains(node.getType())) { node.getType().apply(this); } if(node.getSentinelType() != null && !_visitedNodes.contains(node.getSentinelType())) { node.getSentinelType().apply(this); } outAHistoryExpIR(node); }
@Override public STypeIR caseAClassType(AClassType node, IRInfo question) throws AnalysisException { String typeName = node.getClassdef().getName().getName(); AClassTypeIR classType = new AClassTypeIR(); classType.setName(typeName); return classType; }