ZuneShell.dll/UIX/Microsoft/Iris/Markup/CompiledMarkupLoader.cs

// Decompiled with JetBrains decompiler
// Type: Microsoft.Iris.Markup.CompiledMarkupLoader
// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
// Assembly location: C:\Program Files\Zune\UIX.dll

using Microsoft.Iris.Data;
using Microsoft.Iris.Markup.UIX;
using Microsoft.Iris.OS;
using Microsoft.Iris.Session;
using System;

namespace Microsoft.Iris.Markup
{
    internal class CompiledMarkupLoader
    {
        private const uint c_LineNumberRecordSize = 12;
        private CompiledMarkupLoadResult _loadResultTarget;
        private ByteCodeReader _reader;
        private bool _hasErrors;
        private LoadPass _currentDepersistPass;
        private MarkupLoadResult _binaryDataTableLoadResult;
        private MarkupBinaryDataTable _binaryDataTable;
        private bool _usingSharedDataTable;
        private uint _objectSectionStart;
        private uint _objectSectionEnd;
        private uint _lineNumberTableStart;
        private uint _lineNumberTableEnd;
        private TypeSchema[][] _typeSchemaArrays;

        public static CompiledMarkupLoader Load(
          CompiledMarkupLoadResult loadResult,
          Resource resource)
        {
            return new CompiledMarkupLoader(loadResult, resource);
        }

        private CompiledMarkupLoader(CompiledMarkupLoadResult loadResultTarget, Resource resource)
        {
            this._loadResultTarget = loadResultTarget;
            this._reader = new ByteCodeReader(resource.Buffer, resource.Length, false);
            if (resource is DllResource)
                this._reader.MarkAsInFixedMemory();
            uint num1 = this._reader.ReadUInt32();
            uint num2 = this._reader.ReadUInt32();
            if (num1 != 440551765U)
                this.ReportError("Invalid compiled UIX file");
            if (num2 == 1012U)
                return;
            this.ReportError("Compiled UIX file '{0}' was compiled for the runtime with version {1}, but the current runtime is version {2}", resource.Uri, num2.ToString(), 1012U.ToString());
        }

        public void Depersist(LoadPass currentPass)
        {
            if (this._currentDepersistPass >= currentPass)
                return;
            this._currentDepersistPass = currentPass;
            if (this._binaryDataTableLoadResult != null)
                this._binaryDataTableLoadResult.Load(this._currentDepersistPass);
            if (this._currentDepersistPass == LoadPass.DeclareTypes)
                this.DoLoadPassDeclareTypes();
            else if (this._currentDepersistPass == LoadPass.PopulatePublicModel)
                this.DoLoadPassPopulatePublicModel();
            else if (this._currentDepersistPass == LoadPass.Full)
            {
                this.DoLoadPassFull();
            }
            else
            {
                foreach (MarkupTypeSchema markupTypeSchema in this._loadResultTarget.ExportTable)
                    markupTypeSchema.Seal();
                this._reader = null;
            }
            foreach (LoadResult dependency in this._loadResultTarget.Dependencies)
            {
                if (dependency != this._loadResultTarget)
                {
                    dependency.Load(this._currentDepersistPass);
                    if (dependency.Status == LoadResultStatus.Error)
                        this.MarkHasErrors();
                }
            }
        }

        private void DoLoadPassDeclareTypes()
        {
            if (this.HasErrors)
                return;
            this.DepersistTableOfContents();
            if (this.HasErrors)
                return;
            this.DepersistDependencies();
            if (this.HasErrors)
                return;
            this.DepersistTypeExportDeclarations();
            if (!this.HasErrors)
                ;
        }

        private void DoLoadPassPopulatePublicModel()
        {
            if (this.HasErrors)
                return;
            this.DepersistTypeImportTable();
            if (this.HasErrors)
                return;
            this.DepersistTypeExportDefinitions();
            if (!this.HasErrors)
                ;
        }

        private void DoLoadPassFull()
        {
            if (this.HasErrors)
                return;
            this.DepersistMemberImportTables();
            if (this.HasErrors)
                return;
            this.DepersistDataMappingsTable();
            if (this.HasErrors)
                return;
            this.DepersistConstantsTable();
            if (this.HasErrors)
                return;
            this.DepersistLineNumberTable();
            if (this.HasErrors)
                return;
            this.DepersistObjectSection();
            if (!this.HasErrors)
                ;
        }

        private void DepersistTableOfContents()
        {
            this._objectSectionStart = this._reader.ReadUInt32();
            this._objectSectionEnd = this._reader.ReadUInt32();
            this._lineNumberTableStart = this._reader.ReadUInt32();
            this._lineNumberTableEnd = this._reader.ReadUInt32();
            string uri = this._reader.ReadString();
            if (uri != null)
            {
                this._binaryDataTableLoadResult = MarkupSystem.ResolveLoadResult(uri, this._loadResultTarget.IslandReferences) as MarkupLoadResult;
                if (this._binaryDataTableLoadResult != null)
                {
                    this._binaryDataTableLoadResult.Load(this._currentDepersistPass);
                    this._binaryDataTable = this._binaryDataTableLoadResult.BinaryDataTable;
                    this._loadResultTarget.SetBinaryDataTable(this._binaryDataTable);
                    if (this._binaryDataTable.SharedDependenciesTableWithBinaryDataTable == null)
                        this._binaryDataTable.SharedDependenciesTableWithBinaryDataTable = new LoadResult[1]
                        {
               _binaryDataTableLoadResult
                        };
                    this._loadResultTarget.SetDependenciesTable(this._binaryDataTable.SharedDependenciesTableWithBinaryDataTable);
                    this._usingSharedDataTable = true;
                }
                else
                    this.MarkHasErrors();
            }
            else
                this.DepersistBinaryDataTable(this._reader.ReadUInt32());
        }

        private void DepersistDependencies()
        {
            if (this._usingSharedDataTable)
                return;
            ushort num = this._reader.ReadUInt16();
            LoadResult[] dependenciesTable = new LoadResult[num];
            for (ushort index = 0; index < num; ++index)
            {
                this._reader.ReadBool();
                string uri = this.ReadDataTableString();
                LoadResult loadResult = MarkupSystem.ResolveLoadResult(uri, this._loadResultTarget.IslandReferences);
                if (loadResult == null || loadResult.Status == LoadResultStatus.Error)
                {
                    this.ReportError("Import of '{0}' failed", uri);
                    return;
                }
                dependenciesTable[index] = loadResult;
            }
            this._loadResultTarget.SetDependenciesTable(dependenciesTable);
        }

        private void DepersistTypeExportDeclarations()
        {
            ushort num1 = this._reader.ReadUInt16();
            TypeSchema[] exportTable = new TypeSchema[num1];
            for (int index = 0; index < num1; ++index)
            {
                string name = this.ReadDataTableString();
                MarkupTypeSchema markupTypeSchema = MarkupTypeSchema.Build(this.MarkupTypeToDefinition((MarkupType)this._reader.ReadInt32()), _loadResultTarget, name);
                exportTable[index] = markupTypeSchema;
            }
            this._loadResultTarget.SetExportTable(exportTable);
            ushort num2 = this._reader.ReadUInt16();
            if (num2 <= 0)
                return;
            AliasMapping[] aliasTable = new AliasMapping[num2];
            for (int index1 = 0; index1 < num2; ++index1)
            {
                string alias = this.ReadDataTableString();
                ushort index2 = this._reader.ReadUInt16();
                string targetType = this.ReadDataTableString();
                LoadResult dependent = this.MapIndexToDependent(index2);
                aliasTable[index1] = new AliasMapping(alias, dependent, targetType);
            }
            this._loadResultTarget.SetAliasTable(aliasTable);
        }

        private void DepersistTypeImportTable()
        {
            if (this._usingSharedDataTable)
                return;
            MarkupImportTables importTables = new MarkupImportTables();
            this._loadResultTarget.BinaryDataTable.SetImportTables(importTables);
            ushort num = this._reader.ReadUInt16();
            if (num <= 0)
                return;
            TypeSchema[] typeSchemaArray = new TypeSchema[num];
            for (ushort index = 0; index < num; ++index)
            {
                LoadResult dependent = this.MapIndexToDependent(this._reader.ReadUInt16());
                string name = this.ReadDataTableString();
                TypeSchema type = dependent.FindType(name);
                if (type == null)
                    this.ReportError("Import of {0} named '{1}' from '{2}' failed", "type", name, dependent.Uri);
                else
                    typeSchemaArray[index] = type;
            }
            importTables.TypeImports = typeSchemaArray;
        }

        private void DepersistTypeExportDefinitions()
        {
            TypeSchema[] typeImports = this._loadResultTarget.ImportTables.TypeImports;
            foreach (MarkupTypeSchema markupTypeSchema in this._loadResultTarget.ExportTable)
            {
                MarkupType markupType = markupTypeSchema.MarkupType;
                TypeSchema definition = this.MarkupTypeToDefinition(markupType);
                uint typeDepth = this._reader.ReadUInt16();
                markupTypeSchema.SetTypeDepth(typeDepth);
                if (typeDepth > 1U)
                {
                    ushort num = this._reader.ReadUInt16();
                    TypeSchema typeSchema = typeImports[num];
                    markupTypeSchema.SetBaseType((MarkupTypeSchema)typeSchema);
                }
                uint offset1 = this._reader.ReadUInt32();
                markupTypeSchema.SetInitializePropertiesOffset(offset1);
                uint offset2 = this._reader.ReadUInt32();
                markupTypeSchema.SetInitializeLocalsInputOffset(offset2);
                uint offset3 = this._reader.ReadUInt32();
                markupTypeSchema.SetInitializeContentOffset(offset3);
                markupTypeSchema.SetInitialEvaluateOffsets(this.ReadUInt32ArrayHelper());
                markupTypeSchema.SetFinalEvaluateOffsets(this.ReadUInt32ArrayHelper());
                markupTypeSchema.SetRefreshListenerGroupOffsets(this.ReadUInt32ArrayHelper());
                uint listenerCount = this._reader.ReadUInt32();
                markupTypeSchema.SetListenerCount(listenerCount);
                uint num1 = this._reader.ReadUInt32();
                if (num1 > 0U)
                {
                    SymbolReference[] symbolTable = new SymbolReference[num1];
                    for (int index = 0; index < num1; ++index)
                    {
                        SymbolReference symbolReference = new SymbolReference(this.ReadDataTableString(), (SymbolOrigin)this._reader.ReadByte());
                        symbolTable[index] = symbolReference;
                    }
                    markupTypeSchema.SetSymbolReferenceTable(symbolTable);
                }
                this.DepersistInheritedSymbolTable(markupTypeSchema);
                int totalPropertiesAndLocalsCount = this._reader.ReadInt32();
                markupTypeSchema.SetTotalPropertiesAndLocalsCount(totalPropertiesAndLocalsCount);
                if (markupType == MarkupType.UI)
                {
                    ushort num2 = this._reader.ReadUInt16();
                    if (num2 > 0)
                    {
                        NamedContentRecord[] namedContentTable = new NamedContentRecord[num2];
                        for (int index = 0; index < num2; ++index)
                        {
                            string name = this.ReadDataTableString();
                            uint offset4 = this._reader.ReadUInt32();
                            namedContentTable[index] = new NamedContentRecord(name);
                            namedContentTable[index].SetOffset(offset4);
                        }
                      ((UIClassTypeSchema)markupTypeSchema).SetNamedContentTable(namedContentTable);
                    }
                }
                else
                {
                    if (this._reader.ReadBool())
                        ((ClassTypeSchema)markupTypeSchema).MarkShareable();
                    if (markupType == MarkupType.Effect)
                    {
                        EffectClassTypeSchema effectClassTypeSchema = (EffectClassTypeSchema)markupTypeSchema;
                        effectClassTypeSchema.SetTechniqueOffsets(this.ReadUInt32ArrayHelper());
                        effectClassTypeSchema.SetInstancePropertyAssignments(this.ReadUInt32ArrayHelper());
                        effectClassTypeSchema.SetDynamicElementAssignments(this.ReadStringArrayHelper());
                        int symbolIndex = this._reader.ReadInt32();
                        effectClassTypeSchema.SetDefaultElementSymbolIndex(symbolIndex);
                    }
                    if (markupType == MarkupType.DataQuery)
                    {
                        MarkupDataQuerySchema markupDataQuerySchema = (MarkupDataQuerySchema)markupTypeSchema;
                        markupDataQuerySchema.ProviderName = this.ReadDataTableString();
                        ushort index = this._reader.ReadUInt16();
                        markupDataQuerySchema.ResultType = this.MapIndexToType(index);
                    }
                }
                ushort num3 = this._reader.ReadUInt16();
                if (num3 > 0)
                {
                    PropertySchema[] properties = new PropertySchema[num3];
                    for (int index1 = 0; index1 < num3; ++index1)
                    {
                        string name = this.ReadDataTableString();
                        bool requiredForCreation = this._reader.ReadBool();
                        bool flag = this._reader.ReadBool();
                        PropertyOverrideCriteriaTypeConstraint criteriaTypeConstraint = null;
                        if (flag)
                        {
                            ushort num2 = this._reader.ReadUInt16();
                            ushort num4 = this._reader.ReadUInt16();
                            TypeSchema constraint = typeImports[num2];
                            criteriaTypeConstraint = new PropertyOverrideCriteriaTypeConstraint(typeImports[num4], constraint);
                        }
                        ushort num5 = this._reader.ReadUInt16();
                        TypeSchema propertyType = typeImports[num5];
                        MarkupPropertySchema markupPropertySchema = MarkupPropertySchema.Build(definition, markupTypeSchema, name, propertyType);
                        markupPropertySchema.SetRequiredForCreation(requiredForCreation);
                        markupPropertySchema.SetOverrideCriteria(criteriaTypeConstraint);
                        if (markupType == MarkupType.DataType)
                        {
                            MarkupDataTypePropertySchema typePropertySchema = (MarkupDataTypePropertySchema)markupPropertySchema;
                            ushort index2 = this._reader.ReadUInt16();
                            if (index2 != ushort.MaxValue)
                                typePropertySchema.SetUnderlyingCollectionType(this.MapIndexToType(index2));
                        }
                        if (markupType == MarkupType.DataQuery)
                        {
                            MarkupDataQueryPropertySchema queryPropertySchema = (MarkupDataQueryPropertySchema)markupPropertySchema;
                            if (this._reader.ReadBool())
                                queryPropertySchema.DefaultValue = queryPropertySchema.PropertyType.DecodeBinary(this._reader);
                            queryPropertySchema.InvalidatesQuery = this._reader.ReadBool();
                            ushort index2 = this._reader.ReadUInt16();
                            if (index2 != ushort.MaxValue)
                                queryPropertySchema.SetUnderlyingCollectionType(this.MapIndexToType(index2));
                        }
                        properties[index1] = markupPropertySchema;
                    }
                    markupTypeSchema.SetPropertyList(properties);
                }
                MethodSchema[] methods = this.ReadMarkupMethodArrayHelper(definition, markupTypeSchema);
                if (methods != null)
                    markupTypeSchema.SetMethodList(methods);
                MethodSchema[] virtualMethods = this.ReadMarkupMethodArrayHelper(definition, markupTypeSchema);
                if (virtualMethods != null)
                    markupTypeSchema.SetVirtualMethodList(virtualMethods);
            }
            foreach (MarkupTypeSchema markupTypeSchema in this._loadResultTarget.ExportTable)
                markupTypeSchema.BuildProperties();
        }

        private void DepersistMemberImportTables()
        {
            if (this._usingSharedDataTable)
                return;
            MarkupImportTables importTables = this._loadResultTarget.ImportTables;
            ushort num1 = this._reader.ReadUInt16();
            if (num1 > 0)
            {
                ConstructorSchema[] constructorSchemaArray = new ConstructorSchema[num1];
                for (int index1 = 0; index1 < num1; ++index1)
                {
                    TypeSchema type = this.MapIndexToType(this._reader.ReadUInt16());
                    ushort num2 = this._reader.ReadUInt16();
                    TypeSchema[] parameters = TypeSchema.EmptyList;
                    if (num2 > 0)
                    {
                        parameters = this.GetTempParameterArray(num2);
                        for (ushort index2 = 0; index2 < num2; ++index2)
                        {
                            ushort index3 = this._reader.ReadUInt16();
                            parameters[index2] = this.MapIndexToType(index3);
                        }
                    }
                    ConstructorSchema constructor = type.FindConstructor(parameters);
                    if (constructor == null)
                        this.ReportError("Import of {0} named '{1}' from '{2}' failed", "constructor", type.Name, type.Owner.Uri);
                    else
                        constructorSchemaArray[index1] = constructor;
                }
                importTables.ConstructorImports = constructorSchemaArray;
            }
            ushort num3 = this._reader.ReadUInt16();
            if (num3 > 0)
            {
                PropertySchema[] propertySchemaArray = new PropertySchema[num3];
                for (int index = 0; index < num3; ++index)
                {
                    TypeSchema type = this.MapIndexToType(this._reader.ReadUInt16());
                    string name = this.ReadDataTableString();
                    PropertySchema property = type.FindProperty(name);
                    if (property == null)
                        this.ReportError("Import of {0} named '{1}' from '{2}' failed", "property", name, type.Name);
                    else
                        propertySchemaArray[index] = property;
                }
                importTables.PropertyImports = propertySchemaArray;
            }
            ushort num4 = this._reader.ReadUInt16();
            if (num4 > 0)
            {
                MethodSchema[] methodSchemaArray = new MethodSchema[num4];
                for (int index1 = 0; index1 < num4; ++index1)
                {
                    MethodSchema methodSchema = null;
                    TypeSchema type = this.MapIndexToType(this._reader.ReadUInt16());
                    if (!this._reader.ReadBool())
                    {
                        string name = this.ReadDataTableString();
                        ushort num2 = this._reader.ReadUInt16();
                        TypeSchema[] parameters = TypeSchema.EmptyList;
                        if (num2 > 0)
                        {
                            parameters = this.GetTempParameterArray(num2);
                            for (ushort index2 = 0; index2 < num2; ++index2)
                            {
                                ushort index3 = this._reader.ReadUInt16();
                                parameters[index2] = this.MapIndexToType(index3);
                            }
                        }
                        methodSchema = type.FindMethod(name, parameters);
                        if (methodSchema == null)
                            this.ReportError("Import of {0} named '{1}' from '{2}' failed", "method", name, type.Name);
                    }
                    else
                    {
                        int num2 = this._reader.ReadInt32();
                        if (type is MarkupTypeSchema markupTypeSchema)
                        {
                            foreach (MarkupMethodSchema virtualMethod in markupTypeSchema.VirtualMethods)
                            {
                                if (virtualMethod.VirtualId == num2)
                                {
                                    methodSchema = virtualMethod;
                                    break;
                                }
                            }
                        }
                        if (methodSchema == null)
                            this.ReportError("Import of virtual method with index {0} from '{1}' failed", num2.ToString(), type.Name);
                    }
                    methodSchemaArray[index1] = methodSchema;
                }
                importTables.MethodImports = methodSchemaArray;
            }
            ushort num5 = this._reader.ReadUInt16();
            if (num5 <= 0)
                return;
            EventSchema[] eventSchemaArray = new EventSchema[num5];
            for (int index = 0; index < num5; ++index)
            {
                TypeSchema type = this.MapIndexToType(this._reader.ReadUInt16());
                string name = this.ReadDataTableString();
                EventSchema eventSchema = type.FindEvent(name);
                if (eventSchema == null)
                    this.ReportError("Import of {0} named '{1}' from '{2}' failed", "event", name, type.Name);
                else
                    eventSchemaArray[index] = eventSchema;
            }
            importTables.EventImports = eventSchemaArray;
        }

        private void DepersistDataMappingsTable()
        {
            ushort num1 = this._reader.ReadUInt16();
            if (num1 <= 0)
                return;
            MarkupDataMapping[] dataMappingsTable = new MarkupDataMapping[num1];
            for (int index1 = 0; index1 < num1; ++index1)
            {
                MarkupDataMapping markupDataMapping = new MarkupDataMapping(null);
                ushort index2 = this._reader.ReadUInt16();
                markupDataMapping.TargetType = (MarkupDataTypeSchema)this.MapIndexToType(index2);
                markupDataMapping.Provider = this.ReadDataTableString();
                ushort num2 = this._reader.ReadUInt16();
                markupDataMapping.Mappings = new MarkupDataMappingEntry[num2];
                for (int index3 = 0; index3 < num2; ++index3)
                {
                    MarkupDataMappingEntry dataMappingEntry = new MarkupDataMappingEntry();
                    dataMappingEntry.Source = this.ReadDataTableString();
                    dataMappingEntry.Target = this.ReadDataTableString();
                    ushort num3 = this._reader.ReadUInt16();
                    dataMappingEntry.Property = (MarkupDataTypePropertySchema)this._loadResultTarget.ImportTables.PropertyImports[num3];
                    dataMappingEntry.DefaultValue = !this._reader.ReadBool() ? MarkupDataProvider.GetDefaultValueForType(dataMappingEntry.Property.PropertyType) : dataMappingEntry.Property.PropertyType.DecodeBinary(this._reader);
                    markupDataMapping.Mappings[index3] = dataMappingEntry;
                }
                dataMappingsTable[index1] = markupDataMapping;
            }
            this._loadResultTarget.SetDataMappingsTable(dataMappingsTable);
        }

        public static void DecodeInheritableSymbolTable(
          MarkupTypeSchema typeExport,
          ByteCodeReader reader,
          IntPtr startAddress)
        {
            if (reader == null)
            {
                uint size = ByteCodeReader.ReadUInt32(startAddress);
                reader = new ByteCodeReader(new IntPtr(startAddress.ToInt64() + 4L), size, false);
            }
            else
            {
                int num1 = (int)reader.ReadUInt32();
            }
            MarkupLoadResult owner = typeExport.Owner as MarkupLoadResult;
            MarkupBinaryDataTable binaryDataTable = owner.BinaryDataTable;
            uint num2 = reader.ReadUInt32();
            SymbolRecord[] symbolTable;
            if (num2 > 0U)
            {
                symbolTable = new SymbolRecord[num2];
                for (int index = 0; index < num2; ++index)
                {
                    SymbolRecord symbolRecord = new SymbolRecord();
                    symbolRecord.Name = CompiledMarkupLoader.ReadDataTableString(reader, binaryDataTable);
                    symbolRecord.SymbolOrigin = (SymbolOrigin)reader.ReadByte();
                    ushort num3 = reader.ReadUInt16();
                    symbolRecord.Type = owner.ImportTables.TypeImports[num3];
                    symbolTable[index] = symbolRecord;
                }
            }
            else
                symbolTable = SymbolRecord.EmptyList;
            typeExport.SetInheritableSymbolsTable(symbolTable);
        }

        private void DepersistInheritedSymbolTable(MarkupTypeSchema typeExport)
        {
            if (this._reader.IsInFixedMemory)
            {
                typeExport.SetAddressOfInheritableSymbolTable(this._reader.CurrentAddress);
                this._reader.CurrentOffset += this._reader.ReadUInt32();
            }
            else
                CompiledMarkupLoader.DecodeInheritableSymbolTable(typeExport, this._reader, IntPtr.Zero);
        }

        private void DepersistConstantsTable()
        {
            ushort num = this._reader.ReadUInt16();
            if (num <= 0)
                return;
            object[] runtimeList = new object[num];
            MarkupConstantsTable constantsTable = new MarkupConstantsTable(runtimeList);
            if (!this._reader.IsInFixedMemory)
            {
                this._reader.CurrentOffset += (uint)((num + 1) * 4);
                for (int index = 0; index < num; ++index)
                {
                    object obj = CompiledMarkupLoader.DepersistConstant(this._reader, _loadResultTarget);
                    runtimeList[index] = obj;
                }
            }
            else
            {
                ByteCodeReader constantsTableReader = new ByteCodeReader(this._reader.CurrentAddress, ByteCodeReader.ReadUInt32(this._reader.GetAddress(this._reader.CurrentOffset + num * 4U)), false);
                constantsTable.SetConstantsTableReader(constantsTableReader, _loadResultTarget);
            }
            this._loadResultTarget.BinaryDataTable.SetConstantsTable(constantsTable);
        }

        public static object DepersistConstant(ByteCodeReader reader, MarkupLoadResult loadResult)
        {
            ushort num = reader.ReadUInt16();
            TypeSchema typeImport = loadResult.ImportTables.TypeImports[num];
            MarkupConstantPersistMode constantPersistMode = (MarkupConstantPersistMode)reader.ReadByte();
            object instance = null;
            switch (constantPersistMode)
            {
                case MarkupConstantPersistMode.Binary:
                    instance = typeImport.DecodeBinary(reader);
                    break;
                case MarkupConstantPersistMode.FromString:
                    string str = CompiledMarkupLoader.ReadDataTableString(reader, loadResult.BinaryDataTable);
                    typeImport.TypeConverter(str, StringSchema.Type, out instance);
                    break;
                case MarkupConstantPersistMode.Canonical:
                    string name = CompiledMarkupLoader.ReadDataTableString(reader, loadResult.BinaryDataTable);
                    instance = typeImport.FindCanonicalInstance(name);
                    break;
            }
            return instance;
        }

        private static MarkupLineNumberTable DecodeLineNumberTable(
          ByteCodeReader reader)
        {
            ushort num = reader.ReadUInt16();
            ulong[] runtimeList = new ulong[num];
            for (int index = 0; index < num; ++index)
                runtimeList[index] = reader.ReadUInt64();
            return new MarkupLineNumberTable(runtimeList);
        }

        public static MarkupLineNumberTable DecodeLineNumberTable(IntPtr address)
        {
            uint size = (uint)(ByteCodeReader.ReadUInt16(address) * 12 + 2);
            return CompiledMarkupLoader.DecodeLineNumberTable(new ByteCodeReader(address, size, false));
        }

        private void DepersistLineNumberTable()
        {
            if (this._reader.IsInFixedMemory)
            {
                this._loadResultTarget.SetAddressOfLineNumberData(this._reader.GetAddress(this._lineNumberTableStart));
            }
            else
            {
                uint currentOffset = this._reader.CurrentOffset;
                this._reader.CurrentOffset = this._lineNumberTableStart;
                this._loadResultTarget.SetLineNumberTable(CompiledMarkupLoader.DecodeLineNumberTable(this._reader));
                this._reader.CurrentOffset = currentOffset;
            }
        }

        private void DepersistObjectSection()
        {
            uint num = this._objectSectionEnd - this._objectSectionStart;
            ByteCodeReader reader;
            if (this._reader.IsInFixedMemory)
            {
                reader = new ByteCodeReader(this._reader.GetAddress(this._objectSectionStart), num, false);
            }
            else
            {
                ByteCodeWriter byteCodeWriter = new ByteCodeWriter();
                byteCodeWriter.Write(this._reader.GetAddress(this._objectSectionStart), num);
                reader = byteCodeWriter.CreateReader();
            }
            this._loadResultTarget.SetObjectSection(reader);
        }

        private void DepersistBinaryDataTable(uint binaryDataTableOffset)
        {
            uint currentOffset = this._reader.CurrentOffset;
            this._reader.CurrentOffset = binaryDataTableOffset;
            int stringCount = this._reader.ReadInt32();
            this._binaryDataTable = new MarkupBinaryDataTable(null, stringCount);
            if (!this._reader.IsInFixedMemory)
            {
                this._reader.CurrentOffset += (uint)((stringCount + 1) * 4);
                Vector<string> strings = this._binaryDataTable.Strings;
                for (int index = 0; index < stringCount; ++index)
                {
                    string str = this._reader.ReadString();
                    strings[index] = str;
                }
            }
            else
                this._binaryDataTable.SetStringTableReader(new ByteCodeReader(this._reader.CurrentAddress, ByteCodeReader.ReadUInt32(this._reader.GetAddress(this._reader.CurrentOffset + (uint)(stringCount * 4))), false));
            this._loadResultTarget.SetBinaryDataTable(this._binaryDataTable);
            this._reader.CurrentOffset = currentOffset;
        }

        private LoadResult MapIndexToDependent(ushort index)
        {
            LoadResult loadResult;
            switch (index)
            {
                case 65533:
                    loadResult = _loadResultTarget;
                    break;
                case 65534:
                    loadResult = MarkupSystem.UIXGlobal;
                    break;
                default:
                    loadResult = this._binaryDataTableLoadResult == null ? this._loadResultTarget.Dependencies[index] : this._binaryDataTableLoadResult.Dependencies[index];
                    break;
            }
            return loadResult;
        }

        private TypeSchema MapIndexToType(ushort index) => this._loadResultTarget.ImportTables.TypeImports[index];

        private string ReadDataTableString() => this._binaryDataTable.GetStringByIndex(this._reader.ReadInt32());

        private static string ReadDataTableString(
          ByteCodeReader reader,
          MarkupBinaryDataTable binaryDataTable)
        {
            int index = reader.ReadInt32();
            return binaryDataTable.GetStringByIndex(index);
        }

        private uint[] ReadUInt32ArrayHelper()
        {
            uint num = this._reader.ReadUInt32();
            if (num <= 0U)
                return null;
            uint[] numArray = new uint[num];
            for (int index = 0; index < num; ++index)
                numArray[index] = this._reader.ReadUInt32();
            return numArray;
        }

        private string[] ReadStringArrayHelper()
        {
            uint num = this._reader.ReadUInt32();
            if (num <= 0U)
                return null;
            string[] strArray = new string[num];
            for (int index = 0; index < num; ++index)
                strArray[index] = this.ReadDataTableString();
            return strArray;
        }

        private MethodSchema[] ReadMarkupMethodArrayHelper(
          TypeSchema markupTypeDefinition,
          MarkupTypeSchema typeExport)
        {
            MethodSchema[] methodSchemaArray = null;
            ushort num1 = this._reader.ReadUInt16();
            if (num1 > 0)
            {
                methodSchemaArray = new MethodSchema[num1];
                for (int index1 = 0; index1 < num1; ++index1)
                {
                    string name = this.ReadDataTableString();
                    TypeSchema type = this.MapIndexToType(this._reader.ReadUInt16());
                    uint num2 = this._reader.ReadUInt32();
                    TypeSchema[] parameterTypes = TypeSchema.EmptyList;
                    if (num2 > 0U)
                    {
                        parameterTypes = new TypeSchema[num2];
                        for (int index2 = 0; index2 < num2; ++index2)
                        {
                            ushort index3 = this._reader.ReadUInt16();
                            parameterTypes[index2] = this.MapIndexToType(index3);
                        }
                    }
                    string[] parameterNames = this.ReadStringArrayHelper() ?? MarkupMethodSchema.s_emptyStringArray;
                    int virtualId = this._reader.ReadInt32();
                    bool isVirtualThunk = this._reader.ReadBool();
                    uint codeOffset = this._reader.ReadUInt32();
                    MarkupMethodSchema markupMethodSchema = MarkupMethodSchema.Build(markupTypeDefinition, typeExport, name, type, parameterTypes, parameterNames, isVirtualThunk);
                    markupMethodSchema.SetCodeOffset(codeOffset);
                    markupMethodSchema.SetVirtualId(virtualId);
                    methodSchemaArray[index1] = markupMethodSchema;
                }
            }
            return methodSchemaArray;
        }

        private TypeSchema MarkupTypeToDefinition(MarkupType markupType)
        {
            switch (markupType)
            {
                case MarkupType.UI:
                    return UISchema.Type;
                case MarkupType.Effect:
                    return EffectSchema.Type;
                case MarkupType.DataType:
                    return DataTypeSchema.Type;
                case MarkupType.DataQuery:
                    return DataQuerySchema.Type;
                default:
                    return ClassSchema.Type;
            }
        }

        private TypeSchema[] GetTempParameterArray(int count)
        {
            if (this._typeSchemaArrays == null)
                this._typeSchemaArrays = new TypeSchema[5][];
            if (count >= this._typeSchemaArrays.Length)
                return new TypeSchema[count];
            int index = count - 1;
            if (this._typeSchemaArrays[index] == null)
                this._typeSchemaArrays[index] = new TypeSchema[count];
            return this._typeSchemaArrays[index];
        }

        public void ReportError(string error, string param0, string param1, string param2) => this.ReportError(string.Format(error, param0, param1, param2));

        public void ReportError(string error, string param0, string param1) => this.ReportError(string.Format(error, param0, param1));

        public void ReportError(string error, string param0) => this.ReportError(string.Format(error, param0));

        public void ReportError(string error)
        {
            this.MarkHasErrors();
            ErrorManager.ReportError(error);
        }

        public void MarkHasErrors()
        {
            if (this._hasErrors)
                return;
            this._hasErrors = true;
            this._loadResultTarget.MarkLoadFailed();
        }

        public bool HasErrors => this._hasErrors;

        public static bool IsUIB(Resource resource)
        {
            bool flag = false;
            if (resource.Length > 4U && ByteCodeReader.ReadUInt32(resource.Buffer) == 440551765U)
                flag = true;
            return flag;
        }
    }
}