[/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/dl.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * small test for -ldl\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/dl.c typeset -A hashsum=( [md5]=ecc06e3a5684a1b3223396c963f189cf [sha1]=e55d10a1d9a9c8d3e6b695e022ae3284e839ef8f ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/gdbm.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * small test for -lgdbm\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/gdbm.c typeset -A hashsum=( [md5]=951f496ef4de832290d461446d6f894e [sha1]=b26b6ad17dc26294f24bcccc53f4ae81337c1a2e ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/gdbm2.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * small test for -lgdbm\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/gdbm2.c typeset -A hashsum=( [md5]=cbe1e614b382db2a43606acf0f105234 [sha1]=36c429b6b591d8f828dab10f45e3996443b40edd ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/hello.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/hello.c typeset -A hashsum=( [md5]=19113df84e4f8bc2d96bbd2d7492c195 [sha1]=68ed16d3325eec87406dcd47aa8c42e665a241cc ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/iconv.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/iconv.c typeset -A hashsum=( [md5]=c97e3327e2bbf9dd7f67a171428998aa [sha1]=4cd8a861e37bb6c95da376ce9ba70c4d2c71570e ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/intl.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/intl.c typeset -A hashsum=( [md5]=f5c18d79db7d42e4fa237ba404cf6030 [sha1]=567a33fb6c8506bd2337944f6d5d42445aeef75c ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/ldd.cygwin.i386]=( typeset -a comments comments_parsed=false file_format='' fileformat_found=false filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/ldd.cygwin.i386 typeset -A hashsum=( [md5]=a9daf100bfd65d4fbe61c6625a782f90 [sha1]=58cc7cf3a769e9b4af16146a217364e279be817e ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * -lm test #1\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m.c typeset -A hashsum=( [md5]=864ad3d161248a9c7d2cc692b98e2e7c [sha1]=992f4ed5148d14e05fb463170850eb85d0d02543 ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m2.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * -lm test #2\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m2.c typeset -A hashsum=( [md5]=46c4d96f4dd5ad729b1d2d5d190292e4 [sha1]=720b5c0ede2d2f4e5abe8919fe8ce062e2f01dd6 ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m3.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * -lm test #3\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m3.c typeset -A hashsum=( [md5]=1c81ba09e98202a5a9a8409df2d392c6 [sha1]=3bfb6dcb125a8304cebf6f9c4f733aea303fe6f2 ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m4.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * -lm test #4\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m4.c typeset -A hashsum=( [md5]=935dd176098bfd1bbd463f8f9c0d5603 [sha1]=5d1b1851b4b337a01a07ac89263bf581ca7444cc ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m5.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * -lm test #5\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m5.c typeset -A hashsum=( [md5]=fd3052ea515b62041fb015229de02694 [sha1]=3b3b854f9fb714e6895f37e9f60474fe74592b44 ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m6.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * -lm test #6\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/m6.c typeset -A hashsum=( [md5]=edf665590f2315f26bf06a9d4da5d38c [sha1]=27e8d13063c72c722909bfd34ed18d95ec4795fd ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/mamake.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * mamake -- MAM make\n *\n * coded for portability\n ' $' active target\t\t' $' ok if not found\t\t' $' not found or not generated\t' $' target file exists\t\t' $' generated target\t\t' $' ignore time\t\t\t' $' implicit prerequisite\t' $' already made\t\t\t' $' not a file\t\t\t' $' don\'t fclose() on pop()\t' $' push() file must exist\t' $' pclose() on pop()\t\t' $' owner execute permission\t' $' group execute permission\t' $' other execute permission\t' $' buffer stream\t\t' $' next dropped buffer\t\t' $' 1 past end of buffer\t\t' $' next char to add\t\t' $' buffer space\t\t\t' $' dictionary item\t\t' $' left child\t\t\t' $' right child\t\t\t' $' user defined value\t\t' $' 0 terminated name\t\t' $' dictionary handle\t\t' $' root item\t\t\t' $' Rule_t list\t\t\t' $' next in list\t\t\t' $' list item\t\t\t' $' rule item\t\t\t' $' unbound name\t\t\t' $' bound path\t\t\t' $' prerequisites\t\t' $' recursion leaf alias\t\t' $' RULE_* flags\t\t\t' $' modification time\t\t' $' input file stream stack\t' $' read stream\t\t\t' $' stream path\t\t\t' $' stream line\t\t\t' $' stream flags\t\t\t' $' viewpath level\t\t' $' next level in viewpath\t' $' viewpath node path length\t' $' viewpath level dir prefix\t' $' program state\t\t' $' work buffer\t\t\t' $' dropped buffers\t\t' $' option buffer\t\t' $' recursion leaf dictionary\t' $' library dictionary\t\t' $' rule dictionary\t\t' $' variable dictionary\t\t' $' viewpath levels\t\t' $' work in this directory\t' $' command name\t\t\t' $' first input file\t\t' $' current directory\t\t' $' recursion pattern\t\t' $' ${SHELL}\t\t\t' $' targets currently active\t' $' negative of debug level\t' $' some error(s) occurred\t' $' execute actions\t\t' $' all targets out of date\t' $' ignore command errors\t' $' debug indent\t\t\t' $' do siblings on error\t\t' $' never execute\t\t' $' next line already in input\t' $' probe already done\t\t' $' don\'t bother with verify()\t' $' input file stream stack\t' $' input stream stack pointer\t' $' input buffer\t\t\t' $'\n * emit usage message and exit\n ' $'\n * output error message identification\n ' $'\n * emit error message\n * level:\n *\t<0\tdebug\n *\t 0\tinfo\n *\t 1\twarning\n *\t 2\terror\n *\t>2\texit(level-2)\n ' $'\n * don\'t know how to make or exit code making\n ' $'\n * local strrchr()\n ' $'\n * open a buffer stream\n ' $'\n * close a buffer stream\n ' $'\n * append str length n to buffer and return the buffer base\n ' $'\n * append str to buffer and return the buffer base\n * if str==0 then next pointer reset to base\n ' $'\n * allocate space for s and return the copy\n ' $'\n * open a new dictionary\n ' $'\n * return the value for item name in dictionary dict\n * if value!=0 then name entry value is created if necessary and set\n * uses top-down splaying (ala Tarjan and Sleator)\n ' $'\n * low level for walk()\n ' $'\n * apply func to each dictionary item\n ' $'\n * return a rule pointer for name\n ' $'\n * prepend p onto rule r prereqs\n ' $'\n * initialize the viewpath\n ' $'\n\t\t\t\t * determine the viewpath offset\n\t\t\t\t ' $'\n * return next \'?\' or \'}\' in nested \'}\'\n ' $'\n * expand var refs from s into buf\n ' FALLTHROUGH $'\n * expand var refs from s into buf and return buf base\n ' $'\n * stat() with .exe check\n ' $'\n * return path to file\n ' $'\n * bind r to a file and return the modify time\n ' $'\n * pop the current input file\n ' $'\n * push file onto the input stack\n ' $'\n * return the next input line\n ' $'\n * pass shell action s to ${SHELL:-/bin/sh}\n * the -c wrapper ensures that scripts are run in the selected shell\n * even on systems that otherwise demand #! magic (can you say cygwin)\n ' $'\n * add attributes in s to r\n ' $'\n * define ${mam_libX} for library reference lib\n ' $'\n * input() until `done r\'\n ' $'\n * verify that active targets were made\n ' $'\n * return 1 if name is an initializer\n ' $'\n * update recursion leaf r and its prerequisites\n ' $'\n * scan makefile prereqs\n ' $'\n\t * drop non-leaf rules\n\t ' $'\n\t * always make initializers\n\t ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/mamake.c typeset -A hashsum=( [md5]=5c0ada5fff9ce5e7c4d246e92ec1e2dc [sha1]=78149ae58646f86d66ebb93c2dc2ca2da980541c ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/nsl.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * small test for -lnsl\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/nsl.c typeset -A hashsum=( [md5]=454e8b3d3b7025a66bb7f1246ea014de [sha1]=b908a06eba60a3617cc2f5f2768d1d63199c345c ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/p.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * small test for prototyping cc\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/p.c typeset -A hashsum=( [md5]=1c4ec849f7a5fca4b08dd530a6b3c675 [sha1]=eb941b249afc948ce35dcbcd9863636ed39be130 ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/proto.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1990-2008 AT&T Intellectual Property *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T Intellectual Property *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' ' : : generated by proto : : ' ' 2004-08-11 transition ' 'www.gnu.org/copyleft/gpl.html",sizeof( "http://www.gnu.org/copyleft/gpl.html")-1, 0);' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/proto.c typeset -A hashsum=( [md5]=b2e53ae03d21e60fb665e3e1ae222082 [sha1]=cf0657a30ffb8a05d058c13dfaed9262dbd643e4 ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/ratz.c]=( typeset -a comments=( $'\n * ratz -- read a tar gzip archive from the standard input\n *\n * coded for portability\n * _SEAR_* macros for win32 self extracting archives -- see sear(1).\n ' $'\n * stripped down zlib containing public gzfopen()+gzread() in one file\n * USE THE REAL ZLIB AFTER BOOTSTRAP\n ' $' zlib.h -- interface of the \'zlib\' general purpose compression library\n version 1.2.3, July 18th, 2005\n\n Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler\n\n This software is provided \'as-is\', without any express or implied\n warranty. In no event will the authors be held liable for any damages\n arising from the use of this software.\n\n Permission is granted to anyone to use this software for any purpose,\n including commercial applications, and to alter it and redistribute it\n freely, subject to the following restrictions:\n\n 1. The origin of this software must not be misrepresented; you must not\n claim that you wrote the original software. If you use this software\n in a product, an acknowledgment in the product documentation would be\n appreciated but is not required.\n 2. Altered source versions must be plainly marked as such, and must not be\n misrepresented as being the original software.\n 3. This notice may not be removed or altered from any source distribution.\n\n Jean-loup Gailly Mark Adler\n jloup@gzip.org madler@alumni.caltech.edu\n\n\n The data format used by the zlib library is described by RFCs (Request for\n Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt\n (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).\n' ' for { _WINIX __IMPORT__ __EXPORT__ } ' $'\n * Compile with -DMAXSEG_64K if the alloc function cannot allocate more\n * than 64k bytes at a time (needed on systems with 16-bit int).\n ' ' iSeries (formerly AS/400). ' ' cannot use !defined(STDC) && !defined(const) on Mac ' ' note: need a more gentle solution here ' ' Some Mac compilers merge all .h files incorrectly: ' ' Maximum value for memLevel in deflateInit2 ' $' Maximum value for windowBits in deflateInit2 and inflateInit2.\n * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files\n * created by gzip. (Files created by minigzip can still be extracted by\n * gzip.)\n ' ' 32K LZ77 window ' $' The memory requirements for deflate are (in bytes):\n (1 << (windowBits+2)) + (1 << (memLevel+9))\n that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)\n plus a few kilobytes for small objects. For example, if you want to reduce\n the default memory requirements from 256K to 128K, compile with\n make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"\n Of course this will generally degrade compression (there\'s no free lunch).\n\n The memory requirements for inflate are (in bytes) 1 << windowBits\n that is, 32K for windowBits=15 (default value) plus a few kilobytes\n for small objects.\n' ' Type declarations ' ' function prototypes ' $' The following definitions for FAR are needed only for MSDOS mixed\n * model programming (small or medium model with some far allocations).\n * This was tested only with MSC; for other MSDOS compilers you may have\n * to define NO_MEMCPY in zutil.h. If you don\'t need the mixed model,\n * just define FAR to be empty.\n ' ' MSC small or medium model ' ' Turbo C small or medium model ' $' If building or using zlib as a DLL, define ZLIB_DLL.\n * This is not mandatory, but it offers a little performance increase.\n ' ' ZLIB_DLL ' $' If building or using zlib with the WINAPI/WINAPIV calling convention,\n * define ZLIB_WINAPI.\n * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.\n ' ' No need for _export, use ZLIB.DEF instead. ' ' For complete Windows compatibility, use WINAPI, not __stdcall. ' ' 8 bits ' ' 16 bits or more ' ' 32 bits or more ' ' Borland C/C++ and some old MSC versions ignore FAR inside typedef ' ' for off_t ' ' for SEEK_* and off_t ' ' for off_t ' ' Seek from beginning of file. ' ' Seek from current position. ' ' Set file pointer to EOF plus "offset" ' ' MVS linker does not support external names larger than 8 bytes ' ' _ZCONF_H ' $'\n The \'zlib\' compression library provides in-memory compression and\n decompression functions, including integrity checks of the uncompressed\n data. This version of the library supports only one compression method\n (deflation) but other algorithms will be added later and will have the same\n stream interface.\n\n Compression can be done in a single step if the buffers are large\n enough (for example if an input file is mmap\'ed), or can be done by\n repeated calls of the compression function. In the latter case, the\n application must provide more input and/or consume the output\n (providing more output space) before each call.\n\n The compressed data format used by default by the in-memory functions is\n the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped\n around a deflate stream, which is itself documented in RFC 1951.\n\n The library also supports reading and writing files in gzip (.gz) format\n with an interface similar to that of stdio using the functions that start\n with "gz". The gzip format is different from the zlib format. gzip is a\n gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.\n\n This library can optionally read and write gzip streams in memory as well.\n\n The zlib format was designed to be compact and fast for use in memory\n and on communications channels. The gzip format was designed for single-\n file compression on file systems, has a larger header than zlib to maintain\n directory information, and uses a different, slower check method than zlib.\n\n The library does not install any signal handler. The decoder checks\n the consistency of the compressed data, so the library should never\n crash even in case of corrupted input.\n' ' next input byte ' ' number of bytes available at next_in ' ' total nb of input bytes read so far ' ' next output byte should be put there ' ' remaining free space at next_out ' ' total nb of bytes output so far ' ' last error message, NULL if no error ' ' not visible by applications ' ' used to allocate the internal state ' ' used to free the internal state ' ' private data object passed to zalloc and zfree ' ' best guess about the data type: binary or text ' ' adler32 value of the uncompressed data ' ' reserved for future use ' ' constants ' ' will be removed, use Z_SYNC_FLUSH instead ' ' Allowed flush values; see deflate() and inflate() below for details ' $' Return codes for the compression/decompression functions. Negative\n * values are errors, positive values are used for special but normal events.\n ' ' compression levels ' ' compression strategy; see deflateInit2() below for details ' ' for compatibility with 1.2.2 and earlier ' ' Possible values of the data_type field (though see inflate()) ' ' The deflate compression method (the only one supported in this version) ' ' for initializing zalloc, zfree, opaque ' ' _ZLIB_H ' $' compile with -Dlocal if your debugger can\'t find static symbols ' ' common constants ' ' default windowBits for decompression. MAX_WBITS is for compression only ' ' default memLevel ' ' The three kinds of block type ' ' The minimum and maximum match lengths ' ' preset dictionary flag in zlib header ' ' target dependencies ' ' Allow compilation with ANSI keywords only enabled ' ' MSC or DJGPP ' ' for fdopen ' ' No fdopen() ' ' Cygwin is Unix, not Win32 ' ' Prime/PRIMOS ' ' No fdopen() ' ' No fdopen() ' ' common defaults ' ' assume Unix ' ' functions ' $' vsnprintf may exist on some MS-DOS compilers (DJGPP?),\n but for now we just assume it doesn\'t. ' ' In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. ' $' Use our own functions for small and medium model with MSC <= 5.0.\n * You may have to use the same strategy for Borland C (untested).\n * The __SC__ check is for Symantec.\n ' ' MSDOS small or medium model ' ' Diagnostic functions ' ' _ZUTIL_H ' ' ??? to be unrolled ' ' ??? to be unrolled ' ' Turbo C in 16-bit mode ' $' Turbo C malloc() does not allow dynamic allocation of 64K bytes\n * and farmalloc(64K) returns a pointer with an offset of 8, so we\n * must fix the pointer. Warning: the pointer must be put back to its\n * original form in order to free it, use zcfree().\n ' ' 10*64K = 640K ' $' This table is used to remember the original form of pointers\n * to large buffers (64K). Such pointers are normalized with a zero offset.\n * Since MSDOS is not a preemptive multitasking OS, this table is not\n * protected from concurrent access. This hack doesn\'t work anyway on\n * a protected system like OS/2. Use Microsoft C instead.\n ' ' just to make some compilers happy ' $' If we allocate less than 65520 bytes, we assume that farmalloc\n * will return a usable pointer which doesn\'t have to be normalized.\n ' ' Normalize the pointer to seg:0 ' ' object < 64K ' ' Find the original pointer ' ' just to make some compilers happy ' ' __TURBOC__ ' ' Microsoft C in 16-bit mode ' ' to make compiler happy ' ' to make compiler happy ' ' M_I86 ' ' SYS16BIT ' ' Any system without a special alloc function ' ' make compiler happy ' ' make compiler happy ' ' MY_ZCALLOC ' ' _ZUTIL_C ' $' crc32.h -- tables for rapid CRC calculation\n * Generated automatically by crc32.c\n ' ' _CRC32_H ' ' ========================================================================= ' ' ========================================================================= ' ' DYNAMIC_CRC_TABLE ' ' BYFOUR ' ' _CRC32_C ' ' largest prime smaller than 65536 ' ' NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 ' ' use NO_DIVIDE if your processor does not do division in hardware ' ' ========================================================================= ' ' split Adler-32 into component sums ' ' in case user likes doing a byte at a time, keep it fast ' ' initial Adler-32 value (deferred check for len == 1 speed) ' ' in case short lengths are provided, keep it somewhat fast ' $' only added so many BASE\'s ' ' do length NMAX blocks -- requires just one modulo operation ' ' NMAX is divisible by 16 ' ' 16 sums unrolled ' ' do remaining bytes (less than NMAX, still just one modulo) ' ' avoid modulos if none remaining ' ' return recombined sums ' ' _ADLER32_C ' $' ===========================================================================\n * Internal compression state.\n ' ' number of length codes, not counting the special END_BLOCK code ' ' number of literal bytes 0..255 ' ' number of Literal or Length codes, including the END_BLOCK code ' ' number of distance codes ' ' number of codes used to transfer the bit lengths ' ' maximum heap size ' ' All codes must not exceed MAX_BITS bits ' ' Stream status ' ' Data structure describing a single value and its code string. ' ' frequency count ' ' bit string ' ' father node in Huffman tree ' ' length of bit string ' ' the dynamic tree ' ' largest code with non zero frequency ' ' the corresponding static tree ' $' A Pos is an index in the character window. We use short instead of int to\n * save space in the various tables. IPos is used only for parameter passing.\n ' ' pointer back to this zlib stream ' ' as the name implies ' ' output still pending ' ' size of pending_buf ' ' next pending byte to output to the stream ' ' nb of bytes in the pending buffer ' ' bit 0 true for zlib, bit 1 true for gzip ' ' gzip header information to write ' ' where in extra, name, or comment ' ' STORED (for zip only) or DEFLATED ' ' value of flush param for previous deflate call ' ' used by deflate.c: ' ' LZ77 window size (32K by default) ' ' log2(w_size) (8..16) ' ' w_size - 1 ' $' Sliding window. Input bytes are read into the second half of the window,\n * and move to the first half later to keep a dictionary of at least wSize\n * bytes. With this organization, matches are limited to a distance of\n * wSize-MAX_MATCH bytes, but this ensures that IO is always\n * performed with a length multiple of the block size. Also, it limits\n * the window size to 64K, which is quite useful on MSDOS.\n * To do: use the user input buffer as sliding window.\n ' $' Actual size of window: 2*wSize, except when the user input buffer\n * is directly used as sliding window.\n ' $' Link to older string with same hash index. To limit the size of this\n * array to 64K, this link is maintained only for the last 32K strings.\n * An index in this array is thus a window index modulo 32K.\n ' ' Heads of the hash chains or NIL. ' ' hash index of string to be inserted ' ' number of elements in hash table ' ' log2(hash_size) ' ' hash_size-1 ' $' Number of bits by which ins_h must be shifted at each input\n * step. It must be such that after MIN_MATCH steps, the oldest\n * byte no longer takes part in the hash key, that is:\n * hash_shift * MIN_MATCH >= hash_bits\n ' $' Window position at the beginning of the current output block. Gets\n * negative when the window is moved backwards.\n ' ' length of best match ' ' previous match ' ' set if previous match exists ' ' start of string to insert ' ' start of matching string ' ' number of valid bytes ahead in window ' $' Length of the best match at previous step. Matches not greater than this\n * are discarded. This is used in the lazy match evaluation.\n ' $' To speed up deflation, hash chains are never searched beyond this\n * length. A higher limit improves compression ratio but degrades the\n * speed.\n ' $' Attempt to find a better match only when the current match is strictly\n * smaller than this value. This mechanism is used only for compression\n * levels >= 4.\n ' $' Insert new strings in the hash table only if the match length is not\n * greater than this length. This saves time but degrades compression.\n * max_insert_length is used only for compression levels <= 3.\n ' ' compression level (1..9) ' ' favor or force Huffman coding' ' Use a faster search when the previous match is longer than this ' ' Stop searching when current match exceeds this ' ' used by trees.c: ' $' Didn\'t use ct_data typedef below to supress compiler warning ' ' literal and length tree ' ' distance tree ' ' Huffman tree for bit lengths ' ' desc. for literal tree ' ' desc. for distance tree ' ' desc. for bit length tree ' ' number of codes at each bit length for an optimal tree ' ' heap used to build the Huffman trees ' ' number of elements in the heap ' ' element of largest frequency ' $' The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.\n * The same heap array is used to build all trees.\n ' $' Depth of each subtree used as tie breaker for trees of equal frequency\n ' ' buffer for literals or lengths ' $' Size of match buffer for literals/lengths. There are 4 reasons for\n * limiting lit_bufsize to 64K:\n * - frequencies can be kept in 16 bit counters\n * - if compression is not successful for the first block, all input\n * data is still in the window so we can still emit a stored block even\n * when input comes from standard input. (This can also be done for\n * all blocks if lit_bufsize is not greater than 32K.)\n * - if compression is not successful for a file smaller than 64K, we can\n * even emit a stored file instead of a stored block (saving 5 bytes).\n * This is applicable only for zip (not gzip or zlib).\n * - creating new Huffman trees less frequently may not provide fast\n * adaptation to changes in the input data statistics. (Take for\n * example a binary file with poorly compressible code followed by\n * a highly compressible string table.) Smaller buffer sizes give\n * fast adaptation but have of course the overhead of transmitting\n * trees more frequently.\n * - I can\'t count above 4\n ' ' running index in l_buf ' $' Buffer for distances. To simplify the code, d_buf and l_buf have\n * the same number of elements. To use different lengths, an extra flag\n * array would be necessary.\n ' ' bit length of current block with optimal trees ' ' bit length of current block with static trees ' ' number of string matches in current block ' ' bit length of EOB code for last block ' ' total bit length of compressed file mod 2^32 ' ' bit length of compressed data sent mod 2^32 ' $' Output buffer. bits are inserted starting at the bottom (least\n * significant bits).\n ' $' Number of valid bits in bi_buf. All bits above the last valid bit\n * are always zero.\n ' $' Output a byte on the stream.\n * IN assertion: there is enough room in pending_buf.\n ' $' Minimum amount of lookahead, except at the end of the input file.\n * See deflate.c for comments about the MIN_MATCH+1.\n ' $' In order to simplify the code, particularly on 16 bit machines, match\n * distances are limited to MAX_DIST instead of WSIZE.\n ' ' in trees.c ' $' Mapping from a distance to a distance code. dist is the distance - 1 and\n * must not have side effects. _dist_code[256] and _dist_code[257] are never\n * used.\n ' ' Inline versions of _tr_tally for speed: ' ' _DEFLATE_H ' ' operation, extra bits, table bits ' ' bits in this part of the code ' ' offset in table or code value ' $' op values as set by inflate_table():\n 00000000 - literal\n 0000tttt - table link, tttt != 0 is the number of table index bits\n 0001eeee - length or distance, eeee is the number of extra bits\n 01100000 - end of block\n 01000000 - invalid code\n ' $' Maximum size of dynamic tree. The maximum found in a long but non-\n exhaustive search was 1444 code structures (852 for length/literals\n and 592 for distances, the latter actually the result of an\n exhaustive search). The true maximum is not known, but the value\n below is more than safe. ' ' Type of code to build for inftable() ' ' _INFTREES_H ' ' Possible inflate modes between inflate() calls ' ' i: waiting for magic header ' ' i: waiting for method and flags (gzip) ' ' i: waiting for modification time (gzip) ' ' i: waiting for extra flags and operating system (gzip) ' ' i: waiting for extra length (gzip) ' ' i: waiting for extra bytes (gzip) ' ' i: waiting for end of file name (gzip) ' ' i: waiting for end of comment (gzip) ' ' i: waiting for header crc (gzip) ' ' i: waiting for dictionary check value ' ' waiting for inflateSetDictionary() call ' ' i: waiting for type bits, including last-flag bit ' ' i: same, but skip check to exit inflate on new block ' ' i: waiting for stored size (length and complement) ' ' i/o: waiting for input or output to copy stored block ' ' i: waiting for dynamic block table lengths ' ' i: waiting for code length code lengths ' ' i: waiting for length/lit and distance code lengths ' ' i: waiting for length/lit code ' ' i: waiting for length extra bits ' ' i: waiting for distance code ' ' i: waiting for distance extra bits ' ' o: waiting for output space to copy string ' ' o: waiting for output space to write literal ' ' i: waiting for 32-bit check value ' ' i: waiting for 32-bit length (gzip) ' ' finished check, done -- remain here until reset ' ' got a data error -- remain here until reset ' ' got an inflate() memory error -- remain here until reset ' ' looking for synchronization bytes to restart inflate() ' $'\n State transitions between above modes -\n\n (most modes can go to the BAD or MEM mode -- not shown for clarity)\n\n Process header:\n HEAD -> (gzip) or (zlib)\n (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME\n NAME -> COMMENT -> HCRC -> TYPE\n (zlib) -> DICTID or TYPE\n DICTID -> DICT -> TYPE\n Read deflate blocks:\n TYPE -> STORED or TABLE or LEN or CHECK\n STORED -> COPY -> TYPE\n TABLE -> LENLENS -> CODELENS -> LEN\n Read deflate codes:\n LEN -> LENEXT or LIT or TYPE\n LENEXT -> DIST -> DISTEXT -> MATCH -> LEN\n LIT -> LEN\n Process trailer:\n CHECK -> LENGTH -> DONE\n ' ' state maintained between inflate() calls. Approximately 7K bytes. ' ' current inflate mode ' ' true if processing last block ' ' bit 0 true for zlib, bit 1 true for gzip ' ' true if dictionary provided ' ' gzip header method and flags (0 if zlib) ' ' zlib header max distance (INFLATE_STRICT) ' ' protected copy of check value ' ' protected copy of output count ' ' where to save gzip header information ' ' sliding window ' ' log base 2 of requested window size ' ' window size or zero if not using window ' ' valid bytes in the window ' ' window write index ' ' allocated sliding window, if needed ' ' bit accumulator ' ' input bit accumulator ' ' number of bits in "in" ' ' for string and stored block copying ' ' literal or length of data to copy ' ' distance back to copy string from ' ' for table and code decoding ' ' extra bits needed ' ' fixed and dynamic code tables ' ' starting table for length/literal codes ' ' starting table for distance codes ' ' index bits for lencode ' ' index bits for distcode ' ' dynamic table building ' ' number of code length code lengths ' ' number of length code lengths ' ' number of distance code lengths ' ' number of code lengths in lens[] ' ' next available space in codes[] ' ' temporary storage for code lengths ' ' work area for code table building ' ' space for code tables ' ' _INFLATE_H ' $'\n If you use the zlib library in a product, an acknowledgment is welcome\n in the documentation of your product. If for some reason you cannot\n include such an acknowledgment, I would appreciate that you keep this\n copyright string in the executable of your product.\n ' $'\n Build a set of tables to decode the provided canonical Huffman code.\n The code lengths are lens[0..codes-1]. The result starts at *table,\n whose indices are 0..2^bits-1. work is a writable array of at least\n lens shorts, which is used as a work area. type is the type of code\n to be generated, CODES, LENS, or DISTS. On return, zero is success,\n -1 is an invalid code, and +1 means that ENOUGH isn\'t enough. table\n on return points to the next available entry\'s address. bits is the\n requested root table index bits, and on return it is the actual root\n table index bits. It will differ if the request is greater than the\n longest code or if it is less than the shortest code.\n ' $' a code\'s length in bits ' ' index of code symbols ' ' minimum and maximum code lengths ' ' number of index bits for root table ' ' number of index bits for current table ' ' code bits to drop for sub-table ' ' number of prefix codes available ' ' code entries in table used ' ' Huffman code ' ' for incrementing code, index ' ' index for replicating entries ' ' low bits for current root entry ' ' mask for low root bits ' ' table entry for duplication ' ' next available space in table ' ' base value table to use ' ' extra bits table to use ' ' use base and extra for symbol > end ' ' number of codes of each length ' ' offsets in table for each length ' ' Length codes 257..285 base ' ' Length codes 257..285 extra ' ' Distance codes 0..29 base ' ' Distance codes 0..29 extra ' $'\n Process a set of code lengths to create a canonical Huffman code. The\n code lengths are lens[0..codes-1]. Each length corresponds to the\n symbols 0..codes-1. The Huffman code is generated by first sorting the\n symbols by length from short to long, and retaining the symbol order\n for codes with equal lengths. Then the code starts with all zero bits\n for the first code of the shortest length, and the codes are integer\n increments for the same length, and zeros are appended as the length\n increases. For the deflate format, these bits are stored backwards\n from their more natural integer increment ordering, and so when the\n decoding tables are built in the large loop below, the integer codes\n are incremented backwards.\n\n This routine assumes, but does not check, that all of the entries in\n lens[] are in the range 0..MAXBITS. The caller must assure this.\n 1..MAXBITS is interpreted as that code length. zero means that that\n symbol does not occur in this code.\n\n The codes are sorted by computing a count of codes for each length,\n creating from that a table of starting indices for each length in the\n sorted table, and then entering the symbols in order in the sorted\n table. The sorted table is work[], with that space being provided by\n the caller.\n\n The length counts are used for other purposes as well, i.e. finding\n the minimum and maximum length codes, determining if there are any\n codes at all, checking for a valid set of lengths, and looking ahead\n at length counts to determine sub-table sizes when building the\n decoding tables.\n ' ' accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) ' ' bound code lengths, force root to be within code lengths ' ' no symbols to code at all ' ' invalid code marker ' ' make a table to force an error ' ' no symbols, but wait for decoding to report error ' ' check for an over-subscribed or incomplete set of lengths ' ' over-subscribed ' ' incomplete set ' ' generate offsets into symbol table for each length for sorting ' ' sort symbols by length, by symbol order within each length ' $'\n Create and fill in decoding tables. In this loop, the table being\n filled is at next and has curr index bits. The code being used is huff\n with length len. That code is converted to an index by dropping drop\n bits off of the bottom. For codes where len is less than drop + curr,\n those top drop + curr - len bits are incremented through all values to\n fill the table with replicated entries.\n\n root is the number of index bits for the root table. When len exceeds\n root, sub-tables are created pointed to by the root entry with an index\n of the low root bits of huff. This is saved in low to check for when a\n new sub-table should be started. drop is zero when the root table is\n being filled, and drop is root when sub-tables are being filled.\n\n When a new sub-table is needed, it is necessary to look ahead in the\n code lengths to determine what size sub-table is needed. The length\n counts are used for this, and so count[] is decremented as codes are\n entered in the tables.\n\n used keeps track of how many table entries have been allocated from the\n provided *table space. It is checked when a LENS table is being made\n against the space in *table, ENOUGH, minus the maximum space needed by\n the worst case distance code, MAXD. This should never happen, but the\n sufficiency of ENOUGH has not been proven exhaustively, hence the check.\n This assumes that when type == LENS, bits == 9.\n\n sym increments through all symbols, and the loop terminates when\n all codes of length max, i.e. all codes, have been processed. This\n routine permits incomplete codes, so another loop after this one fills\n in the rest of the decoding tables with invalid code markers.\n ' ' set up for code type ' ' dummy value--not used ' ' DISTS ' ' initialize state for loop ' ' starting code ' ' starting code symbol ' ' starting code length ' ' current table to fill in ' ' current table index bits ' ' current bits to drop from code for index ' ' trigger new sub-table when len > root ' ' use root table entries ' ' mask for comparing low ' ' check available table space ' ' process all codes and make table entries ' ' create table entry ' ' end of block ' ' replicate for those indices with low len bits equal to huff ' ' save offset to next table ' ' backwards increment the len-bit code huff ' ' go to next symbol, update count, len ' ' create new sub-table if needed ' ' if first time, transition to sub-tables ' ' increment past last table ' ' here min is 1 << curr ' ' determine length of next table ' ' check for enough space ' ' point entry in root table to sub-table ' $'\n Fill in rest of table for incomplete codes. This loop is similar to the\n loop above in incrementing huff for table indices. It is assumed that\n len is equal to curr + drop, so there is no loop needed to increment\n through high index bits. When the current sub-table is filled, the loop\n drops back to the root table to fill in any remaining entries there.\n ' ' invalid code marker ' ' when done with sub-table, drop back to root table ' ' put invalid code marker in table ' ' backwards increment the len-bit code huff ' ' set return parameters ' ' _INFTREES_C ' $' Allow machine dependent optimization for post-increment or pre-increment.\n Based on testing to date,\n Pre-increment preferred for:\n - PowerPC G3 (Adler)\n - MIPS R5000 (Randers-Pehrson)\n Post-increment preferred for:\n - none\n No measurable difference:\n - Pentium III (Anderson)\n - M68060 (Nikl)\n ' ' (ancient) sunos ' $'\n Decode literal, length, and distance codes and write out the resulting\n literal and match bytes until either not enough input or output is\n available, an end-of-block is encountered, or a data error is encountered.\n When large enough input and output buffers are supplied to inflate(), for\n example, a 16K input buffer and a 64K output buffer, more than 95% of the\n inflate execution time is spent in this routine.\n\n Entry assumptions:\n\n state->mode == LEN\n strm->avail_in >= 6\n strm->avail_out >= 258\n start >= strm->avail_out\n state->bits < 8\n\n On return, state->mode is one of:\n\n LEN -- ran out of enough output space or enough available input\n TYPE -- reached end of block code, inflate() to interpret next block\n BAD -- error in block data\n\n Notes:\n\n - The maximum input bits used by a length/distance pair is 15 bits for the\n length code, 5 bits for the length extra, 15 bits for the distance code,\n and 13 bits for the distance extra. This totals 48 bits, or six bytes.\n Therefore if strm->avail_in >= 6, then there is enough input to avoid\n checking for available input while decoding.\n\n - The maximum bytes that a single length/distance pair can output is 258\n bytes, which is the maximum length that can be coded. inflate_fast()\n requires strm->avail_out >= 258 for each loop to avoid checking for\n output space.\n ' $' inflate()\'s starting value for strm->avail_out ' ' local strm->next_in ' ' while in < last, enough input available ' ' local strm->next_out ' $' inflate()\'s initial strm->next_out ' ' while out < end, enough space available ' ' maximum distance from zlib header ' ' window size or zero if not using window ' ' valid bytes in the window ' ' window write index ' ' allocated sliding window, if wsize != 0 ' ' local strm->hold ' ' local strm->bits ' ' local strm->lencode ' ' local strm->distcode ' ' mask for first level of length codes ' ' mask for first level of distance codes ' ' retrieved table entry ' ' code bits, operation, extra bits, or ' ' window position, window bytes to copy ' ' match length, unused bytes ' ' match distance ' ' where to copy match from ' ' copy state to local variables ' $' decode literals and length/distances until end-of-block or not enough\n input data or output space ' ' literal ' ' length base ' ' number of extra bits ' ' distance base ' ' number of extra bits ' ' max distance in output ' ' see if copy from window ' ' distance back in window ' ' very common case ' ' some from window ' ' rest from output ' ' wrap around window ' ' some from end of window ' ' some from start of window ' ' rest from output ' ' contiguous in window ' ' some from window ' ' rest from output ' ' copy direct from output ' ' minimum length is three ' ' 2nd level distance code ' ' 2nd level length code ' ' end-of-block ' $' return unused bytes (on entry, bits < 8, so in won\'t go too far back) ' ' update state and return ' $'\n inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):\n - Using bit fields for code structure\n - Different op definition to avoid & for extra bits (do & for table bits)\n - Three separate decoding do-loops for direct, window, and write == 0\n - Special case for distance > 1 copies to do overlapped load and store copy\n - Explicit branch predictions (based on measured branch probabilities)\n - Deferring match copy and interspersed it with decoding subsequent codes\n - Swapping literal/length else\n - Swapping window/direct else\n - Larger unrolled copy loops (three is about right)\n - Moving len -= 3 statement into middle of loop\n ' ' _INFFAST_C ' ' function prototypes ' ' to support ill-conceived Java test suite ' ' in case we return an error ' $'\n Return state with length and distance decoding tables and index sizes set to\n fixed code decoding. Normally this returns fixed tables from inffixed.h.\n If BUILDFIXED is defined, then instead this routine builds the tables the\n first time it\'s called, and returns those tables the first time and\n thereafter. This reduces the size of the code by about 2K bytes, in\n exchange for a little execution time. However, BUILDFIXED should not be\n used for threaded applications, since the rewriting of the tables and virgin\n may not be thread-safe.\n ' ' _INFFIXED_H ' $'\n Update the window with the last wsize (normally 32K) bytes written before\n returning. If window does not exist yet, create it. This is only called\n when a window is already in use, or when output has been written during this\n inflate call, but the end of the deflate stream has not been reached yet.\n It is also called to create a window for dictionary data when a dictionary\n is loaded.\n\n Providing output buffers larger than 32K to inflate() should provide a speed\n advantage, since only the last 32K of output is copied to the sliding window\n upon return from inflate(), and since all distances after the first 32K of\n output will fall in the output data, making match copies simpler and faster.\n The advantage may be dependent on the size of the processor\'s data caches.\n ' $' if it hasn\'t been done already, allocate space for the window ' ' if window not in use yet, initialize ' ' copy state->wsize or less output bytes into the circular window ' ' Macros for inflate(): ' ' check function to use adler32() for zlib or crc32() for gzip ' ' check macros for header crc ' ' Load registers with state in inflate() for speed ' ' Restore state from registers in inflate() ' ' Clear the input bit accumulator ' $' Get a byte of input into the bit accumulator, or return from inflate()\n if there is no input available. ' $' Assure that there are at least n bits in the bit accumulator. If there is\n not enough available input to do that, then return from inflate(). ' ' Return the low n bits of the bit accumulator (n < 16) ' ' Remove n bits from the bit accumulator ' ' Remove zero to seven bits as needed to go to a byte boundary ' ' Reverse the bytes in a 32-bit value ' $'\n inflate() uses a state machine to process as much input data and generate as\n much output data as possible before returning. The state machine is\n structured roughly as follows:\n\n for (;;) switch (state) {\n ...\n case STATEn:\n if (not enough input data or output space to make progress)\n return;\n ... make progress ...\n state = STATEm;\n break;\n ...\n }\n\n so when inflate() is called again, the same case is attempted again, and\n if the appropriate resources are provided, the machine proceeds to the\n next state. The NEEDBITS() macro is usually the way the state evaluates\n whether it can proceed or should return. NEEDBITS() does the return if\n the requested bits are not available. The typical use of the BITS macros\n is:\n\n NEEDBITS(n);\n ... do something with BITS(n) ...\n DROPBITS(n);\n\n where NEEDBITS(n) either returns from inflate() if there isn\'t enough\n input left to load n bits into the accumulator, or it continues. BITS(n)\n gives the low n bits in the accumulator. When done, DROPBITS(n) drops\n the low n bits off the accumulator. INITBITS() clears the accumulator\n and sets the number of available bits to zero. BYTEBITS() discards just\n enough bits to put the accumulator on a byte boundary. After BYTEBITS()\n and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.\n\n NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return\n if there is no input available. The decoding of variable length codes uses\n PULLBYTE() directly in order to pull just enough bytes to decode the next\n code, and no more.\n\n Some states loop until they get enough input, making sure that enough\n state information is maintained to continue the loop where it left off\n if NEEDBITS() returns in the loop. For example, want, need, and keep\n would all have to actually be part of the saved state in case NEEDBITS()\n returns:\n\n case STATEw:\n while (want < need) {\n NEEDBITS(n);\n keep[want++] = BITS(n);\n DROPBITS(n);\n }\n state = STATEx;\n case STATEx:\n\n As shown above, if the next state is also the next case, then the break\n is omitted.\n\n A state may also return if there is not enough output space available to\n complete that state. Those states are copying stored data, writing a\n literal byte, and copying a matching string.\n\n When returning, a "goto inf_leave" is used to update the total counters,\n update the check value, and determine whether any progress has been made\n during that inflate() call in order to return the proper return code.\n Progress is defined as a change in either strm->avail_in or strm->avail_out.\n When there is a window, goto inf_leave will update the window with the last\n output written. If a goto inf_leave occurs in the middle of decompression\n and there is no window currently, goto inf_leave will create one and copy\n output to the window for the next call of inflate().\n\n In this implementation, the flush parameter of inflate() only affects the\n return code (per zlib.h). inflate() always writes as much as possible to\n strm->next_out, given the space available and the provided input--the effect\n documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers\n the allocation of and copying into a sliding window until necessary, which\n provides the effect documented in zlib.h for Z_FINISH when the entire input\n stream available. So the only thing the flush parameter actually does is:\n when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it\n will return Z_BUF_ERROR if it has not reached the end of the stream.\n ' ' next input ' ' next output ' ' available input and output ' ' bit buffer ' ' bits in bit buffer ' ' save starting available input and output ' ' number of stored or match bytes to copy ' ' where to copy match bytes from ' ' current decoding table entry ' ' parent table entry ' ' length to copy for repeats, bits to drop ' ' return code ' ' buffer for gzip header crc calculation ' ' permutation of code lengths ' ' skip check ' ' gzip header ' ' expect zlib header ' ' check if zlib header allowed ' ' stored block ' ' fixed block ' ' decode codes ' ' dynamic block ' ' go to byte boundary ' ' handle error breaks in while ' ' build code tables ' ' copy from window ' ' copy from output ' $'\n Return from inflate(), updating the total counts and the check value.\n If there was no progress during the inflate() call, return a buffer\n error. Call updatewindow() to create and/or update the window state.\n Note: a memory error from inflate() is non-recoverable.\n ' ' check state ' ' check for correct dictionary id ' ' copy dictionary to window ' ' check state ' ' save header structure ' $'\n Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found\n or when out of input. When called, *have is the number of pattern bytes\n found in order so far, in 0..3. On return *have is updated to the new\n state. If on return *have equals four, then the pattern was found and the\n return value is how many bytes were read including the last byte of the\n pattern. If *have is less than four, then the pattern has not been found\n yet and the return value is len. In the latter case, syncsearch() can be\n called again with more data and the *have state. *have is initialized to\n zero for the first call.\n ' ' number of bytes to look at or looked at ' ' temporary to save total_in and total_out ' ' to restore bit buffer to byte string ' ' check parameters ' ' if first time, start search in bit buffer ' ' search available input ' ' return no joy or set up to restart inflate() on a new block ' $'\n Returns true if inflate is currently at the end of a block generated by\n Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP\n implementation to provide an additional safety check. PPP uses\n Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored\n block. When decompressing, PPP checks that at the end of input packet,\n inflate is waiting for these length bytes.\n ' ' check input ' ' allocate space ' ' copy state ' ' _INFLATE_C ' ' minimize memory usage for 16-bit DOS ' ' gzip magic header ' ' gzip flag byte ' ' bit 0 set: file probably ascii text ' ' bit 1 set: header CRC present ' ' bit 2 set: extra field present ' ' bit 3 set: original file name present ' ' bit 4 set: file comment present ' ' bits 5..7: reserved ' ' error code for last stream operation ' ' set if end of input file ' ' .gz file ' ' input buffer ' ' output buffer ' ' crc32 of uncompressed data ' ' error message ' ' path name for debugging only ' ' 1 if input file is not a .gz file ' ' fatal stream error => all other ops fail ' $' 1 to skip \'r\' crc checks ' ' 1 to skip destroy fclose ' $' 2-byte magic read and verified (\'v\') ' $' \'w\' or \'r\' ' ' start of compressed data in file (header skipped) ' ' bytes into deflate or inflate ' ' bytes out of deflate or inflate ' ' one character push-back ' ' true if push-back is last character ' $' ===========================================================================\n Opens a gzip (.gz) file for reading or writing. The mode parameter\n is as in fopen ("rb" or "wb"). The file is given either by FILE pointer\n or path name (if fp == 0).\n gz_open returns NULL if the file could not be opened or if there was\n insufficient memory to allocate the (de)compression state; errno\n can be checked to distinguish the two cases (if errno is zero, the\n zlib error is Z_MEM_ERROR).\n' ' compression level ' ' compression strategy ' ' copy of mode, without the compression level ' ' do this early for debugging ' ' copy the mode ' ' windowBits is passed < 0 to suppress zlib header ' $' windowBits is passed < 0 to tell that there is no zlib header.\n * Note that in this case inflate *requires* an extra "dummy" byte\n * after the compressed stream in order to complete decompression and\n * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are\n * present after the compressed stream.\n ' $' Write a very simple .gz header:\n ' flags time xflags $' We use 10L instead of ftell(s->file) to because ftell causes an\n * fflush on some systems. This version of the library doesn\'t use\n * start anyway in write mode, so this initialization is not\n * necessary.\n ' ' skip the .gz header ' $' ===========================================================================\n Associate a gzFile with the stdio stream fp.\n' ' for debugging ' $' ===========================================================================\n Read a byte from a gz_stream; update next_in and avail_in. Return EOF\n for end of file.\n IN assertion: the stream s has been sucessfully opened for reading.\n' $' ===========================================================================\n Check the gzip header of a gz_stream opened for reading. Set the stream\n mode to transparent if the gzip magic header is not present; set s->err\n to Z_DATA_ERROR if the magic header is present but the rest of the header\n is incorrect.\n IN assertion: the stream s has already been created sucessfully;\n s->stream.avail_in is zero for the first time, but may be non-zero\n for concatenated .gz files.\n' ' method byte ' ' flags byte ' $' Assure two bytes in the buffer so we can peek ahead -- handle case\n where first byte of header is at the end of the buffer after the last\n gzip segment ' ' Peek ahead to check the gzip magic header ' ' Check the rest of the gzip header ' ' Discard time, xflags and OS code: ' ' skip the extra field ' ' len is garbage if EOF but the loop below will quit anyway ' ' skip the original file name ' ' skip the .gz file comment ' ' skip the header crc ' $' ===========================================================================\n * Cleanup then free the given gz_stream. Return a zlib error code.\n Try freeing in the reverse order of allocations.\n ' ' fclose is broken for pipes in HP/UX ' $' ===========================================================================\n Reads the given number of uncompressed bytes from the compressed file.\n gzread returns the number of bytes actually read (0 for end of file).\n' ' starting point for crc computation ' ' == stream.next_out but not forced far (for MSDOS) ' ' EOF ' ' Copy first the lookahead bytes: ' ' Check CRC and original size ' $' The uncompressed length returned by above getlong() may be\n * different from s->out in case of concatenated .gz files.\n * Check for such files:\n ' $' ===========================================================================\n Reads a long in LSB order from the given gz_stream. Sets z_err in case\n of error.\n' ' _GZIO_C ' ' _GUNZIP_H ' $'\n * Standard Archive Format\n * USTAR - Uniform Standard Tape ARchive\n ' $' ustar and a null\t\t' $' 00 and no null\t\t' $'\n * values used in typeflag field\n ' $' regular file\t\t\t' $' alternate REGTYPE\t\t' $' hard link\t\t\t' $' soft link\t\t\t' $' character special\t\t' $' block special\t\t' $' directory\t\t\t' $' FIFO special\t\t\t' $' reserved\t\t\t' $' socket -- reserved\t\t' $' version -- reserved\t\t' $' extended header -- reserved\t' $'\n * bits used in mode field\n ' $' set uid on exec\t\t' $' set gid on exec\t\t' $' sticky bit -- reserved\t' $'\n * file permissions\n ' $' read by owner\t\t' $' write by owner\t\t' $' execute by owner\t\t' $' read by group\t\t' $' execute by group\t\t' $' write by group\t\t' $' read by other\t\t' $' write by other\t\t' $' execute by other\t\t' $'\n * the X/Open dd EBCDIC table\n ' $'\n * the X/Open dd IBM table\n ' $'\n * the mvs OpenEdition EBCDIC table\n ' $'\n * ascii text vs. control\n ' $'\n * remove dir and its subdirs\n ' $'\n * system(3) without PATH search that should work on all windows variants\n ' $'\n * execute cmd, chdir .., and remove sear_tmp\n ' FALLTHROUGH $'\n\t * commit on the first gzip magic char\n\t ' $'\n\t * loop on all the header blocks\n\t ' $'\n\t\t * last 2 blocks are NUL\n\t\t ' $'\n\t\t * verify the checksum\n\t\t ' $'\n\t\t * convert to the native charset\n\t\t ' $'\n\t\t * get the pathname, type and size\n\t\t ' $'\n\t\t * verify the dir prefix\n\t\t ' $'\n\t\t * check for non-local paths\n\t\t ' $'\n\t\t * create and grab the data\n\t\t ' FALLTHROUGH ' _RATZ_C ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/ratz.c typeset -A hashsum=( [md5]=bc5e98021e74f54e54405e6447844fa9 [sha1]=b9bfc568b909025f95c9f7f819f76035538f9387 ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/release.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * release -- list recent release changes\n *\n * coded for portability\n ' FALLTHROUGH ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/release.c typeset -A hashsum=( [md5]=64cb3bed5c524d8929e6fb846818d58c [sha1]=ee9cb807a90037196a8753cfb7eb6ba3634611bb ) ) [/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/socket.c]=( typeset -a comments=( $'**********************************************************************\n* *\n* This software is part of the ast package *\n* Copyright (c) 1994-2008 AT&T *\n* and is licensed under the *\n* Common Public License, Version 1.0 *\n* by AT&T *\n* *\n* A copy of the License is available at *\n* http://www.opensource.org/licenses/cpl1.0.txt *\n* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *\n* *\n* Information and Software Systems Research *\n* AT&T Research *\n* Florham Park NJ *\n* *\n* Glenn Fowler *\n* *\n**********************************************************************' $'\n * small test for -lnsl\n ' ) comments_parsed=true file_format=c_source fileformat_found=true filename=/home/test001/ksh93/ast_ksh_20080602/build_sparc_32bit/src/cmd/INIT/socket.c typeset -A hashsum=( [md5]=08b794e0771bff4ff58f91af41057a36 [sha1]=ef50eaaba5bad8a9a40bce712d6bfb1f0a143a64 ) )