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);
}
