Exemplo n.º 1
0
    private static string MangleDefaultConstructorName(ES_TypeInfo *typeName, bool isStatic)
    {
        // Sample name: "struct.System.Numerics__Vector2"
        using var mangleChars = new StructPooledList <char> (CL_ClearMode.Auto);

        // The prefix.
        if (!isStatic)
        {
            mangleChars.AddRange("defaultConstructor!");
        }
        else
        {
            mangleChars.AddRange("defaultStaticConstructor!");
        }

        // The namespace.
        var namespaceName = typeName->Name.NamespaceName.Span;

        ES_Encodings.Identifier.GetChars(namespaceName, mangleChars.AddSpan(namespaceName.Length));

        // The mangled namespace separator.
        mangleChars.Add('_', 2);

        // The function name.
        var structName = typeName->Name.TypeName.Span;

        ES_Encodings.Identifier.GetChars(structName, mangleChars.AddSpan(structName.Length));

        return(mangleChars.Span.GetPooledString());
    }
Exemplo n.º 2
0
    private void CreateFunctions_Function(
        ref TranslationUnitData transUnit, ES_NamespaceData.Builder namespaceBuilder,
        SymbolStack <FrontendSymbol> symbols, SourceData unitSrc,
        ES_TypeInfo *parentType, ES_AstFunctionDefinition funcDef
        )
    {
        Debug.Assert(Environment is not null);
        Debug.Assert(EnvironmentBuilder is not null);

        var sourceUnit = transUnit.Name;
        var idPool     = Environment.IdPool;

        // Get the namespace and function names.
        var funcName = Environment.IdPool.GetIdentifier(funcDef.Name.Text.Span);

        // Get the fully-qualified name.
        ES_FullyQualifiedName fullyQualifiedName;

        if (parentType == null)
        {
            var namespaceName = namespaceBuilder.NamespaceData.NamespaceName;
            fullyQualifiedName = new ES_FullyQualifiedName(namespaceName, funcName);
        }
        else
        {
            using var namespaceBytes = UnmanagedArray <byte> .GetArray(parentType->Name.NamespaceName.Length + 2 + parentType->Name.TypeName.Length);

            var span = namespaceBytes.Span;

            parentType->Name.NamespaceName.Span.CopyTo(span);
            span = span [parentType->Name.NamespaceName.Length..];
Exemplo n.º 3
0
    public ES_ArrayTypeData(ES_FullyQualifiedName fullyQualifiedName, [NotNull] ES_TypeInfo *elemType, int dims)
    {
        TypeInfo             = new (ES_TypeTag.Array, ES_AccessModifier.Public, ES_TypeFlag.None, ArrayPointer <byte> .Null, fullyQualifiedName);
        TypeInfo.RuntimeSize = sizeof(void *) + sizeof(int);

        elementType = elemType;
        dimCount    = dims;
    }
Exemplo n.º 4
0
    private bool TypeSizing_AnalyzeCycles_Traverse([NotNull] ES_TypeInfo *innerType, [NotNull] ES_TypeInfo *containingType)
    {
        switch (innerType->TypeTag)
        {
        case ES_TypeTag.Struct:
        case ES_TypeTag.Class:
            break;

        case ES_TypeTag.Const:
        case ES_TypeTag.Immutable: {
            var constData = (ES_ConstData *)innerType;
            return(TypeSizing_AnalyzeCycles_Traverse(constData->InnerType, containingType));
        }

        case ES_TypeTag.Array:
        case ES_TypeTag.Void:
        case ES_TypeTag.Bool:
        case ES_TypeTag.Int:
        case ES_TypeTag.Float:
        case ES_TypeTag.Function:
        case ES_TypeTag.Enum:
        case ES_TypeTag.Interface:
        case ES_TypeTag.Reference:
            return(false);

        default:
            throw new NotImplementedException("Type not implemented yet.");
        }

        foreach (var memberAddr in innerType->MembersList.MembersList.Span)
        {
            var member = memberAddr.Address;

            if (member->MemberType != ES_MemberType.Field)
            {
                continue;
            }

            if (member->Flags.HasFlag(ES_MemberFlags.Static))
            {
                continue;
            }

            var field = (ES_MemberData_Variable *)member;

            if (field->Type == containingType)
            {
                return(true);
            }

            if (TypeSizing_AnalyzeCycles_Traverse(field->Type, containingType))
            {
                return(true);
            }
        }

        return(false);
    }
Exemplo n.º 5
0
 public ES_MemberData_Variable(
     ArrayPointer <byte> name, ArrayPointer <byte> srcUnit, ES_AccessModifier accessMod,
     ES_MemberFlags flags, int offset, ES_TypeInfo *type
     )
 {
     Info   = new ES_MemberData(accessMod, ES_MemberType.Field, flags, name, srcUnit);
     Offset = offset;
     Type   = type;
 }
Exemplo n.º 6
0
    private unsafe void AddTypeToTree(ES_TypeInfo *typeData, TreeViewItem parentItem)
    {
        string typeType = null;

        typeType = typeData->TypeTag switch {
            ES_TypeTag.Void => "Void",
            ES_TypeTag.Bool => "Bool",
            ES_TypeTag.Int => "Int",
            ES_TypeTag.Float => "Float",
            ES_TypeTag.Enum => "Enum",

            ES_TypeTag.Struct => "Struct",
            ES_TypeTag.Class => "Class",
            ES_TypeTag.Interface => "Interface",

            ES_TypeTag.Function => "Prototype",

            ES_TypeTag.Reference => "Reference",
            ES_TypeTag.Array => "Array",

            ES_TypeTag.Const => "Const",
            ES_TypeTag.Immutable => "Immutable",

            _ => "[UNRECOGNIZED]",
        };
        var typeNode = AddNodeToTree($"{typeType} {typeData->Name.TypeNameString}", parentItem);

        AddNodeToTree($"Runtime size: {typeData->RuntimeSize}", typeNode);
        AddNodeToTree($"Fully qualified name: {typeData->Name.GetNameAsTypeString ()}", typeNode);
        AddNodeToTree($"Source unit: {typeData->SourceUnitString}", typeNode);

        if (typeData->TypeTag == ES_TypeTag.Function)
        {
            var funcData = (ES_FunctionPrototypeData *)typeData;

            AddNodeToTree($"Return type: {funcData->ReturnType->Name.GetNameAsTypeString ()}", typeNode);

            var argsListNode = AddNodeToTree($"Arguments list", typeNode);
            foreach (var arg in funcData->ArgumentsList.Span)
            {
                var    argType = arg.ArgType.ToString();
                string argTypeName;

                if (arg.ValueType != null)
                {
                    argTypeName = arg.ValueType->Name.GetNameAsTypeString();
                }
                else
                {
                    argTypeName = "[NULL]";
                }

                AddNodeToTree($"{argType} {argTypeName}", argsListNode);
            }
        }
    }
Exemplo n.º 7
0
    public static T *AllocObject <T> (ES_TypeInfo *type, bool pinned, T defaultVal = default) where T : unmanaged
    {
        EnsureInitialized();

        var ptr = (T *)garbageCollector !.AllocateObject(type, pinned);

        *ptr = defaultVal;

        return(ptr);
    }
Exemplo n.º 8
0
        public static ExpressionData NewType(ES_AstExpression expr, ES_TypeInfo *typeInfo)
        {
            return(new ExpressionData {
                Expr = expr,
                TypeInfo = typeInfo,

                Type = null,
                Function = null
            });
        }
Exemplo n.º 9
0
    public ES_ConstData(
        ES_FullyQualifiedName fullyQualifiedName, ES_TypeInfo *innerType, bool immutable
        )
    {
        var tag = immutable ? ES_TypeTag.Immutable : ES_TypeTag.Const;

        TypeInfo = new ES_TypeInfo(tag, ES_AccessModifier.Public, ES_TypeFlag.None, ArrayPointer <byte> .Null, fullyQualifiedName);

        InnerType = innerType;
    }
Exemplo n.º 10
0
    public ES_FunctionPrototypeData(ES_AccessModifier accessMod,
                                    ES_TypeInfo *retType, ArrayPointer <ES_FunctionPrototypeArgData> argsList,
                                    ES_FullyQualifiedName fullyQualifiedName, ArrayPointer <byte> sourceUnit
                                    )
    {
        TypeInfo             = new (ES_TypeTag.Function, accessMod, ES_TypeFlag.NoNew, sourceUnit, fullyQualifiedName);
        TypeInfo.RuntimeSize = IntPtr.Size;

        returnType    = retType;
        argumentsList = argsList;
    }
Exemplo n.º 11
0
    private static bool FoldConstants_EnsureCompat(ES_TypeInfo *dstType, ref ES_AstExpression expr)
    {
        if (dstType is null)
        {
            return(false);
        }

        switch (expr)
        {
        case ES_AstFloat32ConstantExpression exprFlt64: {
            if (dstType->TypeTag != ES_TypeTag.Float)
            {
                return(false);
            }

            var dstTypeFlt = (ES_FloatTypeData *)dstType;
            if (dstTypeFlt->FloatSize < ES_FloatSize.Single)
            {
                return(false);
            }

            switch (dstTypeFlt->FloatSize)
            {
            case ES_FloatSize.Single:
                return(true);

            case ES_FloatSize.Double:
                expr = new ES_AstFloat64ConstantExpression(exprFlt64.Value, expr);
                return(true);

            default:
                throw new NotImplementedException("Size not implemented.");
            }
        }

        case ES_AstFloat64ConstantExpression exprFlt64: {
            if (dstType->TypeTag != ES_TypeTag.Float)
            {
                return(false);
            }

            var dstTypeFlt = (ES_FloatTypeData *)dstType;
            if (dstTypeFlt->FloatSize < ES_FloatSize.Double)
            {
                return(false);
            }

            return(dstTypeFlt->FloatSize switch {
                    ES_FloatSize.Double => true,

                    _ => throw new NotImplementedException("Size not implemented."),
                });
        }
Exemplo n.º 12
0
    private static ExpressionSyntax CompileCode_NewObject(ES_TypeInfo *type, ExpressionSyntax?assignValue)
    {
        var isReference = type->TypeTag == ES_TypeTag.Reference;

        // Get the roslyn type.
        var intPtrType = IdentifierName(nameof(IntPtr));
        var roslynType = GetRoslynType(type);

        // Generate the member access.
        var accessExpr = MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                IdentifierName(nameof(ES_GarbageCollector)),
                                                GenericName(Identifier(nameof(ES_GarbageCollector.AllocObject))).WithTypeArgumentList(
                                                    TypeArgumentList(SingletonSeparatedList(!isReference ? roslynType : intPtrType))
                                                    )
                                                );

        // Construct the args list.
        using var argsList = new StructPooledList <SyntaxNodeOrToken> (CL_ClearMode.Auto);
        argsList.EnsureCapacity(3);

        // Generate the pointer type syntax for the type pointer.
        var pointerTypeSyntax = PointerType(IdentifierName(nameof(ES_TypeInfo)));

        // Add the type pointer.
        argsList.Add(Argument(PointerLiteral(type, pointerTypeSyntax)));

        // Add the "pinned" bool.
        argsList.Add(Token(SyntaxKind.CommaToken));
        argsList.Add(Argument(BoolLiteral(false)));

        // Add the value to assign.
        if (assignValue is not null)
        {
            argsList.Add(Token(SyntaxKind.CommaToken));
            if (isReference)
            {
                assignValue = CastExpression(intPtrType, assignValue);
            }
            argsList.Add(Argument(assignValue));
        }

        // Generate the function call.
        ExpressionSyntax ret = InvocationExpression(accessExpr)
                               .WithArgumentList(ArgumentList(SeparatedListSpan <ArgumentSyntax> (argsList.Span)));

        if (isReference)
        {
            ret = CastExpression(PointerType(roslynType), ret);
        }

        return(ret);
    }
Exemplo n.º 13
0
    public ES_ReferenceData(
        ES_FullyQualifiedName fullyQualifiedName, ES_TypeInfo *pointedType
        )
    {
        TypeInfo = new (ES_TypeTag.Reference, ES_AccessModifier.Public, ES_TypeFlag.None, ArrayPointer <byte> .Null, fullyQualifiedName) {
            RuntimeSize = sizeof(void *)
        };

        PointedType = pointedType;
    }

    #endregion
}
Exemplo n.º 14
0
    private static ES_TypeInfo *StripFirstConst(ES_TypeInfo *type)
    {
        switch (type->TypeTag)
        {
        case ES_TypeTag.Const:
        case ES_TypeTag.Immutable: {
            var constData = (ES_ConstData *)type;
            return(constData->InnerType);
        }

        default:
            return(type);
        }
    }
Exemplo n.º 15
0
    internal static string MangleMemberFunctionName([DisallowNull] ES_TypeInfo *owner, [DisallowNull] ES_FunctionData *func)
    {
        using var mangleChars = new StructPooledList <char> (CL_ClearMode.Auto);

        // The type name.
        mangleChars.AddRange(owner->Name.TypeNameString);

        // The mangled namespace separator.
        mangleChars.AddRange("__");

        // The function name.
        mangleChars.AddRange(func->Name.TypeNameString);

        return(mangleChars.Span.GetPooledString());
    }
Exemplo n.º 16
0
    private static TypeSyntax GetRoslynType(ES_TypeInfo *type)
    {
        switch (type->TypeTag)
        {
        case ES_TypeTag.Void: return(PredefinedType(Token(SyntaxKind.VoidKeyword)));

        case ES_TypeTag.Bool: return(PredefinedType(Token(SyntaxKind.BoolKeyword)));

        case ES_TypeTag.Int: {
            var intType = (ES_IntTypeData *)type;
            return(GetIntType(intType->IntSize, intType->Unsigned));
        }

        case ES_TypeTag.Float: {
            var floatType = (ES_FloatTypeData *)type;
            return(GetFloatType(floatType->FloatSize));
        }

        case ES_TypeTag.Struct: return(IdentifierName(MangleTypeName(type)));

        case ES_TypeTag.Reference: {
            var pointerType = (ES_ReferenceData *)type;
            var pointedType = GetRoslynType(pointerType->PointedType);
            return(PointerType(pointedType));
        }

        case ES_TypeTag.Array: return(PointerType(IdentifierName(MangleTypeName(type))));

        case ES_TypeTag.Function:
        case ES_TypeTag.Class:
        case ES_TypeTag.Enum:
        case ES_TypeTag.Interface:

        case ES_TypeTag.Const:
        case ES_TypeTag.Immutable: {
            var constData = (ES_ConstData *)type;
            return(GetRoslynType(constData->InnerType));
        }

        default:
            throw new NotImplementedException("Type not implemented.");
        }
    }
Exemplo n.º 17
0
    internal static bool UnaryOpCompat(
        EchelonScriptEnvironment env,
        ES_TypeInfo *exprType,
        SimpleUnaryExprType op,
        out ES_TypeInfo *finalType,
        out bool isConst
        )
    {
        finalType = env.TypeUnknownValue;
        isConst   = false;

        return(exprType->TypeTag switch {
            ES_TypeTag.Int => UnaryOpCompat_Int(env, exprType, op, out finalType, out isConst),
            ES_TypeTag.Bool => UnaryOpCompat_Bool(env, exprType, op, out finalType, out isConst),
            ES_TypeTag.Float => UnaryOpCompat_Float(env, exprType, op, out finalType, out isConst),
            ES_TypeTag.Reference => UnaryOpCompat_Ref(env, exprType, op, out finalType, out isConst),

            _ => false,
        });
Exemplo n.º 18
0
    private unsafe string GetTypeName(ES_TypeInfo *type)
    {
        switch (type->TypeTag)
        {
        case ES_TypeTag.UNKNOWN: return("[UNKNOWN]");

        case ES_TypeTag.Null: return("[null]");

        case ES_TypeTag.Reference: {
            var refData = (ES_ReferenceData *)type;
            return($"{GetTypeName (refData->PointedType)}&");
        }

        case ES_TypeTag.Array: {
            var arrData = (ES_ArrayTypeData *)type;

            var dimCount  = arrData->DimensionsCount;
            var dimString = dimCount > 1 ? new string (',', arrData->DimensionsCount - 1) : string.Empty;

            return($"{GetTypeName (arrData->ElementType)} [{dimString}]");
        }

        /*case ES_TypeTag.Const:
         * case ES_TypeTag.Immutable:
         *  return "Const/Immutable [NOT IMPLEMENTED INTERNALLY]";*/

        case ES_TypeTag.Void:
        case ES_TypeTag.Bool:
        case ES_TypeTag.Int:
        case ES_TypeTag.Float:
            return(type->Name.TypeNameString);

        //case ES_TypeTag.Function: return "Function [NOT IMPLEMENTED]";

        case ES_TypeTag.Struct:
        case ES_TypeTag.Class:
        case ES_TypeTag.Interface:
        case ES_TypeTag.Enum:
            return(type->Name.GetNameAsTypeString());

        default: return($"{type->TypeTag} [NOT IMPLEMENTED]");
        }
    }
Exemplo n.º 19
0
    public static bool BinaryOpCompat(
        EchelonScriptEnvironment env,
        ES_TypeInfo *lhsType, ES_TypeInfo *rhsType,
        SimpleBinaryExprType exprType,
        out ES_TypeInfo *finalType,
        out bool isConst
        )
    {
        finalType = env.TypeUnknownValue;

        if (lhsType->TypeTag == ES_TypeTag.UNKNOWN || rhsType->TypeTag == ES_TypeTag.UNKNOWN)
        {
            isConst = false;
            return(true);
        }

        if (lhsType->TypeTag == ES_TypeTag.Null || rhsType->TypeTag == ES_TypeTag.Null)
        {
            return(BinaryOpCompat_Null(env, lhsType, rhsType, exprType, out finalType, out isConst));
        }

        return((lhsType->TypeTag, rhsType->TypeTag) switch {
            (ES_TypeTag.Int, ES_TypeTag.Int) =>
            BinaryOpCompat_IntInt(env, lhsType, rhsType, exprType, out finalType, out isConst),

            (ES_TypeTag.Bool, ES_TypeTag.Bool) =>
            BinaryOpCompat_BoolBool(env, lhsType, rhsType, exprType, out finalType, out isConst),

            (ES_TypeTag.Float, ES_TypeTag.Float) =>
            BinaryOpCompat_FloatFloat(env, lhsType, rhsType, exprType, out finalType, out isConst),

            (ES_TypeTag.Float, ES_TypeTag.Int) =>
            BinaryOpCompat_FloatInt(env, lhsType, rhsType, exprType, out finalType, out isConst),

            (ES_TypeTag.Reference, ES_TypeTag.Reference) =>
            BinaryOpCompat_RefRef(env, lhsType, rhsType, exprType, out finalType, out isConst),

            (ES_TypeTag.Array, ES_TypeTag.Array) =>
            BinaryOpCompat_ArrayArray(env, lhsType, rhsType, exprType, out finalType, out isConst),

            _ => isConst = false,
        });
Exemplo n.º 20
0
    private void CreateTypes_Aggregate(
        ref TranslationUnitData transUnit, ES_NamespaceData.Builder namespaceBuilder,
        ES_TypeTag type, ES_AstAggregateDefinition typeDef
        )
    {
        var namespaceName = namespaceBuilder.NamespaceData.NamespaceName;
        var typeName      = Environment !.IdPool.GetIdentifier(typeDef.Name.Text.Span);

        if (namespaceBuilder.CheckTypeExists(typeName, null) != null)
        {
            errorList.Add(ES_FrontendErrors.GenTypeAlreadyDefined(
                              namespaceBuilder.NamespaceData.NamespaceNameString,
                              typeDef.Name.Text.Span.GetPooledString(),
                              typeDef.Name
                              ));
            return;
        }

        ES_TypeInfo *typeData = null;

        if (type == ES_TypeTag.Class)
        {
            var classBuilder = namespaceBuilder.GetOrCreateClass(typeDef.AccessModifier, typeName, transUnit.Name);
            typeData = &classBuilder.ClassData->TypeInfo;
        }
        else if (type == ES_TypeTag.Struct)
        {
            var structBuilder = namespaceBuilder.GetOrCreateStruct(typeDef.AccessModifier, typeName, transUnit.Name);
            typeData = &structBuilder.StructData->TypeInfo;
        }
        else
        {
            Debug.Fail("Not implemented/supported.");
        }

        EnvironmentBuilder !.PointerAstMap.Add((IntPtr)typeData, typeDef);
    }
Exemplo n.º 21
0
    private static ExpressionSyntax CompileCode_NullCheck(ExpressionSyntax ptrExpr, ES_TypeInfo *pointedType)
    {
        var isRef = pointedType->IsReferenceType();

        if (isRef)
        {
            ptrExpr = CastExpression(
                PointerType(PredefinedType(Token(SyntaxKind.ByteKeyword))),
                ptrExpr
                );
        }

        var value = CompileCode_NullCheck(ptrExpr);

        if (isRef)
        {
            value = CastExpression(
                PointerType(GetRoslynType(pointedType)),
                ptrExpr
                );
        }

        return(value);
    }
Exemplo n.º 22
0
    private static ES_IntTypeData *DetermineIntLiteralType(
        ref PassData passData,
        ES_AstIntegerLiteralExpression intLitExpr, ES_TypeInfo *expectedType, bool negated
        )
    {
        ES_IntTypeData *expectedIntType = null;

        bool?unsigned   = null;
        var  isSigned   = intLitExpr.Signed;
        var  chosenSize = intLitExpr.Size;

        if (expectedType != null && expectedType->TypeTag == ES_TypeTag.Int)
        {
            expectedIntType = (ES_IntTypeData *)expectedType;

            if (isSigned == null)
            {
                isSigned = !expectedIntType->Unsigned;
            }
        }

        ES_IntSize size;
        ES_IntSize minSize;

        var tooBig = false;

        var value = intLitExpr.Value;

        if (isSigned == false || intLitExpr.HexBin)
        {
            if (value <= byte.MaxValue)
            {
                minSize = ES_IntSize.Int8;
            }
            else if (value <= ushort.MaxValue)
            {
                minSize = ES_IntSize.Int16;
            }
            else if (value <= uint.MaxValue)
            {
                minSize = ES_IntSize.Int32;
            }
            else
            {
                minSize = ES_IntSize.Int64;
            }
        }
        else if (!negated)
        {
            if (value <= (ulong)sbyte.MaxValue)
            {
                minSize = ES_IntSize.Int8;
            }
            else if (value <= (ulong)short.MaxValue)
            {
                minSize = ES_IntSize.Int16;
            }
            else if (value <= int.MaxValue)
            {
                minSize = ES_IntSize.Int32;
            }
            else if (value <= long.MaxValue)
            {
                minSize = ES_IntSize.Int64;
            }
            else
            {
                minSize  = ES_IntSize.Int64;
                unsigned = true;

                if (isSigned == true)
                {
                    tooBig = true;
                }
            }
        }
        else
        {
            unsigned = false;

            if (value <= ((ulong)sbyte.MaxValue) + 1)
            {
                minSize = ES_IntSize.Int8;
            }
            else if (value <= ((ulong)short.MaxValue) + 1)
            {
                minSize = ES_IntSize.Int16;
            }
            else if (value <= ((ulong)int.MaxValue) + 1)
            {
                minSize = ES_IntSize.Int32;
            }
            else if (value <= ((ulong)long.MaxValue) + 1)
            {
                minSize = ES_IntSize.Int64;
            }
            else
            {
                minSize  = ES_IntSize.Int64;
                unsigned = true;

                if (isSigned == true)
                {
                    tooBig = true;
                }
            }
        }

        tooBig |= (
            (chosenSize is not null && chosenSize.Value < minSize) ||
            (unsigned == true && isSigned == true)
            );

        if (tooBig)
        {
            var errSize = minSize;
            if (chosenSize is not null)
            {
                errSize = chosenSize.Value;
            }
            passData.ErrorList.Add(ES_FrontendErrors.GenIntLitTooBig(isSigned !.Value, errSize, intLitExpr.Token));

            if (unsigned is null && isSigned == false)
            {
                unsigned = true;
            }
        }
        else
        {
            if (chosenSize is not null)
            {
                minSize = chosenSize.Value;
            }

            if (unsigned is null && isSigned is not null)
            {
                unsigned = !isSigned.Value;
            }
        }

        size = minSize;
        if (expectedIntType is not null)
        {
            var isCompat = false;

            var expectsUnsign = expectedIntType->Unsigned;
            var expectedSize  = expectedIntType->IntSize;

            if (intLitExpr.HexBin && (isSigned is null || isSigned == !expectsUnsign) && minSize <= expectedSize)
            {
                isCompat = true;
            }
            else if (unsigned == expectsUnsign && minSize <= expectedSize)
            {
                isCompat = true;
            }

            if (isCompat)
            {
                size     = expectedSize;
                unsigned = expectsUnsign;
            }
        }
Exemplo n.º 23
0
 public static FrontendSymbol NewType(ES_TypeInfo *type)
 => new (FrontendSymbolType.Type, type, 0);
Exemplo n.º 24
0
 public static FrontendSymbol NewVariable(ES_TypeInfo *type, FrontendSymbolFlags flags = 0)
 => new (FrontendSymbolType.Variable, type, flags);
Exemplo n.º 25
0
 public static void *AllocObject(ES_TypeInfo *type, bool pinned)
 {
     EnsureInitialized();
     return(garbageCollector !.AllocateObject(type, pinned));
 }
Exemplo n.º 26
0
 public ES_FunctionPrototypeArgData(ES_ArgumentType argType, ES_TypeInfo *valueType)
 {
     ArgType   = argType;
     ValueType = valueType;
 }
Exemplo n.º 27
0
 public static ESIR_Struct Struct(ES_TypeInfo *type, ESIR_List <ESIR_MemberNode> members)
 => Struct(ValueNode(type), members);
Exemplo n.º 28
0
 private static void FoldConstants_ExplicitCast_ToFloat(ES_TypeInfo *dstType, in ES_AstExpression innerExpr, ref ES_AstExpression expr, out bool isRedundant)
Exemplo n.º 29
0
    private void TypeSizing_SizeType([NotNull] ES_TypeInfo *type, ArrayPointer <nint> refListRefType)
    {
        Debug.Assert(Environment is not null);
        Debug.Assert(EnvironmentBuilder is not null);

        if (type->Flags.HasFlag(ES_TypeFlag.Analyzed))
        {
            return;
        }

        var hasRefs = !type->Flags.HasFlag(ES_TypeFlag.NoRefs);

        switch (type->TypeTag)
        {
        case ES_TypeTag.Array:
        case ES_TypeTag.Interface:
        case ES_TypeTag.Reference: {
            type->RuntimeSize = sizeof(void *);
            type->RefsList    = refListRefType;
            type->Flags      &= ~ES_TypeFlag.NoRefs;
            type->Flags      |= ES_TypeFlag.Analyzed;
            return;
        }

        case ES_TypeTag.Void:
        case ES_TypeTag.Bool:
        case ES_TypeTag.Int:
        case ES_TypeTag.Float:
        case ES_TypeTag.Function:
        case ES_TypeTag.Enum:
            type->Flags |= ES_TypeFlag.Analyzed;
            return;

        case ES_TypeTag.Const:
        case ES_TypeTag.Immutable: {
            var constData = (ES_ConstData *)type;

            TypeSizing_SizeType(constData->InnerType, refListRefType);

            type->RuntimeSize = constData->InnerType->RuntimeSize;
            type->RefsList    = constData->InnerType->RefsList;

            type->Flags = constData->InnerType->Flags | ES_TypeFlag.Analyzed;

            return;
        }

        case ES_TypeTag.Struct:
        case ES_TypeTag.Class:
            break;

        default:
            throw new NotImplementedException("Type not implemented yet.");
        }

        using var refsList = new StructPooledList <nint> (CL_ClearMode.Auto);
        var curOffs = 0;

        foreach (var memberAddr in type->MembersList.MembersList.Span)
        {
            var member = memberAddr.Address;

            if (member->MemberType != ES_MemberType.Field)
            {
                continue;
            }

            if (member->Flags.HasFlag(ES_MemberFlags.Static))
            {
                continue;
            }

            var field = (ES_MemberData_Variable *)member;

            field->Offset = curOffs;

            TypeSizing_SizeType(field->Type, refListRefType);

            curOffs += field->Type->RuntimeSize;

            foreach (var refOffs in field->Type->RefsList.Span)
            {
                refsList.Add(field->Offset + refOffs);
            }

            hasRefs |= !field->Type->Flags.HasFlag(ES_TypeFlag.NoRefs);
        }

        type->RuntimeSize = curOffs;
        type->RefsList    = ArrayPointer <nint> .Null;
        if (refsList.Count > 0)
        {
            type->RefsList = EnvironmentBuilder.MemoryManager.GetArrayAligned <nint> (refsList.Count, sizeof(nint));
            refsList.Span.CopyTo(type->RefsList.Span);
        }

        type->Flags &= ~ES_TypeFlag.NoRefs;
        if (!hasRefs)
        {
            type->Flags |= ES_TypeFlag.NoRefs;
        }

        type->Flags |= ES_TypeFlag.Analyzed;
    }
Exemplo n.º 30
0
 public unsafe static ESIR_TypeNode TypeNode (ES_TypeInfo* ptr) {
     Debug.Assert (ptr is not null);
     return TypeNode (ValueNode (ptr));
 }