irc/TechBot/CHMLibrary/CHMDecoding/CHMStrings.cs

   1 using System;
   2 using System.IO;
   3 using System.Collections;
   4 using System.Collections.Specialized;
   5
   6 namespace HtmlHelp.ChmDecoding
   7 {
   8         /// <summary>
   9         /// The class <c>CHMStrings</c> implements a string collection read from the #STRINGS file
  10         /// </summary>
  11         internal sealed class CHMStrings : IDisposable
  12         {
  13                 /// <summary>
  14                 /// Constant specifying the size of the string blocks
  15                 /// </summary>
  16                 private const int STRING_BLOCK_SIZE = 4096;
  17                 /// <summary>
  18                 /// Internal flag specifying if the object is going to be disposed
  19                 /// </summary>
  20                 private bool disposed = false;
  21                 /// <summary>
  22                 /// Internal member storing the binary file data
  23                 /// </summary>
  24                 private byte[] _binaryFileData = null;
  25                 /// <summary>
  26                 /// Internal member storing the string dictionary
  27                 /// </summary>
  28                 private Hashtable _stringDictionary = new Hashtable();
  29                 /// <summary>
  30                 /// Internal member storing the associated chmfile object
  31                 /// </summary>
  32                 private CHMFile _associatedFile = null;
  33
  34                 /// <summary>
  35                 /// Constructor of the class
  36                 /// </summary>
  37                 /// <param name="binaryFileData">binary file data of the #STRINGS file</param>
  38                 /// <param name="associatedFile">associated chm file</param>
  39                 public CHMStrings(byte[] binaryFileData, CHMFile associatedFile)
  40                 {
  41                         _binaryFileData = binaryFileData;
  42                         _associatedFile = associatedFile;
  43                         DecodeData();
  44                 }
  45
  46
  47                 /// <summary>
  48                 /// Standard constructor
  49                 /// </summary>
  50                 internal CHMStrings()
  51                 {
  52                 }
  53
  54                 #region Data dumping
  55                 /// <summary>
  56                 /// Dump the class data to a binary writer
  57                 /// </summary>
  58                 /// <param name="writer">writer to write the data</param>
  59                 internal void Dump(ref BinaryWriter writer)
  60                 {
  61                         writer.Write( _stringDictionary.Count );
  62
  63                         if (_stringDictionary.Count != 0)
  64                         {
  65                                 IDictionaryEnumerator iDictionaryEnumerator = _stringDictionary.GetEnumerator();
  66                                 while (iDictionaryEnumerator.MoveNext())
  67                                 {
  68                                         DictionaryEntry dictionaryEntry = (DictionaryEntry)iDictionaryEnumerator.Current;
  69                                         writer.Write( Int32.Parse(dictionaryEntry.Key.ToString()) );
  70                                         writer.Write( dictionaryEntry.Value.ToString() );
  71                                 }
  72                         }
  73                 }
  74
  75                 /// <summary>
  76                 /// Reads the object data from a dump store
  77                 /// </summary>
  78                 /// <param name="reader">reader to read the data</param>
  79                 internal void ReadDump(ref BinaryReader reader)
  80                 {
  81                         int nCnt = reader.ReadInt32();
  82
  83                         for(int i=0; i<nCnt;i++)
  84                         {
  85                                 int nKey = reader.ReadInt32();
  86                                 string sValue = reader.ReadString();
  87
  88                                 _stringDictionary[nKey.ToString()] = sValue;
  89                         }
  90                 }
  91
  92                 /// <summary>
  93                 /// Sets the associated CHMFile instance
  94                 /// </summary>
  95                 /// <param name="associatedFile">instance to set</param>
  96                 internal void SetCHMFile(CHMFile associatedFile)
  97                 {
  98                         _associatedFile = associatedFile;
  99                 }
 100                 #endregion
 101
 102                 /// <summary>
 103                 /// Decodes the binary file data and fills the internal properties
 104                 /// </summary>
 105                 /// <returns>true if succeeded</returns>
 106                 private bool DecodeData()
 107                 {
 108                         bool bRet = true;
 109
 110                         MemoryStream memStream = new MemoryStream(_binaryFileData);
 111                         BinaryReader binReader = new BinaryReader(memStream);
 112
 113                         //binReader.ReadByte(); // file starts with a NULL character for 0-based offset indexing
 114
 115                         int nStringOffset = 0;
 116                         int nSubsetOffset = 0;
 117
 118                         while( (memStream.Position < memStream.Length) && (bRet) )
 119                         {
 120                                 nStringOffset = (int)memStream.Position;
 121                                 byte [] stringBlock = binReader.ReadBytes(STRING_BLOCK_SIZE);
 122                                 bRet &= DecodeBlock(stringBlock, ref nStringOffset, ref nSubsetOffset);
 123                         }
 124
 125                         return bRet;
 126                 }
 127
 128                 /// <summary>
 129                 /// Decodes a string block
 130                 /// </summary>
 131                 /// <param name="stringBlock">byte array which represents the string block</param>
 132                 /// <param name="nStringOffset">current string offset number</param>
 133                 /// <param name="nSubsetOffset">reference to a subset variable</param>
 134                 /// <returns>true if succeeded</returns>
 135                 /// <remarks>If a string crosses the end of a block then it will be cut off
 136                 /// without a NT and repeated in full, with a NT, at the start of the next block.
 137                 /// For eg "To customize the appearance of a contents file" might become
 138                 /// "To customize the (block ending)To customize the appearance of a contents file"
 139                 /// when there are 17 bytes left at the end of the block. </remarks>
 140                 private bool DecodeBlock( byte[] stringBlock, ref int nStringOffset, ref int nSubsetOffset)
 141                 {
 142                         bool bRet = true;
 143
 144                         MemoryStream memStream = new MemoryStream(stringBlock);
 145                         BinaryReader binReader = new BinaryReader(memStream);
 146
 147                         while( (memStream.Position < memStream.Length) && (bRet) )
 148                         {
 149                                 bool bFoundTerminator = false;
 150
 151                                 int nCurOffset = nStringOffset + (int)memStream.Position;
 152
 153                                 string sTemp = BinaryReaderHelp.ExtractString(ref binReader, ref bFoundTerminator, 0, true, _associatedFile.TextEncoding);
 154
 155                                 if(nSubsetOffset != 0)
 156                                 {
 157                                         _stringDictionary[nSubsetOffset.ToString()] = sTemp.ToString();
 158                                 }
 159                                 else
 160                                 {
 161                                         _stringDictionary[nCurOffset.ToString()] = sTemp.ToString();
 162                                 }
 163
 164                                 if( bFoundTerminator )
 165                                 {
 166                                         nSubsetOffset = 0;
 167                                 }
 168                                 else
 169                                 {
 170                                         nSubsetOffset = nCurOffset;
 171                                 }
 172                         }
 173
 174                         return bRet;
 175                 }
 176
 177                 /// <summary>
 178                 /// Indexer which returns the string at a given offset
 179                 /// </summary>
 180                 public string this[int offset]
 181                 {
 182                         get
 183                         {
 184                                 if(offset == -1)
 185                                         return String.Empty;
 186
 187                                 string sTemp = (string)_stringDictionary[ offset.ToString() ];
 188
 189                                 if(sTemp == null)
 190                                         return String.Empty;
 191
 192                                 return sTemp;
 193                         }
 194                 }
 195
 196                 /// <summary>
 197                 /// Indexer which returns the string at a given offset
 198                 /// </summary>
 199                 public string this[string offset]
 200                 {
 201                         get
 202                         {
 203                                 if(offset == "-1")
 204                                         return String.Empty;
 205
 206                                 string sTemp = (string)_stringDictionary[ offset ];
 207
 208                                 if(sTemp == null)
 209                                         return String.Empty;
 210
 211                                 return sTemp;
 212                         }
 213                 }
 214
 215                 /// <summary>
 216                 /// Implement IDisposable.
 217                 /// </summary>
 218                 public void Dispose()
 219                 {
 220                         Dispose(true);
 221                         // This object will be cleaned up by the Dispose method.
 222                         // Therefore, you should call GC.SupressFinalize to
 223                         // take this object off the finalization queue
 224                         // and prevent finalization code for this object
 225                         // from executing a second time.
 226                         GC.SuppressFinalize(this);
 227                 }
 228
 229                 /// <summary>
 230                 /// Dispose(bool disposing) executes in two distinct scenarios.
 231                 /// If disposing equals true, the method has been called directly
 232                 /// or indirectly by a user's code. Managed and unmanaged resources
 233                 /// can be disposed.
 234                 /// If disposing equals false, the method has been called by the
 235                 /// runtime from inside the finalizer and you should not reference
 236                 /// other objects. Only unmanaged resources can be disposed.
 237                 /// </summary>
 238                 /// <param name="disposing">disposing flag</param>
 239                 private void Dispose(bool disposing)
 240                 {
 241                         // Check to see if Dispose has already been called.
 242                         if(!this.disposed)
 243                         {
 244                                 // If disposing equals true, dispose all managed
 245                                 // and unmanaged resources.
 246                                 if(disposing)
 247                                 {
 248                                         // Dispose managed resources.
 249                                         _binaryFileData = null;
 250                                         _stringDictionary = null;
 251                                 }
 252                         }
 253                         disposed = true;
 254                 }
 255         }
 256 }