Commits

camlspotter committed 90c9da1 Merge

merged with 4.01.0

Comments (0)

Files changed (32)

 .*~$
 tests_out/.*\.ml
 docs/_build
-^lexer\.ml$
+^xlexer\.ml$
 ^linenum\.ml$
 ^\.omake.*
-ocaml-indent$
+ocaml-indent
+
+(* OASIS_START *)
+(* DO NOT EDIT (digest: 43be09c957f9ef510bf859f09bfac24e) *)
+Authors of ocaml-indent
+Jun FURUSE
+(* OASIS_STOP *)
+This OCaml-indent (the Library) is distributed under the terms of 
+the GNU Library General Public License version 2 (included below).
+
+As a special exception to the GNU Library 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 Library General
+Public License.  By "a publicly distributed version of the Library",
+we mean either the unmodified Library as distributed by INRIA, or a
+modified version of the Library that is distributed under the
+conditions defined in clause 3 of the GNU Library General Public
+License.  This exception does not however invalidate any other reasons
+why the executable file might be covered by the GNU Library General
+Public License.
+
+----------------------------------------------------------------------
+
+                  GNU LIBRARY GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1991 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 library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+                            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 Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, 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 or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the 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 a program 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.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  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, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+                  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+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 compile 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) 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.
+
+    c) 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.
+
+    d) 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 source code 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 to
+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 Library 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
+
+     Appendix: 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 Library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library 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!
 # How-to-build using OMake
 #
-# yes no | omake --install # to create OMakeroot for the first time
+# cp OMakeroot.in OMakeroot # to create OMakeroot for the first time
 
 # If OMakeroot is here, include OMyMakefile
 if $(file-exists OMakeroot)
 
 .PHONY: all install clean
 
-OCAMLINCLUDES +=
+CAMLP4PACKS[]= sexplib compiler-libs.common
 
-OCAMLFLAGS    = -annot -bin-annot -w A-4-9 -warn-error A-4-9-32
-OCAMLCFLAGS   +=
-OCAMLOPTFLAGS +=
-OCAML_LINK_FLAGS +=
-OCAML_BYTE_LINK_FLAGS +=
-OCAML_NATIVE_LINK_FLAGS +=
-
-CAMLP4PACKS[]= planck compiler-libs.common
-
-OCAMLPACKS[]= planck compiler-libs.common
+OCAMLPACKS[]= sexplib compiler-libs.common
 
 OCAMLDEPFLAGS= -syntax camlp4o -package sexplib.syntax
 OCAMLPPFLAGS= -syntax camlp4o -package sexplib.syntax
 FILES[] =
     pos
     reader
+    lazyList
     tokenstr
     xparser
-    machine2
-#    args
-#    main
+    xlexer
+    machine
+    args
+    main
 
 PROGRAM = ocaml-indent
 
 OCAML_OTHER_LIBS +=
 OCAML_LIB_FLAGS +=
 
-MyOCamlInstalledProgram($(PROGRAM), $(FILES))
+MyOCamlProgram($(PROGRAM), $(FILES))
 
 .DEFAULT: ocaml-indent
 
   export
 
 result.diff: $(TESTS_OUT)
-    diff -x '*~' -c -r tests tests_out > $@
+    -diff -x '*~' -c -r tests tests_out > $@
 
 test: result.diff
 
   if $(not $(test -e $(dir))):
     mkdir $(dir) 
   return
+
+WithOCamlVeryClean()
+open build/C
+open build/OCaml
+open build/LaTeX
+
+DefineCommandVars()
+
+.SUBDIRS: .
 try
   PREFIX=$(getenv PREFIX)
 default
-  try
-    PREFIX=$(getenv prefix)
-  default
-    eprintln(Specify PREFIX or prefix environment variable.)
-    exit 1 
+  eprintln(Specify PREFIX or prefix environment variable.)
+  exit 1 
 
 # OCaml 
 # ========================================================================
 USE_OCAMLFIND = true
 OCAMLFIND_DESTDIR= $(shell ocamlfind printconf destdir)
 
+OCAMLFIND_QUERY(name) = 
+    return $(shell ocamlfind query $(name))
+
 #|Set NATIVE_ENABLED false locally if a project does not requre opt compilation.
 NATIVE_ENABLED = $(OCAMLOPT_EXISTS)
 NATIVE_SHARED_ENABLED = $(OCAMLOPT_EXISTS)
 BYTE_ENABLED = true
 
 #|The default warning and errors. If you want to use different warning and error switches, use redefine the variable.
-OCAMLFLAGS = -w A-4-9 -warn-error A-4-9
+OCAMLFLAGS = -g 
+
+#|Warnings not to be printed separted with space
+OCAMLWARNING_IGNORE[] = 4 9
+
+#|Warnings treated as non errors
+OCAMLWARNING_NON_ERROR[] = 4 9
+
+#|If it is false, warnings do not stop the compilation even if they are listed in OCAMLWARNING_NON_ERROR
+#If you are in developing something, turn it ture!
+OCAMLWARNING_STOP_AT_ERROR_WARNING=false
+
+#|The maximum warning value.
+# This is the maximum warning ID NOT of the current OCaml compiler,
+#                                BUT of the OCaml compiler used by the author.
+OCAMLWARNING_MAX= 39
+
+#|Function to build warning switches
+OCAMLWARNING_MAKE()=
+    if $(OCAMLWARNING_STOP_AT_ERROR_WARNING)
+        return -w A-$(concat -,$(OCAMLWARNING_IGNORE)) -warn-error +1..$(OCAMLWARNING_MAX)-$(concat -, $(OCAMLWARNING_NON_ERROR))
+    else
+        return -w A-$(concat -,$(OCAMLWARNING_IGNORE)) -warn-error a
+
+#|OMyMakefile assumes installation with .cmt files
+OCAMLANNOTFLAGS = -annot -bin-annot
 
 #|Global variable to be defined as empty
 OCAMLPACKAGEFLAGS=
 #   Subdirs()
 #
 # It includes "findlib" by default. If you want to build findlib in OMy framework, you have to remove it from the list.
-OCAML_PREINSTALLED_PACKS[]= bigarray camlp4 dbm dynlink graphics num num-top stdlib str threads unix findlib compiler-libs compiler-libs.common
+OCAML_PREINSTALLED_PACKS[]= bigarray camlp4 dbm dynlink graphics num num-top stdlib str threads unix findlib compiler-libs compiler-libs.common compiler-libs.bytecomp compiler-libs.optcomp compiler-libs.toplevel
 
 #|Redefinition of compiler commands
 public.OCamlC() =
-    value $(OCAMLFIND) $(OCAMLC) $(OCAMLPACKAGEFLAGS) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS)\
-              $(OCAMLCFLAGS) $(OCAMLPPFLAGS) $(PREFIXED_OCAMLINCLUDES)
+    value $(OCAMLFIND) $(OCAMLC) \
+        $(OCAMLANNOTFLAGS) \
+        $(OCAMLPACKAGEFLAGS) \
+        $(LAZY_OCAMLFINDFLAGS) \
+        $(PREFIXED_OCAMLPACKS) \
+        $(OCAMLFLAGS) \
+        $(OCAMLWARNING_MAKE) \
+        $(OCAMLCFLAGS) \
+        $(OCAMLPPFLAGS) \
+        $(PREFIXED_OCAMLINCLUDES)
 # Why we need "public." ?
 
 public.OCamlOpt() =
-    value $(OCAMLFIND) $(OCAMLOPT) $(OCAMLPACKAGEFLAGS) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS)\
+    value $(OCAMLFIND) $(OCAMLOPT) $(OCAMLANNOTFLAGS) $(OCAMLPACKAGEFLAGS) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS)\
+              $(OCAMLWARNING_MAKE) \
               $(OCAMLOPTFLAGS) $(OCAMLPPFLAGS) $(PREFIXED_OCAMLINCLUDES)
 
 if $(and $(not $(NATIVE_ENABLED)) $(not $(BYTE_ENABLED)))
 #|Additional implicit rules by file extensions
 # annot, cmt, cmti files
 %.annot %.cmt: %.ml %.cmi
-	$(OCamlC) -c -annot -bin-annot $<
+	$(OCamlC) -c -annot $(OCAMLANNOTFLAGS) $<
 
-%.spit %.cmti: %.mli 
-	$(OCamlC) -c -bin-annot $<
+%.cmti: %.mli 
+	$(OCamlC) -c $(OCAMLANNOTFLAGS) $<
 
-#|Define OCAML_ANNOT so that ocamlc/ocamlopt automatically create spot/spit/annot/cmt/cmti files, even without -annot/-bin-annot option. This requires a special compiler patch 
+#|Define OCAML_ANNOT so that ocamlc/ocamlopt automatically create annot/cmt/cmti files, even without -annot/-bin-annot option. This requires a special compiler patch 
 setenv(OCAML_ANNOT, 1)
 
 #|Enable the backtrace
 
 # Common phonies
 # ==================================================================
-.PHONY: all install uninstall clean
+.PHONY: all install uninstall clean veryclean
+
+# Very clean
+# ======================================================================
+
+#| OCaml object files which are not real targets of OMake are not be
+# auto-cleaned away by ``omake clean``. This is not good in some situations
+# at linking.
+WithOCamlVeryClean() =
+    veryclean: 
+        rm -f *.cm* *.annot *.o *.a *.so *.exe *.byt *.opt *.run
 
 # Directories
 # =====================================================================
 
 #|Returns packages managed by OMy framework
 OMyManagedPackages(packages) =
-   return $(set-diff $(packages), $(OCAML_PREINSTALLED_PACKS))
+   # need to rename camlimages.jpeg => camlimages
+   packages_prefix=
+   foreach(x, $(packages))
+       match $(x)
+       case $"^\([^.]+\).*"
+          packages_prefix += $1
+          export
+       default
+          packages_prefix += $(x)
+          export
+       export
+   return $(set-diff $(packages_prefix), $(OCAML_PREINSTALLED_PACKS))
 
 #|Add dependencies of OCaml compiled files (cmx, cmo, etc.) over $(files).
 #
 # .. note:: These functions introduce implicit rules: *you may need to export it, if you use this function in a local context.*
 OCamlRequire(files) =
-    %.cmx %.cmo %.cmi %.cma %.cmxa %.annot %.spot %.spit %.cmt %.cmti: $(files)
+    %.cmx %.cmo %.cmi %.cma %.cmxa %.annot %.cmt %.cmti: $(files)
     export
 
 #|Add dependencies of OCaml compiled files (cmx, cmo, etc.) over $(packages).
 OCamlRequirePackages(packages) =
     required_packs = $(OMyManagedPackages $(packages))
     if $(defined INSTALLED)
-      %.cmx %.cmo %.cmi %.cma %.cmxa %.annot %.spot %.spit %.cmt %.cmti: $(Installed $(required_packs))
+      %.cmx %.cmo %.cmi %.cma %.cmxa %.annot %.cmt %.cmti: $(Installed $(required_packs))
       export
     export
 
     required_packs = $(OMyManagedPackages $(packages))
     if $(defined INSTALLED)
       .SCANNER: scan-ocaml-%: $(Installed $(required_packs))
-      %.cmx %.cmo %.cmi %.cma %.cmxa %.annot %.spot %.spit : $(Installed $(required_packs))
+      %.cmx %.cmo %.cmi %.cma %.cmxa %.annot : $(Installed $(required_packs))
       export 
     export
 
 # Build rules
 # ==========================================================
 
-# Extend the bundled OCamlPackage with .spot creation
 public.OCamlLibrary(name, files) =
    # XXX: JYH: these variables should be marked private in 0.9.9
    protected.name = $(file $(name))
                   $(if $(NATIVE_SHARED_ENABLED), $(NATIVESHAREDLIB)), \
                   $(if $(BYTE_ENABLED), $(BYTELIB)))
 
-# Extend the bundled OCamlPackage with .spot creation
+public.OCAML_BYTE_LINK_FLAGS =
+
 public.OCamlPackage(name, files) =
    # XXX: JYH: these variables should be marked private in 0.9.9
    protected.OFILES   = $(addsuffix $(EXT_OBJ), $(files))
              export
          $(BYTE_TARGETS): $(BYTE_DEPS)
             $(OCAMLFIND) $(OCAMLC) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS) \
-                $(OCAMLCFLAGS) $(OCAML_LIB_FLAGS) -pack -bin-annot -o $(CMO) $(OCamlLinkSort $(CMOFILES))
+                $(OCAMLCFLAGS) $(OCAML_LIB_FLAGS) -pack $(OCAMLANNOTFLAGS) -o $(CMO) $(OCamlLinkSort $(CMOFILES))
 
    protected.NATIVE_DEPS = $(CMXFILES) $(OFILES)
    $(NATIVE_TARGETS): $(NATIVE_DEPS)
             export
          $(NATIVE_TARGETS): $(NATIVE_DEPS)
             $(OCAMLFIND) $(OCAMLOPTLINK) $(LAZY_OCAMLFINDFLAGS) $(PREFIXED_OCAMLPACKS) $(OCAMLFLAGS) \
-                $(OCAMLOPTFLAGS) $(OCAML_LIB_FLAGS) -pack -bin-annot -o $(CMX) $(OCamlLinkSort $(CMXFILES))
+                $(OCAMLOPTFLAGS) $(OCAML_LIB_FLAGS) -pack $(OCAMLANNOTFLAGS) -o $(CMX) $(OCamlLinkSort $(CMXFILES))
 
    $(CMI):
       section rule
 #
 #  Todo: external C library
 MyOCamlPackage(library_name, files, cmodules, linkopts) =
+  WithOCamlVeryClean()
   AddLocalOCamlPackageDependencies()
   export # The above thing is local: need to be exported
 
   CSTUBS=$(addsuffix .o,$(cmodules))
-  CMOS=$(addsuffix .cmo,$(library_name))
-  CMXS=$(addsuffix .cmx,$(library_name))
+  CMO_S=$(addsuffix .cmo,$(library_name))
+  CMX_S=$(addsuffix .cmx,$(library_name))
   CMA=$(library_name).cma
   CMXA=$(library_name).cmxa
+  CMXS=$(library_name).cmxs
 
   if $(not $(defined MyOCamlPackageExtras))
       MyOCamlPackageExtras[]=
   .PHONY: install-lib
   install-lib: $(library_name).cmo $(library_name).cmx $(library_name).cma $(library_name).cmxa $(MyOCamlPackageExtras)
 
-  $(CMA) $(CMXA) $(library_name).a $(CSTUBLIBRARIES) : $(CSTUBS) $(CMOS) $(CMXS)
+  $(CMA) $(CMXA) $(CMXS) $(library_name).a $(CSTUBLIBRARIES) : $(CSTUBS) $(CMO_S) $(CMX_S)
       if $(not $(equal $(cmodules), $(EMPTY)))
-          ocamlmklib -verbose -o $(library_name) $(CSTUBS) $(linkopts) $(CMOS) $(CMXS)
+          ocamlmklib -verbose -o $(library_name) $(CSTUBS) $(linkopts) $(CMO_S) $(CMX_S)
+          $(OCamlOpt) -shared -o $(CMXS) $(CMX_S) # CR jfuruse: right?
       else
-          $(OCamlC) -a -o $(CMA) $(CMOS)
-          $(OCamlOpt) -a -o $(CMXA) $(CMXS)
+          $(OCamlC) -a -o $(CMA) $(CMO_S)
+          $(OCamlOpt) -a -o $(CMXA) $(CMX_S)
+          $(OCamlOpt) -shared -o $(CMXS) $(CMX_S)
 
   ## the followings are necessary for packing
 
   ## clean
   AutoClean()
   clean:
-	rm -f $(library_name).spot $(library_name).cmt
+	rm -f $(library_name).cmt
 
   ## install
 
   # CR jfuruse: x.cmi is required if x.mli does not exist!
-  targets[]=META $(glob i, *.mli) $(library_name).cmi $(library_name).cmo $(library_name).cmx $(library_name).cma $(library_name).cmxa $(library_name).o $(library_name).a $(CSTUBLIBRARIES) $(MyOCamlPackageExtras)
+  targets[]=META $(glob i, *.mli) $(library_name).cmi $(library_name).cmo $(library_name).cmx $(library_name).cma $(library_name).cmxa $(library_name).cmxs $(library_name).o $(library_name).a $(CSTUBLIBRARIES) $(MyOCamlPackageExtras)
 
   targets[]+= $(library_name).cmt
 
 #      files
 #          OCaml module names (without .ml)
 MyOCamlTestProgram(name, files) =
+  WithOCamlVeryClean()
   AddLocalOCamlPackageDependencies()
   export # The above thing is local: need to be exported
 
-  $(name).run $(name).opt: $(Installed $(OMyManagedPackages $(OCAMLPACKS)))
+  # We must write these two separately, or something messy happens!
+  $(name).run: $(Installed $(OMyManagedPackages $(OCAMLPACKS)))
+  $(name).opt: $(Installed $(OMyManagedPackages $(OCAMLPACKS)))
 
   # CR jfuruse: forgot to add the deps over the packages!
   .DEFAULT: $(OCamlProgram $(name), $(files))
 #          OCaml module names (without .ml)
 #  In addition to MyOCamlTestProgram, the binary is installed by omake install
 MyOCamlProgram(name, files) =
+  WithOCamlVeryClean()
   MyOCamlTestProgram($(name), $(files))
   export # The above thing is local: need to be exported
 
    return $(array $(PROG), $(BYTEPROG))
 
 MyOCamlTop(name, files) =
+  WithOCamlVeryClean()
   AddLocalOCamlPackageDependencies()
   export # The above thing is local: need to be exported
 
 #
 #   .. note :: Probably you should use MyOCamlPackage
 MyOCamlLibrary(library_name, files) =
+  WithOCamlVeryClean()
   AddLocalOCamlPackageDependencies()
-  targets = $(OCamlLibrary $(library_name), $(files))
+  protected.CMIFILES = $(addsuffix .cmi, $(files))
+  targets = $(OCamlLibrary $(library_name), $(files)) $(CMIFILES) $(glob i, *.mli) 
 
   .DEFAULT: $(targets)
 
 
   if $(not $(defined NO_INSTALL))
     targets[] += META 
+    cmts =  $(addsuffix .cmt,  $(removesuffix $(glob i, *.cmo)))
+    cmts += $(addsuffix .cmti, $(removesuffix $(glob i, *.mli)))
     if $(defined INSTALLED)
       $(Installed $(library_name)): $(targets)
         $(OCAMLFIND) remove $(library_name)
         section:
-              $(OCAMLFIND) install $(library_name) $(targets)
+              $(OCAMLFIND) install $(library_name) $(targets) $(cmts)
               CreateInstalled($(library_name), $(targets))
 
       install: $(Installed $(library_name))
     else
       install: $(targets)
         $(OCAMLFIND) remove $(library_name)
-        $(OCAMLFIND) install $(library_name) $(targets)
+        $(OCAMLFIND) install $(library_name) $(targets) $(cmts)
 
       uninstall:
 	$(OCAMLFIND) remove $(library_name)
 #|ditto.
 mkdir_if_not_exists(dir) =
   if $(not $(test -e $(dir))):
-    mkdir $(dir) 
+    mkdir -p $(dir) 
   return
+
+# Pa_ounit test
+# =======================================================================
+
+#| Test with Pa_ounit. Pretty version dependent.
+# Thinking from the implementation Pa_ounit_lib.Runtime, it should be
+# pretty unstable in future releases of Pa_ounit. Sigh.
+
+MyOCamlOUnitTest(LIB) =
+    name=ounittest_$(LIB)
+    $(name).ml:
+        section:
+            chan=$(fopen $@, w)
+            fprintln($(chan), module M = $(capitalize $(LIB)))
+            fprintln($(chan), let \(\) = Pa_ounit_lib.Runtime.summarize \(\))
+            close($(chan))
+
+    section:
+        OCAML_LIBS=$(LIB)
+        MyOCamlTestProgram($(name), $(name))
+
+    inline_tests.log: $(name)
+        println(Check inline_tests.log for test results)
+        ./$(name) inline-test-runner $(capitalize $(LIB)) -verbose -log -strict
+
+    .PHONY:test
+
+    test: inline_tests.log
+(* OASIS_START *)
+(* DO NOT EDIT (digest: d83d11f520362285211215e045bb5eca) *)
+This is the README file for the ocaml-indent distribution.
+
+OCaml-indent: OCaml source code indenter
+
+See the files INSTALL.txt for building and installation instructions. 
+
+
+(* OASIS_STOP *)
+OASISFormat: 0.2
+Name:        ocaml-indent
+Version:     1.1.0
+Synopsis:    OCaml-indent: OCaml source code indenter
+Authors:     Jun FURUSE
+License:     LGPL-2.0 with OCaml linking exception
+Plugins:      StdFiles (0.2)
+BuildType:    Custom (0.2)
+InstallType:    Custom (0.2)
+XCustomBuild: cp OMakeroot.in OMakeroot; PREFIX=$prefix omake
+XCustomInstall: PREFIX=$prefix omake install
+XCustomUninstall: PREFIX=$prefix omake uninstall
+XCustomBuildClean: PREFIX=$prefix omake clean
+BuildTools: omake
 let paths, debug, lines, showstate, cursor =
   let rev_paths = ref [] in
   let debug = ref false in
-  let lines = ref Pos.Lines.WholeFile in
+  let lines = ref None in
   let showstate = ref false in
   let cursor = ref None in
   Arg.parse [
                             int_of_string (String.sub s (pos+1) (String.length s - pos - 1))) in
         if start <= 0 || end_ <= 0 || start > end_ then
           failwith (Printf.sprintf "Wrong -lines specification: %s" s);
-        lines := Pos.Lines.Lines (start, end_)
+        lines := Some (start, end_)
       with
       | _ -> failwith (Printf.sprintf "Wrong -lines specification: %s" s)),
      "lines, ex. 10-12") ;
     ("-cursor", Arg.String (fun s ->
       try
         let pos = String.index s ':' in
-        let (rows,cols) = (int_of_string (String.sub s 0 pos),
+        let (lines,cols) = (int_of_string (String.sub s 0 pos),
                            int_of_string (String.sub s (pos+1) (String.length s - pos - 1))) in
-        if rows <= 0 || cols < 0 then
+        if lines <= 0 || cols < 0 then
           failwith (Printf.sprintf "Wrong -cursor specification: %s" s);
-        cursor := Some (rows, cols)
+        cursor := Some (lines, cols)
       with
       | _ -> failwith (Printf.sprintf "Wrong -cursor specification: %s" s)),
      "cursor position, ex. 10:12") ;
   begin match paths, !lines with
   | [], _ -> assert false
   | [_], _ -> ()
-  | _, Pos.Lines.Lines _ -> failwith "Region can be specified with at most one file"
+  | _, Some _ -> failwith "Region can be specified with at most one file"
   | _ -> ()
   end;
   paths, !debug, !lines, !showstate, !cursor
+val paths : string list
+val debug : bool
+val lines : (int * int) option (** invariant: if [lines <> None] then [List.length paths <= 1] *)
+val showstate : bool
+val cursor : (int * int) option
+
+type 'a desc = 
+  | Cons of 'a * 'a t
+  | Null
+
+and 'a t = 'a desc lazy_t
+
+let peek = function
+  | lazy Null -> None
+  | lazy (Cons (car, cdr)) -> Some (car, cdr)
+type 'a desc = 
+  | Cons of 'a * 'a t
+  | Null
+
+and 'a t = 'a desc lazy_t
+
+val peek : 'a t -> ('a * 'a t) option
       | COMMENT _ -> assert false (* COMMENT must be skipped *)
       | STRUCT | SEMISEMI
 
-      | UIDENT _|STRING _|OPTLABEL _|NATIVEINT _|LIDENT _|LABEL _|INT64 _|INT32 _
+      | UIDENT _|STRING _|P4QUOTE _|OPTLABEL _|NATIVEINT _|LIDENT _|LABEL _|INT64 _|INT32 _
       | INT _|FLOAT _|CHAR _|WITH|VIRTUAL|VAL|UNDERSCORE|TYPE|TRUE|TILDE|SIG|SHARP
-      | RPAREN|REC|RBRACKET|RBRACE|QUOTE|QUESTIONQUESTION|QUESTION|PRIVATE|OPEN
+      | RPAREN|REC|RBRACKET|RBRACE|QUOTE|QUESTION|PRIVATE|OPEN
       | OF|OBJECT|NEW|MUTABLE|MODULE|METHOD|MATCH|LET|LAZY|INHERIT|INCLUDE
       | GREATERRBRACKET|GREATERRBRACE|FUNCTOR|FUNCTION|FUN|FOR|FALSE
       | EXTERNAL|EXCEPTION|EOF|END|DOTDOT|DOT|DONE|CONSTRAINT|COLONGREATER
   | _ :: bs -> unwind_top bs
   | [] -> []
 
-open Planck.Lazylist (* for Cons and Null *)
-
 (* true means I found something to make the token a block *)
-let rec lparen_read_ahead lnum = function
-  | lazy Null _ -> false
-  | lazy Cons (i, _, _) when Region.lnum i.Tokenstr.region <> lnum -> false
-  | lazy Cons (i, _, str) ->
+let rec lparen_read_ahead lnum str =
+  match LazyList.peek str with
+  | None -> false
+  | Some (i, _) when Region.lnum i.Tokenstr.region <> lnum -> false
+  | Some (i, str) ->
       match i.Tokenstr.token with
       | COMMENT _ -> lparen_read_ahead lnum str
       | FUN -> false
       | FUNCTION -> false
       | _ -> true
 
-let lbrace_read_ahead lnum = function
-  | lazy Null _ -> false
-  | lazy Cons (i, _, _) when Region.lnum i.Tokenstr.region <> lnum -> false
-  | lazy Cons (i, _,str) ->
+let lbrace_read_ahead lnum str =
+  match LazyList.peek str with
+  | None -> false
+  | Some (i, _) when Region.lnum i.Tokenstr.region <> lnum -> false
+  | Some (i, str) ->
       match i.Tokenstr.token with
       | COMMENT _ -> lparen_read_ahead lnum str
       | _ -> true
         let bases = unwind_top bases0 in
         bases, bases
 
+    | OPEN when state.last_token = Some LET -> (* let open *)
+        bases0, bases0
+
     | OPEN ->
         let bases = unwind_top bases0 in
         bases,
         in
         f bases0
 
-    | INT64 _ | INT32 _ | INT _ | LIDENT _ | UIDENT _ | FLOAT _| CHAR _ | STRING _ | TRUE | FALSE ->
+    | INT64 _ | INT32 _ | INT _ | LIDENT _ | UIDENT _ | FLOAT _| CHAR _ | STRING _ | TRUE | FALSE | P4QUOTE _ ->
         let rec f bases = match bases with
           | { k = KExpr _ } :: _ -> bases0, bases0
           | [] -> bases0, { k = KExpr cols; indent = cols + 2; } :: bases0
 
     |PREFIXOP _|OPTLABEL _|NATIVEINT _|LABEL _
     |WHEN|VIRTUAL|UNDERSCORE|TO|TILDE|
-          SHARP|REC|QUOTE|QUESTIONQUESTION|QUESTION|
+          SHARP|REC|QUOTE|QUESTION|
           PRIVATE|OR|OF|NEW|MUTABLE|METHOD
           |LESSMINUS|LBRACKETGREATER|LBRACKETLESS|LBRACKETBAR|
           LBRACELESS|LAZY|INITIALIZER|INHERIT|INCLUDE|GREATERRBRACKET|

machine2.ml

-open Spotlib.Spot
-open Lazy
-open Parser
-
-module State = struct
-  type t = unit
-end
-
-module P = Planck.Pstate.Make(Tokenstr.Stream)(State)
-open P
-
-let rec top = lazy (
-  token BEGIN >>= fun () -> 
-  !!in_begin
-)
-
-and in_begin = lazy (
-  token END 
-  <|> (take >>= fun tkn -> 
-       
-       !!in_begin)
-)
-  
-  
-  
-(*
-module State = struct
-  type t = {
-    modified : bool;   (* Has the source code ever modified ? *)
-    orig_indent : int; (* The original indent of the current line *)
-    last_indent : int; (* At line head, first pass: the fixed indent of the last line
-                          At line head, snd pass: the fixed indent of the current line
-                          Otherwise: the fixed indent of the current line *)
-    last_token : Parser.token option;
-    bases : Stack.t;
-  } with sexp_of
-
-  let init = { bases = []; orig_indent = 0; last_indent = 0; last_token = None; modified = false }
-
-  let indent t = Stack.indent t.last_indent t.bases
-
-  let print t = print_endline (Sexplib.Sexp.to_string_mach (sexp_of_t t))
-end
-
-open State
-open Stack
-open Parser
-
-(* Check the previous token and tell the LET is toplevel or not *)
-let is_top_let = function
-  | None -> true
-  | Some t ->
-      match t with
-      | COMMENT _ -> assert false (* COMMENT must be skipped *)
-      | STRUCT | SEMISEMI
-
-      | UIDENT _|STRING _|OPTLABEL _|NATIVEINT _|LIDENT _|LABEL _|INT64 _|INT32 _
-      | INT _|FLOAT _|CHAR _|WITH|VIRTUAL|VAL|UNDERSCORE|TYPE|TRUE|TILDE|SIG|SHARP
-      | RPAREN|REC|RBRACKET|RBRACE|QUOTE|QUESTIONQUESTION|QUESTION|PRIVATE|OPEN
-      | OF|OBJECT|NEW|MUTABLE|MODULE|METHOD|MATCH|LET|LAZY|INHERIT|INCLUDE
-      | GREATERRBRACKET|GREATERRBRACE|FUNCTOR|FUNCTION|FUN|FOR|FALSE
-      | EXTERNAL|EXCEPTION|EOF|END|DOTDOT|DOT|DONE|CONSTRAINT|COLONGREATER
-      | COLON|CLASS|BARRBRACKET|BAR|BANG|BACKQUOTE|ASSERT|AS|AND
-          -> true
-
-      | _ -> false
-
-let rec unwind_top bases = match bases with (* unwind the top *)
-  | { k = KLet (`Top, _) } :: bs -> bs (* CR jfuruse: probably we don't need it *)
-  | { k = (KStruct _ | KSig _) } :: _ -> bases
-  | _ :: bs -> unwind_top bs
-  | [] -> []
-
-open Planck.Lazylist (* for Cons and Null *)
-
-(* true means I found something to make the token a block *)
-let rec lparen_read_ahead lnum = function
-  | lazy Null _ -> false
-  | lazy Cons (i, _, _) when Region.lnum i.Tokenstr.region <> lnum -> false
-  | lazy Cons (i, _, str) ->
-      match i.Tokenstr.token with
-      | COMMENT _ -> lparen_read_ahead lnum str
-      | FUN -> false
-      | FUNCTION -> false
-      | _ -> true
-
-let lbrace_read_ahead lnum = function
-  | lazy Null _ -> false
-  | lazy Cons (i, _, _) when Region.lnum i.Tokenstr.region <> lnum -> false
-  | lazy Cons (i, _,str) ->
-      match i.Tokenstr.token with
-      | COMMENT _ -> lparen_read_ahead lnum str
-      | _ -> true
-
-let lbracket_read_ahead = lbrace_read_ahead
-
-let function_read_ahead = lbrace_read_ahead
-
-let token state str at_the_head region (t : Parser.token) : State.t * State.t =
-
-  (** Which line the token is in *)
-  let line = Region.lnum region in
-
-  (** Which column the token is at *)
-  let cols = Region.columns region in
-
-  (** The indent of the current line.
-      If the token is at the head of the line, it may be the original indent
-  *)
-  let indent = state.last_indent in
-
-  (** The original indent stack. You must update this. *)
-  let bases0 = state.bases in
-
-  (** Just change the indentation to [cols]. Useful at the line heads *)
-  let fix cols = [{ k = KNone; indent = cols }] in
-
-  (* A basic rule.
-
-     An effect of a token cannot exceed a token whose connectivity power is stronger.
-
-     CR jfuruse: I could encode this information into Stack.k's ordering.
-  *)
-
-  let pre_bases, post_bases = match t with
-    | SEMISEMI ->
-        (* unwind the top *)
-        let bases = unwind_top bases0 in
-        bases, bases
-
-    | OPEN ->
-        let bases = unwind_top bases0 in
-        bases,
-        { k = KOpen; indent = cols + 2; } :: bases
-
-    | MODULE ->
-        let bases = unwind_top bases0 in
-        bases,
-        { k = KModule cols; indent = cols + 2; } :: bases
-
-    | VAL ->
-        let bases = unwind_top bases0 in
-        bases,
-        { k = KVal; indent = cols + 2; } :: bases
-
-    | LET when is_top_let state.last_token ->
-        let bases = unwind_top bases0 in
-        bases,
-        { k = KLet (`Top, cols); indent = cols + 2; } :: bases
-
-    | LET ->
-        bases0, { k = KLet (`Local, cols); indent = cols + 2; } :: bases0
-
-    | EQUAL ->
-        (* CR jfuruse: TODO
-           - pre bases
-           - for non definition equals *)
-        let rec f bases = match bases with
-          (* Definition equal rolls things back to its head *)
-          | {k = (KLet (_, _cols) | KType _cols | KModule _cols) } :: _ ->
-              bases, bases
-          (* Equal can exceed the following *)
-          | { k = (KExpr _ | KNone) } :: bs -> f bs
-          (* Equal cannot exceed the other *)
-          | _ :: _bs -> bases0, bases0
-          | [] -> [], []
-        in
-        f bases0
-
-    | TYPE when state.last_token = Some MODULE -> (* module type *)
-        (* we might change the kind to KModuleType, but ... let's keep it simpler *)
-        bases0, bases0
-
-    | TYPE ->
-        let bases = unwind_top bases0 in
-        bases,
-        { k = KType cols; indent = cols + 2; } :: bases
-
-    | EXCEPTION ->
-        let bases = unwind_top bases0 in
-        bases,
-        { k = KException cols; indent = cols + 2; } :: bases
-
-    | AND ->
-        (* for let *)
-        (* recover the last let, type, module *)
-        let rec f bases = match bases with
-          | {k = (KLet (_,cols) | KType cols | KModule cols) } :: _ ->
-              fix cols, bases
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | IN ->
-        (* in must paired with let *)
-        let rec f bases = match bases with
-          | { k = KLet(_, cols) } :: bs ->
-              fix cols, bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | STRUCT ->
-        bases0, { k = KStruct indent; indent = indent + 2; } :: bases0
-
-    | SIG ->
-        bases0, { k = KSig indent; indent = indent + 2; } :: bases0
-
-    | BEGIN ->
-        bases0, { k = KBegin indent; indent = indent + 2; } :: bases0
-
-    | OBJECT ->
-        bases0, { k = KObject indent; indent = indent + 2; } :: bases0
-
-    | END ->
-        let rec f bases = match bases with
-          | { k = (KStruct cols | KSig cols | KBegin cols | KObject cols) } :: bs ->
-              fix cols, bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | MATCH ->
-        bases0,
-        if at_the_head then
-          { k = KMatch cols; indent = cols + 2; } :: bases0
-        else
-          (* bit special handling *)
-          let rec compute bases = match bases with
-            | [] -> indent
-            | { k = KLet (_, cols) } :: _ -> max (cols + 2) indent
-            | _ :: bs -> compute bs
-          in
-          { k = KMatch (compute bases0); indent = cols + 2; } :: bases0
-
-    | TRY ->
-        bases0,
-        if at_the_head then
-          { k = KTry cols; indent = cols + 2; } :: bases0
-        else
-          { k = KTry indent; indent = indent + 2; } :: bases0
-
-    | WITH ->
-        (* support for typeconv *)
-        let rec f bases = match bases with
-          | { k = KBrace cols } :: _ ->
-              fix (cols + 2), bases
-          | { k = (KType cols | KException cols | KMatch cols | KTry cols) } :: bs ->
-              fix cols,
-             { k = KWith cols; indent = cols + 2; } :: bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | IF ->
-        bases0, { k = KIf cols; indent = cols + 2; } :: bases0
-
-    | THEN ->
-        let rec f bases = match bases with
-          | { k = KIf cols } :: bs ->
-              fix cols,
-              { k = KThen cols; indent = cols + 2; } :: bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | ELSE ->
-        let rec f bases = match bases with
-          | { k = KThen cols } :: bs ->
-              fix cols,
-              { k = KElse cols; indent = cols + 2; } :: bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | WHILE ->
-        bases0, { k = KWhile indent; indent = cols + 2; } :: bases0
-
-    | DO ->
-        let rec f bases = match bases with
-          | { k = (KWhile cols ) } :: bs ->
-              { k = KDo cols; indent = cols; } :: bs, bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | DONE ->
-        let rec f bases = match bases with
-          | { k = (KDo cols ) } :: bs ->
-              fix cols, bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | LPAREN ->
-        if lparen_read_ahead line str then
-          bases0, { k = KParen cols; indent = cols + 2; } :: bases0
-        else
-          bases0, { k = KParen indent; indent = indent + 2; } :: bases0
-
-    | RPAREN ->
-        let rec f bases = match bases with
-          | { k = (KParen cols ) } :: bs ->
-              fix cols, bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | LBRACE ->
-        if lbrace_read_ahead line str then
-          bases0, { k = KBrace cols; indent = cols + 2; } :: bases0
-        else
-          bases0, { k = KBrace indent; indent = indent + 2; } :: bases0
-
-    | RBRACE ->
-        let rec f bases = match bases with
-          | { k = (KBrace cols ) } :: bs ->
-              fix cols, bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | LBRACKET ->
-        if lbracket_read_ahead line str then
-          bases0, { k = KBracket cols; indent = cols + 2; } :: bases0
-        else
-          bases0, { k = KBracket indent; indent = indent + 2; } :: bases0
-
-    | RBRACKET ->
-        let rec f bases = match bases with
-          | { k = (KBracket cols ) } :: bs ->
-              fix cols, bs
-          | [] -> [], []
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | FUNCTION ->
-        if function_read_ahead line str then
-          bases0,
-          { k = KFunction cols; indent = cols + 10 (* function+2 *); } :: bases0
-        else
-          bases0,
-          { k = KFunction indent; indent = indent + 4 (* "  | " *); } :: bases0
-
-    | FUN ->
-        bases0, { k = KFun indent; indent = indent + 2; } :: bases0
-
-    | BAR ->
-        let rec f bases = match bases with
-          | { k = ( KType cols
-                  | KFunction cols) } :: _ ->
-              fix (cols + 2), bases
-          | { k = ( KBracket cols
-                  | KWith cols
-                  | KParen cols) } :: _ ->
-              fix cols, bases
-          | [] -> bases0, bases0 (* if overrun, keep the original *)
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | MINUSGREATER ->
-        let rec f bases = match bases with
-          | { k = (KWith cols) } :: _ ->
-              fix (cols + 2),
-              { k = KCaseArrow; indent = cols + 4; } :: bases
-          | { k = (KFunction cols) } :: _ ->
-              fix (cols + 2),
-              { k = KCaseArrow; indent = cols + 6; } :: bases
-          | { k = (KFun cols) } :: _ ->
-              fix (cols + 2),
-              { k = KCaseArrow; indent = cols + 2; } :: bases
-          | [] -> bases0, bases0 (* if overrun, keep the original *)
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | COMMA ->
-        let rec f bases = match bases with
-          | { k = ( KBegin cols
-                  | KBracket cols
-                  | KBrace cols
-                  | KLet (_, cols) ) } :: _ ->
-              fix (cols + 2), bases
-          | { k = ( KParen cols ) } :: _ ->
-              fix cols, bases
-          (* comma cannot exceeds them (comma is stronger than them) *)
-          | { k = (KThen _ | KElse _ | KWith _ | KFunction _ | KFun _ | KMatch _ | KTry _ | KCaseArrow ) } :: _ ->
-              bases0, bases
-          | [] -> bases0, bases0 (* if overrun, keep the original *)
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | SEMI ->
-        let rec f bases = match bases with
-          | { k = (KParen cols | KBegin cols | KBracket cols | KBrace cols | KLet (_, cols)) | KTry cols | KMatch cols | KFun cols | KFunction cols } :: _ ->
-              fix cols, bases
-          | { k = KCaseArrow } :: _ -> bases, bases
-          | { k = (KThen cols | KElse cols ) } :: bs ->
-              fix cols, bs
-          | [] -> bases0, bases0 (* if overrun, keep the original *)
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | INT64 _ | INT32 _ | INT _ | LIDENT _ | UIDENT _ | FLOAT _| CHAR _ | STRING _ | TRUE | FALSE ->
-        let rec f bases = match bases with
-          | { k = KExpr _ } :: _ -> bases0, bases0
-          | [] -> bases0, { k = KExpr cols; indent = cols + 2; } :: bases0
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | STAR | PLUSDOT | PLUS | MINUSDOT | MINUS
-    | INFIXOP4 _ | INFIXOP3 _ | INFIXOP2 _ | INFIXOP1 _ | INFIXOP0 _
-    | LESS | GREATER | AMPERSAND | AMPERAMPER
-      ->
-        let rec f bases = match bases with
-          | { k = KExpr cols } :: _ ->
-              { k = KNone; indent = cols } :: bases0, bases0
-          | [] -> bases0, bases0
-          | _ :: bs -> f bs
-        in
-        f bases0
-
-    | COMMENT _ ->
-        (* Comments are tricky. It is:
-
-           - sometimes affected by the previous line's indentation
-           - sometimes affected by the next line's indentation
-           - sometimes independent
-        *)
-        fix cols, bases0
-
-    |PREFIXOP _|OPTLABEL _|NATIVEINT _|LABEL _
-    |WHEN|VIRTUAL|UNDERSCORE|TO|TILDE|
-          SHARP|REC|QUOTE|QUESTIONQUESTION|QUESTION|
-          PRIVATE|OR|OF|NEW|MUTABLE|METHOD
-          |LESSMINUS|LBRACKETGREATER|LBRACKETLESS|LBRACKETBAR|
-          LBRACELESS|LAZY|INITIALIZER|INHERIT|INCLUDE|GREATERRBRACKET|
-          GREATERRBRACE|FUNCTOR|FOR|EXTERNAL|EOF|
-          DOWNTO|DOTDOT|DOT|CONSTRAINT|COLONGREATER|COLONEQUAL|
-          COLONCOLON|COLON|CLASS|BARRBRACKET|BARBAR|BANG|BACKQUOTE|ASSERT|AS
-          -> bases0, bases0
-  in
-  { state with bases = pre_bases },
-  { state with bases = post_bases }
-
-let update_state state ~at_new_line ~fix_indent str orig_region t =
-
-  (* If it is a new line + we need to fix the indent of the line, compute the line's indentation.
-     Otherwise, we use the original state.
-  *)
-  let state' =
-    if fix_indent && at_new_line then
-      let pre, _ = token state str at_new_line orig_region t in
-      { pre with last_indent = State.indent pre }
-    else
-      state
-  in
-
-  (* Fix the indentation. It may be updated by the previous call of [token]. *)
-  let fixed_region =
-    (* CR jfuruse: Spaghetti... *)
-    if fix_indent then Region.move_chars (state'.last_indent - state.orig_indent) orig_region else orig_region
-  in
-  let state = { state
-                with
-                last_indent = state'.last_indent
-                ; modified = state'.modified || orig_region <> fixed_region
-              }
-  in
-
-  (* Rerun [token] *)
-  token state str at_new_line fixed_region t
-*)
 open Pos
+open Args
 module State = Machine.State
 module Stack = Machine.Stack
 
 module Sexp = Sexplib.Sexp (* No open Sexplib, since Parser corrides with Sexplib.Parser *)
 
+module Parser = Xparser
+
+(** [l] is in the interested area or not? *)
+let check_line l = function
+  | None -> `Inside
+  | Some (start, end_) ->
+      if l < start then `Before
+      else if l <= end_ then `Inside
+      else `Over
+
 module Printer : sig
-  val print_debug  : Lines.t -> int-> string -> unit
-  val print_string : Lines.t -> int -> string -> unit
+  type t = (int * int) option
+  val print_debug  : t -> int-> string -> unit
+  val print_string : t -> int -> string -> unit
 end = struct
 
-  let print_debug t lnum s = match Lines.is_between lnum t with
+  type t = (int * int) option
+
+  let print_debug t lnum s = match check_line lnum t with
     | `Before | `Over -> ()
     | `Inside -> print_string s
 
       different number of lines from the original.
   *)
   let print_string t lnum s =
-    let add_line t lnum s = match Lines.is_between lnum t with
+    let add_line t lnum s = match check_line lnum t with
       | `Before -> ()
       | `Over -> raise Exit
       | `Inside -> print_string s
 end
 
 open Tokenstr
-open Planck.Lazylist
 
-let indent_file path =
-  let print_string = Printer.print_string Args.lines in
-  let print_debug  = Printer.print_debug  Args.lines in
+let with_open_in_or_stdin path f = 
+  match path with
+  | None -> f stdin
+  | Some path ->
+      let ic = open_in path in
+      let res = try `Ok (f ic) with e -> `Error e in
+      close_in ic;
+      match res with
+      | `Ok v -> v
+      | `Error e -> raise e
 
-  let tkstr = if path = "" then Tokenstr.of_channel stdin else Tokenstr.of_path path in
-  let stream = stream tkstr in
+let indent_ic ic =
+  let print_string = Printer.print_string lines in
+  let print_debug = Printer.print_debug lines in
+
+  let str = Tokenstr.of_channel ic in
 
   let flush_remaining_space info =
     print_string (Region.lnum (fst info.space)) (snd info.space)
   in
 
-  let rec loop last_orig_region state = function
-    | lazy Null _ -> state
+  let rec loop last_orig_region state str = match LazyList.peek str with
+    | None -> state
 
-    | lazy Cons (({ token = Parser.EOF } as info), _, _) ->
+    | Some (({ token = Parser.EOF } as info), _) ->
         flush_remaining_space info;
         state
 
-    | lazy Cons (({ token = t;
-                    region = orig_region;
-                    space = (_space_between_region, space_between);
-                    substr } as info), 
-                 _, str) ->
+    | Some (({ token = t;
+               region = orig_region;
+               space = (_space_between_region, space_between);
+               substr } as info), str) ->
 
-        match Lines.is_between (Region.lnum orig_region) Args.lines with
+        match check_line (Region.lnum orig_region) lines with
         | `Over ->
             (* The token is outside of our interest.
                Print the remaining things and go out *)
               else state
             in
 
-            (* Where the cursor move *)
-            let _cursor_info = match Args.cursor with
-              | None -> None
-              | Some lines_cols ->
-                  match
-                    Region.contain_lines_cols last_orig_region lines_cols,
-                    Region.contain_lines_cols orig_region lines_cols
-                  with
-                  | (`In | `Right), _ -> None                   (* far past *)
-                  | `Left, `Right     -> None                   (* far future *)
-                  | `Left, `Left      -> Some `In_space_between (* cursor in the space_between *)
-                  | `Left, `In        -> Some `In_the_token     (* cursor on the token *)
-                  | _                 -> assert false           (* It must be more tolerant, but for now... *)
-            in
-
             let fix_indent = match line_status with
               | `Inside -> true
               | `Before -> false
 
             let pre, post = Machine.update_state state ~at_new_line ~fix_indent str orig_region t in
 
+            (* cursor *)
+            (* if [fix_indent], and the cursor is on the line, the cursor pos may move *)
+            (* Where the cursor move *)
+(*
+            if fix_indent then begin
+              let cursor_info = match cursor with
+                | None -> None
+                | Some lines_cols ->
+                    match
+                      Region.contains_lines_cols last_orig_region lines_cols,
+                      Region.contains_lines_cols orig_region lines_cols
+                    with
+                    | (`In | `Out_left), _   -> None                   (* far past *)
+                    | `Out_right, `Out_right -> None                   (* far future *)
+                    | `Out_right, `Out_left  -> Some `In_space_between (* cursor in the space_between *)
+                    | `Out_right, `In        -> Some `In_the_token     (* cursor on the token *)
+                    | _                      -> assert false           (* It must be more tolerant, but for now... *)
+              in
+            end;
+*)
+
             (* printing *)
 
             if not at_new_line then print_string current_line space_between
               (* CR jfuruse: can be a bug. something from space_between_region *)
               print_string last_line spaces;
 
-              if Args.debug then begin
+              if debug then begin
                 print_string current_line indent_string;
                 if pre == post then
                   print_debug current_line
 
             loop orig_region post str
   in
-  let final_state = loop Region.zero State.init stream in
-  if Args.showstate then State.print final_state;
-  Tokenstr.close tkstr
+  let final_state = loop Region.zero State.init str in
+  if showstate then State.print final_state
 
-let () = List.iter indent_file Args.paths
+let indent_file path = with_open_in_or_stdin (if path = "" then None else Some path) indent_ic
+
+let _ = List.iter indent_file paths

opam/ocaml-indent.1.1.0/descr

 The indentation tries to follow my style as possible. Neither the
 official one (does it exists?) or something already available
 (i.e. ocaml-mode/tuareg).
-

opam/ocaml-indent.1.1.0/opam

 build: [
   ["ocaml" "setup.ml" "-configure" "--prefix" "%{prefix}%"]
   ["ocaml" "setup.ml" "-build"]
-  ["env" "PREFIX=%{prefix}%" "ocaml" "setup.ml" "-install"]
+  ["ocaml" "setup.ml" "-install"]
 ]
 remove: [
-  ["env" "PREFIX=%{prefix}%" "omake" "uninstall"]
+  ["ocaml" "setup.ml" "-uninstall"]
 ]
 depends: [ "ocamlfind" "sexplib" "omake" ]
 ocaml-version: [>= "4.00.0"]

opam/ocaml-indent.1.1.0/url

 archive: "https://bitbucket.org/camlspotter/ocaml-indent/get/1.1.0.tar.gz"
-checksum: "49a7938f913f9d30c75801b9be42295c"
+OCaml-indent: OCaml source code indenter
+OCaml-indent is an OCaml source code indenter. 
+
+* Lexer based, simple, easy to maintain, robust against P4 extensions.
+
+* It simply indents OCaml source code with a CLI like: ./ocaml-indent foo.ml 
+
+* Editors should communicate with the CLI. An Emacs interface, 
+  ocaml-indent.el is currently available.
+
+* Just fixes indentations. No other code beautifier included.
+
+The indentation tries to follow my style as possible. Neither the
+official one (does it exists?) or something already available
+(i.e. ocaml-mode/tuareg).
+depends: [ "ocamlfind" "sexplib" "omake" ]
+ocaml-version: [>= "4.00.0"]
-open Spotlib.Spot
-
 module Position = struct
   open Sexplib.Conv
 
     pos_cnum : int;
   } with sexp
 
-  let show t = 
+  let to_string t = 
     Printf.sprintf "%s%d:%d" 
       (if t.pos_fname = "" then "" else t.pos_fname ^ ":")
       t.pos_lnum 
       (t.pos_cnum - t.pos_bol)
 
-  let format ppf t = Format.fprintf ppf "%s" & show t
+(*
+  let zero = { pos_fname = "";
+               pos_lnum = 1;
+               pos_bol = 0;
+               pos_cnum = 0 }
+*)
 
-  let top fname = { pos_fname = fname;
-                    pos_lnum = 1;
-                    pos_bol = 0;
-                    pos_cnum = 0 }
-
-  let none = Lexing.dummy_pos
+  let zero = { pos_fname = "";
+               pos_lnum = 0;
+               pos_bol = 0;
+               pos_cnum = 0 }
 
   let columns p = p.pos_cnum - p.pos_bol
 
   type t = Position.t * Position.t with sexp
   let lnum (p,_) = p.pos_lnum
   let columns (p,_) = columns p
-  let top fname = let p = Position.top fname in p, p
-  let none = (Position.none, Position.none)
+  let zero = (Position.zero, Position.zero)
   let move_chars diff (p,p') = 
     { p  with pos_cnum = p .pos_cnum + diff },
     { p' with pos_cnum = p'.pos_cnum + diff } 
 
-  let show (p1,p2) = Printf.sprintf "%s-%s" (Position.show p1) (Position.show p2)
-  let format ppf = Format.string ppf @@ show
-
-  let contain (start, end_) pos = 
+  let contains (start, end_) pos = 
     match Position.compare start pos, Position.compare pos end_ with
     | (-1 | 0), (-1 | 0) -> `In
     | _, 1 -> `Out_right
     | -1, _ -> `Out_left
     | _ -> assert false
 
-  let contain_lines_cols (start, end_) l_c = 
+  let contains_lines_cols (start, end_) l_c = 
     match Position.compare_lines_cols start l_c, Position.compare_lines_cols end_ l_c with
     | (-1 | 0), (1 | 0) -> `In
-    | _, -1 -> `Out_right
+    | _, 1 -> `Out_right
     | -1, _ -> `Out_left
-    | _ -> assert false
+    | x,y -> Format.eprintf "ERROR: Pos.contain_lines_cols: %d %d@." x y; assert false
 end
-
-module Lines = struct
-  type t = WholeFile | Lines of int * int
-
-  (** [l] is in the interested area or not? *)
-  let is_between : int -> t -> [> `Before | `Inside | `Over ] = 
-    fun l -> function
-      | WholeFile -> `Inside
-      | Lines (start, end_) ->
-          if l < start then `Before
-          else if l <= end_ then `Inside
-          else `Over
-end
+module Position : sig
+  type t = Lexing.position = {
+    pos_fname : string;
+    pos_lnum : int;
+    pos_bol : int;
+    pos_cnum : int;
+  } with sexp
+
+  val to_string : t -> string
+  val zero : t
+  val columns : t -> int
+  val compare : t -> t -> int
+  val compare_lines_cols : t -> int * int -> int
+end
+
+module Region : sig
+  type t = Position.t * Position.t with sexp
+  
+  val lnum : Position.t * 'a -> int
+  val columns : Position.t * 'a -> int
+  val zero : t
+  val move_chars : int -> t -> t
+  val contains : t -> Position.t -> [> `In | `Out_left | `Out_right ]
+  val contains_lines_cols : t -> int * int -> [> `In | `Out_left | `Out_right ]
+end
   let substring_of_region t (p1, p2) = 
     substring t p1.Position.pos_cnum (p2.Position.pos_cnum - p1.Position.pos_cnum)
 
-  let forget_before t pos =
+  let _forget_before t pos =
     assert (t.pos <= pos);
     let removing = pos - t.pos in
     if removing = 0 then ()
   val current_substring : t -> string
   val region : t -> Region.t
 end = struct
-  (* CR jfuruse: we should set lexer file name *)
+  (* open Lexbuf *)
 
   type t = Lexbuf.t * Lexing.lexbuf
 
   let region (_, lexbuf) = lexbuf.Lexing.lex_start_p, lexbuf.Lexing.lex_curr_p
 end
 
+include LexReader
+(** This module provides the same functionality of [Lexing.from_function] 
+    but the actual substring can be retrievable from the obtained tokens.
+*)
+
+type t (** The reader type *)
+
+val create_from_channel : in_channel -> t
+(** Creation from [in_channel] *)
+
+val lex : t -> (Lexing.lexbuf -> 'a) -> 'a
+(** Run a lexing function once over the reader *)
+
+val substring : t -> int -> int -> string
+(** [substring t pos len] returns the substring of [t] *)
+
+val substring_of_region : t -> Pos.Region.t -> string
+(** Same as [substring] but by [Pos.Region.t] *)
+
+val region : t -> Pos.Region.t
+(** Returns the reader's internal lexbuf's current region. *)
+
+val current_substring : t -> string
+(** Returns the reader's internal lexbuf's current region's substring. *)
+
+(* setup.ml generated for the first time by OASIS v0.3.0 *)
+
+(* OASIS_START *)
+(* DO NOT EDIT (digest: 148571aea88c87319af99a9f0c50758b) *)
+(*
+   Regenerated by OASIS v0.3.0
+   Visit http://oasis.forge.ocamlcore.org for more information and
+   documentation about functions used in this file.
+*)
+module OASISGettext = struct
+(* # 21 "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 OASISContext = struct
+(* # 21 "src/oasis/OASISContext.ml" *)
+
+  open OASISGettext
+
+  type level =
+    [ `Debug
+    | `Info
+    | `Warning
+    | `Error]
+
+  type t =
+    {
+      quiet:                 bool;
+      info:                  bool;
+      debug:                 bool;
+      ignore_plugins:        bool;
+      ignore_unknown_fields: bool;
+      printf:                level -> string -> unit;
+    }
+
+  let printf lvl str =
+    let beg =
+      match lvl with
+        | `Error -> s_ "E: "
+        | `Warning -> s_ "W: "
+        | `Info  -> s_ "I: "
+        | `Debug -> s_ "D: "
+    in
+      prerr_endline (beg^str)
+
+  let default =
+    ref
+      {
+        quiet                 = false;
+        info                  = false;
+        debug                 = false;
+        ignore_plugins        = false;
+        ignore_unknown_fields = false;
+        printf                = printf;
+      }
+
+  let quiet =
+    {!default with quiet = true}
+
+
+  let args () =
+    ["-quiet",
+     Arg.Unit (fun () -> default := {!default with quiet = true}),
+     (s_ " Run quietly");
+
+     "-info",
+     Arg.Unit (fun () -> default := {!default with info = true}),
+     (s_ " Display information message");
+
+
+     "-debug",
+     Arg.Unit (fun () -> default := {!default with debug = true}),
+     (s_ " Output debug message")]
+end
+
+module OASISString = struct
+(* # 1 "src/oasis/OASISString.ml" *)
+
+
+
+  (** Various string utilities.
+     
+      Mostly inspired by extlib and batteries ExtString and BatString libraries.
+
+      @author Sylvain Le Gall
+    *)
+
+  let nsplitf str f =
+    if str = "" then
+      []
+    else
+      let buf = Buffer.create 13 in
+      let lst = ref [] in
+      let push () =
+        lst := Buffer.contents buf :: !lst;
+        Buffer.clear buf
+      in
+      let str_len = String.length str in
+        for i = 0 to str_len - 1 do
+          if f str.[i] then
+            push ()
+          else
+            Buffer.add_char buf str.[i]
+        done;
+        push ();
+        List.rev !lst
+
+  (** [nsplit c s] Split the string [s] at char [c]. It doesn't include the
+      separator.
+    *)
+  let nsplit str c =
+    nsplitf str ((=) c)
+
+  let find ~what ?(offset=0) str =
+    let what_idx = ref 0 in
+    let str_idx = ref offset in 
+      while !str_idx < String.length str && 
+            !what_idx < String.length what do
+        if str.[!str_idx] = what.[!what_idx] then
+          incr what_idx
+        else
+          what_idx := 0;
+        incr str_idx
+      done;
+      if !what_idx <> String.length what then
+        raise Not_found