bio-velvet_underground 0.0.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (286) hide show
  1. checksums.yaml +7 -0
  2. data/.document +5 -0
  3. data/.gitmodules +3 -0
  4. data/.travis.yml +13 -0
  5. data/Gemfile +19 -0
  6. data/LICENSE.txt +20 -0
  7. data/README.md +53 -0
  8. data/Rakefile +51 -0
  9. data/VERSION +1 -0
  10. data/ext/bioruby.patch +60 -0
  11. data/ext/mkrf_conf.rb +50 -0
  12. data/ext/src/Makefile +125 -0
  13. data/ext/src/src/allocArray.c +305 -0
  14. data/ext/src/src/allocArray.h +86 -0
  15. data/ext/src/src/autoOpen.c +107 -0
  16. data/ext/src/src/autoOpen.h +18 -0
  17. data/ext/src/src/binarySequences.c +813 -0
  18. data/ext/src/src/binarySequences.h +125 -0
  19. data/ext/src/src/concatenatedGraph.c +233 -0
  20. data/ext/src/src/concatenatedGraph.h +30 -0
  21. data/ext/src/src/concatenatedPreGraph.c +262 -0
  22. data/ext/src/src/concatenatedPreGraph.h +29 -0
  23. data/ext/src/src/correctedGraph.c +2642 -0
  24. data/ext/src/src/correctedGraph.h +32 -0
  25. data/ext/src/src/dfib.c +509 -0
  26. data/ext/src/src/dfib.h +69 -0
  27. data/ext/src/src/dfibHeap.c +89 -0
  28. data/ext/src/src/dfibHeap.h +39 -0
  29. data/ext/src/src/dfibpriv.h +105 -0
  30. data/ext/src/src/fib.c +628 -0
  31. data/ext/src/src/fib.h +78 -0
  32. data/ext/src/src/fibHeap.c +79 -0
  33. data/ext/src/src/fibHeap.h +41 -0
  34. data/ext/src/src/fibpriv.h +110 -0
  35. data/ext/src/src/globals.h +153 -0
  36. data/ext/src/src/graph.c +3983 -0
  37. data/ext/src/src/graph.h +233 -0
  38. data/ext/src/src/graphReConstruction.c +1472 -0
  39. data/ext/src/src/graphReConstruction.h +30 -0
  40. data/ext/src/src/graphStats.c +2167 -0
  41. data/ext/src/src/graphStats.h +72 -0
  42. data/ext/src/src/kmer.c +652 -0
  43. data/ext/src/src/kmer.h +73 -0
  44. data/ext/src/src/kmerOccurenceTable.c +236 -0
  45. data/ext/src/src/kmerOccurenceTable.h +44 -0
  46. data/ext/src/src/kseq.h +223 -0
  47. data/ext/src/src/locallyCorrectedGraph.c +557 -0
  48. data/ext/src/src/locallyCorrectedGraph.h +40 -0
  49. data/ext/src/src/passageMarker.c +677 -0
  50. data/ext/src/src/passageMarker.h +137 -0
  51. data/ext/src/src/preGraph.c +1717 -0
  52. data/ext/src/src/preGraph.h +106 -0
  53. data/ext/src/src/preGraphConstruction.c +990 -0
  54. data/ext/src/src/preGraphConstruction.h +26 -0
  55. data/ext/src/src/readCoherentGraph.c +557 -0
  56. data/ext/src/src/readCoherentGraph.h +30 -0
  57. data/ext/src/src/readSet.c +1734 -0
  58. data/ext/src/src/readSet.h +67 -0
  59. data/ext/src/src/recycleBin.c +199 -0
  60. data/ext/src/src/recycleBin.h +58 -0
  61. data/ext/src/src/roadMap.c +342 -0
  62. data/ext/src/src/roadMap.h +65 -0
  63. data/ext/src/src/run.c +318 -0
  64. data/ext/src/src/run.h +52 -0
  65. data/ext/src/src/run2.c +712 -0
  66. data/ext/src/src/scaffold.c +1876 -0
  67. data/ext/src/src/scaffold.h +64 -0
  68. data/ext/src/src/shortReadPairs.c +1243 -0
  69. data/ext/src/src/shortReadPairs.h +32 -0
  70. data/ext/src/src/splay.c +259 -0
  71. data/ext/src/src/splay.h +43 -0
  72. data/ext/src/src/splayTable.c +1315 -0
  73. data/ext/src/src/splayTable.h +31 -0
  74. data/ext/src/src/tightString.c +362 -0
  75. data/ext/src/src/tightString.h +82 -0
  76. data/ext/src/src/utility.c +199 -0
  77. data/ext/src/src/utility.h +98 -0
  78. data/ext/src/third-party/zlib-1.2.3/ChangeLog +855 -0
  79. data/ext/src/third-party/zlib-1.2.3/FAQ +339 -0
  80. data/ext/src/third-party/zlib-1.2.3/INDEX +51 -0
  81. data/ext/src/third-party/zlib-1.2.3/Makefile +154 -0
  82. data/ext/src/third-party/zlib-1.2.3/Makefile.in +154 -0
  83. data/ext/src/third-party/zlib-1.2.3/README +125 -0
  84. data/ext/src/third-party/zlib-1.2.3/adler32.c +149 -0
  85. data/ext/src/third-party/zlib-1.2.3/algorithm.txt +209 -0
  86. data/ext/src/third-party/zlib-1.2.3/amiga/Makefile.pup +66 -0
  87. data/ext/src/third-party/zlib-1.2.3/amiga/Makefile.sas +65 -0
  88. data/ext/src/third-party/zlib-1.2.3/as400/bndsrc +132 -0
  89. data/ext/src/third-party/zlib-1.2.3/as400/compile.clp +123 -0
  90. data/ext/src/third-party/zlib-1.2.3/as400/readme.txt +111 -0
  91. data/ext/src/third-party/zlib-1.2.3/as400/zlib.inc +331 -0
  92. data/ext/src/third-party/zlib-1.2.3/compress.c +79 -0
  93. data/ext/src/third-party/zlib-1.2.3/configure +459 -0
  94. data/ext/src/third-party/zlib-1.2.3/contrib/README.contrib +71 -0
  95. data/ext/src/third-party/zlib-1.2.3/contrib/ada/buffer_demo.adb +106 -0
  96. data/ext/src/third-party/zlib-1.2.3/contrib/ada/mtest.adb +156 -0
  97. data/ext/src/third-party/zlib-1.2.3/contrib/ada/read.adb +156 -0
  98. data/ext/src/third-party/zlib-1.2.3/contrib/ada/readme.txt +65 -0
  99. data/ext/src/third-party/zlib-1.2.3/contrib/ada/test.adb +463 -0
  100. data/ext/src/third-party/zlib-1.2.3/contrib/ada/zlib-streams.adb +225 -0
  101. data/ext/src/third-party/zlib-1.2.3/contrib/ada/zlib-streams.ads +114 -0
  102. data/ext/src/third-party/zlib-1.2.3/contrib/ada/zlib-thin.adb +141 -0
  103. data/ext/src/third-party/zlib-1.2.3/contrib/ada/zlib-thin.ads +450 -0
  104. data/ext/src/third-party/zlib-1.2.3/contrib/ada/zlib.adb +701 -0
  105. data/ext/src/third-party/zlib-1.2.3/contrib/ada/zlib.ads +328 -0
  106. data/ext/src/third-party/zlib-1.2.3/contrib/ada/zlib.gpr +20 -0
  107. data/ext/src/third-party/zlib-1.2.3/contrib/asm586/README.586 +43 -0
  108. data/ext/src/third-party/zlib-1.2.3/contrib/asm586/match.S +364 -0
  109. data/ext/src/third-party/zlib-1.2.3/contrib/asm686/README.686 +34 -0
  110. data/ext/src/third-party/zlib-1.2.3/contrib/asm686/match.S +329 -0
  111. data/ext/src/third-party/zlib-1.2.3/contrib/blast/Makefile +8 -0
  112. data/ext/src/third-party/zlib-1.2.3/contrib/blast/README +4 -0
  113. data/ext/src/third-party/zlib-1.2.3/contrib/blast/blast.c +444 -0
  114. data/ext/src/third-party/zlib-1.2.3/contrib/blast/blast.h +71 -0
  115. data/ext/src/third-party/zlib-1.2.3/contrib/blast/test.pk +0 -0
  116. data/ext/src/third-party/zlib-1.2.3/contrib/blast/test.txt +1 -0
  117. data/ext/src/third-party/zlib-1.2.3/contrib/delphi/ZLib.pas +557 -0
  118. data/ext/src/third-party/zlib-1.2.3/contrib/delphi/ZLibConst.pas +11 -0
  119. data/ext/src/third-party/zlib-1.2.3/contrib/delphi/readme.txt +76 -0
  120. data/ext/src/third-party/zlib-1.2.3/contrib/delphi/zlibd32.mak +93 -0
  121. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib.build +33 -0
  122. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib.chm +0 -0
  123. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib.sln +21 -0
  124. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/AssemblyInfo.cs +58 -0
  125. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/ChecksumImpl.cs +202 -0
  126. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/CircularBuffer.cs +83 -0
  127. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/CodecBase.cs +198 -0
  128. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/Deflater.cs +106 -0
  129. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/DotZLib.cs +288 -0
  130. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/DotZLib.csproj +141 -0
  131. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/GZipStream.cs +301 -0
  132. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/Inflater.cs +105 -0
  133. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/DotZLib/UnitTests.cs +274 -0
  134. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/LICENSE_1_0.txt +23 -0
  135. data/ext/src/third-party/zlib-1.2.3/contrib/dotzlib/readme.txt +58 -0
  136. data/ext/src/third-party/zlib-1.2.3/contrib/infback9/README +1 -0
  137. data/ext/src/third-party/zlib-1.2.3/contrib/infback9/infback9.c +608 -0
  138. data/ext/src/third-party/zlib-1.2.3/contrib/infback9/infback9.h +37 -0
  139. data/ext/src/third-party/zlib-1.2.3/contrib/infback9/inffix9.h +107 -0
  140. data/ext/src/third-party/zlib-1.2.3/contrib/infback9/inflate9.h +47 -0
  141. data/ext/src/third-party/zlib-1.2.3/contrib/infback9/inftree9.c +323 -0
  142. data/ext/src/third-party/zlib-1.2.3/contrib/infback9/inftree9.h +55 -0
  143. data/ext/src/third-party/zlib-1.2.3/contrib/inflate86/inffas86.c +1157 -0
  144. data/ext/src/third-party/zlib-1.2.3/contrib/inflate86/inffast.S +1368 -0
  145. data/ext/src/third-party/zlib-1.2.3/contrib/iostream/test.cpp +24 -0
  146. data/ext/src/third-party/zlib-1.2.3/contrib/iostream/zfstream.cpp +329 -0
  147. data/ext/src/third-party/zlib-1.2.3/contrib/iostream/zfstream.h +128 -0
  148. data/ext/src/third-party/zlib-1.2.3/contrib/iostream2/zstream.h +307 -0
  149. data/ext/src/third-party/zlib-1.2.3/contrib/iostream2/zstream_test.cpp +25 -0
  150. data/ext/src/third-party/zlib-1.2.3/contrib/iostream3/README +35 -0
  151. data/ext/src/third-party/zlib-1.2.3/contrib/iostream3/TODO +17 -0
  152. data/ext/src/third-party/zlib-1.2.3/contrib/iostream3/test.cc +50 -0
  153. data/ext/src/third-party/zlib-1.2.3/contrib/iostream3/zfstream.cc +479 -0
  154. data/ext/src/third-party/zlib-1.2.3/contrib/iostream3/zfstream.h +466 -0
  155. data/ext/src/third-party/zlib-1.2.3/contrib/masm686/match.asm +413 -0
  156. data/ext/src/third-party/zlib-1.2.3/contrib/masmx64/bld_ml64.bat +2 -0
  157. data/ext/src/third-party/zlib-1.2.3/contrib/masmx64/gvmat64.asm +513 -0
  158. data/ext/src/third-party/zlib-1.2.3/contrib/masmx64/gvmat64.obj +0 -0
  159. data/ext/src/third-party/zlib-1.2.3/contrib/masmx64/inffas8664.c +186 -0
  160. data/ext/src/third-party/zlib-1.2.3/contrib/masmx64/inffasx64.asm +392 -0
  161. data/ext/src/third-party/zlib-1.2.3/contrib/masmx64/inffasx64.obj +0 -0
  162. data/ext/src/third-party/zlib-1.2.3/contrib/masmx64/readme.txt +28 -0
  163. data/ext/src/third-party/zlib-1.2.3/contrib/masmx86/bld_ml32.bat +2 -0
  164. data/ext/src/third-party/zlib-1.2.3/contrib/masmx86/gvmat32.asm +972 -0
  165. data/ext/src/third-party/zlib-1.2.3/contrib/masmx86/gvmat32.obj +0 -0
  166. data/ext/src/third-party/zlib-1.2.3/contrib/masmx86/gvmat32c.c +62 -0
  167. data/ext/src/third-party/zlib-1.2.3/contrib/masmx86/inffas32.asm +1083 -0
  168. data/ext/src/third-party/zlib-1.2.3/contrib/masmx86/inffas32.obj +0 -0
  169. data/ext/src/third-party/zlib-1.2.3/contrib/masmx86/mkasm.bat +3 -0
  170. data/ext/src/third-party/zlib-1.2.3/contrib/masmx86/readme.txt +21 -0
  171. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/ChangeLogUnzip +67 -0
  172. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/Makefile +25 -0
  173. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/crypt.h +132 -0
  174. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/ioapi.c +177 -0
  175. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/ioapi.h +75 -0
  176. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/iowin32.c +270 -0
  177. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/iowin32.h +21 -0
  178. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/miniunz.c +585 -0
  179. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/minizip.c +420 -0
  180. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/mztools.c +281 -0
  181. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/mztools.h +31 -0
  182. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/unzip.c +1598 -0
  183. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/unzip.h +354 -0
  184. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/zip.c +1219 -0
  185. data/ext/src/third-party/zlib-1.2.3/contrib/minizip/zip.h +235 -0
  186. data/ext/src/third-party/zlib-1.2.3/contrib/pascal/example.pas +599 -0
  187. data/ext/src/third-party/zlib-1.2.3/contrib/pascal/readme.txt +76 -0
  188. data/ext/src/third-party/zlib-1.2.3/contrib/pascal/zlibd32.mak +93 -0
  189. data/ext/src/third-party/zlib-1.2.3/contrib/pascal/zlibpas.pas +236 -0
  190. data/ext/src/third-party/zlib-1.2.3/contrib/puff/Makefile +8 -0
  191. data/ext/src/third-party/zlib-1.2.3/contrib/puff/README +63 -0
  192. data/ext/src/third-party/zlib-1.2.3/contrib/puff/puff.c +837 -0
  193. data/ext/src/third-party/zlib-1.2.3/contrib/puff/puff.h +31 -0
  194. data/ext/src/third-party/zlib-1.2.3/contrib/puff/zeros.raw +0 -0
  195. data/ext/src/third-party/zlib-1.2.3/contrib/testzlib/testzlib.c +275 -0
  196. data/ext/src/third-party/zlib-1.2.3/contrib/testzlib/testzlib.txt +10 -0
  197. data/ext/src/third-party/zlib-1.2.3/contrib/untgz/Makefile +14 -0
  198. data/ext/src/third-party/zlib-1.2.3/contrib/untgz/Makefile.msc +17 -0
  199. data/ext/src/third-party/zlib-1.2.3/contrib/untgz/untgz.c +674 -0
  200. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/readme.txt +73 -0
  201. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc7/miniunz.vcproj +126 -0
  202. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc7/minizip.vcproj +126 -0
  203. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc7/testzlib.vcproj +126 -0
  204. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc7/zlib.rc +32 -0
  205. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc7/zlibstat.vcproj +246 -0
  206. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc7/zlibvc.def +92 -0
  207. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc7/zlibvc.sln +78 -0
  208. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc7/zlibvc.vcproj +445 -0
  209. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc8/miniunz.vcproj +566 -0
  210. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc8/minizip.vcproj +563 -0
  211. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc8/testzlib.vcproj +948 -0
  212. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc8/testzlibdll.vcproj +567 -0
  213. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc8/zlib.rc +32 -0
  214. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc8/zlibstat.vcproj +870 -0
  215. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc8/zlibvc.def +92 -0
  216. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc8/zlibvc.sln +144 -0
  217. data/ext/src/third-party/zlib-1.2.3/contrib/vstudio/vc8/zlibvc.vcproj +1219 -0
  218. data/ext/src/third-party/zlib-1.2.3/crc32.c +423 -0
  219. data/ext/src/third-party/zlib-1.2.3/crc32.h +441 -0
  220. data/ext/src/third-party/zlib-1.2.3/deflate.c +1736 -0
  221. data/ext/src/third-party/zlib-1.2.3/deflate.h +331 -0
  222. data/ext/src/third-party/zlib-1.2.3/example.c +565 -0
  223. data/ext/src/third-party/zlib-1.2.3/examples/README.examples +42 -0
  224. data/ext/src/third-party/zlib-1.2.3/examples/fitblk.c +233 -0
  225. data/ext/src/third-party/zlib-1.2.3/examples/gun.c +693 -0
  226. data/ext/src/third-party/zlib-1.2.3/examples/gzappend.c +500 -0
  227. data/ext/src/third-party/zlib-1.2.3/examples/gzjoin.c +448 -0
  228. data/ext/src/third-party/zlib-1.2.3/examples/gzlog.c +413 -0
  229. data/ext/src/third-party/zlib-1.2.3/examples/gzlog.h +58 -0
  230. data/ext/src/third-party/zlib-1.2.3/examples/zlib_how.html +523 -0
  231. data/ext/src/third-party/zlib-1.2.3/examples/zpipe.c +191 -0
  232. data/ext/src/third-party/zlib-1.2.3/examples/zran.c +404 -0
  233. data/ext/src/third-party/zlib-1.2.3/gzio.c +1026 -0
  234. data/ext/src/third-party/zlib-1.2.3/infback.c +623 -0
  235. data/ext/src/third-party/zlib-1.2.3/inffast.c +318 -0
  236. data/ext/src/third-party/zlib-1.2.3/inffast.h +11 -0
  237. data/ext/src/third-party/zlib-1.2.3/inffixed.h +94 -0
  238. data/ext/src/third-party/zlib-1.2.3/inflate.c +1368 -0
  239. data/ext/src/third-party/zlib-1.2.3/inflate.h +115 -0
  240. data/ext/src/third-party/zlib-1.2.3/inftrees.c +329 -0
  241. data/ext/src/third-party/zlib-1.2.3/inftrees.h +55 -0
  242. data/ext/src/third-party/zlib-1.2.3/make_vms.com +461 -0
  243. data/ext/src/third-party/zlib-1.2.3/minigzip.c +322 -0
  244. data/ext/src/third-party/zlib-1.2.3/msdos/Makefile.bor +109 -0
  245. data/ext/src/third-party/zlib-1.2.3/msdos/Makefile.dj2 +104 -0
  246. data/ext/src/third-party/zlib-1.2.3/msdos/Makefile.emx +69 -0
  247. data/ext/src/third-party/zlib-1.2.3/msdos/Makefile.msc +106 -0
  248. data/ext/src/third-party/zlib-1.2.3/msdos/Makefile.tc +94 -0
  249. data/ext/src/third-party/zlib-1.2.3/old/Makefile.riscos +151 -0
  250. data/ext/src/third-party/zlib-1.2.3/old/README +3 -0
  251. data/ext/src/third-party/zlib-1.2.3/old/descrip.mms +48 -0
  252. data/ext/src/third-party/zlib-1.2.3/old/os2/Makefile.os2 +136 -0
  253. data/ext/src/third-party/zlib-1.2.3/old/os2/zlib.def +51 -0
  254. data/ext/src/third-party/zlib-1.2.3/old/visual-basic.txt +160 -0
  255. data/ext/src/third-party/zlib-1.2.3/old/zlib.html +971 -0
  256. data/ext/src/third-party/zlib-1.2.3/projects/README.projects +41 -0
  257. data/ext/src/third-party/zlib-1.2.3/projects/visualc6/README.txt +73 -0
  258. data/ext/src/third-party/zlib-1.2.3/projects/visualc6/example.dsp +278 -0
  259. data/ext/src/third-party/zlib-1.2.3/projects/visualc6/minigzip.dsp +278 -0
  260. data/ext/src/third-party/zlib-1.2.3/projects/visualc6/zlib.dsp +609 -0
  261. data/ext/src/third-party/zlib-1.2.3/projects/visualc6/zlib.dsw +59 -0
  262. data/ext/src/third-party/zlib-1.2.3/qnx/package.qpg +141 -0
  263. data/ext/src/third-party/zlib-1.2.3/trees.c +1219 -0
  264. data/ext/src/third-party/zlib-1.2.3/trees.h +128 -0
  265. data/ext/src/third-party/zlib-1.2.3/uncompr.c +61 -0
  266. data/ext/src/third-party/zlib-1.2.3/win32/DLL_FAQ.txt +397 -0
  267. data/ext/src/third-party/zlib-1.2.3/win32/Makefile.bor +107 -0
  268. data/ext/src/third-party/zlib-1.2.3/win32/Makefile.emx +69 -0
  269. data/ext/src/third-party/zlib-1.2.3/win32/Makefile.gcc +141 -0
  270. data/ext/src/third-party/zlib-1.2.3/win32/Makefile.msc +126 -0
  271. data/ext/src/third-party/zlib-1.2.3/win32/VisualC.txt +3 -0
  272. data/ext/src/third-party/zlib-1.2.3/win32/zlib.def +60 -0
  273. data/ext/src/third-party/zlib-1.2.3/win32/zlib1.rc +39 -0
  274. data/ext/src/third-party/zlib-1.2.3/zconf.h +332 -0
  275. data/ext/src/third-party/zlib-1.2.3/zconf.in.h +332 -0
  276. data/ext/src/third-party/zlib-1.2.3/zlib.3 +159 -0
  277. data/ext/src/third-party/zlib-1.2.3/zlib.h +1357 -0
  278. data/ext/src/third-party/zlib-1.2.3/zutil.c +318 -0
  279. data/ext/src/third-party/zlib-1.2.3/zutil.h +269 -0
  280. data/lib/bio-velvet_underground.rb +12 -0
  281. data/lib/bio-velvet_underground/external/VERSION +1 -0
  282. data/lib/bio-velvet_underground/velvet_underground.rb +72 -0
  283. data/spec/binary_sequence_store_spec.rb +27 -0
  284. data/spec/data/1/CnyUnifiedSeq +0 -0
  285. data/spec/spec_helper.rb +31 -0
  286. metadata +456 -0
@@ -0,0 +1,318 @@
1
+ /* inffast.c -- fast decoding
2
+ * Copyright (C) 1995-2004 Mark Adler
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ */
5
+
6
+ #include "zutil.h"
7
+ #include "inftrees.h"
8
+ #include "inflate.h"
9
+ #include "inffast.h"
10
+
11
+ #ifndef ASMINF
12
+
13
+ /* Allow machine dependent optimization for post-increment or pre-increment.
14
+ Based on testing to date,
15
+ Pre-increment preferred for:
16
+ - PowerPC G3 (Adler)
17
+ - MIPS R5000 (Randers-Pehrson)
18
+ Post-increment preferred for:
19
+ - none
20
+ No measurable difference:
21
+ - Pentium III (Anderson)
22
+ - M68060 (Nikl)
23
+ */
24
+ #ifdef POSTINC
25
+ # define OFF 0
26
+ # define PUP(a) *(a)++
27
+ #else
28
+ # define OFF 1
29
+ # define PUP(a) *++(a)
30
+ #endif
31
+
32
+ /*
33
+ Decode literal, length, and distance codes and write out the resulting
34
+ literal and match bytes until either not enough input or output is
35
+ available, an end-of-block is encountered, or a data error is encountered.
36
+ When large enough input and output buffers are supplied to inflate(), for
37
+ example, a 16K input buffer and a 64K output buffer, more than 95% of the
38
+ inflate execution time is spent in this routine.
39
+
40
+ Entry assumptions:
41
+
42
+ state->mode == LEN
43
+ strm->avail_in >= 6
44
+ strm->avail_out >= 258
45
+ start >= strm->avail_out
46
+ state->bits < 8
47
+
48
+ On return, state->mode is one of:
49
+
50
+ LEN -- ran out of enough output space or enough available input
51
+ TYPE -- reached end of block code, inflate() to interpret next block
52
+ BAD -- error in block data
53
+
54
+ Notes:
55
+
56
+ - The maximum input bits used by a length/distance pair is 15 bits for the
57
+ length code, 5 bits for the length extra, 15 bits for the distance code,
58
+ and 13 bits for the distance extra. This totals 48 bits, or six bytes.
59
+ Therefore if strm->avail_in >= 6, then there is enough input to avoid
60
+ checking for available input while decoding.
61
+
62
+ - The maximum bytes that a single length/distance pair can output is 258
63
+ bytes, which is the maximum length that can be coded. inflate_fast()
64
+ requires strm->avail_out >= 258 for each loop to avoid checking for
65
+ output space.
66
+ */
67
+ void inflate_fast(strm, start)
68
+ z_streamp strm;
69
+ unsigned start; /* inflate()'s starting value for strm->avail_out */
70
+ {
71
+ struct inflate_state FAR *state;
72
+ unsigned char FAR *in; /* local strm->next_in */
73
+ unsigned char FAR *last; /* while in < last, enough input available */
74
+ unsigned char FAR *out; /* local strm->next_out */
75
+ unsigned char FAR *beg; /* inflate()'s initial strm->next_out */
76
+ unsigned char FAR *end; /* while out < end, enough space available */
77
+ #ifdef INFLATE_STRICT
78
+ unsigned dmax; /* maximum distance from zlib header */
79
+ #endif
80
+ unsigned wsize; /* window size or zero if not using window */
81
+ unsigned whave; /* valid bytes in the window */
82
+ unsigned write; /* window write index */
83
+ unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */
84
+ unsigned long hold; /* local strm->hold */
85
+ unsigned bits; /* local strm->bits */
86
+ code const FAR *lcode; /* local strm->lencode */
87
+ code const FAR *dcode; /* local strm->distcode */
88
+ unsigned lmask; /* mask for first level of length codes */
89
+ unsigned dmask; /* mask for first level of distance codes */
90
+ code this; /* retrieved table entry */
91
+ unsigned op; /* code bits, operation, extra bits, or */
92
+ /* window position, window bytes to copy */
93
+ unsigned len; /* match length, unused bytes */
94
+ unsigned dist; /* match distance */
95
+ unsigned char FAR *from; /* where to copy match from */
96
+
97
+ /* copy state to local variables */
98
+ state = (struct inflate_state FAR *)strm->state;
99
+ in = strm->next_in - OFF;
100
+ last = in + (strm->avail_in - 5);
101
+ out = strm->next_out - OFF;
102
+ beg = out - (start - strm->avail_out);
103
+ end = out + (strm->avail_out - 257);
104
+ #ifdef INFLATE_STRICT
105
+ dmax = state->dmax;
106
+ #endif
107
+ wsize = state->wsize;
108
+ whave = state->whave;
109
+ write = state->write;
110
+ window = state->window;
111
+ hold = state->hold;
112
+ bits = state->bits;
113
+ lcode = state->lencode;
114
+ dcode = state->distcode;
115
+ lmask = (1U << state->lenbits) - 1;
116
+ dmask = (1U << state->distbits) - 1;
117
+
118
+ /* decode literals and length/distances until end-of-block or not enough
119
+ input data or output space */
120
+ do {
121
+ if (bits < 15) {
122
+ hold += (unsigned long)(PUP(in)) << bits;
123
+ bits += 8;
124
+ hold += (unsigned long)(PUP(in)) << bits;
125
+ bits += 8;
126
+ }
127
+ this = lcode[hold & lmask];
128
+ dolen:
129
+ op = (unsigned)(this.bits);
130
+ hold >>= op;
131
+ bits -= op;
132
+ op = (unsigned)(this.op);
133
+ if (op == 0) { /* literal */
134
+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
135
+ "inflate: literal '%c'\n" :
136
+ "inflate: literal 0x%02x\n", this.val));
137
+ PUP(out) = (unsigned char)(this.val);
138
+ }
139
+ else if (op & 16) { /* length base */
140
+ len = (unsigned)(this.val);
141
+ op &= 15; /* number of extra bits */
142
+ if (op) {
143
+ if (bits < op) {
144
+ hold += (unsigned long)(PUP(in)) << bits;
145
+ bits += 8;
146
+ }
147
+ len += (unsigned)hold & ((1U << op) - 1);
148
+ hold >>= op;
149
+ bits -= op;
150
+ }
151
+ Tracevv((stderr, "inflate: length %u\n", len));
152
+ if (bits < 15) {
153
+ hold += (unsigned long)(PUP(in)) << bits;
154
+ bits += 8;
155
+ hold += (unsigned long)(PUP(in)) << bits;
156
+ bits += 8;
157
+ }
158
+ this = dcode[hold & dmask];
159
+ dodist:
160
+ op = (unsigned)(this.bits);
161
+ hold >>= op;
162
+ bits -= op;
163
+ op = (unsigned)(this.op);
164
+ if (op & 16) { /* distance base */
165
+ dist = (unsigned)(this.val);
166
+ op &= 15; /* number of extra bits */
167
+ if (bits < op) {
168
+ hold += (unsigned long)(PUP(in)) << bits;
169
+ bits += 8;
170
+ if (bits < op) {
171
+ hold += (unsigned long)(PUP(in)) << bits;
172
+ bits += 8;
173
+ }
174
+ }
175
+ dist += (unsigned)hold & ((1U << op) - 1);
176
+ #ifdef INFLATE_STRICT
177
+ if (dist > dmax) {
178
+ strm->msg = (char *)"invalid distance too far back";
179
+ state->mode = BAD;
180
+ break;
181
+ }
182
+ #endif
183
+ hold >>= op;
184
+ bits -= op;
185
+ Tracevv((stderr, "inflate: distance %u\n", dist));
186
+ op = (unsigned)(out - beg); /* max distance in output */
187
+ if (dist > op) { /* see if copy from window */
188
+ op = dist - op; /* distance back in window */
189
+ if (op > whave) {
190
+ strm->msg = (char *)"invalid distance too far back";
191
+ state->mode = BAD;
192
+ break;
193
+ }
194
+ from = window - OFF;
195
+ if (write == 0) { /* very common case */
196
+ from += wsize - op;
197
+ if (op < len) { /* some from window */
198
+ len -= op;
199
+ do {
200
+ PUP(out) = PUP(from);
201
+ } while (--op);
202
+ from = out - dist; /* rest from output */
203
+ }
204
+ }
205
+ else if (write < op) { /* wrap around window */
206
+ from += wsize + write - op;
207
+ op -= write;
208
+ if (op < len) { /* some from end of window */
209
+ len -= op;
210
+ do {
211
+ PUP(out) = PUP(from);
212
+ } while (--op);
213
+ from = window - OFF;
214
+ if (write < len) { /* some from start of window */
215
+ op = write;
216
+ len -= op;
217
+ do {
218
+ PUP(out) = PUP(from);
219
+ } while (--op);
220
+ from = out - dist; /* rest from output */
221
+ }
222
+ }
223
+ }
224
+ else { /* contiguous in window */
225
+ from += write - op;
226
+ if (op < len) { /* some from window */
227
+ len -= op;
228
+ do {
229
+ PUP(out) = PUP(from);
230
+ } while (--op);
231
+ from = out - dist; /* rest from output */
232
+ }
233
+ }
234
+ while (len > 2) {
235
+ PUP(out) = PUP(from);
236
+ PUP(out) = PUP(from);
237
+ PUP(out) = PUP(from);
238
+ len -= 3;
239
+ }
240
+ if (len) {
241
+ PUP(out) = PUP(from);
242
+ if (len > 1)
243
+ PUP(out) = PUP(from);
244
+ }
245
+ }
246
+ else {
247
+ from = out - dist; /* copy direct from output */
248
+ do { /* minimum length is three */
249
+ PUP(out) = PUP(from);
250
+ PUP(out) = PUP(from);
251
+ PUP(out) = PUP(from);
252
+ len -= 3;
253
+ } while (len > 2);
254
+ if (len) {
255
+ PUP(out) = PUP(from);
256
+ if (len > 1)
257
+ PUP(out) = PUP(from);
258
+ }
259
+ }
260
+ }
261
+ else if ((op & 64) == 0) { /* 2nd level distance code */
262
+ this = dcode[this.val + (hold & ((1U << op) - 1))];
263
+ goto dodist;
264
+ }
265
+ else {
266
+ strm->msg = (char *)"invalid distance code";
267
+ state->mode = BAD;
268
+ break;
269
+ }
270
+ }
271
+ else if ((op & 64) == 0) { /* 2nd level length code */
272
+ this = lcode[this.val + (hold & ((1U << op) - 1))];
273
+ goto dolen;
274
+ }
275
+ else if (op & 32) { /* end-of-block */
276
+ Tracevv((stderr, "inflate: end of block\n"));
277
+ state->mode = TYPE;
278
+ break;
279
+ }
280
+ else {
281
+ strm->msg = (char *)"invalid literal/length code";
282
+ state->mode = BAD;
283
+ break;
284
+ }
285
+ } while (in < last && out < end);
286
+
287
+ /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
288
+ len = bits >> 3;
289
+ in -= len;
290
+ bits -= len << 3;
291
+ hold &= (1U << bits) - 1;
292
+
293
+ /* update state and return */
294
+ strm->next_in = in + OFF;
295
+ strm->next_out = out + OFF;
296
+ strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
297
+ strm->avail_out = (unsigned)(out < end ?
298
+ 257 + (end - out) : 257 - (out - end));
299
+ state->hold = hold;
300
+ state->bits = bits;
301
+ return;
302
+ }
303
+
304
+ /*
305
+ inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
306
+ - Using bit fields for code structure
307
+ - Different op definition to avoid & for extra bits (do & for table bits)
308
+ - Three separate decoding do-loops for direct, window, and write == 0
309
+ - Special case for distance > 1 copies to do overlapped load and store copy
310
+ - Explicit branch predictions (based on measured branch probabilities)
311
+ - Deferring match copy and interspersed it with decoding subsequent codes
312
+ - Swapping literal/length else
313
+ - Swapping window/direct else
314
+ - Larger unrolled copy loops (three is about right)
315
+ - Moving len -= 3 statement into middle of loop
316
+ */
317
+
318
+ #endif /* !ASMINF */
@@ -0,0 +1,11 @@
1
+ /* inffast.h -- header to use inffast.c
2
+ * Copyright (C) 1995-2003 Mark Adler
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ */
5
+
6
+ /* WARNING: this file should *not* be used by applications. It is
7
+ part of the implementation of the compression library and is
8
+ subject to change. Applications should only use zlib.h.
9
+ */
10
+
11
+ void inflate_fast OF((z_streamp strm, unsigned start));
@@ -0,0 +1,94 @@
1
+ /* inffixed.h -- table for decoding fixed codes
2
+ * Generated automatically by makefixed().
3
+ */
4
+
5
+ /* WARNING: this file should *not* be used by applications. It
6
+ is part of the implementation of the compression library and
7
+ is subject to change. Applications should only use zlib.h.
8
+ */
9
+
10
+ static const code lenfix[512] = {
11
+ {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
12
+ {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
13
+ {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
14
+ {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
15
+ {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
16
+ {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
17
+ {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
18
+ {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
19
+ {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
20
+ {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
21
+ {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
22
+ {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
23
+ {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
24
+ {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
25
+ {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
26
+ {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
27
+ {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
28
+ {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
29
+ {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
30
+ {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
31
+ {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
32
+ {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
33
+ {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
34
+ {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
35
+ {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
36
+ {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
37
+ {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
38
+ {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
39
+ {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
40
+ {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
41
+ {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
42
+ {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
43
+ {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
44
+ {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
45
+ {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
46
+ {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
47
+ {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
48
+ {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
49
+ {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
50
+ {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
51
+ {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
52
+ {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
53
+ {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
54
+ {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
55
+ {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
56
+ {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
57
+ {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
58
+ {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
59
+ {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
60
+ {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
61
+ {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
62
+ {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
63
+ {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
64
+ {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
65
+ {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
66
+ {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
67
+ {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
68
+ {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
69
+ {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
70
+ {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
71
+ {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
72
+ {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
73
+ {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
74
+ {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
75
+ {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
76
+ {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
77
+ {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
78
+ {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
79
+ {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
80
+ {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
81
+ {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
82
+ {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
83
+ {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
84
+ {0,9,255}
85
+ };
86
+
87
+ static const code distfix[32] = {
88
+ {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
89
+ {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
90
+ {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
91
+ {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
92
+ {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
93
+ {22,5,193},{64,5,0}
94
+ };
@@ -0,0 +1,1368 @@
1
+ /* inflate.c -- zlib decompression
2
+ * Copyright (C) 1995-2005 Mark Adler
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ */
5
+
6
+ /*
7
+ * Change history:
8
+ *
9
+ * 1.2.beta0 24 Nov 2002
10
+ * - First version -- complete rewrite of inflate to simplify code, avoid
11
+ * creation of window when not needed, minimize use of window when it is
12
+ * needed, make inffast.c even faster, implement gzip decoding, and to
13
+ * improve code readability and style over the previous zlib inflate code
14
+ *
15
+ * 1.2.beta1 25 Nov 2002
16
+ * - Use pointers for available input and output checking in inffast.c
17
+ * - Remove input and output counters in inffast.c
18
+ * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
19
+ * - Remove unnecessary second byte pull from length extra in inffast.c
20
+ * - Unroll direct copy to three copies per loop in inffast.c
21
+ *
22
+ * 1.2.beta2 4 Dec 2002
23
+ * - Change external routine names to reduce potential conflicts
24
+ * - Correct filename to inffixed.h for fixed tables in inflate.c
25
+ * - Make hbuf[] unsigned char to match parameter type in inflate.c
26
+ * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
27
+ * to avoid negation problem on Alphas (64 bit) in inflate.c
28
+ *
29
+ * 1.2.beta3 22 Dec 2002
30
+ * - Add comments on state->bits assertion in inffast.c
31
+ * - Add comments on op field in inftrees.h
32
+ * - Fix bug in reuse of allocated window after inflateReset()
33
+ * - Remove bit fields--back to byte structure for speed
34
+ * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
35
+ * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
36
+ * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
37
+ * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
38
+ * - Use local copies of stream next and avail values, as well as local bit
39
+ * buffer and bit count in inflate()--for speed when inflate_fast() not used
40
+ *
41
+ * 1.2.beta4 1 Jan 2003
42
+ * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
43
+ * - Move a comment on output buffer sizes from inffast.c to inflate.c
44
+ * - Add comments in inffast.c to introduce the inflate_fast() routine
45
+ * - Rearrange window copies in inflate_fast() for speed and simplification
46
+ * - Unroll last copy for window match in inflate_fast()
47
+ * - Use local copies of window variables in inflate_fast() for speed
48
+ * - Pull out common write == 0 case for speed in inflate_fast()
49
+ * - Make op and len in inflate_fast() unsigned for consistency
50
+ * - Add FAR to lcode and dcode declarations in inflate_fast()
51
+ * - Simplified bad distance check in inflate_fast()
52
+ * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
53
+ * source file infback.c to provide a call-back interface to inflate for
54
+ * programs like gzip and unzip -- uses window as output buffer to avoid
55
+ * window copying
56
+ *
57
+ * 1.2.beta5 1 Jan 2003
58
+ * - Improved inflateBack() interface to allow the caller to provide initial
59
+ * input in strm.
60
+ * - Fixed stored blocks bug in inflateBack()
61
+ *
62
+ * 1.2.beta6 4 Jan 2003
63
+ * - Added comments in inffast.c on effectiveness of POSTINC
64
+ * - Typecasting all around to reduce compiler warnings
65
+ * - Changed loops from while (1) or do {} while (1) to for (;;), again to
66
+ * make compilers happy
67
+ * - Changed type of window in inflateBackInit() to unsigned char *
68
+ *
69
+ * 1.2.beta7 27 Jan 2003
70
+ * - Changed many types to unsigned or unsigned short to avoid warnings
71
+ * - Added inflateCopy() function
72
+ *
73
+ * 1.2.0 9 Mar 2003
74
+ * - Changed inflateBack() interface to provide separate opaque descriptors
75
+ * for the in() and out() functions
76
+ * - Changed inflateBack() argument and in_func typedef to swap the length
77
+ * and buffer address return values for the input function
78
+ * - Check next_in and next_out for Z_NULL on entry to inflate()
79
+ *
80
+ * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
81
+ */
82
+
83
+ #include "zutil.h"
84
+ #include "inftrees.h"
85
+ #include "inflate.h"
86
+ #include "inffast.h"
87
+
88
+ #ifdef MAKEFIXED
89
+ # ifndef BUILDFIXED
90
+ # define BUILDFIXED
91
+ # endif
92
+ #endif
93
+
94
+ /* function prototypes */
95
+ local void fixedtables OF((struct inflate_state FAR *state));
96
+ local int updatewindow OF((z_streamp strm, unsigned out));
97
+ #ifdef BUILDFIXED
98
+ void makefixed OF((void));
99
+ #endif
100
+ local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
101
+ unsigned len));
102
+
103
+ int ZEXPORT inflateReset(strm)
104
+ z_streamp strm;
105
+ {
106
+ struct inflate_state FAR *state;
107
+
108
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
109
+ state = (struct inflate_state FAR *)strm->state;
110
+ strm->total_in = strm->total_out = state->total = 0;
111
+ strm->msg = Z_NULL;
112
+ strm->adler = 1; /* to support ill-conceived Java test suite */
113
+ state->mode = HEAD;
114
+ state->last = 0;
115
+ state->havedict = 0;
116
+ state->dmax = 32768U;
117
+ state->head = Z_NULL;
118
+ state->wsize = 0;
119
+ state->whave = 0;
120
+ state->write = 0;
121
+ state->hold = 0;
122
+ state->bits = 0;
123
+ state->lencode = state->distcode = state->next = state->codes;
124
+ Tracev((stderr, "inflate: reset\n"));
125
+ return Z_OK;
126
+ }
127
+
128
+ int ZEXPORT inflatePrime(strm, bits, value)
129
+ z_streamp strm;
130
+ int bits;
131
+ int value;
132
+ {
133
+ struct inflate_state FAR *state;
134
+
135
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
136
+ state = (struct inflate_state FAR *)strm->state;
137
+ if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
138
+ value &= (1L << bits) - 1;
139
+ state->hold += value << state->bits;
140
+ state->bits += bits;
141
+ return Z_OK;
142
+ }
143
+
144
+ int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
145
+ z_streamp strm;
146
+ int windowBits;
147
+ const char *version;
148
+ int stream_size;
149
+ {
150
+ struct inflate_state FAR *state;
151
+
152
+ if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
153
+ stream_size != (int)(sizeof(z_stream)))
154
+ return Z_VERSION_ERROR;
155
+ if (strm == Z_NULL) return Z_STREAM_ERROR;
156
+ strm->msg = Z_NULL; /* in case we return an error */
157
+ if (strm->zalloc == (alloc_func)0) {
158
+ strm->zalloc = zcalloc;
159
+ strm->opaque = (voidpf)0;
160
+ }
161
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
162
+ state = (struct inflate_state FAR *)
163
+ ZALLOC(strm, 1, sizeof(struct inflate_state));
164
+ if (state == Z_NULL) return Z_MEM_ERROR;
165
+ Tracev((stderr, "inflate: allocated\n"));
166
+ strm->state = (struct internal_state FAR *)state;
167
+ if (windowBits < 0) {
168
+ state->wrap = 0;
169
+ windowBits = -windowBits;
170
+ }
171
+ else {
172
+ state->wrap = (windowBits >> 4) + 1;
173
+ #ifdef GUNZIP
174
+ if (windowBits < 48) windowBits &= 15;
175
+ #endif
176
+ }
177
+ if (windowBits < 8 || windowBits > 15) {
178
+ ZFREE(strm, state);
179
+ strm->state = Z_NULL;
180
+ return Z_STREAM_ERROR;
181
+ }
182
+ state->wbits = (unsigned)windowBits;
183
+ state->window = Z_NULL;
184
+ return inflateReset(strm);
185
+ }
186
+
187
+ int ZEXPORT inflateInit_(strm, version, stream_size)
188
+ z_streamp strm;
189
+ const char *version;
190
+ int stream_size;
191
+ {
192
+ return inflateInit2_(strm, DEF_WBITS, version, stream_size);
193
+ }
194
+
195
+ /*
196
+ Return state with length and distance decoding tables and index sizes set to
197
+ fixed code decoding. Normally this returns fixed tables from inffixed.h.
198
+ If BUILDFIXED is defined, then instead this routine builds the tables the
199
+ first time it's called, and returns those tables the first time and
200
+ thereafter. This reduces the size of the code by about 2K bytes, in
201
+ exchange for a little execution time. However, BUILDFIXED should not be
202
+ used for threaded applications, since the rewriting of the tables and virgin
203
+ may not be thread-safe.
204
+ */
205
+ local void fixedtables(state)
206
+ struct inflate_state FAR *state;
207
+ {
208
+ #ifdef BUILDFIXED
209
+ static int virgin = 1;
210
+ static code *lenfix, *distfix;
211
+ static code fixed[544];
212
+
213
+ /* build fixed huffman tables if first call (may not be thread safe) */
214
+ if (virgin) {
215
+ unsigned sym, bits;
216
+ static code *next;
217
+
218
+ /* literal/length table */
219
+ sym = 0;
220
+ while (sym < 144) state->lens[sym++] = 8;
221
+ while (sym < 256) state->lens[sym++] = 9;
222
+ while (sym < 280) state->lens[sym++] = 7;
223
+ while (sym < 288) state->lens[sym++] = 8;
224
+ next = fixed;
225
+ lenfix = next;
226
+ bits = 9;
227
+ inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
228
+
229
+ /* distance table */
230
+ sym = 0;
231
+ while (sym < 32) state->lens[sym++] = 5;
232
+ distfix = next;
233
+ bits = 5;
234
+ inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
235
+
236
+ /* do this just once */
237
+ virgin = 0;
238
+ }
239
+ #else /* !BUILDFIXED */
240
+ # include "inffixed.h"
241
+ #endif /* BUILDFIXED */
242
+ state->lencode = lenfix;
243
+ state->lenbits = 9;
244
+ state->distcode = distfix;
245
+ state->distbits = 5;
246
+ }
247
+
248
+ #ifdef MAKEFIXED
249
+ #include <stdio.h>
250
+
251
+ /*
252
+ Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also
253
+ defines BUILDFIXED, so the tables are built on the fly. makefixed() writes
254
+ those tables to stdout, which would be piped to inffixed.h. A small program
255
+ can simply call makefixed to do this:
256
+
257
+ void makefixed(void);
258
+
259
+ int main(void)
260
+ {
261
+ makefixed();
262
+ return 0;
263
+ }
264
+
265
+ Then that can be linked with zlib built with MAKEFIXED defined and run:
266
+
267
+ a.out > inffixed.h
268
+ */
269
+ void makefixed()
270
+ {
271
+ unsigned low, size;
272
+ struct inflate_state state;
273
+
274
+ fixedtables(&state);
275
+ puts(" /* inffixed.h -- table for decoding fixed codes");
276
+ puts(" * Generated automatically by makefixed().");
277
+ puts(" */");
278
+ puts("");
279
+ puts(" /* WARNING: this file should *not* be used by applications.");
280
+ puts(" It is part of the implementation of this library and is");
281
+ puts(" subject to change. Applications should only use zlib.h.");
282
+ puts(" */");
283
+ puts("");
284
+ size = 1U << 9;
285
+ printf(" static const code lenfix[%u] = {", size);
286
+ low = 0;
287
+ for (;;) {
288
+ if ((low % 7) == 0) printf("\n ");
289
+ printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
290
+ state.lencode[low].val);
291
+ if (++low == size) break;
292
+ putchar(',');
293
+ }
294
+ puts("\n };");
295
+ size = 1U << 5;
296
+ printf("\n static const code distfix[%u] = {", size);
297
+ low = 0;
298
+ for (;;) {
299
+ if ((low % 6) == 0) printf("\n ");
300
+ printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
301
+ state.distcode[low].val);
302
+ if (++low == size) break;
303
+ putchar(',');
304
+ }
305
+ puts("\n };");
306
+ }
307
+ #endif /* MAKEFIXED */
308
+
309
+ /*
310
+ Update the window with the last wsize (normally 32K) bytes written before
311
+ returning. If window does not exist yet, create it. This is only called
312
+ when a window is already in use, or when output has been written during this
313
+ inflate call, but the end of the deflate stream has not been reached yet.
314
+ It is also called to create a window for dictionary data when a dictionary
315
+ is loaded.
316
+
317
+ Providing output buffers larger than 32K to inflate() should provide a speed
318
+ advantage, since only the last 32K of output is copied to the sliding window
319
+ upon return from inflate(), and since all distances after the first 32K of
320
+ output will fall in the output data, making match copies simpler and faster.
321
+ The advantage may be dependent on the size of the processor's data caches.
322
+ */
323
+ local int updatewindow(strm, out)
324
+ z_streamp strm;
325
+ unsigned out;
326
+ {
327
+ struct inflate_state FAR *state;
328
+ unsigned copy, dist;
329
+
330
+ state = (struct inflate_state FAR *)strm->state;
331
+
332
+ /* if it hasn't been done already, allocate space for the window */
333
+ if (state->window == Z_NULL) {
334
+ state->window = (unsigned char FAR *)
335
+ ZALLOC(strm, 1U << state->wbits,
336
+ sizeof(unsigned char));
337
+ if (state->window == Z_NULL) return 1;
338
+ }
339
+
340
+ /* if window not in use yet, initialize */
341
+ if (state->wsize == 0) {
342
+ state->wsize = 1U << state->wbits;
343
+ state->write = 0;
344
+ state->whave = 0;
345
+ }
346
+
347
+ /* copy state->wsize or less output bytes into the circular window */
348
+ copy = out - strm->avail_out;
349
+ if (copy >= state->wsize) {
350
+ zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
351
+ state->write = 0;
352
+ state->whave = state->wsize;
353
+ }
354
+ else {
355
+ dist = state->wsize - state->write;
356
+ if (dist > copy) dist = copy;
357
+ zmemcpy(state->window + state->write, strm->next_out - copy, dist);
358
+ copy -= dist;
359
+ if (copy) {
360
+ zmemcpy(state->window, strm->next_out - copy, copy);
361
+ state->write = copy;
362
+ state->whave = state->wsize;
363
+ }
364
+ else {
365
+ state->write += dist;
366
+ if (state->write == state->wsize) state->write = 0;
367
+ if (state->whave < state->wsize) state->whave += dist;
368
+ }
369
+ }
370
+ return 0;
371
+ }
372
+
373
+ /* Macros for inflate(): */
374
+
375
+ /* check function to use adler32() for zlib or crc32() for gzip */
376
+ #ifdef GUNZIP
377
+ # define UPDATE(check, buf, len) \
378
+ (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
379
+ #else
380
+ # define UPDATE(check, buf, len) adler32(check, buf, len)
381
+ #endif
382
+
383
+ /* check macros for header crc */
384
+ #ifdef GUNZIP
385
+ # define CRC2(check, word) \
386
+ do { \
387
+ hbuf[0] = (unsigned char)(word); \
388
+ hbuf[1] = (unsigned char)((word) >> 8); \
389
+ check = crc32(check, hbuf, 2); \
390
+ } while (0)
391
+
392
+ # define CRC4(check, word) \
393
+ do { \
394
+ hbuf[0] = (unsigned char)(word); \
395
+ hbuf[1] = (unsigned char)((word) >> 8); \
396
+ hbuf[2] = (unsigned char)((word) >> 16); \
397
+ hbuf[3] = (unsigned char)((word) >> 24); \
398
+ check = crc32(check, hbuf, 4); \
399
+ } while (0)
400
+ #endif
401
+
402
+ /* Load registers with state in inflate() for speed */
403
+ #define LOAD() \
404
+ do { \
405
+ put = strm->next_out; \
406
+ left = strm->avail_out; \
407
+ next = strm->next_in; \
408
+ have = strm->avail_in; \
409
+ hold = state->hold; \
410
+ bits = state->bits; \
411
+ } while (0)
412
+
413
+ /* Restore state from registers in inflate() */
414
+ #define RESTORE() \
415
+ do { \
416
+ strm->next_out = put; \
417
+ strm->avail_out = left; \
418
+ strm->next_in = next; \
419
+ strm->avail_in = have; \
420
+ state->hold = hold; \
421
+ state->bits = bits; \
422
+ } while (0)
423
+
424
+ /* Clear the input bit accumulator */
425
+ #define INITBITS() \
426
+ do { \
427
+ hold = 0; \
428
+ bits = 0; \
429
+ } while (0)
430
+
431
+ /* Get a byte of input into the bit accumulator, or return from inflate()
432
+ if there is no input available. */
433
+ #define PULLBYTE() \
434
+ do { \
435
+ if (have == 0) goto inf_leave; \
436
+ have--; \
437
+ hold += (unsigned long)(*next++) << bits; \
438
+ bits += 8; \
439
+ } while (0)
440
+
441
+ /* Assure that there are at least n bits in the bit accumulator. If there is
442
+ not enough available input to do that, then return from inflate(). */
443
+ #define NEEDBITS(n) \
444
+ do { \
445
+ while (bits < (unsigned)(n)) \
446
+ PULLBYTE(); \
447
+ } while (0)
448
+
449
+ /* Return the low n bits of the bit accumulator (n < 16) */
450
+ #define BITS(n) \
451
+ ((unsigned)hold & ((1U << (n)) - 1))
452
+
453
+ /* Remove n bits from the bit accumulator */
454
+ #define DROPBITS(n) \
455
+ do { \
456
+ hold >>= (n); \
457
+ bits -= (unsigned)(n); \
458
+ } while (0)
459
+
460
+ /* Remove zero to seven bits as needed to go to a byte boundary */
461
+ #define BYTEBITS() \
462
+ do { \
463
+ hold >>= bits & 7; \
464
+ bits -= bits & 7; \
465
+ } while (0)
466
+
467
+ /* Reverse the bytes in a 32-bit value */
468
+ #define REVERSE(q) \
469
+ ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
470
+ (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
471
+
472
+ /*
473
+ inflate() uses a state machine to process as much input data and generate as
474
+ much output data as possible before returning. The state machine is
475
+ structured roughly as follows:
476
+
477
+ for (;;) switch (state) {
478
+ ...
479
+ case STATEn:
480
+ if (not enough input data or output space to make progress)
481
+ return;
482
+ ... make progress ...
483
+ state = STATEm;
484
+ break;
485
+ ...
486
+ }
487
+
488
+ so when inflate() is called again, the same case is attempted again, and
489
+ if the appropriate resources are provided, the machine proceeds to the
490
+ next state. The NEEDBITS() macro is usually the way the state evaluates
491
+ whether it can proceed or should return. NEEDBITS() does the return if
492
+ the requested bits are not available. The typical use of the BITS macros
493
+ is:
494
+
495
+ NEEDBITS(n);
496
+ ... do something with BITS(n) ...
497
+ DROPBITS(n);
498
+
499
+ where NEEDBITS(n) either returns from inflate() if there isn't enough
500
+ input left to load n bits into the accumulator, or it continues. BITS(n)
501
+ gives the low n bits in the accumulator. When done, DROPBITS(n) drops
502
+ the low n bits off the accumulator. INITBITS() clears the accumulator
503
+ and sets the number of available bits to zero. BYTEBITS() discards just
504
+ enough bits to put the accumulator on a byte boundary. After BYTEBITS()
505
+ and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
506
+
507
+ NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
508
+ if there is no input available. The decoding of variable length codes uses
509
+ PULLBYTE() directly in order to pull just enough bytes to decode the next
510
+ code, and no more.
511
+
512
+ Some states loop until they get enough input, making sure that enough
513
+ state information is maintained to continue the loop where it left off
514
+ if NEEDBITS() returns in the loop. For example, want, need, and keep
515
+ would all have to actually be part of the saved state in case NEEDBITS()
516
+ returns:
517
+
518
+ case STATEw:
519
+ while (want < need) {
520
+ NEEDBITS(n);
521
+ keep[want++] = BITS(n);
522
+ DROPBITS(n);
523
+ }
524
+ state = STATEx;
525
+ case STATEx:
526
+
527
+ As shown above, if the next state is also the next case, then the break
528
+ is omitted.
529
+
530
+ A state may also return if there is not enough output space available to
531
+ complete that state. Those states are copying stored data, writing a
532
+ literal byte, and copying a matching string.
533
+
534
+ When returning, a "goto inf_leave" is used to update the total counters,
535
+ update the check value, and determine whether any progress has been made
536
+ during that inflate() call in order to return the proper return code.
537
+ Progress is defined as a change in either strm->avail_in or strm->avail_out.
538
+ When there is a window, goto inf_leave will update the window with the last
539
+ output written. If a goto inf_leave occurs in the middle of decompression
540
+ and there is no window currently, goto inf_leave will create one and copy
541
+ output to the window for the next call of inflate().
542
+
543
+ In this implementation, the flush parameter of inflate() only affects the
544
+ return code (per zlib.h). inflate() always writes as much as possible to
545
+ strm->next_out, given the space available and the provided input--the effect
546
+ documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
547
+ the allocation of and copying into a sliding window until necessary, which
548
+ provides the effect documented in zlib.h for Z_FINISH when the entire input
549
+ stream available. So the only thing the flush parameter actually does is:
550
+ when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
551
+ will return Z_BUF_ERROR if it has not reached the end of the stream.
552
+ */
553
+
554
+ int ZEXPORT inflate(strm, flush)
555
+ z_streamp strm;
556
+ int flush;
557
+ {
558
+ struct inflate_state FAR *state;
559
+ unsigned char FAR *next; /* next input */
560
+ unsigned char FAR *put; /* next output */
561
+ unsigned have, left; /* available input and output */
562
+ unsigned long hold; /* bit buffer */
563
+ unsigned bits; /* bits in bit buffer */
564
+ unsigned in, out; /* save starting available input and output */
565
+ unsigned copy; /* number of stored or match bytes to copy */
566
+ unsigned char FAR *from; /* where to copy match bytes from */
567
+ code this; /* current decoding table entry */
568
+ code last; /* parent table entry */
569
+ unsigned len; /* length to copy for repeats, bits to drop */
570
+ int ret; /* return code */
571
+ #ifdef GUNZIP
572
+ unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
573
+ #endif
574
+ static const unsigned short order[19] = /* permutation of code lengths */
575
+ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
576
+
577
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
578
+ (strm->next_in == Z_NULL && strm->avail_in != 0))
579
+ return Z_STREAM_ERROR;
580
+
581
+ state = (struct inflate_state FAR *)strm->state;
582
+ if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
583
+ LOAD();
584
+ in = have;
585
+ out = left;
586
+ ret = Z_OK;
587
+ for (;;)
588
+ switch (state->mode) {
589
+ case HEAD:
590
+ if (state->wrap == 0) {
591
+ state->mode = TYPEDO;
592
+ break;
593
+ }
594
+ NEEDBITS(16);
595
+ #ifdef GUNZIP
596
+ if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
597
+ state->check = crc32(0L, Z_NULL, 0);
598
+ CRC2(state->check, hold);
599
+ INITBITS();
600
+ state->mode = FLAGS;
601
+ break;
602
+ }
603
+ state->flags = 0; /* expect zlib header */
604
+ if (state->head != Z_NULL)
605
+ state->head->done = -1;
606
+ if (!(state->wrap & 1) || /* check if zlib header allowed */
607
+ #else
608
+ if (
609
+ #endif
610
+ ((BITS(8) << 8) + (hold >> 8)) % 31) {
611
+ strm->msg = (char *)"incorrect header check";
612
+ state->mode = BAD;
613
+ break;
614
+ }
615
+ if (BITS(4) != Z_DEFLATED) {
616
+ strm->msg = (char *)"unknown compression method";
617
+ state->mode = BAD;
618
+ break;
619
+ }
620
+ DROPBITS(4);
621
+ len = BITS(4) + 8;
622
+ if (len > state->wbits) {
623
+ strm->msg = (char *)"invalid window size";
624
+ state->mode = BAD;
625
+ break;
626
+ }
627
+ state->dmax = 1U << len;
628
+ Tracev((stderr, "inflate: zlib header ok\n"));
629
+ strm->adler = state->check = adler32(0L, Z_NULL, 0);
630
+ state->mode = hold & 0x200 ? DICTID : TYPE;
631
+ INITBITS();
632
+ break;
633
+ #ifdef GUNZIP
634
+ case FLAGS:
635
+ NEEDBITS(16);
636
+ state->flags = (int)(hold);
637
+ if ((state->flags & 0xff) != Z_DEFLATED) {
638
+ strm->msg = (char *)"unknown compression method";
639
+ state->mode = BAD;
640
+ break;
641
+ }
642
+ if (state->flags & 0xe000) {
643
+ strm->msg = (char *)"unknown header flags set";
644
+ state->mode = BAD;
645
+ break;
646
+ }
647
+ if (state->head != Z_NULL)
648
+ state->head->text = (int)((hold >> 8) & 1);
649
+ if (state->flags & 0x0200) CRC2(state->check, hold);
650
+ INITBITS();
651
+ state->mode = TIME;
652
+ case TIME:
653
+ NEEDBITS(32);
654
+ if (state->head != Z_NULL)
655
+ state->head->time = hold;
656
+ if (state->flags & 0x0200) CRC4(state->check, hold);
657
+ INITBITS();
658
+ state->mode = OS;
659
+ case OS:
660
+ NEEDBITS(16);
661
+ if (state->head != Z_NULL) {
662
+ state->head->xflags = (int)(hold & 0xff);
663
+ state->head->os = (int)(hold >> 8);
664
+ }
665
+ if (state->flags & 0x0200) CRC2(state->check, hold);
666
+ INITBITS();
667
+ state->mode = EXLEN;
668
+ case EXLEN:
669
+ if (state->flags & 0x0400) {
670
+ NEEDBITS(16);
671
+ state->length = (unsigned)(hold);
672
+ if (state->head != Z_NULL)
673
+ state->head->extra_len = (unsigned)hold;
674
+ if (state->flags & 0x0200) CRC2(state->check, hold);
675
+ INITBITS();
676
+ }
677
+ else if (state->head != Z_NULL)
678
+ state->head->extra = Z_NULL;
679
+ state->mode = EXTRA;
680
+ case EXTRA:
681
+ if (state->flags & 0x0400) {
682
+ copy = state->length;
683
+ if (copy > have) copy = have;
684
+ if (copy) {
685
+ if (state->head != Z_NULL &&
686
+ state->head->extra != Z_NULL) {
687
+ len = state->head->extra_len - state->length;
688
+ zmemcpy(state->head->extra + len, next,
689
+ len + copy > state->head->extra_max ?
690
+ state->head->extra_max - len : copy);
691
+ }
692
+ if (state->flags & 0x0200)
693
+ state->check = crc32(state->check, next, copy);
694
+ have -= copy;
695
+ next += copy;
696
+ state->length -= copy;
697
+ }
698
+ if (state->length) goto inf_leave;
699
+ }
700
+ state->length = 0;
701
+ state->mode = NAME;
702
+ case NAME:
703
+ if (state->flags & 0x0800) {
704
+ if (have == 0) goto inf_leave;
705
+ copy = 0;
706
+ do {
707
+ len = (unsigned)(next[copy++]);
708
+ if (state->head != Z_NULL &&
709
+ state->head->name != Z_NULL &&
710
+ state->length < state->head->name_max)
711
+ state->head->name[state->length++] = len;
712
+ } while (len && copy < have);
713
+ if (state->flags & 0x0200)
714
+ state->check = crc32(state->check, next, copy);
715
+ have -= copy;
716
+ next += copy;
717
+ if (len) goto inf_leave;
718
+ }
719
+ else if (state->head != Z_NULL)
720
+ state->head->name = Z_NULL;
721
+ state->length = 0;
722
+ state->mode = COMMENT;
723
+ case COMMENT:
724
+ if (state->flags & 0x1000) {
725
+ if (have == 0) goto inf_leave;
726
+ copy = 0;
727
+ do {
728
+ len = (unsigned)(next[copy++]);
729
+ if (state->head != Z_NULL &&
730
+ state->head->comment != Z_NULL &&
731
+ state->length < state->head->comm_max)
732
+ state->head->comment[state->length++] = len;
733
+ } while (len && copy < have);
734
+ if (state->flags & 0x0200)
735
+ state->check = crc32(state->check, next, copy);
736
+ have -= copy;
737
+ next += copy;
738
+ if (len) goto inf_leave;
739
+ }
740
+ else if (state->head != Z_NULL)
741
+ state->head->comment = Z_NULL;
742
+ state->mode = HCRC;
743
+ case HCRC:
744
+ if (state->flags & 0x0200) {
745
+ NEEDBITS(16);
746
+ if (hold != (state->check & 0xffff)) {
747
+ strm->msg = (char *)"header crc mismatch";
748
+ state->mode = BAD;
749
+ break;
750
+ }
751
+ INITBITS();
752
+ }
753
+ if (state->head != Z_NULL) {
754
+ state->head->hcrc = (int)((state->flags >> 9) & 1);
755
+ state->head->done = 1;
756
+ }
757
+ strm->adler = state->check = crc32(0L, Z_NULL, 0);
758
+ state->mode = TYPE;
759
+ break;
760
+ #endif
761
+ case DICTID:
762
+ NEEDBITS(32);
763
+ strm->adler = state->check = REVERSE(hold);
764
+ INITBITS();
765
+ state->mode = DICT;
766
+ case DICT:
767
+ if (state->havedict == 0) {
768
+ RESTORE();
769
+ return Z_NEED_DICT;
770
+ }
771
+ strm->adler = state->check = adler32(0L, Z_NULL, 0);
772
+ state->mode = TYPE;
773
+ case TYPE:
774
+ if (flush == Z_BLOCK) goto inf_leave;
775
+ case TYPEDO:
776
+ if (state->last) {
777
+ BYTEBITS();
778
+ state->mode = CHECK;
779
+ break;
780
+ }
781
+ NEEDBITS(3);
782
+ state->last = BITS(1);
783
+ DROPBITS(1);
784
+ switch (BITS(2)) {
785
+ case 0: /* stored block */
786
+ Tracev((stderr, "inflate: stored block%s\n",
787
+ state->last ? " (last)" : ""));
788
+ state->mode = STORED;
789
+ break;
790
+ case 1: /* fixed block */
791
+ fixedtables(state);
792
+ Tracev((stderr, "inflate: fixed codes block%s\n",
793
+ state->last ? " (last)" : ""));
794
+ state->mode = LEN; /* decode codes */
795
+ break;
796
+ case 2: /* dynamic block */
797
+ Tracev((stderr, "inflate: dynamic codes block%s\n",
798
+ state->last ? " (last)" : ""));
799
+ state->mode = TABLE;
800
+ break;
801
+ case 3:
802
+ strm->msg = (char *)"invalid block type";
803
+ state->mode = BAD;
804
+ }
805
+ DROPBITS(2);
806
+ break;
807
+ case STORED:
808
+ BYTEBITS(); /* go to byte boundary */
809
+ NEEDBITS(32);
810
+ if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
811
+ strm->msg = (char *)"invalid stored block lengths";
812
+ state->mode = BAD;
813
+ break;
814
+ }
815
+ state->length = (unsigned)hold & 0xffff;
816
+ Tracev((stderr, "inflate: stored length %u\n",
817
+ state->length));
818
+ INITBITS();
819
+ state->mode = COPY;
820
+ case COPY:
821
+ copy = state->length;
822
+ if (copy) {
823
+ if (copy > have) copy = have;
824
+ if (copy > left) copy = left;
825
+ if (copy == 0) goto inf_leave;
826
+ zmemcpy(put, next, copy);
827
+ have -= copy;
828
+ next += copy;
829
+ left -= copy;
830
+ put += copy;
831
+ state->length -= copy;
832
+ break;
833
+ }
834
+ Tracev((stderr, "inflate: stored end\n"));
835
+ state->mode = TYPE;
836
+ break;
837
+ case TABLE:
838
+ NEEDBITS(14);
839
+ state->nlen = BITS(5) + 257;
840
+ DROPBITS(5);
841
+ state->ndist = BITS(5) + 1;
842
+ DROPBITS(5);
843
+ state->ncode = BITS(4) + 4;
844
+ DROPBITS(4);
845
+ #ifndef PKZIP_BUG_WORKAROUND
846
+ if (state->nlen > 286 || state->ndist > 30) {
847
+ strm->msg = (char *)"too many length or distance symbols";
848
+ state->mode = BAD;
849
+ break;
850
+ }
851
+ #endif
852
+ Tracev((stderr, "inflate: table sizes ok\n"));
853
+ state->have = 0;
854
+ state->mode = LENLENS;
855
+ case LENLENS:
856
+ while (state->have < state->ncode) {
857
+ NEEDBITS(3);
858
+ state->lens[order[state->have++]] = (unsigned short)BITS(3);
859
+ DROPBITS(3);
860
+ }
861
+ while (state->have < 19)
862
+ state->lens[order[state->have++]] = 0;
863
+ state->next = state->codes;
864
+ state->lencode = (code const FAR *)(state->next);
865
+ state->lenbits = 7;
866
+ ret = inflate_table(CODES, state->lens, 19, &(state->next),
867
+ &(state->lenbits), state->work);
868
+ if (ret) {
869
+ strm->msg = (char *)"invalid code lengths set";
870
+ state->mode = BAD;
871
+ break;
872
+ }
873
+ Tracev((stderr, "inflate: code lengths ok\n"));
874
+ state->have = 0;
875
+ state->mode = CODELENS;
876
+ case CODELENS:
877
+ while (state->have < state->nlen + state->ndist) {
878
+ for (;;) {
879
+ this = state->lencode[BITS(state->lenbits)];
880
+ if ((unsigned)(this.bits) <= bits) break;
881
+ PULLBYTE();
882
+ }
883
+ if (this.val < 16) {
884
+ NEEDBITS(this.bits);
885
+ DROPBITS(this.bits);
886
+ state->lens[state->have++] = this.val;
887
+ }
888
+ else {
889
+ if (this.val == 16) {
890
+ NEEDBITS(this.bits + 2);
891
+ DROPBITS(this.bits);
892
+ if (state->have == 0) {
893
+ strm->msg = (char *)"invalid bit length repeat";
894
+ state->mode = BAD;
895
+ break;
896
+ }
897
+ len = state->lens[state->have - 1];
898
+ copy = 3 + BITS(2);
899
+ DROPBITS(2);
900
+ }
901
+ else if (this.val == 17) {
902
+ NEEDBITS(this.bits + 3);
903
+ DROPBITS(this.bits);
904
+ len = 0;
905
+ copy = 3 + BITS(3);
906
+ DROPBITS(3);
907
+ }
908
+ else {
909
+ NEEDBITS(this.bits + 7);
910
+ DROPBITS(this.bits);
911
+ len = 0;
912
+ copy = 11 + BITS(7);
913
+ DROPBITS(7);
914
+ }
915
+ if (state->have + copy > state->nlen + state->ndist) {
916
+ strm->msg = (char *)"invalid bit length repeat";
917
+ state->mode = BAD;
918
+ break;
919
+ }
920
+ while (copy--)
921
+ state->lens[state->have++] = (unsigned short)len;
922
+ }
923
+ }
924
+
925
+ /* handle error breaks in while */
926
+ if (state->mode == BAD) break;
927
+
928
+ /* build code tables */
929
+ state->next = state->codes;
930
+ state->lencode = (code const FAR *)(state->next);
931
+ state->lenbits = 9;
932
+ ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
933
+ &(state->lenbits), state->work);
934
+ if (ret) {
935
+ strm->msg = (char *)"invalid literal/lengths set";
936
+ state->mode = BAD;
937
+ break;
938
+ }
939
+ state->distcode = (code const FAR *)(state->next);
940
+ state->distbits = 6;
941
+ ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
942
+ &(state->next), &(state->distbits), state->work);
943
+ if (ret) {
944
+ strm->msg = (char *)"invalid distances set";
945
+ state->mode = BAD;
946
+ break;
947
+ }
948
+ Tracev((stderr, "inflate: codes ok\n"));
949
+ state->mode = LEN;
950
+ case LEN:
951
+ if (have >= 6 && left >= 258) {
952
+ RESTORE();
953
+ inflate_fast(strm, out);
954
+ LOAD();
955
+ break;
956
+ }
957
+ for (;;) {
958
+ this = state->lencode[BITS(state->lenbits)];
959
+ if ((unsigned)(this.bits) <= bits) break;
960
+ PULLBYTE();
961
+ }
962
+ if (this.op && (this.op & 0xf0) == 0) {
963
+ last = this;
964
+ for (;;) {
965
+ this = state->lencode[last.val +
966
+ (BITS(last.bits + last.op) >> last.bits)];
967
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
968
+ PULLBYTE();
969
+ }
970
+ DROPBITS(last.bits);
971
+ }
972
+ DROPBITS(this.bits);
973
+ state->length = (unsigned)this.val;
974
+ if ((int)(this.op) == 0) {
975
+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
976
+ "inflate: literal '%c'\n" :
977
+ "inflate: literal 0x%02x\n", this.val));
978
+ state->mode = LIT;
979
+ break;
980
+ }
981
+ if (this.op & 32) {
982
+ Tracevv((stderr, "inflate: end of block\n"));
983
+ state->mode = TYPE;
984
+ break;
985
+ }
986
+ if (this.op & 64) {
987
+ strm->msg = (char *)"invalid literal/length code";
988
+ state->mode = BAD;
989
+ break;
990
+ }
991
+ state->extra = (unsigned)(this.op) & 15;
992
+ state->mode = LENEXT;
993
+ case LENEXT:
994
+ if (state->extra) {
995
+ NEEDBITS(state->extra);
996
+ state->length += BITS(state->extra);
997
+ DROPBITS(state->extra);
998
+ }
999
+ Tracevv((stderr, "inflate: length %u\n", state->length));
1000
+ state->mode = DIST;
1001
+ case DIST:
1002
+ for (;;) {
1003
+ this = state->distcode[BITS(state->distbits)];
1004
+ if ((unsigned)(this.bits) <= bits) break;
1005
+ PULLBYTE();
1006
+ }
1007
+ if ((this.op & 0xf0) == 0) {
1008
+ last = this;
1009
+ for (;;) {
1010
+ this = state->distcode[last.val +
1011
+ (BITS(last.bits + last.op) >> last.bits)];
1012
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
1013
+ PULLBYTE();
1014
+ }
1015
+ DROPBITS(last.bits);
1016
+ }
1017
+ DROPBITS(this.bits);
1018
+ if (this.op & 64) {
1019
+ strm->msg = (char *)"invalid distance code";
1020
+ state->mode = BAD;
1021
+ break;
1022
+ }
1023
+ state->offset = (unsigned)this.val;
1024
+ state->extra = (unsigned)(this.op) & 15;
1025
+ state->mode = DISTEXT;
1026
+ case DISTEXT:
1027
+ if (state->extra) {
1028
+ NEEDBITS(state->extra);
1029
+ state->offset += BITS(state->extra);
1030
+ DROPBITS(state->extra);
1031
+ }
1032
+ #ifdef INFLATE_STRICT
1033
+ if (state->offset > state->dmax) {
1034
+ strm->msg = (char *)"invalid distance too far back";
1035
+ state->mode = BAD;
1036
+ break;
1037
+ }
1038
+ #endif
1039
+ if (state->offset > state->whave + out - left) {
1040
+ strm->msg = (char *)"invalid distance too far back";
1041
+ state->mode = BAD;
1042
+ break;
1043
+ }
1044
+ Tracevv((stderr, "inflate: distance %u\n", state->offset));
1045
+ state->mode = MATCH;
1046
+ case MATCH:
1047
+ if (left == 0) goto inf_leave;
1048
+ copy = out - left;
1049
+ if (state->offset > copy) { /* copy from window */
1050
+ copy = state->offset - copy;
1051
+ if (copy > state->write) {
1052
+ copy -= state->write;
1053
+ from = state->window + (state->wsize - copy);
1054
+ }
1055
+ else
1056
+ from = state->window + (state->write - copy);
1057
+ if (copy > state->length) copy = state->length;
1058
+ }
1059
+ else { /* copy from output */
1060
+ from = put - state->offset;
1061
+ copy = state->length;
1062
+ }
1063
+ if (copy > left) copy = left;
1064
+ left -= copy;
1065
+ state->length -= copy;
1066
+ do {
1067
+ *put++ = *from++;
1068
+ } while (--copy);
1069
+ if (state->length == 0) state->mode = LEN;
1070
+ break;
1071
+ case LIT:
1072
+ if (left == 0) goto inf_leave;
1073
+ *put++ = (unsigned char)(state->length);
1074
+ left--;
1075
+ state->mode = LEN;
1076
+ break;
1077
+ case CHECK:
1078
+ if (state->wrap) {
1079
+ NEEDBITS(32);
1080
+ out -= left;
1081
+ strm->total_out += out;
1082
+ state->total += out;
1083
+ if (out)
1084
+ strm->adler = state->check =
1085
+ UPDATE(state->check, put - out, out);
1086
+ out = left;
1087
+ if ((
1088
+ #ifdef GUNZIP
1089
+ state->flags ? hold :
1090
+ #endif
1091
+ REVERSE(hold)) != state->check) {
1092
+ strm->msg = (char *)"incorrect data check";
1093
+ state->mode = BAD;
1094
+ break;
1095
+ }
1096
+ INITBITS();
1097
+ Tracev((stderr, "inflate: check matches trailer\n"));
1098
+ }
1099
+ #ifdef GUNZIP
1100
+ state->mode = LENGTH;
1101
+ case LENGTH:
1102
+ if (state->wrap && state->flags) {
1103
+ NEEDBITS(32);
1104
+ if (hold != (state->total & 0xffffffffUL)) {
1105
+ strm->msg = (char *)"incorrect length check";
1106
+ state->mode = BAD;
1107
+ break;
1108
+ }
1109
+ INITBITS();
1110
+ Tracev((stderr, "inflate: length matches trailer\n"));
1111
+ }
1112
+ #endif
1113
+ state->mode = DONE;
1114
+ case DONE:
1115
+ ret = Z_STREAM_END;
1116
+ goto inf_leave;
1117
+ case BAD:
1118
+ ret = Z_DATA_ERROR;
1119
+ goto inf_leave;
1120
+ case MEM:
1121
+ return Z_MEM_ERROR;
1122
+ case SYNC:
1123
+ default:
1124
+ return Z_STREAM_ERROR;
1125
+ }
1126
+
1127
+ /*
1128
+ Return from inflate(), updating the total counts and the check value.
1129
+ If there was no progress during the inflate() call, return a buffer
1130
+ error. Call updatewindow() to create and/or update the window state.
1131
+ Note: a memory error from inflate() is non-recoverable.
1132
+ */
1133
+ inf_leave:
1134
+ RESTORE();
1135
+ if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
1136
+ if (updatewindow(strm, out)) {
1137
+ state->mode = MEM;
1138
+ return Z_MEM_ERROR;
1139
+ }
1140
+ in -= strm->avail_in;
1141
+ out -= strm->avail_out;
1142
+ strm->total_in += in;
1143
+ strm->total_out += out;
1144
+ state->total += out;
1145
+ if (state->wrap && out)
1146
+ strm->adler = state->check =
1147
+ UPDATE(state->check, strm->next_out - out, out);
1148
+ strm->data_type = state->bits + (state->last ? 64 : 0) +
1149
+ (state->mode == TYPE ? 128 : 0);
1150
+ if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1151
+ ret = Z_BUF_ERROR;
1152
+ return ret;
1153
+ }
1154
+
1155
+ int ZEXPORT inflateEnd(strm)
1156
+ z_streamp strm;
1157
+ {
1158
+ struct inflate_state FAR *state;
1159
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1160
+ return Z_STREAM_ERROR;
1161
+ state = (struct inflate_state FAR *)strm->state;
1162
+ if (state->window != Z_NULL) ZFREE(strm, state->window);
1163
+ ZFREE(strm, strm->state);
1164
+ strm->state = Z_NULL;
1165
+ Tracev((stderr, "inflate: end\n"));
1166
+ return Z_OK;
1167
+ }
1168
+
1169
+ int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
1170
+ z_streamp strm;
1171
+ const Bytef *dictionary;
1172
+ uInt dictLength;
1173
+ {
1174
+ struct inflate_state FAR *state;
1175
+ unsigned long id;
1176
+
1177
+ /* check state */
1178
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1179
+ state = (struct inflate_state FAR *)strm->state;
1180
+ if (state->wrap != 0 && state->mode != DICT)
1181
+ return Z_STREAM_ERROR;
1182
+
1183
+ /* check for correct dictionary id */
1184
+ if (state->mode == DICT) {
1185
+ id = adler32(0L, Z_NULL, 0);
1186
+ id = adler32(id, dictionary, dictLength);
1187
+ if (id != state->check)
1188
+ return Z_DATA_ERROR;
1189
+ }
1190
+
1191
+ /* copy dictionary to window */
1192
+ if (updatewindow(strm, strm->avail_out)) {
1193
+ state->mode = MEM;
1194
+ return Z_MEM_ERROR;
1195
+ }
1196
+ if (dictLength > state->wsize) {
1197
+ zmemcpy(state->window, dictionary + dictLength - state->wsize,
1198
+ state->wsize);
1199
+ state->whave = state->wsize;
1200
+ }
1201
+ else {
1202
+ zmemcpy(state->window + state->wsize - dictLength, dictionary,
1203
+ dictLength);
1204
+ state->whave = dictLength;
1205
+ }
1206
+ state->havedict = 1;
1207
+ Tracev((stderr, "inflate: dictionary set\n"));
1208
+ return Z_OK;
1209
+ }
1210
+
1211
+ int ZEXPORT inflateGetHeader(strm, head)
1212
+ z_streamp strm;
1213
+ gz_headerp head;
1214
+ {
1215
+ struct inflate_state FAR *state;
1216
+
1217
+ /* check state */
1218
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1219
+ state = (struct inflate_state FAR *)strm->state;
1220
+ if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1221
+
1222
+ /* save header structure */
1223
+ state->head = head;
1224
+ head->done = 0;
1225
+ return Z_OK;
1226
+ }
1227
+
1228
+ /*
1229
+ Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
1230
+ or when out of input. When called, *have is the number of pattern bytes
1231
+ found in order so far, in 0..3. On return *have is updated to the new
1232
+ state. If on return *have equals four, then the pattern was found and the
1233
+ return value is how many bytes were read including the last byte of the
1234
+ pattern. If *have is less than four, then the pattern has not been found
1235
+ yet and the return value is len. In the latter case, syncsearch() can be
1236
+ called again with more data and the *have state. *have is initialized to
1237
+ zero for the first call.
1238
+ */
1239
+ local unsigned syncsearch(have, buf, len)
1240
+ unsigned FAR *have;
1241
+ unsigned char FAR *buf;
1242
+ unsigned len;
1243
+ {
1244
+ unsigned got;
1245
+ unsigned next;
1246
+
1247
+ got = *have;
1248
+ next = 0;
1249
+ while (next < len && got < 4) {
1250
+ if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
1251
+ got++;
1252
+ else if (buf[next])
1253
+ got = 0;
1254
+ else
1255
+ got = 4 - got;
1256
+ next++;
1257
+ }
1258
+ *have = got;
1259
+ return next;
1260
+ }
1261
+
1262
+ int ZEXPORT inflateSync(strm)
1263
+ z_streamp strm;
1264
+ {
1265
+ unsigned len; /* number of bytes to look at or looked at */
1266
+ unsigned long in, out; /* temporary to save total_in and total_out */
1267
+ unsigned char buf[4]; /* to restore bit buffer to byte string */
1268
+ struct inflate_state FAR *state;
1269
+
1270
+ /* check parameters */
1271
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1272
+ state = (struct inflate_state FAR *)strm->state;
1273
+ if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1274
+
1275
+ /* if first time, start search in bit buffer */
1276
+ if (state->mode != SYNC) {
1277
+ state->mode = SYNC;
1278
+ state->hold <<= state->bits & 7;
1279
+ state->bits -= state->bits & 7;
1280
+ len = 0;
1281
+ while (state->bits >= 8) {
1282
+ buf[len++] = (unsigned char)(state->hold);
1283
+ state->hold >>= 8;
1284
+ state->bits -= 8;
1285
+ }
1286
+ state->have = 0;
1287
+ syncsearch(&(state->have), buf, len);
1288
+ }
1289
+
1290
+ /* search available input */
1291
+ len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1292
+ strm->avail_in -= len;
1293
+ strm->next_in += len;
1294
+ strm->total_in += len;
1295
+
1296
+ /* return no joy or set up to restart inflate() on a new block */
1297
+ if (state->have != 4) return Z_DATA_ERROR;
1298
+ in = strm->total_in; out = strm->total_out;
1299
+ inflateReset(strm);
1300
+ strm->total_in = in; strm->total_out = out;
1301
+ state->mode = TYPE;
1302
+ return Z_OK;
1303
+ }
1304
+
1305
+ /*
1306
+ Returns true if inflate is currently at the end of a block generated by
1307
+ Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1308
+ implementation to provide an additional safety check. PPP uses
1309
+ Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1310
+ block. When decompressing, PPP checks that at the end of input packet,
1311
+ inflate is waiting for these length bytes.
1312
+ */
1313
+ int ZEXPORT inflateSyncPoint(strm)
1314
+ z_streamp strm;
1315
+ {
1316
+ struct inflate_state FAR *state;
1317
+
1318
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1319
+ state = (struct inflate_state FAR *)strm->state;
1320
+ return state->mode == STORED && state->bits == 0;
1321
+ }
1322
+
1323
+ int ZEXPORT inflateCopy(dest, source)
1324
+ z_streamp dest;
1325
+ z_streamp source;
1326
+ {
1327
+ struct inflate_state FAR *state;
1328
+ struct inflate_state FAR *copy;
1329
+ unsigned char FAR *window;
1330
+ unsigned wsize;
1331
+
1332
+ /* check input */
1333
+ if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1334
+ source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
1335
+ return Z_STREAM_ERROR;
1336
+ state = (struct inflate_state FAR *)source->state;
1337
+
1338
+ /* allocate space */
1339
+ copy = (struct inflate_state FAR *)
1340
+ ZALLOC(source, 1, sizeof(struct inflate_state));
1341
+ if (copy == Z_NULL) return Z_MEM_ERROR;
1342
+ window = Z_NULL;
1343
+ if (state->window != Z_NULL) {
1344
+ window = (unsigned char FAR *)
1345
+ ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1346
+ if (window == Z_NULL) {
1347
+ ZFREE(source, copy);
1348
+ return Z_MEM_ERROR;
1349
+ }
1350
+ }
1351
+
1352
+ /* copy state */
1353
+ zmemcpy(dest, source, sizeof(z_stream));
1354
+ zmemcpy(copy, state, sizeof(struct inflate_state));
1355
+ if (state->lencode >= state->codes &&
1356
+ state->lencode <= state->codes + ENOUGH - 1) {
1357
+ copy->lencode = copy->codes + (state->lencode - state->codes);
1358
+ copy->distcode = copy->codes + (state->distcode - state->codes);
1359
+ }
1360
+ copy->next = copy->codes + (state->next - state->codes);
1361
+ if (window != Z_NULL) {
1362
+ wsize = 1U << state->wbits;
1363
+ zmemcpy(window, state->window, wsize);
1364
+ }
1365
+ copy->window = window;
1366
+ dest->state = (struct internal_state FAR *)copy;
1367
+ return Z_OK;
1368
+ }