Node * SymbolClassName::findNodeNoInAClassInstance(UTI instance, NNO n)
{
assert(getUlamTypeIdx() == instance);
Node * foundNode = NULL;
NodeBlockClass * classNode = getClassBlockNode();
assert(classNode);
m_state.pushClassContext(getUlamTypeIdx(), classNode, classNode, false, NULL);
classNode->findNodeNo(n, foundNode);
//if not in the tree, ask the resolver
if(!foundNode)
{
SymbolClass::findNodeNoInResolver(n, foundNode);
}
m_state.popClassContext(); //restore
return foundNode;
} //findNodeNoInAClassInstance
bool SymbolWithValue::getInitValue(u64& val)
{
assert(hasInitValue());
if(isInitValueReady())
{
u32 len = m_state.getTotalBitSize(getUlamTypeIdx());
val = m_initialValue.ReadLong(0u, len); //return value
return true;
}
return false;
}
bool SymbolWithValue::getInitValue(BV8K& val)
{
assert(hasInitValue());
if(isInitValueReady())
{
u32 len = m_state.getUlamTypeByIndex(getUlamTypeIdx())->getSizeofUlamType();
m_initialValue.CopyBV(0u, 0u, len, val);
return true;
}
return false;
}
bool SymbolWithValue::getValue(u64& val)
{
if(isReady())
{
u32 len = m_state.getTotalBitSize(getUlamTypeIdx());
if(len > MAXBITSPERLONG)
m_state.abortGreaterThanMaxBitsPerLong();
val = m_constantValue.ReadLong(0u, len); //return value
return true;
}
return false;
}
bool SymbolClassName::statusUnknownTypeNamesInClassInstances()
{
bool aok = true;
NodeBlockClass * classNode = getClassBlockNode();
assert(classNode);
m_state.pushClassContext(getUlamTypeIdx(), classNode, classNode, false, NULL);
aok = SymbolClass::statusUnknownTypeNamesInClass();
m_state.popClassContext(); //restore
return aok;
} //statusUnknownTypeNamesInClassInstances
void SymbolModelParameterValue::printPostfixValuesOfVariableDeclarations(File * fp, s32 slot, u32 startpos, ULAMCLASSTYPE classtype)
{
UTI tuti = getUlamTypeIdx();
fp->write(" parameter");
fp->write(" ");
fp->write(m_state.getUlamTypeNameBriefByIndex(tuti).c_str());
fp->write(" ");
fp->write(m_state.m_pool.getDataAsString(getId()).c_str());
fp->write(" = ");
SymbolWithValue::printPostfixValue(fp);
fp->write("; ");
} //printPostfixValuesOfVariableDeclarations
bool SymbolWithValue::getArrayItemValue(u32 item, u64& rtnitem)
{
if(isReady())
{
UTI suti = getUlamTypeIdx();
UlamType * sut = m_state.getUlamTypeByIndex(suti);
u32 bs = sut->getBitSize();
s32 arrsize = sut->getArraySize();
assert(bs <= MAXBITSPERLONG);
assert((arrsize >= 0) && (item < (u32) arrsize));
//no casting!
rtnitem = m_constantValue.ReadLong(item * bs, bs);
return true;
}
return false;
}
bool SymbolWithValue::getArrayItemInitValue(u32 item, u32& rtnitem)
{
assert(hasInitValue());
if(isInitValueReady())
{
UTI suti = getUlamTypeIdx();
UlamType * sut = m_state.getUlamTypeByIndex(suti);
u32 bs = sut->getBitSize();
s32 arrsize = sut->getArraySize();
assert(bs <= MAXBITSPERINT);
assert((arrsize >= 0) && (item < (u32) arrsize));
//no casting!
rtnitem = m_initialValue.Read(item * bs, bs);
return true;
}
return false;
}
void SymbolWithValue::printPostfixValueArrayStringAsComment(File * fp)
{
BV8K dval;
bool oktoprint = getValueReadyToPrint(dval);
UTI tuti = getUlamTypeIdx();
UlamType * tut = m_state.getUlamTypeByIndex(tuti);
bool isString = (tut->getUlamTypeEnum() == String); //t3953
assert(isString);
if(!oktoprint)
{
fp->write("// ");
fp->write(getMangledName().c_str());
fp->write(": NONREADYCONSTARRAY OF STRINGS"); GCNL;
return;
}
//like the code generated in CS::genCodeClassDefaultConstantArray
u32 uvals[ARRAY_LEN8K];
dval.ToArray(uvals);
u32 nwords = tut->getTotalNumberOfWords();
//indented comments of string value items (one per line); e.g. t3953,4
for(u32 w = 0; w < nwords; w++)
{
m_state.indent(fp);
fp->write("// ");
fp->write("[");
fp->write_decimal_unsigned(w);
fp->write("] = ");
fp->write(m_state.getDataAsFormattedUserString(uvals[w]).c_str());
fp->write("\n");
}
m_state.indent(fp);
fp->write("// = ");
fp->write(getMangledName().c_str());
fp->write("[");
fp->write_decimal_unsigned(nwords);
fp->write("]");
GCNL;
} //printPostfixValueArrayStringAsComment
void SymbolWithValue::printPostfixValueArray(File * fp)
{
BV8K dval;
bool oktoprint = getValueReadyToPrint(dval);
if(!oktoprint)
{
fp->write("NONREADYCONSTARRAY");
return;
}
UTI tuti = getUlamTypeIdx();
UlamType * tut = m_state.getUlamTypeByIndex(tuti);
s32 tbs = tut->getTotalBitSize();
if(tbs == 0)
{
fp->write("{ }");
return; //nothing to do
}
//required as hex for String arrays too (needed for initialization) (t3974)
//like the code generated in CS::genCodeClassDefaultConstantArray
std::string dhex;
bool nonZero = SymbolWithValue::getHexValueAsString(tbs, dval, dhex);
//short-circuit if all zeros
if(!nonZero)
{
if(tut->getUlamTypeEnum() == String) //t3953
m_state.abortShouldntGetHere();
fp->write("{ 0 }");
return; //nothing else to do
}
fp->write("{ ");
fp->write(dhex.c_str());
fp->write(" }");
} //printPostfixValueArray
bool SymbolWithValue::getValueAsHexString(std::string& vstr)
{
BV8K dval;
bool oktoprint = getValueReadyToPrint(dval);
if(!oktoprint) return false;
UTI tuti = getUlamTypeIdx();
UlamType * tut = m_state.getUlamTypeByIndex(tuti);
s32 tbs = tut->getTotalBitSize();
if(tbs == 0)
{
vstr = "0"; //no "0x" hex indicates empty array
return true;
}
s32 tnybbles = int(tbs/4); //4 bits per nybble (one Hex digit)
std::ostringstream ostream;
//ostream << "0x"; //no "0x"
for(s32 i = 0; i < tnybbles; i++)
{
ostream << std::hex << dval.Read(i, 4); //per bit?
}
s32 remainder = tbs - tnybbles*4;
if(remainder > 0)
{
//shift left for continguous bits
ostream << std::hex << ((dval.Read(tnybbles*4, remainder)) << (4 - remainder));
}
vstr = ostream.str();
return true;
} //getValueAsHexString
// 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
std::string SymbolClassName::formatAnInstancesArgValuesAsAString(UTI instance)
{
assert(instance == getUlamTypeIdx());
return "10"; //zero args
}
u32 SymbolConstantValue::getConstantStackFrameAbsoluteSlotIndex()
{
assert(!m_state.isScalar(getUlamTypeIdx()));
return m_constantStackFrameAbsoluteSlotIndex;
}
void SymbolConstantValue::setConstantStackFrameAbsoluteSlotIndex(u32 slot)
{
assert(!m_state.isScalar(getUlamTypeIdx()));
assert(slot > 0);
m_constantStackFrameAbsoluteSlotIndex = slot;
}
void SymbolClassName::setSuperClassForClassInstance(UTI superclass, UTI instance)
{
assert(instance == getUlamTypeIdx());
SymbolClass::setSuperClass(superclass);
} //setSuperClassForClassInstance
void SymbolWithValue::printPostfixValueScalar(File * fp)
{
u64 val = 0;
bool oktoprint = getValueReadyToPrint(val);
if(oktoprint)
{
UTI tuti = getUlamTypeIdx();
UlamType * tut = m_state.getUlamTypeByIndex(tuti);
u32 twordsize = tut->getTotalWordSize(); //must be commplete
s32 tbs = tut->getBitSize();
ULAMTYPE etyp = tut->getUlamTypeEnum();
switch(etyp)
{
case Int:
{
if(twordsize <= MAXBITSPERINT)
{
s32 sval = _Int32ToCs32((u32) val, tbs);
fp->write_decimal(sval);
}
else if(twordsize <= MAXBITSPERLONG)
{
s64 sval = _Int64ToCs64(val, tbs);
fp->write_decimal_long(sval);
}
else
m_state.abortGreaterThanMaxBitsPerLong();
}
break;
case Bool:
{
bool bval = _Bool64ToCbool(val, tbs);
if(bval)
fp->write("true");
else
fp->write("false");
}
break;
case Unary:
case Unsigned:
case Bits:
{
// NO CASTING NEEDED, assume saved in its ulam-native format
if( tbs <= MAXBITSPERINT)
fp->write_decimal_unsigned(val);
else if( tbs <= MAXBITSPERLONG)
fp->write_decimal_unsignedlong(val);
else
m_state.abortGreaterThanMaxBitsPerLong(); //TBD > 64
fp->write("u");
}
break;
case String:
// scalar strings generate comments (output value rather than index) e.g. t3951,2
fp->write(m_state.getDataAsFormattedUserString(val).c_str());
break;
default:
m_state.abortUndefinedUlamPrimitiveType();
};
}
else
fp->write("NONREADYCONST");
} //printPostfixValueScalar
// 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
bool SymbolClassName::hasInstanceMappedUTI(UTI instance, UTI auti, UTI& mappedUTI)
{
assert(instance == getUlamTypeIdx());
return SymbolClass::hasMappedUTI(auti, mappedUTI);
} //hasInstanceMappedUTI
void SymbolWithValue::setValue(const BV8K& val)
{
u32 len = m_state.getUlamTypeByIndex(getUlamTypeIdx())->getSizeofUlamType();
val.CopyBV(0u, 0u, len, m_constantValue); //frompos, topos, len, destBV
m_isReady = true;
}
bool SymbolClassName::mapInstanceUTI(UTI instance, UTI auti, UTI mappeduti)
{
assert(instance == getUlamTypeIdx());
return SymbolClass::mapUTItoUTI(auti, mappeduti);
} //mapInstanceUTI
