// public methods -------------------------------------------------------- /// <summary> /// <p> /// ICU data header reader method. Takes a ICU generated big-endian input /// stream, parse the ICU standard file header and authenticates them. /// </p> /// <p> /// Header format: /// <ul> /// <li>Header size (char) /// <li>Magic number 1 (byte) /// <li>Magic number 2 (byte) /// <li>Rest of the header size (char) /// <li>Reserved word (char) /// <li>Big endian indicator (byte) /// <li>Character set family indicator (byte) /// <li>Size of a char (byte) for c++ and c use /// <li>Reserved byte (byte) /// <li>Data format identifier (4 bytes), each ICU data has its own /// identifier to distinguish them. [0] major [1] minor [2] milli [3] micro /// <li>Data version (4 bytes), the change version of the ICU data [0] major /// [1] minor [2] milli [3] micro /// <li>Unicode version (4 bytes) this ICU is based on. /// </ul> /// </p> /// <p> /// Example of use:<br> /// <pre> /// try { /// FileInputStream input = new FileInputStream(filename); /// If (Utility.readICUDataHeader(input, dataformat, dataversion, /// unicode) { /// System.out.println("Verified file header, this is a ICU data file"); /// } /// } catch (IOException e) { /// System.out.println("This is not a ICU data file"); /// } /// </pre> /// </p> /// </summary> /// /// <param name="inputStream">input stream that contains the ICU data header</param> /// <param name="dataFormatIDExpected">Data format expected. An array of 4 bytes information aboutthe data format. E.g. data format ID 1.2.3.4. will became anarray of {1, 2, 3, 4}</param> /// <param name="authenticate">user defined extra data authentication. This value can benull, if no extra authentication is needed.</param> /// <exception cref="IOException">thrown if there is a read error or when headerauthentication fails.</exception> /// @draft 2.1 public static byte[] ReadHeader(Stream inputStream, byte[] dataFormatIDExpected, ICUBinary.Authenticate authenticate) { DataInputStream input = new DataInputStream(inputStream); char headersize = input.ReadChar(); int readcount = 2; // reading the header format byte magic1 = (byte)input.ReadByte(); readcount++; byte magic2 = (byte)input.ReadByte(); readcount++; if (magic1 != MAGIC1 || magic2 != MAGIC2) { throw new IOException(MAGIC_NUMBER_AUTHENTICATION_FAILED_); } input.ReadChar(); // reading size readcount += 2; input.ReadChar(); // reading reserved word readcount += 2; sbyte bigendian = input.ReadByte(); readcount++; sbyte charset = input.ReadByte(); readcount++; sbyte charsize = input.ReadByte(); readcount++; input.ReadByte(); // reading reserved byte readcount++; byte[] dataFormatID = new byte[4]; input.ReadFully(dataFormatID); readcount += 4; byte[] dataVersion = new byte[4]; input.ReadFully(dataVersion); readcount += 4; byte[] unicodeVersion = new byte[4]; input.ReadFully(unicodeVersion); readcount += 4; if (headersize < readcount) { throw new IOException("Internal Error: Header size error"); } input.SkipBytes(headersize - readcount); if (bigendian != BIG_ENDIAN_ || charset != CHAR_SET_ || charsize != CHAR_SIZE_ || !ILOG.J2CsMapping.Collections.Arrays.Equals(dataFormatIDExpected, dataFormatID) || (authenticate != null && !authenticate .IsDataVersionAcceptable(dataVersion))) { throw new IOException(HEADER_AUTHENTICATION_FAILED_); } return(unicodeVersion); }
/// <summary> /// Reads in the inverse uca data /// </summary> /// /// <param name="input">input stream with the inverse uca data</param> /// <returns>an object containing the inverse uca data</returns> /// <exception cref="IOException">thrown when error occurs while reading the inverse uca</exception> private static CollationParsedRuleBuilder.InverseUCA ReadInverseUCA( Stream inputStream) { byte[] UnicodeVersion = IBM.ICU.Impl.ICUBinary.ReadHeader(inputStream, INVERSE_UCA_DATA_FORMAT_ID_, INVERSE_UCA_AUTHENTICATE_); // weiv: check that we have the correct Unicode version in // binary files VersionInfo UCDVersion = IBM.ICU.Lang.UCharacter.GetUnicodeVersion(); if (UnicodeVersion[0] != UCDVersion.GetMajor() || UnicodeVersion[1] != UCDVersion.GetMinor()) { throw new IOException(WRONG_UNICODE_VERSION_ERROR_); } CollationParsedRuleBuilder.InverseUCA result = new CollationParsedRuleBuilder.InverseUCA(); DataInputStream input = new DataInputStream(inputStream); input.ReadInt(); // bytesize int tablesize = input.ReadInt(); // in int size int contsize = input.ReadInt(); // in char size input.ReadInt(); // table in bytes input.ReadInt(); // conts in bytes result.m_UCA_version_ = ReadVersion(input); input.SkipBytes(8); // skip padding int size = tablesize * 3; // one column for each strength result.m_table_ = new int[size]; result.m_continuations_ = new char[contsize]; for (int i = 0; i < size; i++) { result.m_table_[i] = input.ReadInt(); } for (int i_0 = 0; i_0 < contsize; i_0++) { result.m_continuations_[i_0] = input.ReadChar(); } // input.Close(); return(result); }
// INodesUnderConstruction /// <summary>Process the blocks section of the fsimage.</summary> /// <param name="in">Datastream to process</param> /// <param name="v">Visitor to walk over inodes</param> /// <param name="skipBlocks">Walk over each block?</param> /// <exception cref="System.IO.IOException"/> private void ProcessBlocks(DataInputStream @in, ImageVisitor v, int numBlocks, bool skipBlocks) { v.VisitEnclosingElement(ImageVisitor.ImageElement.Blocks, ImageVisitor.ImageElement .NumBlocks, numBlocks); // directory or symlink or reference node, no blocks to process if (numBlocks < 0) { v.LeaveEnclosingElement(); // Blocks return; } if (skipBlocks) { int bytesToSkip = ((long.Size * 3) / 8) * numBlocks; /* fields */ /*bits*/ if (@in.SkipBytes(bytesToSkip) != bytesToSkip) { throw new IOException("Error skipping over blocks"); } } else { for (int j = 0; j < numBlocks; j++) { v.VisitEnclosingElement(ImageVisitor.ImageElement.Block); v.Visit(ImageVisitor.ImageElement.BlockId, @in.ReadLong()); v.Visit(ImageVisitor.ImageElement.NumBytes, @in.ReadLong()); v.Visit(ImageVisitor.ImageElement.GenerationStamp, @in.ReadLong()); v.LeaveEnclosingElement(); } } // Block v.LeaveEnclosingElement(); }
/* * Get an RBBIDataWrapper from an InputStream onto a pre-compiled set of * RBBI rules. */ static internal RBBIDataWrapper Get(Stream mask0) { int i; DataInputStream dis = new DataInputStream(new BufferedStream(mask0)); RBBIDataWrapper This = new RBBIDataWrapper(); // Seek past the ICU data header. // TODO: verify that the header looks good. dis.SkipBytes(0x80); // Read in the RBBI data header... This.fHeader = new RBBIDataWrapper.RBBIDataHeader(); This.fHeader.fMagic = dis.ReadInt(); This.fHeader.fVersion = dis.ReadInt(); This.fHeader.fFormatVersion[0] = (byte)(This.fHeader.fVersion >> 24); This.fHeader.fFormatVersion[1] = (byte)(This.fHeader.fVersion >> 16); This.fHeader.fFormatVersion[2] = (byte)(This.fHeader.fVersion >> 8); This.fHeader.fFormatVersion[3] = (byte)(This.fHeader.fVersion); This.fHeader.fLength = dis.ReadInt(); This.fHeader.fCatCount = dis.ReadInt(); This.fHeader.fFTable = dis.ReadInt(); This.fHeader.fFTableLen = dis.ReadInt(); This.fHeader.fRTable = dis.ReadInt(); This.fHeader.fRTableLen = dis.ReadInt(); This.fHeader.fSFTable = dis.ReadInt(); This.fHeader.fSFTableLen = dis.ReadInt(); This.fHeader.fSRTable = dis.ReadInt(); This.fHeader.fSRTableLen = dis.ReadInt(); This.fHeader.fTrie = dis.ReadInt(); This.fHeader.fTrieLen = dis.ReadInt(); This.fHeader.fRuleSource = dis.ReadInt(); This.fHeader.fRuleSourceLen = dis.ReadInt(); This.fHeader.fStatusTable = dis.ReadInt(); This.fHeader.fStatusTableLen = dis.ReadInt(); dis.SkipBytes(6 * 4); // uint32_t fReserved[6]; if (This.fHeader.fMagic != 0xb1a0 || !(This.fHeader.fVersion == 1 || // ICU // 3.2 // and // earlier This.fHeader.fFormatVersion[0] == 3) // ICU 3.4 ) { throw new IOException( "Break Iterator Rule Data Magic Number Incorrect, or unsupported data version."); } // Current position in input stream. int pos = 24 * 4; // offset of end of header, which has 24 fields, all // int32_t (4 bytes) // // Read in the Forward state transition table as an array of shorts. // // Quick Sanity Check if (This.fHeader.fFTable < pos || This.fHeader.fFTable > This.fHeader.fLength) { throw new IOException("Break iterator Rule data corrupt"); } // Skip over any padding preceding this table dis.SkipBytes(This.fHeader.fFTable - pos); pos = This.fHeader.fFTable; This.fFTable = new short[This.fHeader.fFTableLen / 2]; for (i = 0; i < This.fFTable.Length; i++) { This.fFTable[i] = dis.ReadShort(); pos += 2; } // // Read in the Reverse state table // // Skip over any padding in the file dis.SkipBytes(This.fHeader.fRTable - pos); pos = This.fHeader.fRTable; // Create & fill the table itself. This.fRTable = new short[This.fHeader.fRTableLen / 2]; for (i = 0; i < This.fRTable.Length; i++) { This.fRTable[i] = dis.ReadShort(); pos += 2; } // // Read in the Safe Forward state table // if (This.fHeader.fSFTableLen > 0) { // Skip over any padding in the file dis.SkipBytes(This.fHeader.fSFTable - pos); pos = This.fHeader.fSFTable; // Create & fill the table itself. This.fSFTable = new short[This.fHeader.fSFTableLen / 2]; for (i = 0; i < This.fSFTable.Length; i++) { This.fSFTable[i] = dis.ReadShort(); pos += 2; } } // // Read in the Safe Reverse state table // if (This.fHeader.fSRTableLen > 0) { // Skip over any padding in the file dis.SkipBytes(This.fHeader.fSRTable - pos); pos = This.fHeader.fSRTable; // Create & fill the table itself. This.fSRTable = new short[This.fHeader.fSRTableLen / 2]; for (i = 0; i < This.fSRTable.Length; i++) { This.fSRTable[i] = dis.ReadShort(); pos += 2; } } // // Unserialize the Character categories TRIE // Because we can't be absolutely certain where the Trie deserialize // will // leave the input stream, leave position unchanged. // The seek to the start of the next item following the TRIE will get us // back in sync. // dis.SkipBytes(This.fHeader.fTrie - pos); // seek input stream from end of // previous section to pos = This.fHeader.fTrie; // to the start of the trie dis.Mark(This.fHeader.fTrieLen + 100); // Mark position of start of TRIE // in the input // and tell Java to keep the mark // valid so long // as we don't go more than 100 // bytes past the // past the end of the TRIE. This.fTrie = new CharTrie(dis, fTrieFoldingFunc); // Deserialize the // TRIE, leaving input // stream at an unknown position, preceding the // padding between TRIE and following section. dis.Reset(); // Move input stream back to marked position at // the start of the serialized TRIE. Now our // "pos" variable and the input stream are in // agreement. // // Read the Rule Status Table // if (pos > This.fHeader.fStatusTable) { throw new IOException("Break iterator Rule data corrupt"); } dis.SkipBytes(This.fHeader.fStatusTable - pos); pos = This.fHeader.fStatusTable; This.fStatusTable = new int[This.fHeader.fStatusTableLen / 4]; for (i = 0; i < This.fStatusTable.Length; i++) { This.fStatusTable[i] = dis.ReadInt(); pos += 4; } // // Put the break rule source into a String // if (pos > This.fHeader.fRuleSource) { throw new IOException("Break iterator Rule data corrupt"); } dis.SkipBytes(This.fHeader.fRuleSource - pos); pos = This.fHeader.fRuleSource; StringBuilder sb = new StringBuilder(This.fHeader.fRuleSourceLen / 2); for (i = 0; i < This.fHeader.fRuleSourceLen; i += 2) { sb.Append(dis.ReadChar()); pos += 2; } This.fRuleSource = sb.ToString(); if (IBM.ICU.Text.RuleBasedBreakIterator.fDebugEnv != null && IBM.ICU.Text.RuleBasedBreakIterator.fDebugEnv.IndexOf("data") >= 0) { This.Dump(); } return(This); }
public static void Main(String[] args) { int ident; int dirofs; int dirlen; int i; int numLumps; byte[] name = new byte[56]; string nameString; int filepos; int filelen; FileStream readLump; DataInputStream directory; string pakName; string pattern; if (args.length == 2) { if (!args[0].Equals("-list")) { Usage(); } pakName = args[1]; pattern = null; } else if (args.length == 3) { pakName = args[0]; pattern = args[1]; } else { pakName = null; pattern = null; Usage(); } try { directory = new DataInputStream(new FileInputStream(pakName)); readLump = new FileStream(pakName, "r"); ident = IntSwap(directory.ReadInt32()); dirofs = IntSwap(directory.ReadInt32()); dirlen = IntSwap(directory.ReadInt32()); if (ident != IDPAKHEADER) { System.Diagnostics.Debug.WriteLine(pakName + " is not a pakfile."); System.Exit(1); } directory.SkipBytes(dirofs - 12); numLumps = dirlen / 64; System.Diagnostics.Debug.WriteLine(numLumps + " lumps in " + pakName); for (i = 0; i < numLumps; i++) { directory.ReadFully(name); filepos = IntSwap(directory.ReadInt32()); filelen = IntSwap(directory.ReadInt32()); nameString = new string (name); nameString = nameString.Substring(0, nameString.IndexOf(0)); if (pattern == null) { System.Diagnostics.Debug.WriteLine(nameString + " : " + filelen + "bytes"); } else if (PatternMatch(pattern, nameString)) { File writeFile; DataOutputStream writeLump; byte[] buffer = new byte[filelen]; StringBuffer fixedString; string finalName; int index; System.Diagnostics.Debug.WriteLine("Unpaking " + nameString + " " + filelen + " bytes"); readLump.Seek(filepos); readLump.ReadFully(buffer); fixedString = new StringBuffer(args[2] + File.separator + nameString); for (index = 0; index < fixedString.Length; index++) { if (fixedString[index] == '/') { fixedString.Se[index, File.separatorChar]; } } finalName = fixedString.ToString(); index = finalName.LastIndexOf(File.separatorChar); if (index != -1) { string finalPath; File writePath; finalPath = finalName.Substring(0, index); writePath = new File(finalPath); writePath.Mkdirs(); } writeFile = new File(finalName); writeLump = new DataOutputStream(new FileOutputStream(writeFile)); writeLump.Write(buffer); writeLump.Close(); } } readLump.Close(); directory.Close(); } catch (IOException e) { System.Diagnostics.Debug.WriteLine(e.ToString()); } }
/// <exception cref="IOException"/> private static TypeAnnotation Parse(DataInputStream data, ConstantPool pool) { int targetType = data.ReadUnsignedByte(); int target = targetType << 24; switch (targetType) { case TypeAnnotation.Class_Type_Parameter: case TypeAnnotation.Method_Type_Parameter: case TypeAnnotation.Method_Parameter: { target |= data.ReadUnsignedByte(); break; } case TypeAnnotation.Super_Type_Reference: case TypeAnnotation.Class_Type_Parameter_Bound: case TypeAnnotation.Method_Type_Parameter_Bound: case TypeAnnotation.Throws_Reference: case TypeAnnotation.Catch_Clause: case TypeAnnotation.Expr_Instanceof: case TypeAnnotation.Expr_New: case TypeAnnotation.Expr_Constructor_Ref: case TypeAnnotation.Expr_Method_Ref: { target |= data.ReadUnsignedShort(); break; } case TypeAnnotation.Type_Arg_Cast: case TypeAnnotation.Type_Arg_Constructor_Call: case TypeAnnotation.Type_Arg_Method_Call: case TypeAnnotation.Type_Arg_Constructor_Ref: case TypeAnnotation.Type_Arg_Method_Ref: { data.SkipBytes(3); break; } case TypeAnnotation.Local_Variable: case TypeAnnotation.Resource_Variable: { data.SkipBytes(data.ReadUnsignedShort() * 6); break; } case TypeAnnotation.Field: case TypeAnnotation.Method_Return_Type: case TypeAnnotation.Method_Receiver: { break; } default: { throw new Exception("unknown target type: " + targetType); } } int pathLength = data.ReadUnsignedByte(); byte[] path = null; if (pathLength > 0) { path = new byte[2 * pathLength]; data.ReadFully(path); } AnnotationExprent annotation = StructAnnotationAttribute.ParseAnnotation(data, pool ); return(new TypeAnnotation(target, path, annotation)); }