Commits

camlspotter committed cb4e6bb

type-conv -> type_conv

Comments (0)

Files changed (44)

type-conv/OMakefile

-OMyOasisDir(type_conv, type_conv-3.0.5, $(EMPTY))
Add a comment to this file

type-conv/type_conv-3.0.5.tar.gz

Binary file removed.

type-conv/type_conv-3.0.5/.hg_archival.txt

-repo: 34f1a44fc0f63ea91a9b9c5fb5be4f01af781405
-node: c2b8787045374643f4f2348556ab17a60c71c294
-branch: default
-tag: forge-release-3.0.5

type-conv/type_conv-3.0.5/.hgignore

-(^|/)\.bzr($|/)
-(^|/)\.hg($|/)
-(^|/)\.hgtags($|/)

type-conv/type_conv-3.0.5/.hgtags

-44f5759efba0f35e9f1fb070649f353af8f0c9f1 release 1.6.4
-2ba6f2041cf4bec3db94d284e0ee45374a0b156f release 1.6.5
-0000000000000000000000000000000000000000 release 1.6.5
-0000000000000000000000000000000000000000 release 1.6.4
-44f5759efba0f35e9f1fb070649f353af8f0c9f1 release-1.6.4
-2ba6f2041cf4bec3db94d284e0ee45374a0b156f release-1.6.5
-cf8f6adacc3b543e319d60488890519b3d97f705 release-1.6.6
-17eba49094174706d7f2f24a4ba32b7fee5af76e release-1.6.7
-c8957621576fc529315d22ccc00a06b6ae7b1db8 release-1.6.8
-ddc8b943a81bd2a13c7402a953c098f534ac6179 release-1.6.9
-312bc5928e37142cb39c6cf240c6fb5ceee857af release-1.6.10
-31b3cbe5118d39587755acd0aceee7f79ccb932b release-1.7.0
-ffa800611e8fea848af0e00ec37f46a9660ee659 release-1.7.1
-d52dcd8902a7502d1ae53c19e4b4d7bc913bb0d2 release-2.0.0
-a5e283924c481ae9f206a4f49f81c0bfb124cc48 release-2.0.1
-9638a97829baa9635eecdb0f80b4ed0238c7da9a release-2.0.2
-5f78b02a0ff7d5f89fc4203d97330064eb5993c2 release-3.0.0
-5f78b02a0ff7d5f89fc4203d97330064eb5993c2 release-3.0.0
-0000000000000000000000000000000000000000 release-3.0.0
-0000000000000000000000000000000000000000 release-3.0.0
-68b11176fd0d7e882123bf65de852e03e746b472 release-3.0.0
-1d8294efc38cc41dca723cba21fc8ddf21e8468b release-3.0.1
-a57ad4918bccb0228758f4e623091f48965a43b4 forge-release-3.0.1
-b537823664574bfa89a6df297ea1ad18ea852b40 forge-release-3.0.2
-90784af296231cc53279b17c7c6197b26093bf30 forge-release-3.0.3
-287c573ff3363b3018750f5d7416bf396139f840 forge-release-3.0.4

type-conv/type_conv-3.0.5/COPYRIGHT

-Most of this library was written by:
-
-  Markus Mottl          <markus.mottl@gmail.com>
-
-This work is derived from the library "Tywith", version 0.45.  The library
-"Tywith" was written and is distributed by:
-
-  Martin Sandin         <msandin@hotmail.com>
-
-The original license of "Tywith" can be found in the file
-"LICENSE.Tywith".  Files that were derived from "Tywith" contain a
-reference to the original author.
-
-The following company has sponsored and has copyright in part of this work:
-
-  Jane Street Holding, LLC
-  1 New York Plaza, 33rd Floor 
-  New York, NY 10004
-  USA

type-conv/type_conv-3.0.5/Changelog

-2011-09-15:  Fixes to improve package dependency resolution.
-
-2011-08-02:  Added missing module type case for "module type of".
-
-2011-07-04:  Merged with Jane Street version.  API changes:
-
-             Removed functions:
-
-               * Gen.ide
-               * Gen.idp
-
-             Removed location arguments from:
-
-               * type_is_recursive
-               * drop_variance_annotations
-
-2010-12-22:  Merged with Jane Street version.  No code changes.
-
-2010-09-25:  Added a missing type case to type_is_recursive.
-             Thanks to Michael Wawrzoniak <mhw@cs.princeton.edu> for this
-             patch!
-
-2010-07-07:  Major changes for compatibility with OCaml 3.12.
-
-2010-06-03:  Improved determination of type-conv paths.
-             Thanks to Jacques Le Normand <rathereasy@gmail.com> for this
-             patch!
-
-2009-09-19:  Added missing type cases for supporting variant types.
-
-2009-01-14:  Added support for type converters that take arguments.
-             Thanks to Jérémie Dimino <jeremie@dimino.org> for this
-             patch!
-
-             Added support for deprecated OCaml syntax, since the compiler
-             still supports it, too.
-
-2008-10-22:  Fixed bug preprocessing labeled arguments in function types.
-
-2008-10-18:  Fix for upcoming OCaml release 3.11.
-
-2008-10-07:  Added a patch to improve handling of type conversion paths.
-
-             Thanks to David Rajchenbach-Teller
-             <David.Teller@ens-lyon.org> for the patch!
-
-2008-08-20:  Added support for exception converters.
-
-2008-07-25:  Fixed bug concerning variance annotations in type
-             definitions within structures.
-
-2008-03-17:  Improved META file and support of toplevel interpreter.
-
-2008-02-11:  Added support for handling variance annotations in
-             signatures, and for empty types.
-
-2007-10-14:  Initial release.

type-conv/type_conv-3.0.5/INSTALL

-(* OASIS_START *)
-(* DO NOT EDIT (digest: 26d81a1be27dd82d33a35af5a28ce21f) *)
-This is the INSTALL file for the type_conv distribution.
-
-This package uses OASIS to generate its build system. See section OASIS for
-full information. 
-
-Dependencies
-============
-
-In order to compile this package, you will need:
-* ocaml (>= 3.12)
-* findlib
-
-Installing
-==========
-
-1. Uncompress the source archive and go to the root of the package
-2. Run 'ocaml setup.ml -configure'
-3. Run 'ocaml setup.ml -build'
-4. Run 'ocaml setup.ml -install'
-
-Uninstalling
-============
-
-1. Go to the root of the package 
-2. Run 'ocaml setup.ml -uninstall'
-
-OASIS
-=====
-
-OASIS is a program that generates a setup.ml file using a simple '_oasis'
-configuration file. The generated setup only depends on the standard OCaml
-installation: no additional library is required.
-
-(* OASIS_STOP *)

type-conv/type_conv-3.0.5/LICENSE

-The Library is distributed under the terms of the GNU Lesser General
-Public License version 2.1 (included below).
-
-As a special exception to the GNU Lesser General Public License, you
-may link, statically or dynamically, a "work that uses the Library"
-with a publicly distributed version of the Library to produce an
-executable file containing portions of the Library, and distribute that
-executable file under terms of your choice, without any of the additional
-requirements listed in clause 6 of the GNU Lesser General Public License.
-By "a publicly distributed version of the Library", we mean either the
-unmodified Library as distributed by the authors, or a modified version
-of the Library that is distributed under the conditions defined in clause
-3 of the GNU Lesser General Public License.  This exception does not
-however invalidate any other reasons why the executable file might be
-covered by the GNU Lesser General Public License.
-
----------------------------------------------------------------------------
-
-		  GNU LESSER GENERAL PUBLIC LICENSE
-		       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-		  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!

type-conv/type_conv-3.0.5/LICENSE.Tywith

----------------------------------------------------------------------------
-Copyright (c) 2004 Martin Sandin
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-3. The name of the author may not be used to endorse or promote products
-   derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------

type-conv/type_conv-3.0.5/Makefile

-# OASIS_START
-# DO NOT EDIT (digest: bc1e05bfc8b39b664f29dae8dbd3ebbb)
-
-SETUP = ocaml setup.ml
-
-build: setup.data
-	$(SETUP) -build $(BUILDFLAGS)
-
-doc: setup.data build
-	$(SETUP) -doc $(DOCFLAGS)
-
-test: setup.data build
-	$(SETUP) -test $(TESTFLAGS)
-
-all: 
-	$(SETUP) -all $(ALLFLAGS)
-
-install: setup.data
-	$(SETUP) -install $(INSTALLFLAGS)
-
-uninstall: setup.data
-	$(SETUP) -uninstall $(UNINSTALLFLAGS)
-
-reinstall: setup.data
-	$(SETUP) -reinstall $(REINSTALLFLAGS)
-
-clean: 
-	$(SETUP) -clean $(CLEANFLAGS)
-
-distclean: 
-	$(SETUP) -distclean $(DISTCLEANFLAGS)
-
-setup.data:
-	$(SETUP) -configure $(CONFIGUREFLAGS)
-
-.PHONY: build doc test all install uninstall reinstall clean distclean configure
-
-# OASIS_STOP

type-conv/type_conv-3.0.5/README.txt

-The type-conv mini library factors out functionality needed by different
-preprocessors that generate code from type specifications, because this
-functionality cannot be duplicated without losing the ability to use
-these preprocessors simultaneously.

type-conv/type_conv-3.0.5/_oasis

-OASISFormat:  0.3
-OCamlVersion: >= 3.12
-Name:         type_conv
-Version:      3.0.5
-Synopsis:     support library for preprocessor type conversions
-Authors:      Martin Sandin,
-              Markus Mottl,
-              Jane Street Capital, LLC
-License:      LGPL-2.1 with OCaml linking exception
-LicenseFile:  LICENSE
-Plugins:      StdFiles (0.3), DevFiles (0.3), META (0.3)
-BuildTools:   ocamlbuild, camlp4o
-XStdFilesAUTHORS: false
-XStdFilesINSTALLFilename: INSTALL
-XStdFilesREADME: false
-
-Library pa_type_conv
-  Path:               lib
-  FindlibName:        type_conv
-  Modules:            Pa_type_conv
-  BuildDepends:       camlp4.quotations, camlp4.extend
-  CompiledObject:     byte
-  XMETAType:          syntax
-  XMETARequires:      camlp4
-  XMETADescription:   Syntax extension for type_conv

type-conv/type_conv-3.0.5/_tags

-# OASIS_START
-# DO NOT EDIT (digest: 2ec1ae99a7330b9ba63e802f2059e460)
-# Ignore VCS directories, you can use the same kind of rule outside 
-# OASIS_START/STOP if you want to exclude directories that contains 
-# useless stuff for the build process
-<**/.svn>: -traverse
-<**/.svn>: not_hygienic
-".bzr": -traverse
-".bzr": not_hygienic
-".hg": -traverse
-".hg": not_hygienic
-".git": -traverse
-".git": not_hygienic
-"_darcs": -traverse
-"_darcs": not_hygienic
-# Library pa_type_conv
-"lib": include
-<lib/*.ml{,i}>: pkg_camlp4.quotations
-<lib/*.ml{,i}>: pkg_camlp4.extend
-# OASIS_STOP
-# MM: required, since Oasis does not generate this yet
-<lib/pa_type_conv.ml>: syntax_camlp4o

type-conv/type_conv-3.0.5/configure

-#!/bin/sh
-
-# OASIS_START
-# DO NOT EDIT (digest: 425187ed8bfdbdd207fd76392dd243a7)
-set -e
-
-FST=true
-for i in "$@"; do 
-  if $FST; then
-    set --
-    FST=false
-  fi
-
-  case $i in
-    --*=*)
-      ARG=${i%%=*}
-      VAL=${i##*=}
-      set -- "$@" "$ARG" "$VAL"
-      ;;
-    *)
-      set -- "$@" "$i"
-      ;;
-  esac
-done
-
-ocaml setup.ml -configure "$@"
-# OASIS_STOP

type-conv/type_conv-3.0.5/lib/META

-# OASIS_START
-# DO NOT EDIT (digest: b1d083395b7a1a482b9b4d8759bc11a8)
-version = "3.0.5"
-description = "Syntax extension for type_conv"
-requires = "camlp4"
-archive(syntax, preprocessor) = "pa_type_conv.cma"
-archive(syntax, toploop) = "pa_type_conv.cma"
-exists_if = "pa_type_conv.cma"
-# OASIS_STOP
-

type-conv/type_conv-3.0.5/lib/Makefile

-RESULT = type-conv
-
-OCAMLMAKEFILE = ../OCamlMakefile
-OCAMLFLAGS = -w Ae
-
-INCDIRS = +camlp4
-
-TRASH = pa_type_conv.cmi pa_type_conv.cmo pa_type_conv.annot
-
-all: pa_type_conv.cmi pa_type_conv.cmo
-
-LIBINSTALL_FILES = pa_type_conv.cmi pa_type_conv.cmo
-
-install:	libinstall
-uninstall:	libuninstall
-
--include $(OCAMLMAKEFILE)

type-conv/type_conv-3.0.5/lib/pa_type_conv.ml

-(******************************************************************************
- *                             Type-conv                                      *
- *                                                                            *
- * Copyright (C) 2005- Jane Street Holding, LLC                               *
- *    Contact: opensource@janestreet.com                                      *
- *    WWW: http://www.janestreet.com/ocaml                                    *
- *    Author: Markus Mottl                                                    *
- *                                                                            *
- * This library is free software; you can redistribute it and/or              *
- * modify it under the terms of the GNU Lesser General Public                 *
- * License as published by the Free Software Foundation; either               *
- * version 2 of the License, or (at your option) any later version.           *
- *                                                                            *
- * This library is distributed in the hope that it will be useful,            *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU          *
- * Lesser General Public License for more details.                            *
- *                                                                            *
- * You should have received a copy of the GNU Lesser General Public           *
- * License along with this library; if not, write to the Free Software        *
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  *
- *                                                                            *
- ******************************************************************************)
-
-(* Pa_type_conv: Preprocessing Module for Registering Type Conversions *)
-
-open Printf
-open Lexing
-
-open Camlp4
-open PreCast
-open Ast
-
-(* Utility functions *)
-
-let both fa fb (a, b) = fa a, fb b
-
-let get_loc_err loc msg =
-  sprintf "File \"%s\", line %d, characters %d-%d: %s"
-    (Loc.file_name loc) (Loc.start_line loc)
-    (Loc.start_off loc - Loc.start_bol loc)
-    (Loc.stop_off loc - Loc.stop_bol loc)
-    msg
-
-(* To be deleted once the OCaml team fixes Mantis issue #4751. *)
-let hash_variant str =
-  let acc_ref = ref 0 in
-  for i = 0 to String.length str - 1 do
-    acc_ref := 223 * !acc_ref + Char.code str.[i]
-  done;
-  if Sys.word_size = 32 then !acc_ref
-  else !acc_ref land int_of_string "0x7FFFFFFF"
-
-
-(* Module/File path management *)
-
-type path =
-  | Not_initialized  (* Initial state *)
-  | Too_late  (* already in a submodule, too late to initialize *)
-  | Path of string * string list  (* Actually initialized *)
-
-(* Reference storing the path to the currently preprocessed module *)
-let conv_path_ref = ref Not_initialized
-
-let get_conv_path_el () =
-  match !conv_path_ref with
-  | Path (e, el) -> e, el
-  | _ -> failwith "Pa_type_conv: path not set"
-
-(* Get path to the currently preprocessed module *)
-let get_conv_path () = fst (get_conv_path_el ())
-
-(* Set path to the currently preprocessed module *)
-let set_conv_path conv_path =
-  if !conv_path_ref = Not_initialized || !Sys.interactive then
-    conv_path_ref := Path (conv_path, [conv_path])
-  else failwith "Pa_type_conv: module name set twice"
-
-let () = if !Sys.interactive then set_conv_path "Toplevel"
-
-let push_conv_path mod_name =
-  match !conv_path_ref with
-  | Not_initialized -> conv_path_ref := Too_late (* Entered a submodule *)
-  | Too_late -> ()
-  | Path (str, rev_lst) ->
-      conv_path_ref := Path (str ^ "." ^ mod_name, mod_name :: rev_lst)
-
-let pop_conv_path () =
-  match !conv_path_ref with
-  | Path (_, _ :: rev_lst) ->
-      conv_path_ref := Path (String.concat "." (List.rev rev_lst), rev_lst)
-  | _ -> ()
-
-
-(* Generator registration *)
-
-
-(* Map of "with"-generators for types in structures *)
-let generators = Hashtbl.create 0
-
-(* Map of "with"-generators for types in signatures *)
-let sig_generators = Hashtbl.create 0
-
-(* Map of "with"-generators for exceptions in structures *)
-let exn_generators = Hashtbl.create 0
-
-(* Map of "with"-generators for exceptions in signatures *)
-let sig_exn_generators = Hashtbl.create 0
-
-(* Check that there is no argument for generators that do not expect
-   arguments *)
-let no_arg id e typ arg =
-  if arg = None then e typ
-  else
-    failwith (
-      "Pa_type_conv: generator '" ^ id ^ "' does not expect an argument")
-
-(* Parse a list of tokens with the given grammar entry *)
-let parse_with entry = function
-  | Some tokens ->
-      Some (Gram.parse_tokens_after_filter entry (Stream.of_list tokens))
-  | None -> None
-
-(* Entry which ignores its input *)
-let ignore_tokens = Gram.Entry.of_parser "ignore_tokens" ignore
-
-(* Add new generator, fail if already defined *)
-let safe_add_gen gens id entry e =
-  if Hashtbl.mem gens id then
-    failwith ("Pa_type_conv: generator '" ^ id ^ "' defined multiple times")
-  else Hashtbl.add gens id (fun typ arg -> e typ (parse_with entry arg))
-
-(* Register a "with"-generator for types in structures *)
-let add_generator_with_arg ?(is_exn = false) id entry e =
-  let gens = if is_exn then exn_generators else generators in
-  safe_add_gen gens id entry e
-
-let add_generator ?is_exn id e =
-  add_generator_with_arg ?is_exn id ignore_tokens (no_arg id e)
-
-(* Removes a "with"-generator for types in structures *)
-let rm_generator ?(is_exn = false) id =
-  let gens = if is_exn then exn_generators else generators in
-  Hashtbl.remove gens id
-
-(* Register a "with"-generator for types in signatures *)
-let add_sig_generator_with_arg ?(is_exn = false) id entry e =
-  let gens = if is_exn then sig_exn_generators else sig_generators in
-  safe_add_gen gens id entry e
-
-let add_sig_generator ?is_exn id e =
-  add_sig_generator_with_arg ?is_exn id ignore_tokens (no_arg id e)
-
-(* Removes a "with"-generator for types in signatures *)
-let rm_sig_generator ?(is_exn = false) id =
-  let gens = if is_exn then sig_exn_generators else sig_generators in
-  Hashtbl.remove gens id
-
-
-(* General purpose code generation module *)
-
-module Gen = struct
-  let gensym =
-    let cnt = ref 0 in
-    fun ?(prefix = "_x") () ->
-      incr cnt;
-      sprintf "%s__%03i_" prefix !cnt
-
-  (* Like Ast.exSem_of_list but for application *)
-  let exApp_of_list l =
-    let rec aux = function
-      | [] -> Ast.ExNil Loc.ghost
-      | [x] -> x
-      | x :: xs ->
-        let loc = Ast.loc_of_expr x in
-        <:expr@loc< $aux xs$ $x$ >>
-    in
-    aux (List.rev l)
-
-  let rec tyArr_of_list = function
-    | [] -> Ast.TyNil Loc.ghost
-    | [x] -> x
-    | x :: xs ->
-      let loc = loc_of_ctyp x in
-      <:ctyp@loc< $x$ -> $tyArr_of_list xs$ >>
-
-  let rec paOr_of_list = function
-    | [] -> Ast.PaNil Loc.ghost
-    | [x] -> x
-    | x :: xs ->
-      let loc = loc_of_patt x in
-      <:patt@loc< $x$ | $paOr_of_list xs$ >>
-
-  module PP = Camlp4.Printers.OCaml.Make (Syntax)
-  let conv_ctyp = (new PP.printer ())#ctyp
-
-  let string_of_ctyp ctyp =
-    let buffer = Buffer.create 32 in
-    Format.bprintf buffer "%a@?" conv_ctyp ctyp;
-    Buffer.contents buffer
-
-  let error tp ~fn ~msg =
-    let loc = Ast.loc_of_ctyp tp in
-    Loc.raise loc (Failure (fn ^ ": " ^ msg ^ "\n" ^ string_of_ctyp tp))
-
-  let unknown_type tp fn = error tp ~fn ~msg:"unknown type"
-
-  let rec ty_var_list_of_ctyp tp acc =
-    match tp with
-    | <:ctyp< $tp1$ $tp2$ >> ->
-        ty_var_list_of_ctyp tp1 (ty_var_list_of_ctyp tp2 acc)
-    | <:ctyp< '$param$ >> -> param :: acc
-    | _ -> invalid_arg "ty_var_list_of_ctyp"
-
-  let rec get_rev_id_path tp acc =
-    match tp with
-    | <:ident< $id1$ . $id2$ >> -> get_rev_id_path id2 (get_rev_id_path id1 acc)
-    | <:ident< $lid:id$ >> | <:ident< $uid:id$ >> -> id :: acc
-    | _ -> invalid_arg "get_rev_id_path"
-
-  let mk_ident _loc str =
-    let first = str.[0] in
-    if first >= 'A' && first <= 'Z' then <:ident< $uid:str$ >>
-    else <:ident< $lid:str$ >>
-
-  let rec ident_of_rev_path _loc = function
-    | [str] -> mk_ident _loc str
-    | str :: strs ->
-        <:ident< $ident_of_rev_path _loc strs$ . $mk_ident _loc str$ >>
-    | _ -> invalid_arg "ident_of_rev_path"
-
-  let rec get_appl_path _loc = function
-    | <:ctyp< $id:id$ >> -> id
-    | <:ctyp< $tp$ $_$ >> -> get_appl_path _loc tp
-    | _ -> failwith "get_appl_path: unknown type"
-
-  let abstract _loc = List.fold_right (fun p e -> <:expr< fun $p$ -> $e$ >>)
-  let apply _loc = List.fold_left (fun f arg -> <:expr< $f$ $arg$ >>)
-
-  let switch_tp_def ~alias ~sum ~record ~variants ~mani ~nil tp =
-    let rec loop = function
-      | <:ctyp< private $tp$ >> -> loop tp
-      | <:ctyp@loc< [ $alts$ ] >> -> sum loc alts
-      | <:ctyp@loc< [< $row_fields$ ] >> | <:ctyp@loc< [> $row_fields$ ] >>
-      | <:ctyp@loc< [= $row_fields$ ] >> -> variants loc row_fields
-      | <:ctyp@loc< $id:_$ >>
-      | <:ctyp@loc< ( $tup:_$ ) >>
-      | <:ctyp@loc< $_$ -> $_$ >>
-      | <:ctyp@loc< '$_$ >>
-      | <:ctyp@loc< $_$ $_$ >> as tp_def -> alias loc tp_def
-      | <:ctyp@loc< { $flds$ } >> -> record loc flds
-      | <:ctyp@loc< $tp1$ == $tp2$ >> -> mani loc tp1 tp2
-      | <:ctyp@loc< >> -> nil loc
-      | tp -> unknown_type tp "switch_tp_def"
-    in
-    loop tp
-
-  let rec mk_expr_lst _loc = function
-    | [] -> <:expr< [] >>
-    | e :: es -> <:expr< [$e$ :: $mk_expr_lst _loc es$] >>
-
-  let rec mk_patt_lst _loc = function
-    | [] -> <:patt< [] >>
-    | p :: ps -> <:patt< [$p$ :: $mk_patt_lst _loc ps$] >>
-
-  let get_tparam_id = function
-    | <:ctyp< '$id$ >> | <:ctyp< +'$id$ >> | <:ctyp< -'$id$ >> -> id
-    | tp -> error tp ~fn:"get_tparam_id" ~msg:"not a type parameter"
-
-  let type_is_recursive type_name tp =
-    let bad_type tp = unknown_type tp "type_is_recursive" in
-    let rec loop = function
-      | <:ctyp< private $tp$>> -> loop tp
-      | <:ctyp< $tp1$ $tp2$ >>
-      | <:ctyp< $tp1$ * $tp2$ >>
-      | <:ctyp< $tp1$; $tp2$ >>
-      | <:ctyp< $tp1$ -> $tp2$ >>
-      | <:ctyp< $tp1$ == $tp2$ >>
-      | <:ctyp< $tp1$ and $tp2$ >>
-      | <:ctyp< $tp1$ & $tp2$ >>
-      | <:ctyp< $tp1$, $tp2$ >>
-      | <:ctyp< [ < $tp1$ > $tp2$ ] >>
-      | <:ctyp< $tp1$ | $tp2$ >> -> loop tp1 || loop tp2
-      | <:ctyp< ( $tup:tp$ ) >> | <:ctyp< { $tp$ } >>
-      | <:ctyp< [ $tp$ ] >>
-      | <:ctyp< $_$ : $tp$ >>
-      | <:ctyp< ~ $_$ : $tp$ >>
-      | <:ctyp< ? $_$ : $tp$ >>
-      | <:ctyp< < $tp$; $..:_$ > >>
-      | <:ctyp< mutable $tp$ >>
-      | <:ctyp< $_$ of & $tp$ >>
-      | <:ctyp< $_$ of $tp$ >>
-      | <:ctyp< $tp$ as $_$ >>
-      | <:ctyp< [< $tp$ ] >> | <:ctyp< [> $tp$ ] >> | <:ctyp< [= $tp$ ] >>
-      | <:ctyp< ! $_$ . $tp$ >> -> loop tp
-      | <:ctyp< $lid:id$ >> -> id = type_name
-      | <:ctyp< $id:_$ >>
-      | <:ctyp< #$id:_$ >>
-      | <:ctyp< `$_$ >>
-      | <:ctyp< '$_$ >>
-      | <:ctyp< -'$_$ >>
-      | <:ctyp< +'$_$ >>
-      | <:ctyp< _ >>
-      | <:ctyp< >> -> false
-      | <:ctyp< (module $module_type$) >> -> loop_module_type module_type
-      | Ast.TyDcl _
-      | Ast.TyAnt _ as tp -> bad_type tp
-    and loop_module_type = function
-      | <:module_type< $module_type$ with $with_constr$ >> ->
-          let rec loop_with_constr = function
-            | <:with_constr< type $_$ = $tp$ >>
-            | <:with_constr< type $_$ := $tp$ >> -> loop tp
-            | <:with_constr< $wc1$ and $wc2$ >> ->
-                loop_with_constr wc1 || loop_with_constr wc2
-            | <:with_constr< module $_$ = $_$ >>
-            | <:with_constr< module $_$ := $_$ >>
-            | <:with_constr< >> -> false
-            | Ast.WcAnt _ -> bad_type tp
-          in
-          loop_with_constr with_constr || loop_module_type module_type
-      | <:module_type< $id:_$ >>
-      | <:module_type< '$_$ >>
-      | <:module_type< >> -> false
-      | <:module_type< functor ($_$ : $_$) -> $_$ >>
-      | <:module_type< sig $_$ end >>
-      | <:module_type< module type of $_$ >>
-      | Ast.MtAnt _ -> bad_type tp
-    in
-    loop tp
-
-  let drop_variance_annotations =
-    (map_ctyp (function
-      | <:ctyp@loc< +'$var$ >> | <:ctyp@loc< -'$var$ >> -> <:ctyp@loc< '$var$ >>
-      | tp -> tp))#ctyp
-end
-
-
-(* Functions for interpreting derivation types *)
-
-let generate tp (drv_id, drv_arg) =
-  try Hashtbl.find generators drv_id tp drv_arg
-  with Not_found ->
-    failwith (
-      "Pa_type_conv: '" ^ drv_id ^ "' is not a supported type generator.")
-
-let gen_derived_defs _loc tp drvs =
-  let coll drv der_sis = <:str_item< $der_sis$; $generate tp drv$ >> in
-  List.fold_right coll drvs <:str_item< >>
-
-let generate_exn tp (drv_id, drv_arg) =
-  try Hashtbl.find exn_generators drv_id tp drv_arg
-  with Not_found ->
-    failwith (
-      "Pa_type_conv: '" ^ drv_id ^ "' is not a supported exception generator.")
-
-let gen_derived_exn_defs _loc tp drvs =
-  let coll drv der_sis = <:str_item< $der_sis$; $generate_exn tp drv$ >> in
-  List.fold_right coll drvs <:str_item< >>
-
-let sig_generate tp (drv_id, drv_arg) =
-  try Hashtbl.find sig_generators drv_id tp drv_arg
-  with Not_found ->
-    failwith (
-      "Pa_type_conv: '" ^ drv_id ^ "' is not a supported signature generator.")
-
-let gen_derived_sigs _loc tp drvs =
-  let coll drv der_sis = <:sig_item< $der_sis$; $sig_generate tp drv$ >> in
-  List.fold_right coll drvs (SgNil _loc)
-
-let sig_exn_generate tp (drv_id, drv_arg) =
-  try Hashtbl.find sig_exn_generators drv_id tp drv_arg
-  with Not_found ->
-    failwith (
-      "Pa_type_conv: '" ^ drv_id ^ "' is not a supported signature generator.")
-
-let gen_derived_exn_sigs _loc tp drvs =
-  let coll drv der_sis = <:sig_item< $der_sis$; $sig_exn_generate tp drv$ >> in
-  List.fold_right coll drvs (SgNil _loc)
-
-
-(* Syntax extension *)
-
-open Syntax
-
-let is_prefix ~prefix x =
-  let prefix_len = String.length prefix in
-  String.length x >= prefix_len && prefix = String.sub x 0 prefix_len
-
-let chop_prefix ~prefix x =
-  if is_prefix ~prefix x then
-    let prefix_len = String.length prefix in
-    Some (String.sub x prefix_len (String.length x - prefix_len))
-  else None
-
-let get_default_path _loc =
-  try
-    let prefix = Sys.getenv "TYPE_CONV_ROOT" in
-    match chop_prefix ~prefix (Loc.file_name (Loc.make_absolute _loc)) with
-    | Some x -> x ^ "#"
-    | None -> Loc.file_name _loc
-  with _ -> Loc.file_name _loc
-
-let set_conv_path_if_not_set _loc =
-  if !conv_path_ref = Not_initialized || !Sys.interactive then
-    let conv_path = get_default_path _loc in
-    conv_path_ref := Path (conv_path, [conv_path])
-
-let found_module_name =
-  Gram.Entry.of_parser "found_module_name" (fun strm ->
-    match Stream.npeek 1 strm with
-    | [(UIDENT name, token_info)] ->
-        set_conv_path_if_not_set (Gram.token_location token_info);
-        push_conv_path name;
-        Stream.junk strm;
-        name
-    | _ -> raise Stream.Failure)
-
-let rec fetch_generator_arg paren_count strm =
-  match Stream.next strm with
-  | KEYWORD "(", _ -> fetch_generator_arg (paren_count + 1) strm
-  | KEYWORD ")", token_info ->
-      if paren_count = 1 then [(EOI, token_info)]
-      else fetch_generator_arg (paren_count - 1) strm
-  | EOI, token_info ->
-      Loc.raise (Gram.token_location token_info) (Stream.Error "')' missing")
-  | x -> x :: fetch_generator_arg paren_count strm
-
-let generator_arg =
-  Gram.Entry.of_parser "generator_arg" (fun strm ->
-    match Stream.peek strm with
-    | Some (KEYWORD "(", _) ->
-        Stream.junk strm;
-        Some (fetch_generator_arg 1 strm)
-    | _ -> None)
-
-DELETE_RULE Gram str_item: "module"; a_UIDENT; module_binding0 END;
-
-EXTEND Gram
-  GLOBAL: str_item sig_item;
-
-  str_item:
-    [[
-      "TYPE_CONV_PATH"; conv_path = STRING ->
-        set_conv_path conv_path;
-        <:str_item< >>
-    ]];
-
-  generator: [[ id = LIDENT; arg = generator_arg -> (id, arg) ]];
-
-  str_item:
-    [[
-      "type"; tds = type_declaration; "with"; drvs = LIST1 generator SEP "," ->
-        set_conv_path_if_not_set _loc;
-        <:str_item< type $tds$; $gen_derived_defs _loc tds drvs$ >>
-    ]];
-
-  str_item:
-    [[
-      "exception"; tds = constructor_declaration; "with";
-      drvs = LIST1 generator SEP "," ->
-        set_conv_path_if_not_set _loc;
-        <:str_item< exception $tds$; $gen_derived_exn_defs _loc tds drvs$ >>
-    ]];
-
-  sig_item:
-    [[
-      "type"; tds = type_declaration; "with"; drvs = LIST1 generator SEP "," ->
-        set_conv_path_if_not_set _loc;
-        <:sig_item< type $tds$; $gen_derived_sigs _loc tds drvs$ >>
-    ]];
-
-  sig_item:
-   [[
-     "exception"; cd = constructor_declaration; "with";
-     drvs = LIST1 generator SEP "," ->
-       set_conv_path_if_not_set _loc;
-       <:sig_item< exception $cd$; $gen_derived_exn_sigs _loc cd drvs$ >>
-    ]];
-
-  str_item:
-    [[
-      "module"; i = found_module_name; mb = module_binding0 ->
-        pop_conv_path ();
-        <:str_item< module $i$ = $mb$ >>
-    ]];
-
-END

type-conv/type_conv-3.0.5/lib/pa_type_conv.mli

-(******************************************************************************
- *                             Type-conv                                      *
- *                                                                            *
- * Copyright (C) 2005- Jane Street Holding, LLC                               *
- *    Contact: opensource@janestreet.com                                      *
- *    WWW: http://www.janestreet.com/ocaml                                    *
- *    Author: Markus Mottl                                                    *
- *                                                                            *
- * This library is free software; you can redistribute it and/or              *
- * modify it under the terms of the GNU Lesser General Public                 *
- * License as published by the Free Software Foundation; either               *
- * version 2 of the License, or (at your option) any later version.           *
- *                                                                            *
- * This library is distributed in the hope that it will be useful,            *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU          *
- * Lesser General Public License for more details.                            *
- *                                                                            *
- * You should have received a copy of the GNU Lesser General Public           *
- * License along with this library; if not, write to the Free Software        *
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  *
- *                                                                            *
- ******************************************************************************)
-
-(** Pa_type_conv: Preprocessing Module for Registering Type Conversions *)
-
-open Camlp4.PreCast.Ast
-
-(** {6 Generator registration} *)
-
-val add_generator : ?is_exn : bool -> string -> (ctyp -> str_item) -> unit
-(** [add_generator ?is_exn name gen] adds the code generator [gen],
-    which maps type or exception declarations to structure items, where
-    [is_exn] specifies whether the declaration is an exception.  Note that
-    the original type/exception declarations get added automatically in
-    any case.
-
-    @param is_exn = [false]
-*)
-
-val add_generator_with_arg :
-  ?is_exn : bool -> string -> 'a Camlp4.PreCast.Gram.Entry.t ->
-  (ctyp -> 'a option -> str_item) -> unit
-(** [add_generator_with_arg ?is_exn name entry generator] same as
-    [add_generator], but the generator may accept an argument, which is
-    parsed with [entry]. *)
-
-val rm_generator : ?is_exn : bool -> string -> unit
-(** [rm_generator ?is_exn name] removes the code generator named [name]. *)
-
-val add_sig_generator :
-  ?is_exn : bool -> string -> (ctyp -> sig_item) -> unit
-(** [add_generator ?is_exn name gen] adds the code generator [gen],
-    which maps type or exception declarations to signature items, where
-    [is_exn] specifies whether the declaration is an exception.  Note that
-    the original type/exception declarations get added automatically in
-    any case.
-
-    @param is_exn = [false]
-*)
-
-val set_conv_path_if_not_set : Loc.t -> unit
-
-val add_sig_generator_with_arg :
-  ?is_exn : bool -> string -> 'a Camlp4.PreCast.Gram.Entry.t ->
-  (ctyp -> 'a option -> sig_item) -> unit
-(** [add_sig_generator_with_arg ?is_exn name entry generator] same as
-    [add_sig_generator], but the generator may accept an argument,
-    which is parsed with [entry]. *)
-
-val rm_sig_generator : ?is_exn : bool -> string -> unit
-(** [rm_sig_generator name] removes the code signature generator named
-    [name]. *)
-
-val get_conv_path : unit -> string
-(** [get_conv_path ()] @return the name to module containing a type
-    as required for error messages. *)
-
-
-(** {6 Utility functions} *)
-
-val get_loc_err : Loc.t -> string -> string
-(** [get_loc_err loc msg] generates a compile-time error message. *)
-
-val hash_variant : string -> int
-(** [hash_variant str] @return the integer encoding a variant tag with
-    name [str]. *)
-
-
-(** {6 General purpose code generation module} *)
-
-module Gen : sig
-  val exApp_of_list : expr list -> expr
-  (** [expr_app_of_list l] takes list [l] of expressions [e1; e2; e3; ...]
-      and returns the expression [e1 e2 e3].  C.f.: [Ast.exSem_of_list]. *)
-
-  val tyArr_of_list : ctyp list -> ctyp
-  (** [tyArr_of_list l] takes list [l] of types [e1; e2; e3; ...] and
-      returns the type [e1 e2 e3].  C.f.: [Ast.exSem_of_list]. *)
-
-  val paOr_of_list : patt list -> patt
-  (** [paOr_of_list l] takes list [l] of patterns [p1; p2; p3; ...] and returns
-      the pattern [p1 | p2 | p3 | ...] *)
-
-  val gensym : ?prefix : string -> unit -> string
-  (** [gensym ?prefix ()] generates a fresh variable name with [prefix].
-      When used with the default parameters, it will return: [_x__001],
-      [_x__002], [_x__003], ...
-
-      @param prefix default = "_x"
-  *)
-
-  val error : ctyp -> fn : string -> msg : string -> _
-  (** [error tp ~fn ~msg] raises an error with [msg] on type [tp] occuring
-      in function [fn]. *)
-
-  val unknown_type : ctyp -> string -> _
-  (** [unknown_type tp fn] type [tp] cannot be handled by function [fn]. *)
-
-  val ty_var_list_of_ctyp : ctyp -> string list -> string list
-  (** [ty_var_list_of_ctyp tp acc] accumulates a list of type parameters
-      contained in [tp] into [acc] as strings. *)
-
-  val get_rev_id_path : ident -> string list -> string list
-  (** [get_rev_id_path id acc] takes an identifier.  @return a reversed
-      module path (list of strings) denoting this identifier, appending
-      it to [acc]. *)
-
-  val ident_of_rev_path : Loc.t -> string list -> ident
-  (** [ident_of_rev_path loc path] takes a location [loc] and a reversed path
-      [rev_path] to an identifier.  @return identifier denoting the
-      bound value. *)
-
-  val get_appl_path : Loc.t -> ctyp -> ident
-  (** [get_appl_path loc tp] @return the identifier path associated with
-      a polymorphic type. *)
-
-  val abstract : Loc.t -> patt list -> expr -> expr
-  (** [abstract loc patts body] takes a location [loc], a pattern list
-      [patts], and an expression [body].  @return a function expression
-      that takes the patterns as arguments, and binds them in [body]. *)
-
-  val apply : Loc.t -> expr -> expr list -> expr
-  (** [apply loc f_expr arg_exprs] takes a location [loc], an expression
-      [f_expr] representing a function, and a list of argument expressions
-      [arg_exprs].  @return an expression in which the function is
-      applied to its arguments. *)
-
-  val switch_tp_def :
-    alias : (Loc.t -> ctyp -> 'a) ->
-    sum : (Loc.t -> ctyp -> 'a) ->
-    record : (Loc.t -> ctyp -> 'a) ->
-    variants : (Loc.t -> ctyp -> 'a) ->
-    mani : (Loc.t -> ctyp -> ctyp -> 'a) ->
-    nil : (Loc.t -> 'a) ->
-    ctyp
-    -> 'a
-  (** [switch_tp_def ~alias ~sum ~record ~variants ~mani tp_def]
-      takes a handler function for each kind of type definition and
-      applies the appropriate handler when [tp_def] matches. *)
-
-  val mk_expr_lst : Loc.t -> expr list -> expr
-  (** [mk_expr_lst loc expr_list] takes a list of expressions.
-      @return an expression representing a list of expressions. *)
-
-  val mk_patt_lst : Loc.t -> patt list -> patt
-  (** [mk_patt_lst _loc patt_list] takes a list of patterns.
-      @return a pattern representing a list of patterns. *)
-
-  val get_tparam_id : ctyp -> string
-  (** [get_tparam_id tp] @return the string identifier associated with
-      [tp] if it is a type parameter.  @raise Failure otherwise. *)
-
-  val type_is_recursive : string -> ctyp -> bool
-  (** [type_is_recursive id tp] @return whether the type [tp] with name [id]
-      refers to itself, assuming that it is not mutually recursive with
-      another type. *)
-
-  val drop_variance_annotations : ctyp -> ctyp
-  (** [drop_variance_annotations tp] @return the type resulting from dropping
-      all variance annotations in [tp]. *)
-end

type-conv/type_conv-3.0.5/lib/pa_type_conv.mllib

-# OASIS_START
-# DO NOT EDIT (digest: 4688111c934ddd0f4ac3eded6942b27f)
-Pa_type_conv
-# OASIS_STOP

type-conv/type_conv-3.0.5/myocamlbuild.ml

-(* OASIS_START *)
-(* DO NOT EDIT (digest: 7abc86d1a2ae10bc0282f0ab3963fde4) *)
-module OASISGettext = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISGettext.ml"
-  
-  let ns_ str =
-    str
-  
-  let s_ str =
-    str
-  
-  let f_ (str : ('a, 'b, 'c, 'd) format4) =
-    str
-  
-  let fn_ fmt1 fmt2 n =
-    if n = 1 then
-      fmt1^^""
-    else
-      fmt2^^""
-  
-  let init =
-    []
-  
-end
-
-module OASISExpr = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISExpr.ml"
-  
-  
-  
-  open OASISGettext
-  
-  type test = string 
-  
-  type flag = string 
-  
-  type t =
-    | EBool of bool
-    | ENot of t
-    | EAnd of t * t
-    | EOr of t * t
-    | EFlag of flag
-    | ETest of test * string
-    
-  
-  type 'a choices = (t * 'a) list 
-  
-  let eval var_get t =
-    let rec eval' =
-      function
-        | EBool b ->
-            b
-  
-        | ENot e ->
-            not (eval' e)
-  
-        | EAnd (e1, e2) ->
-            (eval' e1) && (eval' e2)
-  
-        | EOr (e1, e2) ->
-            (eval' e1) || (eval' e2)
-  
-        | EFlag nm ->
-            let v =
-              var_get nm
-            in
-              assert(v = "true" || v = "false");
-              (v = "true")
-  
-        | ETest (nm, vl) ->
-            let v =
-              var_get nm
-            in
-              (v = vl)
-    in
-      eval' t
-  
-  let choose ?printer ?name var_get lst =
-    let rec choose_aux =
-      function
-        | (cond, vl) :: tl ->
-            if eval var_get cond then
-              vl
-            else
-              choose_aux tl
-        | [] ->
-            let str_lst =
-              if lst = [] then
-                s_ "<empty>"
-              else
-                String.concat
-                  (s_ ", ")
-                  (List.map
-                     (fun (cond, vl) ->
-                        match printer with
-                          | Some p -> p vl
-                          | None -> s_ "<no printer>")
-                     lst)
-            in
-              match name with
-                | Some nm ->
-                    failwith
-                      (Printf.sprintf
-                         (f_ "No result for the choice list '%s': %s")
-                         nm str_lst)
-                | None ->
-                    failwith
-                      (Printf.sprintf
-                         (f_ "No result for a choice list: %s")
-                         str_lst)
-    in
-      choose_aux (List.rev lst)
-  
-end
-
-
-module BaseEnvLight = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/base/BaseEnvLight.ml"
-  
-  module MapString = Map.Make(String)
-  
-  type t = string MapString.t
-  
-  let default_filename =
-    Filename.concat
-      (Sys.getcwd ())
-      "setup.data"
-  
-  let load ?(allow_empty=false) ?(filename=default_filename) () =
-    if Sys.file_exists filename then
-      begin
-        let chn =
-          open_in_bin filename
-        in
-        let st =
-          Stream.of_channel chn
-        in
-        let line =
-          ref 1
-        in
-        let st_line =
-          Stream.from
-            (fun _ ->
-               try
-                 match Stream.next st with
-                   | '\n' -> incr line; Some '\n'
-                   | c -> Some c
-               with Stream.Failure -> None)
-        in
-        let lexer =
-          Genlex.make_lexer ["="] st_line
-        in
-        let rec read_file mp =
-          match Stream.npeek 3 lexer with
-            | [Genlex.Ident nm; Genlex.Kwd "="; Genlex.String value] ->
-                Stream.junk lexer;
-                Stream.junk lexer;
-                Stream.junk lexer;
-                read_file (MapString.add nm value mp)
-            | [] ->
-                mp
-            | _ ->
-                failwith
-                  (Printf.sprintf
-                     "Malformed data file '%s' line %d"
-                     filename !line)
-        in
-        let mp =
-          read_file MapString.empty
-        in
-          close_in chn;
-          mp
-      end
-    else if allow_empty then
-      begin
-        MapString.empty
-      end
-    else
-      begin
-        failwith
-          (Printf.sprintf
-             "Unable to load environment, the file '%s' doesn't exist."
-             filename)
-      end
-  
-  let var_get name env =
-    let rec var_expand str =
-      let buff =
-        Buffer.create ((String.length str) * 2)
-      in
-        Buffer.add_substitute
-          buff
-          (fun var ->
-             try
-               var_expand (MapString.find var env)
-             with Not_found ->
-               failwith
-                 (Printf.sprintf
-                    "No variable %s defined when trying to expand %S."
-                    var
-                    str))
-          str;
-        Buffer.contents buff
-    in
-      var_expand (MapString.find name env)
-  
-  let var_choose lst env =
-    OASISExpr.choose
-      (fun nm -> var_get nm env)
-      lst
-end
-
-
-module MyOCamlbuildFindlib = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/plugins/ocamlbuild/MyOCamlbuildFindlib.ml"
-  
-  (** OCamlbuild extension, copied from 
-    * http://brion.inria.fr/gallium/index.php/Using_ocamlfind_with_ocamlbuild
-    * by N. Pouillard and others
-    *
-    * Updated on 2009/02/28
-    *
-    * Modified by Sylvain Le Gall 
-    *)
-  open Ocamlbuild_plugin
-  
-  (* these functions are not really officially exported *)
-  let run_and_read = 
-    Ocamlbuild_pack.My_unix.run_and_read
-  
-  let blank_sep_strings = 
-    Ocamlbuild_pack.Lexers.blank_sep_strings
-  
-  let split s ch =
-    let x = 
-      ref [] 
-    in
-    let rec go s =
-      let pos = 
-        String.index s ch 
-      in
-        x := (String.before s pos)::!x;
-        go (String.after s (pos + 1))
-    in
-      try
-        go s
-      with Not_found -> !x
-  
-  let split_nl s = split s '\n'
-  
-  let before_space s =
-    try
-      String.before s (String.index s ' ')
-    with Not_found -> s
-  
-  (* this lists all supported packages *)
-  let find_packages () =
-    List.map before_space (split_nl & run_and_read "ocamlfind list")
-  
-  (* this is supposed to list available syntaxes, but I don't know how to do it. *)
-  let find_syntaxes () = ["camlp4o"; "camlp4r"]
-  
-  (* ocamlfind command *)
-  let ocamlfind x = S[A"ocamlfind"; x]
-  
-  let dispatch =
-    function
-      | Before_options ->
-          (* by using Before_options one let command line options have an higher priority *)
-          (* on the contrary using After_options will guarantee to have the higher priority *)
-          (* override default commands by ocamlfind ones *)
-          Options.ocamlc     := ocamlfind & A"ocamlc";
-          Options.ocamlopt   := ocamlfind & A"ocamlopt";
-          Options.ocamldep   := ocamlfind & A"ocamldep";
-          Options.ocamldoc   := ocamlfind & A"ocamldoc";
-          Options.ocamlmktop := ocamlfind & A"ocamlmktop"
-                                  
-      | After_rules ->
-          
-          (* When one link an OCaml library/binary/package, one should use -linkpkg *)
-          flag ["ocaml"; "link"; "program"] & A"-linkpkg";
-          
-          (* For each ocamlfind package one inject the -package option when
-           * compiling, computing dependencies, generating documentation and
-           * linking. *)
-          List.iter 
-            begin fun pkg ->
-              flag ["ocaml"; "compile";  "pkg_"^pkg] & S[A"-package"; A pkg];
-              flag ["ocaml"; "ocamldep"; "pkg_"^pkg] & S[A"-package"; A pkg];
-              flag ["ocaml"; "doc";      "pkg_"^pkg] & S[A"-package"; A pkg];
-              flag ["ocaml"; "link";     "pkg_"^pkg] & S[A"-package"; A pkg];
-              flag ["ocaml"; "infer_interface"; "pkg_"^pkg] & S[A"-package"; A pkg];
-            end 
-            (find_packages ());
-  
-          (* Like -package but for extensions syntax. Morover -syntax is useless
-           * when linking. *)
-          List.iter begin fun syntax ->
-          flag ["ocaml"; "compile";  "syntax_"^syntax] & S[A"-syntax"; A syntax];
-          flag ["ocaml"; "ocamldep"; "syntax_"^syntax] & S[A"-syntax"; A syntax];
-          flag ["ocaml"; "doc";      "syntax_"^syntax] & S[A"-syntax"; A syntax];
-          flag ["ocaml"; "infer_interface"; "syntax_"^syntax] & S[A"-syntax"; A syntax];
-          end (find_syntaxes ());
-  
-          (* The default "thread" tag is not compatible with ocamlfind.
-           * Indeed, the default rules add the "threads.cma" or "threads.cmxa"
-           * options when using this tag. When using the "-linkpkg" option with
-           * ocamlfind, this module will then be added twice on the command line.
-           *                        
-           * To solve this, one approach is to add the "-thread" option when using
-           * the "threads" package using the previous plugin.
-           *)
-          flag ["ocaml"; "pkg_threads"; "compile"] (S[A "-thread"]);
-          flag ["ocaml"; "pkg_threads"; "doc"] (S[A "-I"; A "+threads"]);
-          flag ["ocaml"; "pkg_threads"; "link"] (S[A "-thread"]);
-          flag ["ocaml"; "pkg_threads"; "infer_interface"] (S[A "-thread"])
-  
-      | _ -> 
-          ()
-  
-end
-
-module MyOCamlbuildBase = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
-  
-  (** Base functions for writing myocamlbuild.ml
-      @author Sylvain Le Gall
-    *)
-  
-  
-  
-  open Ocamlbuild_plugin
-  
-  type dir = string 
-  type file = string 
-  type name = string 
-  type tag = string 
-  
-# 55 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
-  
-  type t =
-      {
-        lib_ocaml: (name * dir list) list;
-        lib_c:     (name * dir * file list) list; 
-        flags:     (tag list * (spec OASISExpr.choices)) list;
-      } 
-  
-  let env_filename =
-    Pathname.basename 
-      BaseEnvLight.default_filename
-  
-  let dispatch_combine lst =
-    fun e ->
-      List.iter 
-        (fun dispatch -> dispatch e)
-        lst 
-  
-  let dispatch t e = 
-    let env = 
-      BaseEnvLight.load 
-        ~filename:env_filename 
-        ~allow_empty:true
-        ()
-    in
-      match e with 
-        | Before_options ->
-            let no_trailing_dot s =
-              if String.length s >= 1 && s.[0] = '.' then
-                String.sub s 1 ((String.length s) - 1)
-              else
-                s
-            in
-              List.iter
-                (fun (opt, var) ->
-                   try 
-                     opt := no_trailing_dot (BaseEnvLight.var_get var env)
-                   with Not_found ->
-                     Printf.eprintf "W: Cannot get variable %s" var)
-                [
-                  Options.ext_obj, "ext_obj";
-                  Options.ext_lib, "ext_lib";
-                  Options.ext_dll, "ext_dll";
-                ]
-  
-        | After_rules -> 
-            (* Declare OCaml libraries *)
-            List.iter 
-              (function
-                 | lib, [] ->
-                     ocaml_lib lib;
-                 | lib, dir :: tl ->
-                     ocaml_lib ~dir:dir lib;
-                     List.iter 
-                       (fun dir -> 
-                          flag 
-                            ["ocaml"; "use_"^lib; "compile"] 
-                            (S[A"-I"; P dir]))
-                       tl)
-              t.lib_ocaml;
-  
-            (* Declare C libraries *)
-            List.iter
-              (fun (lib, dir, headers) ->
-                   (* Handle C part of library *)
-                   flag ["link"; "library"; "ocaml"; "byte"; "use_lib"^lib]
-                     (S[A"-dllib"; A("-l"^lib); A"-cclib"; A("-l"^lib)]);
-  
-                   flag ["link"; "library"; "ocaml"; "native"; "use_lib"^lib]
-                     (S[A"-cclib"; A("-l"^lib)]);
-                        
-                   flag ["link"; "program"; "ocaml"; "byte"; "use_lib"^lib]
-                     (S[A"-dllib"; A("dll"^lib)]);
-  
-                   (* When ocaml link something that use the C library, then one
-                      need that file to be up to date.
-                    *)
-                   dep  ["link"; "ocaml"; "program"; "use_lib"^lib]
-                     [dir/"lib"^lib^"."^(!Options.ext_lib)];
-  
-                   dep  ["compile"; "ocaml"; "program"; "use_lib"^lib]
-                     [dir/"lib"^lib^"."^(!Options.ext_lib)];
-  
-                   (* TODO: be more specific about what depends on headers *)
-                   (* Depends on .h files *)
-                   dep ["compile"; "c"] 
-                     headers;
-  
-                   (* Setup search path for lib *)
-                   flag ["link"; "ocaml"; "use_"^lib] 
-                     (S[A"-I"; P(dir)]);
-              )
-              t.lib_c;
-  
-              (* Add flags *)
-              List.iter
-              (fun (tags, cond_specs) ->
-                 let spec = 
-                   BaseEnvLight.var_choose cond_specs env
-                 in
-                   flag tags & spec)
-              t.flags
-        | _ ->