Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-10 12:32:20 +02:00
Code Activity

Renamed TypeCode_Single to TypeCode_Float. Float struct interop fixes.

Browse source
This commit is contained in:
Brian Fiete 2020-07-03 13:54:45 -07:00
parent 14c3d0cd35
commit 2fe209447e
20 changed files with 595 additions and 69 deletions
Download patch file Download diff file Expand all files Collapse all files

2
IDEHelper/Compiler/BfAst.h
View file

@ -94,7 +94,7 @@ struct BfVariant
{
if (mTypeCode == BfTypeCode_Double)
return mDouble;
if (mTypeCode == BfTypeCode_Single)
if (mTypeCode == BfTypeCode_Float)
return mSingle;
return (double)mInt64;
}

2
IDEHelper/Compiler/BfAutoComplete.cpp
View file

@ -3163,7 +3163,7 @@ String BfAutoComplete::ConstantToString(BfIRConstHolder* constHolder, BfIRValue
case BfTypeCode_Int64:
return StrFormat(":(int64) %lld", constant->mInt64);
case BfTypeCode_Single:
case BfTypeCode_Float:
{
ExactMinimalFloatToStr((float)constant->mDouble, str);
String result;

11
IDEHelper/Compiler/BfExprEvaluator.cpp
View file

@ -2945,7 +2945,7 @@ void BfExprEvaluator::GetLiteral(BfAstNode* refNode, const BfVariant& variant)
mResult = BfTypedValue(mModule->mBfIRBuilder->CreateConst(variant.mTypeCode, variant.mUInt64), mModule->GetPrimitiveType(variant.mTypeCode));
break;
case BfTypeCode_Single:
case BfTypeCode_Float:
mResult = BfTypedValue(mModule->mBfIRBuilder->CreateConst(variant.mTypeCode, variant.mSingle), mModule->GetPrimitiveType(variant.mTypeCode));
break;
case BfTypeCode_Double:
@ -5196,7 +5196,12 @@ void BfExprEvaluator::PushArg(BfTypedValue argVal, SizedArrayImpl<BfIRValue>& ir
{
auto primType2 = mModule->mBfIRBuilder->GetPrimitiveType(loweredTypeCode2);
auto ptrType2 = mModule->mBfIRBuilder->GetPointerTo(primType2);
BfIRValue primPtrVal2 = mModule->mBfIRBuilder->CreateBitCast(mModule->mBfIRBuilder->CreateInBoundsGEP(primPtrVal, 1), ptrType2);
BfIRValue primPtrVal2;
if (mModule->mBfIRBuilder->GetSize(loweredTypeCode) < mModule->mBfIRBuilder->GetSize(loweredTypeCode2))
primPtrVal2 = mModule->mBfIRBuilder->CreateInBoundsGEP(mModule->mBfIRBuilder->CreateBitCast(primPtrVal, ptrType2), 1);
else
primPtrVal2 = mModule->mBfIRBuilder->CreateBitCast(mModule->mBfIRBuilder->CreateInBoundsGEP(primPtrVal, 1), ptrType2);
auto primVal2 = mModule->mBfIRBuilder->CreateLoad(primPtrVal2);
irArgs.push_back(primVal2);
}
@ -5474,7 +5479,7 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, const BfTypedValu
{
auto typeInst = argValue.mType->ToTypeInstance();
if (argValue.mType == mModule->GetPrimitiveType(BfTypeCode_Single))
if (argValue.mType == mModule->GetPrimitiveType(BfTypeCode_Float))
argValue = mModule->Cast(argValues[argIdx].mExpression, argValue, mModule->GetPrimitiveType(BfTypeCode_Double));
if ((typeInst != NULL) && (typeInst->mTypeDef == mModule->mCompiler->mStringTypeDef))

72
IDEHelper/Compiler/BfIRBuilder.cpp
View file

@ -67,7 +67,7 @@ USING_NS_BF;
case BfTypeCode_Char32: val = OP(constLHS->mUInt32, constRHS->mUInt32); break; \
case BfTypeCode_Int64: val = OP(constLHS->mInt64, constRHS->mInt64); break; \
case BfTypeCode_UInt64: val = OP(constLHS->mUInt64, constRHS->mUInt64); break; \
case BfTypeCode_Single: \
case BfTypeCode_Float: \
case BfTypeCode_Double: \
return CreateConst(constLHS->mTypeCode, OP(constLHS->mDouble, constRHS->mDouble)); break; \
default: break; \
@ -121,7 +121,7 @@ USING_NS_BF;
case BfTypeCode_Char32: val = constLHS->mUInt32 OP constRHS->mUInt32; break; \
case BfTypeCode_Int64: val = constLHS->mInt64 OP constRHS->mInt64; break; \
case BfTypeCode_UInt64: val = constLHS->mUInt64 OP constRHS->mUInt64; break; \
case BfTypeCode_Single: \
case BfTypeCode_Float: \
case BfTypeCode_Double: \
return CreateConst(constLHS->mTypeCode, constLHS->mDouble OP constRHS->mDouble); break; \
default: break; \
@ -167,7 +167,7 @@ USING_NS_BF;
case BfTypeCode_Char32: val = OP constVal->mUInt32; break; \
case BfTypeCode_Int64: val = OP constVal->mInt64; break; \
case BfTypeCode_UInt64: val = OP constVal->mUInt64; break; \
case BfTypeCode_Single: \
case BfTypeCode_Float: \
case BfTypeCode_Double: \
return CreateConst(constVal->mTypeCode, OP constVal->mDouble); break; \
default: break; \
@ -198,7 +198,7 @@ USING_NS_BF;
case BfTypeCode_UInt32: val = constLHS->mUInt32 OP constRHS->mUInt32; break; \
case BfTypeCode_Int64: val = constLHS->mInt64 OP constRHS->mInt64; break; \
case BfTypeCode_UInt64: val = constLHS->mUInt64 OP constRHS->mUInt64; break; \
case BfTypeCode_Single: val = constLHS->mDouble OP constRHS->mDouble; break; \
case BfTypeCode_Float: val = constLHS->mDouble OP constRHS->mDouble; break; \
case BfTypeCode_Double: val = constLHS->mDouble OP constRHS->mDouble; break; \
default: break; \
} \
@ -289,6 +289,58 @@ void BfIRConstHolder::FixTypeCode(BfTypeCode& typeCode)
}
}
int BfIRConstHolder::GetSize(BfTypeCode typeCode)
{
switch (typeCode)
{
case BfTypeCode_None: return 0;
case BfTypeCode_CharPtr: return mModule->mSystem->mPtrSize;
case BfTypeCode_StringId: return 4;
case BfTypeCode_Pointer: return mModule->mSystem->mPtrSize;
case BfTypeCode_NullPtr: return mModule->mSystem->mPtrSize;
case BfTypeCode_Self: return 0;
case BfTypeCode_Dot: return 0;
case BfTypeCode_Var: return 0;
case BfTypeCode_Let: return 0;
case BfTypeCode_Boolean: return 1;
case BfTypeCode_Int8: return 1;
case BfTypeCode_UInt8: return 1;
case BfTypeCode_Int16: return 2;
case BfTypeCode_UInt16: return 2;
case BfTypeCode_Int24: return 3;
case BfTypeCode_UInt24: return 3;
case BfTypeCode_Int32: return 4;
case BfTypeCode_UInt32: return 4;
case BfTypeCode_Int40: return 5;
case BfTypeCode_UInt40: return 5;
case BfTypeCode_Int48: return 6;
case BfTypeCode_UInt48: return 6;
case BfTypeCode_Int56: return 7;
case BfTypeCode_UInt56: return 7;
case BfTypeCode_Int64: return 8;
case BfTypeCode_UInt64: return 8;
case BfTypeCode_Int128: return 16;
case BfTypeCode_UInt128: return 16;
case BfTypeCode_IntPtr: return mModule->mSystem->mPtrSize;
case BfTypeCode_UIntPtr: return mModule->mSystem->mPtrSize;
case BfTypeCode_IntUnknown: return 0;
case BfTypeCode_UIntUnknown: return 0;
case BfTypeCode_Char8: return 1;
case BfTypeCode_Char16: return 2;
case BfTypeCode_Char32: return 4;
case BfTypeCode_Float: return 4;
case BfTypeCode_Double: return 8;
case BfTypeCode_Float2: return 8;
case BfTypeCode_Object: return mModule->mSystem->mPtrSize;
case BfTypeCode_Interface: return mModule->mSystem->mPtrSize;
case BfTypeCode_Struct: return 0;
case BfTypeCode_Enum: return 0;
case BfTypeCode_TypeAlias: return 0;
case BfTypeCode_Extension: return 0;
default: return 0;
}
}
bool BfIRConstHolder::IsInt(BfTypeCode typeCode)
{
@ -306,7 +358,7 @@ bool BfIRConstHolder::IsSigned(BfTypeCode typeCode)
bool BfIRConstHolder::IsFloat(BfTypeCode typeCode)
{
return (typeCode == BfTypeCode_Single) ||
return (typeCode == BfTypeCode_Float) ||
(typeCode == BfTypeCode_Double);
}
@ -580,7 +632,7 @@ BfIRValue BfIRConstHolder::CreateConst(BfConstant* fromConst, BfIRConstHolder* f
{
return CreateConst(fromConst->mTypeCode, fromConst->mUInt64);
}
else if ((fromConst->mTypeCode == BfTypeCode_Single) || (fromConst->mTypeCode == BfTypeCode_Double))
else if ((fromConst->mTypeCode == BfTypeCode_Float) || (fromConst->mTypeCode == BfTypeCode_Double))
{
return CreateConst(fromConst->mTypeCode, fromConst->mDouble);
}
@ -1152,7 +1204,7 @@ String BfIRBuilder::ToString(BfIRValue irValue)
{
return constant->mBool ? "true" : "false";
}
else if (constant->mTypeCode == BfTypeCode_Single)
else if (constant->mTypeCode == BfTypeCode_Float)
{
return StrFormat("Constant %ff", constant->mDouble);
}
@ -1705,7 +1757,7 @@ void BfIRBuilder::Write(const BfIRValue& irValue)
switch ((int)constant->mTypeCode)
{
case (int)BfTypeCode_Single:
case (int)BfTypeCode_Float:
{
float f = (float)constant->mDouble;
mStream.Write(&f, sizeof(float));
@ -2247,7 +2299,7 @@ void BfIRBuilder::CreateTypeDeclaration(BfType* type, bool forceDbgDefine)
case BfTypeCode_Char32:
dwarfType = llvm::dwarf::DW_ATE_unsigned_char;
break;
case BfTypeCode_Single:
case BfTypeCode_Float:
case BfTypeCode_Double:
dwarfType = llvm::dwarf::DW_ATE_float;
break;
@ -2609,7 +2661,7 @@ void BfIRBuilder::CreateDbgTypeDefinition(BfType* type)
if (constant != NULL)
{
int64 writeVal = constant->mInt64;
if (constant->mTypeCode == BfTypeCode_Single)
if (constant->mTypeCode == BfTypeCode_Float)
{
// We need to do this because Singles are stored in mDouble, so we need to reduce here
float floatVal = (float)constant->mDouble;

6
IDEHelper/Compiler/BfIRBuilder.h
View file

@ -115,8 +115,9 @@ enum BfTypeCode : uint8
BfTypeCode_Char8,
BfTypeCode_Char16,
BfTypeCode_Char32,
BfTypeCode_Single,
BfTypeCode_Double,
BfTypeCode_Float,
BfTypeCode_Double,
BfTypeCode_Float2,
BfTypeCode_Object,
BfTypeCode_Interface,
BfTypeCode_Struct,
@ -846,6 +847,7 @@ public:
public:
void FixTypeCode(BfTypeCode& typeCode);
int GetSize(BfTypeCode typeCode);
static bool IsInt(BfTypeCode typeCode);
static bool IsSigned(BfTypeCode typeCode);
static bool IsFloat(BfTypeCode typeCode);

8
IDEHelper/Compiler/BfIRCodeGen.cpp
View file

@ -420,7 +420,7 @@ BfTypeCode BfIRCodeGen::GetTypeCode(llvm::Type* type, bool isSigned)
}
if (type->isFloatingPointTy())
return BfTypeCode_Single;
return BfTypeCode_Float;
if (type->isDoubleTy())
return BfTypeCode_Double;
@ -509,10 +509,12 @@ llvm::Type* BfIRCodeGen::GetLLVMType(BfTypeCode typeCode, bool& isSigned)
return llvm::Type::getInt32Ty(*mLLVMContext);
else
return llvm::Type::getInt64Ty(*mLLVMContext);*/
case BfTypeCode_Single:
case BfTypeCode_Float:
return llvm::Type::getFloatTy(*mLLVMContext);
case BfTypeCode_Double:
return llvm::Type::getDoubleTy(*mLLVMContext);
case BfTypeCode_Float2:
return llvm::VectorType::get(llvm::Type::getFloatTy(*mLLVMContext), 2);
default: break;
}
return NULL;
@ -826,7 +828,7 @@ void BfIRCodeGen::Read(llvm::Value*& llvmValue, BfIRCodeGenEntry** codeGenEntry)
bool isSigned;
llvm::Type* llvmConstType = GetLLVMType(typeCode, isSigned);
if (typeCode == BfTypeCode_Single)
if (typeCode == BfTypeCode_Float)
{
float f;
mStream->Read(&f, sizeof(float));

6
IDEHelper/Compiler/BfMangler.cpp
View file

@ -73,7 +73,7 @@ BfTypeCode BfGNUMangler::GetPrimTypeAt(MangleContext& mangleContext, StringImpl&
else if (name[strIdx + 1] == 's')
return BfTypeCode_Char16;
break;
case 'f': return BfTypeCode_Single;
case 'f': return BfTypeCode_Float;
case 'd': return BfTypeCode_Double;
}
return (BfTypeCode)-1;
@ -485,7 +485,7 @@ void BfGNUMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfType
name += "Ds"; return;
case BfTypeCode_Char32:
name += "Di"; return;
case BfTypeCode_Single:
case BfTypeCode_Float:
name += "f"; return;
case BfTypeCode_Double:
name += "d"; return;
@ -1495,7 +1495,7 @@ void BfMSMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfType*
name += "D"; return;
case BfTypeCode_Char16:
name += "_S"; return; //char16_t
case BfTypeCode_Single:
case BfTypeCode_Float:
name += "M"; return;
case BfTypeCode_Double:
name += "N"; return;

14
IDEHelper/Compiler/BfModule.cpp
View file

@ -5619,7 +5619,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
{
PUSH_INT32(constant->mInt32);
}
else if (constant->mTypeCode == BfTypeCode_Single)
else if (constant->mTypeCode == BfTypeCode_Float)
{
float val = (float)constant->mDouble;
PUSH_INT32(*(int*)&val);
@ -6696,7 +6696,7 @@ void BfModule::ResolveGenericParamConstraints(BfGenericParamInstance* genericPar
case BfTypeCode_UIntPtr:
case BfTypeCode_IntUnknown:
case BfTypeCode_UIntUnknown:
case BfTypeCode_Single:
case BfTypeCode_Float:
case BfTypeCode_Double:
case BfTypeCode_Char8:
case BfTypeCode_Char16:
@ -9843,7 +9843,7 @@ BfTypedValue BfModule::GetTypedValueFromConstant(BfConstant* constant, BfIRConst
case BfTypeCode_Char8:
case BfTypeCode_Char16:
case BfTypeCode_Char32:
case BfTypeCode_Single:
case BfTypeCode_Float:
case BfTypeCode_Double:
{
auto constVal = mBfIRBuilder->CreateConst(constant, constHolder);
@ -10586,7 +10586,7 @@ BfVariant BfModule::TypedValueToVariant(BfAstNode* refNode, const BfTypedValue&
case BfTypeCode_UIntPtr:
case BfTypeCode_IntUnknown:
case BfTypeCode_UIntUnknown:
case BfTypeCode_Single:
case BfTypeCode_Float:
case BfTypeCode_Double:
case BfTypeCode_Char8:
case BfTypeCode_Char16:
@ -17267,7 +17267,11 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup)
auto primType2 = mBfIRBuilder->GetPrimitiveType(loweredTypeCode2);
auto primPtrType2 = mBfIRBuilder->GetPointerTo(primType2);
auto primPtrVal2 = mBfIRBuilder->CreateBitCast(mBfIRBuilder->CreateInBoundsGEP(primPtrVal, 1), primPtrType2);
BfIRValue primPtrVal2;
if (mBfIRBuilder->GetSize(loweredTypeCode) < mBfIRBuilder->GetSize(loweredTypeCode2))
primPtrVal2 = mBfIRBuilder->CreateInBoundsGEP(mBfIRBuilder->CreateBitCast(primPtrVal, primPtrType2), 1);
else
primPtrVal2 = mBfIRBuilder->CreateBitCast(mBfIRBuilder->CreateInBoundsGEP(primPtrVal, 1), primPtrType2);
mBfIRBuilder->CreateStore(mBfIRBuilder->GetArgument(argIdx + 1), primPtrVal2);
}

12
IDEHelper/Compiler/BfModuleTypeUtils.cpp
View file

@ -1181,7 +1181,7 @@ bool BfModule::PopulateType(BfType* resolvedTypeRef, BfPopulateType populateType
case BfTypeCode_Char32:
PRIMITIVE_TYPE("char32", Int32, 4, DW_ATE_unsigned_char);
return true;
case BfTypeCode_Single:
case BfTypeCode_Float:
PRIMITIVE_TYPE("float", Float, 4, DW_ATE_float);
return true;
case BfTypeCode_Double:
@ -4688,7 +4688,7 @@ BfPrimitiveType* BfModule::GetPrimitiveType(BfTypeCode typeCode)
case BfTypeCode_Char32:
primType = (BfPrimitiveType*)ResolveTypeDef(mSystem->mTypeChar32);
break;
case BfTypeCode_Single:
case BfTypeCode_Float:
primType = (BfPrimitiveType*)ResolveTypeDef(mSystem->mTypeSingle);
break;
case BfTypeCode_Double:
@ -4968,7 +4968,7 @@ BfTypeInstance* BfModule::GetPrimitiveStructType(BfTypeCode typeCode)
typeInst = ResolveTypeDef(mSystem->FindTypeDef("System.Char16"), BfPopulateType_Identity)->ToTypeInstance(); break;
case BfTypeCode_Char32:
typeInst = ResolveTypeDef(mSystem->FindTypeDef("System.Char32"), BfPopulateType_Identity)->ToTypeInstance(); break;
case BfTypeCode_Single:
case BfTypeCode_Float:
typeInst = ResolveTypeDef(mSystem->FindTypeDef("System.Float"), BfPopulateType_Identity)->ToTypeInstance(); break;
case BfTypeCode_Double:
typeInst = ResolveTypeDef(mSystem->FindTypeDef("System.Double"), BfPopulateType_Identity)->ToTypeInstance(); break;
@ -9646,7 +9646,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp
default: break;
}
break;
case BfTypeCode_Single:
case BfTypeCode_Float:
switch (fromTypeCode)
{
case BfTypeCode_Int8:
@ -9683,7 +9683,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp
case BfTypeCode_UIntPtr:
case BfTypeCode_UIntUnknown:
allowCast = true; break;
case BfTypeCode_Single:
case BfTypeCode_Float:
allowCast = true; break;
default: break;
}
@ -10764,7 +10764,7 @@ void BfModule::VariantToString(StringImpl& str, const BfVariant& variant)
case BfTypeCode_UInt64:
str += StrFormat("%llu", variant.mInt64);
break;
case BfTypeCode_Single:
case BfTypeCode_Float:
{
char cstr[64];
ExactMinimalFloatToStr(variant.mSingle, cstr);

4
IDEHelper/Compiler/BfParser.cpp
View file

@ -2374,7 +2374,7 @@ void BfParser::NextToken(int endIdx)
if ((c == 'f') || (c == 'F'))
{
mTokenEnd = mSrcIdx;
mLiteral.mTypeCode = BfTypeCode_Single;
mLiteral.mTypeCode = BfTypeCode_Float;
mLiteral.mSingle = (float)ParseLiteralDouble();//(float)dVal;
mSyntaxToken = BfSyntaxToken_Literal;
return;
@ -2547,7 +2547,7 @@ void BfParser::NextToken(int endIdx)
else if ((c == 'f') || (c == 'F'))
{
mTokenEnd = mSrcIdx;
mLiteral.mTypeCode = BfTypeCode_Single;
mLiteral.mTypeCode = BfTypeCode_Float;
mLiteral.mSingle = (float)ParseLiteralDouble();//(float)val;
mSyntaxToken = BfSyntaxToken_Literal;
return;

132
IDEHelper/Compiler/BfResolvedTypeUtils.cpp
View file

@ -1470,27 +1470,121 @@ bool BfTypeInstance::GetLoweredType(BfTypeUsage typeUsage, BfTypeCode* outTypeCo
return false;
}
else
{
{
// Non-Windows systems allow lowered splitting of composites over two int params
if (mModule->mSystem->mPtrSize == 8)
{
if (mInstSize == 12)
{
if (outTypeCode != NULL)
*outTypeCode = BfTypeCode_Int64;
if (outTypeCode2 != NULL)
*outTypeCode2 = BfTypeCode_Int32;
return true;
}
if (mInstSize == 16)
{
if (outTypeCode != NULL)
*outTypeCode = BfTypeCode_Int64;
if (outTypeCode2 != NULL)
*outTypeCode2 = BfTypeCode_Int64;
return true;
}
if ((mInstSize >= 4) && (mInstSize <= 16))
{
BfTypeCode types[4] = { BfTypeCode_None };
std::function<void(BfType*, int)> _CheckType = [&](BfType* type, int offset)
{
if (auto typeInst = type->ToTypeInstance())
{
if (typeInst->IsValueType())
{
if (typeInst->mBaseType != NULL)
_CheckType(typeInst->mBaseType, offset);
for (auto& fieldInstance : typeInst->mFieldInstances)
{
if (fieldInstance.mDataOffset >= 0)
_CheckType(fieldInstance.mResolvedType, offset + fieldInstance.mDataOffset);
}
}
else
types[offset / 4] = BfTypeCode_Object;
}
else if (type->IsPrimitiveType())
{
auto primType = (BfPrimitiveType*)type;
types[offset / 4] = primType->mTypeDef->mTypeCode;
}
else if (type->IsSizedArray())
{
auto sizedArray = (BfSizedArrayType*)type;
for (int i = 0; i < sizedArray->mElementCount; i++)
_CheckType(sizedArray->mElementType, offset + i * sizedArray->mElementType->GetStride());
}
};
_CheckType(this, 0);
bool handled = false;
if (mInstSize >= 8)
{
if (outTypeCode != NULL)
*outTypeCode = BfTypeCode_Int64;
}
if (mInstSize == 8)
{
handled = true;
}
if (mInstSize == 9)
{
handled = true;
if (outTypeCode2 != NULL)
*outTypeCode2 = BfTypeCode_Int8;
}
if (mInstSize == 10)
{
handled = true;
if (outTypeCode2 != NULL)
*outTypeCode2 = BfTypeCode_Int16;
}
if (mInstSize == 12)
{
handled = true;
if (outTypeCode2 != NULL)
*outTypeCode2 = BfTypeCode_Int32;
}
if (mInstSize == 16)
{
handled = true;
if (outTypeCode2 != NULL)
*outTypeCode2 = BfTypeCode_Int64;
}
if ((types[0] == BfTypeCode_Float) && (types[1] == BfTypeCode_None))
{
handled = true;
if (outTypeCode != NULL)
*outTypeCode = BfTypeCode_Float;
}
if ((types[0] == BfTypeCode_Float) && (types[1] == BfTypeCode_Float))
{
if (outTypeCode != NULL)
*outTypeCode = BfTypeCode_Float2;
}
if (types[0] == BfTypeCode_Double)
{
if (outTypeCode != NULL)
*outTypeCode = BfTypeCode_Double;
}
if ((types[2] == BfTypeCode_Float) && (mInstSize == 12))
{
if (outTypeCode2 != NULL)
*outTypeCode2 = BfTypeCode_Float;
}
if ((types[2] == BfTypeCode_Float) && (types[3] == BfTypeCode_Float))
{
if (outTypeCode2 != NULL)
*outTypeCode2 = BfTypeCode_Float2;
}
if (types[2] == BfTypeCode_Double)
{
if (outTypeCode2 != NULL)
*outTypeCode2 = BfTypeCode_Double;
}
if (handled)
return true;
}
}
}
@ -2267,7 +2361,7 @@ BfVariant BfResolvedTypeSet::EvaluateToVariant(LookupContext* ctx, BfExpression*
// when the constraint requirement is int64 (but we don't know that at hash time)
if (BfIRConstHolder::IsInt(variant.mTypeCode))
variant.mTypeCode = BfTypeCode_Int64;
else if (variant.mTypeCode == BfTypeCode_Single)
else if (variant.mTypeCode == BfTypeCode_Float)
{
variant.mTypeCode = BfTypeCode_Double;
variant.mDouble = variant.mSingle;

4
IDEHelper/Compiler/BfResolvedTypeUtils.h
View file

@ -588,13 +588,13 @@ public:
virtual bool IsSigned() override { return (mTypeDef->mTypeCode == BfTypeCode_Int8) || (mTypeDef->mTypeCode == BfTypeCode_Int16) ||
(mTypeDef->mTypeCode == BfTypeCode_Int32) || (mTypeDef->mTypeCode == BfTypeCode_Int64) || (mTypeDef->mTypeCode == BfTypeCode_IntPtr) ||
(mTypeDef->mTypeCode == BfTypeCode_IntUnknown) ||
(mTypeDef->mTypeCode == BfTypeCode_Single) || (mTypeDef->mTypeCode == BfTypeCode_Double); }
(mTypeDef->mTypeCode == BfTypeCode_Float) || (mTypeDef->mTypeCode == BfTypeCode_Double); }
virtual bool IsSignedInt() override { return (mTypeDef->mTypeCode == BfTypeCode_Int8) || (mTypeDef->mTypeCode == BfTypeCode_Int16) ||
(mTypeDef->mTypeCode == BfTypeCode_Int32) || (mTypeDef->mTypeCode == BfTypeCode_Int64) || (mTypeDef->mTypeCode == BfTypeCode_IntPtr) ||
(mTypeDef->mTypeCode == BfTypeCode_IntUnknown); }
virtual bool IsIntUnknown() override { return (mTypeDef->mTypeCode == BfTypeCode_IntUnknown) || (mTypeDef->mTypeCode == BfTypeCode_UIntUnknown); }
virtual bool IsChar() override { return (mTypeDef->mTypeCode == BfTypeCode_Char8) || (mTypeDef->mTypeCode == BfTypeCode_Char16) || (mTypeDef->mTypeCode == BfTypeCode_Char32); }
virtual bool IsFloat() override { return (mTypeDef->mTypeCode == BfTypeCode_Single) || (mTypeDef->mTypeCode == BfTypeCode_Double); }
virtual bool IsFloat() override { return (mTypeDef->mTypeCode == BfTypeCode_Float) || (mTypeDef->mTypeCode == BfTypeCode_Double); }
virtual bool IsNull() override { return mTypeDef->mTypeCode == BfTypeCode_NullPtr; }
virtual bool IsVoid() override { return mTypeDef->mTypeCode == BfTypeCode_None; }
virtual bool CanBeValuelessType() override { return mTypeDef->mTypeCode == BfTypeCode_None; }

2
IDEHelper/Compiler/BfSystem.cpp
View file

@ -2048,7 +2048,7 @@ void BfSystem::CreateBasicTypes()
SYSTEM_TYPE(mTypeChar8, "char8", BfTypeCode_Char8);
SYSTEM_TYPE(mTypeChar16, "char16", BfTypeCode_Char16);
SYSTEM_TYPE(mTypeChar32, "char32", BfTypeCode_Char32);
SYSTEM_TYPE(mTypeSingle, "float", BfTypeCode_Single);
SYSTEM_TYPE(mTypeSingle, "float", BfTypeCode_Float);
SYSTEM_TYPE(mTypeDouble, "double", BfTypeCode_Double);
}