packages feed

cpphs 1.11 → 1.12

raw patch · 126 files changed

+31/−4589 lines, 126 filesdep +directorydep +old-localedep +old-timedep −haskell98dep ~basePVP ok

version bump matches the API change (PVP)

Dependencies added: directory, old-locale, old-time

Dependencies removed: haskell98

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

− CHANGELOG 
@@ -1,159 +0,0 @@-Version 1.11--------------  * API change: runCpphs, cppIfdef, and macroPass are now in the IO monad.--Version 1.10-------------  * New command-line option: "--linepragma"-    It converts #line droppings into {-# LINE #-}.--Version 1.9-------------  * Bugfix for #undef.--Version 1.8-------------  * Bugfix for off-by-one error in line numbers with --include=file.--Version 1.7-------------  * Bugfix in interaction of --unlit with \end{code}--Version 1.6-------------  * New command-line option: "--include=filename".-  * New command-line option: "--strip-eol" for comment-stripping.-  * Line pragmas can have filenames containing spaces.--Version 1.5-------------  * Parametrised macro-calls now permitted in #ifdef's.-  * Recursive textual expansion now permitted in #ifdef's.-  * Better options-handling when used as a library.-  * Various small bugfixes--Version 1.4-------------  * Added a "--pragma" option to retain #pragma in the output.-  * Fixed a number of obscure corner cases involving the interaction of-    multiple features e.g. foo##__LINE__.-  * Added the "--nowarn" option.--Version 1.3-------------  * Added a "--cpp" option for drop-in compatibility with standard cpp.-    It causes cpphs to accept standard cpp flags and translate-    them to cpphs equivalents.  Compatibility options include: -o, -ansi,-    -traditional, -stdc, -x, -include, -P, -C, -CC, -A.  The file-    behaviour is different too - if two filenames are given on the-    commandline, then the second is treated as the output location.-  * Fixed a corner-case bug in evaluating chained and overlapping #ifdefs.--Version 1.2-------------  * Re-arranged the source files into hierarchical libraries.-  * Exposed the library interface as an installable Cabal package, with-    Haddock documentation.-  * Added the --unlit option, for removing literate-style comments.--Version 1.1-------------  * Fix the .cabal way of building cpphs.-  * Update the --version reported (forgotten in 1.0, which still reports 0.9)-  * No longer throws an error when given an empty file as input.--Version 1.0-------------  * Add a compatibility script cpphs.compat, allowing cpphs to act as-    a drop-in replacement for cpp, e.g.-        ghc -cpp -pgmP cpphs.compat-  * Place quotes around replacements for special macros __FILE__, __DATE__,-    and __TIME__.-  * If no files are specified, read from stdin.-  * Ignore #! lines (e.g. in scripts)-  * Parse -D commandline options once only, and consistently with cpp,-    i.e. -Dfoo means foo=1-  * Fix compatibility with preprocessors like hsc2hs, which use-    non-cpp directives like #def.  They are now passed through to the-    output with a warning to stderr.--Version 0.9-------------  * Bugfix for ghc-6.4 -O: flush the output buffer.--Version 0.8-------------  * Added the --text option, to signify the input should not-    be lexed as Haskell.  This causes macros to be defined or expanded-    regardless of their location within comments, string delimiters, etc.-  * Shuffle a few files around to make it easier to say 'hmake cpphs'.-    There is also now a runhugs script to invoke cpphs nicely.--Version 0.7-------------  * Enable the __FILE__, __LINE__, __DATE__, and __TIME__ specials, which-    can be useful for creating DIY error messages.--Version 0.6-------------  * Recognise and ignore the #pragma cpp directive.-  * Fix beginning-of-file bug, where in --noline mode, a # cpp directive-    at the top of the file appeared in the output.-  * Fix chained parenthesised boolean exprs in #if, e.g.-        #if ( foo ) && ( bar )-  * Fix precedence in chained unparenthesised boolean exprs in #if, e.g.-        #if foo && bar || baz && frob-  * For better compatibility with cpp, and because otherwise-    there are certain constructs that cannot be expressed, we no-    longer permit whitespace in a <tt>#define</tt> between the-    symbolname and an opening parenthesis, e.g.-        #define f (f' id)-    Previously, this was interpreted as a parametrised macro,-    with arguments in the parens, and no expansion.  Now, the space-    indicates that this is a textual replacement, and the parenthesised-    expression is in fact the replacement.--Version 0.5-------------  * Added a --version flag to report the version number.-  * Renamed --stringise to --hashes, and use it to turn on ## catenation-    as well.-  * Bugfix for #if 1, previously taken as false.-  * Bugfix for --nolines: it no longer adds extra spurious newlines.-  * File inclusion now looks in the directory of the calling file.-  * Failure to find an include file is now merely a warning to stderr-    rather than an error.-  * Added a --layout flag.  Previously, line continuations in a macro-    definition were always preserved in the output, permitting use-    of the Haskell layout rule even inside a macro.  The default is now-    to remove line continuations for conformance with cpp, but the option-    of using --layout is still possible.--Version 0.4-------------  * New flag -Ofile to redirect output-  * Bugfix for precedence in   #if !False && False-  * Bugfix for whitespace between # and if-  * Bugfix for #define F "blah"; #include F--Version 0.3-------------  * Bugfix for recursive macro expansion.-  * New flag --strip to remove C comments even outside cpp directives.-  * New flag --stringise to recognise the # stringise operator in macros.--Version 0.2-------------  * New flag --noline to eliminate #line directives from output.-  * Add symbol-replacement and macro-expansion.-  * New flag --nomacro to turn off symbol/macro-expansion.--2004-Apr-21-------------  * Now accept multi-line # commands via the \ line continuation operator.-    The original file line numbering is preserved in the output by-    some tricky acrobatics.--Version 0.1-------------  * Initial release.
− LICENCE-GPL 
@@ -1,342 +0,0 @@-		    GNU GENERAL PUBLIC LICENSE-		       Version 2, June 1991-- Copyright (C) 1989, 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.--			    Preamble--  The licenses for most software are designed to take away your-freedom to share and change it.  By contrast, the GNU General Public-License is intended to guarantee your freedom to share and change free-software--to make sure the software is free for all its users.  This-General Public License applies to most of the Free Software-Foundation's software and to any other program whose authors commit to-using it.  (Some other Free Software Foundation software is covered by-the GNU Library General Public License instead.)  You can apply it to-your programs, 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 software, or if you modify it.--  For example, if you distribute copies of such a program, whether-gratis or for a fee, you must give the recipients all the rights that-you have.  You must make sure that they, too, receive or can get the-source code.  And you must show them these terms so they know their-rights.--  We protect your rights with two steps: (1) copyright the software, and-(2) offer you this license which gives you legal permission to copy,-distribute and/or modify the software.--  Also, for each author's protection and ours, we want to make certain-that everyone understands that there is no warranty for this free-software.  If the software is modified by someone else and passed on, we-want its recipients to know that what they have is not the original, 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 redistributors of a free-program will individually obtain patent licenses, in effect making the-program proprietary.  To prevent this, we have made it clear that any-patent must be licensed for everyone's free use or not licensed at all.--  The precise terms and conditions for copying, distribution and-modification follow.---		    GNU GENERAL PUBLIC LICENSE-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION--  0. This License applies to any program or other work which contains-a notice placed by the copyright holder saying it may be distributed-under the terms of this General Public License.  The "Program", below,-refers to any such program or work, and a "work based on the Program"-means either the Program or any derivative work under copyright law:-that is to say, a work containing the Program or a portion of it,-either verbatim or with modifications and/or translated into another-language.  (Hereinafter, translation is included without limitation in-the term "modification".)  Each licensee is addressed as "you".--Activities other than copying, distribution and modification are not-covered by this License; they are outside its scope.  The act of-running the Program is not restricted, and the output from the Program-is covered only if its contents constitute a work based on the-Program (independent of having been made by running the Program).-Whether that is true depends on what the Program does.--  1. You may copy and distribute verbatim copies of the Program's-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 give any other recipients of the Program a copy of this License-along with the Program.--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 Program or any portion-of it, thus forming a work based on the Program, 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) You must cause the modified files to carry prominent notices-    stating that you changed the files and the date of any change.--    b) You must cause any work that you distribute or publish, that in-    whole or in part contains or is derived from the Program or any-    part thereof, to be licensed as a whole at no charge to all third-    parties under the terms of this License.--    c) If the modified program normally reads commands interactively-    when run, you must cause it, when started running for such-    interactive use in the most ordinary way, to print or display an-    announcement including an appropriate copyright notice and a-    notice that there is no warranty (or else, saying that you provide-    a warranty) and that users may redistribute the program under-    these conditions, and telling the user how to view a copy of this-    License.  (Exception: if the Program itself is interactive but-    does not normally print such an announcement, your work based on-    the Program is not required to print an announcement.)--These requirements apply to the modified work as a whole.  If-identifiable sections of that work are not derived from the Program,-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 Program, 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 Program.--In addition, mere aggregation of another work not based on the Program-with the Program (or with a work based on the Program) on a volume of-a storage or distribution medium does not bring the other work under-the scope of this License.--  3. You may copy and distribute the Program (or a work based on it,-under Section 2) in object code or executable form under the terms of-Sections 1 and 2 above provided that you also do one of the following:--    a) 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; or,--    b) Accompany it with a written offer, valid for at least three-    years, to give any third party, for a charge no more than your-    cost of physically performing source distribution, a complete-    machine-readable copy of the corresponding source code, to be-    distributed under the terms of Sections 1 and 2 above on a medium-    customarily used for software interchange; or,--    c) Accompany it with the information you received as to the offer-    to distribute corresponding source code.  (This alternative is-    allowed only for noncommercial distribution and only if you-    received the program in object code or executable form with such-    an offer, in accord with Subsection b above.)--The source code for a work means the preferred form of the work for-making modifications to it.  For an executable work, 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 executable.  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.--If distribution of executable or 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 counts as-distribution of the source code, even though third parties are not-compelled to copy the source along with the object code.--  4. You may not copy, modify, sublicense, or distribute the Program-except as expressly provided under this License.  Any attempt-otherwise to copy, modify, sublicense or distribute the Program 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.--  5. 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 Program or its derivative works.  These actions are-prohibited by law if you do not accept this License.  Therefore, by-modifying or distributing the Program (or any work based on the-Program), you indicate your acceptance of this License to do so, and-all its terms and conditions for copying, distributing or modifying-the Program or works based on it.--  6. Each time you redistribute the Program (or any work based on the-Program), the recipient automatically receives a license from the-original licensor to copy, distribute or modify the Program 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.--  7. 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 Program at all.  For example, if a patent-license would not permit royalty-free redistribution of the Program 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 Program.--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.--  8. If the distribution and/or use of the Program is restricted in-certain countries either by patents or by copyrighted interfaces, the-original copyright holder who places the Program 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.--  9. The Free Software Foundation may publish revised and/or new versions-of the 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 Program-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 Program does not specify a version number of-this License, you may choose any version ever published by the Free Software-Foundation.--  10. If you wish to incorporate parts of the Program into other free-programs whose distribution conditions are different, 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--  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES-PROVIDE THE PROGRAM "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 PROGRAM IS WITH YOU.  SHOULD THE-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,-REPAIR OR CORRECTION.--  12. 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 PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER-PROGRAMS), 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 Programs--  If you develop a new program, and you want it to be of the greatest-possible use to the public, the best way to achieve this is to make it-free software which everyone can redistribute and change under these terms.--  To do so, attach the following notices to the program.  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 program's name and a brief idea of what it does.>-    Copyright (C) <year>  <name of author>--    This program is free software; you can redistribute it and/or modify-    it under the terms of the GNU General Public License as published by-    the Free Software Foundation; either version 2 of the License, or-    (at your option) any later version.--    This program 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 General Public License for more details.--    You should have received a copy of the GNU General Public License-    along with this program; 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.--If the program is interactive, make it output a short notice like this-when it starts in an interactive mode:--    Gnomovision version 69, Copyright (C) year name of author-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.-    This is free software, and you are welcome to redistribute it-    under certain conditions; type `show c' for details.--The hypothetical commands `show w' and `show c' should show the appropriate-parts of the General Public License.  Of course, the commands you use may-be called something other than `show w' and `show c'; they could even be-mouse-clicks or menu items--whatever suits your program.--You should also get your employer (if you work as a programmer) or your-school, if any, to sign a "copyright disclaimer" for the program, if-necessary.  Here is a sample; alter the names:--  Yoyodyne, Inc., hereby disclaims all copyright interest in the program-  `Gnomovision' (which makes passes at compilers) written by James Hacker.--  <signature of Ty Coon>, 1 April 1989-  Ty Coon, President of Vice--This General Public License does not permit incorporating your program into-proprietary programs.  If your program is a subroutine library, you may-consider it more useful to permit linking proprietary applications with the-library.  If this is what you want to do, use the GNU Library General-Public License instead of this License.
LICENCE-LGPL view
@@ -2,7 +2,7 @@                        Version 2.1, February 1999   Copyright (C) 1991, 1999 Free Software Foundation, Inc.-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA+     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA  Everyone is permitted to copy and distribute verbatim copies  of this license document, but changing it is not allowed.
Language/Preprocessor/Cpphs/CppIfdef.hs view
@@ -28,10 +28,10 @@ import Language.Preprocessor.Cpphs.HashDefine(HashDefine(..),parseHashDefine                                              ,expandMacro) import Language.Preprocessor.Cpphs.MacroPass (preDefine,defineMacro)-import Char      (isDigit)+import Data.Char      (isDigit) import Numeric   (readHex,readOct,readDec) import System.IO.Unsafe (unsafeInterleaveIO)-import IO        (hPutStrLn,stderr)+import System.IO        (hPutStrLn,stderr)   -- | Run a first pass of cpp, evaluating \#ifdef's and processing \#include's,
Language/Preprocessor/Cpphs/HashDefine.hs view
@@ -18,8 +18,8 @@   , parseHashDefine   ) where -import Char (isSpace)-import List (intersperse)+import Data.Char (isSpace)+import Data.List (intersperse)  data HashDefine 	= LineDrop
Language/Preprocessor/Cpphs/MacroPass.hs view
@@ -27,8 +27,8 @@ import Language.Preprocessor.Cpphs.Options    (BoolOptions(..)) import System.IO.Unsafe (unsafeInterleaveIO) import Control.Monad    ((=<<))-import Time       (getClockTime, toCalendarTime, formatCalendarTime)-import Locale     (defaultTimeLocale)+import System.Time       (getClockTime, toCalendarTime, formatCalendarTime)+import System.Locale     (defaultTimeLocale)  noPos :: Posn noPos = newfile "preDefined"
Language/Preprocessor/Cpphs/Options.hs view
@@ -19,8 +19,8 @@   , defaultBoolOptions   ) where -import Maybe-import List (isPrefixOf)+import Data.Maybe+import Data.List (isPrefixOf)  -- | Cpphs options structure. data CpphsOptions = CpphsOptions
Language/Preprocessor/Cpphs/Position.hs view
@@ -19,7 +19,7 @@   , filename, lineno, directory   ) where -import List (isPrefixOf)+import Data.List (isPrefixOf)  -- | Source positions contain a filename, line, column, and an --   inclusion point, which is itself another source position,
Language/Preprocessor/Cpphs/ReadFirst.hs view
@@ -15,10 +15,10 @@   ( readFirst   ) where -import IO        (hPutStrLn, stderr)-import Directory (doesFileExist)-import List      (intersperse)-import Monad     (when)+import System.IO        (hPutStrLn, stderr)+import System.Directory (doesFileExist)+import Data.List      (intersperse)+import Control.Monad     (when) import Language.Preprocessor.Cpphs.Position  (Posn,directory)  -- | Attempt to read the given file from any location within the search path.
Language/Preprocessor/Cpphs/Tokenise.hs view
@@ -22,7 +22,7 @@   , parseMacroCall   ) where -import Char+import Data.Char import Language.Preprocessor.Cpphs.HashDefine import Language.Preprocessor.Cpphs.Position
Language/Preprocessor/Unlit.hs view
@@ -2,8 +2,8 @@ --   version 1.2, appendix C. module Language.Preprocessor.Unlit (unlit) where -import Char-import List (isPrefixOf)+import Data.Char+import Data.List (isPrefixOf)  data Classified = Program String | Blank | Comment                 | Include Int String | Pre String
− Makefile 
@@ -1,56 +0,0 @@-LIBRARY = cpphs-VERSION = 1.11--DIRS	= Language/Preprocessor/Cpphs \-	  Text/ParserCombinators--SRCS	= Language/Preprocessor/Cpphs.hs \-          Language/Preprocessor/Cpphs/CppIfdef.hs \-          Language/Preprocessor/Cpphs/HashDefine.hs \-          Language/Preprocessor/Cpphs/MacroPass.hs \-          Language/Preprocessor/Cpphs/Options.hs \-          Language/Preprocessor/Cpphs/Position.hs \-          Language/Preprocessor/Cpphs/ReadFirst.hs \-          Language/Preprocessor/Cpphs/RunCpphs.hs \-          Language/Preprocessor/Cpphs/SymTab.hs \-          Language/Preprocessor/Cpphs/Tokenise.hs \-          Language/Preprocessor/Unlit.hs \-          Text/ParserCombinators/HuttonMeijer.hs \-          cpphs.hs--AUX	= README LICENCE* CHANGELOG $(LIBRARY).cabal Setup.hs Makefile \-	  cpphs.hugs cpphs.compat \-	  tests/[A-BD-Z]* tests/[a-np-z]* \-	  docs/[a-z]*--HC	= ghc-HFLAGS	=-HEAP	=-HOSTSTRIP = strip--all: $(LIBRARY)-package:-	tar cf tmp.tar $(SRCS) $(AUX)-	mkdir $(LIBRARY)-$(VERSION)-	cd $(LIBRARY)-$(VERSION); tar xf ../tmp.tar-	tar zcf $(LIBRARY)-$(VERSION).tar.gz $(LIBRARY)-$(VERSION)-	zip -r $(LIBRARY)-$(VERSION).zip $(LIBRARY)-$(VERSION)-	rm -r tmp.tar $(LIBRARY)-$(VERSION)-haddock: $(SRCS)-	mkdir -p docs/$(LIBRARY)-	for dir in $(DIRS); do mkdir -p docs/$(LIBRARY)/$$dir; done-	for file in $(SRCS); \-	    do HsColour -anchor -html $$file \-	          >docs/$(LIBRARY)/`dirname $$file`/`basename $$file .hs`.html;\-	    done-	haddock --html --title=$(LIBRARY) \-	    --odir=docs/$(LIBRARY) --package=$(LIBRARY) \-	    --source-module="%{MODULE/.//}.html" \-	    --source-entity="%{MODULE/.//}.html#%{NAME}" \-	    $(SRCS)----$(LIBRARY): $(SRCS)-	$(HC) $(HFLAGS) $(HEAP) -o $@  $(SRCS)-	$(HOSTSTRIP) $@
− README 
@@ -1,50 +0,0 @@-This directory contains 'cpphs', a simplified but robust-re-implementation of cpp, the C pre-processor, in Haskell.--TO BUILD----------Just use-    hmake cpphs [-package base]-or-    ghc --make cpphs [-o cpphs]		#  -o needed for ghc <= 6.4.1 ]-or-    runhugs cpphs	# or rename the script cpphs.hugs to cpphs---USAGE-------	cpphs  [filename | -Dsym | -Dsym=val | -Ipath]+  [-Ofile]-               [ --include=file ]*-               [ --nomacro | --noline | --nowarn | --strip | --strip-eol |-                 --pragma | --text | --hashes | --layout | --unlit |-                 --linepragma ]*-               [ --cpp compatopts ]--For fuller details, see docs/index.html--If you want to use cpphs as a completely drop-in replacement for the-real cpp, that is, to accept the same arguments, and have broadly-the same behaviour in response to them, then use the --cpp compatibility-option.---COPYRIGHT-----------Copyright (c) 2004-2010 Malcolm Wallace (Malcolm.Wallace@cs.york.ac.uk)-except for Text.ParserCombinators.HuttonMeijer (Copyright (c) 1995-Graham Hutton and Erik Meijer).---LICENCE---------These library modules are distributed under the terms of the LGPL.-The application module 'cpphs.hs' is GPL.--This software comes with no warranty.  Use at your own risk.---WEBSITE---------http://haskell.org/cpphs/-http://www.cs.york.ac.uk/fp/cpphs/-darcs get http://www.cs.york.ac.uk/fp/darcs/cpphs
Text/ParserCombinators/HuttonMeijer.hs view
@@ -34,8 +34,8 @@     letter, alphanum, string, ident, nat, int, spaces, comment, junk,     skip, token, natural, integer, symbol, identifier) where -import Char-import Monad+import Data.Char+import Control.Monad  infixr 5 +++
cpphs.cabal view
@@ -1,11 +1,11 @@ Name: cpphs-Version: 1.11-Copyright: 2004-2010, Malcolm Wallace-Build-Depends: base < 6, haskell98+Version: 1.12+Copyright: 2004-2011, Malcolm Wallace+Build-Depends: base>3&&<6, old-locale, old-time, directory License: LGPL License-File: LICENCE-LGPL-Author: Malcolm Wallace <Malcolm.Wallace@cs.york.ac.uk>-Maintainer: Malcolm Wallace <Malcolm.Wallace@cs.york.ac.uk>+Author: Malcolm Wallace <Malcolm.Wallace@me.com>+Maintainer: Malcolm Wallace <Malcolm.Wallace@me.com> Homepage: http://haskell.org/cpphs/ Synopsis: A liberalised re-implementation of cpp, the C pre-processor. Description:
− cpphs.compat 
@@ -1,48 +0,0 @@-#!/bin/sh-#	A minimal compatibility script to make cpphs accept the same-#	arguments as real cpp, wherever possible.-CPPHS=/usr/malcolm/Haskell/cpphs/cpphs--processArgs () {-  TRADITIONAL=no-  STRIP=yes-  INFILE="-"-  OUTFILE="-"-  while test "$1" != ""-  do-    case $1 in-      -D)            shift; echo -D$1 ;;-      -D*)           echo $1 ;;-      -U)            shift; echo -U$1 ;;-      -U*)           echo $1 ;;-      -I)            shift; echo -I$1 ;;-      -I*)           echo $1 ;;-      -o)            shift; echo -O$1 ;;-      -o*)           echo -O`echo $1 | cut -c3-` ;;-      -std*)         ;;		# ignore language spec-      -x)            shift ;;	# ignore language spec-      -ansi*)        TRADITIONAL=no ;;-      -traditional*) TRADITIONAL=yes ;;-      -include)      shift; echo $1 ;;-      -P)            echo --noline ;;-      -C)            STRIP=no ;;-      -CC)           STRIP=no ;;-      -A)            shift ;;	# strip assertions-      --help)        echo $1 ;;-      -version)      echo -$1 ;;-      --version)     echo $1 ;;-      -*)            ;;	# strip all other flags-      *)     if [ "$INFILE" = "-" ]-             then INFILE=$1-             else OUTFILE=$1-             fi ;;-    esac-    if test "$1" != ""; then shift; fi-  done-  if [ "$TRADITIONAL" = "no" ]; then echo "--hashes";   fi-  if [ "$STRIP" = "yes" ];      then echo "--strip";    fi-  echo $INFILE-  if [ "$OUTFILE" != "-" ];     then echo "-O$OUTFILE"; fi-}--exec $CPPHS `processArgs "$@"`
cpphs.hs view
@@ -11,15 +11,16 @@ -} module Main where -import System ( getArgs, getProgName, exitWith, ExitCode(..) )-import Maybe+import System.Environment ( getArgs, getProgName)+import System.Exit ( exitWith, ExitCode(..) )+import Data.Maybe import Language.Preprocessor.Cpphs ( runCpphs, CpphsOptions(..), parseOptions )-import IO     ( stdout, IOMode(WriteMode), openFile, hPutStr, hFlush, hClose )-import Monad  ( when )-import List   ( isPrefixOf )+import System.IO     ( stdout, IOMode(WriteMode), openFile, hPutStr, hFlush, hClose )+import Control.Monad  ( when )+import Data.List   ( isPrefixOf )  version :: String-version = "1.11"+version = "1.12"  main :: IO () main = do
− cpphs.hugs 
@@ -1,2 +0,0 @@-#!/bin/sh-runhugs cpphs.hs --noline -D__HASKELL98__ -D__HUGS__ "$@"
− docs/cpphs.1 
@@ -1,276 +0,0 @@-.TH CPPHS 1 2004-10-01 "cpphs version 0.9" "User Manual"--.SH NAME-cpphs \- liberalised cpp-a-like preprocessor for Haskell--.SH SYNOPSIS-.B cpphs-[\fIFILENAME\fR|\fIOPTION\fR]...--.SH DESCRIPTION-.ds c \fIcpphs\fP-\*c is a liberalised re-implementation of-.B cpp (1),-the C pre-processor, in and for Haskell.-.PP-Why re-implement cpp?  Rightly or wrongly, the C pre-processor is-widely used in Haskell source code.  It enables conditional compilation-for different compilers, different versions of the same compiler,-and different OS platforms.  It is also occasionally used for its-macro language, which can enable certain forms of platform-specific-detail-filling, such as the tedious boilerplate generation of instance-definitions and FFI declarations.  However, there are two problems with-cpp, aside from the obvious aesthetic ones:-.IP-For some Haskell systems, notably Hugs on Windows, a true cpp-is not available by default.-.IP-Even for the other Haskell systems, the common cpp provided by-the gcc 3.x series is changing subtly in ways that are-incompatible with Haskell's syntax.  There have always been-problems with, for instance, string gaps, and prime characters-in identifiers.  These problems are only going to get worse.-.PP-So, it seemed right to attempt to provide an alternative to cpp,-both more compatible with Haskell, and itself written in Haskell so-that it can be distributed with compilers.-.PP-\*c is pretty-much feature-complete,-and compatible with the-.B \-traditional-style of cpp.-It has two modes:-.IP-conditional compilation only (\fB\-\-nomacro\fR),-.IP-and full macro-expansion (default).-.PP-In-.B \-\-nomacro-mode, \*c performs only conditional compilation actions, i.e.-\fB#include\fR's, \fB#if\fR's, and \fB#ifdef\fR's are processed-according to text-replacement-definitions (both command-line and internal), but no parameterised-macro expansion is performed.  In full compatibility mode (the-default), textual replacements and macro expansions are also processed-in the remaining body of non-cpp text.-.PP-Working Features:-.TP-.B #ifdef-simple conditional compilation-.TP-.B #if-the full boolean language of defined(), &&, ||, ==, etc.-.TP-.B #elif-chained conditionals-.TP-.B #define-in-line definitions (text replacements and macros)-.TP-.B #undef-in-line revocation of definitions-.TP-.B #include-file inclusion-.TP-.B #line-line number directives-.TP-.B \\\\n-line continuations within all # directives-.TP-.B /**/-token catenation within a macro definition-.TP-.B ##-ANSI-style token catenation-.TP-.B #-ANSI-style token stringisation-.TP-.B __FILE__-special text replacement for DIY error messages-.TP-.B __LINE__-special text replacement for DIY error messages-.TP-.B __DATE__-special text replacement-.TP-.B __TIME__-special text replacement-.PP-Macro expansion is recursive.  Redefinition of a macro name does not-generate a warning.  Macros can be defined on the command-line with-.B \-D-just like textual replacements.  Macro names are permitted to be-Haskell identifiers e.g. with the prime \(ga and backtick \(aa characters,-which is slightly looser than in C, but they still may not include-operator symbols.-.PP-Numbering of lines in the output is preserved so that any later-processor can give meaningful error messages.  When a file is-\fB#include\fR'd, \*c inserts-.B #line-directives for the same reason. Numbering should be correct-even in the presence of line continuations. If you don't want-.B #line-directives in the final output, use the-.B \-\-noline-option.-.PP-Any syntax errors in cpp directives gives a message to stderr and-halts the program.  Failure to find a #include'd file produces a-warning to stderr, but processing continues.-.PP-You can give any number of filenames on the command-line.  The-results are catenated on standard output.-.TP-.B \-D\fIsym\fR-define a textual replacement (default value is 1)-.TP-.B \-Dsym=\fIval\fR-define a textual replacement with a specific value-.TP-.B \-I\fIpath\fR-add a directory to the search path for #include's-.TP-.B \-O\fIfile\fR-specify a file for output (default is stdout)-.TP-.B \-\-nomacro-only process #ifdef's and #include's,-                      do not expand macros-.TP-.B \-\-noline-remove #line droppings from the output-.TP-.B \-\-strip-convert C-style comments to whitespace, even outside-                      cpp directives-.TP-.B \-\-hashes-recognise the ANSI # stringise operator, and ## for-                      token catenation, within macros-.TP-.B \-\-text-treat the input as plain text, not Haskell code-.TP-.B \-\-layout-preserve newlines within macro expansions-.TP-.B \-\-unlit-remove literate-style comments-.TP-.B \-\-version-report version number of cpphs and stop-.PP-There are NO textual replacements defined by default.  (Normal cpp-usually has definitions for machine, OS, etc.  These could easily-be added to the cpphs source code if you wish.)  The search path is-searched in order of the-.B \-I-options, except that the directory of the-calling file, then the current directory, are always searched first.-Again, there is no default search path (and again, this could easily-be changed).--.SH "DIFFERENCES FROM CPP"-.PP-In general, cpphs is based on the-.B \-traditional-behaviour, not ANSI C, and has the following main differences from the-standard cpp.--.B General-.PP-The-.B #-that introduces any cpp directive must be in the first-column of a line (whereas ANSI permits whitespace before the-.B #-).-.PP-Generates the-.B "#line \fIn\fR \(dq\fIfilename\fR\(dq"-syntax, not the-.B "# \fIn\fR \(dq\fIfilename\fR\(dq"-variant.-.PP-C comments are only removed from within cpp directives.  They are-not stripped from other text.  Consider for instance that in-Haskell, all of the following are valid operator symbols:-.B /*  */  */*-However, you can turn on C-comment removal with the-.B \-\-strip-option.--.B Macro language-.PP-Accepts-.B /**/-for token-pasting in a macro definition.-However,-.B /* */-(with any text between the open/close comment) inserts whitespace.-.PP-The ANSI-.B ##-token-pasting operator is available with-the-.B \-\-hashes-flag.  This is to avoid misinterpreting-any valid Haskell operator of the same name.-.PP-Replaces a macro formal parameter with the actual, even inside a-string (double or single quoted).  This is \-traditional behaviour,-not supported in ANSI.-.PP-Recognises the-.B #-stringisation operator in a macro-definition only if you use the-.B \-\-hashes-option.  (It is-an ANSI addition, only needed because quoted stringisation (above)-is prohibited by ANSI.)-.PP-Preserves whitespace within a textual replacement definition-exactly (modulo newlines), but leading and trailing space is eliminated.-.PP-Preserves whitespace within a macro definition (and trailing it)-exactly (modulo newlines), but leading space is eliminated.-.PP-Preserves whitespace within macro call arguments exactly-(including newlines), but leading and trailing space is eliminated.-.PP-With the-.B \-\-layout-option, line continuations in a textual-replacement or macro definition are preserved as line-breaks in the-macro call.  (Useful for layout-sensitive code in Haskell.)--.SH BUGS-Bug reports, and any other feedback, should be sent to-Malcolm Wallace <Malcolm.Wallace@cs.york.ac.uk>-.SH COPYRIGHT-Copyright \(co 2004-2005 Malcolm Wallace,-except for ParseLib (Copyright \(co 1995 Graham Hutton and Erik Meijer).-.PP-The library modules in cpphs are distributed under-the terms of the LGPL. If that's a problem for you, contact me to make-other arrangements. The application module-.B Main.hs-itself is GPL.-.SH "SEE ALSO"-.BR cpp (1)--.SH AUTHOR--This manual page was written, based on \fBindex.html\fR,-by Ian Lynagh <igloo@debian.org> for the Debian-system (but may be used by others).--
− docs/design 
@@ -1,29 +0,0 @@-Design for hspp--First pass:-------------  * traverse the file,-      - processing #if's and #ifdef's-      - reading #include's and recursively doing this pass on them-      - leaving #line's behind-      - whilst taking account of #define's and #undef's-  * only needs to look at lines beginning with a #-  * should discard C-style comments?  (no)-  * DO NOT gather the #define's for macros - their sequence matters!--pass1 :: SymTab -> String -> String--Second pass:--------------  * traverse the residual file,-      - keeping track of #define'd macros-      - expanding #define'd macros when an instance is encountered-  * needs a whitespace-preserving tokeniser with odd rules to-    cover e.g. token concatenation.  Within Haskell, quotation marks start-    strings, haskell comments are preserved.  Within a cpp directive,-    quotation marks do not start a string, and C-style comments are-    converted to whitespace.-  * Line continuation characters are tricky; probably should only-    be recognised within a macro definition, not in ordinary code.--pass2 :: SymTab -> String -> String
− docs/index.html 
@@ -1,592 +0,0 @@-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">-<html>-<head>-<title>-  cpphs-</title>-</head>- -<body bgcolor='#ffffff'>--<center>-<h1>cpphs</h1>-<table><tr><td width=200 align=center>-<a href="#what">What is cpphs?</a><br>-<a href="#how">How do I use it?</a><br>-<a href="#download">Downloads</a><br>-</td><td width=200 align=center>-<a href="#diff">Differences to cpp</a><br>-<a href="#library">cpphs as a library</a><br>-<a href="#who">Contacts</a><br>-</td></tr></table>-</center>-<hr>--<center><h3><a name="what">What is cpphs?</a></h3></center>-<p>-<b>cpphs</b> is a liberalised re-implementation of-<a href="http://gcc.gnu.org/onlinedocs/gcc-2.95.3/cpp.html">cpp</a>,-the C pre-processor, in <a href="http://haskell.org/">Haskell</a>.--<p>-Why re-implement cpp?  Rightly or wrongly, the C pre-processor is-widely used in Haskell source code.  It enables conditional compilation-for different compilers, different versions of the same compiler,-and different OS platforms.  It is also occasionally used for its-macro language, which can enable certain forms of platform-specific-detail-filling, such as the tedious boilerplate generation of instance-definitions and FFI declarations.  However, there are two problems with-cpp, aside from the obvious aesthetic ones:-<ul>-  <li> For some Haskell systems, notably Hugs on Windows, a true cpp-       is not available by default.-  <li> Even for the other Haskell systems, the common cpp provided by-       the gcc 3.x and 4.x series has changed subtly in ways that are-       incompatible with Haskell's syntax.  There have always been-       problems with, for instance, string gaps, and prime characters-       in identifiers.  These problems are only going to get worse.-</ul>-So, it seemed right to provide an alternative to cpp, both more-compatible with Haskell, and itself written in Haskell so that it-can be distributed with compilers.--<p>-This version of the C pre-processor is pretty-much feature-complete,-and compatible with the <tt>-traditional</tt> style.-It has two main modes:-<ul>-  <li> conditional compilation only (--nomacro),-  <li> and full macro-expansion (default).-</ul>-In <tt>--nomacro</tt> mode, cpphs performs only conditional compilation-actions, namely <tt>#include</tt>'s, <tt>#if</tt>'s, and-<tt>#ifdef</tt>'s are processed according to text-replacement-definitions and macro expansions (both command-line and internal).-In full compatibility mode (the default), textual replacements and macro-expansions are also processed in the remaining body of non-cpp text.--<p>-Source language features:-<table border=0 align=center>-<tr><td>#ifdef</td>  <td>simple conditional compilation</td></tr>-<tr><td>#if</td>     <td>the full boolean language of defined(),-                     &amp;&amp;, ||, ==, etc.</td></tr>-<tr><td>#elif</td>   <td>chained conditionals</td></tr>-<tr><td>#define</td> <td>in-line definitions (text replacements and macros)</td></tr>-<tr><td>#undef</td>  <td>in-line revocation of definitions</td></tr>-<tr><td>#include</td><td>file inclusion</td></tr>-<tr><td>#line</td>   <td>line number directives</td></tr>-<tr><td>#pragma</td> <td>cpp pragmas (ignored)</td></tr>-<tr><td>\\n</td>     <td>line continuations within all # directives</td></tr>-<tr><td>/**/</td>    <td>token catenation within a macro definition</td></tr>-<tr><td>##</td>      <td>ANSI-style token catenation</td></tr>-<tr><td>#</td>       <td>ANSI-style token stringisation</td></tr>-<tr><td>__FILE__</td><td>special text replacement for DIY error messages</td></tr>-<tr><td>__LINE__</td><td>special text replacement for DIY error messages</td></tr>-<tr><td>__DATE__</td><td>special text replacement</td></tr>-<tr><td>__TIME__</td><td>special text replacement</td></tr>-</table>--<p>-Macro expansion is recursive.  Redefinition of a macro name does not-generate a warning.  Macros can be defined on the command-line with--D just like textual replacements.  Macro names are permitted to be-Haskell identifiers e.g. with the prime ' and backtick ` characters,-which is slightly looser than in C, but they still may not include-operator symbols.--<p>-Numbering of lines in the output is preserved so that any later-processor can give meaningful error messages.  When a file is-<tt>#include</tt>'d, cpphs inserts <tt>#line</tt> directives for the-same reason.  Numbering should be correct even in the presence of-line continuations.  If you don't want <tt>#line</tt> directives in-the final output, use the <tt>--noline</tt> option, or if you would-prefer them in <tt>{-# LINE #-}</tt> Haskell pragma format, use the-<tt>--linepragma</tt> option.--<p>-Any syntax error in a cpp directive gives a warning message to stderr.-Failure to find a #include'd file also produces a warning to stderr.  In-both cases, processing continues on the rest of the input.--<hr>-<center><h3><a name="how">How do I use it?</a></h3></center>-<p>-<center><pre>-Usage: cpphs  [ filename | -Dsym | -Dsym=val | -Ipath ]+  [-Ofile]-              [--include=file]*-              [--nomacro] [--noline] [--linepragma] [--nowarn] [--pragma]-              [--strip] [--strip-eol]-              [--text] [--hashes] [--layout] [--unlit]-              [ --cpp compatopts ]-       cpphs --version                                             -</pre></center>-<p>-You can give any number of filenames on the command-line.  The results-are catenated on standard output.  (Macro definitions in one file do not-carry over into the next.)  If no filename is given, cpphs reads from-standard input.--<p> <em>Note:</em> if you wish to use cpphs as a replacement for gcc's-cpp in conjunction with the ghc compiler then the extra options you need-to give to ghc are these:-<pre>-  -cpp  -pgmPcpphs  -optP--cpp-</pre>--<p>-Options:-<table border=0 align=center>-<tr><td>-Dsym</td>-    <td>define a textual replacement (default value is 1)</td></tr>-<tr><td>-Dsym=val</td>-    <td>define a textual replacement with a specific value</td></tr>-<tr><td>-Dsym(args)=val</td>-    <td>define a macro with arguments</td></tr>-<tr><td>-Ipath</td>-    <td>add a directory to the search path for #include's</td></tr>-<tr><td>-Ofile</td>-    <td>specify a file for output (default is stdout)</td></tr>-<tr><td>--include=file</td>-    <td>#include the given file at the start of the input</td></tr>-<tr><td>--nomacro</td>-    <td>only process #ifdef's and #include's, do not expand macros</td></tr>-<tr><td>--noline</td>-    <td>remove #line droppings from the output</td></tr>-<tr><td>--linepragma</td>-    <td>convert #line droppings into {-# LINE #-} format</td></tr>-<tr><td>--nowarn</td>-    <td>suppress messages from missing #include files, or #warning</td></tr>-<tr><td>--pragma</td>-    <td>retain #pragma in the output (normally removed)</td></tr>-<tr><td>--strip</td>-    <td>convert traditional C-style comments (not eol //) to whitespace,-                      even outside cpp directives</td></tr>-<tr><td>--strip-eol</td>-    <td>convert modern C-style comments (including /**/ and //) to whitespace,-                      even outside cpp directives</td></tr>-<tr><td>--hashes</td>-    <td>recognise the ANSI # stringise operator, and ## for-                      token catenation, within macros</td></tr>-<tr><td>--text</td>-    <td>treat input as plain text, not Haskell code</td></tr>-<tr><td>--layout</td>-    <td>preserve newlines within macro expansions</td></tr>-<tr><td>--unlit</td>-    <td>unlit literate source code</td></tr>-<tr><td>--cpp compatopts</td>-    <td>accept standard cpp options: -o, -x, -ansi, -traditional,-                                     -P, -C, -A, etc</td></tr>-<tr><td>--version</td>-    <td>report version number of cpphs and stop</td></tr>-</table>--<p>-There are NO textual replacements defined by default.  (Normal cpp-usually has definitions for machine, OS, etc.  You can easily create-a wrapper script if you need these.) The search path is searched in-order of the -I options, except that the directory of the calling file,-then the current directory, are always searched first.  Again, there-is no default search path (unless you define one via a wrapper script).---<hr>-<center><h3><a name="download">Downloads</a></h3></center>--<p>-<b>Current stable version:</b>--<p>-cpphs-1.11, release date 2010.01.31<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.11.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.11.zip">.zip</a>,-<a href="http://hackage.haskell.org/package/cpphs">Hackage</a>.-<ul>-<li> Major API change: runCpphs, cppIfdef and macroPass are now in the IO monad.-</ul>--<p>-<b>Development:</b>-<p>-The current <a href="http://darcs.net/">darcs</a> repository of-cpphs is available at-<pre>-    darcs get http://www.cs.york.ac.uk/fp/darcs/cpphs-</pre>-(Users on Windows or MacOS filesystems need to use the-<tt>--partial</tt> flag.)  The source tree and version history can-be browsed on-line through-<a href="http://www.cs.york.ac.uk/fp/darcs/">darcsweb</a>.-What's new, over and above the latest stable release?-<ul>-<li> Nothing since last release.-</ul>--<p>-<b>Older versions:</b>--<p>-cpphs-1.10, release date 2010.01.30<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.10.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.10.zip">.zip</a>,-<ul>-<li> New command-line flag: --linepragma-</ul>--<p>-cpphs-1.9, release date 2009.09.07<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.9.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.9.zip">.zip</a>.-<ul>-<li> Bugfix for #undef.-</ul>--<p>-cpphs-1.8, release date 2009.08.06<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.8.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.8.zip">.zip</a>.-<ul>-<li> Bugfix for off-by-one error in line numbers with --include=file.-</ul>--<p>-cpphs-1.7, release date 2009.06.22<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.7.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.7.zip">.zip</a>.-<ul>-<li> Bugfix for --unlit interaction with \end{code}.-</ul>--<p>-cpphs-1.6, release date 2008.10.09<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.6.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.6.zip">.zip</a>.-<ul>-<li> New option <tt>--include=filename</tt>, compatible with cpp's-     <tt>-include filename</tt>.-<li> New option <tt>--strip-eol</tt> now strips C eol <tt>//</tt> comments-     in addition to <tt>/**/</tt>.-<li> Line pragmas can now have filenames containing spaces.-<li> Bugfix for cpp directives within <tt>{- -}</tt> Haskell comments.-</ul>-<p>-cpphs-1.5, release date 2007.06.05<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.5.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.5.zip">.zip</a>.-<a href="http://www.cs.york.ac.uk/fp/cpphs-1.5-win32.zip">Windows binary</a>,-<ul>-<li> Fixed some more obscure corner cases, involving parameterised macro-     expansion within conditionals e.g. #if FOO(BAR,QUUX)-<li> Internal refactoring, affecting parts of the library API.-</ul>--<p>-cpphs-1.4, release date 2007.04.17<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.4.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.4.zip">.zip</a>.-<ul>-<li> Added a "--pragma" option to retain #pragma in the output.-<li> Fixed a number of obscure corner cases involving the interaction of-     multiple features e.g. foo##__LINE__.-<li> Added the "--nowarn" option.-</ul>--<p>-cpphs-1.3, release date 2006.10.09<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.3.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.3.zip">.zip</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs-1.3-win32.zip">Windows binary</a>.-<ul>-<li> Added a "--cpp" option for drop-in compatibility with standard cpp.-     It causes cpphs to accept standard cpp flags and translate-     them to cpphs equivalents.  Compatibility options include: -o, -ansi,-     -traditional, -stdc, -x, -include, -P, -C, -CC, -A.  The file-     behaviour is different too - if two filenames are given on the-     commandline, then the second is treated as the output location.-<li> Fixed a corner-case bug in evaluating chained and overlapping #ifdefs.-</ul>--<p>-cpphs-1.2, release date 2006.05.04<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.2.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.2.zip">.zip</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs-1.2-win32.zip">Windows binary</a>.-<ul>-<li> Re-arranged the source files into hierarchical libraries.-<li> Exposed the library interface as an installable Cabal package, with-     Haddock documentation.-<li> Added the --unlit option, for removing literate-style comments.-</ul>--<p>-cpphs-1.1, release date 2005.10.14<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.1.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.1.zip">.zip</a>.-<ul>-<li> Fixed the .cabal way of building cpphs.-<li> Update the --version reported (forgotten in 1.0, which still-     mistakenly reports 0.9).-<li> No longer throws an error on an empty file.-</ul>--<p>-cpphs-1.0, release date 2005.10.05<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.0.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-1.0.zip">.zip</a>.-<ul>-<li> Included the <tt>cpphs.compat</tt> script for argument-     compatibility with the original <em>cpp</em>.-<li> Placed quotes around replacements for special macros __FILE__, __DATE__,-     and __TIME__.-<li> If no files are specified, read from stdin.-<li> Ignore #! lines (e.g. in scripts)-<li> Parse -D commandline options consistently with cpp,-     i.e. -Dfoo means foo=1-<li> Fix compatibility with preprocessors like hsc2hs, which use-     non-cpp directives like #def.  They are now passed through to the-     output with a warning to stderr.-</ul>--<p>-cpphs-0.9, release date 2005.03.17<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.9.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.9.zip">.zip</a>.-<ul>-<li> Bugfix for <tt>ghc-6.4 -O</tt>: flush output buffer.-</ul>--<p>-cpphs-0.8, release date 2004.11.14<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.8.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.8.zip">.zip</a>.-<ul>-<li> Added the <tt>--text</tt> option, to signify the input should not-     be lexed as Haskell.  This causes macros to be defined or expanded-     regardless of their location within comments, string delimiters, etc.-<li> Shuffled some source files around - there is now a runhugs script-     to invoke cpphs nicely.-</ul>--<p>-cpphs-0.7, release date 2004.09.01<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.7.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.7.zip">.zip</a>.-<ul>-<li> Enable the <tt>__FILE__</tt>, <tt>__LINE__</tt>, <tt>__DATE__</tt>,-     and <tt>__TIME__</tt> specials, which can be useful for creating-     DIY error messages.-</ul>--<p>-cpphs-0.6, release date 2004.07.30<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.6.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.6.zip">.zip</a>.-<ul>-<li> Recognise and ignore the <tt>#pragma</tt> cpp directive.-<li> Fix beginning-of-file bug, where in <tt>--noline</tt> mode, a-     <tt>#line</tt> cpp directive appeared at the top of the output file.-<li> Fix chained parenthesised boolean exprs in <tt>#if</tt>, e.g.-        <pre>#if ( foo ) &amp;&amp; ( bar )</pre>-<li> Fix precedence in chained unparenthesised boolean exprs in-     <tt>#if</tt>, e.g.-        <pre>#if foo &amp;&amp; bar || baz &amp;&amp; frob</pre>-<li> For better compatibility with cpp, and because otherwise-     there are certain constructs that cannot be expressed, we no-     longer permit whitespace in a <tt>#define</tt> between the-     symbolname and an opening parenthesis, e.g.  -     <pre>#define f (f' id)</pre>.  Previously, this was interpreted-     as a parametrised macro, with arguments in the parens, and-     no expansion.  Now, the space indicates that this is a textual-     replacement, and the parenthesised expression is in fact the-     replacement.-</ul>--<p>-cpphs-0.5, release date 2004.06.07<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.5.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.5.zip">.zip</a>.-<ul>-<li> Added a --version flag to report the version number.-<li> Renamed --stringise to --hashes, and use it to turn on ## catenation-     as well.-<li> Bugfix for <tt>#if 1</tt>, previously interpreted as false.-<li> Bugfix for --nolines: it no longer adds extra spurious newlines.-<li> File inclusion now looks in the directory of the calling file.-<li> Failure to find an include file is now merely a warning to stderr-     rather than an error.-<li> Added a --layout flag.  Previously, line continuations in a macro-     definition were always preserved in the output, permitting use-     of the Haskell layout rule even inside a macro.  The default is now-     to remove line continuations for conformance with cpp, but the option-     of using --layout is still possible.-</ul>--<p>-cpphs-0.4, release date 2004.05.19<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.4.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.4.zip">.zip</a>.-<ul>-<li> New flag -Ofile to redirect output-<li> Bugfix for precedence of ! in #if !False &amp;&amp; False-<li> Bugfix for whitespace permitted between # and if-<li> Bugfix for <tt>#define F "blah";  #include F</tt>-</ul>--<p>-cpphs-0.3, release date 2004.05.18<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.3.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.3.zip">.zip</a>.-<p>-Fix recursive macro expansion bug.  Added option to strip C comments.-Added option to recognise the # stringise operator.--<p>-cpphs-0.2, release date 2004.05.15<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.2.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.2.zip">.zip</a>.-<p>-Implements textual replacement and macro expansion.--<p>-cpphs-0.1, release date 2004.04.07<br>-By HTTP:-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.1.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/cpphs/cpphs-0.1.zip">.zip</a>.-<p>-Initial release: implements conditional compilation and file inclusion only.---<p>-<b>Building instructions</b>-<p>-To build cpphs, use-<pre>    hmake cpphs [-package base]-</pre>-or-<pre>    ghc --make cpphs [-o cpphs]-</pre>-or-<pre>    mv cpphs.hugs cpphs	# a simple runhugs script-</pre>--<p>-You will notice that the command-line arguments for <em>cpphs</em>-are not the same as for the original <em>cpp</em>.  If you want-to use <em>cpphs</em> as a completely drop-in replacement for-the real <em>cpp</em>, that is, to accept the same arguments, and-have broadly the same behaviour in response to them, then use the-<tt>--cpp</tt> compatibility option as the first commandline flag.---<hr>-<center><h3><a name="diff">Differences from cpp</a></h3></center>-<p>-In general, cpphs is based on the <tt>-traditional</tt> behaviour, not-ANSI C, and has the following main differences from the standard cpp.--<p>-<b>General</b>-<ul>-<li> The <tt>#</tt> that introduces any cpp directive must be in the first-     column of a line (whereas ANSI permits whitespace before the <tt>#</tt>).-<li> Generates the <tt>#line n "filename"</tt> syntax, not the <tt># n-     "filename"</tt> variant.-<li> C comments are only removed from within cpp directives.  They are-     not stripped from other text.  Consider for instance that in-     Haskell, all of the following are valid operator symbols:  <tt>/*-     */  */*</tt>   However, you can turn on C-comment removal with the-     <tt>--strip</tt> option.-<li> Macros are never expanded within Haskell comments, strings,-     or character constants, unless you give the <tt>--text</tt> option to-     disable lexing the input as Haskell.-<li> Macros are always expanded recursively, unlike ANSI, which detects-     and prevents self-recursion.  For instance, <tt>#define foo x:foo</tt>-     expands <tt>foo</tt> once only to <tt>x:foo</tt> in ANSI, but in cpphs-     it becomes an infinite list <tt>x:x:x:x:...</tt>, i.e. cpphs does not-     terminate.-</ul>-<p>-<b>Macro definition language</b>-<ul>-<li> Accepts <tt>/**/</tt> for token-pasting in a macro definition.-     However, <tt>/* */</tt> (with any text between the open/close-     comment) inserts whitespace.-<li> The ANSI <tt>##</tt> token-pasting operator is available with-     the <tt>--hashes</tt> flag.  This is to avoid misinterpreting-     any valid Haskell operator of the same name.-<li> Replaces a macro formal parameter with the actual, even inside a-     string (double or single quoted).  This is -traditional behaviour,-     not supported in ANSI.-<li> Recognises the <tt>#</tt> stringisation operator in a macro-     definition only if you use the <tt>--hashes</tt> option.  (It is-     an ANSI addition, only needed because quoted stringisation (above)-     is prohibited by ANSI.)-<li> Preserves whitespace within a textual replacement definition-     exactly (modulo newlines), but leading and trailing space is eliminated.-<li> Preserves whitespace within a macro definition (and trailing it)-     exactly (modulo newlines), but leading space is eliminated.-<li> Preserves whitespace within macro call arguments exactly-     (including newlines), but leading and trailing space is eliminated.-<li> With the <tt>--layout</tt> option, line continuations in a textual-     replacement or macro definition are preserved as line-breaks in the-     macro call.  (Useful for layout-sensitive code in Haskell.)-</ul>--<hr>-<center><h3><a name="library">cpphs as a library</a></h3></center>-<p>-You can use cpphs as a library from within a Haskell program.  The main-interface is in <tt>Language.Preprocessor.Cpphs</tt>.  Haddock-documentation is <a href="cpphs/">here</a>.  To make the library-available to your haskell compiler, you must install the cpphs package-using Cabal.--<hr>-<center><h3><a name="who">Contacts</a></h3></center>-<p>-I am interested in hearing your feedback on cpphs.  Bug reports-especially welcome.  You can send feature requests too, but I won't-guarantee to implement them if they depart much from the ordinary-cpp's behaviour.  Please mail-<ul>-<li>    <a href="mailto:Malcolm.Wallace@cs.york.ac.uk">-        Malcolm.Wallace@cs.york.ac.uk</a> -</ul>--<p><b>Copyright:</b> &copy; 2004-2010 Malcolm Wallace,-except for ParseLib (Copyright &copy; 1995 Graham Hutton and Erik Meijer)--<p><b>License:</b> The library modules in cpphs are distributed under-the terms of the LGPL (see file <a href="LICENCE-LGPL">LICENCE-LGPL</a>-for more details).  If that's a problem for you, contact me to make-other arrangements.  The application module 'cpphs.hs' itself is GPL-(see file <a href="LICENCE-GPL">LICENCE-GPL</a>).--<p>-This software comes with no warranty.  Use at your own risk.--<hr>- -</body>-</html>
− tests/Arr.lhs 
@@ -1,683 +0,0 @@-\begin{code}-{-# OPTIONS_GHC -fno-implicit-prelude -fno-bang-patterns #-}--------------------------------------------------------------------------------- |--- Module      :  GHC.Arr--- Copyright   :  (c) The University of Glasgow, 1994-2000--- License     :  see libraries/base/LICENSE--- --- Maintainer  :  cvs-ghc@haskell.org--- Stability   :  internal--- Portability :  non-portable (GHC extensions)------ GHC\'s array implementation.--- ---------------------------------------------------------------------------------- #hide-module GHC.Arr where--import {-# SOURCE #-} GHC.Err ( error )-import GHC.Enum-import GHC.Num-import GHC.ST-import GHC.Base-import GHC.List-import GHC.Show--infixl 9  !, //--default ()-\end{code}---%*********************************************************-%*							*-\subsection{The @Ix@ class}-%*							*-%*********************************************************--\begin{code}--- | The 'Ix' class is used to map a contiguous subrange of values in--- a type onto integers.  It is used primarily for array indexing--- (see "Data.Array", "Data.Array.IArray" and "Data.Array.MArray").------ The first argument @(l,u)@ of each of these operations is a pair--- specifying the lower and upper bounds of a contiguous subrange of values.------ An implementation is entitled to assume the following laws about these--- operations:------ * @'inRange' (l,u) i == 'elem' i ('range' (l,u))@------ * @'range' (l,u) '!!' 'index' (l,u) i == i@, when @'inRange' (l,u) i@------ * @'map' ('index' (l,u)) ('range' (l,u))) == [0..'rangeSize' (l,u)-1]@------ * @'rangeSize' (l,u) == 'length' ('range' (l,u))@------ Minimal complete instance: 'range', 'index' and 'inRange'.----class (Ord a) => Ix a where-    -- | The list of values in the subrange defined by a bounding pair.-    range		:: (a,a) -> [a]-    -- | The position of a subscript in the subrange.-    index		:: (a,a) -> a -> Int-    -- | Like 'index', but without checking that the value is in range.-    unsafeIndex		:: (a,a) -> a -> Int-    -- | Returns 'True' the given subscript lies in the range defined-    -- the bounding pair.-    inRange		:: (a,a) -> a -> Bool-    -- | The size of the subrange defined by a bounding pair.-    rangeSize		:: (a,a) -> Int-    -- | like 'rangeSize', but without checking that the upper bound is-    -- in range.-    unsafeRangeSize     :: (a,a) -> Int--	-- Must specify one of index, unsafeIndex-    index b i | inRange b i = unsafeIndex b i	-	      | otherwise   = error "Error in array index"-    unsafeIndex b i = index b i--    rangeSize b@(_l,h) | inRange b h = unsafeIndex b h + 1-		       | otherwise   = 0	-- This case is only here to-						-- check for an empty range-	-- NB: replacing (inRange b h) by (l <= h) fails for-	--     tuples.  E.g.  (1,2) <= (2,1) but the range is empty--    unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1-\end{code}--Note that the following is NOT right-	rangeSize (l,h) | l <= h    = index b h + 1-			| otherwise = 0--Because it might be the case that l<h, but the range-is nevertheless empty.  Consider-	((1,2),(2,1))-Here l<h, but the second index ranges from 2..1 and-hence is empty--%*********************************************************-%*							*-\subsection{Instances of @Ix@}-%*							*-%*********************************************************--\begin{code}--- abstract these errors from the relevant index functions so that--- the guts of the function will be small enough to inline.--{-# NOINLINE indexError #-}-indexError :: Show a => (a,a) -> a -> String -> b-indexError rng i tp-  = error (showString "Ix{" . showString tp . showString "}.index: Index " .-           showParen True (showsPrec 0 i) .-	   showString " out of range " $-	   showParen True (showsPrec 0 rng) "")-------------------------------------------------------------------------instance  Ix Char  where-    {-# INLINE range #-}-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (m,_n) i = fromEnum i - fromEnum m--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Char"--    inRange (m,n) i	=  m <= i && i <= n-------------------------------------------------------------------------instance  Ix Int  where-    {-# INLINE range #-}-	-- The INLINE stops the build in the RHS from getting inlined,-	-- so that callers can fuse with the result of range-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (m,_n) i = i - m--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Int"--    {-# INLINE inRange #-}-    inRange (I# m,I# n) (I# i) =  m <=# i && i <=# n-------------------------------------------------------------------------instance  Ix Integer  where-    {-# INLINE range #-}-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (m,_n) i   = fromInteger (i - m)--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Integer"--    inRange (m,n) i	=  m <= i && i <= n-------------------------------------------------------------------------instance Ix Bool where -- as derived-    {-# INLINE range #-}-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (l,_) i = fromEnum i - fromEnum l--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Bool"--    inRange (l,u) i = fromEnum i >= fromEnum l && fromEnum i <= fromEnum u-------------------------------------------------------------------------instance Ix Ordering where -- as derived-    {-# INLINE range #-}-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (l,_) i = fromEnum i - fromEnum l--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Ordering"--    inRange (l,u) i = fromEnum i >= fromEnum l && fromEnum i <= fromEnum u-------------------------------------------------------------------------instance Ix () where-    {-# INLINE range #-}-    range   ((), ())    = [()]-    {-# INLINE unsafeIndex #-}-    unsafeIndex   ((), ()) () = 0-    {-# INLINE inRange #-}-    inRange ((), ()) () = True-    {-# INLINE index #-}-    index b i = unsafeIndex b i-------------------------------------------------------------------------instance (Ix a, Ix b) => Ix (a, b) where -- as derived-    {-# SPECIALISE instance Ix (Int,Int) #-}--    {- INLINE range #-}-    range ((l1,l2),(u1,u2)) =-      [ (i1,i2) | i1 <- range (l1,u1), i2 <- range (l2,u2) ]--    {- INLINE unsafeIndex #-}-    unsafeIndex ((l1,l2),(u1,u2)) (i1,i2) =-      unsafeIndex (l1,u1) i1 * unsafeRangeSize (l2,u2) + unsafeIndex (l2,u2) i2--    {- INLINE inRange #-}-    inRange ((l1,l2),(u1,u2)) (i1,i2) =-      inRange (l1,u1) i1 && inRange (l2,u2) i2--    -- Default method for index-------------------------------------------------------------------------instance  (Ix a1, Ix a2, Ix a3) => Ix (a1,a2,a3)  where-    {-# SPECIALISE instance Ix (Int,Int,Int) #-}--    range ((l1,l2,l3),(u1,u2,u3)) =-        [(i1,i2,i3) | i1 <- range (l1,u1),-                      i2 <- range (l2,u2),-                      i3 <- range (l3,u3)]--    unsafeIndex ((l1,l2,l3),(u1,u2,u3)) (i1,i2,i3) =-      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (-      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (-      unsafeIndex (l1,u1) i1))--    inRange ((l1,l2,l3),(u1,u2,u3)) (i1,i2,i3) =-      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&-      inRange (l3,u3) i3--    -- Default method for index-------------------------------------------------------------------------instance  (Ix a1, Ix a2, Ix a3, Ix a4) => Ix (a1,a2,a3,a4)  where-    range ((l1,l2,l3,l4),(u1,u2,u3,u4)) =-      [(i1,i2,i3,i4) | i1 <- range (l1,u1),-                       i2 <- range (l2,u2),-                       i3 <- range (l3,u3),-                       i4 <- range (l4,u4)]--    unsafeIndex ((l1,l2,l3,l4),(u1,u2,u3,u4)) (i1,i2,i3,i4) =-      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (-      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (-      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (-      unsafeIndex (l1,u1) i1)))--    inRange ((l1,l2,l3,l4),(u1,u2,u3,u4)) (i1,i2,i3,i4) =-      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&-      inRange (l3,u3) i3 && inRange (l4,u4) i4--    -- Default method for index--instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5) => Ix (a1,a2,a3,a4,a5)  where-    range ((l1,l2,l3,l4,l5),(u1,u2,u3,u4,u5)) =-      [(i1,i2,i3,i4,i5) | i1 <- range (l1,u1),-                          i2 <- range (l2,u2),-                          i3 <- range (l3,u3),-                          i4 <- range (l4,u4),-                          i5 <- range (l5,u5)]--    unsafeIndex ((l1,l2,l3,l4,l5),(u1,u2,u3,u4,u5)) (i1,i2,i3,i4,i5) =-      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (-      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (-      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (-      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (-      unsafeIndex (l1,u1) i1))))--    inRange ((l1,l2,l3,l4,l5),(u1,u2,u3,u4,u5)) (i1,i2,i3,i4,i5) =-      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&-      inRange (l3,u3) i3 && inRange (l4,u4) i4 && -      inRange (l5,u5) i5--    -- Default method for index-\end{code}--%*********************************************************-%*							*-\subsection{The @Array@ types}-%*							*-%*********************************************************--\begin{code}-type IPr = (Int, Int)---- | The type of immutable non-strict (boxed) arrays--- with indices in @i@ and elements in @e@.-data Ix i => Array     i e = Array   !i !i (Array# e)---- | Mutable, boxed, non-strict arrays in the 'ST' monad.  The type--- arguments are as follows:------  * @s@: the state variable argument for the 'ST' type------  * @i@: the index type of the array (should be an instance of 'Ix')------  * @e@: the element type of the array.----data         STArray s i e = STArray !i !i (MutableArray# s e)-	-- No Ix context for STArray.  They are stupid,-	-- and force an Ix context on the equality instance.---- Just pointer equality on mutable arrays:-instance Eq (STArray s i e) where-    STArray _ _ arr1# == STArray _ _ arr2# =-        sameMutableArray# arr1# arr2#-\end{code}---%*********************************************************-%*							*-\subsection{Operations on immutable arrays}-%*							*-%*********************************************************--\begin{code}-{-# NOINLINE arrEleBottom #-}-arrEleBottom :: a-arrEleBottom = error "(Array.!): undefined array element"---- | Construct an array with the specified bounds and containing values--- for given indices within these bounds.------ The array is undefined (i.e. bottom) if any index in the list is--- out of bounds.  The Haskell 98 Report further specifies that if any--- two associations in the list have the same index, the value at that--- index is undefined (i.e. bottom).  However in GHC's implementation,--- the value at such an index is the value part of the last association--- with that index in the list.------ Because the indices must be checked for these errors, 'array' is--- strict in the bounds argument and in the indices of the association--- list, but nonstrict in the values.  Thus, recurrences such as the--- following are possible:------ > a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i <- [2..100]])------ Not every index within the bounds of the array need appear in the--- association list, but the values associated with indices that do not--- appear will be undefined (i.e. bottom).------ If, in any dimension, the lower bound is greater than the upper bound,--- then the array is legal, but empty.  Indexing an empty array always--- gives an array-bounds error, but 'bounds' still yields the bounds--- with which the array was constructed.-{-# INLINE array #-}-array :: Ix i-	=> (i,i)	-- ^ a pair of /bounds/, each of the index type-			-- of the array.  These bounds are the lowest and-			-- highest indices in the array, in that order.-			-- For example, a one-origin vector of length-			-- '10' has bounds '(1,10)', and a one-origin '10'-			-- by '10' matrix has bounds '((1,1),(10,10))'.-	-> [(i, e)]	-- ^ a list of /associations/ of the form-			-- (/index/, /value/).  Typically, this list will-			-- be expressed as a comprehension.  An-			-- association '(i, x)' defines the value of-			-- the array at index 'i' to be 'x'.-	-> Array i e-array (l,u) ies = unsafeArray (l,u) [(index (l,u) i, e) | (i, e) <- ies]--{-# INLINE unsafeArray #-}-unsafeArray :: Ix i => (i,i) -> [(Int, e)] -> Array i e-unsafeArray (l,u) ies = runST (ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# arrEleBottom s1#  of { (# s2#, marr# #) ->-    foldr (fill marr#) (done l u marr#) ies s2# }})--{-# INLINE fill #-}-fill :: MutableArray# s e -> (Int, e) -> STRep s a -> STRep s a-fill marr# (I# i#, e) next s1# =-    case writeArray# marr# i# e s1#     of { s2# ->-    next s2# }--{-# INLINE done #-}-done :: Ix i => i -> i -> MutableArray# s e -> STRep s (Array i e)-done l u marr# s1# =-    case unsafeFreezeArray# marr# s1#   of { (# s2#, arr# #) ->-    (# s2#, Array l u arr# #) }---- This is inefficient and I'm not sure why:--- listArray (l,u) es = unsafeArray (l,u) (zip [0 .. rangeSize (l,u) - 1] es)--- The code below is better. It still doesn't enable foldr/build--- transformation on the list of elements; I guess it's impossible--- using mechanisms currently available.---- | Construct an array from a pair of bounds and a list of values in--- index order.-{-# INLINE listArray #-}-listArray :: Ix i => (i,i) -> [e] -> Array i e-listArray (l,u) es = runST (ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# arrEleBottom s1#  of { (# s2#, marr# #) ->-    let fillFromList i# xs s3# | i# ==# n# = s3#-                               | otherwise = case xs of-            []   -> s3#-            y:ys -> case writeArray# marr# i# y s3# of { s4# ->-                    fillFromList (i# +# 1#) ys s4# } in-    case fillFromList 0# es s2#         of { s3# ->-    done l u marr# s3# }}})---- | The value at the given index in an array.-{-# INLINE (!) #-}-(!) :: Ix i => Array i e -> i -> e-arr@(Array l u _) ! i = unsafeAt arr (index (l,u) i)--{-# INLINE unsafeAt #-}-unsafeAt :: Ix i => Array i e -> Int -> e-unsafeAt (Array _ _ arr#) (I# i#) =-    case indexArray# arr# i# of (# e #) -> e---- | The bounds with which an array was constructed.-{-# INLINE bounds #-}-bounds :: Ix i => Array i e -> (i,i)-bounds (Array l u _) = (l,u)---- | The list of indices of an array in ascending order.-{-# INLINE indices #-}-indices :: Ix i => Array i e -> [i]-indices (Array l u _) = range (l,u)---- | The list of elements of an array in index order.-{-# INLINE elems #-}-elems :: Ix i => Array i e -> [e]-elems arr@(Array l u _) =-    [unsafeAt arr i | i <- [0 .. rangeSize (l,u) - 1]]---- | The list of associations of an array in index order.-{-# INLINE assocs #-}-assocs :: Ix i => Array i e -> [(i, e)]-assocs arr@(Array l u _) =-    [(i, unsafeAt arr (unsafeIndex (l,u) i)) | i <- range (l,u)]---- | The 'accumArray' deals with repeated indices in the association--- list using an /accumulating function/ which combines the values of--- associations with the same index.--- For example, given a list of values of some index type, @hist@--- produces a histogram of the number of occurrences of each index within--- a specified range:------ > hist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b--- > hist bnds is = accumArray (+) 0 bnds [(i, 1) | i<-is, inRange bnds i]------ If the accumulating function is strict, then 'accumArray' is strict in--- the values, as well as the indices, in the association list.  Thus,--- unlike ordinary arrays built with 'array', accumulated arrays should--- not in general be recursive.-{-# INLINE accumArray #-}-accumArray :: Ix i-	=> (e -> a -> e)	-- ^ accumulating function-	-> e			-- ^ initial value-	-> (i,i)		-- ^ bounds of the array-	-> [(i, a)]		-- ^ association list-	-> Array i e-accumArray f init (l,u) ies =-    unsafeAccumArray f init (l,u) [(index (l,u) i, e) | (i, e) <- ies]--{-# INLINE unsafeAccumArray #-}-unsafeAccumArray :: Ix i => (e -> a -> e) -> e -> (i,i) -> [(Int, a)] -> Array i e-unsafeAccumArray f init (l,u) ies = runST (ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# init s1#          of { (# s2#, marr# #) ->-    foldr (adjust f marr#) (done l u marr#) ies s2# }})--{-# INLINE adjust #-}-adjust :: (e -> a -> e) -> MutableArray# s e -> (Int, a) -> STRep s b -> STRep s b-adjust f marr# (I# i#, new) next s1# =-    case readArray# marr# i# s1#        of { (# s2#, old #) ->-    case writeArray# marr# i# (f old new) s2# of { s3# ->-    next s3# }}---- | Constructs an array identical to the first argument except that it has--- been updated by the associations in the right argument.--- For example, if @m@ is a 1-origin, @n@ by @n@ matrix, then------ > m//[((i,i), 0) | i <- [1..n]]------ is the same matrix, except with the diagonal zeroed.------ Repeated indices in the association list are handled as for 'array':--- Haskell 98 specifies that the resulting array is undefined (i.e. bottom),--- but GHC's implementation uses the last association for each index.-{-# INLINE (//) #-}-(//) :: Ix i => Array i e -> [(i, e)] -> Array i e-arr@(Array l u _) // ies =-    unsafeReplace arr [(index (l,u) i, e) | (i, e) <- ies]--{-# INLINE unsafeReplace #-}-unsafeReplace :: Ix i => Array i e -> [(Int, e)] -> Array i e-unsafeReplace arr@(Array l u _) ies = runST (do-    STArray _ _ marr# <- thawSTArray arr-    ST (foldr (fill marr#) (done l u marr#) ies))---- | @'accum' f@ takes an array and an association list and accumulates--- pairs from the list into the array with the accumulating function @f@.--- Thus 'accumArray' can be defined using 'accum':------ > accumArray f z b = accum f (array b [(i, z) | i <- range b])----{-# INLINE accum #-}-accum :: Ix i => (e -> a -> e) -> Array i e -> [(i, a)] -> Array i e-accum f arr@(Array l u _) ies =-    unsafeAccum f arr [(index (l,u) i, e) | (i, e) <- ies]--{-# INLINE unsafeAccum #-}-unsafeAccum :: Ix i => (e -> a -> e) -> Array i e -> [(Int, a)] -> Array i e-unsafeAccum f arr@(Array l u _) ies = runST (do-    STArray _ _ marr# <- thawSTArray arr-    ST (foldr (adjust f marr#) (done l u marr#) ies))--{-# INLINE amap #-}-amap :: Ix i => (a -> b) -> Array i a -> Array i b-amap f arr@(Array l u _) =-    unsafeArray (l,u) [(i, f (unsafeAt arr i)) | i <- [0 .. rangeSize (l,u) - 1]]---- | 'ixmap' allows for transformations on array indices.--- It may be thought of as providing function composition on the right--- with the mapping that the original array embodies.------ A similar transformation of array values may be achieved using 'fmap'--- from the 'Array' instance of the 'Functor' class.-{-# INLINE ixmap #-}-ixmap :: (Ix i, Ix j) => (i,i) -> (i -> j) -> Array j e -> Array i e-ixmap (l,u) f arr =-    unsafeArray (l,u) [(unsafeIndex (l,u) i, arr ! f i) | i <- range (l,u)]--{-# INLINE eqArray #-}-eqArray :: (Ix i, Eq e) => Array i e -> Array i e -> Bool-eqArray arr1@(Array l1 u1 _) arr2@(Array l2 u2 _) =-    if rangeSize (l1,u1) == 0 then rangeSize (l2,u2) == 0 else-    l1 == l2 && u1 == u2 &&-    and [unsafeAt arr1 i == unsafeAt arr2 i | i <- [0 .. rangeSize (l1,u1) - 1]]--{-# INLINE cmpArray #-}-cmpArray :: (Ix i, Ord e) => Array i e -> Array i e -> Ordering-cmpArray arr1 arr2 = compare (assocs arr1) (assocs arr2)--{-# INLINE cmpIntArray #-}-cmpIntArray :: Ord e => Array Int e -> Array Int e -> Ordering-cmpIntArray arr1@(Array l1 u1 _) arr2@(Array l2 u2 _) =-    if rangeSize (l1,u1) == 0 then if rangeSize (l2,u2) == 0 then EQ else LT else-    if rangeSize (l2,u2) == 0 then GT else-    case compare l1 l2 of-        EQ    -> foldr cmp (compare u1 u2) [0 .. rangeSize (l1, min u1 u2) - 1]-        other -> other-    where-    cmp i rest = case compare (unsafeAt arr1 i) (unsafeAt arr2 i) of-        EQ    -> rest-        other -> other--{-# RULES "cmpArray/Int" cmpArray = cmpIntArray #-}-\end{code}---%*********************************************************-%*							*-\subsection{Array instances}-%*							*-%*********************************************************--\begin{code}-instance Ix i => Functor (Array i) where-    fmap = amap--instance (Ix i, Eq e) => Eq (Array i e) where-    (==) = eqArray--instance (Ix i, Ord e) => Ord (Array i e) where-    compare = cmpArray--instance (Ix a, Show a, Show b) => Show (Array a b) where-    showsPrec p a =-        showParen (p > appPrec) $-        showString "array " .-        showsPrec appPrec1 (bounds a) .-        showChar ' ' .-        showsPrec appPrec1 (assocs a)-	-- Precedence of 'array' is the precedence of application---- The Read instance is in GHC.Read-\end{code}---%*********************************************************-%*							*-\subsection{Operations on mutable arrays}-%*							*-%*********************************************************--Idle ADR question: What's the tradeoff here between flattening these-datatypes into @STArray ix ix (MutableArray# s elt)@ and using-it as is?  As I see it, the former uses slightly less heap and-provides faster access to the individual parts of the bounds while the-code used has the benefit of providing a ready-made @(lo, hi)@ pair as-required by many array-related functions.  Which wins? Is the-difference significant (probably not).--Idle AJG answer: When I looked at the outputted code (though it was 2-years ago) it seems like you often needed the tuple, and we build-it frequently. Now we've got the overloading specialiser things-might be different, though.--\begin{code}-{-# INLINE newSTArray #-}-newSTArray :: Ix i => (i,i) -> e -> ST s (STArray s i e)-newSTArray (l,u) init = ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# init s1#          of { (# s2#, marr# #) ->-    (# s2#, STArray l u marr# #) }}--{-# INLINE boundsSTArray #-}-boundsSTArray :: STArray s i e -> (i,i)  -boundsSTArray (STArray l u _) = (l,u)--{-# INLINE readSTArray #-}-readSTArray :: Ix i => STArray s i e -> i -> ST s e-readSTArray marr@(STArray l u _) i =-    unsafeReadSTArray marr (index (l,u) i)--{-# INLINE unsafeReadSTArray #-}-unsafeReadSTArray :: Ix i => STArray s i e -> Int -> ST s e-unsafeReadSTArray (STArray _ _ marr#) (I# i#) = ST $ \s1# ->-    readArray# marr# i# s1#--{-# INLINE writeSTArray #-}-writeSTArray :: Ix i => STArray s i e -> i -> e -> ST s () -writeSTArray marr@(STArray l u _) i e =-    unsafeWriteSTArray marr (index (l,u) i) e--{-# INLINE unsafeWriteSTArray #-}-unsafeWriteSTArray :: Ix i => STArray s i e -> Int -> e -> ST s () -unsafeWriteSTArray (STArray _ _ marr#) (I# i#) e = ST $ \s1# ->-    case writeArray# marr# i# e s1#     of { s2# ->-    (# s2#, () #) }-\end{code}---%*********************************************************-%*							*-\subsection{Moving between mutable and immutable}-%*							*-%*********************************************************--\begin{code}-freezeSTArray :: Ix i => STArray s i e -> ST s (Array i e)-freezeSTArray (STArray l u marr#) = ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# arrEleBottom s1#  of { (# s2#, marr'# #) ->-    let copy i# s3# | i# ==# n# = s3#-                    | otherwise =-            case readArray# marr# i# s3# of { (# s4#, e #) ->-            case writeArray# marr'# i# e s4# of { s5# ->-            copy (i# +# 1#) s5# }} in-    case copy 0# s2#                    of { s3# ->-    case unsafeFreezeArray# marr'# s3#  of { (# s4#, arr# #) ->-    (# s4#, Array l u arr# #) }}}}--{-# INLINE unsafeFreezeSTArray #-}-unsafeFreezeSTArray :: Ix i => STArray s i e -> ST s (Array i e)-unsafeFreezeSTArray (STArray l u marr#) = ST $ \s1# ->-    case unsafeFreezeArray# marr# s1#   of { (# s2#, arr# #) ->-    (# s2#, Array l u arr# #) }--thawSTArray :: Ix i => Array i e -> ST s (STArray s i e)-thawSTArray (Array l u arr#) = ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# arrEleBottom s1#  of { (# s2#, marr# #) ->-    let copy i# s3# | i# ==# n# = s3#-                    | otherwise =-            case indexArray# arr# i#    of { (# e #) ->-            case writeArray# marr# i# e s3# of { s4# ->-            copy (i# +# 1#) s4# }} in-    case copy 0# s2#                    of { s3# ->-    (# s3#, STArray l u marr# #) }}}--{-# INLINE unsafeThawSTArray #-}-unsafeThawSTArray :: Ix i => Array i e -> ST s (STArray s i e)-unsafeThawSTArray (Array l u arr#) = ST $ \s1# ->-    case unsafeThawArray# arr# s1#      of { (# s2#, marr# #) ->-    (# s2#, STArray l u marr# #) }-\end{code}
− tests/HsOpenGLExt.h 
@@ -1,31 +0,0 @@-/* ------------------------------------------------------------------------------ *- * Module      :  GL extension support for Graphics.Rendering.OpenGL- * Copyright   :  (c) Sven Panne 2002-2004- * License     :  BSD-style (see the file libraries/OpenGL/LICENSE)- * - * Maintainer  :  sven.panne@aedion.de- * Stability   :  provisional- * Portability :  portable- *- * This header should only define preprocessor macros!- *- * -------------------------------------------------------------------------- */--#ifndef HSOPENGLEXT_H-#define HSOPENGLEXT_H--/* NOTE: The macro must immediately start with the foreign declaration,-   otherwise the magic mangler (hack_foreign) in the Hugs build system-   doesn't recognize it. */-#define EXTENSION_ENTRY(_msg,_entry,_ty) \-foreign import CALLCONV unsafe "dynamic" dyn_/**/_entry :: Graphics.Rendering.OpenGL.GL.Extensions.Invoker (_ty) ; \-_entry :: (_ty) ; \-_entry = dyn_##_entry ptr_##_entry ; \-ptr_/**/_entry :: FunPtr a ; \-ptr_/**/_entry = unsafePerformIO (Graphics.Rendering.OpenGL.GL.Extensions.getProcAddress (_msg) ("_entry")) ; \-{-# NOINLINE ptr_/**/_entry #-}--#endif--EXTENSION_ENTRY("GL_EXT_fog_coord or OpenGL 1.4",glFogCoorddEXT,GLdouble -> IO ())
− tests/MachDeps.h 
− tests/Storable.hs 
@@ -1,246 +0,0 @@-{-# OPTIONS -fno-implicit-prelude #-}--------------------------------------------------------------------------------- |--- Module      :  Foreign.Storable--- Copyright   :  (c) The FFI task force 2001--- License     :  see libraries/base/LICENSE--- --- Maintainer  :  ffi@haskell.org--- Stability   :  provisional--- Portability :  portable------ The module "Foreign.Storable" provides most elementary support for--- marshalling and is part of the language-independent portion of the--- Foreign Function Interface (FFI), and will normally be imported via--- the "Foreign" module.-----------------------------------------------------------------------------------module Foreign.Storable-	( Storable(-	     sizeOf,         -- :: a -> Int-	     alignment,      -- :: a -> Int-	     peekElemOff,    -- :: Ptr a -> Int      -> IO a-	     pokeElemOff,    -- :: Ptr a -> Int -> a -> IO ()-	     peekByteOff,    -- :: Ptr b -> Int      -> IO a-	     pokeByteOff,    -- :: Ptr b -> Int -> a -> IO ()-	     peek,           -- :: Ptr a             -> IO a-	     poke)           -- :: Ptr a        -> a -> IO ()-        ) where---#ifdef __NHC__-import NHC.FFI (Storable(..),Ptr,FunPtr,StablePtr-               ,Int8,Int16,Int32,Int64,Word8,Word16,Word32,Word64)-#else--import Control.Monad		( liftM )--#include "MachDeps.h"-#include "config.h"--#ifdef __GLASGOW_HASKELL__-import GHC.Storable-import GHC.Stable	( StablePtr )-import GHC.Num-import GHC.Int-import GHC.Word-import GHC.Stable-import GHC.Ptr-import GHC.Float-import GHC.Err-import GHC.IOBase-import GHC.Base-#else-import Data.Int-import Data.Word-import Foreign.Ptr-import Foreign.StablePtr-#endif--#ifdef __HUGS__-import Hugs.Prelude-import Hugs.Storable-#endif--{- |-The member functions of this class facilitate writing values of-primitive types to raw memory (which may have been allocated with the-above mentioned routines) and reading values from blocks of raw-memory.  The class, furthermore, includes support for computing the-storage requirements and alignment restrictions of storable types.--Memory addresses are represented as values of type @'Ptr' a@, for some-@a@ which is an instance of class 'Storable'.  The type argument to-'Ptr' helps provide some valuable type safety in FFI code (you can\'t-mix pointers of different types without an explicit cast), while-helping the Haskell type system figure out which marshalling method is-needed for a given pointer.--All marshalling between Haskell and a foreign language ultimately-boils down to translating Haskell data structures into the binary-representation of a corresponding data structure of the foreign-language and vice versa.  To code this marshalling in Haskell, it is-necessary to manipulate primtive data types stored in unstructured-memory blocks.  The class 'Storable' facilitates this manipulation on-all types for which it is instantiated, which are the standard basic-types of Haskell, the fixed size @Int@ types ('Int8', 'Int16',-'Int32', 'Int64'), the fixed size @Word@ types ('Word8', 'Word16',-'Word32', 'Word64'), 'StablePtr', all types from "Foreign.C.Types",-as well as 'Ptr'.--Minimal complete definition: 'sizeOf', 'alignment', one of 'peek',-'peekElemOff' and 'peekByteOff', and one of 'poke', 'pokeElemOff' and-'pokeByteOff'.--}--class Storable a where--   sizeOf      :: a -> Int-   -- ^ Computes the storage requirements (in bytes) of the argument.-   -- The value of the argument is not used.--   alignment   :: a -> Int-   -- ^ Computes the alignment constraint of the argument.  An-   -- alignment constraint @x@ is fulfilled by any address divisible-   -- by @x@.  The value of the argument is not used.--   peekElemOff :: Ptr a -> Int      -> IO a-   -- ^       Read a value from a memory area regarded as an array-   --         of values of the same kind.  The first argument specifies-   --         the start address of the array and the second the index into-   --         the array (the first element of the array has index-   --         @0@).  The following equality holds,-   -- -   -- > peekElemOff addr idx = IOExts.fixIO $ \result ->-   -- >   peek (addr `plusPtr` (idx * sizeOf result))-   ---   --         Note that this is only a specification, not-   --         necessarily the concrete implementation of the-   --         function.--   pokeElemOff :: Ptr a -> Int -> a -> IO ()-   -- ^       Write a value to a memory area regarded as an array of-   --         values of the same kind.  The following equality holds:-   -- -   -- > pokeElemOff addr idx x = -   -- >   poke (addr `plusPtr` (idx * sizeOf x)) x--   peekByteOff :: Ptr b -> Int      -> IO a-   -- ^       Read a value from a memory location given by a base-   --         address and offset.  The following equality holds:-   ---   -- > peekByteOff addr off = peek (addr `plusPtr` off)--   pokeByteOff :: Ptr b -> Int -> a -> IO ()-   -- ^       Write a value to a memory location given by a base-   --         address and offset.  The following equality holds:-   ---   -- > pokeByteOff addr off x = poke (addr `plusPtr` off) x-  -   peek        :: Ptr a      -> IO a-   -- ^ Read a value from the given memory location.-   ---   --  Note that the peek and poke functions might require properly-   --  aligned addresses to function correctly.  This is architecture-   --  dependent; thus, portable code should ensure that when peeking or-   --  poking values of some type @a@, the alignment-   --  constraint for @a@, as given by the function-   --  'alignment' is fulfilled.--   poke        :: Ptr a -> a -> IO ()-   -- ^ Write the given value to the given memory location.  Alignment-   -- restrictions might apply; see 'peek'.- -   -- circular default instances-#ifdef __GLASGOW_HASKELL__-   peekElemOff = peekElemOff_ undefined-      where peekElemOff_ :: a -> Ptr a -> Int -> IO a-            peekElemOff_ undef ptr off = peekByteOff ptr (off * sizeOf undef)-#else-   peekElemOff ptr off = peekByteOff ptr (off * sizeOfPtr ptr undefined)-#endif-   pokeElemOff ptr off val = pokeByteOff ptr (off * sizeOf val) val--   peekByteOff ptr off = peek (ptr `plusPtr` off)-   pokeByteOff ptr off = poke (ptr `plusPtr` off)--   peek ptr = peekElemOff ptr 0-   poke ptr = pokeElemOff ptr 0--#ifndef __GLASGOW_HASKELL__-sizeOfPtr :: Storable a => Ptr a -> a -> Int-sizeOfPtr px x = sizeOf x-#endif---- System-dependent, but rather obvious instances--instance Storable Bool where-   sizeOf _          = sizeOf (undefined::HTYPE_INT)-   alignment _       = alignment (undefined::HTYPE_INT)-   peekElemOff p i   = liftM (/= (0::HTYPE_INT)) $ peekElemOff (castPtr p) i-   pokeElemOff p i x = pokeElemOff (castPtr p) i (if x then 1 else 0::HTYPE_INT)--#define STORABLE(T,size,align,read,write)	\-instance Storable (T) where {			\-    sizeOf    _ = size;				\-    alignment _ = align;			\-    peekElemOff = read;				\-    pokeElemOff = write }--#ifdef __GLASGOW_HASKELL__-STORABLE(Char,SIZEOF_INT32,ALIGNMENT_INT32,-	 readWideCharOffPtr,writeWideCharOffPtr)-#elif defined(__HUGS__)-STORABLE(Char,SIZEOF_HSCHAR,ALIGNMENT_HSCHAR,-	 readCharOffPtr,writeCharOffPtr)-#endif--STORABLE(Int,SIZEOF_HSINT,ALIGNMENT_HSINT,-	 readIntOffPtr,writeIntOffPtr)--#ifdef __GLASGOW_HASKELL__-STORABLE(Word,SIZEOF_HSWORD,ALIGNMENT_HSWORD,-	 readWordOffPtr,writeWordOffPtr)-#endif--STORABLE((Ptr a),SIZEOF_HSPTR,ALIGNMENT_HSPTR,-	 readPtrOffPtr,writePtrOffPtr)--STORABLE((FunPtr a),SIZEOF_HSFUNPTR,ALIGNMENT_HSFUNPTR,-	 readFunPtrOffPtr,writeFunPtrOffPtr)--STORABLE((StablePtr a),SIZEOF_HSSTABLEPTR,ALIGNMENT_HSSTABLEPTR,-	 readStablePtrOffPtr,writeStablePtrOffPtr)--STORABLE(Float,SIZEOF_HSFLOAT,ALIGNMENT_HSFLOAT,-	 readFloatOffPtr,writeFloatOffPtr)--STORABLE(Double,SIZEOF_HSDOUBLE,ALIGNMENT_HSDOUBLE,-	 readDoubleOffPtr,writeDoubleOffPtr)--STORABLE(Word8,SIZEOF_WORD8,ALIGNMENT_WORD8,-	 readWord8OffPtr,writeWord8OffPtr)--STORABLE(Word16,SIZEOF_WORD16,ALIGNMENT_WORD16,-	 readWord16OffPtr,writeWord16OffPtr)--STORABLE(Word32,SIZEOF_WORD32,ALIGNMENT_WORD32,-	 readWord32OffPtr,writeWord32OffPtr)--STORABLE(Word64,SIZEOF_WORD64,ALIGNMENT_WORD64,-	 readWord64OffPtr,writeWord64OffPtr)--STORABLE(Int8,SIZEOF_INT8,ALIGNMENT_INT8,-	 readInt8OffPtr,writeInt8OffPtr)--STORABLE(Int16,SIZEOF_INT16,ALIGNMENT_INT16,-	 readInt16OffPtr,writeInt16OffPtr)--STORABLE(Int32,SIZEOF_INT32,ALIGNMENT_INT32,-	 readInt32OffPtr,writeInt32OffPtr)--STORABLE(Int64,SIZEOF_INT64,ALIGNMENT_INT64,-	 readInt64OffPtr,writeInt64OffPtr)--#endif
− tests/Test.hsc 
@@ -1,11 +0,0 @@-module Test where--main :: IO ()-main = putStrLn "shows a cpphs+hsc2hs bug with comments"--#def inline int that_one_will_work(void) {return 42;}--{--#def inline int cpphs_will_stumble(void) {return 42;}--}-
− tests/chains 
@@ -1,16 +0,0 @@-For this test, assume that all of e,f,g,h are defined.-Also that c,d are defined, a,b are not.-If cpphs does operator precedence wrongly in infix chains, the final-conditional will be interpreted wrongly.--#if defined(a) || defined(b) || defined(c) || defined(d)-chained || OK-#endif-#if defined(e) && defined(f) && defined(g) && defined(h)-chained && OK-#endif-#if defined(a) && defined(b) || defined(c) && defined(d)-mixed chain of || and && OK-#else-mixed chain of || and && BROKEN-#endif
− tests/comments 
@@ -1,3 +0,0 @@-here is an ordinary C comment:			/* comment here */-and here is a C++-style end-of-line comment:	// comment here-this line has no comments
− tests/config.h 
− tests/cpp 
@@ -1,9 +0,0 @@-#define /**/ ++ `mplus`		// not expected to work-#define 0   mzero		// not expected to work-#define x0  X'			// should work-#define x'  Xprime		// should work-#define `foo` .(foo)/**/,	// bizarreness--x ++ y = x0 * 0 * y `foo` x' --//  /*
− tests/elif 
@@ -1,10 +0,0 @@-#if ( defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ > 502 ) || \-    ( defined(__NHC__) && __NHC__ > 114 ) || defined(__HUGS__)-import System.IO.Unsafe (unsafePerformIO)-#elif defined(__GLASGOW_HASKELL__)-import IOExts (unsafePerformIO)-#elif defined(__NHC__)-import IOExtras (unsafePerformIO)-#elif defined(__HBC__)-import UnsafePerformIO-#endif
− tests/endcode-a 
@@ -1,3 +0,0 @@-\hidden{-\begin{code}-\end{code}}
− tests/endcode-b 
@@ -1,4 +0,0 @@-\hidden{-\begin{code}-\end{code}-}
− tests/expect1 
@@ -1,36 +0,0 @@-#line 1 "testfile"-1 top of file--3--5 X is defined--7----11----15----19----23 no inclusion, this is an else clause--25------31 third branch of elif--33-34 end of file-
− tests/expect10 
@@ -1,15 +0,0 @@-#line 1 "multiline"-----5 back to ordinary text.-#line 1 "./inclusion"-hello world, this is an inclusion--#line 7 "multiline"-7 hello again-8 some more-9 aLongMacroDefinition(a,b)-10 end-
− tests/expect11 
@@ -1,3 +0,0 @@-#line 1 "stringise"--This is "abcd ef" foo abcd ef
− tests/expect12 
@@ -1,5 +0,0 @@-#line 1 "recursive"----D D D D D D D D
− tests/expect13 
@@ -1,20 +0,0 @@-#line 1 "ross"-                                                         --                           ----f = 4--                                                             -----g = do { putStr "Hello ";   putStrLn "World" }--                          ---h = 4
− tests/expect14 
@@ -1,4 +0,0 @@-#line 1 "precedence"---
− tests/expect15 
@@ -1,6 +0,0 @@-#line 1 "indirect"--#line 1 "./inclusion"-hello world, this is an inclusion--#line 3 "indirect"
− tests/expect15a 
@@ -1,6 +0,0 @@-#line 1 "indirect-a"--#line 1 "./inclusion"-hello world, this is an inclusion--#line 3 "indirect-a"
− tests/expect16 
@@ -1,30 +0,0 @@-#line 1 "numbers"--number (1) in if--------number (0) in if------rejected false hex number in if----real hex number (0x1) in if--------hex number (0x00) in if-
− tests/expect17 
@@ -1,2 +0,0 @@-#line 1 "pragma"-
− tests/expect18 
@@ -1,1 +0,0 @@-
− tests/expect19 
@@ -1,6 +0,0 @@-#line 1 "parens"-----yes
− tests/expect2 
@@ -1,36 +0,0 @@-#line 1 "testfile"-1 top of file--3--5 X is defined--7----11----15----19----23 no inclusion, this is an else clause--25--27 no elif------33-34 end of file-
− tests/expect20 
@@ -1,17 +0,0 @@-#line 1 "chains"-For this test, assume that all of 1,1,1,1 are defined.-Also that 1,1 are defined, a,b are not.-If cpphs does operator precedence wrongly in infix chains, the final-conditional will be interpreted wrongly.---chained || OK---chained && OK---mixed chain of || and && OK---
− tests/expect21 
@@ -1,6 +0,0 @@-#line 1 "specials"--line 2-line 3-line 4  Error "horrible" at line 4 of file "specials"-line 5
− tests/expect22 
@@ -1,13 +0,0 @@-#line 1 "specialinclude"-1-2-#line 1 "./specials"--line 2-line 3-line 4  Error "horrible" at line 4 of file "./specials"-line 5--#line 4 "specialinclude"-4-5
− tests/expect23 
@@ -1,2 +0,0 @@-#line 1 "incomplete"-incomplete
− tests/expect24 
@@ -1,15 +0,0 @@-#line 1 "text"-Here is some ordinary text with embedded Haskell-ish constructs,-that should however /not/ be interpreted as Haskell if the --text-option is given to cpphs.  For instance, here is a Haskell comment-including a cpp definition: {--#  define FOO bar-and now we end the comment: -}   and try out the definition:  FOO-Likewise, double and single quotes no longer delimit strings or chars: "-#  define BAZ FOO-and what do we have here?: "  ' BAZ  '---Also, in text-mode, macros should be expanded inside Haskell comments:-    -- expand(this,other,that)-and strings "expand(this,other,that)".
− tests/expect25 
@@ -1,15 +0,0 @@-#line 1 "text"-Here is some ordinary text with embedded Haskell-ish constructs,-that should however /not/ be interpreted as Haskell if the --text-option is given to cpphs.  For instance, here is a Haskell comment-including a cpp definition: {---and now we end the comment: -}   and try out the definition:  bar-Likewise, double and single quotes no longer delimit strings or chars: "--and what do we have here?: "  ' bar  '---Also, in text-mode, macros should be expanded inside Haskell comments:-    -- Some text including this, the other, and that.-and strings "Some text including this, the other, and that.".
− tests/expect26 
@@ -1,17 +0,0 @@-#line 1 "nastyhack"---- hackery to convice cpp to splice 6.2.2 into a string-version :: String-version = tail "\ -    \ 6.2.2"--version2 = "6.2.2"---version3 = "6.2.2"---version4 = #6.2.2---version5 = "6.2.2"
− tests/expect27 
@@ -1,17 +0,0 @@-#line 1 "nastyhack"---- hackery to convice cpp to splice GHC_PKG_VERSION into a string-version :: String-version = tail "\ -    \ GHC_PKG_VERSION"--version2 = "GHC_PKG_VERSION"---version3 = "GHC_PKG_VERSION"---version4 = #6.2.2---version5 = "6.2.2"
− tests/expect28 
@@ -1,4 +0,0 @@-#line 1 "symbolvalue"--the symbol is defined as 1-
− tests/expect29 
@@ -1,12 +0,0 @@-#line 1 "Test.hsc"-module Test where--main :: IO ()-main = putStrLn "shows a cpphs+hsc2hs bug with comments"----{--#def inline int cpphs_will_stumble(void) {return 42;}--}-
− tests/expect3 
@@ -1,36 +0,0 @@-#line 1 "testfile"-1 top of file--3--5 X is defined--7----11----15----19----23 no inclusion, this is an else clause--25----29 this is an elif----33-34 end of file-
− tests/expect30 
@@ -1,685 +0,0 @@-#line 1 "Arr.lhs"--{-# OPTIONS_GHC -fno-implicit-prelude -fno-bang-patterns #-}--------------------------------------------------------------------------------- |--- Module      :  GHC.Arr--- Copyright   :  (c) The University of Glasgow, 1994-2000--- License     :  see libraries/base/LICENSE--- --- Maintainer  :  cvs-ghc@haskell.org--- Stability   :  internal--- Portability :  non-portable (GHC extensions)------ GHC\'s array implementation.--- ---------------------------------------------------------------------------------- #hide-module GHC.Arr where--import {-# SOURCE #-} GHC.Err ( error )-import GHC.Enum-import GHC.Num-import GHC.ST-import GHC.Base-import GHC.List-import GHC.Show--infixl 9  !, //--default ()------------- | The 'Ix' class is used to map a contiguous subrange of values in--- a type onto integers.  It is used primarily for array indexing--- (see "Data.Array", "Data.Array.IArray" and "Data.Array.MArray").------ The first argument @(l,u)@ of each of these operations is a pair--- specifying the lower and upper bounds of a contiguous subrange of values.------ An implementation is entitled to assume the following laws about these--- operations:------ * @'inRange' (l,u) i == 'elem' i ('range' (l,u))@------ * @'range' (l,u) '!!' 'index' (l,u) i == i@, when @'inRange' (l,u) i@------ * @'map' ('index' (l,u)) ('range' (l,u))) == [0..'rangeSize' (l,u)-1]@------ * @'rangeSize' (l,u) == 'length' ('range' (l,u))@------ Minimal complete instance: 'range', 'index' and 'inRange'.----class (Ord a) => Ix a where-    -- | The list of values in the subrange defined by a bounding pair.-    range		:: (a,a) -> [a]-    -- | The position of a subscript in the subrange.-    index		:: (a,a) -> a -> Int-    -- | Like 'index', but without checking that the value is in range.-    unsafeIndex		:: (a,a) -> a -> Int-    -- | Returns 'True' the given subscript lies in the range defined-    -- the bounding pair.-    inRange		:: (a,a) -> a -> Bool-    -- | The size of the subrange defined by a bounding pair.-    rangeSize		:: (a,a) -> Int-    -- | like 'rangeSize', but without checking that the upper bound is-    -- in range.-    unsafeRangeSize     :: (a,a) -> Int--	-- Must specify one of index, unsafeIndex-    index b i | inRange b i = unsafeIndex b i	-	      | otherwise   = error "Error in array index"-    unsafeIndex b i = index b i--    rangeSize b@(_l,h) | inRange b h = unsafeIndex b h + 1-		       | otherwise   = 0	-- This case is only here to-						-- check for an empty range-	-- NB: replacing (inRange b h) by (l <= h) fails for-	--     tuples.  E.g.  (1,2) <= (2,1) but the range is empty--    unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1---------------------- abstract these errors from the relevant index functions so that--- the guts of the function will be small enough to inline.--{-# NOINLINE indexError #-}-indexError :: Show a => (a,a) -> a -> String -> b-indexError rng i tp-  = error (showString "Ix{" . showString tp . showString "}.index: Index " .-           showParen True (showsPrec 0 i) .-	   showString " out of range " $-	   showParen True (showsPrec 0 rng) "")-------------------------------------------------------------------------instance  Ix Char  where-    {-# INLINE range #-}-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (m,_n) i = fromEnum i - fromEnum m--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Char"--    inRange (m,n) i	=  m <= i && i <= n-------------------------------------------------------------------------instance  Ix Int  where-    {-# INLINE range #-}-	-- The INLINE stops the build in the RHS from getting inlined,-	-- so that callers can fuse with the result of range-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (m,_n) i = i - m--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Int"--    {-# INLINE inRange #-}-    inRange (I# m,I# n) (I# i) =  m <=# i && i <=# n-------------------------------------------------------------------------instance  Ix Integer  where-    {-# INLINE range #-}-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (m,_n) i   = fromInteger (i - m)--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Integer"--    inRange (m,n) i	=  m <= i && i <= n-------------------------------------------------------------------------instance Ix Bool where -- as derived-    {-# INLINE range #-}-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (l,_) i = fromEnum i - fromEnum l--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Bool"--    inRange (l,u) i = fromEnum i >= fromEnum l && fromEnum i <= fromEnum u-------------------------------------------------------------------------instance Ix Ordering where -- as derived-    {-# INLINE range #-}-    range (m,n) = [m..n]--    {-# INLINE unsafeIndex #-}-    unsafeIndex (l,_) i = fromEnum i - fromEnum l--    index b i | inRange b i =  unsafeIndex b i-	      | otherwise   =  indexError b i "Ordering"--    inRange (l,u) i = fromEnum i >= fromEnum l && fromEnum i <= fromEnum u-------------------------------------------------------------------------instance Ix () where-    {-# INLINE range #-}-    range   ((), ())    = [()]-    {-# INLINE unsafeIndex #-}-    unsafeIndex   ((), ()) () = 0-    {-# INLINE inRange #-}-    inRange ((), ()) () = True-    {-# INLINE index #-}-    index b i = unsafeIndex b i-------------------------------------------------------------------------instance (Ix a, Ix b) => Ix (a, b) where -- as derived-    {-# SPECIALISE instance Ix (Int,Int) #-}--    {- INLINE range #-}-    range ((l1,l2),(u1,u2)) =-      [ (i1,i2) | i1 <- range (l1,u1), i2 <- range (l2,u2) ]--    {- INLINE unsafeIndex #-}-    unsafeIndex ((l1,l2),(u1,u2)) (i1,i2) =-      unsafeIndex (l1,u1) i1 * unsafeRangeSize (l2,u2) + unsafeIndex (l2,u2) i2--    {- INLINE inRange #-}-    inRange ((l1,l2),(u1,u2)) (i1,i2) =-      inRange (l1,u1) i1 && inRange (l2,u2) i2--    -- Default method for index-------------------------------------------------------------------------instance  (Ix a1, Ix a2, Ix a3) => Ix (a1,a2,a3)  where-    {-# SPECIALISE instance Ix (Int,Int,Int) #-}--    range ((l1,l2,l3),(u1,u2,u3)) =-        [(i1,i2,i3) | i1 <- range (l1,u1),-                      i2 <- range (l2,u2),-                      i3 <- range (l3,u3)]--    unsafeIndex ((l1,l2,l3),(u1,u2,u3)) (i1,i2,i3) =-      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (-      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (-      unsafeIndex (l1,u1) i1))--    inRange ((l1,l2,l3),(u1,u2,u3)) (i1,i2,i3) =-      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&-      inRange (l3,u3) i3--    -- Default method for index-------------------------------------------------------------------------instance  (Ix a1, Ix a2, Ix a3, Ix a4) => Ix (a1,a2,a3,a4)  where-    range ((l1,l2,l3,l4),(u1,u2,u3,u4)) =-      [(i1,i2,i3,i4) | i1 <- range (l1,u1),-                       i2 <- range (l2,u2),-                       i3 <- range (l3,u3),-                       i4 <- range (l4,u4)]--    unsafeIndex ((l1,l2,l3,l4),(u1,u2,u3,u4)) (i1,i2,i3,i4) =-      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (-      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (-      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (-      unsafeIndex (l1,u1) i1)))--    inRange ((l1,l2,l3,l4),(u1,u2,u3,u4)) (i1,i2,i3,i4) =-      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&-      inRange (l3,u3) i3 && inRange (l4,u4) i4--    -- Default method for index--instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5) => Ix (a1,a2,a3,a4,a5)  where-    range ((l1,l2,l3,l4,l5),(u1,u2,u3,u4,u5)) =-      [(i1,i2,i3,i4,i5) | i1 <- range (l1,u1),-                          i2 <- range (l2,u2),-                          i3 <- range (l3,u3),-                          i4 <- range (l4,u4),-                          i5 <- range (l5,u5)]--    unsafeIndex ((l1,l2,l3,l4,l5),(u1,u2,u3,u4,u5)) (i1,i2,i3,i4,i5) =-      unsafeIndex (l5,u5) i5 + unsafeRangeSize (l5,u5) * (-      unsafeIndex (l4,u4) i4 + unsafeRangeSize (l4,u4) * (-      unsafeIndex (l3,u3) i3 + unsafeRangeSize (l3,u3) * (-      unsafeIndex (l2,u2) i2 + unsafeRangeSize (l2,u2) * (-      unsafeIndex (l1,u1) i1))))--    inRange ((l1,l2,l3,l4,l5),(u1,u2,u3,u4,u5)) (i1,i2,i3,i4,i5) =-      inRange (l1,u1) i1 && inRange (l2,u2) i2 &&-      inRange (l3,u3) i3 && inRange (l4,u4) i4 && -      inRange (l5,u5) i5--    -- Default method for index----------type IPr = (Int, Int)---- | The type of immutable non-strict (boxed) arrays--- with indices in @i@ and elements in @e@.-data Ix i => Array     i e = Array   !i !i (Array# e)---- | Mutable, boxed, non-strict arrays in the 'ST' monad.  The type--- arguments are as follows:------  * @s@: the state variable argument for the 'ST' type------  * @i@: the index type of the array (should be an instance of 'Ix')------  * @e@: the element type of the array.----data         STArray s i e = STArray !i !i (MutableArray# s e)-	-- No Ix context for STArray.  They are stupid,-	-- and force an Ix context on the equality instance.---- Just pointer equality on mutable arrays:-instance Eq (STArray s i e) where-    STArray _ _ arr1# == STArray _ _ arr2# =-        sameMutableArray# arr1# arr2#-----------{-# NOINLINE arrEleBottom #-}-arrEleBottom :: a-arrEleBottom = error "(Array.!): undefined array element"---- | Construct an array with the specified bounds and containing values--- for given indices within these bounds.------ The array is undefined (i.e. bottom) if any index in the list is--- out of bounds.  The Haskell 98 Report further specifies that if any--- two associations in the list have the same index, the value at that--- index is undefined (i.e. bottom).  However in GHC's implementation,--- the value at such an index is the value part of the last association--- with that index in the list.------ Because the indices must be checked for these errors, 'array' is--- strict in the bounds argument and in the indices of the association--- list, but nonstrict in the values.  Thus, recurrences such as the--- following are possible:------ > a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i <- [2..100]])------ Not every index within the bounds of the array need appear in the--- association list, but the values associated with indices that do not--- appear will be undefined (i.e. bottom).------ If, in any dimension, the lower bound is greater than the upper bound,--- then the array is legal, but empty.  Indexing an empty array always--- gives an array-bounds error, but 'bounds' still yields the bounds--- with which the array was constructed.-{-# INLINE array #-}-array :: Ix i-	=> (i,i)	-- ^ a pair of /bounds/, each of the index type-			-- of the array.  These bounds are the lowest and-			-- highest indices in the array, in that order.-			-- For example, a one-origin vector of length-			-- '10' has bounds '(1,10)', and a one-origin '10'-			-- by '10' matrix has bounds '((1,1),(10,10))'.-	-> [(i, e)]	-- ^ a list of /associations/ of the form-			-- (/index/, /value/).  Typically, this list will-			-- be expressed as a comprehension.  An-			-- association '(i, x)' defines the value of-			-- the array at index 'i' to be 'x'.-	-> Array i e-array (l,u) ies = unsafeArray (l,u) [(index (l,u) i, e) | (i, e) <- ies]--{-# INLINE unsafeArray #-}-unsafeArray :: Ix i => (i,i) -> [(Int, e)] -> Array i e-unsafeArray (l,u) ies = runST (ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# arrEleBottom s1#  of { (# s2#, marr# #) ->-    foldr (fill marr#) (done l u marr#) ies s2# }})--{-# INLINE fill #-}-fill :: MutableArray# s e -> (Int, e) -> STRep s a -> STRep s a-fill marr# (I# i#, e) next s1# =-    case writeArray# marr# i# e s1#     of { s2# ->-    next s2# }--{-# INLINE done #-}-done :: Ix i => i -> i -> MutableArray# s e -> STRep s (Array i e)-done l u marr# s1# =-    case unsafeFreezeArray# marr# s1#   of { (# s2#, arr# #) ->-    (# s2#, Array l u arr# #) }---- This is inefficient and I'm not sure why:--- listArray (l,u) es = unsafeArray (l,u) (zip [0 .. rangeSize (l,u) - 1] es)--- The code below is better. It still doesn't enable foldr/build--- transformation on the list of elements; I guess it's impossible--- using mechanisms currently available.---- | Construct an array from a pair of bounds and a list of values in--- index order.-{-# INLINE listArray #-}-listArray :: Ix i => (i,i) -> [e] -> Array i e-listArray (l,u) es = runST (ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# arrEleBottom s1#  of { (# s2#, marr# #) ->-    let fillFromList i# xs s3# | i# ==# n# = s3#-                               | otherwise = case xs of-            []   -> s3#-            y:ys -> case writeArray# marr# i# y s3# of { s4# ->-                    fillFromList (i# +# 1#) ys s4# } in-    case fillFromList 0# es s2#         of { s3# ->-    done l u marr# s3# }}})---- | The value at the given index in an array.-{-# INLINE (!) #-}-(!) :: Ix i => Array i e -> i -> e-arr@(Array l u _) ! i = unsafeAt arr (index (l,u) i)--{-# INLINE unsafeAt #-}-unsafeAt :: Ix i => Array i e -> Int -> e-unsafeAt (Array _ _ arr#) (I# i#) =-    case indexArray# arr# i# of (# e #) -> e---- | The bounds with which an array was constructed.-{-# INLINE bounds #-}-bounds :: Ix i => Array i e -> (i,i)-bounds (Array l u _) = (l,u)---- | The list of indices of an array in ascending order.-{-# INLINE indices #-}-indices :: Ix i => Array i e -> [i]-indices (Array l u _) = range (l,u)---- | The list of elements of an array in index order.-{-# INLINE elems #-}-elems :: Ix i => Array i e -> [e]-elems arr@(Array l u _) =-    [unsafeAt arr i | i <- [0 .. rangeSize (l,u) - 1]]---- | The list of associations of an array in index order.-{-# INLINE assocs #-}-assocs :: Ix i => Array i e -> [(i, e)]-assocs arr@(Array l u _) =-    [(i, unsafeAt arr (unsafeIndex (l,u) i)) | i <- range (l,u)]---- | The 'accumArray' deals with repeated indices in the association--- list using an /accumulating function/ which combines the values of--- associations with the same index.--- For example, given a list of values of some index type, @hist@--- produces a histogram of the number of occurrences of each index within--- a specified range:------ > hist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b--- > hist bnds is = accumArray (+) 0 bnds [(i, 1) | i<-is, inRange bnds i]------ If the accumulating function is strict, then 'accumArray' is strict in--- the values, as well as the indices, in the association list.  Thus,--- unlike ordinary arrays built with 'array', accumulated arrays should--- not in general be recursive.-{-# INLINE accumArray #-}-accumArray :: Ix i-	=> (e -> a -> e)	-- ^ accumulating function-	-> e			-- ^ initial value-	-> (i,i)		-- ^ bounds of the array-	-> [(i, a)]		-- ^ association list-	-> Array i e-accumArray f init (l,u) ies =-    unsafeAccumArray f init (l,u) [(index (l,u) i, e) | (i, e) <- ies]--{-# INLINE unsafeAccumArray #-}-unsafeAccumArray :: Ix i => (e -> a -> e) -> e -> (i,i) -> [(Int, a)] -> Array i e-unsafeAccumArray f init (l,u) ies = runST (ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# init s1#          of { (# s2#, marr# #) ->-    foldr (adjust f marr#) (done l u marr#) ies s2# }})--{-# INLINE adjust #-}-adjust :: (e -> a -> e) -> MutableArray# s e -> (Int, a) -> STRep s b -> STRep s b-adjust f marr# (I# i#, new) next s1# =-    case readArray# marr# i# s1#        of { (# s2#, old #) ->-    case writeArray# marr# i# (f old new) s2# of { s3# ->-    next s3# }}---- | Constructs an array identical to the first argument except that it has--- been updated by the associations in the right argument.--- For example, if @m@ is a 1-origin, @n@ by @n@ matrix, then------ > m//[((i,i), 0) | i <- [1..n]]------ is the same matrix, except with the diagonal zeroed.------ Repeated indices in the association list are handled as for 'array':--- Haskell 98 specifies that the resulting array is undefined (i.e. bottom),--- but GHC's implementation uses the last association for each index.-{-# INLINE (//) #-}-(//) :: Ix i => Array i e -> [(i, e)] -> Array i e-arr@(Array l u _) // ies =-    unsafeReplace arr [(index (l,u) i, e) | (i, e) <- ies]--{-# INLINE unsafeReplace #-}-unsafeReplace :: Ix i => Array i e -> [(Int, e)] -> Array i e-unsafeReplace arr@(Array l u _) ies = runST (do-    STArray _ _ marr# <- thawSTArray arr-    ST (foldr (fill marr#) (done l u marr#) ies))---- | @'accum' f@ takes an array and an association list and accumulates--- pairs from the list into the array with the accumulating function @f@.--- Thus 'accumArray' can be defined using 'accum':------ > accumArray f z b = accum f (array b [(i, z) | i <- range b])----{-# INLINE accum #-}-accum :: Ix i => (e -> a -> e) -> Array i e -> [(i, a)] -> Array i e-accum f arr@(Array l u _) ies =-    unsafeAccum f arr [(index (l,u) i, e) | (i, e) <- ies]--{-# INLINE unsafeAccum #-}-unsafeAccum :: Ix i => (e -> a -> e) -> Array i e -> [(Int, a)] -> Array i e-unsafeAccum f arr@(Array l u _) ies = runST (do-    STArray _ _ marr# <- thawSTArray arr-    ST (foldr (adjust f marr#) (done l u marr#) ies))--{-# INLINE amap #-}-amap :: Ix i => (a -> b) -> Array i a -> Array i b-amap f arr@(Array l u _) =-    unsafeArray (l,u) [(i, f (unsafeAt arr i)) | i <- [0 .. rangeSize (l,u) - 1]]---- | 'ixmap' allows for transformations on array indices.--- It may be thought of as providing function composition on the right--- with the mapping that the original array embodies.------ A similar transformation of array values may be achieved using 'fmap'--- from the 'Array' instance of the 'Functor' class.-{-# INLINE ixmap #-}-ixmap :: (Ix i, Ix j) => (i,i) -> (i -> j) -> Array j e -> Array i e-ixmap (l,u) f arr =-    unsafeArray (l,u) [(unsafeIndex (l,u) i, arr ! f i) | i <- range (l,u)]--{-# INLINE eqArray #-}-eqArray :: (Ix i, Eq e) => Array i e -> Array i e -> Bool-eqArray arr1@(Array l1 u1 _) arr2@(Array l2 u2 _) =-    if rangeSize (l1,u1) == 0 then rangeSize (l2,u2) == 0 else-    l1 == l2 && u1 == u2 &&-    and [unsafeAt arr1 i == unsafeAt arr2 i | i <- [0 .. rangeSize (l1,u1) - 1]]--{-# INLINE cmpArray #-}-cmpArray :: (Ix i, Ord e) => Array i e -> Array i e -> Ordering-cmpArray arr1 arr2 = compare (assocs arr1) (assocs arr2)--{-# INLINE cmpIntArray #-}-cmpIntArray :: Ord e => Array Int e -> Array Int e -> Ordering-cmpIntArray arr1@(Array l1 u1 _) arr2@(Array l2 u2 _) =-    if rangeSize (l1,u1) == 0 then if rangeSize (l2,u2) == 0 then EQ else LT else-    if rangeSize (l2,u2) == 0 then GT else-    case compare l1 l2 of-        EQ    -> foldr cmp (compare u1 u2) [0 .. rangeSize (l1, min u1 u2) - 1]-        other -> other-    where-    cmp i rest = case compare (unsafeAt arr1 i) (unsafeAt arr2 i) of-        EQ    -> rest-        other -> other--{-# RULES "cmpArray/Int" cmpArray = cmpIntArray #-}-----------instance Ix i => Functor (Array i) where-    fmap = amap--instance (Ix i, Eq e) => Eq (Array i e) where-    (==) = eqArray--instance (Ix i, Ord e) => Ord (Array i e) where-    compare = cmpArray--instance (Ix a, Show a, Show b) => Show (Array a b) where-    showsPrec p a =-        showParen (p > appPrec) $-        showString "array " .-        showsPrec appPrec1 (bounds a) .-        showChar ' ' .-        showsPrec appPrec1 (assocs a)-	-- Precedence of 'array' is the precedence of application---- The Read instance is in GHC.Read------------------------{-# INLINE newSTArray #-}-newSTArray :: Ix i => (i,i) -> e -> ST s (STArray s i e)-newSTArray (l,u) init = ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# init s1#          of { (# s2#, marr# #) ->-    (# s2#, STArray l u marr# #) }}--{-# INLINE boundsSTArray #-}-boundsSTArray :: STArray s i e -> (i,i)  -boundsSTArray (STArray l u _) = (l,u)--{-# INLINE readSTArray #-}-readSTArray :: Ix i => STArray s i e -> i -> ST s e-readSTArray marr@(STArray l u _) i =-    unsafeReadSTArray marr (index (l,u) i)--{-# INLINE unsafeReadSTArray #-}-unsafeReadSTArray :: Ix i => STArray s i e -> Int -> ST s e-unsafeReadSTArray (STArray _ _ marr#) (I# i#) = ST $ \s1# ->-    readArray# marr# i# s1#--{-# INLINE writeSTArray #-}-writeSTArray :: Ix i => STArray s i e -> i -> e -> ST s () -writeSTArray marr@(STArray l u _) i e =-    unsafeWriteSTArray marr (index (l,u) i) e--{-# INLINE unsafeWriteSTArray #-}-unsafeWriteSTArray :: Ix i => STArray s i e -> Int -> e -> ST s () -unsafeWriteSTArray (STArray _ _ marr#) (I# i#) e = ST $ \s1# ->-    case writeArray# marr# i# e s1#     of { s2# ->-    (# s2#, () #) }-----------freezeSTArray :: Ix i => STArray s i e -> ST s (Array i e)-freezeSTArray (STArray l u marr#) = ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# arrEleBottom s1#  of { (# s2#, marr'# #) ->-    let copy i# s3# | i# ==# n# = s3#-                    | otherwise =-            case readArray# marr# i# s3# of { (# s4#, e #) ->-            case writeArray# marr'# i# e s4# of { s5# ->-            copy (i# +# 1#) s5# }} in-    case copy 0# s2#                    of { s3# ->-    case unsafeFreezeArray# marr'# s3#  of { (# s4#, arr# #) ->-    (# s4#, Array l u arr# #) }}}}--{-# INLINE unsafeFreezeSTArray #-}-unsafeFreezeSTArray :: Ix i => STArray s i e -> ST s (Array i e)-unsafeFreezeSTArray (STArray l u marr#) = ST $ \s1# ->-    case unsafeFreezeArray# marr# s1#   of { (# s2#, arr# #) ->-    (# s2#, Array l u arr# #) }--thawSTArray :: Ix i => Array i e -> ST s (STArray s i e)-thawSTArray (Array l u arr#) = ST $ \s1# ->-    case rangeSize (l,u)                of { I# n# ->-    case newArray# n# arrEleBottom s1#  of { (# s2#, marr# #) ->-    let copy i# s3# | i# ==# n# = s3#-                    | otherwise =-            case indexArray# arr# i#    of { (# e #) ->-            case writeArray# marr# i# e s3# of { s4# ->-            copy (i# +# 1#) s4# }} in-    case copy 0# s2#                    of { s3# ->-    (# s3#, STArray l u marr# #) }}}--{-# INLINE unsafeThawSTArray #-}-unsafeThawSTArray :: Ix i => Array i e -> ST s (STArray s i e)-unsafeThawSTArray (Array l u arr#) = ST $ \s1# ->-    case unsafeThawArray# arr# s1#      of { (# s2#, marr# #) ->-    (# s2#, STArray l u marr# #) }--
− tests/expect31 
@@ -1,11 +0,0 @@-#line 1 "elif"---import System.IO.Unsafe (unsafePerformIO)-------
− tests/expect32 
@@ -1,2 +0,0 @@-#line 1 "pragma"-#pragma  ident   "@(#)time.h     1.39    99/08/10 SMI"                
− tests/expect33 
@@ -1,1 +0,0 @@-#pragma  ident   "@(#)time.h     1.39    99/08/10 SMI"                
− tests/expect34 
@@ -1,11 +0,0 @@-#line 1 "igloo"----1---foo---
− tests/expect35 
@@ -1,12 +0,0 @@-#line 1 "igloo2"----baz-1---foo---
− tests/expect36 
@@ -1,12 +0,0 @@-#line 1 "igloo3"----quux-FOOFOO-----bar-
− tests/expect36a 
@@ -1,12 +0,0 @@-#line 1 "igloo3a"----quux-FOOFOO-----bar-
− tests/expect36b 
@@ -1,13 +0,0 @@-#line 1 "igloo3b"-----quux-11---foo---
− tests/expect37 
@@ -1,11 +0,0 @@-#line 1 "igloo4"---wibble-11---foo---
− tests/expect37a 
@@ -1,11 +0,0 @@-#line 1 "igloo4a"---wibble-11---foo---
− tests/expect38 
@@ -1,8 +0,0 @@-#line 1 "mauke"-------main = print 7 -- should print 7
− tests/expect39 
@@ -1,5 +0,0 @@-#line 1 "mauke2"----4
− tests/expect4 
@@ -1,39 +0,0 @@-#line 1 "testfile"-1 top of file--3--5 X is defined--7----11----15----19--#line 1 "./inclusion"-hello world, this is an inclusion--#line 22 "testfile"----25------31 third branch of elif--33-34 end of file-
− tests/expect40 
@@ -1,8 +0,0 @@-#line 1 "fasta"-------b7 = unsafeVisualize(foo)
− tests/expect40a 
@@ -1,7 +0,0 @@-#line 1 "fasta2"------b6 = unsafeVisualize(foo)
− tests/expect41 
@@ -1,6 +0,0 @@-#line 1 "hashjoin"-----2
− tests/expect42 
@@ -1,5 +0,0 @@-#line 1 "wrongline"--2-#line 20 "foo"-20
− tests/expect43 
@@ -1,6 +0,0 @@-#line 1 "param"-----11	-- gcc gives BARBAR, cpphs gives 11
− tests/expect44 
@@ -1,4 +0,0 @@-#line 1 "comments"-here is an ordinary C comment:			                  -and here is a C++-style end-of-line comment:	// comment here-this line has no comments
− tests/expect44a 
@@ -1,4 +0,0 @@-#line 1 "comments"-here is an ordinary C comment:			                  -and here is a C++-style end-of-line comment:	               -this line has no comments
− tests/expect45 
@@ -1,8 +0,0 @@-#line 1 "nestcomment"-{---foo-----}
− tests/expect46 
@@ -1,7 +0,0 @@-#line 1 "preinclude"-#line 1 "./inclusion"-hello world, this is an inclusion--#line 2 "preinclude"-#line 1 "preinclude"-something arbitrary
− tests/expect47 
@@ -1,5 +0,0 @@-#line 1 "endcode-a"----
− tests/expect48 
@@ -1,6 +0,0 @@-#line 1 "endcode-b"-----
− tests/expect49 
@@ -1,5 +0,0 @@-#line 1 "undef.hs"--wibble 3--this is FOO
− tests/expect5 
@@ -1,35 +0,0 @@-1 top of file--3--5 0 is defined--7----11----15----19--hello world, this is an inclusion-----25------31 third branch of elif--33-34 end of file
− tests/expect50 
@@ -1,9 +0,0 @@-{-# LINE 1 "linepragma" #-}-{-# LINE 1 "./inclusion" #-}-hello world, this is an inclusion--{-# LINE 2 "linepragma" #-}-{-# LINE 2 "linepragma" #-}--{-# LINE 3 "linepragma" #-}-
− tests/expect6 
@@ -1,10 +0,0 @@-#line 1 "cpp"-------x ++ y = X' * 0 * y .(foo), Xprime --//  /*
− tests/expect7 
@@ -1,297 +0,0 @@-#line 1 "Storable.hs"-{-# OPTIONS -fno-implicit-prelude #-}--------------------------------------------------------------------------------- |--- Module      :  Foreign.Storable--- Copyright   :  (c) The FFI task force 2001--- License     :  see libraries/base/LICENSE--- --- Maintainer  :  ffi@haskell.org--- Stability   :  provisional--- Portability :  portable------ The module "Foreign.Storable" provides most elementary support for--- marshalling and is part of the language-independent portion of the--- Foreign Function Interface (FFI), and will normally be imported via--- the "Foreign" module.-----------------------------------------------------------------------------------module Foreign.Storable-	( Storable(-	     sizeOf,         -- :: a -> Int-	     alignment,      -- :: a -> Int-	     peekElemOff,    -- :: Ptr a -> Int      -> IO a-	     pokeElemOff,    -- :: Ptr a -> Int -> a -> IO ()-	     peekByteOff,    -- :: Ptr b -> Int      -> IO a-	     pokeByteOff,    -- :: Ptr b -> Int -> a -> IO ()-	     peek,           -- :: Ptr a             -> IO a-	     poke)           -- :: Ptr a        -> a -> IO ()-        ) where--------import Control.Monad		( liftM )--#line 1 "./MachDeps.h"-#line 40 "Storable.hs"-#line 1 "./config.h"-#line 41 "Storable.hs"---import GHC.Storable-import GHC.Stable	( StablePtr )-import GHC.Num-import GHC.Int-import GHC.Word-import GHC.Stable-import GHC.Ptr-import GHC.Float-import GHC.Err-import GHC.IOBase-import GHC.Base-------------{- |-The member functions of this class facilitate writing values of-primitive types to raw memory (which may have been allocated with the-above mentioned routines) and reading values from blocks of raw-memory.  The class, furthermore, includes support for computing the-storage requirements and alignment restrictions of storable types.--Memory addresses are represented as values of type @'Ptr' a@, for some-@a@ which is an instance of class 'Storable'.  The type argument to-'Ptr' helps provide some valuable type safety in FFI code (you can\'t-mix pointers of different types without an explicit cast), while-helping the Haskell type system figure out which marshalling method is-needed for a given pointer.--All marshalling between Haskell and a foreign language ultimately-boils down to translating Haskell data structures into the binary-representation of a corresponding data structure of the foreign-language and vice versa.  To code this marshalling in Haskell, it is-necessary to manipulate primtive data types stored in unstructured-memory blocks.  The class 'Storable' facilitates this manipulation on-all types for which it is instantiated, which are the standard basic-types of Haskell, the fixed size @Int@ types ('Int8', 'Int16',-'Int32', 'Int64'), the fixed size @Word@ types ('Word8', 'Word16',-'Word32', 'Word64'), 'StablePtr', all types from "Foreign.C.Types",-as well as 'Ptr'.--Minimal complete definition: 'sizeOf', 'alignment', one of 'peek',-'peekElemOff' and 'peekByteOff', and one of 'poke', 'pokeElemOff' and-'pokeByteOff'.--}--class Storable a where--   sizeOf      :: a -> Int-   -- ^ Computes the storage requirements (in bytes) of the argument.-   -- The value of the argument is not used.--   alignment   :: a -> Int-   -- ^ Computes the alignment constraint of the argument.  An-   -- alignment constraint @x@ is fulfilled by any address divisible-   -- by @x@.  The value of the argument is not used.--   peekElemOff :: Ptr a -> Int      -> IO a-   -- ^       Read a value from a memory area regarded as an array-   --         of values of the same kind.  The first argument specifies-   --         the start address of the array and the second the index into-   --         the array (the first element of the array has index-   --         @0@).  The following equality holds,-   -- -   -- > peekElemOff addr idx = IOExts.fixIO $ \result ->-   -- >   peek (addr `plusPtr` (idx * sizeOf result))-   ---   --         Note that this is only a specification, not-   --         necessarily the concrete implementation of the-   --         function.--   pokeElemOff :: Ptr a -> Int -> a -> IO ()-   -- ^       Write a value to a memory area regarded as an array of-   --         values of the same kind.  The following equality holds:-   -- -   -- > pokeElemOff addr idx x = -   -- >   poke (addr `plusPtr` (idx * sizeOf x)) x--   peekByteOff :: Ptr b -> Int      -> IO a-   -- ^       Read a value from a memory location given by a base-   --         address and offset.  The following equality holds:-   ---   -- > peekByteOff addr off = peek (addr `plusPtr` off)--   pokeByteOff :: Ptr b -> Int -> a -> IO ()-   -- ^       Write a value to a memory location given by a base-   --         address and offset.  The following equality holds:-   ---   -- > pokeByteOff addr off x = poke (addr `plusPtr` off) x-  -   peek        :: Ptr a      -> IO a-   -- ^ Read a value from the given memory location.-   ---   --  Note that the peek and poke functions might require properly-   --  aligned addresses to function correctly.  This is architecture-   --  dependent; thus, portable code should ensure that when peeking or-   --  poking values of some type @a@, the alignment-   --  constraint for @a@, as given by the function-   --  'alignment' is fulfilled.--   poke        :: Ptr a -> a -> IO ()-   -- ^ Write the given value to the given memory location.  Alignment-   -- restrictions might apply; see 'peek'.- -   -- circular default instances--   peekElemOff = peekElemOff_ undefined-      where peekElemOff_ :: a -> Ptr a -> Int -> IO a-            peekElemOff_ undef ptr off = peekByteOff ptr (off * sizeOf undef)----   pokeElemOff ptr off val = pokeByteOff ptr (off * sizeOf val) val--   peekByteOff ptr off = peek (ptr `plusPtr` off)-   pokeByteOff ptr off = poke (ptr `plusPtr` off)--   peek ptr = peekElemOff ptr 0-   poke ptr = pokeElemOff ptr 0--------- System-dependent, but rather obvious instances--instance Storable Bool where-   sizeOf _          = sizeOf (undefined::HTYPE_INT)-   alignment _       = alignment (undefined::HTYPE_INT)-   peekElemOff p i   = liftM (/= (0::HTYPE_INT)) $ peekElemOff (castPtr p) i-   pokeElemOff p i x = pokeElemOff (castPtr p) i (if x then 1 else 0::HTYPE_INT)----------instance Storable (Char) where {			-    sizeOf    _ = SIZEOF_INT32;				-    alignment _ = ALIGNMENT_INT32;			-    peekElemOff = readWideCharOffPtr;				-    pokeElemOff = writeWideCharOffPtr }------instance Storable (Int) where {			-    sizeOf    _ = SIZEOF_HSINT;				-    alignment _ = ALIGNMENT_HSINT;			-    peekElemOff = readIntOffPtr;				-    pokeElemOff = writeIntOffPtr }---instance Storable (Word) where {			-    sizeOf    _ = SIZEOF_HSWORD;				-    alignment _ = ALIGNMENT_HSWORD;			-    peekElemOff = readWordOffPtr;				-    pokeElemOff = writeWordOffPtr }---instance Storable ((Ptr a)) where {			-    sizeOf    _ = SIZEOF_HSPTR;				-    alignment _ = ALIGNMENT_HSPTR;			-    peekElemOff = readPtrOffPtr;				-    pokeElemOff = writePtrOffPtr }--instance Storable ((FunPtr a)) where {			-    sizeOf    _ = SIZEOF_HSFUNPTR;				-    alignment _ = ALIGNMENT_HSFUNPTR;			-    peekElemOff = readFunPtrOffPtr;				-    pokeElemOff = writeFunPtrOffPtr }--instance Storable ((StablePtr a)) where {			-    sizeOf    _ = SIZEOF_HSSTABLEPTR;				-    alignment _ = ALIGNMENT_HSSTABLEPTR;			-    peekElemOff = readStablePtrOffPtr;				-    pokeElemOff = writeStablePtrOffPtr }--instance Storable (Float) where {			-    sizeOf    _ = SIZEOF_HSFLOAT;				-    alignment _ = ALIGNMENT_HSFLOAT;			-    peekElemOff = readFloatOffPtr;				-    pokeElemOff = writeFloatOffPtr }--instance Storable (Double) where {			-    sizeOf    _ = SIZEOF_HSDOUBLE;				-    alignment _ = ALIGNMENT_HSDOUBLE;			-    peekElemOff = readDoubleOffPtr;				-    pokeElemOff = writeDoubleOffPtr }--instance Storable (Word8) where {			-    sizeOf    _ = SIZEOF_WORD8;				-    alignment _ = ALIGNMENT_WORD8;			-    peekElemOff = readWord8OffPtr;				-    pokeElemOff = writeWord8OffPtr }--instance Storable (Word16) where {			-    sizeOf    _ = SIZEOF_WORD16;				-    alignment _ = ALIGNMENT_WORD16;			-    peekElemOff = readWord16OffPtr;				-    pokeElemOff = writeWord16OffPtr }--instance Storable (Word32) where {			-    sizeOf    _ = SIZEOF_WORD32;				-    alignment _ = ALIGNMENT_WORD32;			-    peekElemOff = readWord32OffPtr;				-    pokeElemOff = writeWord32OffPtr }--instance Storable (Word64) where {			-    sizeOf    _ = SIZEOF_WORD64;				-    alignment _ = ALIGNMENT_WORD64;			-    peekElemOff = readWord64OffPtr;				-    pokeElemOff = writeWord64OffPtr }--instance Storable (Int8) where {			-    sizeOf    _ = SIZEOF_INT8;				-    alignment _ = ALIGNMENT_INT8;			-    peekElemOff = readInt8OffPtr;				-    pokeElemOff = writeInt8OffPtr }--instance Storable (Int16) where {			-    sizeOf    _ = SIZEOF_INT16;				-    alignment _ = ALIGNMENT_INT16;			-    peekElemOff = readInt16OffPtr;				-    pokeElemOff = writeInt16OffPtr }--instance Storable (Int32) where {			-    sizeOf    _ = SIZEOF_INT32;				-    alignment _ = ALIGNMENT_INT32;			-    peekElemOff = readInt32OffPtr;				-    pokeElemOff = writeInt32OffPtr }--instance Storable (Int64) where {			-    sizeOf    _ = SIZEOF_INT64;				-    alignment _ = ALIGNMENT_INT64;			-    peekElemOff = readInt64OffPtr;				-    pokeElemOff = writeInt64OffPtr }--
− tests/expect8 
@@ -1,37 +0,0 @@-#line 1 "HsOpenGLExt.h"-/* ------------------------------------------------------------------------------ *- * Module      :  GL extension support for Graphics.Rendering.OpenGL- * Copyright   :  (c) Sven Panne 2002-2004- * License     :  BSD-style (see the file libraries/OpenGL/LICENSE)- * - * Maintainer  :  sven.panne@aedion.de- * Stability   :  provisional- * Portability :  portable- *- * This header should only define preprocessor macros!- *- * -------------------------------------------------------------------------- */-----/* NOTE: The macro must immediately start with the foreign declaration,-   otherwise the magic mangler (hack_foreign) in the Hugs build system-   doesn't recognize it. */-----------foreign import ccall unsafe "dynamic" dyn_glFogCoorddEXT :: Graphics.Rendering.OpenGL.GL.Extensions.Invoker (GLdouble -> IO ()) ; -glFogCoorddEXT :: (GLdouble -> IO ()) ; -glFogCoorddEXT = dyn_glFogCoorddEXT ptr_glFogCoorddEXT ; -ptr_glFogCoorddEXT :: FunPtr a ; -ptr_glFogCoorddEXT = unsafePerformIO (Graphics.Rendering.OpenGL.GL.Extensions.getProcAddress ("GL_EXT_fog_coord or OpenGL 1.4") ("glFogCoorddEXT")) ; -{-# NOINLINE ptr_glFogCoorddEXT #-}
− tests/expect9 
@@ -1,16 +0,0 @@-#line 1 "multiline"-----5 back to ordinary text.-#line 1 "./inclusion"-hello world, this is an inclusion--#line 7 "multiline"-7 hello again-8 some more-9 some line here;	-	and some more;	-	finish now-10 end
− tests/fasta 
@@ -1,7 +0,0 @@-#define XCONCAT(a, b) a##b-#define CONCAT(a, b) XCONCAT(a, b)-#define PS(val) () <- trace (val) (return ())-#define VIS(ioaction) let CONCAT(b, __LINE__) = unsafeVisualize(ioaction)-#define V(ioaction) CONCAT(b, __LINE__) = unsafeVisualize(ioaction)--V(foo)
− tests/fasta2 
@@ -1,6 +0,0 @@-#define XCONCAT(a, b) a##b-#define CONCAT(a, b) XCONCAT(a, b)-#define PS(val) () <- trace (val) (return ())-#define VIS(ioaction) let CONCAT(b, __LINE__) = unsafeVisualize(ioaction)-#define V(ioaction) CONCAT(b, __LINE__) = unsafeVisualize(ioaction)-V(foo)
− tests/hashjoin 
@@ -1,5 +0,0 @@-#define FOO 1-#define BAR FOO##FOO-#define FOOFOO 2--BAR
− tests/igloo 
@@ -1,10 +0,0 @@-#define FOO 1-#define BAR FOO--BAR--#if BAR == 1-foo-#else-bar-#endif
− tests/igloo2 
@@ -1,11 +0,0 @@-#define FOO 1-#define BAZ(x) x--baz-BAZ(1)--#if BAZ(1) == 1-foo-#else-bar-#endif
− tests/igloo3 
@@ -1,11 +0,0 @@-#define FOO 1-#define QUUX FOO ## FOO--quux-QUUX--#if QUUX == 11-foo-#else-bar-#endif
− tests/igloo3a 
@@ -1,11 +0,0 @@-#define FOO 1-#define QUUX FOO##FOO--quux-QUUX--#if QUUX == 11-foo-#else-bar-#endif
− tests/igloo3b 
@@ -1,12 +0,0 @@-#define FOO 1-#define QUUX(a) a ## a-#define WIBBLE QUUX(FOO)--quux-WIBBLE--#if WIBBLE == 11-foo-#else-bar-#endif
− tests/igloo4 
@@ -1,10 +0,0 @@-#define WIBBLE 1 ## 1--wibble-WIBBLE--#if WIBBLE == 11-foo-#else-bar-#endif
− tests/igloo4a 
@@ -1,10 +0,0 @@-#define WIBBLE 1##1--wibble-WIBBLE--#if WIBBLE == 11-foo-#else-bar-#endif
− tests/inclusion 
@@ -1,1 +0,0 @@-hello world, this is an inclusion
− tests/incomplete 
@@ -1,1 +0,0 @@-incomplete
− tests/indirect 
@@ -1,2 +0,0 @@-#define F "inclusion"-#include F
− tests/indirect-a 
@@ -1,2 +0,0 @@-#define F(f) in##f-#include F(clusion)
− tests/linepragma 
@@ -1,5 +0,0 @@-#include "inclusion"-#line 2 "linepragma"--#line 3 "linepragma"-
− tests/mauke 
@@ -1,7 +0,0 @@-#define X /\-* comment */ main--#define Y _\-_LINE__--X = print Y -- should print 7
− tests/mauke2 
@@ -1,4 +0,0 @@-#define foo _\-_LINE__--foo
− tests/multiline 
@@ -1,10 +0,0 @@-#define aLongMacroDefinition(x,y)	\-	some line here;	\-	and some more;	\-	finish now-5 back to ordinary text.-#include "inclusion"-7 hello again-8 some more-9 aLongMacroDefinition(a,b)-10 end
− tests/nastyhack 
@@ -1,16 +0,0 @@-#define GHC_PKG_VERSION 6.2.2--- hackery to convice cpp to splice GHC_PKG_VERSION into a string-version :: String-version = tail "\ -    \ GHC_PKG_VERSION"--version2 = "GHC_PKG_VERSION"--#define v3 "GHC_PKG_VERSION"-version3 = v3--#define stringify(s) #s-version4 = stringify(GHC_PKG_VERSION)--#define stringify2(s) "s"-version5 = stringify2(GHC_PKG_VERSION)
− tests/nestcomment 
@@ -1,7 +0,0 @@-{--#if 1-foo-#else-bar-#endif--}
− tests/numbers 
@@ -1,29 +0,0 @@-#if 1-number (1) in if-#else-rejected number (1) in if-#endif--#if 0-wrongly accepted number (0) in if-#else-number (0) in if-#endif--#if eaf-false hex number in if-#else-rejected false hex number in if-#endif--#if 0x1-real hex number (0x1) in if-#else-rejected real hex number (0x1) in if-#endif--#if 0x00-wrongly accepted real hex number (0x00) in if-#else-hex number (0x00) in if-#endif
− tests/param 
@@ -1,5 +0,0 @@-#define FOO 1-#define BAR FOO-#define JOIN(f)  f##f--JOIN(BAR)	-- gcc gives BARBAR, cpphs gives 11
− tests/parens 
@@ -1,5 +0,0 @@-#if ( defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 600 ) \-    || ( defined(__NHC__) && __NHC__ >= 117 )-#define FINALIZERPTR yes-#endif-FINALIZERPTR
− tests/pragma 
@@ -1,1 +0,0 @@-#pragma  ident   "@(#)time.h     1.39    99/08/10 SMI"   /* SVr4.0 1.18 */
− tests/precedence 
@@ -1,3 +0,0 @@-#if !0 && 0-boolean operator precedence is wrong-#endif
− tests/preinclude 
@@ -1,1 +0,0 @@-something arbitrary
− tests/recursive 
@@ -1,4 +0,0 @@-#define C D D-#define B C C-#define A B B-A
− tests/ross 
@@ -1,19 +0,0 @@-/* 1. C comments should be deleted by the preprocessor */--/* 2. repeated expansion */-#define FOO 4-#define BAR FOO--f = BAR--/* 3. continuation lines in macros shouldn't give newlines */-#define LONG_MACRO \-{ putStr "Hello "; \-  putStrLn "World" }--g = do LONG_MACRO--/* 4. projection macros */-#define MACRO(x) x--h = MACRO(FOO)
− tests/runtests 
@@ -1,71 +0,0 @@-#!/bin/sh-CPPHS=${1:-"../cpphs"}-FAIL=0--runtest() {-  if $1 >out 2>/dev/null && diff $2 out >/dev/null-  then echo "passed: " $1-  else FAIL=$?-       echo "FAILED: ($2) " $1-  fi-}--if $CPPHS </dev/null; then echo -n "passed: "; else echo -n "FAILED: "; fi-echo " $CPPHS </dev/null"-runtest "$CPPHS --nomacro testfile" expect1-runtest "$CPPHS --nomacro -Dnoelif testfile" expect2-runtest "$CPPHS --nomacro -Delif testfile" expect3-runtest "$CPPHS --nomacro -Dinclude testfile" expect4-runtest "$CPPHS --noline -Dinclude testfile" expect5-runtest "$CPPHS cpp" expect6-runtest "$CPPHS -D__GLASGOW_HASKELL__ --layout Storable.hs " expect7-runtest "$CPPHS -DCALLCONV=ccall --hashes --layout HsOpenGLExt.h" expect8-runtest "$CPPHS --layout multiline" expect9-runtest "$CPPHS --nomacro multiline" expect10-runtest "$CPPHS --hashes stringise" expect11-runtest "$CPPHS recursive" expect12-runtest "$CPPHS --strip ross" expect13-runtest "$CPPHS precedence" expect14-runtest "$CPPHS indirect" expect15-runtest "$CPPHS --hashes indirect-a" expect15a-runtest "$CPPHS numbers" expect16-runtest "$CPPHS pragma" expect17		# see also test 32-runtest "$CPPHS --noline pragma" expect18	# see also test 33-runtest "$CPPHS -D__NHC__=117 parens" expect19-runtest "$CPPHS -Dc -Dd -De -Df -Dg -Dh chains" expect20-runtest "$CPPHS --hashes specials" expect21-runtest "$CPPHS --hashes specialinclude" expect22-runtest "$CPPHS incomplete" expect23-runtest "$CPPHS text" expect24-runtest "$CPPHS --text text" expect25-runtest "$CPPHS --text nastyhack" expect26-runtest "$CPPHS nastyhack" expect27-runtest "$CPPHS -DXXX symbolvalue" expect28-runtest "$CPPHS Test.hsc" expect29-runtest "$CPPHS --unlit Arr.lhs" expect30-runtest "$CPPHS -D__NHC__=118 elif" expect31-runtest "$CPPHS --pragma pragma" expect32-runtest "$CPPHS --pragma --noline pragma" expect33-runtest "$CPPHS igloo" expect34-runtest "$CPPHS igloo2" expect35-runtest "$CPPHS --hashes igloo3" expect36-runtest "$CPPHS --hashes igloo3a" expect36a-runtest "$CPPHS --hashes igloo3b" expect36b-runtest "$CPPHS --hashes igloo4" expect37-runtest "$CPPHS --hashes igloo4a" expect37a-runtest "$CPPHS mauke" expect38-runtest "$CPPHS mauke2" expect39-runtest "$CPPHS --hashes fasta" expect40-runtest "$CPPHS --hashes fasta2" expect40a-runtest "$CPPHS --hashes hashjoin" expect41-runtest "$CPPHS wrongline" expect42-runtest "$CPPHS --hashes param" expect43-runtest "$CPPHS --strip comments" expect44-runtest "$CPPHS --strip-eol comments" expect44a-runtest "$CPPHS nestcomment" expect45-runtest "$CPPHS --include=inclusion preinclude" expect46-runtest "$CPPHS --unlit endcode-a" expect47-runtest "$CPPHS --unlit endcode-b" expect48-runtest "$CPPHS undef.hs" expect49-runtest "$CPPHS --linepragma linepragma" expect50-exit $FAIL
− tests/specialinclude 
@@ -1,5 +0,0 @@-1-2-#include "specials"-4-5
− tests/specials 
@@ -1,5 +0,0 @@-#define error(s)	Error #s at line __LINE__ of file __FILE__-line 2-line 3-line 4  error(horrible)-line 5
− tests/stringise 
@@ -1,2 +0,0 @@-#define foo(x)	This is #x foo x-foo(abcd ef)
− tests/symbolvalue 
@@ -1,3 +0,0 @@-#if XXX-the symbol is defined as XXX-#endif
− tests/testfile 
@@ -1,34 +0,0 @@-1 top of file-#define X 0-3-#ifdef X-5 X is defined-#endif-7-#if X-9 X is non-zero-#endif-11-#if error-#error "error message goes here"-#endif-15-#if warning-#warning "warning message goes here"-#endif-19-#if include-#include "inclusion"-#else-23 no inclusion, this is an else clause-#endif-25-#if noelif-27 no elif-#elif elif-29 this is an elif-#else-31 third branch of elif-#endif-33-34 end of file
− tests/text 
@@ -1,14 +0,0 @@-Here is some ordinary text with embedded Haskell-ish constructs,-that should however /not/ be interpreted as Haskell if the --text-option is given to cpphs.  For instance, here is a Haskell comment-including a cpp definition: {--#  define FOO bar-and now we end the comment: -}   and try out the definition:  FOO-Likewise, double and single quotes no longer delimit strings or chars: "-#  define BAZ FOO-and what do we have here?: "  ' BAZ  '--#  define expand(a,b,c)	  Some text including a, the b, and c.-Also, in text-mode, macros should be expanded inside Haskell comments:-    -- expand(this,other,that)-and strings "expand(this,other,that)".
− tests/undef.hs 
@@ -1,4 +0,0 @@-#define FOO 3-wibble FOO-#undef FOO-this is FOO
− tests/wrongline 
@@ -1,4 +0,0 @@-#define whereami __LINE__-whereami-#line 20 "foo"-__LINE__