示例#1
0
        /// <summary>
        /// Reads the specified file and shows it in an ASCII format.
        /// </summary>
        /// <param name="file">The file.</param>
        internal static void ShowAsAscii(FileInfo file)
        {
            Console.WriteLine("Converting to ASCII...");

            var cachedFile = new CachedFileReader(file);

            // Dump 16 bytes per line
            var len = cachedFile.Length;

            for (var i = 0; i < len; i += 16)
            {
                var cnt  = Math.Min(16, len - i);
                var line = new byte[cnt];
                Array.Copy(cachedFile.Buffer, i, line, 0, cnt);

                // Write address + hex + ascii
                Console.Write("{0:X6} ", i);
                Console.Write(BitConverter.ToString(line));
                Console.Write(" ");

                // Convert non-ascii characters to "."
                for (var j = 0; j < cnt; ++j)
                {
                    if (line[j] < 0x20 || line[j] > 0x7f)
                    {
                        line[j] = (byte)'.';
                    }
                }
                Console.WriteLine(Encoding.ASCII.GetString(line));
            }
        }
示例#2
0
        /// <summary>
        /// Parses the specified data.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns></returns>
        internal static object Parse(byte[] data)
        {
            var reader = new CachedFileReader(data);
            var parser = new CachedFileParser(reader);

            parser.Parse();

            return(parser.m_stream.Members.Select(member => member.ToObject()).ToList());
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="CachedFileReader"/> class.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="length">The length.</param>
        internal CachedFileReader(CachedFileReader source, int length)
        {
            Buffer = new byte[length];
            Array.Copy(source.Buffer, source.Position, Buffer, 0, length);

            Filename = source.Filename;
            Fullname = source.Fullname;

            SecurityCheck();
            EndOfObjectsData = length - m_shareSkip;
        }
示例#4
0
        /// <summary>
        /// Parses the specified file.
        /// </summary>
        /// <param name="file">The file.</param>
        /// <returns></returns>
        internal static KeyValuePair <object, object> Parse(FileInfo file)
        {
            Console.WriteLine("Parsing...");

            SType.Reset();
            var cachedFile = new CachedFileReader(file);
            var parser     = new CachedFileParser(cachedFile);

            parser.Parse();

            return(!s_dumpStructure?parser.ToObjects() : new KeyValuePair <object, object>());
        }
示例#5
0
        /// <summary>
        /// Parses a sub stream.
        /// </summary>
        /// <returns></returns>
        SType ParseSubStream()
        {
            SType subStream = new SStreamType(StreamType.SubStream);
            var   length    = m_reader.ReadLength();

            if (s_dumpStructure)
            {
                var subReader = new CachedFileReader(m_reader, length);
                var subParser = new CachedFileParser(subReader);
                subParser.Parse();
                subStream.AddMember(subParser.m_stream.Clone());
            }

            if (s_cachedObject)
            {
                return(new SStringType(m_reader.ReadString(length)));
            }

            m_reader.Seek(length);

            return(subStream);
        }
示例#6
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CachedFileParser"/> class.
 /// </summary>
 /// <param name="reader">The reader.</param>
 CachedFileParser(CachedFileReader reader)
 {
     m_reader = reader;
     m_stream = new SStreamType(StreamType.StreamStart);
 }
示例#7
0
        /// <summary>
        /// Parses a database row.
        /// </summary>
        /// <returns></returns>
        SType ParseDBRow()
        {
            var header = GetObject() as SObjectType;

            if (header == null)
            {
                throw new ParserException("DBRow header not found");
            }

            if (!header.IsDBRowDescriptor)
            {
                throw new ParserException("Bad DBRow descriptor name");
            }

            var fields = header.Members.First().Members.First(
                member => member is STupleType).Members.First().Members.Cast <STupleType>().ToList();

            if (!fields.Any())
            {
                return(new SNoneType());
            }

            // Check for double marker in stream (usually found in a file with one DBRow)
            var length = m_reader.ReadLength();

            if (m_reader.IsDoubleMarker(length))
            {
                length = m_reader.ReadLength();
            }

            var unpackedDataSize = GetUnpackedDataSize(fields);
            var compressedData   = m_reader.ReadBytes(length);
            var uncompressedData = Rle_Unpack(compressedData, unpackedDataSize);

            var reader = new CachedFileReader(uncompressedData, false);

            // Find the maximum number of elements for each field member
            var maxElements = fields.Select(field => field.Members.Count).Concat(new[] { 0 }).Max();

            // The size of SDict must be the ammount of entries stored,
            // multiplied by the max elements of each field member
            var dict = new SDictType((uint)(fields.Count() * maxElements));
            var pass = 1;

            while (pass < 7)
            {
                // The pattern for what data to read on each pass is:
                // 1: 64 bit (Int64, Double)
                // 2: 32 bit (Int32, Single)
                // 3: 16 bit (Int16)
                // 4: 8 bit (Byte)
                // 5: 1 bit (Boolean)
                // 6: strings

                foreach (var field in fields)
                {
                    var fieldName = field.Members.First();
                    var fieldType = (SLongType)field.Members.Last();
                    var dbType    = (DbTypes)fieldType.Value;

                    byte  boolCount  = 0;
                    var   boolBuffer = false;
                    SType obj        = null;

                    switch (dbType)
                    {
                    case DbTypes.Short:
                    case DbTypes.UShort:
                        if (pass == 3)
                        {
                            obj = new SShortType(reader.ReadShort());
                        }
                        break;

                    case DbTypes.Int:
                    case DbTypes.UInt:
                        if (pass == 2)
                        {
                            obj = new SIntType(reader.ReadInt());
                        }
                        break;

                    case DbTypes.Float:
                        if (pass == 2)
                        {
                            obj = new SDoubleType(reader.ReadFloat());
                        }
                        break;

                    case DbTypes.Double:
                        if (pass == 1)
                        {
                            obj = new SDoubleType(reader.ReadDouble());
                        }
                        break;

                    case DbTypes.Currency:
                        if (pass == 1)
                        {
                            obj = new SDoubleType(reader.ReadLong() / 10000.0);
                        }
                        break;

                    case DbTypes.Long:
                    case DbTypes.ULong:
                    case DbTypes.Filetime:     // Timestamp
                    case DbTypes.DBTimestamp:
                        if (pass == 1)
                        {
                            obj = new SLongType(reader.ReadLong());
                        }
                        break;

                    case DbTypes.Bool:
                        if (pass == 5)
                        {
                            if (boolCount == 0)
                            {
                                boolBuffer = Convert.ToBoolean(reader.ReadByte());
                                boolCount++;
                            }

                            obj = boolBuffer && boolCount != 0
                                          ? new SBooleanType(1)
                                          : new SBooleanType(0);
                        }
                        break;

                    case DbTypes.Byte:
                    case DbTypes.UByte:
                        if (pass == 4)
                        {
                            obj = new SByteType(reader.ReadByte());
                        }
                        break;

                    case DbTypes.Bytes:     // String types
                    case DbTypes.String:
                    case DbTypes.WideString:
                        if (pass == 6)
                        {
                            obj = GetObject();
                        }
                        break;

                    default:
                        throw new ParserException("Unhandled db column type: " + dbType);
                    }

                    if (obj == null)
                    {
                        continue;
                    }

                    dict.AddMember(obj);
                    dict.AddMember(fieldName.Clone());
                }

                pass++;
            }

            var parsedDBRow = new STupleType(2);

            parsedDBRow.AddMember(header);
            parsedDBRow.AddMember(dict);
            return(parsedDBRow);
        }