ATerm createMustSum(ATerm sum){
ATerm cond, newCond, condSort, act, newAct, newSum;
char newActName[250];
AFun memberTag;
ATbool toAbs = ATfalse;
memberTag = createNewFuncSym(memberSym,
ATmakeList2(MCRLterm_bool, liftSort(MCRLterm_bool)));
cond = (ATerm) ATgetArgument((ATermAppl) sum ,4);
condSort = getTermSort(cond);
if(isLifted(condSort)) toAbs = ATtrue;
if(isAbstracted(condSort))
cond = createGammaTerm(cond, condSort);
if(toAbs){
newCond = (ATerm) ATmakeAppl1(MCRLsym_not,
(ATerm) ATmakeAppl2(memberTag, MCRLterm_false, cond));
}
else{
newCond = cond;
newSum = sum;
}
newSum = (ATerm) ATsetArgument((ATermAppl) sum, (ATerm) newCond, 4);
act = (ATerm) ATgetArgument((ATermAppl) sum, 1);
appendString(MCRLgetName(act), mustSufix, newActName);
newAct = (ATerm) ATmakeAppl0(ATmakeAFun(newActName, 0, ATtrue));
return (ATerm) ATsetArgument((ATermAppl) newSum, newAct, 1);
}
ATerm createMemberAuxCondition(ATerm cond, ATerm var,
ATerm arg, ATerm varSort){
AFun memberTag, andTag;
memberTag = createNewFuncSym(memberSym,
ATmakeList2(varSort, liftSort(varSort)));
andTag = createNewFuncSym(andSym,
ATmakeList2(MCRLterm_bool, MCRLterm_bool));
if(cond == NULL){
cond = (ATerm) ATmakeAppl2(memberTag, var, arg);
}
else{
cond = (ATerm) ATmakeAppl2(andTag, cond,
(ATerm) ATmakeAppl2(memberTag, var, arg));
}
return cond;
}
ATerm createAuxCondition2(ATerm auxCond, ATerm cond){
AFun andTag;
andTag = createNewFuncSym(andSym,
ATmakeList2(MCRLterm_bool, MCRLterm_bool));
if(auxCond != NULL){
cond = (ATerm) ATmakeAppl2(andTag, cond,
auxCond);
}
return cond;
}
ATermList T_getAllKeyValuePairs(Table table)
{
ATermList keys = T_getAllKeys(table);
ATermList pairs;
for (pairs = ATempty; !ATisEmpty(keys); keys = ATgetNext(keys)) {
ATerm key = ATgetFirst(keys);
ATerm value = T_getValue(table, key);
ATermList pair = ATmakeList2(key, value);
pairs = ATinsert(pairs, (ATerm) pair);
}
return pairs;
}
ATerm createSingletonAuxCondition(ATerm cond, ATerm func, ATerm fSort){
AFun singletonTag, andTag;
andTag = createNewFuncSym(andSym,
ATmakeList2(MCRLterm_bool, MCRLterm_bool));
singletonTag = createNewFuncSym(singletonSym,
ATmakeList1(fSort));
if(cond == NULL){
cond = (ATerm) ATmakeAppl1(singletonTag, func);
}
else{
cond = (ATerm) ATmakeAppl2(andTag, cond,
(ATerm) ATmakeAppl1(singletonTag, func));
}
return cond;
}
void initAbsInt(){
ATbool ok;
AFun memberTag;
initTables();
conflictingPars = ATmakeList0();
ATprotect((ATerm *)&conflictingPars);
memberTag = createNewFuncSym(memberSym,
ATmakeList2(MCRLterm_bool, liftSort(MCRLterm_bool)));
MCRLputMap((ATerm)ATmakeAppl2(memberTag,
MCRLterm_bool, liftSort(MCRLterm_bool)),
MCRLterm_bool, &ok);
}
ATermList generateNewSums(ATerm sum){
ATerm maySum, mustSum;
ATermList procArgs, newProcArgs;
ATerm proc, procArg, procArgSort;
ATermList actArgs;
ATermList newActArgs;
ATerm actArg, actArgSort;
ATermList vars;
ATerm var, varName, varSort;
ATerm cond, auxMayCondition, auxMustCondition;
int i;
char auxVarName[NAME_LENGTH];
proc = (ATerm) ATgetArgument(sum, 3);
procArgs = (ATermList)ATgetArgument(proc, 0);
newProcArgs = ATmakeList0();
auxMayCondition = NULL;
auxMustCondition = NULL;
maySum = sum;
mustSum = sum;
if(HOMOMORPHISM){
for(i=0;!ATisEmpty(procArgs); procArgs= ATgetNext(procArgs)) {
procArg = ATgetFirst(procArgs);
procArgSort = getTermSort(procArg);
if(isLifted(procArgSort)){
sprintf(auxVarName, "%s%d", auxVarPrefix, i);
i++;
varName = (ATerm)ATmakeAppl0(ATmakeAFun(auxVarName, 0, ATtrue));
varSort = getUnLifted(procArgSort);
maySum = addVar(maySum, varName, varSort);
newProcArgs = ATappend(newProcArgs,
createSingleton(varName, varSort));
auxMayCondition = createMemberAuxCondition(auxMayCondition,
varName, procArg, varSort);
auxMustCondition = createSingletonAuxCondition(auxMustCondition,
procArg, procArgSort);
}
else{
newProcArgs = ATappend(newProcArgs, procArg);
}
}
proc = (ATerm)ATsetArgument((ATermAppl)
proc, (ATerm) newProcArgs, 0);
maySum = (ATerm)ATsetArgument((ATermAppl)maySum, proc, 3);
mustSum = sum;
actArgs = (ATermList)ATgetArgument(sum,2);
newActArgs = ATmakeList0();
for(;!ATisEmpty(actArgs); actArgs= ATgetNext(actArgs),i++) {
actArg = ATgetFirst(actArgs);
actArgSort = getTermSort(actArg);
if(isLifted(actArgSort)){
sprintf(auxVarName, "%s%d", auxVarPrefix, i);
i++;
varName = (ATerm)ATmakeAppl0(ATmakeAFun(auxVarName, 0, ATtrue));
varSort = getUnLifted(actArgSort);
maySum = addVar(maySum, varName, varSort);
mustSum = addVar(mustSum, varName, varSort);
newActArgs = ATappend(newActArgs, varName);
auxMayCondition = createMemberAuxCondition(auxMayCondition,
varName, actArg, varSort);
auxMustCondition = createMemberAuxCondition(auxMustCondition,
varName, actArg, varSort);
auxMustCondition = createSingletonAuxCondition(auxMustCondition,
actArg, actArgSort);
}
else{
newActArgs = ATappend(newActArgs, actArg);
}
maySum = (ATerm)ATsetArgument((ATermAppl)maySum,
(ATerm)newActArgs, 2);
}
}
maySum = (ATerm)createMaySum(maySum);
mustSum = (ATerm)createMustSum(mustSum);
if(HOMOMORPHISM){
cond = ATgetArgument(maySum, 4);
cond = createAuxCondition2(auxMayCondition, cond);
maySum = (ATerm)ATsetArgument((ATermAppl)maySum, cond, 4);
cond = ATgetArgument(mustSum, 4);
cond = createAuxCondition2(auxMustCondition, cond);
mustSum = (ATerm)ATsetArgument((ATermAppl)mustSum, cond, 4);
}
if(MAY && MUST)
return ATmakeList2(maySum, mustSum);
else if(MAY)
return ATmakeList1(maySum);
else if(MUST)
return ATmakeList1(mustSum);
}
void ACC_push_unfold_data(AN2Data data, AN2Data bindings) {
unfold_stack = ATinsert(unfold_stack, (ATerm)ATmakeList2(data,bindings));
}
ATerm SG_CreateAmbiKey(ATerm key, size_t pos)
{
return (ATerm) ATmakeList2(key, (ATerm) ATmakeInt(pos));
}
