//unlike NodeBinaryOp, NodeBinaryOpCompare has a node type that's different from
// its nodes, where left and right nodes are casted to be the same.
bool NodeBinaryOpCompare::doBinaryOperationArray(s32 lslot, s32 rslot, u32 slots)
{
assert(0); //not implemented yet..TODO return bool.
UlamValue rtnUV;
UTI nuti = getNodeType(); //Bool, same array size as lhs/rhs
UTI luti = m_nodeLeft->getNodeType();
UTI ruti = m_nodeRight->getNodeType();
s32 arraysize = m_state.getArraySize(luti);
assert(arraysize = m_state.getArraySize(nuti)); //node is same array size as lhs/rhs
s32 bitsize = m_state.getBitSize(luti);
UTI scalartypidx = m_state.getUlamTypeAsScalar(luti);
PACKFIT packRtn = m_state.determinePackable(nuti);
if(WritePacked(packRtn))
{
// pack result too. (slot size known ahead of time)
rtnUV = UlamValue::makeAtom(nuti); //accumulate result here
}
// point to base array slots, packedness determines its 'pos'
UlamValue lArrayPtr = UlamValue::makePtr(lslot, EVALRETURN, luti, packRtn, m_state);
UlamValue rArrayPtr = UlamValue::makePtr(rslot, EVALRETURN, ruti, packRtn, m_state);
// to use incrementPtr(), 'pos' depends on packedness
UlamValue lp = UlamValue::makeScalarPtr(lArrayPtr, m_state);
UlamValue rp = UlamValue::makeScalarPtr(rArrayPtr, m_state);
//make immediate result for each element inside loop
for(s32 i = 0; i < arraysize; i++)
{
UlamValue luv = m_state.getPtrTarget(lp);
UlamValue ruv = m_state.getPtrTarget(rp);
u32 ldata = luv.getData(lp.getPtrPos(), bitsize); //'pos' doesn't vary for unpacked
u32 rdata = ruv.getData(rp.getPtrPos(), bitsize); //'pos' doesn't vary for unpacked
if(WritePacked(packRtn))
//use calc position where base [0] is furthest from the end.
appendBinaryOp(rtnUV, ldata, rdata, (BITSPERATOM-(bitsize * (arraysize - i))), bitsize);
else
{
rtnUV = makeImmediateBinaryOp(scalartypidx, ldata, rdata, bitsize);
//cp result UV to stack, -1 (first array element deepest) relative to current frame pointer
m_state.m_nodeEvalStack.storeUlamValueInSlot(rtnUV, -slots + i);
}
assert(lp.incrementPtr(m_state));
assert(rp.incrementPtr(m_state));
} //forloop
if(WritePacked(packRtn))
m_state.m_nodeEvalStack.storeUlamValueInSlot(rtnUV, -1); //store accumulated packed result
return false;
} //end dobinaryoparray
//for eval, want the value of the rhs
bool NodeMemberSelect::doBinaryOperation(s32 lslot, s32 rslot, u32 slots)
{
assert(slots);
//the return value of a function call, or value of a data member
UlamValue ruv = m_state.m_nodeEvalStack.loadUlamValueFromSlot(rslot);
UlamValue rtnUV;
UTI ruti = getNodeType();
PACKFIT packFit = m_state.determinePackable(ruti);
if(m_state.isScalar(ruti) || WritePacked(packFit))
{
rtnUV = ruv;
}
else
{
//make a ptr to an unpacked array, base[0] ? [pls test]
rtnUV = UlamValue::makePtr(rslot, EVALRETURN, ruti, UNPACKED, m_state);
}
if((rtnUV.getUlamValueTypeIdx() == Nav) || (ruti == Nav))
return false;
if((rtnUV.getUlamValueTypeIdx() == Hzy) || (ruti == Hzy))
return false;
//copy result UV to stack, -1 relative to current frame pointer
Node::assignReturnValueToStack(rtnUV);
return true;
} //doBinaryOperation
void UlamTypePrimitive::genUlamTypeAutoWriteDefinitionForC(File * fp)
{
//scalar and entire PACKEDLOADABLE array handled by base class write method
if(!isScalar())
{
// writes an element of array
//3rd argument generated for compatibility with underlying method
m_state.indent(fp);
fp->write("void writeArrayItem(const ");
fp->write(getArrayItemTmpStorageTypeAsString().c_str()); //s32 or u32
fp->write("& v, const u32 index, const u32 itemlen) { ");
fp->write("UlamRef<EC>(");
fp->write("*this, index * itemlen, "); //rel offset
fp->write("itemlen, NULL, UlamRef<EC>::PRIMITIVE)."); //itemlen, primitive effself
fp->write(writeArrayItemMethodForCodeGen().c_str());
fp->write("(v); }"); GCNL;
}
if(isScalar() || WritePacked(getPackable()))
{
// write must be scalar; ref param to avoid excessive copying
//not an array
m_state.indent(fp);
fp->write("void");
fp->write(" write(const ");
fp->write(getTmpStorageTypeAsString().c_str()); //u32, u64, or BV96
fp->write("& targ) { UlamRef<EC>::");
fp->write(writeMethodForCodeGen().c_str());
fp->write("(targ); /* entire */ }"); GCNL;
}
} //genUlamTypeAutoWriteDefinitionForC
void UlamTypePrimitive::genUlamTypeAutoReadDefinitionForC(File * fp)
{
//scalar and entire PACKEDLOADABLE array handled by base class read method
if(!isScalar())
{
//reads an item of array;
//2nd argument generated for compatibility with underlying method
m_state.indent(fp);
fp->write("const ");
fp->write(getArrayItemTmpStorageTypeAsString().c_str()); //s32 or u32
fp->write(" readArrayItem(");
fp->write("const u32 index, const u32 itemlen) const { return ");
fp->write("UlamRef<EC>(");
fp->write("*this, index * itemlen, "); //rel offset
fp->write("itemlen, NULL, UlamRef<EC>::PRIMITIVE)."); //itemlen, primitive effself
fp->write(readArrayItemMethodForCodeGen().c_str());
fp->write("(); }"); GCNL;
}
if(isScalar() || WritePacked(getPackable()))
{
// write must be scalar; ref param to avoid excessive copying
//not an array
m_state.indent(fp);
fp->write("const ");
fp->write(getTmpStorageTypeAsString().c_str()); //u32, u64, or BV96
fp->write(" read() const { ");
fp->write("return ");
fp->write("UlamRef<EC>::");
fp->write(readMethodForCodeGen().c_str()); //just the guts
fp->write("(); /* entire */ }"); GCNL;
}
} //genUlamTypeAutoReadDefinitionForC
// replaces NodeVarDecl:printPostfix to learn the values of Class' storage in center site
void SymbolVariableDataMember::printPostfixValuesOfVariableDeclarations(File * fp, s32 slot, u32 startpos, ULAMCLASSTYPE classtype)
{
UTI vuti = getUlamTypeIdx();
UlamKeyTypeSignature vkey = m_state.getUlamKeyTypeSignatureByIndex(vuti);
UlamType * vut = m_state.getUlamTypeByIndex(vuti);
ULAMCLASSTYPE vclasstype = vut->getUlamClassType();
ULAMTYPE vetyp = vut->getUlamTypeEnum();
fp->write(" ");
if(vclasstype == UC_NOTACLASS)
fp->write(vkey.getUlamKeyTypeSignatureNameAndBitSize(&m_state).c_str());
else
fp->write(vut->getUlamTypeNameBrief().c_str());
fp->write(" ");
fp->write(m_state.m_pool.getDataAsString(getId()).c_str());
s32 arraysize = m_state.getArraySize(vuti);
//scalar has 'size=1'; empty array [0] is still '0'.
s32 size = (arraysize > NONARRAYSIZE ? arraysize : 1);
//output the arraysize (optional), and open paren
if(arraysize > NONARRAYSIZE)
{
fp->write("[");
fp->write_decimal(arraysize);
fp->write("]");
}
else if(arraysize == UNKNOWNSIZE)
{
fp->write("[UNKNOWN]");
}
fp->write("(");
if(vclasstype == UC_QUARK)
{
//outputs the data members, not just the lump value (e.g. SWV::printPostfixValue())
UTI scalarquark = m_state.getUlamTypeAsScalar(vuti);
//printPostfixValuesForClass:
SymbolClass * csym = NULL;
AssertBool isDefined = m_state.alreadyDefinedSymbolClass(scalarquark, csym);
assert(isDefined);
NodeBlockClass * classNode = csym->getClassBlockNode();
assert(classNode);
u32 newstartpos = startpos + getPosOffset();
s32 len = vut->getBitSize();
for(s32 i = 0; i < size; i++)
classNode->printPostfixDataMembersSymbols(fp, slot, newstartpos + len * i, vclasstype);
}
else
{
PACKFIT packFit = m_state.determinePackable(vuti);
assert(WritePacked(packFit)); //has to be to fit in an atom/site;
char * valstr = new char[size * 8 + MAXBITSPERLONG]; //was 32
if(size > 0)
{
//build the string of values (for both scalar and packed array)
UlamValue arrayPtr = UlamValue::makePtr(slot, EVENTWINDOW, vuti, packFit, m_state, startpos + getPosOffset(), getId());
UlamValue nextPtr = UlamValue::makeScalarPtr(arrayPtr, m_state);
UlamValue atval = m_state.getPtrTarget(nextPtr);
s32 len = m_state.getBitSize(vuti);
if(len == UNKNOWNSIZE)
{
sprintf(valstr,"unknown");
for(s32 i = 1; i < size; i++)
{
strcat(valstr,", unknown");
}
}
else if(len <= MAXBITSPERINT)
{
u32 data = atval.getDataFromAtom(nextPtr, m_state);
vut->getDataAsString(data, valstr, 'z'); //'z' -> no preceeding ','
if(vetyp == Unsigned || vetyp == Unary)
strcat(valstr, "u");
for(s32 i = 1; i < size; i++)
{
char tmpstr[8];
AssertBool isNext = nextPtr.incrementPtr(m_state);
assert(isNext);
atval = m_state.getPtrTarget(nextPtr);
data = atval.getDataFromAtom(nextPtr, m_state);
vut->getDataAsString(data, tmpstr, ',');
if(vetyp == Unsigned || vetyp == Unary)
strcat(tmpstr, "u");
strcat(valstr,tmpstr);
}
}
else if(len <= MAXBITSPERLONG)
{
u64 data = atval.getDataLongFromAtom(nextPtr, m_state);
vut->getDataLongAsString(data, valstr, 'z'); //'z' -> no preceeding ','
if(vetyp == Unsigned || vetyp == Unary)
strcat(valstr, "u");
for(s32 i = 1; i < size; i++)
{
char tmpstr[8];
AssertBool isNext = nextPtr.incrementPtr(m_state);
assert(isNext);
atval = m_state.getPtrTarget(nextPtr);
data = atval.getDataLongFromAtom(nextPtr, m_state);
vut->getDataLongAsString(data, tmpstr, ',');
if(vetyp == Unsigned || vetyp == Unary)
strcat(tmpstr, "u");
strcat(valstr,tmpstr);
}
}
else
assert(0);
} //end arrays > 0, and scalar
else
{
sprintf(valstr," ");
}
fp->write(valstr); //results out here!
delete [] valstr;
} //not a quark
fp->write("); ");
} //printPostfixValuesOfVariableDeclarations
// replaces NodeVarDecl:printPostfix to learn the values of Class' storage in center site
void SymbolVariableDataMember::printPostfixValuesOfVariableDeclarations(File * fp, s32 slot, u32 startpos, ULAMCLASSTYPE classtype)
{
UTI vuti = getUlamTypeIdx();
UlamKeyTypeSignature vkey = m_state.getUlamKeyTypeSignatureByIndex(vuti);
UlamType * vut = m_state.getUlamTypeByIndex(vuti);
ULAMCLASSTYPE vclasstype = vut->getUlamClass();
fp->write(" ");
if(vclasstype == UC_NOTACLASS)
fp->write(vkey.getUlamKeyTypeSignatureNameAndBitSize(&m_state).c_str());
else
fp->write(vut->getUlamTypeNameBrief().c_str());
fp->write(" ");
fp->write(m_state.m_pool.getDataAsString(getId()).c_str());
s32 arraysize = m_state.getArraySize(vuti);
//scalar has 'size=1'; empty array [0] is still '0'.
s32 size = (arraysize > NONARRAYSIZE ? arraysize : 1);
//output the arraysize (optional), and open paren
if(arraysize > NONARRAYSIZE)
{
fp->write("[");
fp->write_decimal(arraysize);
fp->write("]");
}
else if(arraysize == UNKNOWNSIZE)
{
fp->write("[UNKNOWN]");
}
fp->write("(");
if(vclasstype == UC_QUARK)
{
//printPostfixValuesForClass:
SymbolClass * csym = NULL;
if(m_state.alreadyDefinedSymbolClass(vuti, csym))
{
NodeBlockClass * classNode = csym->getClassBlockNode();
assert(classNode);
SymbolTable * stptr = classNode->getSymbolTablePtr(); //ST of data members
u32 newstartpos = startpos + getPosOffset();
s32 len = vut->getBitSize();
for(s32 i = 0; i < size; i++)
stptr->printPostfixValuesForTableOfVariableDataMembers(fp, slot, newstartpos + len * i, vclasstype);
}
else
{
assert(0); //error!
}
}
else
{
PACKFIT packFit = m_state.determinePackable(vuti);
assert(WritePacked(packFit)); //has to be to fit in an atom/site;
char * valstr = new char[size * 8 + MAXBITSPERLONG]; //was 32
if(size > 0)
{
//simplifying assumption for testing purposes: center site
//Coord c0(0,0);
//u32 slot = c0.convertCoordToIndex();
//build the string of values (for both scalar and packed array)
UlamValue arrayPtr = UlamValue::makePtr(slot, EVENTWINDOW, vuti, packFit, m_state, startpos + getPosOffset(), getId());
UlamValue nextPtr = UlamValue::makeScalarPtr(arrayPtr, m_state);
UlamValue atval = m_state.getPtrTarget(nextPtr);
s32 len = nextPtr.getPtrLen();
assert(len != UNKNOWNSIZE);
if(len <= MAXBITSPERINT)
{
u32 data = atval.getDataFromAtom(nextPtr, m_state);
vut->getDataAsString(data, valstr, 'z'); //'z' -> no preceeding ','
for(s32 i = 1; i < size; i++)
{
char tmpstr[8];
assert(nextPtr.incrementPtr(m_state));
atval = m_state.getPtrTarget(nextPtr);
data = atval.getDataFromAtom(nextPtr, m_state);
vut->getDataAsString(data, tmpstr, ',');
strcat(valstr,tmpstr);
}
}
else if(len <= MAXBITSPERLONG)
{
u64 data = atval.getDataLongFromAtom(nextPtr, m_state);
vut->getDataLongAsString(data, valstr, 'z'); //'z' -> no preceeding ','
for(s32 i = 1; i < size; i++)
{
char tmpstr[8];
assert(nextPtr.incrementPtr(m_state));
atval = m_state.getPtrTarget(nextPtr);
data = atval.getDataLongFromAtom(nextPtr, m_state);
vut->getDataLongAsString(data, tmpstr, ',');
strcat(valstr,tmpstr);
}
}
else
assert(0);
} //end arrays > 0, and scalar
else
{
sprintf(valstr," ");
}
fp->write(valstr); //results out here!
delete [] valstr;
} //not a quark
fp->write("); ");
} //printPostfixValuesOfVariableDeclarations
