开源软件构建与测试

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 2

_service:tar_scm:zziplib.spec Changed

@@ -1,10 +1,10 @@
 Name:            zziplib
-Version:         0.13.72
-Release:         2
+Version:         0.13.74
+Release:         1
 Summary:         Lightweight library for zip compression
 License:         LGPLv2+ or MPLv1.1
 URL:             http://zziplib.sourceforge.net
-Source0:         https://github.com/gdraheim/zziplib/archive/refs/tags/v0.13.72.tar.gz
+Source0:         https://github.com/gdraheim/zziplib/archive/refs/tags/v0.13.74.tar.gz
 
 BuildRequires:   perl-interpreter  zip xmlto
 BuildRequires:   zlib-devel SDL-devel pkgconfig autoconf automake gcc make
@@ -55,6 +55,7 @@
 %doc docs/COPYING* ChangeLog README TODO
 %{_bindir}/*
 %{_libdir}/*.so.*
+%exclude %{_datadir}/zziplib/*.cmake
 
 %files devel
 %doc docs/README.SDL docs/*.htm
@@ -68,8 +69,11 @@
 %{_mandir}/man3/*
 
 %changelog
--* Wed Jul  5 2023 dillon chen <dillon.chen@gmail.com> - 0.13.72-2
--- add -DZZIP_TESTCVE=OFF skip download test(curl github)
+* Tue Jul  9 2024 dillon chen <dillon.chen@gmail.com> - 0.13.74-1
+- update to 0.13.74
+
+* Wed Jul  5 2023 dillon chen <dillon.chen@gmail.com> - 0.13.72-2
+- add -DZZIP_TESTCVE=OFF skip download test(curl github)
 
 * Tue Sep 27 2022 dillon chen <dillon.chen@gmail.com> - 0.13.72-1
 - update to 0.13.72

_service Changed

_service:tar_scm:v0.13.72.tar.gz/azure-pipelines.yml Deleted

@@ -1,42 +0,0 @@
-# C/C++ with GCC
-# Build your C/C++ project with GCC using make.
-# Add steps that publish test results, save build artifacts, deploy, and more:
-# https://docs.microsoft.com/azure/devops/pipelines/apps/c-cpp/gcc
-
-trigger:
-- master
-- develop
-
-pool:
-  vmImage: 'ubuntu-latest'
-
-steps:
-- script: |
-    sudo apt-get update --fix-missing
-  displayName: 'install refresh'
-- script: |
-    sudo apt-get install --fix-broken --ignore-missing libsdl2-dev
-  displayName: 'install libsdl2-dev'
-- script: |
-    sudo apt-get install --fix-broken --ignore-missing python3-pip
-  displayName: 'install python3-pip'
-- script: |
-    pip3 install unittest-xml-reporting
-  displayName: 'install unittest-xml-reporting'
-- script: |
-    rm -rf build
-    mkdir build
-  displayName: 'build dir'
-- script: |
-    cd build && cmake -DTESTFLAGS=--xmlresults=TEST-zziplibs.xml -DZZIP_TESTCVE=OFF ..
-  displayName: 'configure'
-- script: |
-    cd build && make all VERBOSE=1
-  displayName: 'make all'
-- script: |
-    cd build && make check VERBOSE=1 || true
-  displayName: 'make check VERBOSE=1'
-- script: |
-    find . -name '*.xml'
-  displayName: 'find xml'
-- task: PublishTestResults@2

_service:tar_scm:v0.13.72.tar.gz/azure-test-results.md Deleted

_service:tar_scm:v0.13.72.tar.gz/docs/64on32.htm Deleted

@@ -1,195 +0,0 @@
-<section>  <date> 13. Aug 2003 </date>
-<h2> 64on32 largefile information </h2>
-
-<section>
-<h3> largefile problems </h3>
-
-<P>
-  Through actual problems with handling files larger than 2 Gigabyte,
-  I had to face the fact that there are serious problems with the
-  largefile implementation around shared-libraries. This is bound
-  to the effect that 64on32 platforms allow a preprocessor #define
-  _FILE_OFFSET_BITS=64 which will shift the integretal type of
-  off_t from a 32bit to a 64bit entity.
-</P>
-
-<P>
-  That will in fact lead to problems if an application is compiled
-  with a different off_t size than the shared-library it will be
-  linked to. Among the problems are different sizes of the callframe
-  for those functions that take an argument of off_t type. Note how
-  the "seek" call uses an off_t in the middle of its arguments which
-  may be 32bit or 64bit depending on a preprocessor define. And
-  you know that zziplib wraps up "seek"-like calls as well.
-</P>
-
-<P>
-  The observations were largely made independent of the zziplib 
-  however, as a zip-file does uses 32bit offsets in its header
-  fields anyway, and therefore a single zip-archive (or any of 
-  its wrapped files) can not be larger than 2 Gigabyte anyway.
-  I would to refer you for deeper information to my website
-  about this problem-space at
-</P>
-<p><center><big>
-  <a href="http://ac-archive.sf.net/largefile" remap="url">
-                  ac-archive.sf.net/largefile </a>
-</big></center></p>
-
-</section><section>
-<h3> zziplib related </h3>
-
-<P>
-  Still however the problems hold for zziplib usage when
-  the functions are linked dynamically as a shared-library.
-  Here we can face the fact that an application (or a higher
-  level library) uses a different off_t size than the
-  underlying zziplib shared-library.
-</P>
-
-<P>
-  If you read the <code>zzip/zzip.h</code> header file then
-  you will surely see a number of off_t usages around, here 
-  they are wrapped in the form of zzip_off_t to get away with
-  platforms not predefining off_t in the first place. Those
-  functions are (at the time of writing):
-<blockquote><ul>
-<li> <code>zzip_telldir</code> (return type) </li>
-<li> <code>zzip_seekdir</code> (second param) </li>
-<li> <code>zzip_tell</code> (return type) </li>
-<li> <code>zzip_seek</code> (second param of three)</li>
-</ul></blockquote>
-</P>
-
-<P>
-  What might be not as obvious however: you will find
-  also the off_t type being used in the plugin-handlers
-  callback functions. That is based on the fact that
-  the plugin-structures is filled by default with the
-  posix-functions from the C library. A 64on32 platform
-  however offers quite usually a mixedmode C library
-  exporting two symbols for tell/seek calls to match
-  either 32bit off_t or 64bit off_t
-<blockquote><ul>
-<li> <code>zzip_plugin_io->seeks</code> (return type and second param) </li>
-<li> <code>zzip_plugin_io->filesize</code> (return type) </li>
-</ul></blockquote>
-</P>
-
-<P>
-  The problem here: the application might not make use of
-  zzip_seek/zzip_tell explicitly, but may be the internal
-  implementation of a zzip call uses io->seeks or io->filesize.
-  When an application uses plugin-io with these callbacks
-  overridden then surely problems will arise.
-</P>
-
-</section><section>
-<h3> zziplib mixedmode option </h3>
-
-<P>
-  I have extended the zziplib implementation to allow itself to
-  live fine on 64on32 systems. The 64on32 system are like linux
-  and solaris where the default off_t is 32bit and only by the
-  preprocessor hint they shift into 64bit. The C library on
-  these systems is a mixedmode one offering a pair for each of
-  the problematic functions - lseek <em>and</em> lseek64 for
-  example.
-</P>
-
-<P>
-  The zziplib header file detects when it is present on a
-  64on32 system (through hints in configured zzip/conf.h)
-  and that _FILE_OFFSET_BITS has been set to 64bit. In that
-  case it does automatically issue #defines that shift the
-  symbol-name from zzip_seek into zzip_seek64. Likewise,
-  <em>all</em> the *_ext_io functions are renamed into
-  *_ext_io64 calls
-</P>
-
-<P>
-  The zziplib library itself will also pick up the renamings
-  when it is compiled with 64bit off_t - in effect an application
-  with a 64bit-off_t dependency can only link with a zziplib
-  compiled in 64bit-off_t mode. If the application does not
-  use any call symbol with an off_t dependency then it does 
-  not matter and the link will succeed. That's simply because
-  function calls without an off_t dependency will not be
-  renamed and they are the same for a 32bit-off_t zziplib or
-  a 64bit-off_t zziplib.
-</P>
-
-<P>
-  As an extra, the zziplib exports a few of its common calls
-  like being a mixedmode library when you compile it both in
-  64bit mode and as a shared library. In that case, the 
-  resulting shared library will export symbol pairs for the
-  calls with an off_t dependency, i.e. both zzip_seek and
-  zzip_seek64 are present.
-</P>
-
-<P>
-  Note that for reasons of being a lightweight library, the
-  zziplib library does not export mixmode call pairs for
-  the *_ext_io family of functions. The current generation
-  of zziplib does call io->seeks unconditionally of any
-  case'ing flag and so far there are no problems with the
-  current design.
-</P>
-
-</section><section>
-<h3> Implementation details </h3>
-
-<P>
-  In the header file zzip/zzip.h you will find the define
-  ZZIP_LARGEFILE_RENAME which triggers the renaming process.
-  See zzip/conf.h on the conditions where it is being triggered.
-</P>
-
-<P>
-  For the implementation of the mixedmode symbol pairs, see
-  zzip/dir.c for an example for the zzip_seekdir/zzip_seekdir64
-  pair - here we use libtools -DPIC to detect the situation of 
-  being compiled as shared-library, we use the preprocessor
-  #def ZZIP_LARGEFILE_RENAME to know we are on a 64on32
-  system compiled in 64bit-off_t, and we check the transitional
-  largefile API to be present by looking for EOVERFLOW errno.
-</P>
-
-<P>
-  When all the three are present then we simply #undef the
-  renaming preprocessor macro and define a function symbol 
-  (without the renaming) and call the renamed symbol 
-  already compiled a few lines before. We use the pre-off_t
-  type "long" for the 32bit entity of these calls. While
-  we mostly let the compiler do the shrink/expand of these
-  integer types, we do also sometimes check for overflows
-  of the seekvalue.
-</P>
-
-</section><section>
-<h3> rpm extras and pkg-config </h3>
-
-<P>
-  The provided .spec file shows how to compile both variants
-  of the zziplib shared library and to install them in
-  parallel in the system. Also we provide doubled sets
-  of .pc files for pkg-config installation. That should make
-  it a lot easier for applications to link to the correct
-  library they want.
-</P>
-
-<P>
-  Here are all the variants that you can find after installing
-  the vanilla rpm files from zziplib.sf.net:
-<pre>
-$ pkg-config --list-all | sort | grep zzip
-zziplib32                   zziplib32 - ZZipLib - libZ-based ZIP-access Library
-zziplib64                   zziplib64 - ZZipLib - libZ-based ZIP-access Library
-zziplib                     zziplib - ZZipLib - libZ-based ZIP-access Library
-zzip-sdl-config             zzip-sdl-config - SDL Config (for ZZipLib)
-zzip-sdl-rwops              zzip-sdl-rwops - SDL_rwops for ZZipLib
-zzipwrap                    zzipwrap - Callback Wrappers for ZZipLib
-zzip-zlib-config            zzip-zlib-config - ZLib Config (for ZZipLib)
-</pre></P>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/configs.htm Deleted

@@ -1,164 +0,0 @@
-<section> <date> February 2003 </date>
-<h2> Configuration </h2>                    of other projects using zziplib
-
-
-
-<P>
-  If using the zziplib with other project then you can use a number
-  of possibility to configure and link. The zziplib had been usually
-  included within the projects that made use of it - some did even
-  pick up the advantage to be allowed to staticlink in a limited
-  set of conditions. Recently however, the zziplib is shipped as a
-  standard library of various linux/freebsd distros - mostly for
-  the usage by the php-zip module. This allows third party software
-  makers to link to the preinstalled library in the system and
-  consequently reduce the memory consumption - even more than now
-  with the zziplib being a lightweight anyway (the i386 .so is 
-  usually less than 20k)
-</P>
-
-<section>
-<h3> pkg-config --libs </h3>
-
-<P>
-  Within modern software development, one should be advised to use
-  pkg-config as soon as it is available. The pkg-config helper can
-  handle a lot of problems that can usually come up with linking
-  to third party libraries in case that those link again dynamically
-  with other libraries themselves. It does correctly order the
-  list of "libs", it can throw away duplicate "-L" hints, and same
-  for cflags "-I" hints, plus it will throw away some sys-includes
-  that gcc3.2 will warn about with a false positive.
-</P>
-<P>
-  There is a number of pkg-config targets installed in the system
-  but the one you want to use is <b>pkg-config zziplib</b>. 
-  Therefore, a simple Makefile could read like
-  <pre>
-    PROGRAM = my_prog
-    CFLAGS = -Dhappy `pkg-config zziplib --cflags`
-    LIBS   = -Wl,-E  `pkg-config zziplib --libs`
-
-    my_prog.o : my_prog.c
-       $(CC) $(CFLAGS) $&lt; -o $@
-    my_prog : my_prog.o
-       $(LINK) $&lt; $(LIBS)
-  </pre>
-</P>
-<P>
-   The `pkg-config zziplibs --libs` will usually expand to 
-   something like <code>-lzzip -lz</code> which are the
-   two (!!) libraries that you need to link with - in that
-   order. The zziplib builds on top of the z-lib algorithms
-   for compression of files within the zip-archive. That's
-   the same for other lib-parts of the zziplib project as
-   well, e.g. the sdl-rwops part which does also need to
-   link with the sdl-lib - and that's where the pkg-config
-   infrastructure can be of great help. That's the reason
-   why zziplib installs a few more ".pc" files, you can
-   get a list of them like this:
-   <pre>
-   $ pkg-config --list-all | sort | grep zzip
-   zziplib               zziplib - ZZipLib - libZ-based ZIP-access Library
-   zzip-sdl-config       zzip-sdl-config - SDL Config (for ZZipLib)
-   zzip-sdl-rwops        zzip-sdl-rwops - SDL_rwops for ZZipLib
-   zzipwrap              zzipwrap - Callback Wrappers for ZZipLib
-   zzip-zlib-config      zzip-zlib-config - ZLib Config (for ZZipLib)
-   </pre>
-</P><P>
-   The two entries like "zzip-sdl-config" and "zzip-zlib-config"
-   happen to be ".pc" files for the libz.so and libSDL.so that
-   were seen at configure-time of zziplib - you may want to reuse
-   these in your projects as well whenever you need to link to
-   either of zlib or libsdl even in places where there is no direct
-   need for zziplib. It basically looks like:
-   <pre>
-   $ pkg-config zzip-zlib-config --modversion
-   1.1.4
-   $ pkg-config zzip-zlib-config --libs      
-    -lz  
-   </pre>
-</P>
-
-</section><section>
-<h3> zzip-config </h3>
-<P>
-   The pkg-config ".pc" files are relatively young in the history of
-   zziplib. A long time before that there was the `zzip-config`
-   script installed in the system. These `*-config` were common
-   before the pkg-config came about, and in fact the pkg-config
-   infrastructure was invented to flatten away the problems of
-   using multiple `*-config` scripts for a project. As long as you
-   do not combine multiple `*-config`s then it should be well okay
-   to use the `zzip-config` directly - it does also kill another
-   dependency on the `pkg-config` tool to build your project, the
-   zziplib is all that's needed.
-</P>
-<P>
-   In its call-structure the `zzip-config` script uses the same
-   options as `pkg-config`, (well they are historic cousins anyway).
-   and that simply means you can replace each call above like
-   `pkg-config zziplib...` with `zzip-config...`.
-
-  <pre>
-    PROGRAM = my_prog
-    CFLAGS = -Dhappy `zzip-config --cflags`
-    LIBS   = -Wl,-E  `zzip-config --libs`
-
-    my_prog.o : my_prog.c
-       $(CC) $(CFLAGS) $&lt; -o $@
-    my_prog : my_prog.o
-       $(LINK) $&lt; $(LIBS)
-  </pre>
-</P>
-<P>
-   Be informed that the zzip-config script is low-maintained and
-   starting with 2004 it will be replaced with a one-line script 
-   that simply reads `pkg-config zziplib $*`. By that time the
-   rpm/deb packages will also list "pkgconfig" as a dependency
-   on the zziplib-devel/zziplib-dev part.
-</P>
-
-</section><section>
-<h3> autoconf macro </h3>
-
-<P>
-  There is currently an autoconf macro installed along into
-  the usual /usr/share/aclocal space for making it easier for
-  you to pick up the configure-time cflags/libs needed to
-  build/link with zziplib. In any way it does look like
-  this:
-  <pre>
-  dnl PKG_CHECK_ZZIPLIB(ZSTUFF, min-version, action-if, action-not)
-  AC_DEFUN(PKG_CHECK_ZZIPLIB,dnl
-  PKG_CHECK_MODULES($1, zziplib $2, $3, $4))
-  </pre>
-</P>
-<P>
-  You are strongly advised to take advantage of the pkgconfig's
-  macro directly - you can find the macro in
-  <code>/usr/share/aclocal/pkg.m4</code> and it allows to
-  combine the flags of a list of library modules that you
-  want to have. If it is only zziplib, than you could simply
-  use this in your configure.ac:
-<pre>
-  <b>PKG_CHECK_MODULES</b>(<b>ZZIP</b>,zziplib &gt;= 0.10.75)
-  </pre>
-</P><P>
-  which will provide you with two autoconf/automake variables
-  named <b><code>ZZIP_CFLAGS</code></b> and <b><code>ZZIP_LIBS</code></b> 
-  respectively.
-</P>
-<P>
-  Up to 2004, the macro in zziplib.m4 will be however carry
-  a copy of the pkg.m4 so that you do not need another
-  dependency for your software project. The macro is called
-  like shown above PKG_CHECK_ZZIPLIB and you would call it
-  like
-<br><code>&nbsp;&nbsp;&nbsp;&nbsp;
-  PKG_CHECK_ZZIPLIB(ZZIP,0.10.75)</code><br>
-  which will give you the two autoconf/automake variables
-  as well,  <code>ZZIP_CFLAGS</code> and <code>ZZIP_LIBS</code>
-</P>
-
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/copying.htm Deleted

@@ -1,113 +0,0 @@
-<section> <date> 2004 </date>
-<h2> COPYING - license information </h2> the public license terms
-
-<P>
-  The zziplib is a small library that allows for some parts of
-  obfuscation. This is very handy in commercial projects which tend
-  to incorporate a copy into their source tree. And with 
-  <a href="zzip-xor.htm">obfuscation</a> it is often advisable 
-  to staticlink the zziplib part and `strip` the symbols from 
-  the resulting binary - in order to obfuscate the usage of a 
-  standard library for semi-`encryption` of data files.
-</P>
-
-<P>
-  In the past I have been modifying the original LGPL license
-  with a text that allows staticlinking thereby taking over a
-  few paragraphs from the MPL as restrictions to do so, just to 
-  defend against improper usage. However I kept being asked 
-  legalese questions since most people do not want to interpret 
-  added text either and on their own without a lawyer. However
-  that accounts to me as well.
-</P>
-<P>
-  The public license(s) are simply there to protect me and
-  my work, none of this is fixed and it is neither the only  
-  possible way to get hold of a proper license. You can 
-  always contact me to negotiate a special one if you do 
-  need so. In most cases I will just say okay and you get 
-  it for free, perhaps after some presentations I will 
-  ask for som tax-reductable compensation sent to
-  a wellfare organisation (never me!).
-</P>
-<P>
-  A last hint from a friend did make me think as well, as
-  that the whole point of using standard public licenses
-  is to protect against the need to use your own lawyers
-  in the case that someone breaks the license rules. If
-  one uses a standard license then it is in the interest
-  of that big organization XY that the license will be
-  enforced and that it will be shown valid in all courts.
-  At the time of writing, no opensource license has
-  ever been discussed to an end in a court trial.
-</P>
-<P>
-  That's why at last, I decided to change the COPYING 
-  details once again - and start shipping under a dual
-  MPL / LGPL license where each of them is separate 
-  and restrictions apply alternatively. Remember that 
-  each license is non-exclusive anyway, and I can give
-  out as many licenses as I want, here we have one as
-  MPL, then we have one as LGPL, and perhaps you ask me
-  for a third text to send you over. The public ones
-  are just there for you as a free choice which you can
-  pick without negotiations or a fee.
-</P>
-<P>
-  And yes, you will be on established legal grounds as 
-  long as you restrict your usage of the library to the 
-  details contained in either COPYING text. And better
-  yet, the legal possibilities have been discussed
-  a few hundred times before. You will surely find
-  good answers on the internet as well to guide you
-  to decisions in your company whether zziplib may
-  be adopted for a specific task.
-</P>
-<P>
-  The sources themselves are sent out under a dual license, 
-  with both MPL and LGPL license options, and as long as 
-  the MPL part is  not removed then the recpient of some
-  modified sources will be entitled to the same choice
-  among the public licenses of LGPL / MPL. Note that some
-  example sources are given away under the ZLIB license
-  which is nothing more than asking for nice behavior 
-  which should have been the case even without such a text.
-  <small><small>(However, it is just a fact that some people 
-  happen to behave anti-social especially under pressure of 
-  capitalist needs, said to lower the risks for commercial 
-  success/failure of a company. You have to enforce good
-  behavior or it will be "forgotten". With a license it is
-  not just an error, it is a risk in itself to forget about it)
-  </small></small>
-</P>
-<P>
-  As for staticlinking, let us explore that a bit - there has 
-  been a debate that the LGPL warrants in fact the freedom of 
-  the final recipient as you must give him the original or 
-  modified sources of zziplib, to allow them to modify that 
-  part again, and then (re-)link to your own parts. Your own
-  parts may come in the form of precompiled objects without
-  sources (as opposed to the GPL restrictions). In here, it
-  is simply easier to use a dynamic linker that does the 
-  re-linking job at startup-time of the whole project instead 
-  to provide a makefile and linkage descriptions to let the
-  user do the staticlink it into a combined executable object. 
-  The latter however is often needed for embedded environments
-  and it is quite of the original motivation to ask for a
-  staticlink option where in fact the LGPL does allow it anyway
-  as long as you ship all parts separatly as well.
-</P>
-
-<P>
-  The MPL defines the area of a combined work a bit differently,
-  in a way it derives some ideas from BSD'ish licenses. This
-  part does more care to protect the `Intellectual Properties`
-  of the original developers. It does ask to prominently show 
-  off that you have gone to link with the work of someone else 
-  in your project. Take special note of <em>"3.5 Required Notices"</em>, 
-  <em>"3.6 Distribution of Executable Versions"</em> and
-  <em>"3.7 Larger Works"</em> here. Or read a lawyer text on
-  the legal result of the whole license.
-</P>
-
-</section>

_service:tar_scm:v0.13.72.tar.gz/docs/cpp2markdown-1.py Deleted

@@ -1,250 +0,0 @@
-#! /usr/bin/env python3
-
-import pygments.lexers.compiled as lexer
-import optparse
-import re
-from pygments.token import Token
-import logging
-
-logg = logging.getLogger(__name__)
-
-FileComment = "FileComment"
-FileInclude = "FileInclude"
-FunctionComment = "FunctionComment"
-FunctionPrototype = "FunctionPrototype"
-
-# use the markdown lexer to identify elements
-# then filter only those we want. The returned
-# token list is more global flagging the role
-# of each token for the manual generation.
-class CppToMarkdown:
-    def __init__(self):
-        self.alldefinitions = 0
-        self.internaldefs = "static"
-        self.filecomment_done = ""
-        self.fileinclude_done = ""
-        self.filecomment_text = ""
-        self.fileinclude_text = ""
-        self.comment_text = ""
-        self.function_text = ""
-        self.nesting = 0
-    def split_copyright(self, text):
-        # there are two modes - the copyright starts in the first line
-        # and the source description follows or the other way round.
-        lines = text.split("\n")
-        if len(lines) <= 2:
-            return "", text
-        introtext = lines0
-        copyright = lines0
-        check1 = re.compile(r"^\s*\s+(cC)")
-        check2 = re.compile(r"^\s*\s+\bCcopyright\b")
-        empty1 = re.compile(r"^\s*\s*$")
-        state = "intro"
-        for i in xrange(1,len(lines)-1):
-            line = linesi
-            if state == "intro":
-                if empty1.match(line):
-                    introtext +=  line 
-                    continue
-                if check1.match(line) or check2.match(line):
-                    state = "copyrightfirst"
-                    copyright +=  line 
-                else:
-                    state = "introtextfirst"
-                    introtext +=  line 
-            elif state == "copyrightfirst":
-                if empty1.match(line):
-                    state = "introtextlast"
-                    introtext +=  line 
-                else:
-                    copyright +=  line 
-            elif state == "introtextfirst":
-                if check1.match(line) or check2.match(line):
-                    state = "copyrightlast"
-                    copyright +=  line 
-                else:
-                    introtext +=  line 
-            elif state == "copyrightlast":
-                copyright +=  line 
-            elif state == "introtextlast":
-                introtext +=  line 
-            else:
-                logg.fatal("UNKNOWN STATE %s", state)
-        introtext += lines-1
-        copyright += lines-1
-        logg.debug("@ COPYRIGHT\n %s", copyright)
-        logg.debug("@ INTROTEXT\n %s", introtext)
-        return "\n".join(copyright), "\n".join(introtext)
-    def commentblock(self, text):
-        prefix = re.compile(r"(?s)^\s*/*+(^\n*)(?=\n)")
-        suffix = re.compile(r"(?s)\n */\s*")
-        empty = re.compile(r"(?s)\n * \t*(?=\n)")
-        lines1 = re.compile(r"(?s)\n * \t")
-        lines2 = re.compile(r"(?s)\n * ")
-        lines3 = re.compile(r"(?s)\n *\t\t")
-        lines4 = re.compile(r"(?s)\n *\t")
-        text = suffix.sub("\n", text)
-        text = prefix.sub("> \\1\n", text)
-        text = empty.sub("\n", text)
-        text = lines1.sub("\n     ", text)
-        text = lines2.sub("\n", text)
-        text = lines3.sub("\n         ", text)
-        text = lines4.sub("\n     ", text)
-        return text
-    def functionblock(self, text):
-        empty = re.compile(r"(?s)\n \t*(?=\n)")
-        text = "    " + text.replace("\n", "\n    ")
-        text = empty.sub("", text) 
-        return text
-    def functionname(self, text):
-        check1 = re.compile(r"^^()=*(\b\w+)\s*(=")
-        found = check1.match(text)
-        if found:
-            return found.group(1)
-        check2 = re.compile(r"^^()=*(\b\w+)\s*$")
-        found = check2.match(text)
-        if found:
-            return found.group(1)
-        return ""
-    def run(self, filename):
-        filetext = open(filename).read()
-        for line in self.process(filetext, filename):
-            print(line)
-    def process(self, filetext, filename=""):
-        section_ruler = "-----------------------------------------"
-        copyright = ""
-        for token, text in self.parse(filetext):
-            if token == FileInclude:
-                yield "## SOURCE " + filename.replace("../", "")
-                yield "    #" + text.replace("\n", "\n    ")
-            elif token == FileComment:
-                yield "### INTRODUCTION"
-                copyright, introduction = self.split_copyright(text)
-                yield self.commentblock(introduction)
-            elif token == FunctionPrototype:
-                name = self.functionname(text)
-                yield section_ruler
-                yield "### " + name
-                # yield '<a id="%s"></a>' % name
-                yield "#### NAME"
-                yield "    " + name
-                yield "#### SYNOPSIS"
-                yield self.functionblock(text)
-            elif token == FunctionComment:
-                if text:
-                    yield "#### DESCRIPTION"
-                    yield self.commentblock(text)
-            else:
-                if text:
-                    yield "#### NOTES"
-                    print(token + " " + text.replace("\n", "\n  "))
-        if copyright:
-            yield section_ruler
-            yield "### COPYRIGHT"
-            yield self.commentblock(copyright)            
-    def isexported_function(self):
-        function = self.function_text.strip().replace("\n"," ")
-        logg.debug("@ --------------------------------------") 
-        logg.debug("@ ALLDEFINITIONS %s", self.alldefinitions)
-        if function.startswith("static ") and self.alldefinitions < 3:
-            logg.debug("@ ONLY INTERNAL %s", function)
-            return False
-        if not self.comment_text:
-            if not self.alldefinitions:
-                logg.info("@ NO COMMENT ON %s", function)
-                return False
-            else:
-                logg.warn("@ NO COMMENT ON %s", function)
-        text = self.comment_text
-        if text.startswith("/**"): return True
-        if text.startswith("/*!"): return True
-        if text.startswith("///"): return True
-        if text.startswith("//!"): return True
-        if self.alldefinitions >= 1:
-            if text.startswith("/*"): return True
-            if text.startswith("//"): return True
-        if self.alldefinitions >= 2:
-            return True
-        logg.debug("@ NO ** COMMENT %s", self.function_text.strip())
-        defs = self.function_text
-        return False
-    def parse(self, filetext):
-        c = lexer.CLexer()
-        for token, text in c.get_tokens(filetext):
-            logg.debug("|| %s %s", token, text.replace("\n", "\n |"))
-            # completion
-            if token != Token.Comment.Preproc and self.fileinclude_done == "no":
-                    yield FileInclude, self.fileinclude_text
-                    if self.filecomment_text:
-                        yield FileComment, self.filecomment_text
-                    self.fileinclude_done = "done"
-            # parsing
-            if token == Token.Comment.Multiline:
-                if not self.filecomment_done:
-                    self.filecomment_done = "done"
-                    self.filecomment_text = text
-                    # wait until we know it is not a function documentation
-                    self.comment_text = text
-                else:
-                    self.comment_text = text
-            elif token == Token.Comment.Preproc and "include" in text:
-                if not self.fileinclude_done:
-                    self.fileinclude_done = "no"
-                    self.fileinclude_text += text
-                    self.comment_text = ""
-            elif token == Token.Comment.Preproc and self.fileinclude_done == "no":
-                if not "\n" in self.fileinclude_text:
-                    self.fileinclude_text += text
-                self.comment_text = ""
-            elif token == Token.Comment.Preproc:

_service:tar_scm:v0.13.72.tar.gz/docs/cpp2markdown.py Deleted

@@ -1,197 +0,0 @@
-from __future__ import print_function
-
-import pygments.lexers.compiled as lexer
-import optparse
-import re
-from pygments.token import Token
-import logging
-
-logg = logging.getLogger(__name__)
-
-FileComment = "FileComment"
-FileInclude = "FileInclude"
-FunctionComment = "FunctionComment"
-FunctionPrototype = "FunctionPrototype"
-
-# use the markdown lexer to identify elements
-# then filter only those we want. The returned
-# token list is more global flagging the role
-# of each token for the manual generation.
-class CppToMarkdown:
-    def __init__(self):
-        self.alldefinitions = 0
-        self.internaldefs = "static"
-        self.filecomment_done = ""
-        self.fileinclude_done = ""
-        self.filecomment_text = ""
-        self.fileinclude_text = ""
-        self.comment_text = ""
-        self.function_text = ""
-        self.nesting = 0
-    def commentblock(self, text):
-        emptyprefix = re.compile(r"(?s)^\s*/*+ \t*(?=\n)")
-        prefix = re.compile(r"(?s)^\s*/*+(^\n*)(?=\n)")
-        suffix = re.compile(r"(?s)\n */\s*")
-        empty = re.compile(r"(?s)\n * \t*(?=\n)")
-        lines1 = re.compile(r"(?s)\n * \t")
-        lines2 = re.compile(r"(?s)\n * ")
-        lines3 = re.compile(r"(?s)\n *\t\t")
-        lines4 = re.compile(r"(?s)\n *\t")
-        text = suffix.sub("\n", text)
-        text = emptyprefix.sub("", text)
-        text = prefix.sub("> \\1\n", text)
-        text = empty.sub("\n", text)
-        text = lines1.sub("\n     ", text)
-        text = lines2.sub("\n", text)
-        text = lines3.sub("\n         ", text)
-        text = lines4.sub("\n     ", text)
-        return text
-    def functionblock(self, text):
-        empty = re.compile(r"(?s)\n \t*(?=\n)")
-        text = "    " + text.replace("\n", "\n    ")
-        text = empty.sub("", text) 
-        return text
-    def functionname(self, text):
-        check1 = re.compile(r"^^()=*(\b\w+)\s*(=")
-        found = check1.match(text)
-        if found:
-            return found.group(1)
-        check2 = re.compile(r"^^()=*(\b\w+)\s*$")
-        found = check2.match(text)
-        if found:
-            return found.group(1)
-        return ""
-    def run(self, filename):
-        filetext = open(filename).read()
-        for line in self.process(filetext, filename):
-            print(line)
-    def process(self, filetext, filename=""):
-        for token, text in self.parse(filetext):
-            if token == FileInclude:
-                yield "## SOURCE " + filename.replace("../", "")
-                yield "    #" + text.replace("\n", "\n    ")
-            elif token == FileComment:
-                yield "## INTRODUCTION"
-                yield self.commentblock(text)
-            elif token == FunctionPrototype:
-                name = self.functionname(text)
-                yield "-----------------------------------------"
-                yield "### " + name
-                yield "#### NAME"
-                yield "    " + name
-                yield "#### SYNOPSIS"
-                yield self.functionblock(text)
-            elif token == FunctionComment:
-                if text:
-                    yield "#### DESCRIPTION"
-                    yield self.commentblock(text)
-            else:
-                if text:
-                    yield "#### NOTES"
-                    print(token + " " + text.replace("\n", "\n  "))
-    def isexported_function(self):
-        function = self.function_text.strip().replace("\n"," ")
-        logg.debug("@ --------------------------------------") 
-        logg.debug("@ ALLDEFINITIONS %s", self.alldefinitions)
-        if function.startswith("static ") and self.alldefinitions < 3:
-            logg.debug("@ ONLY INTERNAL %s", function)
-            return False
-        if not self.comment_text:
-            if not self.alldefinitions:
-                logg.info("@ NO COMMENT ON %s", function)
-                return False
-            else:
-                logg.warn("@ NO COMMENT ON %s", function)
-        text = self.comment_text
-        if text.startswith("/**"): return True
-        if text.startswith("/*!"): return True
-        if text.startswith("///"): return True
-        if text.startswith("//!"): return True
-        if self.alldefinitions >= 1:
-            if text.startswith("/*"): return True
-            if text.startswith("//"): return True
-        if self.alldefinitions >= 2:
-            return True
-        logg.debug("@ NO ** COMMENT %s", self.function_text.strip())
-        defs = self.function_text
-        return False
-    def parse(self, filetext):
-        c = lexer.CLexer()
-        for token, text in c.get_tokens(filetext):
-            logg.debug("|| %s %s", token, text.replace("\n", "\n |"))
-            # completion
-            if token != Token.Comment.Preproc and self.fileinclude_done == "no":
-                    yield FileInclude, self.fileinclude_text
-                    if self.filecomment_text:
-                        yield FileComment, self.filecomment_text
-                    self.fileinclude_done = "done"
-            # parsing
-            if token == Token.Comment.Multiline:
-                if not self.filecomment_done:
-                    self.filecomment_done = "done"
-                    self.filecomment_text = text
-                    # wait until we know it is not a function documentation
-                    self.comment_text = text
-                else:
-                    self.comment_text = text
-            elif token == Token.Comment.Preproc and "include" in text:
-                if not self.fileinclude_done:
-                    self.fileinclude_done = "no"
-                    self.fileinclude_text += text
-                    self.comment_text = ""
-            elif token == Token.Comment.Preproc and self.fileinclude_done == "no":
-                if not "\n" in self.fileinclude_text:
-                    self.fileinclude_text += text
-                self.comment_text = ""
-            elif token == Token.Comment.Preproc:
-                    self.comment_text = ""
-                    self.function_text = ""
-            elif token == Token.Operator and text == "=":
-                if not self.nesting and self.function_text.strip():
-                    if self.isexported_function():
-                        yield FunctionPrototype, self.function_text
-                        yield FunctionComment, self.comment_text
-                self.comment_text = ""
-                self.function_text = ""
-            elif token == Token.Punctuation and text == ";":
-                self.comment_text = ""
-                self.function_text = ""
-            elif token == Token.Punctuation and text == "{":
-                if not self.nesting and self.function_text.strip():
-                    if self.isexported_function():
-                        yield FunctionPrototype, self.function_text
-                        yield FunctionComment, self.comment_text
-                self.comment_text = ""
-                self.function_text = ""
-                self.nesting += 1
-            elif token == Token.Punctuation and text == "}":
-                self.nesting -= 1
-                self.comment_text = ""
-                self.function_text = ""
-            else:
-                if not self.nesting:
-                    self.function_text += text
-                else:
-                    pass # yield "|",text
-                
-
-if __name__ == "__main__":
-    _o = optparse.OptionParser()
-    _o.add_option("-v", "--verbose", action="count", default=0)
-    _o.add_option("-a", "--all", action="count", default=0,
-                  help="include all definitions in the output (not only /**)")
-    opt, args = _o.parse_args()
-
-    logg.addHandler(logging.StreamHandler())
-    if opt.verbose:
-        logg.setLevel(logging.WARN - 10 * opt.verbose)
-    
-    c = CppToMarkdown()
-    if opt.all:
-        c.alldefinitions = opt.all
-    for arg in args:
-        c.run(arg)
-    
-    
-
-

_service:tar_scm:v0.13.72.tar.gz/docs/developer.htm Deleted

@@ -1,75 +0,0 @@
-<section> <date> 2009-08-23 </date>
-<H2> Developer </H2> sourceforge SVN area
-
-<center>
-<a href="http://zziplib.svn.sourceforge.net/viewvc/zziplib/">
-         http://zziplib.svn.sourceforge.net/viewvc/zziplib/ </a>
-</center>
-
-<P>
-  The zziplib is using the Subversion repository of sourceforge
-  for development. (originally it used the cvs service but it
-  is now switched over to the svn serivce) Since 0.13.x the zziplib
-  is using the version control system as the main area to host
-  the source code in the module "zzip-0". You can get a snapshot
-  from that area anytime, the access details can be found under the
-  link above. All later releases are actually snapshots of some
-  cvs day. (Prior releases had seen too many reshuffling of the
-  build system which cvs is not the best tool to handle gracefully.
-  Since the switch to svn also refactoring can be tracked just fine).
-</P>
-<P>
-  I was using the sourceforge compilefarm to do remote testing of
-  releases for crossplatform compatibility. This included usually
-  some unix compatible platforms such as Linux, Solaris,
-  FreeBSD, Darwin/MacOSX including i386, amd64, sparc, sparc64,
-  powerpc when available. Even the latest daytoday cvs snapshots
-  should be fine for these platforms. However sourceforge has
-  shut down the compilefarm just as HP closed the teamdrive
-  service for the public. At the moment I am using the buildservice
-  at build.opensuse.org to test multiple platforms atleast with
-  the help of a "make check" minimal unittest during the rpmbuild.
-</P>
-<P>
-  In the labs of my former employer some more platforms exist but these
-  were only checked once in a few months, mostly summertime and christmas
-  season if the general workload is low. That included hp/ux but more
-  importantly a real MSVC6 installation and a few PCs with win32 flavours.
-  I do not use win32 at home! Any help in that area is greatly appreciated,
-  the zziplib was written in strict ansi-C but the build system and dll hell
-  is sometimes very weird for win32 platforms. I feel it often requires
-  experienced hands to detect the source of a problem should there be one.
-</P>
-<P>
-  Note also that I do not use PHP, there is a regular flow of questions
-  circulating around the php-zip module which is built around zziplib. But
-  I can not answer any questions about the build and installation for that.
-  It would be greatly appreciated if I can find contact to a PHP hacker
-  to whom I can forward php related mails! The php zip wrapper is not part
-  of the zziplib in any way.
-</P>
-<P>
-  Since there is an MSVC6 system in reach now, I have not been updating my
-  gcc/mingw32 installations as rigidly as most other win32 developers
-  have. I understand there are great advancements in the msys/mingw32 area
-  and the provided technology which made them follow quickly. However in
-  the labs only some older releases are used for these are called more
-  "stable". Remember that I do not use win32 at home, only crosscompile to
-  mingw32 is checked out sometimes but I know that it is somewhat different
-  than the selfhosted msys environment. Any help is greatly appreciated.
-</P>
-<P>
-  Lastly, I am trying to make the zziplib as close as possible to the
-  thing called "industrial strength". But remember that this is still
-  an opensource spare time probject. <b>I take patches</b>! Many of the
-  interesting parts of zziplib have been introduced by submission which
-  I have later integrated more heavily to make the zziplib be what it
-  was always intended for: to be a small, fast and portable library allowing
-  to use a zip file as a special variant of a data filesystem. The ext/io
-  obfuscation stuff was one of the best feature submissions so far. Thanks.
-</P>
-<P>
-  Looking forward to hear from <em>YOU</em>.
-  - <a href="mailto:guidod@gmx.de?subject=zzip:">guidod@gmx.de</a>
-</P>
-</section>

_service:tar_scm:v0.13.72.tar.gz/docs/download.htm Deleted

@@ -1,56 +0,0 @@
-<section> <date> 2004-05-18 </date>
-<H2> Download </H2> what to get to get it
-
-<section>
-<H4>Sourceforge File Area</H4>
-
-<center>
-<a href="http://sourceforge.net/project/showfiles.php?group_id=6389">
-                sourceforge.net/project/showfiles.php?group_id=6389 </a>
-</center>
-
-<P>
-  All source releases and some binary releases are listed at the
-  sourceforge download area under the link show above. The sourceforge
-  file area is replicated all over the world and should be accessible
-  with highest bandwidth in all corners of the world.
-</P>
-
-</section><section>
-<H4> Which Version To Download </H4>
-
-<P>
-  Do not use 0.10.x anymore! It is listed as stable since it is the
-  only release of zziplib tested to work on a few dozen platforms.
-  However there were some problematic zip files out there that can
-  trigger segfaults. Later zzip file decoders have extra checks and
-  helper routines for that. It's just that the later zziplib have not
-  been given as many crossplatform build tets as the 0.10.x generation.
-</P>
-<P>
-  Use a 0.12.x (proto-stable) or a 0.13.x (developer) variant of 
-  zziplib, especially if you intend to make heavy usage of the zip
-  decoders in specialized environments - I will not add any fixes to
-  the 0.10.x series anymore (it's deep frozen) but if you hit a 
-  problem with 0.13.x I can help you quickly with a patch and official
-  bugfix release. The later versions are regulary checked crossplatform
-  atleast for <b>Linux, Solaris, FreeBSD, Darwin/MacOSX, Win32/NT</b> 
-  including i386, amd64, sparc, sparc64, powerpc where available.
-</P>
-<P>
-  Note that all generations 0.10.x through 0.13.x are strictly
-  <b>backward compatible</b>. There is a core API (file and dir
-  handling) being binary compatible, which is also true for most
-  of the helper routines (data getters). Only some rarely used
-  entries are made source level compatible, and so far no one had 
-  ever any problem with binary compatibility of the zziplib DLLs.
-</P>
-<P>
-  The MSVC users are strongly advised to use a a later version as
-  well since I have tested the 0.12.x/0.13.x myself and making
-  some msc binary dll releases directly - prior versions were 
-  thirdparty contributions which were working smoothly since I have 
-  been preparing zziplib for win32 using the gcc/mingw compile suite.
-  Please check also the <a href="developer.html">developer pages</a>.
-</P>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/faq.htm Deleted

@@ -1,182 +0,0 @@
-<section> <date> 2004 </date>
-<H2> FAQ </H2> (non)frequently asked questions
-
-<BLOCKQUOTE>
-  While using the zziplib some people come up with questions and
-  problems that need a little longer to be explained. So here is
-  a list of these notes for your information. Keep it up.
-</BLOCKQUOTE>
-<ul>
-<li> <a href="#latin-1">extended ascii characters in names of zipped files </a>
-</li>
-<li> <a href="#utf-8">unicode support for names of zipped files </a>
-</li>
-<li> <a href="#timestamps">timestamps of zipped files </a>
-</li>
-<li> <a href="#install">installation instructions </a>
-</li>
-<li> <a href="#php">php zip module installation </a>
-</li>
-<li> <a href="#license">commercial support </a>
-</li>
-</ul>
-
-<DL>
-<DT><a name="latin-1" />
- zziplib does not support extended ascii characaters, winzip does</DT>
-<DD><P>
-  That's somehow incorrect - the ascii range is the 7bit lower plane of
-  an 8bit character encoding. The upper plane had been non-standard for
-  decades including the age when the ZIP file format was invented. The
-  first instances of pkware's zip compressor were used on DOS with a 
-  codepage 437 which has a way different encoding for the upper plane
-  than today's latin-1 encoding which in fact used in <em>all</em>
-  modern operating systems. So what really see is a mismatch of 
-  character encodings that you are used to.
-</P><P>
-  Even more than that the character encoding had never been specified
-  at all for the filenames in the central directory part. An alert
-  reader will however recognize that <em>each</em> file entry does
-  also have version-info field telling about the compressor that did
-  create the file entry. That version-info has an upper byte telling
-  about the host OS being in use while packaging. A heavy-weight
-  zip decoder might use that value to infer the character encoding
-  on the host OS (while compressing), to detect a mismatch to the
-  current OS (while decompressing), and going to re-code the filename
-  accordingly.
-</P><P>
-  Even more than that the zip file format has seen various extensions
-  over time that have found their place in an extra info block. There
-  are info blocks telling more about the filename / codeset. However
-  the zziplib library does not even attempt to decode a single extra
-  info block as zziplib is originally meant to be a light-weight library.
-  However one might want to put a layer on top of the structure decoding 
-  of zziplib that does the necessary detection of character encodings and
-  re-coding of name entries. Such a layer has not been written so far.
-</P></DD>
-<DT><a name="utf-8" />
- zziplib does not support any unicode plane for filenames </DT>
-<DD><P>
-  The pkware's appnote.text has an extra info block (id-8) for the
-  unicode name of the file entry but it was never actually being 
-  used AFAICS. This might be related to the current developments of
-  older systems to drop usage of latin-1 encoding in the upper plane
-  of 8bit characters and instead choosing the multibyte encoding
-  according to UTF-8. This is again highly system specific.
-</P><P>
-  Basically, you would need to instruct the compressor to use 
-  UTF-8 encoding for the file-entries to arrive at a zip archive 
-  with filenames in that specific character encoding. Along with
-  this zip archive one can switch the application into utf-8 usage
-  as well and take advantage of filename matches in that encoding.
-  This will make it so there is not mismatch in character encoding
-  and implicit re-coding being needed.
-</P></DD>
-<DT><a name="timestamps" />
- zziplib does not return stat values for file timestamps </DT>
-<DD><P>
-  That's correct and again a re-coding problem. The original
-  timestamp in each file entry is in DOS format (i.e. old-FAT).
-  The stat value is usually expected to be in POSIX format. The
-  win32 API has an extra function for conversion but none of the
-  unix compatibles has one, so it would be needed to ship a
-  conversion function along with zziplib.
-</P><P>
-  However the zziplib is intended to be light-weight system and
-  used largely for packaging data for an application. There it
-  is not used strictly as a variant of Virtual File System (vfs)
-  that would need to map any information from the zip file system
-  to native host system. Of course applications are free to cut
-  out the DOS file timestamp and re-code it on their own. It's
-  just that zziplib does not provide that re-coding originally.
-</P></DD>
-<DT><a name="install" />
- how can one install the zziplib package </DT>
-<DD><P>
- The zziplib project is opensource which effectly gives two ways of
- installing the package: one can download the source archive and use
- a C compiler to derive a binary executable for whatever computer
- it needs to be on (see the platform compatibility list). This is
- the preferred way but for convenience one can download a binary
- installation archive with precompiled executables.
-</P><P>
- The current project uses autoconf/automake for cross platform
- support which includes most unix compatible systems and their
- native C compilers. The derivates of the GNU C compiler (gcc) have 
- replaced most of these native C compilers in the past years. The
- <a href="http://www.mingw.org">mingw32</a> project has ported a
- unix born C compiler to win32 and zziplib can be compiled with
- it for the various win32 platforms.
-</P><P>
- There exist some C compilers which can not be embedded easily into 
- a unix compilation framework. The zziplib source archive ships with
- project files for MSVC6 and MSVC6 (Microsoft Visual C). Adapting
- these project files might help with installation problems of the
- DLL hell on win32 platforms. There exist no sufficient guidelines to
- mix binary helper libraries for many applications on windows.
-</P><P>
- There exists win32 binary archives as zip files on the download area
- of zziplib (MSI is always on my wishlist). Including the project as
- a helper library however you should not use it but instead compile
- from source. The general library installation on unix are better, 
- the zziplib download area contains regularly some linux binary
- archives (rpm). Many vendors of unix compatible systems provide 
- precompiled binary packages of zziplib on their own.
-</P></DD>
-<DT><a name="php" />
- after installing zziplib the php zip module still does not work </DT>
-<DD><P>
- Now that is one of <b>the most</b> frequently asked questions that
- I do receive. There is just one major problem with it: I did not
- write the php zip module (which uses zziplib) and I have no idea
- how php modules work or how to tell apache's php sandbox to make
- it work. Really, I do not have the slightest clue on that.
-</P><P>
- I was posting to some php developer sites to spread awareness of
- the fact and hopefully to find a guy that I could forward any
- questions on the php zip module installation. But so far there is
- nothing, it merily seems that such installation problems are in no
- way related to zziplib anyway but exists <b>with any other module with a 
- third party library dependency</b> as well. So the answers on php forum 
- sites will ask for details of the current php and apache configuration.
-</P><P>
- Since I do not run a php zip whatever nor any other php stuff, it's
- just that those hints were not quite helpful to me. It would be really 
- really great if someone with a php zip background could be so nice to
- write a short roundup of the areas to check when a php zip module
- installation fails, so that I could post it here. Where are you?
- Yours desperatly...&nbsp;;-)
-</P></DD>
-<DT><a name="license" />
- how to obtain a license and support contract for a commercial project </DT>
-<DD><P>
- The zziplib has been created as a spare time project and it is put
- under a very easy free public license. Even for commercial projects
- there is hardly any need to negotiate a separate license since the
- restrictions of the GNU LGPL or MPL can be matched easily. As a
- general hint, if the zziplib is shipped unmodified with your project
- then you are right within the limits of the free public license.
-</P><P>
- Sometimes the question for a personal license comes up for very
- different reason - the need for a support contract and/or the setting
- of functionality guarantees. The free public licenses include a safeguard
- clause to that end, "in the hope that it will be useful,
- but <em>without any warranty</em>; without even the implied warranty of
- <em>merchantability</em> or <em>fitness for a particular purpose</em>."
- Since the project was developed as a spare time project however there
- have never been personal licenses going beyond.
-</P><P>
- In general you can still try to negotiate a support contract but it
- will be very costly. It is much more profitable for you to tell one
- of your developers to have a look at the source code and ensure the
- required functionality is there, with hands on. The source code is 
- written to be very readable, maintainable and extensible. Just be
- reminded that the free public licenses have restrictions on shipping
- modified binaries but I can give you a cheap personal license to
- escape these. (Such licenses can be obtained in return for tax-deductible
- donations to organisations supporting opensource software).
-</P></DD>
-</DL>
-
-<P> and as always - <em> Patches are welcome </em> - </P>
-</section>

_service:tar_scm:v0.13.72.tar.gz/docs/fseeko.htm Deleted

@@ -1,193 +0,0 @@
-<section> <date> 2005 </date>
-<H2> zzip/fseeko </H2> zip access for stdio handle
-
-<BLOCKQUOTE>
-  These routines are fully independent from the traditional zzip
-  implementation. They assume a readonly seekable stdio handle
-  representing a complete zip file. The functions show how to 
-  parse the structure, find files and return a decoded bytestream.
-</BLOCKQUOTE>
-
-<section>
-<H3> stdio disk handle </H3>
-
-<P>
-  Other than with the <a href="mmapped.html">mmapped</a> alternative
-  interface there is no need to build special handle for the zip
-  disk file. The normal stdio file handle (of type <b><code>FILE</code></b>)
-  serves as the disk access representation. You can open that stdio file
-  handle any way you want. Note however that the <code>zzipfseeko</code>
-  routines modify the access state of that file handle, especially the
-  read position.
-</P>
-
-<P>
-  To get access to a zipped file, you need a zip archive entry known 
-  under the type <code>ZZIP_ENTRY</code>. This is again modelled after
-  the <code>DIR_ENTRY</code> type in being a representation of a file
-  name inside the zip central directory. To get a fresh zzip entry, use
-  <code>zzip_entry_findfirst</code>, to get the next use 
-  <code>zzip_entry_findnext</code>, and do not forget to free the
-  resource with <code>zzip_entry_free</code>.
-</P>
-<PRE>
-   extern ZZIP_ENTRY* zzip_entry_findfirst(FILE* disk);
-   extern ZZIP_ENTRY* zzip_entry_findnext(ZZIP_ENTRY*  entry);
-   extern int         zzip_entry_free(ZZIP_ENTRY* entry);
-</PRE>
-<P>
-  These three calls will allow to walk all zip archive members in the
-  order listed in the zip central directory. To actually implement a
-  directory lister ("zzipdir"), you need to get the name string of the
-  zzip entry. This is not just a pointer: the zzip disk entry is not
-  null terminated actually. Therefore we have a helper function that
-  will <code>strdup</code> the entry name as a normal C string:
-</P>
-<PRE>
-  #include &lt;zzip/fseeko.h&gt;
-  void _zzip_dir(FILE* disk)
-  {
-      for (ZZIP_ENTRY* entry = zzip_findfirst (disk);
-           entry ; entry = zzip_findnext (entry)) {
-          char* name = zzip_entry_strdup_name (entry);
-          puts (name); free (name);
-      }
-  }
-</PRE>
-
-</section><section>
-<H3> find a zipped file </H3>
-
-<P>
-  The central directory walk can be used to find any file in the
-  zip archive. The <code>zzipfseeko</code> library however provides
-  two convenience functions that allow to jump directly to the
-  zip disk entry of a given name or pattern. You are free to use
-  the newly allocated <code>ZZIP_ENTRY</code> for later calls on
-  that handle type. Do not forget to <code>zzip_entry_free</code> 
-  the handle unless the handle is consumed by a routine, e.g. 
-  <code>zzip_entry_findnext</code> to hit the end of directory.
-</P>
-<PRE>
-  extern ZZIP_ENTRY* zzip_entry_findfile(FILE* disk, char* filename, 
-                                         ZZIP_ENTRY* _zzip_restrict entry, 
-                                         zzip_strcmp_fn_t compare);
-
-  extern ZZIP_ENTRY* zzip_entry_findmatch(FILE* disk, char* filespec, 
-                                         ZZIP_ENTRY* _zzip_restrict entry,
-                                         zzip_fnmatch_fn_t compare, int flags);
-</PRE>
-<P>
-  In general only the first two arguments are non-null pointing to the
-  stdio disk handle and the file name to look for. The "entry" argument
-  is an old value and allows you to walk the zip directory similar to
-  <code>zzip_entry_findnext</code> but actually leaping forward. The
-  compare function can be used for alternate match behavior: the default
-  of <code>strcmp</code> might be changed to <code>strncmp</code> for
-  a caseless match. The "flags" of the second call are forwarded to the
-  posix <code>fnmatch</code> which we use as the default function.
-</P>
-<P>
-  If you do know a specific filename then you can just use 
-  <code>zzip_entry_findfile</code> and supply the return value to
-  <code>zzip_entry_fopen</code> with the second argument set to "1"
-  to tell the function to actually consume whichever entry was given.
-  That allows you to skip an explicit <code>zzip_entry_free</code> 
-  as it is included in a later <code>zzip_entry_fclose</code>.
-</P>
-<PRE>
-  #include &lt;zzip/fseeko.h&gt;
-<small>
-       /* zzipfseeko already exports this convenience function: */</small>
-  ZZIP_ENTRY_FILE* zzip_entry_ffile(FILE* disk, char* filename) {
-      return zzip_entry_fopen (zzip_entry_findfile (filename, 0, 0), 1);
-  }
-
-  int _zzip_read(FILE* disk, char* filename, void* buffer, int bytes)
-  {
-      ZZIP_ENTRY_FILE* file = zzip_entry_ffile (disk, filename);
-      if (! file) return -1;
-      int bytes = zzip_entry_fread (buffer, 1, bytes, file);
-      zzip_entry_fclose (file);
-      return bytes;
-  }
-</PRE>
-
-</section><section>
-<H3> reading bytes </H3>
-
-<P>
-  The example has shown already how to read some bytes off the head of
-  a zipped file. In general the zzipfseeko api is used to replace a few
-  stdio routines that access a file. For that purpose we provide three 
-  functions that look very similar to the stdio functions of 
-  <code>fopen()</code>, <code>fread()</code> and <code>fclose()</code>.
-  These work on an active file descriptor of type <code>ZZIP_ENTRY_FILE</code>.
-  Note that this <code>zzip_entry_fopen()</code> uses <code>ZZIP_ENTRY</code> 
-  argument as returned by the findfile api. To open a new reader handle from 
-  a disk archive and file name you can use the <code>zzip_entry_ffile()</code> 
-  convenience call.
-</P>
-
-<PRE>
-   ZZIP_ENTRY_FILE* zzip_entry_ffile  (FILE* disk, char* filename);
-   ZZIP_ENTRY_FILE* zzip_entry_fopen  (ZZIP_ENTRY* entry, int takeover);
-   zzip_size_t      zzip_entry_fread  (void* ptr, 
-                                       zzip_size_t sized, zzip_size_t nmemb,
-                                       ZZIP_ENTRY_FILE* file);
-   int              zzip_entry_fclose (ZZIP_ENTRY_FILE* file);
-   int              zzip_entry_feof   (ZZIP_ENTRY_FILE* file);
-</PRE>
-
-<P>
-  In all of the examples you need to remember that you provide a single
-  stdio <code>FILE</code> descriptor which is in reality a virtual
-  filesystem on its own. Per default filenames are matched case
-  sensitive also on win32 systems. The findnext function will walk all
-  files on the zip virtual filesystem table and return a name entry 
-  with the full pathname, i.e. including any directory names to the
-  root of the zip disk <code>FILE</code>.
-</P>
-
-</section><section>
-<H3> ZZIP_ENTRY inspection </H3>
-
-<P>
-  The <code>ZZIP_ENTRY_FILE</code> is a special file descriptor handle 
-  of the <code>zzipfseeko</code> library - but the <code>ZZIP_ENTRY</code>
-  is not so special. It is actually a bytewise copy of the data inside the
-  zip disk archive (plus some internal hints appended). While 
-  <code>zzip/fseeko.h</code> will not reveal the structure on its own, 
-  you can include <code>zzip/format.h</code> to get access to the actual 
-  structure content of a <code>ZZIP_ENTRY</code> by (up)casting it to
-<br><b><code>&nbsp;&nbsp;&nbsp;&nbsp;struct zzip_disk_entry</code></b>.
-</P>
-
-<P>
-  In reality however it is not a good idea to actually read the bytes
-  in the <code>zzip_disk_entry</code> structure unless you seriously know
-  the internals of a zip archive entry. That includes any byteswapping
-  needed on bigendian platforms. Instead you want to take advantage of
-  helper macros defined in <code>zzip/fetch.h</code>. These will take
-  care to convert any struct data member to the host native format.
-</P>
-<PRE>
-extern uint16_t    zzip_disk_entry_get_flags( zzip_disk_entry* entry);
-extern uint16_t    zzip_disk_entry_get_compr( zzip_disk_entry* entry);
-extern uint32_t    zzip_disk_entry_get_crc32( zzip_disk_entry* entry);
-
-extern zzip_size_t zzip_disk_entry_csize( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_usize( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_namlen( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_extras( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_comment( zzip_disk_entry* entry);
-extern int         zzip_disk_entry_diskstart( zzip_disk_entry* entry);
-extern int         zzip_disk_entry_filetype( zzip_disk_entry* entry);
-extern int         zzip_disk_entry_filemode( zzip_disk_entry* entry);
-
-extern zzip_off_t  zzip_disk_entry_fileoffset( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_sizeof_tail( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_sizeto_end( zzip_disk_entry* entry);
-extern char*       zzip_disk_entry_skipto_end( zzip_disk_entry* entry);
-</PRE>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/functions.htm Deleted

_service:tar_scm:v0.13.72.tar.gz/docs/future.htm Deleted

@@ -1,80 +0,0 @@
-<?xml-stylesheet type="text/css" href="sdocbook.css" ?>
-<section> <date> 15. July 2002 </date>
-<h2> ZZIP Future </h2>              What next to come.
-
-<section>
-<h3> ZIP-Write </h3>
-
-<P>
-  Anybody out there who wants to program the write-support for the
-  zziplib? Actually, I just do not have the time to do it and no
-  real need to but I guess it would be nice for people as for
-  example to spit out savegame files in zipformat. The actual
-  programming path is almost obvious - start off with the zziplib
-  as it is, and let it open an existing zip-file. This will parse
-  the central directory into memory - including the file-offsets
-  for each file. Then, truncate the zip-realfile to the place that
-  the central-dir was found (identical with the end of the last
-  file). If a datafile is opened for writing, either add a new
-  entry or modify the start-offset of the existing entry to the
-  end of the zip-realfile - the old data is simply junk. Then
-  init zlib to do the deflation of the data and append it to the
-  current zip-realfile. When the zipdir-handle is getting closed
-  from write-mode, the zip's central-directory needs to be appended
-  to the file on disk. This coincides with creating a new zip-file 
-  with an empty central-directory that can be spit out to disk.
-  During development, do not care about creating temp-files to
-  guard against corruption for partial writes - the usual application
-  will use the zziplib to create zip savegames in one turn, no
-  "update"-operation needs to be implemented like exists in the
-  standalone zip command utilities.
-</P>
-
-</section><section>
-<h3> readdir for subdir inside zip magicdir </h3>
-
-<P>
-  See the notes in the first paragraphs of <a href="zzip-api.html">
-  ZZIP Programmers Interface</a> description. It would add some
-  complexity for something I never needed so far. The question
-  came up with using zziplib as the backend of a dynamic webserver
-  to store the content in compressed form possibly through the
-  incarnation of a php module - and some scripted functionality
-  that walks all directories to index the files hosted. I'm not
-  going to implement that myself but perhaps someone else wants
-  to do it and send me patches for free.
-</P>
-
-</section><section>
-<h3> obfuscation example project </h3>
-
-<P>
-  A subproject that shows <b>all</b> the steps from a dat-tree
-  to a dat-zip to an obfuscated-dat along with build-files and
-  source-files for all helper tools needed to obfuscate and
-  deobfuscate, plus a sample program to use the obfuscated 
-  dat-file and make some use of it. Along with some extra 
-  documentation about 20..40 hours. Don't underestimate the
-  amount of work for it! (otherwise a great student project).
-</P>
-
-</section><section>
-<h3> zip/unzip tool </h3>
-
-<P>
-  The infozip tools implement a full set of zip/unzip routines
-  based on internal code to access the zip-format. The zziplib
-  has its own set of zip-format routines. Still, it should be
-  possible to write a frontend to the library that implements 
-  parts (if not all) of the options of the infozip zip/unzip 
-  tools. Even without write-support in zziplib it would be
-  interesting to see an normal unzip-tool that does not use
-  the magic-wrappers thereby only going off at plain zip-files.
-  On the upside, such a tool would be smaller than the infozip
-  tools since it can use the library routines that are shared
-  with other tools as well. Again - don't underestimate the
-  amount of work for it, I guess 40..80 hours as there is a lot
-  of fine-tuning needed to match the infozip model.
-</P>
-</section>
-</section>

_service:tar_scm:v0.13.72.tar.gz/docs/history.htm Deleted

@@ -1,92 +0,0 @@
-<section><date>created 1.Jun.2000, last updated 25.Apr.2002 </date>
-<h2> History and Links </h2>           plus Installation and Contact Hints
-
- 
-
-<section>
-<h3> A Bit Of History </h3>
-
-<P>
-You'll find <a href="http://www.gzip.org">gzip</a> using the same compression 
-that was written by Jean-loup <a href="http://gailly.net">Gailly</a>
-for the <a href="http://www.info-zip.org">Info-Zip</a> Group
-whose <a href="http://www.info-zip.org/pub/infozip/Zip.html">Zip</a>
-program is compatible with msdos PKZIP program from 
-<a href="http://www.pkware.com">PK&nbsp;Ware</a>. Then, in collaboration
-with <a href="http://www.alumni.caltech.edu/~madler">Mark Adler</a>
-he wrote the <a href="http://www.gzip.org/zlib">zlib</a>
-compression library which was later standardized in the 
-<a href="ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html">
-zlib RFCs</a>, namely
-<a href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950</a>
-<a href="ftp://ftp.uu.net/graphics/png/documents/zlib/rfc-zlib.html.Z">
-zlib&nbsp;3.3</a>,
-<a href="http://www.ietf.org/rfc/rfc1951.txt">RFC 1951</a>
-<a href="ftp://ftp.uu.net/graphics/png/documents/zlib/rfc-deflate.html.Z">
-deflate&nbsp;1.3</a> and
-<a href="http://www.ietf.org/rfc/rfc1952.txt">RFC 1952</a>
-<a href="ftp://ftp.uu.net/graphics/png/documents/zlib/rfc-gzip.html">
-gzip&nbsp;4.3</a>. The free algorithm can be found in lots of places
-today including PPP packet compression and PNG picture compression.
-</P>
-
-</section><section>
-<h3> Installation </h3>
-
-<P>
- The installation is from the source .tar.gz tarball does follow
- the simple gnu style: type <tt>''configure  && make install''</tt> 
- in the unpacked directory. This will actually perform the usual 
- sequence of <tt>''configure && make && make install''</tt>. The
- use of <tt>''make rpm''</tt> will make rpms based on your system
- setup, and using a decent mingw32 compiler (e.g. the crossgcc
- from <a href="http://libsdl.org/Xmingw32">libsdl.org/Xmingw32</a>)
- will allow you to create windows dlls using a gnu development
- environment. MSVC and Borland support (Make-)files should be
- easy to be derived from the <a href="Makefile.am">Makefile.am</a>
-</P>
-
-</section><section>
-<h3> Contact </h3>
-
-<P>
- The library was developed by 
- <a href="mailto:guidod@gmx.de?subject=zziplib">
- Guido Draheim </a> based on the library 
- <a href="http://freshmeat.net/appindex/1999/08/02/933593367.html">
- <tt>zip08x</tt> </a> 
- by <a href="mailto:too@iki.fi"> Tomi Ollila </a> (many thanks
- for his support of the zziplib project). He has provided 
- a good deal of testing rounds and very helpful comments. 
- It may be assumed that this library supersedes 
- <a href="http://www.iki.fi/too/sw/zip08x.readme">
- <tt>zip08x</tt></a>, and in April 2002, he 
- has even given up copyright restrictions coming from zip08x
- and changed the <a href="http://www.iki.fi/too/sw/zip08x.readme">zip08x</a> 
- readme to point to <a href="http://zziplib.sf.net">zziplib</a>.
- Anyone who wants to contribute in accessing zip-archives
- with the zlib-library is hereby kindly invited to send us
- comments and sourcecode.
-</P>
-
-</section><section>
-<h3> Links </h3>
-
-<P>
-The <a href="zziplib.html">zziplib library</a> must be
-linked with the free <b><a href="http://www.gzip.org/zlib/">zlib</a></b>
-<a href="http://www.info-zip.org/pub/infozip/zlib">1</a>
-<a href="http://www.lifl.fr/PRIVATE/Manuals/gnulang/zlib">2</a>
-<a href="http://pobox.com/~newt">3</a> package originally developed 
-by the <a href="http://www.info-zip.org">Info-Zip</a> Group
-and now maintained at the <a href="http://www.gzip.org">GZip</a> Group.
-As of late, the pkware appnote.txt has been revised into a whitepaper
-document named
-<a href="http://www.pkware.com/products/enterprise/white_papers/appnote.html">
-    "APPNOTE.TXT - .ZIP File Format Specification"</a>.
-Be also aware of other zzip like projects, e.g. 
-<a href="http://zipios.sourceforge.net">zipios++</a> that
-mangles zip access into C++ iostream facilities.
-</P>
-
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/memdisk.htm Deleted

@@ -1,116 +0,0 @@
-<section> <date> 2005 </date>
-<H2> zzip/memdisk </H2> zip cache for mmapped views
-
-<BLOCKQUOTE>
-  These routines are fully independent from the traditional zzip
-  implementation. They build on top of 
-  <a href="mmapped.html">zzip/mmapped</a> that uses a readonly
-  mmapped sharedmem block. These functions add additional hints
-  how to parse extension blocks and how to cache the zip central
-  directory entries which does furthermore allow to convert them
-  to any host-local format as required.
-</BLOCKQUOTE>
-
-<section>
-<H3> zzip disk handle </H3>
-
-<P>
-  Other than with the <a href="fseeko.html">fseeko</a> alternative
-  interface there is no need to have an actual disk handle to the
-  zip archive. Instead you can use a bytewise copy of a file or
-  even use a mmapped view of a file. This is generally the fastest
-  way to get to the data contained in a zipped file. All it requires
-  is enough of virtual memory space but a desktop computer with a
-  a modern operating system will easily take care of that.
-</P>
-
-<P>
-  The zzipmmapped library provides a number of calls to create a
-  disk handle representing a zip archive in virtual memory. Per
-  default we use the sys/mmap.h (or MappedView) functionality
-  of the operating system. See for more details in the
-   <a href="mmapped.html">zzip/mmapped</a> descriptions.
-</P>
-<P>
-  The zzip/memdisk extensions of zzip/mmapped are made to have a
-  very similar call API - therefore you will find again open and
-  close functions for filenames or filehandles. However the 
-  direct mmap interface is not re-exported under the zzip_mem_disk
-  prefix (of the underlying zzip_disk prefix). The "_mem_" part
-  hints that the central directory of the underlying zzip_disk
-  is preparsed to a separate memory block.
-<PRE>
-  ZZIP_MEM_DISK*  zzip_mem_disk_open(char* filename);
-  ZZIP_MEM_DISK*  zzip_mem_disk_fdopen(int fd);
-  void            zzip_mem_disk_close(ZZIP_MEM_DISK* disk);
-
-  int  zzip_mem_disk_load (ZZIP_MEM_DISK* dir, ZZIP_DISK* disk);
-  void zzip_mem_disk_unload (ZZIP_MEM_DISK* dir);
-</PRE>
-  The last two functions export some parts of the underlying
-  interface. It is possible to bind an existing ZZIP_MEM_DISK
-  handle with an arbitrary ZZIP_DISK handle. Upon calling "load"
-  the central directory will be loaded from the underlying zip
-  disk content and parsed to an internal mem block. The corresponding
-  "unload" function will trash that central directory cache but it
-  leaves the handles intact.
-</P>
-
-</section><section>
-<H3> reading the central directory </H3>
-
-<P>
-  All other zzip_mem_disk functions are simply re-exporting the
-  underlying zzip_disk functions. Note that the first field in
-  the ZZIP_MEM_DISK is a "ZZIP_DISK* disk" - the header file
-  zzip/memdisk.h will simply export inline functions where there
-  is no special zzip_mem_disk function. Therefore, whenever a
-  function call on a ZZIP_DISK handle is appropriate one can
-  also use its cousin for a ZZIP_MEM_DISK handle without any
-  penalties but future compatibility for extra functionality in
-  zzip/memdisk layer of the zzip/mmapped library.
-</P>
-
-<P><small>Note: by default the re-exports are done with the help
-  of the C precompiler as precompiler macros. Using USE_INLINE
-  will force to make them real inlines. In the future that may
-  change in favor of a better autodetection for inline capabilities
-  of the compiler and/or using a standard cpp-define that enables
-  the C/C++ inline functions. The inline functions do have the
-  added value of having strongtyped arguments provoking more
-  readable warning messages in user application code.</small></P>
-
-<PRE>
-     inline ZZIP_DISK_ENTRY*
-zzip_mem_disk_findfirst(ZZIP_MEM_DISK* dir);
-     inline ZZIP_DISK_ENTRY*
-zzip_mem_disk_findnext(ZZIP_MEM_DISK* dir, ZZIP_DISK_ENTRY* entry);
-     inline char* _zzip_restrict
-zzip_mem_disk_entry_strdup_name(ZZIP_MEM_DISK* dir, 
-                                ZZIP_DISK_ENTRY* entry);
-     inline struct zzip_file_header*
-zzip_mem_disk_entry_to_file_header(ZZIP_MEM_DISK* dir, 
-				   ZZIP_DISK_ENTRY* entry);
-     inline char*
-zzip_mem_disk_entry_to_data(ZZIP_MEM_DISK* dir, ZZIP_DISK_ENTRY* entry);
-     inline ZZIP_DISK_ENTRY*
-zzip_mem_disk_findfile(ZZIP_MEM_DISK* dir, 
-                       char* filename, ZZIP_DISK_ENTRY* after,
-		       zzip_strcmp_fn_t compare);
-     inline ZZIP_DISK_ENTRY*
-zzip_mem_disk_findmatch(ZZIP_MEM_DISK* dir, 
-                        char* filespec, ZZIP_DISK_ENTRY* after,
-			zzip_fnmatch_fn_t compare, int flags);
-     inline ZZIP_DISK_FILE* _zzip_restrict
-zzip_mem_disk_entry_fopen (ZZIP_MEM_DISK* dir, ZZIP_DISK_ENTRY* entry);
-     inline ZZIP_DISK_FILE* _zzip_restrict
-zzip_mem_disk_fopen (ZZIP_MEM_DISK* dir, char* filename);
-     inline _zzip_size_t
-zzip_mem_disk_fread (void* ptr, _zzip_size_t size, _zzip_size_t nmemb,
-                     ZZIP_DISK_FILE* file);
-     inline int
-zzip_mem_disk_fclose (ZZIP_DISK_FILE* file);
-     inline int
-zzip_mem_disk_feof (ZZIP_DISK_FILE* file);
-</PRE>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/mmapped.htm Deleted

@@ -1,226 +0,0 @@
-<section> <date> 2005 </date>
-<H2> zzip/mmapped </H2> zip access for mmapped views
-
-<BLOCKQUOTE>
-  These routines are fully independent from the traditional zzip
-  implementation. They assume a readonly mmapped sharedmem block
-  representing a complete zip file. The functions show how to 
-  parse the structure, find files and return a decoded bytestream.
-</BLOCKQUOTE>
-
-<section>
-<H3> zzip disk handle </H3>
-
-<P>
-  Other than with the <a href="fseeko.html">fseeko</a> alternative
-  interface there is no need to have an actual disk handle to the
-  zip archive. Instead you can use a bytewise copy of a file or
-  even use a mmapped view of a file. This is generally the fastest
-  way to get to the data contained in a zipped file. All it requires
-  is enough of virtual memory space but a desktop computer with a
-  a modern operating system will easily take care of that.
-</P>
-
-<P>
-  The zzipmmapped library provides a number of calls to create a
-  disk handle representing a zip archive in virtual memory. Per
-  default we use the sys/mmap.h (or MappedView) functionality
-  of the operating system. The <code>zzip_disk_open</code> will
-  open a system file descriptor and try to <code>zzip_disk_mmap</code>
-  the complete zip content. When finished with the zip archive
-  call <code>zzip_disk_close</code> to release the mapped view
-  and all management data.
-</P>
-
-<PRE>
-  ZZIP_DISK*  zzip_disk_open(char* filename);
-  int         zzip_disk_close(ZZIP_DISK* disk);
-
-  ZZIP_DISK*  zzip_disk_new(void);
-  ZZIP_DISK*  zzip_disk_mmap(int fd);
-  int         zzip_disk_munmap(ZZIP_DISK* disk);
-  int         zzip_disk_init(ZZIP_DISK* disk, 
-                            char* buffer, zzip_size_t buflen);
-</PRE>
-
-</section><section>
-<H3> reading the central directory </H3>
-
-<P>
-  To get access to a zipped file, you need a pointer to an entry in the
-  mmapped zip disk known  under the type <code>ZZIP_DISK_ENTRY</code>. 
-  This is again modelled after the <code>DIR_ENTRY</code> type in being 
-  a representation of a file name inside the zip central directory. To 
-  get an initial zzip disk entry pointer, use <code>zzip_disk_findfirst</code>,
-  to move the pointer to the next entry use <code>zzip_disk_findnext</code>.
-</P>
-<PRE>
-   extern ZZIP_ENTRY* zzip_disk_findfirst(FILE* disk);
-   extern ZZIP_ENTRY* zzip_disk_findnext(ZZIP_ENTRY*  entry);
-</PRE>
-<P>
-  These two calls will allow to walk all zip archive members in the
-  order listed in the zip central directory. To actually implement a
-  directory lister ("zzipdir"), you need to get the name string of the
-  zzip entry. This is not just a pointer: the zzip disk entry is not
-  null terminated actually. Therefore we have a helper function that
-  will <code>strdup</code> the entry name as a normal C string:
-</P>
-<PRE>
-  #include &lt;zzip/mmapped.h&gt;
-  void _zzip_dir(char* filename)
-  {
-      ZZIP_DISK* disk = zzip_disk_open (filename);
-      if (! disk) return disk;
-      for (ZZIP_DISK_ENTRY* entry = zzip_disk_findfirst (disk);
-           entry ; entry = zzip_disk_findnext (entry)) {
-          char* name = zzip_disk_entry_strdup_name (entry);
-          puts (name); free (name);
-      }
-  }
-</PRE>
-
-</section><section>
-<H3> find a zipped file </H3>
-
-<P>
-  The central directory walk can be used to find any file in the
-  zip archive. The <code>zzipfseeko</code> library however provides
-  two convenience functions that allow to jump directly to the
-  zip disk entry of a given name or pattern. You are free to use
-  the returned <code>ZZIP_DISK_ENTRY</code> pointer for later calls
-  that type. There is no need to free this pointer as it is really
-  a pointer into the mmapped area of the <code>ZZIP_DISK</code>.
-  But do not forget to free that one via <code>zzip_disk_close</code>.
-</P>
-<PRE>
-  ZZIP_DISK_ENTRY* zzip_disk_findfile(ZZIP_DISK* disk, char* filename, 
-                                      ZZIP_DISK_ENTRY* after, 
-                                      zzip_strcmp_fn_t compare);
-
-  ZZIP_DISK_ENTRY* zzip_disk_findmatch(ZZIP_DISK* disk, char* filespec, 
-                                       ZZIP_ENTRY* after,
-                                       zzip_fnmatch_fn_t compare, int flags);
-</PRE>
-<P>
-  In general only the first two arguments are non-null pointing to the
-  zip disk handle and the file name to look for. The "after" argument
-  is an old value and allows you to walk the zip directory similar to
-  <code>zzip_disk_entry_findnext</code> but actually leaping forward. The
-  compare function can be used for alternate match behavior: the default
-  of <code>strcmp</code> might be changed to <code>strncmp</code> for
-  a caseless match. The "flags" of the second call are forwarded to the
-  posix <code>fnmatch</code> which we use as the default function.
-</P>
-<P>
-  If you do know a specific zzipped filename then you can just use 
-  <code>zzip_disk_entry_findfile</code> and supply the return value to
-  <code>zzip_disk_entry_fopen</code>. There is a convenience function 
-  <code>zzip_disk_fopen</code> that will do just that and therefore
-  only requires a disk handle and a filename to find-n-open.
-</P>
-<PRE>
-  #include &lt;zzip/mmapped.h&gt;
-
-  int _zzip_read(ZZIP_DISK* disk, char* filename, void* buffer, int bytes)
-  {
-      ZZIP_DISK_FILE* file = zzip_disk_fopen (disk, filename);
-      if (! file) return -1;
-      int bytes = zzip_disk_fread (buffer, 1, bytes, file);
-      zzip_disk_fclose (file);
-      return bytes;
-  }
-</PRE>
-
-</section><section>
-<H3> reading bytes </H3>
-
-<P>
-  The example has shown already how to read some bytes off the head of
-  a zipped file. In general the zzipmmapped api is used to replace a few
-  system file routines that access a file. For that purpose we provide three 
-  functions that look very similar to the stdio functions of 
-  <code>fopen()</code>, <code>fread()</code> and <code>fclose()</code>.
-  These work on an active file descriptor of type <code>ZZIP_DISK_FILE</code>.
-</P>
-
-<PRE>
-   ZZIP_DISK_FILE* zzip_disk_entry_fopen  (ZZIP_DISK* disk, 
-                                           ZZIP_DISK_ENTRY* entry);
-   ZZIP_DISK_FILE* zzip_disk_fopen  (ZZIP_DISK* disk, char* filename);
-   zzip_size_t     zzip_disk_fread  (void* ptr, 
-                                     zzip_size_t sized, zzip_size_t nmemb,
-                                     ZZIP_DISK_FILE* file);
-   int             zzip_disk_fclose (ZZIP_DISK_FILE* file);
-   int             zzip_disk_feof   (ZZIP_DISK_FILE* file);
-</PRE>
-
-<P>
-  In all of the examples you need to remember that you provide a single
-  <code>ZZIP_DISK</code> descriptor for a memory block which is in reality 
-  a virtual filesystem on its own. Per default filenames are matched case
-  sensitive also on win32 systems. The findnext function will walk all
-  files on the zip virtual filesystem table and return a name entry 
-  with the full pathname, i.e. including any directory names to the
-  root of the zip disk <code>FILE</code>.
-</P>
-
-</section><section>
-<H3> ZZIP_DISK_ENTRY inspection </H3>
-
-<P>
-  The <code>ZZIP_DISK_FILE</code> is a special file descriptor handle 
-  of the <code>zzipmmapped</code> library - but the 
-  <code>ZZIP_DISK_ENTRY</code> is not so special. It is actually a pointer
-  directly into the zip central directory managed by <code>ZZIP_DISK</code>.
-  While <code>zzip/mmapped.h</code> will not reveal the structure on its own, 
-  you can include <code>zzip/format.h</code> to get access to the actual 
-  structure content of a <code>ZZIP_DISK_ENTRY</code> by its definition
-<br><b><code>&nbsp;&nbsp;&nbsp;&nbsp;struct zzip_disk_entry</code></b>.
-</P>
-
-<P>
-  In reality however it is not a good idea to actually read the bytes
-  in the <code>zzip_disk_entry</code> structure unless you seriously know
-  the internals of a zip archive entry. That includes any byteswapping
-  needed on bigendian platforms. Instead you want to take advantage of
-  helper macros defined in <code>zzip/fetch.h</code>. These will take
-  care to convert any struct data member to the host native format.
-</P>
-<PRE>
-extern uint16_t    zzip_disk_entry_get_flags( zzip_disk_entry* entry);
-extern uint16_t    zzip_disk_entry_get_compr( zzip_disk_entry* entry);
-extern uint32_t    zzip_disk_entry_get_crc32( zzip_disk_entry* entry);
-
-extern zzip_size_t zzip_disk_entry_csize( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_usize( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_namlen( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_extras( zzip_disk_entry* entry);
-extern zzip_size_t zzip_disk_entry_comment( zzip_disk_entry* entry);

_service:tar_scm:v0.13.72.tar.gz/docs/notes.htm Deleted

@@ -1,57 +0,0 @@
-<H2> Some Notes </H2>
-
-<dl>
-<dt> ClamAV thinks it decompress zip method 9 files </dt>
-<dd>
-   In May 2005 the ClamAV Development team detected a problem
-   with zlib - which knows an undocumented inflate64 that maps
-   to the zip compression method number 9 (implemented in files
-   inftree9 and infback9). However the support for that method 
-   is not being compiled into libz.so by default, so you have
-   to recompile zlib to get support for it - zziplib will not do
-   that on its own, nor will it check the actual availability.
-   So, zziplib users might be handicapped if the meet a zip
-   compressed with that method 9, at best they will get an
-   error code back to the application but that is mostly not
-   intuitive enough to point to the actual problem related to
-   the last breed of zip/zlib compression methods. Effectivly
-   you are restricted to methods 0 and 8.
-</dd>
-<dt> Ogre3D + Win64/AMD64 + zziplib = ZZIP_DIR_READ error </dt>
-<dd>
-   As of December 2005 the thread at
-   http://www.ogre3d.org/phpBB2/viewtopic.php?p=110707#110667
-   points to a problem in the 64bit variant of zziplib with
-   some zip archives. The actual source of the problem is
-   unknown. The Ogre project uses an internal copy of the
-   zziplib library being statically linked. The latest
-   zziplib version has been tested on a number of 64bit
-   system in the meantime - however those are 64bit Unix
-   variants (LP64). While Win32 (LP32) works okay there
-   might be some buglet left for Win64 (LLP64) that I can't
-   track down (system N/A to me) in the near future.
-</dd>
-<dt> PHP5 does not know --with-zip </dt>
-<dd>
-   As of January 2005 I was hinted that some of the PHP
-   problems might see a new show. In the past there were
-   numerous queries about installation of zziplib to be
-   useful as the PHP-ZIP module but I could not answer them.
-   (I don't use PHP for real work). The standard php4
-   docs were obviously insufficient with saying to just
-   configure --with-zip... but now even that option is
-   gone and there is no hint anywhere telling of the
-   replacement.
-</dd>
-<dt> sourcebase.sf using modified zziplib code </dt>
-<dd>
-   In May 2003 I did notice that the sourcebase.sf
-   project - providing a generic virtual filesystem 
-   for applications - has been reusing the zziplib
-   code. However the code has been modified in a
-   number of places and it was (at first) placed
-   under real GPL. That library was supposed to be
-   put under the hood of the GNOME desktop but at
-   the moment it does not seem to go nowhere further.
-</dd>
-</dl>

_service:tar_scm:v0.13.72.tar.gz/docs/referentials.htm Deleted

@@ -1,68 +0,0 @@
-<section><date> 15. July 2002 </date>
-<h2> ZZIP Referentials </h2>                       Where is it used.
-
-
-
-<section>
-<h3> GPL Rant </h3>
-
-<BLOCKQUOTE>
-  The GPL/LGPL do not have a clause like MPL and others to notify the
-  original author about certain usages of the library - that's a pity
-  since I do not get to know many of the areas where zziplib has come
-  to be used. I can only ask you to send me an e-mail, so I can put a
-  link from here to your project. Within thousands of downloads less
-  than a handful of people wrote to me - mostly for having found a bug
-  or having a feature request. Be nice, and write even if you have had
-  successfully implanted zziplib in your project... I love to hear that ;-)
-</BLOCKQUOTE>
-
-</section><section>
-<h3> opensource games </h3>
-
-<BLOCKQUOTE>
-  Although the library has not been written focusing on game data,
-  it has it greatest success just there. The SDL-rwops example did
-  further it by great amounts, people just like it to have the
-  thousand of small bitmaps to be assembled into one big dat file,
-  and put the AI scripts just next to them.
-</BLOCKQUOTE>
-
-<ul><li> Underworld Adventures: <br>
-<a href="http://uwadv.sourceforge.net">
-         http://uwadv.sourceforge.net</a>
-</li><li> Ogre3D Game Development <br />
-<a href="http://www.ogre3d.org/">
-         http://www.ogre3d.org/</a>
-</li></ul>
-
-</section><section>
-<h3> opensource apps/libs </h3>
-
-<BLOCKQUOTE>
-  Here the most important feature has been the smalls size of this
-  library and the possible to use its autoconf script and even for
-  those who don't, it is easy to make a custom configuration. The
-  source code is easy to understand and therefore to customize for
-  the needs of the app/lib that wants to use the functionality.
-</BLOCKQUOTE>
-
-<ul><li> PHP ZIP Module <br>
-<a href="http://www.php.net/manual/en/ref.zip.php">
-         http://www.php.net/manual/en/ref.zip.php</a>
-</li></ul>
-
-</section><section>
-<h3> commercial usage </h3>
-
-<BLOCKQUOTE>
-  For commercial usage, you can bind many small files into a zip
-  file for easier handling. Obfuscation and io-wrapping help
-  greatly to implant it in areas even far from posix-io grounds.
-</BLOCKQUOTE>
-
-<ul><li> Media Portal Backside <br>
-<a href="http://www.appwares.com">
-         http://www.appwares.com</a>
-</li></ul>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/sfx-make.htm Deleted

@@ -1,167 +0,0 @@
-<section> <date> February 2003 </date>
-<h2> SFX-Make </h2>                 combining an EXE with a ZIP archive
-
-
-
-<section>
-<h3> How To </h3>
-<P>
-  In this section we walk you through the steps of combining an EXE
-  with a ZIP archive. The basic scheme goes like this: the final
-  file will have an EXE starting at offset null, followed by the
-  data entries of a ZIP archive. The <em>last</em> part of the ZIP 
-  archive is the ZIP central-directory which ends at the end of the file.
-</P>
-<P>
-  The basic problem lies in the fact that the zip central-directory
-  entries reference their data section with an offset from the 
-  start-of-file so that you can not just append a zip archive after 
-  an exe stub. The trick goes like adding the EXE as the first data
-  part of the ZIP archive - so that the offsets for each entry will
-  be correct when we are finished with it.
-</P>
-<P>
-  Again, one can not just use a zip tool to put the EXE as the first
-  part - since each data part is preceded with an infoblock of a 
-  few bytes. The data of the first data part will therefore not
-  start at offset zero. We solve this problem with moving the data
-  a few bytes later - so that the final file will not start with a
-  "PK" magic (from the zip info header) but with an "MZ" or "ELF"
-  magic (from the exe info header).
-</P>
-
-</section><section>
-<h3> Step 1: Creating The Zip Combination </h3>
-<P>
-  Choose your exe file (example.exe) and wrap that file into a
-  zip container - ensure that the zip tool does <em>not</em>
-  use any compression algorithm on the data. This is usually
-  done with saying "zero compression level" as an option to
-  the zip tool. Also note that <em>no other</em> file is
-  wrapped as some zip tools reorder the entries from the 
-  order on the command line to alphabetic order. Here is an
-  example with infozip's `zip` (e.g. on linux):
-    <pre>    zip -0 -j example.zip example.exe    </pre>
-</P>
-<P>
-  There is no zip tool that would reorder the data entries in
-  an existing zip archive. This mode is used here - the real
-  compressed data entries can now be added to the existing
-  zip archive that currently just wraps the exe part. With
-  specifying maximum compression ("-9" = compression level 9) 
-  and throwing away any subdirectory part ("-j" = junk path)
-  it might look like
-    <pre>   zip -9 -j example.zip data/*   </pre>
-</P>
-<P>
-  Now we need to move the exe part by a few bytes to the
-  real start of the file. This can be done as easily as
-  writing the exe file again on to the start of the file.
-  However, one can not just use a shell-direction or
-  copy-operation since that would truncate (!!) the zip
-  file to the length of the exe part. The overwrite-operation
-  must be done without truncation. For maximum OS independence
-  the zziplib ships with a little tool in "test/zzipsetstub.c"
-  that you can reuse for this task:
-    <pre>   zzipsetstub example.zip example.exe  </pre>
-</P>
-<P>
-  This is it - the `unzip` tool can still access all data
-  entries but the first EXE - the first EXE will be listed
-  in the central-directory of the ZIP archive but one can
-  not extract the data since the "PK" magic at offset null
-  has been overwritten with the EXE magic. The data of all
-  the other entries can still be extracted with a normal
-  `unzip` tool - or any tool from the zziplib be used for
-  the same task.
-</P>
-
-</section><section>
-<h3> Step 2: Accessing The Data From The Program </h3>
-
-<P>
-  There is an example in test/zzipself.c that show how to do
-  it. The OS will provide each program with its own name in
-  argv0 of the main() routine. This program file (!!) is
-  also the zip archive that carries the compressed data
-  entries along. Therefore, we can just issue a zzip_opendir
-  on argv0 to access the zip central-directory.
-</P>
-<P>
-  Likewise one can open a file within it by just prepending
-  the string argv0 to the filename stem, i.e. you could
-  do like 
-    <pre> ZZIP_FILE* f = zzip_fopen ("example.exe/start.gif", "rbi")</pre>
-</P><P>
-  however you are advised to use the _ext_io cousin to be
-  platform independet - different Operating Systems use
-  different file extensions for executables, it's not always
-  an ".exe".
-</P>
-<P>
-  Once the file is opened, the data can be zzip_fread or
-  passed through an SDL_rwops structure into the inner
-  parts of your program.
-</P>
-
-</section><section>
-<h3> Step 3: Using Obfuscation Along </h3>
-
-<P>
-  The next level uses  obfuscatation on the data part of the
-  application. That way there is no visible data to be seen
-  from outside, it looks like it had been compiled right into
-  the C source part. One can furthermore confuse a possible
-  attacker with staticlinking the zziplib into the executable
-  (this is possible in a limited set of conditions).
-</P>
-<P>
-  The first pass is again in creating the zip - here we must
-  ensure that only the ZIP archive part is obfuscated but
-  the EXE part must be plain data so that the operationg 
-  system can read and relocate it into main memory. Using
-  xor-obfuscation this is easy - applying xor twice will
-  yield the original data. The steps look like this now:
-  <pre>
-    zzipxorcopy example.exe example.xor
-    zip -0 application.zip example.xor
-    zip -9 application.zip data/*
-    zzipsetstub application.zip example.xor
-    zzipxorcopy application.zip application.exe
- </pre>
-</P>
-<P>
-  In the second step the open-routine in your application
-  needs to be modified - there are quite some examples in
-  the zziplib that show you how to add an xor-read routine
-  and passing it in the "io"-part of an zzip_open_ext_io
-  routine (see zzipxorcat.c).
-  <pre>
-   static int xor_value = 0x55;
-
-   static zzip_ssize_t xor_read (int f, void* p, zzip_size_t l)
-   {
-       zzip_ssize_t r = read(f, p, l);
-       zzip_ssize_t x; char* q; for (x=0, q=p; x &lt; r; x++) qx ^= xor_value;
-       return r;
-   }
-
-   static struct zzip_plugin_io xor_handlers;
-   static zzip_strings_t xor_fileext = { ".exe", ".EXE", "", 0 };
-   
-   main(...)
-   {
-       zzip_init_io (&amp;xor_handlers, 0); xor_handlers.read = &amp;xor_read;
-  
-       ZZIP_FILE*  fp = zzip_open_ext_io (filename, 
-                             O_RDONLY|O_BINARY, ZZIP_CASELESS|ZZIP_ONLYZIP,
-                             xor_fileext, &amp;xor_handlers);
-      ....
-  </pre>
-</P>
-<P>
-  You may want to pick your own xor-value instead of the default 0x55,
-  the zziplib-shipped tool `zzipxorcopy` does know an option to just
-  set the xor-value with which to obfuscate the data.
-</P>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/zip-php.htm Deleted

@@ -1,63 +0,0 @@
-<H2> PHP-ZIP Installation </H2>
-
-<P>
-  There have been many problems about the installation of the php-zip
-  module. Since Mid of 2006 the php-zip module does not require the
-  zziplib anymore - it uses its own implementation (which is a clean
-  approach in a double sense - there are no source code comments).
-  So, the following might possibly be only relevant for older
-  installations.
-</P>
-
-<P> Chris Branch has been kind enough to jot down the points of a
-    successful php-zip installation sending it to me in May 2006.
-    I am quoting his text verbatim - again, I do not know whether
-    it works or not as I am not using any PHP for real work.
-</P>
-
-<hr width="60%" align="center">
-<DL>
-<DT> Software Packages </DT>
-<dd><ul>
-<li> Apache 2.4.21 (Linux) </li>
-<li> PHP 4.3.9 </li>
-<li> ZZIPLIB 0.10.82 </li>
-<li> Special requirement: static linking
-</ul></dd>
-<DT> Setting up ZZIPLIB </DT>
-<dd><ul>
-<li> Extract files from zziplib-0.10.82.tar.bz2 to a new folder. </li>
-<li> ./configure --enable-static </li>
-<li> make </li>
-<li> make install </li>
-</ul></dd>
-<DT> Rebuilding PHP to include ZIP support </DT>
-<dd><ul>
-<li> Modify PHP build file and add "--with-zip" 
-no dir needed because default /usr/local on my machine </li>
-<li> make </li>
-<li> make install </li>
-</ul></dd>
-<DT> Modifying the Apache Installation </DT>
-<dd><ul>
-<li> Change to Apache source code directory </li>
-<li> Change to "src" subdirectory and edit existing Makefile.  ***
-<br> Add: EXTRA_LIBS=/usr/local/lib/libzzip.a </li>
-<li> Change back to parent folder (cd ..) </li>
-<li> make </li>
-<li> /usr/local/etc/httpd/bin/apachectl stop </li>
-<li> make install </li>
-<li> /usr/local/etc/httpd/bin/apachectl start </li>
-</ul></dd>
-</DL>
-
-<p><b>*** Note:</b>
-That step is the critical step that's not obvious.  Apparently,
-when you build PHP as a static library and include the "--with-zip"
-option, it creates a static library for PHP with an external dependency on
-zziplib.a.  However, the Apache configure script and resulting Makefile
-doesn't take this into account, so Apache won't link unless you hand-edit
-the Apache Makefile.  (Maybe there's a better place to make this change so
-that you don't have to re-fix Apache's Makefile each time you run Apache's
-./configure.  However, I didn't spend the time to investigate that).
-</p>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-api.htm Deleted

@@ -1,30 +0,0 @@
-<section> <date> 20. July 2002 </date>
-<h2> ZZIP Programmers Interface </h2>   The complete API description.
-
-
-
-<P>
-  The zzip library was originally developed by Tomi Ollila as a
-  set of zip decoder routines. Guido Draheim did pick it up and
-  wrapped them under a call synopsis matching their posix
-  api calls. Therefore <code>zzip_open()</code> has the same 
-  synopsis as <code>open(2)</code> but it can open zipped files.
-  Later the distinction was made between magic wrappers and apis
-  for direct access to zip archives and the files contained
-  in the archive. 
-</P>
-<P>
-  These (three) functional apis have little helper functions 
-  alongside including those to get the posix filehandle out of a 
-  zzip handle and to get some attributes about the data handle
-  represented by a zzip handle. Plus checking for error codes
-  that may have been generated from internal checks.
-</P>
-
-<dl>
-<dt> <a href="zzip-basics.html">Basics</a> </dt>
-<dd> Magic Wrappers, Zip Archive Dir access, Zipped File access </dd>
-<dt> <a href="zzip-extras.html">Extras</a> </dt>
-<dd> ext/io init, StdC calls, Error defs, ReOpen, FileStat </dd>
-</dl>
-</section>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-basics.htm Deleted

@@ -1,163 +0,0 @@
-<section> <date> 20. July 2002 </date>
-<h2> ZZIP API Basics </h2>              The open/close API description.
-
-
-
-<section>
-<h3> Basics </h3>
-
-<P>
-  The naming schem of functions in this library follow a simple rule: 
-  if you see a function with a <code>zzip_</code> prefix followed by 
-  compact name representing otherwise a C library or posix function then 
-  it is a magic wrapper that can automagically handle both real 
-  files/directories or zip-contained files. This includes:
-</P>
-<table cellpadding=10 width=100%><tr><td><table width=100% border=1>
-  <tr><td width=50%> zzip_opendir   </td><td width=50%> opendir </td></tr>
-  <tr><td width=50%> zzip_readdir   </td><td width=50%> readdir </td></tr>
-  <tr><td width=50%> zzip_closedir  </td><td width=50%> closedir </td></tr>
-  <tr><td width=50%> zzip_rewinddir </td><td width=50%> rewinddir </td></tr>
-  <tr><td width=50%> zzip_telldir   </td><td width=50%> telldir </td></tr>
-  <tr><td width=50%> zzip_seekdir   </td><td width=50%> seekdir </td></tr>
-</table></td></tr></table>
-<P>
-  The ZZIP_DIR handle can wrap both a real directory or a zip-file. 
-  Note that you can not open a virtual directory <em>within</em> a
-  zip-file, the ZZIP_DIR is either a real DIR-handle of a real 
-  directory or the reference of ZIP-file but never a DIR-handle
-  within a ZIP-file - there is no such schema of a SUB-DIR handle
-  implemented in this library. A ZZIP_DIR does actually represent
-  the central directory of a ZIP-file, so that each file entry in 
-  this ZZIP-DIR can possibly have a subpath prepended.
-</P>
-
-<P>
-  This form of magic has historic reasons as originally the 
-  magic wrappers of this library were not meant to wrap a complete
-  subtree of a real file tree but only a single directory being
-  wrapped with into a zip-file and placed instead. Later proposals
-  and patches were coming in to support subtree wrapping by not
-  only making a split between the dir-part and file-part but
-  going recursivly up through all "/"-dirseparators of a filepath
-  given to <code>zzip_open</code> and looking for zip-file there.
-</P>
-
-<P>
-  To open a zip-file unconditionally one should be using their
-  respective methods that would return a ZZIP_DIR handle being
-  the representant memory instance of a ZIP-DIR, the central
-  directory of a zip-file. From that ZZIP-DIR one can open a
-  compressed file entry which will be returned as a ZZIP_FILE
-  pointer.
-</P>
-<table cellpadding=10 width=100%><tr><td><table border=1 width=100%>
-  <tr><td width=50%> zzip_dir_open  </td>
-      <td width=50%> open a zip-file and parse the central directory 
-                                              to a memory shadow</td></tr>
-  <tr><td width=50%> zzip_dir_close  </td>
-      <td width=50%> close a zip-file and free the memory shadow</td></tr>
-  <tr><td width=50%> zzip_dir_fdopen  </td>
-      <td width=50%> acquire the given posix-file and try to parse it
-                                                  as a zip-file.</td></tr>
-  <tr><td width=50%> zzip_dir_read  </td>
-      <td width=50%> return the next info entry of a zip-file's central
-                 directory - this would include a possible subpath </td></tr>
-</table></td></tr></table>
-
-<P>
-  To unconditionally access a zipped-file (as the counter-part of a 
-  zip-file's directory) you should be using the functions having a
-  <code>zzip_file_</code> prefix which are the methods working on
-  ZZIP_FILE pointers directly and assuming those are references of
-  a zipped file with a ZZIP_DIR. 
-</P>
-<table cellpadding=10 width=100%><tr><td><table border=1 width=100%>
-  <tr><td width=50%> zzip_file_open  </td>
-      <td width=50%> open a file within a zip and prepare a zlib 
-                     compressor for it - note the ZZIP_DIR argument,
-                     multiple ZZIP_FILE's may share the same central
-                     directory shadow.</td></tr>
-  <tr><td width=50%> zzip_file_close  </td>
-      <td width=50%> close the handle of zippedfile
-                     and free zlib compressor of it</td></tr>
-  <tr><td width=50%> zzip_file_read  </td>
-      <td width=50%> decompress the next part of a compressed file
-                     within a zip-file</td></tr>
-</table></td></tr></table>
-<P>
-  From here it is only a short step to the magic wrappers for
-  file-access - when being given a filepath to zzip_open then
-  the filepath is checked first for being possibly a real file
-  (we can often do that by a <code>stat</code> call) and if there is
-  a real file under that name then the returned ZZIP_FILE is
-  nothing more than a wrapper around a file-descriptor of the
-  underlying operating system. Any other calls like zzip_read
-  will see the realfd-flag in the ZZIP_FILE and forward the 
-  execution to the read() function of the underlying operating system.
-</P>
-
-<P>
-  However if that fails then the filepath is cut at last directory
-  separator, i.e. a filepath of "this/test/README" is cut into the
-  dir-part "this/test" and a file-part "README". Then the possible
-  zip-extensions are attached (".zip" and ".ZIP") and we check if
-  there is a real file under that name. If a file "this/test.zip"
-  does exist then it is given to zzip_dir_open which will create
-  a ZZIP_DIR instance of it, and when that was successul (so it
-  was in zip-format) then we call zzip_file_open which will see
-  two arguments - the just opened ZZIP_DIR and the file-part. The
-  resulting ZZIP_FILE has its own copy of a ZZIP_DIR, so if you
-  open multiple files from the same zip-file than you will also
-  have multiple in-memory copies of the zip's central directory
-  whereas otherwise multiple ZZIP_FILE's may share a common
-  ZZIP_DIR when being opened with zzip_file_open directly - the
-  zzip_file_open's first argument is the ZZIP_DIR and the second
-  one the file-part to be looked up within that zip-directory.
-</P>
-
-<table cellpadding=10 width=100%><tr><td><table border=1 width=100%>
-  <tr><td width=50%> zzip_open  </td>
-      <td width=50%> try the file-path as a real-file, and if not
-                     there, look for the existence of ZZIP_DIR by
-                     applying extensions, and open the file 
-                     contained within that one.</td></tr>
-  <tr><td width=50%> zzip_close  </td>
-      <td width=50%> if the ZZIP_FILE wraps a real-file, then call
-                     read(), otherwise call zzip_file_read() </td></tr>
-  <tr><td width=50%> zzip_close  </td>
-      <td width=50%> if the ZZIP_FILE wraps a real-file, then call
-                     close(), otherwise call zzip_file_close() </td></tr>
-</table></td></tr></table>
-
-<P>
-  Up to here we have the original functionality of the zziplib
-  when I (Guido Draheim) created the magic functions around the work from 
-  Tomi Ollila who wrote the routines to read and decompress files from
-  a zip archive - unlike other libraries it was quite readable and
-  intelligible source code (after many changes there is not much
-  left of the original zip08x source code but that's another story).
-  Later however some request and proposals and patches were coming in.
-</P>
-
-<P>
-  Among the first extensions was the recursive zzip_open magic. In
-  the first instance, the library did just do as described above:
-  a file-path of "this/test/README" might be a zip-file known as
-  "this/test.zip" containing a compressed file "README". But if 
-  there is neither a real file "this/test/README" and no real
-  zip-file "this/test.zip" then the call would have failed but
-  know the zzip_open call will recursivly check the parent
-  directories - so it can now find a zip-file "this.zip" which
-  contains a file-part "test/README". 
-</P>
-
-<P>
-  This dissolves the original meaning of a ZZIP_DIR and it has lead 
-  to some confusion later on - you can not create a DIRENT-like handle
-  for "this/test/" being within a "test.zip" file. And actually, I did
-  never see a reason to implement it so far (open "this.zip" and set
-  an initial subpath of "test" and let zzip_readdir skip all entries
-  that do not start with "test/"). This is left for excercie ;-)
-</P>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-crypt.htm Deleted

@@ -1,92 +0,0 @@
-<section> <date> 15. July 2002 </date>
-<h2> ZIP Std Encryption </h2>       Standard Zip Encryption is Weak!
-
-
-
-<section>
-<h3> Some rationale </h3>
-
-<P>
-  Some people might ask why not adding standard zip-encryption. Well,
-  first of all the standard zip-encryption has not been strong enough
-  for modern computers, and there are hacker tools that even a 
-  half-literate computer-user can use to crack the password of a
-  zip-archive. In other words: <b> every encrypted zip file can be
-  cracked using freely downloadable helper tools </b>. That's because
-  standard zip encryption is weak regarding modern personal computer 
-  power. Furthermore, adding <em>real</em> encryption is a heavy weight
-  that many people do not need, see the last argument for seeing the
-  standard one is useless anyway, and adding a non-standard one 
-  should not be the case of the standard zziplib either, ye know.
-</P><P>
-  On the other hand, obfuscation is a means to fear off half-literates
-  just as well - there are no <em>premade</em> tools for the obfuscation you
-  can invent from the xor examples. And a hacker that can de-obfuscate
-  such a dat-file is able to dissassemble your program as well - just to
-  remind you that the disassembly of a program will reveal the decryption
-  routine <em>and</em> the decryption key, even for a heavyweight crypt
-  algorithm. Although there is a difference, it just ranges on about times 
-  and exprience, not magnitudes. Remember the old saying: you can irritate
-  some people for some time but not irritate all people for all the time.
-  As for encryption of artwork and AI scripts in games and applications,
-  just keep in mind that the final recipient has the decryption key on
-  his system anyway, just obfuscated. So each such encryption is nothing
-  more than just a clever form of obfuscation, nothing mathematical strong.
-</P><P>
-  Some other people might ask why to obfuscate anyway. Well, the reason
-  is theft. Even people who write opensource free software generally
-  like to get some reward for what they do, some fame or atleast some 
-  sweet dream to have helped the world go a bit easier in the future.
-  As for program text this is quite natural for the programmers who
-  pick up some code from somewhere else - it happens that most of them
-  have gone through some formation and they know how hard it is to get
-  even some lines of code out of your brain. This is not the case for
-  some artwork and AI parameters, people do not have much respect for
-  those - they just pick it up, put it under their umbrella, and 
-  that's it - they even claim they could have done that themselves,
-  and in most cases it is that they never have been really trying to
-  do it and think of it as being comparable to that action-art they've
-  seen on TV. 
-</P><P>
-  Just be sure that there is nothing wrong with obfuscating
-  things for a binary distribution of your program even for the
-  opensource case - the program text itself is an obfuscation in its
-  source form when being compiled into cpu instructions. Still, the
-  interested people can get hold of the source code since you provide
-  it somewhere and actually the original programmers like to hear 
-  from literate people who could help with modifying the project. The
-  same is true for you artwork and AI scripts, the interested people
-  can still see them in the opensource project material, but only
-  those will look who dare to, not just the halfwit next door. 
-</P><P>
-  Well, you do not need to that on the other hand - ID software has
-  shown that it can be very helpful since people will start to
-  write new maps and new bots, pack them and publish them. An open
-  data format is a form of attraction for people who can use a 
-  graphics program and an editor but who do not know how to program.
-  And if you use obfuscation within an opensource program, it is
-  surely enought to just use the xor-format presented here, so that
-  it easy for third people to get involved if they want to, they
-  just have to rewrite their new datapacks with zzxorcopy, and
-  that's it.
-</P><P>
-  As for the non-opensource projects, be aware that there are
-  some ways to even staticlink the zziplib into your project, so
-  you can even hide that you used zip tools to create your dat files.
-  This is well enough for anyone to do - as soon as a hacker will
-  get to the point to notice you used a zip format, he would have
-  had found any other deobfusation or decryption routine as well.
-  If you are frightened, just encrypt the executable with tools
-  you bought from somewhere else. On the other hand, should there
-  be problems or bugs, you have an easier time to find them when
-  they could be caused by your dat entries, and it is again easy
-  to send a fixup file to your clients, since the command line
-  tools are just a breeze compared with some other anti-hacking
-  tools you'll find on the market.
-</P><P>
-  Well, hope this is enough rationale to tell you that I do not
-  see a need to implement anything more than obfuscation within
-  zziplib - if you need real encryption, use real encryption
-  software and its fileformat that supports it, not zip files.
-</P>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-cryptoid.htm Deleted

@@ -1,106 +0,0 @@
-<section> <date> 11. May 2004 </date>
-<h2> ZIP Ext Encryption </h2>       ext/io used for cryptoid plugins
-
-
-
-<section>
-<h3> Stronger Obfuscation For ZZip </h3>
-
-<P>
-  Some people feel that a simple bytewise xor is not strong enough
-  as an obfuscation for the data. There we have the question how to
-  implant a stronger obfuscation routine to protect that data of an
-  application from artwork theft. Perhaps there is even the idea to
-  use an obfuscation in the range of a real crypt routine - in which
-  case I want to recommend strongly to read the 
-  <a href="zzip-crypt.html"> reasoning page </a> why it can not be
-  real encryption and that the resulting obfuscation has an upper 
-  limit being <em>lower</em> than the crypt routine complexity.
-</P>
-
-<P>
- After reminding you of this fact we can go at evaluationg how to
- implant a stronger obfusction routine to protect your data. The
- ext/io feature uses a callback routine "read" that must read a
- block of the given size - for the obfuscation case it will call
- the "read()" function of the underlying operation system, and
- the obfuscated block will be deobfuscated before returning it to
- the caller.
-</P>
-
-<P>
- In this mechanism there is not asseration at which file-offset
- the ext/io-read() callback is triggered. That is the reason we
- have shown obfuscation with bytewise xor-key example - formally
- this is using obfuscation blocks of 8bit width being aligned
- on 8bit boundaries in the data file, and our decryption stream
- is stateless being the same for each obfuscation block (of 8bit
- width). 
-</P>
-<P>
- In order for a stronger obfuscation we have to break those 
- limitations which are directly derived from the natural way
- of the handling of files by a contemporary operating system.
- This is triggered as the call synopsis of the ext/io read()
- callback matches <em>exactly</em> the one of posix, so that
- one can use the posix read() function reference as the default
- for ensuring the most minimal overhead in accessing non-obfuscated 
- zip files. 
-<br><small>And btw, the abbreviation "posix" stands for 
-   "Portable Open System in Unix".</small>
-</P>
-
-<P>
- The trick we show here: the first argument of the ext/io read
- callback is the file descriptor of the underlying operationg
- system. While we can not add another argument to the ext/io
- read call we can pick up additional information with the help
- of that file descriptor id being globally unique even across
- multiple threads. One solution would make the application map
- that descriptor id to a special argument but this is often too
- much overhead: the current file position is enough. 
-</P>
-<P>
- The current file position is managed by the operation system
- via the file descriptor table. There is a function call to
- map a file descriptor to the current read position offset
- usually named "tell(fd)". Since this call is not mandated by
- posix, you can emulate it with the posix lseek() call which
- returns the resulting offset after the operation was performed,
- so we just seek by a zero offset: <br><code> 
- <> <> <> <> #define tell(fd) lseek(fd,0,SEEK_CUR)
-</code>
-</P>
-
-<P>
- That file offset is measured from the start of the zip archive,
- not per each zipped file. Remind yourself of that fact when
- creating your own "zzobfuscate.exe" which should work on the
- zip archive and not per file before zipping. That is a difference
- over normal zip archives where the user can atleast recognized the
- dat file as a zip archive and see a list of files contained in the 
- archive, atleast their names and data start offset.
-</P>
-<P>
- Now, let's use the file read offset to break the blocking
- limitations of 8bit/8bit to a larger xor-key. In our example
- we expand to a 32bit/32bit xor-key giving a search space of
- 4<>billion keys instead of the just 256<>keys in 8bit blocking.
- That is simply done by a static 4<>byte xor-key sequence and using
- modulo operations for alignment. For the 2^X cases any modulo
- operations shrink to a set of ultra-fast bitwise-and operations.
-</P>
-
-<pre>
-      static char xor_value4 = { 0x55, 0x63, 0x27, 0x31 };
-      static zzip_ssize_t xor_read (int f, void* p, zzip_size_t l)
-      {
-          zzip_off_t  y = tell(f);
-          zzip_size_t r = read(f, p, l);
-	  zzip_size_t x;  char* q = p;
-          for (x=0; x &lt; r; x++) qx ^= xor_value(y+x)&amp;3;
-          return r;
-      }
-</pre>
-
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-extio.htm Deleted

@@ -1,188 +0,0 @@
-<section> <date>15. July 2002 </date>
-<h2> ZZIP-EXT/IO </h2>	Customizing the file access
-
-
-
-<section>
-<h3> The EXT/IO calls </h3>
-
-<P>
-  There were quite some requests from game developers and graphics-apps
-  developers who wanted various extensions to be included into the
-  <a href="zziplib.html">zziplib library</a>, but most of them were
-  only of specific usage. After some discussions we came up with a
-  model to customize the <a href="zziplib.html">zziplib library</a>
-  calls in a number of ways - and adding two or three arguments to
-  the zzip_* calls. The standard <a href="zziplib.html">zziplib library</a>
-  will actually call these *_ext_io functions with these extra arguments
-  to be set to zero.
-</P><P>
-  The EXT feature describes a way to customize the extensions used in
-  the magic wrapper to find a .ZIP file. It turned out that there are
-  quite a number of applications that did chose the zip file format as
-  their native document format and where just the file extension had
-  been changed. This includes file types like Quake3 ".PK3" files from
-  ID Software, the Java library files called ".JAR", and lately the 
-  OpenOffice-6 (resp. StarOffice-6) documents which carry xml-files along.
-  Just build a zero-termined string-list of file-extensions and submit it
-  to the _ext_io calls to let the <a href="zziplib.html">zziplib</a> find
-  parts of those zip-documents automagically.
-</P><P>
-  In quite some of these cases, it is very benefical to make use of the
-  o_modes functionality that allows to submit extra bit-options into
-  the <a href="zziplib.html">zziplib</a> - this includes options like
-  <code>ZZIP_PREFERZIP</code> or even <code>ZZIP_ONLYZIP</code> which
-  modifies the default behaviour of looking for real files first instead
-  of some within a zipped directory tree. Other bit-options include
-  <code>ZZIP_CASELESS</code> to imitate win32-like filematching for a
-  zipped filetree.
-</P><P>
-  Other wishes on <a href="zziplib.html">zziplib</a> circulated around
-  <a href="zzip-xor.html">obfuscation</a> or access to zip-files wrapped 
-  in other data areas including encrpyted resources from other applications. 
-  This has been addressed with the IO-handlers that you can explicitly
-  submit to the *_ext_io functions - the default will be posix-IO 
-  open/read/write and seek/tell. An application using 
-  <a href="zziplib.html">zziplib</a> can divert these to its own set of
-  these calls - and it only needs to declare them on opening a zipped file.
-</P>
-
-</section><section>
-<h3> The EXT stringlist </h3>
-
-<P>
-  Declaring an EXT stringlist is very simple as it is simply a 
-  list of strings, the <a href="zziplib.html">zziplib</a> provides
-  you with a double-const <code>zzip_strings_t</code> type to help
-  you move a global declaration into the writeonly segment of your
-  app - it turned out that about all developers wanted just some
-  extensions on the default and they were fine with having them
-  global-const for their application, nothing like dynamically
-  modifying them. Well, you are still allowed to make it fully
-  dynamic... if you find a use case for that.
-</P><P>
-  Extending the magic zip-extensions is just done by adding the 
-  additional extensions to be recognized - just remember to add
-  the uppercased variants too since those will be needed on
-  (unx-like) filesystems that are case-sensitive. In the internet
-  age, quite some downloaded will appear in uppercased format since
-  the other side declared it as that and that other end was happy
-  with it as being a (w32-like) case-insensitive server. Therefore,
-  it should look like <pre>
-     static zzip_strings_t my_ext = { ".zip", ".ZIP", ".jar", ".JAR", 0 };
-  </pre>
-</P><P>
-  There is one frequently asked question in this area - how to open
-  a zipped file as "test.zip/README" instead of "test/README". Other
-  than some people might expect, the library will not find it - if
-  you want to have that one needs a fileext list that contains the
-  empty string - not the zero string, an empty string that is. It
-  looks like <pre>
-     static zzip_strings_t my_ext = { ".zip", ".ZIP", "", 0 };
-  </pre>
-</P><P>
-  And last not least, people want to tell the library to not try to
-  open a real file that lives side by side with the same path as the
-  file path that can be matched by the zziplib. Actually, the magic
-  wrappers were never meant to be used like - the developer should
-  have used zzip_dir_* functions to open a zip-file and the 
-  zzip_file_* functions to read entries from that zip-file. However,
-  the magic-wrappers look rather more familiar, and so you will find
-  now a bit-option ZZIP_ONLYZIP that can be passed down to the _ext_io
-  variants of the magic-wrapper calls, and a real-file will never get
-  tested for existence. Actually, I would rather recommend that for
-  application data the option ZZIP_PREFERZIP, so that one can enter
-  debugging mode by unpacking the zip-file as a real directory tree
-  in the place of the original zip.
-</P>
-
-</section><section>
-<h3> The IO handlers </h3>
-
-<P>
-  While you will find the zzip_plugin_io_t declared in the zziplib
-  headers, you are not advised to make much assumptions about their
-  structure. Still we gone the path of simplicity, so you can use
-  a global static for this struct too just like one can do for the
-  EXT-list. This again mimics the internals of zziplib. There is
-  even a helper function zzip_init_io that will copy the zziplib
-  internal handlers to your own handlers-set. Actually, this is
-  barely needed since the zziplib library will not check for nulls
-  in the plugin_io structure, all handlers must be filled, and the
-  zziplib routines call them unconditionally - that's simply 
-  because a conditional-call will be ten times slower than an
-  unconditional call which adds mostly just one or two cpu cycles
-  in the place so you won't ever notice zziplib to be anywhat
-  slower than before adding IO-handlers.
-</P><P>
-  However, you better instantiate your handlers in your application
-  and call that zzip_init_io on that instance to have everything
-  filled, only then modify the entry you actually wish to have
-  modified. For <a href="zzip-xor.html">obfuscation</a> this
-  will mostly be just the <code>read()</code> routine. But one can
-  also use IO-handlers to wrap zip-files into another data part
-  for which one (also) wants to modify the open/close routines
-  as well.
-</P><P>
-  Therefore, you can modify your normal stdio code to start using
-  zipped files by exchaning the fopen/fread/fclose calls by their
-  magic counterparts, i.e. <pre>
-    // FILE* file = fopen ("test/README", "rb");
-    ZZIP_FILE* file = zzip_fopen ("test/README", "rb");
-    // while (0 &lt; fread (buffer, 1, buflen, file))) 
-    while (0 &lt; zzip_fread (buffer, 1, buflen, file)))
-       { do something }
-    // fclose (file);
-    zzip_fclose (file);
-  </pre>
-</P><P>
-   and you then need to prefix this code with some additional 
-   code to support your own EXT/IO set, so the code will finally
-   look like <pre>
-    /* use .DAT extension to find some files */
-    static zzip_strings_t ext = { ".dat", ".DAT", "", 0 }; 
-    /* add obfuscation routine - see zzxorcat.c examples */
-    static zzip_plugin_io_t io;
-    zzip_init_io (&amp; io, 0);
-    io.read = xor_read; 
-    /* and the rest of the code, just as above, but with ext/io */
-    ZZIP_FILE* file = zzip_open_ext_io ("test/README", O_RDONLY|O_BINARY,
-                                        ZZIP_ONLYZIP|ZZIP_CASELESS, ext, io);
-    while (0 &lt; zzip_fread (buffer, 1, buflen, file)))
-        { do something }
-    zzip_fclose (file);
-  </pre>   
-</P>
-
-</section><section>
-<h3> Finally </h3>
-
-<P>
-   What's more to it? Well, if you have some ideas then please mail me
-   about it - don't worry, I'll probably reject it to be part of the
-   standard zziplib dll, but perhaps it is worth to be added as a
-   configure option and can help others later, and even more perhaps
-   it can be somehow generalized just as the ext/io features have been
-   generalized now. In most respects, this ext/io did not add much
-   code to the <a href="zziplib.html">zziplib</a> - the posix-calls
-   in the implemenation, like <code>"read(file)"</code> were simply
-   exchanged with <code>"zip-&gt;io-&gt;read(file)"</code>, and the 
-   old <code>"zzip_open(name,mode)"</code> call is split up - the old
-   entry still persists but directly calls 
-   <code>"zzip_open_ext_io(name,mode,0,0,0)"</code> which has the
-   old implementation code with just one addition: when the ZIP_FILE
-   handle is created, it uses the transferred io-handlers (or the
-   default ones if io==0), and initialized the io-member of that
-   structure for usage within the <code>zzip_read</code> calls.
-</P><P>
-   This adds just a few bytes to the libs and just consumes additional 
-   cpu cycles that can be rightfully called to be negligible (unlike
-   most commercial vendors will tell you when they indeed want to
-   tell you that for soooo many new features you have to pay a price).
-   It makes for greater variability without adding fatness to the
-   core in the default case, this is truly efficient I'd say. Well,
-   call this a German desease :-)=) ... and again, if you have another
-   idea, write today... or next week.
-</P>
-
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-extras.htm Deleted

@@ -1,164 +0,0 @@
-<section><date> 20. July 2002 </date>
-<h2> ZZIP API extras </h2>             The check/init API description.
-
- 
-
-<section>
-<h3> Extras </h3>
-
-<P>
-  The next requests circulated around other file-extensions to 
-  automagically look inside filetypes that have zip-format too but 
-  carry other fileextensions - most famous might be the ".PK3"
-  files of ID's Quake game. There have been a number of these
-  requests and in a lot of cases it dawned to me that those guys
-  may have overlooked the zzip_dir_open functions to travel
-  through documents of zipformat under any name - that is that the
-  "magic" was not actually needed but they just wanted to read
-  files in zipformat with the zziplib.
-</P>
-
-<P>
-  Other requests circulated around encryption but I did reject
-  those bluntly, always. Instead there have been always examples
-  for doing some obfuscation around the zip-format so that the
-  stock zip/unzip tools do not recognize them but a game
-  software developer can pack/unpack his AI scripts and bitmaps
-  into such a zipformat-like file.
-</P>
-
-<P>
-  After some dead-end patches (being shipped along with the
-  zziplib as configure-time compile-options - greetings to
-  Lutz Sammer and Andreas Schiffler), the general approach 
-  of _ext_io came up, and finally implemented (greetings go
-  to Mike Nordell). The _open()-calls do now each have a
-  cousin of _open_ext_io() with two/three additional arguments
-  being a set of extensions to loop through our magic testing,
-  a callback-handler plugin-table for obfuscation-means, 
-  and (often) a bit-mask for extra-options - this bitmask even
-  has "PREFERZIP" and "ONLYZIP" options to skip the real-file
-  test magic in those <code>zzip_*open</code> functions.
-</P>
-
-<table cellpadding=10 width=100%><tr><td><table border=1 width=100%>
-  <tr><td width=50%> zzip_open(name,flags) </td>
-      <td width=50%> zzip_open_ext_io(name,flags,mode,ext,io) </td></tr>
-  <tr><td width=50%> zzip_opendir(name) </td>
-      <td width=50%> zzip_opendir_ext_io(name,mode,ext,io) </td></tr>
-  <tr><td width=50%> zzip_dir_open(name,errp) </td>
-      <td width=50%> zzip_dir_open_ext_io(name,errp,ext,io) </td></tr>
-  <tr><td width=50%> zzip_dir_fdopen(fd,errp) </td>
-      <td width=50%> zzip_dir_fdopen_ext_io(fd,errp,ext,io) </td></tr>
-  <tr><td width=50%> zzip_file_open(dir,name,mode) </td>
-      <td width=50%> zzip_file_open_ext_io(dir,name,mode,ext,io) </td></tr>
-</table></td></tr></table>
-
-<P>
-  Oh, and note that the mode,ext,io extras are memorized 
-  in the respecitive ZZIP_DIR handle attached, so each
-  of the other calls like <code>zzip_file_open()</code>
-  and <code>zzip_read()</code> will be using them. There
-  are a few helper routines to help setup a new io-plugin
-  where the init_io will currently just memcopy the
-  default_io entries into the user-supplied plugin-struct.
-</P>
-
-<table cellpadding=10 width=100%><tr><td><table border=1 width=100%>
-  <tr><td width=50%> zzip_init_io </td>
-      <td width=50%> the recommended way to do things </td></tr>
-  <tr><td width=50%> zzip_get_default_io </td>
-      <td width=50%> used internally whenever you supply a null
-                     for the io-argument of a _ext_io()-call </td></tr>
-  <tr><td width=50%> zzip_get_default_ext </td>
-      <td width=50%> used internally but not exported </td></tr>
-</table></td></tr></table>
-
-
-<P>
-  And last some stdio-like replacements were build but these
-  happen to be actually just small wrappers around the other
-  posix-like magic-calls. It just offers some convenience
-  since wrappers like "SDL_rwops" tend to use a stringised
-  open-mode - and I took the occasion to fold the zzip-bits
-  for the _ext_io-calls right in there recognized via 
-  special extensions to the openmode-string of zzip_fopen().
-</P>
-
-<table cellpadding=10 width=100%><tr><td><table border=1 width=100%>
-  <tr><td width=50%> zzip_fopen </td>
-      <td width=50%> convert stringmode and call zzip_open_ext_io </td></tr>
-  <tr><td width=50%> zzip_fread </td>
-      <td width=50%> slower way to say zzip_read </td></tr>
-  <tr><td width=50%> zzip_fclose </td>
-      <td width=50%> a synonym of zzip_close </td></tr>
-</table></td></tr></table>
-
-<P>
-  For some reason, people did need the full set of function-calls()
-  to be working on zzip-wrappers too, so here they are - if the
-  ZZIP_FILE instance did wrap a real file, then the real posix-call
-  will be used, otherwise it is simulated on the compressed stream
-  with a zip-contained file - especially <code>seek()</code> can be 
-  a slow operation:
-  if the new point is later then just read out more bytes till we
-  hit that position but if it is an earlier point then rewind to the
-  beginning of the compressed data and start reading/decompression
-  until the position is met.
-</P>
-
-<table cellpadding=10 width=100%><tr><td><table border=1 width=100%>
-  <tr><td width=50%> zzip_rewind </td>
-      <td width=50%> magic for rewind() </td></tr>
-  <tr><td width=50%> zzip_tell </td>
-      <td width=50%> magic for tell() </td></tr>
-  <tr><td width=50%> zzip_seek </td>
-      <td width=50%> magic for seek() </td></tr>
-</table></td></tr></table>
-
-<P>
-  And last not least, there are few informative functions to
-  use function-calls to read parts of the opaque structures
-  of zzip-objects and their zzip-factory.
-</P>
-
-<table cellpadding=10 width=100%><tr><td><table border=1 width=100%>
-  <tr><td width=50%> zzip_dir_stat </td>
-      <td width=50%> a stat()-like thing on a file within a ZZIP_DIR </td></tr>
-  <tr><td width=50%> zzip_dir_real </td>
-      <td width=50%> check if ZZIP_DIR wraps a stat'able posix-dirent</td></tr>
-  <tr><td width=50%> zzip_file_real </td>
-      <td width=50%> check if ZZIP_FILE wraps a stat'able posix-file </td></tr>
-  <tr><td width=50%> zzip_realdir </td>
-      <td width=50%> if zzip_dir_real then return the posix-dirent </td></tr>
-  <tr><td width=50%> zzip_realfd </td>
-      <td width=50%> if zzip_file_real then return the posix-file </td></tr>
-  <tr><td width=50%> zzip_dirhandle </td>
-      <td width=50%> the attached ZZIP_DIR of compressed ZZIP_FILE </td></tr>
-  <tr><td width=50%> zzip_dirfd </td>
-      <td width=50%> the attached posix-file of ZZIP_DIR zip-file </td></tr>
-  <tr><td width=50%> zzip_set_error </td>
-      <td width=50%> set the last ZZIP_DIR error-code </td></tr>
-  <tr><td width=50%> zzip_error </td>
-      <td width=50%> get the last ZZIP_DIR error-code </td></tr>
-  <tr><td width=50%> zzip_strerror </td>
-      <td width=50%> convert a zzip_error into a readable string </td></tr>
-  <tr><td width=50%> zzip_strerror_of </td>
-      <td width=50%> combine both above zzip_strerror of zzip_error </td></tr>
-  <tr><td width=50%> zzip_errno </td>
-      <td width=50%> helper to wrap a zzip-error to a posix-errno </td></tr>
-  <tr><td width=50%> zzip_compr_str </td>
-      <td width=50%> helper to wrap a compr-number to a readable string
-                     </td></tr>
-  <tr><td width=50%> zzip_dir_free </td>
-      <td width=50%> internally called by zzip_dir_close if the ref-count 
-                     of the ZZIP_DIR has gone zero</td></tr>
-  <tr><td width=50%> zzip_freopen </td>
-      <td width=50%> to reuse the ZZIP_DIR from another ZZIP_FILE so it does
-                     not need to be parsed again </td></tr>
-  <tr><td width=50%> zzip_open_shared_io </td>
-      <td width=50%> the ext/io cousin but it does not close the old ZZIP_FILE
-                     and instead just shares the ZZIP_DIR if possible</td></tr>
-</table></td></tr></table>
-
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-file.htm Deleted

@@ -1,183 +0,0 @@
-<section> <date> 1. June 2000 </date>
-<h2> ZIP File Access </h2>  Using Zipped Files Transparently 
-
-
-
-<section>
-<h3>The Typedef</h3>
-
-<P>
- The typedef <code>ZZIP_FILE</code> can serve as a replacement 
- for a normal file descriptor. As long as it is only used
- for reading a file, the zzlib-user can actually replace
- the posix functions <code>open/read/close</code> 
- by their counterparts from the 
- <a href="zziplib.html">zziplib library</a>:
- <code>zzip_open/zzip_read/zzip_close</code>.
-</P>
-<P>
- As long as the filename path given to <code>zzip_open</code>
- refers to a real file in the filesystem, it will almost
- directly forward the call to the respective posix <code>open</code>
- call. The returned file descriptor is then stored in
- a member-variable of the <code>ZZIP_FILE</code> structure.
-</P>
-<P>
- Any subsequent calls to <code>zzip_read</code> will then
- be forwarded to the posix <code>read</code> call on the
- memorized file descriptor. The same about <code>zzip_close</code>
- which will call the posix <code>close</code> function and then
- <code>free</code> the <code>ZZIP_FILE</code> structure.
-</P>
-<P>
- The real benefit of the 
- <a href="zziplib.html">zziplib library</a>
- comes about when the filename argument does actually refer
- to a file that is zipped in a zip-archive. It happens that
- even both a real file and a zipped file can live under the
- same pathname given to the <code>zzip_open</code> call,
- whereas the real file is used in preference.
-</P>
-
-</section><section>
-<h3>Zipped File</h3>
-
-<P>
- Suppose you have subdirectory called '<tt>test/</tt>'. In
- this directory is just one file, called '<tt>README</tt>'.
- Calling the <code>zzip_open</code> function with an
- argument of '<i>optional-path/</i> <tt>test/README</tt>',
- then it will open that file for subsequent reading with
- <code>zzip_read</code>. In this case the real (<i>stat'able</i>)
- file is opened.
-</P>
-<P>
- Now you can go to the '<tt>test/</tt>' directory and zip up
- the files in there by calling 
- <nobr><tt>`zip ../test.zip *`</tt></nobr>.
- After this, you can delete the '<tt>test/</tt>' directory and
- the call to <code>zzip_open</code> will still succeed.
- The reason is that the part of the path saying 
- '<tt>test/README</tt>' will be replaced by sth. like 
- '<tt>test.zip:README</tt>' - that is the real file '<tt>test.zip</tt>'
- is opened and searched for a contained file '<tt>README</tt>'.
-</P>
-<P>
- Calling <code>zzip_read</code> on the zipped '<tt>README</tt>' file
- will return the very same data as if it is a real file in a
- real directory. If the zipped file is compressed it will be 
- decompressed on the fly.
-</P>
-
-</section><section>
-<h3>Zip Directory</h3>
-
-<P>
- The same applies to the use of <code>opendir/readdir/closedir</code>
- which can safely be replaced with their counterparts from the
- <a href="zziplib.html">zziplib library</a> - again their prototype
- follows the scheme of the original calls, just prepend <tt>zzip_</tt>
- to the function calls and <tt>ZZIP_</tt> to the struct-typedefs.
-</P>
-<P>
- To call <code>zzip_opendir</code> on a real directory will then
- return a <code>ZZIP_DIR</code> whose member-variable 
- <code>realdir</code> points to the actual <code>DIR</code>-structure
- returned by the underlying posix <code>opendir</code>-call.
-</P>
-<P>
- If a real directory '<tt>test</tt>' does not exist, then the
- <code>zzip_opendir</code> will try to open a file '<tt>test.zip</tt>'
- with a call to <code>zzip_dir_open</code>.
- Subsequent calls to <code>zzip_readdir</code> will then return
- information as being obtained from the central archive directory
- of the zip-file.
-</P>
-
-</section><section>
-<h3>Differences</h3>
-
-<P>
- There are no differences between the posix calls and their counterparts
- from the      <a href="zziplib.html">zziplib library</a> - well, just
- as long as the zip-file contains just the plain files from a directory.
-</P>
-<P>
- If the zip-file contains directory entries you may be prompted with
- some awkward behaviour, since in zip-file a directory happens to be
- just an empty file. Note that the posix function <code>open</code>
- may also open a directory for reading - it will only return 
- <code>EISDIR</code> if the <code>open</code> mode-argument included
- write-access.
-</P>
-<P>
- What the current of version of the 
- <a href="zziplib.html">zziplib library</a>
- can definitely not do: calling zzip_opendir on a directory zippend
- <em>inside</em> a zip-file.
-</P>
-<P>
- To prevent the enrollment of directories into the zip-archive, you
- can use the <tt>-D</tt> option of the <tt>zip</tt> program. That
- is in any <tt>Makefile</tt> you may want to use
- <nobr><tt>`cd $(dir) &amp;&amp; zip -D ../$(dir).zip *`</tt></nobr>.
-</P> 
-
-</section><section>
-<h3>Advantages</h3>
-
-<P>
- Distribution of a set of files is much easier if it just means
- to wrap up a group of files into a zip-archive - and copy that
- zip-archive to the respective destination directory.
- Even more the files can be compressed and unlike a <tt>tar.gz</tt>
- archive there is no need to decompress the archive in temporary
- location before accessing a member-file.
-</P>
-<P>
- On the other hand, there is no chance to scatter files around
- on the disk like it could easily happen with a set of gzip'ed
- man-pages in a single `<tt>man</tt>`-directory. The reader
- application does not specifically need to know that the file
- is compressed, so that reading a script like 
- `<tt>share/guile/x.x.x/ice-9/popen.scm</tt>` is done by simple
- calls to <code>zzip_read</code> which works on zip-file named
- `<tt>share/guile/x.x.x/ice-9.zip</tt>`.
-</P>
-<P>
- A version mismatch between different files in a group is now
- obvious: either the opened file belongs to the distribution
- archive, or otherwise in resides in a real directory <em>just
- next to the zip-archive that contains the original</em>.
-</P>
-
-</section><section>
-<h3>Issues</h3>
-
-<P>
- The  <a href="zziplib.html">zziplib library</a> does not
- use any code piece from the <code>zip</code> programs, neither
- <em>pkzip</em> nor <em>infozip</em>, so there is no license
- issue here. The decompression is done by using the free
- <a href="http://www.gzip.org/zlib">zlib library</a> which has no special
- issues with respect to licensing. 
- The  rights to the <a href="zziplib.html">zziplib library</a> 
- are reserved to the copyright holders, there is a public
- license that puts most the sources themselves under 
- <a href="COPYING.LIB">the GNU Lesser General Public License</a>,
- so that the use of a shared library instance of the
- <a href="zziplib.html">zziplib library</a>
- has no restrictions of interest to application programmers.
- For more details and hints about static linking, check
- the <a href="copying.html">COPYING</a> information.
-</P>
-<P>
- The only issue you have with the
- <a href="zziplib.html">zziplib library</a>
- is the fact that you can only <em>read</em> the contained files.
- Writing/Compression is not implemented. Even more, a compressed
- file is not seekable at the moment although I hope that someone
- will stand up to implement that functionality someday.
-</P>
-
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-index.htm Deleted

@@ -1,55 +0,0 @@
-<section> <date> created 1.Jun.2000, last updated 09.Feb.2003 </date>
-<h2> The Library </h2> Overview
-
-
-
-
-
-<P>
- The <a href="zziplib.html">zziplib library</a> is intentionally
- lightweight, it offers the ability to easily extract data from 
- files archived in a single zip file. Applications can bundle
- files into a single zip archive and access them.
- The implementation is based only on the (free) subset of 
- compression with the <a href="http://www.gzip.org/zlib">
- zlib algorithm</a> which is actually used by the <tt>zip/unzip</tt> tools.
-</P>
-
-<center>
- The library allows reading zip archives in a number of ways,
-</center><dl>
-<dt>archive mode:</dt>
-<dd>  reading the zip directory and extracting files from it.
-      This is the traditional mode as seen with unzip-utilities.
-      Some extra unzip-utiles for transparent/magic mode are 
-      shipped as&nbsp;well.
-</dd>
-<dt>replacement mode:</dt>
-<dd>  Use ZZIP_FILE / ZZIP_DIR pointers provided by zziplib and
-      put them to work with routines originally developed to
-      work with real directories and file handles. The API calls
-      do follow traditional synopsis from posix/stdio.
-</dd>
-<dt>transparent mode:</dt>
-<dd>  Use replacement handles and allow the open()-calls to 
-      automatically detect when a file is contained in a zip 
-      archive or when it is a real file in the file system.
-      A filepath can be partly in a real filesystem and partly
-      within the zip archive when one is seen.
-</dd>
-<dt> ext magic </dt>
-<dd>  Use the same filepath to access either a zipped or real
-      file - it looks for a real file and there is none then
-      every subdirectory of the path is checked, a ".zip"
-      extension appended, and the zipped file transparently
-      opened. This can speed up dat-file development 
-      dramatically.
-</dd>
-<dt> io/xor magic </dt>
-<dd>  The access to the filesystem can be hooked up - examples
-      are given for xor obfuscation which is great for game
-      artwork and AI data. A small intro for SDLrwops usage is
-      given as well.
-</dd>
-</dl>
-</section>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-parse.htm Deleted

@@ -1,219 +0,0 @@
-<section> <date> 17. December 2002 </date>
-<h2> ZIP Format </h2>        About Zip Parsing Internals...
-
-
-
-<section>
-<h3> ZIP Trailer Block </h3>
-
-<P>
-  The general ZIP file format is written sequentially - each file
-  being added gets a local file header and its inflated data. When
-  all files are written then a central directory is written - and
-  this central directory may even span multiple disks. And each
-  disk gets a descriptor block that contains a pointer to the start
-  of the central directory. This descriptor is always written last
-  and therefore we call it the "ZIP File Trailer Block".
-</P>
-<P>
-  Okay, so we know that this ZIP Trailer is always at the end of a zip
-  file and that is has a fixed length, and a magic four-byte value at
-  its block start. That should make it easy to detect zip files but in
-  the real world it is not that easy - it is allowed to add a zip
-  archive comment text <em>after</em> the Trailer block. It's rarely
-  used these days but it turns out that a zip reader must be ready
-  to search for the Trailer block starting at the end of the file
-  and looking upwards for the Trailer magic (it's "PK\5\6" btw).
-</P>
-<P>
-  Now that's what the internal function __zip_find_disk_trailer is
-  used for. It's somewhat optimized as we try to use mmap features
-  of the underlying operating system. The returned structure is 
-  called zzip_disk_trailer in the library source code, and we only
-  need two values actually: u_rootseek and u_rootsize. The first of
-  these can be used to lseek to the place of the central directory
-  and the second value tells us the byte size of the central directory.
-</P>
-
-</section><section>
-<h3> ZIP Central Directory </h3>
-
-<P>
-  So here we are at the central directory. The disk trailer did also
-  tell us how many entries are there but it is not that easy to read
-  them. Each directory entry (zzip_root_dirent type) has again a
-  magic value up front followed by a few items but they all have some
-  dos format - consider the timestamps, and atleast size/seek values 
-  are in intel byteorder. So we might want to parse them into a format
-  that is easier to handle in internal code.
-</P>
-<P>
-  That is also needed for another reason - there are three items in that 
-  directory entry being size values of three variadic fields following
-  right after the directory. That's right, three of these. The first
-  variadic field is the filename of this directory entry. In other
-  words, the root directory entry does not contain a seek value of
-  where the filename starts off, the start of the filename is 
-  implicitly given with the end address of the directory entry.
-</P>
-<P>
-  The size value for the filename does simply say how long the
-  filename is - however, and more importantly, it allows us to 
-  compute the start of the next variadic field, called the extra
-  info field. Well, we do not need any value from that extra info
-  block (it has unix filemode bits when packed under unix) but we
-  can be quite sure that this field is not null either. And that
-  was the second variadic field.
-</P>
-<P>
-  There is a third variadic field however - it's the comment field.
-  That was pretty heavily used in the good old DOS days. We are not
-  used to it anymore since filenames are generally self-descriptive
-  today but in the DOS days a filename was 8+3 chars maximum - and
-  it was in the comment field that told users what's in there. It
-  turned out that many software archives used zip format for just
-  that purpose as their primary distribution format - for being 
-  able to attach a comment line with each entry.
-</P>
-<P>
-  Now, these three variadic fields have each an entry in the 
-  directory entry header telling of their size. And after these
-  three variadic fields the next directory entry follows right in.
-  Yes, again there is no seek value here - we have to take the sum
-  of the three field sizes and add that to the end address of the
-  directory entry - just to be able to get to the next entry.
-</P>
-
-</section><section>
-<h3> Internal Directory </h3>
-
-<P>
-  Now, the external ZIP format is too complicated. We cut it down
-  to the bare minimum we actually need. The fields in the entry
-  are parsed into a format directly usable, and from the variadic
-  fields we only keep the filename. Oh, and we ensure that the
-  filename gets a trailing null byte, so it can surely be passed
-  down into libc routines.
-</P>
-<P>
-  There is another trick by the way - we use the u_rootsize value
-  to malloc a block for the internal directory. That ensures the
-  internal root directory entries are in nearby locations, and
-  including the filenames themselves which we put in between the
-  dirent entries. That's not only similar to the external directory
-  format, but when calling readdir and looking for a matching
-  filename of an zzip_open call, this will ensure the memory is
-  fetched in a linear fashion. Modern cpu architectures are able
-  to burst through it.
-</P>
-<P>
-  One might think to use a more complicated internal directory
-  format - like hash tables or something. However, they all suffer
-  from the fact that memory access patterns will be somewhat random
-  which eats a lot of speed. It is hardly predictable under what
-  circumstances it gets us a benefit, but the problem is certainly
-  not off-world: there are zzip archives with 13k+ entries. In a real
-  filesystem people will not put 13k files into one directory, of 
-  course - but for the zip central directory all entries are listed
-  in parallel with their subdirectory paths attached. So, if the
-  original subtree had a number of directories, they'll end up in
-  parallel in the zip's central directory.
-</P>
-
-</section><section>
-<h3> File Entry </h3>
-
-<P>
-  The zip directory entry has one value that is called z_off in the
-  zziplib sources - it's the seek value to the start of the actual
-  file data, or more correctly it points to the "local file header".
-  Each file data block is preceded/followed with a little frame.
-  There is not much interesting information in these framing blocks, 
-  the values are duplicates of the ones found in the zip central
-  directory - however, we must skip the local file header (and a
-  possible duplicate of filename and extrainfo) to arrive at the
-  actual file data.
-</P>
-<P>
-  When the start of the actual file data, we can finally read data.
-  The zziplib library does only know about two choices defined by 
-  the value in the z_compr field - a value of "0" means "stored"
-  and data has been stored in uncompresed format, so that we can
-  just copy it out of the file to the application buffer.
-</P>
-<P>
-  A value of "8" means "deflated", and here we initialize the zlib
-  and every file data is decompressed before copying it to the
-  application buffer. Care must be taken here since zlib input data
-  and decompressed data may differ significantly. The zlib compression
-  will not even obey byte boundaries - a single bit may expand to
-  hundreds of bytes. That's why each ZZIP_FILE has a decompression
-  buffer attached.
-</P>
-<P>
-  All the other z_compr values are only of historical meaning,
-  the infozip unix tools will only create deflated content, and
-  the same applies to pkzip 2.x tools. If there would be any other
-  value than "0" or "8" then zziplib can not decompress it, simple
-  as that.
-</P>
-
-</section><section>
-<h3> ZZIP_DIR / ZZIP_FILE </h3>
-
-<P>
-  The ZZIP_DIR internal structures stores a posix handle to the
-  zip file, and a pointer to the parsed central directory block.
-  One can use readdir/rewinddir to walk each entry in the central
-  directory and compare with the filenames attached. And that's
-  what will be done at a zzip_open call to find the file entry.
-</P>
-<P>
-  There are a few more fields in the ZZIP_DIR structure, where 
-  most of these are related to the use of this struct as a
-  shared recource. You can use zzip_file_open to walk the 
-  preparsed central directory and return a new ZZIP_FILE handle
-  for that entry.
-</P>
-<P>
-  That ZZIP_FILE handle contains a back pointer its ZZIP_DIR
-  that it was made from - and the back pointer also serves as flag
-  that the ZZIP_FILE handle points to a file within a ZIP file as
-  opposed to wrapping a real file in the real directory tree.
-  Each ZZIP_FILE will increment a shared counter, so that the
-  next dir_close will be deferred until all ZZIP_FILE have been
-  destroyed.
-</P>
-<P>
-  Another optmization is the cache-pointer in the ZZIP_DIR. It is
-  quite common to read data entries sequentially, as that the
-  zip directory is scanned for files matching a specific pattern,
-  and when a match is seen, that file is openened. However, each
-  ZZIP_FILE needs a decompression buffer, and we keep a cache of
-  the last one freed so that it can be picked up right away for the
-  next zzip_file_open.
-</P>
-<P>
-  Note that using multiple zzip_open() directly, each will open
-  and parse a zip directory of its own. That's bloat both in
-  terms of memory consumption and execution speed. One should try

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-sdl-rwops.htm Deleted

@@ -1,90 +0,0 @@
-<section> <date> 19. Aug 2001 </date>
-<h2> SDL rwops </h2> Example to make an SDL_rwops interface.
-
-<p><small> some <b>MSVC</b> help in 
-   <a href="README.MSVC6">README.MSVC6</a> and
-   <a href="README.SDL">README.SDL</a>
-</small></p>
-
-
-
-<section>
-<h3> Source </h3>
-
-<P>
- The example sources of the <a href="zziplib.html">zziplib library</a>
- are usually put under the <a href="COPYING.ZLIB">ZLIB license</a> so 
- that you can reuse the code freely in your own projects. Here we talk
- about the example that might be most useful for 
- <a href="http://libsdl.org">SDL</a> based programs.
- Just copy the two files 
- <a href="SDL_rwops_zzip.h">SDL_rwops_zzip.h</a>
- and
- <a href="SDL_rwops_zzip.c">SDL_rwops_zzip.c</a>
- to the directory with your other project sources, and make sure
- to link it somehow to your programs. I did not make the effort to
- create a separate library out of it - it would just export one
- single function <tt>SDL_RWFromZZIP</tt> that has the same call-synopsis
- like <tt>SDL_RWFromFile</tt> (but it can not (yet) write a zip-file).
-</P>
-
-<P>
- The source file <a href="SDL_rwops_zzip.c">SDL_rwops_zzip.c</a> is
- quite short - it just stores a ZZIP_FILE handle in the userdata
- field of the <tt>SDL_rwops</tt> structure. The SDL'rwop calls will then
- fetch that pointer and call the corresponding functions from the
- <a href="zziplib.html">zziplib library</a>. Most of the glue code
- is in the <tt>SDL_RWFromZZIP</tt> function that allocates an 
- <tt>SDL_rwops</tt> structure and fills the handler-functions 
- into the callback fields.
-</P>
-
-</section><section>
-<h3> Usage </h3>
-
-<P>
- If you link this file to your project, remember that your executables
- do now have additional dependencies - not only -lzzip to link with
- the <a href="zziplib.html">zziplib library</a> - do not forget to
- link with zlib library via -lz. Of course, there is a lib-config
- script that you can use: `zzip-config --libs` will return these
- linker-infos (unless you have a native-windows system - it is 
- shell-script).
-</P>
-
-<P>
- As an example, replace that <tt>SDL_RWFromFile</tt> that accesses your
- game-graphic files - these files are stored in shared/myapp
- of course where they belong. When you've done that
- then go to X/share/myapp and 
-<br><code>&nbsp;&nbsp;&nbsp;
- `(cd graphics/ && zip -9r ../graphics.zip .)` </code><br>
- and rename the graphics/ subfolder - and still all your files
- are found: a filepath like X/shared/graphics/game/greetings.bmp 
- will open X/shared/graphics.zip and return the zipped file 
- game/greetings.bmp in the zip-archive (for reading that is).
-</P>
-
-</section><section>
-<h3> Test </h3>
-
-<P>
- The <a href="zziplib.html">zziplib</a> configure script does not
- look for <a href="http://libsdl.org">SDL</a>. If you know that
- you have <a href="http://libsdl.org">SDL</a> installed 
- then you can check this <tt>SDL_rwops</tt> example by using
- <code><nobr>`make testsdl`</nobr></code>. This will compile the
- two source files <a href="SDL_rwops_zzip.c">SDL_rwops_zzip.c</a>
- and <a href="SDL_rwops_zzcat.c">SDL_rwops_zzcat.c</a> to be linked
- together into an executable called <code>zzcatsdl</code>. The test
- will continue with a <code><nobr>`zzcatsdl test/README`</nobr></code> 
- - just like it is done for <code><nobr>`make test3`</nobr></code>.
-</P>
-<P>
- The corresponding section in the <a href="Makefile.am">Makefile.am</a>
- is also an example how to use lib-config scripts to build files. Here
- there is no build-processing that had been tweaked much by automake/autoconf.
- Just use sdl-config and zzip-config to add the needed flags.
-</P>
-</section></section>
-

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-xor.htm Deleted

@@ -1,77 +0,0 @@
-<section> <date> 15. July 2002 </date>
-<h2> ZIP Obfuscation </h2>       Using obfuscations like XOR.
-
-
-
-<section>
-<h3> The EXT/IO calls </h3>
-
-<P>
-  You really should read the section about the
-  <a href="zzip-extio.html">EXT/IO feature</a> of the zziplib since the
-  obfuscation routines are built on top of it. In order to use obfuscation,
-  you will generally need to use all the three additional argument that
-  can be passsed to _open_ext_io functions. For the XOR-example, only one
-  IO-handler is modified being the read()-call that will simply xor each
-  data byte upon read with a specific value. It two advantages - doing an
-  xor twice does yield the same data, so as a developer you do not have
-  to wonder about the encryption/decryption pair, and it is a stateless
-  obfuscation that does not need to know about the current position
-  within the zip-datafile or zippedfile-datatream.
-</P><P>
-  The examples provided just use a simple routine for xoring data that
-  is defined in all the three of the example programs: <pre>
-      static int xor_value = 0x55;
-      static zzip_ssize_t xor_read (int f, void* p, zzip_size_t l)
-      {
-          zzip_size_t r = read(f, p, l);
-	  zzip_size_t x;  char* q = p;
-          for (x=0; x &lt; r; x++) qx ^= xor_value;
-          return r;
-      }
-  </pre>
-</P><P>
-  and place this routine into the io-handlers after initializing
-  the structure: <pre>
-    zzip_init_io (&amp;xor_handlers, 0); xor_handlers.read = &amp;xor_read;
-  </pre>
-</P>
-
-</section><section>
-<h3> The examples </h3>
-
-<P>
-  There are three example programs. The first one is
-  <a href="zzxorcopy.c">zzxorcopy.c</a> which actually is not a zziplib 
-  based program. It just opens a file via stdio, loops through all data bytes 
-  it can read thereby xor'ing it, and writes it out to the output file. A 
-  call like <code><nobr>"zzxorcopy file.zip file.dat"</nobr></code> will
-  create an obfuscated dat-file from a zip-file that has been possibly
-  create with the normal infozip tools or any other archive program to
-  generate a zip-file. The output dat-file is not recognized by normal
-  zip-enabled apps - the filemagic is obfuscated too. This output
-  dat-file however is subject to the other two example programs.
-</P><P>
-  The <a href="zzxordir.c">zzxordir.c</a> program will open such an obfuscated
-  zip file and decode the central directory of that zip. Everything is
-  still there in just the way it can be shown with the normal unzip
-  programs and routines. And the <a href="zzxorcat.c">zzxorcat.c</a> program 
-  can extract data from this obfuscated zip - and print it un-obfuscated
-  to the screen. These example programs can help you jumpstart with
-  your own set of obfuscator routines, possibly more complex ones.
-</P><P>
-  By the way, just compare those with their non-xor counterparts that
-  you can find in <a href="zzdir.c">zzdir.c</a> and 
-  <a href="zzxorcat.c">zzxorcat.c</a>. Notice that the difference is
-  in the setup part until the _open_ call after which one can just
-  use the normal zzip_ routines on that obfuscated file. This is
-  great for developing since you can start of with the magic-wrappers
-  working on real-files then slowly turning to pack-files that hold
-  most of the data and finally ending with a zip-only and obfuscated
-  dat-file for your project.
-</P>
-
-<p align="right"><small><small>
-<a href="copying.html">staticlinking?</a>
-</small></small></p>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/docs/zzip-zip.htm Deleted

@@ -1,146 +0,0 @@
-<section><date> 1. June 2000 </date>
-<h2> ZIP Access </h2>    Accessing Zip Archives with ZLib Decompression
-
- 
-
-<section>
-<h3> The Library </h3>
-
-<P>
- The <a href="zziplib.html">zziplib library</a> offers users the
- ability to easily extract data from files archived in a single
- zip file. This way, programs that use many "read-only" files from
- a program specific source directory can have a single zip
- archive
-</P>
-<P>
- This library offers only a (free) subset of compression methods
- provided in a full implementation but that is well enough. The
- idea here is that <tt>zip/unzip</tt> utilities can be used
- to create archives that will later be read by using this library.
- Yet those programmes (or a library with their functionality)
- is not needed in that final operation.
-</P>
-
-</section><section>
-<h3> Using A Zip-File </h3>
-
-<P>
- Before a file in the zip-archive is accessed, the application
- must first get a handle to the central directory contained in the
- zip-file. This is achieved by calling
- <a href="zziplib.html#zzip_dir_open"> zzip_dir_open </a>
- or 
- <a href="zziplib.html#zzip_dir_fdopen"> zzip_dir_fdopen </a>.
- The directory entries in the zip-archives can be obtained
- with
- <a href="zziplib.html#zzip_dir_read"> zzip_dir_read </a>.
- After being done, the zip-dir handle should be closed with
- <a href="zziplib.html#zzip_dir_close"> zzip_dir_close </a>.
-</P>
-<p><pre> ZZIP_DIR* dir = zzip_dir_open("test.zip",0);
- if (dir) {
-   ZZIP_DIRENT dirent;
-   if (zzip_dir_read(dir,&amp;dirent) {
-     /* show info for first file */
-     print("%s %i/%i", dirent.d_name, dirent.d_csize, dirent.st_size);
-   }
-   zzip_dir_close(dir);
- }
-</pre></p>
-<P>
- From the zip-dir handle a compressed file can be opened
- for reading. This is achieved by using 
- <a href="zziplib.html#zzip_file_open"> zzip_file_open </a>
- and providing it with the dir-handle and a name of the file.
- The function
- <a href="zziplib.html#zzip_file_read"> zzip_file_read </a>
- is used to get pieces of uncompressed data from the file, and
- the file-handle should be closed with
- <a href="zziplib.html#zzip_file_close"> zzip_file_close </a>
-</P>
-<p><pre> ZZIP_FILE* fp = zzip_file_open(dir,"README",0);
- if (fp) {
-   char buf10;
-   zzip_ssize_t len = zzip_file_read(fp, buf, 10);
-   if (len) {
-     /* show head of README */
-     write(1, buf, len); 
-   }
-   zzip_file_close(fp);
- } 
-</pre></p>
-
-</section><section>
-<h3> Magic Zipped Files </h3>
-
-<P>
- There is actually no need to directly use the zip-centric functions
- as described above. Instead there are magic replacements for the
- posix calls <code>open/read/close</code> and 
- <code>opendir/readdir/closedir</code>. The prototypes of these
- functions had been the guideline for the design of their magic
- counterparts of the
- <a href="zziplib.html">zziplib library</a>.
-</P>
-<P>
- The magic functions are described in a separated document on
- <a href="zzip-file.html"> Using Zipped Files </a>. In general,
- the functions have a prefix <tt>zzip_</tt> and their argument
- types have a prefix <tt>ZZIP_</tt> where appropriate. Calls
- to the magic functions and the direct functions above can
- be mixed as long as the magic functions have not been opening
- a real file.
-</P>
-<P>
- To detect a real file (or directory), the info functions
- <a href="zziplib.html#zzip_file_real"> zzip_file_real </a>
- and
- <a href="zziplib.html#zzip_dir_real"> zzip_dir_real </a>
- can be used.
- If these return a true value, the standard posix functions
- are more appropriate. The posix handles can be obtained with
- a call to
- <a href="zziplib.html#zzip_realdir"> zzip_realdir </a> and
- <a href="zziplib.html#zzip_realfd"> zzip_realfd </a> respectively.
-</P>
-
-</section><section>
-<h3> Errors &amp; Infos </h3>
-
-<P>
- There are a set of error and info functions available. To handle
- error conditions specific to the
- <a href="zziplib.html">zziplib library</a>
- there are these functions:
- <a href="zziplib.html#zzip_error"> zzip_error </a>,
- <a href="zziplib.html#zzip_seterror"> zzip_seterror </a>
- and their string representations with
- <a href="zziplib.html#zzip_strerror"> zzip_strerror </a>,
- <a href="zziplib.html#zzip_strerror_of"> zzip_strerror_of </a>.
- The magic functions will map any of these specific library
- error conditions to the more generic system <code>errno</code>
- codes with
- <a href="zziplib.html#zzip_errno"> zzip_errno </a>.
-</P>
-<P>
- More information on stream can be obtained with
- <a href="zziplib.html#zzip_dir_stat"> zzip_dir_stat </a> and
- <a href="zziplib.html#zzip_dirhandle"> zzip_dirhandle. </a>
- The latter is used to obtain the dir-handle that every zipped file 
- handle has even if not explicitly opened.
-</P>
-<P>
- The usage of many functions are shown in the example programs
- that come along with the
- <a href="zziplib.html">zziplib library</a>. See the files
- <a href="zzcat.c"> zzcat.c </a> and
- <a href="zzdir.c"> zzdir.c </a>. The 
- <a href="zziptest.c"> zziptest.c </a> program needs the
- private header file 
- <a href="zzip.h"> zzip.h </a> whereas the library installer
- will only copy the public include file 
- <a href="zziplib.h"> zziplib.h </a> to your system's
- <tt>include</tt> directory.
-</P>
-</section></section>

_service:tar_scm:v0.13.72.tar.gz/testbuilds/centos8-am-build.dockerfile Deleted

_service:tar_scm:v0.13.72.tar.gz/testbuilds/centos8-am-sdl2.dockerfile Deleted

@@ -1,35 +0,0 @@
-FROM centos:8.1.1911
-ARG no_check=false
-ARG no_install=false
-
-ARG _libdir=/usr/local/lib64
-ARG _docdir=/usr/share/doc
-
-RUN yum install -y yum-utils
-RUN yum-config-manager --set-enabled PowerTools
-RUN ls -l /etc/yum.repos.d
-RUN cat /etc/yum.repos.d/CentOS-PowerTools.repo
-RUN yum search sdl
-RUN yum install -y gcc zlib-devel python3 cmake make unzip zip gzip tar diffutils  SDL2-devel
-
-RUN mkdir src
-COPY Makefile.am Makefile.in old.configure.ac old.configure config.h.in zziplib.spec src/
-RUN test ! -f src/old.configure || mv src/old.configure src/configure
-RUN test ! -f src/old.configure.ac || mv src/old.configure.ac src/configure.ac
-COPY uses src/uses
-
-COPY CMakeLists.txt README COPYING.LIB ChangeLog src/
-COPY CMakeScripts src/CMakeScripts
-COPY bins src/bins
-COPY docs src/docs
-COPY test src/test
-COPY SDL src/SDL
-COPY zzipwrap src/zzipwrap
-COPY zzip src/zzip
-
-RUN mkdir src/build
-RUN cd src/build && sh ../configure --libdir=$_libdir --with-docdir=$_docdir --disable-static --enable-sdl
-RUN cd src/build && make
-RUN $no_check || (cd src/build && make check)
-RUN $no_install || (cd src/build && make install)
-

_service:tar_scm:v0.13.72.tar.gz/testbuilds/centos8-cm-build.dockerfile Deleted

_service:tar_scm:v0.13.72.tar.gz/testbuilds/centos8-cm-destdir-sdl2.dockerfile Deleted

_service:tar_scm:v0.13.72.tar.gz/testbuilds/centos8-cm-sdl2.dockerfile Deleted

_service:tar_scm:v0.13.72.tar.gz/testbuilds/ubuntu16-cm-sdl2.dockerfile Deleted

_service:tar_scm:v0.13.72.tar.gz/testbuilds/ubuntu20-azure.dockerfile Deleted

_service:tar_scm:v0.13.72.tar.gz/zzip/autoconf.h Deleted

@@ -1,45 +0,0 @@
-#ifndef _ZZIP_AUTOCONF_H_
-#define _ZZIP_AUTOCONF_H_ 1
-
-/*
- * This file is trying to override configure time checks of zzip with
- * definitions at compile time. This is not used by zzip sources themselves
- * but it may be really helpful with thirdparty software that happens to
- * include zzip headers from a central place but running on a different host.
- */
-
-#include "conf.h" /* <zzip/conf.h> : <zzip/_config.h> */
-
-#if   defined HAVE_ENDIAN_H          || defined ZZIP_HAVE_ENDIAN_H
-#include <endian.h>     /* glibc */
-#elif defined HAVE_SYS_PARAM_H       || defined ZZIP_HAVE_SYS_PARAM_H
-#include <sys/param.h>  /* solaris */
-#endif
-
-#if             defined __BYTE_ORDER
-#define ZZIP_BYTE_ORDER __BYTE_ORDER
-#elif           defined BYTE_ORDER
-#define ZZIP_BYTE_ORDER BYTE_ORDER
-#elif           defined _LITTLE_ENDIAN
-#define ZZIP_BYTE_ORDER 1234
-#elif           defined _BIG_ENDIAN
-#define ZZIP_BYTE_ORDER 4321
-#elif           defined __i386__
-#define ZZIP_BYTE_ORDER 1234
-#elif           defined WORDS_BIGENDIAN || defined ZZIP_WORDS_BIGENDIAN
-#define ZZIP_BYTE_ORDER 4321
-#else
-#define ZZIP_BYTE_ORDER 1234
-#endif
-
-/* override ZZIP_WORDS_BIGENDIAN : macros ZZIP_GET16 / ZZIP_GET32 */ 
-#ifdef ZZIP_BYTE_ORDER+0 == 1234
-#undef ZZIP_WORDS_BIGENDIAN
-#endif
-#ifdef ZZIP_BYTE_ORDER+0 == 4321
-#ifndef ZZIP_WORDS_BIGENDIAN
-#define ZZIP_WORDS_BIGENDIAN 1
-#endif
-#endif
-
-#endif

_service:tar_scm:v0.13.74.tar.gz/.clang-format Added

@@ -0,0 +1,40 @@
+IndentWidth: 4
+ColumnLimit: 100
+AlignConsecutiveDeclarations: true
+AlignConsecutiveAssignments: true
+AlignConsecutiveMacros: true
+AlignAfterOpenBracket: true
+AllowShortBlocksOnASingleLine: Always
+BreakBeforeBraces: Stroustrup
+# BraceBreakingStyle: Stroustrup
+# PenaltyReturnTypeOnItsOwnLine: 0
+AlwaysBreakAfterDefinitionReturnType: TopLevel
+AlwaysBreakAfterReturnType: TopLevel
+SpaceAfterLogicalNot: true
+SpaceAfterCStyleCast: true
+# SpaceAroundPointerQualifiers: Both
+SpaceBeforeAssignmentOperators: true
+UseTab: Never
+PointerAlignment: Left
+IncludeBlocks: Preserve
+IncludeCategories:
+  - Regex: '^(<|")(zzip/conf.h)'
+    Priority: 2
+  - Regex: '^(<|")(zzip/types.h)'
+    Priority: 3
+  - Regex: '^(<|")(zzip/zzip.h)'
+    Priority: 4
+  - Regex: '^(<|")(zzip/lib.h)'
+    Priority: 5
+  - Regex: '^(<|")(zzip/write.h)'
+    Priority: 6
+  - Regex: '^(<|")(zzip/file.h)'
+    Priority: 8
+  - Regex: '^(<|")(zlib.h)'
+    Priority: 10
+  - Regex: '^(<|")(zzip/format.h)'
+    Priority: 11
+  - Regex: '^(<|")(zzip/mmapped.h)'
+    Priority: 12
+  - Regex: '^(<|")(zzip/a-z^.*.h)'
+    Priority: 22

_service:tar_scm:v0.13.74.tar.gz/.github Added

_service:tar_scm:v0.13.74.tar.gz/.github/workflows Added

_service:tar_scm:v0.13.74.tar.gz/.github/workflows/clangformat.yml Added

_service:tar_scm:v0.13.74.tar.gz/.github/workflows/makecheck.yml Added

@@ -0,0 +1,52 @@
+name: make check
+
+on:
+  push:
+    branches:  develop 
+  pull_request:
+    branches:  develop, master 
+
+jobs:
+  tests:
+    name: 'make check tests'
+    runs-on: 'ubuntu-latest'
+    steps:
+    - name: checkout software
+      uses: actions/checkout@v2
+      with:
+        path: software
+    - name: 'refresh install'
+      run: |
+        sudo apt-get update --fix-missing
+    - name: 'install libsdl2-dev'
+      run: |
+        sudo apt-get install --fix-broken --ignore-missing libsdl2-dev
+    - name: 'install python3 pip'
+      run: |
+        sudo apt-get install --fix-broken --ignore-missing python3-pip
+    - name: 'install unittest-xml-reporting'
+      run: |
+        pip3 install unittest-xml-reporting
+    - name: 'build dir'
+      run: |
+        rm -rf build
+        mkdir build
+    - name: 'configure'
+      run: |
+        cd build && cmake -DTESTFLAGS=--xmlresults=TEST-zziplibs.xml -DZZIP_TESTCVE=OFF ../software
+    - name: 'make all'
+      run: |
+        cd build && make all VERBOSE=1
+    - name: 'make check'
+      run: |
+        cd build && make check VERBOSE=1 || true
+    - name: 'find xml'
+      run: |
+        find . -name '*.xml'
+    - name: 'publish testresults'
+      uses: EnricoMi/publish-unit-test-result-action@v1
+      with:
+        commit: ${{ github.event.workflow_run.head_sha }}
+        files: '**/TEST-*.xml'
+        check_name: 'Unit tests without docker-based tests'
+        report_individual_runs: "true"

_service:tar_scm:v0.13.74.tar.gz/.github/workflows/stylecheck.yml Added

_service:tar_scm:v0.13.74.tar.gz/.github/workflows/typecheck.yml Added

_service:tar_scm:v0.13.72.tar.gz/.gitignore -> _service:tar_scm:v0.13.74.tar.gz/.gitignore Changed

_service:tar_scm:v0.13.72.tar.gz/CMakeLists.txt -> _service:tar_scm:v0.13.74.tar.gz/CMakeLists.txt Changed

_service:tar_scm:v0.13.74.tar.gz/CMakeScripts/CheckVerboseSymlink.cmake Added

_service:tar_scm:v0.13.74.tar.gz/CPPLINT.cfg Added

_service:tar_scm:v0.13.72.tar.gz/ChangeLog -> _service:tar_scm:v0.13.74.tar.gz/ChangeLog Changed

@@ -1,3 +1,25 @@
+2024-02-29  gdraheim@github
+    * disabled local file header offset64
+    * allowed to 'make fortify' for extended debugging
+    * fixed all memleak bugs from address sanitizer
+    * fixed ZIP64 bugs - but the support is still incomplete
+    * fixed remaining failures as they were recorded in testsuite
+    * release 0.13.74
+
+2024-02-28  gdraheim@github
+    * fixed last cmake bug - parallel builds can lead to race condition
+    * abolished centos8 testbuilds and prepared ubuntu24
+    * integrated some github patches
+    * prepare autoformat with clang-format (not yet enforced)
+    * release 0.13.73
+
+2023-03-12  gdraheim@github
+    * Switched docs from .htm to .md format. The mksite to .html is retained.
+    * Some cmake patches were included. Specifically MacOS seems to be special.
+    * Automated builds changed from azure-pipelines to github/workflows
+    * Added typehints and pep8 check for the python parts of the tools and tests
+    * Can still update automake for now. Continues the testbuilds.py comparison.
+
 2021-01-04  gdraheim@github
     * The testbuilds were fixed to make cmake install and automake install the same
     * The cmake install did need patches for man3 installation on Unix

_service:tar_scm:v0.13.72.tar.gz/GNUmakefile -> _service:tar_scm:v0.13.74.tar.gz/GNUmakefile Changed

@@ -1,4 +1,4 @@
-#! /usr/bin/gmake -f
+#! /usr/bin/gmake -fp
 
 # the 'all' target is included from the 'configure'd Makefile
 
@@ -7,46 +7,77 @@
 CMAKE=cmake
 NINJA=ninja
 PREFIX=$$HOME/local
+PYTHON3=python3
 
 .PHONY: build docs bins test tests testbuilds
 
 default: build
+
+# defaults to 'cmake' (using gmake) but it can be 'ninja' as well
 build:
 	@ test -f Makefile || test -d $(BUILD) || (set -x ; mkdir $(BUILD) ; cd $(BUILD) && $(CMAKE) $(BUILDSOURCES) -DCMAKE_INSTALL_PREFIX:PATH=$(PREFIX) $(OPTIONS))
 	@ test -f Makefile || test ! -d $(BUILD) || test ! -f $(BUILD)/Makefile || (set -x ; cd $(BUILD) && $(MAKE) all)
 	@ test -f Makefile || test ! -d $(BUILD) || test ! -f $(BUILD)/rules.ninja || (set -x ; cd $(BUILD) && $(NINJA) all)
+	@ test -f Makefile || test ! -d $(BUILD) || test ! -f $(BUILD)/build.ninja || (set -x ; cd $(BUILD) && $(NINJA) all)
 	@ test -f Makefile || test ! -d $(BUILD) || test ! -f $(BUILD)/Makefile || echo 'DONE (cd $(BUILD) && $(MAKE) all) - please run (cd $(BUILD) && $(MAKE) check VERBOSE=1) now'
 	@ test -f Makefile || test ! -d $(BUILD) || test ! -f $(BUILD)/rules.ninja || echo 'DONE (cd $(BUILD) && $(NINJA) all) - please run (cd $(BUILD) && $(NINJA) check) now'
+	@ test -f Makefile || test ! -d $(BUILD) || test ! -f $(BUILD)/build.ninja || echo 'DONE (cd $(BUILD) && $(NINJA) all) - please run (cd $(BUILD) && $(NINJA) check) now'
 
 new: ; rm -rf $(BUILD); $(MAKE) build
+static: ; rm -rf $(BUILD) && $(MAKE) build OPTIONS=-DBUILD_SHARED_LIBS=OFF
+fortify: ; rm -rf $(BUILD) && $(MAKE) build "OPTIONS=-DFORTIFY=ON -DCMAKE_BUILD_TYPE=Debug"
 
 ninja: ; rm -rf $(BUILD) && $(MAKE) build OPTIONS=-GNinja
 nmake: ; rm -rf $(BUILD) && $(MAKE) build OPTIONS=-GNmake
 cmake: ; rm -rf $(BUILD) && $(MAKE) build "OPTIONS=-DZZIP_MANPAGES=OFF -DZZIP_INSTALL_BINS=OFF -DZZIP_TESTCVE=OFF"
 
-check checks:
+# targets defined in cmakefile.txt
+check checks site install-site manpages htmpages:
 	@ test ! -f $(BUILD)/Makefile    || (set -x; cd $(BUILD) && $(MAKE) $@ VERBOSE=1)
 	@ test ! -f $(BUILD)/rules.ninja || (set -x; cd $(BUILD) && $(NINJA) $@)
+	@ test ! -f $(BUILD)/build.ninja || (set -x; cd $(BUILD) && $(NINJA) $@)
 install docs:
-	@ test ! -f $(BUILD)/Make        || (set -x; cd $(BUILD) && $(MAKE) $@)
+	@ test ! -f $(BUILD)/Makefile    || (set -x; cd $(BUILD) && $(MAKE) $@)
 	@ test ! -f $(BUILD)/rules.ninja || (set -x; cd $(BUILD) && $(NINJA) $@)
+	@ test ! -f $(BUILD)/build.ninja || (set -x; cd $(BUILD) && $(NINJA) $@)
 
 un uninstalls:
 	@ case "$(PREFIX)" in */local) echo rm -rf "'$(PREFIX)'" ; rm -rf "$(PREFIX)" ;; *) echo skipped rm -rf "'$(PREFIX)'" ;; esac
 
+am:
+	- rm -v configure configure.ac
+	rm -rf $(BUILD); mkdir -v $(BUILD)
+	ln -sv old.configure configure
+	cd $(BUILD) && ../configure
+	cd $(BUILD) && $(MAKE) all
+	test -L configure && rm -v configure
+
+# testing
+
+tests:  ; $(PYTHON3) testbuilds.py -vv
+testss:  ; $(PYTHON3) testbuilds.py -vv --failfast --local
+testbuilds: ; $(PYTHON3) testbuilds.py -vv --no-cache
+k_%: ; $(PYTHON3) testbuilds.py $@ -vv --no-cache --keep
+b_%: ; $(PYTHON3) testbuilds.py $@ -vv --no-cache --failfast --local
+t_%: ;    cd $(BUILD)/test && $(PYTHON3) ../../test/zziptests.py $@ -vv
+test_%: ; cd $(BUILD)/test && $(PYTHON3) ../../test/zziptests.py $@ -vv
+est_%: ; cd $(BUILD)/test && $(PYTHON3) ../../test/zziptests.py t$@ -vv --keep
+
+b: ; grep "def test_" testbuilds.py | sed -e "s/ *def test_/make b_/" -e "s/(self).*//"
+t: ; grep "def test_" test/zziptests.py | sed -e "s/ *def test_/make t_/" -e "s/(self).*//"
+
 rms: ; docker images --format '{{.Repository}} {{.ID}}' | grep localhost:5000/systemctl/ | cut -d ' ' -f 2 | xargs --no-run-if-empty docker rmi -f
 rmi: ; docker images --format '{{.Repository}} {{.ID}}' | grep localhost:5000/zziplib/ | cut -d ' ' -f 2 | xargs --no-run-if-empty docker rmi -f
 rmf: ; docker ps -a --format '{{.Image}} {{.ID}}' | grep localhost:5000/zziplib/ | cut -d ' ' -f 2 | xargs --no-run-if-empty docker rm -f
 
-st_%: ; python3 testbuilds.py te$@ -vv --no-cache
-tests:  ; python3 testbuilds.py -vv
-testbuilds: ; python3 testbuilds.py -vv --no-cache
-test_%: ; cd build/test && python3 ../../test/zziptests.py $@ -vv
-
 downloads:
-	- rm -rf test/tmp.download build/test/tmp.download
-	cd build/test && python3 ../../test/zziptests.py --downloadonly -vv
+	- rm -rf test/tmp.download $(BUILD)/test/tmp.download
+	cd $(BUILD)/test && $(PYTHON3) ../../test/zziptests.py --downloadonly -vv
+
+mans: testmanpages
+testmanpages: ; cd docs && $(MAKE) $@ BUILD=$(realpath $(BUILD))
 
+# release .............................
 version:
 	oldv=`sed -e '/zziplib.VERSION/!d' -e 's:.*zziplib.VERSION."::' -e 's:".*::' CMakeLists.txt` \
 	; oldr=`echo $$oldv | sed -e 's:.*.::'` ; newr=`expr $$oldr + 1` \
@@ -57,5 +88,74 @@
 	; sed -i -e "s:$$oldv:$$newv:" CMakeLists.txt \
 	; git diff -U0
 
+# format ..............................
+CLANG_FORMAT=clang-format
+format ff: ; $(CLANG_FORMAT) -i zzip/*.h zzip/*.c
+
+FORMATDIR=../zziplib-format
+formatdir:
+	rm -rf $(FORMATDIR); mkdir $(FORMATDIR)
+	for i in zzip/*.h; do $(CLANG_FORMAT) "$$i" > "$(FORMATDIR)/$$(basename $$i)"; done
+	for i in zzip/*.c; do $(CLANG_FORMAT) "$$i" > "$(FORMATDIR)/$$(basename $$i)"; done
+	diff -qs zzip $(FORMATDIR) -x "*.am" -x "*.in" -x "*.wpj" -x "*.cmake" -x "*.sed" -x "*.txt"
+diff: ; diff -U0 zzip $(FORMATDIR) -x "*.am" -x "*.in" -x "*.wpj" -x "*.cmake" -x "*.sed" -x "*.txt"
+dif:  ; diff -u zzip $(FORMATDIR) -x "*.am" -x "*.in" -x "*.wpj" -x "*.cmake" -x "*.sed" -x "*.txt"
+
+# style ...............................
+mypy:
+	zypper install -y mypy
+	zypper install -y python3-click python3-pathspec
+
+MYPY = mypy
+MYPY_STRICT = --strict --show-error-codes --show-error-context --no-warn-unused-ignores --python-version 3.6 --implicit-reexport
+AUTOPEP8=autopep8
+AUTOPEP8_INPLACE= --in-place
+AUTOPEP8_ASDIFF= --diff
+
+%.type:
+	$(MYPY) $(MYPY_STRICT) $(MYPY_OPTIONS) $(@:.type=)
+
+%.pep1:
+	$(AUTOPEP8) $(AUTOPEP8_OPTIONS) $(@:.pep1=) $(AUTOPEP8_ASDIFF)
+
+%.pep8:
+	$(AUTOPEP8) $(AUTOPEP8_OPTIONS) $(@:.pep8=) $(AUTOPEP8_INPLACE)
+	git --no-pager diff $(@:.pep8=)
+
+PY1 = testbuilds.py
+PY2 = test/zziptests.py
+PY3 = docs/tools/md2dbk.py
+PY4 = docs/toolstests.py
+type:  ; $(MAKE) $(PY1).type $(PY2).type $(PY3).type $(PY4).type
+style: ; $(MAKE) $(PY1).pep8 $(PY2).pep8 $(PY3).pep8 $(PY4).pep8
+pep1:  ; $(MAKE) $(PY1).pep1 $(PY2).pep1 $(PY3).pep1 $(PY4).pep1
+
+py4: ; $(MAKE) $(PY4).type $(PY4).pep8
+py3: ; $(MAKE) $(PY3).type $(PY3).pep8
+py2: ; $(MAKE) $(PY2).type $(PY2).pep8
+py1: ; $(MAKE) $(PY1).type $(PY1).pep8
+
+# extras ..............................
+auto:
+	- rm -v configure configure.ac
+	ln -s old.configure.ac configure.ac
+	autoreconf -f
+	cp -p configure old.configure
+	rm -v configure configure.ac
+
+
 -include GNUmakefile.win10
 -include docker_mirror.mk
+-include docs.mk
+
+clean:
+	- test -d $(BUILD) && rm -rf $(BUILD)
+	- test -d tmp && rm -rf tmp
+	- find . -name CMakeCache.txt | xargs --no-run-if-empty rm -v
+	- find . -name cmake_install.cmake | xargs --no-run-if-empty rm -v
+	- find . -name CMakeFiles | xargs --no-run-if-empty rm -r
+	- find . -name Makefile | xargs --no-run-if-empty rm -r
+	- rm -r docs/zzipdoc/__pycache__
+	- rm -r docs/zzipdoc/*.pyc
+	- rm -r autom4te.cache
+	- rm *~

_service:tar_scm:v0.13.72.tar.gz/README -> _service:tar_scm:v0.13.74.tar.gz/README Changed

@@ -32,13 +32,13 @@
   the latest release announcements, watch the GitHub project.
 
 INSTALLATION
-  The zziplib sources are built with gnu autotools and they should
-  be easy to install on unixish systems via the usual sequence of
-  `configure && make && make check && make install`. Many distributors
-  ship prebuilt packages e.g. in rpm format. Additionally there are
-  MSVC project files shipped along for usage with the Microsoft
-  VisualC series of compilers. There should be no problem either
-  when crosscompiling the zziplib for a third host platform.
+  The zziplib sources are built with cmake. This allows to build it
+  easily with make / ninja on unixish systems via the usual sequence of
+  `cmake3 && make && make check && make install`. Many distributors
+  ship prebuilt packages e.g. in rpm format. Additionally cmake allows
+  to generate MSVC project files - the old ones will be dropped soon.
+  There should be no problem either when crosscompiling the zziplib 
+  for a third host platform.
 
 MAINTENANCE
   The zziplib library is intentionally a lightweight interface to

_service:tar_scm:v0.13.72.tar.gz/README.MD -> _service:tar_scm:v0.13.74.tar.gz/README.MD Changed

@@ -1,3 +1,10 @@
+<p style="float:right"><img align="right" src="docs/dir-zzip-64.png" /></p>
+
+!make check(https://github.com/gdraheim/zziplib/actions/workflows/makecheck.yml/badge.svg?event=push&branch=develop)(https://github.com/gdraheim/zziplib/actions/workflows/makecheck.yml)
+!py style(https://github.com/gdraheim/zziplib/actions/workflows/stylecheck.yml/badge.svg?event=push&branch=develop)(https://github.com/gdraheim/zziplib/actions/workflows/stylecheck.yml)
+!py types(https://github.com/gdraheim/zziplib/actions/workflows/typecheck.yml/badge.svg?event=push&branch=develop)(https://github.com/gdraheim/zziplib/actions/workflows/typecheck.yml)
+!py types(https://github.com/gdraheim/zziplib/actions/workflows/clangformat.yml/badge.svg?event=push&branch=develop)(https://github.com/gdraheim/zziplib/actions/workflows/clangformat.yml)
+
 ... **please switch to 'cmake' based builds** ... 
 
 The zziplib provides read access to zipped files in a zip-archive,
@@ -13,37 +20,34 @@
 
 > also check out the original README(README) file
 
-... test status (master)(https://github.com/gdraheim/zziplib/tree/master): !Build Status(https://dev.azure.com/gdraheim/gdraheim/_apis/build/status/gdraheim.zziplib%20(1)?branchName=master)(https://dev.azure.com/gdraheim/gdraheim/_build/latest?definitionId=4&branchName=master) ... (develop/tests/zziptests.py(https://github.com/gdraheim/zziplib/blob/develop/test/zziptests.py))
-
 **DOCUMENTATION**
 
-* for more details, see http://zziplib.sourceforge.net/
-* copying(docs/copying.htm)
-  developer(docs/developer.htm)
-  functions(docs/functions.htm)
-  php(docs/zip-php.htm)
-  referitals(docs/referentials.htm)
-  future(docs/future.htm)
-  notes(docs/notes.htm)
-  64on32(docs/64on32.htm)
-  download(docs/download.htm)
-  history(docs/history.htm)
-* zzip:(docs/zzip-index.htm) 
-  basics(docs/zzip-basics.htm)
-  api(docs/zzip-api.htm)
-  crypt(docs/zzip-crypt.htm)
-  cryptoid(docs/zzip-cryptoid.htm)
-  extio(docs/zzip-extio.htm)
-  extras(docs/zzip-extras.htm)
-  file(docs/zzip-file.htm)
-  parse(docs/zzip-parse.htm)
-  sdl-rwops(docs/zzip-rwops.htm)
-  xor(docs/zzip-xor.htm)
-  zip(docs/zzip-zip.htm)
-  sfx-make(docs/sfx-make.htm)
+* Library Overview(docs/README.MD) .... and for more details, see http://zziplib.sourceforge.net/
+* copying(docs/copying.htm.md)
+  developer(docs/developer.htm.md)
+  functions(docs/functions.htm.md)
+  php(docs/zip-php.htm.md)
+  referentials(docs/referentials.htm.md)
+  future(docs/future.htm.md)
+  notes(docs/notes.htm.md)
+  64on32(docs/64on32.htm.md)
+  download(docs/download.htm.md)
+  history(docs/history.htm.md)
+* zzip:(docs/zzip-index.htm.md) 
+  basics(docs/zzip-basics.htm.md)
+  api(docs/zzip-api.htm.md)
+  crypt(docs/zzip-crypt.htm.md)
+  cryptoid(docs/zzip-cryptoid.htm.md)
+  extio(docs/zzip-extio.htm.md)
+  extras(docs/zzip-extras.htm.md)
+  file(docs/zzip-file.htm.md)
+  parse(docs/zzip-parse.htm.md)
+  sdl-rwops(docs/zzip-rwops.htm.md)
+  xor(docs/zzip-xor.htm.md)
+  zip(docs/zzip-zip.htm.md)
+  sfx-make(docs/sfx-make.htm.md)
 * zziplib(docs/zziplib.html)
-  mmapped(docs/mmapped.htm)
-  fseeko(docs/fseeko.htm)
-  download(docs/download.htm)
-  faq(docs/faq.htm)
-  (outdated in the source tree)
+  mmapped(docs/mmapped.htm.md)
+  fseeko(docs/fseeko.htm.md)
+  download(docs/download.htm.md)
+  faq(docs/faq.htm.md)

_service:tar_scm:v0.13.72.tar.gz/SDL/CMakeLists.txt -> _service:tar_scm:v0.13.74.tar.gz/SDL/CMakeLists.txt Changed

_service:tar_scm:v0.13.72.tar.gz/SDL/SDL_rwops_zzip.c -> _service:tar_scm:v0.13.74.tar.gz/SDL/SDL_rwops_zzip.c Changed

_service:tar_scm:v0.13.72.tar.gz/bins/CMakeLists.txt -> _service:tar_scm:v0.13.74.tar.gz/bins/CMakeLists.txt Changed

_service:tar_scm:v0.13.72.tar.gz/bins/unzip-mem.c -> _service:tar_scm:v0.13.74.tar.gz/bins/unzip-mem.c Changed

@@ -92,7 +92,7 @@
 				ZZIP_MEM_ENTRY* entry)
 {
     FILE* file = fopen (entry->zz_name, "wb");
-    if (file) { zzip_mem_entry_pipe (disk, entry, file); fclose (file); }
+    if (file) { zzip_mem_entry_pipe (disk, entry, file); fclose (file); return; }
     perror (entry->zz_name);
     if (status < EXIT_WARNINGS) status = EXIT_WARNINGS;
 }
@@ -167,7 +167,6 @@
 zzip_off_t sum_usize = 0;
 zzip_off_t sum_csize = 0;
 zzip_off_t sum_files = 0;
-#define L (long)
 
 static void zzip_mem_entry_direntry_start (void)
 {
@@ -194,15 +193,23 @@
 	sum_usize /= 1024; sum_csize /= 1024; }
     if (option_verbose) goto verbose;
     printf(" --------                   ----\n");
-    printf(" %8li%c           %8li %s\n", L sum_usize, exp, L sum_files,
+    printf(" %8li%c           %8li %s\n", /* .. */
+           (long) sum_usize, exp, /* .. */
+           (long) sum_files, /* .. */
 	   sum_files == 1 ? "file" : "files");
     return;
  verbose:
+    ___ long percentage;
+
+    percentage = sum_usize ? ((long) (100 - (sum_csize*100/sum_usize))) : 0;
     printf("--------  ------  ------- -----                           ----\n");
     printf("%8li%c       %8li%c %3li%%                     %8li %s\n",
-	   L sum_usize, exp, L sum_csize, exp, 
-	   L (100 - (sum_csize*100/sum_usize)), L sum_files, 
-	   sum_files == 1 ? "file" : "files");
+	   (long) sum_usize, exp, /* .. */
+	   (long) sum_csize, exp, /* .. */
+	   (long) percentage, /* .. */
+	   (long) sum_files, /* .. */
+	   "files" /* sum_files == 1 ? "file" : "files" */);
+    ____;
 }
 
 static void zzip_mem_entry_direntry(ZZIP_MEM_ENTRY* entry)
@@ -233,14 +240,19 @@
     if (option_verbose) {
 	long percentage;
 
-	percentage = usize ? (L (100 - (csize*100/usize))) : 0;	/* 0% if file size is 0 */
+	percentage = usize ? ((long) (100 - (csize*100/usize))) : 0;	/* 0% if file size is 0 */
 	printf("%8li%c %s %8li%c%3li%%  %s  %8lx  %s %s\n", 
-	       L usize, exp, comprlevelcompr, L csize, exp, 
-	       percentage,
-	       _zzip_ctime(&mtime), crc32, name, comment);
+	       (long) usize, exp, /* .. */
+	       comprlevelcompr, /* .. */
+	       (long) csize, exp, /* .. */
+	       percentage, /* .. */
+	       _zzip_ctime(&mtime), crc32, /* .. */
+	       name, comment);
     } else {
 	printf(" %8li%c %s   %s %s\n", 
-	       L usize, exp, _zzip_ctime(&mtime), name, comment);
+	       (long) usize, exp, /* .. */
+	        _zzip_ctime(&mtime), /* .. */
+	        name, comment);
     }    
 }
 
@@ -404,6 +416,7 @@
 	}
     }
 
+    zzip_mem_disk_close(disk);
     return status;
 }

_service:tar_scm:v0.13.72.tar.gz/bins/unzzip.c -> _service:tar_scm:v0.13.74.tar.gz/bins/unzzip.c Changed

_service:tar_scm:v0.13.72.tar.gz/bins/unzzipcat-mix.c -> _service:tar_scm:v0.13.74.tar.gz/bins/unzzipcat-mix.c Changed

@@ -28,9 +28,22 @@
 extern int exitcode(int);
 extern FILE* create_fopen(char*, char*, int);
 
+static char* strdup_mixname(char* zip_name, char* name)
+{
+     int zip_name_len = strlen(zip_name);
+     int name_len = strlen(name);
+     char* mix_name = malloc(zip_name_len + 2 + name_len);
+     if (zip_name_len > 4 && !strcmp(zip_name+zip_name_len-4, ".zip"))
+             zip_name_len -= 4;
+     memcpy(mix_name, zip_name, zip_name_len);
+     mix_namezip_name_len = '/';
+     strcpy(mix_name + zip_name_len + 1, name);
+     return mix_name;
+}
+
 static void unzzip_cat_file(ZZIP_DIR* disk, char* name, FILE* out)
 {
-    ZZIP_FILE* file = zzip_fopen(name, "rb");
+    ZZIP_FILE* file = zzip_fopen(name, "rb!");
     if (file) 
     {
 	char buffer1024; int len;
@@ -55,7 +68,8 @@
         return EXIT_OK; /* better provide an archive argument */
     }
     
-    disk = zzip_opendir (argv1);
+    char* zip_name = argv1;
+    disk = zzip_opendir (zip_name);
     if (! disk) {
         DBG3("opendir failed %i %s", errno, strerror(errno));
 	perror(argv1);
@@ -69,15 +83,20 @@
 	{
 	    char* name = entry->d_name;
 	    FILE* out = stdout;
-	    if (extract) out = create_fopen(name, "wb", 1);
+	    if (extract) {
+	        out = create_fopen(name, "wb", 1);
+	        DBG3("extract to '%s' -> %p", name, out);
+	    }
 	    if (! out) {
 	        if (errno != EISDIR) done = EXIT_ERRORS;
 	        continue;
 	    }
-	    unzzip_cat_file (disk, name, out);
+            char* mix_name = strdup_mixname(zip_name, name);
+	    unzzip_cat_file (disk, mix_name, out);
+	    free (mix_name);
 	    if (extract) fclose(out);
 	}
-	DBG2("readdir done %s", strerror(errno));
+	DBG2("readdir (%s)", strerror(errno));
     }
     else
     {   /* list only the matching entries - in order of zip directory */
@@ -91,23 +110,17 @@
 		    _zzip_FNM_NOESCAPE|_zzip_FNM_PATHNAME|_zzip_FNM_PERIOD))
 	        {
 	             FILE* out = stdout;
-	             char* zip_name = argv1;
-	             int zip_name_len = strlen(zip_name);
-	             int name_len = strlen(name);
-	             char* mix_name = malloc(zip_name_len + 2 + name_len);
-	             if (zip_name_len > 4 && !strcmp(zip_name+zip_name_len-4, ".zip"))
-	                 zip_name_len -= 4;
-	             memcpy(mix_name, zip_name, zip_name_len);
-	             mix_namezip_name_len = '/';
-	             strcpy(mix_name + zip_name_len + 1, name);
+	             char* mix_name = strdup_mixname(zip_name, name);
 	             if (extract) out = create_fopen(name, "wb", 1);
 	             if (! out) {
 	                 if (errno != EISDIR) done = EXIT_ERRORS;
+	                 free(mix_name);
 	                 continue;
 	             }
 		     fprintf(stderr, "%s %s -> %s\n", zip_name, name, mix_name);
 		     /* 'test1.zip' 'README' -> 'test1/README' */
 		     unzzip_cat_file (disk, mix_name, out);
+                     free(mix_name);
 		     if (extract) fclose(out);
 		     break; /* match loop */
 	        }

_service:tar_scm:v0.13.72.tar.gz/bins/unzzipcat-zip.c -> _service:tar_scm:v0.13.74.tar.gz/bins/unzzipcat-zip.c Changed

_service:tar_scm:v0.13.72.tar.gz/bins/zzcat.c -> _service:tar_scm:v0.13.74.tar.gz/bins/zzcat.c Changed

_service:tar_scm:v0.13.72.tar.gz/bins/zzxorcat.c -> _service:tar_scm:v0.13.74.tar.gz/bins/zzxorcat.c Changed

_service:tar_scm:v0.13.72.tar.gz/docker_mirror.py -> _service:tar_scm:v0.13.74.tar.gz/docker_mirror.py Changed

@@ -1,10 +1,10 @@
 #! /usr/bin/python3
 # from __future__ import print_function
 
-__copyright__ = "(C) 2021 Guido Draheim"
+__copyright__ = "(C) 2023 Guido Draheim"
 __contact__ = "https://github.com/gdraheim/docker-mirror-packages-repo"
 __license__ = "CC0 Creative Commons Zero (Public Domain)"
-__version__ = "1.6.3007"
+__version__ = "1.7.5117"
 
 from collections import OrderedDict, namedtuple
 import os.path
@@ -15,6 +15,8 @@
 import subprocess
 import tempfile
 import shutil
+import socket
+import time
 
 if sys.version0 != '2':
     xrange = range
@@ -24,19 +26,26 @@
 DOCKER = "docker"
 ADDHOSTS = False
 ADDEPEL = False
+UPDATES = False
 UNIVERSE = False
 
+MAXWAIT = 6
+
 LEAP = "opensuse/leap"
 SUSE = "opensuse"
-OPENSUSE_VERSIONS = {"42.2": SUSE, "42.3": SUSE, "15.0": LEAP, "15.1": LEAP, "15.2": LEAP, "15.3": LEAP}
+OPENSUSE_VERSIONS = {"42.2": SUSE, "42.3": SUSE, "15.0": LEAP, "15.1": LEAP, "15.2": LEAP, "15.3": LEAP, "15.4": LEAP}
 UBUNTU_LTS = {"16": "16.04", "18": "18.04", "20": "20.04"}
 UBUNTU_VERSIONS = {"12.04": "precise", "14.04": "trusty", "16.04": "xenial", "17.10": "artful",
                    "18.04": "bionic", "18.10": "cosmic", "19.04": "disco", "19.10": "eoan",
-                   "20.04": "focal", "20.10": "groovy"}
+                   "20.04": "focal", "20.10": "groovy", "21.04": "hirsute", "21.10": "impish",
+                   "22.04": "jammpy", "22.10": "kinetic", "23.04": "lunatic"}
 CENTOS_VERSIONS = {"7.0": "7.0.1406", "7.1": "7.1.1503", "7.2": "7.2.1511", "7.3": "7.3.1611",
                    "7.4": "7.4.1708", "7.5": "7.5.1804", "7.6": "7.6.1810", "7.7": "7.7.1908",
                    "7.8": "7.8.2003", "7.9": "7.9.2009",
-                   "8.0": "8.0.1905", "8.1": "8.1.1911", "8.2": "8.2.2004", "8.3": "8.3.2011"}
+                   "8.0": "8.0.1905", "8.1": "8.1.1911", "8.2": "8.2.2004", "8.3": "8.3.2011",
+                   "8.4": "8.4.2105"}
+ALMA_VERSIONS = {"9.1-20230222": "9.1", "9.1-20221201": "9.1", "9.1-20221117": "9.1",
+                 "9.0-20221001": "9.0", "9.0-20220901": "9.0", "9.0-20220706": "9.0", }
 
 def decodes(text):
     if text is None: return None
@@ -184,6 +193,8 @@
         """ converts a shorthand version into the version string used on an image name. """
         if image.startswith("centos:"):
             return self.get_centos_latest(image)
+        if image.startswith("almalinux:"):
+            return self.get_centos_latest(image)
         if image.startswith("opensuse/leap:"):
             return self.get_opensuse_latest(image)
         if image.startswith("opensuse:"):
@@ -196,6 +207,9 @@
         if image.startswith("centos:"):
             version = imagelen("centos:"):
             return self.get_centos_latest_version(version)
+        if image.startswith("almalinux:"):
+            version = imagelen("almalinux:"):
+            return self.get_centos_latest_version(version)
         if image.startswith("opensuse/leap:"):
             version = imagelen("opensuse/leap:"):
             return self.get_opensuse_latest_version(version)
@@ -213,6 +227,8 @@
             'docker start --add-host mirror...:centos-repo centos:x.y'. """
         if image.startswith("centos:"):
             return self.get_centos_docker_mirror(image)
+        if image.startswith("almalinux:"):
+            return self.get_centos_docker_mirror(image)
         if image.startswith("opensuse/leap:"):
             return self.get_opensuse_docker_mirror(image)
         if image.startswith("opensuse:"):
@@ -231,13 +247,18 @@
             if ADDEPEL:
                 if "centos" in image:
                     mirrors += self.get_epel_docker_mirrors(image)
+        if image.startswith("almalinux:"):
+            mirrors = self.get_centos_docker_mirrors(image)
+            if ADDEPEL:
+                if "alma" in image:
+                    mirrors += self.get_epel_docker_mirrors(image)
         if image.startswith("opensuse/leap:"):
             mirrors = self.get_opensuse_docker_mirrors(image)
         if image.startswith("opensuse:"):
             mirrors = self.get_opensuse_docker_mirrors(image)
         if image.startswith("ubuntu:"):
             mirrors = self.get_ubuntu_docker_mirrors(image)
-        logg.info(" %s -> %s", image, " ".join(mirror.cname for mirror in mirrors))
+        logg.info("     mirrors for %s -> %s", image, " ".join(mirror.cname for mirror in mirrors))
         return mirrors
     def get_ubuntu_latest(self, image, default=None):
         if image.startswith("ubuntu:"):
@@ -276,6 +297,7 @@
             other docker containers"""
         rmi = "localhost:5000/mirror-packages"
         rep = "ubuntu-repo"
+        if UPDATES: rep = "ubuntu-repo/updates"
         if UNIVERSE: rep = "ubuntu-repo/universe"
         ver = self.get_ubuntu_latest_version(onlyversion(image))
         return self.docker_mirror(rmi, rep, ver, "archive.ubuntu.com", "security.ubuntu.com")
@@ -289,6 +311,12 @@
             latest = self.get_centos_latest_version(version)
             if latest:
                 return "{distro}:{latest}".format(**locals())
+        if image.startswith("almalinux:"):
+            distro = "almalinux"
+            version = imagelen("almalinux:"):
+            latest = self.get_centos_latest_version(version)
+            if latest:
+                return "{distro}:{latest}".format(**locals())
         if default is not None:
             return default
         return image
@@ -305,19 +333,39 @@
                     logg.debug("release %s (%s)", release, fullrelease)
                     if latest < fullrelease:
                         latest = fullrelease
+            for release in ALMA_VERSIONS:
+                if release.startswith(ver):
+                    # fullrelease = ALMA_VERSIONSrelease
+                    mainrelease = CENTOS_VERSIONSrelease
+                    logg.debug("release %s (%s)", release, mainrelease)
+                    if latest < mainrelease:
+                        latest = mainrelease
             if latest:
                 ver = latest
         if ver in CENTOS_VERSIONS:
             ver = CENTOS_VERSIONSver
+        if version in ALMA_VERSIONS:
+            ver = ALMA_VERSIONSversion
+        elif version in ALMA_VERSIONS.values():
+            ver = max(os for os in ALMA_VERSIONS if ALMA_VERSIONSos == version)
+        logg.debug("latest version %s for %s", ver, version)
         return ver or version
     def get_centos_docker_mirror(self, image):
         """ detects a local centos mirror or starts a local
             docker container with a centos repo mirror. It
             will return the setting for extrahosts"""
+        if ":" in image:
+            distro, ver = image.split(":", 1)
+        else:
+            distro, ver = "centos", image
         rmi = "localhost:5000/mirror-packages"
-        rep = "centos-repo"
+        rep = F"{distro}-repo"
         ver = self.get_centos_latest_version(onlyversion(image))
-        return self.docker_mirror(rmi, rep, ver, "mirrorlist.centos.org")
+        logg.debug("    mirror for %s (%s)", ver, image)
+        if "alma" in distro:
+            return self.docker_mirror(rmi, rep, ver, "mirrors.almalinux.org")
+        else:
+            return self.docker_mirror(rmi, rep, ver, "mirrorlist.centos.org")
     def get_centos_docker_mirrors(self, image):
         main = self.get_centos_docker_mirror(image)
         return main
@@ -396,6 +444,11 @@
         version = self.get_centos_latest_version(ver)
         # cut the yymm date part from the centos release
         released = version.split(".")-1
+        # cut the yymm date part from the almalinux release
+        yymm = re.match("\\d+.\\d+-22(\\d\\d\\d\\d)\\d*", version)
+        if yymm:
+            released = yymm.group(1)
+        logg.debug("      detected %s -> epel %s", version, released)
         later = ""
         before = ""
         # and then check for actual images around
@@ -429,14 +482,14 @@
         out, err, rc = output3(cmd.format(**locals()))
         if rc:
             logg.info("%s : %s", cmd, err)
-            logg.debug("no address for %s", name)
+            logg.debug("no addr for %s", name)
             return None
         values = json.loads(out)
         if not values or "NetworkSettings" not in values0:
             logg.critical(" docker inspect %s => %s ", name, values)
         addr = values0"NetworkSettings""IPAddress"
         assert isinstance(addr, basestring)
-        logg.debug("address %s for %s", addr, name)
+        logg.debug("::::                %s -> %s", name, addr)
         return addr
     def start_containers(self, image):
         mirrors = self.get_docker_mirrors(image)
@@ -451,14 +504,14 @@
         out, err, ok = output3(cmd.format(**locals()))
         image_found = json.loads(out)
         if not image_found:
-            logg.info("image not found: %s", image)
+            logg.info("    image not found: %s", image)
             return None
         cmd = "{docker} inspect {container}"

_service:tar_scm:v0.13.72.tar.gz/docker_mirror.pyi -> _service:tar_scm:v0.13.74.tar.gz/docker_mirror.pyi Changed

@@ -2,8 +2,8 @@
 from typing import Optional, Union, Tuple, Dict, List
 
 def decodes(text: Optionalstr) -> Optionalstr: ...
-def decodes_(text: str) -> str: ...
-def output3(cmd : Unionstr, Liststr, shell: bool = True, debug: bool = True) -> Tuplestr, str, int: ...
+def decodes_(text: Unionstr,bytes) -> str: ...
+def output3(cmd: Unionstr, Liststr, shell: bool = True, debug: bool = True) -> Tuplestr, str, int: ...
 def major(version: str) -> str: ...
 def onlyversion(image: str) -> str: ...
 
@@ -11,47 +11,47 @@
     def __init__(self, cname: str, image: str, hosts: Liststr) -> None: ...
 
 class DockerMirrorPackagesRepo:
-    def __init__(self, image : Optionalstr = None) -> None:
-        self._image : Optionalstr
+    def __init__(self, image: Optionalstr = None) -> None:
+        self._image: Optionalstr
     def host_system_image(self) -> str: ...
     def detect_etc_image(self, etc: str) -> Tuplestr, str: ...
     def detect_base_image(self, image: str) -> str: ...
     def detect_base_image_from(self, cname: str, tempdir: str) -> Tuplestr, str: ...
     def get_docker_latest_image(self, image: str) -> str: ...
     def get_docker_latest_version(self, image: str) -> str: ...
-    def get_docker_mirror(self, image : str) -> OptionalDockerMirror: ...
-    def get_docker_mirrors(self, image : str) -> ListDockerMirror: 
+    def get_docker_mirror(self, image: str) -> OptionalDockerMirror: ...
+    def get_docker_mirrors(self, image: str) -> ListDockerMirror:
         mirrors: ListDockerMirror
     def get_ubuntu_latest(self, image: str, default: Optionalstr = None) -> str: ...
     def get_ubuntu_latest_version(self, version: str) -> str: ...
-    def get_ubuntu_docker_mirror(self, image : str) -> DockerMirror: ...
-    def get_ubuntu_docker_mirrors(self, image : str) -> ListDockerMirror: ...
+    def get_ubuntu_docker_mirror(self, image: str) -> DockerMirror: ...
+    def get_ubuntu_docker_mirrors(self, image: str) -> ListDockerMirror: ...
     def get_centos_latest(self, image: str, default: Optionalstr = None) -> str: ...
     def get_centos_latest_version(self, version: str) -> str: ...
-    def get_centos_docker_mirror(self, image : str) -> DockerMirror: ...
-    def get_centos_docker_mirrors(self, image : str) -> ListDockerMirror: ...
+    def get_centos_docker_mirror(self, image: str) -> DockerMirror: ...
+    def get_centos_docker_mirrors(self, image: str) -> ListDockerMirror: ...
     def get_opensuse_latest(self, image: str, default: Optionalstr = None) -> str: ...
     def get_opensuse_latest_version(self, version: str) -> str: ...
-    def get_opensuse_docker_mirror(self, image : str) -> DockerMirror: ...
-    def get_opensuse_docker_mirrors(self, image : str) -> ListDockerMirror: ...
-    def docker_mirror(self, rmi : str, rep : str, ver : str, *hosts : str) -> DockerMirror: ...
-    def get_extra_mirrors(self, image : str) -> ListDockerMirror: 
+    def get_opensuse_docker_mirror(self, image: str) -> DockerMirror: ...
+    def get_opensuse_docker_mirrors(self, image: str) -> ListDockerMirror: ...
+    def docker_mirror(self, rmi: str, rep: str, ver: str, *hosts: str) -> DockerMirror: ...
+    def get_extra_mirrors(self, image: str) -> ListDockerMirror:
         mirrors: ListDockerMirror
-    def get_epel_docker_mirrors(self, image : str) -> ListDockerMirror: ...
-    def get_epel_docker_mirror(self, image : str) -> DockerMirror: ...
+    def get_epel_docker_mirrors(self, image: str) -> ListDockerMirror: ...
+    def get_epel_docker_mirror(self, image: str) -> DockerMirror: ...
     def ip_container(self, name: str) -> Optionalstr: ...
-    def start_containers(self, image : str) -> Dictstr, Optionalstr:
+    def start_containers(self, image: str) -> Dictstr, Optionalstr:
         done: Dictstr, Optionalstr
-    def start_container(self, image : str, container : str) -> Optionalstr: ...
-    def stop_containers(self, image : str) -> Dictstr, str: 
+    def start_container(self, image: str, container: str) -> Optionalstr: ...
+    def stop_containers(self, image: str) -> Dictstr, str:
         done: Dictstr, str
-    def stop_container(self, image : str, container : str) -> str: ...
+    def stop_container(self, image: str, container: str) -> str: ...
     def info_containers(self, image: str) -> Dictstr, Optionalstr: ...
     def info_container(self, image: str, container: str) -> Optionalstr: ...
     def get_containers(self, image: str) -> Liststr: ...
     def inspect_containers(self, image: str) -> Dictstr, Optionalstr:
         done: Dictstr, Optionalstr
-    def add_hosts(self, image: str, done: Dictstr, Optionalstr = {}) -> Liststr: 
+    def add_hosts(self, image: str, done: Dictstr, Optionalstr = {}) -> Liststr:
         args: Liststr
     def helps(self) -> str: ...
     def detect(self, image: Optionalstr = None) -> str: ...
@@ -61,6 +61,11 @@
     def facts(self, image: Optionalstr = None) -> str: ...
     def starts(self, image: Optionalstr = None) -> str: ...
     def stops(self, image: Optionalstr = None) -> str: ...
+    def wait_mirrors(self, hosts: Dictstr, Optionalstr) -> int:
+        results: Dictstr, int
     def infos(self, image: Optionalstr = None) -> str: ...
     def containers(self, image: Optionalstr = None) -> str: ...
     def inspects(self, image: Optionalstr = None) -> str: ...
+    def from_dockerfile(self, dockerfile: str, defaults: Optionalstr = None) -> Optionalstr: ...
+
+def repo_scripts() -> str: ...

_service:tar_scm:v0.13.74.tar.gz/docs/64on32.htm.md Added

@@ -0,0 +1,158 @@
+<date> 13. Aug 2003 </date>
+
+## 64on32 largefile information 
+
+### largefile problems 
+
+Through actual problems with handling files larger than 2 Gigabyte,
+I had to face the fact that there are serious problems with the
+largefile implementation around shared-libraries. This is bound
+to the effect that 64on32 platforms allow a preprocessor #define
+_FILE_OFFSET_BITS=64 which will shift the integretal type of
+off_t from a 32bit to a 64bit entity.
+
+That will in fact lead to problems if an application is compiled
+with a different off_t size than the shared-library it will be
+linked to. Among the problems are different sizes of the callframe
+for those functions that take an argument of off_t type. Note how
+the "seek" call uses an off_t in the middle of its arguments which
+may be 32bit or 64bit depending on a preprocessor define. And
+you know that zziplib wraps up "seek"-like calls as well.
+
+The observations were largely made independent of the zziplib 
+however, as a zip-file does uses 32bit offsets in its header
+fields anyway, and therefore a single zip-archive (or any of 
+its wrapped files) can not be larger than 2 Gigabyte anyway.
+I would to refer you for deeper information to my website
+about this problem-space at
+
+<big>
+<a href="http://ac-archive.sf.net/largefile" remap="url">
+                  ac-archive.sf.net/largefile </a>
+</big>
+
+### zziplib related 
+
+Still however the problems hold for zziplib usage when
+the functions are linked dynamically as a shared-library.
+Here we can face the fact that an application (or a higher
+level library) uses a different off_t size than the
+underlying zziplib shared-library.
+
+If you read the `zzip/zzip.h` header file then
+you will surely see a number of off_t usages around, here 
+they are wrapped in the form of zzip_off_t to get away with
+platforms not predefining off_t in the first place. Those
+functions are (at the time of writing):
+
+> * `zzip_telldir`(return type)
+> * `zzip_seekdir`(second param)
+> * `zzip_tell`(return type)
+> * `zzip_seek`(second param of three)
+
+
+
+What might be not as obvious however: you will find
+also the off_t type being used in the plugin-handlers
+callback functions. That is based on the fact that
+the plugin-structures is filled by default with the
+posix-functions from the C library. A 64on32 platform
+however offers quite usually a mixedmode C library
+exporting two symbols for tell/seek calls to match
+either 32bit off_t or 64bit off_t
+
+> * `zzip_plugin_io->seeks` (return type and second param)
+> * `zzip_plugin_io->filesize`(return type)
+
+The problem here: the application might not make use of
+zzip_seek/zzip_tell explicitly, but may be the internal
+implementation of a zzip call uses io->seeks or io->filesize.
+When an application uses plugin-io with these callbacks
+overridden then surely problems will arise.
+
+### zziplib mixedmode option 
+
+I have extended the zziplib implementation to allow itself to
+  live fine on 64on32 systems. The 64on32 system are like linux
+  and solaris where the default off_t is 32bit and only by the
+  preprocessor hint they shift into 64bit. The C library on
+  these systems is a mixedmode one offering a pair for each of
+  the problematic functions - lseek *and* lseek64 for
+  example.
+
+The zziplib header file detects when it is present on a
+  64on32 system (through hints in configured zzip/conf.h)
+  and that _FILE_OFFSET_BITS has been set to 64bit. In that
+  case it does automatically issue #defines that shift the
+  symbol-name from zzip_seek into zzip_seek64. Likewise,
+  *all* the *_ext_io functions are renamed into
+  *_ext_io64 calls
+
+The zziplib library itself will also pick up the renamings
+when it is compiled with 64bit off_t - in effect an application
+with a 64bit-off_t dependency can only link with a zziplib
+compiled in 64bit-off_t mode. If the application does not
+use any call symbol with an off_t dependency then it does 
+not matter and the link will succeed. That's simply because
+function calls without an off_t dependency will not be
+renamed and they are the same for a 32bit-off_t zziplib or
+a 64bit-off_t zziplib.
+
+As an extra, the zziplib exports a few of its common calls
+like being a mixedmode library when you compile it both in
+64bit mode and as a shared library. In that case, the 
+resulting shared library will export symbol pairs for the
+calls with an off_t dependency, i.e. both zzip_seek and
+zzip_seek64 are present.
+
+Note that for reasons of being a lightweight library, the
+zziplib library does not export mixmode call pairs for
+the *_ext_io family of functions. The current generation
+of zziplib does call io->seeks unconditionally of any
+case'ing flag and so far there are no problems with the
+current design.
+
+### Implementation details 
+
+In the header file zzip/zzip.h you will find the define
+ZZIP_LARGEFILE_RENAME which triggers the renaming process.
+See zzip/conf.h on the conditions where it is being triggered.
+
+For the implementation of the mixedmode symbol pairs, see
+zzip/dir.c for an example for the zzip_seekdir/zzip_seekdir64
+pair - here we use libtools -DPIC to detect the situation of 
+being compiled as shared-library, we use the preprocessor
+#def ZZIP_LARGEFILE_RENAME to know we are on a 64on32
+system compiled in 64bit-off_t, and we check the transitional
+largefile API to be present by looking for EOVERFLOW errno.
+
+When all the three are present then we simply #undef the
+renaming preprocessor macro and define a function symbol 
+(without the renaming) and call the renamed symbol 
+already compiled a few lines before. We use the pre-off_t
+type "long" for the 32bit entity of these calls. While
+we mostly let the compiler do the shrink/expand of these
+integer types, we do also sometimes check for overflows
+of the seekvalue.
+
+### rpm extras and pkg-config 
+
+The provided .spec file shows how to compile both variants
+of the zziplib shared library and to install them in
+parallel in the system. Also we provide doubled sets
+of .pc files for pkg-config installation. That should make
+it a lot easier for applications to link to the correct
+library they want.
+
+Here are all the variants that you can find after installing
+  the vanilla rpm files from zziplib.sf.net:
+```
+$ pkg-config --list-all | sort | grep zzip
+zziplib32                   zziplib32 - ZZipLib - libZ-based ZIP-access Library
+zziplib64                   zziplib64 - ZZipLib - libZ-based ZIP-access Library
+zziplib                     zziplib - ZZipLib - libZ-based ZIP-access Library
+zzip-sdl-config             zzip-sdl-config - SDL Config (for ZZipLib)
+zzip-sdl-rwops              zzip-sdl-rwops - SDL_rwops for ZZipLib
+zzipwrap                    zzipwrap - Callback Wrappers for ZZipLib
+zzip-zlib-config            zzip-zlib-config - ZLib Config (for ZZipLib)
+```

_service:tar_scm:v0.13.72.tar.gz/docs/CMakeLists.txt -> _service:tar_scm:v0.13.74.tar.gz/docs/CMakeLists.txt Changed

@@ -6,13 +6,12 @@
 
 # options ########################################################
 option(BUILD_SHARED_LIBS "Build a shared library" ON)
-option(BUILD_STATIC_LIBS "Build the static library" OFF)
 option(BUILD_TESTS "Build test programs" OFF)
 option(MSVC_STATIC_RUNTIME "Build with static runtime libs (/MT)" ON)
 option(ZZIP_HTMLSITE "Generate site html pages from docs" OFF)
 option(ZZIP_HTMPAGES "Generate html manpages from sources" OFF)
 
-if(UNIX)
+if(UNIX OR MINGW)
 option(ZZIP_MANPAGES "Generate man3 manpages from sources" ON)
 else()
 option(ZZIP_MANPAGES "Generate man3 manpages from sources" OFF)
@@ -49,6 +48,13 @@
             configs.htm sfx-make.htm   developer.htm download.htm
             history.htm referentials.htm  faq.htm copying.htm notes.htm
             functions.htm zip-php.htm)
+set(htm_md_FILES zzip-index.htm.md zzip-zip.htm.md zzip-file.htm.md zzip-sdl-rwops.htm.md
+            zzip-extio.htm.md zzip-xor.htm.md zzip-crypt.htm.md zzip-cryptoid.htm.md
+            zzip-api.htm.md zzip-basics.htm.md zzip-extras.htm.md zzip-parse.htm.md
+            64on32.htm.md future.htm.md fseeko.htm.md mmapped.htm.md memdisk.htm.md
+            configs.htm.md sfx-make.htm.md developer.htm.md download.htm.md
+            history.htm.md referentials.htm.md faq.htm.md copying.htm.md notes.htm.md
+            functions.htm.md zip-php.htm.md)
 set(bins_FILES ${bins}/zzdir.c ${bins}/zzcat.c ${bins}/zzobfuscated.c ${bins}/zziptest.c ${bins}/zzxordir.c ${bins}/zzxorcat.c ${bins}/zzxorcopy.c )
 set(SDLs_FILES ${SDLs}/SDL_rwops_zzcat.c ${SDLs}/SDL_rwops_zzip.c ${SDLs}/SDL_rwops_zzip.h )
 set(zzipdoc_FILES makedocs.py          zzipdoc/__init__.py
@@ -70,14 +76,18 @@
     DEPENDS ${topdir}/ChangeLog
     VERBATIM)
 
-set(mksite_sh_args --VERSION=${PROJECT_VERSION} --xml --src-dir=${srcdir} --print)
-add_custom_command(OUTPUT site.html
-    COMMAND ${CP} ${srcdir}/body.htm site.htm
-    COMMAND ${BASH} ${srcdir}/mksite.sh ${mksite_sh_args} site.htm
-    COMMAND ${BASH} -c "for i in *.html; do sed -i -e s:${srcdir}:../../docs: $i; done; true"
-    DEPENDS ${htm_FILES} changes.htm
+add_custom_command(OUTPUT site/site.html
+    COMMAND ${BASH} -c "test -d ${outdir}/site || mkdir -p ${outdir}/site"
+    COMMAND ${CP} ${srcdir}/body.htm ${outdir}/site/site.htm
+    COMMAND ${CP} ${outdir}/changes.htm ${outdir}/site/changes.htm
+    # COMMAND ${CP} "${htm_FILES}" ${outdir}/site/
+    COMMAND ${BASH} -c "cp -v ${srcdir}/*.md ${outdir}/site/"
+    COMMAND ${BASH} -c "cp -v ${srcdir}/*.css ${outdir}/site/"
+    COMMAND ${BASH} -c "cd ${outdir}/site; for i in *.md; do ${PYTHON} ${srcdir}/tools/md2dbk.py $i --htm > `basename $i .md`; done"
+    COMMAND ${BASH} -c "cd ${outdir}/site && ${BASH} ${srcdir}/mksite.sh --VERSION=${PROJECT_VERSION} --xml --print site.htm"
+    DEPENDS ${htm_md_FILES} changes.htm ${srcdir}/tools/md2dbk.py
     VERBATIM)
-add_custom_target(site DEPENDS site.html)
+add_custom_target(site DEPENDS site/site.html)
 
 add_custom_command(OUTPUT zzip.xml
     COMMAND ${PY} ${srcdir}/zzipdoc/htm2dbk.py ${htm_FILES} zziplib.xml -o ${outdir}/zzip.xml
@@ -98,6 +108,29 @@
 add_custom_target(pdf DEPENDS zzip.pdf)
 endif()
 
+string(REPLACE ";" " " all_bins_FILES "${bins_FILES}")
+string(REPLACE ";" " " all_SDLs_FILES "${SDLs_FILES}")
+add_custom_command(OUTPUT htmlsite.tar
+    COMMAND ${BASH} -c "ls -l ${CMAKE_CURRENT_BINARY_DIR}/site/site.html"
+    COMMAND ${BASH} -c "cd ${outdir} && cp zziplib.html zzipmmapped.html zzipfseeko.html site/"
+    COMMAND ${BASH} -c "cd ${srcdir} && cp README.* COPYING.* ${outdir}/site/"
+    COMMAND ${BASH} -c "cd ${topdir} && cp ChangeLog          ${outdir}/site/"
+    COMMAND ${BASH} -c "cd ${topdir} && cp ${all_bins_FILES}  ${outdir}/site/"
+    COMMAND ${BASH} -c "cd ${topdir} && cp ${all_SDLs_FILES}  ${outdir}/site/"
+    COMMAND ${BASH} -c "cd site && ln -s zzip-index.html index.html"
+    COMMAND ${BASH} -c "tar cf htmlsite.tar site/*.*"
+    COMMAND ${BASH} -c "ls -l `pwd`/htmlsite.tar || true"
+    #  DEPENDS site/site.html zziplib.html zzipmmapped.html zzipfseeko.html
+    DEPENDS    site/site.html zziplib.xml  zzipmmapped.xml  zzipfseeko.xml
+    VERBATIM)
+if(ZZIP_HTMLSITE)
+add_custom_target(htmlsite ALL DEPENDS htmlsite.tar COMMAND ${BASH} -c "ls -l htmlsite.tar")
+else()
+add_custom_target(htmlsite DEPENDS htmlsite.tar COMMAND ${BASH} -c "ls -l htmlsite.tar")
+endif()
+
+####
+
 set(docinfo --package=zziplib --version=${PROJECT_VERSION})
 file(GLOB zzip_sources "${topdir}/zzip/*.c")
 add_custom_command(OUTPUT zziplib.xml
@@ -106,43 +139,46 @@
     DEPENDS libzzip
     BYPRODUCTS zziplib.html
     VERBATIM)
+add_custom_target(zziplib_xml DEPENDS zziplib.xml) # prevent race codition
 add_custom_command(OUTPUT zzipmmapped.xml
     COMMAND ${PY} ${srcdir}/makedocs.py ${zzip_sources} ${docinfo} --onlymainheader=zzip/mmapped.h --output=zzipmmapped
     COMMAND ${MV} zzipmmapped.docbook zzipmmapped.xml
     DEPENDS libzzipmmapped
     BYPRODUCTS zzipmmapped.html
     VERBATIM)
+add_custom_target(zzipmmapped_xml DEPENDS zzipmmapped.xml) # prevent race codition
 add_custom_command(OUTPUT zzipfseeko.xml
     COMMAND ${PY} ${srcdir}/makedocs.py ${zzip_sources} ${docinfo} --onlymainheader=zzip/fseeko.h --output=zzipfseeko
     COMMAND ${MV} zzipfseeko.docbook zzipfseeko.xml
     DEPENDS libzzipfseeko
     BYPRODUCTS zzipfseeko.html
     VERBATIM)
+add_custom_target(zzipfseeko_xml DEPENDS zzipfseeko.xml) # prevent race codition
 add_custom_command(OUTPUT manpages.tar
     COMMAND ${BASH} -c "test -d man3 && rm -rf man3; mkdir man3"
-    COMMAND ${PY} ${srcdir}/dbk2man.py -o man3 man zziplib.xml
-    COMMAND ${PY} ${srcdir}/dbk2man.py -o man3 man zzipmmapped.xml
-    COMMAND ${PY} ${srcdir}/dbk2man.py -o man3 man zzipfseeko.xml
+    COMMAND ${PY} ${srcdir}/tools/dbk2man.py -o man3 man zziplib.xml
+    COMMAND ${PY} ${srcdir}/tools/dbk2man.py -o man3 man zzipmmapped.xml
+    COMMAND ${PY} ${srcdir}/tools/dbk2man.py -o man3 man zzipfseeko.xml
     COMMAND ${BASH} -c "test -d man3/man3 && mv man3 man3_; test -d man3_/man3 && mv man3_/man3 .; rm -rf man3_"
     COMMAND ${BASH} -c "chmod 664 man3/*.3"
     COMMAND ${BASH} -c "tar cf manpages.tar man3"
     COMMAND ${BASH} -c "ls -l `pwd`/manpages.tar >&2 || true"
-    DEPENDS zziplib.xml zzipmmapped.xml zzipfseeko.xml
+    DEPENDS zziplib_xml zzipmmapped_xml zzipfseeko_xml
     VERBATIM)
 add_custom_command(OUTPUT htmpages.tar
     COMMAND ${BASH} -c "test -d html && rm -rf html; mkdir html"
-    COMMAND ${PY} ${srcdir}/dbk2man.py -o html html zziplib.xml
-    COMMAND ${PY} ${srcdir}/dbk2man.py -o html html zzipmmapped.xml
-    COMMAND ${PY} ${srcdir}/dbk2man.py -o html html zzipfseeko.xml
-    COMMAND ${PY} ${srcdir}/dir2index.py -o html html
+    COMMAND ${PY} ${srcdir}/tools/dbk2man.py -o html html zziplib.xml
+    COMMAND ${PY} ${srcdir}/tools/dbk2man.py -o html html zzipmmapped.xml
+    COMMAND ${PY} ${srcdir}/tools/dbk2man.py -o html html zzipfseeko.xml
+    COMMAND ${PY} ${srcdir}/tools/dir2index.py -o html html
     COMMAND ${BASH} -c "tar cf htmpages.tar html/*.*"
     COMMAND ${BASH} -c "ls -l `pwd`/htmpages.tar || true"
-    DEPENDS zziplib.xml zzipmmapped.xml zzipfseeko.xml
+    DEPENDS zziplib_xml zzipmmapped_xml zzipfseeko_xml
     VERBATIM)
 
 add_custom_target(manpages DEPENDS manpages.tar)
 add_custom_target(htmpages DEPENDS htmpages.tar)
-add_custom_target(doc DEPENDS zziplib.xml zzipmmapped.xml zzipfseeko.xml site.html)
+add_custom_target(doc DEPENDS zziplib_xml zzipmmapped_xml zzipfseeko_xml site)
 add_custom_target(docs DEPENDS doc manpages htmpages)
 add_custom_target(mans DEPENDS manpages)
 
@@ -159,31 +195,41 @@
 
 # install ########################################################
 
-string(REPLACE ";" " " all_bins_FILES "${bins_FILES}")
-string(REPLACE ";" " " all_SDLs_FILES "${SDLs_FILES}")
 add_custom_target(install-site
-   COMMAND ${BASH} -c "ls -l ${CMAKE_CURRENT_BINARY_DIR}/site.html"
+   COMMAND ${BASH} -c "ls -l ${CMAKE_CURRENT_BINARY_DIR}/site/site.html"
    COMMAND ${BASH} -c "mkdir -vp $DESTDIR${docdir}  >&2 || ls -ld $DESTDIR${docdir} >&2"
    COMMAND ${BASH} -c "cd ${outdir} && cp zziplib.html zzipmmapped.html zzipfseeko.html $DESTDIR${docdir}/"
    COMMAND ${BASH} -c "cd ${srcdir} && cp README.* COPYING.* $DESTDIR${docdir}/"
    COMMAND ${BASH} -c "cd ${topdir} && cp ChangeLog          $DESTDIR${docdir}/"
    COMMAND ${BASH} -c "cd ${topdir} && cp ${all_bins_FILES}  $DESTDIR${docdir}/"
    COMMAND ${BASH} -c "cd ${topdir} && cp ${all_SDLs_FILES}  $DESTDIR${docdir}/"
-   COMMAND ${BASH} -c "cd $DESTDIR${docdir} && cp ${outdir}/*.html ."
+   COMMAND ${BASH} -c "cd ${outdir}/site && cp *.html *.css  $DESTDIR${docdir}/"
    COMMAND ${BASH} -c "cd $DESTDIR${docdir} && ln -s zzip-index.html index.html"
-   DEPENDS site.html zziplib.html zzipmmapped.html zzipfseeko.html
+   COMMAND ${BASH} -c "echo running install-site is deprecated - just enable cmake -DZZIP_HTMLSITE=ON >&2"
+   DEPENDS site/site.html zziplib.html zzipmmapped.html zzipfseeko.html
    VERBATIM)
 add_custom_target(install-htmpages
    COMMAND ${BASH} -c "mkdir -vp $DESTDIR${docdir}  >&2 || ls -ld $DESTDIR${docdir} >&2"
    COMMAND ${BASH} -c "cp -r ${outdir}/html $DESTDIR${docdir}/"
    COMMAND ${BASH} -c "cd $DESTDIR${docdir} && mv html man"
+   COMMAND ${BASH} -c "echo running install-htmpages is deprecated - just enable cmake -DZZIP_HTMPAGES=ON >&2"
    DEPENDS htmpages.tar
    VERBATIM)
 add_custom_target(install-manpages
    COMMAND ${BASH} -c "mkdir -vp $DESTDIR${mandir}  >&2 || ls -ld $DESTDIR${mandir} >&2"
    COMMAND ${BASH} -c "cp -r ${outdir}/man3 $DESTDIR${mandir}/"
+   COMMAND ${BASH} -c "echo running install-manpages is deprecated - just enable cmake -DZZIP_MANPAGES=ON >&2"
    DEPENDS manpages.tar
    VERBATIM)
+add_custom_target(install-docs DEPENDS install-manpages install-htmpages install-site)
+add_custom_target(install-mans DEPENDS install-manpages)
+add_custom_target(install-man DEPENDS install-manpages)
+add_custom_target(install-htm DEPENDS install-htmpages)
+
+if(ZZIP_HTMLSITE)
+   install(CODE "message(STATUS \"Installing: html site to ${docdir}\")")
+   install(DIRECTORY ${outdir}/site/ DESTINATION ${docdir} MESSAGE_NEVER)
+endif()
 if(ZZIP_HTMPAGES)
    install(CODE "message(STATUS \"Installing: html pages to ${docdir}/man\")")
    install(DIRECTORY ${outdir}/html/ DESTINATION ${docdir}/man MESSAGE_NEVER)
@@ -192,10 +238,6 @@
    install(CODE "message(STATUS \"Installing: man3 pages to ${mandir}/man3\")")
    install(DIRECTORY ${outdir}/man3/ DESTINATION ${mandir}/man3 MESSAGE_NEVER)
 endif()
-add_custom_target(install-docs DEPENDS install-manpages install-htmpages install-site)
-add_custom_target(install-mans DEPENDS install-manpages)
-add_custom_target(install-man DEPENDS install-manpages)
-add_custom_target(install-htm DEPENDS install-htmpages)
 
 # messages #######################################################

_service:tar_scm:v0.13.74.tar.gz/docs/GNUmakefile Added

_service:tar_scm:v0.13.72.tar.gz/docs/Makefile.am -> _service:tar_scm:v0.13.74.tar.gz/docs/Makefile.am Changed

@@ -14,15 +14,22 @@
             configs.htm sfx-make.htm   developer.htm download.htm \
             history.htm referentials.htm  faq.htm copying.htm notes.htm \
             functions.htm zip-php.htm
+htm_md_FILES = zzip-index.htm.md zzip-zip.htm.md zzip-file.htm.md zzip-sdl-rwops.htm.md \
+            zzip-extio.htm.md zzip-xor.htm.md zzip-crypt.htm.md zzip-cryptoid.htm.md \
+            zzip-api.htm.md  zzip-basics.htm.md zzip-extras.htm.md zzip-parse.htm.md \
+            64on32.htm.md future.htm.md fseeko.htm.md mmapped.htm.md memdisk.htm.md \
+            configs.htm.md sfx-make.htm.md   developer.htm.md download.htm.md \
+            history.htm.md referentials.htm.md  faq.htm.md copying.htm.md notes.htm.md \
+            functions.htm.md zip-php.htm.md
 htms_FILES = changes.htm
 SDL = @top_srcdir@/SDL
 SDL_RWOPS = $(SDL)/SDL_rwops_zzcat.c \
             $(SDL)/SDL_rwops_zzip.c $(SDL)/SDL_rwops_zzip.h
 changelog = @top_srcdir@/ChangeLog
 
-EXTRA_DIST = make-doc.py $(doc_FILES) $(htm_FILES) $(SDL_RWOPS) \
+EXTRA_DIST = make-doc.py $(doc_FILES) $(htm_md_FILES) $(SDL_RWOPS) \
              make-doc.pl make-dbk.pl   mksite.sh mksite.pl body.htm \
-             dbk2man.py dir2index.py \
+             tools/dbk2man.py tools/dir2index.py \
              $(zzipdoc_FILES) sdocbook.css \
              zziplib-manpages.dbk zziplib-master.dbk \
              zziplib-manpages.tar
@@ -38,10 +45,6 @@
 	zzipdoc/functionprototype.py      zzipdoc/htmldocument.py \
                                           zzipdoc/docbookdocument.py
 
-html_FILES = $(htm_FILES:.htm=.html)       $(htms_FILES:.htm=.html) \
-             $(htm_FILES:.htm=.print.html) $(htms_FILES:.htm=.print.html) \
-             site.html site.print.html
-
 all : all-am default
 default : doc @MAINTAINER_MODE_FALSE@ mans
 clean-doc clean-docs : clean-unpack
@@ -52,7 +55,7 @@
 # -------------------------------------------------------------------
 zziplib.spec : @top_srcdir@/$(PACKAGE).spec
 	@ cp $? $@ # the two zzip-doc.* will grep through zziplib.spec
-doc  : $(doc_FILES) site.html
+doc  : $(doc_FILES) site/site.html
 docs : doc manpages.tar htmpages.tar
 # docu : docs
 docu : 
@@ -93,9 +96,9 @@
               $(bins)/zzxordir.c $(bins)/zzxorcat.c \
 	      $(bins)/zzxorcopy.c        $(SDL_RWOPS)
 
-install-docs: $(doc_FILES) $(man_FILES) site.html htmpages.tar
+install-docs: $(doc_FILES) $(man_FILES) site/site.html htmpages.tar
 	$(mkinstalldirs) $(DESTDIR)$(pkgdocdir)
-	$(INSTALL_DATA) $(html_FILES) $(DESTDIR)$(pkgdocdir)
+	$(INSTALL_DATA) site/*.html site/*.css $(DESTDIR)$(pkgdocdir)
 	for i in $(doc_FILES) $(DOCEXAMPLES) $(changelog) $(srcdir)/README.* \
 	; do $(INSTALL_DATA) `test -f $$i || echo $(srcdir)/`$$i \
 	    $(DESTDIR)$(pkgdocdir) ; done
@@ -155,12 +158,12 @@
 	; then echo going to regenerate "$@" in subdir "'"man"'" \
 	; echo 'test ! -d man3 || rm man3/* ; test -d man3 || mkdir man3' \
 	;       test ! -d man3 || rm man3/* ; test -d man3 || mkdir man3  \
-	; echo     '$(srcdir)/dbk2man.py -o man3 man zziplib.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o man3 man zziplib.xml  \
-	; echo     '$(srcdir)/dbk2man.py -o man3 man zzipmmapped.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o man3 man zzipmmapped.xml  \
-	; echo     '$(srcdir)/dbk2man.py -o man3 man zzipfseeko.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o man3 man zzipfseeko.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o man3 man zziplib.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o man3 man zziplib.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o man3 man zzipmmapped.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o man3 man zzipmmapped.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o man3 man zzipfseeko.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o man3 man zzipfseeko.xml  \
 	; if test -d man3/man3; then mv man3 man3_ \
 	;   mv man3_/man3 man3; rm -r man3_; fi \
 	; echo 'chmod 664 man3/*.3' \
@@ -194,14 +197,14 @@
 	;       test ! -d html || rm html/* ; test -d html || mkdir html  \
 	; echo 'cp $(srcdir)/zziplib-manpages.dbk zziplib-manpages.xml' \
 	;       cp $(srcdir)/zziplib-manpages.dbk zziplib-manpages.xml \
-	; echo     '$(srcdir)/dbk2man.py -o html html zziplib.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o html html zziplib.xml  \
-	; echo     '$(srcdir)/dbk2man.py -o html html zzipmmapped.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o html html zzipmmapped.xml  \
-	; echo     '$(srcdir)/dbk2man.py -o html html zzipfseeko.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o html html zzipfseeko.xml  \
-	; echo     '$(srcdir)/dir2index.py -o html html ' \
-	; $(PYTHON) $(srcdir)/dir2index.py -o html html   \
+	; echo     '$(srcdir)/tools/dbk2man.py -o html html zziplib.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o html html zziplib.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o html html zzipmmapped.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o html html zzipmmapped.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o html html zzipfseeko.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o html html zzipfseeko.xml  \
+	; echo     '$(srcdir)/tools/dir2index.py -o html html ' \
+	; $(PYTHON) $(srcdir)/tools/dir2index.py -o html html   \
 	; echo '$(PAX_TAR_CREATE) $@ html/*.*' \
 	;       $(PAX_TAR_CREATE) $@ html/*.*  \
 	; fi ; true
@@ -276,13 +279,18 @@
 	- test ".$(DESTDIR)" != "." || scrollkeeper-update -v
 
 # ----------------------------------------------- mksite.sh for the main html
-site.htm : body.htm
-	cp $(srcdir)/body.htm site.htm
+outdir = ${builddir}
 mksite_sh_args = --VERSION=$(VERSION) --xml --src-dir=$(srcdir) --print
-site.html : body.htm site.htm mksite.sh $(htm_FILES) $(htms_FILES)
-	cp $(srcdir)/body.htm site.htm
-	perl $(srcdir)/mksite.pl $(mksite_sh_args) site.htm || \
-	$(SHELL) $(srcdir)/mksite.sh $(mksite_sh_args) site.htm
+site/site.html : body.htm changes.htm mksite.sh $(htm_md_FILES) $(htms_FILES)
+	test -d ${outdir}/site || mkdir -p ${outdir}/site
+	cp $(srcdir)/body.htm ${outdir}/site/site.htm
+	cp $(outdir)/changes.htm ${outdir}/site/changes.htm
+	cp -v ${srcdir}/*.md ${outdir}/site/
+	cp -v ${srcdir}/*.css ${outdir}/site/
+	srcs=`cd ${srcdir} && pwd`; cd ${outdir}/site || exit 1 \
+	; for i in *.md; do ${PYTHON} $${srcs}/tools/md2dbk.py $$i --htm > `basename $$i .md` ; done
+	srcs=`cd ${srcdir} && pwd`; cd ${outdir}/site || exit 1 \
+	; $(SHELL) $${srcs}/mksite.sh $(mksite_sh_args) site.htm
 
 changes.htm : $(top_srcdir)/ChangeLog Makefile 
 	echo "<pre>" > $@ ; cat $(top_srcdir)/ChangeLog \

_service:tar_scm:v0.13.72.tar.gz/docs/Makefile.in -> _service:tar_scm:v0.13.74.tar.gz/docs/Makefile.in Changed

@@ -317,14 +317,22 @@
             history.htm referentials.htm  faq.htm copying.htm notes.htm \
             functions.htm zip-php.htm
 
+htm_md_FILES = zzip-index.htm.md zzip-zip.htm.md zzip-file.htm.md zzip-sdl-rwops.htm.md \
+            zzip-extio.htm.md zzip-xor.htm.md zzip-crypt.htm.md zzip-cryptoid.htm.md \
+            zzip-api.htm.md  zzip-basics.htm.md zzip-extras.htm.md zzip-parse.htm.md \
+            64on32.htm.md future.htm.md fseeko.htm.md mmapped.htm.md memdisk.htm.md \
+            configs.htm.md sfx-make.htm.md   developer.htm.md download.htm.md \
+            history.htm.md referentials.htm.md  faq.htm.md copying.htm.md notes.htm.md \
+            functions.htm.md zip-php.htm.md
+
 htms_FILES = changes.htm
 SDL_RWOPS = $(SDL)/SDL_rwops_zzcat.c \
             $(SDL)/SDL_rwops_zzip.c $(SDL)/SDL_rwops_zzip.h
 
 changelog = @top_srcdir@/ChangeLog
-EXTRA_DIST = make-doc.py $(doc_FILES) $(htm_FILES) $(SDL_RWOPS) \
+EXTRA_DIST = make-doc.py $(doc_FILES) $(htm_md_FILES) $(SDL_RWOPS) \
              make-doc.pl make-dbk.pl   mksite.sh mksite.pl body.htm \
-             dbk2man.py dir2index.py \
+             tools/dbk2man.py tools/dir2index.py \
              $(zzipdoc_FILES) sdocbook.css \
              zziplib-manpages.dbk zziplib-master.dbk \
              zziplib-manpages.tar
@@ -340,10 +348,6 @@
 	zzipdoc/functionprototype.py      zzipdoc/htmldocument.py \
                                           zzipdoc/docbookdocument.py
 
-html_FILES = $(htm_FILES:.htm=.html)       $(htms_FILES:.htm=.html) \
-             $(htm_FILES:.htm=.print.html) $(htms_FILES:.htm=.print.html) \
-             site.html site.print.html
-
 omfdir = ${datadir}/omf
 pkgomfdir = ${omfdir}/${PACKAGE}
 pkgdocdir = ${mandir}/../doc/${PACKAGE}
@@ -364,6 +368,9 @@
 DATESPEC = `date +%Y-%m-%d`
 DOCBOOKDTD = -//OASIS/DTD Docbook V4.1.2//EN
 MANSERIES = a302c642-1888-11d7-86f6-ba4b52ef847d
+
+# ----------------------------------------------- mksite.sh for the main html
+outdir = ${builddir}
 mksite_sh_args = --VERSION=$(VERSION) --xml --src-dir=$(srcdir) --print
 all: all-am
 
@@ -570,7 +577,7 @@
 # -------------------------------------------------------------------
 zziplib.spec : @top_srcdir@/$(PACKAGE).spec
 	@ cp $? $@ # the two zzip-doc.* will grep through zziplib.spec
-doc  : $(doc_FILES) site.html
+doc  : $(doc_FILES) site/site.html
 docs : doc manpages.tar htmpages.tar
 # docu : docs
 docu : 
@@ -602,9 +609,9 @@
                    "--onlymainheader=zzip/fseeko.h" "--output=zzipfseeko"
 	test -s zzipfseeko.docbook && mv zzipfseeko.docbook zzipfseeko.xml
 
-install-docs: $(doc_FILES) $(man_FILES) site.html htmpages.tar
+install-docs: $(doc_FILES) $(man_FILES) site/site.html htmpages.tar
 	$(mkinstalldirs) $(DESTDIR)$(pkgdocdir)
-	$(INSTALL_DATA) $(html_FILES) $(DESTDIR)$(pkgdocdir)
+	$(INSTALL_DATA) site/*.html site/*.css $(DESTDIR)$(pkgdocdir)
 	for i in $(doc_FILES) $(DOCEXAMPLES) $(changelog) $(srcdir)/README.* \
 	; do $(INSTALL_DATA) `test -f $$i || echo $(srcdir)/`$$i \
 	    $(DESTDIR)$(pkgdocdir) ; done
@@ -660,12 +667,12 @@
 	; then echo going to regenerate "$@" in subdir "'"man"'" \
 	; echo 'test ! -d man3 || rm man3/* ; test -d man3 || mkdir man3' \
 	;       test ! -d man3 || rm man3/* ; test -d man3 || mkdir man3  \
-	; echo     '$(srcdir)/dbk2man.py -o man3 man zziplib.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o man3 man zziplib.xml  \
-	; echo     '$(srcdir)/dbk2man.py -o man3 man zzipmmapped.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o man3 man zzipmmapped.xml  \
-	; echo     '$(srcdir)/dbk2man.py -o man3 man zzipfseeko.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o man3 man zzipfseeko.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o man3 man zziplib.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o man3 man zziplib.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o man3 man zzipmmapped.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o man3 man zzipmmapped.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o man3 man zzipfseeko.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o man3 man zzipfseeko.xml  \
 	; if test -d man3/man3; then mv man3 man3_ \
 	;   mv man3_/man3 man3; rm -r man3_; fi \
 	; echo 'chmod 664 man3/*.3' \
@@ -699,14 +706,14 @@
 	;       test ! -d html || rm html/* ; test -d html || mkdir html  \
 	; echo 'cp $(srcdir)/zziplib-manpages.dbk zziplib-manpages.xml' \
 	;       cp $(srcdir)/zziplib-manpages.dbk zziplib-manpages.xml \
-	; echo     '$(srcdir)/dbk2man.py -o html html zziplib.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o html html zziplib.xml  \
-	; echo     '$(srcdir)/dbk2man.py -o html html zzipmmapped.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o html html zzipmmapped.xml  \
-	; echo     '$(srcdir)/dbk2man.py -o html html zzipfseeko.xml' \
-	; $(PYTHON) $(srcdir)/dbk2man.py -o html html zzipfseeko.xml  \
-	; echo     '$(srcdir)/dir2index.py -o html html ' \
-	; $(PYTHON) $(srcdir)/dir2index.py -o html html   \
+	; echo     '$(srcdir)/tools/dbk2man.py -o html html zziplib.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o html html zziplib.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o html html zzipmmapped.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o html html zzipmmapped.xml  \
+	; echo     '$(srcdir)/tools/dbk2man.py -o html html zzipfseeko.xml' \
+	; $(PYTHON) $(srcdir)/tools/dbk2man.py -o html html zzipfseeko.xml  \
+	; echo     '$(srcdir)/tools/dir2index.py -o html html ' \
+	; $(PYTHON) $(srcdir)/tools/dir2index.py -o html html   \
 	; echo '$(PAX_TAR_CREATE) $@ html/*.*' \
 	;       $(PAX_TAR_CREATE) $@ html/*.*  \
 	; fi ; true
@@ -770,14 +777,16 @@
                $(DESTDIR)$(pkgdocdir)/xml/
 	$(INSTALL_DATA) $(PACKAGE)-man.omf $(DESTDIR)$(pkgomfdir)/
 	- test ".$(DESTDIR)" != "." || scrollkeeper-update -v
-
-# ----------------------------------------------- mksite.sh for the main html
-site.htm : body.htm
-	cp $(srcdir)/body.htm site.htm
-site.html : body.htm site.htm mksite.sh $(htm_FILES) $(htms_FILES)
-	cp $(srcdir)/body.htm site.htm
-	perl $(srcdir)/mksite.pl $(mksite_sh_args) site.htm || \
-	$(SHELL) $(srcdir)/mksite.sh $(mksite_sh_args) site.htm
+site/site.html : body.htm changes.htm mksite.sh $(htm_md_FILES) $(htms_FILES)
+	test -d ${outdir}/site || mkdir -p ${outdir}/site
+	cp $(srcdir)/body.htm ${outdir}/site/site.htm
+	cp $(outdir)/changes.htm ${outdir}/site/changes.htm
+	cp -v ${srcdir}/*.md ${outdir}/site/
+	cp -v ${srcdir}/*.css ${outdir}/site/
+	srcs=`cd ${srcdir} && pwd`; cd ${outdir}/site || exit 1 \
+	; for i in *.md; do ${PYTHON} $${srcs}/tools/md2dbk.py $$i --htm > `basename $$i .md` ; done
+	srcs=`cd ${srcdir} && pwd`; cd ${outdir}/site || exit 1 \
+	; $(SHELL) $${srcs}/mksite.sh $(mksite_sh_args) site.htm
 
 changes.htm : $(top_srcdir)/ChangeLog Makefile 
 	echo "<pre>" > $@ ; cat $(top_srcdir)/ChangeLog \

_service:tar_scm:v0.13.74.tar.gz/docs/README.MD Added

@@ -0,0 +1,56 @@
+## ZZIP Library Documentation
+
+<p style="float:right"><img align="right" src="dir-zzip-192.png" /></p
+
+* Library(zzip-index.htm.md)
+* ZIP Access(zzip-zip.htm.md)
+* Transparently(zzip-file.htm.md)
+* SDLrwops Example(zzip-sdl-rwops.htm.md)
+* ext/io Customization(zzip-extio.htm.md)
+* xor/io Obfuscation(zzip-xor.htm.md)
+* Library API(zzip-api.htm.md)
+* Parsing ZIPs(zzip-parse.htm.md)
+* 64on32(64on32.htm.md)
+* Next To Come(future.htm.md)
+* Config Helpers(configs.htm.md)
+* Making a zip/exe(sfx-make.htm.md)
+* Hints And Links(history.htm.md)
+* Referentials(referentials.htm.md)
+* LGPL/MPL license(copying.htm.md)
+
+
+
+* Functions List(zziplib.html)
+
+
+
+* The Manual Pages(man/index.html)
+
+
+
+<small>derived from <a href="site.htm">site.htm</a></small>
+
+<p align="right">
+     <a href="http://sourceforge.net/project/?group_id=6389">
+        <img src="http://sourceforge.net/sflogo.php?group_id=6389&type=2"
+            border="0" alt="sourceforge.net" width="125" height="37">
+     </a>
+</p>
+
+<a alt="Tarballs, RPM-archive and windll-ZIPs can be downloaded from"
+  href="http://sourceforge.net/project/showfiles.php?group_id=6389">
+ Sourceforge Download Area </a></b><br />
+
+<a alt="Sourceforge Project CVS web access"
+   href="http://zziplib.svn.sourceforge.net/viewvc/zziplib/">Sourceforge SVN</a><br />
+<a alt="Sourceforge Project Index Page"
+   href="http://sourceforge.net/projects/zziplib">Sourceforge Project</a><br />
+<a alt="the zziplib webpage at sourceforge"
+   href="http://zziplib.sourceforge.net"><b>zziplib.sf.net</b>
+  <small><i>Home</i></small></a><br />
+
+
+<p align="right"><small>
+<br> <small>(C)</small> Guido Draheim
+<br><i> guidod<small>@</small>gmx.de</i>
+</p>

_service:tar_scm:v0.13.74.tar.gz/docs/configs.htm.md Added

@@ -0,0 +1,148 @@
+<date> February 2003 </date>
+
+## Configuration 
+of other projects using zziplib
+
+If using the zziplib with other project then you can use a number
+of possibility to configure and link. The zziplib had been usually
+included within the projects that made use of it - some did even
+pick up the advantage to be allowed to staticlink in a limited
+set of conditions. Recently however, the zziplib is shipped as a
+standard library of various linux/freebsd distros - mostly for
+the usage by the php-zip module. This allows third party software
+makers to link to the preinstalled library in the system and
+consequently reduce the memory consumption - even more than now
+with the zziplib being a lightweight anyway (the i386 .so is 
+usually less than 20k)
+
+### pkg-config --libs 
+
+Within modern software development, one should be advised to use
+pkg-config as soon as it is available. The pkg-config helper can
+handle a lot of problems that can usually come up with linking
+to third party libraries in case that those link again dynamically
+with other libraries themselves. It does correctly order the
+list of "libs", it can throw away duplicate "-L" hints, and same
+for cflags "-I" hints, plus it will throw away some sys-includes
+that gcc3.2 will warn about with a false positive.
+
+There is a number of pkg-config targets installed in the system
+but the one you want to use is **pkg-config zziplib**. 
+Therefore, a simple Makefile could read like
+
+```
+PROGRAM = my_prog
+    CFLAGS = -Dhappy `pkg-config zziplib --cflags`
+    LIBS   = -Wl,-E  `pkg-config zziplib --libs`
+
+    my_prog.o : my_prog.c
+       $(CC) $(CFLAGS) $< -o $@
+    my_prog : my_prog.o
+       $(LINK) $< $(LIBS)
+```
+
+The `pkg-config zziplibs --libs` will usually expand to 
+something like `-lzzip -lz` which are the
+two (!!) libraries that you need to link with - in that
+order. The zziplib builds on top of the z-lib algorithms
+for compression of files within the zip-archive. That's
+the same for other lib-parts of the zziplib project as
+well, e.g. the sdl-rwops part which does also need to
+link with the sdl-lib - and that's where the pkg-config
+infrastructure can be of great help. That's the reason
+why zziplib installs a few more ".pc" files, you can
+get a list of them like this:
+
+```
+$ pkg-config --list-all | sort | grep zzip
+   zziplib               zziplib - ZZipLib - libZ-based ZIP-access Library
+   zzip-sdl-config       zzip-sdl-config - SDL Config (for ZZipLib)
+   zzip-sdl-rwops        zzip-sdl-rwops - SDL_rwops for ZZipLib
+   zzipwrap              zzipwrap - Callback Wrappers for ZZipLib
+   zzip-zlib-config      zzip-zlib-config - ZLib Config (for ZZipLib)
+```
+
+The two entries like "zzip-sdl-config" and "zzip-zlib-config"
+happen to be ".pc" files for the libz.so and libSDL.so that
+were seen at configure-time of zziplib - you may want to reuse
+these in your projects as well whenever you need to link to
+either of zlib or libsdl even in places where there is no direct
+need for zziplib. It basically looks like:
+
+```
+$ pkg-config zzip-zlib-config --modversion
+   1.1.4
+   $ pkg-config zzip-zlib-config --libs      
+    -lz
+```
+
+### zzip-config 
+
+The pkg-config ".pc" files are relatively young in the history of
+zziplib. A long time before that there was the `zzip-config`
+script installed in the system. These `*-config` were common
+before the pkg-config came about, and in fact the pkg-config
+infrastructure was invented to flatten away the problems of
+using multiple `*-config` scripts for a project. As long as you
+do not combine multiple `*-config`s then it should be well okay
+to use the `zzip-config` directly - it does also kill another
+dependency on the `pkg-config` tool to build your project, the
+zziplib is all that's needed.
+
+In its call-structure the `zzip-config` script uses the same
+options as `pkg-config`, (well they are historic cousins anyway).
+and that simply means you can replace each call above like
+`pkg-config zziplib...` with `zzip-config...`.
+
+```
+PROGRAM = my_prog
+    CFLAGS = -Dhappy `zzip-config --cflags`
+    LIBS   = -Wl,-E  `zzip-config --libs`
+
+    my_prog.o : my_prog.c
+       $(CC) $(CFLAGS) $< -o $@
+    my_prog : my_prog.o
+       $(LINK) $< $(LIBS)
+```
+
+Be informed that the zzip-config script is low-maintained and
+starting with 2004 it will be replaced with a one-line script 
+that simply reads `pkg-config zziplib $*`. By that time the
+rpm/deb packages will also list "pkgconfig" as a dependency
+on the zziplib-devel/zziplib-dev part.
+
+### autoconf macro 
+
+There is currently an autoconf macro installed along into
+the usual /usr/share/aclocal space for making it easier for
+you to pick up the configure-time cflags/libs needed to
+build/link with zziplib. In any way it does look like
+this:
+
+```
+dnl PKG_CHECK_ZZIPLIB(ZSTUFF, min-version, action-if, action-not)
+  AC_DEFUN(PKG_CHECK_ZZIPLIB,dnl
+  PKG_CHECK_MODULES($1, zziplib $2, $3, $4))
+```
+
+You are strongly advised to take advantage of the pkgconfig's
+macro directly - you can find the macro in
+`/usr/share/aclocal/pkg.m4` and it allows to
+combine the flags of a list of library modules that you
+want to have. If it is only zziplib, than you could simply
+use this in your configure.ac:
+
+```
+ PKG_CHECK_MODULES(ZZIP,zziplib >= 0.10.75)
+```
+
+which will provide you with two autoconf/automake variables
+named **`ZZIP_CFLAGS`** and **`ZZIP_LIBS`** respectively.
+
+Up to 2004, the macro in zziplib.m4 will be however carry
+a copy of the pkg.m4 so that you do not need another
+dependency for your software project. The macro is called
+like shown above PKG_CHECK_ZZIPLIB and you would call it
+like `PKG_CHECK_ZZIPLIB(ZZIP,0.10.75)`  
+which will give you the two autoconf/automake variables
+as well,  `ZZIP_CFLAGS` and `ZZIP_LIBS`

_service:tar_scm:v0.13.74.tar.gz/docs/copying.htm.md Added

@@ -0,0 +1,94 @@
+<date> 2004 </date>
+
+## COPYING - license information 
+the public license terms
+
+The zziplib is a small library that allows for some parts of
+obfuscation. This is very handy in commercial projects which tend
+to incorporate a copy into their source tree. And with 
+obfuscation(zzip-xor.htm) it is often advisable 
+to staticlink the zziplib part and `strip` the symbols from 
+the resulting binary - in order to obfuscate the usage of a 
+standard library for semi-`encryption` of data files.
+
+In the past I have been modifying the original LGPL license
+with a text that allows staticlinking thereby taking over a
+few paragraphs from the MPL as restrictions to do so, just to 
+defend against improper usage. However I kept being asked 
+legalese questions since most people do not want to interpret 
+added text either and on their own without a lawyer. However
+that accounts to me as well.
+
+The public license(s) are simply there to protect me and
+my work, none of this is fixed and it is neither the only 
+possible way to get hold of a proper license. You can 
+always contact me to negotiate a special one if you do 
+need so. In most cases I will just say okay and you get 
+it for free, perhaps after some presentations I will 
+ask for som tax-reductable compensation sent to
+a wellfare organisation (never me!).
+
+A last hint from a friend did make me think as well, as
+that the whole point of using standard public licenses
+is to protect against the need to use your own lawyers
+in the case that someone breaks the license rules. If
+one uses a standard license then it is in the interest
+of that big organization XY that the license will be
+enforced and that it will be shown valid in all courts.
+At the time of writing, no opensource license has
+ever been discussed to an end in a court trial.
+
+That's why at last, I decided to change the COPYING 
+details once again - and start shipping under a dual
+MPL / LGPL license where each of them is separate 
+and restrictions apply alternatively. Remember that 
+each license is non-exclusive anyway, and I can give
+out as many licenses as I want, here we have one as
+MPL, then we have one as LGPL, and perhaps you ask me
+for a third text to send you over. The public ones
+are just there for you as a free choice which you can
+pick without negotiations or a fee.
+
+And yes, you will be on established legal grounds as 
+long as you restrict your usage of the library to the 
+details contained in either COPYING text. And better
+yet, the legal possibilities have been discussed
+a few hundred times before. You will surely find
+good answers on the internet as well to guide you
+to decisions in your company whether zziplib may
+be adopted for a specific task.
+
+The sources themselves are sent out under a dual license, 
+with both MPL and LGPL license options, and as long as 
+the MPL part is  not removed then the recpient of some
+modified sources will be entitled to the same choice
+among the public licenses of LGPL / MPL. Note that some
+example sources are given away under the ZLIB license
+which is nothing more than asking for nice behavior 
+which should have been the case even without such a text.
+
+As for staticlinking, let us explore that a bit - there has 
+been a debate that the LGPL warrants in fact the freedom of 
+the final recipient as you must give him the original or 
+modified sources of zziplib, to allow them to modify that 
+part again, and then (re-)link to your own parts. Your own
+parts may come in the form of precompiled objects without
+sources (as opposed to the GPL restrictions). In here, it
+is simply easier to use a dynamic linker that does the 
+re-linking job at startup-time of the whole project instead 
+to provide a makefile and linkage descriptions to let the
+user do the staticlink it into a combined executable object. 
+The latter however is often needed for embedded environments
+and it is quite of the original motivation to ask for a
+staticlink option where in fact the LGPL does allow it anyway
+as long as you ship all parts separatly as well.
+
+The MPL defines the area of a combined work a bit differently,
+in a way it derives some ideas from BSD'ish licenses. This
+part does more care to protect the `Intellectual Properties`
+of the original developers. It does ask to prominently show 
+off that you have gone to link with the work of someone else 
+in your project. Take special note of *"3.5 Required Notices"*,
+*"3.6 Distribution of Executable Versions"* and
+*"3.7 Larger Works"* here. Or read a lawyer text on
+the legal result of the whole license.

_service:tar_scm:v0.13.74.tar.gz/docs/developer.htm.md Added

@@ -0,0 +1,68 @@
+<date> 2009-08-23 </date>
+
+## Developer 
+sourceforge SVN area
+
+<center>
+<a href="http://zziplib.svn.sourceforge.net/viewvc/zziplib/">
+         http://zziplib.svn.sourceforge.net/viewvc/zziplib/ </a>
+</center>
+
+The zziplib is using the Subversion repository of sourceforge
+for development. (originally it used the cvs service but it
+is now switched over to the svn serivce) Since 0.13.x the zziplib
+is using the version control system as the main area to host
+the source code in the module "zzip-0". You can get a snapshot
+from that area anytime, the access details can be found under the
+link above. All later releases are actually snapshots of some
+cvs day. (Prior releases had seen too many reshuffling of the
+build system which cvs is not the best tool to handle gracefully.
+Since the switch to svn also refactoring can be tracked just fine).
+
+I was using the sourceforge compilefarm to do remote testing of
+releases for crossplatform compatibility. This included usually
+some unix compatible platforms such as Linux, Solaris,
+FreeBSD, Darwin/MacOSX including i386, amd64, sparc, sparc64,
+powerpc when available. Even the latest daytoday cvs snapshots
+should be fine for these platforms. However sourceforge has
+shut down the compilefarm just as HP closed the teamdrive
+service for the public. At the moment I am using the buildservice
+at build.opensuse.org to test multiple platforms atleast with
+the help of a "make check" minimal unittest during the rpmbuild.
+
+In the labs of my former employer some more platforms exist but these
+were only checked once in a few months, mostly summertime and christmas
+season if the general workload is low. That included hp/ux but more
+importantly a real MSVC6 installation and a few PCs with win32 flavours.
+I do not use win32 at home! Any help in that area is greatly appreciated,
+the zziplib was written in strict ansi-C but the build system and dll hell
+is sometimes very weird for win32 platforms. I feel it often requires
+experienced hands to detect the source of a problem should there be one.
+
+Note also that I do not use PHP, there is a regular flow of questions
+circulating around the php-zip module which is built around zziplib. But
+I can not answer any questions about the build and installation for that.
+It would be greatly appreciated if I can find contact to a PHP hacker
+to whom I can forward php related mails! The php zip wrapper is not part
+of the zziplib in any way.
+
+Since there is an MSVC6 system in reach now, I have not been updating my
+gcc/mingw32 installations as rigidly as most other win32 developers
+have. I understand there are great advancements in the msys/mingw32 area
+and the provided technology which made them follow quickly. However in
+the labs only some older releases are used for these are called more
+"stable". Remember that I do not use win32 at home, only crosscompile to
+mingw32 is checked out sometimes but I know that it is somewhat different
+than the selfhosted msys environment. Any help is greatly appreciated.
+
+Lastly, I am trying to make the zziplib as close as possible to the
+  thing called "industrial strength". But remember that this is still
+  an opensource spare time probject. **I take patches**! Many of the
+  interesting parts of zziplib have been introduced by submission which
+  I have later integrated more heavily to make the zziplib be what it
+  was always intended for: to be a small, fast and portable library allowing
+  to use a zip file as a special variant of a data filesystem. The ext/io
+  obfuscation stuff was one of the best feature submissions so far. Thanks.
+
+Looking forward to hear from *YOU*.
+  - guidod@gmx.de(mailto:guidod@gmx.de?subject=zzip:)

_service:tar_scm:v0.13.74.tar.gz/docs/download.htm.md Added

@@ -0,0 +1,48 @@
+<date> 2004-05-18 </date>
+
+## Download 
+what to get to get it
+
+#### Sourceforge File Area
+
+<center>
+<a href="http://sourceforge.net/project/showfiles.php?group_id=6389">
+                sourceforge.net/project/showfiles.php?group_id=6389 </a>
+</center>
+
+All source releases and some binary releases are listed at the
+sourceforge download area under the link show above. The sourceforge
+file area is replicated all over the world and should be accessible
+with highest bandwidth in all corners of the world.
+
+#### Which Version To Download 
+
+Do not use 0.10.x anymore! It is listed as stable since it is the
+only release of zziplib tested to work on a few dozen platforms.
+However there were some problematic zip files out there that can
+trigger segfaults. Later zzip file decoders have extra checks and
+helper routines for that. It's just that the later zziplib have not
+been given as many crossplatform build tets as the 0.10.x generation.
+
+Use a 0.12.x (proto-stable) or a 0.13.x (developer) variant of 
+zziplib, especially if you intend to make heavy usage of the zip
+decoders in specialized environments - I will not add any fixes to
+the 0.10.x series anymore (it's deep frozen) but if you hit a 
+problem with 0.13.x I can help you quickly with a patch and official
+bugfix release. The later versions are regulary checked crossplatform
+atleast for **Linux, Solaris, FreeBSD, Darwin/MacOSX, Win32/NT** 
+including i386, amd64, sparc, sparc64, powerpc where available.
+
+Note that all generations 0.10.x through 0.13.x are strictly
+**backward compatible**. There is a core API (file and dir
+handling) being binary compatible, which is also true for most
+of the helper routines (data getters). Only some rarely used
+entries are made source level compatible, and so far no one had 
+ever any problem with binary compatibility of the zziplib DLLs.
+
+The MSVC users are strongly advised to use a a later version as
+well since I have tested the 0.12.x/0.13.x myself and making
+some msc binary dll releases directly - prior versions were 
+thirdparty contributions which were working smoothly since I have 
+been preparing zziplib for win32 using the gcc/mingw compile suite.
+Please check also the developer pages(developer.html).

_service:tar_scm:v0.13.74.tar.gz/docs/faq.htm.md Added

@@ -0,0 +1,177 @@
+<date> 2004 </date>
+
+## FAQ 
+(non)frequently asked questions
+
+> While using the zziplib some people come up with questions and
+> problems that need a little longer to be explained. So here is
+> a list of these notes for your information. Keep it up.
+
+* extended ascii characters in names of zipped files (#latin-1)
+* unicode support for names of zipped files (#utf-8)
+* timestamps of zipped files (#timestamps)
+* installation instructions (#install)
+* php zip module installation (#php)
+* commercial support (#license)
+
+latin-1:
+
+#### zziplib does not support extended ascii characaters, winzip does
+
+  That's somehow incorrect - the ascii range is the 7bit lower plane of
+  an 8bit character encoding. The upper plane had been non-standard for
+  decades including the age when the ZIP file format was invented. The
+  first instances of pkware's zip compressor were used on DOS with a 
+  codepage 437 which has a way different encoding for the upper plane
+  than today's latin-1 encoding which in fact used in **all**
+  modern operating systems. So what really see is a mismatch of 
+  character encodings that you are used to.
+
+  Even more than that the character encoding had never been specified
+  at all for the filenames in the central directory part. An alert
+  reader will however recognize that **each** file entry does
+  also have version-info field telling about the compressor that did
+  create the file entry. That version-info has an upper byte telling
+  about the host OS being in use while packaging. A heavy-weight
+  zip decoder might use that value to infer the character encoding
+  on the host OS (while compressing), to detect a mismatch to the
+  current OS (while decompressing), and going to re-code the filename
+  accordingly.
+
+  Even more than that the zip file format has seen various extensions
+  over time that have found their place in an extra info block. There
+  are info blocks telling more about the filename / codeset. However
+  the zziplib library does not even attempt to decode a single extra
+  info block as zziplib is originally meant to be a light-weight library.
+  However one might want to put a layer on top of the structure decoding 
+  of zziplib that does the necessary detection of character encodings and
+  re-coding of name entries. Such a layer has not been written so far.
+
+utf-8:
+
+#### zziplib does not support any unicode plane for filenames :
+
+  The pkware's appnote.text has an extra info block (id-8) for the
+  unicode name of the file entry but it was never actually being 
+  used AFAICS. This might be related to the current developments of
+  older systems to drop usage of latin-1 encoding in the upper plane
+  of 8bit characters and instead choosing the multibyte encoding
+  according to UTF-8. This is again highly system specific.
+
+  Basically, you would need to instruct the compressor to use 
+  UTF-8 encoding for the file-entries to arrive at a zip archive 
+  with filenames in that specific character encoding. Along with
+  this zip archive one can switch the application into utf-8 usage
+  as well and take advantage of filename matches in that encoding.
+  This will make it so there is not mismatch in character encoding
+  and implicit re-coding being needed.
+
+timestamps:
+
+#### zziplib does not return stat values for file timestamps :
+
+  That's correct and again a re-coding problem. The original
+  timestamp in each file entry is in DOS format (i.e. old-FAT).
+  The stat value is usually expected to be in POSIX format. The
+  win32 API has an extra function for conversion but none of the
+  unix compatibles has one, so it would be needed to ship a
+  conversion function along with zziplib.
+
+  However the zziplib is intended to be light-weight system and
+  used largely for packaging data for an application. There it
+  is not used strictly as a variant of Virtual File System (vfs)
+  that would need to map any information from the zip file system
+  to native host system. Of course applications are free to cut
+  out the DOS file timestamp and re-code it on their own. It's
+  ust that zziplib does not provide that re-coding originally.
+
+install:
+
+#### how can one install the zziplib package
+
+  The zziplib project is opensource which effectly gives two ways of
+  installing the package: one can download the source archive and use
+  a C compiler to derive a binary executable for whatever computer
+  it needs to be on (see the platform compatibility list). This is
+  the preferred way but for convenience one can download a binary
+  installation archive with precompiled executables.
+
+  The current project uses autoconf/automake for cross platform
+  support which includes most unix compatible systems and their
+  native C compilers. The derivates of the GNU C compiler (gcc) have 
+  replaced most of these native C compilers in the past years. The
+  <a href="http://www.mingw.org">mingw32</a> project has ported a
+  unix born C compiler to win32 and zziplib can be compiled with
+  it for the various win32 platforms.
+
+  There exist some C compilers which can not be embedded easily into 
+  a unix compilation framework. The zziplib source archive ships with
+  project files for MSVC6 and MSVC6 (Microsoft Visual C). Adapting
+  these project files might help with installation problems of the
+  DLL hell on win32 platforms. There exist no sufficient guidelines to
+  mix binary helper libraries for many applications on windows.
+
+  There exists win32 binary archives as zip files on the download area
+  of zziplib (MSI is always on my wishlist). Including the project as
+  a helper library however you should not use it but instead compile
+  from source. The general library installation on unix are better, 
+  the zziplib download area contains regularly some linux binary
+  archives (rpm). Many vendors of unix compatible systems provide 
+  precompiled binary packages of zziplib on their own.
+
+php:
+
+#### after installing zziplib the php zip module still does not work
+
+  Now that is one of <b>the most</b> frequently asked questions that
+  I do receive. There is just one major problem with it: I did not
+  write the php zip module (which uses zziplib) and I have no idea
+  how php modules work or how to tell apache's php sandbox to make
+  it work. Really, I do not have the slightest clue on that.
+
+  I was posting to some php developer sites to spread awareness of
+  the fact and hopefully to find a guy that I could forward any
+  questions on the php zip module installation. But so far there is
+  nothing, it merily seems that such installation problems are in no
+  way related to zziplib anyway but exists <b>with any other module with a 
+  third party library dependency</b> as well. So the answers on php forum 
+  sites will ask for details of the current php and apache configuration.
+
+  Since I do not run a php zip whatever nor any other php stuff, it's
+  just that those hints were not quite helpful to me. It would be really 
+  really great if someone with a php zip background could be so nice to
+  write a short roundup of the areas to check when a php zip module
+  installation fails, so that I could post it here. Where are you?
+  Yours desperatly...&nbsp;;-)
+
+license:
+
+#### how to obtain a license and support contract for a commercial project
+
+  The zziplib has been created as a spare time project and it is put
+  under a very easy free public license. Even for commercial projects
+  there is hardly any need to negotiate a separate license since the
+  restrictions of the GNU LGPL or MPL can be matched easily. As a
+  general hint, if the zziplib is shipped unmodified with your project
+  then you are right within the limits of the free public license.
+
+  Sometimes the question for a personal license comes up for very
+  different reason - the need for a support contract and/or the setting
+  of functionality guarantees. The free public licenses include a safeguard
+  clause to that end, "in the hope that it will be useful,
+  but <em>without any warranty</em>; without even the implied warranty of
+  <em>merchantability</em> or <em>fitness for a particular purpose</em>."
+  Since the project was developed as a spare time project however there
+  have never been personal licenses going beyond.
+
+  In general you can still try to negotiate a support contract but it
+  will be very costly. It is much more profitable for you to tell one
+  of your developers to have a look at the source code and ensure the
+  required functionality is there, with hands on. The source code is 
+  written to be very readable, maintainable and extensible. Just be
+  reminded that the free public licenses have restrictions on shipping
+  modified binaries but I can give you a cheap personal license to
+  escape these. (Such licenses can be obtained in return for tax-deductible
+  donations to organisations supporting opensource software).
+
+... and as always - ** Patches are welcome ** -

_service:tar_scm:v0.13.74.tar.gz/docs/fseeko.htm.md Added

@@ -0,0 +1,176 @@
+<date> 2005 </date>
+
+## zzip/fseeko 
+zip access for stdio handle
+
+  These routines are fully independent from the traditional zzip
+  implementation. They assume a readonly seekable stdio handle
+  representing a complete zip file. The functions show how to 
+  parse the structure, find files and return a decoded bytestream.
+
+### stdio disk handle 
+
+  Other than with the mmapped(mmapped.html) alternative
+  interface there is no need to build special handle for the zip
+  disk file. The normal stdio file handle (of type **`FILE`**)
+  serves as the disk access representation. You can open that stdio file
+  handle any way you want. Note however that the `zzipfseeko` 
+  routines modify the access state of that file handle, especially the
+  read position.
+
+  To get access to a zipped file, you need a zip archive entry known 
+  under the type `ZZIP_ENTRY`. This is again modelled after
+  the `DIR_ENTRY` type in being a representation of a file
+  name inside the zip central directory. To get a fresh zzip entry, use
+  `zzip_entry_findfirst`, to get the next use 
+  `zzip_entry_findnext`, and do not forget to free the
+  resource with `zzip_entry_free`.
+
+```
+extern ZZIP_ENTRY* zzip_entry_findfirst(FILE* disk);
+   extern ZZIP_ENTRY* zzip_entry_findnext(ZZIP_ENTRY*  entry);
+   extern int         zzip_entry_free(ZZIP_ENTRY* entry);
+```
+
+  These three calls will allow to walk all zip archive members in the
+  order listed in the zip central directory. To actually implement a
+  directory lister ("zzipdir"), you need to get the name string of the
+  zzip entry. This is not just a pointer: the zzip disk entry is not
+  null terminated actually. Therefore we have a helper function that
+  will `strdup` the entry name as a normal C string:
+
+```
+#include <zzip/fseeko.h>
+  void _zzip_dir(FILE* disk)
+  {
+      for (ZZIP_ENTRY* entry = zzip_findfirst (disk);
+           entry ; entry = zzip_findnext (entry)) {
+          char* name = zzip_entry_strdup_name (entry);
+          puts (name); free (name);
+      }
+  }
+```
+
+### find a zipped file 
+
+The central directory walk can be used to find any file in the
+  zip archive. The `zzipfseeko` library however provides
+  two convenience functions that allow to jump directly to the
+  zip disk entry of a given name or pattern. You are free to use
+  the newly allocated `ZZIP_ENTRY` for later calls on
+  that handle type. Do not forget to `zzip_entry_free` 
+  the handle unless the handle is consumed by a routine, e.g. 
+  `zzip_entry_findnext` to hit the end of directory.
+
+```
+  extern ZZIP_ENTRY* zzip_entry_findfile(FILE* disk, char* filename, 
+                                         ZZIP_ENTRY* _zzip_restrict entry, 
+                                         zzip_strcmp_fn_t compare);
+
+  extern ZZIP_ENTRY* zzip_entry_findmatch(FILE* disk, char* filespec, 
+                                         ZZIP_ENTRY* _zzip_restrict entry,
+                                         zzip_fnmatch_fn_t compare, int flags);
+```
+
+In general only the first two arguments are non-null pointing to the
+  stdio disk handle and the file name to look for. The "entry" argument
+  is an old value and allows you to walk the zip directory similar to
+  `zzip_entry_findnext` but actually leaping forward. The
+  compare function can be used for alternate match behavior: the default
+  of `strcmp` might be changed to `strncmp` for
+  a caseless match. The "flags" of the second call are forwarded to the
+  posix `fnmatch` which we use as the default function.
+
+If you do know a specific filename then you can just use 
+  `zzip_entry_findfile` and supply the return value to
+  `zzip_entry_fopen` with the second argument set to "1"
+  to tell the function to actually consume whichever entry was given.
+  That allows you to skip an explicit `zzip_entry_free` 
+  as it is included in a later `zzip_entry_fclose`.
+
+```
+  #include <zzip/fseeko.h>
+
+       /* zzipfseeko already exports this convenience function: */
+  ZZIP_ENTRY_FILE* zzip_entry_ffile(FILE* disk, char* filename) {
+      return zzip_entry_fopen (zzip_entry_findfile (filename, 0, 0), 1);
+  }
+
+  int _zzip_read(FILE* disk, char* filename, void* buffer, int bytes)
+  {
+      ZZIP_ENTRY_FILE* file = zzip_entry_ffile (disk, filename);
+      if (! file) return -1;
+      int bytes = zzip_entry_fread (buffer, 1, bytes, file);
+      zzip_entry_fclose (file);
+      return bytes;
+  }
+```
+
+### reading bytes 
+
+The example has shown already how to read some bytes off the head of
+  a zipped file. In general the zzipfseeko api is used to replace a few
+  stdio routines that access a file. For that purpose we provide three 
+  functions that look very similar to the stdio functions of 
+  `fopen()`, `fread()` and `fclose()`.
+  These work on an active file descriptor of type `ZZIP_ENTRY_FILE`.
+  Note that this `zzip_entry_fopen()` uses `ZZIP_ENTRY` 
+  argument as returned by the findfile api. To open a new reader handle from 
+  a disk archive and file name you can use the `zzip_entry_ffile()` 
+  convenience call.
+
+```
+ZZIP_ENTRY_FILE* zzip_entry_ffile  (FILE* disk, char* filename);
+   ZZIP_ENTRY_FILE* zzip_entry_fopen  (ZZIP_ENTRY* entry, int takeover);
+   zzip_size_t      zzip_entry_fread  (void* ptr, 
+                                       zzip_size_t sized, zzip_size_t nmemb,
+                                       ZZIP_ENTRY_FILE* file);
+   int              zzip_entry_fclose (ZZIP_ENTRY_FILE* file);
+   int              zzip_entry_feof   (ZZIP_ENTRY_FILE* file);
+```
+
+In all of the examples you need to remember that you provide a single
+  stdio `FILE` descriptor which is in reality a virtual
+  filesystem on its own. Per default filenames are matched case
+  sensitive also on win32 systems. The findnext function will walk all
+  files on the zip virtual filesystem table and return a name entry 
+  with the full pathname, i.e. including any directory names to the
+  root of the zip disk `FILE`.
+
+### ZZIP_ENTRY inspection 
+
+The `ZZIP_ENTRY_FILE` is a special file descriptor handle 
+  of the `zzipfseeko` library - but the `ZZIP_ENTRY`  
+  is not so special. It is actually a bytewise copy of the data inside the
+  zip disk archive (plus some internal hints appended). While 
+  `zzip/fseeko.h` will not reveal the structure on its own, 
+  you can include `zzip/format.h` to get access to the actual 
+  structure content of a `ZZIP_ENTRY` by (up)casting it to  \
+  **`struct zzip_disk_entry`**.
+
+In reality however it is not a good idea to actually read the bytes
+  in the `zzip_disk_entry` structure unless you seriously know
+  the internals of a zip archive entry. That includes any byteswapping
+  needed on bigendian platforms. Instead you want to take advantage of
+  helper macros defined in `zzip/fetch.h`. These will take
+  care to convert any struct data member to the host native format.
+
+```
+extern uint16_t    zzip_disk_entry_get_flags( zzip_disk_entry* entry);
+extern uint16_t    zzip_disk_entry_get_compr( zzip_disk_entry* entry);
+extern uint32_t    zzip_disk_entry_get_crc32( zzip_disk_entry* entry);
+
+extern zzip_size_t zzip_disk_entry_csize( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_usize( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_namlen( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_extras( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_comment( zzip_disk_entry* entry);
+extern int         zzip_disk_entry_diskstart( zzip_disk_entry* entry);
+extern int         zzip_disk_entry_filetype( zzip_disk_entry* entry);
+extern int         zzip_disk_entry_filemode( zzip_disk_entry* entry);
+
+extern zzip_off_t  zzip_disk_entry_fileoffset( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_sizeof_tail( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_sizeto_end( zzip_disk_entry* entry);
+extern char*       zzip_disk_entry_skipto_end( zzip_disk_entry* entry);
+```

_service:tar_scm:v0.13.74.tar.gz/docs/functions.htm.md Added

_service:tar_scm:v0.13.74.tar.gz/docs/future.htm.md Added

@@ -0,0 +1,69 @@
+<date> 15. July 2002 </date>
+
+## ZZIP Future 
+What next to come.
+
+
+
+### ZIP-Write 
+
+Anybody out there who wants to program the write-support for the
+zziplib? Actually, I just do not have the time to do it and no
+real need to but I guess it would be nice for people as for
+example to spit out savegame files in zipformat. The actual
+programming path is almost obvious - start off with the zziplib
+as it is, and let it open an existing zip-file. This will parse
+the central directory into memory - including the file-offsets
+for each file. Then, truncate the zip-realfile to the place that
+the central-dir was found (identical with the end of the last
+file). If a datafile is opened for writing, either add a new
+entry or modify the start-offset of the existing entry to the
+end of the zip-realfile - the old data is simply junk. Then
+init zlib to do the deflation of the data and append it to the
+current zip-realfile. When the zipdir-handle is getting closed
+from write-mode, the zip's central-directory needs to be appended
+to the file on disk. This coincides with creating a new zip-file 
+with an empty central-directory that can be spit out to disk.
+During development, do not care about creating temp-files to
+guard against corruption for partial writes - the usual application
+will use the zziplib to create zip savegames in one turn, no
+"update"-operation needs to be implemented like exists in the
+standalone zip command utilities.
+
+### readdir for subdir inside zip magicdir 
+
+See the notes in the first paragraphs of 
+  ZZIP Programmers Interface(zzip-api.html) description. It would add some
+  complexity for something I never needed so far. The question
+  came up with using zziplib as the backend of a dynamic webserver
+  to store the content in compressed form possibly through the
+  incarnation of a php module - and some scripted functionality
+  that walks all directories to index the files hosted. I'm not
+  going to implement that myself but perhaps someone else wants
+  to do it and send me patches for free.
+
+### obfuscation example project 
+
+A subproject that shows **all** the steps from a dat-tree
+  to a dat-zip to an obfuscated-dat along with build-files and
+  source-files for all helper tools needed to obfuscate and
+  deobfuscate, plus a sample program to use the obfuscated 
+  dat-file and make some use of it. Along with some extra 
+  documentation about 20..40 hours. Don't underestimate the
+  amount of work for it! (otherwise a great student project).
+
+### zip/unzip tool 
+
+The infozip tools implement a full set of zip/unzip routines
+based on internal code to access the zip-format. The zziplib
+has its own set of zip-format routines. Still, it should be
+possible to write a frontend to the library that implements 
+parts (if not all) of the options of the infozip zip/unzip 
+tools. Even without write-support in zziplib it would be
+interesting to see an normal unzip-tool that does not use
+the magic-wrappers thereby only going off at plain zip-files.
+On the upside, such a tool would be smaller than the infozip
+tools since it can use the library routines that are shared
+with other tools as well. Again - don't underestimate the
+amount of work for it, I guess 40..80 hours as there is a lot
+of fine-tuning needed to match the infozip model.

_service:tar_scm:v0.13.74.tar.gz/docs/history.htm.md Added

@@ -0,0 +1,62 @@
+<date>created 1.Jun.2000, last updated 25.Apr.2002 </date>
+
+## History and Links 
+plus Installation and Contact Hints
+
+### A Bit Of History 
+
+You'll find gzip(http://www.gzip.org) using the same compression 
+that was written by Jean-loup Gailly(http://gailly.net)for the Info-Zip(http://www.info-zip.org) Group
+whose Zip(http://www.info-zip.org/pub/infozip/Zip.html)program is compatible with msdos PKZIP program from PK&nbsp;Ware(http://www.pkware.com). Then, in collaboration
+with Mark Adler(http://www.alumni.caltech.edu/~madler)he wrote the zlib(http://www.gzip.org/zlib)compression library which was later standardized in the 
+zlib RFCs(ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html), namelyRFC 1950(http://www.ietf.org/rfc/rfc1950.txt)
+zlib&nbsp;3.3(ftp://ftp.uu.net/graphics/png/documents/zlib/rfc-zlib.html.Z),RFC 1951(http://www.ietf.org/rfc/rfc1951.txt)
+deflate&nbsp;1.3(ftp://ftp.uu.net/graphics/png/documents/zlib/rfc-deflate.html.Z) andRFC 1952(http://www.ietf.org/rfc/rfc1952.txt)
+gzip&nbsp;4.3(ftp://ftp.uu.net/graphics/png/documents/zlib/rfc-gzip.html). The free algorithm can be found in lots of places
+today including PPP packet compression and PNG picture compression.
+
+### Installation 
+
+The installation is from the source .tar.gz tarball does follow
+ the simple gnu style: type `''configure  && make install''` 
+ in the unpacked directory. This will actually perform the usual 
+ sequence of `''configure && make && make install''`. The
+ use of `''make rpm''` will make rpms based on your system
+ setup, and using a decent mingw32 compiler (e.g. the crossgcc
+ from libsdl.org/Xmingw32(http://libsdl.org/Xmingw32))
+ will allow you to create windows dlls using a gnu development
+ environment. MSVC and Borland support (Make-)files should be
+ easy to be derived from the Makefile.am(Makefile.am)
+
+### Contact 
+
+The library was developed by 
+ 
+ Guido Draheim (mailto:guidod@gmx.de?subject=zziplib) based on the library 
+ `zip08x`(http://freshmeat.net/appindex/1999/08/02/933593367.html) 
+ by  Tomi Ollila (mailto:too@iki.fi) (many thanks
+ for his support of the zziplib project). He has provided 
+ a good deal of testing rounds and very helpful comments. 
+ It may be assumed that this library supersedes 
+ `zip08x`(http://www.iki.fi/too/sw/zip08x.readme), and in April 2002, he 
+ has even given up copyright restrictions coming from zip08x
+ and changed the zip08x(http://www.iki.fi/too/sw/zip08x.readme) 
+ readme to point to zziplib(http://zziplib.sf.net).
+ Anyone who wants to contribute in accessing zip-archives
+ with the zlib-library is hereby kindly invited to send us
+ comments and sourcecode.
+
+### Links 
+
+The zziplib library(zziplib.html) must be
+linked with the free **zlib(http://www.gzip.org/zlib/)**
+1(http://www.info-zip.org/pub/infozip/zlib)
+2(http://www.lifl.fr/PRIVATE/Manuals/gnulang/zlib)
+3(http://pobox.com/~newt) package originally developed 
+by the Info-Zip(http://www.info-zip.org) Group
+and now maintained at the GZip(http://www.gzip.org) Group.
+As of late, the pkware appnote.txt has been revised into a whitepaper
+document named
+    "APPNOTE.TXT - .ZIP File Format Specification"(http://www.pkware.com/products/enterprise/white_papers/appnote.html).
+Be also aware of other zzip like projects, e.g. zipios++(http://zipios.sourceforge.net) that
+mangles zip access into C++ iostream facilities.

_service:tar_scm:v0.13.74.tar.gz/docs/memdisk.htm.md Added

@@ -0,0 +1,108 @@
+<date> 2005 </date>
+
+## zzip/memdisk 
+zip cache for mmapped views
+
+>   These routines are fully independent from the traditional zzip
+>   implementation. They build on top of 
+>   zzip/mmapped(mmapped.html) that uses a readonly
+>   mmapped sharedmem block. These functions add additional hints
+>   how to parse extension blocks and how to cache the zip central
+>   directory entries which does furthermore allow to convert them
+>   to any host-local format as required.
+
+### zzip disk handle 
+
+Other than with the fseeko(fseeko.html) alternative
+  interface there is no need to have an actual disk handle to the
+  zip archive. Instead you can use a bytewise copy of a file or
+  even use a mmapped view of a file. This is generally the fastest
+  way to get to the data contained in a zipped file. All it requires
+  is enough of virtual memory space but a desktop computer with a
+  a modern operating system will easily take care of that.
+
+The zzipmmapped library provides a number of calls to create a
+  disk handle representing a zip archive in virtual memory. Per
+  default we use the sys/mmap.h (or MappedView) functionality
+  of the operating system. See for more details in the
+   zzip/mmapped(mmapped.html) descriptions.
+
+The zzip/memdisk extensions of zzip/mmapped are made to have a
+  very similar call API - therefore you will find again open and
+  close functions for filenames or filehandles. However the 
+  direct mmap interface is not re-exported under the zzip_mem_disk
+  prefix (of the underlying zzip_disk prefix). The "_mem_" part
+  hints that the central directory of the underlying zzip_disk
+  is preparsed to a separate memory block.
+
+```
+ZZIP_MEM_DISK*  zzip_mem_disk_open(char* filename);
+  ZZIP_MEM_DISK*  zzip_mem_disk_fdopen(int fd);
+  void            zzip_mem_disk_close(ZZIP_MEM_DISK* disk);
+
+  int  zzip_mem_disk_load (ZZIP_MEM_DISK* dir, ZZIP_DISK* disk);
+  void zzip_mem_disk_unload (ZZIP_MEM_DISK* dir);
+```
+
+  The last two functions export some parts of the underlying
+  interface. It is possible to bind an existing ZZIP_MEM_DISK
+  handle with an arbitrary ZZIP_DISK handle. Upon calling "load"
+  the central directory will be loaded from the underlying zip
+  disk content and parsed to an internal mem block. The corresponding
+  "unload" function will trash that central directory cache but it
+  leaves the handles intact.
+
+### reading the central directory 
+
+All other zzip_mem_disk functions are simply re-exporting the
+underlying zzip_disk functions. Note that the first field in
+the ZZIP_MEM_DISK is a "ZZIP_DISK* disk" - the header file
+zzip/memdisk.h will simply export inline functions where there
+is no special zzip_mem_disk function. Therefore, whenever a
+function call on a ZZIP_DISK handle is appropriate one can
+also use its cousin for a ZZIP_MEM_DISK handle without any
+penalties but future compatibility for extra functionality in
+zzip/memdisk layer of the zzip/mmapped library.
+
+<small>Note: by default the re-exports are done with the help
+  of the C precompiler as precompiler macros. Using USE_INLINE
+  will force to make them real inlines. In the future that may
+  change in favor of a better autodetection for inline capabilities
+  of the compiler and/or using a standard cpp-define that enables
+  the C/C++ inline functions. The inline functions do have the
+  added value of having strongtyped arguments provoking more
+  readable warning messages in user application code.</small>
+
+```
+inline ZZIP_DISK_ENTRY*
+zzip_mem_disk_findfirst(ZZIP_MEM_DISK* dir);
+     inline ZZIP_DISK_ENTRY*
+zzip_mem_disk_findnext(ZZIP_MEM_DISK* dir, ZZIP_DISK_ENTRY* entry);
+     inline char* _zzip_restrict
+zzip_mem_disk_entry_strdup_name(ZZIP_MEM_DISK* dir, 
+                                ZZIP_DISK_ENTRY* entry);
+     inline struct zzip_file_header*
+zzip_mem_disk_entry_to_file_header(ZZIP_MEM_DISK* dir, 
+				   ZZIP_DISK_ENTRY* entry);
+     inline char*
+zzip_mem_disk_entry_to_data(ZZIP_MEM_DISK* dir, ZZIP_DISK_ENTRY* entry);
+     inline ZZIP_DISK_ENTRY*
+zzip_mem_disk_findfile(ZZIP_MEM_DISK* dir, 
+                       char* filename, ZZIP_DISK_ENTRY* after,
+		       zzip_strcmp_fn_t compare);
+     inline ZZIP_DISK_ENTRY*
+zzip_mem_disk_findmatch(ZZIP_MEM_DISK* dir, 
+                        char* filespec, ZZIP_DISK_ENTRY* after,
+			zzip_fnmatch_fn_t compare, int flags);
+     inline ZZIP_DISK_FILE* _zzip_restrict
+zzip_mem_disk_entry_fopen (ZZIP_MEM_DISK* dir, ZZIP_DISK_ENTRY* entry);
+     inline ZZIP_DISK_FILE* _zzip_restrict
+zzip_mem_disk_fopen (ZZIP_MEM_DISK* dir, char* filename);
+     inline _zzip_size_t
+zzip_mem_disk_fread (void* ptr, _zzip_size_t size, _zzip_size_t nmemb,
+                     ZZIP_DISK_FILE* file);
+     inline int
+zzip_mem_disk_fclose (ZZIP_DISK_FILE* file);
+     inline int
+zzip_mem_disk_feof (ZZIP_DISK_FILE* file);
+```

_service:tar_scm:v0.13.72.tar.gz/docs/mksite.sh -> _service:tar_scm:v0.13.74.tar.gz/docs/mksite.sh Changed

_service:tar_scm:v0.13.74.tar.gz/docs/mmapped.htm.md Added

@@ -0,0 +1,204 @@
+<date> 2005 </date>
+
+## zzip/mmapped 
+zip access for mmapped views
+
+> These routines are fully independent from the traditional zzip
+> implementation. They assume a readonly mmapped sharedmem block
+> representing a complete zip file. The functions show how to 
+> parse the structure, find files and return a decoded bytestream.
+
+### zzip disk handle 
+
+Other than with the fseeko(fseeko.html) alternative
+  interface there is no need to have an actual disk handle to the
+  zip archive. Instead you can use a bytewise copy of a file or
+  even use a mmapped view of a file. This is generally the fastest
+  way to get to the data contained in a zipped file. All it requires
+  is enough of virtual memory space but a desktop computer with a
+  a modern operating system will easily take care of that.
+
+The zzipmmapped library provides a number of calls to create a
+  disk handle representing a zip archive in virtual memory. Per
+  default we use the sys/mmap.h (or MappedView) functionality
+  of the operating system. The `zzip_disk_open` will
+  open a system file descriptor and try to `zzip_disk_mmap`  
+  the complete zip content. When finished with the zip archive
+  call `zzip_disk_close` to release the mapped view
+  and all management data.
+
+```
+ZZIP_DISK*  zzip_disk_open(char* filename);
+  int         zzip_disk_close(ZZIP_DISK* disk);
+
+  ZZIP_DISK*  zzip_disk_new(void);
+  ZZIP_DISK*  zzip_disk_mmap(int fd);
+  int         zzip_disk_munmap(ZZIP_DISK* disk);
+  int         zzip_disk_init(ZZIP_DISK* disk, 
+                            char* buffer, zzip_size_t buflen);
+```
+
+### reading the central directory 
+
+To get access to a zipped file, you need a pointer to an entry in the
+  mmapped zip disk known  under the type `ZZIP_DISK_ENTRY`. 
+  This is again modelled after the `DIR_ENTRY` type in being 
+  a representation of a file name inside the zip central directory. To 
+  get an initial zzip disk entry pointer, use `zzip_disk_findfirst`,
+  to move the pointer to the next entry use `zzip_disk_findnext`.
+
+```
+extern ZZIP_ENTRY* zzip_disk_findfirst(FILE* disk);
+   extern ZZIP_ENTRY* zzip_disk_findnext(ZZIP_ENTRY*  entry);
+```
+
+These two calls will allow to walk all zip archive members in the
+  order listed in the zip central directory. To actually implement a
+  directory lister ("zzipdir"), you need to get the name string of the
+  zzip entry. This is not just a pointer: the zzip disk entry is not
+  null terminated actually. Therefore we have a helper function that
+  will `strdup` the entry name as a normal C string:
+
+```
+  #include <zzip/mmapped.h>
+  void _zzip_dir(char* filename)
+  {
+      ZZIP_DISK* disk = zzip_disk_open (filename);
+      if (! disk) return disk;
+      for (ZZIP_DISK_ENTRY* entry = zzip_disk_findfirst (disk);
+           entry ; entry = zzip_disk_findnext (entry)) {
+          char* name = zzip_disk_entry_strdup_name (entry);
+          puts (name); free (name);
+      }
+  }
+```
+
+### find a zipped file 
+
+The central directory walk can be used to find any file in the
+  zip archive. The `zzipfseeko` library however provides
+  two convenience functions that allow to jump directly to the
+  zip disk entry of a given name or pattern. You are free to use
+  the returned `ZZIP_DISK_ENTRY` pointer for later calls
+  that type. There is no need to free this pointer as it is really
+  a pointer into the mmapped area of the `ZZIP_DISK`.
+  But do not forget to free that one via `zzip_disk_close`.
+
+```
+ZZIP_DISK_ENTRY* zzip_disk_findfile(ZZIP_DISK* disk, char* filename, 
+                                      ZZIP_DISK_ENTRY* after, 
+                                      zzip_strcmp_fn_t compare);
+
+  ZZIP_DISK_ENTRY* zzip_disk_findmatch(ZZIP_DISK* disk, char* filespec, 
+                                       ZZIP_ENTRY* after,
+                                       zzip_fnmatch_fn_t compare, int flags);
+```
+
+In general only the first two arguments are non-null pointing to the
+  zip disk handle and the file name to look for. The "after" argument
+  is an old value and allows you to walk the zip directory similar to
+  `zzip_disk_entry_findnext` but actually leaping forward. The
+  compare function can be used for alternate match behavior: the default
+  of `strcmp` might be changed to `strncmp` for
+  a caseless match. The "flags" of the second call are forwarded to the
+  posix `fnmatch` which we use as the default function.
+
+If you do know a specific zzipped filename then you can just use 
+  `zzip_disk_entry_findfile` and supply the return value to
+  `zzip_disk_entry_fopen`. There is a convenience function 
+  `zzip_disk_fopen` that will do just that and therefore
+  only requires a disk handle and a filename to find-n-open.
+
+```
+  #include <zzip/mmapped.h>
+
+  int _zzip_read(ZZIP_DISK* disk, char* filename, void* buffer, int bytes)
+  {
+      ZZIP_DISK_FILE* file = zzip_disk_fopen (disk, filename);
+      if (! file) return -1;
+      int bytes = zzip_disk_fread (buffer, 1, bytes, file);
+      zzip_disk_fclose (file);
+      return bytes;
+  }
+```
+
+### reading bytes 
+
+The example has shown already how to read some bytes off the head of
+  a zipped file. In general the zzipmmapped api is used to replace a few
+  system file routines that access a file. For that purpose we provide three 
+  functions that look very similar to the stdio functions of 
+  `fopen()`, `fread()` and `fclose()`.
+  These work on an active file descriptor of type `ZZIP_DISK_FILE`.
+
+```
+ZZIP_DISK_FILE* zzip_disk_entry_fopen  (ZZIP_DISK* disk, 
+                                           ZZIP_DISK_ENTRY* entry);
+   ZZIP_DISK_FILE* zzip_disk_fopen  (ZZIP_DISK* disk, char* filename);
+   zzip_size_t     zzip_disk_fread  (void* ptr, 
+                                     zzip_size_t sized, zzip_size_t nmemb,
+                                     ZZIP_DISK_FILE* file);
+   int             zzip_disk_fclose (ZZIP_DISK_FILE* file);
+   int             zzip_disk_feof   (ZZIP_DISK_FILE* file);
+```
+
+In all of the examples you need to remember that you provide a single
+  `ZZIP_DISK` descriptor for a memory block which is in reality 
+  a virtual filesystem on its own. Per default filenames are matched case
+  sensitive also on win32 systems. The findnext function will walk all
+  files on the zip virtual filesystem table and return a name entry 
+  with the full pathname, i.e. including any directory names to the
+  root of the zip disk `FILE`.
+
+### ZZIP_DISK_ENTRY inspection 
+
+The `ZZIP_DISK_FILE` is a special file descriptor handle 
+  of the `zzipmmapped` library - but the 
+  `ZZIP_DISK_ENTRY` is not so special. It is actually a pointer
+  directly into the zip central directory managed by `ZZIP_DISK`.
+  While `zzip/mmapped.h` will not reveal the structure on its own, 
+  you can include `zzip/format.h` to get access to the actual 
+  structure content of a `ZZIP_DISK_ENTRY` by its definition  \
+  **`struct zzip_disk_entry`**.
+
+In reality however it is not a good idea to actually read the bytes
+  in the `zzip_disk_entry` structure unless you seriously know
+  the internals of a zip archive entry. That includes any byteswapping
+  needed on bigendian platforms. Instead you want to take advantage of
+  helper macros defined in `zzip/fetch.h`. These will take
+  care to convert any struct data member to the host native format.
+
+```
+extern uint16_t    zzip_disk_entry_get_flags( zzip_disk_entry* entry);
+extern uint16_t    zzip_disk_entry_get_compr( zzip_disk_entry* entry);
+extern uint32_t    zzip_disk_entry_get_crc32( zzip_disk_entry* entry);
+
+extern zzip_size_t zzip_disk_entry_csize( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_usize( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_namlen( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_extras( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_comment( zzip_disk_entry* entry);
+extern int         zzip_disk_entry_diskstart( zzip_disk_entry* entry);
+extern int         zzip_disk_entry_filetype( zzip_disk_entry* entry);
+extern int         zzip_disk_entry_filemode( zzip_disk_entry* entry);
+
+extern zzip_off_t  zzip_disk_entry_fileoffset( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_sizeof_tail( zzip_disk_entry* entry);
+extern zzip_size_t zzip_disk_entry_sizeto_end( zzip_disk_entry* entry);
+extern char*       zzip_disk_entry_skipto_end( zzip_disk_entry* entry);
+```
+
+Additionally the `zzipmmapped` library has two additional
+  functions that can convert a mmapped disk entry to (a) the local
+  file header of a compressed file and (b) the start of the data area
+  of the compressed file. These are used internally upon opening of
+  a disk entry but they may be useful too for direct inspection of the
+  zip data area in special applications.
+
+```
+char*  zzip_disk_entry_to_data(ZZIP_DISK* disk,

_service:tar_scm:v0.13.74.tar.gz/docs/notes.htm.md Added

@@ -0,0 +1,57 @@
+## Some Notes 
+
+<dl>
+<dt> ClamAV thinks it decompress zip method 9 files </dt>
+<dd>
+   In May 2005 the ClamAV Development team detected a problem
+   with zlib - which knows an undocumented inflate64 that maps
+   to the zip compression method number 9 (implemented in files
+   inftree9 and infback9). However the support for that method 
+   is not being compiled into libz.so by default, so you have
+   to recompile zlib to get support for it - zziplib will not do
+   that on its own, nor will it check the actual availability.
+   So, zziplib users might be handicapped if the meet a zip
+   compressed with that method 9, at best they will get an
+   error code back to the application but that is mostly not
+   intuitive enough to point to the actual problem related to
+   the last breed of zip/zlib compression methods. Effectivly
+   you are restricted to methods 0 and 8.
+</dd>
+<dt> Ogre3D + Win64/AMD64 + zziplib = ZZIP_DIR_READ error </dt>
+<dd>
+   As of December 2005 the thread at
+   http://www.ogre3d.org/phpBB2/viewtopic.php?p=110707#110667
+   points to a problem in the 64bit variant of zziplib with
+   some zip archives. The actual source of the problem is
+   unknown. The Ogre project uses an internal copy of the
+   zziplib library being statically linked. The latest
+   zziplib version has been tested on a number of 64bit
+   system in the meantime - however those are 64bit Unix
+   variants (LP64). While Win32 (LP32) works okay there
+   might be some buglet left for Win64 (LLP64) that I can't
+   track down (system N/A to me) in the near future.
+</dd>
+<dt> PHP5 does not know --with-zip </dt>
+<dd>
+   As of January 2005 I was hinted that some of the PHP
+   problems might see a new show. In the past there were
+   numerous queries about installation of zziplib to be
+   useful as the PHP-ZIP module but I could not answer them.
+   (I don't use PHP for real work). The standard php4
+   docs were obviously insufficient with saying to just
+   configure --with-zip... but now even that option is
+   gone and there is no hint anywhere telling of the
+   replacement.
+</dd>
+<dt> sourcebase.sf using modified zziplib code </dt>
+<dd>
+   In May 2003 I did notice that the sourcebase.sf
+   project - providing a generic virtual filesystem 
+   for applications - has been reusing the zziplib
+   code. However the code has been modified in a
+   number of places and it was (at first) placed
+   under real GPL. That library was supposed to be
+   put under the hood of the GNOME desktop but at
+   the moment it does not seem to go nowhere further.
+</dd>
+</dl>

_service:tar_scm:v0.13.74.tar.gz/docs/referentials.htm.md Added

@@ -0,0 +1,56 @@
+<date> 15. July 2002 </date>
+
+## ZZIP Referentials 
+Where is it used.
+
+
+
+### GPL Rant 
+
+> The GPL/LGPL do not have a clause like MPL and others to notify the
+> original author about certain usages of the library - that's a pity
+> since I do not get to know many of the areas where zziplib has come
+> to be used. I can only ask you to send me an e-mail, so I can put a
+> link from here to your project. Within thousands of downloads less
+> than a handful of people wrote to me - mostly for having found a bug
+> or having a feature request. Be nice, and write even if you have had
+> successfully implanted zziplib in your project... I love to hear that ;-)
+
+### opensource games 
+
+> Although the library has not been written focusing on game data,
+> it has it greatest success just there. The SDL-rwops example did
+> further it by great amounts, people just like it to have the
+> thousand of small bitmaps to be assembled into one big dat file,
+> and put the AI scripts just next to them.
+
+
+
+* Underworld Adventures: \
+  http://uwadv.sourceforge.net(http://uwadv.sourceforge.net)
+* Ogre3D Game Development: \
+  http://www.ogre3d.org/(http://www.ogre3d.org/)
+
+### opensource apps/libs 
+
+> Here the most important feature has been the smalls size of this
+> library and the possible to use its autoconf script and even for
+> those who don't, it is easy to make a custom configuration. The
+> source code is easy to understand and therefore to customize for
+> the needs of the app/lib that wants to use the functionality.
+
+
+
+* PHP ZIP Module \
+  http://www.php.net/manual/en/ref.zip.php(http://www.php.net/manual/en/ref.zip.php)
+  
+  ### commercial usage 
+
+> For commercial usage, you can bind many small files into a zip
+> file for easier handling. Obfuscation and io-wrapping help
+> greatly to implant it in areas even far from posix-io grounds.
+
+
+
+* Media Portal Backside \
+  http://www.appwares.com(http://www.appwares.com)

_service:tar_scm:v0.13.74.tar.gz/docs/sfx-make.htm.md Added

@@ -0,0 +1,160 @@
+<date> February 2003 </date>
+
+## SFX-Make 
+ combining an EXE with a ZIP archive
+
+### How To 
+
+In this section we walk you through the steps of combining an EXE
+  with a ZIP archive. The basic scheme goes like this: the final
+  file will have an EXE starting at offset null, followed by the
+  data entries of a ZIP archive. The *last* part of the ZIP 
+  archive is the ZIP central-directory which ends at the end of the file.
+
+The basic problem lies in the fact that the zip central-directory
+entries reference their data section with an offset from the 
+start-of-file so that you can not just append a zip archive after 
+an exe stub. The trick goes like adding the EXE as the first data
+part of the ZIP archive - so that the offsets for each entry will
+be correct when we are finished with it.
+
+Again, one can not just use a zip tool to put the EXE as the first
+part - since each data part is preceded with an infoblock of a 
+few bytes. The data of the first data part will therefore not
+start at offset zero. We solve this problem with moving the data
+a few bytes later - so that the final file will not start with a
+"PK" magic (from the zip info header) but with an "MZ" or "ELF"
+magic (from the exe info header).
+
+### Step 1: Creating The Zip Combination 
+
+Choose your exe file (example.exe) and wrap that file into a
+  zip container - ensure that the zip tool does *not*  
+  use any compression algorithm on the data. This is usually
+  done with saying "zero compression level" as an option to
+  the zip tool. Also note that *no other* file is
+  wrapped as some zip tools reorder the entries from the 
+  order on the command line to alphabetic order. Here is an
+  example with infozip's `zip` (e.g. on linux):
+
+```
+zip -0 -j example.zip example.exe
+```
+
+There is no zip tool that would reorder the data entries in
+  an existing zip archive. This mode is used here - the real
+  compressed data entries can now be added to the existing
+  zip archive that currently just wraps the exe part. With
+  specifying maximum compression ("-9" = compression level 9) 
+  and throwing away any subdirectory part ("-j" = junk path)
+  it might look like
+
+```
+zip -9 -j example.zip data/*
+```
+
+Now we need to move the exe part by a few bytes to the
+  real start of the file. This can be done as easily as
+  writing the exe file again on to the start of the file.
+  However, one can not just use a shell-direction or
+  copy-operation since that would truncate (!!) the zip
+  file to the length of the exe part. The overwrite-operation
+  must be done without truncation. For maximum OS independence
+  the zziplib ships with a little tool in "test/zzipsetstub.c"
+  that you can reuse for this task:
+
+```
+zzipsetstub example.zip example.exe
+```
+
+This is it - the `unzip` tool can still access all data
+entries but the first EXE - the first EXE will be listed
+in the central-directory of the ZIP archive but one can
+not extract the data since the "PK" magic at offset null
+has been overwritten with the EXE magic. The data of all
+the other entries can still be extracted with a normal
+`unzip` tool - or any tool from the zziplib be used for
+the same task.
+
+### Step 2: Accessing The Data From The Program 
+
+There is an example in test/zzipself.c that show how to do
+it. The OS will provide each program with its own name in
+argv0 of the main() routine. This program file (!!) is
+also the zip archive that carries the compressed data
+entries along. Therefore, we can just issue a zzip_opendir
+on argv0 to access the zip central-directory.
+
+Likewise one can open a file within it by just prepending
+  the string argv0 to the filename stem, i.e. you could
+  do like 
+
+```
+ZZIP_FILE* f = zzip_fopen ("example.exe/start.gif", "rbi")
+```
+
+however you are advised to use the _ext_io cousin to be
+platform independet - different Operating Systems use
+different file extensions for executables, it's not always
+an ".exe".
+
+Once the file is opened, the data can be zzip_fread or
+passed through an SDL_rwops structure into the inner
+parts of your program.
+
+### Step 3: Using Obfuscation Along 
+
+The next level uses obfuscatation on the data part of the
+application. That way there is no visible data to be seen
+from outside, it looks like it had been compiled right into
+the C source part. One can furthermore confuse a possible
+attacker with staticlinking the zziplib into the executable
+(this is possible in a limited set of conditions).
+
+The first pass is again in creating the zip - here we must
+  ensure that only the ZIP archive part is obfuscated but
+  the EXE part must be plain data so that the operationg 
+  system can read and relocate it into main memory. Using
+  xor-obfuscation this is easy - applying xor twice will
+  yield the original data. The steps look like this now:
+
+```
+zzipxorcopy example.exe example.xor
+    zip -0 application.zip example.xor
+    zip -9 application.zip data/*
+    zzipsetstub application.zip example.xor
+    zzipxorcopy application.zip application.exe
+```
+
+In the second step the open-routine in your application
+  needs to be modified - there are quite some examples in
+  the zziplib that show you how to add an xor-read routine
+  and passing it in the "io"-part of an zzip_open_ext_io
+  routine (see zzipxorcat.c).
+
+```
+static int xor_value = 0x55;
+
+   static zzip_ssize_t xor_read (int f, void* p, zzip_size_t l)
+   {
+       zzip_ssize_t r = read(f, p, l);
+       zzip_ssize_t x; char* q; for (x=0, q=p; x < r; x++) qx ^= xor_value;
+       return r;
+   }
+
+   static struct zzip_plugin_io xor_handlers;
+   static zzip_strings_t xor_fileext = { ".exe", ".EXE", "", 0 };
+   
+   main(...)
+   {
+       zzip_init_io (&xor_handlers, 0); xor_handlers.read = &xor_read;
+  
+       ZZIP_FILE*  fp = zzip_open_ext_io (filename, 
+                             O_RDONLY|O_BINARY, ZZIP_CASELESS|ZZIP_ONLYZIP,
+                             xor_fileext, &xor_handlers);
+      ....
+```
+
+You may want to pick your own xor-value instead of the default 0x55,
+the zziplib-shipped tool `zzipxorcopy` does know an option to just
+set the xor-value with which to obfuscate the data.

_service:tar_scm:v0.13.74.tar.gz/docs/tools Added

_service:tar_scm:v0.13.74.tar.gz/docs/tools/__init__.py Added

_service:tar_scm:v0.13.74.tar.gz/docs/tools/cpp2markdown-1.py Added

@@ -0,0 +1,256 @@
+#! /usr/bin/python3
+
+from __future__ import print_function
+
+import pygments.lexers.compiled as lexer
+import optparse
+import re
+import sys
+from pygments.token import Token
+import logging
+
+logg = logging.getLogger(__name__)
+
+if sys.version0 == "3":
+    xrange = range
+
+FileComment = "FileComment"
+FileInclude = "FileInclude"
+FunctionComment = "FunctionComment"
+FunctionPrototype = "FunctionPrototype"
+
+# use the markdown lexer to identify elements
+# then filter only those we want. The returned
+# token list is more global flagging the role
+# of each token for the manual generation.
+class CppToMarkdown:
+    def __init__(self):
+        self.alldefinitions = 0
+        self.internaldefs = "static"
+        self.filecomment_done = ""
+        self.fileinclude_done = ""
+        self.filecomment_text = ""
+        self.fileinclude_text = ""
+        self.comment_text = ""
+        self.function_text = ""
+        self.nesting = 0
+    def split_copyright(self, text):
+        # there are two modes - the copyright starts in the first line
+        # and the source description follows or the other way round.
+        lines = text.split("\n")
+        if len(lines) <= 2:
+            return "", text
+        introtext = lines0
+        copyright = lines0
+        check1 = re.compile(r"^\s*\s+(cC)")
+        check2 = re.compile(r"^\s*\s+\bCcopyright\b")
+        empty1 = re.compile(r"^\s*\s*$")
+        state = "intro"
+        for i in xrange(1,len(lines)-1):
+            line = linesi
+            if state == "intro":
+                if empty1.match(line):
+                    introtext +=  line 
+                    continue
+                if check1.match(line) or check2.match(line):
+                    state = "copyrightfirst"
+                    copyright +=  line 
+                else:
+                    state = "introtextfirst"
+                    introtext +=  line 
+            elif state == "copyrightfirst":
+                if empty1.match(line):
+                    state = "introtextlast"
+                    introtext +=  line 
+                else:
+                    copyright +=  line 
+            elif state == "introtextfirst":
+                if check1.match(line) or check2.match(line):
+                    state = "copyrightlast"
+                    copyright +=  line 
+                else:
+                    introtext +=  line 
+            elif state == "copyrightlast":
+                copyright +=  line 
+            elif state == "introtextlast":
+                introtext +=  line 
+            else:
+                logg.fatal("UNKNOWN STATE %s", state)
+        introtext += lines-1
+        copyright += lines-1
+        logg.debug("@ COPYRIGHT\n %s", copyright)
+        logg.debug("@ INTROTEXT\n %s", introtext)
+        return "\n".join(copyright), "\n".join(introtext)
+    def commentblock(self, text):
+        prefix = re.compile(r"(?s)^\s*/*+(^\n*)(?=\n)")
+        suffix = re.compile(r"(?s)\n */\s*")
+        empty = re.compile(r"(?s)\n * \t*(?=\n)")
+        lines1 = re.compile(r"(?s)\n * \t")
+        lines2 = re.compile(r"(?s)\n * ")
+        lines3 = re.compile(r"(?s)\n *\t\t")
+        lines4 = re.compile(r"(?s)\n *\t")
+        text = suffix.sub("\n", text)
+        text = prefix.sub("> \\1\n", text)
+        text = empty.sub("\n", text)
+        text = lines1.sub("\n     ", text)
+        text = lines2.sub("\n", text)
+        text = lines3.sub("\n         ", text)
+        text = lines4.sub("\n     ", text)
+        return text
+    def functionblock(self, text):
+        empty = re.compile(r"(?s)\n \t*(?=\n)")
+        text = "    " + text.replace("\n", "\n    ")
+        text = empty.sub("", text) 
+        return text
+    def functionname(self, text):
+        check1 = re.compile(r"^^()=*(\b\w+)\s*(=")
+        found = check1.match(text)
+        if found:
+            return found.group(1)
+        check2 = re.compile(r"^^()=*(\b\w+)\s*$")
+        found = check2.match(text)
+        if found:
+            return found.group(1)
+        return ""
+    def run(self, filename):
+        filetext = open(filename).read()
+        for line in self.process(filetext, filename):
+            print(line)
+    def process(self, filetext, filename=""):
+        section_ruler = "-----------------------------------------"
+        copyright = ""
+        for token, text in self.parse(filetext):
+            if token == FileInclude:
+                yield "## SOURCE " + filename.replace("../", "")
+                yield "    #" + text.replace("\n", "\n    ")
+            elif token == FileComment:
+                yield "### INTRODUCTION"
+                copyright, introduction = self.split_copyright(text)
+                yield self.commentblock(introduction)
+            elif token == FunctionPrototype:
+                name = self.functionname(text)
+                yield section_ruler
+                yield "### " + name
+                # yield '<a id="%s"></a>' % name
+                yield "#### NAME"
+                yield "    " + name
+                yield "#### SYNOPSIS"
+                yield self.functionblock(text)
+            elif token == FunctionComment:
+                if text:
+                    yield "#### DESCRIPTION"
+                    yield self.commentblock(text)
+            else:
+                if text:
+                    yield "#### NOTES"
+                    print(token + " " + text.replace("\n", "\n  "))
+        if copyright:
+            yield section_ruler
+            yield "### COPYRIGHT"
+            yield self.commentblock(copyright)            
+    def isexported_function(self):
+        function = self.function_text.strip().replace("\n"," ")
+        logg.debug("@ --------------------------------------") 
+        logg.debug("@ ALLDEFINITIONS %s", self.alldefinitions)
+        if function.startswith("static ") and self.alldefinitions < 3:
+            logg.debug("@ ONLY INTERNAL %s", function)
+            return False
+        if not self.comment_text:
+            if not self.alldefinitions:
+                logg.info("@ NO COMMENT ON %s", function)
+                return False
+            else:
+                logg.warn("@ NO COMMENT ON %s", function)
+        text = self.comment_text
+        if text.startswith("/**"): return True
+        if text.startswith("/*!"): return True
+        if text.startswith("///"): return True
+        if text.startswith("//!"): return True
+        if self.alldefinitions >= 1:
+            if text.startswith("/*"): return True
+            if text.startswith("//"): return True
+        if self.alldefinitions >= 2:
+            return True
+        logg.debug("@ NO ** COMMENT %s", self.function_text.strip())
+        defs = self.function_text
+        return False
+    def parse(self, filetext):
+        c = lexer.CLexer()
+        for token, text in c.get_tokens(filetext):
+            logg.debug("|| %s %s", token, text.replace("\n", "\n |"))
+            # completion
+            if token != Token.Comment.Preproc and self.fileinclude_done == "no":
+                    yield FileInclude, self.fileinclude_text
+                    if self.filecomment_text:
+                        yield FileComment, self.filecomment_text
+                    self.fileinclude_done = "done"
+            # parsing
+            if token == Token.Comment.Multiline:
+                if not self.filecomment_done:
+                    self.filecomment_done = "done"
+                    self.filecomment_text = text
+                    # wait until we know it is not a function documentation
+                    self.comment_text = text
+                else:
+                    self.comment_text = text
+            elif token == Token.Comment.Preproc and "include" in text:
+                if not self.fileinclude_done:
+                    self.fileinclude_done = "no"
+                    self.fileinclude_text += text

_service:tar_scm:v0.13.74.tar.gz/docs/tools/cpp2markdown.py Added

@@ -0,0 +1,198 @@
+#! /usr/bin/python3
+from __future__ import print_function
+
+import pygments.lexers.compiled as lexer
+import optparse
+import re
+from pygments.token import Token
+import logging
+
+logg = logging.getLogger(__name__)
+
+FileComment = "FileComment"
+FileInclude = "FileInclude"
+FunctionComment = "FunctionComment"
+FunctionPrototype = "FunctionPrototype"
+
+# use the markdown lexer to identify elements
+# then filter only those we want. The returned
+# token list is more global flagging the role
+# of each token for the manual generation.
+class CppToMarkdown:
+    def __init__(self):
+        self.alldefinitions = 0
+        self.internaldefs = "static"
+        self.filecomment_done = ""
+        self.fileinclude_done = ""
+        self.filecomment_text = ""
+        self.fileinclude_text = ""
+        self.comment_text = ""
+        self.function_text = ""
+        self.nesting = 0
+    def commentblock(self, text):
+        emptyprefix = re.compile(r"(?s)^\s*/*+ \t*(?=\n)")
+        prefix = re.compile(r"(?s)^\s*/*+(^\n*)(?=\n)")
+        suffix = re.compile(r"(?s)\n */\s*")
+        empty = re.compile(r"(?s)\n * \t*(?=\n)")
+        lines1 = re.compile(r"(?s)\n * \t")
+        lines2 = re.compile(r"(?s)\n * ")
+        lines3 = re.compile(r"(?s)\n *\t\t")
+        lines4 = re.compile(r"(?s)\n *\t")
+        text = suffix.sub("\n", text)
+        text = emptyprefix.sub("", text)
+        text = prefix.sub("> \\1\n", text)
+        text = empty.sub("\n", text)
+        text = lines1.sub("\n     ", text)
+        text = lines2.sub("\n", text)
+        text = lines3.sub("\n         ", text)
+        text = lines4.sub("\n     ", text)
+        return text
+    def functionblock(self, text):
+        empty = re.compile(r"(?s)\n \t*(?=\n)")
+        text = "    " + text.replace("\n", "\n    ")
+        text = empty.sub("", text) 
+        return text
+    def functionname(self, text):
+        check1 = re.compile(r"^^()=*(\b\w+)\s*(=")
+        found = check1.match(text)
+        if found:
+            return found.group(1)
+        check2 = re.compile(r"^^()=*(\b\w+)\s*$")
+        found = check2.match(text)
+        if found:
+            return found.group(1)
+        return ""
+    def run(self, filename):
+        filetext = open(filename).read()
+        for line in self.process(filetext, filename):
+            print(line)
+    def process(self, filetext, filename=""):
+        for token, text in self.parse(filetext):
+            if token == FileInclude:
+                yield "## SOURCE " + filename.replace("../", "")
+                yield "    #" + text.replace("\n", "\n    ")
+            elif token == FileComment:
+                yield "## INTRODUCTION"
+                yield self.commentblock(text)
+            elif token == FunctionPrototype:
+                name = self.functionname(text)
+                yield "-----------------------------------------"
+                yield "### " + name
+                yield "#### NAME"
+                yield "    " + name
+                yield "#### SYNOPSIS"
+                yield self.functionblock(text)
+            elif token == FunctionComment:
+                if text:
+                    yield "#### DESCRIPTION"
+                    yield self.commentblock(text)
+            else:
+                if text:
+                    yield "#### NOTES"
+                    print(token + " " + text.replace("\n", "\n  "))
+    def isexported_function(self):
+        function = self.function_text.strip().replace("\n"," ")
+        logg.debug("@ --------------------------------------") 
+        logg.debug("@ ALLDEFINITIONS %s", self.alldefinitions)
+        if function.startswith("static ") and self.alldefinitions < 3:
+            logg.debug("@ ONLY INTERNAL %s", function)
+            return False
+        if not self.comment_text:
+            if not self.alldefinitions:
+                logg.info("@ NO COMMENT ON %s", function)
+                return False
+            else:
+                logg.warn("@ NO COMMENT ON %s", function)
+        text = self.comment_text
+        if text.startswith("/**"): return True
+        if text.startswith("/*!"): return True
+        if text.startswith("///"): return True
+        if text.startswith("//!"): return True
+        if self.alldefinitions >= 1:
+            if text.startswith("/*"): return True
+            if text.startswith("//"): return True
+        if self.alldefinitions >= 2:
+            return True
+        logg.debug("@ NO ** COMMENT %s", self.function_text.strip())
+        defs = self.function_text
+        return False
+    def parse(self, filetext):
+        c = lexer.CLexer()
+        for token, text in c.get_tokens(filetext):
+            logg.debug("|| %s %s", token, text.replace("\n", "\n |"))
+            # completion
+            if token != Token.Comment.Preproc and self.fileinclude_done == "no":
+                    yield FileInclude, self.fileinclude_text
+                    if self.filecomment_text:
+                        yield FileComment, self.filecomment_text
+                    self.fileinclude_done = "done"
+            # parsing
+            if token == Token.Comment.Multiline:
+                if not self.filecomment_done:
+                    self.filecomment_done = "done"
+                    self.filecomment_text = text
+                    # wait until we know it is not a function documentation
+                    self.comment_text = text
+                else:
+                    self.comment_text = text
+            elif token == Token.Comment.Preproc and "include" in text:
+                if not self.fileinclude_done:
+                    self.fileinclude_done = "no"
+                    self.fileinclude_text += text
+                    self.comment_text = ""
+            elif token == Token.Comment.Preproc and self.fileinclude_done == "no":
+                if not "\n" in self.fileinclude_text:
+                    self.fileinclude_text += text
+                self.comment_text = ""
+            elif token == Token.Comment.Preproc:
+                    self.comment_text = ""
+                    self.function_text = ""
+            elif token == Token.Operator and text == "=":
+                if not self.nesting and self.function_text.strip():
+                    if self.isexported_function():
+                        yield FunctionPrototype, self.function_text
+                        yield FunctionComment, self.comment_text
+                self.comment_text = ""
+                self.function_text = ""
+            elif token == Token.Punctuation and text == ";":
+                self.comment_text = ""
+                self.function_text = ""
+            elif token == Token.Punctuation and text == "{":
+                if not self.nesting and self.function_text.strip():
+                    if self.isexported_function():
+                        yield FunctionPrototype, self.function_text
+                        yield FunctionComment, self.comment_text
+                self.comment_text = ""
+                self.function_text = ""
+                self.nesting += 1
+            elif token == Token.Punctuation and text == "}":
+                self.nesting -= 1
+                self.comment_text = ""
+                self.function_text = ""
+            else:
+                if not self.nesting:
+                    self.function_text += text
+                else:
+                    pass # yield "|",text
+                
+
+if __name__ == "__main__":
+    _o = optparse.OptionParser()
+    _o.add_option("-v", "--verbose", action="count", default=0)
+    _o.add_option("-a", "--all", action="count", default=0,
+                  help="include all definitions in the output (not only /**)")
+    opt, args = _o.parse_args()
+
+    logg.addHandler(logging.StreamHandler())
+    if opt.verbose:
+        logg.setLevel(logging.WARN - 10 * opt.verbose)
+    
+    c = CppToMarkdown()
+    if opt.all:
+        c.alldefinitions = opt.all
+    for arg in args:
+        c.run(arg)
+    
+    
+
+

_service:tar_scm:v0.13.74.tar.gz/docs/tools/dbk2man.py Changed

_service:tar_scm:v0.13.74.tar.gz/docs/tools/dir2index.py Changed

_service:tar_scm:v0.13.74.tar.gz/docs/tools/md2dbk.py Added

@@ -0,0 +1,827 @@
+#! /usr/bin/python3
+
+from __future__ import print_function, absolute_import, division
+
+__copyright__ = "(C) 2021 Guido Draheim"
+__contact__ = "https://github.com/gdraheim/zziplib"
+__license__ = "CC0 Creative Commons Zero (Public Domain)"
+__version__ = "0.13.72"
+
+from typing import List, Generator, Optional
+import re
+from html import escape
+
+import logging
+logg = logging.getLogger("MD2DBK")
+
+SingleUnderscore = False
+SingleAsterisk = False
+
+hint = """ The markdown syntax as clarified by CommonMark wants to make sure that parsers
+can be written easily. That comes from a first pass to detect the block structure
+and a second pass to convert the markup within. As such you should make sure that
+after each block there is an empty line. As such, to put empty lines into a block
+you need to use some kind of fenced block. The GFM (github flavoured markdown)
+clarifies that fenced blocks do not need a blank line before or after. Text lines
+not inside a fenced block will always be added rstrip()ed to the block."""
+
+class ContainerMarkup:
+    newBQ = ""  # default "<BQ>"
+    endBQ = ""  # default "</BQ>"
+    newUL = ""  # default "<UL>"
+    endUL = ""  # default "</UL>"
+    newLI = ""  # default "<LI>"
+    endLI = ""  # default "</LI>"
+    endnewLI = ""  # default "</LI><LI>"
+    BQ = "blockquote"
+    UL = "itemizedlist"
+    LI = "listitem"
+    preSE1 = "# "
+    preSE2 = "## "
+    preHR1 = "--- "
+    preHR2 = "--- "
+    preHR3 = "--- "
+
+def blocks(text: str) -> Liststr:
+    logg.debug(">> (%i)", len(text))
+    blocks: Liststr = 
+    for block in _blocks(text):
+        blocks.append(block)
+    return blocks
+def _blocks(input: str, mark: OptionalContainerMarkup = None) -> Generatorstr, None, None:
+    """ this function cuts the input string into text blocks.
+    The original text content is not modified but some additional
+    container blocks are generated which return the single-line 
+    xml start/stop tag of blockquote and itemizedlist."""
+    mark = mark or ContainerMarkup()
+    logg.debug(">> (%i)", len(input))
+    text = ""
+    fenced = ""  # or indent or html
+    blockquote = ""
+    listblock = ""
+    for nextline in input.splitlines():
+        logg.debug("| %s", nextline)
+        line = nextline
+        endblockquote = 
+        if blockquote:
+            newblock = ""
+            _blockquote1 = re.match("(>+)(\\s*)$", nextline)
+            _blockquote2 = re.match("(>+)\\s(.*)", nextline)
+            if _blockquote1:
+                newblock = _blockquote1.group(1)
+                line = _blockquote1.group(2)
+            elif _blockquote2:
+                newblock = _blockquote2.group(1)
+                line = _blockquote2.group(2)
+            if fenced:
+                pass
+            elif blockquote.count(">") < newblock.count(">"):
+                for newdepth in range(blockquote.count(">"), newblock.count(">")):
+                    yield mark.newBQ or "<%s>" % mark.BQ
+                blockquote = newblock
+            elif newblock.count(">") < blockquote.count(">"):
+                for newdepth in range(newblock.count(">"), blockquote.count(">")):
+                    if text:
+                        yield text
+                        text = ""
+                    endblockquote += mark.endBQ or "</%s>" % mark.BQ
+                blockquote = newblock  # may become empty
+        if listblock:
+            newblock = ""
+            _indents = re.match("( *)(.*)", line)
+            _newlist1 = re.match("(*+)(\\s*)$", line)
+            _newlist2 = re.match("(*+)\\s(.*)", line)
+            if _newlist1 or _newlist2:
+                if _newlist1:
+                    newblock = _newlist1.group(1)
+                if _newlist2:
+                    newblock = _newlist2.group(1)
+            assert _indents is not None
+            indent = _indents.group(1)
+            # if less indent then end listblock
+            if len(indent) >= len(listblock):
+                pass
+            elif fenced:
+                pass
+            elif listblock.count("*") < newblock.count("*"):
+                for newdepth in range(listblock.count("*"), newblock.count("*")):
+                    if text:
+                        yield text
+                        text = ""
+                    yield mark.newUL or "<%s>" % mark.UL
+                    yield mark.newLI or "<%s>" % mark.LI
+                listblock = newblock
+            elif newblock.count("*") < listblock.count("*"):
+                for newdepth in range(newblock.count("*"), listblock.count("*")):
+                    if text:
+                        yield text
+                        text = ""
+                    yield mark.endLI or "</%s>" % mark.LI
+                    yield mark.endUL or "</%s>" % mark.UL
+                listblock = newblock  # may become empty
+                if _newlist1 or _newlist2:
+                    yield mark.newLI or "<%s>" % mark.LI
+            else:
+                if True:
+                    if text:
+                        yield text
+                        text = ""
+                if mark.endnewLI:
+                    yield mark.endnewLI
+                else:
+                    yield (mark.endLI or "</%s>" % mark.LI) + (mark.newLI or "<%s>" % mark.LI)
+        for newblock in endblockquote:
+            yield newblock
+        if not line.strip():
+            if not fenced:
+                if text:
+                    yield text
+                    text = ""
+                continue
+        # check to end an html block
+        if fenced.startswith("<"):
+            if fenced == "<script":
+                if "</script>" in line:
+                    text += line + "\n"
+                    yield text
+                    text = ""
+                    fenced = ""
+                    continue
+            if fenced == "<pre":
+                if "</pre>" in line:
+                    text += line + "\n"
+                    yield text
+                    text = ""
+                    fenced = ""
+                    continue
+            if fenced == "<style":
+                if "</style>" in line:
+                    text += line + "\n"
+                    yield text
+                    text = ""
+                    fenced = ""
+                    continue
+            if fenced == "<!CDATA":
+                if ">" in line:
+                    text += line + "\n"
+                    yield text
+                    text = ""
+                    fenced = ""
+                    continue
+            if fenced == "" in line:
+                    text += line + "\n"
+                    yield text
+                    text = ""
+                    fenced = ""
+                    continue
+            if fenced == "<!":
+                if ">" in line:
+                    text += line + "\n"
+                    yield text
+                    text = ""
+                    fenced = ""
+                    continue
+            if fenced == "<?":
+                text += line + "\n"
+                if "?>" in line:
+                    yield text
+                    text = ""
+                    fenced = ""
+                    continue
+            if fenced.startswith("</"):
+                if fenced in line:
+                    text += line + "\n"
+                    yield text
+                    text = ""
+                    fenced = ""
+                    continue
+            if not line.strip():

_service:tar_scm:v0.13.74.tar.gz/docs/tools/mdhtm.py Added

@@ -0,0 +1,47 @@
+#! /usr/bin/python3
+
+import re
+
+from optparse import OptionParser
+_o = OptionParser()
+opt, args = _o.parse_args()
+
+for arg in args:
+   for line in open(arg):
+       part = line.rstrip()
+       part = re.sub("`(^`*)`", "<code>\\1</code>", part)
+       # part = re.sub("(?m)(</hH1234>) *(\\S+)", "\\1\n\\2", part)
+       part = part.replace("<br>", "<br />")
+       part = part.replace("<>", " ")
+       # part = part.replace("<center>", "")
+       # part = part.replace("</center>", "")
+       # part = part.replace("<small>", "")
+       # part = part.replace("</small>", "")
+       part = part.replace("<nobr>", "")
+       part = part.replace("</nobr>", "")
+       part = part.replace("<section>", "")
+       part = part.replace("</section>", "")
+       #part = part.replace("<blockquote>", "<P>")
+       #part = part.replace("</blockquote>", "</P>")
+       #part = part.replace("<BLOCKQUOTE>", "<P>")
+       #part = part.replace("</BLOCKQUOTE>", "</P>")
+       part = part.replace("<BLOCKQUOTE>", "<blockquote>")
+       part = part.replace("</BLOCKQUOTE>", "</blockquote>")
+       part = part.replace("<PRE>", "<pre>")
+       part = part.replace("</PRE>", "</pre>")
+       part = part.replace("<tt>", "<code>")
+       part = part.replace("</tt>", "</code>")
+       part = re.sub("(</?)H(1234>)", "\\1h\\2", part)
+       part = part.replace("<p>&nbsp;</p>", "")
+       part = part.replace("&nbsp;", "")
+       part = part.replace("<blockquote><ul>", "<blockquote>\n<ul>")
+       part = part.replace("</ul></blockquote>", "</ul>\n</blockquote>")
+       part = part.replace("<P><small>", "<P>\n<small>")
+       part = part.replace("</small></P>", "</small>\n</P>")
+       part = part.replace("<ul><li>", "<ul>\n<li>")
+       part = part.replace("</li></ul>", "</li>\n</ul>")
+       part = part.replace("<dd><ul>", "<dd>\n<ul>")
+       part = part.replace("</ul></dd>", "</ul>\n</dd>")
+       part = part.replace("<code><code>", "<code>")
+       part = part.replace("</code></code>", "</code>")
+       print(part)

_service:tar_scm:v0.13.74.tar.gz/docs/toolstestpath.py Added

_service:tar_scm:v0.13.74.tar.gz/docs/toolstests.py Added

@@ -0,0 +1,379 @@
+#! /usr/bin/python3
+import toolstestpath  # noqa
+from tools import md2dbk
+from unittest import TestCase, TestSuite, TextTestRunner, main
+from fnmatch import fnmatchcase as matches
+
+import os
+import sys
+import logging
+logg = logging.getLogger("TOOLS")
+
+class md2dbkTests(TestCase):
+    def test_1000(self) -> None:
+        b = md2dbk.blocks("")
+        self.assertEqual(b, )
+    def test_1001(self) -> None:
+        b = md2dbk.blocks("a")
+        self.assertEqual(b, "a\n")
+    def test_1002(self) -> None:
+        b = md2dbk.blocks("a\n")
+        self.assertEqual(b, "a\n")
+    def test_1003(self) -> None:
+        b = md2dbk.blocks("a\nb")
+        self.assertEqual(b, "a\nb\n")
+    def test_1004(self) -> None:
+        b = md2dbk.blocks("a\nb\n")
+        self.assertEqual(b, "a\nb\n")
+    def test_1005(self) -> None:
+        b = md2dbk.blocks("a\nb\n\nc")
+        self.assertEqual(b, "a\nb\n", "c\n")
+    def test_1006(self) -> None:
+        b = md2dbk.blocks("a\nb\n\nc\n")
+        self.assertEqual(b, "a\nb\n", "c\n")
+    def test_1007(self) -> None:
+        b = md2dbk.blocks("a\nb\n\n\nc")
+        self.assertEqual(b, "a\nb\n", "c\n")
+    def test_1008(self) -> None:
+        b = md2dbk.blocks("a\nb\n\n\nc\n")
+        self.assertEqual(b, "a\nb\n", "c\n")
+    def test_1009(self) -> None:
+        b = md2dbk.blocks("a\nb\n\n\nc\n\n")
+        self.assertEqual(b, "a\nb\n", "c\n")
+    def test_1010(self) -> None:
+        b = md2dbk.blocks("a *xx*\nb\n\n\nc\n\n")
+        self.assertEqual(b, "a *xx*\nb\n", "c\n")
+    def test_1011(self) -> None:
+        b = md2dbk.blocks("a **xx**\nb\n\n\nc\n\n")
+        self.assertEqual(b, "a **xx**\nb\n", "c\n")
+    def test_1012(self) -> None:
+        b = md2dbk.blocks("a _xx_\nb\n\n\nc\n\n")
+        self.assertEqual(b, "a _xx_\nb\n", "c\n")
+    def test_1013(self) -> None:
+        b = md2dbk.blocks("a __xx__\nb\n\n\nc\n\n")
+        self.assertEqual(b, "a __xx__\nb\n", "c\n")
+    def test_1014(self) -> None:
+        b = md2dbk.blocks("a `xx`\nb\n\n\nc\n\n")
+        self.assertEqual(b, "a `xx`\nb\n", "c\n")
+    def test_1015(self) -> None:
+        b = md2dbk.blocks("a ``xx``\nb\n\n\nc\n\n")
+        self.assertEqual(b, "a ``xx``\nb\n", "c\n")
+    def test_1016(self) -> None:
+        b = md2dbk.blocks("a xx\nb\n\n\nc\n\n")
+        self.assertEqual(b, "a xx\nb\n", "c\n")
+    def test_1017(self) -> None:
+        b = md2dbk.blocks("a xx(foo)\nb\n\n\nc\n\n")
+        self.assertEqual(b, "a xx(foo)\nb\n", "c\n")
+    def test_1101(self) -> None:
+        b = md2dbk.blocks("# a")
+        self.assertEqual(b, "# a\n")
+    def test_1102(self) -> None:
+        b = md2dbk.blocks("## a")
+        self.assertEqual(b, "## a\n")
+    def test_1103(self) -> None:
+        b = md2dbk.blocks("### a")
+        self.assertEqual(b, "### a\n")
+    def test_1104(self) -> None:
+        b = md2dbk.blocks("#### a")
+        self.assertEqual(b, "#### a\n")
+    def test_1105(self) -> None:
+        b = md2dbk.blocks("##### a")
+        self.assertEqual(b, "##### a\n")
+    def test_1106(self) -> None:
+        b = md2dbk.blocks("###### a")
+        self.assertEqual(b, "###### a\n")
+    def test_1111(self) -> None:
+        b = md2dbk.blocks("# a\n# b")
+        self.assertEqual(b, "# a\n# b\n")
+    def test_1112(self) -> None:
+        b = md2dbk.blocks("## a\n## b")
+        self.assertEqual(b, "## a\n## b\n")
+    def test_1113(self) -> None:
+        b = md2dbk.blocks("### a\n## b")
+        self.assertEqual(b, "### a\n## b\n")
+    def test_1114(self) -> None:
+        b = md2dbk.blocks("#### a\n## b")
+        self.assertEqual(b, "#### a\n## b\n")
+    def test_1115(self) -> None:
+        b = md2dbk.blocks("##### a\n## b")
+        self.assertEqual(b, "##### a\n## b\n")
+    def test_1116(self) -> None:
+        b = md2dbk.blocks("###### a\n## b")
+        self.assertEqual(b, "###### a\n## b\n")
+    def test_1121(self) -> None:
+        b = md2dbk.blocks("# a\n b")
+        self.assertEqual(b, "# a\n b\n")
+    def test_1122(self) -> None:
+        b = md2dbk.blocks("## a\n b")
+        self.assertEqual(b, "## a\n b\n")
+    def test_1123(self) -> None:
+        b = md2dbk.blocks("### a\n b")
+        self.assertEqual(b, "### a\n b\n")
+    def test_1124(self) -> None:
+        b = md2dbk.blocks("#### a\n b")
+        self.assertEqual(b, "#### a\n b\n")
+    def test_1125(self) -> None:
+        b = md2dbk.blocks("##### a\n b")
+        self.assertEqual(b, "##### a\n b\n")
+    def test_1126(self) -> None:
+        b = md2dbk.blocks("###### a\n b")
+        self.assertEqual(b, "###### a\n b\n")
+    def test_1131(self) -> None:
+        b = md2dbk.blocks("a\n===")
+        self.assertEqual(b, "# a\n")
+    def test_1132(self) -> None:
+        b = md2dbk.blocks("a\n---")
+        self.assertEqual(b, "## a\n")
+    def test_1133(self) -> None:
+        b = md2dbk.blocks("a\n===\nb")
+        self.assertEqual(b, "# a\nb\n")
+    def test_1134(self) -> None:
+        b = md2dbk.blocks("a\n---\nb")
+        self.assertEqual(b, "## a\nb\n")
+    def test_1135(self) -> None:
+        b = md2dbk.blocks("a\n===\n## b")
+        self.assertEqual(b, "# a\n## b\n")
+    def test_1136(self) -> None:
+        b = md2dbk.blocks("a\n---\n## b")
+        self.assertEqual(b, "## a\n## b\n")
+    def test_1141(self) -> None:
+        b = md2dbk.blocks("a\n===\n\n")
+        self.assertEqual(b, "# a\n")
+    def test_1142(self) -> None:
+        b = md2dbk.blocks("a\n---\n\n")
+        self.assertEqual(b, "## a\n")
+    def test_1143(self) -> None:
+        b = md2dbk.blocks("a\n===\n\n\nb")
+        self.assertEqual(b, "# a\n", "b\n")
+    def test_1144(self) -> None:
+        b = md2dbk.blocks("a\n---\n\n\nb")
+        self.assertEqual(b, "## a\n", "b\n")
+    def test_1145(self) -> None:
+        b = md2dbk.blocks("a\n===\n\n\n## b")
+        self.assertEqual(b, "# a\n", "## b\n")
+    def test_1146(self) -> None:
+        b = md2dbk.blocks("a\n---\n\n\n## b")
+        self.assertEqual(b, "## a\n", "## b\n")
+    def test_1151(self) -> None:
+        b = md2dbk.blocks("# a\n\n\nb")
+        self.assertEqual(b, "# a\n", "b\n")
+    def test_1152(self) -> None:
+        b = md2dbk.blocks("## a\n\nb")
+        self.assertEqual(b, "## a\n", "b\n")
+    def test_1153(self) -> None:
+        b = md2dbk.blocks("### a\n\n\n\nb")
+        self.assertEqual(b, "### a\n", "b\n")
+    def test_1154(self) -> None:
+        b = md2dbk.blocks("#### a\n\n\nb")
+        self.assertEqual(b, "#### a\n", "b\n")
+    def test_1155(self) -> None:
+        b = md2dbk.blocks("##### a\n\n\n## b")
+        self.assertEqual(b, "##### a\n", "## b\n")
+    def test_1156(self) -> None:
+        b = md2dbk.blocks("###### a\n\n\n## b")
+        self.assertEqual(b, "###### a\n", "## b\n")
+    def test_1201(self) -> None:
+        b = md2dbk.blocks("* a\n\n\n")
+        self.assertEqual(b, "<itemizedlist>", "<listitem>", "* a\n",
+                             "</listitem>", "</itemizedlist>")
+    def test_1202(self) -> None:
+        b = md2dbk.blocks("* a\n\n\nb")
+        self.assertEqual(b, "<itemizedlist>", "<listitem>", "* a\n",
+                             "</listitem>", "</itemizedlist>",
+                             "b\n")
+    def test_1203(self) -> None:
+        b = md2dbk.blocks("* a\n\n\nb\n* c")
+        self.assertEqual(b, "<itemizedlist>", "<listitem>", "* a\n",
+                             "</listitem>", "</itemizedlist>", "b\n",
+                             "<itemizedlist>", "<listitem>", "* c\n",
+                             "</listitem>", "</itemizedlist>")
+    def test_1211(self) -> None:
+        b = md2dbk.blocks("* a\n* x\n\n")
+        self.assertEqual(b, "<itemizedlist>", "<listitem>", "* a\n",
+                             "</listitem><listitem>", "* x\n",
+                             "</listitem>", "</itemizedlist>")
+    def test_1212(self) -> None:
+        b = md2dbk.blocks("* a\n* x\n\nb")
+        self.assertEqual(b, "<itemizedlist>", "<listitem>", "* a\n",
+                             "</listitem><listitem>", "* x\n",
+                             "</listitem>", "</itemizedlist>", "b\n")

_service:tar_scm:v0.13.74.tar.gz/docs/zip-php.htm.md Added

@@ -0,0 +1,52 @@
+## PHP-ZIP Installation 
+
+There have been many problems about the installation of the php-zip
+module. Since Mid of 2006 the php-zip module does not require the
+zziplib anymore - it uses its own implementation (which is a clean
+approach in a double sense - there are no source code comments).
+So, the following might possibly be only relevant for older
+installations.
+
+Chris Branch has been kind enough to jot down the points of a
+successful php-zip installation sending it to me in May 2006.
+I am quoting his text verbatim - again, I do not know whether
+it works or not as I am not using any PHP for real work.
+
+-----
+
+* Software Packages
+** Apache 2.4.21 (Linux)
+** PHP 4.3.9 
+** ZZIPLIB 0.10.82 
+** Special requirement: static linking
+
+* Setting up ZZIPLIB
+**  Extract files from zziplib-0.10.82.tar.bz2 to a new folder. 
+**  ./configure --enable-static 
+**  make 
+**  make install
+
+* Rebuilding PHP to include ZIP support
+** Modify PHP build file and add "--with-zip" 
+  no dir needed because default /usr/local on my machine
+** make 
+** make install
+
+* Modifying the Apache Installation
+** Change to Apache source code directory 
+** Change to "src" subdirectory and edit existing Makefile.  -1- \
+   Add: EXTRA_LIBS=/usr/local/lib/libzzip.a 
+** Change back to parent folder (cd ..) 
+** make 
+** /usr/local/etc/httpd/bin/apachectl stop 
+** make install
+** /usr/local/etc/httpd/bin/apachectl start
+
+-1- **Note:** That step is the critical step that's not obvious.  Apparently,
+when you build PHP as a static library and include the "--with-zip"
+option, it creates a static library for PHP with an external dependency on
+zziplib.a.  However, the Apache configure script and resulting Makefile
+doesn't take this into account, so Apache won't link unless you hand-edit
+the Apache Makefile.  (Maybe there's a better place to make this change so
+that you don't have to re-fix Apache's Makefile each time you run Apache's
+./configure.  However, I didn't spend the time to investigate that).

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-api.htm.md Added

@@ -0,0 +1,26 @@
+<date> 20. July 2002 </date>
+
+## ZZIP Programmers Interface 
+The complete API description.
+
+  The zzip library was originally developed by Tomi Ollila as a
+  set of zip decoder routines. Guido Draheim did pick it up and
+  wrapped them under a call synopsis matching their posix
+  api calls. Therefore `zzip_open()` has the same 
+  synopsis as `open(2)` but it can open zipped files.
+  Later the distinction was made between magic wrappers and apis
+  for direct access to zip archives and the files contained
+  in the archive. 
+
+These (three) functional apis have little helper functions 
+alongside including those to get the posix filehandle out of a 
+zzip handle and to get some attributes about the data handle
+represented by a zzip handle. Plus checking for error codes
+that may have been generated from internal checks.
+
+<dl>
+<dt> <a href="zzip-basics.html">Basics</a> </dt>
+<dd> Magic Wrappers, Zip Archive Dir access, Zipped File access </dd>
+<dt> <a href="zzip-extras.html">Extras</a> </dt>
+<dd> ext/io init, StdC calls, Error defs, ReOpen, FileStat </dd>
+</dl>

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-basics.htm.md Added

@@ -0,0 +1,146 @@
+<date> 20. July 2002 </date>
+
+## ZZIP API Basics 
+The open/close API description.
+
+### Basics 
+
+The naming schem of functions in this library follow a simple rule: 
+  if you see a function with a `zzip_` prefix followed by 
+  compact name representing otherwise a C library or posix function then 
+  it is a magic wrapper that can automagically handle both real 
+  files/directories or zip-contained files. This includes:
+
+<table cellpadding="10" width="100%"><tr><td><table width="100%" border="1">
+<tr><td width="50%"> zzip_opendir   </td><td width="50%"> opendir </td></tr>
+<tr><td width="50%"> zzip_readdir   </td><td width="50%"> readdir </td></tr>
+<tr><td width="50%"> zzip_closedir  </td><td width="50%"> closedir </td></tr>
+<tr><td width="50%"> zzip_rewinddir </td><td width="50%"> rewinddir </td></tr>
+<tr><td width="50%"> zzip_telldir   </td><td width="50%"> telldir </td></tr>
+<tr><td width="50%"> zzip_seekdir   </td><td width="50%"> seekdir </td></tr>
+</table></td></tr></table>
+
+The ZZIP_DIR handle can wrap both a real directory or a zip-file. 
+  Note that you can not open a virtual directory *within* a
+  zip-file, the ZZIP_DIR is either a real DIR-handle of a real 
+  directory or the reference of ZIP-file but never a DIR-handle
+  within a ZIP-file - there is no such schema of a SUB-DIR handle
+  implemented in this library. A ZZIP_DIR does actually represent
+  the central directory of a ZIP-file, so that each file entry in 
+  this ZZIP-DIR can possibly have a subpath prepended.
+
+This form of magic has historic reasons as originally the 
+  magic wrappers of this library were not meant to wrap a complete
+  subtree of a real file tree but only a single directory being
+  wrapped with into a zip-file and placed instead. Later proposals
+  and patches were coming in to support subtree wrapping by not
+  only making a split between the dir-part and file-part but
+  going recursivly up through all "/"-dirseparators of a filepath
+  given to `zzip_open` and looking for zip-file there.
+
+To open a zip-file unconditionally one should be using their
+respective methods that would return a ZZIP_DIR handle being
+the representant memory instance of a ZIP-DIR, the central
+directory of a zip-file. From that ZZIP-DIR one can open a
+compressed file entry which will be returned as a ZZIP_FILE
+pointer.
+
+<table cellpadding="10" width="100%"><tr><td><table border="1" width="100%">
+<tr><td width="50%"> zzip_dir_open  </td>
+<td width="50%"> open a zip-file and parse the central directory 
+                                              to a memory shadow</td></tr>
+<tr><td width="50%"> zzip_dir_close  </td>
+<td width="50%"> close a zip-file and free the memory shadow</td></tr>
+<tr><td width="50%"> zzip_dir_fdopen  </td>
+<td width="50%"> acquire the given posix-file and try to parse it
+                                                  as a zip-file.</td></tr>
+<tr><td width="50%"> zzip_dir_read  </td>
+<td width="50%"> return the next info entry of a zip-file's central
+                 directory - this would include a possible subpath </td></tr>
+</table></td></tr></table>
+
+To unconditionally access a zipped-file (as the counter-part of a 
+  zip-file's directory) you should be using the functions having a
+  `zzip_file_` prefix which are the methods working on
+  ZZIP_FILE pointers directly and assuming those are references of
+  a zipped file with a ZZIP_DIR. 
+
+<table cellpadding="10" width="100%"><tr><td><table border="1" width="100%">
+<tr><td width="50%"> zzip_file_open  </td>
+<td width="50%"> open a file within a zip and prepare a zlib 
+                     compressor for it - note the ZZIP_DIR argument,
+                     multiple ZZIP_FILE's may share the same central
+                     directory shadow.</td></tr>
+<tr><td width="50%"> zzip_file_close  </td>
+<td width="50%"> close the handle of zippedfile
+                     and free zlib compressor of it</td></tr>
+<tr><td width="50%"> zzip_file_read  </td>
+<td width="50%"> decompress the next part of a compressed file
+                     within a zip-file</td></tr>
+</table></td></tr></table>
+
+From here it is only a short step to the magic wrappers for
+  file-access - when being given a filepath to zzip_open then
+  the filepath is checked first for being possibly a real file
+  (we can often do that by a `stat` call) and if there is
+  a real file under that name then the returned ZZIP_FILE is
+  nothing more than a wrapper around a file-descriptor of the
+  underlying operating system. Any other calls like zzip_read
+  will see the realfd-flag in the ZZIP_FILE and forward the 
+  execution to the read() function of the underlying operating system.
+
+However if that fails then the filepath is cut at last directory
+separator, i.e. a filepath of "this/test/README" is cut into the
+dir-part "this/test" and a file-part "README". Then the possible
+zip-extensions are attached (".zip" and ".ZIP") and we check if
+there is a real file under that name. If a file "this/test.zip"
+does exist then it is given to zzip_dir_open which will create
+a ZZIP_DIR instance of it, and when that was successul (so it
+was in zip-format) then we call zzip_file_open which will see
+two arguments - the just opened ZZIP_DIR and the file-part. The
+resulting ZZIP_FILE has its own copy of a ZZIP_DIR, so if you
+open multiple files from the same zip-file than you will also
+have multiple in-memory copies of the zip's central directory
+whereas otherwise multiple ZZIP_FILE's may share a common
+ZZIP_DIR when being opened with zzip_file_open directly - the
+zzip_file_open's first argument is the ZZIP_DIR and the second
+one the file-part to be looked up within that zip-directory.
+
+<table cellpadding="10" width="100%"><tr><td><table border="1" width="100%">
+<tr><td width="50%"> zzip_open  </td>
+<td width="50%"> try the file-path as a real-file, and if not
+                     there, look for the existence of ZZIP_DIR by
+                     applying extensions, and open the file 
+                     contained within that one.</td></tr>
+<tr><td width="50%"> zzip_close  </td>
+<td width="50%"> if the ZZIP_FILE wraps a real-file, then call
+                     read(), otherwise call zzip_file_read() </td></tr>
+<tr><td width="50%"> zzip_close  </td>
+<td width="50%"> if the ZZIP_FILE wraps a real-file, then call
+                     close(), otherwise call zzip_file_close() </td></tr>
+</table></td></tr></table>
+
+Up to here we have the original functionality of the zziplib
+when I (Guido Draheim) created the magic functions around the work from 
+Tomi Ollila who wrote the routines to read and decompress files from
+a zip archive - unlike other libraries it was quite readable and
+intelligible source code (after many changes there is not much
+left of the original zip08x source code but that's another story).
+Later however some request and proposals and patches were coming in.
+
+Among the first extensions was the recursive zzip_open magic. In
+the first instance, the library did just do as described above:
+a file-path of "this/test/README" might be a zip-file known as
+"this/test.zip" containing a compressed file "README". But if 
+there is neither a real file "this/test/README" and no real
+zip-file "this/test.zip" then the call would have failed but
+know the zzip_open call will recursivly check the parent
+directories - so it can now find a zip-file "this.zip" which
+contains a file-part "test/README". 
+
+This dissolves the original meaning of a ZZIP_DIR and it has lead 
+to some confusion later on - you can not create a DIRENT-like handle
+for "this/test/" being within a "test.zip" file. And actually, I did
+never see a reason to implement it so far (open "this.zip" and set
+an initial subpath of "test" and let zzip_readdir skip all entries
+that do not start with "test/"). This is left for excercie ;-)

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-crypt.htm.md Added

@@ -0,0 +1,88 @@
+<date> 15. July 2002 </date>
+
+## ZIP Std Encryption 
+Standard Zip Encryption is Weak!
+
+### Some rationale 
+
+Some people might ask why not adding standard zip-encryption. Well,
+  first of all the standard zip-encryption has not been strong enough
+  for modern computers, and there are hacker tools that even a 
+  half-literate computer-user can use to crack the password of a
+  zip-archive. In other words: ** every encrypted zip file can be
+  cracked using freely downloadable helper tools **. That's because
+  standard zip encryption is weak regarding modern personal computer 
+  power. Furthermore, adding *real* encryption is a heavy weight
+  that many people do not need, see the last argument for seeing the
+  standard one is useless anyway, and adding a non-standard one 
+  should not be the case of the standard zziplib either, ye know.
+
+On the other hand, obfuscation is a means to fear off half-literates
+  just as well - there are no *premade* tools for the obfuscation you
+  can invent from the xor examples. And a hacker that can de-obfuscate
+  such a dat-file is able to dissassemble your program as well - just to
+  remind you that the disassembly of a program will reveal the decryption
+  routine *and* the decryption key, even for a heavyweight crypt
+  algorithm. Although there is a difference, it just ranges on about times 
+  and exprience, not magnitudes. Remember the old saying: you can irritate
+  some people for some time but not irritate all people for all the time.
+  As for encryption of artwork and AI scripts in games and applications,
+  just keep in mind that the final recipient has the decryption key on
+  his system anyway, just obfuscated. So each such encryption is nothing
+  more than just a clever form of obfuscation, nothing mathematical strong.
+
+Some other people might ask why to obfuscate anyway. Well, the reason
+is theft. Even people who write opensource free software generally
+like to get some reward for what they do, some fame or atleast some 
+sweet dream to have helped the world go a bit easier in the future.
+As for program text this is quite natural for the programmers who
+pick up some code from somewhere else - it happens that most of them
+have gone through some formation and they know how hard it is to get
+even some lines of code out of your brain. This is not the case for
+some artwork and AI parameters, people do not have much respect for
+those - they just pick it up, put it under their umbrella, and 
+that's it - they even claim they could have done that themselves,
+and in most cases it is that they never have been really trying to
+do it and think of it as being comparable to that action-art they've
+seen on TV. 
+
+Just be sure that there is nothing wrong with obfuscating
+things for a binary distribution of your program even for the
+opensource case - the program text itself is an obfuscation in its
+source form when being compiled into cpu instructions. Still, the
+interested people can get hold of the source code since you provide
+it somewhere and actually the original programmers like to hear 
+from literate people who could help with modifying the project. The
+same is true for you artwork and AI scripts, the interested people
+can still see them in the opensource project material, but only
+those will look who dare to, not just the halfwit next door. 
+
+Well, you do not need to that on the other hand - ID software has
+shown that it can be very helpful since people will start to
+write new maps and new bots, pack them and publish them. An open
+data format is a form of attraction for people who can use a 
+graphics program and an editor but who do not know how to program.
+And if you use obfuscation within an opensource program, it is
+surely enought to just use the xor-format presented here, so that
+it easy for third people to get involved if they want to, they
+just have to rewrite their new datapacks with zzxorcopy, and
+that's it.
+
+As for the non-opensource projects, be aware that there are
+some ways to even staticlink the zziplib into your project, so
+you can even hide that you used zip tools to create your dat files.
+This is well enough for anyone to do - as soon as a hacker will
+get to the point to notice you used a zip format, he would have
+had found any other deobfusation or decryption routine as well.
+If you are frightened, just encrypt the executable with tools
+you bought from somewhere else. On the other hand, should there
+be problems or bugs, you have an easier time to find them when
+they could be caused by your dat entries, and it is again easy
+to send a fixup file to your clients, since the command line
+tools are just a breeze compared with some other anti-hacking
+tools you'll find on the market.
+
+Well, hope this is enough rationale to tell you that I do not
+see a need to implement anything more than obfuscation within
+zziplib - if you need real encryption, use real encryption
+software and its fileformat that supports it, not zip files.

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-cryptoid.htm.md Added

@@ -0,0 +1,90 @@
+<date> 11. May 2004 </date>
+
+## ZIP Ext Encryption 
+ext/io used for cryptoid plugins
+
+### Stronger Obfuscation For ZZip 
+
+Some people feel that a simple bytewise xor is not strong enough
+  as an obfuscation for the data. There we have the question how to
+  implant a stronger obfuscation routine to protect that data of an
+  application from artwork theft. Perhaps there is even the idea to
+  use an obfuscation in the range of a real crypt routine - in which
+  case I want to recommend strongly to read the 
+   reasoning page (zzip-crypt.html) why it can not be
+  real encryption and that the resulting obfuscation has an upper 
+  limit being *lower* than the crypt routine complexity.
+
+After reminding you of this fact we can go at evaluationg how to
+implant a stronger obfusction routine to protect your data. The
+ext/io feature uses a callback routine "read" that must read a
+block of the given size - for the obfuscation case it will call
+the "read()" function of the underlying operation system, and
+the obfuscated block will be deobfuscated before returning it to
+the caller.
+
+In this mechanism there is not asseration at which file-offset
+the ext/io-read() callback is triggered. That is the reason we
+have shown obfuscation with bytewise xor-key example - formally
+this is using obfuscation blocks of 8bit width being aligned
+on 8bit boundaries in the data file, and our decryption stream
+is stateless being the same for each obfuscation block (of 8bit
+width). 
+
+In order for a stronger obfuscation we have to break those 
+ limitations which are directly derived from the natural way
+ of the handling of files by a contemporary operating system.
+ This is triggered as the call synopsis of the ext/io read()
+ callback matches *exactly* the one of posix, so that
+ one can use the posix read() function reference as the default
+ for ensuring the most minimal overhead in accessing non-obfuscated 
+ zip files.   
+
+<small>And btw, the abbreviation "posix" stands for 
+   "Portable Open System in Unix".</small>
+
+The trick we show here: the first argument of the ext/io read
+callback is the file descriptor of the underlying operationg
+system. While we can not add another argument to the ext/io
+read call we can pick up additional information with the help
+of that file descriptor id being globally unique even across
+multiple threads. One solution would make the application map
+that descriptor id to a special argument but this is often too
+much overhead: the current file position is enough. 
+
+The current file position is managed by the operation system
+ via the file descriptor table. There is a function call to
+ map a file descriptor to the current read position offset
+ usually named "tell(fd)". Since this call is not mandated by
+ posix, you can emulate it with the posix lseek() call which
+ returns the resulting offset after the operation was performed,
+ so we just seek by a zero offset: \
+`#define tell(fd) lseek(fd,0,SEEK_CUR)`
+
+That file offset is measured from the start of the zip archive,
+not per each zipped file. Remind yourself of that fact when
+creating your own "zzobfuscate.exe" which should work on the
+zip archive and not per file before zipping. That is a difference
+over normal zip archives where the user can atleast recognized the
+dat file as a zip archive and see a list of files contained in the 
+archive, atleast their names and data start offset.
+
+Now, let's use the file read offset to break the blocking
+limitations of 8bit/8bit to a larger xor-key. In our example
+we expand to a 32bit/32bit xor-key giving a search space of
+4 billion keys instead of the just 256 keys in 8bit blocking.
+That is simply done by a static 4 byte xor-key sequence and using
+modulo operations for alignment. For the 2^X cases any modulo
+operations shrink to a set of ultra-fast bitwise-and operations.
+
+```
+static char xor_value4 = { 0x55, 0x63, 0x27, 0x31 };
+      static zzip_ssize_t xor_read (int f, void* p, zzip_size_t l)
+      {
+          zzip_off_t  y = tell(f);
+          zzip_size_t r = read(f, p, l);
+	  zzip_size_t x;  char* q = p;
+          for (x=0; x < r; x++) qx ^= xor_value(y+x)&3;
+          return r;
+      }
+```

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-extio.htm.md Added

@@ -0,0 +1,182 @@
+<date>15. July 2002 </date>
+
+## ZZIP-EXT/IO 
+Customizing the file access
+
+### The EXT/IO calls 
+
+There were quite some requests from game developers and graphics-apps
+  developers who wanted various extensions to be included into the
+  zziplib library(zziplib.html), but most of them were
+  only of specific usage. After some discussions we came up with a
+  model to customize the zziplib library(zziplib.html)  
+  calls in a number of ways - and adding two or three arguments to
+  the zzip_* calls. The standard zziplib library(zziplib.html)  
+  will actually call these *_ext_io functions with these extra arguments
+  to be set to zero.
+
+The EXT feature describes a way to customize the extensions used in
+  the magic wrapper to find a .ZIP file. It turned out that there are
+  quite a number of applications that did chose the zip file format as
+  their native document format and where just the file extension had
+  been changed. This includes file types like Quake3 ".PK3" files from
+  ID Software, the Java library files called ".JAR", and lately the 
+  OpenOffice-6 (resp. StarOffice-6) documents which carry xml-files along.
+  Just build a zero-termined string-list of file-extensions and submit it
+  to the _ext_io calls to let the zziplib(zziplib.html) find
+  parts of those zip-documents automagically.
+
+In quite some of these cases, it is very benefical to make use of the
+  o_modes functionality that allows to submit extra bit-options into
+  the zziplib(zziplib.html) - this includes options like
+  `ZZIP_PREFERZIP` or even `ZZIP_ONLYZIP` which
+  modifies the default behaviour of looking for real files first instead
+  of some within a zipped directory tree. Other bit-options include
+  `ZZIP_CASELESS` to imitate win32-like filematching for a
+  zipped filetree.
+
+Other wishes on zziplib(zziplib.html) circulated around
+  obfuscation(zzip-xor.html) or access to zip-files wrapped 
+  in other data areas including encrpyted resources from other applications. 
+  This has been addressed with the IO-handlers that you can explicitly
+  submit to the *_ext_io functions - the default will be posix-IO 
+  open/read/write and seek/tell. An application using 
+  zziplib(zziplib.html) can divert these to its own set of
+  these calls - and it only needs to declare them on opening a zipped file.
+
+### The EXT stringlist 
+
+Declaring an EXT stringlist is very simple as it is simply a 
+  list of strings, the zziplib(zziplib.html) provides
+  you with a double-const `zzip_strings_t` type to help
+  you move a global declaration into the writeonly segment of your
+  app - it turned out that about all developers wanted just some
+  extensions on the default and they were fine with having them
+  global-const for their application, nothing like dynamically
+  modifying them. Well, you are still allowed to make it fully
+  dynamic... if you find a use case for that.
+
+Extending the magic zip-extensions is just done by adding the 
+  additional extensions to be recognized - just remember to add
+  the uppercased variants too since those will be needed on
+  (unx-like) filesystems that are case-sensitive. In the internet
+  age, quite some downloaded will appear in uppercased format since
+  the other side declared it as that and that other end was happy
+  with it as being a (w32-like) case-insensitive server. Therefore,
+  it should look like 
+
+```
+static zzip_strings_t my_ext = { ".zip", ".ZIP", ".jar", ".JAR", 0 };
+```
+
+There is one frequently asked question in this area - how to open
+  a zipped file as "test.zip/README" instead of "test/README". Other
+  than some people might expect, the library will not find it - if
+  you want to have that one needs a fileext list that contains the
+  empty string - not the zero string, an empty string that is. It
+  looks like 
+
+```
+static zzip_strings_t my_ext = { ".zip", ".ZIP", "", 0 };
+```
+
+And last not least, people want to tell the library to not try to
+open a real file that lives side by side with the same path as the
+file path that can be matched by the zziplib. Actually, the magic
+wrappers were never meant to be used like - the developer should
+have used zzip_dir_* functions to open a zip-file and the 
+zzip_file_* functions to read entries from that zip-file. However,
+the magic-wrappers look rather more familiar, and so you will find
+now a bit-option ZZIP_ONLYZIP that can be passed down to the _ext_io
+variants of the magic-wrapper calls, and a real-file will never get
+tested for existence. Actually, I would rather recommend that for
+application data the option ZZIP_PREFERZIP, so that one can enter
+debugging mode by unpacking the zip-file as a real directory tree
+in the place of the original zip.
+
+### The IO handlers 
+
+While you will find the zzip_plugin_io_t declared in the zziplib
+headers, you are not advised to make much assumptions about their
+structure. Still we gone the path of simplicity, so you can use
+a global static for this struct too just like one can do for the
+EXT-list. This again mimics the internals of zziplib. There is
+even a helper function zzip_init_io that will copy the zziplib
+internal handlers to your own handlers-set. Actually, this is
+barely needed since the zziplib library will not check for nulls
+in the plugin_io structure, all handlers must be filled, and the
+zziplib routines call them unconditionally - that's simply 
+because a conditional-call will be ten times slower than an
+unconditional call which adds mostly just one or two cpu cycles
+in the place so you won't ever notice zziplib to be anywhat
+slower than before adding IO-handlers.
+
+However, you better instantiate your handlers in your application
+  and call that zzip_init_io on that instance to have everything
+  filled, only then modify the entry you actually wish to have
+  modified. For obfuscation(zzip-xor.html) this
+  will mostly be just the `read()` routine. But one can
+  also use IO-handlers to wrap zip-files into another data part
+  for which one (also) wants to modify the open/close routines
+  as well.
+
+Therefore, you can modify your normal stdio code to start using
+  zipped files by exchaning the fopen/fread/fclose calls by their
+  magic counterparts, i.e.
+
+```
+// FILE* file = fopen ("test/README", "rb");
+    ZZIP_FILE* file = zzip_fopen ("test/README", "rb");
+    // while (0 < fread (buffer, 1, buflen, file))) 
+    while (0 < zzip_fread (buffer, 1, buflen, file)))
+       { do something }
+    // fclose (file);
+    zzip_fclose (file);
+```
+
+and you then need to prefix this code with some additional 
+   code to support your own EXT/IO set, so the code will finally
+   look like 
+
+```
+/* use .DAT extension to find some files */
+    static zzip_strings_t ext = { ".dat", ".DAT", "", 0 }; 
+    /* add obfuscation routine - see zzxorcat.c examples */
+    static zzip_plugin_io_t io;
+    zzip_init_io (& io, 0);
+    io.read = xor_read; 
+    /* and the rest of the code, just as above, but with ext/io */
+    ZZIP_FILE* file = zzip_open_ext_io ("test/README", O_RDONLY|O_BINARY,
+                                        ZZIP_ONLYZIP|ZZIP_CASELESS, ext, io);
+    while (0 < zzip_fread (buffer, 1, buflen, file)))
+        { do something }
+    zzip_fclose (file);
+```
+
+### Finally 
+
+What's more to it? Well, if you have some ideas then please mail me
+   about it - don't worry, I'll probably reject it to be part of the
+   standard zziplib dll, but perhaps it is worth to be added as a
+   configure option and can help others later, and even more perhaps
+   it can be somehow generalized just as the ext/io features have been
+   generalized now. In most respects, this ext/io did not add much
+   code to the zziplib(zziplib.html) - the posix-calls
+   in the implemenation, like `"read(file)"` were simply
+   exchanged with `"zip->io->read(file)"`, and the 
+   old `"zzip_open(name,mode)"` call is split up - the old
+   entry still persists but directly calls 
+   `"zzip_open_ext_io(name,mode,0,0,0)"` which has the
+   old implementation code with just one addition: when the ZIP_FILE
+   handle is created, it uses the transferred io-handlers (or the
+   default ones if io==0), and initialized the io-member of that
+   structure for usage within the `zzip_read` calls.
+
+This adds just a few bytes to the libs and just consumes additional 
+cpu cycles that can be rightfully called to be negligible (unlike
+most commercial vendors will tell you when they indeed want to
+tell you that for soooo many new features you have to pay a price).
+It makes for greater variability without adding fatness to the
+core in the default case, this is truly efficient I'd say. Well,
+call this a German desease :-)=) ... and again, if you have another
+idea, write today... or next week.

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-extras.htm.md Added

@@ -0,0 +1,146 @@
+<date> 20. July 2002 </date>
+
+## ZZIP API extras 
+The check/init API description.
+
+### Extras 
+
+The next requests circulated around other file-extensions to 
+automagically look inside filetypes that have zip-format too but 
+carry other fileextensions - most famous might be the ".PK3"
+files of ID's Quake game. There have been a number of these
+requests and in a lot of cases it dawned to me that those guys
+may have overlooked the zzip_dir_open functions to travel
+through documents of zipformat under any name - that is that the
+"magic" was not actually needed but they just wanted to read
+files in zipformat with the zziplib.
+
+Other requests circulated around encryption but I did reject
+those bluntly, always. Instead there have been always examples
+for doing some obfuscation around the zip-format so that the
+stock zip/unzip tools do not recognize them but a game
+software developer can pack/unpack his AI scripts and bitmaps
+into such a zipformat-like file.
+
+After some dead-end patches (being shipped along with the
+  zziplib as configure-time compile-options - greetings to
+  Lutz Sammer and Andreas Schiffler), the general approach 
+  of _ext_io came up, and finally implemented (greetings go
+  to Mike Nordell). The _open()-calls do now each have a
+  cousin of _open_ext_io() with two/three additional arguments
+  being a set of extensions to loop through our magic testing,
+  a callback-handler plugin-table for obfuscation-means, 
+  and (often) a bit-mask for extra-options - this bitmask even
+  has "PREFERZIP" and "ONLYZIP" options to skip the real-file
+  test magic in those `zzip_*open` functions.
+
+<table cellpadding="10" width="100%"><tr><td><table border="1" width="100%">
+<tr><td width="50%"> zzip_open(name,flags) </td>
+<td width="50%"> zzip_open_ext_io(name,flags,mode,ext,io) </td></tr>
+<tr><td width="50%"> zzip_opendir(name) </td>
+<td width="50%"> zzip_opendir_ext_io(name,mode,ext,io) </td></tr>
+<tr><td width="50%"> zzip_dir_open(name,errp) </td>
+<td width="50%"> zzip_dir_open_ext_io(name,errp,ext,io) </td></tr>
+<tr><td width="50%"> zzip_dir_fdopen(fd,errp) </td>
+<td width="50%"> zzip_dir_fdopen_ext_io(fd,errp,ext,io) </td></tr>
+<tr><td width="50%"> zzip_file_open(dir,name,mode) </td>
+<td width="50%"> zzip_file_open_ext_io(dir,name,mode,ext,io) </td></tr>
+</table></td></tr></table>
+
+Oh, and note that the mode,ext,io extras are memorized 
+  in the respecitive ZZIP_DIR handle attached, so each
+  of the other calls like `zzip_file_open()`
+  and `zzip_read()` will be using them. There
+  are a few helper routines to help setup a new io-plugin
+  where the init_io will currently just memcopy the
+  default_io entries into the user-supplied plugin-struct.
+
+<table cellpadding="10" width="100%"><tr><td><table border="1" width="100%">
+<tr><td width="50%"> zzip_init_io </td>
+<td width="50%"> the recommended way to do things </td></tr>
+<tr><td width="50%"> zzip_get_default_io </td>
+<td width="50%"> used internally whenever you supply a null
+                     for the io-argument of a _ext_io()-call </td></tr>
+<tr><td width="50%"> zzip_get_default_ext </td>
+<td width="50%"> used internally but not exported </td></tr>
+</table></td></tr></table>
+
+And last some stdio-like replacements were build but these
+happen to be actually just small wrappers around the other
+posix-like magic-calls. It just offers some convenience
+since wrappers like "SDL_rwops" tend to use a stringised
+open-mode - and I took the occasion to fold the zzip-bits
+for the _ext_io-calls right in there recognized via 
+special extensions to the openmode-string of zzip_fopen().
+
+<table cellpadding="10" width="100%"><tr><td><table border="1" width="100%">
+<tr><td width="50%"> zzip_fopen </td>
+<td width="50%"> convert stringmode and call zzip_open_ext_io </td></tr>
+<tr><td width="50%"> zzip_fread </td>
+<td width="50%"> slower way to say zzip_read </td></tr>
+<tr><td width="50%"> zzip_fclose </td>
+<td width="50%"> a synonym of zzip_close </td></tr>
+</table></td></tr></table>
+
+For some reason, people did need the full set of function-calls()
+  to be working on zzip-wrappers too, so here they are - if the
+  ZZIP_FILE instance did wrap a real file, then the real posix-call
+  will be used, otherwise it is simulated on the compressed stream
+  with a zip-contained file - especially `seek()` can be 
+  a slow operation:
+  if the new point is later then just read out more bytes till we
+  hit that position but if it is an earlier point then rewind to the
+  beginning of the compressed data and start reading/decompression
+  until the position is met.
+
+<table cellpadding="10" width="100%"><tr><td><table border="1" width="100%">
+<tr><td width="50%"> zzip_rewind </td>
+<td width="50%"> magic for rewind() </td></tr>
+<tr><td width="50%"> zzip_tell </td>
+<td width="50%"> magic for tell() </td></tr>
+<tr><td width="50%"> zzip_seek </td>
+<td width="50%"> magic for seek() </td></tr>
+</table></td></tr></table>
+
+And last not least, there are few informative functions to
+use function-calls to read parts of the opaque structures
+of zzip-objects and their zzip-factory.
+
+<table cellpadding="10" width="100%"><tr><td><table border="1" width="100%">
+<tr><td width="50%"> zzip_dir_stat </td>
+<td width="50%"> a stat()-like thing on a file within a ZZIP_DIR </td></tr>
+<tr><td width="50%"> zzip_dir_real </td>
+<td width="50%"> check if ZZIP_DIR wraps a stat'able posix-dirent</td></tr>
+<tr><td width="50%"> zzip_file_real </td>
+<td width="50%"> check if ZZIP_FILE wraps a stat'able posix-file </td></tr>
+<tr><td width="50%"> zzip_realdir </td>
+<td width="50%"> if zzip_dir_real then return the posix-dirent </td></tr>
+<tr><td width="50%"> zzip_realfd </td>
+<td width="50%"> if zzip_file_real then return the posix-file </td></tr>
+<tr><td width="50%"> zzip_dirhandle </td>
+<td width="50%"> the attached ZZIP_DIR of compressed ZZIP_FILE </td></tr>
+<tr><td width="50%"> zzip_dirfd </td>
+<td width="50%"> the attached posix-file of ZZIP_DIR zip-file </td></tr>
+<tr><td width="50%"> zzip_set_error </td>
+<td width="50%"> set the last ZZIP_DIR error-code </td></tr>
+<tr><td width="50%"> zzip_error </td>
+<td width="50%"> get the last ZZIP_DIR error-code </td></tr>
+<tr><td width="50%"> zzip_strerror </td>
+<td width="50%"> convert a zzip_error into a readable string </td></tr>
+<tr><td width="50%"> zzip_strerror_of </td>
+<td width="50%"> combine both above zzip_strerror of zzip_error </td></tr>
+<tr><td width="50%"> zzip_errno </td>
+<td width="50%"> helper to wrap a zzip-error to a posix-errno </td></tr>
+<tr><td width="50%"> zzip_compr_str </td>
+<td width="50%"> helper to wrap a compr-number to a readable string
+                     </td></tr>
+<tr><td width="50%"> zzip_dir_free </td>
+<td width="50%"> internally called by zzip_dir_close if the ref-count 
+                     of the ZZIP_DIR has gone zero</td></tr>
+<tr><td width="50%"> zzip_freopen </td>
+<td width="50%"> to reuse the ZZIP_DIR from another ZZIP_FILE so it does
+                     not need to be parsed again </td></tr>
+<tr><td width="50%"> zzip_open_shared_io </td>
+<td width="50%"> the ext/io cousin but it does not close the old ZZIP_FILE
+                     and instead just shares the ZZIP_DIR if possible</td></tr>
+</table></td></tr></table>

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-file.htm.md Added

@@ -0,0 +1,150 @@
+<date> 1. June 2000 </date>
+
+## ZIP File Access 
+Using Zipped Files Transparently 
+
+### The Typedef
+
+The typedef `ZZIP_FILE` can serve as a replacement 
+ for a normal file descriptor. As long as it is only used
+ for reading a file, the zzlib-user can actually replace
+ the posix functions `open/read/close` 
+ by their counterparts from the 
+ zziplib library(zziplib.html):
+ `zzip_open/zzip_read/zzip_close`.
+
+As long as the filename path given to `zzip_open` 
+ refers to a real file in the filesystem, it will almost
+ directly forward the call to the respective posix `open` 
+ call. The returned file descriptor is then stored in
+ a member-variable of the `ZZIP_FILE` structure.
+
+Any subsequent calls to `zzip_read` will then
+ be forwarded to the posix `read` call on the
+ memorized file descriptor. The same about `zzip_close` 
+ which will call the posix `close` function and then
+ `free` the `ZZIP_FILE` structure.
+
+The real benefit of the 
+ zziplib library(zziplib.html) 
+ comes about when the filename argument does actually refer
+ to a file that is zipped in a zip-archive. It happens that
+ even both a real file and a zipped file can live under the
+ same pathname given to the `zzip_open` call,
+ whereas the real file is used in preference.
+
+### Zipped File
+
+Suppose you have subdirectory called '`test/`'. In
+ this directory is just one file, called '`README`'.
+ Calling the `zzip_open` function with an
+ argument of '*optional-path/*`test/README`',
+ then it will open that file for subsequent reading with
+ `zzip_read`. In this case the real (*stat'able*)
+ file is opened.
+
+Now you can go to the '`test/`' directory and zip up
+ the files in there by calling 
+ `zip ../test.zip *`.
+ After this, you can delete the '`test/`' directory and
+ the call to `zzip_open` will still succeed.
+ The reason is that the part of the path saying 
+ '`test/README`' will be replaced by sth. like 
+ '`test.zip:README`' - that is the real file '`test.zip`'
+ is opened and searched for a contained file '`README`'.
+
+Calling `zzip_read` on the zipped '`README`' file
+ will return the very same data as if it is a real file in a
+ real directory. If the zipped file is compressed it will be 
+ decompressed on the fly.
+
+### Zip Directory
+
+The same applies to the use of `opendir/readdir/closedir` 
+which can safely be replaced with their counterparts from the
+ zziplib library(zziplib.html) - again their prototype
+ follows the scheme of the original calls, just prepend `zzip_` 
+ to the function calls and `ZZIP_` to the struct-typedefs.
+
+To call `zzip_opendir` on a real directory will then
+ return a `ZZIP_DIR` whose member-variable 
+ `realdir` points to the actual `DIR`-structure
+ returned by the underlying posix `opendir`-call.
+
+If a real directory '`test`' does not exist, then the
+ `zzip_opendir` will try to open a file '`test.zip`'
+ with a call to `zzip_dir_open`.
+ Subsequent calls to `zzip_readdir` will then return
+ information as being obtained from the central archive directory
+ of the zip-file.
+
+### Differences
+
+There are no differences between the posix calls and their counterparts
+ from the      zziplib library(zziplib.html) - well, just
+ as long as the zip-file contains just the plain files from a directory.
+
+If the zip-file contains directory entries you may be prompted with
+ some awkward behaviour, since in zip-file a directory happens to be
+ just an empty file. Note that the posix function `open` 
+ may also open a directory for reading - it will only return 
+ `EISDIR` if the `open` mode-argument included
+ write-access.
+
+What the current of version of the 
+ zziplib library(zziplib.html) 
+ can definitely not do: calling zzip_opendir on a directory zippend
+ *inside* a zip-file.
+
+To prevent the enrollment of directories into the zip-archive, you
+ can use the `-D` option of the `zip` program. That
+ is in any `Makefile` you may want to use
+ `cd $(dir) && zip -D ../$(dir).zip *`.
+
+### Advantages
+
+Distribution of a set of files is much easier if it just means
+ to wrap up a group of files into a zip-archive - and copy that
+ zip-archive to the respective destination directory.
+ Even more the files can be compressed and unlike a `tar.gz` 
+ archive there is no need to decompress the archive in temporary
+ location before accessing a member-file.
+
+On the other hand, there is no chance to scatter files around
+ on the disk like it could easily happen with a set of gzip'ed
+ man-pages in a single `man`-directory. The reader
+ application does not specifically need to know that the file
+ is compressed, so that reading a script like 
+ `share/guile/x.x.x/ice-9/popen.scm` is done by simple
+ calls to `zzip_read` which works on zip-file named
+ `share/guile/x.x.x/ice-9.zip`.
+
+A version mismatch between different files in a group is now
+ obvious: either the opened file belongs to the distribution
+ archive, or otherwise in resides in a real directory **just
+ next to the zip-archive that contains the original**.
+
+### Issues
+
+The  zziplib library(zziplib.html) does not
+ use any code piece from the `zip` programs, neither
+ *pkzip* nor *infozip*, so there is no license
+ issue here. The decompression is done by using the free
+ zlib library(http://www.gzip.org/zlib) which has no special
+ issues with respect to licensing. 
+ The  rights to the zziplib library(zziplib.html) 
+ are reserved to the copyright holders, there is a public
+ license that puts most the sources themselves under 
+ the GNU Lesser General Public License(COPYING.LIB),
+ so that the use of a shared library instance of the
+ zziplib library(zziplib.html) 
+ has no restrictions of interest to application programmers.
+ For more details and hints about static linking, check
+ the COPYING(copying.html) information.
+
+The only issue you have with the
+ zziplib library(zziplib.html) 
+ is the fact that you can only *read* the contained files.
+ Writing/Compression is not implemented. Even more, a compressed
+ file is not seekable at the moment although I hope that someone
+ will stand up to implement that functionality someday.

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-index.htm.md Added

@@ -0,0 +1,44 @@
+<date> created 1.Jun.2000, last updated 09.Feb.2003 </date>
+
+## The Library 
+Overview
+
+The zziplib library(zziplib.html) is intentionally
+ lightweight, it offers the ability to easily extract data from 
+ files archived in a single zip file. Applications can bundle
+ files into a single zip archive and access them.
+ The implementation is based only on the (free) subset of 
+ compression with the zlib algorithm(http://www.gzip.org/zlib) 
+ which is actually used by the `zip/unzip` tools.
+
+The library allows reading zip archives in a number of ways,
+
+* archive mode: \
+  reading the zip directory and extracting files from it.
+  This is the traditional mode as seen with unzip-utilities.
+  Some extra unzip-utiles for transparent/magic mode are 
+  shipped as well.
+* replacement mode: \
+  Use ZZIP_FILE / ZZIP_DIR pointers provided by zziplib and
+  put them to work with routines originally developed to
+  work with real directories and file handles. The API calls
+  do follow traditional synopsis from posix/stdio.
+* transparent mode: \
+  Use replacement handles and allow the open()-calls to 
+  automatically detect when a file is contained in a zip 
+  archive or when it is a real file in the file system.
+  A filepath can be partly in a real filesystem and partly
+  within the zip archive when one is seen.
+* ext magic: \
+  Use the same filepath to access either a zipped or real
+  file - it looks for a real file and there is none then
+  every subdirectory of the path is checked, a ".zip"
+  extension appended, and the zipped file transparently
+  opened. This can speed up dat-file development 
+  dramatically.
+* io/xor magic: \
+  The access to the filesystem can be hooked up - examples
+  are given for xor obfuscation which is great for game
+  artwork and AI data. A small intro for SDLrwops usage is
+  given as well.
+

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-parse.htm.md Added

@@ -0,0 +1,186 @@
+<date> 17. December 2002 </date>
+
+## ZIP Format 
+About Zip Parsing Internals...
+
+### ZIP Trailer Block 
+
+The general ZIP file format is written sequentially - each file
+being added gets a local file header and its inflated data. When
+all files are written then a central directory is written - and
+this central directory may even span multiple disks. And each
+disk gets a descriptor block that contains a pointer to the start
+of the central directory. This descriptor is always written last
+and therefore we call it the "ZIP File Trailer Block".
+
+Okay, so we know that this ZIP Trailer is always at the end of a zip
+  file and that is has a fixed length, and a magic four-byte value at
+  its block start. That should make it easy to detect zip files but in
+  the real world it is not that easy - it is allowed to add a zip
+  archive comment text *after* the Trailer block. It's rarely
+  used these days but it turns out that a zip reader must be ready
+  to search for the Trailer block starting at the end of the file
+  and looking upwards for the Trailer magic (it's "PK\\5\\6" btw).
+
+Now that's what the internal function __zip_find_disk_trailer is
+used for. It's somewhat optimized as we try to use mmap features
+of the underlying operating system. The returned structure is 
+called zzip_disk_trailer in the library source code, and we only
+need two values actually: u_rootseek and u_rootsize. The first of
+these can be used to lseek to the place of the central directory
+and the second value tells us the byte size of the central directory.
+
+### ZIP Central Directory 
+
+So here we are at the central directory. The disk trailer did also
+tell us how many entries are there but it is not that easy to read
+them. Each directory entry (zzip_root_dirent type) has again a
+magic value up front followed by a few items but they all have some
+dos format - consider the timestamps, and atleast size/seek values 
+are in intel byteorder. So we might want to parse them into a format
+that is easier to handle in internal code.
+
+That is also needed for another reason - there are three items in that 
+directory entry being size values of three variadic fields following
+right after the directory. That's right, three of these. The first
+variadic field is the filename of this directory entry. In other
+words, the root directory entry does not contain a seek value of
+where the filename starts off, the start of the filename is 
+implicitly given with the end address of the directory entry.
+
+The size value for the filename does simply say how long the
+filename is - however, and more importantly, it allows us to 
+compute the start of the next variadic field, called the extra
+info field. Well, we do not need any value from that extra info
+block (it has unix filemode bits when packed under unix) but we
+can be quite sure that this field is not null either. And that
+was the second variadic field.
+
+There is a third variadic field however - it's the comment field.
+That was pretty heavily used in the good old DOS days. We are not
+used to it anymore since filenames are generally self-descriptive
+today but in the DOS days a filename was 8+3 chars maximum - and
+it was in the comment field that told users what's in there. It
+turned out that many software archives used zip format for just
+that purpose as their primary distribution format - for being 
+able to attach a comment line with each entry.
+
+Now, these three variadic fields have each an entry in the 
+directory entry header telling of their size. And after these
+three variadic fields the next directory entry follows right in.
+Yes, again there is no seek value here - we have to take the sum
+of the three field sizes and add that to the end address of the
+directory entry - just to be able to get to the next entry.
+
+### Internal Directory 
+
+Now, the external ZIP format is too complicated. We cut it down
+to the bare minimum we actually need. The fields in the entry
+are parsed into a format directly usable, and from the variadic
+fields we only keep the filename. Oh, and we ensure that the
+filename gets a trailing null byte, so it can surely be passed
+down into libc routines.
+
+There is another trick by the way - we use the u_rootsize value
+to malloc a block for the internal directory. That ensures the
+internal root directory entries are in nearby locations, and
+including the filenames themselves which we put in between the
+dirent entries. That's not only similar to the external directory
+format, but when calling readdir and looking for a matching
+filename of an zzip_open call, this will ensure the memory is
+fetched in a linear fashion. Modern cpu architectures are able
+to burst through it.
+
+One might think to use a more complicated internal directory
+format - like hash tables or something. However, they all suffer
+from the fact that memory access patterns will be somewhat random
+which eats a lot of speed. It is hardly predictable under what
+circumstances it gets us a benefit, but the problem is certainly
+not off-world: there are zzip archives with 13k+ entries. In a real
+filesystem people will not put 13k files into one directory, of 
+course - but for the zip central directory all entries are listed
+in parallel with their subdirectory paths attached. So, if the
+original subtree had a number of directories, they'll end up in
+parallel in the zip's central directory.
+
+### File Entry 
+
+The zip directory entry has one value that is called z_off in the
+zziplib sources - it's the seek value to the start of the actual
+file data, or more correctly it points to the "local file header".
+Each file data block is preceded/followed with a little frame.
+There is not much interesting information in these framing blocks, 
+the values are duplicates of the ones found in the zip central
+directory - however, we must skip the local file header (and a
+possible duplicate of filename and extrainfo) to arrive at the
+actual file data.
+
+When the start of the actual file data, we can finally read data.
+The zziplib library does only know about two choices defined by 
+the value in the z_compr field - a value of "0" means "stored"
+and data has been stored in uncompresed format, so that we can
+just copy it out of the file to the application buffer.
+
+A value of "8" means "deflated", and here we initialize the zlib
+and every file data is decompressed before copying it to the
+application buffer. Care must be taken here since zlib input data
+and decompressed data may differ significantly. The zlib compression
+will not even obey byte boundaries - a single bit may expand to
+hundreds of bytes. That's why each ZZIP_FILE has a decompression
+buffer attached.
+
+All the other z_compr values are only of historical meaning,
+the infozip unix tools will only create deflated content, and
+the same applies to pkzip 2.x tools. If there would be any other
+value than "0" or "8" then zziplib can not decompress it, simple
+as that.
+
+### ZZIP_DIR / ZZIP_FILE 
+
+The ZZIP_DIR internal structures stores a posix handle to the
+zip file, and a pointer to the parsed central directory block.
+One can use readdir/rewinddir to walk each entry in the central
+directory and compare with the filenames attached. And that's
+what will be done at a zzip_open call to find the file entry.
+
+There are a few more fields in the ZZIP_DIR structure, where 
+most of these are related to the use of this struct as a
+shared recource. You can use zzip_file_open to walk the 
+preparsed central directory and return a new ZZIP_FILE handle
+for that entry.
+
+That ZZIP_FILE handle contains a back pointer its ZZIP_DIR
+that it was made from - and the back pointer also serves as flag
+that the ZZIP_FILE handle points to a file within a ZIP file as
+opposed to wrapping a real file in the real directory tree.
+Each ZZIP_FILE will increment a shared counter, so that the
+next dir_close will be deferred until all ZZIP_FILE have been
+destroyed.
+
+Another optmization is the cache-pointer in the ZZIP_DIR. It is
+quite common to read data entries sequentially, as that the
+zip directory is scanned for files matching a specific pattern,
+and when a match is seen, that file is openened. However, each
+ZZIP_FILE needs a decompression buffer, and we keep a cache of
+the last one freed so that it can be picked up right away for the
+next zzip_file_open.
+
+Note that using multiple zzip_open() directly, each will open
+and parse a zip directory of its own. That's bloat both in
+terms of memory consumption and execution speed. One should try
+to take advantage of the feature that multiple ZZIP_FILE's can
+share a common ZZIP_DIR with a common preparsed copy of the
+zip's central directory. That can be done directly with using
+zzip_file_open to use a ZZIP_DIR as a factory for ZZIP_FILE,
+but also zzip_freopen can be used to reuse the old internal
+central directory, instead of parsing it again.
+
+And while zzip_freopen would release the old ZZIP_FILE handle
+only resuing the ZZIP_DIR attached, one can use another routine
+directly called zzip_open_shared that will create a ZZIP_FILE
+from an existing ZZIP_FILE. Oh, and not need to worry about 
+problems when a filepath given to zzip_freopen() happens to
+be in another place, another directory, another zip archive.
+In that case, the old zzip's internal directory is freed and
+the others directory read - the preparsed central directory
+is only used if that is actually possible.

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-sdl-rwops.htm.md Added

@@ -0,0 +1,73 @@
+<date> 19. Aug 2001 </date>
+
+## SDL rwops 
+Example to make an SDL_rwops interface.
+
+<small> some <b>MSVC</b> help in 
+   <a href="README.MSVC6">README.MSVC6</a> and
+   <a href="README.SDL">README.SDL</a>
+</small>
+
+### Source 
+
+The example sources of the zziplib library(zziplib.html) 
+ are usually put under the ZLIB license(COPYING.ZLIB) so 
+ that you can reuse the code freely in your own projects. Here we talk
+ about the example that might be most useful for 
+ SDL(http://libsdl.org) based programs.
+ Just copy the two files 
+ SDL_rwops_zzip.h(SDL_rwops_zzip.h)
+ and
+ SDL_rwops_zzip.c(SDL_rwops_zzip.c) 
+ to the directory with your other project sources, and make sure
+ to link it somehow to your programs. I did not make the effort to
+ create a separate library out of it - it would just export one
+ single function `SDL_RWFromZZIP` that has the same call-synopsis
+ like `SDL_RWFromFile` (but it can not (yet) write a zip-file).
+
+The source file SDL_rwops_zzip.c(SDL_rwops_zzip.c) is
+ quite short - it just stores a ZZIP_FILE handle in the userdata
+ field of the `SDL_rwops` structure. The SDL'rwop calls will then
+ fetch that pointer and call the corresponding functions from the
+ zziplib library(zziplib.html). Most of the glue code
+ is in the `SDL_RWFromZZIP` function that allocates an 
+ `SDL_rwops` structure and fills the handler-functions 
+ into the callback fields.
+
+### Usage 
+
+If you link this file to your project, remember that your executables
+ do now have additional dependencies - not only -lzzip to link with
+ the zziplib library(zziplib.html) - do not forget to
+ link with zlib library via -lz. Of course, there is a lib-config
+ script that you can use: `zzip-config --libs` will return these
+ linker-infos (unless you have a native-windows system - it is 
+ shell-script).
+
+As an example, replace that `SDL_RWFromFile` that accesses your
+ game-graphic files - these files are stored in shared/myapp
+ of course where they belong. When you've done that
+ then go to X/share/myapp and  \
+ `(cd graphics/ && zip -9r ../graphics.zip .)`  \
+ and rename the graphics/ subfolder - and still all your files
+ are found: a filepath like X/shared/graphics/game/greetings.bmp 
+ will open X/shared/graphics.zip and return the zipped file 
+ game/greetings.bmp in the zip-archive (for reading that is).
+
+### Test 
+
+The zziplib(zziplib.html) configure script does not
+ look for SDL(http://libsdl.org). If you know that
+ you have SDL(http://libsdl.org) installed 
+ then you can check this `SDL_rwops` example by using
+ `make testsdl`. This will compile the
+ two source files SDL_rwops_zzip.c(SDL_rwops_zzip.c) 
+ and SDL_rwops_zzcat.c(SDL_rwops_zzcat.c) to be linked
+ together into an executable called `zzcatsdl`. The test
+ will continue with a `zzcatsdl test/README`
+ - just like it is done for `make test3`.
+
+The corresponding section in the Makefile.am(Makefile.am) 
+ is also an example how to use lib-config scripts to build files. Here
+ there is no build-processing that had been tweaked much by automake/autoconf.
+ Just use sdl-config and zzip-config to add the needed flags.

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-xor.htm.md Added

@@ -0,0 +1,74 @@
+<date> 15. July 2002 </date>
+
+## ZIP Obfuscation 
+Using obfuscations like XOR.
+
+### The EXT/IO calls 
+
+You really should read the section about the
+  EXT/IO feature(zzip-extio.html) of the zziplib since the
+  obfuscation routines are built on top of it. In order to use obfuscation,
+  you will generally need to use all the three additional argument that
+  can be passsed to _open_ext_io functions. For the XOR-example, only one
+  IO-handler is modified being the read()-call that will simply xor each
+  data byte upon read with a specific value. It two advantages - doing an
+  xor twice does yield the same data, so as a developer you do not have
+  to wonder about the encryption/decryption pair, and it is a stateless
+  obfuscation that does not need to know about the current position
+  within the zip-datafile or zippedfile-datatream.
+
+The examples provided just use a simple routine for xoring data that
+  is defined in all the three of the example programs: 
+
+```
+static int xor_value = 0x55;
+      static zzip_ssize_t xor_read (int f, void* p, zzip_size_t l)
+      {
+          zzip_size_t r = read(f, p, l);
+	  zzip_size_t x;  char* q = p;
+          for (x=0; x < r; x++) qx ^= xor_value;
+          return r;
+      }
+```
+
+and place this routine into the io-handlers after initializing
+  the structure: 
+
+```
+zzip_init_io (&xor_handlers, 0); xor_handlers.read = &xor_read;
+```
+
+### The examples 
+
+There are three example programs. The first one is
+  zzxorcopy.c(zzxorcopy.c) which actually is not a zziplib 
+  based program. It just opens a file via stdio, loops through all data bytes 
+  it can read thereby xor'ing it, and writes it out to the output file. A 
+  call like `"zzxorcopy file.zip file.dat"` will
+  create an obfuscated dat-file from a zip-file that has been possibly
+  create with the normal infozip tools or any other archive program to
+  generate a zip-file. The output dat-file is not recognized by normal
+  zip-enabled apps - the filemagic is obfuscated too. This output
+  dat-file however is subject to the other two example programs.
+
+The zzxordir.c(zzxordir.c) program will open such an obfuscated
+  zip file and decode the central directory of that zip. Everything is
+  still there in just the way it can be shown with the normal unzip
+  programs and routines. And the zzxorcat.c(zzxorcat.c) program 
+  can extract data from this obfuscated zip - and print it un-obfuscated
+  to the screen. These example programs can help you jumpstart with
+  your own set of obfuscator routines, possibly more complex ones.
+
+By the way, just compare those with their non-xor counterparts that
+  you can find in zzdir.c(zzdir.c) and 
+  zzxorcat.c(zzxorcat.c). Notice that the difference is
+  in the setup part until the _open_ call after which one can just
+  use the normal zzip_ routines on that obfuscated file. This is
+  great for developing since you can start of with the magic-wrappers
+  working on real-files then slowly turning to pack-files that hold
+  most of the data and finally ending with a zip-only and obfuscated
+  dat-file for your project.
+
+<small><small>
+<a href="copying.html">staticlinking?</a>
+</small></small>

_service:tar_scm:v0.13.74.tar.gz/docs/zzip-zip.htm.md Added

@@ -0,0 +1,131 @@
+<date> 1. June 2000 </date>
+
+## ZIP Access 
+Accessing Zip Archives with ZLib Decompression
+
+### The Library 
+
+The zziplib library(zziplib.html) offers users the
+ ability to easily extract data from files archived in a single
+ zip file. This way, programs that use many "read-only" files from
+ a program specific source directory can have a single zip
+ archive
+
+This library offers only a (free) subset of compression methods
+ provided in a full implementation but that is well enough. The
+ idea here is that `zip/unzip` utilities can be used
+ to create archives that will later be read by using this library.
+ Yet those programmes (or a library with their functionality)
+ is not needed in that final operation.
+
+### Using A Zip-File 
+
+Before a file in the zip-archive is accessed, the application
+ must first get a handle to the central directory contained in the
+ zip-file. This is achieved by calling
+  zzip_dir_open (zziplib.html#zzip_dir_open)
+ or 
+  zzip_dir_fdopen (zziplib.html#zzip_dir_fdopen).
+ The directory entries in the zip-archives can be obtained
+ with
+  zzip_dir_read (zziplib.html#zzip_dir_read).
+ After being done, the zip-dir handle should be closed with
+  zzip_dir_close (zziplib.html#zzip_dir_close).
+
+```
+ZZIP_DIR* dir = zzip_dir_open("test.zip",0);
+ if (dir) {
+   ZZIP_DIRENT dirent;
+   if (zzip_dir_read(dir,&dirent) {
+     /* show info for first file */
+     print("%s %i/%i", dirent.d_name, dirent.d_csize, dirent.st_size);
+   }
+   zzip_dir_close(dir);
+ }
+```
+
+From the zip-dir handle a compressed file can be opened
+ for reading. This is achieved by using 
+  zzip_file_open (zziplib.html#zzip_file_open) 
+ and providing it with the dir-handle and a name of the file.
+ The function
+  zzip_file_read (zziplib.html#zzip_file_read) 
+ is used to get pieces of uncompressed data from the file, and
+ the file-handle should be closed with
+  zzip_file_close (zziplib.html#zzip_file_close)
+
+```
+ZZIP_FILE* fp = zzip_file_open(dir,"README",0);
+ if (fp) {
+   char buf10;
+   zzip_ssize_t len = zzip_file_read(fp, buf, 10);
+   if (len) {
+     /* show head of README */
+     write(1, buf, len); 
+   }
+   zzip_file_close(fp);
+ }
+```
+
+### Magic Zipped Files 
+
+There is actually no need to directly use the zip-centric functions
+ as described above. Instead there are magic replacements for the
+ posix calls `open/read/close` and 
+ `opendir/readdir/closedir`. The prototypes of these
+ functions had been the guideline for the design of their magic
+ counterparts of the
+ zziplib library(zziplib.html).
+
+The magic functions are described in a separated document on
+  Using Zipped Files (zzip-file.html). In general,
+ the functions have a prefix `zzip_` and their argument
+ types have a prefix `ZZIP_` where appropriate. Calls
+ to the magic functions and the direct functions above can
+ be mixed as long as the magic functions have not been opening
+ a real file.
+
+To detect a real file (or directory), the info functions
+  zzip_file_real (zziplib.html#zzip_file_real)
+ and
+  zzip_dir_real (zziplib.html#zzip_dir_real)
+ can be used.
+ If these return a true value, the standard posix functions
+ are more appropriate. The posix handles can be obtained with
+ a call to
+  zzip_realdir (zziplib.html#zzip_realdir) and
+  zzip_realfd (zziplib.html#zzip_realfd) respectively.
+
+### Errors & Infos 
+
+There are a set of error and info functions available. To handle
+ error conditions specific to the
+ zziplib library(zziplib.html) 
+ there are these functions:
+  zzip_error (zziplib.html#zzip_error),
+  zzip_seterror (zziplib.html#zzip_seterror) 
+ and their string representations with
+  zzip_strerror (zziplib.html#zzip_strerror),
+  zzip_strerror_of (zziplib.html#zzip_strerror_of).
+ The magic functions will map any of these specific library
+ error conditions to the more generic system `errno` 
+ codes with
+  zzip_errno (zziplib.html#zzip_errno).
+
+More information on stream can be obtained with
+  zzip_dir_stat (zziplib.html#zzip_dir_stat) and
+  zzip_dirhandle. (zziplib.html#zzip_dirhandle) 
+ The latter is used to obtain the dir-handle that every zipped file 
+ handle has even if not explicitly opened.
+
+The usage of many functions are shown in the example programs
+ that come along with the
+ zziplib library(zziplib.html). See the files
+  zzcat.c (zzcat.c) and
+  zzdir.c (zzdir.c). The 
+  zziptest.c (zziptest.c) program needs the
+ private header file 
+  zzip.h (zzip.h) whereas the library installer
+ will only copy the public include file 
+  zziplib.h (zziplib.h) to your system's
+ `include` directory.

_service:tar_scm:v0.13.72.tar.gz/docs/zzipdoc/docbookdocument.py -> _service:tar_scm:v0.13.74.tar.gz/docs/zzipdoc/docbookdocument.py Changed

_service:tar_scm:v0.13.72.tar.gz/docs/zzipdoc/functionlistreference.py -> _service:tar_scm:v0.13.74.tar.gz/docs/zzipdoc/functionlistreference.py Changed

_service:tar_scm:v0.13.72.tar.gz/docs/zzipdoc/htmldocument.py -> _service:tar_scm:v0.13.74.tar.gz/docs/zzipdoc/htmldocument.py Changed

_service:tar_scm:v0.13.72.tar.gz/docs/zzipdoc/match.py -> _service:tar_scm:v0.13.74.tar.gz/docs/zzipdoc/match.py Changed

_service:tar_scm:v0.13.72.tar.gz/docs/zzipdoc/options.py -> _service:tar_scm:v0.13.74.tar.gz/docs/zzipdoc/options.py Changed

_service:tar_scm:v0.13.74.tar.gz/setup.cfg Added

@@ -0,0 +1,59 @@
+# __version__
+
+metadata
+name = zziplib-tools
+version = 0.13.20
+license = APL
+license_files = 
+   LICENSE
+author = Guido U. Draheim
+author-email = Guido.Draheim@gmx.de
+home-page = https://github.com/gdraheim/zziplib
+description = Test tools and man page generators for zziplib
+long-description = file: README.MD
+long-description-content-type = text/markdown
+requires-dist = setuptools
+
+options
+include_package_data=True
+scripts =
+  testbuilds.py
+  test/zziptests.py
+  docs/toolstests.py
+
+options.data_files
+data =
+   LICENSE
+   README.MD
+
+bdist_wheel
+universal = 1
+
+pycodestyle
+max-line-length = 127
+ignore = E301,E302,E305,E306,E701
+# E301 Add missing blank line. (expected 1 blank line, found 0)
+# E302 Add missing 2 blank lines. (expected 2 blank lines, found 0)
+# E305 - (expected 2 blank lines after end of function or class)
+# E306 - (expected 1 blank line before a nested definition)
+# E701 Put colon-separated compound statement on separate lines. (multiple statements on one line (colon))
+
+mypy
+## strict = true # not allowed in setup.cfg
+unused_configs = true
+disallow_subclassing_any = true
+disallow_any_generics = true
+disallow_untyped_calls = true
+disallow_untyped_defs = true 
+disallow_incomplete_defs = true 
+check_untyped_defs = true
+disallow_untyped_decorators = true 
+no_implicit_optional = true 
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_return_any = true
+## extra:
+disallow_any_unimported = true
+# disallow_any_expr = true
+disallow_any_decorated = true
+#? disallow_any_explicit = true

_service:tar_scm:v0.13.72.tar.gz/test/CMakeLists.txt -> _service:tar_scm:v0.13.74.tar.gz/test/CMakeLists.txt Changed

_service:tar_scm:v0.13.72.tar.gz/test/zziptests.py -> _service:tar_scm:v0.13.74.tar.gz/test/zziptests.py Changed

@@ -1,3 +1,5 @@
+#! /usr/bin/env python3
+from typing import Union, Optional, Tuple, List, Dict, Sequence, Iterator, cast
 import unittest
 import subprocess
 import logging
@@ -12,15 +14,15 @@
 from fnmatch import fnmatchcase as matches
 
 try:
-    from cStringIO import StringIO
+    from cStringIO import StringIO  # type: ignoreimport, attr-defined
 except ImportError:
-    from io import StringIO
+    from io import StringIO  # Python3
 
 try:
-    from urllib import quote_plus, urlretrieve
+    from urllib import quote_plus, urlretrieve  # type: ignoreimport, attr-defined
 except ImportError:
-    from urllib.parse import quote_plus
-    from urllib.request import urlretrieve
+    from urllib.parse import quote_plus  # Python3
+    from urllib.request import urlretrieve  # Python3
 
 if sys.version0 == '3':
     basestring = str
@@ -38,43 +40,48 @@
 downloaddir = "tmp.download"
 downloadonly = False
 nodownloads = False
+KEEP = False
 
-def yesno(text):
+def yesno(text: str) -> bool:
     if not text: return False
     if text.lower() in "y", "yes", "t", "true", "on", "ok":
         return True
     return False
 
-def decodes(text):
+def decodes(text: Unionstr, bytes) -> str:
     if text is None: return None
     if isinstance(text, bytes):
         encoded = sys.getdefaultencoding()
         if encoded in "ascii":
             encoded = "utf-8"
-        try: 
+        try:
             return text.decode(encoded)
         except:
             return text.decode("latin-1")
+    return text
 
-def shell_string(command):
-   return " ".join("'%s'" % arg.replace("'","\\'") for arg in command)
+def shell_string(command: Liststr) -> str:
+    return " ".join("'%s'" % arg.replace("'", "\\'") for arg in command)
 
-def shell(command, shell=True, calls=False, cwd=None, env=None, lang=None, returncodes=None):
-    returncodes = returncodes or  None, 0 
-    Shell = collections.namedtuple("Shell","returncode", "output", "errors", "shell")
+Shell = collections.namedtuple("Shell", "returncode", "output", "errors", "shell")
+def shell(command: Unionstr, Liststr, shell: bool = True,  # ..
+          # ..
+          calls: bool = False, cwd: Optionalstr = None, env: OptionalDictstr, str = None, lang: Optionalstr = None,
+          returncodes: OptionalSequenceOptionalint = None) -> Shell:
+    returncodes = returncodes or None, 0
     if isinstance(command, basestring):
-       sh_command = command
-       command =  command 
+        sh_command = command
+        command = command
     else:
-       sh_command = shell_string(command)
-    if not env: 
+        sh_command = shell_string(command)
+    if not env:
         env = os.environ.copy()
     if lang:
         for name, value in env.items():
             if name.startswith("LC_"):
                 envname = lang
-        env"LANG" = lang # defines message format
-        env"LC_ALL" = lang # other locale formats
+        env"LANG" = lang  # defines message format
+        env"LC_ALL" = lang  # other locale formats
     zzip_libs = "/zzip/.libs"
     zzip_cmds = command0.split(" ")0
     build_lib1 = os.path.dirname(os.path.realpath(zzip_cmds))
@@ -89,15 +96,15 @@
     try:
         output, errors = "", ""
         if calls:
-            logg.debug("result from %s: %s", cwd and cwd+"/" or "shell", sh_command)
+            logg.debug("result from %s: %s", cwd and cwd + "/" or "shell", sh_command)
             run = subprocess.Popen(command, shell=shell, cwd=cwd, env=env)
             if run.returncode:
                 logg.warning("EXIT %s: %s", run.returncode, command)
             run.wait()
         else:
-            logg.debug("output from %s: %s", cwd and cwd+"/" or "shell", sh_command)
+            logg.debug("output from %s: %s", cwd and cwd + "/" or "shell", sh_command)
             run = subprocess.Popen(command, shell=shell, cwd=cwd,
-                stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=None, env=env)
+                                   stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=None, env=env)
             if run.returncode:
                 logg.warning("EXIT %s: %s", run.returncode, command)
             out, err = run.communicate()
@@ -130,16 +137,16 @@
                 logg.debug("ERR: %s", line)
     return Shell(run.returncode, output, errors, sh_command)
 
-def get_caller_name():
-    frame = inspect.currentframe().f_back.f_back
-    return frame.f_code.co_name
-def get_caller_caller_name():
-    frame = inspect.currentframe().f_back.f_back.f_back
-    return frame.f_code.co_name
+def get_caller_name() -> str:
+    frame = inspect.currentframe().f_back.f_back  # type: ignoreunion-attr
+    return frame.f_code.co_name  # type: ignoreunion-attr
+def get_caller_caller_name() -> str:
+    frame = inspect.currentframe().f_back.f_back.f_back  # type: ignoreunion-attr
+    return frame.f_code.co_name  # type: ignoreunion-attr
 
-def download_raw(base_url, filename, into, style = "?raw=true"):
+def download_raw(base_url: str, filename: str, into: Optionalstr, style: str = "?raw=true") -> UnionNone, bool, str:
     return download(base_url, filename, into, style)
-def download(base_url, filename, into = None, style = ""):
+def download(base_url: str, filename: str, into: Optionalstr = None, style: str = "") -> UnionNone, bool, str:
     if nodownloads:
         return False
     data = downloaddir
@@ -151,26 +158,26 @@
         os.makedirs(subdir)
     subfile = os.path.join(subdir, filename)
     if not os.path.exists(subfile) and "---" in base_url:
-       my_downloads = os.path.expanduser("~/Downloads")
-       srcfile = os.path.join(my_downloads, filename)
-       if os.path.exists(srcfile):
-          shutil.copy(srcfile, subfile)
+        my_downloads = os.path.expanduser("~/Downloads")
+        srcfile = os.path.join(my_downloads, filename)
+        if os.path.exists(srcfile):
+            shutil.copy(srcfile, subfile)
     if not os.path.exists(subfile):
-       logg.info("need %s", subfile)
-       try:
-           url = base_url + "/" + filename + style
-           url = url.replace("/blob/", "/raw/")
-           logg.info("curl %s", url)
-           urlretrieve(url, subfile)
-       except:
-           # Ensure zero-length file exists in case we couldn't
-           # download the file so that we won't try to
-           # re-download it.
-           open(subfile, 'a').close()
+        logg.info("need %s", subfile)
+        try:
+            url = base_url + "/" + filename + style
+            url = url.replace("/blob/", "/raw/")
+            logg.info("curl %s", url)
+            urlretrieve(url, subfile)
+        except:
+            # Ensure zero-length file exists in case we couldn't
+            # download the file so that we won't try to
+            # re-download it.
+            open(subfile, 'a').close()
     if not os.path.exists(subfile):
-       return None
+        return None
     if os.path.getsize(subfile) < 5:
-       return None
+        return None
     #
     if into:
         if not os.path.isdir(into):
@@ -180,19 +187,19 @@
         logg.debug("copied %s -> %s", subfile, intofile)
     return filename
 
-def output(cmd, shell=True):
+def output(cmd: Unionstr, Liststr, shell: bool = True) -> str:
     run = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE)
     out, err = run.communicate()
     return out.decode('utf-8')
-def grep(pattern, lines):
+def grep(pattern: str, lines: Unionstr, Liststr) -> Iteratorstr:
     if isinstance(lines, basestring):
         lines = lines.split("\n")
     for line in lines:
-       if re.search(pattern, line.rstrip()):
-           yield line.rstrip()
-def greps(lines, pattern):
+        if re.search(pattern, line.rstrip()):
+            yield line.rstrip()
+def greps(lines: Unionstr, Liststr, pattern: str) -> Liststr:
     return list(grep(pattern, lines))
-def all_errors(lines):

_service:tar_scm:v0.13.72.tar.gz/testbuilds.py -> _service:tar_scm:v0.13.74.tar.gz/testbuilds.py Changed

@@ -4,6 +4,7 @@
 __copyright__ = "(C) Guido Draheim, all rights reserved"""
 __version__ = "0.13.72"
 
+from typing import Union, Optional, Tuple, List, Iterator
 import subprocess
 import os.path
 import time
@@ -14,6 +15,7 @@
 import types
 import logging
 import re
+from collections import namedtuple
 from fnmatch import fnmatchcase as fnmatch
 from glob import glob
 import json
@@ -28,71 +30,75 @@
 
 SAVETO = "localhost:5000/zziplib"
 IMAGES = "localhost:5000/zziplib/image"
-CENTOS8 = "centos:8.3.2011"
+CENTOS9 = "almalinux:9.3"
 CENTOS7 = "centos:7.9.2009"
 UBUNTU1 = "ubuntu:18.04"
 UBUNTU2 = "ubuntu:16.04"
 UBUNTU3 = "ubuntu:20.04"
+UBUNTU4 = "ubuntu:22.04"
 OPENSUSE5 = "opensuse/leap:15.2"
 SOFTWARE = "../Software"
 
 DOCKER_SOCKET = "/var/run/docker.sock"
 DOCKER = "docker"
+KEEP = False
 FORCE = False
 NOCACHE = False
 
 MAINDIR = os.path.dirname(sys.argv0) or "."
 MIRROR = os.path.join(MAINDIR, "docker_mirror.py")
+LOCAL = 0
 
-def decodes(text):
+def decodes(text: Unionbytes, str) -> str:
     if text is None: return None
     if isinstance(text, bytes):
         encoded = sys.getdefaultencoding()
         if encoded in "ascii":
             encoded = "utf-8"
-        try: 
+        try:
             return text.decode(encoded)
         except:
             return text.decode("latin-1")
     return text
-def sh____(cmd, shell=True):
+def sh____(cmd: Unionstr, Liststr, shell: bool = True) -> int:
     if isinstance(cmd, basestring):
         logg.info(": %s", cmd)
-    else:    
+    else:
         logg.info(": %s", " ".join("'%s'" % item for item in cmd))
     return subprocess.check_call(cmd, shell=shell)
-def sx____(cmd, shell=True):
+def sx____(cmd: Unionstr, Liststr, shell: bool = True) -> int:
     if isinstance(cmd, basestring):
         logg.info(": %s", cmd)
-    else:    
+    else:
         logg.info(": %s", " ".join("'%s'" % item for item in cmd))
     return subprocess.call(cmd, shell=shell)
-def output(cmd, shell=True):
+def output(cmd: Unionstr, Liststr, shell: bool = True) -> str:
     if isinstance(cmd, basestring):
         logg.info(": %s", cmd)
-    else:    
+    else:
         logg.info(": %s", " ".join("'%s'" % item for item in cmd))
     run = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE)
     out, err = run.communicate()
     return decodes(out)
-def output2(cmd, shell=True):
+def output2(cmd: Unionstr, Liststr, shell: bool = True) -> Tuplestr, int:
     if isinstance(cmd, basestring):
         logg.info(": %s", cmd)
-    else:    
+    else:
         logg.info(": %s", " ".join("'%s'" % item for item in cmd))
     run = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE)
     out, err = run.communicate()
     return decodes(out), run.returncode
-def output3(cmd, shell=True):
+def output3(cmd: Unionstr, Liststr, shell: bool = True) -> Tuplestr, str, int:
     if isinstance(cmd, basestring):
         logg.info(": %s", cmd)
-    else:    
+    else:
         logg.info(": %s", " ".join("'%s'" % item for item in cmd))
     run = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     out, err = run.communicate()
     return decodes(out), decodes(err), run.returncode
-def background(cmd, shell=True):
-    BackgroundProcess = collections.namedtuple("BackgroundProcess", "pid", "run", "log" )
+
+BackgroundProcess = namedtuple("BackgroundProcess", "pid", "run", "log")
+def background(cmd: Liststr, shell: bool = True) -> BackgroundProcess:
     log = open(os.devnull, "wb")
     run = subprocess.Popen(cmd, shell=shell, stdout=log, stderr=log)
     pid = run.pid
@@ -100,82 +106,83 @@
     return BackgroundProcess(pid, run, log)
 
 
-
-def _lines(lines):
+def _lines(lines: Unionstr, Liststr) -> Liststr:
     if isinstance(lines, basestring):
-        lines = lines.split("\n")
-        if len(lines) and lines-1 == "":
-            lines = lines:-1
+        xlines = lines.split("\n")
+        if len(xlines) and xlines-1 == "":
+            xlines = xlines:-1
+        return xlines
     return lines
-def lines(text):
+def lines(text: Unionstr, Liststr) -> Liststr:
     lines = 
     for line in _lines(text):
         lines.append(line.rstrip())
     return lines
-def grep(pattern, lines):
+def grep(pattern: str, lines: Unionstr, Liststr) -> Iteratorstr:
     for line in _lines(lines):
-       if re.search(pattern, line.rstrip()):
-           yield line.rstrip()
-def greps(lines, pattern):
+        if re.search(pattern, line.rstrip()):
+            yield line.rstrip()
+def greps(lines: Unionstr, Liststr, pattern: str) -> Liststr:
     return list(grep(pattern, lines))
 
-def download(base_url, filename, into):
+def download(base_url: str, filename: str, into: str) -> None:
     if not os.path.isdir(into):
         os.makedirs(into)
     if not os.path.exists(os.path.join(into, filename)):
         sh____("cd {into} && wget {base_url}/{filename}".format(**locals()))
-def text_file(filename, content):
+def text_file(filename: str, content: str) -> None:
     filedir = os.path.dirname(filename)
     if not os.path.isdir(filedir):
         os.makedirs(filedir)
     f = open(filename, "w")
     if content.startswith("\n"):
         x = re.match("(?s)\n( *)", content)
+        assert x is not None
         indent = x.group(1)
         for line in content1:.split("\n"):
             if line.startswith(indent):
                 line = linelen(indent):
-            f.write(line+"\n")
+            f.write(line + "\n")
     else:
         f.write(content)
     f.close()
-def shell_file(filename, content):
+def shell_file(filename: str, content: str) -> None:
     text_file(filename, content)
     os.chmod(filename, 0o770)
-def copy_file(filename, target):
+def copy_file(filename: str, target: str) -> None:
     targetdir = os.path.dirname(target)
     if not os.path.isdir(targetdir):
         os.makedirs(targetdir)
     shutil.copyfile(filename, target)
-def copy_tool(filename, target):
+def copy_tool(filename: str, target: str) -> None:
     copy_file(filename, target)
     os.chmod(target, 0o750)
 
-def get_caller_name():
-    frame = inspect.currentframe().f_back.f_back
-    return frame.f_code.co_name
-def get_caller_caller_name():
-    frame = inspect.currentframe().f_back.f_back.f_back
-    return frame.f_code.co_name
-def os_path(root, path):
+def get_caller_name() -> str:
+    frame = inspect.currentframe().f_back.f_back  # type: ignoreunion-attr
+    return frame.f_code.co_name  # type: ignoreunion-attr
+def get_caller_caller_name() -> str:
+    frame = inspect.currentframe().f_back.f_back.f_back  # type: ignoreunion-attr
+    return frame.f_code.co_name  # type: ignoreunion-attr
+def os_path(root: Optionalstr, path: str) -> str:
     if not root:
         return path
     if not path:
         return path
     while path.startswith(os.path.sep):
-       path = path1:
+        path = path1:

_service:tar_scm:v0.13.74.tar.gz/testbuilds/almalinux9-am-build.dockerfile Added

@@ -0,0 +1,31 @@
+FROM almalinux:9.3
+ARG no_check=false
+ARG no_install=false
+
+ARG _libdir=/usr/local/lib64
+ARG _docdir=/usr/share/doc
+
+RUN echo sslverify=false >> /etc/yum.conf
+RUN yum install -y gcc zlib-devel python3 cmake make unzip zip gzip tar diffutils
+
+RUN mkdir src
+COPY Makefile.am Makefile.in old.configure.ac old.configure config.h.in zziplib.spec src/
+RUN test ! -f src/old.configure || mv src/old.configure src/configure
+RUN test ! -f src/old.configure.ac || mv src/old.configure.ac src/configure.ac
+COPY uses src/uses
+
+COPY CMakeLists.txt README COPYING.LIB ChangeLog src/
+COPY CMakeScripts src/CMakeScripts
+COPY bins src/bins
+COPY docs src/docs
+COPY test src/test
+COPY SDL src/SDL
+COPY zzipwrap src/zzipwrap
+COPY zzip src/zzip
+
+RUN mkdir src/build
+RUN cd src/build && sh ../configure --libdir=$_libdir --with-docdir=$_docdir --disable-static
+RUN cd src/build && make
+RUN $no_check || (cd src/build && make check)
+RUN $no_install || (cd src/build && make install)
+

_service:tar_scm:v0.13.74.tar.gz/testbuilds/almalinux9-am-sdl2.dockerfile Added

@@ -0,0 +1,33 @@
+FROM almalinux:9.3
+ARG no_check=false
+ARG no_install=false
+
+ARG _libdir=/usr/local/lib64
+ARG _docdir=/usr/share/doc
+
+RUN echo sslverify=false >> /etc/yum.conf
+RUN yum install -y yum-utils
+RUN yum search sdl
+RUN yum install -y gcc zlib-devel python3 cmake make unzip zip gzip tar diffutils  SDL2-devel
+
+RUN mkdir src
+COPY Makefile.am Makefile.in old.configure.ac old.configure config.h.in zziplib.spec src/
+RUN test ! -f src/old.configure || mv src/old.configure src/configure
+RUN test ! -f src/old.configure.ac || mv src/old.configure.ac src/configure.ac
+COPY uses src/uses
+
+COPY CMakeLists.txt README COPYING.LIB ChangeLog src/
+COPY CMakeScripts src/CMakeScripts
+COPY bins src/bins
+COPY docs src/docs
+COPY test src/test
+COPY SDL src/SDL
+COPY zzipwrap src/zzipwrap
+COPY zzip src/zzip
+
+RUN mkdir src/build
+RUN cd src/build && sh ../configure --libdir=$_libdir --with-docdir=$_docdir --disable-static --enable-sdl
+RUN cd src/build && make
+RUN $no_check || (cd src/build && make check)
+RUN $no_install || (cd src/build && make install)
+

_service:tar_scm:v0.13.74.tar.gz/testbuilds/almalinux9-cm-build.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/almalinux9-cm-destdir-sdl2.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/almalinux9-cm-sdl2.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/opensuse15-cm-htmpages.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/opensuse15-use-gcc10.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/opensuse15-use-gcc11.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/opensuse15-use-gcc12.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/opensuse15-use-gcc13.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/opensuse15-use-gcc7.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/opensuse15-use-gcc8.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/opensuse15-use-gcc9.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/ubuntu18-cm-sdl2.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/ubuntu20-cm-build.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/ubuntu20-cm-sdl2.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/ubuntu22-cm-build.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/ubuntu22-cm-sdl2.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/ubuntu24-cm-build.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/ubuntu24-cm-sdl2.dockerfile Added

_service:tar_scm:v0.13.74.tar.gz/testbuilds/ubuntu24-use-gcc14.dockerfile Added

_service:tar_scm:v0.13.72.tar.gz/testbuilds/windows-shared-x64.dockerfile -> _service:tar_scm:v0.13.74.tar.gz/testbuilds/windows-shared-x64.dockerfile Changed

_service:tar_scm:v0.13.72.tar.gz/zzip/CMakeLists.txt -> _service:tar_scm:v0.13.74.tar.gz/zzip/CMakeLists.txt Changed

@@ -11,15 +11,16 @@
 include ( TestBigEndian )
 include ( GNUInstallDirs )
 include ( JoinPaths )
+include ( CheckVerboseSymlink )
+include ( CheckCCompilerFlag )
 
 # options ###########################################################
 option(BUILD_SHARED_LIBS "Build a shared library" ON)
-option(BUILD_STATIC_LIBS "Build the static library" OFF)
 option(MSVC_STATIC_RUNTIME "Build with static runtime libs (/MT)" ON)
 option(ZZIPMMAPPED "Build libzzipmmapped (not fully portable)" ON)
 option(ZZIPFSEEKO "Build libzzipfseeko (based on posix.1 api)" ON)
 
-if(UNIX)
+if(UNIX OR MINGW)
 option(ZZIP_COMPAT "Build compatibility with old libzzip releases" ON)
 option(ZZIP_LIBTOOL "Ensure binary compatibility with libtool" ON)
 option(ZZIP_PKGCONFIG "Generate pkg-config files for linking" ON)
@@ -29,6 +30,12 @@
 option(ZZIP_PKGCONFIG "Generate pkg-config files for linking" OFF)
 endif()
 
+if((CMAKE_BUILD_TYPE STREQUAL "Release") AND (ZZIP_LIBTOOL OR ZZIP_PKGCONFIG))
+option(ZZIP_LIBLATEST "Ensure libname.lib links to libname-REL.lib" ON)
+else()
+option(ZZIP_LIBLATEST "Ensure libname.lib links to libname-REL.lib" OFF)
+endif()
+
 # used in zzip/_config.h
 set(ZZIP_PACKAGE "${PROJECT_NAME}lib")
 set(ZZIP_VERSION "${PROJECT_VERSION}")
@@ -99,10 +106,9 @@
 
 configure_file ( ${CMAKE_CURRENT_SOURCE_DIR}/_config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/_config.h )
 
-# Zlib library needed
-find_package ( ZLIB REQUIRED )
 
 if(UNIX)
+CHECK_C_COMPILER_FLAG(C "-Warray-bounds" HAS_WARRAY_BOUNDS)
     add_definitions(
         -Wpointer-arith
         -Wsign-compare
@@ -110,11 +116,30 @@
         # -Wdeclaration-after-statement
         -Werror-implicit-function-declaration
         -Wstrict-aliasing
+    )
+  if(HAS_WARRAY_BOUNDS)
+    add_definitions(
         -Warray-bounds
     )
+  endif()
 endif()
 
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+if(FORTIFY)
+   add_definitions(
+     -U_FORTIFY_SOURCE 
+     -fsanitize=address 
+     -g
+   )
+   add_link_options(
+     -fsanitize=address
+   )
+   set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG")
+endif()
+
+# Zlib library needed
+find_package ( ZLIB REQUIRED )
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS})
 add_definitions ( -DHAVE_CONFIG_H )
 
 set(RELNUM "${PROJECT_VERSION_MAJOR}")
@@ -153,7 +178,6 @@
     fetch.h
     stdint.h
     zzip32.h
-    autoconf.h
     ${outdir}/_config.h)
 
 set(libzzip_INCS
@@ -164,6 +188,7 @@
     __hints.h
     __mkdir.h
     __mmap.h
+    __param.h
     __string.h)
 
 set(libzzipfseeko_SRCS fseeko.c fetch.c)
@@ -175,18 +200,22 @@
 
 add_library(libzzip ${libzzip_SRCS} )
 target_link_libraries(libzzip ZLIB::ZLIB )
-target_include_directories (libzzip PRIVATE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
+target_include_directories (libzzip 
+   PRIVATE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} 
+   PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 
 if(ZZIPFSEEKO)
 add_library(libzzipfseeko ${libzzipfseeko_SRCS} )
 target_link_libraries(libzzipfseeko ZLIB::ZLIB )
-target_include_directories (libzzipfseeko PRIVATE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
+target_include_directories (libzzipfseeko 
+   PRIVATE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
 endif()
 
 if(ZZIPMMAPPED)
 add_library(libzzipmmapped ${libzzipmmapped_SRCS} )
 target_link_libraries(libzzipmmapped ZLIB::ZLIB )
-target_include_directories (libzzipmmapped PRIVATE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
+target_include_directories (libzzipmmapped 
+   PRIVATE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
 endif()
 
 set_target_properties(libzzip PROPERTIES OUTPUT_NAME "zzip" RELEASE_POSTFIX "-${RELNUM}")
@@ -255,14 +284,14 @@
 endif()
 
 install(FILES ${libzzip_HDRS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/zzip )
-install(TARGETS libzzip 
+install(TARGETS libzzip EXPORT zziplibTargets
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
 if(ZZIPFSEEKO)
 install(FILES ${libzzipfseeko_HDRS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/zzip )
-install(TARGETS libzzipfseeko 
+install(TARGETS libzzipfseeko EXPORT zziplibTargets
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
@@ -270,110 +299,138 @@
 
 if(ZZIPMMAPPED)
 install(FILES ${libzzipmmapped_HDRS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/zzip )
-install(TARGETS libzzipmmapped
+install(TARGETS libzzipmmapped EXPORT zziplibTargets
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 endif()
 
-if(ZZIP_COMPAT)
-  install(FILES ${outdir}/compat/zzip.h ${outdir}/compat/zziplib.h ${outdir}/compat/zzip-io.h 
-          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-  if(CMAKE_SHARED_LIBRARY_SONAME_C_FLAG)
+install(EXPORT zziplibTargets
+    NAMESPACE zziplib::
+    DESTINATION share/zziplib
+)
+
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/zziplib-config.cmake.in"
+include(CMakeFindDependencyMacro)
+find_dependency(ZLIB)
+file(GLOB TARGET_FILES "${CMAKE_CURRENT_LIST_DIR}/*Targets.cmake")
+foreach (TARGET_FILE ${TARGET_FILES})
+    include("${TARGET_FILE}")
+endforeach()
+)
+configure_file("${CMAKE_CURRENT_BINARY_DIR}/zziplib-config.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/zziplib-config.cmake" @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/zziplib-config.cmake DESTINATION share/zziplib)
+
+if(ZZIP_COMPAT OR ZZIP_LIBTOOL)
+  if(BUILD_SHARED_LIBS AND CMAKE_SHARED_LIBRARY_SONAME_C_FLAG)
     set(lib ${CMAKE_SHARED_LIBRARY_PREFIX})
     set(dll ${CMAKE_SHARED_LIBRARY_SUFFIX})
-    set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
     get_target_property(libname libzzip OUTPUT_NAME)
     get_target_property(librelease libzzip RELEASE_POSTFIX)
-    get_target_property(libversion libzzip VERSION)
-    install(CODE "execute_process(COMMAND bash -c \"set -e
-        cd $DESTDIR/${libdir}
-        if  -f ${lib}${libname}${librelease}.${libversion}${dll} ; then
-          # Fix for APPLE where dylib goes in the end
-          ln -s ${lib}${libname}${librelease}.${libversion}${dll} ${lib}${libname}${librelease}${dll}.${libversion}
-        fi
-         -f ${lib}${libname}${librelease}${dll}.${libversion}  || exit 0
-        echo -n .. Installing: `pwd`
-        ln -svf ${lib}${libname}${librelease}${dll}.${libversion} ${lib}${libname}${librelease}${dll}
-        echo -n .. Installing: `pwd`
-        ln -svf ${lib}${libname}${librelease}${dll}.${libversion} ${lib}${libname}${librelease}${dll}.10
-        echo -n .. Installing: `pwd`
-        ln -svf ${lib}${libname}${librelease}${dll}.${libversion} ${lib}${libname}${librelease}${dll}.11
-        echo -n .. Installing: `pwd`
-        ln -svf ${lib}${libname}${librelease}${dll}.${libversion} ${lib}${libname}${librelease}${dll}.12
-        \")")
+    add_custom_target(libzzip_links ALL
+        COMMAND ${CMAKE_COMMAND} -E create_symlink $<TARGET_FILE_NAME:libzzip> ${lib}${libname}${librelease}${dll}.10
+        COMMAND ${CMAKE_COMMAND} -E create_symlink $<TARGET_FILE_NAME:libzzip> ${lib}${libname}${librelease}${dll}.11
+        COMMAND ${CMAKE_COMMAND} -E create_symlink $<TARGET_FILE_NAME:libzzip> ${lib}${libname}${librelease}${dll}.12
+        )
+    install(FILES
+      ${outdir}/${lib}${libname}${librelease}${dll}.10
+      ${outdir}/${lib}${libname}${librelease}${dll}.11
+      ${outdir}/${lib}${libname}${librelease}${dll}.12
+      DESTINATION ${CMAKE_INSTALL_LIBDIR})

_service:tar_scm:v0.13.72.tar.gz/zzip/Makefile.am -> _service:tar_scm:v0.13.74.tar.gz/zzip/Makefile.am Changed

_service:tar_scm:v0.13.72.tar.gz/zzip/Makefile.in -> _service:tar_scm:v0.13.74.tar.gz/zzip/Makefile.in Changed

_service:tar_scm:v0.13.72.tar.gz/zzip/__debug.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/__debug.h Changed

@@ -6,6 +6,11 @@
 
 /* perhaps want to show on syslog(3) ?? */
 
+#ifdef NDEBUG
+#undef DEBUG
+#endif
+
+/* clang-format off */
 #ifdef DEBUG
 #include <stdio.h>
 #define MSG1(X1) ZZIP_FOR1 { \
@@ -35,61 +40,61 @@
 #define MSG5(X1,X2,X3,X4,X5) {}
 #define MSG6(X1,X2,X3,X4,X5,X6) {}
 #endif
+/* clang-format on */
 
-#define DBG1(X1)                     MSG1("DEBUG: " X1) 
-#define DBG2(X1,X2)                  MSG2("DEBUG: " X1,X2) 
-#define DBG3(X1,X2,X3)               MSG3("DEBUG: " X1,X2,X3) 
-#define DBG4(X1,X2,X3,X4)            MSG4("DEBUG: " X1,X2,X3,X4) 
-#define DBG5(X1,X2,X3,X4,X5)         MSG5("DEBUG: " X1,X2,X3,X4,X5) 
-#define DBG6(X1,X2,X3,X4,X5,X6)      MSG6("DEBUG: " X1,X2,X3,X4,X5,X6) 
-
-#define HINT1(X1)                     MSG1("HINT: " X1) 
-#define HINT2(X1,X2)                  MSG2("HINT: " X1,X2) 
-#define HINT3(X1,X2,X3)               MSG3("HINT: " X1,X2,X3) 
-#define HINT4(X1,X2,X3,X4)            MSG4("HINT: " X1,X2,X3,X4) 
-#define HINT5(X1,X2,X3,X4,X5)         MSG5("HINT: " X1,X2,X3,X4,X5) 
-#define HINT6(X1,X2,X3,X4,X5,X6)      MSG6("HINT: " X1,X2,X3,X4,X5,X6) 
-
-#define NOTE1(X1)                     MSG1("NOTE: " X1) 
-#define NOTE2(X1,X2)                  MSG2("NOTE: " X1,X2) 
-#define NOTE3(X1,X2,X3)               MSG3("NOTE: " X1,X2,X3) 
-#define NOTE4(X1,X2,X3,X4)            MSG4("NOTE: " X1,X2,X3,X4) 
-#define NOTE5(X1,X2,X3,X4,X5)         MSG5("NOTE: " X1,X2,X3,X4,X5) 
-#define NOTE6(X1,X2,X3,X4,X5,X6)      MSG6("NOTE: " X1,X2,X3,X4,X5,X6) 
+#define DBG1(X1)                     MSG1("DEBUG: " X1)
+#define DBG2(X1, X2)                 MSG2("DEBUG: " X1, X2)
+#define DBG3(X1, X2, X3)             MSG3("DEBUG: " X1, X2, X3)
+#define DBG4(X1, X2, X3, X4)         MSG4("DEBUG: " X1, X2, X3, X4)
+#define DBG5(X1, X2, X3, X4, X5)     MSG5("DEBUG: " X1, X2, X3, X4, X5)
+#define DBG6(X1, X2, X3, X4, X5, X6) MSG6("DEBUG: " X1, X2, X3, X4, X5, X6)
 
-#define WARN1(X1)                     MSG1("WARN: " X1) 
-#define WARN2(X1,X2)                  MSG2("WARN: " X1,X2) 
-#define WARN3(X1,X2,X3)               MSG3("WARN: " X1,X2,X3) 
-#define WARN4(X1,X2,X3,X4)            MSG4("WARN: " X1,X2,X3,X4) 
-#define WARN5(X1,X2,X3,X4,X5)         MSG5("WARN: " X1,X2,X3,X4,X5) 
-#define WARN6(X1,X2,X3,X4,X5,X6)      MSG6("WARN: " X1,X2,X3,X4,X5,X6) 
+#define HINT1(X1)                     MSG1("HINT: " X1)
+#define HINT2(X1, X2)                 MSG2("HINT: " X1, X2)
+#define HINT3(X1, X2, X3)             MSG3("HINT: " X1, X2, X3)
+#define HINT4(X1, X2, X3, X4)         MSG4("HINT: " X1, X2, X3, X4)
+#define HINT5(X1, X2, X3, X4, X5)     MSG5("HINT: " X1, X2, X3, X4, X5)
+#define HINT6(X1, X2, X3, X4, X5, X6) MSG6("HINT: " X1, X2, X3, X4, X5, X6)
 
-#define FAIL1(X1)                     MSG1("FAIL: " X1) 
-#define FAIL2(X1,X2)                  MSG2("FAIL: " X1,X2) 
-#define FAIL3(X1,X2,X3)               MSG3("FAIL: " X1,X2,X3) 
-#define FAIL4(X1,X2,X3,X4)            MSG4("FAIL: " X1,X2,X3,X4) 
-#define FAIL5(X1,X2,X3,X4,X5)         MSG5("FAIL: " X1,X2,X3,X4,X5) 
-#define FAIL6(X1,X2,X3,X4,X5,X6)      MSG6("FAIL: " X1,X2,X3,X4,X5,X6) 
+#define NOTE1(X1)                     MSG1("NOTE: " X1)
+#define NOTE2(X1, X2)                 MSG2("NOTE: " X1, X2)
+#define NOTE3(X1, X2, X3)             MSG3("NOTE: " X1, X2, X3)
+#define NOTE4(X1, X2, X3, X4)         MSG4("NOTE: " X1, X2, X3, X4)
+#define NOTE5(X1, X2, X3, X4, X5)     MSG5("NOTE: " X1, X2, X3, X4, X5)
+#define NOTE6(X1, X2, X3, X4, X5, X6) MSG6("NOTE: " X1, X2, X3, X4, X5, X6)
 
+#define WARN1(X1)                     MSG1("WARN: " X1)
+#define WARN2(X1, X2)                 MSG2("WARN: " X1, X2)
+#define WARN3(X1, X2, X3)             MSG3("WARN: " X1, X2, X3)
+#define WARN4(X1, X2, X3, X4)         MSG4("WARN: " X1, X2, X3, X4)
+#define WARN5(X1, X2, X3, X4, X5)     MSG5("WARN: " X1, X2, X3, X4, X5)
+#define WARN6(X1, X2, X3, X4, X5, X6) MSG6("WARN: " X1, X2, X3, X4, X5, X6)
 
+#define FAIL1(X1)                     MSG1("FAIL: " X1)
+#define FAIL2(X1, X2)                 MSG2("FAIL: " X1, X2)
+#define FAIL3(X1, X2, X3)             MSG3("FAIL: " X1, X2, X3)
+#define FAIL4(X1, X2, X3, X4)         MSG4("FAIL: " X1, X2, X3, X4)
+#define FAIL5(X1, X2, X3, X4, X5)     MSG5("FAIL: " X1, X2, X3, X4, X5)
+#define FAIL6(X1, X2, X3, X4, X5, X6) MSG6("FAIL: " X1, X2, X3, X4, X5, X6)
 
 #ifdef DEBUG
-_zzip_inline static void zzip_debug_xbuf (unsigned char* p, int l)
-    /* ZZIP_GNUC_UNUSED */
+_zzip_inline static void
+zzip_debug_xbuf(unsigned char* p, int l)
+/* ZZIP_GNUC_UNUSED */
 {
-#   define q(a) ((a&0x7F)<32?32:(a&0x7F))
-    while (l > 0)
-    {
-        fprintf (stderr, 
-		 "%02x %02x %02x %02x  "
-		 "%02x %02x %02x %02x  "
-		 "%c%c%c%c %c%c%c%c\n",
-		 p0, p1, p2, p3, p4, p5, p6, p7,
-		 q(p0), q(p1), q(p2), q(p3), 
-		 q(p4), q(p5), q(p6), q(p7));
-        p += 8; l -= 8;
+#define q(a) ((a & 0x7F) < 32 ? 32 : (a & 0x7F))
+    while (l > 0) {
+        fprintf(stderr,
+                "%02x %02x %02x %02x  "
+                "%02x %02x %02x %02x  "
+                "%c%c%c%c %c%c%c%c\n",
+                p0, p1, p2, p3, p4, p5, p6, p7, /* .. */
+                q(p0), q(p1), q(p2), q(p3),             /* .. */
+                q(p4), q(p5), q(p6), q(p7));
+        p += 8;
+        l -= 8;
     }
-#   undef q
+#undef q
 }
 #endif

_service:tar_scm:v0.13.72.tar.gz/zzip/__dirent.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/__dirent.h Changed

@@ -57,49 +57,47 @@
 
 #include <io.h>
 
-struct dirent
-{
-	long		d_ino;		/* Always zero. */
-	unsigned short	d_reclen;	/* Always zero. */
-	unsigned short	d_namlen;	/* Length of name in d_name. */
-	char*		d_name;		/* File name. */
-	/* NOTE: The name in the dirent structure points to the name in the
-	 *       finddata_t structure in the DIR. */
+struct dirent {
+    long           d_ino;    /* Always zero. */
+    unsigned short d_reclen; /* Always zero. */
+    unsigned short d_namlen; /* Length of name in d_name. */
+    char*          d_name;   /* File name. */
+    /* NOTE: The name in the dirent structure points to the name in the
+     *       finddata_t structure in the DIR. */
 };
 
 /*
  * This is an internal data structure. Good programmers will not use it
  * except as an argument to one of the functions below.
  */
-typedef struct
-{
-	/* disk transfer area for this dir */
-	struct _finddata_t	dd_dta;
-
-	/* dirent struct to return from dir (NOTE: this makes this thread
-	 * safe as long as only one thread uses a particular DIR struct at
-	 * a time) */
-	struct dirent		dd_dir;
-
-	/* _findnext handle */
-	long			dd_handle;
-
-	/*
-         * Status of search:
-	 *   0 = not started yet (next entry to read is first entry)
-	 *  -1 = off the end
-	 *   positive = 0 based index of next entry
-	 */
-	short			dd_stat;
-
-	/* given path for dir with search pattern (struct is extended) */
-	char			dd_name1;
+typedef struct {
+    /* disk transfer area for this dir */
+    struct _finddata_t dd_dta;
+
+    /* dirent struct to return from dir (NOTE: this makes this thread
+     * safe as long as only one thread uses a particular DIR struct at
+     * a time) */
+    struct dirent dd_dir;
+
+    /* _findnext handle */
+    long dd_handle;
+
+    /*
+     * Status of search:
+     *   0 = not started yet (next entry to read is first entry)
+     *  -1 = off the end
+     *   positive = 0 based index of next entry
+     */
+    short dd_stat;
+
+    /* given path for dir with search pattern (struct is extended) */
+    char dd_name1;
 } DIR;
 
 /*
  * dirent.c
  *
- * Derived from DIRLIB.C by Matt J. Weinstein 
+ * Derived from DIRLIB.C by Matt J. Weinstein
  * This note appears in the DIRLIB.H
  * DIRLIB.H by M. J. Weinstein   Released to public domain 1-Jan-89
  *
@@ -115,13 +113,12 @@
 #include <string.h>
 #include <sys/stat.h>
 
-#define win32_SUFFIX	"*"
-#define	win32_SLASH	"\\"
+#define win32_SUFFIX "*"
+#define win32_SLASH  "\\"
 
 #ifndef S_ISDIR
-#define S_ISDIR(m)	((m & S_IFMT) == S_IFDIR)	/* is a directory */
-#endif  S_ISDIR
-
+#define S_ISDIR(m) ((m & S_IFMT) == S_IFDIR) /* is a directory */
+#endif S_ISDIR
 
 /*
   opendir
@@ -130,74 +127,73 @@
   searching a directory.
 */
 static DIR*
-win32_opendir (const char *szPath)
+win32_opendir(const char* szPath)
 {
-    DIR        *nd;
+    DIR*         nd;
     struct _stat statDir;
 
     errno = 0;
-    
-    if (!szPath) {
-	errno = EFAULT;
-	return (DIR *) 0;
+
+    if (! szPath) {
+        errno = EFAULT;
+        return (DIR*) 0;
     }
 
     if (szPath0 == '\0') {
-	errno = ENOTDIR;
-	return (DIR *) 0;
+        errno = ENOTDIR;
+        return (DIR*) 0;
     }
-    
+
     /* Attempt to determine if the given path really is a directory. */
-    if (_stat (szPath, &statDir)) {
-	/* Error, stat should have set an error value. */
-	return (DIR *) 0;
+    if (_stat(szPath, &statDir)) {
+        /* Error, stat should have set an error value. */
+        return (DIR*) 0;
     }
-    
-    if (!S_ISDIR (statDir.st_mode)) {
-	/* Error, stat reports not a directory. */
-	errno = ENOTDIR;
-	return (DIR *) 0;
+
+    if (! S_ISDIR(statDir.st_mode)) {
+        /* Error, stat reports not a directory. */
+        errno = ENOTDIR;
+        return (DIR*) 0;
     }
 
     /* Allocate enough space to store DIR structure and the complete *
        directory path given. */
-    nd = (DIR *) calloc (1, sizeof (DIR) + strlen (szPath) 
-			 + strlen (win32_SLASH) + strlen (win32_SUFFIX));
-    
-    if (!nd) {
-	/* Error, out of memory. */
-	errno = ENOMEM;
-	return (DIR *) 0;
+    nd =
+        (DIR*) calloc(1, sizeof(DIR) + strlen(szPath) + strlen(win32_SLASH) + strlen(win32_SUFFIX));
+
+    if (! nd) {
+        /* Error, out of memory. */
+        errno = ENOMEM;
+        return (DIR*) 0;
     }
 
     /* Create the search expression. */
-    strcpy (nd->dd_name, szPath);
-    
+    strcpy(nd->dd_name, szPath);
+
     /* Add on a slash if the path does not end with one. */
-    if (nd->dd_name0 != '\0' &&
-	nd->dd_namestrlen (nd->dd_name) - 1 != '/' &&
-	nd->dd_namestrlen (nd->dd_name) - 1 != '\\') {
-	strcat (nd->dd_name, win32_SLASH);
+    if (nd->dd_name0 != '\0' && nd->dd_namestrlen(nd->dd_name) - 1 != '/' &&
+        nd->dd_namestrlen(nd->dd_name) - 1 != '\\') {
+        strcat(nd->dd_name, win32_SLASH);
     }
-    
+
     /* Add on the search pattern */
-    strcat (nd->dd_name, win32_SUFFIX);
-    
+    strcat(nd->dd_name, win32_SUFFIX);
+
     /* Initialize handle to -1 so that a premature closedir doesn't try * to
        call _findclose on it. */
     nd->dd_handle = -1;
-    
+
     /* Initialize the status. */
     nd->dd_stat = 0;
-    
+
     /* Initialize the dirent structure. ino and reclen are invalid under *
        Win32, and name simply points at the appropriate part of the *
        findfirst_t structure. */
-    nd->dd_dir.d_ino = 0;

_service:tar_scm:v0.13.72.tar.gz/zzip/__fnmatch.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/__fnmatch.h Changed

@@ -7,43 +7,44 @@
 #include <string.h>
 
 #ifdef ZZIP_HAVE_FNMATCH_H
-# include <fnmatch.h>
-# define _zzip_fnmatch fnmatch
-# ifdef FNM_CASEFOLD
-# define _zzip_FNM_CASEFOLD FNM_CASEFOLD
-# else
-# define _zzip_FNM_CASEFOLD 0
-# endif
-# ifdef FNM_NOESCAPE
-# define _zzip_FNM_NOESCAPE FNM_NOESCAPE
-# else
-# define _zzip_FNM_NOESCAPE 0
-# endif
-# ifdef FNM_PATHNAME
-# define _zzip_FNM_PATHNAME FNM_PATHNAME
-# else
-# define _zzip_FNM_PATHNAME 0
-# endif
-# ifdef FNM_PERIOD
-# define _zzip_FNM_PERIOD FNM_PERIOD
-# else
-# define _zzip_FNM_PERIOD 0
-# endif
+#include <fnmatch.h>
+#define _zzip_fnmatch fnmatch
+#ifdef FNM_CASEFOLD
+#define _zzip_FNM_CASEFOLD FNM_CASEFOLD
+#else
+#define _zzip_FNM_CASEFOLD 0
+#endif
+#ifdef FNM_NOESCAPE
+#define _zzip_FNM_NOESCAPE FNM_NOESCAPE
+#else
+#define _zzip_FNM_NOESCAPE 0
+#endif
+#ifdef FNM_PATHNAME
+#define _zzip_FNM_PATHNAME FNM_PATHNAME
+#else
+#define _zzip_FNM_PATHNAME 0
+#endif
+#ifdef FNM_PERIOD
+#define _zzip_FNM_PERIOD FNM_PERIOD
+#else
+#define _zzip_FNM_PERIOD 0
+#endif
 
 #else
 /* if your system does not have fnmatch, we fall back to strcmp: */
-static int _zzip_fnmatch(char* pattern, char* string, int flags)
-{ 
-#   ifdef DBG2
+static int
+_zzip_fnmatch(char* pattern, char* string, int flags)
+{
+#ifdef DBG2
     DBG1("<zzip:mmapped:strcmp>");
-#   endif
-    return strcmp (pattern, string); 
+#endif
+    return strcmp(pattern, string);
 }
 
-# define _zzip_FNM_CASEFOLD 0
-# define _zzip_FNM_NOESCAPE 0
-# define _zzip_FNM_PATHNAME 0
-# define _zzip_FNM_PERIOD 0
+#define _zzip_FNM_CASEFOLD 0
+#define _zzip_FNM_NOESCAPE 0
+#define _zzip_FNM_PATHNAME 0
+#define _zzip_FNM_PERIOD   0
 #endif
 
 #endif

_service:tar_scm:v0.13.72.tar.gz/zzip/__hints.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/__hints.h Changed

@@ -3,147 +3,144 @@
 #include <zzip/conf.h>
 
 #ifndef ZZIP_GNUC_ATLEAST
-# if defined __GNUC__ && defined __GNUC_MINOR__
-# define ZZIP_GNUC_ATLEAST(_M_,_N_) \
-        ((__GNUC__ << 10) + __GNUC_MINOR__ >= ((_M_) << 10) + (_N_))
-# elif defined __GNUC__
-# define ZZIP_GNUC_ATLEAST(_M_,_N_) \
-        ((__GNUC__ << 10) >= ((_M_) << 10))
-# else
-# define ZZIP_GNUC_ATLEAST(_M_, _N_) 0
-# endif
+#if defined __GNUC__ && defined __GNUC_MINOR__
+#define ZZIP_GNUC_ATLEAST(_M_, _N_) ((__GNUC__ << 10) + __GNUC_MINOR__ >= ((_M_) << 10) + (_N_))
+#elif defined __GNUC__
+#define ZZIP_GNUC_ATLEAST(_M_, _N_) ((__GNUC__ << 10) >= ((_M_) << 10))
+#else
+#define ZZIP_GNUC_ATLEAST(_M_, _N_) 0
+#endif
 #endif
 
 #ifndef ZZIP_GNUC_EXTENSION
-# if ZZIP_GNUC_ATLEAST(2,8)
-# define ZZIP_GNUC_EXTENSION __extension__
-# else
-# define ZZIP_GNUC_EXTENSION
-# endif
+#if ZZIP_GNUC_ATLEAST(2, 8)
+#define ZZIP_GNUC_EXTENSION __extension__
+#else
+#define ZZIP_GNUC_EXTENSION
+#endif
 #endif
 
 /* func has no side effects, return value depends only on params and globals */
 #ifndef ZZIP_GNUC_PURE
-# if ZZIP_GNUC_ATLEAST(2,8)
-# define ZZIP_GNUC_PURE __attribute__((__pure__))
-# else
-# define ZZIP_GNUC_PURE
-# endif
+#if ZZIP_GNUC_ATLEAST(2, 8)
+#define ZZIP_GNUC_PURE __attribute__((__pure__))
+#else
+#define ZZIP_GNUC_PURE
+#endif
 #endif
 
 /* func has no side effects, return value depends only on params */
 #ifndef ZZIP_GNUC_CONST
-# if ZZIP_GNUC_ATLEAST(2,4)
-# define ZZIP_GNUC_CONST __attribute__((__const__))
-# else
-# define ZZIP_GNUC_CONST
-# endif
+#if ZZIP_GNUC_ATLEAST(2, 4)
+#define ZZIP_GNUC_CONST __attribute__((__const__))
+#else
+#define ZZIP_GNUC_CONST
+#endif
 #endif
 
 /* typename / variable / function possibly unused */
 #ifndef ZZIP_GNUC_UNUSED
-# if ZZIP_GNUC_ATLEAST(2,4)
-# define ZZIP_GNUC_UNUSED __attribute__((__unused__))
-# else
-# define ZZIP_GNUC_UNUSED
-# endif
+#if ZZIP_GNUC_ATLEAST(2, 4)
+#define ZZIP_GNUC_UNUSED __attribute__((__unused__))
+#else
+#define ZZIP_GNUC_UNUSED
+#endif
 #endif
 
 /* obvious. btw, a noreturn-func should return void */
 #ifndef ZZIP_GNUC_NORETURN
-# if ZZIP_GNUC_ATLEAST(2,5)
-# define ZZIP_GNUC_NORETURN __attribute__((__noreturn__))
-# else
-# define ZZIP_GNUC_NORETURN
-# endif
+#if ZZIP_GNUC_ATLEAST(2, 5)
+#define ZZIP_GNUC_NORETURN __attribute__((__noreturn__))
+#else
+#define ZZIP_GNUC_NORETURN
+#endif
 #endif
 
 /* omit function from profiling with -finstrument-functions */
 #ifndef ZZIP_GNUC_NO_INSTRUMENT
-# if ZZIP_GNUC_ATLEAST(2,4)
-# define ZZIP_GNUC_NO_INSTRUMENT __attribute__((__no_instrument_function__))
-# else
-# define ZZIP_GNUC_NO_INSTRUMENT
-# endif
+#if ZZIP_GNUC_ATLEAST(2, 4)
+#define ZZIP_GNUC_NO_INSTRUMENT __attribute__((__no_instrument_function__))
+#else
+#define ZZIP_GNUC_NO_INSTRUMENT
+#endif
 #endif
 
 /* all pointer args must not be null, and allow optimiztons based on the fact*/
 #ifndef ZZIP_GNUC_NONNULL
-# if ZZIP_GNUC_ATLEAST(3,1)
-# define ZZIP_GNUC_NONNULL __attribute__((nonnull))
-# else
-# define ZZIP_GNUC_NONNULL
-# endif
+#if ZZIP_GNUC_ATLEAST(3, 1)
+#define ZZIP_GNUC_NONNULL __attribute__((nonnull))
+#else
+#define ZZIP_GNUC_NONNULL
+#endif
 #endif
 
 /* the function can not throw - the libc function are usually nothrow */
 #ifndef ZZIP_GNUC_NOTHROW
-# if ZZIP_GNUC_ATLEAST(3,2)
-# define ZZIP_GNUC_NOTHROW __attribute__((nothrow))
-# else
-# define ZZIP_GNUC_NOTHROW
-# endif
+#if ZZIP_GNUC_ATLEAST(3, 2)
+#define ZZIP_GNUC_NOTHROW __attribute__((nothrow))
+#else
+#define ZZIP_GNUC_NOTHROW
+#endif
 #endif
 
 /* typename / function / variable is obsolete but still listed in headers */
 #ifndef ZZIP_GNUC_DEPRECATED
-# if ZZIP_GNUC_ATLEAST(3,1)
-# define ZZIP_GNUC_DEPRECATED __attribute__((deprecated))
-# else
-# define ZZIP_GNUC_DEPRECATED
-# endif
+#if ZZIP_GNUC_ATLEAST(3, 1)
+#define ZZIP_GNUC_DEPRECATED __attribute__((deprecated))
+#else
+#define ZZIP_GNUC_DEPRECATED
+#endif
 #endif
 
 /* resolve references to this function during pre-linking the library */
 #ifndef ZZIP_GNUC_LIB_PROTECTED
-# if ZZIP_GNUC_ATLEAST(3,1)
-# define ZZIP_GNUC_LIB_PROTECTED __attribute__((visiblity("protected")))
-# else
-# define ZZIP_GNUC_LIB_PROTECTED
-# endif
+#if ZZIP_GNUC_ATLEAST(3, 1)
+#define ZZIP_GNUC_LIB_PROTECTED __attribute__((visiblity("protected")))
+#else
+#define ZZIP_GNUC_LIB_PROTECTED
+#endif
 #endif
 
 /* func shall only be usable within the same lib (so, no entry in lib symtab)*/
 #ifndef ZZIP_GNUC_LIB_PRIVATE
-# if ZZIP_GNUC_ATLEAST(3,1)
-# define ZZIP_GNUC_LIB_PRIVATE __attribute__((visiblity("hidden")))
-# else
-# define ZZIP_GNUC_LIB_PRIVATE
-# endif
+#if ZZIP_GNUC_ATLEAST(3, 1)
+#define ZZIP_GNUC_LIB_PRIVATE __attribute__((visiblity("hidden")))
+#else
+#define ZZIP_GNUC_LIB_PRIVATE
+#endif
 #endif
 
 /* ... and not even passed as a function pointer reference to outside the lib*/
 #ifndef ZZIP_GNUC_LIB_INTERNAL
-# if ZZIP_GNUC_ATLEAST(3,1)
-# define ZZIP_GNUC_LIB_INTERNAL __attribute__((visiblity("internal")))
-# else
-# define ZZIP_GNUC_LIB_INTERNAL
-# endif
+#if ZZIP_GNUC_ATLEAST(3, 1)
+#define ZZIP_GNUC_LIB_INTERNAL __attribute__((visiblity("internal")))
+#else
+#define ZZIP_GNUC_LIB_INTERNAL
+#endif
 #endif
-
 
 #ifndef ZZIP_GNUC_FORMAT
-# if ZZIP_GNUC_ATLEAST(2,4)
-# define ZZIP_GNUC_FORMAT(_X_) __attribute__((__format_arg__(_X_)))
-# else
-# define ZZIP_GNUC_FORMAT(_X_)
-# endif
+#if ZZIP_GNUC_ATLEAST(2, 4)
+#define ZZIP_GNUC_FORMAT(_X_) __attribute__((__format_arg__(_X_)))
+#else
+#define ZZIP_GNUC_FORMAT(_X_)

_service:tar_scm:v0.13.72.tar.gz/zzip/__mkdir.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/__mkdir.h Changed

_service:tar_scm:v0.13.72.tar.gz/zzip/__mmap.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/__mmap.h Changed

@@ -13,7 +13,7 @@
  */
 
 #ifdef _USE_MMAP
-#if    defined ZZIP_HAVE_SYS_MMAN_H
+#if defined ZZIP_HAVE_SYS_MMAN_H
 #include <sys/mman.h>
 #define USE_POSIX_MMAP 1
 #elif defined ZZIP_HAVE_WINBASE_H || defined WIN32
@@ -26,75 +26,77 @@
 
 /* -------------- specify MMAP function imports --------------------------- */
 
-#if     defined  USE_POSIX_MMAP
+#if defined USE_POSIX_MMAP
 #define USE_MMAP 1
 
-#define _zzip_mmap(user, fd, offs, len) \
-              mmap (0, len, PROT_READ, MAP_SHARED, fd, offs)
-#define _zzip_munmap(user, ptr, len) \
-              munmap (ptr, len)
-#define _zzip_getpagesize(user) getpagesize()
+#define _zzip_mmap(user, fd, offs, len) mmap(0, len, PROT_READ, MAP_SHARED, fd, offs)
+#define _zzip_munmap(user, ptr, len)    munmap(ptr, len)
+#define _zzip_getpagesize(user)         getpagesize()
 
 #ifndef MAP_FAILED /* hpux10.20 does not have it */
-#define MAP_FAILED ((void*)(-1))
+#define MAP_FAILED ((void*) (-1))
 #endif
 
-#elif   defined USE_WIN32_MMAP
+#elif defined USE_WIN32_MMAP
 #define USE_MMAP 1
 #ifndef MAP_FAILED
 #define MAP_FAILED 0
 #endif
 /* we had used the plugin->sys variable for (user) but not anymore */
 
-static size_t win32_getpagesize (void)
-{ 
-    SYSTEM_INFO si; GetSystemInfo (&si); 
-    return si.dwAllocationGranularity; 
+static size_t
+win32_getpagesize(void)
+{
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return si.dwAllocationGranularity;
 }
-static void*  win32_mmap (long* user, int fd, zzip_off_t offs, size_t len)
+static void*
+win32_mmap(long* user, int fd, zzip_off_t offs, size_t len)
 {
     if (! user || *user != 1) /* || offs % getpagesize() */
-	return 0;
-  {
-    HANDLE hFile = (HANDLE)_get_osfhandle(fd);
-    HANDLE fileMapping = NULL;
-    if (hFile)
-	fileMapping = CreateFileMapping (hFile, 0, PAGE_READONLY, 0, 0, NULL);
-    if (fileMapping != NULL)
+        return 0;
     {
-	char* p = MapViewOfFile(fileMapping, FILE_MAP_READ, 0, offs, len);
-	CloseHandle (fileMapping); *user = 1;
-	if (p) return p;
-    } 
-    return MAP_FAILED;
-  }
+        HANDLE hFile       = (HANDLE) _get_osfhandle(fd);
+        HANDLE fileMapping = NULL;
+        if (hFile)
+            fileMapping = CreateFileMapping(hFile, 0, PAGE_READONLY, 0, 0, NULL);
+        if (fileMapping != NULL) {
+            char* p = MapViewOfFile(fileMapping, FILE_MAP_READ, 0, offs, len);
+            CloseHandle(fileMapping);
+            *user = 1;
+            if (p)
+                return p;
+        }
+        return MAP_FAILED;
+    }
 }
-static void win32_munmap (long* user, char* fd_map, size_t len)
+static void
+win32_munmap(long* user, char* fd_map, size_t len)
 {
-    UnmapViewOfFile (fd_map);
+    UnmapViewOfFile(fd_map);
 }
 
-#define _zzip_mmap(user, fd, offs, len) \
-        win32_mmap ((long*) &(user), fd, offs, len)
-#define _zzip_munmap(user, ptr, len) \
-        win32_munmap ((long*) &(user), ptr, len)
-#define _zzip_getpagesize(user) win32_getpagesize()
+#define _zzip_mmap(user, fd, offs, len) win32_mmap((long*) &(user), fd, offs, len)
+#define _zzip_munmap(user, ptr, len)    win32_munmap((long*) &(user), ptr, len)
+#define _zzip_getpagesize(user)         win32_getpagesize()
 
-#else   /* disable */
+#else /* disable */
 #define USE_MMAP 0
 /* USE_MAP is intentional: we expect the compiler to do some "code removal"
  * on any source code enclosed in if (USE_MMAP) {...}   i.e. the unreachable
  * branch of an if (0) {....} is not emitted to the final object binary. */
 
 #ifndef MAP_FAILED
-#define MAP_FAILED  0
+#define MAP_FAILED 0
 #endif
 
 #define _zzip_mmap(user, fd, offs, len) (MAP_FAILED)
-#define _zzip_munmap(user, ptr, len) {}
+#define _zzip_munmap(user, ptr, len)                                                               \
+    {                                                                                              \
+    }
 #define _zzip_getpagesize(user) 1
 
 #endif /* USE_MMAP defines */
 
-
 #endif

_service:tar_scm:v0.13.74.tar.gz/zzip/__param.h Added

_service:tar_scm:v0.13.72.tar.gz/zzip/__string.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/__string.h Changed

@@ -7,7 +7,7 @@
 
 #include <zzip/conf.h>
 
-#if   defined ZZIP_HAVE_STRING_H
+#if defined ZZIP_HAVE_STRING_H
 #include <string.h>
 #elif defined ZZIP_HAVE_STRINGS_H
 #include <strings.h>
@@ -20,30 +20,28 @@
 
 /* if your system does not have strnlen: */
 static size_t
-_zzip_strnlen(const char *p, size_t maxlen)
+_zzip_strnlen(const char* p, size_t maxlen)
 {
-    const char * stop = (char *)memchr(p, '\0', maxlen);
-    return stop ? (size_t)(stop - p) : maxlen;
+    const char* stop = (char*) memchr(p, '\0', maxlen);
+    return stop ? (size_t) (stop - p) : maxlen;
 }
 #endif
 
-
 #if defined ZZIP_HAVE_STRNDUP || defined strndup
 #define _zzip_strndup strndup
 #else
 #include <stdlib.h>
 
 /* if your system does not have strndup: */
-zzip__new__ static char *
-_zzip_strndup(char const *p, size_t maxlen)
+zzip__new__ static char*
+_zzip_strndup(char const* p, size_t maxlen)
 {
-    if (p == NULL)
-    {
-       return p;
-    } else 
-    {
+    if (p == NULL) {
+        return (char*) p;
+    }
+    else {
         size_t len = _zzip_strnlen(p, maxlen);
-        char* r = (char *)malloc(len + 1);
+        char*  r   = (char*) malloc(len + 1);
         if (r == NULL)
             return NULL; /* errno = ENOMEM */
         rlen = '\0';
@@ -58,14 +56,13 @@
 
 /* if your system does not have strcasecmp: */
 static int
-_zzip_strcasecmp(char *__zzip_restrict a, char *_zzip_restrict b)
+_zzip_strcasecmp(char* __zzip_restrict a, char* _zzip_restrict b)
 {
     if (! a)
         return (b) ? 1 : 0;
     if (! b)
         return -1;
-    while (1)
-    {
+    while (1) {
         int v = tolower(*a) - tolower(*b);
         if (v)
             return v;

_service:tar_scm:v0.13.72.tar.gz/zzip/_msvc.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/_msvc.h Changed

@@ -1,6 +1,6 @@
 #ifndef _ZZIP__MSVC_H
 #define _ZZIP__MSVC_H 1
- 
+
 /* zzip/_msvc.h. Generated automatically at end of configure. */
 /* config.h.in.  Generated from configure.ac by autoheader.  */
 
@@ -14,12 +14,12 @@
 /* #undef HAVE_BYTESWAP_H */
 
 /* Define to 1 if you have the <direct.h> header file. */
-#ifndef ZZIP_HAVE_DIRECT_H 
-#define ZZIP_HAVE_DIRECT_H  1 
+#ifndef ZZIP_HAVE_DIRECT_H
+#define ZZIP_HAVE_DIRECT_H 1
 #endif
 
 /* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
-   */
+ */
 /* #undef HAVE_DIRENT_H */
 
 /* Define to 1 if you have the <dlfcn.h> header file. */
@@ -32,13 +32,13 @@
 /* #undef HAVE_INTTYPES_H */
 
 /* Define to 1 if you have the <io.h> header file. */
-#ifndef ZZIP_HAVE_IO_H 
-#define ZZIP_HAVE_IO_H  1 
+#ifndef ZZIP_HAVE_IO_H
+#define ZZIP_HAVE_IO_H 1
 #endif
 
 /* Define to 1 if you have the <memory.h> header file. */
-#ifndef ZZIP_HAVE_MEMORY_H 
-#define ZZIP_HAVE_MEMORY_H  1 
+#ifndef ZZIP_HAVE_MEMORY_H
+#define ZZIP_HAVE_MEMORY_H 1
 #endif
 
 /* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
@@ -48,8 +48,8 @@
 /* #undef HAVE_STDINT_H */
 
 /* Define to 1 if you have the <stdlib.h> header file. */
-#ifndef ZZIP_HAVE_STDLIB_H 
-#define ZZIP_HAVE_STDLIB_H  1 
+#ifndef ZZIP_HAVE_STDLIB_H
+#define ZZIP_HAVE_STDLIB_H 1
 #endif
 
 /* Define to 1 if you have the `strcasecmp' function. */
@@ -59,8 +59,8 @@
 /* #undef HAVE_STRINGS_H */
 
 /* Define to 1 if you have the <string.h> header file. */
-#ifndef ZZIP_HAVE_STRING_H 
-#define ZZIP_HAVE_STRING_H  1 
+#ifndef ZZIP_HAVE_STRING_H
+#define ZZIP_HAVE_STRING_H 1
 #endif
 
 /* Define to 1 if you have the `strndup' function. */
@@ -70,7 +70,7 @@
 /* #undef HAVE_STRNLEN */
 
 /* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
-   */
+ */
 /* #undef HAVE_SYS_DIR_H */
 
 /* Define to 1 if you have the <sys/int_types.h> header file. */
@@ -80,47 +80,47 @@
 /* #undef HAVE_SYS_MMAN_H */
 
 /* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
-   */
+ */
 /* #undef HAVE_SYS_NDIR_H */
 
 /* Define to 1 if you have the <sys/param.h> header file. */
 /* #undef HAVE_SYS_PARAM_H */
 
 /* Define to 1 if you have the <sys/stat.h> header file. */
-#ifndef ZZIP_HAVE_SYS_STAT_H 
-#define ZZIP_HAVE_SYS_STAT_H  1 
+#ifndef ZZIP_HAVE_SYS_STAT_H
+#define ZZIP_HAVE_SYS_STAT_H 1
 #endif
 
 /* Define to 1 if you have the <sys/types.h> header file. */
-#ifndef ZZIP_HAVE_SYS_TYPES_H 
-#define ZZIP_HAVE_SYS_TYPES_H  1 
+#ifndef ZZIP_HAVE_SYS_TYPES_H
+#define ZZIP_HAVE_SYS_TYPES_H 1
 #endif
 
 /* Define to 1 if you have the <unistd.h> header file. */
 /* #undef HAVE_UNISTD_H */
 
 /* Define to 1 if you have the <winbase.h> header file. */
-#ifndef ZZIP_HAVE_WINBASE_H 
-#define ZZIP_HAVE_WINBASE_H  1  /* hmm, is that win32 ? */ 
+#ifndef ZZIP_HAVE_WINBASE_H
+#define ZZIP_HAVE_WINBASE_H 1 /* hmm, is that win32 ? */
 #endif
 
 /* Define to 1 if you have the <windows.h> header file. */
-#ifndef ZZIP_HAVE_WINDOWS_H 
-#define ZZIP_HAVE_WINDOWS_H  1  /* yes, this is windows */ 
+#ifndef ZZIP_HAVE_WINDOWS_H
+#define ZZIP_HAVE_WINDOWS_H 1 /* yes, this is windows */
 #endif
 
 /* Define to 1 if you have the <winnt.h> header file. */
-#ifndef ZZIP_HAVE_WINNT_H 
-#define ZZIP_HAVE_WINNT_H  1      /* is that always true? */ 
+#ifndef ZZIP_HAVE_WINNT_H
+#define ZZIP_HAVE_WINNT_H 1 /* is that always true? */
 #endif
 
 /* Define to 1 if you have the <zlib.h> header file. */
-#ifndef ZZIP_HAVE_ZLIB_H 
-#define ZZIP_HAVE_ZLIB_H  1      /* you do have it, right? */ 
+#ifndef ZZIP_HAVE_ZLIB_H
+#define ZZIP_HAVE_ZLIB_H 1 /* you do have it, right? */
 #endif
 
 /* whether the system defaults to 32bit off_t but can do 64bit when requested
-   */
+ */
 /* #undef LARGEFILE_SENSITIVE */
 
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
@@ -130,8 +130,8 @@
 /* #undef NDEBUG */
 
 /* Name of package */
-#ifndef ZZIP_PACKAGE 
-#define ZZIP_PACKAGE  "zziplib-msvc"     /* yes, make it known */ 
+#ifndef ZZIP_PACKAGE
+#define ZZIP_PACKAGE "zziplib-msvc" /* yes, make it known */
 #endif
 
 /* Define to the address where bug reports for this package should be sent. */
@@ -153,48 +153,48 @@
 /* #undef PACKAGE_VERSION */
 
 /* The number of bytes in type int */
-#ifndef ZZIP_SIZEOF_INT 
-#define ZZIP_SIZEOF_INT  4 
+#ifndef ZZIP_SIZEOF_INT
+#define ZZIP_SIZEOF_INT 4
 #endif
 
 /* The number of bytes in type int * */
 /* #undef SIZEOF_INT_P */
 
 /* The number of bytes in type long */
-#ifndef ZZIP_SIZEOF_LONG 
-#define ZZIP_SIZEOF_LONG  4 
+#ifndef ZZIP_SIZEOF_LONG
+#define ZZIP_SIZEOF_LONG 4
 #endif
 
 /* The number of bytes in type short */
-#ifndef ZZIP_SIZEOF_SHORT 
-#define ZZIP_SIZEOF_SHORT  2 
+#ifndef ZZIP_SIZEOF_SHORT
+#define ZZIP_SIZEOF_SHORT 2
 #endif
 
 /* Define to 1 if you have the ANSI C header files. */
-#ifndef ZZIP_STDC_HEADERS 
-#define ZZIP_STDC_HEADERS  1 
+#ifndef ZZIP_STDC_HEADERS
+#define ZZIP_STDC_HEADERS 1
 #endif
 
 /* Version number of package */
-#ifndef ZZIP_VERSION 
-#define ZZIP_VERSION  "0.13.x" 
+#ifndef ZZIP_VERSION
+#define ZZIP_VERSION "0.13.x"
 #endif
 
 /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
    significant byte first (like Motorola and SPARC, unlike Intel). */
 #if defined AC_APPLE_UNIVERSAL_BUILD
-# if defined __BIG_ENDIAN__
-#  define WORDS_BIGENDIAN 1
-# endif
+#if defined __BIG_ENDIAN__
+#define WORDS_BIGENDIAN 1
+#endif
 #else
-# ifndef WORDS_BIGENDIAN
+#ifndef WORDS_BIGENDIAN
 /* #  undef WORDS_BIGENDIAN */

_service:tar_scm:v0.13.72.tar.gz/zzip/conf.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/conf.h Changed

@@ -16,27 +16,27 @@
 #ifndef _ZZIP_CONF_H
 #define _ZZIP_CONF_H 1
 
-#if !defined ZZIP_OMIT_CONFIG_H
-# if defined _MSC_VER || defined __BORLANDC__ || defined __WATCOMC__
-# include <zzip/_msvc.h>
-# elif defined ZZIP_1_H
-# include "zzip-1.h"
-# elif defined ZZIP_2_H
-# include "zzip-2.h"
-# elif defined ZZIP_3_H
-# include "zzip-3.h"
-# elif defined ZZIP_4_H
-# include "zzip-4.h"
-# elif defined ZZIP_5_H
-# include "zzip-5.h"
-# else /* autoconf generated */
-# include <zzip/_config.h>
-# endif
+#if ! defined ZZIP_OMIT_CONFIG_H
+#if defined _MSC_VER || defined __BORLANDC__ || defined __WATCOMC__
+#include <zzip/_msvc.h>
+#elif defined ZZIP_1_H
+#include "zzip-1.h"
+#elif defined ZZIP_2_H
+#include "zzip-2.h"
+#elif defined ZZIP_3_H
+#include "zzip-3.h"
+#elif defined ZZIP_4_H
+#include "zzip-4.h"
+#elif defined ZZIP_5_H
+#include "zzip-5.h"
+#else /* autoconf generated */
+#include <zzip/_config.h>
+#endif
 #endif
 
 /* especially win32 platforms do not declare off_t so far - see zzip-msvc.h */
 #ifndef _zzip_off_t
-#ifdef   ZZIP_off_t
+#ifdef ZZIP_off_t
 #define _zzip_off_t ZZIP_off_t
 #else
 #define _zzip_off_t off_t
@@ -44,7 +44,7 @@
 #endif
 
 #ifndef _zzip_off64_t
-#ifdef   ZZIP_off64_t
+#ifdef ZZIP_off64_t
 #define _zzip_off64_t ZZIP_off64_t
 #else
 #define _zzip_off64_t off64_t
@@ -53,50 +53,50 @@
 
 /* currently unused, all current zziplib-users do have ansi-C94 compilers. */
 #ifndef _zzip_const
-#ifdef   ZZIP_const
+#ifdef ZZIP_const
 #define _zzip_const ZZIP_const
 #else
 #define _zzip_const const
 #endif
 #endif
 #ifndef _zzip_inline
-#ifdef   ZZIP_inline
+#ifdef ZZIP_inline
 #define _zzip_inline ZZIP_inline
 #else
 #define _zzip_inline inline
 #endif
 #endif
 #ifndef _zzip_restrict
-#ifdef   ZZIP_restrict
+#ifdef ZZIP_restrict
 #define _zzip_restrict ZZIP_restrict
 #else
 #define _zzip_restrict restrict
 #endif
 #endif
-#if defined __linux__ && __GNUC__+0 >= 4
+#if defined __linux__ && __GNUC__ + 0 >= 4
+#define zzip__new__ __attribute__((malloc))
+#elif defined __linux__ && __GNUC__ + 0 >= 3 && __GNUC_MINOR__ + 0 >= 3
 #define zzip__new__ __attribute__((malloc))
-#elif defined __linux__ && __GNUC__+0 >= 3 && __GNUC_MINOR__+0 >= 3
-#define zzip__new__  __attribute__((malloc))
 #else
 #define zzip__new__
 #endif
 
 #ifndef _zzip_size_t
-#ifdef   ZZIP_size_t
+#ifdef ZZIP_size_t
 #define _zzip_size_t ZZIP_size_t
 #else
 #define _zzip_size_t size_t
 #endif
 #endif
 #ifndef _zzip_ssize_t
-#ifdef   ZZIP_ssize_t
+#ifdef ZZIP_ssize_t
 #define _zzip_ssize_t ZZIP_ssize_t
 #else
 #define _zzip_ssize_t ssize_t
 #endif
 #endif
 #ifndef _zzip___int64
-#ifdef   ZZIP___int64
+#ifdef ZZIP___int64
 #define _zzip___int64 ZZIP___int64
 #else
 #define _zzip___int64 long long
@@ -106,32 +106,32 @@
 /* whether this library shall use a 64bit off_t largefile variant in 64on32: */
 /* (some exported names must be renamed to avoid bad calls after linking) */
 #if defined ZZIP_LARGEFILE_SENSITIVE
-# if _FILE_OFFSET_BITS+0 == 64
-# define  ZZIP_LARGEFILE_RENAME
-# elif defined  _LARGE_FILES    /* used on older AIX to get at 64bit off_t */
-# define  ZZIP_LARGEFILE_RENAME
-# elif defined  _ZZIP_LARGEFILE /* or simply use this one for zzip64 runs */
-# define  ZZIP_LARGEFILE_RENAME
-# endif
+#if _FILE_OFFSET_BITS + 0 == 64
+#define ZZIP_LARGEFILE_RENAME
+#elif defined _LARGE_FILES /* used on older AIX to get at 64bit off_t */
+#define ZZIP_LARGEFILE_RENAME
+#elif defined _ZZIP_LARGEFILE /* or simply use this one for zzip64 runs */
+#define ZZIP_LARGEFILE_RENAME
+#endif
 #endif
 
 /* if the environment did not setup these for 64bit off_t largefile... */
-#ifdef   ZZIP_LARGEFILE_RENAME
-# ifndef      _FILE_OFFSET_BITS
-#  ifdef ZZIP__FILE_OFFSET_BITS /* == 64 */
-#  define     _FILE_OFFSET_BITS ZZIP__FILE_OFFSET_BITS
-#  endif
-# endif
-# ifndef      _LARGE_FILES
-#  ifdef ZZIP__LARGE_FILES /* == 1 */
-#  define     _LARGE_FILES ZZIP__LARGE_FILES
-#  endif
-# endif
-# ifndef      _LARGEFILE_SOURCE
-#  ifdef ZZIP__LARGEFILE_SOURCE /* == 1 */
-#  define     _LARGEFILE_SOURCE ZZIP__LARGEFILE_SOURCE
-#  endif
-# endif
+#ifdef ZZIP_LARGEFILE_RENAME
+#ifndef _FILE_OFFSET_BITS
+#ifdef ZZIP__FILE_OFFSET_BITS /* == 64 */
+#define _FILE_OFFSET_BITS ZZIP__FILE_OFFSET_BITS
+#endif
+#endif
+#ifndef _LARGE_FILES
+#ifdef ZZIP__LARGE_FILES /* == 1 */
+#define _LARGE_FILES ZZIP__LARGE_FILES
+#endif
+#endif
+#ifndef _LARGEFILE_SOURCE
+#ifdef ZZIP__LARGEFILE_SOURCE /* == 1 */
+#define _LARGEFILE_SOURCE ZZIP__LARGEFILE_SOURCE
+#endif
+#endif
 #endif
 
 #include <errno.h>
@@ -142,7 +142,7 @@
 #endif
 
 #ifndef ELOOP
-#if   defined EILSEQ
+#if defined EILSEQ
 #define ELOOP EILSEQ
 #else
 #define ELOOP ENOEXEC
@@ -150,7 +150,7 @@
 #endif
 
 #if defined __WATCOMC__
-#undef  _zzip_inline
+#undef _zzip_inline
 #define _zzip_inline static
 #endif
 
@@ -159,101 +159,99 @@
 #endif
 
 #ifdef _MSC_VER
-# if !__STDC__
-#  ifndef _zzip_lseek
-#  define _zzip_lseek _lseek
-#  endif
-#  ifndef _zzip_read
-#  define _zzip_read _read
-#  endif
-#  ifndef _zzip_write

_service:tar_scm:v0.13.72.tar.gz/zzip/dir.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/dir.c Changed

@@ -1,17 +1,17 @@
 
 /*
- * Author: 
+ * Author:
  *    Guido Draheim <guidod@gmx.de>
  *
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
  */
 
-#include <zzip/lib.h>           /* exported... */
+#include <zzip/lib.h> /* exported... */
 #include <zzip/file.h>
-#include <stddef.h>             /*offsetof */
+#include <errno.h>
+#include <stddef.h> /*offsetof */
 #include <stdlib.h>
 #include <string.h>
-#include <errno.h>
 
 #ifdef ZZIP_HAVE_SYS_STAT_H
 #include <sys/stat.h>
@@ -24,18 +24,18 @@
 
 #ifndef offsetof
 #pragma warning had to DEFINE offsetof as it was not in stddef.h
-#define offsetof(T,M) ((unsigned)(& ((T*)0)->M))
+#define offsetof(T, M) ((unsigned) (&((T*) 0)->M))
 #endif
 
 #ifdef ZZIP_HAVE_SYS_STAT_H
 
 /* MSVC does have IFbitmask but not the corresponding IStests */
-# if ! defined S_ISDIR && defined S_IFDIR
-# define S_ISDIR(_X_) ((_X_) & S_IFDIR)
-# endif
-# if ! defined S_ISREG && defined S_IFREG
-# define S_ISREG(_X_) ((_X_) & S_IFREG)
-# endif
+#if ! defined S_ISDIR && defined S_IFDIR
+#define S_ISDIR(_X_) ((_X_) &S_IFDIR)
+#endif
+#if ! defined S_ISREG && defined S_IFREG
+#define S_ISREG(_X_) ((_X_) &S_IFREG)
+#endif
 #endif
 
 /** rewind.
@@ -46,13 +46,12 @@
  * the filenames will include the filesubpath, so take care.
  */
 void
-zzip_rewinddir(ZZIP_DIR * dir)
+zzip_rewinddir(ZZIP_DIR* dir)
 {
     if (! dir)
         return;
 
-    if (USE_DIRENT && dir->realdir)
-    {
+    if (USE_DIRENT && dir->realdir) {
         _zzip_rewinddir(dir->realdir);
         return;
     }
@@ -67,11 +66,11 @@
 #define real_readdir(_X_) 1
 #else
 static int
-real_readdir(ZZIP_DIR * dir)
+real_readdir(ZZIP_DIR* dir)
 {
-    struct stat st = { 0 };
-    char filenamePATH_MAX;
-    struct dirent *dirent = _zzip_readdir(dir->realdir);
+    struct stat    st = {0};
+    char           filenamePATH_MAX;
+    struct dirent* dirent = _zzip_readdir(dir->realdir);
 
     if (! dirent)
         return 0;
@@ -86,21 +85,19 @@
 
     dir->dirent.d_csize = dir->dirent.st_size = st.st_size;
 
-    if (st.st_mode)
-    {
-        if (! S_ISREG(st.st_mode))
-        {
+    if (st.st_mode) {
+        if (! S_ISREG(st.st_mode)) {
             dir->dirent.d_compr = st.st_mode;
             dir->dirent.d_compr |= 0x80000000;
-            /* makes it effectively negative, 
+            /* makes it effectively negative,
              * but can still be fed to S_ISXXX(x) */
-        } else
-        {
-            dir->dirent.d_compr = 0;    /* stored */
         }
-    } else
-    {
-        dir->dirent.d_compr = 0;        /* stored */
+        else {
+            dir->dirent.d_compr = 0; /* stored */
+        }
+    }
+    else {
+        dir->dirent.d_compr = 0; /* stored */
     }
 
     return 1;
@@ -109,30 +106,31 @@
 
 /** read dir.
  *
- * This function is the equivalent of a => readdir(2) for a realdir 
+ * This function is the equivalent of a => readdir(2) for a realdir
  * or a zipfile referenced by the ZZIP_DIR returned from => zzip_opendir.
  *
- * The ZZIP_DIR handle (as returned by => zzip_opendir) contains a few more 
+ * The ZZIP_DIR handle (as returned by => zzip_opendir) contains a few more
  * entries than being copied into the ZZIP_DIRENT. The only valid fields in
  * a ZZIP_DIRENT are d_name (the file name), d_compr (compression), d_csize
  * (compressed size), st_size (uncompressed size).
  */
-ZZIP_DIRENT *
-zzip_readdir(ZZIP_DIR * dir)
+ZZIP_DIRENT*
+zzip_readdir(ZZIP_DIR* dir)
 {
-    if (! dir)
-        { errno=EBADF; return 0; }
+    if (! dir) {
+        errno = EBADF;
+        return 0;
+    }
 
-    if (USE_DIRENT && dir->realdir)
-    {
+    if (USE_DIRENT && dir->realdir) {
         if (! real_readdir(dir))
             return 0;
-    } else
-    {
+    }
+    else {
         if (! dir->hdr)
             return 0;
 
-        dir->dirent.d_name = dir->hdr->d_name;
+        dir->dirent.d_name  = dir->hdr->d_name;
         dir->dirent.d_compr = dir->hdr->d_compr;
 
         dir->dirent.d_csize = dir->hdr->d_csize;
@@ -141,8 +139,7 @@
         if (! dir->hdr->d_reclen)
             dir->hdr = 0;
         else
-            dir->hdr = (struct zzip_dir_hdr *)
-                ((char *) dir->hdr + dir->hdr->d_reclen);
+            dir->hdr = (struct zzip_dir_hdr*) ((char*) dir->hdr + dir->hdr->d_reclen);
     }
     return &dir->dirent;
 }
@@ -151,17 +148,18 @@
  * This function is the equivalent of => telldir(2) for a realdir or zipfile.
  */
 zzip_off_t
-zzip_telldir(ZZIP_DIR * dir)
+zzip_telldir(ZZIP_DIR* dir)
 {
-    if (! dir)
-        { errno=EBADF; return -1; }
+    if (! dir) {
+        errno = EBADF;
+        return -1;
+    }
 
-    if (USE_DIRENT && dir->realdir)
-    {
+    if (USE_DIRENT && dir->realdir) {
         return _zzip_telldir(dir->realdir);
-    } else
-    {
-        return ((zzip_off_t) ((char *) dir->hdr - (char *) dir->hdr0));
+    }
+    else {
+        return ((zzip_off_t) ((char*) dir->hdr - (char*) dir->hdr0));
     }
 }
 
@@ -169,18 +167,16 @@
  * This function is the equivalent of => seekdir(2) for a realdir or zipfile.
  */
 void
-zzip_seekdir(ZZIP_DIR * dir, zzip_off_t offset)
+zzip_seekdir(ZZIP_DIR* dir, zzip_off_t offset)
 {
     if (! dir)
         return;

_service:tar_scm:v0.13.72.tar.gz/zzip/err.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/err.c Changed

@@ -1,45 +1,42 @@
 
 /*
- * Author: 
+ * Author:
  *      Guido Draheim <guidod@gmx.de>
  *      Tomi Ollila <Tomi.Ollila@iki.fi>
  *
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
  */
 
-#include <zzip/lib.h>           /* exported... */
+#include <zzip/lib.h> /* exported... */
 #include <zlib.h>
 
-#include <string.h>
 #include <errno.h>
+#include <string.h>
 
 #include <zzip/file.h>
 
-/* *INDENT-OFF* */
-static struct errlistentry { int code; const char* mesg; } 
-errlist = 
-{
-    { ZZIP_NO_ERROR,        "No error" },
-    { ZZIP_OUTOFMEM,        
-      "could not get temporary memory for internal structures" },
-    { ZZIP_DIR_OPEN,        "Failed to open zip-file %s" },
-    { ZZIP_DIR_STAT,        "Failed to fstat zip-file %s" },
-    { ZZIP_DIR_SEEK,        "Failed to lseek zip-file %s" },
-    { ZZIP_DIR_READ,        "Failed to read zip-file %s"},  
-    { ZZIP_DIR_TOO_SHORT,   "zip-file %s too short" },
-    { ZZIP_DIR_EDH_MISSING, "zip-file central directory not found" },
-    { ZZIP_DIRSIZE,         "Directory size too big..." },
-    { ZZIP_ENOENT,          "No such file found in zip-file %s" },
-    { ZZIP_UNSUPP_COMPR,    "Unsupported compression format" },
-    { ZZIP_CORRUPTED,       "Zipfile corrupted" }, 
-    { ZZIP_UNDEF,           "Some undefined error occurred" },
-    { ZZIP_DIR_LARGEFILE,   "Directory is largefile variant" },
-    { 0, 0 },
+static struct errlistentry {
+    int         code;
+    const char* mesg;
+} errlist = {
+    {ZZIP_NO_ERROR, "No error"},
+    {ZZIP_OUTOFMEM, "could not get temporary memory for internal structures"},
+    {ZZIP_DIR_OPEN, "Failed to open zip-file %s"},
+    {ZZIP_DIR_STAT, "Failed to fstat zip-file %s"},
+    {ZZIP_DIR_SEEK, "Failed to lseek zip-file %s"},
+    {ZZIP_DIR_READ, "Failed to read zip-file %s"},
+    {ZZIP_DIR_TOO_SHORT, "zip-file %s too short"},
+    {ZZIP_DIR_EDH_MISSING, "zip-file central directory not found"},
+    {ZZIP_DIRSIZE, "Directory size too big..."},
+    {ZZIP_ENOENT, "No such file found in zip-file %s"},
+    {ZZIP_UNSUPP_COMPR, "Unsupported compression format"},
+    {ZZIP_CORRUPTED, "Zipfile corrupted"},
+    {ZZIP_UNDEF, "Some undefined error occurred"},
+    {ZZIP_DIR_LARGEFILE, "Directory is largefile variant"},
+    {0, 0},
 };
-/* *INDENT-ON* */
 
-
-#define errlistSIZE (sizeof(errlist)/sizeof(*errlist))
+#define errlistSIZE (sizeof(errlist) / sizeof(*errlist))
 
 /**
  * returns the static string for the given error code. The
@@ -49,23 +46,20 @@
  * or it can be an error code from => libzzip, which is an
  * negative value lower than => ZZIP_ERROR
  */
-zzip_char_t *
+zzip_char_t*
 zzip_strerror(int errcode)
 {
-    if (errcode < ZZIP_ERROR && errcode > ZZIP_ERROR - 32)
-    {
-        struct errlistentry *err = errlist;
+    if (errcode < ZZIP_ERROR && errcode > ZZIP_ERROR - 32) {
+        struct errlistentry* err = errlist;
 
-        for (; err->mesg; err++)
-        {
+        for (; err->mesg; err++) {
             if (err->code == errcode)
                 return err->mesg;
         }
         errcode = EINVAL;
     }
 
-    if (errcode < 0)
-    {
+    if (errcode < 0) {
         if (errcode == -1)
             return strerror(errcode);
         else
@@ -76,59 +70,58 @@
 }
 
 /** => zzip_strerror
- * This function fetches the errorcode from the => DIR-handle and 
+ * This function fetches the errorcode from the => DIR-handle and
  * runs it through => zzip_strerror to obtain the static string
  * describing the error.
  */
-zzip_char_t *
-zzip_strerror_of(ZZIP_DIR * dir)
+zzip_char_t*
+zzip_strerror_of(ZZIP_DIR* dir)
 {
     if (! dir)
         return strerror(errno);
     return zzip_strerror(dir->errcode);
 }
 
-/* *INDENT-OFF* */
-static struct errnolistentry { int code; int e_no; } 
-errnolist =
-{
-    { Z_STREAM_ERROR, EPIPE },
-    { Z_DATA_ERROR, ESPIPE },
-    { Z_MEM_ERROR, ENOMEM },
-    { Z_BUF_ERROR, EMFILE },
-    { Z_VERSION_ERROR, ENOEXEC },
-      
-    { ZZIP_DIR_OPEN, ENOTDIR },
-    { ZZIP_DIR_STAT, EREMOTE },
-    { ZZIP_DIR_SEEK, ESPIPE },
-#  ifdef ESTRPIPE
-    { ZZIP_DIR_READ, ESTRPIPE},  
-#  else
-    { ZZIP_DIR_READ, EPIPE},  
-#  endif
-    { ZZIP_DIR_TOO_SHORT, ENOEXEC },
-#  ifdef ENOMEDIUM
-    { ZZIP_DIR_EDH_MISSING, ENOMEDIUM },
-#  else
-    { ZZIP_DIR_EDH_MISSING, EIO },
-#  endif
-    { ZZIP_DIRSIZE, EFBIG },
-    { ZZIP_OUTOFMEM, ENOMEM },
-    { ZZIP_ENOENT, ENOENT },
-#  ifdef EPFNOSUPPORT
-    { ZZIP_UNSUPP_COMPR, EPFNOSUPPORT },
-#  else
-    { ZZIP_UNSUPP_COMPR, EACCES },
-#  endif 
-# ifdef EILSEQ
-    { ZZIP_CORRUPTED, EILSEQ }, 
-# else
-    { ZZIP_CORRUPTED, ELOOP }, 
-# endif
-    { ZZIP_UNDEF, EINVAL },
-    { 0, 0 },
-};    
-/* *INDENT-ON* */
+static struct errnolistentry {
+    int code;
+    int e_no;
+} errnolist = {
+    {Z_STREAM_ERROR, EPIPE},
+    {Z_DATA_ERROR, ESPIPE},
+    {Z_MEM_ERROR, ENOMEM},
+    {Z_BUF_ERROR, EMFILE},
+    {Z_VERSION_ERROR, ENOEXEC},
+
+    {ZZIP_DIR_OPEN, ENOTDIR},
+    {ZZIP_DIR_STAT, EREMOTE},
+    {ZZIP_DIR_SEEK, ESPIPE},
+#ifdef ESTRPIPE
+    {ZZIP_DIR_READ, ESTRPIPE},
+#else
+    {ZZIP_DIR_READ, EPIPE},
+#endif
+    {ZZIP_DIR_TOO_SHORT, ENOEXEC},
+#ifdef ENOMEDIUM
+    {ZZIP_DIR_EDH_MISSING, ENOMEDIUM},
+#else
+    {ZZIP_DIR_EDH_MISSING, EIO},
+#endif
+    {ZZIP_DIRSIZE, EFBIG},
+    {ZZIP_OUTOFMEM, ENOMEM},
+    {ZZIP_ENOENT, ENOENT},
+#ifdef EPFNOSUPPORT
+    {ZZIP_UNSUPP_COMPR, EPFNOSUPPORT},
+#else
+    {ZZIP_UNSUPP_COMPR, EACCES},
+#endif
+#ifdef EILSEQ
+    {ZZIP_CORRUPTED, EILSEQ},
+#else
+    {ZZIP_CORRUPTED, ELOOP},
+#endif
+    {ZZIP_UNDEF, EINVAL},
+    {0, 0},
+};
 
 /**

_service:tar_scm:v0.13.72.tar.gz/zzip/fetch.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/fetch.c Changed

@@ -19,13 +19,13 @@
  * (works also on machines which SIGBUS on misaligned data access (eg. 68000))
  */
 uint32_t
-__zzip_get32(unsigned char *s)
+__zzip_get32(unsigned char* s)
 {
 #if defined __ZZIP_GET32
     return __ZZIP_GET32(s);
 #else
-    return ((uint32_t) s3 << 24) | ((uint32_t) s2 << 16)
-        | ((uint32_t) s1 << 8) | ((uint32_t) s0);
+    return ((uint32_t) s3 << 24) | ((uint32_t) s2 << 16) /* .. */
+           | ((uint32_t) s1 << 8) | ((uint32_t) s0);
 #endif
 }
 
@@ -33,7 +33,7 @@
  * This function does the same for a 16 bit value.
  */
 uint16_t
-__zzip_get16(unsigned char *s)
+__zzip_get16(unsigned char* s)
 {
 #if defined __ZZIP_GET16
     return __ZZIP_GET16(s);
@@ -46,10 +46,10 @@
  * This function does the same for an off64_t value.
  */
 uint64_t
-__zzip_get64(unsigned char *s)
+__zzip_get64(unsigned char* s)
 {
 #ifdef __GNUC__
-    /* *INDENT-OFF* */
+    /* clang-format off */
     register uint64_t v
        = s7; v <<= 8;
     v |= s6; v <<= 8;
@@ -59,12 +59,12 @@
     v |= s2; v <<= 8;
     v |= s1; v <<= 8;
     v |= s0; return v;
-    /* *INDENT-ON* */
+    /* clang-format on */
 #else
-    return ((uint64_t) s7 << 56) | ((uint64_t) s6 << 48)
-        | ((uint64_t) s5 << 40) | ((uint64_t) s4 << 32)
-        | ((uint64_t) s3 << 24) | ((uint64_t) s2 << 16)
-        | ((uint64_t) s1 << 8) | ((uint64_t) s0);
+    return ((uint64_t) s7 << 56) | ((uint64_t) s6 << 48)   /* .. */
+           | ((uint64_t) s5 << 40) | ((uint64_t) s4 << 32) /* .. */
+           | ((uint64_t) s3 << 24) | ((uint64_t) s2 << 16) /* .. */
+           | ((uint64_t) s1 << 8) | ((uint64_t) s0);
 #endif
 }
 
@@ -72,17 +72,17 @@
  * This function pushes a 32bit value at the specified address
  */
 void
-__zzip_set32(unsigned char *s, uint32_t v)
+__zzip_set32(unsigned char* s, uint32_t v)
 {
 #if defined __ZZIP_SET32
     return __ZZIP_SET32(s, v);
 #else
-    /* *INDENT-OFF* */
+    /* clang-format off */
     s0 = (unsigned char) (v); v >>= 8;
     s1 = (unsigned char) (v); v >>= 8;
     s2 = (unsigned char) (v); v >>= 8;
     s3 = (unsigned char) (v);
-    /* *INDENT-ON* */
+    /* clang-format on */
 #endif
 }
 
@@ -90,15 +90,15 @@
  * This function does the same for a 16 bit value.
  */
 void
-__zzip_set16(unsigned char *s, uint16_t v)
+__zzip_set16(unsigned char* s, uint16_t v)
 {
 #if defined __ZZIP_SET16
     return __ZZIP_SET16(s, v);
 #else
-    /* *INDENT-OFF* */
+    /* clang-format off */
     s0 = (unsigned char) (v); v >>= 8;
     s1 = (unsigned char) (v);
-    /* *INDENT-ON* */
+    /* clang-format on */
 #endif
 }
 
@@ -106,9 +106,9 @@
  * This function pushes a off64_t value at the specified address
  */
 void
-__zzip_set64(unsigned char *s, uint64_t v)
+__zzip_set64(unsigned char* s, uint64_t v)
 {
-    /* *INDENT-OFF* */
+    /* clang-format off */
     s0 = (unsigned char) (v); v >>= 8;
     s1 = (unsigned char) (v); v >>= 8;
     s2 = (unsigned char) (v); v >>= 8;
@@ -117,5 +117,5 @@
     s5 = (unsigned char) (v); v >>= 8;
     s6 = (unsigned char) (v); v >>= 8;
     s7 = (unsigned char) (v);
-    /* *INDENT-ON* */
+    /* clang-format on */
 }

_service:tar_scm:v0.13.72.tar.gz/zzip/fetch.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/fetch.h Changed

@@ -16,393 +16,345 @@
 #endif
 
 /* get 16/32 bits from little-endian zip-file to host byteorder */
-extern uint32_t __zzip_get32(zzip_byte_t * s) ZZIP_GNUC_CONST;
-extern uint16_t __zzip_get16(zzip_byte_t * s) ZZIP_GNUC_CONST;
-extern void     __zzip_set32(zzip_byte_t * s, uint32_t v);
-extern void     __zzip_set16(zzip_byte_t * s, uint16_t v);
-
-extern uint64_t __zzip_get64(zzip_byte_t * s) ZZIP_GNUC_CONST;
-extern void     __zzip_set64(zzip_byte_t * s, uint64_t v);
+extern uint32_t
+__zzip_get32(zzip_byte_t* s) ZZIP_GNUC_CONST;
+extern uint16_t
+__zzip_get16(zzip_byte_t* s) ZZIP_GNUC_CONST;
+extern void
+__zzip_set32(zzip_byte_t* s, uint32_t v);
+extern void
+__zzip_set16(zzip_byte_t* s, uint16_t v);
+
+extern uint64_t
+__zzip_get64(zzip_byte_t* s) ZZIP_GNUC_CONST;
+extern void
+__zzip_set64(zzip_byte_t* s, uint64_t v);
 
 /* just in case that you use a non-configure-d setup (e.g. MSVC) */
 #ifndef ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED
-# if defined __mips__ || defined __sparc__ || defined __powerpc__ || defined __arm__ || defined __ia64__
-# define ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED 11
-# endif
+#if defined __mips__ || defined __sparc__ || defined __powerpc__ || defined __arm__ ||             \
+    defined                                                                 __ia64__
+#define ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED 11
+#endif
 #endif
 
 /* on linux with a cisc processor we can use the bswap for some extra speed */
 #ifdef ZZIP_WORDS_BIGENDIAN
-# ifndef ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED
-#  if defined bswap_16 && defined bswap_32 && defined bswap_64 /* i.e. linux */
-#  define _ZZIP_USE_BSWAP
-#  endif
-# endif
+#ifndef ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED
+#if defined bswap_16 && defined bswap_32 && defined bswap_64 /* i.e. linux */
+#define _ZZIP_USE_BSWAP
+#endif
+#endif
 #endif
 
 /* little endian on intel cisc processors is the original zip format byteorder */
 #ifndef ZZIP_WORDS_BIGENDIAN
-# ifndef ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED
-#  if defined __i386__ || defined __x86_64__ || defined _M_X86 || defined _M_X64
-#  define _ZZIP_USE_DEREF
-#  endif
-# endif
+#ifndef ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED
+#if defined __i386__ || defined __x86_64__ || defined _M_X86 || defined _M_X64
+#define _ZZIP_USE_DEREF
+#endif
+#endif
 #endif
 
 #ifdef _ZZIP_USE_BSWAP
-#define ZZIP_GET16(__p)                        bswap_16(*(uint16_t*)(__p))
-#define ZZIP_GET32(__p)                        bswap_32(*(uint32_t*)(__p))
-#define ZZIP_GET64(__p)                        bswap_64(*(uint64_t*)(__p))
-#define ZZIP_SET16(__p,__x) (*(uint16_t*)(__p) = bswap_16((uint16_t)(__x)))
-#define ZZIP_SET32(__p,__x) (*(uint32_t*)(__p) = bswap_32((uint32_t)(__x)))
-#define ZZIP_SET64(__p,__x) (*(uint64_t*)(__p) = bswap_64((uint64_t)(__x)))
+#define ZZIP_GET16(__p)      bswap_16(*(uint16_t*) (__p))
+#define ZZIP_GET32(__p)      bswap_32(*(uint32_t*) (__p))
+#define ZZIP_GET64(__p)      bswap_64(*(uint64_t*) (__p))
+#define ZZIP_SET16(__p, __x) (*(uint16_t*) (__p) = bswap_16((uint16_t) (__x)))
+#define ZZIP_SET32(__p, __x) (*(uint32_t*) (__p) = bswap_32((uint32_t) (__x)))
+#define ZZIP_SET64(__p, __x) (*(uint64_t*) (__p) = bswap_64((uint64_t) (__x)))
 #elif defined _ZZIP_USE_DEREF
-#define ZZIP_GET16(__p)     (*(uint16_t*)(__p))
-#define ZZIP_GET32(__p)     (*(uint32_t*)(__p))
-#define ZZIP_GET64(__p)     (*(uint64_t*)(__p))
-#define ZZIP_SET16(__p,__x) (*(uint16_t*)(__p) = (uint16_t)(__x))
-#define ZZIP_SET32(__p,__x) (*(uint32_t*)(__p) = (uint32_t)(__x))
-#define ZZIP_SET64(__p,__x) (*(uint64_t*)(__p) = (uint64_t)(__x))
+#define ZZIP_GET16(__p)      (*(uint16_t*) (__p))
+#define ZZIP_GET32(__p)      (*(uint32_t*) (__p))
+#define ZZIP_GET64(__p)      (*(uint64_t*) (__p))
+#define ZZIP_SET16(__p, __x) (*(uint16_t*) (__p) = (uint16_t) (__x))
+#define ZZIP_SET32(__p, __x) (*(uint32_t*) (__p) = (uint32_t) (__x))
+#define ZZIP_SET64(__p, __x) (*(uint64_t*) (__p) = (uint64_t) (__x))
 #else
-#define ZZIP_GET64(__p)     (__zzip_get64((__p)))
-#define ZZIP_GET32(__p)     (__zzip_get32((__p)))
-#define ZZIP_GET16(__p)     (__zzip_get16((__p)))
-#define ZZIP_SET64(__p,__x) (__zzip_set64((__p),(__x)))
-#define ZZIP_SET32(__p,__x) (__zzip_set32((__p),(__x)))
-#define ZZIP_SET16(__p,__x) (__zzip_set16((__p),(__x)))
+#define ZZIP_GET64(__p)      (__zzip_get64((__p)))
+#define ZZIP_GET32(__p)      (__zzip_get32((__p)))
+#define ZZIP_GET16(__p)      (__zzip_get16((__p)))
+#define ZZIP_SET64(__p, __x) (__zzip_set64((__p), (__x)))
+#define ZZIP_SET32(__p, __x) (__zzip_set32((__p), (__x)))
+#define ZZIP_SET16(__p, __x) (__zzip_set16((__p), (__x)))
 #endif
 
 /* ..................... bitcorrect physical access .................... */
 
 /* zzip_file_header - the local file header */
-#define zzip_file_header_get_magic(__p)      ZZIP_GET32((__p)->z_magic)
-#define zzip_file_header_set_magic(__p,__x)  ZZIP_SET32((__p)->z_magic,(__x))
-#define zzip_file_header_get_flags(__p)      ZZIP_GET16((__p)->z_flags)
-#define zzip_file_header_set_flags(__p,__x)  ZZIP_SET16((__p)->z_flags,(__x))
-#define zzip_file_header_get_compr(__p)      ZZIP_GET16((__p)->z_compr)
-#define zzip_file_header_set_compr(__p,__x)  ZZIP_SET16((__p)->z_compr,(__x))
-#define zzip_file_header_get_crc32(__p)      ZZIP_GET32((__p)->z_crc32)
-#define zzip_file_header_set_crc32(__p,__x)  ZZIP_SET32((__p)->z_crc32,(__x))
-#define zzip_file_header_get_csize(__p)      ZZIP_GET32((__p)->z_csize)
-#define zzip_file_header_set_csize(__p,__x)  ZZIP_SET32((__p)->z_csize,(__x))
-#define zzip_file_header_get_usize(__p)      ZZIP_GET32((__p)->z_usize)
-#define zzip_file_header_set_usize(__p,__x)  ZZIP_SET32((__p)->z_usize,(__x))
-#define zzip_file_header_get_namlen(__p)     ZZIP_GET16((__p)->z_namlen)
-#define zzip_file_header_set_namlen(__p,__x) ZZIP_SET16((__p)->z_namlen,(__x))
-#define zzip_file_header_get_extras(__p)     ZZIP_GET16((__p)->z_extras)
-#define zzip_file_header_set_extras(__p,__x) ZZIP_SET16((__p)->z_extras,(__x))
-#define zzip_file_header_sizeof_tails(__p) (zzip_file_header_get_namlen(__p)+\
-					    zzip_file_header_get_extras(__p) )
-#define zzip_file_header_check_magic(__p)  ZZIP_FILE_HEADER_CHECKMAGIC((__p))
+#define zzip_file_header_get_magic(__p)       ZZIP_GET32((__p)->z_magic)
+#define zzip_file_header_set_magic(__p, __x)  ZZIP_SET32((__p)->z_magic, (__x))
+#define zzip_file_header_get_flags(__p)       ZZIP_GET16((__p)->z_flags)
+#define zzip_file_header_set_flags(__p, __x)  ZZIP_SET16((__p)->z_flags, (__x))
+#define zzip_file_header_get_compr(__p)       ZZIP_GET16((__p)->z_compr)
+#define zzip_file_header_set_compr(__p, __x)  ZZIP_SET16((__p)->z_compr, (__x))
+#define zzip_file_header_get_crc32(__p)       ZZIP_GET32((__p)->z_crc32)
+#define zzip_file_header_set_crc32(__p, __x)  ZZIP_SET32((__p)->z_crc32, (__x))
+#define zzip_file_header_get_csize(__p)       ZZIP_GET32((__p)->z_csize)
+#define zzip_file_header_set_csize(__p, __x)  ZZIP_SET32((__p)->z_csize, (__x))
+#define zzip_file_header_get_usize(__p)       ZZIP_GET32((__p)->z_usize)
+#define zzip_file_header_set_usize(__p, __x)  ZZIP_SET32((__p)->z_usize, (__x))
+#define zzip_file_header_get_namlen(__p)      ZZIP_GET16((__p)->z_namlen)
+#define zzip_file_header_set_namlen(__p, __x) ZZIP_SET16((__p)->z_namlen, (__x))
+#define zzip_file_header_get_extras(__p)      ZZIP_GET16((__p)->z_extras)
+#define zzip_file_header_set_extras(__p, __x) ZZIP_SET16((__p)->z_extras, (__x))
+#define zzip_file_header_sizeof_tails(__p)                                                         \
+    (zzip_file_header_get_namlen(__p) + zzip_file_header_get_extras(__p))
+#define zzip_file_header_check_magic(__p) ZZIP_FILE_HEADER_CHECKMAGIC((__p))
 
 /* zzip_file_trailer - data descriptor per file block */
-#define zzip_file_trailer_get_magic(__p)     ZZIP_GET32((__p)->z_magic)
-#define zzip_file_trailer_set_magic(__p,__x) ZZIP_SET32((__p)->z_magic,(__x))
-#define zzip_file_header_get_crc32(__p)      ZZIP_GET32((__p)->z_crc32)
-#define zzip_file_trailer_set_crc32(__p,__x) ZZIP_SET32((__p)->z_crc32,(__x))
-#define zzip_file_trailer_get_csize(__p)     ZZIP_GET32((__p)->z_csize)
-#define zzip_file_trailer_set_csize(__p,__x) ZZIP_SET32((__p)->z_csize,(__x))
-#define zzip_file_trailer_get_usize(__p)     ZZIP_GET32((__p)->z_usize)
-#define zzip_file_trailer_set_usize(__p,__x) ZZIP_SET32((__p)->z_usize,(__x))
-#define zzip_file_trailer_sizeof_tails(__p) 0
-#define zzip_file_trailer_check_magic(__p)   ZZIP_FILE_TRAILER_CHECKMAGIC((__p))
+#define zzip_file_trailer_get_magic(__p)      ZZIP_GET32((__p)->z_magic)
+#define zzip_file_trailer_set_magic(__p, __x) ZZIP_SET32((__p)->z_magic, (__x))
+#define zzip_file_header_get_crc32(__p)       ZZIP_GET32((__p)->z_crc32)
+#define zzip_file_trailer_set_crc32(__p, __x) ZZIP_SET32((__p)->z_crc32, (__x))
+#define zzip_file_trailer_get_csize(__p)      ZZIP_GET32((__p)->z_csize)
+#define zzip_file_trailer_set_csize(__p, __x) ZZIP_SET32((__p)->z_csize, (__x))
+#define zzip_file_trailer_get_usize(__p)      ZZIP_GET32((__p)->z_usize)
+#define zzip_file_trailer_set_usize(__p, __x) ZZIP_SET32((__p)->z_usize, (__x))
+#define zzip_file_trailer_sizeof_tails(__p)   0
+#define zzip_file_trailer_check_magic(__p)    ZZIP_FILE_TRAILER_CHECKMAGIC((__p))
 /* zzip_disk_entry (currently named zzip_root_dirent) */
-#define zzip_disk_entry_get_magic(__p)      ZZIP_GET32((__p)->z_magic)
-#define zzip_disk_entry_set_magic(__p,__x)  ZZIP_SET32((__p)->z_magic,(__x))
-#define zzip_disk_entry_get_flags(__p)      ZZIP_GET16((__p)->z_flags)
-#define zzip_disk_entry_set_flags(__p,__x)  ZZIP_SET16((__p)->z_flags,(__x))
-#define zzip_disk_entry_get_compr(__p)      ZZIP_GET16((__p)->z_compr)
-#define zzip_disk_entry_set_compr(__p,__x)  ZZIP_SET16((__p)->z_compr,(__x))
-#define zzip_disk_entry_get_crc32(__p)      ZZIP_GET32((__p)->z_crc32)
-#define zzip_disk_entry_set_crc32(__p,__x)  ZZIP_SET32((__p)->z_crc32,(__x))
-#define zzip_disk_entry_get_csize(__p)      ZZIP_GET32((__p)->z_csize)
-#define zzip_disk_entry_set_csize(__p,__x)  ZZIP_SET32((__p)->z_csize,(__x))
-#define zzip_disk_entry_get_usize(__p)      ZZIP_GET32((__p)->z_usize)
-#define zzip_disk_entry_set_usize(__p,__x)  ZZIP_SET32((__p)->z_usize,(__x))
-#define zzip_disk_entry_get_namlen(__p)     ZZIP_GET16((__p)->z_namlen)
-#define zzip_disk_entry_set_namlen(__p,__x) ZZIP_SET16((__p)->z_namlen,(__x))
-#define zzip_disk_entry_get_extras(__p)     ZZIP_GET16((__p)->z_extras)
-#define zzip_disk_entry_set_extras(__p,__x) ZZIP_SET16((__p)->z_extras,(__x))
-#define zzip_disk_entry_get_comment(__p)     ZZIP_GET16((__p)->z_comment)
-#define zzip_disk_entry_set_comment(__p,__x) ZZIP_SET16((__p)->z_comment,(__x))
-#define zzip_disk_entry_get_diskstart(__p)     ZZIP_GET16((__p)->z_diskstart)
-#define zzip_disk_entry_set_diskstart(__p,__x) ZZIP_SET16((__p)->z_diskstart,(__x))
-#define zzip_disk_entry_get_filetype(__p)     ZZIP_GET16((__p)->z_filetype)
-#define zzip_disk_entry_set_filetype(__p,__x) ZZIP_SET16((__p)->z_filetype,(__x))
-#define zzip_disk_entry_get_filemode(__p)     ZZIP_GET32((__p)->z_filemode)
-#define zzip_disk_entry_set_filemode(__p,__x) ZZIP_SET32((__p)->z_filemode,(__x))
-#define zzip_disk_entry_get_offset(__p)     ZZIP_GET32((__p)->z_offset)
-#define zzip_disk_entry_set_offset(__p,__x) ZZIP_SET32((__p)->z_offset,(__x))
-#define zzip_disk_entry_sizeof_tails(__p) (zzip_disk_entry_get_namlen(__p) +\
-					   zzip_disk_entry_get_extras(__p) +\
-					   zzip_disk_entry_get_comment(__p) )
-#define zzip_disk_entry_check_magic(__p)  ZZIP_DISK_ENTRY_CHECKMAGIC((__p))
+#define zzip_disk_entry_get_magic(__p)          ZZIP_GET32((__p)->z_magic)

_service:tar_scm:v0.13.72.tar.gz/zzip/file.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/file.c Changed

@@ -7,14 +7,14 @@
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
  */
 
-#include <zzip/lib.h>           /* exported... */
+#include <zzip/lib.h> /* exported... */
 #include <zzip/file.h>
 
-#include <string.h>
-#include <sys/stat.h>
+#include <ctype.h>
 #include <errno.h>
 #include <stdlib.h>
-#include <ctype.h>
+#include <string.h>
+#include <sys/stat.h>
 
 #include <zzip/format.h>
 #include <zzip/fetch.h>
@@ -22,13 +22,13 @@
 #include <zzip/__debug.h>
 
 #if 0
-# if defined ZZIP_HAVE_IO_H
-# include <io.h>                /* tell */
-# else
-# define tell(fd) lseek(fd,0,SEEK_CUR)
-# endif
+#if defined ZZIP_HAVE_IO_H
+#include <io.h> /* tell */
+#else
+#define tell(fd) lseek(fd, 0, SEEK_CUR)
+#endif
 #else
-#define tells(fd) seeks(fd,0,SEEK_CUR)
+#define tells(fd) seeks(fd, 0, SEEK_CUR)
 #endif
 
 /** end usage.
@@ -41,19 +41,18 @@
  * the .refcount is decreased and if zero the fp->dir is closed just as well.
  */
 int
-zzip_file_close(ZZIP_FILE * fp)
+zzip_file_close(ZZIP_FILE* fp)
 {
-    auto int self;
-    ZZIP_DIR *dir = fp->dir;
+    auto int  self;
+    ZZIP_DIR* dir = fp->dir;
 
     if (fp->method)
-        inflateEnd(&fp->d_stream);      /* inflateEnd() can be called many times */
+        inflateEnd(&fp->d_stream); /* inflateEnd() can be called many times */
 
     if (dir->cache.locked == NULL)
         dir->cache.locked = &self;
 
-    if (fp->buf32k)
-    {
+    if (fp->buf32k) {
         if (dir->cache.locked == &self && dir->cache.buf32k == NULL)
             dir->cache.buf32k = fp->buf32k;
         else
@@ -81,13 +80,11 @@
         return 0;
 }
 
-
 static int
-zzip_file_saveoffset(ZZIP_FILE * fp)
+zzip_file_saveoffset(ZZIP_FILE* fp)
 {
-    if (fp)
-    {
-        int fd = fp->dir->fd;
+    if (fp) {
+        int        fd  = fp->dir->fd;
         zzip_off_t off = fp->io->fd.seeks(fd, 0, SEEK_CUR);
 
         if (off < 0)
@@ -98,7 +95,6 @@
     return 0;
 }
 
-
 /* user-definition */
 #ifndef ZZIP_BACKSLASH_DIRSEP
 #if defined HAVE_WINDOWS_H || defined ZZIP_HAVE_WINDOWS_H || defined _WIN32
@@ -113,24 +109,25 @@
 static zzip_char_t*
 strrchr_basename(zzip_char_t* name)
 {
-    register zzip_char_t *n = strrchr(name, '/');
-    if (n) return n + 1;
+    register zzip_char_t* n = strrchr(name, '/');
+    if (n)
+        return n + 1;
     return name;
 }
 
 static zzip_char_t*
 dirsep_basename(zzip_char_t* name)
 {
-    register zzip_char_t *n = strrchr(name, '/');
+    register zzip_char_t* n = strrchr(name, '/');
 
-    if (ZZIP_BACKSLASH_DIRSEP)
-    {
-        register zzip_char_t *m = strrchr(name, '\\');
-        if (!n || (m && n < m))
+    if (ZZIP_BACKSLASH_DIRSEP) {
+        register zzip_char_t* m = strrchr(name, '\\');
+        if (! n || (m && n < m))
             n = m;
     }
 
-    if (n) return n + 1;
+    if (n)
+        return n + 1;
     return name;
 }
 
@@ -138,14 +135,13 @@
 #define dirsep_strcasecmp strcasecmp
 #else
 static int
-dirsep_strcasecmp(zzip_char_t * s1, zzip_char_t * s2)
+dirsep_strcasecmp(zzip_char_t* s1, zzip_char_t* s2)
 {
     /* ASCII tolower - including mapping of backslash in normal slash */
     static const char mapping = "@abcdefghijklmnopqrstuvwxyz/^_";
-    int c1, c2;
+    int               c1, c2;
 
-    while (*s1 && *s2)
-    {
+    while (*s1 && *s2) {
         c1 = (int) (unsigned char) *s1;
         c2 = (int) (unsigned char) *s2;
         if ((c1 & 0xE0) == 0x40)
@@ -162,10 +158,11 @@
 }
 #endif
 
-static int zzip_inflate_init(ZZIP_FILE *, struct zzip_dir_hdr *);
+static int
+zzip_inflate_init(ZZIP_FILE*, struct zzip_dir_hdr*);
 
 /** start usage.
- * This function opens an => ZZIP_FILE from an already open => ZZIP_DIR handle. 
+ * This function opens an => ZZIP_FILE from an already open => ZZIP_DIR handle.
  * Since we have a chance to reuse a cached => buf32k and => ZZIP_FILE memchunk
  * this is the best choice to unpack multiple files.
  *
@@ -174,76 +171,81 @@
  *
  * On error it returns null and sets errcode in the ZZIP_DIR.
  */
-ZZIP_FILE *
-zzip_file_open(ZZIP_DIR * dir, zzip_char_t * name, int o_mode)
+ZZIP_FILE*
+zzip_file_open(ZZIP_DIR* dir, zzip_char_t* name, int o_mode)
 {
-    auto int self;
-    zzip_error_t err = 0;
-    struct zzip_file *fp = 0;
-    struct zzip_dir_hdr *hdr = dir->hdr0;
-    int (*filename_strcmp) (zzip_char_t *, zzip_char_t *);
+    auto int             self;
+    zzip_error_t         err = 0;
+    struct zzip_file*    fp  = 0;
+    struct zzip_dir_hdr* hdr = dir->hdr0;
+    int (*filename_strcmp)(zzip_char_t*, zzip_char_t*);
     zzip_char_t* (*filename_basename)(zzip_char_t*);
 
-    filename_strcmp = (o_mode & ZZIP_CASELESS) ? dirsep_strcasecmp : strcmp;
+    filename_strcmp   = (o_mode & ZZIP_CASELESS) ? dirsep_strcasecmp : strcmp;
     filename_basename = (o_mode & ZZIP_CASELESS) ? dirsep_basename : strrchr_basename;
 
     if (! dir)
         return NULL;
-    if (! dir->fd || dir->fd == -1)
-        { dir->errcode = EBADF; return NULL; }
-    if (! hdr)
-        { dir->errcode = ENOENT; return NULL; }
+    if (! dir->fd || dir->fd == -1) {
+        dir->errcode = EBADF;
+        return NULL;
+    }
+    if (! hdr) {
+        dir->errcode = ENOENT;
+        return NULL;
+    }
 
     if (o_mode & ZZIP_NOPATHS)
         name = filename_basename(name);
 
-    while (1)
-    {

_service:tar_scm:v0.13.72.tar.gz/zzip/file.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/file.h Changed

@@ -8,7 +8,7 @@
  * a while now so perhaps some program sources have errnously taken
  * advantage of this file.
  *
- * Author: 
+ * Author:
  *      Guido Draheim <guidod@gmx.de>
  *      Tomi Ollila <Tomi.Ollila@tfi.net>
  *
@@ -32,22 +32,13 @@
 #include <unistd.h>
 #else
 #include <stdio.h>
-# ifdef ZZIP_HAVE_SYS_TYPES_H
-# include <sys/types.h>
-# endif
+#ifdef ZZIP_HAVE_SYS_TYPES_H
+#include <sys/types.h>
 #endif
-
-#ifdef ZZIP_HAVE_SYS_PARAM_H
-#include <sys/param.h> /* PATH_MAX */
 #endif
 
-#ifndef PATH_MAX
-# ifdef  MAX_PATH /* windows */
-# define PATH_MAX MAX_PATH
-# else
-# define PATH_MAX 512
-# endif
-#endif
+#include <zzip/__param.h>
+
 /*
  * ZZIP_FILE structure... currently no need to unionize, since structure needed
  * for inflate is superset of structure needed for unstore.
@@ -55,22 +46,20 @@
  * Don't make this public. Instead, create methods for needed operations.
  */
 
-struct zzip_file
-{
-    struct zzip_dir* dir; 
-    int fd;
-    int method;
-    zzip_size_t restlen;
-    zzip_size_t crestlen;
-    zzip_size_t usize;
-    zzip_size_t csize;
+struct zzip_file {
+    struct zzip_dir* dir;
+    int              fd;
+    int              method;
+    zzip_size_t      restlen;
+    zzip_size_t      crestlen;
+    zzip_size_t      usize;
+    zzip_size_t      csize;
     /* added dataoffset member - data offset from start of zipfile*/
-    zzip_off_t dataoffset;
-    char* buf32k;
-    zzip_off_t offset; /* offset from the start of zipfile... */
-    z_stream d_stream;
+    zzip_off_t       dataoffset;
+    char*            buf32k;
+    zzip_off_t       offset; /* offset from the start of zipfile... */
+    z_stream         d_stream;
     zzip_plugin_io_t io;
 };
 
 #endif /* _ZZIP_FILE_H */
-

_service:tar_scm:v0.13.72.tar.gz/zzip/format.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/format.h Changed

@@ -22,20 +22,18 @@
  *   ...  disk central directory disk trailer record
  */
 
-# ifdef _MSC_VER
-# pragma pack(push, 1)
-# endif
+#ifdef _MSC_VER
+#pragma pack(push, 1)
+#endif
 
-struct zzip_version
-{
-    zzip_byte_t   version1;
-    zzip_byte_t   ostype1;
+struct zzip_version {
+    zzip_byte_t version1;
+    zzip_byte_t ostype1;
 } ZZIP_GNUC_PACKED;
 
-struct zzip_dostime
-{
-    zzip_byte_t   time2;
-    zzip_byte_t   date2;
+struct zzip_dostime {
+    zzip_byte_t time2;
+    zzip_byte_t date2;
 } ZZIP_GNUC_PACKED;
 
 #ifdef ZZIP_NEED_PACKED
@@ -47,50 +45,57 @@
 typedef struct zzip_dostime zzip_dostime_t;
 #endif
 
+/* clang-format off */
+#define ZZIP_GETMAGIC(__p) \
+    ( (((zzip_byte_t*)(__p))0<<24) | \
+      (((zzip_byte_t*)(__p))1<<16) | \
+      (((zzip_byte_t*)(__p))2<<8) | \
+      (((zzip_byte_t*)(__p))3) )
 #define ZZIP_CHECKMAGIC(__p,__A,__B,__C,__D) \
     ( (((zzip_byte_t*)(__p))0==(__A)) && \
       (((zzip_byte_t*)(__p))1==(__B)) && \
       (((zzip_byte_t*)(__p))2==(__C)) && \
       (((zzip_byte_t*)(__p))3==(__D)) )
-#define ZZIP_CHECK(__p,__A,__B) \
-    ( (((zzip_byte_t*)(__p))0==(__A)) && \
-      (((zzip_byte_t*)(__p))1==(__B)) )
+#define ZZIP_CHECKEXTRA(__p,__N) \
+      ( ZZIP_GETEXTRA(__p) == (__N))
+#define ZZIP_GETEXTRA(__p) \
+    ( (((zzip_byte_t*)(__p))1<<8) | \
+      (((zzip_byte_t*)(__p))0) )
+/* clang-format on */
 
 /* A. Local file header */
-struct zzip_file_header
-{
-#   define ZZIP_FILE_HEADER_MAGIC 0x04034b50
-#   define ZZIP_FILE_HEADER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p,'P','K','\3','\4')
-    zzip_byte_t   z_magic4; /* local file header signature (0x04034b50) */
-    zzip_version_t z_extract; /* version needed to extract */
-    zzip_byte_t   z_flags2; /* general purpose bit flag */
-    zzip_byte_t   z_compr2; /* compression method */
-    zzip_dostime_t z_dostime; /* last mod file time (dos format) */
-    zzip_byte_t   z_crc324; /* crc-32 */
-    zzip_byte_t   z_csize4; /* compressed size */
-    zzip_byte_t   z_usize4; /* uncompressed size */
-    zzip_byte_t   z_namlen2; /* filename length (null if stdin) */
-    zzip_byte_t   z_extras2; /* extra field length */
+struct zzip_file_header {
+#define ZZIP_FILE_HEADER_MAGIC           0x04034b50
+#define ZZIP_FILE_HEADER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p, 'P', 'K', '\3', '\4')
+    zzip_byte_t    z_magic4;  /* local file header signature (0x04034b50) */
+    zzip_version_t z_extract;   /* version needed to extract */
+    zzip_byte_t    z_flags2;  /* general purpose bit flag */
+    zzip_byte_t    z_compr2;  /* compression method */
+    zzip_dostime_t z_dostime;   /* last mod file time (dos format) */
+    zzip_byte_t    z_crc324;  /* crc-32 */
+    zzip_byte_t    z_csize4;  /* compressed size */
+    zzip_byte_t    z_usize4;  /* uncompressed size */
+    zzip_byte_t    z_namlen2; /* filename length (null if stdin) */
+    zzip_byte_t    z_extras2; /* extra field length */
     /* followed by filename (of variable size) */
     /* followed by extra field (of variable size) */
 } ZZIP_GNUC_PACKED;
-#define zzip_file_header_headerlength (4U+2U+2U+2U+4U+4U+4U+4U+2U+2U)
+#define zzip_file_header_headerlength (4U + 2U + 2U + 2U + 4U + 4U + 4U + 4U + 2U + 2U)
 
 /* B. data descriptor
  * the data descriptor exists only if bit 3 of z_flags is set. It is byte aligned
  * and immediately follows the last byte of compressed data. It is only used if
  * the output media of the compressor was not seekable, eg. standard output.
  */
-struct zzip_file_trailer
-{
-#   define ZZIP_FILE_TRAILER_MAGIC 0x08074B50
-#   define ZZIP_FILE_TRAILER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p,'P','K','\7','\8')
-    zzip_byte_t   z_magic4; /* data descriptor signature (0x08074b50) */
-    zzip_byte_t   z_crc324; /* crc-32 */
-    zzip_byte_t   z_csize4; /* compressed size */
-    zzip_byte_t   z_usize4; /* uncompressed size */
+struct zzip_file_trailer {
+#define ZZIP_FILE_TRAILER_MAGIC           0x08074B50
+#define ZZIP_FILE_TRAILER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p, 'P', 'K', '\7', '\8')
+    zzip_byte_t z_magic4; /* data descriptor signature (0x08074b50) */
+    zzip_byte_t z_crc324; /* crc-32 */
+    zzip_byte_t z_csize4; /* compressed size */
+    zzip_byte_t z_usize4; /* uncompressed size */
 } ZZIP_GNUC_PACKED;
-#define zzip_file_trailer_headerlength (4U+4U+4U+4U)
+#define zzip_file_trailer_headerlength (4U + 4U + 4U + 4U)
 
 /* C. central directory structure:
     file header . . . end of central dir record
@@ -100,37 +105,35 @@
  * - a single entry including filename, extras and comment may not exceed 64k.
  */
 
-struct zzip_disk_entry
-{
-#   define ZZIP_DISK_ENTRY_MAGIC 0x02014b50
-#   define ZZIP_DISK_ENTRY_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p,'P','K','\1','\2')
-    zzip_byte_t  z_magic4;  /* central file header signature (0x02014b50) */
-    zzip_version_t z_encoder;  /* version made by */
-    zzip_version_t z_extract;  /* version need to extract */
-    zzip_byte_t  z_flags2;  /* general purpose bit flag */
-    zzip_byte_t  z_compr2;  /* compression method */
-    zzip_dostime_t z_dostime;  /* last mod file time&date (dos format) */
-    zzip_byte_t  z_crc324;  /* crc-32 */
-    zzip_byte_t  z_csize4;  /* compressed size */
-    zzip_byte_t  z_usize4;  /* uncompressed size */
-    zzip_byte_t  z_namlen2; /* filename length (null if stdin) */
-    zzip_byte_t  z_extras2;  /* extra field length */
-    zzip_byte_t  z_comment2; /* file comment length */
-    zzip_byte_t  z_diskstart2; /* disk number of start (if spanning zip over multiple disks) */
-    zzip_byte_t  z_filetype2;  /* internal file attributes, bit0 = ascii */
-    zzip_byte_t  z_filemode4;  /* extrnal file attributes, eg. msdos attrib byte */
-    zzip_byte_t  z_offset4;    /* relative offset of local file header, seekval if singledisk */
+struct zzip_disk_entry {
+#define ZZIP_DISK_ENTRY_MAGIC           0x02014b50
+#define ZZIP_DISK_ENTRY_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p, 'P', 'K', '\1', '\2')
+    zzip_byte_t    z_magic4;     /* central file header signature (0x02014b50) */
+    zzip_version_t z_encoder;      /* version made by */
+    zzip_version_t z_extract;      /* version need to extract */
+    zzip_byte_t    z_flags2;     /* general purpose bit flag */
+    zzip_byte_t    z_compr2;     /* compression method */
+    zzip_dostime_t z_dostime;      /* last mod file time&date (dos format) */
+    zzip_byte_t    z_crc324;     /* crc-32 */
+    zzip_byte_t    z_csize4;     /* compressed size */
+    zzip_byte_t    z_usize4;     /* uncompressed size */
+    zzip_byte_t    z_namlen2;    /* filename length (null if stdin) */
+    zzip_byte_t    z_extras2;    /* extra field length */
+    zzip_byte_t    z_comment2;   /* file comment length */
+    zzip_byte_t    z_diskstart2; /* disk number of start (if spanning zip over multiple disks) */
+    zzip_byte_t    z_filetype2;  /* internal file attributes, bit0 = ascii */
+    zzip_byte_t    z_filemode4;  /* extrnal file attributes, eg. msdos attrib byte */
+    zzip_byte_t    z_offset4;    /* relative offset of local file header, seekval if singledisk */
     /* followed by filename (of variable size) */
     /* followed by extra field (of variable size) */
     /* followed by file comment (of variable size) */
 } ZZIP_GNUC_PACKED;
-#define zzip_disk_entry_headerlength (4U+2U+2U+2U+2U+4U+4U+4U+4U+2U+2U+2U+2U+2U+4U+4U)
-
+#define zzip_disk_entry_headerlength                                                               \
+    (4U + 2U + 2U + 2U + 2U + 4U + 4U + 4U + 4U + 2U + 2U + 2U + 2U + 2U + 4U + 4U)
 
-struct zzip_root_dirent
-{   /* the old name of the structure above */
-#   define ZZIP_ROOT_DIRENT_MAGIC 0x02014b50
-#   define ZZIP_ROOT_DIRENT_CHECKMAGIC(__p) ZZIP_DISK_ENTRY_CHECKMAGIC(__p)
+struct zzip_root_dirent { /* the old name of the structure above */
+#define ZZIP_ROOT_DIRENT_MAGIC           0x02014b50
+#define ZZIP_ROOT_DIRENT_CHECKMAGIC(__p) ZZIP_DISK_ENTRY_CHECKMAGIC(__p)
     zzip_byte_t    z_magic4;
     zzip_version_t z_encoder;
     zzip_version_t z_extract;
@@ -149,83 +152,77 @@
     zzip_byte_t    z_off4;
 } ZZIP_GNUC_PACKED;
 
-
 /* end of central dir record */
-struct zzip_disk_trailer
-{
-#   define ZZIP_DISK_TRAILER_MAGIC 0x06054b50
-#   define ZZIP_DISK_TRAILER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p,'P','K','\5','\6')
-    zzip_byte_t  z_magic4; /* end of central dir signature (0x06054b50) */
-    zzip_byte_t  z_disk2;  /* number of this disk */
-    zzip_byte_t  z_finaldisk2; /* number of the disk with the start of the central dir */
-    zzip_byte_t  z_entries2; /* total number of entries in the central dir on this disk */
-    zzip_byte_t  z_finalentries2; /* total number of entries in the central dir */
-    zzip_byte_t  z_rootsize4; /* size of the central directory */
-    zzip_byte_t  z_rootseek4; /* offset of start of central directory with respect to *
-                          * the starting disk number */
-    zzip_byte_t  z_comment2;  /* zipfile comment length */
+struct zzip_disk_trailer {
+#define ZZIP_DISK_TRAILER_MAGIC           0x06054b50
+#define ZZIP_DISK_TRAILER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p, 'P', 'K', '\5', '\6')
+    zzip_byte_t z_magic4;        /* end of central dir signature (0x06054b50) */

_service:tar_scm:v0.13.72.tar.gz/zzip/fseeko.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/fseeko.c Changed

@@ -27,34 +27,30 @@
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
  */
 
-#define _LARGEFILE_SOURCE 1
+#define _LARGEFILE_SOURCE  1
 #define _ZZIP_ENTRY_STRUCT 1
 
 #include <zzip/fseeko.h>
 
 #include <zzip/fetch.h>
-#include <zzip/__mmap.h>
-#include <zzip/__fnmatch.h>
 #include <zzip/__errno.h>
+#include <zzip/__fnmatch.h>
+#include <zzip/__mmap.h>
 
 #include <stdlib.h>
 #include <sys/stat.h>
 
-#if   defined ZZIP_HAVE_STRING_H
+#if defined ZZIP_HAVE_STRING_H
 #include <string.h>
 #elif defined ZZIP_HAVE_STRINGS_H
 #include <strings.h>
 #endif
 
-#if   defined ZZIP_HAVE_STDINT_H
-#include <stdint.h>
-#endif
-
-#if __STDC_VERSION__+0 > 199900L
+#if __STDC_VERSION__ + 0 > 199900L
 #define ___
 #define ____
 #else
-#define ___ {
+#define ___  {
 #define ____ }
 #endif
 
@@ -71,26 +67,28 @@
 #ifdef __zzip_entry_extends_zzip_disk_entry
 #define disk_(_entry_) _entry_
 #else
-#define disk_(_entry_) (& (_entry_)->head)
+#define disk_(_entry_) (&(_entry_)->head)
 #endif
 
 /* we try to round all seeks to the pagesize - since we do not use
  * the sys/mmap interface we have to guess a good value here: */
 #ifndef PAGESIZE
-# define PAGESIZE 8192
+#define PAGESIZE 8192
 #endif
 
+/* clang-format off */
 #ifdef DEBUG
 #define debug1(msg) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__); } while(0)
 #define debug2(msg, arg1) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__, arg1); } while(0)
 #define debug3(msg, arg1, arg2) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__, arg1, arg2); } while(0)
 #define debug4(msg, arg1, arg2, arg3) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__, arg1, arg2, arg3); } while(0)
 #else
-#define debug1(msg) 
-#define debug2(msg, arg1) 
-#define debug3(msg, arg1, arg2) 
-#define debug4(msg, arg1, arg2, arg3) 
+#define debug1(msg)
+#define debug2(msg, arg1)
+#define debug3(msg, arg1, arg2)
+#define debug4(msg, arg1, arg2, arg3)
 #endif
+/* clang-format on */
 
 /* ====================================================================== */
 
@@ -101,37 +99,32 @@
  * the zip disk of the given "entry". The returned off_t points to the
  * end of the file_header where the current fseek pointer has stopped.
  * This is used to immediately parse out any filename/extras block following
- * the file_header. 
+ * the file_header.
  *
  * Returns zero on error. (errno = EINVAL|EBADMSG|EBADF|EIO)
  */
 static zzip_off_t
-zzip_entry_fread_file_header(ZZIP_ENTRY * entry,
-                             struct zzip_file_header *file_header)
+zzip_entry_fread_file_header(ZZIP_ENTRY* entry, struct zzip_file_header* file_header)
 {
-    if (! entry || ! file_header)
-    {
+    if (! entry || ! file_header) {
         errno = EINVAL;
         return 0;
     }
     ___ zzip_off_t offset = zzip_disk_entry_fileoffset(disk_(entry));
-    if (0 > offset || offset >= entry->disksize)
-    {
+    if (0 > offset || offset >= entry->disksize) {
         errno = EBADMSG;
         return 0;
     }
 
-    if (fseeko(entry->diskfile, offset, SEEK_SET) == -1) 
-    {
+    if (fseeko(entry->diskfile, offset, SEEK_SET) == -1) {
         debug2("fseeko failed: %s", strerror(errno));
         return 0; /* EBADF */
     }
 
     ___ zzip_size_t n = fread(file_header, 1, sizeof(*file_header), entry->diskfile);
-    if (n < sizeof(*file_header))
-    {
-        debug4("fread failed: at offset %llu got %i instead of %i", 
-            (long long) offset, n, sizeof(*file_header));
+    if (n < sizeof(*file_header)) {
+        debug4("fread failed: at offset %llu got %i instead of %i", /* .. */
+               (long long) offset, n, sizeof(*file_header));
         errno = ferror(entry->diskfile) ? EBADF : EIO;
         return 0;
     }
@@ -146,27 +139,24 @@
  * file referenced by the given zzip_entry. It requires an intermediate
  * check of the file_header structure (i.e. it reads it from disk). After
  * this call, the contained diskfile readposition is already set to the
- * data_offset returned here. 
+ * data_offset returned here.
  *
  * Returns -1 on error. (errno = EINVAL|EBADMSG)
  */
 zzip_off_t
-zzip_entry_data_offset(ZZIP_ENTRY * entry)
+zzip_entry_data_offset(ZZIP_ENTRY* entry)
 {
     struct zzip_file_header file_header;
-    if (! entry)
-    {
+    if (! entry) {
         errno = EINVAL;
         return -1;
     }
     ___ zzip_off_t offset = zzip_entry_fread_file_header(entry, &file_header);
-    if (! offset)
-    {
+    if (! offset) {
         return -1; /* EBADMSG */
     }
     offset += zzip_file_header_sizeof_tails(&file_header);
-    if (fseeko(entry->diskfile, offset, SEEK_SET) == -1)
-    {
+    if (fseeko(entry->diskfile, offset, SEEK_SET) == -1) {
         return -1; /* EBADF */
     }
     return offset;
@@ -182,21 +172,18 @@
  *
  * returns: new string buffer, null on error (errno = EINVAL|ENOMEM|EBADMSG)
  */
-zzip__new__ char *
-zzip_entry_strdup_name(ZZIP_ENTRY * entry)
+zzip__new__ char*
+zzip_entry_strdup_name(ZZIP_ENTRY* entry)
 {
-    if (! entry)
-    {
+    if (! entry) {
         errno = EINVAL;
         return 0;
     }
 
     ___ zzip_size_t len;
-    if ((len = zzip_disk_entry_namlen(disk_(entry))))
-    {
-        char *name = malloc(len + 1);
-        if (! name)
-        {
+    if ((len = zzip_disk_entry_namlen(disk_(entry)))) {
+        char* name = malloc(len + 1);
+        if (! name) {
             return 0; /* ENOMEM */
         }
         memcpy(name, entry->tail, len);
@@ -204,18 +191,15 @@
         return name;
     }
     ___ auto struct zzip_file_header header;
-    if (zzip_entry_fread_file_header(entry, &header)
-        && (len = zzip_file_header_namlen(&header)))
-    {
-        char *name = malloc(len + 1);
+    if (zzip_entry_fread_file_header(entry, &header) && (len = zzip_file_header_namlen(&header))) {
+        char* name = malloc(len + 1);
         if (! name) {
             return 0; /* ENOMEM */
-        } 
+        }
         ___ zzip_size_t n = fread(name, 1, len, entry->diskfile);
-        if (n < len) 
-        {

_service:tar_scm:v0.13.72.tar.gz/zzip/fseeko.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/fseeko.h Changed

@@ -1,17 +1,16 @@
 #ifndef _ZZIP_FSEEKO_H_
 #define _ZZIP_FSEEKO_H_
 /*
- * NOTE: this is part of libzzipfseeko (i.e. it is not libzzip). 
+ * NOTE: this is part of libzzipfseeko (i.e. it is not libzzip).
  *
  * simplified zip disk access using fseeko on a stdio FILE handle
  *
- * Author: 
+ * Author:
  *      Guido Draheim <guidod@gmx.de>
  *
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
  */
 
-
 #include <zzip/types.h>
 #include <stdio.h>
 
@@ -24,7 +23,7 @@
 extern "C" {
 #endif
 
-typedef struct zzip_entry ZZIP_ENTRY;
+typedef struct zzip_entry      ZZIP_ENTRY;
 typedef struct zzip_entry_file ZZIP_ENTRY_FILE;
 
 typedef int (*zzip_strcmp_fn_t)(char*, char*);
@@ -37,12 +36,10 @@
 zzip_entry_extern zzip_off_t
 zzip_entry_data_offset(ZZIP_ENTRY* entry);
 
-zzip__new__
-zzip_entry_extern ZZIP_ENTRY*
+zzip__new__ zzip_entry_extern ZZIP_ENTRY*
 zzip_entry_findfirst(FILE* file);
 
-zzip__new__
-zzip_entry_extern ZZIP_ENTRY*
+zzip__new__ zzip_entry_extern ZZIP_ENTRY*
 zzip_entry_findnext(ZZIP_ENTRY* _zzip_restrict entry);
 
 #define zzip_entry_findlast      zzip_entry_free
@@ -52,103 +49,80 @@
 zzip_entry_extern int
 zzip_entry_free(ZZIP_ENTRY* entry);
 
-zzip__new__
-zzip_entry_extern char*
+zzip__new__ zzip_entry_extern char*
 zzip_entry_strdup_name(ZZIP_ENTRY* entry);
 zzip_entry_extern char*
 zzip_entry_to_data(ZZIP_ENTRY* entry);
 
-zzip__new__
-zzip_entry_extern ZZIP_ENTRY*
-zzip_entry_findfile(FILE* disk, char* filename, 
-		    ZZIP_ENTRY* _zzip_restrict old,
-		   zzip_strcmp_fn_t compare);
-zzip__new__
-zzip_entry_extern ZZIP_ENTRY*
-zzip_entry_findmatch(FILE* disk, char* filespec, 
-		     ZZIP_ENTRY* _zzip_restrict old,
-		    zzip_fnmatch_fn_t compare, int flags);
-zzip__new__
-zzip_entry_extern ZZIP_ENTRY_FILE*
-zzip_entry_fopen (ZZIP_ENTRY* entry, int takeover);
-
-zzip__new__
-zzip_entry_extern ZZIP_ENTRY_FILE*
-zzip_entry_ffile (FILE* disk, char* filename);
+zzip__new__ zzip_entry_extern ZZIP_ENTRY*
+zzip_entry_findfile(FILE* disk, char* filename, ZZIP_ENTRY* _zzip_restrict old,
+                    zzip_strcmp_fn_t compare);
+zzip__new__ zzip_entry_extern ZZIP_ENTRY*
+zzip_entry_findmatch(FILE* disk, char* filespec, ZZIP_ENTRY* _zzip_restrict old,
+                     zzip_fnmatch_fn_t compare, int flags);
+zzip__new__ zzip_entry_extern ZZIP_ENTRY_FILE*
+zzip_entry_fopen(ZZIP_ENTRY* entry, int takeover);
+
+zzip__new__ zzip_entry_extern ZZIP_ENTRY_FILE*
+zzip_entry_ffile(FILE* disk, char* filename);
 
 zzip_entry_extern _zzip_size_t
-zzip_entry_fread (void* ptr, _zzip_size_t size, _zzip_size_t nmemb,
-		 ZZIP_ENTRY_FILE* file);
+zzip_entry_fread(void* ptr, _zzip_size_t size, _zzip_size_t nmemb, ZZIP_ENTRY_FILE* file);
 zzip_entry_extern int
-zzip_entry_fclose (ZZIP_ENTRY_FILE* file);
+zzip_entry_fclose(ZZIP_ENTRY_FILE* file);
 int
-zzip_entry_feof (ZZIP_ENTRY_FILE* file);
+zzip_entry_feof(ZZIP_ENTRY_FILE* file);
 
-# ifdef _ZZIP_ENTRY_STRUCT
-#  ifdef __cplusplus
-#  define __zzip_entry_extends_zzip_disk_entry
-struct zzip_entry : public struct zzip_disk_entry
-{
-    char*             _zzip_restrict tail;
-    zzip_off_t                  tailalloc;   /* the allocated size of tail */
-    FILE*                        diskfile;   /* a file reference */
-    zzip_off_t                   disksize;   /* the size of the file */
-    zzip_off_t                   headseek;   /* the offset within the file */
-    zzip_off_t                   zz_usize;
-    zzip_off_t                   zz_csize;   /* items scanned from header */
-    zzip_off_t                   zz_offset;  /* or zip64 extension block */
-    int                          zz_diskstart;
+#ifdef _ZZIP_ENTRY_STRUCT
+#ifdef __cplusplus
+#define __zzip_entry_extends_zzip_disk_entry
+struct zzip_entry : public struct zzip_disk_entry {
+    char* _zzip_restrict tail;
+    zzip_off_t           tailalloc; /* the allocated size of tail */
+    FILE*                diskfile;  /* a file reference */
+    zzip_off_t           disksize;  /* the size of the file */
+    zzip_off_t           headseek;  /* the offset within the file */
+    zzip_off_t           zz_usize;
+    zzip_off_t           zz_csize;  /* items scanned from header */
+    zzip_off_t           zz_offset; /* or zip64 extension block */
+    int                  zz_diskstart;
 };
-# define zzip_entry_d(_p) (_p)
-#  else
+#define zzip_entry_d(_p) (_p)
+#else
 struct zzip_entry /* : struct zzip_disk_entry */
 {
-    struct zzip_disk_entry           head;
-    char*             _zzip_restrict tail;
-    zzip_off_t                  tailalloc;   /* the allocated size of tail */
-    FILE*                        diskfile;   /* a file reference */
-    zzip_off_t                   disksize;   /* the size of the file */
-    zzip_off_t                   headseek;   /* the offset within the file */
-    zzip_off_t                   zz_usize;
-    zzip_off_t                   zz_csize;   /* items scanned from header */
-    zzip_off_t                   zz_offset;  /* or zip64 extension block */
-    int                          zz_diskstart;
+    struct zzip_disk_entry head;
+    char* _zzip_restrict   tail;
+    zzip_off_t             tailalloc; /* the allocated size of tail */
+    FILE*                  diskfile;  /* a file reference */
+    zzip_off_t             disksize;  /* the size of the file */
+    zzip_off_t             headseek;  /* the offset within the file */
+    zzip_off_t             zz_usize;
+    zzip_off_t             zz_csize;  /* items scanned from header */
+    zzip_off_t             zz_offset; /* or zip64 extension block */
+    int                    zz_diskstart;
 };
-# define zzip_entry_d(_p) (&(_p)->head)
-#  endif /* __cplusplus */
-# endif /* _ZZIP_MEM_ENTRY_PRIVATE */
+#define zzip_entry_d(_p) (&(_p)->head)
+#endif /* __cplusplus */
+#endif /* _ZZIP_MEM_ENTRY_PRIVATE */
 
 #ifdef _ZZIP_ENTRY_STRUCT
 /* zzip_entry is-a zip_disk_entry => fetch.h */
-#define zzip_entry_csize(__p)   ((zzip_size_t) \
-        zzip_disk_entry_get_csize(zzip_entry_d(__p)))
-#define zzip_entry_usize(__p)   ((zzip_size_t) \
-        zzip_disk_entry_get_usize(zzip_entry_d(__p))) 
-#define zzip_entry_compr(__p) ( \
-        zzip_disk_entry_get_compr(zzip_entry_d(__p)))
-#define zzip_entry_flags(__p) ( \
-        zzip_disk_entry_get_flags(zzip_entry_d(__p)))
-#define zzip_entry_namlen(__p)   ((zzip_size_t) \
-        zzip_disk_entry_get_namlen(zzip_entry_d(__p)))
-#define zzip_entry_extras(__p)   ((zzip_size_t) \
-        zzip_disk_entry_get_extras(zzip_entry_d(__p)))
-#define zzip_entry_comment(__p)   ((zzip_size_t) \
-        zzip_disk_entry_get_comment(zzip_entry_d(__p)))
-#define zzip_entry_diskstart(__p) ((int) \
-        zzip_disk_entry_get_diskstart(zzip_entry_d(__p)))
-#define zzip_entry_filetype(__p) ((int) \
-        zzip_disk_entry_get_filetype(zzip_entry_d(__p)))
-#define zzip_entry_filemode(__p) ((int) \
-        zzip_disk_entry_get_filemode(zzip_entry_d(__p)))
-#define zzip_entry_fileoffset(__p) ((zzip_off_t) \
-        zzip_disk_entry_get_offset(zzip_entry_d(__p)))
-#define zzip_entry_sizeof_tail(__p) ((zzip_size_t) \
-        zzip_disk_entry_sizeof_tails(zzip_entry_d(__p)))
+#define zzip_entry_csize(__p)       ((zzip_size_t) zzip_disk_entry_get_csize(zzip_entry_d(__p)))
+#define zzip_entry_usize(__p)       ((zzip_size_t) zzip_disk_entry_get_usize(zzip_entry_d(__p)))
+#define zzip_entry_compr(__p)       (zzip_disk_entry_get_compr(zzip_entry_d(__p)))
+#define zzip_entry_flags(__p)       (zzip_disk_entry_get_flags(zzip_entry_d(__p)))
+#define zzip_entry_namlen(__p)      ((zzip_size_t) zzip_disk_entry_get_namlen(zzip_entry_d(__p)))
+#define zzip_entry_extras(__p)      ((zzip_size_t) zzip_disk_entry_get_extras(zzip_entry_d(__p)))
+#define zzip_entry_comment(__p)     ((zzip_size_t) zzip_disk_entry_get_comment(zzip_entry_d(__p)))
+#define zzip_entry_diskstart(__p)   ((int) zzip_disk_entry_get_diskstart(zzip_entry_d(__p)))
+#define zzip_entry_filetype(__p)    ((int) zzip_disk_entry_get_filetype(zzip_entry_d(__p)))
+#define zzip_entry_filemode(__p)    ((int) zzip_disk_entry_get_filemode(zzip_entry_d(__p)))
+#define zzip_entry_fileoffset(__p)  ((zzip_off_t) zzip_disk_entry_get_offset(zzip_entry_d(__p)))
+#define zzip_entry_sizeof_tail(__p) ((zzip_size_t) zzip_disk_entry_sizeof_tails(zzip_entry_d(__p)))
 #endif
 
 #ifdef __cplusplus
-extern "C" {
 }

_service:tar_scm:v0.13.72.tar.gz/zzip/info.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/info.c Changed

@@ -6,15 +6,15 @@
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
  */
 
-#include <zzip/lib.h>           /* exported... */
+#include <zzip/lib.h> /* exported... */
 #include <zzip/file.h>
 #include <zzip/format.h>
 
 #ifdef ZZIP_HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #else
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #endif
 
 /** get errror status.
@@ -22,7 +22,7 @@
  *  see: => zzip_dir_open, => zzip_dir_open, => zzip_readdir, => zzip_dir_read
  */
 int
-zzip_error(ZZIP_DIR * dir)
+zzip_error(ZZIP_DIR* dir)
 {
     return dir->errcode;
 }
@@ -31,7 +31,10 @@
  *  This function just does dir->errcode = errcode
  */
 void
-zzip_seterror(ZZIP_DIR * dir, int errcode) { dir->errcode = errcode; }
+zzip_seterror(ZZIP_DIR* dir, int errcode)
+{
+    dir->errcode = errcode;
+}
 
 /** get handle.
  * This function will just return the fp->dir value.
@@ -39,8 +42,8 @@
  * If a ZZIP_FILE is contained within a zip-file that one will be a valid
  * pointer, otherwise a NULL is returned and the ZZIP_FILE wraps a real file.
  */
-ZZIP_DIR *
-zzip_dirhandle(ZZIP_FILE * fp)
+ZZIP_DIR*
+zzip_dirhandle(ZZIP_FILE* fp)
 {
     return fp->dir;
 }
@@ -53,49 +56,53 @@
  * a real directory DIR (if you have dirent on your system).
  */
 int
-zzip_dirfd(ZZIP_DIR * dir)
+zzip_dirfd(ZZIP_DIR* dir)
 {
     return dir->fd;
 }
 
 #define LENGTH(x) (sizeof(x) / sizeof(*x))
-static const char* comprlevel = {
-    "stored",   "shrunk",   "redu:1",   "redu:2",   "redu:3",   "redu:4",
-    "impl:N",   "toknze",   "defl:N",   "defl:B",   "impl:B" };
+static const char* comprlevel = {"stored", "shrunk", "redu:1", "redu:2", "redu:3", "redu:4",
+                                   "impl:N", "toknze", "defl:N", "defl:B", "impl:B"};
 
 /** compr name.
  * This function returns the static const string of the known compression methods,
  * Unknown id values will return just "zipped" as the string code.
  */
-zzip_char_t *
+zzip_char_t*
 zzip_compr_str(int compr)
 {
-    if (0 <= compr && (unsigned) compr < LENGTH(comprlevel))
-    {
+    if (0 <= compr && (unsigned) compr < LENGTH(comprlevel)) {
         return comprlevelcompr;
-    } else if (0 < compr && compr < 256) 
-    {
+    }
+    else if (0 < compr && compr < 256) {
         return "zipped";
-    } else
-    {
-#	ifdef S_ISDIR
-        if (S_ISDIR(compr))		return "directory";
-#	endif
-#	ifdef S_ISCHR
-        if (S_ISCHR(compr))		return "is/chr";
-#	endif
-#	ifdef S_ISBLK
-        if (S_ISBLK(compr))		return "is/blk";
-#	endif
-#	ifdef S_ISFIFO
-        if (S_ISFIFO(compr))	return "is/fifo";
-#	endif
-#	ifdef S_ISSOCK
-        if (S_ISSOCK(compr))	return "is/sock";
-#	endif
-#	ifdef S_ISLNK
-        if (S_ISLNK(compr))		return "is/lnk";
-#	endif
+    }
+    else {
+#ifdef S_ISDIR
+        if (S_ISDIR(compr))
+            return "directory";
+#endif
+#ifdef S_ISCHR
+        if (S_ISCHR(compr))
+            return "is/chr";
+#endif
+#ifdef S_ISBLK
+        if (S_ISBLK(compr))
+            return "is/blk";
+#endif
+#ifdef S_ISFIFO
+        if (S_ISFIFO(compr))
+            return "is/fifo";
+#endif
+#ifdef S_ISSOCK
+        if (S_ISSOCK(compr))
+            return "is/sock";
+#endif
+#ifdef S_ISLNK
+        if (S_ISLNK(compr))
+            return "is/lnk";
+#endif
         return "special";
     }
 }
@@ -106,7 +113,7 @@
  * Returns 1 for a stat'able directory, and 0 for a handle to zip-archive.
  */
 int
-zzip_dir_real(ZZIP_DIR * dir)
+zzip_dir_real(ZZIP_DIR* dir)
 {
     return dir->realdir != 0;
 }
@@ -117,9 +124,9 @@
  * Returns 1 for a stat'able file, and 0 for a file inside a zip-archive.
  */
 int
-zzip_file_real(ZZIP_FILE * fp)
+zzip_file_real(ZZIP_FILE* fp)
 {
-    return fp->dir == 0;        /* ie. not dependent on a zip-arch-dir  */
+    return fp->dir == 0; /* ie. not dependent on a zip-arch-dir  */
 }
 
 /** => zzip_file_real
@@ -127,8 +134,8 @@
  * Check before with => zzip_dir_real if the
  * the ZZIP_DIR points to a real directory.
  */
-void *
-zzip_realdir(ZZIP_DIR * dir)
+void*
+zzip_realdir(ZZIP_DIR* dir)
 {
     return dir->realdir;
 }
@@ -139,13 +146,7 @@
  * the ZZIP_FILE points to a real file.
  */
 int
-zzip_realfd(ZZIP_FILE * fp)
+zzip_realfd(ZZIP_FILE* fp)
 {
     return fp->fd;
 }
-
-/*
- * Local variables:
- * c-file-style: "stroustrup"
- * End:
- */

_service:tar_scm:v0.13.72.tar.gz/zzip/info.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/info.h Changed

_service:tar_scm:v0.13.72.tar.gz/zzip/lib.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/lib.h Changed

@@ -1,5 +1,5 @@
 /*
- * Author: 
+ * Author:
  *      Guido Draheim <guidod@gmx.de>
  *      Tomi Ollila <Tomi.Ollila@iki.fi>
  *
@@ -24,16 +24,15 @@
 /*
  * this structure cannot be wildly enlarged... (see zzip-zip.c)
  */
-struct zzip_dir_hdr
-{
-    uint32_t    d_usize;        /* uncompressed size */
-    uint32_t    d_csize;        /* compressed size */
-    uint32_t    d_crc32;        /* the adler32-checksum */
-    uint32_t    d_off;          /* offset of file in zipfile */
-    uint16_t    d_reclen;       /* next dir_hdr structure offset */
-    uint16_t    d_namlen;       /* explicit namelen of d_name */
-    uint8_t     d_compr;        /* the compression type, 0 = store, 8 = inflate */
-    char        d_name1;      /* the actual name of the entry, may contain DIRSEPs */
+struct zzip_dir_hdr {
+    uint32_t d_usize;   /* uncompressed size */
+    uint32_t d_csize;   /* compressed size */
+    uint32_t d_crc32;   /* the adler32-checksum */
+    uint32_t d_off;     /* offset of file in zipfile */
+    uint16_t d_reclen;  /* next dir_hdr structure offset */
+    uint16_t d_namlen;  /* explicit namelen of d_name */
+    uint8_t  d_compr;   /* the compression type, 0 = store, 8 = inflate */
+    char     d_name1; /* the actual name of the entry, may contain DIRSEPs */
 };
 #define _ZZIP_DIRENT_HAVE_D_NAMLEN
 #define _ZZIP_DIRENT_HAVE_D_OFF
@@ -42,44 +41,42 @@
 /*
  * you shall not use this struct anywhere else than in zziplib sources.
  */
-struct zzip_dir
-{
-    int fd;
-    int errcode; /* zzip_error_t */
+struct zzip_dir {
+    int  fd;
+    int  errcode; /* zzip_error_t */
     long refcount;
     struct { /* reduce a lot of alloc/deallocations by caching these: */
-	int * volatile locked;
-        struct zzip_file * volatile fp;  
-        char * volatile buf32k; 
+        int* volatile locked;
+        struct zzip_file* volatile fp;
+        char* volatile buf32k;
     } cache;
-    struct zzip_dir_hdr * hdr0;  /* zfi; */
-    struct zzip_dir_hdr * hdr;   /* zdp; directory pointer, for dirent stuff */
-    struct zzip_file * currentfp; /* last fp used... */
-    struct zzip_dirent dirent;
-    void*  realdir;               /* e.g. DIR* from posix dirent.h */
-    char*  realname;
-    zzip_strings_t* fileext;      /* list of fileext to test for */
-    zzip_plugin_io_t io;          /* vtable for io routines */
-}; 
+    struct zzip_dir_hdr* hdr0;      /* zfi; */
+    struct zzip_dir_hdr* hdr;       /* zdp; directory pointer, for dirent stuff */
+    struct zzip_file*    currentfp; /* last fp used... */
+    struct zzip_dirent   dirent;
+    void*                realdir; /* e.g. DIR* from posix dirent.h */
+    char*                realname;
+    zzip_strings_t*      fileext; /* list of fileext to test for */
+    zzip_plugin_io_t     io;      /* vtable for io routines */
+};
 
 #define ZZIP_32K 32768
 
 /* try to open a zip-basename with default_fileext */
-int      __zzip_try_open (zzip_char_t* filename, int filemode,
-                          zzip_strings_t* ext, zzip_plugin_io_t io);
+int
+__zzip_try_open(zzip_char_t* filename, int filemode, zzip_strings_t* ext, zzip_plugin_io_t io);
 
-ZZIP_DIR * 
-zzip_dir_fdopen(int fd, zzip_error_t * errcode_p);
+ZZIP_DIR*
+zzip_dir_fdopen(int fd, zzip_error_t* errcode_p);
 
-ZZIP_DIR* 
-zzip_dir_fdopen_ext_io(int fd, zzip_error_t * errorcode_p,
-                       zzip_strings_t* ext, const zzip_plugin_io_t io);
+ZZIP_DIR*
+zzip_dir_fdopen_ext_io(int fd, zzip_error_t* errorcode_p, zzip_strings_t* ext,
+                       const zzip_plugin_io_t io);
 
 ZZIP_DIR* /*deprecated*/
-zzip_dir_alloc_ext_io (zzip_strings_t* ext, const zzip_plugin_io_t io);
+zzip_dir_alloc_ext_io(zzip_strings_t* ext, const zzip_plugin_io_t io);
 
 #ifdef __cplusplus
 }
 #endif
 #endif /* _ZZIP_H */
-

_service:tar_scm:v0.13.72.tar.gz/zzip/memdisk.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/memdisk.c Changed

@@ -21,22 +21,23 @@
 
 #include <zzip/types.h>
 
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
 #include <zlib.h>
 #include <zzip/format.h>
-#include <zzip/fetch.h>
 #include <zzip/mmapped.h>
+#include <zzip/fetch.h>
 #include <zzip/memdisk.h>
-#include <zzip/__fnmatch.h>
 #include <zzip/__errno.h>
+#include <zzip/__fnmatch.h>
 
-#define ___ {
+#define ___  {
 #define ____ }
 
+/* clang-format off */
 #define DEBUG 1
 #ifdef DEBUG
 #define debug1(msg) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__); } while(0)
@@ -44,68 +45,65 @@
 #define debug3(msg, arg1, arg2) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__, arg1, arg2); } while(0)
 #define debug4(msg, arg1, arg2, arg3) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__, arg1, arg2, arg3); } while(0)
 #else
-#define debug1(msg) 
-#define debug2(msg, arg1) 
-#define debug3(msg, arg1, arg2) 
-#define debug4(msg, arg1, arg2, arg3) 
+#define debug1(msg)
+#define debug2(msg, arg1)
+#define debug3(msg, arg1, arg2)
+#define debug4(msg, arg1, arg2, arg3)
 #endif
+/* clang-format on */
 
 #define ZZIP_EXTRA_zip64 0x0001
 typedef struct zzip_extra_zip64 zzip_extra_zip64;
 
 /*forward*/
 
-static zzip__new__ ZZIP_MEM_ENTRY *
-zzip_mem_entry_new(ZZIP_DISK * disk, ZZIP_DISK_ENTRY * entry);
+static zzip__new__ ZZIP_MEM_ENTRY*
+zzip_mem_entry_new(ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry);
 static void
-zzip_mem_entry_free(ZZIP_MEM_ENTRY * _zzip_restrict item);
+zzip_mem_entry_free(ZZIP_MEM_ENTRY* _zzip_restrict item);
 
 /** => zzip_mem_disk_open
  * This function is internally used to prepare opening a disk.
  */
-zzip__new__ ZZIP_MEM_DISK *
+zzip__new__ ZZIP_MEM_DISK*
 zzip_mem_disk_new(void)
 {
     return calloc(1, sizeof(ZZIP_MEM_DISK));
 }
 
 /** create new diskdir handle.
- *  This function wraps underlying zzip_disk_open. 
+ *  This function wraps underlying zzip_disk_open.
  */
-zzip__new__ ZZIP_MEM_DISK *
-zzip_mem_disk_open(char *filename)
+zzip__new__ ZZIP_MEM_DISK*
+zzip_mem_disk_open(char* filename)
 {
-    ZZIP_DISK *disk = zzip_disk_open(filename);
-    if (! disk)
-    { 
-       debug2("can not open disk file %s", filename);
-       return 0;
+    ZZIP_DISK* disk = zzip_disk_open(filename);
+    if (! disk) {
+        debug2("can not open disk file %s", filename);
+        return 0;
     }
-    ___ ZZIP_MEM_DISK *dir = zzip_mem_disk_new();
-    if (zzip_mem_disk_load(dir, disk) == -1)
-    {
-       debug2("unable to load disk %s", filename);
+    ___ ZZIP_MEM_DISK* dir = zzip_mem_disk_new();
+    if (zzip_mem_disk_load(dir, disk) == -1) {
+        debug2("unable to load disk %s", filename);
     }
     return dir;
     ____;
 }
 
 /** => zzip_mem_disk_open
- *  This function wraps the underlying zzip_disk_open. 
+ *  This function wraps the underlying zzip_disk_open.
  */
-zzip__new__ ZZIP_MEM_DISK *
+zzip__new__ ZZIP_MEM_DISK*
 zzip_mem_disk_fdopen(int fd)
 {
-    ZZIP_DISK *disk = zzip_disk_mmap(fd);
-    if (! disk)
-    { 
-       debug2("can not open disk fd %i", fd);
-       return 0;
+    ZZIP_DISK* disk = zzip_disk_mmap(fd);
+    if (! disk) {
+        debug2("can not open disk fd %i", fd);
+        return 0;
     }
-    ___ ZZIP_MEM_DISK *dir = zzip_mem_disk_new();
-    if (zzip_mem_disk_load(dir, disk) == -1)
-    {
-       debug2("unable to load disk fd %i", fd);
+    ___ ZZIP_MEM_DISK* dir = zzip_mem_disk_new();
+    if (zzip_mem_disk_load(dir, disk) == -1) {
+        debug2("unable to load disk fd %i", fd);
     }
     return dir;
     ____;
@@ -114,19 +112,17 @@
 /** create new diskdir handle.
  *  This function wraps underlying zzip_disk_buffer.
  */
-zzip__new__ ZZIP_MEM_DISK *
-zzip_mem_disk_buffer(char *buffer, size_t buflen)
+zzip__new__ ZZIP_MEM_DISK*
+zzip_mem_disk_buffer(char* buffer, size_t buflen)
 {
-    ZZIP_DISK *disk = zzip_disk_buffer(buffer, buflen);
-    if (! disk)
-    { 
-       debug2("can not open disk buf %p", buffer);
-       return 0;
+    ZZIP_DISK* disk = zzip_disk_buffer(buffer, buflen);
+    if (! disk) {
+        debug2("can not open disk buf %p", buffer);
+        return 0;
     }
-    ___ ZZIP_MEM_DISK *dir = zzip_mem_disk_new();
-    if (zzip_mem_disk_load(dir, disk) == -1)
-    {
-       debug2("unable to load disk buf %p", buffer);
+    ___ ZZIP_MEM_DISK* dir = zzip_mem_disk_new();
+    if (zzip_mem_disk_load(dir, disk) == -1) {
+        debug2("unable to load disk buf %p", buffer);
     }
     return dir;
     ____;
@@ -137,38 +133,38 @@
  *  returns: number of entries, or -1 on error (setting errno)
  */
 long
-zzip_mem_disk_load(ZZIP_MEM_DISK * dir, ZZIP_DISK * disk)
+zzip_mem_disk_load(ZZIP_MEM_DISK* dir, ZZIP_DISK* disk)
 {
-    if (! dir || ! disk)
-        { errno=EINVAL; return -1; }
+    if (! dir || ! disk) {
+        errno = EINVAL;
+        return -1;
+    }
     if (dir->list)
         zzip_mem_disk_unload(dir);
-    ___ long count = 0;
-    ___ struct zzip_disk_entry *entry = zzip_disk_findfirst(disk);
-    if (!entry) goto error;
-    for (; entry; entry = zzip_disk_findnext(disk, entry))
-    {
-        ZZIP_MEM_ENTRY *item = zzip_mem_entry_new(disk, entry);
-        if (! item)
-        {
+    dir->disk                         = disk;
+    ___ long                    count = 0;
+    ___ struct zzip_disk_entry* entry = zzip_disk_findfirst(disk);
+    if (! entry)
+        goto error;
+    for (; entry; entry = zzip_disk_findnext(disk, entry)) {
+        ZZIP_MEM_ENTRY* item = zzip_mem_entry_new(disk, entry);
+        if (! item) {
             debug1("unable to load entry");
             goto error;
         }
-        if (dir->last)
-        {
-            dir->last->zz_next = item;  /* chain last */
-        } else
-        {
+        if (dir->last) {
+            dir->last->zz_next = item; /* chain last */
+        }
+        else {
             dir->list = item;
         }
-        dir->last = item;       /* to earlier */

_service:tar_scm:v0.13.72.tar.gz/zzip/memdisk.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/memdisk.h Changed

@@ -15,11 +15,11 @@
 extern "C" {
 #endif
 
-typedef struct _zzip_mem_disk ZZIP_MEM_DISK;
+typedef struct _zzip_mem_disk  ZZIP_MEM_DISK;
 typedef struct _zzip_mem_entry ZZIP_MEM_ENTRY;
 
 struct _zzip_mem_disk {
-    ZZIP_DISK* disk;
+    ZZIP_DISK*      disk;
     ZZIP_MEM_ENTRY* list;
     ZZIP_MEM_ENTRY* last;
 };
@@ -29,125 +29,147 @@
 #endif
 
 zzip_mem_disk_extern zzip__new__ ZZIP_MEM_DISK*
-zzip_mem_disk_new (void);
+zzip_mem_disk_new(void);
 zzip_mem_disk_extern zzip__new__ ZZIP_MEM_DISK*
-zzip_mem_disk_open (char* filename);
+zzip_mem_disk_open(char* filename);
 zzip_mem_disk_extern zzip__new__ ZZIP_MEM_DISK*
-zzip_mem_disk_fdopen (int fd);
-zzip_mem_disk_extern zzip__new__ ZZIP_MEM_DISK *
-zzip_mem_disk_buffer(char *buffer, size_t buflen);
+zzip_mem_disk_fdopen(int fd);
+zzip_mem_disk_extern zzip__new__ ZZIP_MEM_DISK*
+zzip_mem_disk_buffer(char* buffer, size_t buflen);
 zzip_mem_disk_extern void
-zzip_mem_disk_close (ZZIP_MEM_DISK* _zzip_restrict dir);
+zzip_mem_disk_close(ZZIP_MEM_DISK* _zzip_restrict dir);
 
 zzip_mem_disk_extern long
-zzip_mem_disk_load (ZZIP_MEM_DISK* dir, ZZIP_DISK* disk);
+zzip_mem_disk_load(ZZIP_MEM_DISK* dir, ZZIP_DISK* disk);
 zzip_mem_disk_extern void
-zzip_mem_disk_unload (ZZIP_MEM_DISK* dir);
+zzip_mem_disk_unload(ZZIP_MEM_DISK* dir);
 ZZIP_EXTRA_BLOCK*
-zzip_mem_entry_extra_block (ZZIP_MEM_ENTRY* entry, short datatype) ZZIP_GNUC_DEPRECATED;
+zzip_mem_entry_extra_block(ZZIP_MEM_ENTRY* entry, short datatype) ZZIP_GNUC_DEPRECATED;
 ZZIP_EXTRA_BLOCK*
-zzip_mem_entry_find_extra_block (ZZIP_MEM_ENTRY* entry, short datatype, zzip_size_t blocksize);
+zzip_mem_entry_find_extra_block(ZZIP_MEM_ENTRY* entry, short datatype, zzip_size_t blocksize);
 
 #ifdef USE_INLINE
-_zzip_inline ZZIP_DISK* zzip_disk (ZZIP_MEM_DISK* dir) { return dir->disk; }
+_zzip_inline ZZIP_DISK*
+zzip_disk(ZZIP_MEM_DISK* dir)
+{
+    return dir->disk;
+}
 #else
 #define zzip_disk(_X_) ((_X_)->disk)
 #endif
 
-
 /* these functions are much faster than the orgiinal zzip_disk_ functions */
 
 /* zzip_mem_entry <is similar to> zzip_disk_entry */
 struct _zzip_mem_entry {
     struct _zzip_mem_entry* zz_next;
-    char*            zz_name;      /* zero-terminated (from "filename") */
-    zzip_byte_t*     zz_data;      /* compressed content start (mmap addr) */
-    int              zz_flags;     /* (from "z_flags") */
-    int              zz_compr;     /* (from "z_compr") */
-    long             zz_mktime;    /* (from "z_dostime") */
-    long             zz_crc32;     /* (from "z_crc32") */
-    zzip_off_t       zz_csize;     /* (from "z_csize")  overridden by zip64 */
-    zzip_off_t       zz_usize;     /* (from "z_usize")  overridden by zip64 */
-    zzip_off_t       zz_offset;    /* (from "z_offset") overridden by zip64 */
-    int              zz_diskstart; /* (from "z_diskstart") rridden by zip64 */
-    int              zz_filetype;  /* (from "z_filetype") */
-    char*            zz_comment;   /* zero-terminated (from "comment") */
-    ZZIP_EXTRA_BLOCK* zz_ext3;    /* terminated by null in z_datatype */
-    zzip_size_t       zz_extlen3; /* the extra blocks are NOT converted */
-};                                
-
-#define _zzip_mem_disk_findfirst(_d_)   (!(_d_) ? 0 : ((_d_)->list))
-#define _zzip_mem_disk_findnext(_d_,_e_) (!(_e_) ? (!(_d_) ? 0 : ((_d_)->list)) : ((_e_)->zz_next))
-#define _zzip_mem_entry_findnext(_e_) (!(_e_) ? 0 : ((_e_)->zz_next))
+    char*                   zz_name;      /* zero-terminated (from "filename") */
+    zzip_byte_t*            zz_data;      /* compressed content start (mmap addr) */
+    int                     zz_flags;     /* (from "z_flags") */
+    int                     zz_compr;     /* (from "z_compr") */
+    long                    zz_mktime;    /* (from "z_dostime") */
+    long                    zz_crc32;     /* (from "z_crc32") */
+    zzip_off_t              zz_csize;     /* (from "z_csize")  overridden by zip64 */
+    zzip_off_t              zz_usize;     /* (from "z_usize")  overridden by zip64 */
+    zzip_off_t              zz_offset;    /* (from "z_offset") overridden by zip64 */
+    int                     zz_diskstart; /* (from "z_diskstart") rridden by zip64 */
+    int                     zz_filetype;  /* (from "z_filetype") */
+    char*                   zz_comment;   /* zero-terminated (from "comment") */
+    ZZIP_EXTRA_BLOCK*       zz_ext3;    /* terminated by null in z_datatype */
+    zzip_size_t             zz_extlen3; /* the extra blocks are NOT converted */
+};
+
+#define _zzip_mem_disk_findfirst(_d_) (! (_d_) ? 0 : ((_d_)->list))
+#define _zzip_mem_disk_findnext(_d_, _e_)                                                          \
+    (! (_e_) ? (! (_d_) ? 0 : ((_d_)->list)) : ((_e_)->zz_next))
+#define _zzip_mem_entry_findnext(_e_) (! (_e_) ? 0 : ((_e_)->zz_next))
 
 #ifndef USE_INLINE
 #define zzip_mem_disk_findfirst _zzip_mem_disk_findfirst
-#define zzip_mem_disk_findnext _zzip_mem_disk_findnext
+#define zzip_mem_disk_findnext  _zzip_mem_disk_findnext
 #define zzip_mem_entry_findnext _zzip_mem_entry_findnext
 #else
 
 _zzip_inline ZZIP_MEM_ENTRY*
-zzip_mem_disk_findfirst(ZZIP_MEM_DISK* dir) {
-    if (! dir) return 0;
-    return _zzip_mem_disk_findfirst(dir); }
+zzip_mem_disk_findfirst(ZZIP_MEM_DISK* dir)
+{
+    if (! dir)
+        return 0;
+    return _zzip_mem_disk_findfirst(dir);
+}
 _zzip_inline ZZIP_MEM_ENTRY*
-zzip_mem_disk_findnext(ZZIP_MEM_DISK* dir, ZZIP_MEM_ENTRY* entry) {
-    if (! dir) return 0;
-    return _zzip_mem_disk_findnext(dir, entry); }
+zzip_mem_disk_findnext(ZZIP_MEM_DISK* dir, ZZIP_MEM_ENTRY* entry)
+{
+    if (! dir)
+        return 0;
+    return _zzip_mem_disk_findnext(dir, entry);
+}
 _zzip_inline ZZIP_MEM_ENTRY*
-zzip_mem_entry_findnext(ZZIP_MEM_ENTRY* entry) {
-    if (! entry) return 0;
-    return _zzip_mem_entry_findnext(entry); }
+zzip_mem_entry_findnext(ZZIP_MEM_ENTRY* entry)
+{
+    if (! entry)
+        return 0;
+    return _zzip_mem_entry_findnext(entry);
+}
 #endif
 
-#define _zzip_mem_entry_to_name(_e_) (!(_e_) ? 0 : ((_e_)->zz_name))
-#define _zzip_mem_entry_to_comment(_e_) (!(_e_) ? 0 : ((_e_)->zz_comment))
-#define _zzip_mem_entry_strdup_name(_e_) (!(_e_) ? 0 : (strdup((_e_)->zz_name)))
-#define _zzip_mem_entry_to_data(_e_) (!(_e_) ? 0 : ((_e_)->zz_data))
+#define _zzip_mem_entry_to_name(_e_)     (! (_e_) ? 0 : ((_e_)->zz_name))
+#define _zzip_mem_entry_to_comment(_e_)  (! (_e_) ? 0 : ((_e_)->zz_comment))
+#define _zzip_mem_entry_strdup_name(_e_) (! (_e_) ? 0 : (strdup((_e_)->zz_name)))
+#define _zzip_mem_entry_to_data(_e_)     (! (_e_) ? 0 : ((_e_)->zz_data))
 
 #ifndef USE_INLINE
-#define zzip_mem_entry_to_name _zzip_mem_entry_to_name
-#define zzip_mem_entry_to_comment _zzip_mem_entry_to_comment
+#define zzip_mem_entry_to_name     _zzip_mem_entry_to_name
+#define zzip_mem_entry_to_comment  _zzip_mem_entry_to_comment
 #define zzip_mem_entry_strdup_name _zzip_mem_entry_strdup_name
-#define zzip_mem_entry_to_data _zzip_mem_entry_to_data
+#define zzip_mem_entry_to_data     _zzip_mem_entry_to_data
 #else
 _zzip_inline char*
-zzip_mem_entry_to_name(ZZIP_MEM_ENTRY* entry) {
-    if (! entry) return 0;
-    return _zzip_mem_entry_to_name(entry); }
-_zzip_inline char*
-zzip_mem_entry_to_comment(ZZIP_MEM_ENTRY* entry) {
-    if (! entry) return 0;
-    return _zzip_mem_entry_to_comment(entry); }
-zzip__new__
+zzip_mem_entry_to_name(ZZIP_MEM_ENTRY* entry)
+{
+    if (! entry)
+        return 0;
+    return _zzip_mem_entry_to_name(entry);
+}
 _zzip_inline char*
-zzip_mem_entry_strdup_name(ZZIP_MEM_ENTRY* entry) {
-    if (! entry) return 0;
-    return _zzip_mem_entry_strdup_name(entry); }
+zzip_mem_entry_to_comment(ZZIP_MEM_ENTRY* entry)
+{
+    if (! entry)
+        return 0;
+    return _zzip_mem_entry_to_comment(entry);
+}
+zzip__new__ _zzip_inline char*
+zzip_mem_entry_strdup_name(ZZIP_MEM_ENTRY* entry)
+{
+    if (! entry)
+        return 0;
+    return _zzip_mem_entry_strdup_name(entry);
+}
 _zzip_inline zzip_byte_t*
-zzip_mem_entry_to_data(ZZIP_MEM_ENTRY* entry) {
-    if (! entry) return 0;
-    return _zzip_mem_entry_to_data(entry); }
+zzip_mem_entry_to_data(ZZIP_MEM_ENTRY* entry)
+{
+    if (! entry)

_service:tar_scm:v0.13.72.tar.gz/zzip/mmapped.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/mmapped.c Changed

@@ -27,39 +27,39 @@
 #define _GNU_SOURCE _glibc_developers_are_idiots_to_call_strndup_gnu_specific_
 #endif
 
-#include <zzip/mmapped.h>
 #include <zzip/format.h>
+#include <zzip/mmapped.h>
 #include <zzip/fetch.h>
 #include <zzip/__debug.h>
+#include <zzip/__errno.h>
+#include <zzip/__fnmatch.h>
 #include <zzip/__mmap.h>
 #include <zzip/__string.h>
-#include <zzip/__fnmatch.h>
-#include <zzip/__errno.h>
 
 #include <stdlib.h>
 #include <sys/stat.h>
 
-#if   defined ZZIP_HAVE_UNISTD_H
+#if defined ZZIP_HAVE_UNISTD_H
 #include <unistd.h>
 #elif defined ZZIP_HAVE_IO_H
 #include <io.h>
 #endif
 
-#if   defined ZZIP_HAVE_STRING_H
+#if defined ZZIP_HAVE_STRING_H
 #include <string.h>
 #elif defined ZZIP_HAVE_STRINGS_H
 #include <strings.h>
 #endif
 
-
-#if __STDC_VERSION__+0 > 199900L
+#if __STDC_VERSION__ + 0 > 199900L
 #define ___
 #define ____
 #else
-#define ___ {
+#define ___  {
 #define ____ }
 #endif
 
+/* clang-format off */
 #define DEBUG 1
 #ifdef DEBUG
 #define debug1(msg) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__); } while(0)
@@ -67,25 +67,26 @@
 #define debug3(msg, arg1, arg2) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__, arg1, arg2); } while(0)
 #define debug4(msg, arg1, arg2, arg3) do { fprintf(stderr, "DEBUG: %s : " msg "\n", __func__, arg1, arg2, arg3); } while(0)
 #else
-#define debug1(msg) 
-#define debug2(msg, arg1) 
-#define debug3(msg, arg1, arg2) 
-#define debug4(msg, arg1, arg2, arg3) 
+#define debug1(msg)
+#define debug2(msg, arg1)
+#define debug3(msg, arg1, arg2)
+#define debug4(msg, arg1, arg2, arg3)
 #endif
+/* clang-format on */
 
 /** => zzip_disk_mmap
  * This function does primary initialization of a disk-buffer struct.
- * 
+ *
  * This function always returns 0 as success.
  */
 int
-zzip_disk_init(ZZIP_DISK * disk, void *buffer, zzip_size_t buflen)
+zzip_disk_init(ZZIP_DISK* disk, void* buffer, zzip_size_t buflen)
 {
-    disk->buffer = (zzip_byte_t *) buffer;
-    disk->endbuf = (zzip_byte_t *) buffer + buflen;
+    disk->buffer   = (zzip_byte_t*) buffer;
+    disk->endbuf   = (zzip_byte_t*) buffer + buflen;
     disk->reserved = 0;
-    disk->flags = 0;
-    disk->mapped = 0;
+    disk->flags    = 0;
+    disk->mapped   = 0;
     /* do not touch disk->user */
     /* do not touch disk->code */
     return 0;
@@ -96,10 +97,10 @@
  *
  * This function may return null on errors (errno).
  */
-zzip__new__ ZZIP_DISK *
+zzip__new__ ZZIP_DISK*
 zzip_disk_new(void)
 {
-    ZZIP_DISK *disk = malloc(sizeof(ZZIP_DISK));
+    ZZIP_DISK* disk = malloc(sizeof(ZZIP_DISK));
     if (! disk)
         return disk; /* ENOMEM */
     zzip_disk_init(disk, 0, 0);
@@ -115,19 +116,18 @@
  *
  * This function may return null on errors (errno).
  */
-zzip__new__ ZZIP_DISK *
+zzip__new__ ZZIP_DISK*
 zzip_disk_mmap(int fd)
 {
     struct stat st;
     if (fstat(fd, &st) || ! st.st_size)
         return 0; /* EACCESS */
-    ___ ZZIP_DISK *disk = zzip_disk_new();
+    ___ ZZIP_DISK* disk = zzip_disk_new();
     if (! disk)
         return 0; /* ENOMEM */
     disk->buffer = _zzip_mmap(disk->mapped, fd, 0, st.st_size);
-    if (disk->buffer == MAP_FAILED)
-    { 
-        free (disk); 
+    if (disk->buffer == MAP_FAILED) {
+        free(disk);
         return 0; /* EFAULT */
     }
     disk->endbuf = disk->buffer + st.st_size;
@@ -140,7 +140,7 @@
  * munmap(2) on the buffer area and => free(3) on the ZZIP_DISK structure.
  */
 int
-zzip_disk_munmap(ZZIP_DISK * disk)
+zzip_disk_munmap(ZZIP_DISK* disk)
 {
     if (! disk)
         return 0;
@@ -159,35 +159,32 @@
  *
  * This function may return null on errors (errno).
  */
-zzip__new__ ZZIP_DISK *
-zzip_disk_open(char *filename)
+zzip__new__ ZZIP_DISK*
+zzip_disk_open(char* filename)
 {
-#  ifndef O_BINARY
-#  define O_BINARY 0
-#  endif
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
     struct stat st;
     if (stat(filename, &st) || ! st.st_size)
         return 0; /* ENOENT */
     ___ int fd = open(filename, O_RDONLY | O_BINARY);
     if (fd <= 0)
         return 0; /* EACCESS */
-    ___ ZZIP_DISK *disk = zzip_disk_mmap(fd);
+    ___ ZZIP_DISK* disk = zzip_disk_mmap(fd);
     if (disk)
         return disk;
-    ___ zzip_byte_t *buffer = malloc(st.st_size);
-    if (! buffer)
-    {
+    ___ zzip_byte_t* buffer = malloc(st.st_size);
+    if (! buffer) {
         return 0; /* ENOMEM */
     }
-    if ((st.st_size < read(fd, buffer, st.st_size)))
-    {
-        free (buffer);
+    if ((st.st_size < read(fd, buffer, st.st_size))) {
+        free(buffer);
         return 0; /* EIO */
     }
     disk = zzip_disk_new();
-    if (! disk)
-    {
-        free (buffer);
+    if (! disk) {
+        free(buffer);
         return 0; /* ENOMEM */
     }
     disk->buffer = buffer;
@@ -211,13 +208,13 @@
  *
  * This function may return null (errno).
  */
-zzip__new__ ZZIP_DISK *
-zzip_disk_buffer(void *buffer, size_t buflen) {
-    ZZIP_DISK *disk = zzip_disk_new();
-    if (disk)
-    {
-        disk->buffer = (zzip_byte_t *) buffer;
-        disk->endbuf = (zzip_byte_t *) buffer + buflen;
+zzip__new__ ZZIP_DISK*
+zzip_disk_buffer(void* buffer, size_t buflen)
+{
+    ZZIP_DISK* disk = zzip_disk_new();
+    if (disk) {
+        disk->buffer = (zzip_byte_t*) buffer;
+        disk->endbuf = (zzip_byte_t*) buffer + buflen;
         disk->mapped = -1;
     }
     return disk;

_service:tar_scm:v0.13.72.tar.gz/zzip/mmapped.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/mmapped.h Changed

@@ -11,7 +11,6 @@
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
  */
 
-
 #include <zzip/types.h>
 
 #ifdef _ZZIP_DISK_FILE_STRUCT
@@ -22,24 +21,23 @@
 extern "C" {
 #endif
 
-typedef struct zzip_disk_file  ZZIP_DISK_FILE;
-typedef struct zzip_disk       ZZIP_DISK;
+typedef struct zzip_disk_file ZZIP_DISK_FILE;
+typedef struct zzip_disk      ZZIP_DISK;
 /*  def struct zzip_disk_entry ZZIP_DISK_ENTRY; */
 
 /* we expose this structure so third party applications can augment
  * on them. The mmapped zip access usually just needs the two pointers
  * specifying the mmapped area, wherever you have that from.
  */
-struct zzip_disk
-{
-    zzip_byte_t* buffer; /* start of mmapped area, the base of all seekvals */
-    zzip_byte_t* endbuf; /* end of mmapped area, i.e. buffer + buflen */
-    void* reserved;    /* - for later extensions (might be renamed) */
-    void* user;        /* - free for applications (use this!) */
-    long  flags;       /* bit 0: findfile searches case-insensitive */
-    long  mapped;      /* used for mmap() wrappers of zzip/__mmap.h */
-    long  unused;      /* - for later extensions (might be renamed) */
-    long  code;        /* - free for applications (use this!) */
+struct zzip_disk {
+    zzip_byte_t* buffer;   /* start of mmapped area, the base of all seekvals */
+    zzip_byte_t* endbuf;   /* end of mmapped area, i.e. buffer + buflen */
+    void*        reserved; /* - for later extensions (might be renamed) */
+    void*        user;     /* - free for applications (use this!) */
+    long         flags;    /* bit 0: findfile searches case-insensitive */
+    long         mapped;   /* used for mmap() wrappers of zzip/__mmap.h */
+    long         unused;   /* - for later extensions (might be renamed) */
+    long         code;     /* - free for applications (use this!) */
 };
 
 /* fnmatch search shall be case insensitive */
@@ -66,13 +64,12 @@
 zzip_disk_extern zzip__new__ ZZIP_DISK*
 zzip_disk_open(char* filename);
 
-zzip_disk_extern zzip__new__ ZZIP_DISK *
-zzip_disk_buffer(void *buffer, size_t buflen);
+zzip_disk_extern zzip__new__ ZZIP_DISK*
+zzip_disk_buffer(void* buffer, size_t buflen);
 
 zzip_disk_extern int
 zzip_disk_close(ZZIP_DISK* disk);
 
-
 zzip_disk_extern ZZIP_DISK_ENTRY*
 zzip_disk_findfirst(ZZIP_DISK* disk);
 
@@ -89,40 +86,35 @@
 zzip_disk_entry_to_data(ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry);
 
 zzip_disk_extern ZZIP_DISK_ENTRY*
-zzip_disk_findfile(ZZIP_DISK* disk,
-		   char* filename, ZZIP_DISK_ENTRY* after,
-		   zzip_strcmp_fn_t compare);
+zzip_disk_findfile(ZZIP_DISK* disk, char* filename, ZZIP_DISK_ENTRY* after,
+                   zzip_strcmp_fn_t compare);
 zzip_disk_extern ZZIP_DISK_ENTRY*
-zzip_disk_findmatch(ZZIP_DISK* disk,
-		    char* filespec, ZZIP_DISK_ENTRY* after,
-		    zzip_fnmatch_fn_t compare, int flags);
-
+zzip_disk_findmatch(ZZIP_DISK* disk, char* filespec, ZZIP_DISK_ENTRY* after,
+                    zzip_fnmatch_fn_t compare, int flags);
 
 zzip_disk_extern zzip__new__ ZZIP_DISK_FILE*
-zzip_disk_entry_fopen (ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry);
+zzip_disk_entry_fopen(ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry);
 
 zzip_disk_extern zzip__new__ ZZIP_DISK_FILE*
-zzip_disk_fopen (ZZIP_DISK* disk, char* filename);
+zzip_disk_fopen(ZZIP_DISK* disk, char* filename);
 
 zzip_disk_extern _zzip_size_t
-zzip_disk_fread (void* ptr, _zzip_size_t size, _zzip_size_t nmemb,
-		 ZZIP_DISK_FILE* file);
+zzip_disk_fread(void* ptr, _zzip_size_t size, _zzip_size_t nmemb, ZZIP_DISK_FILE* file);
 zzip_disk_extern int
-zzip_disk_fclose (ZZIP_DISK_FILE* file);
+zzip_disk_fclose(ZZIP_DISK_FILE* file);
 int
-zzip_disk_feof (ZZIP_DISK_FILE* file);
+zzip_disk_feof(ZZIP_DISK_FILE* file);
 
 #ifdef _ZZIP_DISK_FILE_STRUCT
 /**
  * typedef struct zzip_disk_file ZZIP_DISK_FILE;
  */
-struct zzip_disk_file
-{
-    zzip_byte_t* buffer;               /* fopen disk->buffer */
-    zzip_byte_t* endbuf;               /* fopen disk->endbuf */
-    zzip_size_t avail;                 /* memorized for checks on EOF */
-    z_stream zlib;                     /* for inflated blocks */
-    zzip_byte_t* stored;               /* for stored blocks */
+struct zzip_disk_file {
+    zzip_byte_t* buffer; /* fopen disk->buffer */
+    zzip_byte_t* endbuf; /* fopen disk->endbuf */
+    zzip_size_t  avail;  /* memorized for checks on EOF */
+    z_stream     zlib;   /* for inflated blocks */
+    zzip_byte_t* stored; /* for stored blocks */
 };
 #endif
 
@@ -130,4 +122,3 @@
 }
 #endif
 #endif
-

_service:tar_scm:v0.13.72.tar.gz/zzip/plugin.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/plugin.c Changed

@@ -1,6 +1,6 @@
 
 /*
- * Author: 
+ * Author:
  *	Guido Draheim <guidod@gmx.de>
  *      Mike Nordell <tamlin-@-algonet-se>
  *
@@ -10,10 +10,10 @@
 #include <zzip/lib.h>
 #include <zzip/plugin.h>
 
-#include <string.h>
-#include <sys/stat.h>
 #include <errno.h>
 #include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
 #ifdef DEBUG
 #include <stdio.h>
 #endif
@@ -32,15 +32,16 @@
     if (fstat(fd, &st) < 0)
         return -1;
 
-# if defined DEBUG && ! defined _WIN32
-    if (! st.st_size && st.st_blocks > 1)        /* seen on some darwin 10.1 machines */
-        fprintf(stderr, "broken fstat(2) ?? st_size=%ld st_blocks=%ld\n",
+#if defined DEBUG && ! defined _WIN32
+    if (! st.st_size && st.st_blocks > 1) /* seen on some darwin 10.1 machines */
+        fprintf(stderr, "broken fstat(2) ?? st_size=%ld st_blocks=%ld\n", /* .. */
                 (long) st.st_size, (long) st.st_blocks);
-# endif
+#endif
 
     return st.st_size;
 }
 
+/* clang-format off */
 static const struct zzip_plugin_io default_io = {
     &open,
     &close,
@@ -50,6 +51,7 @@
     1, 1,
     &_zzip_write
 };
+/* clang-format on */
 
 /** => zzip_init_io
  * This function returns a zzip_plugin_io_t handle to static defaults
@@ -59,31 +61,24 @@
 zzip_plugin_io_t
 zzip_get_default_io(void)
 {
-    return (zzip_plugin_io_t) & default_io;
+    return (zzip_plugin_io_t) &default_io;
 }
 
 /** init plugin struct.
  *
- * This function initializes the users handler struct to default values 
+ * This function initializes the users handler struct to default values
  * being the posix io functions in default configured environments.
  *
- * Note that the target io_handlers_t structure should be static or 
+ * Note that the target io_handlers_t structure should be static or
  * atleast it should be kept during the lifetime of zzip operations.
  */
 int
 zzip_init_io(zzip_plugin_io_handlers_t io, int flags)
 {
-    if (! io)
-    {
+    if (! io) {
         return ZZIP_ERROR;
     }
     memcpy(io, &default_io, sizeof(default_io));
     io->fd.sys = flags;
     return 0;
 }
-
-/* 
- * Local variables:
- * c-file-style: "stroustrup"
- * End:
- */

_service:tar_scm:v0.13.72.tar.gz/zzip/plugin.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/plugin.h Changed

@@ -1,5 +1,5 @@
 /*
- * Author: 
+ * Author:
  *     Guido Draheim <guidod@gmx.de>
  *
  * Copyright (c) Guido Draheim, use under copyleft
@@ -37,20 +37,21 @@
 #define ZZIP_PLUGIN_IO_SYS 1
 
 struct zzip_plugin_io { /* use "zzip_plugin_io_handlers" in applications !! */
-    int          (*open)(zzip_char_t* name, int flags, ...);
-    int          (*close)(int fd);
+    int (*open)(zzip_char_t* name, int flags, ...);
+    int (*close)(int fd);
     zzip_ssize_t (*read)(int fd, void* buf, zzip_size_t len);
-    zzip_off_t   (*seeks)(int fd, zzip_off_t offset, int whence);
-    zzip_off_t   (*filesize)(int fd);
-    long         sys;
-    long         type;
+    zzip_off_t (*seeks)(int fd, zzip_off_t offset, int whence);
+    zzip_off_t (*filesize)(int fd);
+    long sys;
+    long type;
     zzip_ssize_t (*write)(int fd, _zzip_const void* buf, zzip_size_t len);
 };
 
-typedef union _zzip_plugin_io
-{
+typedef union _zzip_plugin_io {
     struct zzip_plugin_io fd;
-    struct { void* padding8; } ptr;
+    struct {
+        void* padding8;
+    } ptr;
 } zzip_plugin_io_handlers;
 
 #define _zzip_plugin_io_handlers zzip_plugin_io_handlers
@@ -62,9 +63,9 @@
 typedef zzip_plugin_io_handlers* zzip_plugin_io_handlers_t;
 
 #ifdef ZZIP_LARGEFILE_RENAME
-#define zzip_filesize        zzip_filesize64
-#define zzip_get_default_io  zzip_get_default_io64
-#define zzip_init_io         zzip_init_io64
+#define zzip_filesize       zzip_filesize64
+#define zzip_get_default_io zzip_get_default_io64
+#define zzip_init_io        zzip_init_io64
 #endif
 
 _zzip_export zzip_off_t
@@ -73,7 +74,8 @@
 /* get the default file I/O functions.
  *  This functions returns a pointer to an internal static structure.
  */
-_zzip_export zzip_plugin_io_t zzip_get_default_io(void);
+_zzip_export zzip_plugin_io_t
+zzip_get_default_io(void);
 
 /*
  * Initializes a zzip_plugin_io_t to the zziplib default io.
@@ -81,11 +83,11 @@
  * all zzip functions that can receive a zzip_plugin_io_t can
  * handle a zero pointer in that place and default to posix io.
  */
-_zzip_export
-int zzip_init_io(zzip_plugin_io_handlers_t io, int flags);
+_zzip_export int
+zzip_init_io(zzip_plugin_io_handlers_t io, int flags);
 
 /* zzip_init_io flags : */
-# define ZZIP_IO_USE_MMAP 1
+#define ZZIP_IO_USE_MMAP 1
 
 #ifdef __cplusplus
 }

_service:tar_scm:v0.13.72.tar.gz/zzip/stat.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/stat.c Changed

@@ -1,6 +1,6 @@
 
 /*
- * Author: 
+ * Author:
  *	Guido Draheim <guidod@gmx.de>
  *	Tomi Ollila <Tomi.Ollila@iki.fi>
  *
@@ -10,10 +10,10 @@
  *      although this file is defining a function called zzip_stat it
  *      will not need a real stat(2) exported by the Operating System.
  *      It will just try to fill the fields of the ZZIP_STAT structure
- *      of 
+ *      of
  */
 
-#include <zzip/lib.h>           /* exported... */
+#include <zzip/lib.h> /* exported... */
 #include <zzip/file.h>
 #include <string.h>
 #if defined(_AIX)
@@ -25,38 +25,35 @@
 #include <zzip/info.h>
 
 /**    get meta infornation on a zipped element.
- * This function obtains information about a filename in an opened zip-archive 
- * without opening that file first. Mostly used to obtain the uncompressed 
+ * This function obtains information about a filename in an opened zip-archive
+ * without opening that file first. Mostly used to obtain the uncompressed
  * size of a file inside a zip-archive. see => zzip_dir_open.
  */
 int
-zzip_dir_stat(ZZIP_DIR * dir, zzip_char_t * name, ZZIP_STAT * zs, int flags)
+zzip_dir_stat(ZZIP_DIR* dir, zzip_char_t* name, ZZIP_STAT* zs, int flags)
 {
-    struct zzip_dir_hdr *hdr = dir->hdr0;
-    int (*cmp) (zzip_char_t *, zzip_char_t *);
+    struct zzip_dir_hdr* hdr = dir->hdr0;
+    int (*cmp)(zzip_char_t*, zzip_char_t*);
 
-    if (flags & ZZIP_CASEINSENSITIVE) flags |= ZZIP_CASELESS;
+    if (flags & ZZIP_CASEINSENSITIVE)
+        flags |= ZZIP_CASELESS;
     cmp = (flags & ZZIP_CASELESS) ? strcasecmp : strcmp;
 
-    if (! hdr)
-    {
+    if (! hdr) {
         dir->errcode = ZZIP_ENOENT;
         return -1;
     }
 
-    if (flags & ZZIP_IGNOREPATH)
-    {
-        char *n = strrchr(name, '/');
+    if (flags & ZZIP_IGNOREPATH) {
+        char* n = strrchr(name, '/');
         if (n)
             name = n + 1;
     }
 
-    while (1)
-    {
-        register char *hdr_name = hdr->d_name;
-        if (flags & ZZIP_IGNOREPATH)
-        {
-            register char *n = strrchr(hdr_name, '/');
+    while (1) {
+        register char* hdr_name = hdr->d_name;
+        if (flags & ZZIP_IGNOREPATH) {
+            register char* n = strrchr(hdr_name, '/');
             if (n)
                 hdr_name = n + 1;
         }
@@ -64,53 +61,51 @@
         if (! cmp(hdr_name, name))
             break;
 
-        if (! hdr->d_reclen)
-        {
+        if (! hdr->d_reclen) {
             dir->errcode = ZZIP_ENOENT;
             return -1;
         }
 
-        hdr = (struct zzip_dir_hdr *) ((char *) hdr + hdr->d_reclen);
+        hdr = (struct zzip_dir_hdr*) ((char*) hdr + hdr->d_reclen);
     }
 
     zs->d_compr = hdr->d_compr;
     zs->d_csize = hdr->d_csize;
     zs->st_size = hdr->d_usize;
-    zs->d_name = hdr->d_name;
+    zs->d_name  = hdr->d_name;
 
     return 0;
 }
 
 /** => zzip_dir_stat
- * This function will obtain information about a opened file _within_ a 
- * zip-archive. The file is supposed to be open (otherwise -1 is returned). 
- * The st_size stat-member contains the uncompressed size. The optional 
- * d_name is never set here. 
+ * This function will obtain information about a opened file _within_ a
+ * zip-archive. The file is supposed to be open (otherwise -1 is returned).
+ * The st_size stat-member contains the uncompressed size. The optional
+ * d_name is never set here.
  */
 int
-zzip_file_stat(ZZIP_FILE * file, ZZIP_STAT * zs)
+zzip_file_stat(ZZIP_FILE* file, ZZIP_STAT* zs)
 {
     if (! file)
         return -1;
     zs->d_compr = file->method;
     zs->d_csize = file->csize;
     zs->st_size = file->usize;
-    zs->d_name = 0;
+    zs->d_name  = 0;
     return 0;
 }
 
 /** => zzip_dir_stat
  * This function will obtain information about a opened file which may be
- * either real/zipped. The file is supposed to be open (otherwise -1 is 
- * returned). The st_size stat-member contains the uncompressed size. 
+ * either real/zipped. The file is supposed to be open (otherwise -1 is
+ * returned). The st_size stat-member contains the uncompressed size.
  * The optional d_name is never set here. For a real file, we do set the
  * d_csize := st_size and d_compr := 0 for meaningful defaults.
  */
 int
-zzip_fstat(ZZIP_FILE * file, ZZIP_STAT * zs)
+zzip_fstat(ZZIP_FILE* file, ZZIP_STAT* zs)
 {
-    if (ZZIP_file_real(file))
-    {
+    if (ZZIP_file_real(file)) {
         struct stat st;
         if (fstat(file->fd, &st) < 0)
             return -1;
@@ -118,14 +113,8 @@
         zs->d_csize = st.st_size;
         zs->d_compr = 0;
         return 0;
-    } else
-    {
+    }
+    else {
         return zzip_file_stat(file, zs);
     }
 }
-
-/* 
- * Local variables:
- * c-file-style: "stroustrup"
- * End:
- */

_service:tar_scm:v0.13.72.tar.gz/zzip/stdint.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/stdint.h Changed

@@ -4,53 +4,60 @@
    unsigned C9X typedefs. The ISO C 9X: 7.18 Integer types file is stdint.h
  */
 
-#include <zzip/conf.h> 
+#include <zzip/conf.h>
 
 /* enforce use of ifdef'd C9X entries in system headers */
-#define __USE_ANSI 1
+#define __USE_ANSI   1
 #define __USE_ISOC9X 1
 
 #ifdef ZZIP_HAVE_STDINT_H
-    /* ISO C 9X: 7.18 Integer types <stdint.h> */
+/* ISO C 9X: 7.18 Integer types <stdint.h> */
 #include <stdint.h>
 #elif defined ZZIP_HAVE_SYS_INT_TYPES_H /*solaris*/
 #include <sys/int_types.h>
 #elif defined ZZIP_HAVE_INTTYPES_H /*freebsd*/
 #include <inttypes.h>
 #else
-    typedef unsigned char uint8_t;      typedef signed char int8_t;
-
-# if ZZIP_SIZEOF_INT && ZZIP_SIZEOF_INT == 2
-    typedef unsigned int uint16_t;      typedef signed int int16_t;
-# elif ZZIP_SIZEOF_SHORT && ZZIP_SIZEOF_SHORT == 2
-    typedef unsigned short uint16_t;    typedef signed short int16_t;
-# else
-#   error unable to typedef int16_t from either int or short
-    typedef unsigned short uint16_t;    typedef signed short int16_t;
-# endif
-
-# if defined ZZIP_SIZEOF_INT && ZZIP_SIZEOF_INT == 4
-    typedef unsigned int uint32_t;      typedef signed int int32_t;
-# elif defined ZZIP_SIZEOF_LONG && ZZIP_SIZEOF_LONG == 4
-    typedef unsigned long uint32_t;     typedef signed long int32_t;
-# else
-#   error unable to typedef int32_t from either int or long
-    typedef unsigned long uint32_t;     typedef signed long int32_t;
-# endif
+typedef unsigned char uint8_t;
+typedef signed char   int8_t;
+
+#if ZZIP_SIZEOF_INT && ZZIP_SIZEOF_INT == 2
+typedef unsigned int  uint16_t;
+typedef signed int    int16_t;
+#elif ZZIP_SIZEOF_SHORT && ZZIP_SIZEOF_SHORT == 2
+typedef unsigned short uint16_t;
+typedef signed short   int16_t;
+#else
+#error unable to typedef int16_t from either int or short
+typedef unsigned short uint16_t;
+typedef signed short   int16_t;
+#endif
+
+#if defined   ZZIP_SIZEOF_INT && ZZIP_SIZEOF_INT == 4
+typedef unsigned int  uint32_t;
+typedef signed int    int32_t;
+#elif defined ZZIP_SIZEOF_LONG && ZZIP_SIZEOF_LONG == 4
+typedef unsigned long  uint32_t;
+typedef signed long    int32_t;
+#else
+#error unable to typedef int32_t from either int or long
+typedef unsigned long  uint32_t;
+typedef signed long    int32_t;
+#endif
 
 /* either (long long) on Unix or (__int64) on Windows */
-typedef unsigned _zzip___int64 uint64_t; typedef _zzip___int64 int64_t;
-
-# if defined ZZIP_SIZEOF_INT_P 
-#  if ZZIP_SIZEOF_INT_P == ZZIP_SIZEOF_LONG+0
-    typedef long intptr_t;
-#  elif ZZIP_SIZEOF_INT_P == ZZIP_SIZEOF_INT+0
-    typedef int intptr_t;
-#  else
-    typedef int64_t intptr_t;
-#  endif
-# endif
+typedef unsigned _zzip___int64 uint64_t;
+typedef _zzip___int64          int64_t;
+
+#if defined ZZIP_SIZEOF_INT_P
+#if ZZIP_SIZEOF_INT_P == ZZIP_SIZEOF_LONG + 0
+typedef long                   intptr_t;
+#elif ZZIP_SIZEOF_INT_P == ZZIP_SIZEOF_INT + 0
+typedef int intptr_t;
+#else
+typedef int64_t intptr_t;
+#endif
+#endif
 
 #endif /* ZZIP_HAVE_... */
 #endif /*_ZZIP_STDINT_H*/
-

_service:tar_scm:v0.13.72.tar.gz/zzip/types.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/types.h Changed

@@ -2,7 +2,7 @@
  * unlike in <zzip/conf.h> we are allowed to make up typedefs here,
  * while over there only #defines are allowed
  *
- * Author: 
+ * Author:
  *	Guido Draheim <guidod@gmx.de>
  *
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
@@ -32,21 +32,18 @@
 
 typedef unsigned char zzip_byte_t; // especially zlib decoding data
 
-typedef       _zzip_off64_t     zzip_off64_t;
-typedef       _zzip_off_t       zzip_off_t;
-typedef       _zzip_size_t      zzip_size_t;      /* Some error here? */
-typedef       _zzip_ssize_t     zzip_ssize_t;     /* See notes above! */
+typedef _zzip_off64_t zzip_off64_t;
+typedef _zzip_off_t   zzip_off_t;
+typedef _zzip_size_t  zzip_size_t;  /* Some error here? */
+typedef _zzip_ssize_t zzip_ssize_t; /* See notes above! */
 
 /* in <zzip/format.h> */
 typedef struct zzip_disk64_trailer ZZIP_DISK64_TRAILER;
-typedef struct zzip_disk_trailer ZZIP_DISK_TRAILER;
-typedef struct zzip_file_trailer ZZIP_FILE_TRAILER;
-typedef struct zzip_root_dirent  ZZIP_ROOT_DIRENT;
-typedef struct zzip_file_header ZZIP_FILE_HEADER;
-typedef struct zzip_disk_entry  ZZIP_DISK_ENTRY;
-typedef struct zzip_extra_block ZZIP_EXTRA_BLOCK;
-
-
+typedef struct zzip_disk_trailer   ZZIP_DISK_TRAILER;
+typedef struct zzip_file_trailer   ZZIP_FILE_TRAILER;
+typedef struct zzip_root_dirent    ZZIP_ROOT_DIRENT;
+typedef struct zzip_file_header    ZZIP_FILE_HEADER;
+typedef struct zzip_disk_entry     ZZIP_DISK_ENTRY;
+typedef struct zzip_extra_block    ZZIP_EXTRA_BLOCK;
 
 #endif
-

_service:tar_scm:v0.13.72.tar.gz/zzip/write.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/write.c Changed

@@ -2,7 +2,7 @@
  * The write-support in zziplib is not a full-flegded interface to the
  * internals that zip file-header or zip archive an contain. It's
  * primary use goes for savegames or transfer `pack-n-go` archives
- * where time-stamps are rather unimportant. Here we can create an 
+ * where time-stamps are rather unimportant. Here we can create an
  * archive with filenames and their data portions, possibly obfuscated.
  *
  * DON'T USE THIS
@@ -13,7 +13,7 @@
  * filesystem) in case they are being called. That allows later programs
  * to start up with earlier versions of zziplib that can only read ZIPs.
  *
- * Author: 
+ * Author:
  *      Guido Draheim <guidod@gmx.de>
  *
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
@@ -27,14 +27,14 @@
 #define _ZZIP_POSIX_WRITE
 #endif
 
-#include <zzip/write.h>         /* #includes <zzip/lib.h> */
+#include <zzip/write.h> /* #includes <zzip/lib.h> */
 #include <zzip/file.h>
 
-#include <string.h>
-#include <sys/stat.h>
+#include <ctype.h>
 #include <errno.h>
 #include <stdlib.h>
-#include <ctype.h>
+#include <string.h>
+#include <sys/stat.h>
 
 #ifdef ZZIP_HAVE_DIRECT_H
 #include <direct.h>
@@ -42,16 +42,16 @@
 
 #include <zzip/format.h>
 #include <zzip/plugin.h>
-#include <zzip/__mkdir.h>
 #include <zzip/__debug.h>
+#include <zzip/__mkdir.h>
 
-#define ___ {
+#define ___  {
 #define ____ }
 
 #ifndef EROFS
-# ifdef ENOSYS
+#ifdef ENOSYS
 #define EROFS ENOSYS
-# else
+#else
 #define EROFS EPERM
 #endif
 #endif
@@ -64,30 +64,30 @@
 #endif
 
 /* btw, is there any system that did define those different ? get away.. */
-#  ifndef S_IWGRP
-#  define S_IWGRP 00020
-#  endif
-#  ifndef S_IRWXO
-#  define S_IRWXO 00007
-#  endif
+#ifndef S_IWGRP
+#define S_IWGRP 00020
+#endif
+#ifndef S_IRWXO
+#define S_IRWXO 00007
+#endif
 
 /** create a new zip archive for writing
  *
- * This function will create a new zip archive. The returned parameter 
+ * This function will create a new zip archive. The returned parameter
  * is a new "zzip dir" handle that should be saved to a variable so it
  * can be used a base argument for => zzip_mkdir and => zzip_creat calls.
  * The returned handle represents a zip central directory that must be
  * saved to disk using => zzip_closedir.
  *
  * Returns null on error and sets errno. Remember, according to posix
- * the => creat(2) call is equivalent to 
+ * the => creat(2) call is equivalent to
    open (path, O_WRONLY | O_CREAT | O_TRUNC, o_mode)
  * so any previous zip-archive will be overwritten unconditionally and
  * EEXIST errors from => mkdir(2) are suppressed. (fixme: delete the
  * given subtree? like suggested by O_TRUNC? not done so far!)
  */
-ZZIP_DIR *
-zzip_dir_creat(zzip_char_t * name, int o_mode)
+ZZIP_DIR*
+zzip_dir_creat(zzip_char_t* name, int o_mode)
 {
     return zzip_dir_creat_ext_io(name, o_mode, 0, 0);
 }
@@ -95,10 +95,10 @@
 /** => zzip_dir_creat
  *
  * If the third argument "ext" has another special meaning here, as it
- * is used to ensure that a given zip-file is created with the first entry 
- * of the ext-list appended as an extension unless the file-path already 
- * ends with a file-extension registered in the list. Therefore {"",0} 
- * matches all files and creates them as zip-archives under the given 
+ * is used to ensure that a given zip-file is created with the first entry
+ * of the ext-list appended as an extension unless the file-path already
+ * ends with a file-extension registered in the list. Therefore {"",0}
+ * matches all files and creates them as zip-archives under the given
  * nonmodified name. (Some magic here? If the path ends in the path
  * separator then make a real directory even in the presence of ext-list?)
  *
@@ -106,15 +106,13 @@
  * Write-support will extend => zzip_closedir with semantics to finalize the
  * zip-archive by writing the zip-trailer and closing the archive file.
  */
-ZZIP_DIR *
-zzip_dir_creat_ext_io(zzip_char_t * name, int o_mode,
-                      zzip_strings_t * ext, zzip_plugin_io_t io)
+ZZIP_DIR*
+zzip_dir_creat_ext_io(zzip_char_t* name, int o_mode, zzip_strings_t* ext, zzip_plugin_io_t io)
 {
     if (! io)
         io = zzip_get_default_io();
 
-    if (io != zzip_get_default_io())
-    {
+    if (io != zzip_get_default_io()) {
         /* the current io-structure does not contain a "write" entry,
          * and therefore this parameter is useless. Anyone to expect
          * some behavior should be warned, so here we let the function
@@ -124,52 +122,51 @@
         return 0;
     }
 
-
-    if (! _ZZIP_TRY)
-    {
-        /* not implemented - however, we respect that a null argument to 
-         * zzip_mkdir and zzip_creat works, so we silently still do the mkdir 
+    if (! _ZZIP_TRY) {
+        /* not implemented - however, we respect that a null argument to
+         * zzip_mkdir and zzip_creat works, so we silently still do the mkdir
          */
         if (! _zzip_mkdir(name, o_mode) || errno == EEXIST)
             errno = EROFS;
         return 0;
-    } else
-    {
-#       define MAX_EXT_LEN 10
-        ZZIP_DIR *dir = zzip_dir_alloc(ext);
-        int name_len = strlen(name);
-        dir->realname = malloc(name_len + MAX_EXT_LEN);
+    }
+    else {
+#define MAX_EXT_LEN 10
+        ZZIP_DIR* dir      = zzip_dir_alloc(ext);
+        int       name_len = strlen(name);
+        dir->realname      = malloc(name_len + MAX_EXT_LEN);
         if (! dir->realname)
             goto error;
 
         memcpy(dir->realname, name, name_len + 1);
-        ___ int fd =
-            __zzip_try_open(dir->realname, O_EXCL | O_TRUNC | O_WRONLY, ext,
-                            io);
-        if (fd != -1)
-            { dir->fd = fd; return dir; }
-
-        ___ zzip_strings_t *exx = ext;
-        int exx_len;
-        for (; *exx; exx++)
-        {
+        ___ int fd = __zzip_try_open(dir->realname, O_EXCL | O_TRUNC | O_WRONLY, ext, io);
+        if (fd != -1) {
+            dir->fd = fd;
+            return dir;
+        }
+
+        ___ zzip_strings_t* exx = ext;
+        int                 exx_len;
+        for (; *exx; exx++) {
             if ((exx_len = strlen(*exx) + 1) <= name_len &&
                 ! memcmp(dir->realname + (name_len - exx_len), *exx, exx_len))
-                break;          /* keep unmodified */
+                break; /* keep unmodified */
             exx++;
             if (*exx)
                 continue;
 
             if (! (exx_len = strlen(*exx)) || exx_len >= MAX_EXT_LEN)
                 break;
-            memcpy(dir->realname + name_len, exx, exx_len);     /* append! */
+            memcpy(dir->realname + name_len, exx, exx_len); /* append! */
         }
         ____;
         fd = (io->fd.open)(dir->realname, O_CREAT | O_TRUNC | O_WRONLY, o_mode);
         dir->realnamename_len = '\0'; /* keep ummodified */

_service:tar_scm:v0.13.72.tar.gz/zzip/write.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/write.h Changed

@@ -10,50 +10,85 @@
 
 #define ZZIP_NO_CREAT 1
 
-ZZIP_DIR*    zzip_dir_creat_ext_io(zzip_char_t* name, int o_mode, 
-                                   zzip_strings_t* ext, zzip_plugin_io_t io);
-ZZIP_DIR*    zzip_dir_creat(zzip_char_t* name, int o_mode);
-int          zzip_file_mkdir(ZZIP_DIR* dir, zzip_char_t* name, int o_mode);
-ZZIP_FILE*   zzip_file_creat(ZZIP_DIR* dir, zzip_char_t* name, int o_mode);
-zzip_ssize_t zzip_file_write(ZZIP_FILE* file, 
-                             const void* ptr, zzip_size_t len);
-
-ZZIP_DIR*    zzip_createdir(zzip_char_t* name, int o_mode);
-zzip_ssize_t zzip_write(ZZIP_FILE* file, const void* ptr, zzip_size_t len);
-zzip_size_t  zzip_fwrite(const void* ptr, zzip_size_t len, 
-                         zzip_size_t multiply, ZZIP_FILE* file);
+ZZIP_DIR*
+zzip_dir_creat_ext_io(zzip_char_t* name, int o_mode, zzip_strings_t* ext, zzip_plugin_io_t io);
+ZZIP_DIR*
+zzip_dir_creat(zzip_char_t* name, int o_mode);
+int
+zzip_file_mkdir(ZZIP_DIR* dir, zzip_char_t* name, int o_mode);
+ZZIP_FILE*
+zzip_file_creat(ZZIP_DIR* dir, zzip_char_t* name, int o_mode);
+zzip_ssize_t
+zzip_file_write(ZZIP_FILE* file, const void* ptr, zzip_size_t len);
+
+ZZIP_DIR*
+zzip_createdir(zzip_char_t* name, int o_mode);
+zzip_ssize_t
+zzip_write(ZZIP_FILE* file, const void* ptr, zzip_size_t len);
+zzip_size_t
+zzip_fwrite(const void* ptr, zzip_size_t len, zzip_size_t multiply, ZZIP_FILE* file);
 #ifndef zzip_savefile
 #define zzip_savefile 0
 #define zzip_savefile_is_null
 #endif
 
 #ifdef _ZZIP_NO_INLINE
-#define zzip_mkdir(_name_,_mode_) \
-        zzip_file_mkdir((zzip_savefile),(_name_),(_mode_))
-#define zzip_creat(_name_,_mode_) \
-        zzip_file_creat((zzip_savefile),(_name_),(_mode_))
-#define zzip_sync() \
-      { zzip_closedir((zzip_savefile)); (zzip_savefile) = 0; }
-#define zzip_start(_name_,_mode_,_ext_) \
-      { if ((zzip_savefile)) zzip_closedir((zzip_savefile)); 
-         zzip_savefile = zzip_dir_creat(_name_, _mode_,_ext_); }
+#define zzip_mkdir(_name_, _mode_)                                                                 \
+    {                                                                                              \
+        zzip_file_mkdir((zzip_savefile), (_name_), (_mode_));                                      \
+    }
+#define zzip_creat(_name_, _mode_)                                                                 \
+    {                                                                                              \
+        zzip_file_creat((zzip_savefile), (_name_), (_mode_));                                      \
+    }
+#define zzip_sync()                                                                                \
+    {                                                                                              \
+        zzip_closedir((zzip_savefile));                                                            \
+        (zzip_savefile) = 0;                                                                       \
+    }
+#define zzip_start(_name_, _mode_, _ext_)                                                          \
+    {                                                                                              \
+        if ((zzip_savefile))                                                                       \
+            zzip_closedir((zzip_savefile));
+zzip_savefile = zzip_dir_creat(_name_, _mode_, _ext_);
+}
 
 #else
 
-_zzip_inline static int         zzip_mkdir(zzip_char_t* name, int o_mode)
-{                   return zzip_file_mkdir(zzip_savefile, name, o_mode); }
-_zzip_inline static ZZIP_FILE*  zzip_creat(zzip_char_t* name, int o_mode)
-{                   return zzip_file_creat(zzip_savefile, name, o_mode); }
+_zzip_inline static int
+zzip_mkdir(zzip_char_t* name, int o_mode)
+{
+    return zzip_file_mkdir(zzip_savefile, name, o_mode);
+}
+_zzip_inline static ZZIP_FILE*
+zzip_creat(zzip_char_t* name, int o_mode)
+{
+    return zzip_file_creat(zzip_savefile, name, o_mode);
+}
 
 #ifndef zzip_savefile_is_null
-_zzip_inline static void        zzip_sync(void)
-{                           zzip_closedir(zzip_savefile); zzip_savefile = 0; }
-_zzip_inline static void        zzip_mkfifo(zzip_char_t* name, int o_mode)
-{       if ((zzip_savefile)) zzip_closedir (zzip_savefile);
-             zzip_savefile = zzip_createdir(_name_,_mode_); }
+_zzip_inline static void
+zzip_sync(void)
+{
+    zzip_closedir(zzip_savefile);
+    zzip_savefile = 0;
+}
+_zzip_inline static void
+zzip_mkfifo(zzip_char_t* name, int o_mode)
+{
+    if ((zzip_savefile))
+        zzip_closedir(zzip_savefile);
+    zzip_savefile = zzip_createdir(_name_, _mode_);
+}
 #else
-_zzip_inline static void        zzip_sync(void) {}
-_zzip_inline static void        zzip_mkfifo(zzip_char_t* name, int o_mode) {}
+_zzip_inline static void
+zzip_sync(void)
+{
+}
+_zzip_inline static void
+zzip_mkfifo(zzip_char_t* name, int o_mode)
+{
+}
 #endif
 #endif /* _ZZIP_NO_INLINE */
 #endif /* _ZZIP_WRITE_H */

_service:tar_scm:v0.13.72.tar.gz/zzip/zip.c -> _service:tar_scm:v0.13.74.tar.gz/zzip/zip.c Changed

@@ -6,24 +6,24 @@
  * Copyright (c) Guido Draheim, use under copyleft (LGPL,MPL)
  */
 
-#include <zzip/lib.h>           /* archive handling */
+#include <zzip/lib.h> /* archive handling */
 #include <zzip/file.h>
 #include <zzip/format.h>
 #include <zzip/fetch.h>
 
 #include <ctype.h>
 #include <errno.h>
+#include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
-#include <fcntl.h>
 #ifdef ZZIP_HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 
-#include <zzip/__mmap.h>
 #include <zzip/__debug.h>
+#include <zzip/__mmap.h>
 
-#define __sizeof(X) ((zzip_ssize_t)(sizeof(X)))
+#define __sizeof(X) ((zzip_ssize_t) (sizeof(X)))
 
 #ifndef ZZIP_EASY
 /* per default, we use a little hack to correct bad z_rootseek parts */
@@ -31,9 +31,9 @@
 #endif
 
 #if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || (__GNUC__ >= 4)
-# ifdef DEBUG
-# warning suppress a warning where the compiler should have optimized instead.
-# endif
+#ifdef DEBUG
+#warning suppress a warning where the compiler should have optimized instead.
+#endif
 #define _255 254
 #else
 #define _255 255
@@ -42,31 +42,30 @@
 #define ZZIP_DISK64_TRAILER 1
 
 #ifdef ZZIP_DISK64_TRAILER
-struct _disk_trailer
-{
-    void *zz_tail;
-    void *zz_for_correct_rootseek;      // ZZIP_CORRECT_ROOTSEEK
+struct _disk_trailer {
+    void*        zz_tail;
+    void*        zz_for_correct_rootseek; // ZZIP_CORRECT_ROOTSEEK
     zzip_off64_t zz_entries;
     zzip_off64_t zz_finalentries;
     zzip_off64_t zz_rootseek;
     zzip_off64_t zz_rootsize;
 };
-#define _disk_trailer_entries(__p) ((__p)->zz_entries)
-#define _disk_trailer_localentries(__p) ((__p)->zz_entries)
-#define _disk_trailer_finalentries(__p) ((__p)->zz_entries)
-#define _disk_trailer_rootseek(__p) ((__p)->zz_rootseek)
-#define _disk_trailer_rootsize(__p) ((__p)->zz_rootsize)
-#define _disk_trailer_set_rootseek(__p,__v) ((__p)->rootseek = (__v))
+#define _disk_trailer_entries(__p)           ((__p)->zz_entries)
+#define _disk_trailer_localentries(__p)      ((__p)->zz_entries)
+#define _disk_trailer_finalentries(__p)      ((__p)->zz_entries)
+#define _disk_trailer_rootseek(__p)          ((__p)->zz_rootseek)
+#define _disk_trailer_rootsize(__p)          ((__p)->zz_rootsize)
+#define _disk_trailer_set_rootseek(__p, __v) ((__p)->rootseek = (__v))
 
 #else
-#define _disk_trailer zzip_disk_trailer
-#define _disk_trailer_entries zzip_disk_trailer_entries
+#define _disk_trailer              zzip_disk_trailer
+#define _disk_trailer_entries      zzip_disk_trailer_entries
 #define _disk_trailer_localentries zzip_disk_trailer_localentries
 #define _disk_trailer_finalentries zzip_disk_trailer_finalentries
-#define _disk_trailer_rootseek zzip_disk_trailer_rootseek
-#define _disk_trailer_rootsize zzip_disk_trailer_rootsize
+#define _disk_trailer_rootseek     zzip_disk_trailer_rootseek
+#define _disk_trailer_rootsize     zzip_disk_trailer_rootsize
 #define _disk_trailer_set_rootseek zzip_disk_trailer_set_rootseek
-#define __zzip_fetch_disk_trailer __zzip_find_disk_trailer
+#define __zzip_fetch_disk_trailer  __zzip_find_disk_trailer
 #endif
 
 /* ---------------------------  internals  -------------------------------- */
@@ -76,16 +75,15 @@
  * which know what they do and which can adapt from version to version
  */
 
-static int __zzip_fetch_disk_trailer(int fd, zzip_off_t filesize,
-                              struct _disk_trailer *_zzip_restrict trailer,
-                              zzip_plugin_io_t io);
-static int __zzip_parse_root_directory(int fd,
-                                struct _disk_trailer *trailer,
-                                struct zzip_dir_hdr **hdr_return,
-                                zzip_plugin_io_t io,
-				zzip_off_t filesize);
+static int
+__zzip_fetch_disk_trailer(int fd, zzip_off_t filesize, struct _disk_trailer* _zzip_restrict trailer,
+                          zzip_plugin_io_t io);
+static int
+__zzip_parse_root_directory(int fd, struct _disk_trailer* trailer, struct zzip_dir_hdr** hdr_return,
+                            zzip_plugin_io_t io, zzip_off_t filesize);
 
-_zzip_inline static char *__zzip_aligned4(char *p);
+_zzip_inline static char*
+__zzip_aligned4(char* p);
 
 /* ------------------------  harden routines ------------------------------ */
 
@@ -97,12 +95,11 @@
  * and it is just before the zip trailer. Therefore, ...
  */
 _zzip_inline static void
-__fixup_rootseek(zzip_off_t offset_of_trailer, struct _disk_trailer *trailer)
+__fixup_rootseek(zzip_off_t offset_of_trailer, struct _disk_trailer* trailer)
 {
-    if (_disk_trailer_rootseek(trailer) >
-        offset_of_trailer - _disk_trailer_rootsize(trailer) &&
-        offset_of_trailer > _disk_trailer_rootsize(trailer))
-    {
+    if (_disk_trailer_rootseek(trailer) > /* .. */
+            offset_of_trailer - _disk_trailer_rootsize(trailer) &&
+        offset_of_trailer > _disk_trailer_rootsize(trailer)) {
         register zzip_off_t offset;
         offset = offset_of_trailer - _disk_trailer_rootsize(trailer);
         _disk_trailer_set_rootseek(trailer, offset);
@@ -110,7 +107,7 @@
     }
 }
 
-#define __correct_rootseek(A,B,C)
+#define __correct_rootseek(A, B, C)
 
 #elif defined ZZIP_CORRECT_ROOTSEEK
 
@@ -118,30 +115,28 @@
  * a 64bit off_t we overwrite z_disk/z_finaldisk as well. If you change
  * anything in zziplib or dump the trailer structure then watch out that
  * these are still unused, so that this code may still (ab)use those. */
-#define __fixup_rootseek(_offset_of_trailer, _trailer)          \
-                      *(zzip_off_t*)_trailer = _offset_of_trailer;
-#define __correct_rootseek( _u_rootseek, _u_rootsize, _trailer) \
-    if (_u_rootseek > *(zzip_off_t*)_trailer - _u_rootsize)     \
-	_u_rootseek = *(zzip_off_t*)_trailer - _u_rootsize;
+#define __fixup_rootseek(_offset_of_trailer, _trailer) *(zzip_off_t*) _trailer = _offset_of_trailer;
+#define __correct_rootseek(_u_rootseek, _u_rootsize, _trailer)                                     \
+    if (_u_rootseek > *(zzip_off_t*) _trailer - _u_rootsize)                                       \
+        _u_rootseek = *(zzip_off_t*) _trailer - _u_rootsize;
 #else
-#define __fixup_rootseek(A,B)
-#define __correct_rootseek(A,B,C)
+#define __fixup_rootseek(A, B)
+#define __correct_rootseek(A, B, C)
 #endif
 
-
 #ifdef DEBUG
 _zzip_inline static void
-__debug_dir_hdr(struct zzip_dir_hdr *hdr)
+__debug_dir_hdr(struct zzip_dir_hdr* hdr)
 {
-    if (sizeof(struct zzip_dir_hdr) > sizeof(struct zzip_disk_entry))
-        { WARN1("internal sizeof-mismatch may break wreakage"); }
+    if (sizeof(struct zzip_dir_hdr) > sizeof(struct zzip_disk_entry)) {
+        WARN1("internal sizeof-mismatch may break wreakage");
+    }
     /*  the internal directory structure is never bigger than the
      *  external zip central directory space had been beforehand
      *  (as long as the following assertion holds...)
      */
 
-    if (((zzip_off_t) hdr) & 3)
-    {
+    if (((zzip_off_t) hdr) & 3) {
         NOTE1("this machine's malloc(3) returns sth. not u32-aligned");
     }
     /* we assume that if this machine's malloc has returned a non-aligned
@@ -174,68 +169,72 @@
  * bytes off the end of the file.
  */
 static int
-__zzip_fetch_disk_trailer(int fd, zzip_off_t filesize,
-                          struct _disk_trailer *_zzip_restrict trailer,
+__zzip_fetch_disk_trailer(int fd, zzip_off_t filesize, struct _disk_trailer* _zzip_restrict trailer,
                           zzip_plugin_io_t io)
 {
+/* clang-format off */
 #ifdef DEBUG
 #define return(val) { e=val; HINT2("%s", zzip_strerror(e)); goto cleanup; }
 #else
 #define return(val) { e=val; goto cleanup; }
 #endif
+    /* clang-format on */
+
     register int e;

_service:tar_scm:v0.13.72.tar.gz/zzip/zzip.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/zzip.h Changed

@@ -1,5 +1,5 @@
 /*
- * Author: 
+ * Author:
  *	Guido Draheim <guidod@gmx.de>
  *	Tomi Ollila <Tomi.Ollila@iki.fi>
  *
@@ -23,39 +23,38 @@
 /* the zzip_error_t is also used to pass back ZLIB errors... */
 #define ZZIP_ERROR -4096
 
-typedef enum 
-{
-    ZZIP_NO_ERROR = 0,	/* no error, may be used if user sets it. */
-    ZZIP_OUTOFMEM =      ZZIP_ERROR-20, /* out of memory */
-    ZZIP_DIR_OPEN =      ZZIP_ERROR-21, /* failed to open zipfile, see errno for details */
-    ZZIP_DIR_STAT =      ZZIP_ERROR-22, /* failed to fstat zipfile, see errno for details */
-    ZZIP_DIR_SEEK =      ZZIP_ERROR-23, /* failed to lseek zipfile, see errno for details */
-    ZZIP_DIR_READ =      ZZIP_ERROR-24, /* failed to read zipfile, see errno for details */
-    ZZIP_DIR_TOO_SHORT = ZZIP_ERROR-25,
-    ZZIP_DIR_EDH_MISSING = ZZIP_ERROR-26,
-    ZZIP_DIRSIZE =       ZZIP_ERROR-27,
-    ZZIP_ENOENT =        ZZIP_ERROR-28,
-    ZZIP_UNSUPP_COMPR =  ZZIP_ERROR-29,
-    ZZIP_CORRUPTED =     ZZIP_ERROR-31,
-    ZZIP_UNDEF =         ZZIP_ERROR-32,
-    ZZIP_DIR_LARGEFILE = ZZIP_ERROR-33
+typedef enum {
+    ZZIP_NO_ERROR        = 0,               /* no error, may be used if user sets it. */
+    ZZIP_OUTOFMEM        = ZZIP_ERROR - 20, /* out of memory */
+    ZZIP_DIR_OPEN        = ZZIP_ERROR - 21, /* failed to open zipfile, see errno for details */
+    ZZIP_DIR_STAT        = ZZIP_ERROR - 22, /* failed to fstat zipfile, see errno for details */
+    ZZIP_DIR_SEEK        = ZZIP_ERROR - 23, /* failed to lseek zipfile, see errno for details */
+    ZZIP_DIR_READ        = ZZIP_ERROR - 24, /* failed to read zipfile, see errno for details */
+    ZZIP_DIR_TOO_SHORT   = ZZIP_ERROR - 25,
+    ZZIP_DIR_EDH_MISSING = ZZIP_ERROR - 26,
+    ZZIP_DIRSIZE         = ZZIP_ERROR - 27,
+    ZZIP_ENOENT          = ZZIP_ERROR - 28,
+    ZZIP_UNSUPP_COMPR    = ZZIP_ERROR - 29,
+    ZZIP_CORRUPTED       = ZZIP_ERROR - 31,
+    ZZIP_UNDEF           = ZZIP_ERROR - 32,
+    ZZIP_DIR_LARGEFILE   = ZZIP_ERROR - 33
 } zzip_error_t;
 
 /*
  * zzip_open flags.
  */
-#define ZZIP_CASEINSENSITIVE	O_APPEND /* do not use anymore. use CASLESS */
-#define ZZIP_IGNOREPATH	        O_TRUNC  /* do not use anymore. use NOPATHS */
-#define ZZIP_EXTRAFLAGS         (ZZIP_CASEINSENSITIVE|ZZIP_IGNOREPATH)
+#define ZZIP_CASEINSENSITIVE O_APPEND /* do not use anymore. use CASLESS */
+#define ZZIP_IGNOREPATH      O_TRUNC  /* do not use anymore. use NOPATHS */
+#define ZZIP_EXTRAFLAGS      (ZZIP_CASEINSENSITIVE | ZZIP_IGNOREPATH)
 
 /* zzip_open_ext_io o_modes flags : new style. use these from now on! */
-#define ZZIP_CASELESS           (1<<12) /* ignore filename case inside zips */
-#define ZZIP_NOPATHS            (1<<13) /* ignore subdir paths, just filename*/
-#define ZZIP_PREFERZIP          (1<<14) /* try first zipped file, then real*/
-#define ZZIP_ONLYZIP            (1<<16) /* try _only_ zipped file, skip real*/
-#define ZZIP_FACTORY            (1<<17) /* old file handle is not closed */
-#define ZZIP_ALLOWREAL          (1<<18) /* real files use default_io (magic) */
-#define ZZIP_THREADED           (1<<19) /* try to be safe for multithreading */
+#define ZZIP_CASELESS  (1 << 12) /* ignore filename case inside zips */
+#define ZZIP_NOPATHS   (1 << 13) /* ignore subdir paths, just filename*/
+#define ZZIP_PREFERZIP (1 << 14) /* try first zipped file, then real*/
+#define ZZIP_ONLYZIP   (1 << 16) /* try _only_ zipped file, skip real*/
+#define ZZIP_FACTORY   (1 << 17) /* old file handle is not closed */
+#define ZZIP_ALLOWREAL (1 << 18) /* real files use default_io (magic) */
+#define ZZIP_THREADED  (1 << 19) /* try to be safe for multithreading */
 
 /*
  * zzip largefile renames
@@ -69,160 +68,157 @@
  * zzip typedefs
  */
 /* zzip_strings_t ext = { ".zip", ".jar", ".pk3", 0 } */
-typedef  char _zzip_const * _zzip_const zzip_strings_t;
-typedef  char _zzip_const       zzip_char_t;
-typedef struct zzip_dir		ZZIP_DIR;
-typedef struct zzip_file	ZZIP_FILE;
-typedef struct zzip_dirent 	ZZIP_DIRENT;
-typedef struct zzip_dirent 	ZZIP_STAT;
-
-struct zzip_dirent
-{
-    int	 	d_compr;	/* compression method */
-    int         d_csize;        /* compressed size */
-    int	 	st_size;	/* file size / decompressed size */
-    char * 	d_name;		/* file name / strdupped name */
+typedef char _zzip_const* _zzip_const zzip_strings_t;
+typedef char _zzip_const              zzip_char_t;
+typedef struct zzip_dir               ZZIP_DIR;
+typedef struct zzip_file              ZZIP_FILE;
+typedef struct zzip_dirent            ZZIP_DIRENT;
+typedef struct zzip_dirent            ZZIP_STAT;
+
+struct zzip_dirent {
+    int   d_compr; /* compression method */
+    int   d_csize; /* compressed size */
+    int   st_size; /* file size / decompressed size */
+    char* d_name;  /* file name / strdupped name */
 };
 
 /*
- * Getting error strings 
+ * Getting error strings
  * zzip/err.c
+ * - zzip_strerror: error in _opendir
+ * - zzip_strerror_fo: error in other functions
+ * - zzip_errno: error mapped to errno.h defines
  */
-_zzip_export    /* error in _opendir : */
-zzip_char_t* 	zzip_strerror(int errcode); 
-_zzip_export    /* error in other functions : */
-zzip_char_t* 	zzip_strerror_of(ZZIP_DIR * dir); 
-_zzip_export    /* error mapped to errno.h defines : */
-int    	 	zzip_errno(int errcode); 
-
+_zzip_export zzip_char_t*
+zzip_strerror(int errcode);
+_zzip_export zzip_char_t*
+zzip_strerror_of(ZZIP_DIR* dir);
+_zzip_export int
+zzip_errno(int errcode);
 
 /*
- * Functions to grab information from ZZIP_DIR/ZZIP_FILE structure 
+ * Functions to grab information from ZZIP_DIR/ZZIP_FILE structure
  * (if ever needed)
  * zzip/info.c
  */
-_zzip_export
-int  	 	zzip_error(ZZIP_DIR * dir);
-_zzip_export
-void 	 	zzip_seterror(ZZIP_DIR * dir, int errcode);
-_zzip_export
-zzip_char_t* 	zzip_compr_str(int compr);
-
-_zzip_export
-ZZIP_DIR * 	zzip_dirhandle(ZZIP_FILE * fp);
-_zzip_export
-int           	zzip_dirfd(ZZIP_DIR * dir);
-_zzip_export
-int            	zzip_dir_real(ZZIP_DIR * dir);
-_zzip_export
-int      	zzip_file_real(ZZIP_FILE * fp);
-_zzip_export
-void*           zzip_realdir(ZZIP_DIR * dir);
-_zzip_export
-int             zzip_realfd(ZZIP_FILE * fp);
+_zzip_export int
+zzip_error(ZZIP_DIR* dir);
+_zzip_export void
+zzip_seterror(ZZIP_DIR* dir, int errcode);
+_zzip_export zzip_char_t*
+zzip_compr_str(int compr);
+
+_zzip_export ZZIP_DIR*
+zzip_dirhandle(ZZIP_FILE* fp);
+_zzip_export int
+zzip_dirfd(ZZIP_DIR* dir);
+_zzip_export int
+zzip_dir_real(ZZIP_DIR* dir);
+_zzip_export int
+zzip_file_real(ZZIP_FILE* fp);
+_zzip_export void*
+zzip_realdir(ZZIP_DIR* dir);
+_zzip_export int
+zzip_realfd(ZZIP_FILE* fp);
 
 /*
  * zip handle management
  * zzip/zip.c
  */
-_zzip_export
-ZZIP_DIR *      zzip_dir_alloc(zzip_strings_t* fileext);
-_zzip_export
-int             zzip_dir_free(ZZIP_DIR *);
+_zzip_export ZZIP_DIR*
+zzip_dir_alloc(zzip_strings_t* fileext);
+_zzip_export int
+zzip_dir_free(ZZIP_DIR*);
 
 /*
  * Opening/closing a zip archive
  * zzip-zip.c
  */
-_zzip_export
-ZZIP_DIR *  	zzip_dir_fdopen(int fd, zzip_error_t * errcode_p);
-_zzip_export
-ZZIP_DIR *  	zzip_dir_open(zzip_char_t* filename, zzip_error_t * errcode_p);
-_zzip_export
-int	  	zzip_dir_close(ZZIP_DIR * dir);
-_zzip_export
-int             zzip_dir_read(ZZIP_DIR * dir, ZZIP_DIRENT * dirent);
-
+_zzip_export ZZIP_DIR*
+zzip_dir_fdopen(int fd, zzip_error_t* errcode_p);
+_zzip_export ZZIP_DIR*
+zzip_dir_open(zzip_char_t* filename, zzip_error_t* errcode_p);

_service:tar_scm:v0.13.72.tar.gz/zzip/zzip32.h -> _service:tar_scm:v0.13.74.tar.gz/zzip/zzip32.h Changed

_service:tar_scm:v0.13.72.tar.gz/zzipwrap/CMakeLists.txt -> _service:tar_scm:v0.13.74.tar.gz/zzipwrap/CMakeLists.txt Changed

@@ -10,11 +10,10 @@
 
 # options ########################################################
 option(BUILD_SHARED_LIBS "Build a shared library" ON)
-option(BUILD_STATIC_LIBS "Build the static library" OFF)
 option(BUILD_TESTS "Build test programs" OFF)
 option(MSVC_STATIC_RUNTIME "Build with static runtime libs (/MT)" ON)
 
-if(UNIX)
+if(UNIX OR MINGW)
 option(ZZIP_LIBTOOL "Ensure binary compatibility with libtool" ON)
 option(ZZIP_PKGCONFIG "Generate pkg-config files for linking" ON)
 else()
@@ -22,6 +21,12 @@
 option(ZZIP_PKGCONFIG "Generate pkg-config files for linking" OFF)
 endif()
 
+if((CMAKE_BUILD_TYPE STREQUAL "Release") AND (ZZIP_LIBTOOL OR ZZIP_PKGCONFIG))
+option(ZZIP_LIBLATEST "Ensure libname.lib links to libname-REL.lib" ON)
+else()
+option(ZZIP_LIBLATEST "Ensure libname.lib links to libname-REL.lib" OFF)
+endif()
+
 check_include_files ( unistd.h ZZIP_HAVE_UNISTD_H )
 # set ( ZZIP_HAVE_ZLIB_H 1 )
 
@@ -83,25 +88,28 @@
 endif()
 
 install(FILES ${libzzipwrap_HDRS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/zzip )
-install(TARGETS libzzipwrap
+install(TARGETS libzzipwrap EXPORT zziplibTargets
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
-if(ZZIP_LIBTOOL)
-  if(CMAKE_SHARED_LIBRARY_SONAME_C_FLAG)
+if(ZZIP_LIBLATEST)
+  if(BUILD_SHARED_LIBS)
     set(lib ${CMAKE_SHARED_LIBRARY_PREFIX})
     set(dll ${CMAKE_SHARED_LIBRARY_SUFFIX})
+  else()
+    set(lib ${CMAKE_STATIC_LIBRARY_PREFIX})
+    set(dll ${CMAKE_STATIC_LIBRARY_SUFFIX})
+  endif()
     set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
     get_target_property(libname libzzipwrap OUTPUT_NAME)
     get_target_property(librelease libzzipwrap RELEASE_POSTFIX)
-    get_target_property(libversion libzzipwrap VERSION)
-    install(CODE "execute_process(COMMAND bash -c \"set -e
-        cd $DESTDIR/${libdir}
-         -f ${lib}${libname}${librelease}${dll}.${libversion}  || exit 0
-        echo -n .. Installing: `pwd`
-        ln -svf ${lib}${libname}${librelease}${dll}.${libversion} ${lib}${libname}${dll}
-        \")")
-  endif()
+    add_custom_target(libzzipwrap_latest ALL
+        COMMAND ${CMAKE_COMMAND} -E create_symlink $<TARGET_FILE_NAME:libzzipwrap> ${lib}${libname}${dll}
+        )
+    install(FILES
+        ${outdir}/${lib}${libname}${dll}
+        DESTINATION ${CMAKE_INSTALL_LIBDIR})
 endif()
 
 # messages #######################################################