Пример #1
0
        public void LoadClass(VLTDataClassLoad classLoad, VLTFile vltFile)
        {
            _vltFile   = vltFile;
            _classLoad = classLoad;
            _classHash = classLoad.NameHash;

            _pointers = vltFile.GetChunk(VLTChunkId.Pointers) as VLTPointers;
            int offset = _pointers[classLoad.Pointer].OffsetDest;

            vltFile.RawStream.Seek(offset, SeekOrigin.Begin);
            BinaryReader br = new BinaryReader(vltFile.RawStream);

            _classFields = new ClassField[_classLoad.TotalFieldsCount];
            for (int i = 0; i < _classLoad.TotalFieldsCount; i++)
            {
                ClassField field = new ClassField();
                field.Read(br);

                // HACK: for hash dumping later on
                HashResolver.Resolve(field.NameHash);

                _classFields[i] = field;
            }

            _data = new ClassData(this);
        }
Пример #2
0
        public void LoadClass(VLTDataClassLoad classLoad, VLTFile vltFile)
        {
            VLTClass vltClass = new VLTClass();

            vltClass.LoadClass(classLoad, vltFile);
            vltClass.VLTDatabase = this;
            _classes.Add(classLoad.NameHash, vltClass);
        }
Пример #3
0
        public void LoadDatabase(VLTDataDatabaseLoad dbLoad, VLTFile vltFile)
        {
            VLTPointers vltPointers = vltFile.GetChunk(VLTChunkId.Pointers) as VLTPointers;
            int         offset      = vltPointers[dbLoad.Pointer].OffsetDest;

            vltFile.RawStream.Seek(offset, SeekOrigin.Begin);
            BinaryReader br = new BinaryReader(vltFile.RawStream);

            _types = new Hashtable(dbLoad.Count);

            for (int i = 0; i < dbLoad.Count; i++)
            {
                VLTType type = new VLTType();
                type.TypeName = NullTerminatedString.Read(br);
                type.Length   = dbLoad[i];
                type.Hash     = VLTHasher.Hash(type.TypeName);
                _types.Add(type.Hash, type);
                HashResolver.AddAuto(type.TypeName);
            }

            _classes = new Hashtable();
        }
Пример #4
0
            public void Add(VLTDataCollectionLoad collLoad, VLTFile vltFile)
            {
                BinaryReader br;

                BinaryReader brR = new BinaryReader(vltFile.RawStream);
                BinaryReader brV = new BinaryReader(vltFile.VltStream);

                VLTDataRow  dataRow  = new VLTDataRow(_vltClass.FieldCount);
                VLTPointers pointers = vltFile.GetChunk(VLTChunkId.Pointers) as VLTPointers;

                int offset = 0;

#if CARBON
                if (pointers[collLoad.Pointer] == null)
                {
                    /*
                     * Debug.WriteLine(string.Format("Skipped Exp.. class='{0}', name='{1}', num1={2}, exp_ptr={3:x}, ptr_ptr={4:x}",
                     *      HashResolver.Resolve(collLoad.ClassNameHash), HashResolver.Resolve(collLoad.NameHash),
                     *      collLoad.Num1, collLoad.Address, collLoad.Pointer));
                     */
                }
                else
                {
                    offset = pointers[collLoad.Pointer].OffsetDest;
                }
#else
                offset = pointers[collLoad.Pointer].OffsetDest;
#endif

                dataRow.VLTFile        = vltFile;
                dataRow.VLTClass       = _vltClass;
                dataRow.CollectionLoad = collLoad;

                for (int i = 0; i < _vltClass.FieldCount; i++)
                {
#if CARBON
                    bool runtimeLink = false;
#endif
                    ClassField field = _vltClass[i];

                    if (field.IsOptional)
                    {
                        br = null;
                        for (int j = 0; j < collLoad.CountOptional; j++)
                        {
                            if (collLoad[j].NameHash == field.NameHash)
                            {
                                if (collLoad[j].IsDataEmbedded)
                                {
                                    br = brV;
                                    br.BaseStream.Seek(collLoad[j].Pointer, SeekOrigin.Begin);
                                }
                                else
                                {
                                    VLTPointerBlock block = pointers[collLoad[j].Pointer];
#if CARBON
                                    if (block != null)
#endif
                                    {
                                        int localOffset = block.OffsetDest;
                                        br = brR;
                                        br.BaseStream.Seek(localOffset, SeekOrigin.Begin);
                                    }
#if CARBON
                                    else
                                    {
                                        /*
                                         * System.Diagnostics.Debug.WriteLine(
                                         *      string.Format("Runtime Linkage '{0}', name '{1}', field '{2}', req ptr '{3:x}'",
                                         *              HashResolver.Resolve(_vltClass.ClassHash), HashResolver.Resolve(collLoad.NameHash),
                                         *              HashResolver.Resolve(field.NameHash), collLoad[j].Pointer));
                                         */
                                        runtimeLink = true;
                                        br          = brR;
                                    }
#endif
                                }
                            }
                        }
                        if (br == null)
                        {
                            // data is not defined
                            continue;
                        }
                    }
                    else
                    {
                        br = brR;
                        br.BaseStream.Seek(offset + field.Offset, SeekOrigin.Begin);
                    }

/*
 #if !CARBON
 *                                      if (!field.IsArray && field.Alignment > 0)
 *                                      {
 *                                              int align = field.Alignment;
 *                                              if (br.BaseStream.Position % align != 0)
 *                                                      br.BaseStream.Position += align - (br.BaseStream.Position % align);
 *                                      }
 #endif
 */

                    Type type = VLTTypeResolver.Resolver.Resolve(field.TypeHash);

                    if (type == null)
                    {
                        type = typeof(VLTDataItems.Unknown);
                    }

                    VLTDataItem dataItem;
                    if (field.IsArray)
                    {
                        dataItem = VLTDataItemArray.Instantiate(field, type);
                    }
                    else
                    {
                        dataItem = VLTDataItem.Instantiate(type);
                        if (dataItem is VLTDataItems.Unknown)
                        {
                            (dataItem as VLTDataItems.Unknown).SetLength(field.Length);
                        }
                    }

                    dataItem.Offset     = 0;
                    dataItem.InlineData = (br == brV);
                    dataItem.TypeHash   = field.TypeHash;
                    dataItem.NameHash   = field.NameHash;
                    dataItem.DataRow    = dataRow;

                    if (offset != 0 && !runtimeLink)
                    {
                        dataItem.Offset = (uint)br.BaseStream.Position;
                        dataItem.Read(br);
                    }

                    dataRow[i] = dataItem;
                }

                _collection.Add(dataRow);
            }