/*! Compare two value definitions (used in maps) */
INLINE bool operator< (const ValueDef &def0, const ValueDef &def1) {
const ValueDef::Type type0 = def0.getType();
const ValueDef::Type type1 = def1.getType();
if (type0 != type1) return uint32_t(type0) < uint32_t(type1);
if (type0 == ValueDef::DEF_FN_ARG) {
const FunctionArgument *in0 = def0.getFunctionArgument();
const FunctionArgument *in1 = def1.getFunctionArgument();
return uintptr_t(in0) < uintptr_t(in1);
} else if (type0 == ValueDef::DEF_FN_PUSHED) {
const PushLocation *pushed0 = def0.getPushLocation();
const PushLocation *pushed1 = def1.getPushLocation();
return uintptr_t(pushed0) < uintptr_t(pushed1);
} else if (type0 == ValueDef::DEF_SPECIAL_REG) {
const Register reg0 = def0.getSpecialReg();
const Register reg1 = def1.getSpecialReg();
return uint32_t(reg0) < uint32_t(reg1);
} else {
const Instruction *insn0 = def0.getInstruction();
const Instruction *insn1 = def1.getInstruction();
if (insn0 != insn1) return uintptr_t(insn0) < uintptr_t(insn1);
const uint32_t dst0 = def0.getDstID();
const uint32_t dst1 = def1.getDstID();
return dst0 < dst1;
}
}
void TypeInference::inferTypes(
ValueDef& valueDef,
StaticContextPtr& pMemberCtx,
const LogPtr& pLog)
{
switch (valueDef.getValueType())
{
case OBJECT_INIT:
{
const ObjectInitValueDef& objectInitDef = static_cast<const ObjectInitValueDef&>(valueDef);
TypePtr pType = TypePtr(
new ReferenceType(OBJECT_REF_TYPE, objectInitDef.getClassName()));
valueDef.setInferredType(pType);
const map<const wstring, ActualParamDefPtr>& actualParamsMap = objectInitDef.getActualParamsMap();
map<const wstring, ActualParamDefPtr>::const_iterator it;
for (it = actualParamsMap.begin(); it != actualParamsMap.end(); it++)
{
const ActualParamDefPtr& pActualParamDef = (*it).second;
const ValueDefPtr& pParamValueDef = pActualParamDef->getValue();
inferTypes(*pParamValueDef, pMemberCtx, pLog);
}
}
break;
case ARRAY_INIT:
{
const ArrayInitValueDef& arrayInitDef = static_cast<const ArrayInitValueDef&>(valueDef);
valueDef.setInferredType(arrayInitDef.getDeclaredType());
const list<ValueDefPtr>& arrayValues = arrayInitDef.getValues();
list<ValueDefPtr>::const_iterator it;
for (it = arrayValues.begin(); it != arrayValues.end(); it++)
{
const ValueDefPtr& pArrayValue = *it;
inferTypes(*pArrayValue, pMemberCtx, pLog);
}
}
break;
case LITERAL:
{
const LiteralValueDef& literalDef = static_cast<const LiteralValueDef&>(valueDef);
switch (literalDef.getLiteralType())
{
case INTEGER_LITERAL:
valueDef.setInferredType(P_INTEGER_TYPE);
break;
case FLOAT_LITERAL:
valueDef.setInferredType(P_FLOAT_TYPE);
break;
case STRING_LITERAL:
valueDef.setInferredType(P_STRING_TYPE);
break;
default:
assert(false);
break;
}
}
break;
case REFERENCE_PATH:
{
const ReferencePathValueDef& referencePathDef = static_cast<const ReferencePathValueDef&>(valueDef);
const list<const wstring>& path = referencePathDef.getReferencePath();
StaticContextEntryPtr pEntry;
TypePtr pCurrentType;
list<const wstring>::const_iterator it;
wstring parentPath(L"");
for (it = path.begin(); it != path.end(); it++)
{
const wstring& pathElement = *it;
if (it == path.begin())
{
CStaticContextEntryPtr pEntry;
if (!pMemberCtx->lookup(pathElement, pEntry))
{
boost::wformat f(L"Unable to resolve name %1%");
f % pathElement;
pLog->log(referencePathDef, msg::ErrAnaTypeInfer_NameNotInContext, f.str());
return;
}
else
{
switch (pEntry->getStaticEntryType())
{
case CLASS_DEF_CTX_ENTRY:
{
TypePtr pType(new ReferenceType(CLASS_REF_TYPE, pEntry->getName()));
pCurrentType = pType;
}
break;
case INTERFACE_DEF_CTX_ENTRY:
{
TypePtr pType(new ReferenceType(CLASS_REF_TYPE, pEntry->getName()));
pCurrentType = pType;
}
break;
case VARIABLE_DEF_CTX_ENTRY:
{
VariableDeclDefPtr pVariableDef;
pEntry->getVariable(pVariableDef);
if (pMemberCtx->isStatic() && !pVariableDef->isStatic())
{
boost::wformat f(L"Cannot refer to a non static variable from an static context: %1%");
f % pathElement;
pLog->log(referencePathDef, msg::ErrAnaTypeInfer_NonStaticVarRef, f.str());
return;
}
else
{
pCurrentType = pVariableDef->getDeclaredType();
}
}
break;
case FORMAL_PARAM_DEF_CTX_ENTRY:
{
if (pMemberCtx->isStatic())
{
boost::wformat f(L"Cannot refer to a class parameter from an static context: %1%");
f % pathElement;
pLog->log(referencePathDef, msg::ErrAnaTypeInfer_NonStaticParamRef, f.str());
return;
}
FormalParamDefPtr pFormalParamDef;
pEntry->getFormalParam(pFormalParamDef);
pCurrentType = pFormalParamDef->getType();
}
break;
default:
assert(false);
return;
}
}
}
else
{
assert(pCurrentType.get() != NULL);
StaticContextPtr pRootCtx;
pMemberCtx->getRootContext(pRootCtx);
if (!followPathElement(
*pCurrentType,
*pRootCtx,
pathElement,
pCurrentType))
{
boost::wformat f(L"%1% is not a member of %2%");
f % pathElement % parentPath;
pLog->log(referencePathDef, msg::ErrAnaTypeInfer_NotAMember, f.str());
return;
}
}
if (parentPath.size())
{
parentPath.append(L".");
}
parentPath.append(pathElement);
}
assert(pCurrentType.get() != NULL);
valueDef.setInferredType(pCurrentType);
}
break;
default:
assert(false);
break;
}
}
ValueDef::ValueDef(const ValueDef& def) : value(NULL), insn(NULL)
{
set(def.get());
}
void CodeEmitterNVC0::defId(const ValueDef& def, const int pos)
{
code[pos / 32] |= (def.get() ? DDATA(def).id : 63) << (pos % 32);
}
