added testsuite for the parser

Code freeze for generation of binary distribution packages is imminent.

.authorspellings

@@ -20,4 +20,3 @@ Markus Forsberg		<markus>
 Server Cimen		<e1560697@ceng.metu.edu.tr>
 Grégoire Détrez		<gdetrez@crans.org>
 Ketil Malde <ketil@ii.uib.no>
-John J. Camilleri	<john.j.camilleri@chalmers.se>, john@johnjcamilleri.com, john

.ghci

@@ -1,2 +0,0 @@
-:set -isrc/compiler -isrc/binary -isrc/runtime/haskell -isrc/server -isrc/example-based -isrc/server/transfer -idist/build/autogen -idist/build
-:set -fwarn-unused-imports -optP-DSERVER_MODE -optP-DUSE_INTERRUPT -optP-DCC_LAZY -optP-include -optPdist/build/autogen/cabal_macros.h -odir dist/build/gf/gf-tmp -hidir dist/build/gf/gf-tmp -stubdir dist/build/gf/gf-tmp

Makefile

@@ -1,53 +1,29 @@
-.PHONY: all build install doc clean gf sdist
-
-# This gets the numeric part of the version from the cabal file
-VERSION=$(shell sed -ne "s/^version: *\([0-9.]*\).*/\1/p" gf.cabal)
+.PHONY: all build install doc clean sdist
 
 all: build
 
-dist/setup-config: gf.cabal Setup.hs WebSetup.hs
-	cabal configure
+dist/setup-config: gf.cabal
+	chmod u+x lib/src/mkPresent
+	chmod u+x lib/src/mkMinimal
+	runghc Setup.hs configure
 
 build: dist/setup-config
-	cabal build
+	runghc Setup.hs build
 
 install:
-	cabal copy
-	cabal register
+	runghc Setup.hs install
 
 doc:
-	cabal haddock
+	runghc Setup.hs haddock
 
 clean:
-	cabal clean
-
-#sdist:
-#	cabal sdist
+	runghc Setup.hs clean
 
+sdist:
+	runghc Setup.hs sdist
 gf:
-	cabal build rgl-none
+	runghc Setup.hs build rgl-none
 	strip dist/build/gf/gf
 
 html::
-	bash bin/update_html
-
-# Make a debian package. First add a suitable entry with the correct GF version
-# number to the top of debian/changelog.
-# (Tested on Ubuntu 15.04. You need to install dpkg-dev & debhelper.)
-deb:
-	dpkg-buildpackage -b
-
-# Make an OS X Installer package
-pkg:
-	FMT=pkg bash bin/build-binary-dist.sh
-
-# Make a binary tar distribution
-bintar:
-	bash bin/build-binary-dist.sh
-
-# Make a source tar.gz distribution using darcs to make sure that everything
-# is included. We put the distribution in dist/ so it is removed on
-# `make clean`
-sdist:
-	test -d dist || mkdir dist
-	darcs dist -d dist/gf-${VERSION}
+	bash bin/update_html

README

@@ -30,5 +30,4 @@ GF particularly addresses four aspects of grammars:
 
 
 COMPILATION and INSTALLATION of source distribution:
-See download/index.html for installation instructions.
-(More details can be found in doc/gf-developers.html.)
+See doc/gf-developers.html for installation instructions.

Setup.hs

@@ -1,177 +1,130 @@
+module Main where
+
 import Distribution.Simple
 import Distribution.Simple.LocalBuildInfo
-import Distribution.Simple.BuildPaths(exeExtension)
+import Distribution.Simple.BuildPaths
 import Distribution.Simple.Utils
 import Distribution.Simple.Setup
 import Distribution.PackageDescription hiding (Flag)
 import Control.Monad
-import Data.Char(isSpace)
-import Data.List(isPrefixOf,intersect,unfoldr,stripPrefix)
-import Data.Maybe(listToMaybe)
---import System.IO
-import qualified Control.Exception as E
-import System.Process(readProcess)
+import Data.Maybe
+import Data.List(isPrefixOf)
+import System.IO
+import System.Cmd
 import System.FilePath
-import System.Directory(createDirectoryIfMissing,copyFile,doesDirectoryExist,getDirectoryContents)
---import System.Exit
---import Control.Concurrent(forkIO)
---import Control.Concurrent.Chan(newChan,writeChan,readChan)
-
-import WebSetup
-
-tryIOE :: IO a -> IO (Either E.IOException a)
-tryIOE = E.try
+import System.Directory
+import System.Environment
+import System.Process
+import System.Exit
 
 main :: IO ()
-main = defaultMainWithHooks simpleUserHooks{ preBuild  = gfPreBuild
-                                           , postBuild = gfPostBuild
-                                           , preInst   = gfPreInst
-                                           , postInst  = gfPostInst
-                                           , preCopy   = const . checkRGLArgs
-                                           , postCopy  = gfPostCopy
-                                           , sDistHook = sdistError
+main = defaultMainWithHooks simpleUserHooks{ preBuild =checkRGLArgs
+                                           , postBuild=buildRGL
+                                           , preInst  =checkRGLArgs
+                                           , postInst =installRGL
+                                           , preCopy  =checkRGLArgs
+                                           , postCopy =copyRGL
+                                           , sDistHook=sdistRGL
+                                           , runTests =testRGL
                                            }
-  where
-    gfPreBuild args  = gfPre args . buildDistPref
-    gfPreInst args = gfPre args . installDistPref
-
-    gfPre args distFlag =
-      do h <- checkRGLArgs args
-         extractDarcsVersion distFlag
-         return h
-
-    gfPostBuild args flags pkg lbi =
-      do --writeFile "running" ""
-         buildRGL args flags (flags,pkg,lbi)
---       let gf = default_gf lbi
---       buildWeb gf (pkg,lbi)
-
-    gfPostInst args flags pkg lbi =
-      do installRGL args flags (pkg,lbi)
-         let gf = default_gf lbi
-         installWeb (pkg,lbi)
-
-    gfPostCopy args flags  pkg lbi =
-      do let gf = default_gf lbi
-         copyRGL args flags (pkg,lbi)
-         copyWeb flags (pkg,lbi)
 
 --------------------------------------------------------
 -- Commands for building the Resource Grammar Library
 --------------------------------------------------------
 
-data Mode = AllTenses | Present deriving Show
-all_modes = ["alltenses","present"]
-default_modes = [AllTenses,Present]
+data Mode = AllTenses | Present | Minimal deriving Show
+all_modes = ["minimal","present","alltenses"]
+default_modes = [Present,AllTenses]
 
 data RGLCommand
   = RGLCommand
       { cmdName   :: String
       , cmdIsDef  :: Bool
-      , cmdAction :: [Mode] -> [String] -> Info -> IO ()
+      , cmdAction :: [Mode] -> [String] -> PackageDescription -> LocalBuildInfo -> IO ()
       }
 
-type Info = (BuildFlags,PackageDescription,LocalBuildInfo)
-bf (i,_,_) = i
---pd (_,i,_) = i
-lbi (_,_,i) = i
-
 rglCommands =
-  [ RGLCommand "prelude" True  $ \mode args bi -> do
+  [ RGLCommand "prelude" True  $ \mode args pkg lbi -> do
        putStrLn $ "Compiling [prelude]"
-       let prelude_src_dir = rgl_src_dir    </> "prelude"
-           prelude_dst_dir = rgl_dst_dir (lbi bi) </> "prelude"
+       let prelude_src_dir = rgl_src_dir     </> "prelude"
+           prelude_dst_dir = rgl_dst_dir lbi </> "prelude"
        createDirectoryIfMissing True prelude_dst_dir
-       files <- list_files prelude_src_dir
-       run_gfc bi (["-s", "--gfo-dir="++prelude_dst_dir] ++ [prelude_src_dir </> file | file <- files])
-
-  , RGLCommand "all"     True  $ gfcp [l,s,c,t,sc]
-  , RGLCommand "lang"    False $ gfcp [l,s]
-  , RGLCommand "api"     False $ gfcp [t,sc]
-  , RGLCommand "compat"  False $ gfcp [c]
-  , RGLCommand "web"     True  $ \ _ _ bi -> buildWeb (default_gf (lbi bi)) bi
-
-  , RGLCommand "pgf"     False $ \modes args bi ->
-     parallel_ [
-       do let dir = getRGLBuildDir (lbi bi) mode
+       files <- getDirectoryContents prelude_src_dir
+       run_gfc pkg lbi (["-s", "--gfo-dir="++prelude_dst_dir] ++ [prelude_src_dir </> file | file <- files, take 1 file /= "."])
+  , RGLCommand "lang"    True  $ \mode args pkg lbi -> do
+       mapM_ (gfc mode pkg lbi . lang) (optl langsLang args)
+       mapM_ (gfc mode pkg lbi . symbol) (optl langsAPI args)
+  , RGLCommand "compat"  True  $ \mode args pkg lbi -> do
+       mapM_ (gfc mode pkg lbi . compat) (optl langsCompat args)
+  , RGLCommand "api"     True  $ \mode args pkg lbi -> do
+       mapM_ (gfc mode pkg lbi . try) (optl langsAPI args)
+       mapM_ (gfc mode pkg lbi . symbolic) (optl langsSymbolic args)
+  , RGLCommand "pgf"     False $ \modes args pkg lbi ->
+     sequence_ [
+       do let dir = getRGLBuildDir lbi mode
           createDirectoryIfMissing True dir
-          sequence_ [run_gfc bi ["-s","-make","-name=Lang"++la,
-                                       dir ++ "/Lang" ++ la ++ ".gfo"]
+          sequence_ [run_gfc pkg lbi ["-s","-make","-name=Lang"++la,
+                                       dir ++ "/Lang" ++ la ++ ".gfo"] 
                       | (_,la) <- optl langsPGF args]
-          run_gfc bi (["-s","-make","-name=Lang"]++
+          run_gfc pkg lbi (["-s","-make","-name=Lang"]++
                            ["Lang" ++ la ++ ".pgf"|(_,la)<-optl langsPGF args])
        | mode <- modes]
-  , RGLCommand "demo"    False $ \modes args bi -> do
+  , RGLCommand "demo"    False $ \mode args pkg lbi -> do
        let ls = optl langsDemo args
-       gf bi (demos "Demo" ls) ["demo/Demo" ++ la ++ ".gf" | (_,la) <- ls]
+       gf (demos "Demo" ls) ["demo/Demo" ++ la ++ ".gf" | (_,la) <- ls] pkg lbi
        return ()
-  , RGLCommand "parse"   False $ \modes args bi ->
-       gfc bi modes (summary parse) (map parse (optl langsParse args))
-  , RGLCommand "none"    False $ \modes args bi ->
+  , RGLCommand "parse"   False $ \mode args pkg lbi -> do
+       mapM_ (gfc mode pkg lbi . parse) (optl langsParse args)
+  , RGLCommand "none"    False $ \mode args pkg lbi -> do
        return ()
   ]
   where
-    gfcp cs modes args bi = parallel_ [gfcp' bi mode args cs|mode<-modes]
-
-    gfcp' bi mode args cs = gfcn bi mode (unwords ss) (concat fss)
-      where (ss,fss) = unzip [(summary f,map f as)|c<-cs,let (f,as)=c mode args]
-
-    summary f = f ("*","*")
-
-    l mode args = (lang,optml mode langsLang args)
-    s mode args = (symbol,optml mode langsAPI args)
-    c mode args = (compat,optl langsCompat args)
-    t mode args = (try,optml mode langsAPI args)
-    sc mode args = (symbolic,optml mode langsSymbolic args)
-
-    optl = optml AllTenses
-    optml mode ls args = getOptLangs (shrink ls) args
-      where
-        shrink = case mode of
-                   Present -> intersect langsPresent
-                   _ -> id
+    optl ls args = getOptLangs ls args
 
 --------------------------------------------------------
 
-checkRGLArgs args = do
+checkRGLArgs args flags = do
   let args' = filter (\arg -> not (arg `elem` all_modes ||
                                    rgl_prefix `isPrefixOf` arg ||
                                    langs_prefix `isPrefixOf` arg)) args
-  unless (null args') $
-    putStrLn $ "Unrecognised flags: " ++ intercalate ", " args'
-  return emptyHookedBuildInfo
+  if null args'
+    then return emptyHookedBuildInfo
+    else die $ "Unrecognised flags: " ++ intercalate ", " args'
 
-buildRGL args flags bi = do
+buildRGL args flags pkg lbi = do
   let cmds = getRGLCommands args
   let modes = getOptMode args
-  mapM_ (\cmd -> cmdAction cmd modes args bi) cmds
+  mapM_ (\cmd -> cmdAction cmd modes args pkg lbi) cmds
 
-installRGL args flags bi = do
+installRGL args flags pkg lbi = do
   let modes = getOptMode args
-  let inst_gf_lib_dir = datadir (uncurry absoluteInstallDirs bi NoCopyDest) </> "lib"
-  copyAll "prelude"   (rgl_dst_dir (snd bi) </> "prelude") (inst_gf_lib_dir </> "prelude")
-  sequence_ [copyAll (show mode) (getRGLBuildDir (snd bi) mode) (inst_gf_lib_dir </> getRGLBuildSubDir mode)|mode<-modes]
+  let inst_gf_lib_dir = datadir (absoluteInstallDirs pkg lbi NoCopyDest) </> "lib"
+  copyAll "prelude"   (rgl_dst_dir lbi </> "prelude") (inst_gf_lib_dir </> "prelude")
+  sequence_ [copyAll (show mode) (getRGLBuildDir lbi mode) (inst_gf_lib_dir </> getRGLBuildSubDir lbi mode)|mode<-modes]
 
-copyRGL args flags bi = do
+copyRGL args flags pkg lbi = do
   let modes = getOptMode args
       dest = case copyDest flags of
                NoFlag -> NoCopyDest
                Flag d -> d
-  let inst_gf_lib_dir = datadir (uncurry absoluteInstallDirs bi dest) </> "lib"
-  copyAll "prelude"   (rgl_dst_dir (snd bi) </> "prelude") (inst_gf_lib_dir </> "prelude")
-  sequence_ [copyAll (show mode) (getRGLBuildDir (snd bi) mode) (inst_gf_lib_dir </> getRGLBuildSubDir mode)|mode<-modes]
+  let inst_gf_lib_dir = datadir (absoluteInstallDirs pkg lbi dest) </> "lib"
+  copyAll "prelude"   (rgl_dst_dir lbi </> "prelude") (inst_gf_lib_dir </> "prelude")
+  sequence_ [copyAll (show mode) (getRGLBuildDir lbi mode) (inst_gf_lib_dir </> getRGLBuildSubDir lbi mode)|mode<-modes]
 
 copyAll s from to = do
   putStrLn $ "Installing [" ++ s ++ "] " ++ to
   createDirectoryIfMissing True to
-  mapM_ (\file -> copyFile (from </> file) (to </> file)) =<< list_files from
-{-
+  files <- fmap (filter (\f -> take 1 f /= ".")) $ getDirectoryContents from
+  mapM_ (\file -> copyFile (from </> file) (to </> file)) files
+
 sdistRGL pkg mb_lbi hooks flags = do
   paths <- getRGLFiles rgl_src_dir []
   let pkg' = pkg{dataFiles=paths}
   sDistHook simpleUserHooks pkg' mb_lbi hooks flags
   where
-    getRGLFiles dir paths = foldM (processFile dir) paths =<< ls dir
+    getRGLFiles dir paths = do
+      files <- getDirectoryContents dir
+      foldM (processFile dir) paths [file | file <- files, file /= "." && file /= ".."]
 
     processFile dir paths file = do
       let path = dir </> file
@@ -182,57 +135,70 @@ sdistRGL pkg mb_lbi hooks flags = do
                then return (path : paths)
                else return paths
         else getRGLFiles path paths
--}
 
--- | Cabal doesn't know how to correctly create the source distribution, so
--- we print an error message with the correct instructions when someone tries
--- `cabal sdist`.
-sdistError _ _ _ _ = fail "Error: Use `make sdist` to create the source distribution file"
+testRGL args _ pkg lbi = do
+  let paths = case args of
+                []    -> ["testsuite"]
+                paths -> paths
+  sequence_ [walk path | path <- paths]
+  where
+    walk path = do
+      files <- getDirectoryContents path
+      sequence_ [walkFile (path </> file) | file <- files, file /= "." && file /= ".."]
 
-rgl_src_dir         = "lib" </> "src"
+    walkFile fpath = do
+      exists <- doesFileExist fpath
+      if exists
+        then if takeExtension fpath == ".gfs"
+               then do let in_file   = fpath
+                           gold_file = addExtension fpath ".gold"
+                           out_file  = addExtension fpath ".out"
+                       putStr (in_file++" ... ")
+                       hFlush stdout
+                       res <- runTest in_file out_file gold_file
+                       putStrLn (if res then "OK" else "FAIL")
+               else return ()
+        else walk fpath
+
+    runTest in_file out_file gold_file = do
+      inp <- readFile in_file
+      out <- readProcess (default_gf pkg lbi) ["-run"] inp
+      writeFile out_file out
+      exists <- doesFileExist gold_file
+      if exists
+        then do gold <- readFile gold_file
+                return $! (out == gold)
+        else return False
+
+
+rgl_src_dir     = "lib" </> "src"
 rgl_dst_dir lbi = buildDir lbi </> "rgl"
 
 -- the languages have long directory names and short ISO codes (3 letters)
 -- we also give the decodings for postprocessing linearizations, as long as grammars
 -- don't support all flags needed; they are used in tests
-
+ 
 langsCoding = [
-  (("afrikaans","Afr"),""),
   (("amharic",  "Amh"),""),
   (("arabic",   "Ara"),""),
   (("bulgarian","Bul"),""),
   (("catalan",  "Cat"),""),
-  (("chinese",  "Chi"),""),
   (("danish",   "Dan"),""),
   (("dutch",    "Dut"),""),
   (("english",  "Eng"),""),
-  (("estonian", "Est"),""),
   (("finnish",  "Fin"),""),
   (("french",   "Fre"),""),
-  (("ancient_greek","Grc"),""),
-  (("greek",    "Gre"),""),
-  (("hebrew",   "Heb"),""),
   (("hindi",    "Hin"),"to_devanagari"),
   (("german",   "Ger"),""),
-  (("icelandic","Ice"),""),
   (("interlingua","Ina"),""),
   (("italian",  "Ita"),""),
-  (("japanese", "Jpn"),""),
   (("latin",    "Lat"),""),
-  (("latvian",    "Lav"),""),
-  (("maltese",  "Mlt"),""),
-  (("mongolian","Mon"),""),
-  (("nepali",   "Nep"),""),
   (("norwegian","Nor"),""),
-  (("nynorsk",  "Nno"),""),
-  (("persian",  "Pes"),""),
   (("polish",   "Pol"),""),
-  (("punjabi",   "Pnb"),""),
   (("romanian", "Ron"),""),
   (("russian",  "Rus"),""),
-  (("sindhi",   "Snd"),""),
   (("spanish",  "Spa"),""),
-  (("swedish",  "Swe"),""),
+  (("swedish",  "Swe"),""), 
   (("thai",     "Tha"),"to_thai"),
   (("turkish",  "Tur"),""),
   (("urdu",     "Urd"),"")
@@ -244,22 +210,17 @@ langs = map fst langsCoding
 -- defaultLangs = langs `only` words "Eng Fre Ger Ita Spa Swe"
 
 -- languagues for which to compile Lang
-langsLang = langs -- `except` ["Amh","Ara","Lat","Tur"]
+langsLang = langs `except` ["Amh","Ara","Lat","Hin","Tha","Tur"]
 --langsLang = langs `only` ["Fin"] --test
 
--- languagues that have notpresent marked
-langsPresent = langsLang `except` ["Afr","Chi","Gre","Heb","Ice","Jpn","Mlt","Mon","Nep","Pes","Snd","Tha","Thb","Est"]
+-- languages for which to compile Try 
+langsAPI  = langsLang `except` ["Hin","Ina","Tha"]
 
--- languages for which to compile Try
-langsAPI  = langsLang `except` langsIncomplete -- ["Ina","Amh","Ara"]
-
-langsIncomplete = ["Amh","Ara","Grc","Heb","Ina","Lat","Tur"]
-
--- languages for which to compile Symbolic
-langsSymbolic  = langsAPI `except` ["Afr","Ice","Jpn","Mon","Nep"]
+-- languages for which to compile Symbolic 
+langsSymbolic  = langsAPI `except` ["Rus"]
 
 -- languages for which to run demo test
-langsDemo = langsLang `except` ["Ara","Hin","Ina","Lav","Tha"]
+langsDemo = langsLang `except` ["Ara","Hin","Ina","Tha"]
 
 -- languages for which to compile parsing grammars
 langsParse = langs `only` ["Eng"]
@@ -268,28 +229,28 @@ langsParse = langs `only` ["Eng"]
 langsPGF = langsLang `except` ["Ara","Hin","Ron","Tha"]
 
 -- languages for which Compatibility exists (to be extended)
-langsCompat = langsLang `only` ["Cat","Eng","Fin","Fre","Ita","Lav","Spa","Swe"]
+langsCompat = langsLang `only` ["Cat","Eng","Fin","Fre","Ita","Spa","Swe"]
 
-gfc bi modes summary files = 
-    parallel_ [gfcn bi mode summary files | mode<-modes]
-gfcn bi mode summary files = do
-  let dir = getRGLBuildDir (lbi bi) mode
+gfc modes pkg lbi file = sequence_ [gfc1 mode pkg lbi file | mode<-modes]
+gfc1 mode pkg lbi file = do
+  let dir = getRGLBuildDir lbi mode
       preproc = case mode of
                   AllTenses -> ""
                   Present   -> "-preproc="++({-rgl_src_dir </>-} "mkPresent")
+                  Minimal   -> "-preproc="++({-rgl_src_dir </>-} "mkMinimal")
   createDirectoryIfMissing True dir
-  putStrLn $ "Compiling [" ++ show mode ++ "] " ++ summary
-  run_gfc bi (["-s", "-no-pmcfg", preproc, "--gfo-dir="++dir] ++ files)
+  putStrLn $ "Compiling [" ++ show mode ++ "] " ++ file
+  run_gfc pkg lbi ["-s", preproc, "--gfo-dir="++dir, file]
 
-gf bi comm files = do
+gf comm files pkg lbi = do
   putStrLn $ "Reading " ++ unwords files
-  let gf = default_gf (lbi bi)
+  let gf = default_gf pkg lbi
   putStrLn ("executing: " ++ comm ++ "\n" ++
             "in " ++ gf)
   out <- readProcess gf ("-s":files) comm
   putStrLn out
 
-demos abstr ls = "gr -number=100 | l -treebank " ++ unlexer abstr ls ++
+demos abstr ls = "gr -number=100 | l -treebank " ++ unlexer abstr ls ++ 
            " | ps -to_html | wf -file=resdemo.html"
 
 lang   (lla,la) = rgl_src_dir </> lla </> ("All"           ++ la ++ ".gf")
@@ -310,7 +271,8 @@ getOptMode args =
     then default_modes
     else explicit_modes
   where
-    explicit_modes =
+    explicit_modes = 
+      [Minimal|have "minimal"]++
       [Present|have "present"]++
       [AllTenses|have "alltenses"]
 
@@ -333,14 +295,13 @@ getOptLangs defaultLangs args =
                    then findLangs langs [l]++ls
                    else ls
 
-getRGLBuildSubDir mode =
+getRGLBuildSubDir lbi mode =
   case mode of
     AllTenses -> "alltenses"
     Present   -> "present"
+    Minimal   -> "minimal"
 
-
-getRGLBuildDir :: LocalBuildInfo -> Mode -> FilePath
-getRGLBuildDir lbi mode = rgl_dst_dir lbi </> getRGLBuildSubDir mode
+getRGLBuildDir lbi mode = rgl_dst_dir lbi </> getRGLBuildSubDir lbi mode
 
 getRGLCommands args =
   let cmds0 = [cmd | arg <- args,
@@ -355,86 +316,27 @@ getRGLCommands args =
 langs_prefix = "langs="
 rgl_prefix = "rgl-"
 
-unlexer abstr ls =
-  "-unlexer=\\\"" ++ unwords
-      [abstr ++ la ++ "=" ++ unl |
-        lla@(_,la) <- ls, let unl = unlex lla, not (null unl)] ++
+unlexer abstr ls = 
+  "-unlexer=\\\"" ++ unwords 
+      [abstr ++ la ++ "=" ++ unl | 
+        lla@(_,la) <- ls, let unl = unlex lla, not (null unl)] ++ 
       "\\\""
     where
       unlex lla = maybe "" id $ lookup lla langsCoding
 
 -- | Runs the gf executable in compile mode with the given arguments.
-run_gfc :: Info -> [String] -> IO ()
-run_gfc bi args =
-    do let args' = numJobs (bf bi)++["-batch","-gf-lib-path="++rgl_src_dir]
-                   ++ filter (not . null) args
-           gf = default_gf (lbi bi)
-       execute gf args'
+run_gfc :: PackageDescription -> LocalBuildInfo -> [String] -> IO ()
+run_gfc pkg lbi args = 
+    do let args' = ["-batch","-gf-lib-path="++rgl_src_dir,"+RTS","-K32M","-RTS"] ++ filter (not . null) args
+           gf = default_gf pkg lbi
+       putStrLn $ "Running: " ++ gf ++ " " ++ unwords (map showArg args')
+       e <- rawSystem gf args'
+       case e of
+         ExitSuccess   -> return ()
+         ExitFailure i -> die $ "gf exited with exit code: " ++ show i
+  where showArg arg = "'" ++ arg ++ "'"
 
-default_gf :: LocalBuildInfo -> FilePath
-default_gf lbi = buildDir lbi </> exeName' </> exeNameReal
+default_gf pkg lbi = buildDir lbi </> exeName' </> exeNameReal
   where
-    exeName' = "gf"
-    exeNameReal = exeName' <.> exeExtension
-    {- --old solution, could pick the wrong executable if there is more than one
     exeName' = (exeName . head . executables) pkg
     exeNameReal = exeName' <.> (if null $ takeExtension exeName' then exeExtension else "")
-    -}
-
--- | Create autogen module with detailed version info by querying darcs
-extractDarcsVersion distFlag =
-  do info <- tryIOE askDarcs
-     createDirectoryIfMissing True autogenPath
-     updateFile versionModulePath $ unlines $
-       ["module "++modname++" where",
-        "{-# NOINLINE darcs_info #-}",
-        "darcs_info = "++show (either (const (Left ())) Right info)]
-  where
-    dist = fromFlagOrDefault "dist" distFlag
-    autogenPath = dist</>"build"</>"autogen"
-    versionModulePath = autogenPath</>"DarcsVersion_gf.hs"
-    modname = "DarcsVersion_gf"
-
-askDarcs =
-  do flip unless (fail "no _darcs") =<< doesDirectoryExist "_darcs"
-     tags <- lines `fmap` readProcess "darcs" ["show","tags"] ""
-     let from = case tags of
-                  [] -> []
-                  tag:_ -> ["--from-tag="++tag]
-     dates <- (init' . patches) `fmap` readProcess "darcs" ("changes":from) ""
---   let dates = init' (filter ((`notElem` [""," "]).take 1) changes)
-     whatsnew <- tryIOE $ lines `fmap` readProcess "darcs" ["whatsnew","-s"] ""
-     return (listToMaybe tags,listToMaybe dates,
-             length dates,either (const 0) length whatsnew)
-  where
-    init' [] = []
-    init' xs = init xs
-
--- | Only update the file if contents has changed
-updateFile path new =
-  do old <- tryIOE $ readFile path
-     when (Right new/=old) $ seq (either (const 0) length old) $
-                                 writeFile path new
-
--- | List files, excluding "." and ".."
-list_files path = filter ((/=".").take 1) `fmap` getDirectoryContents path
-
-
--- | For parallel RGL module compilation
--- Unfortunately, this has no effect unless Setup.hs is compiled with -threaded
-parallel_ ms = sequence_ ms {-
-  do c <- newChan
-     ts <- sequence [ forkIO (m >> writeChan c ()) | m <- ms]
-     sequence_ [readChan c | _ <- ts]
---}
-
-patches = paras . lines
-  where
-    paras = unfoldr para
-    para ls = case break null $ dropWhile null ls of
-                ([],[]) -> Nothing
-                (xs,ys) -> Just (info xs,ys)
-
-    info = unwords . map dropHeaders . filter (\l->not $ any (`isPrefixOf` l) [" ","patch "])
-    dropHeaders = dropWhile isSpace . dropPrefix "Author: " . dropPrefix "Date: "
-    dropPrefix pre l = maybe l id (stripPrefix pre l)

WebSetup.hs

@@ -1,111 +0,0 @@
-module WebSetup(buildWeb,installWeb,copyWeb,numJobs,execute) where
-
-import System.Directory(createDirectoryIfMissing,copyFile)
-import System.FilePath((</>),dropExtension)
-import System.Process(rawSystem)
-import System.Exit(ExitCode(..))
-import Distribution.Simple.Setup(BuildFlags(..),Flag(..),CopyDest(..),copyDest)
-import Distribution.Simple.LocalBuildInfo(datadir,buildDir,absoluteInstallDirs)
-import Distribution.Simple.Utils(die)
-
-{-
-   To test the GF web services, the minibar and the grammar editor, use
-   "cabal install" (or "runhaskell Setup.hs install") to install gf as usual.
-   Then start the server with the command "gf -server" and open
-   http://localhost:41296/ in your web browser (Firefox, Safari, Opera or
-   Chrome). The example grammars listed below will be available in the minibar.
--}
-
-example_grammars =  -- :: [(pgf, subdir, src)]
-   [("Letter.pgf","letter",letterSrc)
-   ,("Foods.pgf","foods",foodsSrc)
-   ,("Phrasebook.pgf","phrasebook",phrasebookSrc)
-   ]
-  where
-  --foodsSrc = "Foods???.gf" -- doesn't work on Win32
-    foodsSrc = ["Foods"++lang++".gf"|lang<-foodsLangs]
-    foodsLangs = words "Afr Amh Bul Cat Cze Dut Eng Epo Fin Fre Ger Gle Heb Hin Ice Ita Jpn Lav Mlt Mon Nep Pes Por Ron Spa Swe Tha Tsn Tur Urd"
-
-  --phrasebookSrc = "Phrasebook???.gf" -- doesn't work on Win32
-    phrasebookSrc = ["Phrasebook"++lang++".gf"|lang<-phrasebookLangs]
-    phrasebookLangs = words "Bul Cat Chi Dan Dut Eng Lav Hin Nor Spa Swe Tha" -- only fastish languages
-
-  --letterSrc = "Letter???.gf"
-    letterSrc = ["Letter"++lang++".gf"|lang<-letterLangs]
-    letterLangs = words "Eng Fin Fre Heb Rus Swe"
-
-
-buildWeb gf (flags,pkg,lbi) =
-    do --putStrLn "buildWeb"
-       mapM_ build_pgf example_grammars
-  where
-    gfo_dir = buildDir lbi </> "examples"
-
-    build_pgf (pgf,subdir,src) =
-      do createDirectoryIfMissing True tmp_dir
-         putStrLn $ "Building "++pgf
-         execute gf args
-      where
-        tmp_dir = gfo_dir</>subdir
-        dir = "examples"</>subdir
-        args = numJobs flags++["-make","-s"] -- ,"-optimize-pgf"
-               ++["--gfo-dir="++tmp_dir,
-                  "--gf-lib-path="++buildDir lbi </> "rgl",
-                  "--name="++dropExtension pgf,
-                  "--output-dir="++gfo_dir]
-               ++[dir</>file|file<-src]
-
-installWeb = setupWeb NoCopyDest
-
-copyWeb flags = setupWeb dest
-  where
-    dest = case copyDest flags of
-             NoFlag -> NoCopyDest
-             Flag d -> d
-
-setupWeb dest (pkg,lbi) =
-    do mapM_ (createDirectoryIfMissing True) [grammars_dir,cloud_dir]
-       mapM_ copy_pgf example_grammars
-       copyGFLogo
-  where
-    grammars_dir = www_dir </> "grammars"
-    cloud_dir = www_dir </> "tmp" -- hmm
-    logo_dir = www_dir </> "Logos"
-    www_dir = datadir (absoluteInstallDirs pkg lbi dest) </> "www"
-    gfo_dir = buildDir lbi </> "examples"
-
-    copy_pgf (pgf,subdir,_) =
-      do let dst = grammars_dir</>pgf
-         putStrLn $ "Installing "++dst
-         copyFile (gfo_dir</>pgf) dst
-
-    gf_logo = "gf0.png"
-
-    copyGFLogo =
-      do createDirectoryIfMissing True logo_dir
-         copyFile ("doc"</>"Logos"</>gf_logo) (logo_dir</>gf_logo)
-
-execute command args =
-  do let cmdline = command ++ " " ++ unwords (map showArg args)
---   putStrLn $ "Running: " ++ cmdline
---   appendFile "running" (cmdline++"\n")
-     e <- rawSystem command args
-     case e of
-       ExitSuccess   -> return ()
-       ExitFailure i -> do putStrLn $ "Ran: " ++ cmdline
-                           die $ command++" exited with exit code: " ++ show i
-  where
-    showArg arg = if ' ' `elem` arg then "'" ++ arg ++ "'" else arg
-
--- | This function is used to enable parallel compilation of the RGL and
--- example grammars, but it is commented out by default
--- to avoid casing problems for developers using Cabal<1.20
-numJobs flags =
-    if null n
-    then ["-j","+RTS","-A20M","-N","-RTS"]
-    else ["-j="++n,"+RTS","-A20M","-N"++n,"-RTS"]
-  where
-    -- buildNumJobs is only available in Cabal>=1.20
-    n = {-case buildNumJobs flags of
-          Flag mn | mn/=Just 1-> maybe "" show mn
-          _ ->-} ""

bin/build-binary-dist.sh

@@ -1,86 +0,0 @@
-#! /bin/bash
-
-### This script builds a binary distribution of GF from the source
-### package that this script is a part of. It assumes that you have installed
-### the Haskell Platform, version 2013.2.0.0 or 2012.4.0.0.
-### Two binary package formats are supported: plain tar files (.tar.gz) and
-### OS X Installer packages (.pkg).
-
-os=$(uname)     # Operating system name (e.g. Darwin or Linux)
-hw=$(uname -m)  # Hardware name (e.g. i686 or x86_64)
-
-# GF version number:
-ver=$(grep -i ^version: gf.cabal | sed -e 's/version://' -e 's/ //g')
-
-name="gf-$ver"
-destdir="$PWD/dist/$name"          # assemble binary dist here
-prefix=${PREFIX:-/usr/local}       # where to install
-fmt=${FMT:-tar.gz}                 # binary package format (tar.gz or pkg)
-
-extralib="$destdir$prefix/lib"
-extrainclude="$destdir$prefix/include"
-extra="--extra-lib-dirs=$extralib --extra-include-dirs=$extrainclude"
-
-set -e                             # Stop if an error occurs
-set -x                             # print commands before exuting them
-
-## First configure & build the C run-time system
-pushd src/runtime/c
-bash setup.sh configure --prefix="$prefix"
-bash setup.sh build
-bash setup.sh install prefix="$destdir$prefix"
-popd
-
-## Build the python binding to the C run-time system
-if which >/dev/null python; then
-    pushd src/runtime/python
-    EXTRA_INCLUDE_DIRS="$extrainclude" EXTRA_LIB_DIRS="$extralib" python setup.py build
-    python setup.py install --prefix="$destdir$prefix"
-    if [ "$fmt" == pkg ] ; then
-	# A hack for Python on OS X to find the PGF modules
-	pyver=$(ls "$destdir$prefix/lib" | sed -n 's/^python//p')
-	pydest="$destdir/Library/Python/$pyver/site-packages"
-	mkdir -p "$pydest"
-	ln "$destdir$prefix/lib/python$pyver/site-packages"/pgf* "$pydest"
-    fi
-    popd
-else
-    echo "Python is not installed, so the Python binding will not be included"
-fi
-
-## Build the Java binding to the C run-time system
-if which >/dev/null javac && which >/dev/null jar ; then
-    pushd src/runtime/java
-    rm -f libjpgf.la # In case it contains the wrong INSTALL_PATH
-    if make CFLAGS="-I$extrainclude -L$extralib" INSTALL_PATH="$prefix/lib"
-    then
-	make INSTALL_PATH="$destdir$prefix/lib" install
-    else
-	echo "*** Skipping the Java binding because of errors"
-    fi
-    popd
-else
-    echo "Java SDK is not installed, so the Java binding will not be included"
-fi
-
-## Build GF, with C run-time support enabled
-cabal install --only-dependencies -fserver -fc-runtime $extra
-cabal configure --prefix="$prefix" -fserver -fc-runtime $extra
-DYLD_LIBRARY_PATH="$extralib" LD_LIBRARY_PATH="$extralib" cabal build
-cabal copy --destdir="$destdir"
-libdir=$(dirname $(find "$destdir" -name PGF.hi))
-cabal register --gen-pkg-config=$libdir/gf-$ver.conf
-
-case $fmt in
-    tar.gz)
-	targz="$name-bin-$hw-$os.tar.gz"     # the final tar file
-	tar -C "$destdir/$prefix" -zcf "dist/$targz" .
-	echo "Created $targz, consider renaming it to something more user friendly"
-	;;
-    pkg)
-	pkg=$name.pkg
-	pkgbuild --identifier org.grammaticalframework.gf.pkg --version "$ver" --root "$destdir" --install-location / dist/$pkg
-	echo "Created $pkg"
-esac
-
-rm -r "$destdir"