static
void init(void)
{
current = malloc(sizeof(struct position));
AltFun = ATmakeAFun("alt", 2, ATfalse);
ATprotectAFun(AltFun);
SomeFun = ATmakeAFun("Some", 1, ATfalse);
ATprotectAFun(SomeFun);
NoneFun = ATmakeAFun("None", 0, ATfalse);
ATprotectAFun(NoneFun);
AmbFun = ATmakeAFun("amb", 1, ATfalse);
ATprotectAFun(AmbFun);
init_cons();
}
void STRSGLR_ensure_init(void)
{
ATerm foo;
static ATbool STRSGLR_init = ATfalse;
if(STRSGLR_init)
return;
STRSGLR_init = ATtrue;
ATregisterBlobDestructor(parse_table_blob_destructor);
PT_initMEPTApi();
PT_initAsFix2Api();
initErrorApi();
SG_TOOLBUS_OFF();
SG_OUTPUT_ON();
foo = STRSGLR_set_default_config();
none_term = (ATerm) ATmakeAppl(ATmakeAFun("None", 0, ATfalse));
active_parse_tables = ATmakeList(0);
inactive_parse_tables = malloc(sizeof(ATerm*) * MAX_INACTIVE_PARSE_TABLES);
num_inactive_parse_tables = 0;
ATprotect(&none_term);
ATprotect(&parse_error_term);
ATprotectList(&active_parse_tables);
}
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);
}
static void writeADT(A2PWriter writer, A2PType expected, ATerm value){
int termType = ATgetType(value);
if(termType == AT_APPL){
ATermAppl appl = (ATermAppl) value;
AFun fun = ATgetAFun(appl);
char *name = ATgetName(fun);
int arity = ATgetArity(fun);
A2PType constructorType = A2PlookupConstructorType(expected, name, arity);
if(constructorType == NULL){ fprintf(stderr, "Unable to find a constructor that matches the given ADT type. Name: %s, arity: %d, ADT name: %s.\n", name, arity, ((A2PAbstractDataType) expected->theType)->name); exit(1); }
writeConstructor(writer, constructorType, appl);
}else{
A2PType wrapper;
switch(termType){
case AT_INT:
wrapper = A2PlookupConstructorWrapper(expected, A2PintegerType());
break;
case AT_REAL:
wrapper = A2PlookupConstructorWrapper(expected, A2PrealType());
break;
default:
fprintf(stderr, "The given ATerm of type: %d, can not be a constructor.\n", termType);
exit(1);
}
if(wrapper == NULL){ fprintf(stderr, "Unable to find constructor wrapper for ATerm with type : %d.\n", termType); exit(1);}
writeConstructor(writer, wrapper, ATmakeAppl1(ATmakeAFun(((A2PConstructorType) wrapper->theType)->name, 1, ATfalse), value));
}
}
ATermList TS_getTableNames(void)
{
ATermList tableNames = ATempty;
int i;
for(i = 0; i < MAX_NR_OF_TABLES; i++) {
if (tableStore[i].name != NULL) {
AFun fun = ATmakeAFun(tableStore[i].name, 0, ATtrue);
ATermAppl appl = ATmakeAppl0(fun);
tableNames = ATinsert(tableNames, (ATerm)appl);
}
}
return tableNames;
}
ATerm CO_unquoteAppl(ATerm appl)
{
AFun fun;
int arity;
char *name = NULL;
ATermList args = NULL;
assert(ATgetType(appl) == AT_APPL);
fun = ATgetAFun((ATermAppl) appl);
arity = ATgetArity(fun);
name = ATgetName(fun);
args = ATgetArguments((ATermAppl) appl);
fun = ATmakeAFun(name, arity, ATfalse);
return (ATerm) ATmakeApplList(fun, args);
}
ATermList TS_removeValueFromAllTables(ATerm key)
{
int i;
ATermList changedTables = ATempty;
for(i = 0; i < MAX_NR_OF_TABLES; i++) {
if (tableStore[i].name != NULL) {
Table table = tableStore[i].table;
if (T_containsKey(table, key)) {
AFun fun = ATmakeAFun(tableStore[i].name, 0, ATtrue);
ATermAppl appl = ATmakeAppl0(fun);
changedTables = ATinsert(changedTables, (ATerm)appl);
T_removeValue(table, key);
}
}
}
return changedTables;
}
PROCDECL(_stratego_w_5);
PROCDECL(_stratego_x_5);
PROCDECL(_stratego_y_5);
PROCDECL(_stratego_z_5);
PROCDECL(_stratego_a_6);
PROCDECL(_stratego_b_6);
PROCDECL(_stratego_c_6);
PROCDECL(_stratego_d_6);
PROCDECL(_stratego_e_6);
PROCDECL(_stratego_f_6);
PROCDECL(_stratego_g_6);
PROCDECL(_stratego_h_6);
PROCDECL(_stratego_i_6);
PROC(_stratego_init_afuns)
MOVE(d_0,ATmakeAFun("TNil",0,0));
MOVE(a_0,ATmakeAFun("TCons",2,0));
ENDPROC
PROC(_stratego_main)
Tset(ATmakeString("number-test"));
Tdupl();
Epushd(0,1);
MoveTop(0,1);
NotNULLd(0,1);
Tset(App2("TCons",App0("stderr"),App2("TCons",App2("Cons",ATmakeString("test suite: "),App2("Cons",Egetd(0,1),App0("Nil"))),App0("TNil"))));
Ccall(_stratego_s_5);
Epopd(0,1);
Tpop();
Ccall(_stratego_t_5);
Ccall(_stratego_y_5);
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);
}
PROCDECL(_stratego_a_4);
PROCDECL(_stratego_b_4);
PROCDECL(_stratego_c_4);
PROCDECL(_stratego_d_4);
PROCDECL(_stratego_e_4);
PROCDECL(_stratego_f_4);
PROCDECL(_stratego_g_4);
PROCDECL(_stratego_h_4);
PROCDECL(_stratego_i_4);
PROCDECL(_stratego_j_4);
PROCDECL(_stratego_k_4);
PROCDECL(_stratego_l_4);
PROCDECL(_stratego_m_4);
PROC(_stratego_init_afuns)
MOVE(c_10,ATmakeAFun("Runtime",1,0));
MOVE(t_9,ATmakeAFun("Silent",0,0));
MOVE(f_9,ATmakeAFun("Binary",0,0));
MOVE(t_8,ATmakeAFun("Output",1,0));
MOVE(f_8,ATmakeAFun("Input",1,0));
MOVE(t_7,ATmakeAFun("Program",1,0));
MOVE(e_7,ATmakeAFun("Help",0,0));
MOVE(z_6,ATmakeAFun("Undefined",1,0));
MOVE(z_0,ATmakeAFun("Nil",0,0));
MOVE(v_0,ATmakeAFun("TNil",0,0));
MOVE(s_0,ATmakeAFun("TCons",2,0));
MOVE(e_0,ATmakeAFun("Cons",2,0));
ENDPROC
PROC(_stratego_main)
Cpush(b_0);
PROCDECL(_stratego_main);
PROCDECL(_stratego_l_16);
PROCDECL(_stratego_m_16);
PROCDECL(_stratego_n_16);
PROCDECL(_stratego_o_16);
PROCDECL(_stratego_p_16);
PROCDECL(_stratego_q_16);
PROCDECL(_stratego_r_16);
PROCDECL(_stratego_u_16);
PROCDECL(_stratego_v_16);
PROCDECL(_stratego_z_16);
PROCDECL(_stratego_a_17);
PROCDECL(_stratego_e_17);
PROC(_stratego_init_afuns)
MOVE(h_10,ATmakeAFun("Nil",0,0));
MOVE(t_1,ATmakeAFun("Imports",1,0));
MOVE(i_1,ATmakeAFun("Module",2,0));
MOVE(p_0,ATmakeAFun("Cons",2,0));
MOVE(g_0,ATmakeAFun("TNil",0,0));
MOVE(f_0,ATmakeAFun("TCons",2,0));
ENDPROC
PROC(_stratego_main)
Cpush(b_0);
Epushd(0,1);
Tset(App0("stdin"));
Ccall(_stratego_l_16);
Ccall(_stratego_r_16);
MoveTop(0,1);
NotNULLd(0,1);
int CSwriteString(CompressedStream *cs, char *str){
return HFencodeATerm(cs->bs, &cs->tree, (ATerm)ATmakeAppl(ATmakeAFun(str,0,ATtrue)));
}
PROCDECL(_stratego_a_4);
PROCDECL(_stratego_b_4);
PROCDECL(_stratego_c_4);
PROCDECL(_stratego_d_4);
PROCDECL(_stratego_e_4);
PROCDECL(_stratego_f_4);
PROCDECL(_stratego_g_4);
PROCDECL(_stratego_h_4);
PROCDECL(_stratego_i_4);
PROCDECL(_stratego_j_4);
PROCDECL(_stratego_k_4);
PROCDECL(_stratego_l_4);
PROCDECL(_stratego_m_4);
PROC(_stratego_init_afuns)
MOVE(q_10,ATmakeAFun("Runtime",1,0));
MOVE(h_10,ATmakeAFun("Silent",0,0));
MOVE(t_9,ATmakeAFun("Binary",0,0));
MOVE(h_9,ATmakeAFun("Output",1,0));
MOVE(t_8,ATmakeAFun("Input",1,0));
MOVE(h_8,ATmakeAFun("Program",1,0));
MOVE(s_7,ATmakeAFun("Help",0,0));
MOVE(n_7,ATmakeAFun("Undefined",1,0));
MOVE(z_0,ATmakeAFun("TNil",0,0));
MOVE(v_0,ATmakeAFun("Nil",0,0));
MOVE(p_0,ATmakeAFun("TCons",2,0));
MOVE(a_0,ATmakeAFun("Cons",2,0));
ENDPROC
PROC(_stratego_main)
TestFunTop(a_0);
PROCDECL(_stratego_m_22);
PROCDECL(_stratego_n_22);
PROCDECL(_stratego_q_22);
PROCDECL(_stratego_r_22);
PROCDECL(_stratego_s_22);
PROCDECL(_stratego_t_22);
PROCDECL(_stratego_u_22);
PROCDECL(_stratego_x_22);
PROCDECL(_stratego_y_22);
PROCDECL(_stratego_z_22);
PROCDECL(_stratego_a_23);
PROCDECL(_stratego_b_23);
PROCDECL(_stratego_c_23);
PROC(_stratego_init_afuns)
MOVE(k_5,ATmakeAFun("H",2,0));
MOVE(e_2,ATmakeAFun("Nil",0,0));
MOVE(q_1,ATmakeAFun("Cons",2,0));
MOVE(b_1,ATmakeAFun("TNil",0,0));
MOVE(y_0,ATmakeAFun("TCons",2,0));
ENDPROC
PROC(_stratego_main)
Tset(ATmakeString("list-set-test"));
Tdupl();
Epushd(0,1);
MoveTop(0,1);
NotNULLd(0,1);
Tset(App2("TCons",App0("stderr"),App2("TCons",App2("Cons",ATmakeString("test suite: "),App2("Cons",Egetd(0,1),App0("Nil"))),App0("TNil"))));
Ccall(_stratego_d_22);
Epopd(0,1);
#include <stratego.h>
#include <stratego-lib.h>
#include <stratego-ext.h>
DOIT
VARDECL(AFun,z_0);
VARDECL(AFun,m_0);
VARDECL(AFun,h_0);
VARDECL(AFun,g_0);
PROC(_stratego_init_afuns)
MOVE(z_0,ATmakeAFun("B",0,0));
MOVE(m_0,ATmakeAFun("A",0,0));
MOVE(h_0,ATmakeAFun("G",2,0));
MOVE(g_0,ATmakeAFun("F",2,0));
ENDPROC
PROCDECL(_stratego_main);
PROCDECL(_stratego_i_0);
PROCDECL(_stratego_j_0);
PROCDECL(_stratego_k_0);
PROC(_stratego_main)
Tset(App2("F",App0("B"),App2("G",App0("A"),App0("C"))));
Ccall(_stratego_i_0);
Tset(App2("F",App0("B"),App2("G",App0("C"),App0("A"))));
Ccall(_stratego_i_0);
Tset(App2("F",App0("D"),App2("G",App0("D"),App0("A"))));
Ccall(_stratego_i_0);
Tset(App2("G",MakeInt(1),ATmakeString("a")));
Ccall(_stratego_i_0);
PROCDECL(_stratego_a_4);
PROCDECL(_stratego_b_4);
PROCDECL(_stratego_c_4);
PROCDECL(_stratego_d_4);
PROCDECL(_stratego_e_4);
PROCDECL(_stratego_f_4);
PROCDECL(_stratego_g_4);
PROCDECL(_stratego_h_4);
PROCDECL(_stratego_i_4);
PROCDECL(_stratego_j_4);
PROCDECL(_stratego_k_4);
PROCDECL(_stratego_l_4);
PROCDECL(_stratego_m_4);
PROC(_stratego_init_afuns)
MOVE(f_10,ATmakeAFun("Runtime",1,0));
MOVE(w_9,ATmakeAFun("Silent",0,0));
MOVE(i_9,ATmakeAFun("Binary",0,0));
MOVE(w_8,ATmakeAFun("Output",1,0));
MOVE(i_8,ATmakeAFun("Input",1,0));
MOVE(w_7,ATmakeAFun("Program",1,0));
MOVE(g_7,ATmakeAFun("Help",0,0));
MOVE(c_7,ATmakeAFun("Undefined",1,0));
MOVE(z_0,ATmakeAFun("Nil",0,0));
MOVE(v_0,ATmakeAFun("TNil",0,0));
MOVE(s_0,ATmakeAFun("A",0,0));
MOVE(p_0,ATmakeAFun("TCons",2,0));
MOVE(a_0,ATmakeAFun("Cons",2,0));
ENDPROC
PROC(_stratego_main)
PROCDECL(_stratego_g_5);
PROCDECL(_stratego_h_5);
PROCDECL(_stratego_i_5);
PROCDECL(_stratego_j_5);
PROCDECL(_stratego_k_5);
PROCDECL(_stratego_l_5);
PROCDECL(_stratego_m_5);
PROCDECL(_stratego_n_5);
PROCDECL(_stratego_o_5);
PROCDECL(_stratego_p_5);
PROCDECL(_stratego_q_5);
PROCDECL(_stratego_r_5);
PROCDECL(_stratego_s_5);
PROC(_stratego_init_afuns)
MOVE(k_14,ATmakeAFun("Not",1,0));
MOVE(g_13,ATmakeAFun("Or",2,0));
MOVE(a_13,ATmakeAFun("And",2,0));
MOVE(b_10,ATmakeAFun("Runtime",1,0));
MOVE(s_9,ATmakeAFun("Silent",0,0));
MOVE(b_9,ATmakeAFun("Binary",0,0));
MOVE(o_8,ATmakeAFun("Output",1,0));
MOVE(s_7,ATmakeAFun("Input",1,0));
MOVE(e_7,ATmakeAFun("Program",1,0));
MOVE(w_6,ATmakeAFun("Help",0,0));
MOVE(s_6,ATmakeAFun("Undefined",1,0));
MOVE(w_0,ATmakeAFun("Nil",0,0));
MOVE(s_0,ATmakeAFun("TNil",0,0));
MOVE(p_0,ATmakeAFun("TCons",2,0));
MOVE(a_0,ATmakeAFun("Cons",2,0));
ENDPROC
ATTuple ATR_makeTuple(ATerm aterm1, ATerm aterm2) {
return (ATTuple)ATmakeAppl2(ATmakeAFun("", 2, ATfalse), aterm1, aterm2);
}
#include <stratego-ext.h>
VARDECL(AFun,v_0);
VARDECL(AFun,d_0);
PROCDECL(_stratego_main);
PROCDECL(_stratego_s_3);
PROCDECL(_stratego_t_3);
PROCDECL(_stratego_u_3);
PROCDECL(_stratego_v_3);
PROCDECL(_stratego_w_3);
PROCDECL(_stratego_x_3);
PROCDECL(_stratego_y_3);
PROCDECL(_stratego_z_3);
PROC(_stratego_init_afuns)
MOVE(v_0,ATmakeAFun("Nil",0,0));
MOVE(d_0,ATmakeAFun("Cons",2,0));
ENDPROC
PROC(_stratego_main)
Cpush(b_0);
Epushd(0,1);
Tset(App0("stdin"));
Ccall(_stratego_s_3);
TestFunTop(d_0);
TravInit();
OneNextSon();
Epushd(1,1);
MoveTop(1,1);
NotNULLd(1,1);
Tset(App1("Program",Egetd(1,1)));
