EvalStatus NodeVarRef::eval()
{
assert(m_varSymbol);
assert(m_varSymbol->getAutoLocalType() != ALT_AS); //NodeVarRefAuto
UTI nuti = getNodeType();
if(nuti == Nav) return evalErrorReturn();
assert(m_varSymbol->getUlamTypeIdx() == nuti);
assert(m_nodeInitExpr);
evalNodeProlog(0); //new current frame pointer
makeRoomForSlots(1); //always 1 slot for ptr
EvalStatus evs = m_nodeInitExpr->evalToStoreInto();
if(evs != NORMAL) return evalStatusReturn(evs);
UlamValue pluv = m_state.m_nodeEvalStack.popArg();
assert(m_state.isPtr(pluv.getUlamValueTypeIdx()));
((SymbolVariableStack *) m_varSymbol)->setAutoPtrForEval(pluv); //for future ident eval uses
((SymbolVariableStack *) m_varSymbol)->setAutoStorageTypeForEval(m_nodeInitExpr->getNodeType()); //for future virtual function call eval uses
m_state.m_funcCallStack.storeUlamValueInSlot(pluv, ((SymbolVariableStack *) m_varSymbol)->getStackFrameSlotIndex()); //doesn't seem to matter..
evalNodeEpilog();
return NORMAL;
} //eval
EvalStatus NodeMemberSelect::evalToStoreInto()
{
UTI nuti = getNodeType();
if(nuti == Nav)
return ERROR;
if(nuti == Hzy)
return NOTREADY;
evalNodeProlog(0);
UlamValue saveCurrentObjectPtr = m_state.m_currentObjPtr; //*************
makeRoomForSlots(1); //always 1 slot for ptr
EvalStatus evs = m_nodeLeft->evalToStoreInto();
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
//UPDATE selected member (i.e. element or quark) before eval of rhs
// (i.e. data member or func call)
UlamValue newCurrentObjectPtr = m_state.m_nodeEvalStack.loadUlamValuePtrFromSlot(1); //e.g. Ptr to atom
UTI newobjtype = newCurrentObjectPtr.getUlamValueTypeIdx();
if(!m_state.isPtr(newobjtype))
{
assert(m_nodeLeft->isFunctionCall());// must be the result of a function call;
// copy anonymous class to "uc" hidden slot in STACK, then replace with a pointer to it.
assert(m_state.isAClass(newobjtype));
newCurrentObjectPtr = assignAnonymousClassReturnValueToStack(newCurrentObjectPtr); //t3913
}
m_state.m_currentObjPtr = newCurrentObjectPtr;
makeRoomForSlots(1); //always 1 slot for ptr
evs = m_nodeRight->evalToStoreInto();
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
UlamValue ruvPtr = m_state.m_nodeEvalStack.loadUlamValuePtrFromSlot(2);
UTI robjtype = ruvPtr.getUlamValueTypeIdx(); //t3913
if(!m_state.isPtr(robjtype))
{
// must be the result of a function call;
// copy anonymous class to "uc" hidden slot in STACK, then replace with a pointer to it.
assert(m_state.isAClass(robjtype));
ruvPtr = assignAnonymousClassReturnValueToStack(ruvPtr);
}
Node::assignReturnValuePtrToStack(ruvPtr);
m_state.m_currentObjPtr = saveCurrentObjectPtr; //restore current object ptr **********
evalNodeEpilog();
return NORMAL;
} //evalToStoreInto
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 NodeMemberSelect::eval()
{
assert(m_nodeLeft && m_nodeRight);
UTI nuti = getNodeType();
if(nuti == Nav)
return ERROR;
if(nuti == Hzy)
return NOTREADY;
evalNodeProlog(0); //new current frame pointer on node eval stack
UlamValue saveCurrentObjectPtr = m_state.m_currentObjPtr; //*************
UlamValue saveCurrentSelfPtr = m_state.m_currentSelfPtr; //*************
makeRoomForSlots(1); //always 1 slot for ptr
EvalStatus evs = m_nodeLeft->evalToStoreInto();
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
//UPDATE selected member (i.e. element or quark) before eval of rhs
//(i.e. data member or func call); e.g. Ptr to atom
UlamValue newCurrentObjectPtr = m_state.m_nodeEvalStack.loadUlamValuePtrFromSlot(1);
UTI newobjtype = newCurrentObjectPtr.getUlamValueTypeIdx();
if(!m_state.isPtr(newobjtype))
{
assert(m_nodeLeft->isFunctionCall()); //must be the result of a function call
// copy anonymous class to "uc" hidden slot in STACK, then replace with a pointer to it.
assert(m_state.isAClass(newobjtype));
newCurrentObjectPtr = assignAnonymousClassReturnValueToStack(newCurrentObjectPtr); //t3912
}
u32 superid = m_state.m_pool.getIndexForDataString("super");
if(newCurrentObjectPtr.getPtrNameId() == superid)
{
if(!m_nodeRight->isFunctionCall())
newCurrentObjectPtr = m_state.m_currentSelfPtr; //(t3749)
else
m_state.m_currentSelfPtr = newCurrentObjectPtr; //changes self ********* (t3743, t3745)
}
m_state.m_currentObjPtr = newCurrentObjectPtr;
//UTI ruti = m_nodeRight->getNodeType();
//u32 slot = makeRoomForNodeType(ruti);
u32 slot = makeRoomForNodeType(nuti);
evs = m_nodeRight->eval(); //a Node Function Call here, or data member eval
if(evs != NORMAL)
{
evalNodeEpilog();
return evs;
}
//assigns rhs to lhs UV pointer (handles arrays);
//also copy result UV to stack, -1 relative to current frame pointer
if(slot) //avoid Void's
if(!doBinaryOperation(1, 1+slot, slot))
evs = ERROR;
m_state.m_currentObjPtr = saveCurrentObjectPtr; //restore current object ptr
m_state.m_currentSelfPtr = saveCurrentSelfPtr; //restore current self ptr
evalNodeEpilog();
return evs;
} //eval
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
