// add to general linkedlist and as a value
varData *createGenVarSet(indexList *varList,varType type,int *vals,int size,int value){
indexList *indList = varList;
linkedList fullList = indList->fullList;
int *var = Malloc(sizeof(int)*size);
int n;
for(n=0;n<size;n++)
var[n] = vals[n];
varData *vdat = Malloc(sizeof(varData));
if(!value){
vdat->value = indList->numVar + 1;
indList->numVar++;
}
else{
vdat->value = value;
}
vdat->type = type;
vdat->data = var;
vdat->size = size;
// add as value
int valsForVal[] = {unknownVarType,vdat->value};
createGenInd(varList,vdat,valsForVal,2);
pushLinked(fullList,vdat);
return vdat;
}
treeNode *setNode(int tok,treeNode *var,treeNode *set){
if(!set){
startSetData *startData = Malloc(sizeof(startSetData));
startData->numLines = 1;
startData->maxWidth = 0;
startData->curWidth = 0;
startData->set = createLinked(Malloc,Free);
set = Malloc(sizeof(treeNode));
set->spaces = createLinked(Malloc,Free);
set->type = tempSetType;
set->data = startData;
}
startSetData *sd = set->data;
linkedList list = sd->set;
if(tok == SPACEVAR){
int *num = peekLinked(set->spaces);
*num = *num + 1;
return set;
}
if(tok == SEMI){
pushLinked(list,ENDLINE);
sd->numLines++;
sd->curWidth = 0;
}
sd->curWidth++;
if(sd->maxWidth < sd->curWidth)
sd->maxWidth = sd->curWidth;
void *data = var->data;
pushLinked(list,data);
Free(var);
// for space
int *num = Malloc(sizeof(int));
*num = 0;
pushLinked(set->spaces,num);
return set;
}
// create root at end of chain then build it up
treeNode *choiceNode(int tok,treeNode *choice,treeNode *root){
if(!root)
root = makeRoot();
rootData *data = root->data;
if(tok == TRANSFORM || tok == REQUIRE || tok == OPTION){
if(!choice->stages){
nodeStages *stages = Malloc(sizeof(nodeStages));
stages->start = 0;
stages->end = numStagesGlobal;
choice->stages = stages;
}
}
switch(tok){
case TRANSFORM: pushLinked(data->transNodes,choice); break;
case OBJECT: pushLinked(data->objNodes,choice); break;
case DESOBJECT: pushLinked(data->desObjNodes,choice); break;
case ALLDIF: pushLinked(data->allDifNodes,choice); break;
case REQUIRE: pushLinked(data->reqNodes,choice); break;
case OPTION: pushLinked(data->optNodes,choice); break;
default: assert(NULL,"Node Error");
}
return root;
}
// a trans must be created for each desObj that describes it because the board cells change for each desObj
linkedList expandTrans(rootData *rdata){
int i,j;
linkedList fullTransList = createLinked(Malloc,Free);
// trans
linkedList transNodes = rdata->transNodes;
int transWidth = sizeLinked(transNodes);
treeNode **transArray = toArrayLinked(transNodes);
// desObj
linkedList desObjNodes = rdata->desObjNodes;
int desObjWidth = sizeLinked(desObjNodes);
treeNode **desObjArray = toArrayLinked(desObjNodes);
for(i=0;i<transWidth;i++){
treeNode *trans = transArray[i];
transData *td = trans->data;
int transId = td->transId;
int transObjId = td->objId;
// collect all object descriptions with same object id as this transition
for(j=0;j<desObjWidth;j++){
treeNode *desObj = desObjArray[j];
nameData *objData = desObj->data;
int desObjId = objData->objId;
if(transObjId == desObjId){
tempTransVar *var = Malloc(sizeof(tempTransVar));
var->transId = transId;
var->startData = td->startData;
var->endData = td->endData;
var->objId = objData->objId;
var->desObjId = objData->nameId;
var->desObjSet = objData->set;
var->stages = trans->stages;
var->isSim = 0;
var->isLocked = 0;
if(trans->type == transSimType)
var->isSim = 1;
if(trans->type == transLockType)
var->isLocked = 1;
pushLinked(fullTransList,var);
}
}
}
return fullTransList;
}
int addSymbol(char *sym){
stringData *retSym = getLinked(symTableGlobal,findString,sym);
if(retSym)
return retSym->value;
int len = strlen(sym);
char *newStr = Malloc(sizeof(char)*(len+1));
strcpy(newStr,sym);
stringData *newSym = Malloc(sizeof(stringData));
int nextVar = sizeLinked(symTableGlobal)+1;
newSym->value = nextVar;
newSym->str = newStr;
pushLinked(symTableGlobal,newSym);
return nextVar;
}
// may need to create a treeNode to store elab
treeNode *setCommaNode(int tok,int varId,treeNode *varList){
if(tok == CHARVAR){
// assert no varlist
assertBool(varList == NULL,"Char VarList");
int *dataVar = Malloc(sizeof(int));
*dataVar = varId;
varList = Malloc(sizeof(treeNode));
varList->type = charType;
varList->data = dataVar;
return varList;
}
if(tok == MANYVAR){
if(!varList){
manyData *many = Malloc(sizeof(manyData));
linkedList brackVars = createLinked(Malloc,Free);
many->brackVars = brackVars;
varList = Malloc(sizeof(treeNode));
varList->type = manyType;
varList->data = many;
}
manyData *md = varList->data;
linkedList list = md->brackVars;
int *dataVar = Malloc(sizeof(int));
*dataVar = varId;
pushLinked(list,dataVar);
return varList;
}
if(tok == ELABVAR || tok == ELABNEG){
if(!varList){
elabData *elab = Malloc(sizeof(elabData));
linkedList negVars = createLinked(Malloc,Free);
linkedList posVars = createLinked(Malloc,Free);
elab->tempVarName = 0;
elab->isAny = 0;
elab->negVars = negVars;
elab->posVars = posVars;
varList = Malloc(sizeof(treeNode));
varList->type = elabType;
varList->data = elab;
}
elabData *ed = varList->data;
linkedList addToList;
if(tok == ELABNEG)
addToList = ed->negVars;
else
addToList = ed->posVars;
int *dataVar = Malloc(sizeof(int));
*dataVar = varId;
pushLinked(addToList,dataVar);
return varList;
}
// error
return NULL;
}
void reqOptClauses(rootData *rdata,indexList *varList,linkedList clauseList){
// req
reqOptClausesInit(reqType,rdata->reqNodes,rdata->desObjNodes,varList,clauseList,NULL);
// opt
linkedList optGroupList = createLinked(Malloc,Free);
reqOptClausesInit(optType,rdata->optNodes,rdata->desObjNodes,varList,clauseList,optGroupList);
// add that at least one of each opt group must be true
int optGroupSize = sizeLinked(optGroupList);
optGroup **optGroupArray = toArrayLinked(optGroupList);
// desObj
linkedList desObjNodes = rdata->desObjNodes;
int desObjSize = sizeLinked(desObjNodes);
treeNode **desObjArray = toArrayLinked(desObjNodes);
// at least one Opt-<Opt>-<Any Number>-DesObj-<DesObj>-Stage<Stage>
int n,i,c,x;
for(n=0;n<numStagesGlobal;n++){
for(x=0;x<optGroupSize;x++){
optGroup *optGroup = optGroupArray[x];
int optGroupObj = optGroup->objId;
int optGroupName = optGroup->nameId;
int optSize = sizeLinked(optGroup->list);
treeNode **optArray = toArrayLinked(optGroup->list);
for(c=0;c<desObjSize;c++){
treeNode *desObjNode = desObjArray[c];
nameData *desObjData = desObjNode->data;
int desObjName = desObjData->nameId;
int desObjObj = desObjData->objId;
if(desObjObj != optGroupObj)
continue;
linkedList atLeastList = createLinked(Malloc,Free);
for(i=0;i<optSize;i++){
treeNode *optNode = optArray[i];
// check if is valid at this stage
nodeStages *stages = optNode->stages;
if(n < stages->start || n > stages->end)
continue;
nameData *optData = optNode->data;
int optNum = optData->elabNum;
// if it was not created, it is not used and so is not needed in atLeastList
varData *opt = getOptVar(varList,optGroupName,optNum,desObjName,n);
if(!opt)
continue;
pushLinked(atLeastList,opt);
}
atLeastOne(atLeastList,clauseList);
destroyLinked(atLeastList,NULL);
}
}
}
optGroup *rem;
while((rem = popLinked(optGroupList))){
destroyLinked(rem->list,NULL);
Free(rem);
}
destroyLinked(optGroupList,NULL);
}
// this sets cellUsedStageN=>N+1 variables when that cell is used in that transition
void setUsedClauses(rootData *rdata,indexList *varList,linkedList clauseList,linkedList fullTransNodes){
int i,n;
linkedList clause;
clauseVarData *clauseVar;
// trans
int transWidth = sizeLinked(fullTransNodes);
tempTransVar **transArray = toArrayLinked(fullTransNodes);
// board
treeNode *boardNode = rdata->boardNode;
setData *boardSet = boardNode->data;
int boardWidth = boardSet->width;
int boardHeight = boardSet->height;
cellData **boardVars = boardSet->setVars;
int boardX, boardY;
int desObjX, desObjY;
// for each cellStage used-var
// find all transitions that use that cell, put it into the set
for(boardY=0;boardY<boardHeight;boardY++){
for(boardX=0;boardX<boardWidth;boardX++){
if(!boardVars[boardY*boardWidth+boardX])
continue;
cellData *boardCell = boardVars[boardY*boardWidth+boardX];
int boardCellName = boardCell->cellName;
for(n=0;n<numStagesGlobal-1;n++){
varData *used = getUsedVar(varList,boardX,boardY,n);
assert(used,"Used NULL");
// NOT cellUsedStageN=>N+1 OR tran1StageN=>N+1 OR tran2StageN=>N+1 OR ...
linkedList transListClause = createLinked(Malloc,Free);
// contains varData
// this is for saying at most one of these simultaneous trans that use this cell can be used
linkedList transSimAtMostList = createLinked(Malloc,Free);
// try to find it in trans
for(i=0;i<transWidth;i++){
tempTransVar *trans = transArray[i];
// if this trans does not occur at this stage, it is not included in list that would indicate cell is used
nodeStages *stages = trans->stages;
if(n < stages->start || n > stages->end)
continue;
varData *tv = getTransVar(varList,trans->transId,trans->desObjId,n);
assert(tv,"Trans NULL");
// true if the transition operates on board cell (boardX,boardY)
int transUsesBoardCell = 0;
// if it is the board, this x,y is used
setData *dos = trans->desObjSet;
manyData **desObjSet = dos->setVars;
int desObjHeight = dos->height;
int desObjWidth = dos->width;
for(desObjY=0;desObjY<desObjHeight;desObjY++){
for(desObjX=0;desObjX<desObjWidth;desObjX++){
if(!desObjSet[desObjY*desObjWidth + desObjX])
continue;
manyData *md = desObjSet[desObjY*desObjWidth + desObjX];
linkedList brackVars = md->brackVars;
int *objSymP = peekLinked(brackVars);
int desObjCellName = *objSymP;
if(boardCellName == desObjCellName){
transUsesBoardCell = 1;
}
}
}
// found board cell
if(transUsesBoardCell){
clause = createLinked(Malloc,Free);
clauseVar = createClauseVar(used,0);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(tv,1);
addTailLinked(clause,clauseVar);
assertBool(sizeLinked(clause) != 0,"Empty Clause Used");
addClause(clauseList,clause);
clauseVar = createClauseVar(tv,0);
addTailLinked(transListClause,clauseVar);
// if it is not a TransSim it is already in an at-most-one
if(trans->isSim){
// varData
addTailLinked(transSimAtMostList,tv);
}
}
}
// connect this trans to this used cell
clauseVar = createClauseVar(used,1);
pushLinked(transListClause,clauseVar);
addClause(clauseList,transListClause);
// for TransSim
atMostOne(transSimAtMostList,clauseList);
destroyLinked(transSimAtMostList,NULL);
}
}
}
}
