void abstractVars(){ ATermList newSums, sums = MCRLgetListOfSummands(); ATermList vars, newVars; ATerm proc, sum; ATerm var, varSort, varName, oldVarSort; proc = MCRLgetProc(); newSums = ATmakeList0(); for(;!ATisEmpty(sums); sums= ATgetNext(sums)){ sum = ATgetFirst(sums); vars = (ATermList) ATgetArgument((ATermAppl) sum ,0); newVars = ATmakeList0(); for(;!ATisEmpty(vars); vars= ATgetNext(vars)){ var = (ATerm) ATgetFirst(vars); varName = (ATerm) ATgetArgument((ATermAppl) var, 0); varSort = (ATerm) ATgetArgument((ATermAppl) var, 1); oldVarSort = ATtableGet(var_tab, varName); if(oldVarSort != NULL) if(varSort != getConcrete(oldVarSort)){ PP("Variable "); ppTerm(varName); PP(" appears with two different types, "); ppTerm(varSort); PP(" and "); pTerm(oldVarSort); P("please modify the specification"); exit(-1); } if(toAbstractVar(varName)){ varSort = abstractSort(varSort); } if(toAbstractSort(varSort)){ varSort = abstractSort(varSort); } if(!toAbstractSort(varSort) && BUT_SORT){ varSort = getConcrete(varSort); } ATtablePut(var_tab, varName, varSort); var = (ATerm) ATsetArgument((ATermAppl) var, varSort, 1); newVars = ATinsert(newVars, var); } sum = (ATerm) ATsetArgument((ATermAppl) sum, (ATerm) ATreverse(newVars), 0); newSums = ATinsert(newSums, sum); } proc = (ATerm) ATsetArgument((ATermAppl) proc, (ATerm)ATreverse(newSums), 2); MCRLsetProc(proc); }
static ATermList CaseRewriteList(ATermList ts) { ATermList r = ATempty; for (; !ATisEmpty(ts); ts=ATgetNext(ts)) { ATerm t = ATgetFirst(ts); r = ATinsert(r, CaseRewrite(t)); } return ATreverse(r); }
static ATbool Reduce(void) { ATerm proc = MCRLgetProc(); ATermList sums = MCRLgetListOfSummands(), pars = MCRLgetListOfPars(); ATermList newsums = ATmakeList0(); if (proverFlag) { Declare_vars(pars); if (invariant) MCRLparseInvariants(invariant); } else RWdeclareVariables(pars); for (cnt=0,newcnt = 0;!ATisEmpty(sums);sums=ATgetNext(sums),cnt++) { ATerm sum = ATgetFirst(sums), newsum = NULL; ATermList vars = (ATermList) ATgetArgument((ATermAppl) sum,0); ATerm actname = ATgetArgument((ATermAppl) sum, 1); ATermList actargs = (ATermList) ATgetArgument((ATermAppl) sum,2); ATerm procarg = ATgetArgument((ATermAppl) sum, 3); ATerm cond = ATgetArgument((ATermAppl) sum,4); ATbool invariantUsed = ATfalse; if (proverFlag) { if (!ATisEmpty(vars)) Declare_vars(vars); cond = Prove(cond); if (invariant) { ATerm cond1 = ProveCondition(cond); if (!ATisEqual(cond1, cond)) { invariantUsed = ATtrue; cond = cond1; } /* ATwarning("QQQ cond = %t", cond); */ } cond = RWrewrite(cond); } else { if (!ATisEmpty(vars)) RWdeclareVariables(vars); cond = RWrewrite(cond); } /* if (monitor) ATwarning("Condition of summand %d is rewritten", cnt+1); */ if (ATisEqual(cond, MCRLterm_false)) continue; newcnt++; actargs = RWrewriteList(actargs); if (!ATisEqual(procarg, MCRLterm_terminated)) { ATermList states = (ATermList) ATgetArgument((ATermAppl) procarg, 0); states = proverFlag?ProveList(states):RWrewriteList(states); procarg = (ATerm) ATmakeAppl1(MCRLsym_i, (ATerm) states); } newsum = ATmake("smd(<term>,<term>,<term>,<term>,<term>)",vars, actname, actargs,procarg, cond); newsums = ATinsert(newsums, newsum); if (monitor && !ATisEqual(sum, newsum)) ATwarning("Summand %d is rewritten %s", cnt+1, invariantUsed?"(invariant is used)":""); } MCRLsetProc(ATmake("initprocspec(<term>,<term>,<term>)", (ATerm) RWrewriteList((ATermList) MCRLgetListOfInitValues()), pars, (ATerm) ATreverse(newsums))); return !ATisEqual(MCRLgetProc(), proc); }
static ATermList ProveList(ATermList args) { ATermList r = ATempty; AFun bool = ATgetAFun(MCRLterm_bool); for (;!ATisEmpty(args);args=ATgetNext(args)) { ATerm arg = ATgetFirst(args); r = ATinsert(r, MCRLgetSort(arg)==bool? RWrewrite(Prove(arg)):RWrewrite(arg)); } return ATreverse(r); }
void abstractSummands(){ ATermList mayMustSums, newSums, sums = MCRLgetListOfSummands(); ATerm proc, sum; proc = MCRLgetProc(); newSums = ATmakeList0(); P("Generating Abstract Summands"); sums = ATreverse(sums); for(nSum = 1; !ATisEmpty(sums); sums= ATgetNext(sums), nSum++){ sum = ATgetFirst(sums); mayMustSums = generateNewSums(sum); newSums = ATconcat(newSums, mayMustSums); fprintf(stderr,"."); } proc = (ATerm) ATsetArgument((ATermAppl) proc, (ATerm)newSums, 2); MCRLsetProc(proc); fprintf(stderr,"\n"); }
SDF_SymbolList SDF_reverseSymbolList(SDF_SymbolList l) { return SDF_SymbolListFromTerm((ATerm) ATreverse((ATermList) SDF_SymbolListToTerm(l))); }
SDF_RenamingList SDF_reverseRenamingList(SDF_RenamingList l) { return SDF_RenamingListFromTerm((ATerm) ATreverse((ATermList) SDF_RenamingListToTerm(l))); }
static void generateSource(FILE *file, ATermList terms, ATermList afuns) { int len, row, col, index; unsigned char *data; ATerm all; ATermList list, term_aliases, afun_aliases; ATermList term_values, afun_values; if (opt_gen_date) { time_t now = time(NULL); fprintf(file, "/*\n * Generated at %s", ctime(&now)); fprintf(file, " */\n\n"); } fprintf(file, "#include \"%s.h\"\n\n", file_prefix); /*{{{ unzip term and afun lists */ term_aliases = ATempty; afun_aliases = ATempty; term_values = ATempty; afun_values = ATempty; list = afuns; while (!ATisEmpty(list)) { ATerm alias, value; ATerm pair = ATgetFirst(list); list = ATgetNext(list); if (!ATmatch(pair, "[<term>,<term>]", &alias, &value)) { ATfprintf(stderr, "malformed [alias,afun] pair: %t\n", pair); exit(1); } afun_aliases = ATinsert(afun_aliases, alias); afun_values = ATinsert(afun_values, value); } afun_aliases = ATreverse(afun_aliases); afun_values = ATreverse(afun_values); list = terms; while (!ATisEmpty(list)) { ATerm alias, value; ATerm pair = ATgetFirst(list); list = ATgetNext(list); if (!ATmatch(pair, "[<term>,<term>]", &alias, &value)) { ATfprintf(stderr, "malformed [alias,term] pair: %t\n", pair); exit(1); } term_aliases = ATinsert(term_aliases, alias); term_values = ATinsert(term_values, value); } term_aliases = ATreverse(term_aliases); term_values = ATreverse(term_values); /*}}} */ /*{{{ generate symbol declarations */ list = afun_aliases; while (!ATisEmpty(list)) { ATerm alias = ATgetFirst(list); list = ATgetNext(list); checkAlias(alias); ATfprintf(file, "AFun %t;\n", alias); } fprintf(file, "\n"); /*}}} */ /*{{{ generate term declarations */ list = term_aliases; while (!ATisEmpty(list)) { ATerm alias = ATgetFirst(list); list = ATgetNext(list); checkAlias(alias); ATfprintf(file, "ATerm %t = NULL;\n", alias); } /*}}} */ /*{{{ generate BAF data */ ATfprintf(file, "\n/*\n"); list = afuns; while (!ATisEmpty(list)) { ATermList pair = (ATermList)ATgetFirst(list); list = ATgetNext(list); ATfprintf(file, " * %t = %t\n", ATelementAt(pair, 0), ATelementAt(pair, 1)); } ATfprintf(file, " *\n"); list = terms; while (!ATisEmpty(list)) { ATermList pair = (ATermList)ATgetFirst(list); list = ATgetNext(list); ATfprintf(file, " * %t = %t\n", ATelementAt(pair, 0), ATelementAt(pair, 1)); } ATfprintf(file, " *\n"); ATfprintf(file, " */\n"); ATfprintf(file, "\nstatic ATerm _%s = NULL;\n\n", code_prefix); all = ATmake("[<term>,<term>]", afun_values, term_values); data = (unsigned char *)ATwriteToBinaryString(all, &len); ATfprintf(file, "#define _%s_LEN %d\n\n", code_prefix, len); ATfprintf(file, "static char _%s_baf[_%s_LEN] = {\n", code_prefix, code_prefix, len); index = 0; for (row=0; index<len; row++) { for (col=0; col<ROW_LENGTH && index<len; col++) { fprintf(file, "0x%02X", data[index++]); if (index < len) { fprintf(file, ","); } } fprintf(file, "\n"); } ATfprintf(file, "};\n\n"); /*}}} */ /*{{{ generate init function */ ATfprintf(file, "void init_%s()\n", code_prefix); ATfprintf(file, "{\n"); ATfprintf(file, " ATermList afuns, terms;\n\n"); ATfprintf(file, " _%s = ATreadFromBinaryString(_%s_baf, _%s_LEN);\n", code_prefix, code_prefix, code_prefix); ATfprintf(file, " assert(_%s);\n\n", code_prefix); ATfprintf(file, " ATprotect(&_%s);\n\n", code_prefix); ATfprintf(file, " afuns = (ATermList)ATelementAt((ATermList)_%s, 0);\n\n", code_prefix); list = afuns; while (!ATisEmpty(list)) { ATerm alias; ATermList pair = (ATermList)ATgetFirst(list); list = ATgetNext(list); alias = ATelementAt(pair, 0); ATfprintf(file, " %t = ATgetAFun((ATermAppl)ATgetFirst(afuns));\n", alias); ATfprintf(file, " afuns = ATgetNext(afuns);\n"); } ATfprintf(file, "\n terms = (ATermList)ATelementAt((ATermList)_%s, 1);\n\n", code_prefix); list = terms; index = 0; while (!ATisEmpty(list)) { ATerm alias; ATermList pair = (ATermList)ATgetFirst(list); list = ATgetNext(list); alias = ATelementAt(pair, 0); ATfprintf(file, " %t = ATgetFirst(terms);\n", alias); ATfprintf(file, " terms = ATgetNext(terms);\n"); } ATfprintf(file, "}\n"); /*}}} */ }
PT_Symbols PT_reverseSymbols(PT_Symbols symbols) { return (PT_Symbols) ATreverse((ATermList) symbols); }