示例#1
0
		private void ParseRiff(Stream Stream)
		{
			if (Stream.ReadString(4) != "WAVE") throw (new InvalidDataException("Not a RIFF.WAVE File"));
			while (!Stream.Eof())
			{
				var ChunkType = Stream.ReadString(4);
				var ChunkSize = new BinaryReader(Stream).ReadUInt32();
				var ChunkStream = Stream.ReadStream(ChunkSize);
				HandleChunkInternal(ChunkType, ChunkStream);
			}
		}
示例#2
0
 public virtual bool LoadFrom(Stream stream)
 {
     uint count = stream.ReadUInt();
     for (int i = 0; i < count; i++)
     {
         var key = stream.ReadString();
         var val = stream.ReadString();
         KeyValues.Add(key, val);
     }
     return true;
 }
示例#3
0
文件: gim.cs 项目: memerdot/puyotools
 /* Check to see if this is a GIM */
 public override bool Check(ref Stream input, string filename)
 {
     try
     {
         return (input.ReadString(0x0, 12, false) == GraphicHeader.MIG ||
             input.ReadString(0x0, 12, false) == GraphicHeader.GIM);
     }
     catch
     {
         return false;
     }
 }
示例#4
0
文件: snt.cs 项目: memerdot/puyotools
 /* Checks to see if the input stream is a SNT archive */
 public override bool Check(ref Stream input, string filename)
 {
     try
     {
         return ((input.ReadString(0x0, 4) == ArchiveHeader.NSIF &&
             input.ReadString(0x20, 4) == ArchiveHeader.NSTL) ||
             (input.ReadString(0x0, 4) == ArchiveHeader.NUIF &&
             input.ReadString(0x20, 4) == ArchiveHeader.NUTL));
     }
     catch
     {
         return false;
     }
 }
		public static PlainTextExtension Read(Stream stream)
		{
			var blockSize = stream.ReadByte();
			if (blockSize != BlockSize)
			{
				throw new GifException("Plain text extension data format error");
			}

			var result = new PlainTextExtension
				{
					TextGridLeftPosition = stream.ReadShort(),
					TextGridTopPosition = stream.ReadShort(),
					TextGridWidth = stream.ReadShort(),
					TextGridHeight = stream.ReadShort(),
					CharacterCellWidth = (byte) stream.ReadByte(),
					CharacterCellHeight = (byte) stream.ReadByte(),
					TextForegroundColorIndex = (byte) stream.ReadByte(),
					TextBackgroundColorIndex = (byte) stream.ReadByte(),
					PlainTextData = new List<string>()
				};

			blockSize = stream.ReadByte();
			while (blockSize > 0)
			{
				var plainTextData = stream.ReadString(blockSize);
				result.PlainTextData.Add(plainTextData);

				blockSize = stream.ReadByte();
			}

			return result;
		}
示例#6
0
		private void ParseFile(Stream Stream)
		{
			if (Stream.ReadString(4) != "RIFF") throw (new InvalidDataException("Not a RIFF File"));
			var RiffSize = new BinaryReader(Stream).ReadUInt32();
			var RiffStream = Stream.ReadStream(RiffSize);
			ParseRiff(RiffStream);
		}
 public static ForwardedSubscriptionRequest ReadBody(Stream stream)
 {
     var clientId = stream.ReadInt32();
     var topic = stream.ReadString();
     var isAdd = stream.ReadBoolean();
     return new ForwardedSubscriptionRequest(clientId, topic, isAdd);
 }
        public static BodyChunk ReadChunk(string RawBody, Stream ResponseStream)
        {
            if (RawBody == "0\r\n\r\n")
                return new BodyChunk("", true);

            var bodyIndex = RawBody.IndexOf("\r\n");

            var chunkLength = int.Parse(RawBody.Remove(bodyIndex), System.Globalization.NumberStyles.HexNumber);

            var bodyLength = RawBody.Length - bodyIndex + 2;

            while (bodyLength <= chunkLength)
            {
                var resp = ResponseStream.ReadString(8192 * 4);

                bodyLength += resp.Length;

                RawBody += resp;
            }

            var body = RawBody.Substring(bodyIndex + 2, chunkLength);

            var end = bodyIndex + 2 + chunkLength;

            var tail = RawBody.Substring(end);

            return new BodyChunk(body, tail.Contains("0"));
        }
示例#9
0
文件: sba.cs 项目: memerdot/puyotools
        /* Get the offsets, lengths, and filenames of all the files */
        public override ArchiveFileList GetFileList(ref Stream data)
        {
            try
            {
                /* Get the number of files */
                uint files = data.ReadUInt(0x0);

                /* Create the array of files now */
                ArchiveFileList fileList = new ArchiveFileList(files);

                /* Now we can get the file offsets, lengths, and filenames */
                for (uint i = 0; i < files; i++)
                {
                    fileList.Entries[i] = new ArchiveFileList.Entry(
                        data.ReadUInt(0x4 + (i * 0x2C)), // Offset
                        data.ReadUInt(0x8 + (i * 0x2C)), // Length
                        data.ReadString(0xC + (i * 0x2C), 36) // Filename
                    );
                }

                return fileList;
            }
            catch
            {
                return null;
            }
        }
示例#10
0
        public void Deserialize(Stream input)
        {
            var magic = input.ReadValueU32(this.LittleEndian);

            if (magic != 0x54414653)
                throw new NotSupportedException("Bad magic number");

            this.Unknown04 = input.ReadValueU32(this.LittleEndian);
            this.NumberOfFiles = input.ReadValueU32(this.LittleEndian);

            var count = input.ReadValueU32(this.LittleEndian);

            this.Unknown10 = input.ReadValueU32(this.LittleEndian);

            this.BasePath = input.ReadString(32, true, Encoding.ASCII);

            this.Entries.Clear();
            for (uint i = 0; i < count; i++)
            {
                var entry = new Big.EntryV2();
                entry.NameHash = input.ReadValueU32(this.LittleEndian);
                entry.Locale = input.ReadValueU32(this.LittleEndian);
                entry.Size = input.ReadValueU32(this.LittleEndian);
                var offset = input.ReadValueU32(this.LittleEndian);
                entry.Offset = offset & 0xFFFFFF00;
                entry.File = offset & 0xFF;
                this.Entries.Add(entry);
            }
        }
示例#11
0
        public void ReadFrom(Stream stream)
        {
            int numMaterials = stream.ReadInt32();
            Layers = new MyMaterialLayer[numMaterials];
            for (int i = 0; i < numMaterials; ++i)
            {
                Layers[i] = new MyMaterialLayer();
                Layers[i].StartHeight = stream.ReadFloat();
                Layers[i].EndHeight = stream.ReadFloat();
                Layers[i].StartAngle = stream.ReadFloat();
                Layers[i].EndAngle = stream.ReadFloat();
                Layers[i].HeightStartDeviation = stream.ReadFloat();
                Layers[i].AngleStartDeviation = stream.ReadFloat();
                Layers[i].HeightEndDeviation = stream.ReadFloat();
                Layers[i].AngleEndDeviation = stream.ReadFloat();
                Layers[i].MaterialDefinition = MyDefinitionManager.Static.GetVoxelMaterialDefinition(stream.ReadString());
            }

            int numOreProbabilities = stream.ReadInt32();
            OreProbabilities = new MyOreProbability[numOreProbabilities];
            for (int i = 0; i < numOreProbabilities; ++i)
            {
                OreProbabilities[i] = new MyOreProbability();
                OreProbabilities[i].CummulativeProbability = stream.ReadFloat();
                OreProbabilities[i].OreName = stream.ReadString();
            }

            OreStartDepth = stream.ReadFloat();
            OreEndDepth = stream.ReadFloat();
        }
示例#12
0
 private static string ReadString(Stream input)
 {
     var length = input.ReadValueU32();
     if (length >= 1024)
     {
         throw new InvalidOperationException();
     }
     return input.ReadString(length, true, Encoding.ASCII);
 }
示例#13
0
文件: mrg.cs 项目: memerdot/puyotools
 /* Checks to see if the input stream is a MRG archive */
 public override bool Check(ref Stream input, string filename)
 {
     try
     {
         return (input.ReadString(0x0, 4) == ArchiveHeader.MRG);
     }
     catch
     {
         return false;
     }
 }
		public object Deserialize(Stream stream){
			int count = (int)ZigZag.DeserializeUInt32 (stream);
			var types = new TypeMap ();
			while(count-- != 0) {
				uint tag = ZigZag.DeserializeUInt32 (stream);
				var typeName = stream.ReadString ();
				var type = this.typeNames.GetType (typeName);
				types.Add(tag, typeName, type);
			}	
			return types;
		}
示例#15
0
 // Check
 public override bool Check(ref Stream data, string filename)
 {
     try
     {
         return (data.ReadString(0x0, 4) == "LZ01");
     }
     catch
     {
         return false;
     }
 }
        public Exception Deserialize(Stream source)
        {
            if (source == null)
                throw new ArgumentNullException("source");

            Exception exception = null;

            var flag = source.ReadByte();
            var typeAliasUsed = ((flag & 1) != 0);
            var typeSerializable = ((flag & 2) != 0);

            Type type;
            if (typeAliasUsed)
            {
                var typeAlias = source.Read32BitEncodedInt();
                type = _data.TypeTable.GetType(typeAlias);
                if (type == null)
                {
                    exception = new InvalidOperationException(
                        "Cannot resolve type from alias. Alias=" + typeAlias);
                }
            }
            else
            {
                var typeName = source.ReadString();
                type = TypeUtility.GetType(typeName);
                if (type == null)
                {
                    exception = new InvalidOperationException(
                        "Cannot resolve type from name. Name=" + typeName);
                }
            }

            if (exception == null)
            {
                exception = (Exception)Activator.CreateInstance(type);
                if (typeSerializable)
                {
                    int dataLen = source.Read32BitEncodedInt();
                    _data.MessageSerializer.Deserialize(source, exception, type, dataLen);
                }
            }
            else
            {
                if (typeSerializable)
                {
                    int dataLen = source.Read32BitEncodedInt();
                    source.Position = source.Position + dataLen;
                }
            }

            return exception;
        }
示例#17
0
文件: pvm.cs 项目: memerdot/puyotools
 /* Checks to see if the input stream is a PVM archive */
 public override bool Check(ref Stream input, string filename)
 {
     try
     {
         return (input.ReadString(0x0, 4) == ArchiveHeader.PVM); // &&
             //input.ReadByte(input.ReadUInt(0x4) + 17) < 96);
     }
     catch
     {
         return false;
     }
 }
示例#18
0
        private void LoadGMK_GMDataFile(IList <KeyValuePair <string, GMDataFile> > _list, Stream _s)
        {
            _s.ReadInteger();
            int num = _s.ReadInteger();

            for (int i = 0; i < num; i++)
            {
                string     key   = _s.ReadString();
                GMDataFile value = new GMDataFile(this, _s);
                _list.Add(new KeyValuePair <string, GMDataFile>(key, value));
            }
        }
示例#19
0
        /****************************************************************************/
        public static string LoadResource(this string resName)
        {
            using (Stream s = typeof(MainWindow).Assembly.GetManifestResourceStream("JTranEdit.Assets." + resName))
            {
                if (s == null)
                {
                    throw new InvalidOperationException("Could not find embedded resource");
                }

                return(s.ReadString());
            }
        }
示例#20
0
        private void LoadGMK_GMExtension(IList <GMExtension> _list, Stream _s)
        {
            _s.ReadInteger();
            int num = _s.ReadInteger();

            for (int i = 0; i < num; i++)
            {
                _s.ReadString();
                GMExtension item = new GMExtension(this, _s);
                _list.Add(item);
            }
        }
示例#21
0
        public static string ReadStringU16(this Stream input, ushort maximumLength, Encoding encoding, Endian endian)
        {
            var length = input.ReadValueU16(endian);

            if (length >= maximumLength)
            {
                length = maximumLength;
                length--;
            }

            return(input.ReadString(length, true, encoding));
        }
            static object Reader(Stream stream, DeserializerSession session)
            {
                var name  = stream.ReadString(session);
                var owner = stream.ReadObject(session) as Type;


                var field = owner
                            .GetField(name,
                                      BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

                return(field);
            }
示例#23
0
文件: acx.cs 项目: memerdot/puyotools
 // Check to see if the following data is an ACX
 public override bool Check(ref Stream input, string filename)
 {
     try
     {
         return (input.ReadString(0x0, 4, false) == ArchiveHeader.ACX &&
             Path.GetExtension(filename).ToLower() == ".acx");
     }
     catch
     {
         return false;
     }
 }
 public EnumMatchingFlags(Stream stream)
 {
     switch (stream.ReadNextByte())
     {
         case 1:
             m_matchMode = (EnumMatchingFlagsMode)stream.ReadNextByte();
             m_value = stream.ReadInt32();
             m_description = stream.ReadString();
             break;
         default:
             throw new VersionNotFoundException();
     }
 }
示例#25
0
        protected static IColumnSpec[] ReadColumnSpecs(int colCount, string keyspace, string table, bool globalTablesSpec, Stream stream)
        {
            IColumnSpec[] columnSpecs = new IColumnSpec[colCount];
            for (int colIdx = 0; colIdx < colCount; ++colIdx)
            {
                string colKeyspace = keyspace;
                string colTable    = table;
                if (!globalTablesSpec)
                {
                    colKeyspace = stream.ReadString();
                    colTable    = stream.ReadString();
                }

                string     colName      = stream.ReadString();
                ColumnType colType      = (ColumnType)stream.ReadUShort();
                string     colCustom    = null;
                ColumnType colKeyType   = ColumnType.Custom;
                ColumnType colValueType = ColumnType.Custom;
                switch (colType)
                {
                case ColumnType.Custom:
                    colCustom = stream.ReadString();
                    break;

                case ColumnType.List:
                case ColumnType.Set:
                    colValueType = (ColumnType)stream.ReadUShort();
                    break;

                case ColumnType.Map:
                    colKeyType   = (ColumnType)stream.ReadUShort();
                    colValueType = (ColumnType)stream.ReadUShort();
                    break;
                }

                columnSpecs[colIdx] = new ColumnSpec(colIdx, colKeyspace, colTable, colName, colType, colCustom, colKeyType, colValueType);
            }
            return(columnSpecs);
        }
示例#26
0
 public GMInstance(Stream _stream, bool _gmk)
 {
     X     = _stream.ReadInteger();
     Y     = _stream.ReadInteger();
     Index = _stream.ReadInteger();
     Id    = _stream.ReadInteger();
     Code  = _stream.ReadString();
     _stream.ReadBoolean();
     ScaleX   = 1.0;
     ScaleY   = 1.0;
     Colour   = uint.MaxValue;
     Rotation = 0.0;
 }
            public void Deserialize(Stream input, Endian endian)
            {
                uint length = input.ReadValueU32(endian);

                if (length > 1024)
                {
                    throw new FormatException("doubt there is a file with more than 1024 characters in its name");
                }

                this.Name   = input.ReadString(length, true, Encoding.ASCII);
                this.Offset = input.ReadValueU32(endian);
                this.Size   = input.ReadValueU32(endian);
            }
示例#28
0
 public override bool LoadFrom(Stream stream)
 {
     base.LoadFrom(stream);
     Attribute.LoadFrom(stream);
     UnderlyType = stream.ReadString();
     uint count = stream.ReadUInt();
     for (int i = 0; i < count; i++)
     {
         FieldNames.Add(stream.ReadString());
         FieldValues.Add(stream.ReadInt());
     }
     return true;
 }
            static object Reader(Stream stream, DeserializerSession session)
            {
                var name      = stream.ReadString(session);
                var owner     = stream.ReadObject(session) as Type;
                var arguments = stream.ReadObject(session) as Type[];


                var method = owner.GetMethod(name,
                                             BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null,
                                             CallingConventions.Any, arguments, null);

                return(method);
            }
示例#30
0
文件: tex.cs 项目: memerdot/puyotools
 /* Checks to see if the input stream is a MRG archive */
 public override bool Check(ref Stream input, string filename)
 {
     try
     {
         return (input.ReadString(0x0, 4) == ArchiveHeader.TEX &&
             input.ReadUInt(0x4) != input.Length &&
             input.ReadUInt(0x4) != input.Length - 4);
     }
     catch
     {
         return false;
     }
 }
示例#31
0
        public override object Deserialize(Stream stream, Type type)
        {
            stream.AssertNotNull();
            type.AssertNotNull();

            if (!CanHandle(type))
            {
                Warning($"{nameof(StringSerializer)} cannot handle type {type}!");
                return(null);
            }

            return(stream.ReadString(Encoding));
        }
示例#32
0
        public override void ParseFromStream(Stream Stream, int Length, MinecraftVersion Version)
        {
            int protocolVersion = Stream.ReadVarInt();

            this.Version  = new MinecraftVersion(protocolVersion);
            ServerAddress = Stream.ReadString();
            ServerPort    = Stream.ReadUshort();
            NextState     = (ConnectionState)Stream.ReadVarInt();
            if (NextState != ConnectionState.Login && NextState != ConnectionState.Status)
            {
                throw new FormatException();
            }
        }
示例#33
0
        private static void Deserializer_ReadColumnArray(Stream stream, DataColumnCollection columns)
        {
            //读入数据列个数,最多255个字段列
            int    count = stream.ReadByte();
            string c_name;

            while (--count >= 0)
            {
                c_name = stream.ReadString();
                var colType = GetCodeType((byte)stream.ReadByte());
                columns.Add(c_name, colType);
            }
        }
示例#34
0
        public void Deserialize(Stream input, Endian endian)
        {
            this.Unknown2  = input.ReadValueU32(endian);
            this.Unknown3  = input.ReadValueU32(endian);
            this.Unknown4  = input.ReadValueU32(endian);
            this.Unknown5  = input.ReadValueU64(endian);
            this.Creator   = input.ReadString((int)input.ReadValueU32(endian), Encoding.UTF8);
            this.Unknown7  = input.ReadValueU64(endian);
            this.Author    = input.ReadString((int)input.ReadValueU32(endian), Encoding.UTF8);
            this.Name      = input.ReadString((int)input.ReadValueU32(endian), Encoding.UTF8);
            this.Unknown10 = input.ReadValueU64(endian);

            this.Unknown11 = new byte[36];
            input.Read(this.Unknown11, 0, this.Unknown11.Length);

            this.Unknown12 = new byte[36];
            input.Read(this.Unknown12, 0, this.Unknown12.Length);

            this.Size      = (Size)input.ReadValueU32(endian);
            this.Players   = (Players)input.ReadValueU32(endian);
            this.Unknown15 = input.ReadValueU32(endian);
        }
示例#35
0
 public static object ReadPrimitiveOrStringType(this Stream stream, Type type)
 {
     if (type == typeof(Byte))
     {
         return(stream.ReadByte());
     }
     else if (type == typeof(Boolean))
     {
         return(stream.ReadBool());
     }
     else if (type == typeof(short))
     {
         return(stream.ReadInt16());
     }
     else if (type == typeof(ushort))
     {
         return(stream.ReadUInt16());
     }
     else if (type == typeof(int))
     {
         return(stream.ReadInt32());
     }
     else if (type == typeof(uint))
     {
         return(stream.ReadUInt32());
     }
     else if (type == typeof(long))
     {
         return(stream.ReadInt64());
     }
     else if (type == typeof(ulong))
     {
         return(stream.ReadUInt64());
     }
     else if (type == typeof(float))
     {
         return(stream.ReadFloat());
     }
     else if (type == typeof(double))
     {
         return(stream.ReadDouble());
     }
     else if (type == typeof(string))
     {
         return(stream.ReadString());
     }
     else
     {
         return(null);
     }
 }
示例#36
0
        public static (TreeEntry entry, bool eof) Read(Stream stream)
        {
            try
            {
                var data = stream.ReadString(' ');
                if (string.IsNullOrEmpty(data))
                {
                    return(null, false);
                }

                data = data.Substring(0, data.Length - 1);

                var name = stream.ReadString(0);
                if (string.IsNullOrEmpty(name))
                {
                    return(null, false);
                }

                name = name.Substring(0, name.Length - 1);

                var sha = new byte[20];
                if (stream.Read(sha, 0, 20) != 20)
                {
                    return(null, false);
                }

                return(new TreeEntry
                {
                    name = name,
                    Mode = data,
                    Hash = sha.AsShaToCid()
                }, false);
            }
            catch (EndOfStreamException)
            {
                return(null, true);
            }
        }
        internal override void Deserialize(Stream input, Endian endian, ICacheTables tables)
        {
            var visibility = (Visibility)input.ReadValueU8();

            var unknown88Index = input.ReadValueU32(endian);
            var unknown88      = tables.GetDefinition <NativeDefinition>(unknown88Index);
            var unknown20      = input.ReadValueU16(endian);

            if ((unknown20 & 0x20) != 0)
            {
                var somethingLength = input.ReadValueU16(endian);
                var something       = input.ReadString(somethingLength, true, Encoding.UTF8);
            }

            var unknown58Count = input.ReadValueU32(endian);
            var unknown58s     = new Tuple <string, string> [unknown58Count];

            for (uint i = 0; i < unknown58Count; i++)
            {
                var unknown58_0Length = input.ReadValueU16(endian);
                var unknown58_0       = input.ReadString(unknown58_0Length, true, Encoding.UTF8);
                var unknown58_1Length = input.ReadValueU16(endian);
                var unknown58_1       = input.ReadString(unknown58_1Length, true, Encoding.UTF8);
                unknown58s[i] = new Tuple <string, string>(unknown58_0, unknown58_1);
            }

            var unknown38Count = input.ReadValueU32(endian);
            var unknown38s     = new Tuple <string, string> [unknown38Count];

            for (uint i = 0; i < unknown38Count; i++)
            {
                var unknown38Length = input.ReadValueU16(endian);
                var unknown38       = input.ReadString(unknown38Length, true, Encoding.UTF8);
                var unknown28Length = input.ReadValueU16(endian);
                var unknown28       = input.ReadString(unknown28Length, true, Encoding.UTF8);
                unknown38s[i] = new Tuple <string, string>(unknown38, unknown28);
            }
        }
示例#38
0
 public static void ReadPOF(this Stream stream, ref POF POF)
 {
     if (stream.ReadString(3) == "POF")
     {
         POF.Type = byte.Parse(stream.ReadString(1));
         int IsX = POF.Type + 2;
         stream.Seek(-4, SeekOrigin.Current);
         POF.Header = stream.ReadHeader();
         stream.Seek(POF.Offset + POF.Header.Length, 0);
         POF.Length = stream.ReadInt32();
         while (POF.Length + POF.Offset + POF.Header.Length > stream.Position)
         {
             int a = stream.ReadByte();
             if (a >> 6 == 0)
             {
                 break;
             }
             else if (a >> 6 == 1)
             {
                 a = a & 0x3F;
             }
             else if (a >> 6 == 2)
             {
                 a = a & 0x3F;
                 a = (a << 8) | stream.ReadByte();
             }
             else if (a >> 6 == 3)
             {
                 a = a & 0x3F;
                 a = (a << 8) | stream.ReadByte();
                 a = (a << 8) | stream.ReadByte();
                 a = (a << 8) | stream.ReadByte();
             }
             a <<= IsX;
             POF.LastOffset += a;
         }
     }
 }
示例#39
0
 // Check
 public static bool Check(ref Stream data, string filename)
 {
     try
     {
         // Because this can conflict with other compression formats we are going to add a check them too
         return(data.ReadString(0x0, 1) == "\x10");      //&&
         //!Compression.Dictionary[CompressionFormat.PRS].Check(ref data, filename) &&
         //!Images.Dictionary[GraphicFormat.PVR].Check(ref data, filename));
     }
     catch
     {
         return(false);
     }
 }
示例#40
0
        public void Deserialize(IBlock parent, Stream input, Endian endian)
        {
            var count = input.ReadValueU32(endian);

            this.Unknown00 = input.ReadValueU32(endian);

            this.Paths.Clear();
            for (uint i = 0; i < count; i++)
            {
                var length = input.ReadValueU32(endian);
                this.Paths.Add(input.ReadString((int)length));
                input.Seek(1, SeekOrigin.Current); // skip null
            }
        }
示例#41
0
        public void Read(Stream data)
        {
            string str = data.ReadString(size: 4);

            if (str != TypeStr)
            {
                throw new InvalidDataException("Incorrect header chunk type string found");
            }

            Length      = data.ReadUInt32BE();
            Format      = data.ReadUInt16BE();
            TrackCount  = data.ReadUInt16BE();
            rawDivision = data.ReadUInt16BE();
        }
        /// <summary>
        ///
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        public void ReadRecord()
        {
            Debug.Assert(_stream.ReadStringz(2) == "PK");
            var structType = _binaryReader.ReadUint16Endian(Endianness.BigEndian);

            switch (structType)
            {
            /*
             * // F.  Central directory structure:
             * case 0x0102:
             *  break;
             */
            // A.  Local file header:
            case 0x0304:
            {
                var localFileHeader = _stream.ReadStruct <LocalFileHeader>();
                _stream.Skip(localFileHeader.ExtraFieldLength);
                var name             = _stream.ReadString(localFileHeader.FileNameLength, Encoding.UTF8);
                var compressedStream = _stream.ReadStream(localFileHeader.CompressedSize);
                var extraFieldStream = _stream.ReadStream(localFileHeader.ExtraFieldLength);

                Files.Add(name, new File
                    {
                        ZipArchive       = this,
                        LocalFileHeader  = localFileHeader,
                        Name             = name,
                        CompressedStream = compressedStream,
                        ExtraFieldStream = extraFieldStream
                    });
            }
            break;

            /*
             * // I.  End of central directory record:
             * case 0x0506:
             *  break;
             * // G.  Zip64 end of central directory record
             * case 0x0606:
             *  break;
             * // H.  Zip64 end of central directory locator
             * case 0x0607:
             *  break;
             * // E.  Archive extra data record:
             * case 0x0608:
             *  break;
             */
            default:
                throw new NotImplementedException($"Unknown {structType:X}");
            }
        }
示例#43
0
        private string FindString(Stream LCPCFile, long ValuesOffset)
        {
            byte[] Read = new byte[4];
            LCPCFile.Read(Read, 0, 4);
            Array.Reverse(Read);
            long Valueoffset = BitConverter.ToInt32(Read, 0);
            long currentpos  = LCPCFile.Position;

            LCPCFile.Seek(ValuesOffset + Valueoffset, SeekOrigin.Begin);
            string value = LCPCFile.ReadString();

            LCPCFile.Position = currentpos;
            return(value);
        }
示例#44
0
        public EnumMatchingFlags(Stream stream)
        {
            switch (stream.ReadNextByte())
            {
            case 1:
                m_matchMode   = (EnumMatchingFlagsMode)stream.ReadNextByte();
                m_value       = stream.ReadInt32();
                m_description = stream.ReadString();
                break;

            default:
                throw new VersionNotFoundException();
            }
        }
示例#45
0
        /// <summary>
        /// Derializes an <see cref="Material"/> from a stream.
        /// </summary>
        /// <param name="stream">The stream to read from.</param>
        /// <returns>A new instance of <see cref="Material"/> with data read from the <paramref name="stream"/>.</returns>
        public static Material ReadMaterial(this Stream stream)
        {
            var         name = stream.ReadString();
            MaterialRaw raw  = stream.ReadStructure <MaterialRaw>();

            var properties = new MaterialProperty[raw.PropertiesCount];

            for (uint i = 0; i < raw.PropertiesCount; i++)
            {
                properties[i] = stream.ReadMaterialProperty();
            }

            return(new Material(name, properties));
        }
示例#46
0
文件: onz.cs 项目: memerdot/puyotools
 // Check
 public override bool Check(ref Stream data, string filename)
 {
     try
     {
         // Because this can conflict with other compression formats we are going to add a check them too
         return (data.ReadString(0x0, 1) == "\x11" &&
             !Compression.Dictionary[CompressionFormat.PRS].Check(ref data, filename) &&
             !Images.Dictionary[GraphicFormat.PVR].Check(ref data, filename));
     }
     catch
     {
         return false;
     }
 }
示例#47
0
        public static string ReadStringU32(this Stream stream, Endian endian)
        {
            var size = stream.ReadValueU32(endian);

            if (size == 0)
            {
                return("");
            }

#warning this is an hacked functions by G1zm0!
            int _sizeHacked = Convert.ToInt32(size);

            return(stream.ReadString(_sizeHacked, true, Encoding.ASCII));
        }
        public static string ReadStringPascal(this Stream stream, int maxLength)
        {
            var length = stream.ReadValueU16();

            if (length > maxLength)
            {
                throw new FormatException("string length exceeds maximum length");
            }
            var text    = stream.ReadString(length, Encoding.UTF8);
            var padding = (-(length - 2)) & 3;

            stream.Seek(padding, SeekOrigin.Current);
            return(text);
        }
示例#49
0
        public static AttrDefItem ParseSingle(Stream stream)
        {
            AttrDefItem item = new AttrDefItem();

            item.Label         = stream.ReadString(Encoding.Unicode, 128);
            item.Type          = stream.ReadUint();
            item.DisplayRule   = stream.ReadUint();
            item.CollationRule = (AttrDefCollationRule)stream.ReadInt();
            item.Flags         = (AttrDefType)stream.ReadInt();
            item.MinimumSize   = stream.ReadUlong();
            item.MaximumSize   = stream.ReadUlong();

            return(item);
        }
示例#50
0
        public static Dictionary <string, string[]> ReadStringMultimap(this Stream stream)
        {
            ushort len = stream.ReadUShort();
            Dictionary <string, string[]> data = new Dictionary <string, string[]>(len);

            for (int i = 0; i < len; ++i)
            {
                string   key   = stream.ReadString();
                string[] value = stream.ReadStringList();
                data.Add(key, value);
            }

            return(data);
        }
 public StringMatching(Stream stream)
 {
     switch (stream.ReadNextByte())
     {
         case 1:
             MatchMode = (StringMatchingMode)stream.ReadNextByte();
             MatchText = stream.ReadString();
             if (MatchMode == StringMatchingMode.Regex)
                 m_matchRegex = new Regex(MatchText);
             break;
         default:
             throw new VersionNotFoundException();
     }
 }
示例#52
0
        public void ReadFrom(Stream stream)
        {         
            int numOreProbabilities = stream.ReadInt32();
            OreProbabilities = new MyOreProbability[numOreProbabilities];
            for (int i = 0; i < numOreProbabilities; ++i)
            {
                OreProbabilities[i] = new MyOreProbability();
                OreProbabilities[i].CummulativeProbability = stream.ReadFloat();
                OreProbabilities[i].OreName = stream.ReadString();
            }

            OreStartDepth = stream.ReadFloat();
            OreEndDepth = stream.ReadFloat();
        }
示例#53
0
        /// <summary>
        /// Loads a log messages from the supplied stream
        /// </summary>
        /// <param name="stream">the stream to load the log message from.</param>
        /// <param name="helper">the helper to assist in loading/saving</param>
        internal LogEventPublisherDetails(Stream stream, LogMessageSaveHelper helper)
        {
            byte version = stream.ReadNextByte();

            switch (version)
            {
            case 1:
                string typeName     = stream.ReadString();
                string assemblyName = stream.ReadString();
                TypeData  = new PublisherTypeDefinition(typeName, assemblyName);
                EventName = stream.ReadString();
                break;

            case 2:
                EventName = stream.ReadString();
                TypeData  = helper.LoadPublisherTypeDefinition(stream);
                break;

            default:
                throw new VersionNotFoundException();
            }
            m_hashCode = ComputeHashCode();
        }
示例#54
0
        public void Read(Stream reader)
        {
            ParentPath = reader.ReadString();
            var extensionPointId = StringHelper.GetExtensionPointId(ParentPath);
            var childCount       = reader.ReadInt32();

            _children = new List <ExtensionBuilderRecord>(childCount);
            for (int i = 0; i < childCount; i++)
            {
                var child = ExtensionBuilderRecordHelper.Read(reader, extensionPointId, ParentPath);
                child.Read(reader);
                Children.Add(child);
            }
        }
示例#55
0
        public override object ReadValue(Stream stream, DeserializerSession session)
        {
            var shortname = stream.ReadString(session);
            if (shortname == null)
                return null;

            var name = TypeEx.ToQualifiedAssemblyName(shortname);
            var type = Type.GetType(name,true);

            //add the deserialized type to lookup
            if (session.Serializer.Options.PreserveObjectReferences)
            {
                session.TrackDeserializedObject(type);
            }
            return type;
        }
示例#56
0
        public CompletedResponse(Stream stream)
        {
            string[] tokens = stream.ReadString().Split();
            if (tokens.Length > 1)
            {
                int rowsAffected;
                if (int.TryParse(tokens[tokens.Length - 1], out rowsAffected))
                    _rowsAffected = rowsAffected;
                else
                    _rowsAffected = null;

            }
            _lastInsertedOID = (tokens.Length > 2 && tokens[0].Trim().ToUpperInvariant() == "INSERT")
                                   ? long.Parse(tokens[1])
                                   : (long?)null;
        }
示例#57
0
        public void Deserialize(Stream input)
        {
            var fileAlignment = input.ReadValueU32(true);
            if (fileAlignment != 0x7FF00000 &&
                fileAlignment != 0x0000F07F &&
                fileAlignment != 0x62300000 &&
                fileAlignment != 0x00003062)
            {
                throw new FormatException("unexpected file alignment (should have been 0x7FF00000)");
            }

            this.LittleEndian =
                fileAlignment == 0x7FF00000 ||
                fileAlignment == 0x62300000;
            this.FileAlignment = this.LittleEndian == true ?
                fileAlignment : fileAlignment.Swap();

            this.BasePath = input.ReadString(64, true, Encoding.ASCII);

            var count = input.ReadValueU32(this.LittleEndian);

            var hashes = new uint[count];
            for (uint i = 0; i < count; i++)
            {
                hashes[i] = input.ReadValueU32(this.LittleEndian);
            }

            this.Entries.Clear();
            for (uint i = 0; i < count; i++)
            {
                var entry = new Big.Entry();
                entry.NameHash = hashes[i];
                entry.UncompressedSize = input.ReadValueU32(this.LittleEndian);
                entry.Offset = input.ReadValueU32(this.LittleEndian);
                entry.Locale = input.ReadValueU32(this.LittleEndian);
                entry.CompressedSize = input.ReadValueU32(this.LittleEndian);
                this.Entries.Add(entry);

                if (entry.CompressedSize != 0)
                {
                    throw new NotSupportedException();
                }
            }
        }
示例#58
0
        public static MulticastData ReadBody(Stream stream)
        {
            var topic = stream.ReadString();
            var isImage = stream.ReadBoolean();

            var nbytes = stream.ReadInt32();
            var data = new byte[nbytes];
            var offset = 0;
            while (nbytes > 0)
            {
                var bytesRead = stream.Read(data, offset, nbytes);
                if (bytesRead == 0)
                    throw new EndOfStreamException();
                nbytes -= bytesRead;
                offset += bytesRead;
            }

            return new MulticastData(topic, isImage, data);
        }
示例#59
0
        public static string GetFileExtension(Stream data)
        {
            // Check to see if the file is an archive
            Archive archive = new Archive(data, null);
            if (archive.Format != ArchiveFormat.NULL)
                return archive.FileExtension;

            // Check to see if the file is an image
            Images images = new Images(data, null);
            if (images.Format != GraphicFormat.NULL)
                return images.FileExtension;

            // Check to see if the file is an ADX (special case)
            if (data.Length > 4 && data.ReadUShort(0x00) == 0x0080 &&
                data.Length > data.ReadUShort(0x02).SwapEndian() + 4 &&
                data.ReadString(data.ReadUShort(0x02).SwapEndian() - 0x02, 6, true) == "(c)CRI")
                return ".adx";

            // Unknown
            return String.Empty;
        }
示例#60
0
        public static SetupMessage FromStream(DateTime timestamp, Stream stream)
        {
            bool? ex = stream.ReadNullBoolean();
            bool? low = stream.ReadNullBoolean();

            int count = stream.ReadInt32();
            var contributors = new Models.GameSettings.Contributor[count];
            for (int i = 0; i < count; i++)
            {
                var name = stream.ReadString();
                var active = stream.ReadBoolean();
                contributors[i] = new Models.GameSettings.Contributor() { Name = name, Active = active };
            }

            var settings = new Models.GameSettings()
            {
                ExcludeMerges = ex,
                LowerCase = low,
                Contributors = contributors
            };

            return new SetupMessage(timestamp, settings);
        }