void
Signature::make(IdentList &idents)
{
size = idents.size();
int *tab1 = new int[size];
int *tab2 = new int[size];
IdentList::iterator i;
unsigned int x,y,s;
for (i = idents.begin(), x = 0;
i != idents.end(); i++, x++)
tab1[x] = tab2[x] = offsets.off(*i);
qsort((int *) tab2, size, sizeof(int), sortcmp);
sign = new int[size];
hashvalue = 0;
for (x = 0; x < size; x++) {
for (y = 0, s = 0; tab2[y] != tab1[x]; y++)
if (y < size && tab2[y] != tab2[y+1])
s++;
sign[x] = s;
hashvalue = hashvalue*x+sign[x];
}
delete[] tab1;
delete[] tab2;
}
ASTForm* FullAntiPrenexer::nonDistributiveRule(QuantifierClass *qForm) {
static_assert(std::is_base_of<ASTForm_q, QuantifierClass>::value, "QuantifierClass is not derived from 'ASTForm_q' class");
static_assert(std::is_base_of<ASTForm_ff, BinopClass>::value, "BinopClass is not derived from 'ASTForm_ff' class");
// Ex . f1 op f2 -> (Ex X. f1) op f2
// Ex . f2 op f2 -> f1 op (Ex X. f2)
BinopClass *binopForm = static_cast<BinopClass*>(qForm->f);
ASTForm *tempResult;
IdentList *bound = qForm->vl;
IdentList left, right, middle;
IdentList free1, bound1;
IdentList free2, bound2;
binopForm->f1->freeVars(&free1, &bound1);
binopForm->f2->freeVars(&free2, &bound2);
for (auto var = bound->begin(); var != bound->end(); ++var) {
bool varInLeft = free1.exists(*var);
bool varInRight = free2.exists(*var);
// Ex var. f1 op f2 | var in f1 && var in f2
if (varInLeft && varInRight) {
middle.push_back(*var);
// (Ex var. f1) op f2 | var notin f2
} else if(varInLeft) {
left.push_back(*var);
// f1 op (Ex var. f2) | var notin f1
} else if(varInRight) {
right.push_back(*var);
} // f1 op f2 | var notin f1 && var notin f2
}
qForm->f = nullptr;
delete qForm;
if(!left.empty()) {
tempResult = new QuantifierClass(nullptr, new IdentList(left), binopForm->f1, binopForm->f1->pos);
binopForm->f1 = static_cast<ASTForm*>(tempResult->accept(*this));
}
if(!right.empty()) {
tempResult = new QuantifierClass(nullptr, new IdentList(right), binopForm->f2, binopForm->f2->pos);
binopForm->f2 = static_cast<ASTForm*>(tempResult->accept(*this));
}
if(!middle.empty()) {
tempResult = new QuantifierClass(nullptr, new IdentList(middle), binopForm, binopForm->pos);
return tempResult;
} else {
return binopForm;
}
}
/**
* Adds constraints for first-order variables to be singletons, i.e. contain
* only one element
*
* @return: restricted formula
*/
ASTForm* ASTForm::restrictFormula() {
ASTForm* restrictedFormula = this;
// For all used first-order variables FirstOrder(x) is appended to formulae
IdentList free, bound;
ASTForm_FirstOrder* singleton;
this->freeVars(&free, &bound);
IdentList *allVars = ident_union(&free, &bound);
if (allVars != 0) {
Ident* it = allVars->begin();
while(it != allVars->end()) {
// only variables that are not already singletoned are appended to formula
if (symbolTable.lookupType(*it) == Varname1) {
singleton = new ASTForm_FirstOrder(new ASTTerm1_Var1((*it), Pos()), Pos());
restrictedFormula = new ASTForm_And(singleton, restrictedFormula, Pos());
}
++it;
}
}
return restrictedFormula;
}
void
MonaUntypedAST::makeGTAGuide()
{
IdentList *univs = symbolTable.allUnivs();
if (numTypes > 0) {
// convert types to guide
if (!univs || univs->empty()) {
cout << "Error: Types declared but no universes (or trees)\n"
<< "Execution aborted\n";
exit(-1);
}
if (univs->size() == 1) {
// boolean and universe state space must be different
Name name = Name("<dummy>", dummyPos);
symbolTable.insertUniv(&name, NULL, true);
delete univs;
univs = symbolTable.allUnivs();
}
guide_declaration = new Guide_Declaration(new GuideFuncList, dummyPos);
typedUnivs2guide(univs->size(), univs, 0, "");
}
if (guide_declaration) { // guide is declared
/*#warning NOT REQUIRING UNIVERSES*/
/*
if (!univs || univs->empty()) {
cout << "Error: Guide declared but no universes\n"
<< "Execution aborted\n";
exit(-1);
}
*/
// fill tables
unsigned numUnivs = univs->size();
char **univPos = (char **) mem_alloc(sizeof(char *)*numUnivs);
char **univName = (char **) mem_alloc(sizeof(char *)*numUnivs);
IdentList::iterator id;
int i;
for (id = univs->begin(), i = 0; id != univs->end(); id++, i++) {
univName[i] = symbolTable.lookupSymbol(*id);
univPos[i] = symbolTable.lookupPos(*id);
}
unsigned numSs = guide_declaration->funcList->size();
SsId *muLeft = (SsId *) mem_alloc(sizeof(SsId)*numSs);
SsId *muRight = (SsId *) mem_alloc(sizeof(SsId)*numSs);
char **ssName = (char **) mem_alloc(sizeof(char *)*numSs);
SsKind *ssKind = 0;
int *ssType = 0;
if (numTypes > 0) {
ssKind = (SsKind *) mem_alloc(sizeof(SsKind)*numSs);
ssType = (int *) mem_alloc(sizeof(int)*numSs);
}
GuideFuncList::iterator g;
for (g = guide_declaration->funcList->begin(), i = 0;
g != guide_declaration->funcList->end(); g++, i++) {
muLeft[i] = symbolTable.lookupNumber((*g)->name2);
muRight[i] = symbolTable.lookupNumber((*g)->name3);
ssName[i] = (*g)->name1->str;
if (numTypes > 0) {
switch((*g)->kind) {
case SS_UNIVHAT:
ssKind[i] = gtaSSUNIVHAT;
break;
case SS_ORHAT:
ssKind[i] = gtaSSORHAT;
break;
case SS_ORLEAF:
ssKind[i] = gtaSSORLEAF;
break;
case SS_AND:
ssKind[i] = gtaSSAND;
break;
case SS_DUMMY:
ssKind[i] = gtaSSDUMMY;
break;
default: ;
}
Ident sstype =
symbolTable.lookupSSType(symbolTable.lookupIdent((*g)->name1));
if (sstype != -1) {
char *sstypename = symbolTable.lookupSymbol(sstype);
int j;
for (j = 0; j < numTypes; j++)
if (treetypes[j].name == sstypename) {
ssType[i] = j;
break;
}
invariant(j < numTypes);
}
else
ssType[i] = -1;
}
}
makeGuide(numSs, muLeft, muRight, ssName, numUnivs,
univPos, univName, ssType, ssKind);
if (!checkDisjoint()) {
cout << "Illegal guide and universe declarations:\n"
<< "Universes must have disjoint state spaces\n"
<< "Execution aborted\n";
exit(-1);
}
if (!checkAllUsed()) {
cout << "Illegal guide and universe declarations:\n"
<< "All state spaces must be reachable\n"
<< "Execution aborted\n";
exit(-1);
}
if (!checkAllCovered()) {
cout << "Illegal guide and universe declarations:\n"
<< "Every infinite path in the guide must belong to a universe\n"
<< "Execution aborted\n";
exit(-1);
}
}
else { // no guide declared, make default
if (!univs || univs->empty()) {
// make one universe
Name name = Name("<univ>", dummyPos);
symbolTable.insertUniv(&name, (char *) NULL);
delete univs;
univs = symbolTable.allUnivs();
}
if (univs->size() == 1) {
// boolean and universe state space must be different
Name name = Name("<dummy>", dummyPos);
symbolTable.insertUniv(&name, NULL, true);
delete univs;
univs = symbolTable.allUnivs();
}
// fill name table
unsigned numUnivs = univs->size();
char **univName = (char **) mem_alloc(sizeof(char *)*numUnivs);
Ident *id;
int u;
for (id = univs->begin(), u = 0; id != univs->end(); id++, u++)
univName[u] = symbolTable.lookupSymbol(*id);
makeDefaultGuide(numUnivs, univName);
}
delete univs;
}
