本文整理汇总了C++中UlamValue类的典型用法代码示例。如果您正苦于以下问题:C++ UlamValue类的具体用法?C++ UlamValue怎么用?C++ UlamValue使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了UlamValue类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: assert
bool UlamTypePrimitiveInt::cast(UlamValue & val, UTI typidx)
{
bool brtn = true;
assert(m_state.getUlamTypeByIndex(typidx) == this);
UTI valtypidx = val.getUlamValueTypeIdx();
if(UlamType::safeCast(valtypidx) != CAST_CLEAR) //bad|hazy
return false;
u32 wordsize = getTotalWordSize();
u32 valwordsize = m_state.getTotalWordSize(valtypidx);
if(wordsize <= MAXBITSPERINT)
{
if(valwordsize <= MAXBITSPERINT)
brtn = castTo32(val, typidx);
else if(valwordsize <= MAXBITSPERLONG)
brtn = castTo64(val, typidx); //downcast
else
m_state.abortGreaterThanMaxBitsPerLong();
}
else if(wordsize <= MAXBITSPERLONG)
brtn = castTo64(val, typidx);
else
{
std::ostringstream msg;
msg << "Casting to an unsupported word size: " << wordsize;
msg << ", Value Type and bit size was: ";
msg << valtypidx << "," << m_state.getBitSize(valtypidx);
msg << " TO: ";
msg << typidx << "," << getBitSize();
MSG(m_state.getFullLocationAsString(m_state.m_locOfNextLineText).c_str(), msg.str().c_str(), DEBUG);
brtn = false;
}
return brtn;
} //cast
示例2: evalNodeProlog
// eval() no longer performed before check and label
// returns false if error; UNKNOWNSIZE is not an error!
bool NodeSquareBracket::getArraysizeInBracket(s32 & rtnArraySize)
{
bool noerr = true;
// since square brackets determine the constant size for this type, else error
s32 newarraysize = NONARRAYSIZE;
UTI sizetype = m_nodeRight->checkAndLabelType();
if(sizetype == Nav)
{
rtnArraySize = UNKNOWNSIZE;
return true;
}
UlamType * sizeut = m_state.getUlamTypeByIndex(sizetype);
// expects a constant, numeric type within []
if(sizeut->isNumericType() && m_nodeRight->isAConstant())
{
evalNodeProlog(0); //new current frame pointer
makeRoomForNodeType(sizetype); //offset a constant expression
if(m_nodeRight->eval() == NORMAL)
{
UlamValue arrayUV = m_state.m_nodeEvalStack.popArg();
u32 arraysizedata = arrayUV.getImmediateData(m_state);
newarraysize = sizeut->getDataAsCs32(arraysizedata);
if(newarraysize < 0 && newarraysize != UNKNOWNSIZE) //NONARRAY or UNKNOWN
{
MSG(getNodeLocationAsString().c_str(),
"Array size specifier in [] is not a positive number", ERR);
noerr = false;
}
//else unknown is not an error
}
else //newarraysize = UNKNOWNSIZE; //still true
noerr = false;
evalNodeEpilog();
}
else
{
MSG(getNodeLocationAsString().c_str(),
"Array size specifier in [] is not a constant number", ERR);
noerr = false;
}
rtnArraySize = newarraysize;
return noerr;
} //getArraysizeInBracket
示例3: assert
//overrides parent due to short-circuiting requirement
EvalStatus NodeBinaryOpLogicalOr::eval()
{
assert(m_nodeLeft && m_nodeRight);
UTI nuti = getNodeType();
u32 len = m_state.getTotalBitSize(nuti);
evalNodeProlog(0); //new current frame pointer
u32 slot = makeRoomForNodeType(nuti);
EvalStatus evs = m_nodeLeft->eval();
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
//short-circuit if lhs is true
UlamValue luv = m_state.m_nodeEvalStack.loadUlamValueFromSlot(slot); //immediate value
u32 ldata = luv.getImmediateData(len, m_state);
if(_Bool32ToCbool(ldata, len) == true)
{
//copies return UV to stack, -1 relative to current frame pointer
m_state.m_nodeEvalStack.storeUlamValueInSlot(luv, -1);
}
else
{
u32 slot2 = makeRoomForNodeType(getNodeType());
evs = m_nodeRight->eval();
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
UlamValue ruv = m_state.m_nodeEvalStack.loadUlamValueFromSlot(slot+slot2); //immediate value
//copies return UV to stack, -1 relative to current frame pointer
m_state.m_nodeEvalStack.storeUlamValueInSlot(ruv, -1);
}
evalNodeEpilog();
return NORMAL;
} //eval
示例4: appendBinaryOp
void NodeBinaryOpBitwiseXor::appendBinaryOp(UlamValue& refUV, u32 ldata, u32 rdata, u32 pos, u32 len)
{
UTI type = refUV.getUlamValueTypeIdx();
ULAMTYPE typEnum = m_state.getUlamTypeByIndex(type)->getUlamTypeEnum();
switch(typEnum)
{
case Int:
refUV.putData(pos, len, _BitwiseXorInt32(ldata, rdata, len));
break;
case Unsigned:
refUV.putData(pos, len, _BitwiseXorUnsigned32(ldata, rdata, len));
break;
case Bool:
refUV.putData(pos, len, _BitwiseXorBool32(ldata, rdata, len));
break;
case Unary:
refUV.putData(pos, len, _BitwiseXorUnary32(ldata, rdata, len));
break;
case Bits:
refUV.putData(pos, len, _BitwiseXorBits32(ldata, rdata, len));
break;
default:
assert(0);
break;
};
return;
} //appendBinaryOp
示例5: assert
void NodeBinaryOpShiftLeft::appendBinaryOp(UlamValue& refUV, u32 ldata, u32 rdata, u32 pos, u32 len)
{
assert(0); //not implemented yet!
#if 0
UTI type = refUV.getUlamValueTypeIdx();
ULAMTYPE typEnum = m_state.getUlamTypeByIndex(type)->getUlamTypeEnum();
switch(typEnum)
{
case Int:
refUV.putData(pos, len, _ShiftOpLeftInt32(ldata, rdata, len));
break;
case Unsigned:
refUV.putData(pos, len, _ShiftOpLeftUnsigned32(ldata, rdata, len));
break;
case Bool:
refUV.putData(pos, len, _ShiftOpLeftBool32(ldata, rdata, len));
break;
case Unary:
refUV.putData(pos, len, _ShiftOpLeftUnary32(ldata, rdata, len));
break;
case Bits:
case Unary:
refUV.putData(pos, len, _ShiftOpLeftBits32(ldata, rdata, len));
break;
default:
assert(0);
break;
};
#endif
return;
} //appendBinaryOp
示例6: MSG
void NodeBinaryOpArithDivide::appendBinaryOp(UlamValue& refUV, u32 ldata, u32 rdata, u32 pos, u32 len)
{
if(rdata == 0)
{
MSG(getNodeLocationAsString().c_str(), "Possible Divide By Zero Attempt", ERR);
refUV.setUlamValueTypeIdx(Nav);
setNodeType(Nav); //compiler counts
return;
}
UTI type = refUV.getUlamValueTypeIdx();
ULAMTYPE typEnum = m_state.getUlamTypeByIndex(type)->getUlamTypeEnum();
switch(typEnum)
{
case Int:
refUV.putData(pos, len, _BinOpDivideInt32(ldata, rdata, len));
break;
case Unsigned:
refUV.putData(pos, len, _BinOpDivideUnsigned32(ldata, rdata, len));
break;
case Bool:
refUV.putData(pos, len, _BinOpDivideBool32(ldata, rdata, len));
break;
case Unary:
refUV.putData(pos, len, _BinOpDivideUnary32(ldata, rdata, len));
break;
case Bits:
default:
m_state.abortUndefinedUlamPrimitiveType();
break;
};
return;
} //appendBinaryOp
示例7: getBitSize
bool UlamTypeInt::castTo32(UlamValue & val, UTI typidx)
{
bool brtn = true;
UTI valtypidx = val.getUlamValueTypeIdx();
s32 bitsize = getBitSize();
s32 valbitsize = m_state.getBitSize(valtypidx);
u32 data = val.getImmediateData(m_state);
u32 sdata = 0;
ULAMTYPE valtypEnum = m_state.getUlamTypeByIndex(valtypidx)->getUlamTypeEnum();
switch(valtypEnum)
{
case Int:
// casting Int to Int to change bits size
sdata = _Int32ToInt32(data, valbitsize, bitsize);
break;
case Unsigned:
// casting Unsigned to Int to change type
sdata = _Unsigned32ToInt32(data, valbitsize, bitsize);
break;
case Bits:
// casting Bits to Int to change type
sdata = _Bits32ToInt32(data, valbitsize, bitsize);
break;
case Unary:
sdata = _Unary32ToInt32(data, valbitsize, bitsize);
break;
case Bool:
sdata = _Bool32ToInt32(data, valbitsize, bitsize);
break;
case Void:
default:
//std::cerr << "UlamTypeInt (cast) error! Value Type was: " << valtypidx << std::endl;
brtn = false;
};
if(brtn)
val = UlamValue::makeImmediate(typidx, sdata, m_state); //overwrite val
return brtn;
} //castTo32
示例8: getNodeType
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
示例9: getBitSize
bool UlamTypePrimitiveUnary::castTo32(UlamValue & val, UTI typidx)
{
bool brtn = true;
UTI valtypidx = val.getUlamValueTypeIdx();
u32 data = val.getImmediateData(m_state);
s32 bitsize = getBitSize();
s32 valbitsize = m_state.getBitSize(valtypidx);
//base types e.g. Int, Bool, Unary, Foo, Bar..
ULAMTYPE valtypEnum = m_state.getUlamTypeByIndex(valtypidx)->getUlamTypeEnum();
switch(valtypEnum)
{
case Int:
// cast from Int->Unary, OR Bool->Unary (same as Bool->Int)
data = _Int32ToUnary32(data, valbitsize, bitsize);
break;
case Unsigned:
data = _Unsigned32ToUnary32(data, valbitsize, bitsize);
break;
case Bool:
// Bool -> Unary is the same as Bool -> Int
data = _Bool32ToUnary32(data, valbitsize, bitsize);
break;
case Unary:
data = _Unary32ToUnary32(data, valbitsize, bitsize);
break;
case Bits:
break;
case Void:
default:
//std::cerr << "UlamTypePrimitiveUnary (cast) error! Value Type was: " << valtypidx << std::endl;
brtn = false;
};
if(brtn)
val = UlamValue::makeImmediate(typidx, data, m_state); //overwrite val, same data
return brtn;
} //castTo32
示例10: assert
void UnpackedStorage::assignUlamValue(UlamValue pluv, UlamValue ruv)
{
assert(pluv.getUlamValueTypeIdx() == Ptr);
assert(ruv.getUlamValueTypeIdx() != Ptr);
s32 leftbaseslot = pluv.getPtrSlotIndex(); //even for scalars
if(pluv.isTargetPacked() == UNPACKED)
{
m_values[leftbaseslot] = ruv; //must be immediate
}
else
{
//target is packed or packedloadable, use pos & len in ptr
UlamValue lvalAtIdx = loadDataMemberAt(leftbaseslot);
assert(lvalAtIdx.getUlamValueTypeIdx() == UAtom); //?
lvalAtIdx.putDataIntoAtom(pluv, ruv, m_state);
storeDataMemberAt(lvalAtIdx, leftbaseslot);
}
}
示例11: assert
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
示例12: getNodeType
//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)
{
m_state.abortNotImplementedYet(); //not implemented yet..TODO return bool.
#if 0
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);
u32 navCount = 0;
u32 hzyCount = 0;
//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);
if(rtnUV.getUlamValueTypeIdx() == Nav)
navCount++;
else if(rtnUV.getUlamValueTypeIdx() == Hzy)
hzyCount++;
//cp result UV to stack, -1 (first array element deepest) relative to current frame pointer
m_state.m_nodeEvalStack.storeUlamValueInSlot(rtnUV, -slots + i);
}
AssertBool isNextLeft = lp.incrementPtr(m_state);
assert(isNextLeft);
AssertBool isNextRight = rp.incrementPtr(m_state);
assert(isNextRight);
} //forloop
if(navCount > 0)
return false;
if(hzyCount > 0)
return false;
if(WritePacked(packRtn))
m_state.m_nodeEvalStack.storeUlamValueInSlot(rtnUV, -1); //store accumulated packed result
#endif
return false; //NOT IMPLEMENTED YET!
} //end dobinaryOperaationarray
示例13: assert
//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::doBinaryOperationImmediate(s32 lslot, s32 rslot, u32 slots)
{
assert(slots == 1);
UTI luti = m_nodeLeft->getNodeType();
u32 len = m_state.getTotalBitSize(luti);
UlamValue luv = m_state.m_nodeEvalStack.loadUlamValueFromSlot(lslot); //immediate value
UlamValue ruv = m_state.m_nodeEvalStack.loadUlamValueFromSlot(rslot); //immediate value
if((luv.getUlamValueTypeIdx() == Nav) || (ruv.getUlamValueTypeIdx() == Nav))
return false;
if((luv.getUlamValueTypeIdx() == Hzy) || (ruv.getUlamValueTypeIdx() == Hzy))
return false;
UlamValue rtnUV;
u32 wordsize = m_state.getTotalWordSize(luti);
if(wordsize == MAXBITSPERINT)
{
u32 ldata = luv.getImmediateData(len, m_state);
u32 rdata = ruv.getImmediateData(len, m_state);
rtnUV = makeImmediateBinaryOp(luti, ldata, rdata, len);
}
else if(wordsize == MAXBITSPERLONG)
{
u64 ldata = luv.getImmediateDataLong(len);
u64 rdata = ruv.getImmediateDataLong(len);
rtnUV = makeImmediateLongBinaryOp(luti, ldata, rdata, len);
}
else
m_state.abortGreaterThanMaxBitsPerLong(); //e.g. 0
if(rtnUV.getUlamValueTypeIdx() == Nav)
return false;
if(rtnUV.getUlamValueTypeIdx() == Hzy)
return false;
m_state.m_nodeEvalStack.storeUlamValueInSlot(rtnUV, -1);
return true;
} //dobinaryOperationImmediate
示例14: getUlamTypeIdx
// 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)
//.........这里部分代码省略.........
示例15: assert
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