void UnpackedStorage::assignUlamValuePtr(UlamValue pluv, UlamValue puv)
{
assert(pluv.getPtrTargetType() == puv.getPtrTargetType());
s32 leftbaseslot = pluv.getPtrSlotIndex(); //even for scalars
m_values[leftbaseslot] = puv;
}
EvalStatus NodeVarRefAs::eval()
{
assert(m_varSymbol);
UTI nuti = getNodeType();
if(nuti == Nav)
return ERROR;
if(nuti == Hzy)
return NOTREADY;
assert(m_varSymbol->getUlamTypeIdx() == nuti);
assert(!m_state.isAtom(nuti)); //rhs type of conditional as/has can't be an atom
UlamValue pluv = m_state.m_currentAutoObjPtr;
((SymbolVariableStack *) m_varSymbol)->setAutoPtrForEval(pluv); //for future ident eval uses
UTI luti = pluv.getPtrTargetType();
assert(m_state.okUTItoContinue(luti));
UlamType * lut = m_state.getUlamTypeByIndex(luti);
ULAMCLASSTYPE lclasstype = lut->getUlamClassType();
UTI autostgtype = m_state.m_currentAutoStorageType;
if((UlamType::compare(autostgtype, UAtom, m_state) == UTIC_SAME) && (lclasstype == UC_ELEMENT))
autostgtype = luti; //e.g. funccall expects a class, not an atom (t3636)
((SymbolVariableStack *) m_varSymbol)->setAutoStorageTypeForEval(autostgtype); //for future virtual function call eval uses
//m_state.m_funcCallStack.storeUlamValueInSlot(pluv, ((SymbolVariableStack *) m_varSymbol)->getStackFrameSlotIndex()); //doesn't seem to matter..
return NORMAL;
} //eval
void NodeCast::genCodeCastAtomAndElement(File * fp, UlamValue & uvpass)
{
UTI nuti = getNodeType();
UlamType * nut = m_state.getUlamTypeByIndex(nuti);
UTI vuti = uvpass.getUlamValueTypeIdx();
s32 tmpVarNum = 0;
if(vuti == Ptr)
{
tmpVarNum = uvpass.getPtrSlotIndex();
vuti = uvpass.getPtrTargetType(); //replace
}
// "downcast" might not be true; compare to be sure the atom is an element "Foo"
if(vuti == UAtom)
{
m_state.indent(fp);
fp->write("if(!");
fp->write(nut->getUlamTypeMangledName().c_str());
fp->write("<EC>::THE_INSTANCE.");
fp->write(m_state.getIsMangledFunctionName());
fp->write("(");
fp->write(m_state.getTmpVarAsString(vuti, tmpVarNum).c_str());
fp->write("))\n");
m_state.m_currentIndentLevel++;
m_state.indent(fp);
fp->write("FAIL(BAD_CAST);\n");
m_state.m_currentIndentLevel--;
}
//update the uvpass to have the casted type
uvpass = UlamValue::makePtr(tmpVarNum, uvpass.getPtrStorage(), nuti, m_state.determinePackable(nuti), m_state, 0, uvpass.getPtrNameId()); //POS 0 rightjustified; pass along name id
return;
} //genCodeCastAtomAndElement
UlamValue NodeAtomof::makeUlamValuePtr()
{
// (from NodeVarDecl's makeUlamValuePtr)
UlamValue ptr;
UlamValue atomuv;
UTI auti = getOfType();
assert(m_nodeOf);
if(m_nodeOf->hasASymbolSelf())
{
//when "self/atom" is a quark, we're inside a func called on a quark (e.g. dm or local)
//'atom' gets entire atom/element containing this quark; including its type!
//'self' gets type/pos/len of the quark from which 'atom' can be extracted
UlamValue selfuvp = m_state.m_currentSelfPtr;
UTI ttype = selfuvp.getPtrTargetType();
assert(m_state.okUTItoContinue(ttype));
if((m_state.getUlamTypeByIndex(ttype)->getUlamClassType() == UC_QUARK))
{
selfuvp = atomuv; //bail for error
}
return selfuvp;
} //done
if(m_state.getReferenceType(auti) == ALT_AS)
{
assert(0);
Symbol * vsym = NULL;
m_nodeOf->getSymbolPtr(vsym);
return ((SymbolVariableStack *) vsym)->getAutoPtrForEval(); //haha! we're done.
}
if(m_nodeOf->hasASymbolDataMember())
{
UTI cuti = m_state.m_currentObjPtr.getPtrTargetType();
UlamType * cut = m_state.getUlamTypeByIndex(cuti);
if(cut->getUlamClassType() == UC_QUARK)
ptr = atomuv; //bail
else
{
// return ptr to the m_currentObjPtr that contains this data member within
ptr = UlamValue::makePtr(m_state.m_currentObjPtr.getPtrSlotIndex(), m_state.m_currentObjPtr.getPtrStorage(), auti, m_state.determinePackable(getNodeType()), m_state, 0, 0); //id?
ptr.checkForAbsolutePtr(m_state.m_currentObjPtr);
}
}
else
{
UTI vuti = getOfType();
UlamType * vut = m_state.getUlamTypeByIndex(vuti);
if(vut->getUlamClassType() == UC_QUARK)
ptr = atomuv; //bail
else
{
//local variable on the stack; could be array ptr!
Symbol * vsym = NULL;
m_nodeOf->getSymbolPtr(vsym);
ptr = UlamValue::makePtr(((SymbolVariableStack *) vsym)->getStackFrameSlotIndex(), STACK, auti, m_state.determinePackable(vuti), m_state, 0, vsym->getId()); //id?
}
}
return ptr;
} //makeUlamValuePtr
void NodeCast::genCodeCastAtomAndQuark(File * fp, UlamValue & uvpass)
{
UTI nuti = getNodeType(); //quark tobe
UlamType * nut = m_state.getUlamTypeByIndex(nuti);
UTI vuti = uvpass.getUlamValueTypeIdx();
if(vuti == Ptr)
vuti = uvpass.getPtrTargetType(); //replace
m_node->genCodeToStoreInto(fp, uvpass); //No need to load lhs into tmp (T); symbol's in COS vector
assert(!m_state.m_currentObjSymbolsForCodeGen.empty());
Symbol * stgcos = NULL;
stgcos = m_state.m_currentObjSymbolsForCodeGen[0];
s32 tmpVarPos = m_state.getNextTmpVarNumber();
// "downcast" might not be true; compare to be sure the atom has a quark "Foo"
// get signed pos
if(vuti == UAtom)
{
m_state.indent(fp);
fp->write("const s32 ");
fp->write(m_state.getTmpVarAsString(Int, tmpVarPos).c_str());;
fp->write(" = ");
//internal method, takes uc, u32 and const char*, returns s32 position
fp->write(m_state.getHasMangledFunctionName(vuti));
fp->write("(");
fp->write("uc, ");
Node::genLocalMemberNameOfMethod(fp); //assume atom is a local var (neither dm nor ep)
if(stgcos->isSelf())
fp->write("GetType(), "); //no read for self
else
fp->write("read().GetType(), ");
fp->write("\"");
fp->write(nut->getUlamTypeMangledName().c_str());
fp->write("\");\n"); //keeping pos in tmp
}
else
{
UlamType* vut = m_state.getUlamTypeByIndex(vuti);
if(vut->getUlamClass() == UC_ELEMENT)
{
m_state.indent(fp);
fp->write("const s32 ");
fp->write(m_state.getTmpVarAsString(Int, tmpVarPos).c_str());;
fp->write(" = ");
//internal method, takes uc, u32 and const char*, returns s32 position
fp->write(vut->getUlamTypeMangledName().c_str());
fp->write("<EC>::");
fp->write(m_state.getHasMangledFunctionName(vuti));
fp->write("(\"");
fp->write(nut->getUlamTypeMangledName().c_str());
fp->write("\");\n"); //keeping pos in tmp
}
else
{
//e.g. a quark here would be wrong
std::ostringstream msg;
msg << "Casting 'incomplete' types ";
msg << m_state.getUlamTypeNameBriefByIndex(nuti).c_str();
msg << " to be ";
msg << m_state.getUlamTypeNameBriefByIndex(vuti).c_str();
MSG(getNodeLocationAsString().c_str(), msg.str().c_str(), ERR);
assert(0);//return;
}
}
m_state.indent(fp);
fp->write("if(");
fp->write(m_state.getTmpVarAsString(Int, tmpVarPos).c_str());
fp->write(" < 0)\n");
m_state.m_currentIndentLevel++;
m_state.indent(fp);
fp->write("FAIL(BAD_CAST);\n\n");
m_state.m_currentIndentLevel--;
//informed by genCodedAutoLocal() in NodeVarDecl used for conditional-as
// uses stgcos since there's no m_varSymbol in this situation.
s32 tmpVarStg = m_state.getNextTmpVarNumber();
UTI stguti = stgcos->getUlamTypeIdx();
UlamType * stgut = m_state.getUlamTypeByIndex(stguti);
assert(stguti == UAtom || stgut->getUlamClass() == UC_ELEMENT);
// can't let Node::genCodeReadIntoTmpVar do this for us (we need a ref!):
assert(m_state.m_currentObjSymbolsForCodeGen.size() == 1);
m_state.indent(fp);
// no const here
fp->write(stgut->getTmpStorageTypeAsString().c_str());
fp->write("& ");
fp->write(m_state.getTmpVarAsString(stguti, tmpVarStg, TMPBITVAL).c_str());
fp->write(" = ");
fp->write(stgcos->getMangledName().c_str());
if(!stgcos->isSelf())
fp->write(".getRef()");
fp->write("; //ref needed\n");
// now we have our pos in tmpVarPos, and our T in tmpVarStg
// time to (like a) "shadow 'self'" with auto local variable:
m_state.indent(fp);
fp->write(nut->getUlamTypeImmediateAutoMangledName().c_str()); //for C++ local vars, ie non-data members
fp->write("<EC> ");
s32 tmpIQ = m_state.getNextTmpVarNumber(); //tmp since no variable name
fp->write(m_state.getTmpVarAsString(nuti, tmpIQ).c_str());
fp->write("(");
fp->write(m_state.getTmpVarAsString(stguti, tmpVarStg, TMPBITVAL).c_str());
//for known quark:
fp->write(", ");
fp->write(m_state.getTmpVarAsString(Int, tmpVarPos).c_str());
fp->write(");\n"); //like, shadow lhs of as
//update the uvpass to have the casted immediate quark
uvpass = UlamValue::makePtr(tmpIQ, uvpass.getPtrStorage(), nuti, m_state.determinePackable(nuti), m_state, 0); //POS 0 rightjustified;
m_state.m_currentObjSymbolsForCodeGen.clear(); //clear remnant of lhs
} //genCodeCastAtomAndQuark
void NodeCast::genCodeReadIntoATmpVar(File * fp, UlamValue& uvpass)
{
// e.g. called by NodeFunctionCall on a NodeTerminal..
if(!needsACast())
{
return m_node->genCodeReadIntoATmpVar(fp, uvpass);
}
UTI nuti = getNodeType();
UlamType * nut = m_state.getUlamTypeByIndex(nuti);
UTI vuti = uvpass.getUlamValueTypeIdx();
bool isTerminal = false;
s32 tmpVarNum = 0;
if(vuti == Ptr)
{
tmpVarNum = uvpass.getPtrSlotIndex();
vuti = uvpass.getPtrTargetType(); //replace
}
else
{
// an immediate terminal value
isTerminal = true;
}
if(nuti == vuti)
return; //nothing to do!
UlamType * vut = m_state.getUlamTypeByIndex(vuti); //after vuti replacement
ULAMCLASSTYPE nclasstype = nut->getUlamClass();
ULAMCLASSTYPE vclasstype = vut->getUlamClass();
//handle element-atom and atom-element casting differently:
// handle element->quark, atom->quark, not quark->element or quark->atom
if(nuti == UAtom || vuti == UAtom || vclasstype == UC_ELEMENT || vclasstype == UC_QUARK)
{
//only to be nclasstype quark makes sense!!! check first, one might be element
if(nclasstype == UC_QUARK || vclasstype == UC_QUARK)
return genCodeCastAtomAndQuark(fp, uvpass);
if(nclasstype == UC_ELEMENT || vclasstype == UC_ELEMENT)
return genCodeCastAtomAndElement(fp, uvpass);
{
std::ostringstream msg;
msg << "Casting 'incomplete' types: ";
msg << m_state.getUlamTypeNameByIndex(nuti).c_str();
msg << "(UTI" << nuti << ") to be " << m_state.getUlamTypeNameByIndex(vuti).c_str();
msg << "(UTI" << vuti << ")";
MSG(getNodeLocationAsString().c_str(), msg.str().c_str(), DEBUG);
return;
}
}
s32 tmpVarCastNum = m_state.getNextTmpVarNumber();
m_state.indent(fp);
fp->write("const ");
fp->write(nut->getTmpStorageTypeAsString().c_str()); //e.g. u32, s32, u64, etc.
fp->write(" ");
fp->write(m_state.getTmpVarAsString(nuti, tmpVarCastNum).c_str());
fp->write(" = ");
// write the cast method (e.g. _Unsigned32ToInt32, _Int32ToUnary32, etc..)
fp->write(nut->castMethodForCodeGen(vuti).c_str());
fp->write("(");
if(isTerminal)
{
s32 len = m_state.getBitSize(vuti);
assert(len != UNKNOWNSIZE);
if(len <= MAXBITSPERINT)
{
u32 data = uvpass.getImmediateData(m_state);
char dstr[40];
vut->getDataAsString(data, dstr, 'z');
fp->write(dstr);
}
else if(len <= MAXBITSPERLONG)
{
u64 data = uvpass.getImmediateDataLong(m_state);
char dstr[70];
vut->getDataLongAsString(data, dstr, 'z');
fp->write(dstr);
}
else
assert(0);
}
else
{
fp->write(m_state.getTmpVarAsString(nuti, tmpVarNum).c_str());
}
fp->write(", ");
assert(!(nuti == UAtom || vuti == UAtom));
//LENGTH of node being casted (Uh_AP_mi::LENGTH ?)
//fp->write(m_state.getBitVectorLengthAsStringForCodeGen(nodetype).c_str());
fp->write_decimal(m_state.getTotalBitSize(vuti)); //src length
fp->write(", ");
fp->write_decimal(m_state.getTotalBitSize(nuti)); //tobe length
fp->write(")");
fp->write(";\n");
//PROBLEM is that funccall checks for 0 nameid to use the tmp var!
// but then if we don't pass it along Node::genMemberNameForMethod fails..
if(isTerminal)
uvpass = UlamValue::makePtr(tmpVarCastNum, TMPREGISTER, nuti, m_state.determinePackable(nuti), m_state, 0); //POS 0 rightjustified.
else
uvpass = UlamValue::makePtr(tmpVarCastNum, TMPREGISTER, nuti, m_state.determinePackable(nuti), m_state, 0, uvpass.getPtrNameId()); //POS 0 rightjustified; pass along name id
} //genCodeReadIntoTmp
void NodeBinaryOpEqualBitwise::genCode(File * fp, UlamValue& uvpass)
{
assert(m_nodeLeft && m_nodeRight);
assert(m_state.m_currentObjSymbolsForCodeGen.empty());
#ifdef TMPVARBRACES
m_state.indent(fp);
fp->write("{\n");
m_state.m_currentIndentLevel++;
#endif
// generate rhs first; may update current object globals (e.g. function call)
UlamValue ruvpass;
m_nodeRight->genCode(fp, ruvpass);
// restore current object globals
assert(m_state.m_currentObjSymbolsForCodeGen.empty());
// lhs should be the new current object: node member select updates them,
// but a plain NodeIdent does not!!! because genCodeToStoreInto has been repurposed
// to mean "don't read into a TmpVar" (e.g. by NodeCast).
UlamValue luvpass;
m_nodeLeft->genCodeToStoreInto(fp, luvpass); //may update m_currentObjSymbol
//wiped out by left read; need to write back into left
std::vector<Symbol *> saveCOSVector = m_state.m_currentObjSymbolsForCodeGen;
uvpass = luvpass; //keep luvpass slot untouched
Node::genCodeReadIntoATmpVar(fp, uvpass);
m_state.m_currentObjSymbolsForCodeGen = saveCOSVector; //restore vector after lhs read*************
UTI nuti = getNodeType();
UlamType * nut = m_state.getUlamTypeByIndex(nuti);
s32 tmpVarNum = m_state.getNextTmpVarNumber();
m_state.indent(fp);
fp->write("const ");
fp->write(nut->getTmpStorageTypeAsString().c_str()); //e.g. u32, s32, u64..
fp->write(" ");
fp->write(m_state.getTmpVarAsString(nuti,tmpVarNum).c_str());
fp->write(" = ");
fp->write(methodNameForCodeGen().c_str());
fp->write("(");
UTI uti = uvpass.getUlamValueTypeIdx();
assert(uti == Ptr);
fp->write(m_state.getTmpVarAsString(uvpass.getPtrTargetType(), uvpass.getPtrSlotIndex()).c_str());
fp->write(", ");
UTI ruti = ruvpass.getUlamValueTypeIdx();
assert(ruti == Ptr);
fp->write(m_state.getTmpVarAsString(ruvpass.getPtrTargetType(), ruvpass.getPtrSlotIndex()).c_str());
fp->write(", ");
fp->write_decimal(nut->getBitSize());
fp->write(");\n");
uvpass = UlamValue::makePtr(tmpVarNum, TMPREGISTER, nuti, m_state.determinePackable(nuti), m_state, uvpass.getPtrPos(), uvpass.getPtrNameId()); //P
// current object globals should pertain to lhs for the write
genCodeWriteFromATmpVar(fp, luvpass, uvpass); //uses rhs' tmpvar; orig lhs
#ifdef TMPVARBRACES
m_state.m_currentIndentLevel--;
m_state.indent(fp);
fp->write("}\n"); //close for tmpVar
#endif
assert(m_state.m_currentObjSymbolsForCodeGen.empty());
} //genCode
EvalStatus NodeSquareBracket::evalToStoreInto()
{
assert(m_nodeLeft && m_nodeRight);
UTI nuti = getNodeType();
if(nuti == Nav)
return ERROR;
evalNodeProlog(0); //new current frame pointer
makeRoomForSlots(1); //always 1 slot for ptr
EvalStatus evs = m_nodeLeft->evalToStoreInto();
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
UlamValue pluv = m_state.m_nodeEvalStack.popArg();
makeRoomForNodeType(m_nodeRight->getNodeType()); //offset a constant expression
evs = m_nodeRight->eval();
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
UlamValue offset = m_state.m_nodeEvalStack.popArg();
// constant expression only required for array declaration
u32 offsetdata = offset.getImmediateData(m_state);
s32 offsetInt = m_state.getUlamTypeByIndex(offset.getUlamValueTypeIdx())->getDataAsCs32(offsetdata);
UTI auti = pluv.getPtrTargetType();
UlamType * aut = m_state.getUlamTypeByIndex(auti);
if(aut->isCustomArray())
{
UTI caType = ((UlamTypeClass *) aut)->getCustomArrayType();
UlamType * caut = m_state.getUlamTypeByIndex(caType);
u32 pos = pluv.getPtrPos();
if(caut->getBitSize() > MAXBITSPERINT)
pos = 0;
// itemUV = UlamValue::makeAtom(caType);
//else
// itemUV = UlamValue::makeImmediate(caType, 0, m_state); //quietly skip for now XXX
//use CA type, not the left ident's type
UlamValue scalarPtr = UlamValue::makePtr(pluv.getPtrSlotIndex(),
pluv.getPtrStorage(),
caType,
m_state.determinePackable(caType), //PACKEDLOADABLE
m_state,
pos /* base pos of array */
);
//copy result UV to stack, -1 relative to current frame pointer
assignReturnValuePtrToStack(scalarPtr);
}
else
{
//adjust pos by offset * len, according to its scalar type
UlamValue scalarPtr = UlamValue::makeScalarPtr(pluv, m_state);
if(scalarPtr.incrementPtr(m_state, offsetInt))
//copy result UV to stack, -1 relative to current frame pointer
assignReturnValuePtrToStack(scalarPtr);
else
{
s32 arraysize = m_state.getArraySize(pluv.getPtrTargetType());
Symbol * lsymptr;
u32 lid = 0;
if(getSymbolPtr(lsymptr))
lid = lsymptr->getId();
std::ostringstream msg;
msg << "Array subscript [" << offsetInt << "] exceeds the size (" << arraysize;
msg << ") of array '" << m_state.m_pool.getDataAsString(lid).c_str() << "'";
MSG(getNodeLocationAsString().c_str(), msg.str().c_str(), ERR);
evs = ERROR;
}
}
evalNodeEpilog();
return evs;
} //evalToStoreInto
EvalStatus NodeSquareBracket::eval()
{
assert(m_nodeLeft && m_nodeRight);
UTI nuti = getNodeType();
if(nuti == Nav)
return ERROR;
evalNodeProlog(0); //new current frame pointer
makeRoomForSlots(1); //always 1 slot for ptr
EvalStatus evs = m_nodeLeft->evalToStoreInto();
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
UlamValue pluv = m_state.m_nodeEvalStack.popArg();
UTI ltype = pluv.getPtrTargetType();
//could be a custom array which is a scalar quark. already checked.
UlamType * lut = m_state.getUlamTypeByIndex(ltype);
bool isCustomArray = lut->isCustomArray();
assert(!m_state.isScalar(ltype) || isCustomArray); //already checked, must be array
makeRoomForNodeType(m_nodeRight->getNodeType()); //offset a constant expression
evs = m_nodeRight->eval();
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
UlamValue offset = m_state.m_nodeEvalStack.popArg();
UlamType * offut = m_state.getUlamTypeByIndex(offset.getUlamValueTypeIdx());
s32 offsetInt = 0;
if(offut->isNumericType())
{
// constant expression only required for array declaration
s32 arraysize = m_state.getArraySize(ltype);
u32 offsetdata = offset.getImmediateData(m_state);
offsetInt = offut->getDataAsCs32(offsetdata);
if((offsetInt >= arraysize) && !isCustomArray)
{
Symbol * lsymptr;
u32 lid = 0;
if(getSymbolPtr(lsymptr))
lid = lsymptr->getId();
std::ostringstream msg;
msg << "Array subscript [" << offsetInt << "] exceeds the size (" << arraysize;
msg << ") of array '" << m_state.m_pool.getDataAsString(lid).c_str() << "'";
MSG(getNodeLocationAsString().c_str(), msg.str().c_str(), ERR);
evalNodeEpilog();
return ERROR;
}
}
else if(!isCustomArray)
{
Symbol * lsymptr;
u32 lid = 0;
if(getSymbolPtr(lsymptr))
lid = lsymptr->getId();
std::ostringstream msg;
msg << "Array subscript of array '";
msg << m_state.m_pool.getDataAsString(lid).c_str();
msg << "' requires a numeric type";
MSG(getNodeLocationAsString().c_str(), msg.str().c_str(), ERR);
evalNodeEpilog();
return ERROR;
}
assignReturnValueToStack(pluv.getValAt(offsetInt, m_state));
evalNodeEpilog();
return NORMAL;
} //eval
void NodeBinaryOpCompare::genCode(File * fp, UlamValue& uvpass)
{
assert(m_nodeLeft && m_nodeRight);
assert(m_state.m_currentObjSymbolsForCodeGen.empty()); //*************
#ifdef TMPVARBRACES
m_state.indent(fp);
fp->write("{\n");
m_state.m_currentIndentLevel++;
#endif
// generate rhs first; may update current object globals (e.g. function call)
UlamValue ruvpass;
m_nodeRight->genCode(fp, ruvpass);
// restore current object globals
assert(m_state.m_currentObjSymbolsForCodeGen.empty()); //*************
UlamValue luvpass;
m_nodeLeft->genCode(fp, luvpass); //updates m_currentObjSymbol
UTI nuti = getNodeType();
UlamType * nut = m_state.getUlamTypeByIndex(nuti);
s32 tmpVarNum = m_state.getNextTmpVarNumber();
m_state.indent(fp);
fp->write("const ");
fp->write(nut->getTmpStorageTypeAsString().c_str()); //e.g. u32, s32, u64..
fp->write(" ");
fp->write(m_state.getTmpVarAsString(nuti,tmpVarNum).c_str());
fp->write(" = ");
fp->write(methodNameForCodeGen().c_str());
fp->write("(");
UTI luti = luvpass.getUlamValueTypeIdx();
assert(luti == Ptr);
luti = luvpass.getPtrTargetType(); //reset
fp->write(m_state.getTmpVarAsString(luti, luvpass.getPtrSlotIndex()).c_str());
fp->write(", ");
UTI ruti = ruvpass.getUlamValueTypeIdx();
assert(ruti == Ptr);
fp->write(m_state.getTmpVarAsString(ruvpass.getPtrTargetType(), ruvpass.getPtrSlotIndex()).c_str());
fp->write(", ");
//compare needs size of left/right nodes (only difference!)
fp->write_decimal(m_state.getUlamTypeByIndex(luti)->getTotalBitSize());
fp->write(");\n");
uvpass = UlamValue::makePtr(tmpVarNum, TMPREGISTER, nuti, m_state.determinePackable(nuti), m_state, 0); //P
#ifdef TMPVARBRACES
m_state.m_currentIndentLevel--;
m_state.indent(fp);
fp->write("}\n"); //close for tmpVar
#endif
assert(m_state.m_currentObjSymbolsForCodeGen.empty()); //*************
} //genCode
