diff --git a/.boring b/.boring new file mode 100644 --- /dev/null +++ b/.boring @@ -0,0 +1,59 @@ +# Project specific +\.setup-config$ +autom4te\.cache +c2hs\.spec$ +c2hs/c/CLexer\.hs$ +c2hs/c/CParser\.hs$ +c2hs/c2hs$ +c2hs/c2hs-inplace$ +c2hs/tests/.*\.hs$ +c2hs/tests/.*\.h$ +\.chi$ +c2hs/tests/enums$ +c2hs/tests/marsh$ +c2hs/tests/pointer$ +c2hs/tests/structs$ +c2hs/toplevel/C2HSConfig\.hs$ +c2hs/toplevel/Version\.hs$ +config\.log$ +config\.status$ +configure$ +^dist +doc/c2hs/Makefile$ +doc/c2hs/.*\.html$ +doc/c2hs/.*\.txt$ +doc/c2hs/man1/c2hs.1 +postInst\.sh +# +# Boring file regexps: +\.hi$ +\.o$ +\.o\.cmd$ +\.ko$ +\.ko\.cmd$ +\.mod\.c$ +(^|/)\.tmp_versions($|/) +(^|/)CVS($|/) +(^|/)RCS($|/) +~$ +#(^|/)\.[^/] +(^|/)_darcs($|/) +\.bak$ +\.BAK$ +\.orig$ +(^|/)vssver\.scc$ +\.swp$ +(^|/)MT($|/) +(^|/)\{arch\}($|/) +(^|/).arch-ids($|/) +(^|/), +\.class$ +\.prof$ +(^|/)\.DS_Store$ +(^|/)BitKeeper($|/) +(^|/)ChangeSet($|/) +(^|/)\.svn($|/) +\.py[co]$ +\# +\.cvsignore$ +(^|/)Thumbs\.db$ diff --git a/.gitignore b/.gitignore new file mode 100644 --- /dev/null +++ b/.gitignore @@ -0,0 +1,170 @@ +/.cabal-sandbox/* +/cabal.sandbox.config +*.chi +*.chs.h +/dist/* +*.hi +/issues/* +*.o +/.shelly/*.txt +/tests/bugs/call_capital/Capital +/tests/bugs/call_capital/Capital.chi +/tests/bugs/call_capital/Capital.chs.h +/tests/bugs/call_capital/Capital_c.o +/tests/bugs/call_capital/Capital.hi +/tests/bugs/call_capital/Capital.hs +/tests/bugs/call_capital/Capital.o +/tests/bugs/issue-09/Issue09.hs +/tests/bugs/issue-102/Issue102 +/tests/bugs/issue-102/Issue102.hs +/tests/bugs/issue-103/Issue103A.hs +/tests/bugs/issue-103/Issue103.hs +/tests/bugs/issue-107/Issue107 +/tests/bugs/issue-107/Issue107.hs +/tests/bugs/issue-10/Issue10 +/tests/bugs/issue-10/Issue10.hs +/tests/bugs/issue-10/Issue10.i +/tests/bugs/issue-113/Issue113 +/tests/bugs/issue-113/Issue113.hs +/tests/bugs/issue-115/Issue115 +/tests/bugs/issue-115/Issue115.hs +/tests/bugs/issue-116/Issue116 +/tests/bugs/issue-116/Issue116.hs +/tests/bugs/issue-15/Issue15 +/tests/bugs/issue-15/Issue15.hs +/tests/bugs/issue-16/Issue16 +/tests/bugs/issue-16/Issue16.hs +/tests/bugs/issue-19/Issue19 +/tests/bugs/issue-19/Issue19.hs +/tests/bugs/issue-20/Issue20.i +/tests/bugs/issue-22/Issue22 +/tests/bugs/issue-22/Issue22.hs +/tests/bugs/issue-23/Issue23 +/tests/bugs/issue-23/Issue23.hs +/tests/bugs/issue-29/Issue29.hs +/tests/bugs/issue-29/Issue29.i +/tests/bugs/issue-30/Issue30 +/tests/bugs/issue-30/Issue30Aux1.hs +/tests/bugs/issue-30/Issue30Aux2.hs +/tests/bugs/issue-30/Issue30.hs +/tests/bugs/issue-31/Issue31 +/tests/bugs/issue-31/Issue31.hs +/tests/bugs/issue-32/Issue32 +/tests/bugs/issue-32/Issue32.hs +/tests/bugs/issue-36/Issue36 +/tests/bugs/issue-36/Issue36.hs +/tests/bugs/issue-37/Issue37 +/tests/bugs/issue-37/Issue37.hs +/tests/bugs/issue-38/Issue38 +/tests/bugs/issue-38/Issue38.hs +/tests/bugs/issue-43/Issue43 +/tests/bugs/issue-43/Issue43.hs +/tests/bugs/issue-44/Issue44 +/tests/bugs/issue-44/Issue44.hs +/tests/bugs/issue-45/Issue45 +/tests/bugs/issue-45/Issue45.hs +/tests/bugs/issue-46/Issue46 +/tests/bugs/issue-46/Issue46.hs +/tests/bugs/issue-47/Issue47 +/tests/bugs/issue-47/Issue47.hs +/tests/bugs/issue-51/Issue51 +/tests/bugs/issue-51/Issue51_GNU +/tests/bugs/issue-51/Issue51_GNU.hs +/tests/bugs/issue-51/Issue51.hs +/tests/bugs/issue-51/Issue51_nonGNU +/tests/bugs/issue-51/Issue51_nonGNU.hs +/tests/bugs/issue-54/Issue54 +/tests/bugs/issue-54/Issue54.hs +/tests/bugs/issue-60/Issue60 +/tests/bugs/issue-60/Issue60.hs +/tests/bugs/issue-60/Issue60.i +/tests/bugs/issue-62/Issue62 +/tests/bugs/issue-62/Issue62.hs +/tests/bugs/issue-65/Issue65 +/tests/bugs/issue-65/Issue65.hs +/tests/bugs/issue-69/Issue69 +/tests/bugs/issue-69/Issue69.hs +/tests/bugs/issue-70/Issue70.hs +/tests/bugs/issue-73/Issue73 +/tests/bugs/issue-73/Issue73.hs +/tests/bugs/issue-75/Issue75 +/tests/bugs/issue-75/Issue75.hs +/tests/bugs/issue-79/Issue79 +/tests/bugs/issue-79/Issue79.hs +/tests/bugs/issue-7/Issue7.hs +/tests/bugs/issue-7/Issue7.i +/tests/bugs/issue-80/Issue80 +/tests/bugs/issue-80/Issue80.hs +/tests/bugs/issue-82/Issue82 +/tests/bugs/issue-82/Issue82.hs +/tests/bugs/issue-83/Issue83 +/tests/bugs/issue-83/Issue83.hs +/tests/bugs/issue-93/Issue93 +/tests/bugs/issue-93/Issue93.hs +/tests/bugs/issue-95/Issue95 +/tests/bugs/issue-95/Issue95.hs +/tests/bugs/issue-96/Issue103 +/tests/bugs/issue-96/Issue96 +/tests/bugs/issue-96/Issue96.hs +/tests/bugs/issue-97/Issue97 +/tests/bugs/issue-97/Issue97A.hs +/tests/bugs/issue-97/Issue97.hs +/tests/bugs/issue-98/Issue98 +/tests/bugs/issue-98/Issue98.hs +/tests/bugs/issue-9/Issue9 +/tests/bugs/issue-9/Issue9.hs +/tests/system/calls/Calls.hs +/tests/system/cpp/Cpp.hs +/tests/system/enums/enums +/tests/system/enums/Enums.hs +/tests/system/marsh/marsh +/tests/system/marsh/Marsh.hs +/tests/system/pointer/pointer +/tests/system/pointer/Pointer.hs +/tests/system/simple/simple +/tests/system/simple/Simple.hs +/tests/system/sizeof/sizeof +/tests/system/sizeof/Sizeof.hs +/tests/system/structs/structs +/tests/system/structs/Structs.hs +/tests/bugs/issue-20/Issue20 +/tests/bugs/issue-20/Issue20.hs +/tests/bugs/issue-25/Issue25 +/tests/bugs/issue-25/Issue25.hs +/tests/bugs/issue-48/Issue48 +/tests/bugs/issue-48/Issue48.hs +/tests/bugs/issue-123/Issue123 +/tests/bugs/issue-123/Issue123.hs +/tests/bugs/issue-102/issue-102.txt +/tests/bugs/issue-117/Issue117 +/tests/bugs/issue-117/Issue117.hs +/tests/bugs/issue-117/Issue117.chs.c +/tests/bugs/issue-127/Issue127 +/tests/bugs/issue-127/Issue127.hs +/tests/bugs/issue-128/Issue128 +/tests/bugs/issue-128/Issue128.chs.c +/tests/bugs/issue-128/Issue128.hs +/tests/bugs/issue-131/Issue131.chs.c +/tests/bugs/issue-131/Issue131.hs +/tests/bugs/issue-131/Issue131 +/tests/bugs/issue-130/Issue130 +/tests/bugs/issue-130/Issue130.hs +/tests/bugs/issue-133/Issue133 +/tests/bugs/issue-133/Issue133.hs +/tests/bugs/issue-136/Issue136.hs +/tests/bugs/issue-136/Issue136 +/tests/bugs/issue-134/Issue134 +/tests/bugs/issue-134/Issue134.hs +/tests/bugs/issue-151/Issue151.hs +/tests/bugs/issue-149/Issue149 +/tests/bugs/issue-149/Issue149.hs +/tests/bugs/issue-141/Issue141A.hs +/tests/bugs/issue-141/Issue141B.hs +/tests/bugs/issue-152/Issue152 +/tests/bugs/issue-140/Issue140 +/tests/bugs/issue-140/Issue140.hs +/tests/bugs/issue-152/Issue152.hs +/tests/bugs/issue-155/Issue155 +/tests/bugs/issue-155/Issue155.hs +/tests/bugs/issue-152/Issue152.hs +/tests/bugs/issue-155/Types.hs diff --git a/.travis.yml b/.travis.yml new file mode 100644 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,30 @@ +env: + global: + - AWS_ACCESS_KEY_ID=AKIAIKUEH2ETWTBS2CKQ + - secure: "Jzawnhgk3dX2INzbZIlnHCH+aKWqy96B9T1hzBh/Fqp4whglaZDO0mTLHQnhypqAt1rXO2o3yBNcKgGOcgfUuE71uBCzzaXieB0p8BhYn7cwYeANbuKNOGrsP6oDutS5F57FNWwgRp+2oanpgJNOs/6wvfElA7W6ibN8tZiLQrw=" + matrix: + - GHCVER=7.10.3 + +before_install: + - travis_retry sudo add-apt-repository -y ppa:hvr/ghc + - travis_retry sudo apt-get update + - travis_retry sudo apt-get install libnetcdf-dev libgsl0-dev liblapack-dev + - travis_retry sudo apt-get install cabal-install-1.24 ghc-$GHCVER-prof ghc-$GHCVER-dyn happy + - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/1.24/bin:$PATH + +install: + - sudo apt-get update -qq + - sudo pip install awscli + - cabal update + - | + if [ $GHCVER = "head" ] || [ ${GHCVER%.*} = "7.8" ] || [ ${GHCVER%.*} = "7.10" ]; then + travis_retry sudo apt-get install happy-1.19.5 alex-3.1.7 + export PATH=/opt/alex/3.1.7/bin:/opt/happy/1.19.5/bin:$PATH + else + travis_retry sudo apt-get install happy alex + fi + - cabal install --only-dependencies --enable-tests -fregression + +script: + - cabal install && cabal configure --enable-tests -fregression && cabal build && cabal test + - ./dist/build/regression-suite/regression-suite diff --git a/ChangeLog b/ChangeLog --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,5 @@ +0.28.3 + - Switch to language-c 0.7.1 [#192] 0.28.2 - Switch to language-c 0.6 [#176] 0.28.1 diff --git a/ChangeLog.CTKlight b/ChangeLog.CTKlight new file mode 100644 --- /dev/null +++ b/ChangeLog.CTKlight @@ -0,0 +1,465 @@ +2005-05-18 Manuel M. T. Chakravarty + + * Makefile: Evil Hack to be able create base.build.conf before + building `libctk.a' + +2005-05-18 André Pang + + * Adaptation to GHC 6.4 and the Cabal package system + +2005-05-18 Manuel M. T. Chakravarty + + * admin/BaseVersion.hs (versnum): 0.27.0 + +2004-05-15 Manuel M. T. Chakravarty + + * configure.in: Using `egrep' is available (as grep on SunOS + doesn't handle regular expressions) noticed by Matthias Neubauer + + + * syntax/Parsers.hs (execParser): Added a token mapping as an + extra argument + +2003-10-19 Manuel M T Chakravarty + + * configure.in: Support for Mac OS X by Sean Seefried + + +2003-10-19 Manuel M T Chakravarty + + * sysdep/Makefile: Posix (and hence, `runPiped') support disabled, + as `runPiped' (1) isn't really used at the moment, (2) should be + rewritten anyway, and (3) breaks with GHC 6.3 as the signature of + `forkProcess' changed. + + * admin/BaseVersion.hs (versnum): 0.26.0 + +2003-06-10 Manuel M T Chakravarty + + * ../mk/common.mk (MKDEPENDFILES): defined ghc6 + + * syntax/Makefile (RANK2): defined ghc6 + + * sysdep/Makefile (SRCS): defined SysDepGHC6.hs as an alias for + SysDepGHC4.hs + + * admin/BaseVersion.hs (versnum): 0.25.1 + +2003-03-13 Manuel M T Chakravarty + + * general/Sets.hs (domSetFM): added + + * general/FiniteMaps.hs (domFM): added + (imageFM): added + + * admin/BaseVersion.hs (versnum): 0.25.0 + +2003-02-12 Manuel M T Chakravarty + + * general/UNames.hs: we derive `Show Name' explicitly to print the + number only + +2003-02-05 Manuel M T Chakravarty + + * general/FileOps.hs (mktemp): added + +2003-02-01 Manuel M T Chakravarty + + * ../common.mk: I wasn't careful when removing the ability (for + the user) to invoke make in the part directories and hence the + ability to check dependencies in these directories. As a result, + recursive invocations of make tried to check dependencies in part + directories and erroneously decided that the target is alreasy up + to date. Now the object file are removed before descending into + the recursive make. + + * ../common.mk (gendepend): remove $(DEPEND) first + + * admin/BaseVersion.hs (versnum): 0.24.3 + +2002-09-16 Manuel M T Chakravarty + + * Makefile (libctk.o): generating library for GHCi + +2002-09-06 Manuel M T Chakravarty + + * Makefile (OBJS): excluded state/DynArrays.o from the target + objects for nhc98 (as it chokes on that module) + +2002-05-16 Manuel M T Chakravarty + + * changed name if base package to `ctk' to not clash with GHC's + new package naming scheme + + * admin/BaseVersion.hs (versnum): 0.24.2 + +2002-03-22 Manuel M T Chakravarty + + * ../configure.in: test for availability of the `posix' package + made more reliable + + * admin/BaseVersion.hs (versnum): 0.24.1 + +2002-03-12 Manuel M T Chakravarty + + * Makefile: revised to new build system + + * admin/BaseVersion.hs (versnum): 0.24.0 + +2002-03-06 Manuel M T Chakravarty + + * general/Sets.hs (isSuperSet): cut'n'pasto + +2002-03-05 Manuel M T Chakravarty + + * Makefile: fixed libctk.a target + + * ../configure.in: make sure to include the posix package only for + GHC (and not for nhc98) + + * admin/BaseVersion.hs (versnum): 0.23.1 + +2002-02-11 Manuel M T Chakravarty + + * Makefile: we are now creating a library archive to use packages + +2002-02-10 Manuel M T Chakravarty + + * ../mk/common.mk: added package support + + * ../configure.in: added package support; replaced -syslib by -package + + * admin/BaseVersion.hs (versnum): 0.23.0 + +2002-01-06 Manuel M T Chakravarty + + * common.mk: removed TMP as it causes problems on cygwin as + reported by Karl M. Syring + + * admin/BaseVersion.hs (versnum): 0.22.5 + +2001-09-26 Manuel M. T. Chakravarty + + * general/UNames.hs: nhc98 1.08 doesn't grok deriving Ix + + * ../configure.in: better support for nhc98 + + * admin/BaseVersion.hs (versnum): 0.22.4 + +2001-05-20 Manuel M. T. Chakravarty + + * state/CIO.hs (doesFileExistCIO): added by Axel Simon + +2001-05-13 Manuel M. T. Chakravarty + + * Makefile (spotless): remove config.cache + +2001-04-21 Manuel M. T. Chakravarty + + * ../configure.in: Adapted to support ghc 5.x and removed support + for ghc 3.x + + * admin/BaseVersion.hs (versnum): 0.22.3 + +2000-10-05 Manuel M. T. Chakravarty + + * ../configure.in: uses the fptools macro for determining ghc's + version number + +2000-10-02 Manuel M. T. Chakravarty + + * errors/Errors.hs (showError): special handling of internal positions + + * admin/Common.hs: added internal positions + + * admin/BaseVersion.hs (versnum): 0.22.2 + +2000-09-15 Manuel M. T. Chakravarty + + * ../configure.in: corrected ghc version number extraction to + correctly handle patch levels; added happy - most have gone lost + earlier... + +2000-09-12 Manuel M. T. Chakravarty + + * syntax/Pretty.hs (<>): debugged + +2000-09-11 Manuel M. T. Chakravarty + + * syntax/Pretty.hs (Pretty): type class for pretty printing + (infixOp): added + (usedWhen): added + (punctuate): added + (dot): added + + * admin/BaseVersion.hs (versnum): 0.22.1 + +2000-09-07 Manuel M. T. Chakravarty + + * syntax/Pretty.hs: Revision of the interface; the interface is + now 90% compatible to SimonPJ's `Pretty' module; debugging + (fullRender): dropping leading '\n's + some more combinators + + * admin/BaseVersion.hs (versnum): 0.22.0 + +2000-09-03 Manuel M. T. Chakravarty + + * admin/Common.hs (tabPos): Roman pointed out that tab stops + should be at 1, 9, ... rather than 0, 8, ... + +2000-09-02 Manuel M. T. Chakravarty + + * admin/BaseVersion.hs (versnum): 0.21.1 + +2000-08-18 Manuel M. T. Chakravarty + + * sysdep/Makefile: Moved the posix stuff into an extra module, + which can be enabled individually + + * ../configure.in: CygWin support; based on suggestions by Anibal + Maffioletti Rodrigues de DEUS + + * ../configure.in: uses -silent on lndir only if supported (isn't + supported before X11R6, says Jan Kort ) + + * admin/BaseVersion.hs (versnum): 0.21.0 + +2000-08-08 Manuel M. T. Chakravarty + + * syntax/Lexers.hs: Changed the associativity of `quest`, `star`, + and `plus`. This change was suggested by Martin Norbäck + . + + ** WARNING ** This change may break some existing code!!! + +2000-06-19 Manuel M. T. Chakravarty + + * admin/BaseVersion.hs (versnum): 0.20.2 + +2000-04-06 Manuel M. T. Chakravarty + + * ../configure.in: -fasm-x86 is used only if --with-ghc-native is given + + * general/Sets.hs (powerSet): impl + +2000-04-05 Manuel M. T. Chakravarty + + * general/Sets.hs: derived Eq and Ord for FMs, which allows sets + of sets and added `isSubSet' and `isSuperSet' + + * general/FiniteMaps.hs: derived Eq and Ord for FMs + + * admin/BaseVersion.hs (date): 0.20.1 + +2000-03-04 Manuel M. T. Chakravarty + + * ../configure.in: fixes re compiler & option selection + +2000-03-01 Manuel M. T. Chakravarty + + * ../mk/common.mk: fixed dependency computations + + * ../configure.in: polished; on Linux, uses native code generator + when compiling with GHC 4.0x, x >= 7 + +2000-02-27 Manuel M. T. Chakravarty + + * syntax/Parsers.hs: table handling substantially rewritten to + improve the space behaviour + + * general/Utils.hs: `Tag' class + + * admin/BaseVersion.hs (versnum): 0.20.0 + +2000-02-23 Manuel M. T. Chakravarty + + * ../mk/config.mk.in: set correct access modes in INSTALL_DATA + +1999-12-06 Manuel M. T. Chakravarty + + * graphs/Marks.hs: newly implemented + + * admin/BaseVersion.hs (versnum): 0.19.1 + +1999-12-03 Manuel M. T. Chakravarty + + * syms/Attributes.hs: instance Ord Attrs + +1999-12-02 Manuel M. T. Chakravarty + + * sysdep/SysDepNHC1.hs: debugging + +1999-12-01 Manuel M. T. Chakravarty + + * ../configure.in,../mk/common.mk: better dependency tool computation + + * syms/Idents.hs: uses `Attributed' + + * syms/Attributes.hs: `Attributed' type class, as suggested by + Roman Lechtchinsky + + * admin/BaseVersion.hs (versnum): 0.19.0 + + * sysdep/SysDepNHC1.hs: Started the system dependent module for + nhc98 with assistance from Malcolm Wallace + +1999-11-30 Manuel M. T. Chakravarty + + * state/StateTrans.hs: Adapted to new names in mutable variables API + + * general/UNames.hs: Adapted to new names in mutable variables API + + * sysdep/SysDepGHC3.hs: adapted to new names of exported entities + + * sysdep/SysDepGHC4.hs: Cleaned up; no GHC internal stuff is used + anymore (some of the names of exported entities changed!) + + * sysdep/Makefile: Added support for nhc98 + + * ../configure.in & friends: Added support for nhc98 + + * admin/BaseVersion.hs (versnum): 0.18.2 + +1999-11-17 Manuel M. T. Chakravarty + + * ../mk/config.mk.in: introduced `docdir' and `pkgdocdir' + + * Make system debianised, according to the suggestions and the + patches of Michael Weber + + * admin/BaseVersion.hs (versnum): 0.18.1 + +1999-11-07 Manuel M. T. Chakravarty + + * general/FileOps.hs (fileFindIn): debugged + +1999-11-06 Manuel M. T. Chakravarty + + * general/FileOps.hs: new module; implemented `fileFindIn' + + * general/FNameOps.hs (addPath): added + + * admin/BaseVersion.hs (versnum): 0.18.0 + +1999-10-29 Manuel M. T. Chakravarty + + * admin/BaseVersion.hs (versnum): 0.17.17; fully modularised the + make system + +1999-10-25 Manuel M. T. Chakravarty + + * state/CIO.hs (removeFileCIO): added + + * admin/BaseVersion.hs (versnum): 0.17.16 + +1999-10-24 Manuel M. T. Chakravarty + + * syms/NameSpaces.hs (nameSpaceToList): added + + * admin/BaseVersion.hs (versnum): 0.17.15 + +1999-10-21 Manuel M. T. Chakravarty + + * syms/Idents.hs (isLegalIdent): corrected `checkTail' - thanx Sven + +1999-10-16 Manuel M. T. Chakravarty + + * syms/NameSpaces.hs (defLocal): uses `defGloal' if there is no + local range + + +Pre GNU-style change log +------------------------ + +0.17.13 +~~~~~~~ +09Oct99 Debugging + +0.17.12 +~~~~~~~ +27Sep99 `CIO.systemCIO' +26Sep99 Debugging and some more clean up of `Lexers' +25Sep99 Some convenience function on `Position's in `Common' +23Sep99 Added `\v' to the control lexer + +0.17.11 +~~~~~~~ +22Sep99 Optimised and extended `Lexers' (meta actions can now return tokens or + error messages); prepared the first separate distribution of CTKlight +21Sep99 Debugged `Lexers' + +0.17.10 +~~~~~~~ +29Aug99 Added `Utils.lookupBy' + +0.17.9 +~~~~~~ +22Aug99 Throughly revised `Lexers' (according to SPJ's suggestions) +12Aug99 Revised `Lexers.execLexer' (returns final state, changed semantics + of meta actions slightly, and structure simplified) + +0.17.8 +~~~~~~ +30Jul99 Clarified `NameSpaces' +19Jul99 Using Roman's `Parsers.seplist1' + +0.17.7 +~~~~~~ +05Jul99 `Lexers' exports `ctrlLexer' + +0.17.6 +~~~~~~ +07Jun99 Small additions to `Idents' +03Jun99 Small additions to `Attributes' + +0.17.5 +~~~~~~ +05Apr99 Configurable makefile variables from common.mk into new config.mk +02Apr99 Small bug fixes +31Mar99 `Parsers': Support for parsing prefixes +30Mar99 Bug fixes (incl. `Parsers.sep') + +0.17.4 +~~~~~~ +13Mar99 Added meta actions to `Parsers' +12Mar99 Revised for GHC 4.02 and Haskell 98 +11Mar99 Extension of parser library with threaded state +04Mar99 Self-optimizing lexer library for regular expressions +27Feb99 Self-optimizing LL(1) parser library a la Swierstra/Duponcheel + +0.16.0 +~~~~~~ +11Feb99 `Idents.cloneIdent' & standard attributes in `Attributes' + +0.15.0 +~~~~~~ +02Feb99 `Set' module + +0.14.2 +~~~~~~ +23Jan99 `Ident' got an instance for `Show' + +0.14.1 +~~~~~~ +01Dec98 Extracted mk/dhc.mk and mk/nepal.mk from mk/common.mk + +0.14.0 +~~~~~~ +13Nov98 Rewrote `CST' into `PreCST' that provides an extra state (part of the + base state) that can be instantiated by an client compiler using the + Toolkit. As a consequence, `state/Switches' can be moved into DHC. + +0.13.0 +~~~~~~ +10Nov98 admin/Version.hs + +0.12.0 +~~~~~~ +19Oct98 Added Sven Panne's `GetOpt' to general/ + +0.11.1 +~~~~~~ +23Sep98 Completely overhauled Makefile system. + +29Jul98 Finished extraction from what was originally called the HiPar toolkit. diff --git a/README.CTKlight b/README.CTKlight new file mode 100644 --- /dev/null +++ b/README.CTKlight @@ -0,0 +1,80 @@ + Compiler Toolkit - Light -*-text-*- + ======================== + +Contents: + + README.CTKlight -- This file + LICENSE.LIB -- GNU Library General Public License (LGPL) + BaseVersion.hs -- Version, copyright, and disclaimer + Config.hs -- Configuration module + Common.hs -- Basic definitions, such as representation of positions + DLists.hs -- Difference lists - provide O(1) append + Errors.hs -- Types and functions for error handling + FNameOps.hs -- Common operations on file names + FiniteMaps.hs -- Finite maps based on 2-3 trees + GetOpt.hs -- Sven Panne's Haskell version of the GNU getopt library + Lexers.hs -- Self-optimising lexer combinators + Parsers.hs -- Self-optimising parser combinators + Pretty.hs -- Pretty printing combinators (the interface is essentially + a superset of SimonPJ's pretty printing library) + Sets.hs -- Sets as an instance of the above mentioned finite maps + Utils.hs -- Utility routines + +The Compiler Toolkit Light (CTKlight) is a subset of the Compiler Toolkit +(CTK) - an infrastructure for writing compilers in Haskell. CTKlight +essentially provides support for implementing syntactical analysis without the +more heavy-weight state management (like compiler switches, global error pool, +and exceptions), identifier and attribute management, and various other +utilities included in the full CTK. Both packages can be obtained from + + http://www.cse.unsw.edu.au/~chak/ctk/ + + +-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- BUILDING -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +In contrast to full CTK, CTKlight is simply a set of Haskell modules without +any complicated makefile structure. The code is Haskell 98 compliant with the +exception that `Parser.hs' makes use of existentially quantified type +variables - unfortunately, I do not believe that the same method of +self-optimisation would work without existential types. + +The modules are tested with + +* GHC 4.02 and upwards (use `-fglasgow-exts' to compile `Parsers.hs') and +* Hugs98 (use `-98' when using `Parsers.hs'). + +If you want autoconf, a ready-made makefile structure, and much more +additional library functionality, then use full CTK. + + +-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- COPYLEFT -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +This library is free software; you can redistribute it and/or modify it under +the terms of the GNU Library General Public License as published by the Free +Software Foundation; either version 2 of the License, or (at your option) any +later version. + +This library is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more +details. + +You should have received a copy of the GNU Library General Public License +along with this system; if not, write to the Free Software Foundation, Inc., +675 Mass Ave, Cambridge, MA 02139, USA. + +Note: In essence this means that you can use this library in any program + whether it is free or proprietary. However, if you modify or extend the + library itself, you are bound to distribute these modifications or + extensions according to the terms and conditions of the LGPL. For + details consult the license itself, which is located in the file + `LICENSE.LIB'. + + +-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- CREDITS -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- + +Author & Maintainer: Manuel M. T. Chakravarty + +Thanks to Simon L. Peyton Jones and Roman Lechtchinsky + for their helpful suggestions that improved the +design and implementation of the `Lexers' module. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,35 @@ +[![Build Status](https://travis-ci.org/haskell/c2hs.svg?branch=master)](https://travis-ci.org/haskell/c2hs) + +`c2hs` is a interfacing tool that eases Haskell access to C libraries. +The tool gets information about the C data type definitions and +function signatures by analysing the C header files of the library. +It uses this information to compute the missing details in the +template of a Haskell module — called the binding file — +that implements a Haskell binding to the C library. Hooks embedded in +the binding file signal where, which, and how C objects are accessed +from Haskell. The Haskell code in the binding file determines Haskell +types signatures and marshaling details. + +Further information is on the +[wiki](https://github.com/haskell/c2hs/wiki/Home). Also see the +[user guide](https://github.com/haskell/c2hs/wiki/User-Guide) (also +available in the `doc` directory of the repository). + + +## Installing + +To install `c2hs` from Hackage: + + cabal install c2hs + +If you like to build from the GitHub repository, see the file +`INSTALL`. See the `REGRESSION-SUITE` file for a description of how +to run the regression suite for checking C2HS performance against +existing Haskell packages that use it. + + +## License + +All code **generated by** `c2hs` is under a BSD licence. Hence, `c2hs` is useful for both open and closed source projects. + +The tool itself is released under the GPLv2. This is the same situation as for the GNU C Compiler. For details, see the file `COPYING`. diff --git a/REGRESSION-SUITE b/REGRESSION-SUITE new file mode 100644 --- /dev/null +++ b/REGRESSION-SUITE @@ -0,0 +1,50 @@ + C2HS REGRESSION SUITE + ~~~~~~~~~~~~~~~~~~~~~ + +C2HS is flexible enough that it's difficult to write a test suite that +covers all the cases of interest to users. As well as a general test +suite and tests for individual issues, it makes sense to test for C2HS +regressions by installing a range of packages that use C2HS. + +The regression suite is managed as a single Cabal test suite called +regression-suite. This reads a YAML configuration file giving a list +of packages to test against. The test suite succeeds if a "cabal +install" of each of the test packages succeeds without error, using +the current version of C2HS. + +This process requires care for two reasons: + + 1. Because C2HS is an FFI tool, packages that use C2HS almost always + have dependencies on external libraries, so writing a simple test + suite is not straightforward. + + 2. It's undesireable to install a whole set of Haskell packages for + C2HS regression testing into the user's environment. + +To handle these two issues, the regression-suite test suite behaves as +follows: + + ON TRAVIS + + - Always run the regression suite. + + - Install all library dependencies before attempting to install + Haskell packages. These dependencies are given in the regression + suite configuration file as lists of APT package names, optionally + with PPAs to install them from, or as lists of shell commands to + use to install the dependencies. + + ON NON-TRAVIS SYSTEMS + + - Only run the regression suite if the C2HS_REGRESSION_SUITE + environment variable is defined. + + - Assume that all C library dependencies are already installed. + + - Set Cabal flags from environment variables called + C2HS_REGRESSION_FLAGS_ if these variables exist. + + +The idea is to test for regressions under well-controlled conditions +at each commit on Travis, but maintain the possibility of running the +regression suite locally as well. diff --git a/TODO b/TODO new file mode 100644 --- /dev/null +++ b/TODO @@ -0,0 +1,289 @@ + -*-text-*- + C2HS TODO + ========= + +Next: - enum hooks should define cFromEnum/cToEnum as the default marshallers + (see comment at GenBind.lookupDftMarshIn). + + - Especially with function hooks, it is not sufficient to emit line + pragmas whenever a new CHS fragment starts. As some hooks expand to + multiple lines of Haskell code, we need to reemit the line number of + the hook once for each line of Haskell generated from it. + + - Points raised by PeteG: + * The initial comment put by c2hs shouldn't be put in the first line, + as this makes it difficult to add {-# OPTIONS #-} pragma to the .chs + file, as this pragma must be in the first line. + + The only sensible solution seems to be to copy the first line of the + .chs file on top if it starts with the string "{-# OPTIONS". + + - Ian requests {#const SYM#} where SYM is a pre-preprocessor symbol to + evaluate to the C value of SYM. Main problem is that the value might + be of various C types. + + - Tutorial + + - GenBind.setGet: How is it justified that `bitsPerField' is + fixed to the size of `CInt'? Does the C def guarantee + that bitfields types are of the same size? + + Next Major feature to be added: structure marshalling. + + - the `hsverb' should be normalised with respect to white space and + parenthesis + + - have an option to compute .chi dependencies; do this on a + module-by-module basis generating many small depend files rather than + one big one + + - Pending suggestions from Axel Simon: + + succ/pred definitions for enum hooks + + - marshalling of structs + + - We need to handle the time stamps of .chi files more carefully; + otherwise, we often get lots of unnecessary re-runs of c2hs. + + - Conceptual problem with import hooks: Currently, everything imported + from a .chi file by a binding module is also dumped into its own .chi + file. Is is not generally correct, but it would also not be correct + to omit everything that has been imported. The conceptually correct + solution would be to dump an entry for a type into a .chi file if the + corresponding Haskell type is exported by the binding module. To + achieve this, we would also need an export hook. Moreover, we may + import the same object from different modules, due to an implicit + reexport at the moment. Either eliminate those reexports, or we have + the same problems as in Haskell to determine object identity. + + - c2hs has to properly process GNU C "aligned" attributes. Otherwise, + it's routine to calculate structure layout may deviate from that of + the C compiler, which may lead to nasty bugs in bindings. + + - the use of get/set hooks with `class'ed newtypes is complicated, as + the type doesn't match `Ptr a'; see, eg, `GtkCList.cListGetNoOfRows' + + - class methods should be able to get user-defined names (needed for + GtkData.chs) + + - GenBind.mergePtrMap could be improved (see the comment) + + - {#enum ...#} should create an instance of Storable as follows: + instance Storable MyEnum where + sizeOf _ = sizeOf (undefined :: CInt) + alignment _ = alignment (undefined :: CInt) + + peek p = liftM cToEnum $ peek (castPtr p :: Ptr CInt) + poke p v = poke (castPtr p :: Ptr CInt) (cFromEnum v) + + - `GenBind.setGet' needs to take `C2HSConfig.bitfieldDirection' into + account; otherwise, setting and getting of bitfields won't work on + architectures where bitfields start at the MSB (rather than the LSB) + + - Vorschlag von Axel Krauth : + An option with which c2hs prints a list of all functions that have not + been bound in a header file. The Position info schould be sufficient + to determine this. Maybe also add {#ignore foo#}, which makes it not + list a given identifier (for private functions listed in the header). + - In `GdkGL.chs', the prefix is not properly removed from the + constructors of `GdkGL.Configs'; same problem with + `GdkEvents.EventType' + - install the executable (c2hs and c2hs-config) with a version number + suffix and make a symbolic link for the name without version number + (makes installing multiple versions easier) + - #define enum's (see below) + - intro a safe flag (as opposite to unsafe, but make safe the default) + - overload stdAddr etc for ForeignObj (stable ptr & cast) + - C2HSMarsh: from qrczak@knm.org.pl (Marcin 'Qrczak' Kowalczyk) + mallocForeignObj:: Int -> IO ForeignObj -- malloc + freeing finalizer + - C2HSMarsh: + (!!!) :: FromAddr a => Ptr a -> Int -> IO a + p !!! i = do + v <- fixIO $ deref (p `plusAddr` sizeof v * i) + return v + (Use in GdkColor, then) + Part of New FFI, so use that in GdkColor! + - C2HSMarhs: + for compound structures it is inconvenient that in a pointer-based + out, an initial value is needed; thus + out :: (Storable a, FromAddr a) => a -> Marsh a Addr + out x = malloc x :> addrStd + and this is also convenient + inp :: ToAddr a => a -> Marsh () Addr + inp x = stdAddr x :> free + Axel also proposes this + byValue :: b -> Marsh () b + byValue x = use x :> forget + - Axel suggests, + 2b. Automatisches Marshalling von Strukturen. + Eigentlich müßte es doch möglich sein, automatisch Instanzen von + Storable für Strukturen zu erstellen. Falls man mal einen generische + Pointer hat, kann man ja mit der ... as ... Methode eigene + Marshalling Funktionen zur Verfügung stellen. Oder habe ich da etwas + grundsätzliches übersehen? + +Short term +~~~~~~~~~~ +* cpp directives on the very first line of the .chs file are ignored + because the lexer looks for \n# This is very confusing to users. + +* The C99 spec says (sec. 6.7.2.1): + + [#4] Each enumerated type shall be compatible with an + integer type. The choice of type is + implementation-defined but shall be capable of + representing the values of all the members of the + enumeration. [...] + + Hence, c2hs has to be a bit more clever about determining the integral type + used to represent an enum. + +* The definition of `GenBind.HsObjectMap' doesn't take into account that in + Haskell a single name can be used for both a type and a class. + +* See FIXME at `GenBind.mergeMaps'. + +* Explain the grabbing of cpp -I options from -cppopts= (aka -C) values better + in the docu and add something like: + + I prefer that to giving an option to c2hs and passing it to + cpp, because - as you say - you usually already have a + variable with the cpp options in your makefile and this way + you can easily reuse it. + +* #define enums in C: siehe unten - scheinen aber wichtig + +* In pointer hooks after a `->', we currently allow only type identifiers; + other forms of Haskell types would be nice, too (especially, `()'). + +* A function prototype that uses a defined type on its left hand side may + declare a function, while that is not obvious from the declaration itself + (without also considering the `typedef'). This is not understood by + `GenBind' so far. + +* Why is a stable name an `unsigned long' in C land? How about a `void *' and + being able to get the `Addr' also in Haskell land? + +* if in a binding file erroneously `t->m' is used instead of `t.m' and `t' is + the tag of a struct, the error message just complains that there is no type + object for called `t'; it would be more user friendly to report in addition + that the tag `t' exists, but cannot be used in this expression + +* Should it be possible to specify a calling convention in context hook? + Isn't it a mitake to have explicit calling convention in the FFI? Shouldn't + that be adapted automatically depending on the target architecture? + +* Sven: How about exporting Haskell functions (also dynamic export)? + - callback registration function that explicitly have the type of the + callback function (from which we might want to generate a foreign export + dynamic). + +* `mapM raise errs' in `lexC' increases the heap usage by a factor of _8_ when + running the lexer alone on `gtkext.h' - probably because the whole analysis + has to be completed before we can be sure to have no error (and this kills + an interlocked produced/consumer scheme for the lexer and whatever function + is consuming the tokens). + +* sizeof and type hooks do only allow defined, but not basic types as + arguments. This is not a real problem as C2HS provides all the needed + information to circumvent such usage, but it would still be more elegant to + support basic types as arguments, too. + +Middle term +~~~~~~~~~~~ + +* A hook {#const #} would be nice (as in hsc2hs). Unfortunately, it + is not that easy to realise. We need to parse the in the binding + module. Moreover, the main value of this would be when the is + put into the C field together with `enum define' stuff, so that all + pre-processor symbols in it are resolved. However, this can easily give us + C compiler errors. A cheap way out would be {#const "C expr"#} to avoid + parsing the C expression, but then we can get even more errors during + compiling the C. + +* C->HS might get a lot easier to use by providing as optional marshalling + libraries modules that handle often occurring standard stuff like converting + `time_t' to `CalendarTime' or handle sockets etc. We would, then, probably + like to have a matching Posix or so library. + +------------ Pre-1.0 rewrite --------------- + +Problems: + +* There are some implicit requirements on the position of binding hooks, which + the tool doesn't really enforce: context must be first, context and enum may + only occur where a toplevel definition is allowed. (This should be checked + before `GenBind' is used.) We can not really check that a hook is in a + position where a toplevel definition is allowed (without analysing + significant parts of the Haskell code), but we can at least guarantee that + these hooks occur in column position 0. + +* Sven: #define enums in C: Introduce (#enum define SomeEnum {...}#) hooks + that collect `#define' symbols into an enumeration type; see also + +haskell/4025. One probem: If identifiers with the same lexeme as + `SomeEnum' or the enum members are already defined in the C header, we might + get conflicts. + + The problem of this approach is that if the macro expands to something that + is not a constant expression C, we will get error messages from the + preprocessor, which are strange to the user. + + Further idea, Michael's: extensible enums + + There are, however, a number of interesting options supported by gcc -E that + might make alternative solutions to the problem feasible. + +END of ----- Pre-1.0 rewrite --------------- + +* Do we like direct support for mapping complete structs (if they are + sufficiently wellbehaved?) into Haskell data structures - both by generating + the Haskell data type definitions and by generating a `cFrom' and a + `cTo' routine. The latter would be generated as a cascade of field + hooks. H/Direct's formal definition of structure marshalling might be + helpful here. + +* Support for evaluating constants is not complete yet. In this context, it + should probably also be checked, when there are two overlapping tags in an + enum (this is allowed in C, but is problematic for marshaling). + +* How about Hugs support? Is it already possible with current Hugs? + + +Release Checklist +~~~~~~~~~~~~~~~~~ + +(1) In root of working directory, + + % make tar-c2hs + +(2) Compile the resulting source distribution with latest ghc stable release: + + % tar xzf c2hs-x.y.z.tar.gz + % cd c2hs-x.y.z + % ./configure + % make + +(3) Install and regression testing: + + - Installation procedure + + % make install + + - Tests in build/ghc?/c2hs/tests/ directory + +(4) Check documentation and add release notes + +(5) Extended build test: build with older stable release of ghc and with the + cvs version + +(6) Register CVS tags for CTK and C->HS (syntax: Release-c2hs_x_y_z) + +(7) Make newest `tar' and build rpm + +(8) Put tar.gz and rpm sources and binaries up on Web page + +(9) Optionally also release the current version of CTK + +(10) Update the documentation under the Web page's docu/ directory + +(11) Announce: haskell@haskell.org, freshmeat.net diff --git a/TODO.CTKlight b/TODO.CTKlight new file mode 100644 --- /dev/null +++ b/TODO.CTKlight @@ -0,0 +1,81 @@ + -*-text-*- + Compiler Base TODO + ================== + +Next: + + +Short Term: +~~~~~~~~~~~ +* See general/UNames.hs for nhc98 induced ugliness; change when nhc98 is fixed + +* Lexers: For unicode `Char', we need to explicit support for positive and + negated ranges such as ['\0'..'\255'] and ['\0'..'\255'] \\ ['a'..'c'], + where the latter is usually written [^abc] (see the haskell-cafe + discussion). + +* Roman introduced the class `Printable'. A general class based pretty-print + system would be nice. + +* Parsers: Roman had the idea of allowing boolean functions to disambiguate + the parse table where two rules cannot be distinguished by the usual LL + mechanism alone (see emails). + +* Identifiers in any of the intermediate languages that have the same lexeme as + a keyword or a predefined identifier should always been pretty-printed in + their quoted form. + + Difficult to know for each IL which identifiers have to be treated specially. + We need a kind of IL-dependent exception list. + +Middle Term: +~~~~~~~~~~~~ +* Use a different attribute mechanism. The stuff started for the flatten + prototype looks quite promising. Observations: + + - Current hipar system with a unique in every node => makes it complicated + to construct/transform trees, as we always have to clone subtress in a + monad. + - GHC's system => when attributes of an identifier are updated, the + "new" identifiers have to substituted into all expression that contain + usage occurences. + +* Graph processing support: Does it need to be a new mechanism or can we + realise it via Attrs (what kind of generic functions could we provide). One + possibility is the use of an `Bool' attribute used to implement fast sets + (eg, marking). (If there is a lot of marking, we might want to realise + indexing with attributes via hashing to be able to work with sparse keys and + to already have O(1) during attribute table construction.) + +* `FiniteMap' should be an instance of `Functior' with `fmap = mapFM' + +* configuration shouldn't be in + +* FNameOps, FileOps: Introduce an autoconf set variable that determines + whether "/" or "\" is used as a delimiter in paths + +* Lexers: * After a certain number of errors (say 50); abort lexing. + +* Parsers (maybe similar problem with Lexers): If the grammar is not LL(1), we + just get an `ambiguous grammar' error message at runtime without any hint, + which part of the grammer might be ambiguous. This is too hard to debug! + +* In the language-specific `XXXAttrs.hs' modules, the routines for handling + the different on the attribute tables have always the same structure; Only + the access to the `AttrXXX' datatype is different. It should be possible to + generalize them. + + Moreover, the `referring identifier information' is always needed and might + be generalized. + +* The handling of state could be improved by revising the state modules and + using constructor classes and monad transformers. + + Currently, we only define the state type abstractly when generating a new + instance of `CST'. This is in order to be able to use the generic + operations, such as I/O, also in the monad instance. But this comprises the + security of the monad encapsulation as also the generic functions that allow + to extract and copy the state can be used. Ideally, we want to lift generic + operations like I/O automagically into the new monad and to protect it from + access to its state. Furthermore, some support for stripping and attaching + of the type-tag (intro with `newtype') would be nice. diff --git a/c2hs.cabal b/c2hs.cabal --- a/c2hs.cabal +++ b/c2hs.cabal @@ -1,5 +1,5 @@ Name: c2hs -Version: 0.28.2 +Version: 0.28.3 License: GPL-2 License-File: COPYING Copyright: Copyright (c) 1999-2007 Manuel M T Chakravarty @@ -112,7 +112,7 @@ Executable c2hs Build-Depends: base >= 2 && < 5, bytestring, - language-c >= 0.6 && < 0.7, + language-c >= 0.7.1 && < 0.8, filepath, dlist diff --git a/custom-setup.hs b/custom-setup.hs new file mode 100644 --- /dev/null +++ b/custom-setup.hs @@ -0,0 +1,92 @@ +-- +-- This Cabal setup script should ONLY be used in cases WHERE: +-- +-- the bare structure wrapper capability of C2HS is used (i.e. '%' +-- characters on pointer type arguments in "fun" hooks); +-- +-- AND +-- +-- a version of Cabal is being used that does not allow +-- preprocessors to specify extra C sources (versions of +-- cabal-install <= 1.22.0.0). +-- +-- Otherwise Cabal should be able to deal with the extra C sources +-- itself. +-- +-- If in doubt, ask... +-- + +module Main (main) where + +import Control.Exception (catch) +import Control.Monad (forM) + +import Distribution.PackageDescription + (BuildInfo(..), Executable(..), Library(..), PackageDescription(..)) +import Distribution.Simple (UserHooks(..), + defaultMainWithHooks, simpleUserHooks) +import Distribution.Simple.LocalBuildInfo (LocalBuildInfo(..)) +import Distribution.Simple.Setup (BuildFlags) +-- Test-suites require Cabal-1.10 or greater +import Distribution.PackageDescription (TestSuite(..)) +-- Benchmarks require Cabal-1.14 or greater +import Distribution.PackageDescription (Benchmark(..)) + +import System.Directory (doesDirectoryExist, getDirectoryContents) +import System.Exit (ExitCode) +import System.FilePath ((), takeExtensions) + +main :: IO () +main = defaultMainWithHooks simpleUserHooks { buildHook = chsBuildHook } + +addCSources :: [FilePath] -> BuildInfo -> BuildInfo +addCSources newSrcs bi@(BuildInfo { cSources = oldSrcs }) = + bi { cSources = newSrcs ++ oldSrcs } + +hasChsCExtension :: FilePath -> Bool +hasChsCExtension file = takeExtensions file == ".chs.c" + +getRecursiveContents :: FilePath -> IO [FilePath] +getRecursiveContents topdir = do + topdirExists <- doesDirectoryExist topdir + if (not topdirExists) + then return [] + else do + names <- getDirectoryContents topdir + let properNames = filter (`notElem` [".", ".."]) names + paths <- forM properNames $ \name -> do + let path = topdir name + isDirectory <- doesDirectoryExist path + if isDirectory + then getRecursiveContents path + else return [path] + return (concat paths) + +chsBuildHook :: PackageDescription -> LocalBuildInfo -> UserHooks -> + BuildFlags -> IO () +chsBuildHook pd lbi uh bf = hook `catchExitCode` \_ -> hook + where + hook :: IO () + hook = chsBuildHook' pd lbi uh bf + + catchExitCode :: IO a -> (ExitCode -> IO a) -> IO a + catchExitCode = catch + +chsBuildHook' :: PackageDescription -> LocalBuildInfo -> UserHooks -> + BuildFlags -> IO () +chsBuildHook' pd@(PackageDescription + { library = mbLib + , executables = exes + , testSuites = tss + , benchmarks = bms + }) + lbi uh bf = do + let distBuildDir = buildDir lbi + chsCFiles <- fmap (filter hasChsCExtension) $ + getRecursiveContents distBuildDir + let pd' = pd { library = fmap (\lib -> lib { libBuildInfo = addCSources chsCFiles (libBuildInfo lib) }) mbLib + , executables = fmap (\exe -> exe { buildInfo = addCSources chsCFiles (buildInfo exe) }) exes + , testSuites = fmap (\ts -> ts { testBuildInfo = addCSources chsCFiles (testBuildInfo ts) }) tss + , benchmarks = fmap (\bm -> bm { benchmarkBuildInfo = addCSources chsCFiles (benchmarkBuildInfo bm) }) bms + } + buildHook simpleUserHooks pd' lbi uh bf diff --git a/examples/libghttpHS/Ghttp.chs b/examples/libghttpHS/Ghttp.chs new file mode 100644 --- /dev/null +++ b/examples/libghttpHS/Ghttp.chs @@ -0,0 +1,326 @@ +-- GhttpHS: Haskell binding to the Gnome HTTP library -*-haskell-*- +-- +-- Author : Manuel M. T. Chakravarty +-- Created: 5 August 99 +-- +-- Copyright (c) [1999..2000] Manuel M. T. Chakravarty +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Library General Public +-- License as published by the Free Software Foundation; either +-- version 2 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Library General Public License for more details. +-- +--- DESCRIPTION --------------------------------------------------------------- +-- +-- The C library `libghttp' provides a set of common http functions needed at +-- the client and the server end of an http connection. The Haskell binding +-- is generated with the help of the C->Haskell tool - always modify the +-- original .chs file, _not_ the generated .hs file. +-- +-- This library is fully compliant with HTTP 1.1 as defined in the draft 5 +-- update of RFC 2068. +-- +--- DOCU ---------------------------------------------------------------------- +-- +-- language: Haskell 98 & C->HS binding hooks (v0.7.5) +-- +-- ** Stylistic warning: In the definition of `CurrentStatus', the field +-- labels do not contain the name of the data type to which they belong. +-- This is _not_ good practice in larger interfaces, because in Haskell +-- such field labels pollute the global name space. +-- +--- TODO ---------------------------------------------------------------------- +-- +-- * When and by whom is the memory area passed to `ghttp_set_body' be freed; +-- how about the string returned from `ghttp_get_body'? +-- +-- * Conversion of `time_t' misses for `parseDate'. +-- + +module Ghttp (Request, URI, Type(..), SyncMode(..), Status(..), Proc(..), + CurrentStatus(..), + requestNew, requestDestroy, uriValidate, setURI, setProxy, + setType, setBody, setSync, prepare, setChunksize, setHeader, + process, getStatus, getHeader, close, clean, getSocket, getBody, + getError, {-parseDate,-} setAuthinfo, setProxyAuthinfo) +where + +-- C->HS marshalling library +-- +import C2HS + +import Monad (liftM, when) +import IOExts (unsafePerformIO) + + +{#context lib="libghttp" prefix="ghttp"#} + + +-- data structures +-- --------------- + +-- abstract handle for a http request object (EXPORTED ABSTRACTLY) +-- +newtype Request = Request Addr + +-- Uniform Resource Indicators (EXPORTED) +-- +type URI = String + +-- body type (EXPORTED) +-- +{#enum ghttp_type as Type {underscoreToCase}#} + +-- synchronous/asynchronous mode (EXPORTED) +-- +{#enum sync_mode as SyncMode {underscoreToCase}#} + +-- request status (EXPORTED) +-- +{#enum status as Status {underscoreToCase}#} + +-- describes the activity of a request (EXPORTED) +-- +{#enum proc as Proc {underscoreToCase}#} + +-- status descriptor (EXPORTED) +-- +data CurrentStatus = CurrentStatus { + proc :: Proc, -- What's it doing? + bytesRead :: Int, -- How many bytes have been read? + bytesTotal :: Int -- How many bytes total? + } + +-- error types +-- +invalidURI, illegalRequest :: String +invalidURI = "Ghttp: The Uniform Resource Indicator is invalid." +illegalRequest = "Ghttp: The request is illegal or unsupported." + + +-- functions +-- --------- + +-- create a new request object (EXPORTED) +-- +requestNew :: IO Request +requestNew = liftM Request {#call unsafe request_new#} + +-- delete a current request object (EXPORTED) +-- +requestDestroy :: Request -> IO () +requestDestroy (Request reqa) = {#call unsafe request_destroy#} reqa + +-- validate a uri (EXPORTED) +-- +uriValidate :: URI -> Bool +uriValidate uri = + let res = unsafePerformIO $ + {#call unsafe uri_validate#} `marsh1_` (stdAddr uri :> free) + in + res == -1 + +-- set a uri in a request (EXPORTED) +-- +-- * raise an exception if the URI is not valid +-- +setURI :: Request -> URI -> IO () +setURI (Request reqa) uri = + {#call unsafe set_uri#} reqa `marsh1_` (stdAddr uri :> free) + `ifNegRaise_` invalidURI + +-- set a proxy for a request (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +setProxy :: Request -> URI -> IO () +setProxy (Request reqa) uri = + {#call unsafe set_proxy#} reqa `marsh1_` (stdAddr uri :> free) + `ifNegRaise_` illegalRequest + +-- set a request type (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +setType :: Request -> Type -> IO () +setType (Request reqa) rtype = + {#call unsafe set_type#} reqa (cFromEnum rtype) + `ifNegRaise_` illegalRequest + +-- set the body (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +setBody :: Request -> String -> IO () +setBody (Request reqa) body = + do + (box, len) <- listToAddrWithLen body + {#call unsafe set_body#} reqa box (cFromInt len) + `ifNegRaise_` illegalRequest + +-- set whether or not you want to use sync or async mode (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +setSync :: Request -> SyncMode -> IO () +setSync (Request reqa) smode = + {#call unsafe set_sync#} reqa (cFromEnum smode) + `ifNegRaise_` illegalRequest + +-- Prepare a request; call this before trying to process a request or if you +-- change the uri (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +prepare :: Request -> IO () +prepare (Request reqa) = + {#call unsafe prepare#} reqa + `ifNegRaise_` illegalRequest + +-- set the chunk size; you might want to do this to optimize for different +-- connection speeds (EXPORTED) +-- +setChunksize :: Request -> Int -> IO () +setChunksize (Request reqa) size = + {#call unsafe set_chunksize#} reqa (cFromInt size) + +-- set a random request header (EXPORTED) +-- +setHeader :: Request -> String -> String -> IO () +setHeader (Request reqa) hdr val = + {#call unsafe set_header#} reqa + `marsh2_` (stdAddr hdr :> free) + $ (stdAddr val :> free) + +-- process a request (EXPORTED) +-- +process :: Request -> IO Status +process (Request reqa) = liftM cToEnum $ {#call unsafe process#} reqa + +-- get the status of a request (EXPORTED) +-- +getStatus :: Request -> IO CurrentStatus +getStatus (Request reqa) = + {#call unsafe ghttpHS_get_status #} reqa >>= cFromCurrentStatus + +-- get the value of a random response header (EXPORTED) +-- +getHeader :: Request -> String -> IO String +getHeader (Request reqa) hdr = + {#call unsafe get_header#} reqa `marsh1_` (stdAddr hdr :> free) + >>= addrStd + +-- abort a currently running request (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +close :: Request -> IO () +close (Request reqa) = {#call unsafe close#} reqa + `ifNegRaise_` illegalRequest + +-- clean a request (EXPORTED) +-- +clean :: Request -> IO () +clean (Request reqa) = {#call unsafe clean#} reqa + +-- get the socket associated with a particular connection (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +getSocket :: Request -> IO Int +getSocket (Request reqa) = {#call unsafe get_socket#} reqa + `ifNegRaise` illegalRequest + +-- get the return entity body (EXPORTED) +-- +-- * this includes getting the length with `ghttp_get_body_len', as the string +-- is not necessarily \0 terminated +-- +getBody :: Request -> IO String +getBody (Request reqa) = + do + bodyAddr <- {#call unsafe get_body#} reqa + `ifNullRaise` illegalRequest + bodyLen <- {#call unsafe get_body_len#} reqa + addrWithLenToList bodyAddr (cToInt bodyLen) + +-- get an error message for a request that has failed (EXPORTED) +-- +getError :: Request -> IO String +getError (Request reqa) = + {#call unsafe get_error#} reqa >>= addrStd + +-- parse a date string that is one of the standard date formats (EXPORTED) +-- +{-parseDate :: String -> CalendarTime +parseDate str = + do + time_t <- {#call unsafe parse_date#} `fromString` str + time <- toCalendarTime + -} + +-- return the status code (EXPORTED) +-- +statusCode :: Request -> IO Int +statusCode (Request reqa) = + liftM cToInt $ {#call unsafe status_code#} reqa + +-- return the reason phrase (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +reasonPhrase :: Request -> IO String +reasonPhrase (Request reqa) = + ({#call unsafe reason_phrase#} reqa + `ifNullRaise` illegalRequest + ) >>= addrStd + +-- set your username/password pair (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +setAuthinfo :: Request -> String -> String -> IO () +setAuthinfo (Request reqa) user pass = + ({#call unsafe set_authinfo#} reqa + `marsh2_` (stdAddr user :> free) + $ (stdAddr pass :> free) + ) + `ifNegRaise_` illegalRequest + +-- set your username/password pair for proxy (EXPORTED) +-- +-- * raise an exception if the request is not valid +-- +setProxyAuthinfo :: Request -> String -> String -> IO () +setProxyAuthinfo (Request reqa) user pass = + ({#call unsafe set_proxy_authinfo#} reqa + `marsh2_` (stdAddr user :> free) + $ (stdAddr pass :> free) + ) + `ifNegRaise_` illegalRequest + + +-- auxilliary marshalling function +-- ------------------------------- + +-- marshal the elements of a `ghttp_current_status' struct to Haskell land +-- +-- * frees the C struct +-- +cFromCurrentStatus :: Addr -> IO CurrentStatus +cFromCurrentStatus csPtr = + do + proc <- liftM cToEnum$ {#get current_status.proc#} csPtr + read <- liftM cToInt $ {#get current_status.bytes_read#} csPtr + total<- liftM cToInt $ {#get current_status.bytes_total#} csPtr + free csPtr + return $ CurrentStatus { + proc = proc, + bytesRead = read, + bytesTotal = total + } diff --git a/examples/libghttpHS/Makefile b/examples/libghttpHS/Makefile new file mode 100644 --- /dev/null +++ b/examples/libghttpHS/Makefile @@ -0,0 +1,46 @@ +# GnomeHaskell bindings: Gnome HTTP library +# +# Author : Manuel M. T. Chakravarty +# Created: 8 October 1999 +# +# Copyright (c) 1999 Manuel M. T. Chakravarty +# +# This file 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 file 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. +# +# = DOCU ===================================================================== +# +# = TODO ===================================================================== +# +# * Let configure do the dirty work; how about automake + +# the commented out variants are to be used if the directory is moved out of +# the C->HS source tree +# +GHC=ghc +#C2HS=c2hs +C2HS=../../c2hs +GHTTP_HEADER=ghttpHS.h +#HCFLAGS=`c2hs-config --cflags` +HCFLAGS=-i../../lib -fglasgow-exts + +OBJS=Ghttp.o ghttpHS.o + +Ghttp.hs: Ghttp.chs ghttpHS.h + $(C2HS) $(GHTTP_HEADER) Ghttp.chs + +Ghttp.o: Ghttp.hs ghttpHS.h + $(GHC) '-#include"ghttpHS.h"' $(HCFLAGS) -c $< + +ghttpHS.o: ghttpHS.h ghttpHS.c + +libghttpHS.a: $(OBJS) + -$(RM) $@ + $(AR) -crs $@ $(OBJS) diff --git a/examples/libghttpHS/ghttpHS.c b/examples/libghttpHS/ghttpHS.c new file mode 100644 --- /dev/null +++ b/examples/libghttpHS/ghttpHS.c @@ -0,0 +1,22 @@ +/* Auxiliary C code for Ghttp. + * + * Copyright (c) 1999 Manuel M. T. Chakravarty + * + * This is required due to the inability of GHC's FFI to pass structures from C + * to Haskell. + */ + +#include "ghttpHS.h" + +ghttp_current_status *ghttpHS_get_status (ghttp_request *a_request) +{ + ghttp_current_status *status; + + status = (ghttp_current_status *) malloc (sizeof (ghttp_current_status)); + if (!status) { + printf ("Ghttp: ghttpHS_get_status: Out of memory!"); + exit (1); + } + *status = ghttp_get_status (a_request); + return status; +} diff --git a/examples/libghttpHS/ghttpHS.h b/examples/libghttpHS/ghttpHS.h new file mode 100644 --- /dev/null +++ b/examples/libghttpHS/ghttpHS.h @@ -0,0 +1,21 @@ +/* Auxiliary C code for Ghttp. + * + * Copyright (c) 1999 Manuel M. T. Chakravarty + * + * This is required due to the inability of GHC's FFI to pass structures from C + * to Haskell. + */ + +#ifndef __GHTTPHS_H__ +#define __GHTTPHS_H__ + + +#include + +/* returns a reference to a newly allocated memory area holding the result of + * the corresponding vanilla `libghttp' function + */ +ghttp_current_status *ghttpHS_get_status (ghttp_request *a_request); + + +#endif /* __GHTTPHS_H__ */ diff --git a/import-handling.md b/import-handling.md new file mode 100644 --- /dev/null +++ b/import-handling.md @@ -0,0 +1,104 @@ +## Potentially breaking changes: import handling + +#### The problem + +Previous releases of C2HS had an annoying misfeature -- you had to +manage the imports of Haskell library functions in C2HS-generated code +yourself. Suppose you had the following code in a `.chs` file: + +``` haskell +#include "issue44.h" + +{#pointer *foo as ^ foreign newtype#} +``` + +where the contents of the `issue44.h` header are: + +``` c +typedef struct { int a; } foo; +``` + +Running C2HS would then generate the following Haskell code: + +``` haskell +newtype Foo = Foo (ForeignPtr (Foo)) +withFoo :: Foo -> (Ptr Foo -> IO b) -> IO b +withFoo (Foo fptr) = withForeignPtr fptr +``` + +Note the use of the names `ForeignPtr`, `Ptr` and `withForeignPtr`. +These come from the Haskell library modules `Foreign.Ptr` and +`Foreign.ForeignPtr`, but C2HS didn't generate any `import` +declarations to make these modules accessible. This meant that there +would normally be a bit of back and forth when writing C2HS code: +write your bindings, run C2HS, try compiling with GHC, have the +compile fail because of missing imports, add the imports to your +`.chs` file and repeat. Kind of annoying. + +As well as being annoying, the lack of import declaration generation +meant that it was sometimes impossible to make internal changes to the +way that C2HS binds to C functions without breaking existing user +code. The example that finally drove me to try to fix this was issue +130 (https://github.com/haskell/c2hs/issues/130) that required a +change that would lead to most C2HS code now needing to import +`unsafePerformIO`. It didn't seem like a good idea to push a change +like that (that would break more or less all C2HS code out there!) +without fixing the import problem (so that the change for issue #130 +could happen transparently to all existing working C2HS code). + + +#### The solution + +The solution I ended up with is pretty simple, but I think it's +robust. For the example above, C2HS now generates the following +Haskell code: + +``` haskell +import qualified Foreign.ForeignPtr as C2HSImp +import qualified Foreign.Ptr as C2HSImp + +newtype Foo = Foo (C2HSImp.ForeignPtr (Foo)) +withFoo :: Foo -> (C2HSImp.Ptr Foo -> IO b) -> IO b +withFoo (Foo fptr) = C2HSImp.withForeignPtr fptr +``` + +All library symbols needed to generate Haskell binding code are now +qualified under the name `C2HSImp` and the relevant library modules +are imported qualified as `C2HSImp`. + +The end result of this is that you still need to import modules only +for names that you explicitly use (so if you use `alloca` in an input +marshaller, you need to import `Foreign.Marshal.Alloc`). All external +names that C2HS uses in code that it generates should be imported +automatically. + + +#### Potential complaints + +1. Modules compiled with `-Werror` may now fail because of unused + import warnings. This was something I had to deal with for most of + the C2HS test cases (since they all imported the required library + modules and they're mostly compiled with `-Werror`), but since the + community consensus seems to be that `-Werror` shouldn't be used in + released code, I think it's reasonable to allow the possibility of + this kind of breakage. + +2. It's possible that the code I wrote for deciding where to put the + extra import declarations isn't quite perfect. I tried a couple of + different solutions, but ended up with a hand-made "find the first + safe place to add imports" function that relies quite heavily on + the details of C2HS's CHS file parser. I did try a solution based + on `haskell-src-exts`, but this didn't work very well, because + `haskell-src-exts` doesn't support all available GHC extensions and + I would have needed some mechanism to propagate extension + information from Cabal files to C2HS to make the parsing work. + +These changes have been tested reasonably extensively -- all of the +core C2HS tests pass, and the following packages are known to work +(they're all in the regression suite): abcBridge, alsa-mixer, cuda, +cufft, gnome-keyring, gnuidn, haskell-mpi, hnetcdf, hpuz, hsndfile, +hsshellscript, igraph, libssh2. + +I'll be adding more packages to the regression suite, but if there's a +package you're particularly concerned about that's not on this list, +let me know. diff --git a/regression-suite-vm/Vagrantfile b/regression-suite-vm/Vagrantfile new file mode 100644 --- /dev/null +++ b/regression-suite-vm/Vagrantfile @@ -0,0 +1,9 @@ +Vagrant.configure("2") do |config| + config.vm.box = "c2hs-regression-suite.box" + + config.vm.provider :virtualbox do |vb| + vb.gui = false + vb.customize ["modifyvm", :id, "--memory", "2048"] + vb.customize ["modifyvm", :id, "--cpus", "2"] + end +end diff --git a/regression-suite-vm/Vagrantfile-full b/regression-suite-vm/Vagrantfile-full new file mode 100644 --- /dev/null +++ b/regression-suite-vm/Vagrantfile-full @@ -0,0 +1,84 @@ +$script = <