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