private void terminate() throws AnalysisException { throw new AnalysisException("Invalid record invariant - transformation cannot be applied. See error log."); }
public SStmIR getEnclosingStm(INode node, String nodeStr) throws AnalysisException { SStmIR enclosingStm = findEnclosingStm(node); if (enclosingStm == null) { new AnalysisException(String.format("Could not find enclosing statement for %s", node)); } return enclosingStm; } }
public String formatName(INode node) throws AnalysisException { if (node instanceof ANewExpIR) { ANewExpIR newExp = (ANewExpIR) node; return formatTypeName(node, newExp.getName()); } else if (node instanceof ARecordTypeIR) { ARecordTypeIR record = (ARecordTypeIR) node; ATypeNameIR typeName = record.getName(); return formatTypeName(node, typeName); } throw new AnalysisException("Unexpected node in formatName: " + node.getClass().getName()); }
public GeneratedModule generateIsabelleSyntax(PExp exp) throws AnalysisException, org.overture.codegen.ir.analysis.AnalysisException { IRStatus<SExpIR> status = this.generator.generateFrom(exp); if (status.canBeGenerated()) { return prettyPrint(status); } throw new org.overture.codegen.ir.analysis.AnalysisException(exp.toString() + " cannot be code-generated"); }
public String hackResultName(AFuncDeclIR func) throws AnalysisException { SourceNode x = func.getSourceNode(); if (x.getVdmNode() instanceof AImplicitFunctionDefinition) { AImplicitFunctionDefinition iFunc = (AImplicitFunctionDefinition) x.getVdmNode(); return iFunc.getResult().getPattern().toString(); } throw new AnalysisException("Expected AFuncDeclIR in implicit function source. Got: " + x.getVdmNode().getClass().toString()); }
public static String vdmExp2IsaString(PExp exp) throws AnalysisException, org.overture.codegen.ir.analysis.AnalysisException { IsaGen ig = new IsaGen(); GeneratedModule r = ig.generateIsabelleSyntax(exp); if (r.hasMergeErrors()) { throw new org.overture.codegen.ir.analysis.AnalysisException(exp.toString() + " cannot be generated. Merge errors:" + r.getMergeErrors().toString()); } if (r.hasUnsupportedIrNodes()) { throw new org.overture.codegen.ir.analysis.AnalysisException(exp.toString() + " cannot be generated. Unsupported in IR:" + r.getUnsupportedInIr().toString()); } if (r.hasUnsupportedTargLangNodes()) { throw new org.overture.codegen.ir.analysis.AnalysisException(exp.toString() + " cannot be generated. Unsupported in TargLang:" + r.getUnsupportedInTargLang().toString()); } return r.getContent(); }
public void applyPartialTransformation(IRStatus<? extends INode> status, org.overture.codegen.ir.analysis.intf.IAnalysis transformation) throws org.overture.codegen.ir.analysis.AnalysisException { if (!status.canBeGenerated()) { throw new org.overture.codegen.ir.analysis.AnalysisException("Cannot apply partial transformation to a status that cannot be generated!"); } codeGenInfo.clearTransformationWarnings(); status.getIrNode().apply(transformation); HashSet<IrNodeInfo> transformationWarnings = new HashSet<IrNodeInfo>(codeGenInfo.getTransformationWarnings()); status.addTransformationWarnings(transformationWarnings); }
public void applyTotalTransformation(IRStatus<PIR> status, ITotalTransformation trans) throws org.overture.codegen.ir.analysis.AnalysisException { if (!status.canBeGenerated()) { throw new org.overture.codegen.ir.analysis.AnalysisException("Cannot apply total transformation to a status that cannot be generated!"); } codeGenInfo.clearTransformationWarnings(); status.getIrNode().apply(trans); HashSet<IrNodeInfo> transformationWarnings = new HashSet<IrNodeInfo>(codeGenInfo.getTransformationWarnings()); status.addTransformationWarnings(transformationWarnings); status.setIrNode(trans.getResult()); }
public ATypeNameIR consTypeName(ARecordDeclIR record) throws AnalysisException { ADefaultClassDeclIR classDef = record.getAncestor(ADefaultClassDeclIR.class); ATypeNameIR typeName = new ATypeNameIR(); if (classDef == null) { throw new AnalysisException("A Record declaration must always be defined inside a class"); } else { typeName.setDefiningClass(classDef.getName()); } typeName.setName(record.getName()); return typeName; }
public SSeqTypeIR getSeqTypeCloned(STypeIR typeCg) throws AnalysisException { if (typeCg instanceof SSeqTypeIR) { SSeqTypeIR seqTypeCg = (SSeqTypeIR) typeCg; return seqTypeCg.clone(); } else { SourceNode sourceNode = typeCg.getSourceNode(); if (sourceNode != null && sourceNode.getVdmNode() instanceof PType) { PType vdmType = (PType) sourceNode.getVdmNode(); SSeqType seqType = info.getTcFactory().createPTypeAssistant().getSeq(vdmType); try { typeCg = seqType.apply(info.getTypeVisitor(), info); return (SSeqTypeIR) typeCg; } catch (org.overture.ast.analysis.AnalysisException e) { } } throw new AnalysisException("Exptected sequence type. Got: " + typeCg); } }