private List<PPattern> cloneList(LinkedList<PPattern> parameterPatterns) { List<PPattern> r = new LinkedList<PPattern>(); for (PPattern p : parameterPatterns) { r.add(p.clone()); } return r; }
@Override public List<PMultipleBind> caseATypeBind(ATypeBind bind) throws AnalysisException { List<PPattern> plist = new Vector<PPattern>(); plist.add(bind.getPattern().clone()); List<PMultipleBind> mblist = new Vector<PMultipleBind>(); mblist.add(AstFactory.newATypeMultipleBind(plist, bind.getType().clone())); return mblist; }
public static List<PMultipleBind> bindListFromPattern(PPattern pattern, PType type) { List<PMultipleBind> bindList = new LinkedList<PMultipleBind>(); ATypeMultipleBind tmBind = new ATypeMultipleBind(); List<PPattern> plist = new LinkedList<PPattern>(); plist.add(pattern.clone()); tmBind.setPlist(plist); tmBind.setType(type.clone()); bindList.add(tmBind); return bindList; }
private List<PMultipleBind> makeBinds() { List<PMultipleBind> result = new LinkedList<PMultipleBind>(); Iterator<PType> types = argtypes.iterator(); for (List<PPattern> params : paramPatternList) { for (PPattern param : params) { ATypeMultipleBind typeBind = new ATypeMultipleBind(); List<PPattern> one = new Vector<PPattern>(); one.add(param.clone()); typeBind.setPlist(one); PType type = types.next(); typeBind.setType(type.clone()); result.add(typeBind); } } return result; }
private void addParameterBinds(LinkedList<PMultipleBind> r) { Iterator<PType> types = deftype.getParameters().iterator(); for (PPattern p : paramPatternList) { ATypeMultipleBind tmBind = new ATypeMultipleBind(); List<PPattern> pats = new LinkedList<PPattern>(); pats.add(p.clone()); tmBind.setType(types.next().clone()); tmBind.setPlist(pats); r.add(tmBind); } }
public POForAllContext(ALambdaExp exp) { this.bindings = new Vector<PMultipleBind>(); for (ATypeBind tb : exp.getBindList()) { List<PPattern> pl = new ArrayList<PPattern>(); pl.add(tb.getPattern().clone()); ATypeMultipleBind mtb = AstFactory.newATypeMultipleBind(pl, tb.getType().clone()); bindings.add(mtb); } }
public POForAllContext(PBind bind, PExp exp) { // Create new binding for "bind.pattern in set elems exp" bindings = new Vector<PMultipleBind>(); List<PPattern> pl = new ArrayList<PPattern>(); pl.add(bind.getPattern().clone()); AElementsUnaryExp elems = AstFactory.newAElementsUnaryExp(exp.getLocation(), exp.clone()); ASetMultipleBind msb = AstFactory.newASetMultipleBind(pl, elems); bindings.add(msb); }
private AExplicitFunctionDefinition getRelDef(PRelation node, ATypeDefinition typedef, ILexNameToken fname) { ILexLocation loc = node.getLhsPattern().getLocation(); List<PPattern> params = new Vector<PPattern>(); params.add(node.getLhsPattern().clone()); params.add(node.getRhsPattern().clone()); List<List<PPattern>> parameters = new Vector<List<PPattern>>(); parameters.add(params); PTypeList ptypes = getPTypes(typedef); AFunctionType ftype = AstFactory.newAFunctionType(loc, false, ptypes, AstFactory.newABooleanBasicType(loc)); AExplicitFunctionDefinition def = AstFactory.newAExplicitFunctionDefinition(fname, NameScope.GLOBAL, null, ftype, parameters, node.getRelExp(), null, null, false, null); def.setAccess(typedef.getAccess().clone()); // Same as type's def.setClassDefinition(typedef.getClassDefinition()); return def; }
private List<ACaseAlternative> readCaseAlternatives(PExp exp) throws ParserException, LexException { List<ACaseAlternative> alts = new Vector<ACaseAlternative>(); List<PPattern> plist = getPatternReader().readPatternList(); checkFor(VDMToken.ARROW, 2149, "Expecting '->' after case pattern list"); PExp then = readExpression(); for (PPattern p : plist) { alts.add(AstFactory.newACaseAlternative(exp.clone(), p.clone(), then.clone())); } return alts; }
private List<ACaseAlternativeStm> readCaseAlternatives() throws ParserException, LexException { List<ACaseAlternativeStm> alts = new Vector<ACaseAlternativeStm>(); List<PPattern> plist = getPatternReader().readPatternList(); checkFor(VDMToken.ARROW, 2236, "Expecting '->' after case pattern list"); PStm result = readStatement(); for (PPattern p : plist) { p.getLocation().executable(true); alts.add(AstFactory.newACaseAlternativeStm(p.clone(), result.clone())); } return alts; }
public AExplicitFunctionDefinition getInvDefinition(AStateDefinition d) { ILexLocation loc = d.getInvPattern().getLocation(); List<PPattern> params = new Vector<PPattern>(); params.add(d.getInvPattern().clone()); List<List<PPattern>> parameters = new Vector<List<PPattern>>(); parameters.add(params); PTypeList ptypes = new PTypeList(); ptypes.add(AstFactory.newAUnresolvedType(d.getName())); AFunctionType ftype = AstFactory.newAFunctionType(loc, false, ptypes, AstFactory.newABooleanBasicType(loc)); return AstFactory.newAExplicitFunctionDefinition(d.getName().getInvName(loc), NameScope.GLOBAL, null, ftype, parameters, d.getInvExpression(), null, null, true, null); }
public AExplicitFunctionDefinition getInitDefinition(AStateDefinition d) { ILexLocation loc = d.getInitPattern().getLocation(); List<PPattern> params = new Vector<PPattern>(); params.add(d.getInitPattern().clone()); List<List<PPattern>> parameters = new Vector<List<PPattern>>(); parameters.add(params); PTypeList ptypes = new PTypeList(); ptypes.add(AstFactory.newAUnresolvedType(d.getName())); AFunctionType ftype = AstFactory.newAFunctionType(loc, false, ptypes, AstFactory.newABooleanBasicType(loc)); PExp body = AstFactory.newAStateInitExp(d); AExplicitFunctionDefinition def = AstFactory.newAExplicitFunctionDefinition(d.getName().getInitName(loc), NameScope.GLOBAL, null, ftype, parameters, body, null, null, false, null); return def; }
public ValueBindingObligation(PPattern pattern, PType type, PExp exp, IPOContextStack ctxt, IPogAssistantFactory af) throws AnalysisException { super(pattern, POType.VALUE_BINDING, ctxt, pattern.getLocation(), af); AExistsExp existsExp = new AExistsExp(); List<PPattern> patternList = new Vector<PPattern>(); patternList.add(pattern.clone()); ATypeMultipleBind typeBind = new ATypeMultipleBind(); typeBind.setPlist(patternList); typeBind.setType(type.clone()); List<PMultipleBind> bindList = new Vector<PMultipleBind>(); bindList.add(typeBind); existsExp.setBindList(bindList); AEqualsBinaryExp equals = AstExpressionFactory.newAEqualsBinaryExp(patternToExp(pattern.clone()), exp.clone()); existsExp.setPredicate(equals); stitch = existsExp; valuetree.setPredicate(ctxt.getPredWithContext(existsExp)); // valuetree.setContext(ctxt.getContextNodeList()); } }
private PExp alt2Exp(ACaseAlternative alt, ACasesExp exp, IPogAssistantFactory assistantFactory) throws AnalysisException { if (assistantFactory.createPPatternAssistant().isSimple(alt.getPattern())) { AEqualsBinaryExp equalsExp = AstExpressionFactory.newAEqualsBinaryExp(exp.getExpression().clone(), patternToExp(alt.getPattern().clone())); return equalsExp; } else { PExp matching = patternToExp(alt.getPattern().clone()); AExistsExp existsExp = new AExistsExp(); ATypeMultipleBind tbind = new ATypeMultipleBind(); List<PPattern> plist = new LinkedList<PPattern>(); plist.add(alt.getPattern().clone()); tbind.setPlist(plist); tbind.setType(exp.getExpression().getType().clone()); List<PMultipleBind> bindList = new LinkedList<PMultipleBind>(); bindList.add(tbind); existsExp.setBindList(bindList); AEqualsBinaryExp equalsExp = AstExpressionFactory.newAEqualsBinaryExp(exp.getExpression().clone(), matching); existsExp.setPredicate(equalsExp); return existsExp; } }
public SatisfiabilityObligation(ATypeDefinition node, IPOContextStack ctxt, IPogAssistantFactory af) throws AnalysisException { super(node, POType.TYPE_INV_SAT, ctxt, node.getLocation(), af); AExistsExp exists_exp = new AExistsExp(); exists_exp.setType(new ABooleanBasicType()); ATypeMultipleBind tmb = new ATypeMultipleBind(); List<PPattern> pats = new LinkedList<PPattern>(); pats.add(node.getInvPattern().clone()); tmb.setPlist(pats); tmb.setType(node.getInvType().clone()); List<PMultipleBind> binds = new LinkedList<PMultipleBind>(); binds.add(tmb); exists_exp.setBindList(binds); exists_exp.setPredicate(node.getInvExpression().clone()); stitch = exists_exp; valuetree.setPredicate(ctxt.getPredWithContext(exists_exp)); }
ATypeMultipleBind tmBind = new ATypeMultipleBind(); List<PPattern> patternList = new LinkedList<PPattern>(); patternList.add(result.getPattern().clone()); tmBind.setPlist(patternList); tmBind.setType(result.getType().clone()); localDef.setPattern(result.getPattern().clone()); localDef.setType(result.getType().clone()); localDef.setTest(body.clone());
public AExplicitFunctionDefinition getPostDefinition( AImplicitFunctionDefinition d) { List<List<PPattern>> parameters = getParamPatternList(d); parameters.get(0).add(d.getResult().getPattern().clone()); @SuppressWarnings("unchecked") AExplicitFunctionDefinition def = AstFactory.newAExplicitFunctionDefinition(d.getName().getPostName(d.getPostcondition().getLocation()), NameScope.GLOBAL, (List<ILexNameToken>) d.getTypeParams().clone(), af.createAFunctionTypeAssistant().getPostType((AFunctionType) d.getType()), parameters, d.getPostcondition(), null, null, false, null); def.setAccess(d.getAccess().clone()); def.setClassDefinition(d.getClassDefinition()); return def; }
public AExplicitFunctionDefinition getInvDefinition(ATypeDefinition d) { ILexLocation loc = d.getInvPattern().getLocation(); List<PPattern> params = new Vector<PPattern>(); params.add(d.getInvPattern().clone()); List<List<PPattern>> parameters = new Vector<List<PPattern>>(); parameters.add(params); PTypeList ptypes = new PTypeList(); if (d.getInvType() instanceof ARecordInvariantType) { // Records are inv_R: R +> bool ptypes.add(AstFactory.newAUnresolvedType(d.getName().clone())); } else { // Named types are inv_T: x +> bool, for T = x ANamedInvariantType nt = (ANamedInvariantType) d.getInvType(); ptypes.add(nt.getType().clone()); } AFunctionType ftype = AstFactory.newAFunctionType(loc, false, ptypes, AstFactory.newABooleanBasicType(loc)); AExplicitFunctionDefinition def = AstFactory.newAExplicitFunctionDefinition(d.getName().getInvName(loc), NameScope.GLOBAL, null, ftype, parameters, d.getInvExpression(), null, null, true, null); def.setAccess(d.getAccess().clone()); // Same as type's def.setClassDefinition(d.getClassDefinition()); return def; }
private PExp getCaseExp() { if (assistantFactory.createPPatternAssistant().isSimple(pattern)) { ANotUnaryExp notExp = new ANotUnaryExp(); AEqualsBinaryExp equalsExp = AstExpressionFactory.newAEqualsBinaryExp(patternToExp(pattern.clone(), assistantFactory, new UniqueNameGenerator(exp)), exp.clone()); notExp.setExp(equalsExp); return notExp; } else { ANotUnaryExp notExp = new ANotUnaryExp(); AExistsExp existsExp = new AExistsExp(); List<PMultipleBind> bindList = ContextHelper.bindListFromPattern(pattern.clone(), type.clone()); existsExp.setBindList(bindList); PExp matching = patternToExp(pattern,assistantFactory,new UniqueNameGenerator(exp)); AEqualsBinaryExp equalsExp = AstExpressionFactory.newAEqualsBinaryExp(matching, exp.clone()); existsExp.setPredicate(equalsExp); notExp.setExp(existsExp); return notExp; } }