+++ /dev/null
-using System;\r
-using System.Diagnostics;\r
-using System.Text;\r
-using System.Data;\r
-using System.Text.RegularExpressions;\r
-using System.Collections;\r
-using System.Collections.Specialized;\r
-using System.IO;\r
-using System.Runtime.InteropServices;\r
-\r
-namespace CHMStream\r
-{\r
- /// <summary>\r
- /// Summary description for CHMFile.\r
- /// </summary>\r
- ///\r
- public class CHMStream : IDisposable\r
- {\r
- public MemoryStream OpenStream(chmUnitInfo Info)\r
- {\r
- if (Info==null)\r
- return null;\r
-\r
- MemoryStream st=new MemoryStream();\r
- this.ExtractFile(Info,st);\r
- return st;\r
- }\r
-\r
- public MemoryStream OpenStream(string FileName)\r
- {\r
- chmUnitInfo info=this.GetFileInfo(FileName);\r
- if (info==null)\r
- return null;\r
- return OpenStream(info);\r
- }\r
-\r
- private string m_CHMFileName;\r
- public string CHMFileName\r
- {\r
- get\r
- {\r
- return m_CHMFileName;\r
- }\r
- }\r
-\r
- public CHMStream()\r
- {\r
- }\r
-\r
- public CHMStream(string CHMFileName)\r
- {\r
- OpenCHM(CHMFileName);\r
- }\r
-\r
- public void OpenCHM(string CHMFileName)\r
- { \r
- m_CHMFileName=CHMFileName;\r
- FileInfo fi=new FileInfo(m_CHMFileName);\r
- Dir=fi.DirectoryName;\r
- m_CHMName=fi.Name;\r
- fi=null; \r
- chm_open(m_CHMFileName);\r
- }\r
-\r
- private bool m_bCHMLoaded=false;\r
- public bool CHMLoaded\r
- {\r
- get\r
- {\r
- return m_bCHMLoaded;\r
- }\r
- }\r
-\r
- private string m_CHMName="";\r
- public string CHMName\r
- {\r
- get \r
- {\r
- return m_CHMName;\r
- }\r
- }\r
-\r
- private string Dir="";\r
- private string m_FileFind="";\r
- private string m_FileFindLastPart="";\r
- private chmUnitInfo m_FileInfo=null;\r
- private int m_FileCount=0;\r
- public void FindFile(chmUnitInfo Info, ref CHMStream.CHM_ENUMERATOR Status)\r
- {\r
- string LocalFile=Info.path;\r
- LocalFile=LocalFile.Replace("/",@"\");\r
- if (!LocalFile.StartsWith(@"\"))\r
- LocalFile=@"\"+LocalFile;\r
- LocalFile=LocalFile.ToLower();\r
- \r
- if (m_FileFind.Length<=LocalFile.Length)\r
- { \r
- if (LocalFile.IndexOf(m_FileFind)==LocalFile.Length-m_FileFind.Length)\r
- {\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_SUCCESS;\r
- m_FileInfo=Info;\r
- return;\r
- } \r
- }\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_CONTINUE;\r
- }\r
-\r
- public void FileCount(chmUnitInfo Info, ref CHMStream.CHM_ENUMERATOR Status)\r
- {\r
- m_FileCount++;\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_CONTINUE;\r
- }\r
-\r
- private ArrayList m_FileList=null;\r
- private string m_strByExt="";\r
- public void FileList(chmUnitInfo Info, ref CHMStream.CHM_ENUMERATOR Status)\r
- { \r
- m_FileList.Add(Info.path);\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_CONTINUE;\r
- }\r
-\r
- public void FileListByExtension(chmUnitInfo Info, ref CHMStream.CHM_ENUMERATOR Status)\r
- { \r
- FileInfo fi=new FileInfo(Info.path);\r
- if (fi.Extension.ToLower()==m_strByExt.ToLower())\r
- m_FileList.Add(Info.path);\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_CONTINUE;\r
- }\r
-\r
- public void FindFileIndex(chmUnitInfo Info, ref CHMStream.CHM_ENUMERATOR Status)\r
- { \r
- if (m_FileCount==m_FileFindIndex)\r
- {\r
- m_FileInfo=Info;\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_SUCCESS;\r
- }\r
- else\r
- {\r
- m_FileCount++;\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_CONTINUE;\r
- }\r
- }\r
-\r
- public int GetFileCount()\r
- {\r
- if (!m_bCHMLoaded)\r
- return 0;\r
-\r
- m_FileCount=0;\r
- this.CHMFileFoundEvent+=new CHMStream.CHMFileFound(FileCount); \r
- this.chm_enumerate(CHM_ENUMERATE.CHM_ENUMERATE_ALL);\r
- this.CHMFileFoundEvent-=new CHMStream.CHMFileFound(FileCount);\r
- return m_FileCount;\r
- } \r
-\r
- public ArrayList GetFileList()\r
- {\r
- if (!m_bCHMLoaded)\r
- return null;\r
-\r
- m_FileList=null;\r
- m_FileList=new ArrayList(1000);\r
- this.CHMFileFoundEvent+=new CHMStream.CHMFileFound(FileList); \r
- this.chm_enumerate(CHM_ENUMERATE.CHM_ENUMERATE_ALL);\r
- this.CHMFileFoundEvent-=new CHMStream.CHMFileFound(FileList);\r
- return m_FileList;\r
- } \r
-\r
- public ArrayList GetFileListByExtenstion(string Ext)\r
- {\r
- if (!m_bCHMLoaded)\r
- return null;\r
-\r
- m_FileList=null;\r
- m_FileList=new ArrayList(1000);\r
- m_strByExt=Ext;\r
- this.CHMFileFoundEvent+=new CHMStream.CHMFileFound(FileListByExtension); \r
- this.chm_enumerate(CHM_ENUMERATE.CHM_ENUMERATE_ALL);\r
- this.CHMFileFoundEvent-=new CHMStream.CHMFileFound(FileListByExtension);\r
- return m_FileList;\r
- } \r
-\r
- public chmUnitInfo GetFileInfo(string FileName)\r
- {\r
- if (!m_bCHMLoaded)\r
- return null;\r
- \r
- m_FileFind=FileName.ToLower().Replace("/",@"\"); \r
-\r
- // Remove all leading '..\' \r
- do\r
- { \r
- if (m_FileFind.StartsWith(@"..\"))\r
- m_FileFind=m_FileFind.Substring(3); \r
- else \r
- break;\r
- }\r
- while(true);\r
-\r
- if (!m_FileFind.StartsWith(@"\"))\r
- m_FileFind=@"\"+m_FileFind;\r
- \r
- string []parts=m_FileFind.Split('\\');\r
- m_FileFindLastPart=@"\"+parts[parts.GetUpperBound(0)]; \r
-\r
- this.CHMFileFoundEvent+=new CHMStream.CHMFileFound(FindFile);\r
- m_FileInfo=null;\r
- this.chm_enumerate(CHM_ENUMERATE.CHM_ENUMERATE_ALL);\r
- this.CHMFileFoundEvent-=new CHMStream.CHMFileFound(FindFile);\r
- return m_FileInfo;\r
- } \r
- \r
- private int m_FileFindIndex=0;\r
- public chmUnitInfo GetFileInfo(int FileIndex)\r
- {\r
- if (!m_bCHMLoaded)\r
- return null;\r
-\r
- m_FileFindIndex=FileIndex;\r
-\r
- this.CHMFileFoundEvent+=new CHMStream.CHMFileFound(FindFileIndex);\r
- m_FileCount=0;\r
- m_FileInfo=null;\r
- this.chm_enumerate(CHM_ENUMERATE.CHM_ENUMERATE_ALL);\r
- this.CHMFileFoundEvent-=new CHMStream.CHMFileFound(FindFileIndex);\r
- return m_FileInfo;\r
- }\r
-\r
- public chmUnitInfo GetFileInfoByExtension(string Ext)\r
- {\r
- this.CHMFileFoundEvent+=new CHMStream.CHMFileFound(FindFileByExtension);\r
- m_FileInfo=null;\r
- m_FileFind=Ext.ToLower();\r
- this.chm_enumerate(CHMStream.CHM_ENUMERATE.CHM_ENUMERATE_ALL);\r
- this.CHMFileFoundEvent-=new CHMStream.CHMFileFound(FindFileByExtension);\r
- return m_FileInfo;\r
- }\r
-\r
- public bool ExtractFile(string FileName, System.IO.Stream st)\r
- {\r
- if (!m_bCHMLoaded)\r
- return false;\r
-\r
- chmUnitInfo Info=GetFileInfo(FileName);\r
- return ExtractFile(Info,st);\r
- }\r
-\r
- public bool ExtractFile(chmUnitInfo Info, System.IO.Stream st)\r
- { \r
- if (!m_bCHMLoaded)\r
- return false;\r
-\r
- if (Info==null)\r
- return false;\r
- else\r
- {\r
- chm_retrieve_object(Info,st,0,Info.length); \r
- }\r
- return true;\r
- }\r
-\r
- public string ExtractTextFile(string FileName)\r
- { \r
- if (!m_bCHMLoaded)\r
- return "CHM File not loaded";\r
-\r
- chmUnitInfo Info=GetFileInfo(FileName);\r
- return ExtractTextFile(Info);\r
- }\r
-\r
- public string ExtractTextFile(chmUnitInfo Info)\r
- { \r
- if (!m_bCHMLoaded)\r
- return "CHM File not loaded";\r
-\r
- if (Info==null)\r
- return "";\r
- \r
- if (Info.path.Length>=2)\r
- {\r
- if (Info.path.Substring(0,2).CompareTo("/#")==0)\r
- return "";\r
- if (Info.path.Substring(0,2).CompareTo("/$")==0)\r
- return "";\r
- }\r
-\r
- MemoryStream st=new MemoryStream((int)Info.length);\r
- this.chm_retrieve_object(Info,st,0,Info.length); \r
-\r
- if (st.Length==0)\r
- return "";\r
-\r
- string Text=""; \r
- \r
- ASCIIEncoding ascii=new ASCIIEncoding(); \r
- Text=ascii.GetString(st.ToArray(),0,50);\r
-\r
- // UTF Decoding\r
- if (Text.IndexOf("UTF-8")!=-1)\r
- {\r
- UTF8Encoding utf8 = new UTF8Encoding();\r
- Text=utf8.GetString(st.ToArray(),0,(int)st.Length);\r
- }\r
- else\r
- Text=ascii.GetString(st.ToArray(),0,(int)st.Length);\r
- \r
- return Text;\r
- } \r
- \r
- public void FindFileByExtension(chmUnitInfo Info, ref CHMStream.CHM_ENUMERATOR Status)\r
- { \r
- if ((Info.path.StartsWith("::")) || (Info.path.StartsWith("#")) ||(Info.path.StartsWith("$")))\r
- {\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_CONTINUE;\r
- return;\r
- } \r
-\r
- FileInfo Fi=new FileInfo(Info.path);\r
- if (Fi.Extension.ToLower()==m_FileFind)\r
- {\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_SUCCESS;\r
- m_FileInfo=Info;\r
- }\r
- else\r
- Status=CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_CONTINUE;\r
- }\r
-\r
- public bool GetCHMParts(string Url, ref string CHMFileName, ref string FileName, ref string Anchor)\r
- {\r
- Regex ParseURLRegEx= new Regex( @"ms-its:(?'CHMFile'.*)::(?'Topic'.*)", RegexOptions.IgnoreCase| RegexOptions.Singleline | RegexOptions.ExplicitCapture| RegexOptions.IgnorePatternWhitespace| RegexOptions.Compiled);\r
-\r
- // Parse URL - Get CHM Filename & Page Name\r
- // Format 'ms-its:file name.chm::/topic.htm'\r
- if (ParseURLRegEx.IsMatch(Url))\r
- {\r
- Match m=ParseURLRegEx.Match(Url);\r
- CHMFileName=m.Groups["CHMFile"].Value;\r
- string Topic=m.Groups["Topic"].Value;\r
- int idx=Topic.IndexOf("#");\r
- if (idx>-1)\r
- {\r
- FileName=Topic.Substring(0,idx);\r
- Anchor=Topic.Substring(idx+1);\r
- }\r
- else\r
- FileName=Topic;\r
- return true;\r
- }\r
- return false;\r
- }\r
-\r
- private string m_TempDir=""; \r
- string ReplaceFileName(Match m)\r
- {\r
- string strReplace = m.ToString();\r
-\r
- // Process string.\r
- if (m.Groups["FileName"]==null)\r
- return strReplace;\r
-\r
- string FileName=m.Groups["FileName"].Value;\r
- string FileName2=FileName.Replace("/",@"\");\r
- int idx=FileName2.IndexOf("::");\r
- if (idx!=-1)\r
- FileName2=FileName2.Substring(idx+2);\r
- string []parts=FileName2.Split('\\'); \r
- string NewName=@"file://"+m_TempDir+parts[parts.GetUpperBound(0)];\r
-\r
- strReplace=strReplace.Replace(FileName,NewName); \r
- return strReplace;\r
- }\r
-\r
- public ArrayList GetFileList(ref string Text, string TempDir)\r
- { \r
- if (!m_bCHMLoaded)\r
- return null;\r
-\r
- m_TempDir=TempDir;\r
-\r
- ArrayList FilesList=new ArrayList();\r
-\r
- // Parse HTML for CCS, ima, etc \r
- string regexContent=@"[\x2f a-zA-Z0-9\x5C\x2E\x28\x29\x23\x24\x25\x26\x27\x22\x21\x3F\x3E\x3D\x3C\x3B\x3A\x5B\x5D\x5E\x5F\x7D\x7C\x7B\x7E\x40\x2D\x2C\x2B\x2A]*\s*";\r
- string regexFileName=@"\s*=\s*[""|'](?'FileName'[^""^']*)[""|']\s*";\r
-\r
- Regex ScriptRegex = new Regex(@"<script[^>]*>.*</script>",\r
- RegexOptions.IgnoreCase\r
- | RegexOptions.Multiline\r
- | RegexOptions.Singleline\r
- | RegexOptions.IgnorePatternWhitespace\r
- | RegexOptions.Compiled);\r
-\r
- Regex XMLRegex = new Regex(@"<\?xml.*\?>",\r
- RegexOptions.IgnoreCase\r
- | RegexOptions.Multiline\r
- | RegexOptions.Singleline\r
- | RegexOptions.IgnorePatternWhitespace\r
- | RegexOptions.Compiled);\r
-\r
- Regex XMLRegex2 = new Regex(@"<xml[^>]*>.*</xml>",\r
- RegexOptions.IgnoreCase\r
- | RegexOptions.Multiline\r
- | RegexOptions.Singleline\r
- | RegexOptions.IgnorePatternWhitespace\r
- | RegexOptions.Compiled);\r
-\r
- Regex SRCRegex = new Regex( \r
- @"src"+regexFileName,\r
- RegexOptions.IgnoreCase\r
- | RegexOptions.Multiline\r
- | RegexOptions.Singleline\r
- | RegexOptions.IgnorePatternWhitespace\r
- | RegexOptions.Compiled);\r
-\r
- Regex StyleSheetRegex = new Regex( \r
- @"<link\s*"+regexContent+@"rel\s*=\s*[""|']stylesheet[""|']\s*"+regexContent + "href"+regexFileName,\r
- RegexOptions.IgnoreCase\r
- | RegexOptions.Multiline\r
- | RegexOptions.Singleline\r
- | RegexOptions.IgnorePatternWhitespace\r
- | RegexOptions.Compiled);\r
- \r
- // Remove Script Tags\r
- Text=ScriptRegex.Replace(Text,"");\r
-\r
- // Remove XML Tags\r
- Text=XMLRegex.Replace(Text,"");\r
- Text=XMLRegex2.Replace(Text,""); \r
-\r
-\r
- StringBuilder s=new StringBuilder(Text);\r
- \r
- if (StyleSheetRegex.IsMatch(Text))\r
- { \r
- Match m = StyleSheetRegex.Match(Text);\r
- while (m.Success)\r
- { \r
- string FileName=m.Groups["FileName"].ToString();\r
- FilesList.Add(FileName); \r
- m=m.NextMatch();\r
- }\r
- Text=StyleSheetRegex.Replace(Text,new MatchEvaluator(ReplaceFileName));\r
- }\r
-\r
- if (SRCRegex.IsMatch(Text))\r
- { \r
- Match m = SRCRegex.Match(Text);\r
- while (m.Success)\r
- { \r
- string FileName=m.Groups["FileName"].ToString();\r
- FilesList.Add(FileName);\r
- m=m.NextMatch();\r
- }\r
- Text=SRCRegex.Replace(Text,new MatchEvaluator(ReplaceFileName));\r
- }\r
- \r
- return FilesList;\r
- }\r
-\r
- public string GetHTMLAndFiles(string TempDir, string Url)\r
- {\r
- string HTMLText="";\r
- if (TempDir.EndsWith(@"\")) TempDir=TempDir.Substring(TempDir.Length-1); \r
- \r
- // Delete Temp Directory\r
- if (Directory.Exists(TempDir))\r
- Directory.Delete(TempDir,true);\r
-\r
- // Create Temp Directory\r
- if (!Directory.Exists(TempDir))\r
- Directory.CreateDirectory(TempDir);\r
-\r
- if (!TempDir.EndsWith(@"\")) TempDir+=@"\"; \r
-\r
- string m_TopicName="";\r
-\r
- string m_CHMFile=CHMFileName;\r
- string Anchor="";\r
- if (!GetCHMParts(Url,ref m_CHMFile, ref m_TopicName, ref Anchor))\r
- {\r
- m_CHMFile=this.CHMFileName;\r
- m_TopicName=Url;\r
- }\r
- \r
- if (m_TopicName=="")\r
- return "#No TopicName defined in Url : "+ Url; \r
-\r
- m_TopicName=m_TopicName.Replace("/",@"\"); \r
- if (!m_CHMFile.StartsWith(@"\"))\r
- m_CHMFile=this.Dir+@"\"+m_CHMFile;\r
-\r
- // Open CHM \r
- CHMStream LocalCHM=this;\r
- \r
- if (this.CHMFileName.ToLower().CompareTo(m_CHMFile.ToLower())!=0)\r
- LocalCHM=new CHMStream(m_CHMFile);\r
-\r
- // Get HTML\r
- HTMLText=LocalCHM.ExtractTextFile(m_TopicName);\r
- if (HTMLText=="")\r
- return "#Failed to find Topic in CHM File : "+Url;\r
-\r
- HTMLText=GetFiles(TempDir, HTMLText, LocalCHM);\r
-\r
- return HTMLText;\r
- }\r
-\r
- public string GetFiles(string TempDir, string HTMLText, CHMStream chm)\r
- {\r
- return GetFiles(TempDir, HTMLText, chm,0);\r
- }\r
-\r
- public string GetFiles(string TempDir, string HTMLText, CHMStream chm, int Level)\r
- {\r
- // Get FilesList & Extract Files to Temp Dir\r
- ArrayList FileList=chm.GetFileList(ref HTMLText, TempDir);\r
- if (FileList!=null)\r
- {\r
- foreach(object obj in FileList)\r
- {\r
- string FileName=(string)obj;\r
-\r
- string CHMFileName="";\r
- string TopicName=""; \r
- string Anchor="";\r
- CHMStream NewCHM=chm; \r
- if (GetCHMParts(FileName,ref CHMFileName, ref TopicName, ref Anchor))\r
- { \r
- NewCHM=new CHMStream(chm.Dir+@"\"+CHMFileName);\r
- if (!NewCHM.CHMLoaded)\r
- NewCHM=null;\r
- FileName=TopicName;\r
- }\r
- else\r
- {\r
- CHMFileName=chm.CHMFileName;\r
- NewCHM=chm;\r
- TopicName=FileName;\r
- }\r
- if (NewCHM==null)\r
- continue;\r
-\r
- if (((FileName.ToLower().EndsWith(".htm")) || (FileName.ToLower().EndsWith(".html"))) && (Level<2))\r
- {\r
- string HTMLText2=NewCHM.ExtractTextFile(FileName);\r
- FileInfo Fi=new FileInfo(FileName);\r
- string path=TempDir+Fi.Name;\r
- HTMLText2=GetFiles(TempDir,HTMLText2, chm, Level+1);\r
-\r
- if (File.Exists(path))\r
- File.Delete(path);\r
-\r
- StreamWriter st=new StreamWriter(path);\r
- st.WriteLine(HTMLText2);\r
- st.Close();\r
- }\r
- else\r
- {\r
- // Extract all other files as is \r
- string FileName2=FileName.Replace("/",@"\");\r
- if (FileName2.Substring(0,1)==@"\")\r
- FileName2=FileName2.Substring(1);\r
-\r
- string []parts=FileName2.Split('\\');\r
- string path=TempDir+parts[parts.GetUpperBound(0)];\r
- if (File.Exists(path))\r
- File.Delete(path);\r
- System.IO.FileStream st=new FileStream(path,FileMode.CreateNew);\r
- NewCHM.ExtractFile(FileName2,st);\r
- st.Close();\r
- } \r
- }\r
- }\r
-\r
- // return HTML string of main page\r
- return HTMLText;\r
- }\r
- \r
- #region CHMStream Enums\r
- // the two available spaces in a CHM file \r
- // N.B.: The format supports arbitrarily many spaces, but only \r
- // two appear to be used at present. \r
- public enum CHM_COMPRESSION { CHM_UNCOMPRESSED=0, CHM_COMPRESSED=1};\r
-\r
- // resolve a particular object from the archive \r
- public enum CHM_RESOLVE { CHM_RESOLVE_SUCCESS=0, CHM_RESOLVE_FAILURE=1};\r
- \r
- // retrieve part of an object from the archive \r
- public enum CHM_ENUMERATE\r
- {\r
- None=0,\r
- CHM_ENUMERATE_NORMAL =1,\r
- CHM_ENUMERATE_META =2,\r
- CHM_ENUMERATE_SPECIAL =4,\r
- CHM_ENUMERATE_FILES =8,\r
- CHM_ENUMERATE_DIRS =16,\r
- CHM_ENUMERATE_ALL =31};\r
-\r
- public enum CHM_ENUMERATOR\r
- { \r
- CHM_ENUMERATOR_FAILURE =0, \r
- CHM_ENUMERATOR_SUCCESS =2, \r
- CHM_ENUMERATOR_CONTINUE =1\r
- };\r
- #endregion\r
-\r
- #region Internal Parameters\r
- private int ffs(int val)\r
- {\r
- int bit=1;\r
- int idx=1;\r
- while (bit != 0 && (val & bit) == 0)\r
- {\r
- bit <<= 1;\r
- ++idx;\r
- }\r
- if (bit == 0)\r
- return 0;\r
- else\r
- return idx;\r
- }\r
-\r
- // names of sections essential to decompression \r
- private const string _CHMU_RESET_TABLE = @"::DataSpace/Storage/MSCompressed/Transform/{7FC28940-9D31-11D0-9B27-00A0C91E9C7C}/InstanceData/ResetTable";\r
- private const string _CHMU_LZXC_CONTROLDATA = @"::DataSpace/Storage/MSCompressed/ControlData";\r
- private const string _CHMU_CONTENT = @"::DataSpace/Storage/MSCompressed/Content";\r
- private const string _CHMU_SPANINFO = @"::DataSpace/Storage/MSCompressed/SpanInfo";\r
-\r
- private UInt64 dir_offset=0;\r
- private UInt64 dir_len=0; \r
- private UInt64 data_offset=0;\r
- private Int32 index_root=0;\r
- private Int32 index_head=0;\r
- private UInt32 block_len=0; \r
- \r
- private chmUnitInfo rt_unit;\r
- private chmUnitInfo cn_unit;\r
- private chmLzxcResetTable reset_table;\r
- private bool compression_enabled=false;\r
-\r
- // LZX control data \r
- private int window_size=0;\r
- private UInt32 reset_interval=0;\r
- private UInt32 reset_blkcount=0;\r
- private BinaryReader st=null;\r
-\r
- // decompressor state \r
- private lzw lzx_state; \r
- private int lzx_last_block=0;\r
- #endregion\r
-\r
- #region Open CHM Stream\r
- private bool CheckSig(string Sig1, char[] Sig2)\r
- {\r
- int i=0;\r
- foreach(char ch in Sig1.ToCharArray())\r
- {\r
- if(ch!=Sig2[i])\r
- return false;\r
- i++;\r
- }\r
- return true; \r
- }\r
-\r
- // open an ITS archive \r
- private bool chm_open(string filename)\r
- {\r
- chmItsfHeader itsfHeader=new chmItsfHeader();\r
- chmItspHeader itspHeader=new chmItspHeader();\r
- chmUnitInfo uiSpan=new chmUnitInfo();\r
- chmUnitInfo uiLzxc=new chmUnitInfo();\r
- chmLzxcControlData ctlData=new chmLzxcControlData();\r
- \r
- m_bCHMLoaded=false;\r
- if (!File.Exists(filename))\r
- return false;\r
-\r
- st=new BinaryReader(File.OpenRead(filename));\r
- if (st==null)\r
- return false;\r
-\r
- // read and verify header \r
- if (itsfHeader.Read_itsf_header(st)==0)\r
- {\r
- st.Close();\r
- return false;\r
- }\r
- st.BaseStream.Seek((long)itsfHeader.dir_offset,SeekOrigin.Begin); \r
-\r
- // stash important values from header \r
- dir_offset = itsfHeader.dir_offset;\r
- dir_len = itsfHeader.dir_len;\r
- data_offset = itsfHeader.data_offset;\r
-\r
- // now, read and verify the directory header chunk \r
- if (itspHeader.Read_itsp_header(st)==0)\r
- {\r
- st.Close();\r
- return false;\r
- }\r
-\r
- // grab essential information from ITSP header \r
- dir_offset += (UInt64)itspHeader.header_len;\r
- dir_len -= (UInt64)itspHeader.header_len;\r
- index_root = itspHeader.index_root;\r
- index_head = itspHeader.index_head;\r
- block_len = itspHeader.block_len;\r
-\r
- // if the index root is -1, this means we don't have any PMGI blocks.\r
- // as a result, we must use the sole PMGL block as the index root\r
- \r
- if (index_root == -1)\r
- index_root = index_head;\r
-\r
- compression_enabled=true;\r
-\r
- // prefetch most commonly needed unit infos \r
- // if (CHM_RESOLVE.CHM_RESOLVE_SUCCESS != chm_resolve_object(_CHMU_SPANINFO, ref uiSpan) \r
- // || uiSpan.space == CHM_COMPRESSION.CHM_COMPRESSED || \r
- if (CHM_RESOLVE.CHM_RESOLVE_SUCCESS != chm_resolve_object(_CHMU_RESET_TABLE, ref rt_unit) \r
- || rt_unit.space == CHM_COMPRESSION.CHM_COMPRESSED \r
- || CHM_RESOLVE.CHM_RESOLVE_SUCCESS != chm_resolve_object(_CHMU_CONTENT,ref cn_unit) \r
- || cn_unit.space == CHM_COMPRESSION.CHM_COMPRESSED \r
- || CHM_RESOLVE.CHM_RESOLVE_SUCCESS != chm_resolve_object(_CHMU_LZXC_CONTROLDATA, ref uiLzxc) \r
- || uiLzxc.space == CHM_COMPRESSION.CHM_COMPRESSED)\r
- {\r
- compression_enabled=false;\r
- // st.Close(); \r
- // return false;\r
- }\r
-\r
- // try to read span \r
- // N.B.: we've already checked that uiSpan is in the uncompressed section,\r
- // so this should not require attempting to decompress, which may\r
- // rely on having a valid "span"\r
- \r
- if (compression_enabled)\r
- { \r
- reset_table=new chmLzxcResetTable();\r
- st.BaseStream.Seek((long)((long)data_offset + (long)rt_unit.start),SeekOrigin.Begin);\r
- if (reset_table.Read_lzxc_reset_table(st)!=1)\r
- {\r
- compression_enabled=false;\r
- }\r
- }\r
-\r
- if (compression_enabled)\r
- { \r
- // read control data \r
- ctlData=new chmLzxcControlData();\r
- st.BaseStream.Seek((long)((long)data_offset + (long)uiLzxc.start),SeekOrigin.Begin);\r
- if (ctlData.Read_lzxc_control_data(st)!=1)\r
- {\r
- compression_enabled=false;\r
- } \r
-\r
- window_size = (int)ctlData.windowSize;\r
- reset_interval = ctlData.resetInterval;\r
- try\r
- {\r
- reset_blkcount = (uint)(reset_interval /\r
- (window_size / 2) *\r
- ctlData.windowsPerReset);\r
- }\r
- catch(Exception)\r
- {\r
- reset_blkcount=0;\r
- }\r
- }\r
-\r
- m_bCHMLoaded=true;\r
-\r
- return true;\r
- }\r
- #endregion\r
-\r
- #region Close CHM Stream\r
- // close an ITS archive \r
- private void chm_close()\r
- {\r
- if (!m_bCHMLoaded)\r
- return;\r
-\r
- st.Close();\r
- lzx_state.LZXteardown();\r
- lzx_state=null;\r
- }\r
- #endregion\r
- \r
- #region Find File in CHM Stream\r
- // resolve a particular object from the archive \r
- private CHMStream.CHM_RESOLVE chm_resolve_object(string objPath, ref chmUnitInfo ui)\r
- { \r
- Int32 curPage;\r
- \r
- // starting page \r
- curPage = index_root;\r
-\r
- // until we have either returned or given up \r
- while (curPage != -1)\r
- {\r
- st.BaseStream.Seek((long)((long)dir_offset + (long)(curPage*block_len)),SeekOrigin.Begin);\r
- \r
- char[] sig=st.ReadChars(4);\r
- st.BaseStream.Seek(-4,SeekOrigin.Current);\r
- if (CheckSig("PMGL",sig))\r
- {\r
- chmPmglHeader PmglHeader=new chmPmglHeader();\r
- if (PmglHeader.Read_pmgl_header(st)==1)\r
- {\r
- // scan block \r
- ui=PmglHeader.FindObject(st,block_len,objPath);\r
- if (ui== null) \r
- return CHMStream.CHM_RESOLVE.CHM_RESOLVE_FAILURE;\r
-\r
- // parse entry and return \r
- return CHMStream.CHM_RESOLVE.CHM_RESOLVE_SUCCESS;\r
- }\r
- } \r
- else if (CheckSig("PMGI",sig))\r
- { \r
- chmPmgiHeader pmgiHeader=new chmPmgiHeader();\r
- pmgiHeader.Read_pmgi_header(st);\r
- curPage = pmgiHeader._chm_find_in_PMGI(st, block_len, objPath);\r
- } \r
- else\r
- // else, we are confused. give up. \r
- return CHMStream.CHM_RESOLVE.CHM_RESOLVE_FAILURE;\r
- }\r
-\r
- // didn't find anything. fail. \r
- return CHMStream.CHM_RESOLVE.CHM_RESOLVE_FAILURE;\r
- }\r
- #endregion\r
-\r
- #region Extract File from CHM Stream\r
-\r
- // * utility methods for dealing with compressed data \r
- // get the bounds of a compressed block. return 0 on failure \r
- private int _chm_get_cmpblock_bounds(System.IO.BinaryReader st, UInt64 block, ref UInt64 start, ref UInt64 len)\r
- {\r
- // for all but the last block, use the reset table \r
- if (block < reset_table.block_count-1)\r
- {\r
- // unpack the start address \r
- st.BaseStream.Seek((long)data_offset + (long)rt_unit.start + (long)reset_table.table_offset + (long)(block*8),SeekOrigin.Begin);\r
- start=st.ReadUInt64();\r
- len=st.ReadUInt64();\r
- }\r
-\r
- // for the last block, use the span in addition to the reset table \r
- else\r
- { \r
- // unpack the start address \r
- st.BaseStream.Seek((long)data_offset + (long)rt_unit.start + (long)reset_table.table_offset + (long)(block*8),SeekOrigin.Begin);\r
- start=st.ReadUInt64();\r
- len = reset_table.compressed_len;\r
- }\r
-\r
- // compute the length and absolute start address \r
- len -= start;\r
- start += data_offset + cn_unit.start;\r
-\r
- return 1;\r
- }\r
-\r
- // decompress the block. must have lzx_mutex. \r
- private ulong _chm_decompress_block(UInt64 block, System.IO.Stream OutBuffer)\r
- {\r
- // byte []cbuffer = new byte(reset_table.block_len + 6144);\r
- ulong cmpStart=0; // compressed start \r
- ulong cmpLen=0; // compressed len \r
- UInt32 blockAlign = (UInt32)(block % reset_blkcount); // reset intvl. aln. \r
- \r
- // check if we need previous blocks \r
- if (blockAlign != 0) \r
- {\r
- /* fetch all required previous blocks since last reset */\r
- for (UInt32 i = blockAlign; i > 0; i--)\r
- {\r
- UInt32 curBlockIdx = (UInt32)(block-i);\r
- \r
- /* check if we most recently decompressed the previous block */\r
- if ((ulong)lzx_last_block != curBlockIdx)\r
- {\r
- if ((curBlockIdx % reset_blkcount)==0)\r
- {\r
- lzx_state.LZXreset();\r
- }\r
- \r
- _chm_get_cmpblock_bounds(st,curBlockIdx, ref cmpStart, ref cmpLen);\r
- st.BaseStream.Seek((long)cmpStart,SeekOrigin.Begin); \r
- if (lzx_state.LZXdecompress(st,OutBuffer, ref cmpLen, ref reset_table.block_len) != lzw.DECR_OK)\r
- return (Int64)0;\r
- }\r
- lzx_last_block = (int)(curBlockIdx);\r
- }\r
- }\r
- else\r
- {\r
- if ((block % reset_blkcount)==0)\r
- {\r
- lzx_state.LZXreset();\r
- } \r
- }\r
-\r
- // decompress the block we actually want \r
- if (_chm_get_cmpblock_bounds(st, block, ref cmpStart, ref cmpLen)==0)\r
- return 0;\r
-\r
- st.BaseStream.Seek((long)cmpStart,SeekOrigin.Begin);\r
- \r
- if (lzx_state.LZXdecompress(st, OutBuffer, ref cmpLen,ref reset_table.block_len) != lzw.DECR_OK)\r
- return (Int64)0;\r
-\r
- lzx_last_block = (int)block;\r
-\r
- // XXX: modify LZX routines to return the length of the data they\r
- // * decompressed and return that instead, for an extra sanity check.\r
- return reset_table.block_len;\r
- }\r
-\r
- // grab a region from a compressed block \r
- private ulong _chm_decompress_region(Stream buf, ulong start, ulong len)\r
- {\r
- ulong nBlock, nOffset;\r
- ulong nLen;\r
- ulong gotLen;\r
- // byte [] ubuffer=null;\r
-\r
- if (len <= 0)\r
- return (Int64)0;\r
-\r
- // figure out what we need to read \r
- nBlock = start / reset_table.block_len;\r
- nOffset = start % reset_table.block_len;\r
- nLen = len;\r
- if (nLen > (reset_table.block_len - nOffset))\r
- nLen = reset_table.block_len - nOffset;\r
-\r
- // data request not satisfied, so... start up the decompressor machine \r
- if (lzx_state==null)\r
- {\r
- int window_size = ffs(this.window_size) - 1;\r
- lzx_last_block = -1;\r
-\r
- lzx_state=new lzw();\r
- lzx_state.LZXinit(window_size);\r
- }\r
-\r
- // decompress some data \r
- MemoryStream ms=new MemoryStream((int)reset_table.block_len+6144); \r
- gotLen = _chm_decompress_block(nBlock, ms);\r
- if (gotLen < nLen)\r
- nLen = gotLen; \r
- \r
- // memcpy(buf, ubuffer+nOffset, (unsigned int)nLen);\r
- ms.Position=(long)nOffset;\r
- for(ulong i=0;i<nLen;i++)\r
- buf.WriteByte((byte)ms.ReadByte());\r
- buf.Flush();\r
- return nLen;\r
- }\r
-\r
- // retrieve (part of) an object \r
- private ulong chm_retrieve_object(chmUnitInfo ui, Stream buf, ulong addr, ulong len)\r
- {\r
- // starting address must be in correct range \r
- if (addr < 0 || addr >= (ulong)ui.length)\r
- return (Int64)0;\r
-\r
- // clip length \r
- if (addr + (ulong)len > (ulong)ui.length)\r
- len = (ulong)ui.length - (ulong)addr;\r
-\r
- // if the file is uncompressed, it's simple \r
- if (ui.space == CHMStream.CHM_COMPRESSION.CHM_UNCOMPRESSED)\r
- {\r
- // read data \r
- long FilePos=st.BaseStream.Position; \r
- st.BaseStream.Seek((long)((long)data_offset + (long)ui.start + (long)addr),SeekOrigin.Begin);\r
- // byte [] buffer=st.ReadBytes((int)len);\r
- buf.Write(st.ReadBytes((int)len),0,(int) len);\r
- st.BaseStream.Seek(FilePos,SeekOrigin.Begin);\r
- return (ulong)len;\r
- }\r
-\r
- // else if the file is compressed, it's a little trickier \r
- else // ui->space == CHM_COMPRESSED \r
- { \r
- if (lzx_state!=null)\r
- {\r
- lzx_state.LZXteardown();\r
- lzx_state=null;\r
- }\r
- ulong swath=0, total=0;\r
- do \r
- {\r
- if (!compression_enabled)\r
- return total;\r
-\r
- // swill another mouthful \r
- swath = _chm_decompress_region(buf, ui.start + addr, len);\r
-\r
- // if we didn't get any... \r
- if (swath == 0)\r
- {\r
- Trace.Assert((total!=ui.length),"De-compress failed","Length Required = "+ui.length.ToString()+" Length returned = "+total.ToString());\r
- return total;\r
- }\r
-\r
- // update stats \r
- total += swath;\r
- len -= swath;\r
- addr += swath;\r
- } while (len != 0); \r
- lzx_state=null;\r
-\r
- Trace.Assert((len!=ui.length),"De-compress failed","Length Required = "+ui.length.ToString()+" Length returned = "+len.ToString());\r
- return len;\r
- }\r
- }\r
- #endregion\r
- \r
- #region Enumerate functions \r
- // Enumerate the objects in the .chm archive \r
- // Use delegate to handle callback\r
-\r
- public delegate void CHMFileFound(chmUnitInfo Info, ref CHMStream.CHM_ENUMERATOR Status);\r
- public event CHMFileFound CHMFileFoundEvent;\r
-\r
- public void OnFileFound(chmUnitInfo Info, ref CHMStream.CHM_ENUMERATOR Status)\r
- {\r
- if (CHMFileFoundEvent!=null)\r
- CHMFileFoundEvent(Info,ref Status);\r
- }\r
- private int chm_enumerate(CHM_ENUMERATE what)\r
- {\r
- Int32 curPage;\r
-\r
- // buffer to hold whatever page we're looking at \r
- chmPmglHeader header;\r
- uint end=0;\r
- uint cur=0; \r
-\r
- // the current ui \r
- chmUnitInfo ui= new chmUnitInfo();\r
- CHMStream.CHM_ENUMERATE flag=CHMStream.CHM_ENUMERATE.None;\r
-\r
- // starting page \r
- curPage = index_head;\r
-\r
- // until we have either returned or given up \r
- while (curPage != -1)\r
- {\r
- st.BaseStream.Seek((long)((long)dir_offset + (long)(curPage*block_len)),SeekOrigin.Begin);\r
-\r
- // figure out start and end for this page \r
- cur = (uint)st.BaseStream.Position;\r
- \r
- header=new chmPmglHeader();\r
- if (header.Read_pmgl_header(st)==0) \r
- return 0;\r
-\r
- end = (uint)(st.BaseStream.Position + block_len - (header.free_space)- chmPmglHeader._CHM_PMGL_LEN);\r
-\r
- // loop over this page \r
- while (st.BaseStream.Position < end)\r
- {\r
- if (header._chm_parse_PMGL_entry(st,ref ui)==0)\r
- return 0;\r
-\r
- // check for DIRS \r
- if (ui.length == 0 && ((what & CHM_ENUMERATE.CHM_ENUMERATE_DIRS)==0))\r
- continue;\r
-\r
- // check for FILES \r
- if (ui.length != 0 && ((what & CHM_ENUMERATE.CHM_ENUMERATE_FILES)==0))\r
- continue;\r
-\r
- // check for NORMAL vs. META \r
- if (ui.path[0] == '/')\r
- {\r
- // check for NORMAL vs. SPECIAL \r
- if (ui.path.Length>2)\r
- {\r
- if (ui.path[1] == '#' || ui.path[1] == '$')\r
- flag = CHMStream.CHM_ENUMERATE.CHM_ENUMERATE_SPECIAL;\r
- else\r
- flag = CHMStream.CHM_ENUMERATE.CHM_ENUMERATE_NORMAL;\r
- } \r
- else\r
- flag = CHMStream.CHM_ENUMERATE.CHM_ENUMERATE_META;\r
- if ((what & flag)==0)\r
- continue;\r
- }\r
-\r
- // call the enumerator \r
- {\r
- CHMStream.CHM_ENUMERATOR status = CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_CONTINUE;\r
- OnFileFound(ui,ref status);\r
- \r
- switch (status)\r
- {\r
- case CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_FAILURE: \r
- return 0;\r
-\r
- case CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_CONTINUE: \r
- break;\r
-\r
- case CHMStream.CHM_ENUMERATOR.CHM_ENUMERATOR_SUCCESS: \r
- return 1;\r
-\r
- default:\r
- break;\r
- }\r
- }\r
- }\r
-\r
- // advance to next page \r
- curPage = header.block_next;\r
- }\r
-\r
- return 1;\r
- }\r
- #endregion\r
-\r
- #region IDisposable Members\r
-\r
- private bool disposed=false;\r
- public void Dispose()\r
- {\r
- Dispose(true);\r
- // This object will be cleaned up by the Dispose method.\r
- // Therefore, you should call GC.SupressFinalize to\r
- // take this object off the finalization queue \r
- // and prevent finalization code for this object\r
- // from executing a second time.\r
- GC.SuppressFinalize(this);\r
- }\r
-\r
- /// <summary>\r
- /// Dispose(bool disposing) executes in two distinct scenarios. \r
- /// If disposing equals true, the method has been called directly \r
- /// or indirectly by a user's code. Managed and unmanaged resources \r
- /// can be disposed. \r
- /// If disposing equals false, the method has been called by the \r
- /// runtime from inside the finalizer and you should not reference \r
- /// other objects. Only unmanaged resources can be disposed.\r
- /// </summary>\r
- /// <param name="disposing">disposing flag</param>\r
- private void Dispose(bool disposing)\r
- {\r
- // Check to see if Dispose has already been called.\r
- if(!this.disposed)\r
- {\r
- // If disposing equals true, dispose all managed \r
- // and unmanaged resources.\r
- if(disposing)\r
- {\r
- // Dispose managed resources. \r
- }\r
- }\r
- disposed = true; \r
- }\r
-\r
- #endregion\r
- }\r
-\r
- #region Structures used by CHM Storage\r
- public class BaseStructure\r
- {\r
- public bool CheckSig(string Sig1, char[] Sig2)\r
- {\r
- int i=0;\r
- foreach(char ch in Sig1.ToCharArray())\r
- {\r
- if (ch!=Sig2[i])\r
- return false;\r
- i++;\r
- }\r
- return true;\r
- }\r
-\r
- // skip a compressed dword \r
- public void skip_cword(BinaryReader st)\r
- { \r
- byte b=0;\r
- while ((b=st.ReadByte())>= 0x80); \r
- }\r
-\r
- // skip the data from a PMGL entry \r
- public void _chm_skip_PMGL_entry_data(BinaryReader st)\r
- {\r
- skip_cword(st);\r
- skip_cword(st);\r
- skip_cword(st);\r
- }\r
-\r
- // parse a compressed dword \r
- public UInt64 _chm_parse_cword(BinaryReader st)\r
- {\r
- UInt64 accum = 0;\r
- byte temp=0; \r
- while ((temp=st.ReadByte()) >= 0x80)\r
- {\r
- accum <<= 7;\r
- accum += (ulong)(temp & 0x7f);\r
- }\r
-\r
- return (accum << 7) + temp;\r
- }\r
-\r
- // parse a utf-8 string into an ASCII char buffer \r
- public int _chm_parse_UTF8(BinaryReader st, UInt64 count, ref string path)\r
- {\r
- UTF8Encoding utf8=new UTF8Encoding();\r
- path=utf8.GetString(st.ReadBytes((int)count),0,(int)count); \r
- return 1;\r
- }\r
- }\r
-\r
- public class chmUnitInfo\r
- {\r
- public UInt64 start=0;\r
- public UInt64 length=0;\r
- public CHMStream.CHM_COMPRESSION space=CHMStream.CHM_COMPRESSION.CHM_UNCOMPRESSED;\r
- public string path="";\r
- }\r
-\r
- // structure of ITSF headers \r
- public class chmItsfHeader : BaseStructure\r
- {\r
- public const int _CHM_ITSF_V2_LEN=0x58;\r
- public const int _CHM_ITSF_V3_LEN=0x60;\r
-\r
- public char[] signature=null; // 0 (ITSF) \r
- public Int32 version=0; // 4 \r
- public Int32 header_len=0; // 8 \r
- public Int32 unknown_000c=0; // c \r
- public UInt32 last_modified=0; // 10 \r
- public UInt32 lang_id=0; // 14 \r
- public Guid dir_uuid; // 18 \r
- public Guid stream_uuid; // 28 \r
- public UInt64 unknown_offset=0; // 38 \r
- public UInt64 unknown_len=0; // 40 \r
- public UInt64 dir_offset=0; // 48 \r
- public UInt64 dir_len=0; // 50 \r
- public UInt64 data_offset=0; // 58 (Not present before V3) \r
-\r
- public int Read_itsf_header(BinaryReader st)\r
- { \r
- signature=st.ReadChars(4);\r
- if (CheckSig("ITSF",signature)==false)\r
- return 0;\r
- \r
- version=st.ReadInt32();\r
- header_len=st.ReadInt32();\r
- unknown_000c=st.ReadInt32();\r
- last_modified=st.ReadUInt32();\r
- lang_id=st.ReadUInt32();\r
- dir_uuid=new Guid(st.ReadBytes(16));\r
- stream_uuid=new Guid(st.ReadBytes(16)); \r
- unknown_offset=st.ReadUInt64();\r
- unknown_len=st.ReadUInt64();\r
- dir_offset=st.ReadUInt64();\r
- dir_len=st.ReadUInt64();\r
-\r
- if (version==2)\r
- {\r
- if (header_len != chmItsfHeader._CHM_ITSF_V2_LEN)\r
- return 0;\r
- }\r
- else if (version==3)\r
- {\r
- if (header_len != chmItsfHeader._CHM_ITSF_V3_LEN)\r
- return 0;\r
- }\r
- else return 0;\r
-\r
- if (version==3)\r
- data_offset=st.ReadUInt64();\r
- else\r
- data_offset = dir_offset + dir_len;\r
-\r
- return 1;\r
- }\r
- }\r
-\r
- // structure of ITSP headers \r
- public class chmItspHeader : BaseStructure\r
- {\r
- const int CHM_ITSP_V1_LEN=0x54;\r
- \r
- public char[] signature=null; // 0 (ITSP) \r
- public Int32 version=0; \r
- public Int32 header_len=0; \r
- public Int32 unknown_000c=0; \r
- public UInt32 block_len=0; \r
- public Int32 blockidx_intvl=0; \r
- public Int32 index_depth=0; \r
- public Int32 index_root=0; \r
- public Int32 index_head=0; \r
- public Int32 unknown_0024=0; \r
- public Int32 num_blocks=0; \r
- public Int32 unknown_002c=0; \r
- public UInt32 lang_id=0; \r
- public Guid system_uuid;\r
- public Guid unknown_0044;\r
-\r
- public int Read_itsp_header(BinaryReader st)\r
- { \r
- signature=st.ReadChars(4); // 0 (ITSP) \r
- if (CheckSig("ITSP",signature)==false)\r
- return 0;\r
-\r
- version=st.ReadInt32();\r
- header_len=st.ReadInt32();\r
- \r
- if (header_len!=CHM_ITSP_V1_LEN)\r
- return 0;\r
-\r
- unknown_000c=st.ReadInt32();\r
- block_len=st.ReadUInt32();\r
- blockidx_intvl=st.ReadInt32();\r
- index_depth=st.ReadInt32();\r
- index_root=st.ReadInt32(); \r
- index_head=st.ReadInt32(); \r
- unknown_0024=st.ReadInt32();\r
- num_blocks=st.ReadInt32();\r
- unknown_002c=st.ReadInt32();\r
- lang_id=st.ReadUInt32();\r
- system_uuid=new Guid(st.ReadBytes(16));\r
- unknown_0044=new Guid(st.ReadBytes(16));\r
-\r
- return 1;\r
- }\r
- }\r
-\r
- public class chmPmglHeader : BaseStructure\r
- {\r
- public const int _CHM_PMGL_LEN=0x14;\r
- public char[] signature=null; // 0 (PMGL) \r
- public UInt32 free_space=0; // 4 \r
- public UInt32 unknown_0008=0; // 8 \r
- public Int32 block_prev=0; // c \r
- public Int32 block_next=0; // 10 \r
-\r
- public int Read_pmgl_header(BinaryReader st)\r
- {\r
- signature=st.ReadChars(4);\r
- if (CheckSig("PMGL",signature)==false)\r
- return 0;\r
-\r
- free_space=st.ReadUInt32();\r
- unknown_0008=st.ReadUInt32();\r
- block_prev=st.ReadInt32();\r
- block_next=st.ReadInt32();\r
- return 1;\r
- }\r
-\r
- // parse a PMGL entry into a chmUnitInfo struct; return 1 on success. \r
- public int _chm_parse_PMGL_entry(BinaryReader st, ref chmUnitInfo ui)\r
- {\r
- UInt64 strLen;\r
-\r
- // parse str len \r
- strLen = _chm_parse_cword(st); \r
-\r
- // parse path \r
- if (_chm_parse_UTF8(st, strLen, ref ui.path)==0)\r
- return 0;\r
-\r
- // parse info \r
- ui.space = (CHMStream.CHM_COMPRESSION)_chm_parse_cword(st);\r
- ui.start = _chm_parse_cword(st);\r
- ui.length = _chm_parse_cword(st);\r
- return 1;\r
- }\r
-\r
- public chmUnitInfo FindObject(BinaryReader st, UInt32 block_len, string objPath)\r
- { \r
- UInt32 end = (UInt32)st.BaseStream.Position+ block_len - free_space - _CHM_PMGL_LEN; \r
-\r
- // now, scan progressively \r
- chmUnitInfo FoundObject=new chmUnitInfo();\r
-\r
- while (st.BaseStream.Position < end)\r
- { \r
- _chm_parse_PMGL_entry(st,ref FoundObject);\r
- if (FoundObject.path.ToLower().CompareTo(objPath.ToLower())==0)\r
- return FoundObject;\r
- }\r
- FoundObject=null;\r
-\r
- return null;\r
- }\r
- }\r
-\r
- public class chmPmgiHeader : BaseStructure\r
- {\r
- public const int _CHM_PMGI_LEN=0x8;\r
-\r
- public char[] signature=null; // 0 (PMGL) \r
- public UInt32 free_space=0; // 4 \r
-\r
- public int Read_pmgi_header(BinaryReader st)\r
- {\r
- signature=st.ReadChars(4);\r
- \r
- if ((signature[0]!='P') || (signature[1]!='M') || (signature[2]!='G') || (signature[3]!='I'))\r
- return 0;\r
-\r
- free_space=st.ReadUInt32(); \r
- return 1;\r
- }\r
-\r
- public Int32 _chm_find_in_PMGI(BinaryReader st, UInt32 block_len, string objPath)\r
- { \r
- int page=-1;\r
- UInt64 strLen;\r
- string buffer="";\r
- uint end = (uint)st.BaseStream.Position + block_len - free_space - _CHM_PMGI_LEN;\r
-\r
- // now, scan progressively \r
- while (st.BaseStream.Position < end)\r
- {\r
- // grab the name \r
- strLen = _chm_parse_cword(st);\r
- buffer="";\r
- if (_chm_parse_UTF8(st, strLen, ref buffer)==0)\r
- return -1;\r
-\r
- // check if it is the right name \r
- if (buffer.ToLower().CompareTo(objPath.ToLower())>0)\r
- return page;\r
-\r
- // load next value for path \r
- page = (int)_chm_parse_cword(st);\r
- }\r
- return page;\r
- }\r
- }\r
-\r
- public class chmLzxcResetTable:BaseStructure\r
- { \r
- public UInt32 version=0;\r
- public UInt32 block_count=0;\r
- public UInt32 unknown=0;\r
- public UInt32 table_offset=0;\r
- public UInt64 uncompressed_len=0;\r
- public UInt64 compressed_len=0;\r
- public UInt64 block_len=0; \r
- \r
- public int Read_lzxc_reset_table(BinaryReader st)\r
- {\r
- version=st.ReadUInt32(); \r
- block_count=st.ReadUInt32(); \r
- unknown=st.ReadUInt32(); \r
- table_offset=st.ReadUInt32(); \r
- uncompressed_len=st.ReadUInt64(); \r
- compressed_len=st.ReadUInt64(); \r
- block_len=st.ReadUInt64(); \r
- \r
- // check structure \r
- if (version != 2)\r
- return 0;\r
- else\r
- return 1;\r
- }\r
- }\r
- \r
- // structure of LZXC control data block \r
- public class chmLzxcControlData:BaseStructure\r
- {\r
- public const int _CHM_LZXC_MIN_LEN=0x18;\r
- public const int _CHM_LZXC_V2_LEN=0x1c; \r
-\r
- public UInt32 size=0; // 0 \r
- public char[] signature=null; // 4 (LZXC) \r
- public UInt32 version=0; // 8 \r
- public UInt32 resetInterval=0; // c \r
- public UInt32 windowSize=0; // 10 \r
- public UInt32 windowsPerReset=0; // 14 \r
- public UInt32 unknown_18=0; // 18 \r
- \r
- public int Read_lzxc_control_data(BinaryReader st)\r
- {\r
- size=st.ReadUInt32();\r
- signature=st.ReadChars(4);\r
-\r
- if (CheckSig("LZXC",signature)==false)\r
- return 0;\r
-\r
- version=st.ReadUInt32();\r
- resetInterval=st.ReadUInt32();\r
- windowSize=st.ReadUInt32();\r
- windowsPerReset=st.ReadUInt32(); \r
-\r
- if (size>=_CHM_LZXC_V2_LEN)\r
- unknown_18=st.ReadUInt32();\r
- else\r
- unknown_18 = 0;\r
-\r
- if (version == 2)\r
- {\r
- resetInterval *= 0x8000;\r
- windowSize *= 0x8000; \r
- }\r
- if (windowSize == 0 || resetInterval == 0)\r
- return 0;\r
-\r
- // for now, only support resetInterval a multiple of windowSize/2 \r
- if (windowSize == 1)\r
- return 0;\r
- if ((resetInterval % (windowSize/2)) != 0)\r
- return 0;\r
- \r
- return 1;\r
- }\r
- }\r
- #endregion\r
-\r
- #region LZW Decoder\r
-\r
- internal class lzx_bits \r
- {\r
- public UInt32 bb=0;\r
- public int bl=0; \r
- }\r
-\r
- internal class lzw\r
- {\r
- public lzw()\r
- { \r
- }\r
-\r
- /* $Id: lzx.c,v 1.5 2002/10/09 01:16:33 jedwin Exp $ */\r
- /***************************************************************************\r
- * lzx.c - LZX decompression routines *\r
- * ------------------- *\r
- * *\r
- * maintainer: Jed Wing <jedwin@ugcs.caltech.edu> *\r
- * source: modified lzx.c from cabextract v0.5 *\r
- * notes: This file was taken from cabextract v0.5, which was, *\r
- * itself, a modified version of the lzx decompression code *\r
- * from unlzx. *\r
- * *\r
- * platforms: In its current incarnation, this file has been tested on *\r
- * two different Linux platforms (one, redhat-based, with a *\r
- * 2.1.2 glibc and gcc 2.95.x, and the other, Debian, with *\r
- * 2.2.4 glibc and both gcc 2.95.4 and gcc 3.0.2). Both were *\r
- * Intel x86 compatible machines. *\r
- ***************************************************************************/\r
-\r
- /***************************************************************************\r
- * *\r
- * This program is free software; you can redistribute it and/or modify *\r
- * it under the terms of the GNU General Public License as published by *\r
- * the Free Software Foundation; either version 2 of the License, or *\r
- * (at your option) any later version. Note that an exemption to this *\r
- * license has been granted by Stuart Caie for the purposes of *\r
- * distribution with CHMFile. This does not, to the best of my *\r
- * knowledge, constitute a change in the license of this (the LZX) code *\r
- * in general. *\r
- * *\r
- ***************************************************************************/\r
-\r
- /* some constants defined by the LZX specification */\r
- private const int LZX_MIN_MATCH = 2;\r
- private const int LZX_MAX_MATCH = 257;\r
- private const int LZX_NUM_CHARS = 256;\r
- private const int LZX_BLOCKTYPE_INVALID = 0; /* also blocktypes 4-7 invalid */\r
- private const int LZX_BLOCKTYPE_VERBATIM = 1;\r
- private const int LZX_BLOCKTYPE_ALIGNED = 2;\r
- private const int LZX_BLOCKTYPE_UNCOMPRESSED = 3;\r
- private const int LZX_PRETREE_NUM_ELEMENTS = 20;\r
- private const int LZX_ALIGNED_NUM_ELEMENTS = 8; /* aligned offset tree #elements */\r
- private const int LZX_NUM_PRIMARY_LENGTHS = 7; /* this one missing from spec! */\r
- private const int LZX_NUM_SECONDARY_LENGTHS = 249; /* length tree #elements */\r
-\r
- /* LZX huffman defines: tweak tablebits as desired */\r
- private const int LZX_PRETREE_MAXSYMBOLS = LZX_PRETREE_NUM_ELEMENTS;\r
- private const int LZX_PRETREE_TABLEBITS = 6;\r
- private const int LZX_MAINTREE_MAXSYMBOLS = LZX_NUM_CHARS + 50*8;\r
- private const int LZX_MAINTREE_TABLEBITS = 12;\r
- private const int LZX_LENGTH_MAXSYMBOLS = LZX_NUM_SECONDARY_LENGTHS+1;\r
- private const int LZX_LENGTH_TABLEBITS = 12;\r
- private const int LZX_ALIGNED_MAXSYMBOLS = LZX_ALIGNED_NUM_ELEMENTS;\r
- private const int LZX_ALIGNED_TABLEBITS = 7;\r
- private const int LZX_LENTABLE_SAFETY = 64; /* we allow length table decoding overruns */\r
-\r
- public const int DECR_OK = 0;\r
- public const int DECR_DATAFORMAT = 1;\r
- public const int DECR_ILLEGALDATA = 2;\r
- public const int DECR_NOMEMORY = 3;\r
-\r
- private byte[] window; /* the actual decoding window */\r
- private ulong window_size; /* window size (32Kb through 2Mb) */\r
- private ulong actual_size; /* window size when it was first allocated */\r
- private ulong window_posn; /* current offset within the window */\r
- private ulong R0, R1, R2; /* for the LRU offset system */\r
- private UInt32 main_elements; /* number of main tree elements */\r
- private int header_read; /* have we started decoding at all yet? */\r
- private UInt32 block_type; /* type of this block */\r
- private ulong block_length; /* uncompressed length of this block */\r
- private ulong block_remaining; /* uncompressed bytes still left to decode */\r
- private ulong frames_read; /* the number of CFDATA blocks processed */\r
- private long intel_filesize; /* magic header value used for transform */\r
- private long intel_curpos; /* current offset in transform space */\r
- private int intel_started; /* have we seen any translatable data yet? */\r
-\r
-\r
- private uint [] PRETREE_table = new uint[(1<<(6)) + (((20))<<1)]; \r
- private byte [] PRETREE_len = new byte [((20)) + (64)];\r
-\r
- private uint [] MAINTREE_table= new uint[(1<<(12)) + (((256) + 50*8)<<1)]; \r
- private byte [] MAINTREE_len = new byte [((256) + 50*8) + (64)];\r
-\r
- private uint [] LENGTH_table= new uint[(1<<(12)) + (((249)+1)<<1)]; \r
- private byte [] LENGTH_len = new byte [((249)+1) + (64)];\r
-\r
- private uint [] ALIGNED_table= new uint[(1<<(7)) + (((8))<<1)]; \r
- private byte [] ALIGNED_len = new byte [((8)) + (64)]; \r
- private System.IO.BinaryReader BitSource=null;\r
- private System.IO.Stream OutputStream=null;\r
-\r
- /* LZX decruncher */\r
-\r
- /* Microsoft's LZX document and their implementation of the\r
- * com.ms.util.cab Java package do not concur.\r
- *\r
- * In the LZX document, there is a table showing the correlation between\r
- * window size and the number of position slots. It states that the 1MB\r
- * window = 40 slots and the 2MB window = 42 slots. In the implementation,\r
- * 1MB = 42 slots, 2MB = 50 slots. The actual calculation is 'find the\r
- * first slot whose position base is equal to or more than the required\r
- * window size'. This would explain why other tables in the document refer\r
- * to 50 slots rather than 42.\r
- *\r
- * The constant NUM_PRIMARY_LENGTHS used in the decompression pseudocode\r
- * is not defined in the specification.\r
- *\r
- * The LZX document does not state the uncompressed block has an\r
- * uncompressed length field. Where does this length field come from, so\r
- * we can know how large the block is? The implementation has it as the 24\r
- * bits following after the 3 blocktype bits, before the alignment\r
- * padding.\r
- *\r
- * The LZX document states that aligned offset blocks have their aligned\r
- * offset huffman tree AFTER the main and length trees. The implementation\r
- * suggests that the aligned offset tree is BEFORE the main and length\r
- * trees.\r
- *\r
- * The LZX document decoding algorithm states that, in an aligned offset\r
- * block, if an extra_bits value is 1, 2 or 3, then that number of bits\r
- * should be read and the result added to the match offset. This is\r
- * correct for 1 and 2, but not 3, where just a huffman symbol (using the\r
- * aligned tree) should be read.\r
- *\r
- * Regarding the E8 preprocessing, the LZX document states 'No translation\r
- * may be performed on the last 6 bytes of the input block'. This is\r
- * correct. However, the pseudocode provided checks for the *E8 leader*\r
- * up to the last 6 bytes. If the leader appears between -10 and -7 bytes\r
- * from the end, this would cause the next four bytes to be modified, at\r
- * least one of which would be in the last 6 bytes, which is not allowed\r
- * according to the spec.\r
- *\r
- * The specification states that the huffman trees must always contain at\r
- * least one element. However, many CAB files contain blocks where the\r
- * length tree is completely empty (because there are no matches), and\r
- * this is expected to succeed.\r
- */\r
-\r
- /* LZX uses what it calls 'position slots' to represent match offsets.\r
- * What this means is that a small 'position slot' number and a small\r
- * offset from that slot are encoded instead of one large offset for\r
- * every match.\r
- * - position_base is an index to the position slot bases\r
- * - extra_bits states how many bits of offset-from-base data is needed.\r
- */\r
- private byte [] extra_bits = {\r
- 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,\r
- 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14,\r
- 15, 15, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,\r
- 17, 17, 17\r
- };\r
-\r
- private ulong [] position_base = {\r
- 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192,\r
- 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576, 32768, 49152,\r
- 65536, 98304, 131072, 196608, 262144, 393216, 524288, 655360, 786432, 917504, 1048576, 1179648, 1310720, 1441792, 1572864, 1703936,\r
- 1835008, 1966080, 2097152\r
- };\r
- \r
- private UInt32 ReadUInt16()\r
- {\r
- UInt32 rc=0;\r
- UInt32 Byte1=0;\r
- UInt32 Byte2=0;\r
- try\r
- { \r
- Byte1=BitSource.ReadByte();\r
- Byte2=BitSource.ReadByte();\r
- }\r
- catch(Exception)\r
- {\r
- } \r
- rc=(Byte2<<8)+Byte1;\r
- return rc;\r
- }\r
-\r
- public bool LZXinit(int WindowSize)\r
- { \r
- ulong wndsize = (ulong)(1 << WindowSize);\r
- int i, posn_slots;\r
-\r
- /* LZX supports window sizes of 2^15 (32Kb) through 2^21 (2Mb) */\r
- /* if a previously allocated window is big enough, keep it */\r
- if (WindowSize< 15 || WindowSize> 21) return false;\r
-\r
- /* allocate state and associated window */ \r
- window = new byte[wndsize];\r
- if (window==null)\r
- { \r
- return false;\r
- }\r
-\r
- actual_size = wndsize;\r
- window_size = wndsize;\r
-\r
- /* calculate required position slots */\r
- if (WindowSize == 20) posn_slots = 42;\r
- else if (WindowSize== 21) posn_slots = 50;\r
- else posn_slots = WindowSize << 1;\r
-\r
- /** alternatively **/\r
- /* posn_slots=i=0; while (i < wndsize) i += 1 << extra_bits[posn_slots++]; */\r
-\r
- /* initialize other state */\r
- R0 = R1 = R2 = 1;\r
- main_elements = (uint)(LZX_NUM_CHARS + (posn_slots << 3));\r
- header_read = 0;\r
- frames_read = 0;\r
- block_remaining = 0;\r
- block_type = LZX_BLOCKTYPE_INVALID;\r
- intel_curpos = 0;\r
- intel_started = 0;\r
- window_posn = 0;\r
-\r
- /* initialise tables to 0 (because deltas will be applied to them) */\r
- for (i = 0; i < LZX_MAINTREE_MAXSYMBOLS; i++) MAINTREE_len[i] = 0;\r
- for (i = 0; i < LZX_LENGTH_MAXSYMBOLS; i++) LENGTH_len[i] = 0; \r
-\r
- return true;\r
- }\r
-\r
- public void LZXteardown()\r
- {\r
- window=null; \r
- }\r
-\r
- public int LZXreset()\r
- {\r
- R0 = R1 = R2 = 1;\r
- header_read = 0;\r
- frames_read = 0;\r
- block_remaining = 0;\r
- block_type = LZX_BLOCKTYPE_INVALID;\r
- intel_curpos = 0;\r
- intel_started = 0;\r
- window_posn = 0;\r
-\r
- for (int i = 0; i < LZX_MAINTREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY; i++) MAINTREE_len[i] = 0;\r
- for (int i = 0; i < LZX_LENGTH_MAXSYMBOLS + LZX_LENTABLE_SAFETY; i++) LENGTH_len[i] = 0;\r
-\r
- return DECR_OK;\r
- }\r
-\r
-\r
- /* Bitstream reading macros:\r
- *\r
- * INIT_BITSTREAM should be used first to set up the system\r
- * READ_BITS(var,n) takes N bits from the buffer and puts them in var\r
- *\r
- * ENSURE_BITS(n) ensures there are at least N bits in the bit buffer\r
- * PEEK_BITS(n) extracts (without removing) N bits from the bit buffer\r
- * REMOVE_BITS(n) removes N bits from the bit buffer\r
- *\r
- * These bit access routines work by using the area beyond the MSB and the\r
- * LSB as a free source of zeroes. This avoids having to mask any bits.\r
- * So we have to know the bit width of the bitbuffer variable. This is\r
- * sizeof(ulong) * 8, also defined as ULONG_BITS\r
- */\r
-\r
- /* number of bits in ulong. Note: This must be at multiple of 16, and at\r
- * least 32 for the bitbuffer code to work (ie, it must be able to ensure\r
- * up to 17 bits - that's adding 16 bits when there's one bit left, or\r
- * adding 32 bits when there are no bits left. The code should work fine\r
- * for machines where ulong >= 32 bits.\r
- */\r
- private int ULONG_BITS()\r
- {\r
- int rc=(System.Runtime.InteropServices.Marshal.SizeOf(typeof(System.UInt32))<<3);\r
- return rc;\r
- }\r
-\r
- /* make_decode_table(nsyms, nbits, length[], table[])\r
- *\r
- * This function was coded by David Tritscher. It builds a fast huffman\r
- * decoding table out of just a canonical huffman code lengths table.\r
- *\r
- * nsyms = total number of symbols in this huffman tree.\r
- * nbits = any symbols with a code length of nbits or less can be decoded\r
- * in one lookup of the table.\r
- * length = A table to get code lengths from [0 to syms-1]\r
- * table = The table to fill up with decoded symbols and pointers.\r
- *\r
- * Returns 0 for OK or 1 for error\r
- */\r
-\r
- private int make_decode_table(ulong nsyms, byte nbits, ref byte [] length, ref UInt32[] table) \r
- {\r
- ulong sym;\r
- ulong leaf;\r
- byte bit_num = 1;\r
- ulong fill;\r
- ulong pos = 0; /* the current position in the decode table */\r
- ulong table_mask = (ulong)(1 << nbits);\r
- ulong bit_mask = table_mask >> 1; /* don't do 0 length codes */\r
- ulong next_symbol = bit_mask; /* base of allocation for long codes */\r
-\r
- /* fill entries for codes short enough for a direct mapping */\r
- while (bit_num <= nbits) \r
- {\r
- for (sym = 0; sym < nsyms; sym++) \r
- {\r
- if (length[sym] == bit_num) \r
- {\r
- leaf = pos;\r
-\r
- if((pos += bit_mask) > table_mask) return 1; /* table overrun */\r
-\r
- /* fill all possible lookups of this symbol with the symbol itself */\r
- fill = bit_mask;\r
- while (fill-- > 0) table[leaf++] = (uint)sym;\r
- }\r
- }\r
- bit_mask >>= 1;\r
- bit_num++;\r
- }\r
-\r
- /* if there are any codes longer than nbits */\r
- if (pos != table_mask) \r
- {\r
- /* clear the remainder of the table */\r
- for (sym = pos; sym < table_mask; sym++) table[sym] = 0;\r
-\r
- /* give ourselves room for codes to grow by up to 16 more bits */\r
- pos <<= 16;\r
- table_mask <<= 16;\r
- bit_mask = 1 << 15;\r
-\r
- while (bit_num <= 16) \r
- {\r
- for (sym = 0; sym < nsyms; sym++) \r
- {\r
- if (length[sym] == bit_num) \r
- {\r
- leaf = pos >> 16;\r
- for (fill = 0; fill < (ulong)(bit_num - nbits); fill++) \r
- {\r
- /* if this path hasn't been taken yet, 'allocate' two entries */\r
- if (table[leaf] == 0) \r
- {\r
- table[(next_symbol << 1)] = 0;\r
- table[(next_symbol << 1) + 1] = 0;\r
- table[leaf] = (uint)next_symbol++;\r
- }\r
- /* follow the path and select either left or right for next bit */\r
- leaf = table[leaf] << 1;\r
- if (((pos >> (byte)(15-fill)) & 1)==1) \r
- leaf++;\r
- }\r
- table[leaf] = (uint)sym;\r
-\r
- if ((pos += bit_mask) > table_mask) \r
- return 1; /* table overflow */\r
- }\r
- }\r
- bit_mask >>= 1;\r
- bit_num++;\r
- }\r
- }\r
-\r
- /* full table? */\r
- if (pos == table_mask) \r
- return 0;\r
-\r
- /* either erroneous table, or all elements are 0 - let's find out. */\r
- for (sym = 0; sym < nsyms; sym++) if (length[(uint)sym]!=0) \r
- return 1;\r
-\r
- return 0;\r
- } \r
-\r
- private int lzx_read_lens(byte []lens, ulong first, ulong last, ref lzx_bits lb) \r
- {\r
- ulong i,j, x,y;\r
- int z;\r
- \r
- UInt32 bitbuf = lb.bb;\r
- int bitsleft = lb.bl; \r
-\r
- UInt32 [] hufftbl=null; \r
-\r
- for (x = 0; x < 20; x++) \r
- {\r
- do\r
- {\r
- while (bitsleft < (4)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- y = (bitbuf >> (ULONG_BITS()- (4))); \r
- bitbuf <<= 4; \r
- bitsleft -= 4; \r
- }\r
- while (false);\r
- PRETREE_len[x] = (byte)y;\r
- } \r
- if (make_decode_table( 20, 6, ref PRETREE_len, ref PRETREE_table)!=0)\r
- return 2; \r
-\r
- for (x = first; x < last; ) \r
- {\r
- do\r
- {\r
- while (bitsleft < 16) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- hufftbl = PRETREE_table; \r
- if ((i = hufftbl[((ulong)bitbuf >> (ULONG_BITS()- 6))]) >= 20) \r
- { \r
- j = (ulong)(1 << (byte)(ULONG_BITS()- ((6)))); \r
- do \r
- {\r
- j >>= 1; \r
- i <<= 1; \r
- if ((bitbuf & j)!=0)\r
- i|=1;\r
- else\r
- i|=0;\r
-\r
- if (j==0) \r
- {\r
- return (2); \r
- } \r
- } \r
- while ((i = hufftbl[i]) >= 20); \r
- } \r
- z = (int)i;\r
- j = PRETREE_len[z]; \r
- bitbuf <<= (byte)j;\r
- bitsleft -= (int)j; \r
- }\r
- while (false);\r
-\r
- if (z == 17) \r
- {\r
- do\r
- {\r
- while (bitsleft < (4)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- y = (bitbuf >> (ULONG_BITS()- (4))); \r
- bitbuf <<= 4;\r
- bitsleft -= 4; \r
- }\r
- while(false);\r
- y += 4;\r
- \r
- while ((y--)!=0) \r
- lens[x++] = 0;\r
- }\r
- else if (z == 18) \r
- { \r
- do\r
- {\r
- while (bitsleft < (5)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16;\r
- } \r
- (y) = (bitbuf >> (ULONG_BITS()- (5))); \r
- bitbuf <<= 5;\r
- bitsleft -= 5; \r
- }\r
- while (false);\r
- \r
- y += 20;\r
-\r
- while ((y--)!=0) \r
- lens[x++] = 0;\r
- }\r
- else if (z == 19) \r
- {\r
- do\r
- {\r
- while (bitsleft < (1)) \r
- {\r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- y = (bitbuf >> (ULONG_BITS()- (1))); \r
- bitbuf <<= 1;\r
- bitsleft -= 1; \r
- }\r
- while(false);\r
- y += 4;\r
- do\r
- {\r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- hufftbl = (PRETREE_table); \r
- if ((i = hufftbl[(bitbuf >> (ULONG_BITS()- 6))]) >= 20) \r
- { \r
- j = (ulong)1 << (byte)(ULONG_BITS()- 6); \r
- do \r
- { \r
- j >>= 1; \r
- i <<= 1; \r
- if ((bitbuf & j)==0)\r
- i|=0;\r
- else\r
- i|=1;\r
- if (j==0) \r
- { \r
- return (2); \r
- } \r
- } \r
- while ((i = hufftbl[i]) >= 20); \r
- } \r
- z = (int)i;\r
- j = PRETREE_len[z]; \r
-\r
- bitbuf <<= (byte)j;\r
- bitsleft -= (int)j; \r
- }\r
- while(false);\r
- z = lens[x] - z; \r
- if (z < 0) \r
- z += 17;\r
-\r
- while ((y--)!=0) \r
- lens[x++] = (byte)z;\r
- }\r
- else \r
- {\r
- z = lens[x] - z; \r
- if (z < 0) \r
- z += 17;\r
- lens[x++] = (byte)z;\r
- }\r
- }\r
- lb.bb = bitbuf;\r
- lb.bl = bitsleft;\r
- return 0;\r
- }\r
-\r
- public int LZXdecompress(System.IO.BinaryReader inpos, System.IO.Stream outpos, ref ulong inlen, ref ulong outlen) \r
- {\r
- BitSource=inpos;\r
- OutputStream=outpos;\r
- \r
- long endinp = BitSource.BaseStream.Position+(long)inlen; \r
- ulong runsrc, rundest;\r
- UInt32 [] hufftbl; /* used in READ_HUFFSYM macro as chosen decoding table */\r
-\r
- UInt32 bitbuf;\r
- int bitsleft;\r
- ulong match_offset, i,j,k; /* ijk used in READ_HUFFSYM macro */\r
- lzx_bits lb; /* used in READ_LENGTHS macro */\r
- lb=new lzx_bits(); \r
-\r
- int togo = (int)outlen, this_run, main_element, aligned_bits;\r
- int match_length, length_footer, extra, verbatim_bits;\r
-\r
- bitsleft = 0; \r
- bitbuf = 0; \r
-\r
- /* read header if necessary */\r
- if (header_read==0) \r
- {\r
- i = j = 0; \r
- do\r
- {\r
- while (bitsleft < (1)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- k = (bitbuf >> (ULONG_BITS()- (1))); \r
- bitbuf <<= 1;\r
- bitsleft -= 1;\r
- }\r
- while(false);\r
-\r
- if (k!=0) \r
- {\r
- do\r
- {\r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() -16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- i = (bitbuf >> (ULONG_BITS()- (16))); \r
- bitbuf <<= 16;\r
- bitsleft -= 1;\r
- }\r
- while(false);\r
-\r
- do\r
- {\r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- j = (bitbuf >> (ULONG_BITS()- (16))); \r
- bitbuf <<= 16;\r
- bitsleft -= 16; \r
- }\r
- while(false);\r
- }\r
- intel_filesize = (long)((i << 16) | j); \r
- header_read = 1;\r
- }\r
-\r
- /* main decoding loop */\r
- while (togo > 0) \r
- {\r
- if (block_remaining == 0) \r
- {\r
- if (block_type == (3)) \r
- {\r
- if ((block_length & 1)!=0) \r
- BitSource.ReadByte();\r
- bitsleft = 0; \r
- bitbuf = 0; \r
- }\r
-\r
- do \r
- { \r
- while (bitsleft < (3)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- (block_type) = (uint)(bitbuf >> (ULONG_BITS()- (3))); \r
- bitbuf <<= 3; \r
- bitsleft -= 3; \r
- } \r
- while (false);\r
-\r
- do \r
- { \r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- (i) = (bitbuf >> (ULONG_BITS()- (16))); \r
- bitbuf <<= 16; \r
- bitsleft -= 16; \r
- } \r
- while (false);\r
-\r
- do \r
- { \r
- while (bitsleft < (8)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- (j) = (bitbuf >> (ULONG_BITS()- (8))); \r
- bitbuf <<= 8; \r
- bitsleft -= 8; \r
- } \r
- while (false);\r
- block_remaining = block_length = (i << 8) | j;\r
-\r
- switch (block_type) \r
- {\r
- case (LZX_BLOCKTYPE_ALIGNED):\r
- for (i = 0; i < 8; i++) \r
- { \r
- do \r
- { \r
- while (bitsleft < (3)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- (j) = (bitbuf >> (ULONG_BITS()- (3))); \r
- bitbuf <<= 3; \r
- bitsleft -= 3; \r
- } \r
- while (false); \r
- (ALIGNED_len)[i] = (byte)j; \r
- }\r
- if (make_decode_table( 8, 7, ref ALIGNED_len, ref ALIGNED_table)!=0) \r
- { \r
- return (2); \r
- }\r
-\r
- do \r
- { \r
- lb.bb = bitbuf; \r
- lb.bl = bitsleft; \r
- if (lzx_read_lens(MAINTREE_len,0,256,ref lb)!=0) \r
- { \r
- return (2); \r
- } \r
- bitbuf = lb.bb; \r
- bitsleft = lb.bl; \r
- } \r
- while (false);\r
- do \r
- { \r
- lb.bb = bitbuf; \r
- lb.bl = bitsleft; \r
- if (lzx_read_lens(MAINTREE_len,256,main_elements,ref lb)!=0) \r
- { \r
- return (2); \r
- } \r
- bitbuf = lb.bb; \r
- bitsleft = lb.bl; \r
- } \r
- while (false);\r
-\r
- if (make_decode_table( (256 + 50*8), 12, ref MAINTREE_len, ref MAINTREE_table)!=0) \r
- { \r
- return (2); \r
- }\r
- if (MAINTREE_len[0xE8] != 0) intel_started = 1;\r
-\r
- do \r
- { \r
- lb.bb = bitbuf; \r
- lb.bl = bitsleft; \r
- if (lzx_read_lens(LENGTH_len,0,249,ref lb)!=0) \r
- { \r
- return (2); \r
- } \r
- bitbuf = lb.bb; \r
- bitsleft = lb.bl; \r
- } \r
- while (false);\r
- if (make_decode_table( (249+1), 12, ref LENGTH_len, ref LENGTH_table)!=0) \r
- { \r
- return (2); \r
- }\r
- break; \r
- \r
- case (LZX_BLOCKTYPE_VERBATIM):\r
- do \r
- { \r
- lb.bb = bitbuf; \r
- lb.bl = bitsleft; \r
- if (lzx_read_lens(MAINTREE_len,0,256,ref lb)!=0) \r
- { \r
- return (2); \r
- } \r
- bitbuf = lb.bb; \r
- bitsleft = lb.bl; \r
- } \r
- while (false);\r
- do \r
- { \r
- lb.bb = bitbuf; \r
- lb.bl = bitsleft; \r
- if (lzx_read_lens(MAINTREE_len,256,main_elements,ref lb)!=0) \r
- { \r
- return (2); \r
- } \r
- bitbuf = lb.bb; \r
- bitsleft = lb.bl; \r
- } \r
- while (false);\r
-\r
- if (make_decode_table( (256 + 50*8), 12, ref MAINTREE_len, ref MAINTREE_table)!=0) \r
- { \r
- return (2); \r
- }\r
- if (MAINTREE_len[0xE8] != 0) intel_started = 1;\r
-\r
- do \r
- { \r
- lb.bb = bitbuf; \r
- lb.bl = bitsleft; \r
- if (lzx_read_lens(LENGTH_len,0,249,ref lb)!=0) \r
- { \r
- return (2); \r
- } \r
- bitbuf = lb.bb; \r
- bitsleft = lb.bl; \r
- } \r
- while (false);\r
- if (make_decode_table( (249+1), 12, ref LENGTH_len, ref LENGTH_table)!=0) \r
- { \r
- return (2); \r
- }\r
- break;\r
-\r
- case (LZX_BLOCKTYPE_UNCOMPRESSED):\r
- intel_started = 1; \r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - bitsleft); \r
- bitsleft += 16;\r
- } \r
- if (bitsleft > 16)\r
- {\r
- BitSource.BaseStream.Seek(-2,System.IO.SeekOrigin.Current); \r
- }\r
- R0 = (ulong)(BitSource.ReadByte()+(BitSource.ReadByte()<<8)+(BitSource.ReadByte()<<16)+(BitSource.ReadByte()<<24));\r
- R1 = (ulong)(BitSource.ReadByte()+(BitSource.ReadByte()<<8)+(BitSource.ReadByte()<<16)+(BitSource.ReadByte()<<24));\r
- R2 = (ulong)(BitSource.ReadByte()+(BitSource.ReadByte()<<8)+(BitSource.ReadByte()<<16)+(BitSource.ReadByte()<<24));\r
- break;\r
-\r
- default:\r
- return (DECR_ILLEGALDATA);\r
- }\r
- }\r
-\r
- /* buffer exhaustion check */\r
- if (BitSource.BaseStream.Position > (long) endinp) \r
- {\r
- /* it's possible to have a file where the next run is less than\r
- * 16 bits in size. In this case, the READ_HUFFSYM() macro used\r
- * in building the tables will exhaust the buffer, so we should\r
- * allow for this, but not allow those accidentally read bits to\r
- * be used (so we check that there are at least 16 bits\r
- * remaining - in this boundary case they aren't really part of\r
- * the compressed data)\r
- */\r
- if (BitSource.BaseStream.Position> (long)(endinp+2) || bitsleft < 16) \r
- return DECR_ILLEGALDATA;\r
- }\r
-\r
- while ((this_run = (int)block_remaining) > 0 && togo > 0) \r
- {\r
- if (this_run > togo)\r
- this_run = togo;\r
-\r
- togo -= this_run;\r
- block_remaining -= (ulong)this_run;\r
-\r
- /* apply 2^x-1 mask */\r
- window_posn &= window_size - 1;\r
-\r
- /* runs can't straddle the window wraparound */\r
- if ((window_posn + (ulong)this_run) > window_size)\r
- return DECR_DATAFORMAT;\r
-\r
- switch (block_type) \r
- {\r
- case LZX_BLOCKTYPE_VERBATIM:\r
- while (this_run > 0) \r
- {\r
- do \r
- { \r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- hufftbl = MAINTREE_table; \r
- if ((i = hufftbl[(bitbuf >> (ULONG_BITS()- 12))]) >= 256 + 50*8) \r
- { \r
- j = (ulong)(1 << (ULONG_BITS()- 12)); \r
- do \r
- { \r
- j >>= 1; \r
- i <<= 1; \r
- if ((bitbuf & j)!=0) \r
- i|=1; \r
- else \r
- i|=0; \r
- if (j==0) \r
- { \r
- return (2); \r
- } \r
- } \r
- while ((i = hufftbl[i]) >= (((256) + 50*8))); \r
- } \r
- j = MAINTREE_len[main_element = (int)i]; \r
- bitbuf <<= (byte)j; \r
- bitsleft -= (byte)j; \r
- } \r
- while (false);\r
-\r
- if (main_element < (256)) \r
- { \r
- window[window_posn++] = (byte)main_element;\r
- this_run--;\r
- }\r
- else \r
- { \r
- main_element -= (256);\r
-\r
- match_length = main_element & (7);\r
- if (match_length == (7)) \r
- {\r
- do \r
- { \r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- hufftbl = (LENGTH_table); \r
- if ((i = hufftbl[(bitbuf >> (ULONG_BITS()- 12))]) >= (((249)+1))) \r
- { \r
- j = (ulong)(1 << (ULONG_BITS()- ((12)))); \r
- do \r
- { \r
- j >>= 1; \r
- i <<= 1; \r
- if ((bitbuf & j)!=0) \r
- i|=1; \r
- else \r
- i|=0; \r
- if (j==0) \r
- { \r
- return (2); \r
- } \r
- } \r
- while ((i = hufftbl[i]) >= (((249)+1))); \r
- } \r
- j = LENGTH_len[(length_footer) = (int)i]; \r
- bitbuf <<= (byte)j; \r
- bitsleft -= (byte)j; \r
- } \r
- while (false);\r
-\r
- match_length += length_footer;\r
- }\r
- match_length += (2);\r
-\r
- match_offset = (ulong)(main_element >> 3);\r
-\r
- if (match_offset > 2) \r
- { \r
- if (match_offset != 3) \r
- {\r
- extra = extra_bits[match_offset];\r
- do \r
- { \r
- while (bitsleft < (extra)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- verbatim_bits = (int)(bitbuf >> (ULONG_BITS()- (extra))); \r
- bitbuf <<= extra; \r
- bitsleft -= extra; \r
- } \r
- while (false);\r
- match_offset = position_base[match_offset] - 2 + (ulong)verbatim_bits;\r
- }\r
- else \r
- {\r
- match_offset = 1;\r
- }\r
- \r
- R2 = R1; R1 = R0; R0 = match_offset;\r
- }\r
- else if (match_offset == 0) \r
- {\r
- match_offset = R0;\r
- }\r
- else if (match_offset == 1) \r
- {\r
- match_offset = R1;\r
- R1 = R0; R0 = match_offset;\r
- }\r
- else \r
- {\r
- match_offset = R2;\r
- R2 = R0; R0 = match_offset;\r
- }\r
-\r
- rundest = window_posn;\r
- // rundest= window+window_posn\r
- runsrc = rundest - match_offset; \r
- window_posn += (ulong)match_length;\r
- this_run -= match_length;\r
- \r
- // runsrc < window\r
- while ((runsrc<0) && (match_length-- > 0))\r
- {\r
- window[rundest++]=window[runsrc+window_size];\r
- // *rundest++ = *(runsrc + window_size); \r
- runsrc++;\r
- }\r
- \r
- while (match_length-- > 0) \r
- {\r
- window[rundest++]=window[runsrc++];\r
- // *rundest++ = *runsrc++;\r
- }\r
- }\r
- }\r
- break;\r
-\r
- case LZX_BLOCKTYPE_ALIGNED:\r
- while (this_run > 0) \r
- {\r
- do \r
- { \r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- hufftbl = MAINTREE_table; \r
- if ((i = hufftbl[(bitbuf >> (ULONG_BITS()- 12))]) >= (((256) + 50*8))) \r
- { \r
- j = (ulong)1 << (ULONG_BITS()- ((12))); \r
- do \r
- { \r
- j >>= 1; \r
- i <<= 1; \r
- if ((bitbuf & j)!=0) \r
- i|=1; \r
- else \r
- i|=0; \r
- if (j==0) \r
- { \r
- return (2); \r
- } \r
- } \r
- while ((i = hufftbl[i]) >= (((256) + 50*8))); \r
- } \r
- j = MAINTREE_len[(main_element) = (int)i]; \r
- bitbuf <<= (int)j; \r
- bitsleft -= (int)j; \r
- } \r
- while (false);\r
-\r
- if (main_element < (256)) \r
- { \r
- window[window_posn++] = (byte)main_element;\r
- this_run--;\r
- }\r
- else \r
- { \r
- main_element -= (256);\r
- match_length = main_element & (7);\r
- if (match_length == (7)) \r
- {\r
- do \r
- { \r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- hufftbl = LENGTH_table; \r
- if ((i = hufftbl[(bitbuf >> (ULONG_BITS()- 12))]) >= (((249)+1))) \r
- { \r
- j = (ulong) 1 << (ULONG_BITS()- ((12))); \r
- do \r
- { \r
- j >>= 1; \r
- i <<= 1; \r
- if ((bitbuf & j)!=0)\r
- i|=1;\r
- else\r
- i|=0;\r
-\r
- if (j==0) \r
- { \r
- return (2); \r
- } \r
- } \r
- while ((i = hufftbl[i]) >= (((249)+1))); \r
- } \r
- j = LENGTH_len[length_footer = (int)i]; \r
- bitbuf <<= (int)j; \r
- bitsleft -= (int)j; \r
- } \r
- while (false);\r
- match_length += length_footer;\r
- }\r
- match_length += (2);\r
-\r
- match_offset = (ulong)(main_element >> 3);\r
-\r
- if (match_offset > 2) \r
- { \r
- extra = extra_bits[match_offset];\r
- match_offset = position_base[match_offset] - 2;\r
- if (extra > 3) \r
- { \r
- extra -= 3;\r
- do \r
- { \r
- while (bitsleft < (extra)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- verbatim_bits = (int)(bitbuf >> (ULONG_BITS()- (extra))); \r
- bitbuf <<= extra; \r
- bitsleft -= extra; \r
- } \r
- while (false);\r
- match_offset += (ulong)(verbatim_bits << 3);\r
- do \r
- { \r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- hufftbl = (ALIGNED_table); \r
- if ((i = hufftbl[(bitbuf >> (ULONG_BITS()- 7))]) >= 8) \r
- { \r
- j = (ulong)1 << (ULONG_BITS()- ((7))); \r
- do \r
- { \r
- j >>= 1; \r
- i <<= 1; \r
- if ((bitbuf & j)!=0)\r
- i|=1;\r
- else\r
- i|=0;\r
- if (j==0) \r
- { \r
- return (2); \r
- } \r
- } \r
- while ((i = hufftbl[i]) >= (((8)))); \r
- } \r
-\r
- j = (ALIGNED_len)[(aligned_bits) = (int)i]; \r
- bitbuf <<= (int)j; \r
- bitsleft -= (int)j; \r
- } \r
- while (false);\r
- match_offset += (ulong)aligned_bits;\r
- }\r
- else if (extra == 3) \r
- { \r
- do \r
- { \r
- while (bitsleft < (16)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- hufftbl = (ALIGNED_table); \r
- if ((i = hufftbl[(bitbuf >> (ULONG_BITS()- 7))]) >= 8) \r
- { \r
- j = (ulong)1 << (ULONG_BITS()- ((7))); \r
- do \r
- { \r
- j >>= 1; \r
- i <<= 1; \r
- if ((bitbuf & j)!=0)\r
- i|=1;\r
- else\r
- i|=0;\r
- if (j!=0) \r
- { \r
- return (2); \r
- } \r
- } \r
- while ((i = hufftbl[i]) >= 8); \r
- } \r
- j = (ALIGNED_len)[(aligned_bits) = (int)i]; \r
- bitbuf <<= (int)j; \r
- bitsleft -= (int)j; \r
- } \r
- while (false);\r
- match_offset += (ulong)aligned_bits;\r
- }\r
- else if (extra > 0) \r
- { \r
- do \r
- { \r
- while (bitsleft < (extra)) \r
- { \r
- bitbuf |= (UInt32)ReadUInt16() << (ULONG_BITS() - 16 - bitsleft); \r
- bitsleft += 16; \r
- } \r
- (verbatim_bits) = (int)(bitbuf >> (int)(ULONG_BITS()- (extra))); \r
- bitbuf <<= extra;\r
- bitsleft -= extra; \r
- } \r
- while (false);\r
- match_offset += (ulong)verbatim_bits;\r
- }\r
- else \r
- { \r
- match_offset = 1;\r
- }\r
- \r
- R2 = R1; R1 = R0; R0 = match_offset;\r
- }\r
- else if (match_offset == 0) \r
- {\r
- match_offset = R0;\r
- }\r
- else if (match_offset == 1) \r
- {\r
- match_offset = R1;\r
- R1 = R0; R0 = match_offset;\r
- }\r
- else \r
- {\r
- match_offset = R2;\r
- R2 = R0; R0 = match_offset;\r
- }\r
-\r
- rundest = window_posn;\r
- runsrc = rundest - match_offset;\r
- window_posn += (ulong)match_length;\r
- this_run -= match_length;\r
- \r
- while ((runsrc<0) && (match_length-- > 0))\r
- {\r
- // *rundest++ = *(runsrc + window_size); runsrc++;\r
- window[rundest++]=window[runsrc + window_size];\r
- runsrc++;\r
- }\r
- \r
- while (match_length-- > 0) \r
- {\r
- // *rundest++ = *runsrc++;\r
- window[rundest++]=window[runsrc++];\r
- }\r
- }\r
- }\r
- break;\r
-\r
- case LZX_BLOCKTYPE_UNCOMPRESSED:\r
- if ((BitSource.BaseStream.Position + (long)this_run) > (long)endinp) \r
- return (2);\r
-\r
- // memcpy(window + window_posn, inposCount, this_run);\r
- for(i=0; i<(ulong)this_run;i++)\r
- {\r
- window[window_posn+i]=BitSource.ReadByte();\r
- }\r
- window_posn += (ulong)this_run;\r
- break;\r
-\r
- default:\r
- return DECR_ILLEGALDATA; /* might as well */\r
- }\r
-\r
- }\r
- }\r
-\r
- if (togo != 0) return DECR_ILLEGALDATA;\r
-\r
- // memcpy(outpos, window + ((!window_posn) ? window_size : window_posn) - outlen, (size_t) outlen);\r
- ulong start=0;\r
- if (window_posn==0)\r
- start=(ulong)window_size;\r
- else\r
- start=(ulong)window_posn;\r
- \r
- start-=(ulong)outlen;\r
-\r
- long Pos=OutputStream.Position;\r
- for(i=0;i<(ulong)outlen;i++)\r
- { \r
- OutputStream.WriteByte(window[start+i]);\r
- }\r
- OutputStream.Seek(Pos,System.IO.SeekOrigin.Begin);\r
- \r
- /* intel E8 decoding */\r
- if ((frames_read++ < 32768) && intel_filesize != 0) \r
- {\r
- if (outlen <= 6 || (intel_started==0)) \r
- {\r
- intel_curpos += (long)outlen;\r
- }\r
- else \r
- {\r
- // UBYTE *data = outpos;\r
- long dataend = OutputStream.Position + (int)outlen - 10;\r
- long curpos = intel_curpos;\r
- long filesize = intel_filesize;\r
- long abs_off, rel_off;\r
-\r
- intel_curpos = (long)curpos + (long)outlen;\r
-\r
- while (OutputStream.Position < dataend) \r
- {\r
- if (OutputStream.ReadByte() != 0xE8) \r
- { \r
- curpos++; \r
- continue; \r
- }\r
-\r
- abs_off = (long)(OutputStream.ReadByte() | (OutputStream.ReadByte() <<8) | (OutputStream.ReadByte() <<16) | (OutputStream.ReadByte() <<24));\r
- if (abs_off < filesize)\r
- {\r
- if (abs_off >= 0)\r
- rel_off = (long)(abs_off - curpos);\r
- else \r
- rel_off = (long)abs_off + filesize;\r
- OutputStream.WriteByte((byte)(rel_off & 0x000000ff));\r
- OutputStream.WriteByte((byte)((rel_off & 0x0000ff00)>>8));\r
- OutputStream.WriteByte((byte)((rel_off & 0x00ff0000)>>16));\r
- OutputStream.WriteByte((byte)((rel_off & 0xff000000)>>24)); \r
- }\r
- curpos += 5;\r
- }\r
- }\r
- } \r
- \r
- return DECR_OK;\r
- } \r
- }\r
- #endregion\r
-}\r
projects / reactos.git / blobdiff