// free and clear
void FreeL(void *mal){
if(!globalInitDebug)
InitDebug();
memInfo memS;
memInfo *mem = &memS;
mem->loc = mal;
memInfo *retMem = removeSkip(globalMemHolder,mem);
assert(retMem,"Illegal Free");
char *retMal = retMem->loc;
int size = retMem->size;
assertBool((retMal==mal),"Mal Incorrect");
// clear out memory
int i;
for(i=0;i<size;i++)
retMal[i] = 0x58;
// doesn't really free the memory to make sure that if
// it is called, the result will be that it was freed (0x58)
Free(retMem);
}
void testBools( void ) {
int num_configs = 6;
XPPCItem *configs = XPPCInit( num_configs );
/*
here's a bool
0
here's another bool
1
*/
/* for bools we'll test that real bools are read correctly and that
* ints read as bools fail as expected to the defaults */
bool one = true,
two = false,
three = true,
four = false,
five = true,
six = false;
configs[0].type = XPPC_TYPE_BOOLEAN;
configs[0].key = "here's a bool";
configs[0].ref = &one;
configs[1].type = XPPC_TYPE_BOOLEAN;
configs[1].key = "here's another bool";
configs[1].ref = &two;
configs[2].type = XPPC_TYPE_BOOLEAN;
configs[2].key = "neg int";
configs[2].ref = &three;
configs[3].type = XPPC_TYPE_BOOLEAN;
configs[3].key = "pos int";
configs[3].ref = &four;
configs[4].type = XPPC_TYPE_BOOLEAN;
configs[4].key = "pos int2";
configs[4].ref = &five;
configs[5].type = XPPC_TYPE_BOOLEAN;
configs[5].key = "neg int2";
configs[5].ref = &six;
XPPCParseConfigFile( "./test_conf.txt", configs, num_configs );
printf( "\ntesting bools....\n" );
assertBool( one, false );
assertBool( two, true );
assertBool( three, true );
assertBool( four, false );
assertBool( five, true );
assertBool( six, false );
}
// 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;
}
int main()
{
SystemInit();
const Ec1 g1(-1, 1);
const Ec2 g2(
Fp2(Fp(g2c.aa), Fp(g2c.ab)),
Fp2(Fp(g2c.ba), Fp(g2c.bb))
);
// assertBool g2 and g1 on curve
assertBool("g1 is on EC", g1.isValid());
assertBool("g2 is on twist EC", g2.isValid());
puts("order of group");
const Mpz& r = GetParamR();
PUT(r);
{
Ec1 t = g1;
t.mul(r);
assertBool("orgder of g1 == r", t.isZero());
}
{
Ec2 t = g2;
t.mul(r);
assertBool("order of g2 == r", t.isZero());
}
const Mpz a("123456789012345");
const Mpz b("998752342342342342424242421");
// scalar-multiplication sample
{
Mpz c = a;
c.add(b);
Ec1 Pa = g1; Pa.mul(a);
Ec1 Pb = g1; Pb.mul(b);
Ec1 Pc = g1; Pc.mul(c);
Ec1 out = Pa;
out.add(Pb);
assertEqual("check g1 * c = g1 * a + g1 * b", Pc, out);
}
Fp12 e;
// calc e : G2 x G1 -> G3 pairing
e.pairing(g2, g1); // e = e(g2, g1)
PUT(e);
{
Fp12 t = e;
t.power(r);
assertEqual("order of e == r", t, Fp12(1));
}
Ec2 g2a = g2;
g2a.mul(a);
Fp12 ea1;
ea1.pairing(g2a, g1);
Fp12 ea2 = e;
ea2.power(a); // ea2 = e^a
assertEqual("e(g2 * a, g1) = e(g2, g1)^a", ea1, ea2);
Ec1 g1b = g1;
g1b.mul(b);
Fp12 eb1;
eb1.pairing(g2, g1b); // eb1 = e(g2, g1b)
Fp12 eb2 = e;
eb2.power(b); // eb2 = e^b
assertEqual("e(g2a, g1 * b) = e(g2, g1)^b", eb1, eb2);
Ec1 q1 = g1;
q1.mul(12345);
assertBool("q1 is on EC", q1.isValid());
Fp12 e1, e2;
e1.pairing(g2, g1); // e1 = e(g2, g1)
e2.pairing(g2, q1); // e2 = e(g2, q1)
Ec1 q2 = g1;
q2.add(q1);
e.pairing(g2, q2); // e = e(g2, q2)
e1.mul(e2);
assertEqual("e = e1 * e2", e, e1);
/*
reduce one copy as the following
*/
g2a = g2;
g2a.mul(a);
g1b = g1;
g1b.mul(b);
Ec2 g2at = g2; g2at.mul(a);
Ec1 g1bt = g1; g1bt.mul(b);
assertEqual("g2a == g2 * a", g2a, g2at);
assertEqual("g1b == g1 * b", g1b, g1bt);
printf("errNum = %d\n", errNum);
}
// for all distinct variables
void allDifClauses(rootData *rdata,indexList *varList,linkedList clauseList){
int n,c,s,x,y;
linkedList allDifNodes = rdata->allDifNodes;
int allDifWidth = sizeLinked(allDifNodes);
treeNode **allDifArray = toArrayLinked(allDifNodes);
for(n=0;n<numStagesGlobal;n++){
for(c=0;c<allDifWidth;c++){
treeNode *allDifNode = allDifArray[c];
nameData *allDifData = allDifNode->data;
nodeStages *stages = allDifNode->stages;
if(stages != NULL){
// stages are inclusive between start and end for both
int start = stages->start;
int end = stages->end;
if(n < start || n > end)
continue;
}
setData *allDifSet = allDifData->set;
manyData **many = allDifSet->setVars;
int height = allDifSet->height;
int width = allDifSet->width;
if(width == 0)
return;
// these should all have the same symlist
manyData *manyThis = many[0];
linkedList symList = manyThis->symList;
int symWidth = sizeLinked(symList);
int **symArray = toArrayLinked(symList);
for(s=0;s<symWidth;s++){
int symId = *symArray[s];
// must be exactly one
linkedList singleVars = createLinked(Malloc,Free);
int numCells = 0;
for(y=0;y<height;y++){
for(x=0;x<width;x++){
manyThis = many[width*y+x];
// may not have rectangle shape
if(!manyThis)
continue;
assertBool(manyThis->symList == symList,"SymList Did Not Match.");
linkedList brackVars = manyThis->brackVars;
int *boardCellP = peekLinked(brackVars);
int boardCell = *boardCellP;
varData *v = getSymCellVarByName(varList,boardCell,symId,n);
assert(v,"AllDif Variable Not Found.");
addTailLinked(singleVars,v);
numCells++;
}
}
atMostOne(singleVars,clauseList);
if(numCells == symWidth)
atLeastOne(singleVars,clauseList);
destroyLinked(singleVars,NULL);
}
}
}
}
// this forces the cell to remain the same when cellUsedStageN=>N+1 is not set
void usedClauses(rootData *rdata,indexList *varList,linkedList clauseList,linkedList fullTransNodes){
int i,n;
linkedList clause;
clauseVarData *clauseVar;
// board
treeNode *boardNode = rdata->boardNode;
setData *boardSet = boardNode->data;
int boardWidth = boardSet->width;
int boardHeight = boardSet->height;
cellData **boardVars = boardSet->setVars;
int boardX, boardY;
// 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 *cell = boardVars[boardY*boardWidth+boardX];
linkedList symList = cell->symList;
int symWidth = sizeLinked(symList);
int **symArray = toArrayLinked(symList);
for(n=0;n<numStagesGlobal-1;n++){
varData *used = getUsedVar(varList,boardX,boardY,n);
assert(used,"No Used\n");
for(i=0;i<symWidth;i++){
int sym = *symArray[i];
// empty transitions
// boardCell0UsedStageN=>N+1 OR NOT boardCell0IsSym0StageN OR boardCell0IsSym0StageN+1
// and reverse
varData *scv0 = getSymCellVar(varList,boardX,boardY,sym,n);
assert(scv0,"No SCV0\n");
varData *scv1 = getSymCellVar(varList,boardX,boardY,sym,n+1);
assert(scv1,"No SCV1\n");
clause = createLinked(Malloc,Free);
clauseVar = createClauseVar(used,0);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(scv0,1);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(scv1,0);
addTailLinked(clause,clauseVar);
assertBool(sizeLinked(clause) != 0,"Empty Clause Used");
addClause(clauseList,clause);
clause = createLinked(Malloc,Free);
clauseVar = createClauseVar(used,0);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(scv1,1);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(scv0,0);
addTailLinked(clause,clauseVar);
assertBool(sizeLinked(clause) != 0,"Empty Clause Used");
addClause(clauseList,clause);
}
}
}
}
}
// 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);
}
}
}
}
