Final changes for the GF 3.8 release

News item on the home page
Put the download page and release notes in place.
Add an entry in debian/changelog.
Update the version number in gf.cabal.

.authorspellings

@@ -0,0 +1,23 @@
+-- Use darcs show authors to see the number of patches per person
+
+Aarne Ranta		<aarne@chalmers.se>,		aarne@cs.chalmers.se, aarne
+Björn Bringert		<bjorn@bringert.net>,		bringert@cs.chalmers.se, bringert
+Krasimir Angelov	<krasimir@chalmers.se>,		kr.angelov@chalmers.se,kr.angelov@gmail.com,kr_angelov@gmail.com
+Peter Ljunglöf		<peb@ling.gu.se>,		peb,peb@cs.chalmers.se
+Thomas Hallgren		<hallgren@chalmers.se>,		hallgren@altocumulus.org
+Janna Khegai		<janna@cs.chalmer.se>,		janna,janna@cs.chalmers.se
+Jordi Saludes 		<jordi.saludes@upc.edu>
+Ramona Enache		<ramona.enache@chalmers.se>,	ra.monique@gmail.com
+Hans-Joachim Daniels	<hdaniels>
+Jean-Philippe Bernardy	<bernardy@chalmers.se>
+Kevin Kofler		<kevin.kofler@chello.at>
+Harald Hammarström	<harald2>
+Olga Caprotti		<caprotti@chalmers.se>,		olga.caprotti@gmail.com
+Adam Slaski		<adam.slaski@gmail.com>,	Adam Slaski <adam.slaski@gmail.com>
+Moisés Salvador Meza Moreno<meza@student.chalmers.se>,	'Moises Meza <meza@student.chalmers.se>'
+Ali El Dada		<eldada@student.chalmers.se>,	'ali.eldada@gmail.com'
+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

.gitignore

@@ -1,62 +0,0 @@
-*.class
-*.la
-*.o
-*.lo
-*.jar
-*.gfo
-*.pgf
-dist/
-src/runtime/c/.libs/
-src/runtime/c/Makefile
-src/runtime/c/Makefile.in
-src/runtime/c/aclocal.m4
-src/runtime/c/autom4te.cache/
-src/runtime/c/config.h
-src/runtime/c/config.h.in
-src/runtime/c/config.log
-src/runtime/c/config.status
-src/runtime/c/configure
-src/runtime/c/gu/.deps/
-src/runtime/c/gu/.dirstamp
-src/runtime/c/libgu.pc
-src/runtime/c/libpgf.pc
-src/runtime/c/libsg.pc
-src/runtime/c/libtool
-src/runtime/c/m4/libtool.m4
-src/runtime/c/m4/ltoptions.m4
-src/runtime/c/m4/ltsugar.m4
-src/runtime/c/m4/ltversion.m4
-src/runtime/c/m4/lt~obsolete.m4
-src/runtime/c/pgf/.deps/
-src/runtime/c/pgf/.dirstamp
-src/runtime/c/pgf/lightning/asm.h
-src/runtime/c/pgf/lightning/core.h
-src/runtime/c/pgf/lightning/fp.h
-src/runtime/c/pgf/lightning/funcs.h
-src/runtime/c/scripts/
-src/runtime/c/sg/.deps/
-src/runtime/c/sg/.dirstamp
-src/runtime/c/stamp-h1
-src/runtime/java/.libs/
-src/runtime/python/build/
-.cabal-sandbox
-cabal.sandbox.config
-.stack-work
-DATA_DIR
-
-# Generated documentation (not exhaustive)
-demos/index-numbers.html
-demos/resourcegrammars.html
-demos/translation.html
-doc/tutorial/gf-tutorial.html
-doc/index.html
-doc/gf-bibliography.html
-doc/gf-developers.html
-doc/gf-editor-modes.html
-doc/gf-people.html
-doc/gf-refman.html
-doc/gf-shell-reference.html
-doc/icfp-2012.html
-download/*.html
-gf-book/index.html
-src/www/gf-web-api.html

.travis.yml

@@ -1,14 +0,0 @@
-sudo: required
-
-language: c
-
-services:
-  - docker
-
-before_install:
-  - docker pull odanoburu/gf-src:3.9
-
-script:
-  - |
-    docker run --mount src="$(pwd)",target=/home/gfer,type=bind odanoburu/gf-src:3.9 /bin/bash -c "cd /home/gfer/src/runtime/c &&
-    autoreconf -i && ./configure && make && make install ; cd /home/gfer ; cabal install -fserver -fc-runtime --extra-lib-dirs='/usr/local/lib'"

LICENSE

@@ -8,9 +8,24 @@ other. For this reason the different components have different licenses.
 In summary:
 
   - the GF compiler in the folder src/compiler and the PGF Web service in src/server
-are under the GNU GENERAL PUBLIC LICENSE.
+are under the GNU GENERAL PUBLIC LICENSE. 
 
-  - the GF runtime in src/runtime is under dual GNU LESSER GENERAL PUBLIC LICENSE and BSD LICENSE
+  - the GF runtime in src/runtime is under dual GNU LESSER GENERAL PUBLIC LICENSE
+and BSD LICENSE
+
+  - the resource grammar library in lib/src is under GNU LESSER GENERAL PUBLIC LICENSE.
+However the user have the right to choose any license for any application grammar
+derived from the resource grammar by using the grammar API.
+
+  - the resource grammar library also includes large coverage lexicons for some languages.
+Since these lexicons are derived from external sources they might be under different licenses.
+Look at the source file for every lexicon for details. The lexicons that we currently have
+are:
+
+       lib/src/bulgarian/    DictBul.gf DictBulAbs.gf    for Bulgarian
+       lib/src/english/      DictEng.gf DictEngAbs.gf    for English
+       lib/src/turkish/      DictTur.gf DictTurAbs.gf    for Turkish
+       lib/src/swedish/      DictSwe.gf DictSweAbs.gf    for Swedish
 
 The rest of this document contains copies of the GPL, LGPL and BSD licenses
 which are applicable to the different components of Grammatical Framework

Makefile

@@ -1,4 +1,4 @@
-.PHONY: all build install doc clean gf html deb pkg bintar sdist
+.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)
@@ -20,7 +20,9 @@ doc:
 
 clean:
 	cabal clean
-	bash bin/clean_html
+
+#sdist:
+#	cabal sdist
 
 gf:
 	cabal build rgl-none
@@ -33,7 +35,7 @@ html::
 # number to the top of debian/changelog.
 # (Tested on Ubuntu 15.04. You need to install dpkg-dev & debhelper.)
 deb:
-	dpkg-buildpackage -b -uc
+	dpkg-buildpackage -b
 
 # Make an OS X Installer package
 pkg:
@@ -43,11 +45,9 @@ pkg:
 bintar:
 	bash bin/build-binary-dist.sh
 
-#sdist:
-#	cabal sdist
-
-# Make a source tar.gz distribution using git to make sure that everything is included.
-# We put the distribution in dist/ so it is removed on `make clean`
+# 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
-	git archive --format=tar.gz --output=dist/gf-${VERSION}.tar.gz HEAD
+	darcs dist -d dist/gf-${VERSION}

README

@@ -0,0 +1,34 @@
+DESCRIPTION
+
+The Grammatical Framework (=GF) is a grammar formalism based on type theory. 
+It consists of
+
+    * a special-purpose programming language
+    * a compiler of the language
+    * a generic grammar processor 
+
+The compiler reads GF grammars from user-provided files, and the 
+generic grammar processor performs various tasks with the grammars:
+
+    * generation
+    * parsing
+    * translation
+    * type checking
+    * computation
+    * paraphrasing
+    * random generation
+    * syntax editing 
+
+GF particularly addresses four aspects of grammars:
+
+    * multilinguality (parallel grammars for different languages)
+    * semantics (semantic conditions of well-formedness, semantic 
+      properties of expressions) 
+    * grammar engineering (modularity, abstractions, libraries)
+    * embeddability in programs written in other languages (C,C++,
+      Haskell, Java, JavaScript)
+
+
+COMPILATION and INSTALLATION of source distribution:
+See download/index.html for installation instructions.
+(More details can be found in doc/gf-developers.html.)

README.md

@@ -1,53 +0,0 @@
-![GF Logo](doc/Logos/gf1.svg)
-
-# Grammatical Framework (GF)
-
-[![Build Status](https://travis-ci.org/GrammaticalFramework/gf-core.svg?branch=master)](https://travis-ci.org/GrammaticalFramework/gf-core)
-
-The Grammatical Framework is a grammar formalism based on type theory.
-It consists of:
-
-- a special-purpose programming language
-- a compiler of the language
-- a generic grammar processor
-
-The compiler reads GF grammars from user-provided files, and the
-generic grammar processor performs various tasks with the grammars:
-
-- generation
-- parsing
-- translation
-- type checking
-- computation
-- paraphrasing
-- random generation
-- syntax editing
-
-GF particularly addresses four aspects of grammars:
-
-- multilinguality (parallel grammars for different languages)
-- semantics (semantic conditions of well-formedness, semantic properties of expressions)
-- grammar engineering (modularity, abstractions, libraries)
-- embeddability in programs written in other languages (C, C++, Haskell, Java, JavaScript)
-
-## Compilation and installation
-
-The simplest way of installing GF is with the command:
-```
-cabal install
-```
-
-For more details, see the [download page](http://www.grammaticalframework.org/download/index.html)
-and [developers manual](http://www.grammaticalframework.org/doc/gf-developers.html).
-
-## About this repository
-
-On 2018-07-25, the monolithic [GF repository](https://github.com/GrammaticalFramework/GF)
-was split in two:
-
-1. [gf-core](https://github.com/GrammaticalFramework/gf-core) —  the GF compiler, shell and runtimes
-2. [gf-rgl](https://github.com/GrammaticalFramework/gf-rgl) — the resource grammar library
-
-The former repository is now archived and no longer updated.
-The split was performed using [this script](https://github.com/GrammaticalFramework/GF/blob/30ae1b5a5f73513ac5825ca6712186ef8afe9fd4/split/run.sh)
-and the output of that script is [here](https://gist.github.com/johnjcamilleri/a6c43ff61f15a9657b457ac94ab7db61).

Setup.hs

@@ -1,82 +1,438 @@
-import Distribution.System(Platform(..),OS(..))
-import Distribution.Simple(defaultMainWithHooks,UserHooks(..),simpleUserHooks)
-import Distribution.Simple.LocalBuildInfo(LocalBuildInfo(..),absoluteInstallDirs,datadir)
-import Distribution.Simple.Setup(BuildFlags(..),Flag(..),InstallFlags(..),CopyDest(..),CopyFlags(..),SDistFlags(..))
-import Distribution.PackageDescription(PackageDescription(..),emptyHookedBuildInfo)
+import Distribution.Simple
+import Distribution.Simple.LocalBuildInfo
 import Distribution.Simple.BuildPaths(exeExtension)
-import System.FilePath((</>),(<.>))
+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 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
 
--- | Notice about RGL not built anymore
-noRGLmsg :: IO ()
-noRGLmsg = putStrLn "Notice: the RGL is not built as part of GF anymore. See https://github.com/GrammaticalFramework/gf-rgl"
+tryIOE :: IO a -> IO (Either E.IOException a)
+tryIOE = E.try
 
 main :: IO ()
-main = defaultMainWithHooks simpleUserHooks
-  { preBuild  = gfPreBuild
-  , postBuild = gfPostBuild
-  , preInst   = gfPreInst
-  , postInst  = gfPostInst
-  , postCopy  = gfPostCopy
-  , sDistHook = gfSDist
-  }
+main = defaultMainWithHooks simpleUserHooks{ preBuild  = gfPreBuild
+                                           , postBuild = gfPostBuild
+                                           , preInst   = gfPreInst
+                                           , postInst  = gfPostInst
+                                           , preCopy   = const . checkRGLArgs
+                                           , postCopy  = gfPostCopy
+                                           , sDistHook = sdistError
+                                           }
   where
     gfPreBuild args  = gfPre args . buildDistPref
     gfPreInst args = gfPre args . installDistPref
 
-    gfPre args distFlag = do
-      return emptyHookedBuildInfo
+    gfPre args distFlag =
+      do h <- checkRGLArgs args
+         extractDarcsVersion distFlag
+         return h
 
-    gfPostBuild args flags pkg lbi = do
-      noRGLmsg
-      let gf = default_gf lbi
-      buildWeb gf flags (pkg,lbi)
+    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
-      noRGLmsg
-      saveInstallPath args flags (pkg,lbi)
-      installWeb (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
-      noRGLmsg
-      saveCopyPath args flags (pkg,lbi)
-      copyWeb flags (pkg,lbi)
+    gfPostCopy args flags  pkg lbi =
+      do let gf = default_gf lbi
+         copyRGL args flags (pkg,lbi)
+         copyWeb flags (pkg,lbi)
 
-    -- `cabal sdist` will not make a proper dist archive, for that see `make sdist`
-    -- However this function should exit quietly to allow building gf in sandbox
-    gfSDist pkg lbi hooks flags = do
-      return ()
+--------------------------------------------------------
+-- Commands for building the Resource Grammar Library
+--------------------------------------------------------
 
-saveInstallPath :: [String] -> InstallFlags -> (PackageDescription, LocalBuildInfo) -> IO ()
-saveInstallPath args flags bi = do
-  let
-    dest = NoCopyDest
-    dir = datadir (uncurry absoluteInstallDirs bi dest)
-  writeFile dataDirFile dir
+data Mode = AllTenses | Present deriving Show
+all_modes = ["alltenses","present"]
+default_modes = [AllTenses,Present]
 
-saveCopyPath :: [String] -> CopyFlags -> (PackageDescription, LocalBuildInfo) -> IO ()
-saveCopyPath args flags bi = do
-  let
-    dest = case copyDest flags of
-      NoFlag -> NoCopyDest
-      Flag d -> d
-    dir = datadir (uncurry absoluteInstallDirs bi dest)
-  writeFile dataDirFile dir
+data RGLCommand
+  = RGLCommand
+      { cmdName   :: String
+      , cmdIsDef  :: Bool
+      , cmdAction :: [Mode] -> [String] -> Info -> IO ()
+      }
 
--- | Name of file where installation's data directory is recording
--- This is a last-resort way in which the seprate RGL build script
--- can determine where to put the compiled RGL files
-dataDirFile :: String
-dataDirFile = "DATA_DIR"
+type Info = (BuildFlags,PackageDescription,LocalBuildInfo)
+bf (i,_,_) = i
+--pd (_,i,_) = i
+lbi (_,_,i) = i
+
+rglCommands =
+  [ RGLCommand "prelude" True  $ \mode args bi -> do
+       putStrLn $ "Compiling [prelude]"
+       let prelude_src_dir = rgl_src_dir    </> "prelude"
+           prelude_dst_dir = rgl_dst_dir (lbi bi) </> "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
+          createDirectoryIfMissing True dir
+          sequence_ [run_gfc bi ["-s","-make","-name=Lang"++la,
+                                       dir ++ "/Lang" ++ la ++ ".gfo"]
+                      | (_,la) <- optl langsPGF args]
+          run_gfc bi (["-s","-make","-name=Lang"]++
+                           ["Lang" ++ la ++ ".pgf"|(_,la)<-optl langsPGF args])
+       | mode <- modes]
+  , RGLCommand "demo"    False $ \modes args bi -> do
+       let ls = optl langsDemo args
+       gf bi (demos "Demo" ls) ["demo/Demo" ++ la ++ ".gf" | (_,la) <- ls]
+       return ()
+  , RGLCommand "parse"   False $ \modes args bi ->
+       gfc bi modes (summary parse) (map parse (optl langsParse args))
+  , RGLCommand "none"    False $ \modes args bi ->
+       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
+
+--------------------------------------------------------
+
+checkRGLArgs args = 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
+
+buildRGL args flags bi = do
+  let cmds = getRGLCommands args
+  let modes = getOptMode args
+  mapM_ (\cmd -> cmdAction cmd modes args bi) cmds
+
+installRGL args flags bi = 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]
+
+copyRGL args flags bi = 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]
+
+copyAll s from to = do
+  putStrLn $ "Installing [" ++ s ++ "] " ++ to
+  createDirectoryIfMissing True to
+  mapM_ (\file -> copyFile (from </> file) (to </> file)) =<< list_files from
+{-
+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
+
+    processFile dir paths file = do
+      let path = dir </> file
+      print path
+      isFile <- doesFileExist path
+      if isFile
+        then if takeExtension file == ".gf" || file == "LICENSE"
+               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"
+
+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"),""),
+  (("interlingua","Ina"),""),
+  (("italian",  "Ita"),""),
+  (("japanese", "Jpn"),""),
+  (("latin",    "Lat"),""),
+  (("latvian",    "Lav"),""),
+  (("maltese",  "Mlt"),""),
+  (("mongolian","Mon"),""),
+  (("nepali",   "Nep"),""),
+  (("norwegian","Nor"),""),
+  (("persian",  "Pes"),""),
+  (("polish",   "Pol"),""),
+  (("punjabi",   "Pnb"),""),
+  (("romanian", "Ron"),""),
+  (("russian",  "Rus"),""),
+  (("sindhi",   "Snd"),""),
+  (("spanish",  "Spa"),""),
+  (("swedish",  "Swe"),""),
+  (("thai",     "Tha"),"to_thai"),
+  (("turkish",  "Tur"),""),
+  (("urdu",     "Urd"),"")
+  ]
+
+langs = map fst langsCoding
+
+-- default set of languages to compile
+-- 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 `only` ["Fin"] --test
+
+-- languagues that have notpresent marked
+langsPresent = langsLang `except` ["Afr","Chi","Gre","Heb","Jpn","Mlt","Mon","Nep","Pes","Snd","Tha","Thb","Est"]
+
+-- 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","Jpn","Mon","Nep"]
+
+-- languages for which to run demo test
+langsDemo = langsLang `except` ["Ara","Hin","Ina","Lav","Tha"]
+
+-- languages for which to compile parsing grammars
+langsParse = langs `only` ["Eng"]
+
+-- languages for which langs.pgf is built
+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"]
+
+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
+      preproc = case mode of
+                  AllTenses -> ""
+                  Present   -> "-preproc="++({-rgl_src_dir </>-} "mkPresent")
+  createDirectoryIfMissing True dir
+  putStrLn $ "Compiling [" ++ show mode ++ "] " ++ summary
+  run_gfc bi (["-s", "-no-pmcfg", preproc, "--gfo-dir="++dir] ++ files)
+
+gf bi comm files = do
+  putStrLn $ "Reading " ++ unwords files
+  let gf = default_gf (lbi bi)
+  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 ++
+           " | ps -to_html | wf -file=resdemo.html"
+
+lang   (lla,la) = rgl_src_dir </> lla </> ("All"           ++ la ++ ".gf")
+compat (lla,la) = rgl_src_dir </> lla </> ("Compatibility" ++ la ++ ".gf")
+symbol (lla,la) = rgl_src_dir </> lla </> ("Symbol"        ++ la ++ ".gf")
+
+try    (lla,la) = rgl_src_dir </> "api" </> ("Try"    ++ la ++ ".gf")
+syntax (lla,la) = rgl_src_dir </> "api" </> ("Syntax" ++ la ++ ".gf")
+
+symbolic (lla,la) = rgl_src_dir </> "api"   </> ("Symbolic" ++ la ++ ".gf")
+parse    (lla,la) = rgl_src_dir </> "parse" </> ("Parse"    ++ la ++ ".gf")
+
+except ls es = filter (flip notElem es . snd) ls
+only   ls es = filter (flip elem es . snd) ls
+
+getOptMode args =
+    if null explicit_modes
+    then default_modes
+    else explicit_modes
+  where
+    explicit_modes =
+      [Present|have "present"]++
+      [AllTenses|have "alltenses"]
+
+    have mode = mode `elem` args
+
+-- list of languages overriding the definitions above
+getOptLangs defaultLangs args =
+    case [ls | arg <- args,
+               let (f,ls) = splitAt (length langs_prefix) arg,
+               f==langs_prefix] of
+      ('+':ls):_ -> foldr addLang defaultLangs (seps ls)
+      ('-':ls):_ -> foldr removeLang defaultLangs (seps ls)
+      ls:_ -> findLangs langs (seps ls)
+      _    -> defaultLangs
+  where
+    seps = words . map (\c -> if c==',' then ' ' else c)
+    findLangs langs ls = [lang | lang@(_,la) <- langs, la `elem` ls]
+    removeLang l ls = [lang | lang@(_,la) <- ls, la/=l]
+    addLang l ls = if null (findLangs ls [l])
+                   then findLangs langs [l]++ls
+                   else ls
+
+getRGLBuildSubDir mode =
+  case mode of
+    AllTenses -> "alltenses"
+    Present   -> "present"
+
+
+getRGLBuildDir :: LocalBuildInfo -> Mode -> FilePath
+getRGLBuildDir lbi mode = rgl_dst_dir lbi </> getRGLBuildSubDir mode
+
+getRGLCommands args =
+  let cmds0 = [cmd | arg <- args,
+                     let (prefix,name) = splitAt (length rgl_prefix) arg,
+                     prefix == rgl_prefix,
+                     cmd <- rglCommands,
+                     cmdName cmd == name]
+  in if null cmds0
+       then [cmd | cmd <- rglCommands, cmdIsDef cmd]
+       else cmds0
+
+langs_prefix = "langs="
+rgl_prefix = "rgl-"
+
+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'
 
--- | Get path to locally-built gf
 default_gf :: LocalBuildInfo -> FilePath
 default_gf lbi = buildDir lbi </> exeName' </> exeNameReal
   where
-    -- shadows Distribution.Simple.BuildPaths.exeExtension, which changed type signature in Cabal 2.4
-    exeExtension = case hostPlatform lbi of
-      Platform arch Windows -> "exe"
-      _ -> ""
     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,12 +1,12 @@
 module WebSetup(buildWeb,installWeb,copyWeb,numJobs,execute) where
 
-import System.Directory(createDirectoryIfMissing,copyFile,doesDirectoryExist,doesFileExist)
+import System.Directory(createDirectoryIfMissing,copyFile)
 import System.FilePath((</>),dropExtension)
 import System.Process(rawSystem)
 import System.Exit(ExitCode(..))
-import Distribution.Simple.Setup(BuildFlags(..),Flag(..),CopyFlags(..),CopyDest(..),copyDest)
-import Distribution.Simple.LocalBuildInfo(LocalBuildInfo(..),datadir,buildDir,absoluteInstallDirs)
-import Distribution.PackageDescription(PackageDescription(..))
+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
@@ -16,83 +16,57 @@ import Distribution.PackageDescription(PackageDescription(..))
    Chrome). The example grammars listed below will be available in the minibar.
 -}
 
-{-
-  Update 2018-07-04
-
-  The example grammars have now been removed from the GF repository.
-  This script will look for them in ../gf-contrib and build them from there if possible.
-  If not, the user will be given a message and nothing is build or copied.
-  (Unfortunately cabal install seems to hide all messages from stdout,
-  so users won't see this message unless they check the log.)
--}
-
-example_grammars :: [(String, String, [String])] -- [(pgf, subdir, source modules)]
-example_grammars =
+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"
 
-contrib_dir :: FilePath
-contrib_dir = ".."</>"gf-contrib"
 
-buildWeb :: String -> BuildFlags -> (PackageDescription, LocalBuildInfo) -> IO ()
-buildWeb gf flags (pkg,lbi) = do
-  contrib_exists <- doesDirectoryExist contrib_dir
-  if contrib_exists
-  then mapM_ build_pgf example_grammars
-  else putStr $ unlines
-    [ "Example grammars are no longer included in the main GF repository, but have moved to gf-contrib."
-    , "If you want these example grammars to be built, clone this repository in the same top-level directory as GF:"
-    , "https://github.com/GrammaticalFramework/gf-contrib.git"
-    ]
+buildWeb gf (flags,pkg,lbi) =
+    do --putStrLn "buildWeb"
+       mapM_ build_pgf example_grammars
   where
     gfo_dir = buildDir lbi </> "examples"
 
-    build_pgf :: (String, String, [String]) -> IO Bool
     build_pgf (pgf,subdir,src) =
       do createDirectoryIfMissing True tmp_dir
          putStrLn $ "Building "++pgf
          execute gf args
       where
         tmp_dir = gfo_dir</>subdir
-        dir = contrib_dir</>subdir
-        dest = NoCopyDest
-        gf_lib_path = datadir (absoluteInstallDirs pkg lbi dest) </> "lib"
+        dir = "examples"</>subdir
         args = numJobs flags++["-make","-s"] -- ,"-optimize-pgf"
                ++["--gfo-dir="++tmp_dir,
-                --"--gf-lib-path="++gf_lib_path,
+                  "--gf-lib-path="++buildDir lbi </> "rgl",
                   "--name="++dropExtension pgf,
                   "--output-dir="++gfo_dir]
                ++[dir</>file|file<-src]
 
-installWeb :: (PackageDescription, LocalBuildInfo) -> IO ()
 installWeb = setupWeb NoCopyDest
 
-copyWeb :: CopyFlags -> (PackageDescription, LocalBuildInfo) -> IO ()
 copyWeb flags = setupWeb dest
   where
     dest = case copyDest flags of
              NoFlag -> NoCopyDest
              Flag d -> d
 
-setupWeb :: CopyDest -> (PackageDescription, LocalBuildInfo) -> IO ()
-setupWeb dest (pkg,lbi) = do
-  mapM_ (createDirectoryIfMissing True) [grammars_dir,cloud_dir]
-  contrib_exists <- doesDirectoryExist contrib_dir
-  if contrib_exists
-  then mapM_ copy_pgf example_grammars
-  else return () -- message already displayed from buildWeb
-  copyGFLogo
+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
@@ -100,14 +74,10 @@ setupWeb dest (pkg,lbi) = do
     www_dir = datadir (absoluteInstallDirs pkg lbi dest) </> "www"
     gfo_dir = buildDir lbi </> "examples"
 
-    copy_pgf :: (String, String, [String]) -> IO ()
     copy_pgf (pgf,subdir,_) =
-      do let src = gfo_dir </> pgf
-         let dst = grammars_dir </> pgf
-         ex <- doesFileExist src
-         if ex then do putStrLn $ "Installing "++dst
-                       copyFile src dst
-               else putStrLn $ "Not installing "++dst
+      do let dst = grammars_dir</>pgf
+         putStrLn $ "Installing "++dst
+         copyFile (gfo_dir</>pgf) dst
 
     gf_logo = "gf0.png"
 
@@ -115,27 +85,27 @@ setupWeb dest (pkg,lbi) = do
       do createDirectoryIfMissing True logo_dir
          copyFile ("doc"</>"Logos"</>gf_logo) (logo_dir</>gf_logo)
 
--- | Run an arbitrary system command, returning False on failure
-execute :: String -> [String] -> IO Bool
 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 True
+       ExitSuccess   -> return ()
        ExitFailure i -> do putStrLn $ "Ran: " ++ cmdline
-                           putStrLn $ command++" exited with exit code: " ++ show i
-                           return False
+                           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
-numJobs :: BuildFlags -> [String]
+-- | 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
+    n = {-case buildNumJobs flags of
           Flag mn | mn/=Just 1-> maybe "" show mn
-          _ -> ""
+          _ ->-} ""

bin/build-binary-dist.sh

@@ -2,7 +2,7 @@
 
 ### 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
-### a recent version of the Haskell Platform.
+### 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).
 
@@ -16,14 +16,13 @@ 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)
-ghc=${GHC:-ghc}                    # which Haskell compiler to use
 
 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 executing them
+set -x                             # print commands before exuting them
 
 ## First configure & build the C run-time system
 pushd src/runtime/c
@@ -65,30 +64,13 @@ else
 fi
 
 ## Build GF, with C run-time support enabled
-cabal install -w "$ghc" --only-dependencies -fserver -fc-runtime $extra
-cabal configure -w "$ghc" --prefix="$prefix" -fserver -fc-runtime $extra
+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
-  # Building the example grammars will fail, because the RGL is missing
-cabal copy --destdir="$destdir"  # create www directory
-
-## Build the RGL and copy it to $destdir
-PATH=$PWD/dist/build/gf:$PATH
-export GF_LIB_PATH="$(dirname $(find "$destdir" -name www))/lib"   # hmm
-mkdir -p "$GF_LIB_PATH"
-pushd ../gf-rgl
-make build
-make copy
-popd
-
-# Build GF again, including example grammars that need the RGL
-DYLD_LIBRARY_PATH="$extralib" LD_LIBRARY_PATH="$extralib" cabal build
-
-## Copy GF to $destdir
 cabal copy --destdir="$destdir"
 libdir=$(dirname $(find "$destdir" -name PGF.hi))
 cabal register --gen-pkg-config=$libdir/gf-$ver.conf
 
-## Create the binary distribution package
 case $fmt in
     tar.gz)
 	targz="$name-bin-$hw-$os.tar.gz"     # the final tar file

bin/clean_html

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# This script finds all .t2t (txt2tags) and .md (Markdown) files
-# and deletes the corresponding HTML file of the same name.
-
-find . -name '*.t2t' | while read t2t ; do
-  html="${t2t%.t2t}.html"
-  if [ -f "$html" ] ; then
-    echo "$html"
-    rm -f "$html"
-  fi
-done
-
-find . -name '*.md' | while read md ; do
-  html="${md%.md}.html"
-  if [ -f "$html" ] ; then
-    echo "$html"
-    rm -f "$html"
-  fi
-done

bin/template.html

@@ -1,146 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" lang="$lang$" xml:lang="$lang$"$if(dir)$ dir="$dir$"$endif$>
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-$for(author-meta)$
-  <meta name="author" content="$author-meta$" />
-$endfor$
-$if(date-meta)$
-  <meta name="dcterms.date" content="$date-meta$" />
-$endif$
-$if(keywords)$
-  <meta name="keywords" content="$for(keywords)$$keywords$$sep$, $endfor$" />
-$endif$
-  <title>$if(title-prefix)$$title-prefix$ – $endif$$pagetitle$</title>
-  <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
-  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.4.2/css/all.css" integrity="sha384-/rXc/GQVaYpyDdyxK+ecHPVYJSN9bmVFBvjA/9eOB+pb3F2w2N6fc5qB9Ew5yIns" crossorigin="anonymous">
-$for(css)$
-  <link rel="stylesheet" href="$css$" />
-$endfor$
-$if(math)$
-  $math$
-$endif$
-  <!--[if lt IE 9]>
-    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
-  <![endif]-->
-$for(header-includes)$
-  $header-includes$
-$endfor$
-</head>
-<body class="bg-light">
-  <div class="bg-white pb-5">
-$for(include-before)$
-$include-before$
-$endfor$
-<div class="container-fluid py-5" style="max-width:1200px">
-
-$if(title)$
-<header id="title-block-header">
-<a href="$rel-root$" title="Home">
-  <img src="$rel-root$/doc/Logos/gf1.svg" height="200" class="float-md-right ml-3 mb-3 bg-white" alt="GF Logo">
-</a>
-<h1 class="title">$title$</h1>
-$if(subtitle)$
-<p class="subtitle">$subtitle$</p>
-$endif$
-$for(author)$
-<p class="author">$author$</p>
-$endfor$
-$if(date)$
-<p class="date">$date$</p>
-$endif$
-</header>
-$endif$
-$if(toc)$
-<nav id="$idprefix$TOC">
-$if(table-of-contents)$
-  <!-- pandoc >= 2.0 -->
-  $table-of-contents$
-$else$
-  <!-- pandoc < 2.0 -->
-  $toc$
-$endif$
-</nav>
-$endif$
-$body$
-</div><!-- .container -->
-</div><!-- .bg-white -->
-
-<footer class="py-5">
-  <div class="container">
-    <div class="row">
-
-      <div class="col-6 col-sm-3">
-        <a href="$rel-root$">
-          <i class="fas fa-home"></i>
-          Home
-        </a>
-        <h6 class="text-muted mt-3">Get started</h6>
-        <ul class="list-unstyled">
-          <li><a href="https://www.youtube.com/watch?v=x1LFbDQhbso">Google Tech Talk</a></li>
-          <li><a href="http://cloud.grammaticalframework.org/">GF Cloud</a></li>
-          <li>
-            <a href="$rel-root$/doc/tutorial/gf-tutorial.html">Tutorial</a>
-            /
-            <a href="$rel-root$/lib/doc/rgl-tutorial/index.html">RGL Tutorial</a>
-          </li>
-          <li><a href="$rel-root$/download"><strong>Download GF</strong></a></li>
-        </ul>
-      </div>
-
-      <div class="col-6 col-sm-3">
-        <h6 class="text-muted">Learn more</h6>
-        <ul class="list-unstyled">
-          <li><a href="$rel-root$/gf-book">The GF Book</a></li>
-          <li><a href="$rel-root$/doc/gf-refman.html">Reference Manual</a></li>
-          <li><a href="$rel-root$/doc/gf-shell-reference.html">GF Shell Reference</a></li>
-          <li><a href="http://www.molto-project.eu/sites/default/files/MOLTO_D2.3.pdf">Best Practices</a></li>
-          <li><a href="$rel-root$/lib/doc/synopsis/index.html"><strong>RGL Synopsis</strong></a></li>
-        </ul>
-      </div>
-
-      <div class="col-6 col-sm-3">
-        <h6 class="text-muted">Develop</h6>
-        <ul class="list-unstyled">
-          <li><a href="$rel-root$/doc/gf-developers.html">Developers Guide</a></li>
-          <li><a href="http://hackage.haskell.org/package/gf/docs/PGF.html">PGF library API (Haskell runtime)</a></li>
-          <li><a href="$rel-root$/doc/runtime-api.html">PGF library API (C runtime)</a></li>
-          <li><a href="http://hackage.haskell.org/package/gf/docs/GF.html">GF compiler API</a></li>
-          <li><a href="$rel-root$/doc/gf-editor-modes.html">Text Editor Support</a></li>
-        </ul>
-      </div>
-
-      <div class="col-6 col-sm-3">
-        <h6 class="text-muted">Contribute</h6>
-        <ul class="list-unstyled">
-          <li><a href="http://groups.google.com/group/gf-dev">Mailing List</a></li>
-          <li><a href="https://github.com/GrammaticalFramework/gf-core/issues">Issue Tracker</a></li>
-          <li><a href="$rel-root$/doc/gf-people.html">Authors</a></li>
-          <li><a href="http://school.grammaticalframework.org/2018/">Summer School</a></li>
-        </ul>
-        <h6 class="text-muted">
-          Repositories
-          <i class="fab fa-github ml-1"></i>
-        </h6>
-        <a href="https://github.com/GrammaticalFramework/gf-core">GF</a> ·
-        <a href="https://github.com/GrammaticalFramework/gf-rgl">RGL</a> ·
-        <a href="https://github.com/GrammaticalFramework/gf-contrib">Contributions</a>
-      </div>
-    </div>
-  </div>
-</footer>
-$for(include-after)$
-$include-after$
-$endfor$
-<script type="text/javascript">
-var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
-document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
-</script>
-<script type="text/javascript">
-try {
-var pageTracker = _gat._getTracker("UA-7811807-3");
-pageTracker._trackPageview();
-} catch(err) {}</script>
-</body>
-</html>

bin/update_html

@@ -1,156 +1,11 @@
 #!/bin/bash
 
-# Generate HTML from txt2tags (.t2t) and Markdown (.md)
-# Usage:
-# - update_html
-#   Look for all .t2t and .md files in the current directory and below,
-#   generating the output HTML when the source is newer than the HTML.
-# - update_html path/to/file.t2t path/to/another.md
-#   Generate HTML for the specified file(s), ignoring modification time.
-#
-# Requires:
-# - txt2tags for .t2t files. Tested with 2.6.
-# - pandoc for both .t2t and .md files. Tested with 1.16.0.2 and 2.3.1.
-# - the template file `template.html` in the same directory as this script.
-#
-# Tested with Ubuntu 16.04 and macOS Mojave.
-#
-# See also clean_html for removing the files generated by this script.
+### This script finds all .t2t (txt2tags) files and updates the corresponding
+### .html file, if it is out-of-date.
 
-# Path to directory where this script is
-# https://stackoverflow.com/a/246128/98600
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )"
-
-# HTML template
-template="$DIR/template.html"
-
-# Render txt2tags into html file
-# Arguments:
-# 1. txt2tags source file, e.g. download/index.t2t
-# 2. html target file, e.g. download/index.html
-function render_t2t_html {
-  t2t="$1"
-  html="$2"
-  tmp="$2.tmp"
-  relroot="$( dirname $t2t | sed -E 's/^.\///' | sed -E 's/[^/]+/../g' )"
-
-  # First render with txt2tags to handle pre/post processing
-  txt2tags \
-    --target=html \
-    --no-headers \
-    --quiet \
-    --outfile="$tmp" \
-    --infile="$t2t"
-
-  # Replace <A NAME="toc3"></A> with <div id="toc3"></div> so that Pandoc retains it
-  # Do this for both cases since BSD sed doesn't support /i
-  sed -i.bak "s/<a name=\"\(.*\)\"><\/a>/<div id=\"\1\"><\/div>/" "$tmp"
-  sed -i.bak "s/<A NAME=\"\(.*\)\"><\/A>/<div id=\"\1\"><\/div>/" "$tmp"
-  rm -f "$tmp.bak"
-
-  # Capture first 3 lines of t2t file: title, author, date
-  # Documentation here: https://txt2tags.org/userguide/headerarea
-  l1=$(head -n 1 "$t2t")
-  l2=$(tail -n+2 "$t2t" | head -n 1)
-  l3=$(tail -n+3 "$t2t" | head -n 1)
-  title=
-  author=
-  date=
-  if [ -n "$l1" ] ; then
-    title="$l1"
-    if [ -n "$l2" ] ; then author="$l2" ; fi
-    if [ -n "$l3" ] ; then date="$l3" ; fi
+find . -name '*.t2t' | while read t2t ; do
+  html="${t2t%.t2t}.html"
+  if [ "$t2t" -nt "$html" ] ; then
+    txt2tags -thtml "$t2t"
   fi
-
-  # Run txt2tag's HTML through Pandoc for cleanup
-  pandoc \
-    --from=html \
-    --to=html5 \
-    --standalone \
-    --template="$template" \
-    --variable="lang:en" \
-    --variable="rel-root:$relroot" \
-    --metadata="title:$title" \
-    --metadata="author:$author" \
-    --metadata="date:$date" \
-    "$tmp" \
-    --output="$html"
-  rm -f "$tmp"
-
-  # Final post-processing
-  if [ -f "$html" ] ; then
-    sed -i.bak "s/<table/<table class=\"table\"/" "$html" && rm "$html.bak"
-    echo "$html"
-  fi
-}
-
-# Render markdown into html file
-# Arguments:
-# 1. markdown source file, e.g. download/index.md
-# 2. html target file, e.g. download/index.html
-function render_md_html {
-  md="$1"
-  html="$2"
-  relroot="$( dirname $md | sed -E 's/^.\///' | sed -E 's/[^/]+/../g' )"
-
-  # Look for `show-toc: true` in metadata (first ten lines of file)
-  if head -n 10 "$md" | grep --quiet 'show-toc: true' ; then
-    tocflag='--table-of-contents'
-  else
-    tocflag=''
-  fi
-
-  pandoc \
-    --from=markdown \
-    --to=html5 \
-    --standalone \
-    $tocflag \
-    --template="$template" \
-    --variable="lang:en" \
-    --variable="rel-root:$relroot" \
-    "$md" \
-    --output="$html"
-
-  # Final post-processing
-  if [ -f "$html" ] ; then
-    # add "table" class to tables
-    sed -i.bak "s/<table/<table class=\"table\"/" "$html"
-    # rewrite anchors that Pandoc 1.16 ignores: [content]{#anchor} -> <span id="anchor">content</span>
-    sed -i.bak -E "s/\[(.*)\]\{#(.+)\}/<span id=\"\2\">\1<\/span>/" "$html"
-    rm -f "$html.bak"
-    echo "$html"
-  fi
-}
-
-# Main entry point
-# Script can be run in one of two modes:
-if [ $# -gt 0 ] ; then
-  # Render specific file(s) from args, ignoring dates
-  for file in "$@" ; do
-    ext="${file##*.}"
-    html="${file%.$ext}.html"
-    case $ext in
-      "md")
-        render_md_html "$file" "$html"
-        ;;
-      "t2t")
-        render_t2t_html "$file" "$html"
-        ;;
-    esac
-  done
-else
-  # Render all files found in cwd and deeper if source is newer
-  find . -name '*.t2t' | while read file ; do
-    html="${file%.t2t}.html"
-    if [ "$file" -nt "$html" ] || [ "$template" -nt "$html" ] ; then
-      render_t2t_html "$file" "$html"
-    fi
-  done
-  find . -name '*.md' | while read file ; do
-    if [[ "$file" == *"README.md" ]] ; then continue ; fi
-    html="${file%.md}.html"
-    if [ "$file" -nt "$html" ] || [ "$template" -nt "$html" ] ; then
-      render_md_html "$file" "$html"
-    fi
-  done
-fi
+done

css/oldstyle.css

@@ -0,0 +1,43 @@
+
+/* Found it at http://article.olduse.net/771@mit-eddie.UUCP */
+@font-face {
+  font-family: GlassTTYVT220;
+  src: local("Glass TTY VT220"), local("Glass TTY VT220 Medium"), url(/font/Glass_TTY_VT220.ttf) format("truetype");
+}
+
+body {
+  font-size: 20px;
+  font-family: GlassTTYVT220;
+  color: #e5b800;
+  background-color: #0a0600;
+}
+
+h1,h2,h3,h4 { font-size: 20px; }
+
+img.logo, img.grow { display: none; }
+
+a { color: #ecc800; }
+a:hover { color: #fcd800; }
+
+div.links {
+    display: inline-block;
+    vertical-align: top;
+    margin-right: 1em;
+}
+
+table.news td {
+    background: inherit;
+    border: 0;
+    vertical-align: baseline;
+    padding: 0.25ex 0.5ex;
+}
+
+table.news td:nth-child(1) {
+    /* Don't want the hyphens in dates (2012-06-29) to cause line breaks */
+    white-space: nowrap;
+}
+
+ol.languages {
+    column-width: 12em;
+    -moz-column-width: 12em;
+}

css/style0.css

@@ -18,6 +18,7 @@ img.right { float: right; }
 
 ol.languages {
     column-width: 12em;
+    -moz-column-width: 12em;
 }
 
 .grow {

debian/changelog

@@ -1,27 +1,3 @@
-gf (3.10.3-1) xenial bionic cosmic; urgency=low
-
-  * GF 3.10.3
-
- -- Thomas Hallgren <hallgren@chalmers.se>  Fri,  5 Mar 2019 19:30:00 +0100
-
-gf (3.10-2) xenial bionic cosmic; urgency=low
-
-  * GF 3.10
-
- -- Thomas Hallgren <hallgren@chalmers.se>  Fri,  5 Mar 2019 16:00:00 +0100
-
-gf (3.10-1) xenial bionic cosmic; urgency=low
-
-  * GF 3.10
-
- -- Thomas Hallgren <hallgren@chalmers.se>  Fri,  2 Dec 2018 15:00:00 +0100
-
-gf (3.9-1) vivid xenial zesty; urgency=low
-
-  * GF 3.9
-
- -- Thomas Hallgren <hallgren@chalmers.se>  Fri, 11 Aug 2017 20:00:00 +0200
-
 gf (3.8-1) precise trusty vivid; urgency=low
 
   * GF 3.8

debian/control

@@ -3,7 +3,7 @@ Section: devel
 Priority: optional
 Maintainer: Thomas Hallgren <hallgren@chalmers.se>
 Standards-Version: 3.9.2
-Build-Depends: debhelper (>= 5), haskell-platform (>= 2011.2.0.1), libghc-haskeline-dev, libghc-mtl-dev, libghc-json-dev, autoconf, automake, libtool-bin, python-dev, java-sdk, txt2tags, pandoc
+Build-Depends: debhelper (>= 5), haskell-platform (>= 2011.2.0.1), libghc-haskeline-dev, libghc-mtl-dev, libghc-json-dev, autoconf, automake, libtool-bin, python-dev, java-sdk, txt2tags
 Homepage: http://www.grammaticalframework.org/
 
 Package: gf

debian/rules

@@ -13,38 +13,33 @@
 override_dh_shlibdeps:
 	dh_shlibdeps --dpkg-shlibdeps-params=--ignore-missing-info
 
-override_dh_auto_configure:
-	cd src/runtime/c && bash setup.sh configure --prefix=/usr
-	cd src/runtime/c && bash setup.sh build
-	cabal update
-	cabal install --only-dependencies
-	cabal configure --prefix=/usr -fserver -fc-runtime --extra-lib-dirs=$(CURDIR)/src/runtime/c/.libs --extra-include-dirs=$(CURDIR)/src/runtime/c
-
-SET_LDL=LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:$(CURDIR)/src/runtime/c/.libs
-
 override_dh_auto_build:
 	cd src/runtime/python && EXTRA_INCLUDE_DIRS=$(CURDIR)/src/runtime/c EXTRA_LIB_DIRS=$(CURDIR)/src/runtime/c/.libs python setup.py build
 	cd src/runtime/java && make CFLAGS="-I$(CURDIR)/src/runtime/c -L$(CURDIR)/src/runtime/c/.libs" INSTALL_PATH=/usr/lib
-	echo $(SET_LDL)
-	$(SET_LDL) cabal build # builds gf, fails to build example grammars 
-	PATH=$(CURDIR)/dist/build/gf:$$PATH && make -C ../gf-rgl build
-	GF_LIB_PATH=$(CURDIR)/../gf-rgl/dist $(SET_LDL) cabal build # have RGL now, ok to build example grammars
+	echo LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:$(CURDIR)/src/runtime/c/.libs
+	LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:$(CURDIR)/src/runtime/c/.libs cabal build
 	make html
 
-override_dh_auto_install:
-	$(SET_LDL) cabal copy --destdir=$(CURDIR)/debian/gf # creates www directory
-	export GF_LIB_PATH="$$(dirname $$(find "$(CURDIR)/debian/gf" -name www))/lib" && echo "GF_LIB_PATH=$$GF_LIB_PATH" && mkdir -p "$$GF_LIB_PATH" && make -C ../gf-rgl copy
-	cd src/runtime/c && bash setup.sh copy prefix=$(CURDIR)/debian/gf/usr
-	cd src/runtime/python && python setup.py install --prefix=$(CURDIR)/debian/gf/usr
-	cd src/runtime/java && make INSTALL_PATH=$(CURDIR)/debian/gf/usr/lib install
-	D="`find debian/gf -name site-packages`" && [ -n "$$D" ] && cd $$D && cd .. && mv site-packages dist-packages
-
 override_dh_auto_clean:
 	rm -fr dist/build
 	-cd src/runtime/python && rm -fr build
 	-cd src/runtime/java && make clean
 	-cd src/runtime/c && make clean
 
+override_dh_auto_configure:
+	cd src/runtime/c && bash setup.sh configure --prefix=/usr
+	cd src/runtime/c && bash setup.sh build
+	cabal update
+	cabal install --only-dependencies
+	cabal configure --prefix=/usr -fserver -fc-runtime --extra-lib-dirs=$(CURDIR)/src/runtime/c/.libs --extra-include-dirs=$(CURDIR)/src/runtime/c
+
+override_dh_auto_install:
+	LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:$(CURDIR)/src/runtime/c/.libs cabal copy --destdir=$(CURDIR)/debian/gf
+	cd src/runtime/c && bash setup.sh copy prefix=$(CURDIR)/debian/gf/usr
+	cd src/runtime/python && python setup.py install --prefix=$(CURDIR)/debian/gf/usr
+	cd src/runtime/java && make INSTALL_PATH=$(CURDIR)/debian/gf/usr/lib install
+	D="`find debian/gf -name site-packages`" && [ -n "$$D" ] && cd $$D && cd .. && mv site-packages dist-packages
+
 override_dh_auto_test:
 ifneq (nocheck,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
 	true

demos/index-numbers.html

@@ -0,0 +1,43 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+<META NAME="generator" CONTENT="http://txt2tags.sf.net">
+<TITLE>Portable Numeral Translator</TITLE>
+</HEAD><BODY BGCOLOR="white" TEXT="black">
+<P ALIGN="center"><CENTER><H1>Portable Numeral Translator</H1>
+<FONT SIZE="4">
+<I>15 August 2008</I><BR>
+</FONT></CENTER>
+
+<P>
+Here is the first GF application for the iPhone. It translates
+numerals from digits into number words in 15 languages. It works for
+numerals in the range 1-999,999. You can use the demo online in your iPhone's
+browser, or download and install it by using FileMagnet (from AppStore).
+</P>
+<P>
+The demo should work in any web browser supporting JavaScript, but it has been
+specially dimensioned for the iPhone screen. It is an application of a general
+technology, namely the compilation of GF grammars to JavaScript. Thus you can 
+easily build similar applications from your own grammars.
+</P>
+<P>
+The 
+<A HREF="http://www.cs.chalmers.se/~bringert/gf/translate/">full numeral translator</A>, which
+works in 88 language and permits arbitrary cross translations, cannot yet be ported
+to the iPhone because of memory problems.
+</P>
+<P>
+The current version has some encoding/font issues in Hebrew and Hindi.
+</P>
+<P>
+<A HREF="numbers/numbers.html">Use the translator online</A>
+</P>
+<P>
+<A HREF="numbers.tgz">Download the translator</A>. To install: unpack the file and move
+the directory <CODE>numbers</CODE> to your FileMagnet uploader.
+</P>
+
+<!-- html code generated by txt2tags 2.4 (http://txt2tags.sf.net) -->
+<!-- cmdline: txt2tags -thtml index-numbers.txt -->
+</BODY></HTML>

demos/index.html

@@ -18,8 +18,6 @@ Phrasebook</a>
 
 <p><a href="http://www.phrasomatic.net/">Phrasomatic</a> (conceptual authoring based on Phrasebook)
 
-<p><a href="multilingual_headlines.html">Multilingual Headlines</a>
-
 <p><a href="molto.html">MOLTO Application Grammars</a>
 
 <p><a href="mathbar/">Mathbar</a>
@@ -33,9 +31,9 @@ Phrasebook</a>
 
 <P><a href="http://cloud.grammaticalframework.org/minibar/minibar.html">Minibar</A>
 <!-- | <small><a href="../src/www/minibar/minibar_offline.html">Minibar offline</a></small> -->
-<!--(<small>Predecessors:
+(<small>Predecessors:
 <a href="http://www.grammaticalframework.org:41296/fridge">Fridge poetry</A>
- | <a href="http://www.grammaticalframework.org:41296/translate">Word-completing translator</A></small>)-->
+ | <a href="http://www.grammaticalframework.org:41296/translate">Word-completing translator</A></small>)
 
 <p><a href="http://www.grammaticalframework.org/~hallgren/Talks/GF/Tutorial2012/Ex4/answer.html">Question answering demo</a> for simple math questions.
 <P>
@@ -63,17 +61,16 @@ to your web browser.
 <P>
 <A HREF="http://webalt.math.helsinki.fi/PublicFiles/CD/Screencast/TextMathEditor%20Demo.swf">WebALT Math Editor</A>:
 create mathematical exercises in six languages simultaneously (film).
-<!--
+
 <P>
 [Out of order, early May 2012]
 <small>
 <A HREF="http://www.jem-thematic.net/en/node/846#comment-209">WebALT Math translator</A>:
 translate mathematical exercises in a web service using incremental parsing.
 </small>
--->
-<!--
+
 <P>
- <A HREF="http://csmisc14.cs.chalmers.se/~bjorn/langtrain.cgi">GF Language Trainer</A>:
+<!-- <A HREF="http://csmisc14.cs.chalmers.se/~bjorn/langtrain.cgi">GF Language Trainer</A>:
 translation quizzes in Arabic, English, Russian, Swedish. -->
 
 <P>

doc/Makefile

@@ -1,3 +1,18 @@
+resource:
+	gfdoc -txt2 ../lib/resource-1.0/abstract/*.gf
+	gfdoc -txt2 ../lib/resource-1.0/*/Paradigms*.gf
+	txt2tags --toc resource.txt
+#	cat resource-preamble resource.tex >final-resource.tex
+	sed -i 's/\\docum/%\\docum/g' resource.tex
+	sed -i 's/ion\*{/ion{/g' resource.tex
+	sed -i 's/\\paragraph{}//g' resource.tex
+	sed -i 's/}\\\\/}/g' resource.tex
+	cat resource-preamble resource.tex >resource.tmp
+	mv resource.tmp resource.tex
+	latex resource.tex
+	latex resource.tex
+	dvipdf resource.dvi
+
 gf-help-full.txt::
 	{ echo ; echo ; echo ; } > $@
 	echo help -full -t2t | gf -run >> $@

doc/error-messages.txt

@@ -1,551 +0,0 @@
-Compiler.hs
-mainGFC :: Options -> [FilePath] -> IO ()
-                 _ | null fs -> fail $ "No input files."
-                 _ | all (extensionIs ".pgf") fs -> unionPGFFiles opts fs
-                 _ -> fail $ "Don't know what to do with these input files: " ++ unwords fs)
-
-
-----------------------------------------
-Compile.hs
-
-compileModule
-                       case length file1s of
-                         0 -> raise (render ("Unable to find: " $$ nest 2 candidates))
-                         1 -> do return $ head file1s
-                         _ -> do putIfVerb opts1 ("matched multiple candidates: " +++ show file1s)
-                                 return $ head file1s
-               else raise (render ("File" <+> file <+> "does not exist"))
-
----------------------------------------
-Grammar.Lexer.x
-token :: P Token
-        AlexError (AI pos _ _) -> PFailed pos "lexical error"
-
-
----------------------------------------
-Grammar.Parser.y
-
-happyError = fail "syntax error"
-
-tryLoc (c,mty,Just e) = return (c,(mty,e))
-tryLoc (c,_  ,_     ) = fail ("local definition of" +++ showIdent c +++ "without value")
-
-mkR []       = return $ RecType [] --- empty record always interpreted as record type
-mkR fs@(f:_) =
-  case f of
-    (lab,Just ty,Nothing) -> mapM tryRT fs >>= return . RecType
-    _                     -> mapM tryR  fs >>= return . R
-  where
-    tryRT (lab,Just ty,Nothing) = return (ident2label lab,ty)
-    tryRT (lab,_      ,_      ) = fail $ "illegal record type field" +++ showIdent lab --- manifest fields ?!
-
-    tryR (lab,mty,Just t) = return (ident2label lab,(mty,t))
-    tryR (lab,_  ,_     ) = fail $ "illegal record field" +++ showIdent lab
-
-
----------------------------------------
-ModDeps.hs
-
-mkSourceGrammar :: [SourceModule] -> Err SourceGrammar
-  deplist <- either 
-               return 
-               (\ms -> Bad $ "circular modules" +++ unwords (map show ms)) $ 
-
-
-checkUniqueImportNames :: [Ident] -> SourceModInfo -> Err ()
-   test ms = testErr (all (`notElem` ns) ms)
-                     ("import names clashing with module names among" +++ unwords (map prt ms))
-
-
-moduleDeps :: [SourceModule] -> Err Dependencies
-  deps (c,m) = errIn ("checking dependencies of module" +++ prt c) $ case mtype m of
-      MTConcrete a -> do
-        am <- lookupModuleType gr a
-        testErr (mtype am == MTAbstract) "the of-module is not an abstract syntax" 
-
-    testErr (all (compatMType ety . mtype) ests) "inappropriate extension module type" 
-
-
----------------------------------------
-Update.hs
-
-buildAnyTree
-        Just i  -> case unifyAnyInfo m i j of
-		     Ok k  -> go (Map.insert c k map) is
-		     Bad _ -> fail $ render ("conflicting information in module"<+>m $$
-		                             nest 4 (ppJudgement Qualified (c,i)) $$
-		                             "and" $+$
-		                             nest 4 (ppJudgement Qualified (c,j)))
-extendModule
-    unless (sameMType (mtype m) (mtype mo)) 
-            (checkError ("illegal extension type to module" <+> name))
-
-rebuildModule
-      unless (null is || mstatus mi == MSIncomplete) 
-             (checkError ("module" <+> i <+> 
-                          "has open interfaces and must therefore be declared incomplete"))
-
-         unless (isModRes m1)
-                 (checkError ("interface expected instead of" <+> i0))
-          js' <- extendMod gr False ((i0,m1), isInherited mincl) i (jments mi)
-
-     unless (stat' == MSComplete || stat == MSIncomplete) 
-             (checkError ("module" <+> i <+> "remains incomplete"))
-
-
-extendMod
-		                                 checkError ("cannot unify the information" $$ 
-		                                             nest 4 (ppJudgement Qualified (c,i)) $$
-		                                             "in module" <+> name <+> "with" $$
-		                                             nest 4 (ppJudgement Qualified (c,j)) $$
-		                                             "in module" <+> base)
-
-unifyAnyInfo
-  (ResValue (L l1 t1), ResValue (L l2 t2)) 
-      | t1==t2    -> return (ResValue (L l1 t1))
-      | otherwise -> fail ""
-
-  (AnyInd b1 m1, AnyInd b2 m2) -> do
-    testErr (b1 == b2) $ "indirection status"
-    testErr (m1 == m2) $ "different sources of indirection"
-
-unifAbsDefs _         _         = fail ""
-
-----------------------------------
-
-Rename.hs
-
-renameIdentTerm'
-        _    -> case lookupTreeManyAll showIdent opens c of
-                  [f]  -> return (f c)
-                  []   -> alt c ("constant not found:" <+> c $$
-                                 "given" <+> fsep (punctuate ',' (map fst qualifs)))
-
-                           ts@(t:_) -> do checkWarn ("atomic term" <+> ppTerm Qualified 0 t0 $$
-                                                      "conflict" <+> hsep (punctuate ',' (map (ppTerm Qualified 0) ts)) $$
-                                                      "given" <+> fsep (punctuate ',' (map fst qualifs)))
-                                           return t
-
-renameInfo
-    renLoc ren (L loc x) =
-      checkInModule cwd mi loc ("Happened in the renaming of" <+> i) $ do
-
-renameTerm
-      | otherwise -> checks [ renid' (Q (MN r,label2ident l))      -- .. and qualified expression second.
-                            , renid' t >>= \t -> return (P t l) -- try as a constant at the end
-                            , checkError ("unknown qualified constant" <+> trm)
-                            ]
-
-renamePattern env patt =
-    do r@(p',vs) <- renp patt
-       let dupl = vs \\ nub vs
-       unless (null dupl) $ checkError (hang ("[C.4.13] Pattern is not linear:") 4
-                                             patt)
-       return r
-
-       case c' of
-          Q d -> renp $ PM d
-          _ -> checkError ("unresolved pattern" <+> patt)
-
-          Q  _ -> checkError ("data constructor expected but" <+> ppTerm Qualified 0 c' <+> "is found instead")
-          _    -> checkError ("unresolved data constructor" <+> ppTerm Qualified 0 c')
-
-      PM c -> do
-        x <- renid (Q c)
-        c' <- case x of
-                (Q c') -> return c'
-                _      -> checkError ("not a pattern macro" <+> ppPatt Qualified 0 patt)
-
-     PV x -> checks [ renid' (Vr x) >>= \t' -> case t' of
-                                                 QC c -> return (PP c [],[])
-                                                 _    -> checkError (pp "not a constructor")
-                     , return (patt, [x])
- 
-
-
------------------------------------
-CheckGrammar.hs
-
-checkRestrictedInheritance :: FilePath -> SourceGrammar -> SourceModule -> Check ()
-     let illegals = [(f,is) | 
-           (f,cs) <- allDeps, incld f, let is = filter illegal cs, not (null is)]
-     case illegals of 
-       [] -> return ()
-       cs -> checkWarn ("In inherited module" <+> i <> ", dependence of excluded constants:" $$
-                         nest 2 (vcat [f <+> "on" <+> fsep is | (f,is) <- cs]))
-
-checkCompleteGrammar :: Options -> FilePath -> Grammar -> Module -> Module -> Check Module
-                       case info of
-                         CncCat (Just (L loc (RecType []))) _ _ _ _ -> return (foldr (\_ -> Abs Explicit identW) (R []) cxt)
-                         _                                          -> Bad "no def lin"
-
-         where noLinOf c = checkWarn ("no linearization of" <+> c)
-
-         Ok (CncCat Nothing md mr mp mpmcfg) -> do
-           checkWarn ("no linearization type for" <+> c <> ", inserting default {s : Str}")
-           return $ updateTree (c,CncCat (Just (L NoLoc defLinType)) md mr mp mpmcfg) js
-         _ -> do
-           checkWarn ("no linearization type for" <+> c <> ", inserting default {s : Str}")
-
-                             _       -> do checkWarn ("function" <+> c <+> "is not in abstract")
-
-           Ok (_,AbsFun {}) ->
-                   checkError ("lincat:"<+>c<+>"is a fun, not a cat")
-           -}
-           _ -> do checkWarn ("category" <+> c <+> "is not in abstract")
-
-checkInfo :: Options -> FilePath -> SourceGrammar -> SourceModule -> Ident -> Info -> Check Info
-         (Just (L loct ty), Nothing) -> do
-           chIn loct "operation" $
-             checkError (pp "No definition given to the operation")
-
-    ResOverload os tysts -> chIn NoLoc "overloading" $ do
-    
-       checkUniq xss = case xss of
-     x:y:xs 
-      | x == y    -> checkError $ "ambiguous for type" <+>
-                                  ppType (mkFunType (tail x) (head x))
-
-   compAbsTyp g t = case t of
-     Vr x -> maybe (checkError ("no value given to variable" <+> x)) return $ lookup x g
-
-checkReservedId x =
-  when (isReservedWord x) $
-       checkWarn ("reserved word used as identifier:" <+> x)
-
-
---------------------------------
-TypeCheck/Abstract.hs
-
-grammar2theory :: SourceGrammar -> Theory
-  Bad s -> case lookupCatContext gr m f of
-    Ok cont -> return $ cont2val cont
-    _ -> Bad s
-
-
---------------------------------
-TypeCheck/ConcreteNew.hs
--- Concrete.hs has all its code commented out
-
-
---------------------------------
-TypeCheck/RConcrete.hs
--- seems to be used more than ConcreteNew
-
-computeLType :: SourceGrammar -> Context -> Type -> Check Type
-   AdHocOverload ts -> do
-     over <- getOverload gr g (Just typeType) t
-     case over of
-       Just (tr,_) -> return tr
-       _ -> checkError ("unresolved overloading of constants" <+> ppTerm Qualified 0 t) 
-
-inferLType :: SourceGrammar -> Context -> Term -> Check (Term, Type)
-   Q (m,ident) | isPredef m -> termWith trm $ case typPredefined ident of
-                                                Nothing -> checkError ("unknown in Predef:" <+> ident)
-
-   Q ident -> checks [
-     checkError ("cannot infer type of constant" <+> ppTerm Unqualified 0 trm)
-     ]
-
-   QC ident -> checks [
-       checkError ("cannot infer type of canonical constant" <+> ppTerm Unqualified 0 trm)
-       ]
-
-   Vr ident -> termWith trm $ checkLookup ident g
-
-   AdHocOverload ts -> do
-       _ -> checkError ("unresolved overloading of constants" <+> ppTerm Qualified 0 trm) 
-
-   App f a -> do
-         case fty' of
-           Prod bt z arg val -> do 
-           _ -> checkError ("A function type is expected for" <+> ppTerm Unqualified 0 f <+> "instead of type" <+> ppType fty)
-
-   S f x -> do
-       _ -> checkError ("table lintype expected for the table in" $$ nest 2 (ppTerm Unqualified 0 trm))
-
-   P t i -> do
-                       Nothing -> checkError ("unknown label" <+> i <+> "in" $$ nest 2 (ppTerm Unqualified 0 ty'))
-       _          -> checkError ("record type expected for:" <+> ppTerm Unqualified 0 t $$
-                                 " instead of the inferred:" <+> ppTerm Unqualified 0 ty')
-
-   R r -> do
-     checkCond ("cannot infer type of record" $$ nest 2 (ppTerm Unqualified 0 trm)) (length ts == length fsts)
-
-   T ti pts -> do  -- tries to guess: good in oper type inference
-       [] -> checkError ("cannot infer table type of" <+> ppTerm Unqualified 0 trm)
-
-   ---- hack from Rename.identRenameTerm, to live with files with naming conflicts 18/6/2007
-   Strs (Cn c : ts) | c == cConflict -> do
-     checkWarn ("unresolved constant, could be any of" <+> hcat (map (ppTerm Unqualified 0) ts))
-
-   ExtR r s -> do
-     case (rT', sT') of
-       (RecType rs, RecType ss) -> do
-       _ -> checkError ("records or record types expected in" <+> ppTerm Unqualified 0 trm)
-
-   _ -> checkError ("cannot infer lintype of" <+> ppTerm Unqualified 0 trm)
-
-
-getOverload :: SourceGrammar -> Context -> Maybe Type -> Term -> Check (Maybe (Term,Type))
-   matchOverload f typs ttys = do
-         checkWarn $  "ignoring lock fields in resolving" <+> ppTerm Unqualified 0 ot $$
-                      "for" $$
-                      nest 2 (showTypes tys) $$
-                      "using" $$
-                      nest 2 (showTypes pre)
-       ([],[]) -> do
-         checkError $ "no overload instance of" <+> ppTerm Unqualified 0 f $$
-                      "for" $$
-                      nest 2 stysError $$
-                      "among" $$
-                      nest 2 (vcat stypsError) $$
-                      maybe empty (\x -> "with value type" <+> ppType x) mt
-        ([],[(val,fun)]) -> do
-           checkWarn ("ignoring lock fields in resolving" <+> ppTerm Unqualified 0 ot) 
-         (nps1,nps2) -> do 
-              checkWarn $  "ambiguous overloading of" <+> ppTerm Unqualified 0 f <+>
-                  ----     "with argument types" <+> hsep (map (ppTerm Qualified 0) tys) $$ 
-                           "resolved by selecting the first of the alternatives" $$
-                           nest 2 (vcat [ppTerm Qualified 0 fun | (_,ty,fun) <- vfs1 ++ if null vfs1 then vfs2 else []])
-              case [(mkApp fun tts,val) | (val,fun) <- nps1 ++ nps2] of
-                 [] -> checkError $ "no alternatives left when resolving" <+> ppTerm Unqualified 0 f
- 
-checkLType :: SourceGrammar -> Context -> Term -> Type -> Check (Term, Type)
-    Abs bt x c -> do
-      case typ of
-        Prod bt' z a b -> do 
-        _ -> checkError $ "function type expected instead of" <+> ppType typ
-    AdHocOverload ts -> do
-        _ -> checkError ("unresolved overloading of constants" <+> ppTerm Qualified 0 trm) 
-    T _ [] ->
-      checkError ("found empty table in type" <+> ppTerm Unqualified 0 typ)
-    T _ cs -> case typ of 
-              else checkWarn ("patterns never reached:" $$
-                              nest 2 (vcat (map (ppPatt Unqualified 0) ps)))
-      _ -> checkError $ "table type expected for table instead of" $$ nest 2 (ppType typ)
-    V arg0 vs ->
-              if length vs1 == length vs
-                 then return ()
-                 else checkError $ "wrong number of values in table" <+> ppTerm Unqualified 0 trm
-
-    R r -> case typ of --- why needed? because inference may be too difficult
-       RecType rr -> do
-       _ -> checkError ("record type expected in type checking instead of" $$ nest 2 (ppTerm Unqualified 0 typ))
-
-    ExtR r s -> case typ of
-         case trm' of
-           RecType _ -> termWith trm' $ return typeType
-           ExtR (Vr _) (RecType _) -> termWith trm' $ return typeType 
-                                      -- ext t = t ** ...
-           _ -> checkError ("invalid record type extension" <+> nest 2 (ppTerm Unqualified 0 trm))
-
-             case typ2 of
-               RecType ss -> return $ map fst ss
-               _ ->  checkError ("cannot get labels from" $$ nest 2 (ppTerm Unqualified 0 typ2))
-       _ -> checkError ("record extension not meaningful for" <+> ppTerm Unqualified 0 typ)
-
-    S tab arg -> checks [ do
-        _ -> checkError ("table type expected for applied table instead of" <+> ppType ty')
-
-    _ -> do
-      (trm',ty') <- inferLType gr g trm
-      termWith trm' $ checkEqLType gr g typ ty' trm'
-
-   checkM rms (l,ty) = case lookup l rms of
-     _ -> checkError $ 
-            if isLockLabel l 
-              then let cat = drop 5 (showIdent (label2ident l))
-                   in ppTerm Unqualified 0 (R rms) <+> "is not in the lincat of" <+> cat <> 
-                      "; try wrapping it with lin" <+> cat
-              else "cannot find value for label" <+> l <+> "in" <+> ppTerm Unqualified 0 (R rms)
-
-checkEqLType :: SourceGrammar -> Context -> Type -> Type -> Term -> Check Type
-    False -> checkError $ s <+> "type of" <+> ppTerm Unqualified 0 trm $$
-                          "expected:" <+> ppTerm Qualified 0 t $$ -- ppqType t u $$
-                          "inferred:" <+> ppTerm Qualified 0 u -- ppqType u t
-
-checkIfEqLType :: SourceGrammar -> Context -> Type -> Type -> Term -> Check (Bool,Type,Type,String)
-      Ok lo -> do
-        checkWarn $ "missing lock field" <+> fsep lo
-
-   missingLock g t u = case (t,u) of  
-         _:_ -> Bad $ render ("missing record fields:" <+> fsep (punctuate ',' (others)))
-
-
-
-pattContext :: SourceGrammar -> Context -> Type -> Patt -> Check Context
-    checkCond ("wrong number of arguments for constructor in" <+> ppPatt Unqualified 0 p) 
-              (length cont == length ps)
-  PR r -> do
-      _ -> checkError ("record type expected for pattern instead of" <+> ppTerm Unqualified 0 typ')
-
-  PAlt p' q -> do
-    g1 <- pattContext env g typ p'
-    g2 <- pattContext env g typ q
-    let pts = nub ([x | pt@(_,x,_) <- g1, notElem pt g2] ++ [x | pt@(_,x,_) <- g2, notElem pt g1])
-    checkCond 
-      ("incompatible bindings of" <+>
-       fsep pts <+> 
-       "in pattern alterantives" <+> ppPatt Unqualified 0 p) (null pts) 
-    return g1 -- must be g1 == g2
-    
-   noBind typ p' = do
-    co <- pattContext env g typ p'
-    if not (null co)
-      then checkWarn ("no variable bound inside pattern" <+> ppPatt Unqualified 0 p) 
-           >> return []
-      else return []
-
-checkLookup :: Ident -> Context -> Check Type -- used for looking up Vr x type in context
-    []     -> checkError ("unknown variable" <+> x)
- 
-
-
--------------------------------
-Grammar/Lookup.hs
-
-lookupIdent :: ErrorMonad m => Ident -> BinTree Ident b -> m b
-    Bad _ -> raise ("unknown identifier" +++ showIdent c)
-
-lookupResDefLoc
-        _   -> raise $ render (c <+> "is not defined in resource" <+> m)
-
-lookupResType :: ErrorMonad m => Grammar -> QIdent -> m Type
-    _   -> raise $ render (c <+> "has no type defined in resource" <+> m)
-
-lookupOverloadTypes :: ErrorMonad m => Grammar -> QIdent -> m [(Term,Type)]
-    _            -> raise $ render (c <+> "has no types defined in resource" <+> m)
-
-lookupOverload :: ErrorMonad m => Grammar -> QIdent -> m [([Type],(Type,Term))]
-      _   -> raise $ render (c <+> "is not an overloaded operation")
-
-
-lookupParamValues :: ErrorMonad m => Grammar -> QIdent -> m [Term]
-  case info of
-    ResParam _ (Just pvs) -> return pvs
-    _                     -> raise $ render (ppQIdent Qualified c <+> "has no parameter values defined")
-
-
-allParamValues :: ErrorMonad m => Grammar -> Type -> m [Term]
-    _ -> raise (render ("cannot find parameter values for" <+> ptyp))
-
-
-lookupFunType :: ErrorMonad m => Grammar -> ModuleName -> Ident -> m Type
-    _                           -> raise (render ("cannot find type of" <+> c))
-
-lookupCatContext :: ErrorMonad m => Grammar -> ModuleName -> Ident -> m Context
-    _                      -> raise (render ("unknown category" <+> c))
-
-
--------------------------
-PatternMatch.hs
-
-matchPattern :: ErrorMonad m => [(Patt,rhs)] -> Term -> m (rhs, Substitution)
-  if not (isInConstantForm term)
-    then raise (render ("variables occur in" <+> pp term))
-
-findMatch :: ErrorMonad m => [([Patt],rhs)] -> [Term] -> m (rhs, Substitution)
-   [] -> raise (render ("no applicable case for" <+> hsep (punctuate ',' terms)))
-   (patts,_):_ | length patts /= length terms -> 
-       raise (render ("wrong number of args for patterns :" <+> hsep patts <+> 
-                    "cannot take" <+> hsep terms))
-
-tryMatch :: (Patt, Term) -> Err [(Ident, Term)]
-      (PNeg p',_) -> case tryMatch (p',t) of
-        Bad _ -> return []
-        _ -> raise (render ("no match with negative pattern" <+> p))
-
-
----------------------------------------------
-Compile.Optimize.hs
-
-mkLinDefault :: SourceGrammar -> Type -> Err Term
-                            _   -> Bad (render ("no parameter values given to type" <+> ppQIdent Qualified p))
-     _ -> Bad (render ("linearization type field cannot be" <+> typ))
-
-mkLinReference :: SourceGrammar -> Type -> Err Term
-                            []     -> Bad "no string"
-
-
----------------------------------------------
-Compile.Compute.Concrete.hs
-
-nfx env@(GE _ _ _ loc) t = do
-    Left i  -> fail ("variable #"++show i++" is out of scope")
-
-var :: CompleteEnv -> Ident -> Err OpenValue
-var env x = maybe unbound pick' (elemIndex x (local env))
-  where
-    unbound = fail ("Unknown variable: "++showIdent x)
-    pick' i = return $ \ vs -> maybe (err i vs) ok (pick i vs)
-    err i vs = bug $ "Stack problem: "++showIdent x++": "
-                    ++unwords (map showIdent (local env))
-                    ++" => "++show (i,length vs)
-
-resource env (m,c) =
-  where e = fail $ "Not found: "++render m++"."++showIdent c
-
-extR t vv =
-      (VRecType rs1, VRecType rs2) ->
-          case intersect (map fst rs1) (map fst rs2) of
-            [] -> VRecType (rs1 ++ rs2)
-            ls -> error $ "clash"<+>show ls
-      (v1,v2) -> error $ "not records" $$ show v1 $$ show v2
-  where
-    error explain = ppbug $ "The term" <+> t
-                            <+> "is not reducible" $$ explain
- 
-glue env (v1,v2) = glu v1 v2
-                                         ppL loc (hang "unsupported token gluing:" 4
-                                                        (Glue (vt v1) (vt v2)))
-
-strsFromValue :: Value -> Err [Str]
-  _ -> fail ("cannot get Str from value " ++ show t)
-
-match loc cs v = 
-  case value2term loc [] v of
-    Left i  -> bad ("variable #"++show i++" is out of scope")
-    Right t -> err bad return (matchPattern cs t)
-  where
-    bad = fail . ("In pattern matching: "++)
-
-    inlinePattMacro p =
-                        VPatt p' -> inlinePattMacro p'
-                        _ -> ppbug $ hang "Expected pattern macro:" 4
-
-linPattVars p =
-    if null dups
-    then return pvs
-    else fail.render $ hang "Pattern is not linear:" 4 (ppPatt Unqualified 0 p)
-
----------------------------------------------
-Compile.Compute.Abstract.hs
-
-
----------------------------------------------
-PGF.Linearize.hs
-
-bracketedLinearize :: PGF -> Language -> Tree -> [BracketedString]
-    cnc = lookMap (error "no lang") lang (concretes pgf)
-
-
----------------------------------------------
-PGF.TypeCheck.hs
-
-ppTcError :: TcError -> Doc
-ppTcError (UnknownCat cat)             = text "Category" <+> ppCId cat <+> text "is not in scope"
-ppTcError (UnknownFun fun)             = text "Function" <+> ppCId fun <+> text "is not in scope"
-ppTcError (WrongCatArgs xs ty cat m n) = text "Category" <+> ppCId cat <+> text "should have" <+> int m <+> text "argument(s), but has been given" <+> int n $$
-                                         text "In the type:" <+> ppType 0 xs ty
-ppTcError (TypeMismatch xs e ty1 ty2)  = text "Couldn't match expected type" <+> ppType 0 xs ty1 $$
-                                         text "       against inferred type" <+> ppType 0 xs ty2 $$
-                                         text "In the expression:" <+> ppExpr 0 xs e
-ppTcError (NotFunType xs e ty)         = text "A function type is expected for the expression" <+> ppExpr 0 xs e <+> text "instead of type" <+> ppType 0 xs ty
-ppTcError (CannotInferType xs e)       = text "Cannot infer the type of expression" <+> ppExpr 0 xs e
-ppTcError (UnresolvedMetaVars xs e ms) = text "Meta variable(s)" <+> fsep (List.map ppMeta ms) <+> text "should be resolved" $$
-                                         text "in the expression:" <+> ppExpr 0 xs e
-ppTcError (UnexpectedImplArg xs e)     = braces (ppExpr 0 xs e) <+> text "is implicit argument but not implicit argument is expected here"
-ppTcError (UnsolvableGoal xs metaid ty)= text "The goal:" <+> ppMeta metaid <+> colon <+> ppType 0 xs ty $$
-                                         text "cannot be solved"
-

doc/gf-bibliography.html

@@ -0,0 +1,875 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+<META NAME="generator" CONTENT="http://txt2tags.org">
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
+<LINK REL="stylesheet" TYPE="text/css" HREF="../css/style.css">
+<meta name = "viewport" content = "width = device-width"><TITLE>Grammatical Framework Bibliography</TITLE>
+</HEAD><BODY BGCOLOR="white" TEXT="black">
+<CENTER>
+<H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>Grammatical Framework Bibliography</H1>
+<FONT SIZE="4"><I>Aarne Ranta</I></FONT><BR>
+<FONT SIZE="4">Tue Nov 27 16:47:06 2012</FONT>
+</CENTER>
+
+<P></P>
+<HR NOSHADE SIZE=1>
+<P></P>
+
+    <UL>
+    <LI><A HREF="#toc1">Publications on GF</A>
+    <LI><A HREF="#toc2">Background for GF</A>
+    </UL>
+
+<P></P>
+<HR NOSHADE SIZE=1>
+<P></P>
+
+<A NAME="toc1"></A>
+<H2>Publications on GF</H2>
+
+<P>
+In reverse temporal order:
+</P>
+<P>
+H. Burden and R. Heldal.
+Natural Language Generation from Class Diagrams.
+<I>Proceedings of the 8th International Workshop on Model-Driven Engineering, Verification and Validation (MoDeVVa 2011)</I>,
+Wellington, New Zealand,
+ACM,
+2011.
+<A HREF="http://www.grammaticalframework.org/doc/archive/a9-burden.pdf">Draft PDF</A>
+<br>
+<I>Using GF to verbalize platform-independent requirement specifications as a part of a software engineering tool chain.</I>
+</P>
+<P>
+C. España-Bonet, R. Enache, A. Slaski, A. Ranta, L. Màrquez, and M. Gonzàlez.
+Patent translation within the MOLTO project.
+Proceedings of the 4th Workshop on Patent Translation, 
+MT Summit XIII, Xiamen, China, September 23, 2011.
+<A HREF="http://www.lsi.upc.edu/~cristinae/CV/docs/MTS11PatEspanaetal.pdf">PDF</A>
+<br>
+<I>First steps to a hybrid GF-SMT system.</I>
+</P>
+<P>
+Seyed M. Montazeri, Nivir Roy, and Gerardo Schneider. 
+From Contracts in Structured English to CL Specifications. 
+<I>5th International Workshop on Formal Languages and Analysis of Contract-Oriented Software (FLACOS'11)</I>, 
+volume 68 of EPTCS, pages 55-69, 
+Málaga, Spain, 22-23 September 2011.
+<A HREF="http://dx.doi.org/10.4204/EPTCS.68.6">PDF/DOI</A>
+<br>
+<I>Formal analysis of contracts written in controlled English.</I>
+</P>
+<P>
+S. Virk, M. Humayoun, and A. Ranta.
+An Open-Source Punjabi Resource Grammar.
+Proceedings of RANLP-2011, Recent Advances in Natural Language Processing,
+Hissar, Bulgaria, 12-14 September, 2011.
+pp. 70-76.
+<A HREF="http://lml.bas.bg/~iva/ranlp2011/RANLR2011_Proceedings.PDF">PDF</A>
+<br>
+<I>Punjabi syntax, building on Humayoun and Ranta 2010.</I>
+</P>
+<P>
+D. Dannélls, M. Damova, R.Enache, M. Chechev.
+A Framework for Improved Access to Museum Databases in the Semantic Web.
+Proceedings of the Workshop on Language Technologies for Digital Humanities and Cultural Heritage,
+RANLP-2011, Recent Advances in Natural Language Processing, 
+Hissar, Bulgaria, 12-14 September, 2011,
+pp 8-15
+<A HREF="http://publications.lib.chalmers.se/cpl/record/index.xsql?pubid=145395">PDF</A>
+<br>
+<I>Representing and verbalizing in GF of an Cultural Heritage ontology.</I> 
+</P>
+<P>
+A. Ranta.
+Translating between Language and Logic: What Is Easy and What is Difficult?
+In N. Bjørner and V. Sofronie-Stokkermans (eds.),
+<I>CADE-23. Automated Deduction</I>,
+LNCS/LNAI 6803,
+pp. 5-25,
+2011.
+<A HREF="http://www.springerlink.com/content/42n685777k846810/">PDF at Springer</A>
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/cade2011.pdf">Draft PDF</A>
+<br>
+<I>Invited talk at the CADE conference, showing how GF can help writing natural language interfaces</I> 
+<I>to proof systems, and also exploring how to make the language richer, e.g. how to get from</I>
+<I>"for all numbers x, x is even or x is odd" to "every number is even or odd".</I>
+</P>
+<P>
+A. Ranta. 
+<I>Grammatical Framework: Programming with Multilingual Grammars</I>, 
+  CSLI Publications, Stanford, 2011.
+  <A HREF="http://www.grammaticalframework.org/gf-book/">Book web page</A> 
+<br>
+<I>Meant as the standard reference and textbook on GF.</I>
+</P>
+<P>
+O. Caprotti, K. Angelov, R. Enache, T. Hallgren, A. Ranta.
+The MOLTO Phrasebook.
+Swedish Language Technology Conference SLTC 2010.
+<A HREF="http://publications.lib.chalmers.se/cpl/record/index.xsql?pubid=131251">PDF</A>
+<br>
+<I>Tourist Phrasebook grammar, available in 14 European languages.</I>
+</P>
+<P>
+G. Détrez and R. Enache.
+A Framework for Multilingual Applications on the Android Platform
+Swedish Language Technology Conference SLTC 2010.
+<A HREF="http://www.grammaticalframework.org/doc/archive/sltc10_submission_24.pdf">PDF</A>
+<br>
+<I>A description of the Java implementation of the GF runtime system, which makes it possible</I>
+to create grammar-based applications running on an Android phone.//
+</P>
+<P>
+Normunds Gruzitis and Guntis Barzdins.
+Towards a More Natural Multilingual Controlled Language Interface to OWL,
+<I>9th International Conference on Computational Semantics (IWCS)</I>,
+pp. 335-339,
+2011.
+<A HREF="http://www.aclweb.org/anthology/W/W11/W11-0138.pdf">PDF</A>
+<br>
+<I>Access to ontologies in English and Latvian.</I>
+</P>
+<P>
+M. Humayoun and A. Ranta. 
+Developing Punjabi Morphology, Corpus and Lexicon. 
+<I>The 24th Pacific Asia conference on Language, Information and Computation (PACLIC24)</I>,
+2010.
+<br>
+<I>Yet another South-East Asian language, spoken by 88 million people.</I>
+</P>
+<P>
+J. Camilleri, Gordon J. Pace, and Mike Rosner.
+Playing Nomic using a Controlled Natural Language.
+<I>CNL 2010, Controlled Natural Language</I>,
+Marettimo,
+2010.
+<br>
+<I>Using GF for defining the rules of a game.</I>
+</P>
+<P>
+R. Enache and K. Angelov
+Typeful Ontologies with Direct Multilingual Verbalization.
+<I>CNL 2010, Controlled Natural Language</I>,
+Marettimo, 
+2010.
+<br>
+<I>Investigating the benefits of using GF as a language for representing ontologies.</I>
+<A HREF="http://www.grammaticalframework.org/doc/archive/cnl2010_submission_2.pdf">PDF</A>
+</P>
+<P>
+S. Virk, M. Humayoun, and A. Ranta. 
+An Open Source Urdu Resource Grammar. 
+<I>Proceedings of the 8th Workshop on Asian Language Resources (Coling 2010 workshop)</I>,
+2010.
+<br>
+<I>The national language of Pakistan, spoken by 60 million people; almost the same as Hindi.</I>
+</P>
+<P>
+A. Ranta, K. Angelov, and T. Hallgren.
+Tools for multilingual grammar-based translation on the web.
+<I>Proceedings of the ACL 2010 System Demonstrations</I>,
+ACM Digital Library,
+2010.
+<A HREF="http://www.aclweb.org/anthology-new/P/P10/P10-4012.pdf">PDF</A>
+<br>
+<I>An overview of GF for developers and users of translation systems.</I>
+</P>
+<P>
+D. Dannélls and J. Camilleri. 
+Verb Morphology of Hebrew and Maltese - Towards an Open Source Type Theoretical Resource Grammar in GF.
+<I>Proceedings of the Language Resources (LRs) and Human Language Technologies (HLT) for Semitic Languages Status, Updates, and Prospects, LREC-2010 Workshop</I>,
+Malta, pp. 57-61.
+2010.
+<A HREF="http://spraakdata.gu.se/svedd/pub/lrec10.pdf">PDF</A>
+<br>
+<I>A study of Semitic non-concatenative morphology from the GF point of view.</I>
+</P>
+<P>
+M. Humayoun and C. Raffalli.
+MathNat - Mathematical Text in a Controlled Natural Language. 
+<I>Special issue: Natural Language Processing and its Applications. Journal on Research in Computing Science</I>, Volume 46. 
+2010.
+<br>
+<I>Natural language interface to a proof system, implemented in GF.</I>
+</P>
+<P>
+D. Dannélls.
+Discourse Generation from Formal Specifications Using the Grammatical Framework, GF. 
+<I>Special issue: Natural Language Processing and its Applications.  Journal on Research in Computing Science (RCS)</I>, 
+volume 46. pp. 167-178,
+2010.
+<br>
+<I>Interfacing GF with ontology, with a natural language generation perspective.</I>
+</P>
+<P>
+R. Enache, A. Ranta, and K. Angelov.
+An Open-Source Computational Grammar of Romanian.
+A. Gelbukh (ed.), <I>CiCLING-2010</I>,
+LNCS 6008,
+2010.
+<br>
+<I>A Romance language different enough not to follow the Romance functor.</I>
+</P>
+<P>
+K. Angelov and A. Ranta.
+Implementing Controlled Languages in GF.
+N. Fuchs (ed.), <I>CNL-2009 Controlled Natural Languages</I>,
+LNCS/LNAI 5972,
+2010.
+</P>
+<P>
+K. Angelov, B. Bringert and A. Ranta.
+PGF: A Portable Run-time Format for Type-theoretical Grammars,
+<I>Journal of Logic, Language and Information</I>,
+19(2),
+pp. 201-228,
+2009.
+<A HREF="http://www.springerlink.com/content/y32q021028747k70/">SpringerLink</A>
+</P>
+<P>
+A. Ranta.
+The GF Resource Grammar Library.
+<I>Linguistic Issues in Language Technology</I>, 
+2 (2),
+2009.
+<A HREF="http://elanguage.net/journals/index.php/lilt/article/viewFile/214/158">PDF</A>
+<br>
+<I>A systematic presentation of the library from the linguistic point of view.</I>
+</P>
+<P>
+A. Ranta.
+Grammatical Framework: A Multilingual Grammar Formalism, 
+<I>Language and Linguistics Compass</I>, 
+Vol. 3, <A HREF="http://www.blackwell-compass.com/subject/linguistics/article_view?parent=section&amp;last_results=section%3Dlnco-computational&amp;sortby=date&amp;section=lnco-computational&amp;browse_id=lnco_articles_bpl155&amp;article_id=lnco_articles_bpl155">on-line</A>
+2009.
+<br>
+<I>An overview of GF for readers with a general academic brackground.</I>
+</P>
+<P>
+A. Ranta and K. Angelov.
+Implementing Controlled Languages in GF.
+<I>CNL-2009</I>,
+<I>CEUR Workshop Proceedings</I>,
+vol. 448,
+<A HREF="http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-448/">on-line</A>,
+2009.
+<br>
+<I>Makes a case for using GF in controlled language implementation, illustrated by Attempto Controlled English ported to French, German, and Swedish; longer version in 2010.</I>
+</P>
+<P>
+A. Ranta. Grammars as Software Libraries.
+In Y. Bertot, G. Huet, J-J. Lévy, and G. Plotkin (eds.),
+<I>From Semantics to Computer Science</I>,
+Cambridge University Press, Cambridge, 
+pp. 281-308,
+2009.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/libraries-kahn.pdf">pdf (preliminary version)</A>
+<br>
+<I>Grammar-libraries from the software engineering point of view, with an example application to mathematical language.</I>
+</P>
+<P>
+K. Angelov.
+Incremental Parsing in Parallel Multiple Context-Free Grammars.
+EACL 2009.
+<br>
+<I>Describes the algorithm used in parsing with GF.</I>
+</P>
+<P>
+A. Ranta, B. Bringert, and K. Angelov. 
+The GF Grammar Development Environment. 
+System demo. Proceedings of <I>EACL-2009</I>,
+2009.
+<A HREF="http://www.aclweb.org/anthology-new/E/E09/E09-2015.pdf">PDF</A>
+<br>
+<I>An overview of GF from the grammarian's point of view.</I>
+</P>
+<P>
+B. Bringert, K. Angelov, and A. Ranta. 
+Grammatical Framework Web Service,
+System demo. Proceedings of <I>EACL-2009</I>,
+2009.
+<A HREF="http://www.aclweb.org/anthology-new/E/E09/E09-2003.pdf">PDF</A>
+<br>
+<I>An overview of how to build web services on top of PGF using the Google Web Toolkit.</I>
+</P>
+<P>
+A. Ranta and K. Angelov. 
+Implementing Controlled Languages in GF,
+To appear in the proceedings of <I>CNL-2009</I>, LNCS, Springer,
+2009.
+<br>
+<I>On the use of GF for controlled languages, exemplified by an implementation of Attempto Controlled English then ported to three other language.</I>
+</P>
+<P>
+R. Cooper and A. Ranta. 
+Natural Languages as Collections of Resources. 
+In <I>Language in Flux: Dialogue Coordination, Language Variation, Change</I>, 
+ed. by R. Cooper and R. Kempson, pp. 109-120. London: College Publications,
+2008.
+<br>
+<I>The resource grammar idea applied to language learning and evolution.</I>
+</P>
+<P>
+Moisés Salvador Meza Moreno and B. Bringert.
+Interactive Multilingual Web Applications with Grammatical Framework.
+In B. Nordström and A. Ranta (eds), 
+<I>Advances in Natural Language Processing (GoTAL 2008)</I>, 
+LNCS/LNAI 5221, Springer,
+2008.
+<br>
+<I>Shows how GF compiled to JavaScript is used in dynamic multilingual web pages.</I>
+</P>
+<P>
+Peter Ljunglöf and Staffan Larsson. 
+A grammar formalism for specifying ISU-based dialogue systems.
+In B. Nordström and A. Ranta (eds), 
+<I>Advances in Natural Language Processing (GoTAL 2008)</I>, 
+LNCS/LNAI 5221, Springer,
+2008.
+<A HREF="http://www.ling.gu.se/~peb/pubs/LjunglofLarsson-2008a.pdf">pdf</A>
+<br>
+<I>Explains how GoDiS dialogue systems are specified by GF grammars.</I>
+</P>
+<P>
+K. Angelov.
+Type-Theoretical Bulgarian Grammar.
+In B. Nordström and A. Ranta (eds), 
+<I>Advances in Natural Language Processing (GoTAL 2008)</I>, 
+LNCS/LNAI 5221, Springer,
+2008.
+<br>
+<I>Explains the implementation of a Bulgarian resource grammar in GF.</I>
+</P>
+<P>
+B. Bringert.
+High-precision Domain-specific Interlingua-based Speech Translation
+with Grammatical Framework.
+<I>Coling 2008 Workshop on Speech Translation for Medical and Other Safety-Critical Applications</I>, 
+Manchester, UK, August 23, 
+2008.
+<br>
+<I>Shows how to build spoken language translators based on GF grammars and their compilation to Nuance.</I>
+</P>
+<P>
+A. Ranta.
+How predictable is Finnish morphology? An experiment on lexicon construction.
+In J. Nivre, M. Dahllöf and B. Megyesi (eds),
+<I>Resourceful Language Technology: Festschrift in Honor of Anna Sågvall Hein</I>,
+University of Uppsala,
+2008.
+Available from <A HREF="http://publications.uu.se/abstract.xsql?dbid=8933">series homepage</A>
+<br>
+<I>Presents an experiment on smart paradigms in Finnish.</I>
+</P>
+<P>
+A. Ranta.
+Example-based grammar writing.
+To appear in L. Borin and S. Larsson (eds),
+Festschrift for Robin Cooper,
+2007.
+<br>
+<I>Presents and discusses the ideas of grammar composition and example-based grammar writing.</I>
+</P>
+<P>
+B. Bringert.
+Rapid Development of Dialogue Systems by Grammar Compilation.
+<I>8th SIGdial Workshop on Discourse and Dialogue</I>, 
+Antwerp, Belgium, September 1-2, 
+2007.
+<A HREF="http://www.cse.chalmers.se/~bringert/publ/gf-voicexml/gf-voicexml.pdf">pdf</A>
+<br>
+<I>Shows how to build a web-based spoken dialogue system by generating VoiceXML and JavaScript.</I>
+</P>
+<P>
+A. El Dada and A. Ranta.
+Implementing an Open Source Arabic Resource Grammar in GF.
+In M. Mughazy (ed),
+<I>Perspectives on Arabic Linguistics XX. Papers from the Twentieth Annual Symposium on Arabic Linguistics, Kalamazoo, March 26</I>
+John Benjamins Publishing Company.
+2007.
+<br>
+<I>An outline of the Arabic resource grammar project, focusing on linguistic aspects.</I>
+</P>
+<P>
+A. El Dada.
+Implementation of the Arabic Numerals and their Syntax in GF.
+Computational Approaches to Semitic Languages: Common Issues and Resources, 
+  ACL-2007 Workshop,
+June 28, 2007, Prague.
+2007.
+<br>
+<I>A case study with the resource grammar, focusing on the morphosyntax</I>
+<I>and agreement of constructions with numerals.</I>
+</P>
+<P>
+A. Ranta.
+Modular Grammar Engineering in GF.
+<I>Research on Language and Computation</I>, 
+5:133-158, 2007.
+Draft available as <A HREF="http://www.cse.chalmers.se/~aarne/articles/multieng3.pdf">pdf</A>.
+<br>
+<I>Adapts library-based software engineering methods to grammar writing</I> 
+<I>and introduces the module system of GF.</I>
+</P>
+<P>
+A. Ranta.
+The GF Grammar Compiler.
+<I>Workshop on New Directions in Type-theoretic Grammars</I>,
+Dublin, August 2007 (ESSLLI workshop).
+2007.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/ar-compiler.pdf">pdf</A>
+<br>
+<I>Describes the compilation of GF source code to lower-level run-time formats.</I>
+</P>
+<P>
+M. Humayoun, H. Hammarström, and A. Ranta.
+Urdu Morphology, Orthography and Lexicon Extraction.
+<I>CAASL-2: The Second Workshop on Computational Approaches to Arabic Script-based Languages</I>,
+July 21-22, 2007, LSA 2007 Linguistic Institute, Stanford University.
+2007.
+<br>
+<I>Fairly complete open-source Urdu morphology and elemenraty syntax in GF.</I>
+</P>
+<P>
+N. Perera and A. Ranta.
+Dialogue System Localization with the GF Resource Grammar Library.
+<I>SPEECHGRAM 2007: ACL Workshop on Grammar-Based Approaches to Spoken Language Processing</I>,
+June 29, 2007, Prague.
+2007.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/perera-ranta.pdf">pdf</A>
+<br>
+<I>An experiment in porting an in-car dialogue system from two to six languages.</I> 
+</P>
+<P>
+B. Bringert.
+Speech Recognition Grammar Compilation in Grammatical Framework
+<I>SPEECHGRAM 2007: ACL Workshop on Grammar-Based Approaches to Spoken Language Processing</I>,
+June 29, 2007, Prague.
+2007.
+<br>
+<I>Generation of speech recognition language models from GF in several formats:</I> 
+<I>GSL (Nuance), SRGS, JSGF, and HTK SLF, with embedded semantic interpretation.</I>
+</P>
+<P>
+A. Ranta.
+Features in Abstract and Concrete Syntax.
+<I>The 2nd International Workshop on Typed Feature Structure Grammars</I>,
+Tartu, 24 May 2007 (NODALIDA workshop).
+2007.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/ranta-tfsg2007.pdf">pdf</A>
+<br>
+<I>Explores the design choices of incorporating features in a GF-like grammar,</I>
+<I>with comparisons to feature-based unification grammars.</I>
+</P>
+<P>
+O. Caprotti and M. Seppälä.
+Multilingual Delivery of Online Tests in mathematics.
+Proceedings of Online Educa Berlin 2006. 29 November - 1 December 2006. 
+  Berlin, Germany.
+2006.
+<A HREF="http://webalt.math.helsinki.fi/content/e16/e301/e785/MultilingualDeliveryofOnlineTestsinMathematics_eng.pdf">pdf</A>
+<br>
+<I>This papers shows screenshots of multilingual generation in the</I>
+<I>WebALT project, using GF and the resource grammar library.</I>
+</P>
+<P>
+J. Khegai. 
+Language engineering in Grammatical Framework (GF).
+Phd thesis, Computer Science, Chalmers University of Technology,
+2006.
+<A HREF="http://www.cse.chalmers.se/~janna/Janna_Khegai_phd.pdf">pdf</A>
+<br>
+<I>Collection of articles and technical reports on multilingual authoring</I>
+<I>and the Russian resource grammar.</I>
+</P>
+<P>
+B. Bringert and A. Ranta.
+A Pattern for Almost Compositional Functions.
+<I>ICFP 2006, The 11th ACM SIGPLAN International Conference on Functional Programming, Portland, Oregon, September 18-20, 2006</I>,
+2006.
+<A HREF="http://www.cse.chalmers.se/~bringert/publ/composOp/composOp.pdf">pdf</A>.
+<br>
+<I>A method of generic programming useful for compiler construction</I>
+<I>and transfer-based translation.</I>
+</P>
+<P>
+M. Forsberg, H. Hammarstrom, and A. Ranta.
+Morphological Lexicon Extraction from Raw Text Data. 
+<I>FinTAL 2006</I>, 
+Turku, August 23-25, 2006.
+Springer LNCS/LNAI 4139,
+pp. 488-499,
+2006.
+<br>
+<I>A method for automatical production of morphological lexica based</I>
+<I>on inflection engines such as those of GF resource grammar library.</I>
+</P>
+<P>
+A. Ranta.
+Type Theory and Universal Grammar.
+<I>Philosophia Scientiae, Constructivism: Mathematics, Logic, Philosophy and Linguistics</I>,
+cahier spécial 6,
+pp. 115-131,
+2006.
+<br>
+<I>A philosophical study of the medieval thesis that</I>
+<I>grammar is the same in all languages and the difference is only in words.</I>
+</P>
+<P>
+J. Khegai. 
+GF parallel resource grammars and Russian.
+In proceedings of ACL2006 
+  (The joint conference of the International Committee on Computational 
+  Linguistics and the Association for Computational Linguistics) (pp. 475-482),
+  Sydney, Australia, July 2006.
+<br>
+<I>Gives an outline of the Russian resource grammar project.</I>
+</P>
+<P>
+J. Khegai. 
+Grammatical Framework (GF) for MT in sublanguage domains. 
+Proceedings of 11th Annual conference of the European Association for 
+      Machine Translation, , Oslo.
+pp. 95-104,
+2005.
+<br>
+<I>Shows how GF is used in controlled language translation.</I>
+</P>
+<P>
+W. Ng'ang'a. 
+Multilingual content development for eLearning in Africa. 
+eLearning Africa: 1st Pan-African Conference on ICT for Development, 
+  Education and Training. 24-26 May 2006, Addis Ababa, Ethiopia.
+2006.
+<A HREF="http://webalt.math.helsinki.fi/content/e16/e301/e583/MultilingualContentDevelopmentforeLearninginAfrica-final1_eng.pdf">pdf</A>
+<br>
+<I>Presents a programme for producing educational material in African languages</I>
+<I>via multilingual generation in GF.</I>
+</P>
+<P>
+R. Jonson. 
+Generating statistical language models from interpretation grammars in dialogue system. 
+In Proceedings of EACL'06, Trento, Italy.
+2006.
+<br>
+<I>Uses GF grammars to generate statistical language models for speech recognition.</I>
+</P>
+<P>
+A. El Dada and A. Ranta.
+Arabic Resource Grammar.
+<I>Arabic Language Processing (JETALA)</I>, 
+5-6 June 2006, IERA, Rabat, Morocco,
+2006.
+<br>
+<I>An outline of the Arabic resource grammar project, focusing on software aspects.</I>
+</P>
+<P>
+D. A. Burke and K. Johannisson.
+Translating Formal Software Specifications to Natural Language. A Grammar-Based Approach.
+In P. Blache, E. Stabler, J. Busquets and R. Moot (eds),
+Logical Aspects of Computational Linguistics (LACL 2005), 
+Springer LNAI 3402, 
+pp. 51-66, 
+2005.
+<br>
+<I>A paper explaining how a multilingual GF grammar is completed with</I>
+<I>Natural Language Generation techniques to improve text quality.</I>
+</P>
+<P>
+B. Bringert, R. Cooper, P. Ljunglöf, A. Ranta, 
+Multimodal Dialogue System Grammars.
+<I>Proceedings of DIALOR'05, Ninth Workshop on the Semantics and Pragmatics of Dialogue, Nancy, France, June 9-11, 2005</I>,
+2005.
+<A HREF="http://www.cse.chalmers.se/~bringert/publ/mm-grammars-dialor/mm-grammars-dialor.pdf">pdf</A>.
+<br>
+<I>Shows how mouse clicks can be integrated in GF grammars</I>
+<I>alongside with speech input.</I>
+</P>
+<P>
+K.  Johannisson,
+Formal and Informal Software Specifications.
+PhD thesis,
+Computer Science, Göteborg University, 
+2005.
+[<A HREF="http://www.cse.chalmers.se/~krijo/thesis/thesisA4.pdf">http://www.cse.chalmers.se/~krijo/thesis/thesisA4.pdf</A>]
+<br>
+<I>Collection of articles in the GF-KeY project, with an introduction.</I>
+</P>
+<P>
+P. Ljunglöf.
+Expressivity and Complexity of the  Grammatical Framework.
+PhD thesis, Computer Science, 
+Göteborg University, 
+2004.
+<A HREF="http://www.cse.chalmers.se/~peb/pubs/Ljunglof-2004a.pdf">pdf</A>
+<br>
+<I>Language-theoretical study of GF and its parsing problem.</I>
+</P>
+<P>
+A. Ranta.
+Grammatical Framework: A Type-Theoretical Grammar Formalism.
+<I>Journal of Functional Programming</I>, 14(2),
+pp. 145-189, 
+2004.
+Draft available as <A HREF="http://www.cse.chalmers.se/~aarne/articles/gf-jfp.ps.gz">ps.gz</A>.
+<br>
+<I>Theoretical paper explaining the GF formalism and its implementation.</I>
+<I>The standard reference on GF, but doesn't cover the module system.</I>
+</P>
+<P>
+A. Ranta.
+Computational semantics in type theory.
+<I>Mathematics and Social Sciences</I>, 165,
+pp. 31-57, 
+2004.
+Draft available as <A HREF="http://www.cse.chalmers.se/~aarne/articles/3formsem.pdf">pdf</A>.
+<br>
+// Shows how Montague-style grammars are implemented in GF and extends//
+<I>this to type-theoretical grammars for anaphoric expressions.</I>
+</P>
+<P>
+H. Hammarström and A. Ranta.
+Cardinal Numerals Revisited in GF.
+<I>Workshop on Numerals in the World's Languages</I>. 
+Dept. of Linguistics Max Planck Institute for Evolutionary Anthropology, Leipzig,
+2004.
+<br>
+<I>An overview of the numeral grammar project, covering 88 languages.</I>
+</P>
+<P>
+A. Ranta.
+Grammatical Framework Tutorial.
+In A. Beckmann and N. Preining, editors, 
+<I>ESSLLI 2003 Course Material I</I>, 
+<I>Collegium Logicum</I>, 
+volume V,
+pp. 1-86. 
+Kurt Gödel Society, 
+Vienna,
+2004.
+<br>
+<I>A revised version of the on-line GF tutorial, v1.0.</I>
+</P>
+<P>
+J. Khegai and A. Ranta.
+Building and Using a Russian Resource Grammar in GF.
+In A. Gelbukh (ed), 
+<I>Intelligent Text Processing and Computational Linguistics (CICLing-2004)</I>, 
+Seoul, Korea, February 2003,
+Springer LNCS 945, 
+pp. 38-41,
+2004.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/mexico.ps.gz">ps.gz</A>.
+<br>
+<I>An introduction to the GF resource grammar project, with Russian as prime example.</I>
+</P>
+<P>
+A. Ranta and R. Cooper.
+Dialogue Systems as Proof Editors.
+ <I>Journal of Logic, Language and Information</I>, 13,
+pp. 225-240, 
+2004.
+Conference version (IJCAR/ICoS-3, Siena, June 2001) available as
+  <A HREF="http://www.cse.chalmers.se/~aarne/articles/dialogue3.ps.gz">ps.gz</A>.
+<I>Shows a close analogy between task-oriented dialogue systems</I>
+<I>and metavariable-based proof editors.</I>
+</P>
+<P>
+J. Khegai and A. Ranta.
+Building and Using a Russian Resource Grammar in GF.
+In A. Gelbukh (ed), 
+<I>Intelligent Text Processing and Computational Linguistics (CICLing-2004)</I>, 
+Seoul, Korea, February 2003,
+Springer LNCS 945, 
+pp. 38-41,
+2004.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/mexico.ps.gz">ps.gz</A>.
+<br>
+<I>Explains how the GF GUI is used in syntax editing and discusses</I>
+<I>how new grammars are created.</I>
+</P>
+<P>
+R. Hähnle, K. Johannisson, and A. Ranta.
+An Authoring Tool for Informal and Formal Requirements Specifications.
+In R. D. Kutsche and H. Weber (eds),
+<I>ETAPS/FASE-2002: Fundamental Approaches to Software Engineering</I>,
+Springer LNCS, 
+vol. 2306,
+pp. 233--248, 
+2002.
+<A HREF="http://www.cse.chalmers.se/~krijo/GF/FASE.pdf">pdf</A>
+<br>
+<I>Describes a GF-based authoring tool for object-oriented</I>
+<I>specifications in OCL and English. Carries out in full</I>
+<I>the work proposed in the position paper (Hähnle &amp; Ranta 2001).</I>
+</P>
+<P>
+K. Johannisson and A.Ranta,
+Formal Verification of Multilingual Instructions.
+<I>Proceedings of the Joint Winter Meeting 2001</I>.
+Departments of Computer Science and Computer Engineering,
+Chalmers University of Technology and Göteborg University.
+2001.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/aarne+krijo.ps.gz">ps.gz</A>.
+<br>
+<I>Instructions for an alarm system in four languages, verified in the proof editor Alfa.</I>
+</P>
+<P>
+R. Hähnle and A. Ranta,
+Connecting OCL with the Rest of the World.
+<I>ETAPS 2001 Workshop on Transformations in UML (WTUML)</I>, 
+Genova, 
+2001.
+<A HREF="http://www.cse.chalmers.se/~reiner/papers/wtuml.ps.gz">ps.gz</A>.
+<br>
+<I>A position paper explaining how GF can be used to help in object-oriented</I>
+<I>modelling, with some examples on natural-language interaction with</I>
+<I>OCL (Object Constraint Language)</I>.
+</P>
+<P>
+T. Hallgren, "The Correctness of Insertion Sort",
+Manuscript, Chalmers University, Göteborg, 2001.
+Available in
+<A HREF="http://www.cse.chalmers.se/~hallgren/Papers/insertion_sort.ps">ps</A>
+<br>
+<I>A seven-page text generated by GF-Alfa</I>.
+</P>
+<P>
+A. Ranta. "Bescherelle bricolé",
+<A HREF="../../GF2.0/doc/BeschBric.ps.gz">ps.gz</A>, 
+2001.
+<br>
+<I>A machine-generated book on French conjugation implemented in GF.</I>
+</P>
+<P>
+T. Hallgren and A. Ranta,
+An Extensible Proof Text Editor.
+In M. Parigot and A. Voronkov (eds),
+<I>Logic for Programming and Automated Reasoning (LPAR'2000)</I>,
+LNCS/LNAI 1955, 
+pp. 70-84,
+Springer Verlag, Heidelberg, 
+2000.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/lpar2000.ps.gz">ps.gz</A>.
+<br>
+<I>Describes an interface to the proof editor Alfa written in GF</I>.
+</P>
+<P>
+M. Dymetman, V. Lux, and A. Ranta,
+XML and multilingual document authoring: converging trends.
+<I>Proceedings of the The 18th International Conference on Computational Linguistics (COLING 2000)</I>,
+pp. 243-249,
+Saarbruecken, 
+2000.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/coling2000.ps.gz">ps.gz</A>.
+<br>
+<I>Relates GF not only with XML but also with definite clause grammars</I>.
+</P>
+<P>
+P. Mäenpää and A. Ranta.
+The type theory and type checker of GF.
+<I>Colloquium on Principles, Logics, and Implementations of High-Level Programming Languages, Workshop on Logical Frameworks and Meta-languages, Paris, 28 September 1999</I>.
+1999. 
+<A HREF="href=http://www.cse.chalmers.se/~aarne/papers/lfm1999.ps.gz">ps.gz</A>.
+<br>
+<I>Concise theoretical presentation of GF, using the old notation prior to v0.9</I>.
+</P>
+
+<A NAME="toc2"></A>
+<H2>Background for GF</H2>
+
+<P>
+In alphabetical order:
+</P>
+<P>
+L. Magnusson.
+<I>The Implementation of ALF - a Proof Editor based on Martin-Löf's</I>
+<I>Monomorphic Type Theory with Explicit Substitutions</I>.
+PhD Thesis, Department of Computing Science,
+Chalmers University of Technology and Göteborg University,
+1994.
+<br>
+<I>Back in 1992 the most wonderful program in the world, ALF is</I>
+<I>a model that GF directly follows: GF is Yet ALF.</I>
+</P>
+<P>
+P. Martin-Löf.
+<I>Intuitionistic Type Theory</I>.
+Bibliopolis, Naples, 1984.
+<br>
+<I>A very accessible book (if you have access to it!) on type theory directly from the source.</I>
+</P>
+<P>
+B. Nordström, K. Petersson, and J. Smith.
+<I>Programming in Martin-Löf's Type Theory: an Introduction</I>.
+Oxford University Press, 1990.
+ The book is out of print, but a free version can be picked up from
+<A HREF="http://www.cse.chalmers.se/Cs/Research/Logic/book/">www.cse.chalmers.se/Cs/Research/Logic/book/</A>
+<br>
+<I>Standard reference on the subject</I>.
+</P>
+<P>
+A. Ranta.
+<I>Type Theoretical Grammar</I>.
+Oxford University Press, Oxford, 
+1994.
+<br>
+<I>Monograph on type theory in linguistics. Includes an introduction</I>
+<I>to type theory. Focused on semantics, in particular anaphora. A first,</I> 
+<I>very rudimentary implementation of linearization in the proof system ALF.</I>
+</P>
+<P>
+A. Ranta.
+Syntactic categories in the language of mathematics.
+In P. Dybjer, B. Nordström, and J. Smith, eds.,
+<I>Types for Proofs and Programs</I>, 
+pp. 162-182,
+Lecture Notes in Computer Science
+996,  
+Springer-Verlag, 
+Heidelberg, 
+1995.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/baastad.ps.gz">ps.gz</A>
+<br>
+<I>Predecessor of GF: grammar defined in type theory and implemented in ALF</I>. 
+</P>
+<P>
+A. Ranta.
+Context-relative syntactic categories and the formalization of mathematical text.
+In S. Berardi and M. Coppo, eds.,
+<I>Types for Proofs and Programs</I>, 
+pp. 231-248,
+Lecture Notes in Computer Science 
+1158, 
+Springer-Verlag, 
+Heidelberg, 
+1996.
+<A HREF="http://www.cse.chalmers.se/~aarne/articles/torino.ps.gz">ps.gz</A>.
+<br>
+<I>Extending the theory of the previous paper. The implementation in ALF</I> 
+<I>eventually became so heavy that the need arose for GF.</I>
+</P>
+<P>
+A. Ranta.
+Structures grammaticales dans le français mathématique. 
+<I>Mathématiques, informatique et Sciences Humaines.</I>,
+vol. 138 pp. 5-56 and 139 pp. 5-36, 
+1997.
+<br>
+<I>A rather comprehensive French grammar presented in a type-theoretical style.</I>
+</P>
+<P>
+A. Ranta.
+ Syntactic calculus with dependent types.
+ <I>Journal of Logic, Language and Information</I>, vol. 4,
+  pp. 413-431, 1998.
+<br>
+<I>Interprets Lambek Calculus in type theory and defines some extensions</I>.
+</P>
+
+<!-- html code generated by txt2tags 2.6 (http://txt2tags.org) -->
+<!-- cmdline: txt2tags -thtml ./doc/gf-bibliography.t2t -->
+</BODY></HTML>

doc/gf-developers.t2t

@@ -1,8 +1,16 @@
 GF Developers Guide
+Authors: Björn Bringert, Krasimir Angelov and Thomas Hallgren
+Last update: %%mtime(%F, %H:%M)
 
-2018-07-26
+% NOTE: this is a txt2tags file.
+% Create an html file from this file using:
+% txt2tags -t html gf-developers.t2t
 
+%!style:../css/style.css
+%!target:html
 %!options(html): --toc
+%!encoding:utf-8
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
 
 == Before you start ==
 
@@ -15,15 +23,15 @@ you are a GF user who just wants to download and install GF
 == Setting up your system for building GF ==
 
 To build GF from source you need to install some tools on your
-system: the //Haskell Platform//, //Git// and the //Haskeline library//.
+system: the //Haskell Platform//, //Darcs// and the //Haskeline library//.
 
 **On Linux** the best option is to install the tools via the standard
 software distribution channels, i.e. by using the //Software Center//
 in Ubuntu or the corresponding tool in other popular Linux distributions.
 Or, from a Terminal window, the following command should be enough:
 
-- On Ubuntu: ``sudo apt-get install haskell-platform git libghc6-haskeline-dev``
-- On Fedora: ``sudo dnf install haskell-platform git ghc-haskeline-devel``
+- On Ubuntu: ``sudo apt-get install haskell-platform darcs libghc6-haskeline-dev``
+- On Fedora: ``sudo yum install haskell-platform darcs ghc-haskeline-devel``
 
 
 **On Mac OS and Windows**, the tools can be downloaded from their respective
@@ -32,7 +40,7 @@ web sites, as described below.
 === The Haskell Platform ===
 
 GF is written in Haskell, so first of all you need
-the //Haskell Platform//, e.g. version 8.0.2 or 7.10.3. Downloads
+the //Haskell Platform//, e.g. version 7.10.3. Downloads
 and installation instructions are available from here:
 
     http://hackage.haskell.org/platform/
@@ -46,20 +54,26 @@ This command should show you which version of GHC you have. If the installation
 of the Haskell Platform	 was successful you should see a message like:
 
 ```
-The Glorious Glasgow Haskell Compilation System, version 8.0.2
+The Glorious Glasgow Haskell Compilation System, version 7.8.3
 ```
 
-Other required tools included in the Haskell Platform are
+Other required tools included in the Haskell Platform are 
 [Cabal http://www.haskell.org/cabal/],
 [Alex http://www.haskell.org/alex/]
 and
 [Happy http://www.haskell.org/happy/].
 
-=== Git ===
+=== Darcs ===
+
+To get the GF source code, you also need //Darcs//, version 2 or later.
+Darcs 2.10 is recommended (July 2015).
+
+//Darcs//
+is a distributed version control system, see http://darcs.net/ for
+more information. There are precompiled packages for many platforms
+available and source code if you want to compile it yourself. Darcs
+is also written in Haskell and so you can use GHC to compile it.
 
-To get the GF source code, you also need //Git//.
-//Git// is a distributed version control system, see
-https://git-scm.com/downloads for more information.
 
 === The haskeline library ===
 
@@ -69,7 +83,7 @@ extra step is needed to make sure the C libraries (terminfo)
 required by //haskeline// are installed.  Here is one way to do this:
 
 - On Ubuntu: ``sudo apt-get install libghc-haskeline-dev``
-- On Fedora: ``sudo dnf install ghc-haskeline-devel``
+- On Fedora: ``sudo yum install ghc-haskeline-devel``
 
 
 == Getting the source ==
@@ -85,23 +99,25 @@ GF then you should consider getting read-write access.
 
 ==== Getting a fresh copy for read-only access ====
 
-Anyone can get the latest development version of GF by running:
+Anyone can get the latest development version of GF by running (all on one line):
 
 ```
-$ git clone https://github.com/GrammaticalFramework/gf-core.git
-$ git clone https://github.com/GrammaticalFramework/gf-rgl.git
+$ darcs get --lazy --set-scripts-executable http://www.grammaticalframework.org/ gf
 ```
 
-This will create directories ``gf-core`` and ``gf-rgl`` in the current directory.
+This will create a directory called ``gf`` in the current
+directory.
 
 
 ==== Updating your copy ====
 
-To get all new patches from each repo:
+To get all new patches from the main repo:
 ```
-$ git pull
+$ darcs pull -a
 ```
-This can be done anywhere in your local repository.
+This can be done anywhere in your local repository, i.e. in the ``gf``
+directory, or any of its subdirectories.
+Without ``-a``, you can choose which patches you want to get.
 
 
 ==== Recording local changes ====[record]
@@ -109,17 +125,17 @@ This can be done anywhere in your local repository.
 Since every copy is a repository, you can have local version control
 of your changes.
 
-If you have added files, you first need to tell your local repository to
+If you have added files, you first need to tell your local repository to 
 keep them under revision control:
 
 ```
-$ git add file1 file2 ...
+$ darcs add file1 file2 ...
 ```
 
 To record changes, use:
 
 ```
-$ git commit file1 file2 ...
+$ darcs record
 ```
 
 This creates a patch against the previous version and stores it in your
@@ -127,27 +143,105 @@ local repository. You can record any number of changes before
 pushing them to the main repo. In fact, you don't have to push them at
 all if you want to keep the changes only in your local repo.
 
-Instead of enumerating all modified files on the command line,
-you can use the flag ``-a`` to automatically record //all// modified
-files. You still need to use ``git add`` to add new files.
+If you think there are too many questions about what to record, you
+can answer ``f`` to record all remaining changes in the current file,
+or ``s`` to skip them. Use ``?`` to get a list of more options.
+%use the ``-a`` flag to ``record``. Or answer ``a`` to the first
+%question. Both of these record all the changes you have in your local
+%repository.
+
+
+==== Submitting patches ====
+
+If you are using read-only access, send your patches by email to
+someone with write-access. First record your changes in your local 
+repository, as described above. You can send any number of recorded
+patches as one patch bundle. You create the patch bundle with:
+
+```
+$ darcs send -o mypatch.patch
+$ gzip mypatch.patch
+```
+
+(where ``mypatch`` is hopefully replaced by a slightly more
+descriptive name). Since some e-mail setups change text attachments
+(most likely by changing the newline characters) you need to send
+the patch in some compressed format, such as GZIP, BZIP2 or ZIP.
+
+Send it as an e-mail attachment.
+% If you have
+%sendmail or something equivalent installed, it is possible to send the
+%patch directly from darcs. If so, replace ``-o mypatch.patch`` with
+%``--to=EMAIL`` where ``EMAIL`` is the address to send it to.
+
+
+
 
 
 === Read-write access ===
 
-If you are a member of the GF project on GitHub, you can push your
-changes directly to the GF git repository on GitHub.
+If you have a user account on ``www.grammaticalframework.org``, you can
+get read-write access over SSH to the GF repository.
+
+
+==== Getting a fresh copy ====
+
+Get your copy with (all on one line),
+replacing ``user`` with your own user name on ``www.grammaticalframework.org``:
 
 ```
-$ git push
+$ darcs get --lazy --set-scripts-executable user@www.grammaticalframework.org:/usr/local/www/GF/ gf
 ```
 
-It is also possible for anyone else to contribute by
+The option ``--lazy`` means that darcs defers downloading all the
+history for the repository. This saves space, bandwidth and CPU time,
+and most people don't need the full history of all changes in the
+past.
 
-- creating a fork of the GF repository on GitHub,
-- working with local clone of the fork (obtained with ``git clone``),
-- pushing changes to the fork,
-- and finally sending a pull request.
 
+==== Updating your copy ====
+
+Get all new patches from the main repo:
+
+```
+$ darcs pull
+```
+
+You can add ``-a`` to get all patches without answering yes/no to each patch.
+
+
+
+==== Commit your changes ====
+
+There are two steps to commiting a change to the main repo. First you
+have to record the changes that you want to commit
+(see [Recording local changes #record] above), then you push them
+to the main repo. If you are using ssh-access, all you need to do is:
+
+```
+$ darcs push
+```
+
+If you use the ``-a`` flag to push, all local patches which are not in
+the main repo are pushed.
+
+
+
+==== Apply a patch from someone else ====
+
+Use:
+
+```
+$ darcs apply < mypatch.patch
+```
+
+This applies the patch to your local repository. To commit it to the
+main repo, use ``darcs push``.
+
+=== Further information about Darcs ===
+
+
+For more info about what you can do with darcs, see http://darcs.net/manual/
 
 
 == Compilation from source with Cabal ==
@@ -158,6 +252,7 @@ case, all you need to do to compile and install GF, after downloading the
 source code as described above, is
 
 ```
+$ cd gf
 $ cabal install
 ```
 
@@ -391,28 +486,6 @@ bindings are found in the ``src/runtime/python`` and ``src/runtime/java``
 directories, respecively. Compile them by following the instructions in
 the ``INSTALL`` files in those directories.
 
-== Compilation of RGL ==
-
-As of 2018-07-26, the RGL is distributed separately from the GF compiler and runtimes.
-
-=== Simple ===
-To install the RGL, you can use the following commands from within the ``gf-rgl`` repository:
-```
-$ make install
-```
-There is also ``make build``, ``make copy`` and ``make clean`` which do what you might expect.
-
-=== Advanced ===
-For advanced build options, call the Haskell build script directly:
-```
-$ runghc Setup.hs ...
-```
-For more details see the [README https://github.com/GrammaticalFramework/gf-rgl/blob/master/README.md].
-
-=== Haskell-free ===
-If you do not have Haskell installed, you can use the simple build script ``Setup.sh``
-(or ``Setup.bat`` for Windows).
-
 
 == Creating binary distribution packages ==
 
@@ -469,7 +542,7 @@ This is possible, but the procedure has not been automated.
 It involves using the cabal-rpm tool,
 
 ```
-sudo dnf install cabal-rpm
+sudo yum install cabal-rpm
 ```
 
 and following the Fedora guide
@@ -495,7 +568,7 @@ $ cabal test
 ```
 The testsuite architecture for GF is very simple but still very flexible.
 GF by itself is an interpreter and could execute commands in batch mode.
-This is everything that we need to organize a testsuite. The root of the
+This is everything that we need to organize a testsuite. The root of the 
 testsuite is the testsuite/ directory. It contains subdirectories which
 themself contain GF batch files (with extension .gfs). The above command
 searches the subdirectories of the testsuite/ directory for files with extension

doc/gf-editor-modes.t2t

@@ -1,27 +1,31 @@
 Editor modes & IDE integration for GF
 
 
+%!style:../css/style.css
+%!options(html): --toc
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!encoding:utf-8
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 We collect GF modes for various editors on this page. Contributions are
 welcome!
 
 
 ==Emacs==
 
-[gf.el https://github.com/GrammaticalFramework/gf-emacs-mode] by Johan
-Bockgård provides syntax highlighting and automatic indentation and
-lets you run the GF Shell in an emacs buffer.  See installation
-instructions inside.
-
-==Atom==
-[language-gf https://atom.io/packages/language-gf], by John J. Camilleri
+[gf.el ../src/tools/gf.el] by Johan Bockgård provides syntax highlighting and
+automatic indentation and lets you run the GF Shell in an emacs buffer.
+See installation instructions inside.
 
 ==Eclipse==
 
-[GF Eclipse Plugin https://github.com/GrammaticalFramework/gf-eclipse-plugin/], by John J. Camilleri
+[GF Eclipse Plugin http://www.grammaticalframework.org/eclipse/index.html]
 
 ==Gedit==
 
-By John J. Camilleri
+[John J. Camilleri http://johnjcamilleri.com/]
+provided the following syntax highlighting mode for
+[Gedit http://www.gedit.org/] (the default text editor in Ubuntu).
 
 Copy the file below to
 ``~/.local/share/gtksourceview-3.0/language-specs/gf.lang`` (under Ubuntu).
@@ -33,7 +37,7 @@ Some helpful notes/links:
 
 - The code is based heavily on the ``haskell.lang`` file which I found in
   ``/usr/share/gtksourceview-2.0/language-specs/haskell.lang``.
-- Ruslan Osmanov recommends
+- Ruslan Osmanov recommends 
   [registering your file extension as its own MIME type http://osmanov-dev-notes.blogspot.com/2011/04/how-to-add-new-highlight-mode-in-gedit.html]
   (see also [here https://help.ubuntu.com/community/AddingMimeTypes]),
   however on my system the ``.gf`` extension was already registered
@@ -47,9 +51,8 @@ Some helpful notes/links:
 
 ==Geany==
 
-By John J. Camilleri
-
-[Custom filetype http://www.geany.org/manual/dev/index.html#custom-filetypes]
+[John J. Camilleri http://johnjcamilleri.com/] provided the following
+[custom filetype http://www.geany.org/manual/dev/index.html#custom-filetypes]
 config files for syntax highlighting in [Geany http://www.geany.org/].
 
 Copy one of the files below to ``/usr/share/geany/filetypes.GF.conf``

doc/gf-faq.t2t

@@ -0,0 +1,91 @@
+Grammatical Framework: Frequently Asked Quuestions
+Aarne Ranta
+%%date(%c)
+
+% NOTE: this is a txt2tags file.
+% Create an html file from this file using:
+% txt2tags gf-bibliography.t2t
+
+%!style:../css/style.css
+%!target:html
+%!options(html): --toc
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): #BR <br>
+%!encoding:utf-8
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
+
+===What has been done with GF?===
+
+**Translation**: systems with any number of parallel languages, with input in one language and output in all the others.
+
+**Natural language generation** (NLG): translation from a formal language to natural languages.
+
+**Ontology verbalization** is a special case of NLG.
+
+**Language training**: grammar and vocabulary training systems.
+
+**Human-computer interaction**: natural language interfaces, spoken dialogue systems.
+
+**Linguistics**: comparisons between languages.
+
+
+
+===What parts does GF have?===
+
+A **grammar compiler**, used for compiling grammars to parsing, generation, and translation code. 
+
+A **run-time system**, used for parsing, generation and translation. The run-time system is available in several languages:
+Haskell, Java, C, C++, Javascript, and Python. The point with this is that you can include GF-based parsing and generation in 
+larger programs written in any of these languages.
+
+A **resource grammar library**, containing the morphology and basic syntax of currently 26 languages.
+
+A **web application toolkit**, containing server-side (Haskell) and client-side (Javascript) libraries.
+
+An **integrated development environment**, the GF-Eclipse plug-in.
+
+A **shell**, i.e. a command interpreter for testing and developing GF grammars. This is the program started by the command ``gf`` in a terminal.
+
+
+
+===Is GF open-source?===
+
+
+===Can I use GF for commercial applications?===
+
+Yes. Those parts of GF that you will need to distribute - the run-time system and the libraries - are licensed under LGPL and BSD; it's up to you to choose which. 
+
+
+
+===When was GF started?===
+
+
+===Where does the name GF come from?===
+
+GF = Grammatical Framework = LF + concrete syntax
+
+LF = Logical Framework
+
+Logical Frameworks are implementations of type theory, which have been built since the 1980's to support formalized mathematics. GF has its roots in
+type theory, which is widely used in the semantics of natural language. Some of these ideas were first implemented in ALF, Another Logical Framework,
+in 1992; the book //Type-Theoretical Grammar// (by A. Ranta, OUP 1994) has a chapter and an appendix on this. The first implementations did not have
+a parser, and GF proper, started in 1998, was an implementation of yet another LF together with concrete syntax supporting generation and parsing.
+Grammatical Framework was a natural name for this. We tried to avoid it in the beginning, because it sounded pretentious in its generality. But the
+name was just too natural to be avoided. 
+
+
+
+===Is GF backward compatible?===
+
+
+
+===Do I need Haskell to use GF?===
+
+No. GF is a language of its own, and you don't need to know Haskell. And if you download the GF binary, you don't need any Haskell tools. But if you want to
+become a GF developer, then it's better you install GF from the latest source, and then you need the GHC Haskell compiler to compile GF. But even then, you
+don't need to know Haskell yourself.
+
+
+===What is a lock field?===
+

doc/gf-help-full.txt

@@ -68,9 +68,9 @@ metavariables and the type of the expression.
 Prints a set of strings in the .dot format (the graphviz format).
 The graph can be saved in a file by the wf command as usual.
 If the -view flag is defined, the graph is saved in a temporary file
-which is processed by 'dot' (graphviz) and displayed by the program indicated
-by the view flag. The target format is png, unless overridden by the
-flag -format. Results from multiple trees are combined to pdf with convert (ImageMagick).
+which is processed by graphviz and displayed by the program indicated
+by the flag. The target format is postscript, unless overridden by the
+flag -format.
 
 
 - Options:
@@ -151,7 +151,6 @@ of a pipe.
  | ``-one`` | pick the first strings, if there is any, from records and tables
  | ``-table`` | show all strings labelled by parameters
  | ``-unqual`` | hide qualifying module names
- | ``-trace`` | trace computations
 
 
 #NORMAL
@@ -243,7 +242,7 @@ and thus cannot be a part of a pipe.
 
 ====e = empty====
 #NOINDENT
-``e`` = ``empty``: //empty the environment (except the command history).//
+``e`` = ``empty``: //empty the environment.//
 
 #TINY
 
@@ -282,19 +281,6 @@ but the resulting .gf file must be imported separately.
 #NORMAL
 
 
-#VSPACE
-
-====eh = execute_history====
-#NOINDENT
-``eh`` = ``execute_history``: //read commands from a file and execute them.//
-
-#TINY
-
-- Syntax: ``eh FILE``
-
-#NORMAL
-
-
 #VSPACE
 
 ====gr = generate_random====
@@ -448,14 +434,12 @@ sequences; see example.
  | ``-list`` | show all forms and variants, comma-separated on one line (cf. l -all)
  | ``-multi`` | linearize to all languages (default)
  | ``-table`` | show all forms labelled by parameters
- | ``-tabtreebank`` | show the tree and its linearizations on a tab-separated line
  | ``-treebank`` | show the tree and tag linearizations with language names
  | ``-bind`` | bind tokens separated by Prelude.BIND, i.e. &+
  | ``-chars`` | lexer that makes every non-space character a token
  | ``-from_amharic`` | from unicode to GF Amharic transliteration
  | ``-from_ancientgreek`` | from unicode to GF ancient Greek transliteration
  | ``-from_arabic`` | from unicode to GF Arabic transliteration
- | ``-from_arabic_unvocalized`` | from unicode to GF unvocalized Arabic transliteration
  | ``-from_cp1251`` | decode from cp1251 (Cyrillic used in Bulgarian resource)
  | ``-from_devanagari`` | from unicode to GF Devanagari transliteration
  | ``-from_greek`` | from unicode to GF modern Greek transliteration
@@ -469,14 +453,11 @@ sequences; see example.
  | ``-from_urdu`` | from unicode to GF Urdu transliteration
  | ``-from_utf8`` | decode from utf8 (default)
  | ``-lexcode`` | code-like lexer
- | ``-lexgreek`` | lexer normalizing ancient Greek accentuation
- | ``-lexgreek2`` | lexer normalizing ancient Greek accentuation for text with vowel length annotations
  | ``-lexmixed`` | mixture of text and code, as in LaTeX (code between $...$, \(...)\, \[...\])
  | ``-lextext`` | text-like lexer
  | ``-to_amharic`` | from GF Amharic transliteration to unicode
  | ``-to_ancientgreek`` | from GF ancient Greek transliteration to unicode
  | ``-to_arabic`` | from GF Arabic transliteration to unicode
- | ``-to_arabic_unvocalized`` | from GF unvocalized Arabic transliteration to unicode
  | ``-to_cp1251`` | encode to cp1251 (Cyrillic used in Bulgarian resource)
  | ``-to_devanagari`` | from GF Devanagari transliteration to unicode
  | ``-to_greek`` | from GF modern Greek transliteration to unicode
@@ -492,7 +473,6 @@ sequences; see example.
  | ``-to_utf8`` | encode to utf8 (default)
  | ``-unchars`` | unlexer that puts no spaces between tokens
  | ``-unlexcode`` | code-like unlexer
- | ``-unlexgreek`` | unlexer de-normalizing ancient Greek accentuation
  | ``-unlexmixed`` | mixture of text and code (code between $...$, \(...)\, \[...\])
  | ``-unlextext`` | text-like unlexer
  | ``-unwords`` | unlexer that puts a single space between tokens (default)
@@ -533,7 +513,6 @@ trees where a function node is a metavariable.
  | ``-from_amharic`` | from unicode to GF Amharic transliteration
  | ``-from_ancientgreek`` | from unicode to GF ancient Greek transliteration
  | ``-from_arabic`` | from unicode to GF Arabic transliteration
- | ``-from_arabic_unvocalized`` | from unicode to GF unvocalized Arabic transliteration
  | ``-from_cp1251`` | decode from cp1251 (Cyrillic used in Bulgarian resource)
  | ``-from_devanagari`` | from unicode to GF Devanagari transliteration
  | ``-from_greek`` | from unicode to GF modern Greek transliteration
@@ -547,14 +526,11 @@ trees where a function node is a metavariable.
  | ``-from_urdu`` | from unicode to GF Urdu transliteration
  | ``-from_utf8`` | decode from utf8 (default)
  | ``-lexcode`` | code-like lexer
- | ``-lexgreek`` | lexer normalizing ancient Greek accentuation
- | ``-lexgreek2`` | lexer normalizing ancient Greek accentuation for text with vowel length annotations
  | ``-lexmixed`` | mixture of text and code, as in LaTeX (code between $...$, \(...)\, \[...\])
  | ``-lextext`` | text-like lexer
  | ``-to_amharic`` | from GF Amharic transliteration to unicode
  | ``-to_ancientgreek`` | from GF ancient Greek transliteration to unicode
  | ``-to_arabic`` | from GF Arabic transliteration to unicode
- | ``-to_arabic_unvocalized`` | from GF unvocalized Arabic transliteration to unicode
  | ``-to_cp1251`` | encode to cp1251 (Cyrillic used in Bulgarian resource)
  | ``-to_devanagari`` | from GF Devanagari transliteration to unicode
  | ``-to_greek`` | from GF modern Greek transliteration to unicode
@@ -570,7 +546,6 @@ trees where a function node is a metavariable.
  | ``-to_utf8`` | encode to utf8 (default)
  | ``-unchars`` | unlexer that puts no spaces between tokens
  | ``-unlexcode`` | code-like unlexer
- | ``-unlexgreek`` | unlexer de-normalizing ancient Greek accentuation
  | ``-unlexmixed`` | mixture of text and code (code between $...$, \(...)\, \[...\])
  | ``-unlextext`` | text-like unlexer
  | ``-unwords`` | unlexer that puts a single space between tokens (default)
@@ -691,9 +666,10 @@ command (flag -printer):
  fa		finite automaton in graphviz format
  gsl		Nuance speech recognition format
  haskell		Haskell (abstract syntax)
- java		Java (abstract syntax)
  js		JavaScript (whole grammar)
  jsgf		JSGF speech recognition format
+ lambda_prolog		LambdaProlog (abstract syntax)
+ lp_byte_code		Bytecode for Teyjus (abstract syntax, experimental)
  pgf_pretty		human-readable pgf
  prolog		Prolog (whole grammar)
  python		Python (whole grammar)
@@ -777,7 +753,6 @@ To see transliteration tables, use command ut.
  | ``-from_amharic`` | from unicode to GF Amharic transliteration
  | ``-from_ancientgreek`` | from unicode to GF ancient Greek transliteration
  | ``-from_arabic`` | from unicode to GF Arabic transliteration
- | ``-from_arabic_unvocalized`` | from unicode to GF unvocalized Arabic transliteration
  | ``-from_cp1251`` | decode from cp1251 (Cyrillic used in Bulgarian resource)
  | ``-from_devanagari`` | from unicode to GF Devanagari transliteration
  | ``-from_greek`` | from unicode to GF modern Greek transliteration
@@ -791,14 +766,11 @@ To see transliteration tables, use command ut.
  | ``-from_urdu`` | from unicode to GF Urdu transliteration
  | ``-from_utf8`` | decode from utf8 (default)
  | ``-lexcode`` | code-like lexer
- | ``-lexgreek`` | lexer normalizing ancient Greek accentuation
- | ``-lexgreek2`` | lexer normalizing ancient Greek accentuation for text with vowel length annotations
  | ``-lexmixed`` | mixture of text and code, as in LaTeX (code between $...$, \(...)\, \[...\])
  | ``-lextext`` | text-like lexer
  | ``-to_amharic`` | from GF Amharic transliteration to unicode
  | ``-to_ancientgreek`` | from GF ancient Greek transliteration to unicode
  | ``-to_arabic`` | from GF Arabic transliteration to unicode
- | ``-to_arabic_unvocalized`` | from GF unvocalized Arabic transliteration to unicode
  | ``-to_cp1251`` | encode to cp1251 (Cyrillic used in Bulgarian resource)
  | ``-to_devanagari`` | from GF Devanagari transliteration to unicode
  | ``-to_greek`` | from GF modern Greek transliteration to unicode
@@ -814,7 +786,6 @@ To see transliteration tables, use command ut.
  | ``-to_utf8`` | encode to utf8 (default)
  | ``-unchars`` | unlexer that puts no spaces between tokens
  | ``-unlexcode`` | code-like unlexer
- | ``-unlexgreek`` | unlexer de-normalizing ancient Greek accentuation
  | ``-unlexmixed`` | mixture of text and code (code between $...$, \(...)\, \[...\])
  | ``-unlextext`` | text-like unlexer
  | ``-unwords`` | unlexer that puts a single space between tokens (default)
@@ -828,14 +799,13 @@ To see transliteration tables, use command ut.
 
 - Examples:
 
- | ``l (EAdd 3 4) | ps -unlexcode`` | linearize code-like output
- | ``ps -lexcode | p -cat=Exp`` | parse code-like input
+ | ``l (EAdd 3 4) | ps -code`` | linearize code-like output
+ | ``ps -lexer=code | p -cat=Exp`` | parse code-like input
  | ``gr -cat=QCl | l | ps -bind`` | linearization output from LangFin
  | ``ps -to_devanagari "A-p"`` | show Devanagari in UTF8 terminal
  | ``rf -file=Hin.gf | ps -env=quotes -to_devanagari`` | convert translit to UTF8
  | ``rf -file=Ara.gf | ps -from_utf8 -env=quotes -from_arabic`` | convert UTF8 to transliteration
  | ``ps -to=chinese.trans "abc"`` | apply transliteration defined in file chinese.trans
- | ``ps -lexgreek "a)gavoi` a)'nvrwpoi' tines*"`` | normalize ancient greek accentuation
 
 
 #NORMAL
@@ -858,6 +828,7 @@ are type checking and semantic computation.
 - Options:
 
  | ``-compute`` | compute by using semantic definitions (def)
+ | ``-paraphrase`` | paraphrase by using semantic definitions (def)
  | ``-largest`` | sort trees from largest to smallest, in number of nodes
  | ``-nub`` | remove duplicate trees
  | ``-smallest`` | sort trees from smallest to largest, in number of nodes
@@ -867,10 +838,12 @@ are type checking and semantic computation.
 - Flags:
 
  | ``-number`` | take at most this many trees
+ | ``-transfer`` | syntactic transfer by applying function, recursively in subtrees
 
 - Examples:
 
  | ``pt -compute (plus one two)`` | compute value
+ | ``p "4 dogs love 5 cats" | pt -transfer=digits2numeral | l`` | four...five...
 
 
 #NORMAL
@@ -1017,6 +990,8 @@ This command requires a source grammar to be in scope, imported with 'import -re
 The operations include the parameter constructors that are in scope.
 The optional TYPE filters according to the value type.
 The grep STRINGs filter according to other substrings of the type signatures.
+This command must be a line of its own, and thus cannot be a part
+of a pipe.
 
 - Syntax: ``so (-grep=STRING)* TYPE?``
 - Options:
@@ -1027,12 +1002,6 @@ The grep STRINGs filter according to other substrings of the type signatures.
 
  | ``-grep`` | substring used for filtering (the command can have many of these)
 
-- Examples:
-
- | ``so Det`` | show all opers that create a Det
- | ``so -grep=Prep`` | find opers relating to Prep
- | ``so | wf -file=/tmp/opers`` | write the list of opers to a file
-
 
 #NORMAL
 
@@ -1144,7 +1113,6 @@ This command must be a line of its own, and thus cannot be a part of a pipe.
  | ``-amharic`` | Amharic
  | ``-ancientgreek`` | ancient Greek
  | ``-arabic`` | Arabic
- | ``-arabic_unvocalized`` | unvocalized Arabic
  | ``-devanagari`` | Devanagari
  | ``-greek`` | modern Greek
  | ``-hebrew`` | unvocalized Hebrew
@@ -1169,41 +1137,35 @@ This command must be a line of its own, and thus cannot be a part of a pipe.
 #TINY
 
 Prints a dependency tree in the .dot format (the graphviz format, default)
-or LaTeX (flag -output=latex)
 or the CoNLL/MaltParser format (flag -output=conll for training, malt_input
 for unanalysed input).
 By default, the last argument is the head of every abstract syntax
 function; moreover, the head depends on the head of the function above.
 The graph can be saved in a file by the wf command as usual.
 If the -view flag is defined, the graph is saved in a temporary file
-which is processed by dot (graphviz) and displayed by the program indicated
-by the view flag. The target format is png, unless overridden by the
-flag -format. Results from multiple trees are combined to pdf with convert (ImageMagick).
-See also 'vp -showdep' for another visualization of dependencies.
+which is processed by graphviz and displayed by the program indicated
+by the flag. The target format is png, unless overridden by the
+flag -format.
 
 
 - Options:
 
  | ``-v`` | show extra information
- | ``-conll2latex`` | convert conll to latex
 
 - Flags:
 
- | ``-abslabels`` | abstract configuration file for labels, format per line 'fun label*'
- | ``-cnclabels`` | concrete configuration file for labels, format per line 'fun {words|*} pos label head'
- | ``-file`` | same as abslabels (abstract configuration file)
- | ``-format`` | format of the visualization file using dot (default "png")
- | ``-output`` | output format of graph source (latex, conll, dot (default but deprecated))
- | ``-view`` | program to open the resulting graph file (default "open")
+ | ``-file`` | configuration file for labels per fun, format 'fun l1 ... label ... l2'
+ | ``-format`` | format of the visualization file (default "png")
+ | ``-output`` | output format of graph source (default "dot")
+ | ``-view`` | program to open the resulting file (default "open")
  | ``-lang`` | the language of analysis
 
 - Examples:
 
  | ``gr | vd`` | generate a tree and show dependency tree in .dot
- | ``gr | vd -view=open`` | generate a tree and display dependency tree on with Mac's 'open'
- | ``gr | vd -view=open -output=latex`` | generate a tree and display latex dependency tree with Mac's 'open'
- | ``gr -number=1000 | vd -abslabels=Lang.labels -cnclabels=LangSwe.labels -output=conll`` | generate a random treebank
- | ``rf -file=ex.conll | vd -conll2latex | wf -file=ex.tex`` | convert conll file to latex
+ | ``gr | vd -view=open`` | generate a tree and display dependency tree on a Mac
+ | ``gr -number=1000 | vd -file=dep.labels -output=malt`` | generate training treebank
+ | ``gr -number=100 | vd -file=dep.labels -output=malt_input`` | generate test sentences
 
 
 #NORMAL
@@ -1220,16 +1182,15 @@ See also 'vp -showdep' for another visualization of dependencies.
 Prints a parse tree in the .dot format (the graphviz format).
 The graph can be saved in a file by the wf command as usual.
 If the -view flag is defined, the graph is saved in a temporary file
-which is processed by dot (graphviz) and displayed by the program indicated
-by the view flag. The target format is png, unless overridden by the
-flag -format. Results from multiple trees are combined to pdf with convert (ImageMagick).
+which is processed by graphviz and displayed by the program indicated
+by the flag. The target format is png, unless overridden by the
+flag -format.
 
 
 - Options:
 
  | ``-showcat`` | show categories in the tree nodes (default)
  | ``-nocat`` | don't show categories
- | ``-showdep`` | show dependency labels
  | ``-showfun`` | show function names in the tree nodes
  | ``-nofun`` | don't show function names (default)
  | ``-showleaves`` | show the leaves of the tree (default)
@@ -1237,8 +1198,6 @@ flag -format. Results from multiple trees are combined to pdf with convert (Imag
 
 - Flags:
 
- | ``-lang`` | the language to visualize
- | ``-file`` | configuration file for dependency labels with -deps, format per line 'fun label*'
  | ``-format`` | format of the visualization file (default "png")
  | ``-view`` | program to open the resulting file (default "open")
  | ``-nodefont`` | font for tree nodes (default: Times -- graphviz standard font)
@@ -1251,8 +1210,7 @@ flag -format. Results from multiple trees are combined to pdf with convert (Imag
 - Examples:
 
  | ``p "John walks" | vp`` | generate a tree and show parse tree as .dot script
- | ``gr | vp -view=open`` | generate a tree and display parse tree on a Mac
- | ``p "she loves us" | vp -view=open -showdep -file=uddeps.labels -nocat`` | show a visual variant of a dependency tree
+ | ``gr | vp -view="open"`` | generate a tree and display parse tree on a Mac
 
 
 #NORMAL
@@ -1269,9 +1227,9 @@ flag -format. Results from multiple trees are combined to pdf with convert (Imag
 Prints a set of trees in the .dot format (the graphviz format).
 The graph can be saved in a file by the wf command as usual.
 If the -view flag is defined, the graph is saved in a temporary file
-which is processed by dot (graphviz) and displayed by the command indicated
-by the view flag. The target format is postscript, unless overridden by the
-flag -format. Results from multiple trees are combined to pdf with convert (ImageMagick).
+which is processed by graphviz and displayed by the program indicated
+by the flag. The target format is postscript, unless overridden by the
+flag -format.
 With option -mk, use for showing library style function names of form 'mkC'.
 
 

doc/gf-people.html

@@ -0,0 +1,132 @@
+<!DOCTYPE html>
+<html> 
+
+<head>
+<title>GF People</title>
+<meta charset="UTF-8">
+<link rel=stylesheet href="../css/style.css">
+<meta name = "viewport" content = "width = device-width">
+</head>
+
+<body>
+
+<center>
+<IMG SRC="Logos/gf0.png" alt="[GF]">
+
+<h1>Grammatical Framework: Authors and Acknowledgements</h1>
+
+</center>
+
+The current developers and maintainers are
+<a href="http://www.chalmers.se/cse/EN/organization/divisions/computing-science/people/angelov-krasimir">Krasimir Angelov</a>,
+<a href="http://www.cse.chalmers.se/~hallgren/">Thomas Hallgren</a>,
+and
+<a href="http://www.cse.chalmers.se/~aarne/">Aarne Ranta</a>. Bug reports should be
+posted via the
+<a href="http://code.google.com/p/grammatical-framework/issues/list">GF bug tracker</a>.
+
+
+<p>
+
+Also the following people have contributed code to some of the versions:
+
+<dl>
+
+<dt>Grégoire Détrez (University of Gothenburg)
+<dt>Ramona Enache (University of Gothenburg)
+<dt>
+<a href="http://www.cse.chalmers.se/alumni/bringert">Björn Bringert</a> (University of Gothenburg)
+<dt>
+Håkan Burden (University of Gothenburg)
+<dt>
+Hans-Joachim Daniels (Karlsruhe)
+<dt>
+<a href="http://www.cs.chalmers.se/~markus">Markus Forsberg</a> (Chalmers)
+<dt>
+<a href="http://www.cs.chalmers.se/~krijo">Kristofer Johannisson</a> (University of Gothenburg)
+<dt>
+<a href="http://www.cs.chalmers.se/~janna">Janna Khegai</a> (Chalmers)
+<dt>
+<a href="http://www.cse.chalmers.se/~peb">Peter Ljunglöf</a> (University of Gothenburg)
+<dt>
+Petri Mäenpää (Nokia)
+</dl>
+
+
+At least the following colleagues are thanked for suggestions,
+bug reports, and other indirect contributions to the code. (Notice:
+these are early contributors - the list has not been updated since 2004 or so).
+
+<p>
+
+<a href="http://www.di.unito.it/~stefano/">Stefano Berardi</a> (Torino),
+
+Pascal Boldini (Paris),
+
+<a href="http://www.dur.ac.uk/~dcs0pcc/">Paul Callaghan</a> (Durham),
+
+Lauri Carlson (Helsinki),
+
+<a href="http://www.cse.chalmers.se/~koen">Koen Claessen</a> (Chalmers),
+
+<a href="http://www.cling.gu.se/~cooper">Robin Cooper</a> (Gothenburg),
+
+<a href="http://www.cse.chalmers.se/~coquand">Thierry Coquand</a> (Chalmers),
+
+<a
+href="http://www.xrce.xerox.com/people/dymetman/dymetman.html">Marc
+Dymetman</a> (XRCE),
+
+Bertrand Grégoire (Tudor Institure, Luxembourg),
+
+<a href="http://www.cse.chalmers.se/~reiner">Reiner Hähnle</a> (Chalmers),
+
+<a href="http://pauillac.inria.fr/~huet/">Gérard Huet</a> (INRIA),
+
+<a href="http://www.cse.chalmers.se/~patrikj">Patrik Jansson</a> (Chalmers),
+
+Bernard Jaulin (Paris),
+
+<a href="http://www.xrce.xerox.com/people/karttunen/karttunen.html">
+Lauri Karttunen</a> (PARC),
+
+Matti Kinnunen (Nokia),
+
+<a
+href="http://www.xrce.xerox.com/people/lux/">Veronika
+Lux</a> (XRCE),
+
+Per Martin-Löf (Stockholm),
+
+<a href="http://www.cse.chalmers.se/~bengt">Bengt Nordström</a> (Chalmers),
+
+<a
+href="http://www.cis.uni-muenchen.de/studenten/stud_homepages/okrslar/reklame.html">
+Martin Okrslar</a> (CIS),
+
+Jianmin Pang (Durham),
+
+<a
+href="http://www.xrce.xerox.com/people/pogodalla/index.fr.html">Sylvain
+Pogodalla</a> (XRCE),
+
+<a href="http://www.inria.fr/Loic.Pottier">Loïc Pottier</a> (INRIA),
+
+
+<a href="http://www2.parc.com/istl/members/zaenen/">Annie Zaenen</a> (PARC)
+
+<p>
+
+The GF logo was designed by Uula Ranta.
+
+<p>
+
+From 2001 to 2004, GF enjoyed funding from the
+<a href="http://www.vinnova.se">Vinnova</a> foundation, within the
+<a href="http://www.cse.chalmers.se/research/group/Language-technology/ILT.html">
+Interactive Languge Technology</a> project.
+
+
+</body>
+</html> 
+

doc/gf-people.md

@@ -1,63 +0,0 @@
----
-title: "Grammatical Framework: Authors and Acknowledgements"
----
-
-## Current maintainers
-
-The current maintainers of GF are
-
-[Krasimir Angelov](http://www.chalmers.se/cse/EN/organization/divisions/computing-science/people/angelov-krasimir),
-[Thomas Hallgren](http://www.cse.chalmers.se/~hallgren/),
-[Aarne Ranta](http://www.cse.chalmers.se/~aarne/),
-[John J. Camilleri](http://johnjcamilleri.com), and
-[Inari Listenmaa](https://inariksit.github.io/).
-
-This page is otherwise not up to date.
-For detailed data about contributors to the code repositories since 2007, see
-[here (gf-core)](https://github.com/GrammaticalFramework/gf-core/graphs/contributors)
-and
-[here (gf-rgl)](https://github.com/GrammaticalFramework/gf-rgl/graphs/contributors).
-
-## Previous contributors
-
-The following people have contributed code to some of the versions:
-
-- Grégoire Détrez (University of Gothenburg)
-- Ramona Enache (University of Gothenburg)
-- [Björn Bringert](http://www.cse.chalmers.se/alumni/bringert) (University of Gothenburg)
-- Håkan Burden (University of Gothenburg)
-- Hans-Joachim Daniels (Karlsruhe)
-- [Markus Forsberg](http://www.cs.chalmers.se/~markus) (Chalmers)
-- [Kristofer Johannisson](http://www.cs.chalmers.se/~krijo) (University of Gothenburg)
-- [Janna Khegai](http://www.cs.chalmers.se/~janna) (Chalmers)
-- [Peter Ljunglöf](http://www.cse.chalmers.se/~peb) (University of Gothenburg)
-- Petri Mäenpää (Nokia)
-
-At least the following colleagues are thanked for suggestions, bug
-reports, and other indirect contributions to the code.
-
-- [Stefano Berardi](http://www.di.unito.it/~stefano/) (Torino)
-- Pascal Boldini (Paris)
-- [Paul Callaghan](http://www.dur.ac.uk/~dcs0pcc/) (Durham)
-- Lauri Carlson (Helsinki)
-- [Koen Claessen](http://www.cse.chalmers.se/~koen) (Chalmers)
-- [Robin Cooper](http://www.cling.gu.se/~cooper) (Gothenburg)
-- [Thierry Coquand](http://www.cse.chalmers.se/~coquand) (Chalmers)
-- [Marc Dymetman](http://www.xrce.xerox.com/people/dymetman/dymetman.html) (XRCE)
-- Bertrand Grégoire (Tudor Institute, Luxembourg)
-- [Reiner Hähnle](http://www.cse.chalmers.se/~reiner) (Chalmers)
-- [Gérard Huet](http://pauillac.inria.fr/~huet/) (INRIA)
-- [Patrik Jansson](http://www.cse.chalmers.se/~patrikj) (Chalmers)
-- Bernard Jaulin (Paris)
-- [Lauri Karttunen](http://www.xrce.xerox.com/people/karttunen/karttunen.html) (PARC)
-- Matti Kinnunen (Nokia)
-- [Veronika Lux](http://www.xrce.xerox.com/people/lux/) (XRCE)
-- Per Martin-Löf (Stockholm)
-- [Bengt Nordström](http://www.cse.chalmers.se/~bengt) (Chalmers)
-- [Martin Okrslar](http://www.cis.uni-muenchen.de/studenten/stud_homepages/okrslar/reklame.html) (CIS)
-- Jianmin Pang (Durham)
-- [Sylvain Pogodalla](http://www.xrce.xerox.com/people/pogodalla/index.fr.html) (XRCE)
-- [Loïc Pottier](http://www.inria.fr/Loic.Pottier) (INRIA)
-- [Annie Zaenen](http://www2.parc.com/istl/members/zaenen/) (PARC)
-
-The GF logo was designed by Uula Ranta.

doc/gf-quickstart.html

@@ -0,0 +1,158 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>GF Quickstart</title>
+<link rel=stylesheet href="../css/style.css">
+<meta name = "viewport" content = "width = device-width">
+</head>
+
+
+<body>
+
+<center>
+<img src="Logos/gf0.png">
+<p>
+Aarne Ranta
+<p>
+October 2011 for GF 3.3
+
+<p>
+
+<h1>Grammatical Framework Quick Start</h1>
+
+</center>
+
+This Quick Start shows a few examples of how GF can be used.
+We assume that you have downloaded and installed GF, so that
+the command <tt>gf</tt> works for you. See download and install
+instructions <a href="../download/index.html">here</a>.
+
+<h2>Want to try without downloading?</h2>
+
+<a href="../demos/phrasebook/">Using GF translation</a> with an existing grammar.
+
+<p>
+
+<a href="../demos/gfse/">Writing GF grammars</a> in the cloud, without installing GF.
+
+
+
+
+<h2>Using GF for translation and generation</h2>
+
+When you have downloaded and installed GF:
+<ol>
+<li> Copy the files
+<a href="../examples/tutorial/food/Food.gf"><tt>Food.gf</tt></a>,
+<a href="../examples/tutorial/food/FoodEng.gf"><tt>FoodEng.gf</tt></a>, and
+<a href="../examples/tutorial/food/FoodIta.gf"><tt>FoodIta.gf</tt></a>.
+Or go to <tt>GF/examples/tutorial/food/</tt>, if you have downloaded the
+GF sources.
+
+ <li> Start GF with the shell command (without the prompt <tt>$</tt>)
+<pre>
+  $ gf FoodIta.gf FoodEng.gf
+</pre>
+Alternatively, start GF with <tt>gf</tt> and give the GF command <tt>import FoodIta.gf FoodEng.gf</tt>.
+
+<li> <b>Translation</b>. Try your first translation by giving the GF command
+<pre>
+  parse "this cheese is very very Italian" | linearize
+</pre>
+Notice that the parser accept the tabulator for word completion.
+
+<li> <b>Generation</b>. Random-generate sentences in two languages:
+<pre>
+  generate_random | linearize
+</pre>
+
+<li> <b>Other commands</b>. Use the help command
+<pre>
+  help
+</pre>
+<li> <b>More examples</b>. Go to <tt>GF/examples/phrasebook</tt> or some other
+subdirectory of  <tt>GF/examples/</tt>. Or try a resource grammar by, for instance,
+<pre>
+  import alltenses/LangEng.gfo alltenses/LangGer.gfo
+
+  parse -lang=Eng "I love you" | linearize -treebank
+</pre>
+The resource grammars are found relative to the value of <tt>GF_LIB_PATH</tt>, which
+you may have to set; see <a href="../download/index.html">here</a> for instructions.
+
+
+
+</ol>
+
+
+
+<h2>Grammar development</h2>
+
+Add words to the <tt>Food</tt>
+grammars and try the above commands again. For instance, add the following lines:
+<pre>
+  Bread : Kind ;          -- in Food.gf
+  Bread = {s = "bread"} ; -- in FoodEng.gf
+  Bread = {s = "pane"} ;  -- in FoodIta.gf
+</pre>
+and start GF again with the same command. Now you can even translate
+<i>this bread is very Italian</i>.
+</ol>
+To lear more on GF commands and
+grammar development, go to the one of the tutorials:
+<ul>
+<li> <a href="tutorial/gf-tutorial.html">GF Tutorial</a>: older, more programmer-oriented
+<li> <a href="gf-lrec-2010.pdf">GF Resource Tutorial</a>: newer, more linguist-oriented
+</ul>
+To learn about how GF is used for easily writing grammars for 16 languages, consult the
+<ul>
+<li> <a href="../lib/doc/synopsis.html">GF Resource Grammar Library</a>.
+</ul>
+
+
+
+<h2>Run-time grammars and web applications</h2>
+
+GF has its own "machine language", PGF (Portable Grammar Format),
+which is recommended for use in applications at run time. To produce a PGF file from
+the two grammars above, do
+<pre>
+  gf -make FoodIta.gf FoodEng.gf
+  wrote Food.pgf
+</pre>
+You can use this in Haskell and Java programs, and also on web services, such as
+<ul>
+<li> the
+  <a href="http://cloud.grammaticalframework.org/minibar/minibar.html">minibar</a>
+  fridge magnets
+</ul>
+
+The quickest way to provide a GF web service is to start GF with the <tt>-server</tt> option:
+<pre>
+  $ gf -server
+  This is GF version 3.3
+  Built on linux/i386 with ghc-7.0, flags: interrupt server cclazy
+  Document root = /usr/local/share/gf-3.3/www
+  Starting HTTP server, open http://localhost:41296/ in your web browser.
+</pre>
+You can view it locally by pointing your
+browser to the URL shown. You can add your own <tt>.pgf</tt> grammar to the service by
+copying it over to the <tt>documentRoot</tt> directory. Just push "reload" in
+your browser after each such update.
+
+<p>
+
+To build more customized web application, consult the
+<a href="http://code.google.com/p/grammatical-framework/wiki/SideBar?tm=6">developer wiki</a>.
+
+
+<h2>User group</h2>
+
+You are welcome to join the <A HREF="http://groups.google.com/group/gf-dev">User Group</A>
+to get help and discuss GF-related issues!
+
+
+
+
+
+</body></html>

doc/gf-reference.html

@@ -0,0 +1,664 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+<META NAME="generator" CONTENT="http://txt2tags.org">
+<LINK REL="stylesheet" TYPE="text/css" HREF="../css/style.css">
+<meta name = "viewport" content = "width = device-width"><TITLE>GF Quick Reference</TITLE>
+</HEAD><BODY BGCOLOR="white" TEXT="black">
+<CENTER>
+<H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>GF Quick Reference</H1>
+<FONT SIZE="4"><I>Aarne Ranta</I></FONT><BR>
+<FONT SIZE="4">April 4, 2006</FONT>
+</CENTER>
+
+<P></P>
+<HR NOSHADE SIZE=1>
+<P></P>
+
+      <UL>
+      <LI><A HREF="#toc1">A complete example</A>
+      <LI><A HREF="#toc2">Modules and files</A>
+      <LI><A HREF="#toc3">Judgements</A>
+      <LI><A HREF="#toc4">Types</A>
+      <LI><A HREF="#toc5">Expressions</A>
+      <LI><A HREF="#toc6">Pattern matching</A>
+      <LI><A HREF="#toc7">Sample library functions</A>
+      <LI><A HREF="#toc8">Flags</A>
+      <LI><A HREF="#toc9">File paths</A>
+      <LI><A HREF="#toc10">Alternative grammar formats</A>
+      <LI><A HREF="#toc11">References</A>
+      </UL>
+
+<P></P>
+<HR NOSHADE SIZE=1>
+<P></P>
+<P>
+This is a quick reference on GF grammars. It aims to
+cover all forms of expression available when writing
+grammars. It assumes basic knowledge of GF, which
+can be acquired from the 
+<A HREF="http://www.grammaticalframework.org/doc/tutorial/gf-tutorial.html">GF Tutorial</A>.
+Help on GF commands is obtained on line by the
+help command (<CODE>help</CODE>), and help on invoking
+GF with (<CODE>gf -help</CODE>).
+</P>
+
+<A NAME="toc1"></A>
+<H3>A complete example</H3>
+
+<P>
+This is a complete example of a GF grammar divided
+into three modules in files. The grammar recognizes the
+phrases <I>one pizza</I> and <I>two pizzas</I>.
+</P>
+<P>
+File <CODE>Order.gf</CODE>:
+</P>
+
+<PRE>
+  abstract Order = {
+  cat 
+    Order ; 
+    Item ;
+  fun 
+    One, Two : Item -&gt; Order ;
+    Pizza : Item ;
+  }
+</PRE>
+
+<P>
+File <CODE>OrderEng.gf</CODE> (the top file):
+</P>
+
+<PRE>
+  --# -path=.:prelude
+  concrete OrderEng of Order = 
+   open Res, Prelude in {
+  flags startcat=Order ;
+  lincat 
+    Order = SS ; 
+    Item  = {s : Num =&gt; Str} ;
+  lin 
+    One it = ss ("one" ++ it.s ! Sg) ;
+    Two it = ss ("two" ++ it.s ! Pl) ;
+    Pizza  = regNoun "pizza" ;
+  }
+</PRE>
+
+<P>
+File <CODE>Res.gf</CODE>:
+</P>
+
+<PRE>
+  resource Res = open Prelude in {
+  param Num = Sg | Pl ;
+  oper regNoun : Str -&gt; {s : Num =&gt; Str} =
+    \dog -&gt; {s = table {
+      Sg =&gt; dog ;
+      _  =&gt; dog + "s"
+      }
+    } ;
+  }
+</PRE>
+
+<P>
+To use this example, do
+</P>
+
+<PRE>
+    % gf             -- in shell: start GF
+    &gt; i OrderEng.gf  -- in GF: import grammar
+    &gt; p "one pizza"  --        parse string
+    &gt; l Two Pizza    --        linearize tree
+</PRE>
+
+<A NAME="toc2"></A>
+<H3>Modules and files</H3>
+
+<P>
+One module per file.
+File named <CODE>Foo.gf</CODE> contains module named
+<CODE>Foo</CODE>.
+</P>
+<P>
+Each module has the structure
+</P>
+
+<PRE>
+  moduletypename =   
+    Inherits **        -- optional
+    open Opens in      -- optional
+    { Judgements }   
+</PRE>
+
+<P>
+Inherits are names of modules of the same type.
+Inheritance can be restricted:
+</P>
+
+<PRE>
+    Mo[f,g],  -- inherit only f,g from Mo
+    Lo-[f,g]  -- inheris all but f,g from Lo
+</PRE>
+
+<P>
+Opens are possible in <CODE>concrete</CODE> and <CODE>resource</CODE>.
+They are names of modules of these two types, possibly
+qualified:
+</P>
+
+<PRE>
+    (M = Mo), -- refer to f as M.f or Mo.f
+    (Lo = Lo) -- refer to f as Lo.f
+</PRE>
+
+<P>
+Module types and judgements in them:
+</P>
+
+<PRE>
+  abstract A          -- cat, fun, def, data
+  concrete C of A     -- lincat, lin, lindef, printname
+  resource R          -- param, oper
+  
+  interface I         -- like resource, but can have
+                         oper f : T without definition
+  instance J of I     -- like resource, defines opers
+                         that I leaves undefined
+  incomplete          -- functor: concrete that opens 
+   concrete CI of A =    one or more interfaces
+    open I in ...
+  concrete CJ of A =  -- completion: concrete that
+    CI with              instantiates a functor by
+      (I = J)            instances of open interfaces
+</PRE>
+
+<P>
+The forms 
+<CODE>param</CODE>, <CODE>oper</CODE> 
+may appear in <CODE>concrete</CODE> as well, but are then
+not inherited to extensions.
+</P>
+<P>
+All modules can moreover have <CODE>flags</CODE> and comments.
+Comments have the forms
+</P>
+
+<PRE>
+  -- till the end of line
+  {- any number of lines between -}
+  --# used for compiler pragmas
+</PRE>
+
+<P>
+A <CODE>concrete</CODE> can be opened like a <CODE>resource</CODE>.
+It is translated as follows:
+</P>
+
+<PRE>
+  cat C          ---&gt;  oper C : Type = 
+  lincat C = T           T ** {lock_C : {}}
+  
+  fun f : G -&gt; C ---&gt;  oper f : A* -&gt; C* = \g -&gt; 
+  lin f = t              t g ** {lock_C = &lt;&gt;}          
+</PRE>
+
+<P>
+An <CODE>abstract</CODE> can be opened like an <CODE>interface</CODE>.
+Any <CODE>concrete</CODE> of it then works as an <CODE>instance</CODE>.
+</P>
+
+<A NAME="toc3"></A>
+<H3>Judgements</H3>
+
+<PRE>
+  cat C               -- declare category C
+  cat C (x:A)(y:B x)  -- dependent category C
+  cat C A B           -- same as C (x : A)(y : B)
+  fun f : T           -- declare function f of type T
+  def f = t           -- define f as t
+  def f p q = t       -- define f by pattern matching
+  data C = f | g      -- set f,g as constructors of C
+  data f : A -&gt; C     -- same as 
+                         fun f : A -&gt; C; data C=f
+  
+  lincat C = T        -- define lin.type of cat C
+  lin f = t           -- define lin. of fun f
+  lin f x y = t       -- same as lin f = \x y -&gt; t
+  lindef C = \s -&gt; t  -- default lin. of cat C
+  printname fun f = s -- printname shown in menus
+  printname cat C = s -- printname shown in menus
+  printname f = s     -- same as printname fun f = s
+  
+  param P = C | D Q R -- define parameter type P 
+                         with constructors
+                         C : P, D : Q -&gt; R -&gt; P
+  oper h : T = t      -- define oper h of type T
+  oper h = t          -- omit type, if inferrable
+  
+  flags p=v           -- set value of flag p
+</PRE>
+
+<P>
+Judgements are terminated by semicolons (<CODE>;</CODE>).
+Subsequent judgments of the same form may share the
+keyword:
+</P>
+
+<PRE>
+  cat C ; D ;         -- same as cat C ; cat D ;
+</PRE>
+
+<P>
+Judgements can also share RHS:
+</P>
+
+<PRE>
+  fun f,g : A         -- same as fun f : A ; g : A
+</PRE>
+
+<A NAME="toc4"></A>
+<H3>Types</H3>
+
+<P>
+Abstract syntax (in <CODE>fun</CODE>):
+</P>
+
+<PRE>
+  C                -- basic type, if cat C
+  C a b            -- basic type for dep. category
+  (x : A) -&gt; B     -- dep. functions from A to B
+  (_ : A) -&gt; B     -- nondep. functions from A to B
+  (p,q : A) -&gt; B   -- same as (p : A)-&gt; (q : A) -&gt; B
+  A -&gt; B           -- same as (_ : A) -&gt; B
+  Int              -- predefined integer type
+  Float            -- predefined float type
+  String           -- predefined string type
+</PRE>
+
+<P>
+Concrete syntax (in <CODE>lincat</CODE>):
+</P>
+
+<PRE>
+  Str              -- token lists
+  P                -- parameter type, if param P
+  P =&gt; B           -- table type, if P param. type
+  {s : Str ; p : P}-- record type
+  {s,t : Str}      -- same as {s : Str ; t : Str}
+  {a : A} **{b : B}-- record type extension, same as  
+                      {a : A ; b : B}
+  A * B * C        -- tuple type, same as
+                      {p1 : A ; p2 : B ; p3 : C}
+  Ints n           -- type of n first integers
+</PRE>
+
+<P>
+Resource (in <CODE>oper</CODE>): all those of concrete, plus
+</P>
+
+<PRE>
+  Tok              -- tokens (subtype of Str)
+  A -&gt; B           -- functions from A to B
+  Int              -- integers
+  Strs             -- list of prefixes (for pre)
+  PType            -- parameter type
+  Type             -- any type
+</PRE>
+
+<P>
+As parameter types, one can use any finite type:
+<CODE>P</CODE> defined in <CODE>param P</CODE>,
+<CODE>Ints n</CODE>, and record types of parameter types.
+</P>
+
+<A NAME="toc5"></A>
+<H3>Expressions</H3>
+
+<P>
+Syntax trees = full function applications
+</P>
+
+<PRE>
+  f a b              -- : C if fun f : A -&gt; B -&gt; C
+  1977               -- : Int
+  3.14               -- : Float
+  "foo"              -- : String
+</PRE>
+
+<P>
+Higher-Order Abstract syntax (HOAS): functions as arguments:
+</P>
+
+<PRE>
+  F a (\x -&gt; c)      -- : C if a : A, c : C (x : B), 
+                        fun F : A -&gt; (B -&gt; C) -&gt; C
+</PRE>
+
+<P>
+Tokens and token lists
+</P>
+
+<PRE>
+  "hello"            -- : Tok, singleton Str
+  "hello" ++ "world" -- : Str
+  ["hello world"]    -- : Str, same as "hello" ++ "world"
+  "hello" + "world"  -- : Tok, computes to "helloworld"
+  []                 -- : Str, empty list
+</PRE>
+
+<P>
+Parameters
+</P>
+
+<PRE>
+  Sg                   -- atomic constructor
+  VPres Sg P2          -- applied constructor
+  {n = Sg ; p = P3}    -- record of parameters
+</PRE>
+
+<P>
+Tables
+</P>
+
+<PRE>
+  table {              -- by full branches
+    Sg =&gt; "mouse" ;
+    Pl =&gt; "mice"
+    }
+  table {              -- by pattern matching
+    Pl =&gt; "mice" ;
+    _  =&gt; "mouse"      -- wildcard pattern
+    }
+  table {               
+    n =&gt; regn n "cat"  -- variable pattern 
+    }
+  table Num {...}      -- table given with arg. type
+  table ["ox"; "oxen"] -- table as course of values
+  \\_ =&gt; "fish"        -- same as table {_ =&gt; "fish"} 
+  \\p,q =&gt; t           -- same as \\p =&gt; \\q =&gt; t
+  
+  t ! p                -- select p from table t
+  case e of {...}      -- same as table {...} ! e 
+</PRE>
+
+<P>
+Records
+</P>
+
+<PRE>
+  {s = "Liz"; g = Fem} -- record in full form
+  {s,t = "et"}         -- same as {s = "et";t= "et"}
+  {s = "Liz"} **       -- record extension: same as
+    {g = Fem}             {s = "Liz" ; g = Fem}
+  
+  &lt;a,b,c&gt;        -- tuple, same as {p1=a;p2=b;p3=c}
+</PRE>
+
+<P>
+Functions
+</P>
+
+<PRE>
+  \x -&gt; t            -- lambda abstract
+  \x,y -&gt; t          -- same as \x -&gt; \y -&gt; t
+  \x,_ -&gt; t          -- binding not in t
+</PRE>
+
+<P>
+Local definitions
+</P>
+
+<PRE>
+  let x : A = d in t -- let definition
+  let x = d in t     -- let defin, type inferred
+  let x=d ; y=e in t -- same as 
+                        let x=d in let y=e in t
+  let {...} in t     -- same as let ... in t
+  
+  t where {...}      -- same as let ... in t
+</PRE>
+
+<P>
+Free variation
+</P>
+
+<PRE>
+  variants {x ; y}     -- both x and y possible
+  variants {}          -- nothing possible
+</PRE>
+
+<P>
+Prefix-dependent choices
+</P>
+
+<PRE>
+  pre {"a" ; "an" / v} -- "an" before v, "a" otherw.
+  strs {"a" ; "i" ;"o"}-- list of condition prefixes
+</PRE>
+
+<P>
+Typed expression
+</P>
+
+<PRE>
+  &lt;t:T&gt;                -- same as t, to help type inference
+</PRE>
+
+<P>
+Accessing bound variables in <CODE>lin</CODE>: use fields <CODE>$1, $2, $3,...</CODE>. 
+Example:
+</P>
+
+<PRE>
+  fun F : (A : Set) -&gt; (El A -&gt; Prop) -&gt; Prop ; 
+  lin F A B = {s = ["for all"] ++ A.s ++ B.$1 ++ B.s}
+</PRE>
+
+<A NAME="toc6"></A>
+<H3>Pattern matching</H3>
+
+<P>
+These patterns can be used in branches of <CODE>table</CODE> and
+<CODE>case</CODE> expressions. Patterns are matched in the order in
+which they appear in the grammar.
+</P>
+
+<PRE>
+  C                 -- atomic param constructor
+  C p q             -- param constr. applied to patterns
+  x                 -- variable, matches anything
+  _                 -- wildcard, matches anything
+  "foo"             -- string
+  56                -- integer
+  {s = p ; y = q}   -- record, matches extensions too
+  &lt;p,q&gt;             -- tuple, same as {p1=p ; p2=q}
+  p | q             -- disjunction, binds to first match
+  x@p               -- binds x to what p matches
+  - p               -- negation
+  p + "s"           -- sequence of two string patterns
+  p*                -- repetition of a string pattern
+</PRE>
+
+<A NAME="toc7"></A>
+<H3>Sample library functions</H3>
+
+<PRE>
+  -- lib/prelude/Predef.gf
+  drop   : Int -&gt; Tok -&gt; Tok   -- drop prefix of length
+  take   : Int -&gt; Tok -&gt; Tok   -- take prefix of length
+  tk     : Int -&gt; Tok -&gt; Tok   -- drop suffix of length
+  dp     : Int -&gt; Tok -&gt; Tok   -- take suffix of length
+  occur  : Tok -&gt; Tok -&gt; PBool -- test if substring
+  occurs : Tok -&gt; Tok -&gt; PBool -- test if any char occurs
+  show   : (P:Type) -&gt; P -&gt;Tok -- param to string
+  read   : (P:Type) -&gt; Tok-&gt; P -- string to param
+  toStr  : (L:Type) -&gt; L -&gt;Str -- find "first" string
+  
+  -- lib/prelude/Prelude.gf
+  param Bool = True | False
+  oper
+    SS  : Type                   -- the type {s : Str}
+    ss  : Str -&gt; SS              -- construct SS
+    cc2 : (_,_ : SS) -&gt; SS       -- concat SS's
+    optStr : Str -&gt; Str          -- string or empty
+    strOpt : Str -&gt; Str          -- empty or string
+    bothWays : Str -&gt; Str -&gt; Str -- X++Y or Y++X 
+    init : Tok -&gt; Tok            -- all but last char
+    last : Tok -&gt; Tok            -- last char
+    prefixSS : Str -&gt; SS -&gt; SS
+    postfixSS : Str -&gt; SS -&gt; SS
+    infixSS : Str -&gt; SS -&gt; SS -&gt; SS
+    if_then_else : (A : Type) -&gt; Bool -&gt; A -&gt; A -&gt; A
+    if_then_Str : Bool -&gt; Str -&gt; Str -&gt; Str
+</PRE>
+
+<A NAME="toc8"></A>
+<H3>Flags</H3>
+
+<P>
+Flags can appear, with growing priority,
+</P>
+
+<UL>
+<LI>in files, judgement <CODE>flags</CODE> and without dash (<CODE>-</CODE>)
+<LI>as flags to <CODE>gf</CODE> when invoked, with dash
+<LI>as flags to various GF commands, with dash
+</UL>
+
+<P>
+Some common flags used in grammars:
+</P>
+
+<PRE>
+  startcat=cat    use this category as default 
+  
+  lexer=literals  int and string literals recognized
+  lexer=code      like program code
+  lexer=text      like text: spacing, capitals
+  lexer=textlit   text, unknowns as string lits
+  
+  unlexer=code    like program code
+  unlexer=codelit code, remove string lit quotes
+  unlexer=text    like text: punctuation, capitals
+  unlexer=textlit text, remove string lit quotes
+  unlexer=concat  remove all spaces
+  unlexer=bind    remove spaces around "&amp;+"
+  
+  optimize=all_subs  best for almost any concrete
+  optimize=values    good for lexicon concrete
+  optimize=all       usually good for resource
+  optimize=noexpand  for resource, if =all too big
+</PRE>
+
+<P>
+For the full set of values for <CODE>FLAG</CODE>, 
+use on-line <CODE>h -FLAG</CODE>.
+</P>
+
+<A NAME="toc9"></A>
+<H3>File paths</H3>
+
+<P>
+Colon-separated lists of directories searched in the
+given order: 
+</P>
+
+<PRE>
+  --# -path=.:../abstract:../common:prelude
+</PRE>
+
+<P>
+This can be (in order of growing preference), as
+first line in the top file, as flag to <CODE>gf</CODE>
+when invoked, or as flag to the <CODE>i</CODE> command.
+The prefix <CODE>--#</CODE> is used only in files.
+</P>
+<P>
+If the environment variabls <CODE>GF_LIB_PATH</CODE> is defined, its
+value is automatically prefixed to each directory to
+extend the original search path.
+</P>
+
+<A NAME="toc10"></A>
+<H3>Alternative grammar formats</H3>
+
+<P>
+<B>Old GF</B> (before GF 2.0): 
+all judgements in any kinds of modules,
+division into files uses <CODE>include</CODE>s.
+A file <CODE>Foo.gf</CODE> is recognized as the old format
+if it lacks a module header. 
+</P>
+<P>
+<B>Context-free</B> (file <CODE>foo.cf</CODE>). The form of rules is e.g.
+</P>
+
+<PRE>
+  Fun. S ::= NP "is" AP ;
+</PRE>
+
+<P>
+If <CODE>Fun</CODE> is omitted, it is generated automatically. 
+Rules must be one per line. The RHS can be empty.
+</P>
+<P>
+<B>Extended BNF</B> (file <CODE>foo.ebnf</CODE>). The form of rules is e.g.
+</P>
+
+<PRE>
+  S ::= (NP+ ("is" | "was") AP | V NP*) ;
+</PRE>
+
+<P>
+where the RHS is a regular expression of categories
+and quoted tokens: <CODE>"foo", CAT, T U, T|U, T*, T+, T?</CODE>, or empty.
+Rule labels are generated automatically.
+</P>
+<P>
+<B>Probabilistic grammars</B> (not a separate format).
+You can set the probability of a function <CODE>f</CODE> (in its value category) by
+</P>
+
+<PRE>
+  --# prob f 0.009
+</PRE>
+
+<P>
+These are put into a file given to GF using the <CODE>probs=File</CODE> flag
+on command line. This file can be the grammar file itself.
+</P>
+<P>
+<B>Example-based grammars</B>  (file <CODE>foo.gfe</CODE>). Expressions of the form
+</P>
+
+<PRE>
+  in Cat "example string"
+</PRE>
+
+<P>
+are preprocessed by using a parser given by the flag 
+</P>
+
+<PRE>
+  --# -resource=File
+</PRE>
+
+<P>
+and the result is written to <CODE>foo.gf</CODE>.
+</P>
+
+<A NAME="toc11"></A>
+<H3>References</H3>
+
+<P>
+<A HREF="http://www.grammaticalframework.org/">GF Homepage</A>
+</P>
+<P>
+A. Ranta, Grammatical Framework: A Type-Theoretical Grammar Formalism.
+<I>The Journal of Functional Programming</I>, vol. 14:2. 2004, pp. 145-189. 
+</P>
+
+<!-- html code generated by txt2tags 2.6 (http://txt2tags.org) -->
+<!-- cmdline: txt2tags -thtml ./doc/gf-reference.t2t -->
+</BODY></HTML>

doc/gf-reference.t2t

@@ -0,0 +1,481 @@
+GF Quick Reference
+Aarne Ranta
+April 4, 2006
+
+% NOTE: this is a txt2tags file.
+% Create an html file from this file using:
+% txt2tags -thtml gf-reference.t2t
+
+%!style:../css/style.css
+%!target:html
+%!options: --toc
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
+This is a quick reference on GF grammars. It aims to
+cover all forms of expression available when writing
+grammars. It assumes basic knowledge of GF, which
+can be acquired from the 
+[GF Tutorial http://www.grammaticalframework.org/doc/tutorial/gf-tutorial.html].
+Help on GF commands is obtained on line by the
+help command (``help``), and help on invoking
+GF with (``gf -help``).
+
+
+===A complete example===
+
+This is a complete example of a GF grammar divided
+into three modules in files. The grammar recognizes the
+phrases //one pizza// and //two pizzas//.
+
+File ``Order.gf``:
+```
+abstract Order = {
+cat 
+  Order ; 
+  Item ;
+fun 
+  One, Two : Item -> Order ;
+  Pizza : Item ;
+}
+```
+File ``OrderEng.gf`` (the top file):
+```
+--# -path=.:prelude
+concrete OrderEng of Order = 
+ open Res, Prelude in {
+flags startcat=Order ;
+lincat 
+  Order = SS ; 
+  Item  = {s : Num => Str} ;
+lin 
+  One it = ss ("one" ++ it.s ! Sg) ;
+  Two it = ss ("two" ++ it.s ! Pl) ;
+  Pizza  = regNoun "pizza" ;
+}
+```
+File ``Res.gf``:
+```
+resource Res = open Prelude in {
+param Num = Sg | Pl ;
+oper regNoun : Str -> {s : Num => Str} =
+  \dog -> {s = table {
+    Sg => dog ;
+    _  => dog + "s"
+    }
+  } ;
+}
+```
+To use this example, do
+```
+  % gf             -- in shell: start GF
+  > i OrderEng.gf  -- in GF: import grammar
+  > p "one pizza"  --        parse string
+  > l Two Pizza    --        linearize tree
+```
+
+
+
+===Modules and files===
+
+One module per file.
+File named ``Foo.gf`` contains module named
+``Foo``.
+
+Each module has the structure
+```
+moduletypename =   
+  Inherits **        -- optional
+  open Opens in      -- optional
+  { Judgements }   
+```
+Inherits are names of modules of the same type.
+Inheritance can be restricted:
+```
+  Mo[f,g],  -- inherit only f,g from Mo
+  Lo-[f,g]  -- inheris all but f,g from Lo
+```
+Opens are possible in ``concrete`` and ``resource``.
+They are names of modules of these two types, possibly
+qualified:
+```
+  (M = Mo), -- refer to f as M.f or Mo.f
+  (Lo = Lo) -- refer to f as Lo.f
+```
+Module types and judgements in them:
+```
+abstract A          -- cat, fun, def, data
+concrete C of A     -- lincat, lin, lindef, printname
+resource R          -- param, oper
+
+interface I         -- like resource, but can have
+                       oper f : T without definition
+instance J of I     -- like resource, defines opers
+                       that I leaves undefined
+incomplete          -- functor: concrete that opens 
+ concrete CI of A =    one or more interfaces
+  open I in ...
+concrete CJ of A =  -- completion: concrete that
+  CI with              instantiates a functor by
+    (I = J)            instances of open interfaces
+``` 
+The forms 
+``param``, ``oper`` 
+may appear in ``concrete`` as well, but are then
+not inherited to extensions.
+
+All modules can moreover have ``flags`` and comments.
+Comments have the forms
+```
+-- till the end of line
+{- any number of lines between -}
+--# used for compiler pragmas
+```
+A ``concrete`` can be opened like a ``resource``.
+It is translated as follows:
+```
+cat C          --->  oper C : Type = 
+lincat C = T           T ** {lock_C : {}}
+
+fun f : G -> C --->  oper f : A* -> C* = \g -> 
+lin f = t              t g ** {lock_C = <>}          
+```
+An ``abstract`` can be opened like an ``interface``.
+Any ``concrete`` of it then works as an ``instance``.
+
+
+
+===Judgements===
+
+```
+cat C               -- declare category C
+cat C (x:A)(y:B x)  -- dependent category C
+cat C A B           -- same as C (x : A)(y : B)
+fun f : T           -- declare function f of type T
+def f = t           -- define f as t
+def f p q = t       -- define f by pattern matching
+data C = f | g      -- set f,g as constructors of C
+data f : A -> C     -- same as 
+                       fun f : A -> C; data C=f
+
+lincat C = T        -- define lin.type of cat C
+lin f = t           -- define lin. of fun f
+lin f x y = t       -- same as lin f = \x y -> t
+lindef C = \s -> t  -- default lin. of cat C
+printname fun f = s -- printname shown in menus
+printname cat C = s -- printname shown in menus
+printname f = s     -- same as printname fun f = s
+
+param P = C | D Q R -- define parameter type P 
+                       with constructors
+                       C : P, D : Q -> R -> P
+oper h : T = t      -- define oper h of type T
+oper h = t          -- omit type, if inferrable
+
+flags p=v           -- set value of flag p
+```
+Judgements are terminated by semicolons (``;``).
+Subsequent judgments of the same form may share the
+keyword:
+```
+cat C ; D ;         -- same as cat C ; cat D ;
+```
+Judgements can also share RHS:
+```
+fun f,g : A         -- same as fun f : A ; g : A
+```
+
+
+===Types===
+
+Abstract syntax (in ``fun``):
+```
+C                -- basic type, if cat C
+C a b            -- basic type for dep. category
+(x : A) -> B     -- dep. functions from A to B
+(_ : A) -> B     -- nondep. functions from A to B
+(p,q : A) -> B   -- same as (p : A)-> (q : A) -> B
+A -> B           -- same as (_ : A) -> B
+Int              -- predefined integer type
+Float            -- predefined float type
+String           -- predefined string type
+```
+Concrete syntax (in ``lincat``):
+```
+Str              -- token lists
+P                -- parameter type, if param P
+P => B           -- table type, if P param. type
+{s : Str ; p : P}-- record type
+{s,t : Str}      -- same as {s : Str ; t : Str}
+{a : A} **{b : B}-- record type extension, same as  
+                    {a : A ; b : B}
+A * B * C        -- tuple type, same as
+                    {p1 : A ; p2 : B ; p3 : C}
+Ints n           -- type of n first integers
+```
+Resource (in ``oper``): all those of concrete, plus
+``` 
+Tok              -- tokens (subtype of Str)
+A -> B           -- functions from A to B
+Int              -- integers
+Strs             -- list of prefixes (for pre)
+PType            -- parameter type
+Type             -- any type
+```
+As parameter types, one can use any finite type:
+``P`` defined in ``param P``,
+``Ints n``, and record types of parameter types.
+
+
+
+===Expressions===
+
+Syntax trees = full function applications
+```
+f a b              -- : C if fun f : A -> B -> C
+1977               -- : Int
+3.14               -- : Float
+"foo"              -- : String
+```
+Higher-Order Abstract syntax (HOAS): functions as arguments:
+```
+F a (\x -> c)      -- : C if a : A, c : C (x : B), 
+                      fun F : A -> (B -> C) -> C
+```
+Tokens and token lists
+```
+"hello"            -- : Tok, singleton Str
+"hello" ++ "world" -- : Str
+["hello world"]    -- : Str, same as "hello" ++ "world"
+"hello" + "world"  -- : Tok, computes to "helloworld"
+[]                 -- : Str, empty list
+```
+Parameters
+```
+Sg                   -- atomic constructor
+VPres Sg P2          -- applied constructor
+{n = Sg ; p = P3}    -- record of parameters
+```
+Tables
+```
+table {              -- by full branches
+  Sg => "mouse" ;
+  Pl => "mice"
+  }
+table {              -- by pattern matching
+  Pl => "mice" ;
+  _  => "mouse"      -- wildcard pattern
+  }
+table {               
+  n => regn n "cat"  -- variable pattern 
+  }
+table Num {...}      -- table given with arg. type
+table ["ox"; "oxen"] -- table as course of values
+\\_ => "fish"        -- same as table {_ => "fish"} 
+\\p,q => t           -- same as \\p => \\q => t
+
+t ! p                -- select p from table t
+case e of {...}      -- same as table {...} ! e 
+```
+Records
+```
+{s = "Liz"; g = Fem} -- record in full form
+{s,t = "et"}         -- same as {s = "et";t= "et"}
+{s = "Liz"} **       -- record extension: same as
+  {g = Fem}             {s = "Liz" ; g = Fem}
+
+<a,b,c>        -- tuple, same as {p1=a;p2=b;p3=c}
+```
+Functions
+```
+\x -> t            -- lambda abstract
+\x,y -> t          -- same as \x -> \y -> t
+\x,_ -> t          -- binding not in t
+```
+Local definitions
+```
+let x : A = d in t -- let definition
+let x = d in t     -- let defin, type inferred
+let x=d ; y=e in t -- same as 
+                      let x=d in let y=e in t
+let {...} in t     -- same as let ... in t
+
+t where {...}      -- same as let ... in t
+```
+Free variation
+```
+variants {x ; y}     -- both x and y possible
+variants {}          -- nothing possible
+```
+Prefix-dependent choices
+```
+pre {"a" ; "an" / v} -- "an" before v, "a" otherw.
+strs {"a" ; "i" ;"o"}-- list of condition prefixes
+```
+Typed expression
+```
+<t:T>                -- same as t, to help type inference
+```
+Accessing bound variables in ``lin``: use fields ``$1, $2, $3,...``. 
+Example:
+```
+fun F : (A : Set) -> (El A -> Prop) -> Prop ; 
+lin F A B = {s = ["for all"] ++ A.s ++ B.$1 ++ B.s}
+```
+
+
+===Pattern matching===
+
+These patterns can be used in branches of ``table`` and
+``case`` expressions. Patterns are matched in the order in
+which they appear in the grammar.
+```
+C                 -- atomic param constructor
+C p q             -- param constr. applied to patterns
+x                 -- variable, matches anything
+_                 -- wildcard, matches anything
+"foo"             -- string
+56                -- integer
+{s = p ; y = q}   -- record, matches extensions too
+<p,q>             -- tuple, same as {p1=p ; p2=q}
+p | q             -- disjunction, binds to first match
+x@p               -- binds x to what p matches
+- p               -- negation
+p + "s"           -- sequence of two string patterns
+p*                -- repetition of a string pattern
+```
+
+===Sample library functions===
+
+```
+-- lib/prelude/Predef.gf
+drop   : Int -> Tok -> Tok   -- drop prefix of length
+take   : Int -> Tok -> Tok   -- take prefix of length
+tk     : Int -> Tok -> Tok   -- drop suffix of length
+dp     : Int -> Tok -> Tok   -- take suffix of length
+occur  : Tok -> Tok -> PBool -- test if substring
+occurs : Tok -> Tok -> PBool -- test if any char occurs
+show   : (P:Type) -> P ->Tok -- param to string
+read   : (P:Type) -> Tok-> P -- string to param
+toStr  : (L:Type) -> L ->Str -- find "first" string
+
+-- lib/prelude/Prelude.gf
+param Bool = True | False
+oper
+  SS  : Type                   -- the type {s : Str}
+  ss  : Str -> SS              -- construct SS
+  cc2 : (_,_ : SS) -> SS       -- concat SS's
+  optStr : Str -> Str          -- string or empty
+  strOpt : Str -> Str          -- empty or string
+  bothWays : Str -> Str -> Str -- X++Y or Y++X 
+  init : Tok -> Tok            -- all but last char
+  last : Tok -> Tok            -- last char
+  prefixSS : Str -> SS -> SS
+  postfixSS : Str -> SS -> SS
+  infixSS : Str -> SS -> SS -> SS
+  if_then_else : (A : Type) -> Bool -> A -> A -> A
+  if_then_Str : Bool -> Str -> Str -> Str
+```
+
+
+===Flags===
+
+Flags can appear, with growing priority,
+- in files, judgement ``flags`` and without dash (``-``)
+- as flags to ``gf`` when invoked, with dash
+- as flags to various GF commands, with dash
+
+
+Some common flags used in grammars:
+```
+startcat=cat    use this category as default 
+
+lexer=literals  int and string literals recognized
+lexer=code      like program code
+lexer=text      like text: spacing, capitals
+lexer=textlit   text, unknowns as string lits
+
+unlexer=code    like program code
+unlexer=codelit code, remove string lit quotes
+unlexer=text    like text: punctuation, capitals
+unlexer=textlit text, remove string lit quotes
+unlexer=concat  remove all spaces
+unlexer=bind    remove spaces around "&+"
+
+optimize=all_subs  best for almost any concrete
+optimize=values    good for lexicon concrete
+optimize=all       usually good for resource
+optimize=noexpand  for resource, if =all too big
+```
+For the full set of values for ``FLAG``, 
+use on-line ``h -FLAG``.
+
+
+
+===File paths===
+
+Colon-separated lists of directories searched in the
+given order: 
+```
+--# -path=.:../abstract:../common:prelude
+```
+This can be (in order of growing preference), as
+first line in the top file, as flag to ``gf``
+when invoked, or as flag to the ``i`` command.
+The prefix ``--#`` is used only in files.
+
+If the environment variabls ``GF_LIB_PATH`` is defined, its
+value is automatically prefixed to each directory to
+extend the original search path.
+
+
+===Alternative grammar formats===
+
+**Old GF** (before GF 2.0): 
+all judgements in any kinds of modules,
+division into files uses ``include``s.
+A file ``Foo.gf`` is recognized as the old format
+if it lacks a module header. 
+
+**Context-free** (file ``foo.cf``). The form of rules is e.g.
+```
+Fun. S ::= NP "is" AP ;
+```
+If ``Fun`` is omitted, it is generated automatically. 
+Rules must be one per line. The RHS can be empty.
+
+**Extended BNF** (file ``foo.ebnf``). The form of rules is e.g.
+```
+S ::= (NP+ ("is" | "was") AP | V NP*) ;
+```
+where the RHS is a regular expression of categories
+and quoted tokens: ``"foo", CAT, T U, T|U, T*, T+, T?``, or empty.
+Rule labels are generated automatically.
+
+
+**Probabilistic grammars** (not a separate format).
+You can set the probability of a function ``f`` (in its value category) by
+```
+--# prob f 0.009
+```
+These are put into a file given to GF using the ``probs=File`` flag
+on command line. This file can be the grammar file itself.
+
+**Example-based grammars**  (file ``foo.gfe``). Expressions of the form
+```
+in Cat "example string"
+```
+are preprocessed by using a parser given by the flag 
+```
+--# -resource=File
+```
+and the result is written to ``foo.gf``.
+
+
+===References===
+
+[GF Homepage http://www.grammaticalframework.org/]
+
+A. Ranta, Grammatical Framework: A Type-Theoretical Grammar Formalism.
+//The Journal of Functional Programming//, vol. 14:2. 2004, pp. 145-189. 
+

doc/gf-shell-reference.t2t

@@ -1,8 +1,11 @@
 The GF Software System
 
 
+%!style:../css/style.css
 %!options(html): --toc
 %!options(html): --toc-level=4
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
 %!postproc(html): "#VSPACE" "<hr>"
 %!postproc(html): "#NORMAL" ""
 %!postproc(html): "#TINY" ""
@@ -10,7 +13,7 @@ The GF Software System
 
 The GF software system implements the GF programming language. Its
 components are
-- the //compiler//,
+- the //compiler//, 
 translating ``.gf`` source files to ``.gfo`` object files, to
 ``.pgf`` run-time grammars, and to various other formats
 - the //run-time system//,
@@ -40,7 +43,7 @@ The shell maintains a  //state//, to which belong
 
 
 Unless file arguments are provided to the ``gf`` command, the shell starts in an
-empty state, with no grammars and no history.
+empty state, with no grammars and no history. 
 
 In the shell, a set of commands
 is available. Some of these commands may change the grammars in the state. The general
@@ -56,7 +59,7 @@ syntax of commands is given by the following BNF grammar:
   ARGUMENT     ::= QUOTED_STRING | TREE
   VALUE        ::= IDENT | QUOTED_STRING
 ```
-A command pipe is a sequence of commands interpreted in such a way
+A command pipe is a sequence of commands interpreted in such a way 
 that the output of each command
 is send as input to the next. The option ``-tr`` causes GF to show a trace,
 i.e. the intermediate result of the command to which it is attached.
@@ -66,7 +69,7 @@ executed one by one, in the order of appearance.
 
 ===GF shell commands===
 
-The full set of GF shell commands is listed below with explanations.
+The full set of GF shell commands is listed below with explanations. 
 This list can also be obtained in the GF shell by the command ``help -full``.
 
 %!include: gf-help-full.txt
@@ -74,14 +77,14 @@ This list can also be obtained in the GF shell by the command ``help -full``.
 ==The GF batch compiler==
 
 With the option ``-batch``, GF can be invoked in batch mode, i.e.
-without opening the shell, to compile files from ``.gf`` to ``.gfo``.
-The ``-s`` option ("silent") eliminates all messages except errors.
+without opening the shell, to compile files from ``.gf`` to ``.gfo``. 
+The ``-s`` option ("silent") eliminates all messages except errors. 
 ```
   $ gf -batch -s LangIta.gf
 ```
 With the option ``-make``, and as a set of
 top-level grammar files (with the same abstract syntax) as arguments,
-GF produces a ``.pgf`` file. The flag ``-optimize-pgf`` minimizes
+GF produces a ``.pgf`` file. The flag ``-optimize-pgf`` minimizes 
 the size of the ``.pgf`` file, and is recommended for grammars to be shipped.
 ```
   $ gf -make -optimize-pgf LangIta.gf LangEng.gf LangGer.gf
@@ -104,3 +107,5 @@ To run GF from a //script//, redirection of standard input can be used:
 ```
 The file ``script.gfs`` should then contain a sequence of GF commands, one per line.
 Unrecognized command lines are skipped without terminating GF.
+
+

doc/index.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>GF Documentation</title>
+<link rel=stylesheet href="../css/style.css">
+</head>
+ 
+
+<body>
+
+<div class=center>
+<a href="../"><img src="Logos/gf0.png"></a>
+
+
+
+
+<h1>Grammatical Framework Documents</h1>
+</div>
+
+
+<b>Top-5 documents</b>:
+
+<a href="gf-quickstart.html">Quick start instruction</a>.
+
+
+<a href="tutorial/gf-tutorial.html">Old Tutorial</a>, application-oriented.
+
+<a href="gf-lrec-2010.pdf">New Tutorial</a>, linguistics-oriented.
+
+<a href="gf-refman.html">ReferenceManual</a>.
+
+<a href="../lib/resource/doc/synopsis.html">LibrarySynopsis</a>.
+
+
+
+
+<h2>Language and system documentation</h2>
+
+<ul>
+
+  <li>
+  <a href="gf-reference.html">GF Quick Reference</a>. Also available in
+  <a href="gf-reference.pdf">pdf</a>. Covers all features of GF language
+  in a summary format.
+
+  <li>
+  <a href="gf-refman.html">GF Reference Manual</a>. A full-scale reference
+  manual of the GF language.
+  
+  <li>
+  <a href="gf-shell-reference.html">GF Shell Reference</a>.
+  Describes the commands available in the interactive GF shell. Also
+  summarizes how to run GF as a batch compiler.
+
+  <li>
+  <a href="gf-editor-modes.html">Editor modes for GF</a>.
+  Editor modes for GF provides syntax highligting, automatic indentation and
+  other features that makes editing GF grammar files easier.
+  
+</ul>
+
+
+<h2>Publications</h2>
+
+<a href="gf-bibliography.html">
+Bibliography</a>: more publications on GF, as well as background literature.
+
+
+</body></html>

doc/index.md

@@ -1,13 +0,0 @@
----
-title: Grammatical Framework Documentation
----
-
-Perhaps you're looking for one of the following:
-
-- [Tutorial](tutorial/gf-tutorial.html). This is a hands-on introduction to grammar writing in GF.
-- [Reference Manual](gf-refman.html). A full-scale reference manual of the GF language.
-- [RGL Tutorial](../lib/doc/rgl-tutorial/index.html)
-- [RGL Synopsis](../lib/doc/synopsis/index.html). Documentation of the Resource Grammar Library, including the syntax API and lexical paradigms for each language.
-- [Shell Reference](gf-shell-reference.html). Describes the commands available in the interactive GF shell.
-  Also summarizes how to run GF as a batch compiler.
-- [Developers Guide](gf-developers/html). Detailed information about building and developing GF.

doc/python-api.html

@@ -0,0 +1,433 @@
+<html>
+	<head>
+<style>
+.code {background-color:lightgray}
+</style>
+	</head>
+	<body>
+		<h1>Using the Python binding to the C runtime</h1>
+		<h4>Krasimir Angelov, July 2015</h4>
+		
+<h2>Loading the Grammar</h2>
+
+Before you use the Python binding you need to import the pgf module.
+<pre class="code">
+>>> import pgf
+</pre>
+
+Once you have the module imported, you can use the <tt>dir</tt> and
+<tt>help</tt> functions to see what kind of functionality is available.
+<tt>dir</tt> takes an object and returns a list of methods available
+in the object:
+<pre class="code">
+>>> dir(pgf)
+</pre>
+<tt>help</tt> is a little bit more advanced and it tries
+to produce more human readable documentation, which more over
+contains comments:
+<pre class="code">
+>>> help(pgf)
+</pre>
+
+A grammar is loaded by calling the method readPGF:
+<pre class="code">
+>>> gr = pgf.readPGF("App12.pgf")
+</pre>
+
+From the grammar you can query the set of available languages.
+It is accessible through the property <tt>languages</tt> which
+is a map from language name to an object of class <tt>pgf.Concr</tt>
+which respresents the language.
+For example the following will extract the English language:
+<pre class="code">
+>>> eng = gr.languages["AppEng"]
+>>> print eng
+&lt;pgf.Concr object at 0x7f7dfa4471d0&gt;
+</pre>
+
+<h2>Parsing</h2>
+
+All language specific services are available as methods of the
+class <tt>pgf.Concr</tt>. For example to invoke the parser, you
+can call:
+<pre class="code">
+>>> i = eng.parse("this is a small theatre")
+</pre>
+This gives you an iterator which can enumerates all possible
+abstract trees. You can get the next tree by calling next:
+<pre class="code">
+>>> p,e = i.next()
+</pre>
+The results are always pairs of probability and tree. The probabilities
+are negated logarithmic probabilities and which means that the lowest
+number encodes the most probable result. The possible trees are
+returned in decreasing probability order (i.e. increasing negated logarithm).
+The first tree should have the smallest <tt>p</tt>:
+<pre class="code">
+>>> print p
+35.9166526794
+</pre>
+and this is the corresponding abstract tree:
+<pre class="code">
+>>> print e
+PhrUtt NoPConj (UttS (UseCl (TTAnt TPres ASimul) PPos (PredVP (DetNP (DetQuant this_Quant NumSg)) (UseComp (CompNP (DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA small_A) (UseN theatre_N)))))))) NoVoc
+</pre>
+
+The <tt>parse</tt> method has also the following optional parameters:
+<table border=1>
+	<tr><td>cat</td><td>start category</td></tr>
+	<tr><td>n</td><td>maximum number of trees</td></tr>
+	<tr><td>heuristics</td><td>a real number from 0 to 1</td></tr>
+	<tr><td>callbacks</td><td>a list of category and callback function</td></tr>
+</table>
+
+By using these parameters it is possible for instance to change the start category for
+the parser or to limit the number of trees returned from the parser. For example
+parsing with a different start category can be done as follows:
+<pre class="code">
+>>> i = eng.parse("a small theatre", cat="NP")
+</pre>
+
+<p>The heuristics factor can be used to trade parsing speed for quality.
+By default the list of trees is sorted by probability this corresponds
+to factor 0.0. When we increase the factor then parsing becomes faster
+but at the same time the sorting becomes imprecise. The worst
+factor is 1.0. In any case the parser always returns the same set of
+trees but in different order. Our experience is that even a factor
+of about 0.6-0.8 with the translation grammar, still orders 
+the most probable tree on top of the list but further down the list
+the trees become shuffled.
+</p>
+
+<p>
+The callbacks is a list of functions that can be used for recognizing
+literals. For example we use those for recognizing names and unknown
+words in the translator.
+</p>
+
+<h2>Linearization</h2>
+
+You can either linearize the result from the parser back to another
+language, or you can explicitly construct a tree and then
+linearize it in any language. For example, we can create
+a new expression like this:
+<pre class="code">
+>>> e = pgf.readExpr("AdjCN (PositA red_A) (UseN theatre_N)")
+</pre>
+and then we can linearize it:
+<pre class="code">
+>>> print eng.linearize(e)
+red theatre
+</pre>
+This method produces only a single linearization. If you use variants
+in the grammar then you might want to see all possible linearizations.
+For that purpouse you should use linearizeAll:
+<pre class="code">
+>>> for s in eng.linearizeAll(e):
+       print s
+red theatre
+red theater
+</pre>
+If, instead, you need an inflection table with all possible forms
+then the right method to use is tabularLinearize:
+<pre class="code">
+>>> eng.tabularLinearize(e):
+{'s Sg Nom': 'red theatre', 's Pl Nom': 'red theatres', 's Pl Gen': "red theatres'", 's Sg Gen': "red theatre's"}
+</pre>
+
+<p>
+Finally, you could also get a linearization which is bracketed into
+a list of phrases:
+<pre class="code">
+>>> [b] = eng.bracketedLinearize(e)
+>>> print b
+(CN:4 (AP:1 (A:0 red)) (CN:3 (N:2 theatre)))
+</pre>
+Each bracket is actually an object of type pgf.Bracket. The property
+<tt>cat</tt> of the object gives you the name of the category and 
+the property children gives you a list of nested brackets.
+If a phrase is discontinuous then it is represented as more than
+one brackets with the same category name. In that case, the index
+that you see in the example above will have the same value for all
+brackets of the same phrase.
+</p>
+
+The linearization works even if there are functions in the tree 
+that doesn't have linearization definitions. In that case you
+will just see the name of the function in the generated string.
+It is sometimes helpful to be able to see whether a function
+is linearizable or not. This can be done in this way:
+<pre class="code">
+>>> print eng.hasLinearization("apple_N")
+</pre>
+
+<h2>Analysing and Constructing Expressions</h2>
+
+<p>
+An already constructed tree can be analyzed and transformed
+in the host application. For example you can deconstruct 
+a tree into a function name and a list of arguments:
+<pre class="code">
+>>> e.unpack()
+('AdjCN', [&lt;pgf.Expr object at 0x7f7df6db78c8&gt;, &lt;pgf.Expr object at 0x7f7df6db7878&gt;])
+</pre>
+
+The result from unpack can be different depending on the form of the
+tree. If the tree is a function application then you always get
+a tuple of function name and a list of arguments. If instead the
+tree is just a literal string then the return value is the actual
+literal. For example the result from:
+<pre class="code">
+>>> pgf.readExpr('"literal"').unpack()
+'literal'
+</pre>
+is just the string 'literal'. Situations like this can be detected
+in Python by checking the type of the result from <tt>unpack</tt>.
+</p>
+
+<p>
+For more complex analyses you can use the visitor pattern.
+In object oriented languages this is just a clumpsy way to do
+what is called pattern matching in most functional languages.
+You need to define a class which has one method for each function
+in the abstract syntax of the grammar. If the functions is called
+<tt>f</tt> then you need a method called <tt>on_f</tt>. The method
+will be called each time when the corresponding function is encountered,
+and its arguments will be the arguments from the original tree.
+If there is no matching method name then the runtime will
+to call the method <tt>default</tt>. The following is an example:
+<pre class="code">
+>>> class ExampleVisitor:
+		def on_DetCN(self,quant,cn):
+			print "Found DetCN"
+			cn.visit(self)
+			
+		def on_AdjCN(self,adj,cn):
+			print "Found AdjCN"
+			cn.visit(self)
+			
+		def default(self,e):
+			pass
+>>> e2.visit(ExampleVisitor())
+Found DetCN
+Found AdjCN
+</pre>
+Here we call the method <tt>visit</tt> from the tree e2 and we give
+it, as parameter, an instance of class <tt>ExampleVisitor</tt>.
+<tt>ExampleVisitor</tt> has two methods <tt>on_DetCN</tt>
+and <tt>on_AdjCN</tt> which are called when the top function of
+the current tree is <tt>DetCN</tt> or <tt>AdjCN</tt>
+correspondingly. In this example we just print a message and
+we call <tt>visit</tt> recursively to go deeper into the tree.
+</p>
+
+Constructing new trees is also easy. You can either use 
+<tt>readExpr</tt> to read trees from strings, or you can
+construct new trees from existing pieces. This is possible by
+using the constructor for <tt>pgf.Expr</tt>:
+<pre class="code">
+>>> quant = pgf.readExpr("DetQuant IndefArt NumSg")
+>>> e2 = pgf.Expr("DetCN", [quant, e])
+>>> print e2
+DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA red_A) (UseN theatre_N))
+</pre>
+
+<h2>Embedded GF Grammars</h2>
+
+The GF compiler allows for easy integration of grammars in Haskell
+applications. For that purpose the compiler generates Haskell code
+that makes the integration of grammars easier. Since Python is a
+dynamic language the same can be done at runtime. Once you load
+the grammar you can call the method <tt>embed</tt>, which will
+dynamically create a Python module with one Python function 
+for every function in the abstract syntax of the grammar.
+After that you can simply import the module:
+<pre class="code">
+>>> gr.embed("App")
+&lt;module 'App' (built-in)&gt;
+>>> import App
+</pre>
+Now creating new trees is just a matter of calling ordinary Python
+functions:
+<pre class="code">
+>>> print App.DetCN(quant,e)
+DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA red_A) (UseN house_N))
+</pre>
+
+<h2>Access the Morphological Lexicon</h2>
+
+There are two methods that gives you direct access to the morphological
+lexicon. The first makes it possible to dump the full form lexicon.
+The following code just iterates over the lexicon and prints each
+word form with its possible analyses:
+<pre class="code">
+for entry in eng.fullFormLexicon():
+	print entry
+</pre>
+The second one implements a simple lookup. The argument is a word
+form and the result is a list of analyses:
+<pre class="code">
+print eng.lookupMorpho("letter")
+[('letter_1_N', 's Sg Nom', inf), ('letter_2_N', 's Sg Nom', inf)]
+</pre>
+
+<h2>Access the Abstract Syntax</h2>
+
+There is a simple API for accessing the abstract syntax. For example,
+you can get a list of abstract functions:
+<pre class="code">
+>>> gr.functions
+....
+</pre>
+or a list of categories:
+<pre class="code">
+>>> gr.categories
+....
+</pre>
+You can also access all functions with the same result category:
+<pre class="code">
+>>> gr.functionsByCat("Weekday")
+['friday_Weekday', 'monday_Weekday', 'saturday_Weekday', 'sunday_Weekday', 'thursday_Weekday', 'tuesday_Weekday', 'wednesday_Weekday']
+</pre>
+The full type of a function can be retrieved as:
+<pre class="code">
+>>> print gr.functionType("DetCN")
+Det -> CN -> NP
+</pre>
+
+<h2>Type Checking Abstract Trees</h2>
+
+<p>The runtime type checker can do type checking and type inference
+for simple types. Dependent types are still not fully implemented
+in the current runtime. The inference is done with method <tt>inferExpr</tt>:
+<pre class="code">
+>>> e,ty = gr.inferExpr(e)
+>>> print e
+AdjCN (PositA red_A) (UseN theatre_N)
+>>> print ty
+CN
+</pre>
+The result is a potentially updated expression and its type. In this
+case we always deal with simple types, which means that the new
+expression will be always equal to the original expression. However, this
+wouldn't be true when dependent types are added.
+</p>
+
+<p>Type checking is also trivial:
+<pre class="code">
+>>> e = gr.checkExpr(e,pgf.readType("CN"))
+>>> print e
+AdjCN (PositA red_A) (UseN theatre_N)
+</pre>
+In case of type error you will get an exception:
+<pre class="code">
+>>> e = gr.checkExpr(e,pgf.readType("A"))
+pgf.TypeError: The expected type of the expression AdjCN (PositA red_A) (UseN theatre_N) is A but CN is infered
+</pre>
+</p>
+
+<h2>Partial Grammar Loading</h2>
+
+By default the whole grammar is compiled into a single file
+which consists of an abstract syntax together will all concrete
+languages. For large grammars with many languages this might be
+inconvinient because loading becomes slower and the grammar takes
+more memory. For that purpose you could split the grammar into
+one file for the abstract syntax and one file for every concrete syntax.
+This is done by using the option <tt>-split-pgf</tt> in the compiler:
+<pre class="code">
+$ gf -make -split-pgf App12.pgf
+</pre>
+
+Now you can load the grammar as usual but this time only the
+abstract syntax will be loaded. You can still use the <tt>languages</tt>
+property to get the list of languages and the corresponding
+concrete syntax objects:
+<pre class="code">
+>>> gr = pgf.readPGF("App.pgf")
+>>> eng = gr.languages["AppEng"]
+</pre>
+However, if you now try to use the concrete syntax then you will
+get an exception:
+<pre class="code">
+>>> gr.languages["AppEng"].lookupMorpho("letter")
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+pgf.PGFError: The concrete syntax is not loaded
+</pre>
+
+Before using the concrete syntax, you need to explicitly load it: 
+<pre class="code">
+>>> eng.load("AppEng.pgf_c")
+>>> print eng.lookupMorpho("letter")
+[('letter_1_N', 's Sg Nom', inf), ('letter_2_N', 's Sg Nom', inf)]
+</pre>
+
+When you don't need the language anymore then you can simply
+unload it:
+<pre class="code">
+>>> eng.unload()
+</pre>
+
+<h2>GraphViz</h2>
+
+GraphViz is used for visualizing abstract syntax trees and parse trees.
+In both cases the result is a GraphViz code that can be used for
+rendering the trees. See the examples bellow.
+
+<pre class="code">
+>>> print gr.graphvizAbstractTree(e)
+graph {
+n0[label = "AdjCN", style = "solid", shape = "plaintext"]
+n1[label = "PositA", style = "solid", shape = "plaintext"]
+n2[label = "red_A", style = "solid", shape = "plaintext"]
+n1 -- n2 [style = "solid"]
+n0 -- n1 [style = "solid"]
+n3[label = "UseN", style = "solid", shape = "plaintext"]
+n4[label = "theatre_N", style = "solid", shape = "plaintext"]
+n3 -- n4 [style = "solid"]
+n0 -- n3 [style = "solid"]
+}
+</pre>
+
+<pre class="code">
+>>> print eng.graphvizParseTree(e)
+graph {
+  node[shape=plaintext]
+
+  subgraph {rank=same;
+    n4[label="CN"]
+  }
+
+  subgraph {rank=same;
+    edge[style=invis]
+    n1[label="AP"]
+    n3[label="CN"]
+    n1 -- n3
+  }
+  n4 -- n1
+  n4 -- n3
+
+  subgraph {rank=same;
+    edge[style=invis]
+    n0[label="A"]
+    n2[label="N"]
+    n0 -- n2
+  }
+  n1 -- n0
+  n3 -- n2
+
+  subgraph {rank=same;
+    edge[style=invis]
+    n100000[label="red"]
+    n100001[label="theatre"]
+    n100000 -- n100001
+  }
+  n0 -- n100000
+  n2 -- n100001
+}
+</pre>
+
+	</body>
+</html>
+

doc/tutorial/gf-tutorial.t2t

@@ -8,8 +8,7 @@ December 2010 for GF 3.2
 % txt2tags --toc -ttex gf-tutorial.txt
 
 %!target:html
-%!encoding: utf-8
-%!options: --toc
+%!encoding: iso-8859-1
 
 %!postproc(tex) : "\\subsection\*" "\\newslide"
 %!preproc(tex): "#NEW" ""
@@ -618,32 +617,32 @@ and **semantic definitions**.
 
 
 
-% #NEW
-%
-% ==Slides==
-%
-% You can chop this tutorial into a set of slides by the command
-% ```
-%   htmls gf-tutorial.html
-% ```
-% where the program ``htmls`` is distributed with GF (see below), in
-%
-%   [``GF/src/tools/Htmls.hs`` http://grammaticalframework.org/src/tools/Htmls.hs]
-%
-% The slides will appear as a set of files beginning with ``01-gf-tutorial.htmls``.
-%
-% Internal links will not work in the slide format, except for those in the
-% upper left corner of each slide, and the links behind the "Contents" link.
+#NEW
+
+==Slides==
+
+You can chop this tutorial into a set of slides by the command
+```
+  htmls gf-tutorial.html
+```
+where the program ``htmls`` is distributed with GF (see below), in
+
+  [``GF/src/tools/Htmls.hs`` http://grammaticalframework.org/src/tools/Htmls.hs]
+
+The slides will appear as a set of files beginning with ``01-gf-tutorial.htmls``.
+
+Internal links will not work in the slide format, except for those in the
+upper left corner of each slide, and the links behind the "Contents" link.
 
 
 
 #NEW
 
-#Lchaptwo
-
 =Lesson 1: Getting Started with GF=
 
 
+#Lchaptwo
+
 Goals:
 - install and run GF
 - write the first GF grammar: a "Hello World" grammar in three languages
@@ -836,8 +835,8 @@ Finnish and an Italian concrete syntaxes:
     lin
       Hello recip = {s = "terve" ++ recip.s} ;
       World = {s = "maailma"} ;
-      Mum = {s = "äiti"} ;
-      Friends = {s = "ystävät"} ;
+      Mum = {s = "äiti"} ;
+      Friends = {s = "ystävät"} ;
   }
 
   concrete HelloIta of Hello = {
@@ -925,7 +924,7 @@ Default of the language flag (``-lang``): the last-imported concrete syntax.
 **Multilingual generation**:
 ```
   > parse -lang=HelloEng "hello friends" | linearize
-  terve ystävät
+  terve ystävät
   ciao amici
   hello friends
 ```
@@ -1037,10 +1036,9 @@ Application programs, using techniques from #Rchapeight:
 
 #NEW
 
-#Lchapthree
-
 =Lesson 2: Designing a grammar for complex phrases=
 
+#Lchapthree
 
 Goals:
 - build a larger grammar: phrases about food in English and Italian
@@ -1336,7 +1334,7 @@ Just (?) replace English words with their dictionary equivalents:
       Phrase, Item, Kind, Quality = {s : Str} ;
 
     lin
-      Is item quality = {s = item.s ++ "è" ++ quality.s} ;
+      Is item quality = {s = item.s ++ "č" ++ quality.s} ;
       This kind = {s = "questo" ++ kind.s} ;
       That kind = {s = "quel" ++ kind.s} ;
       QKind quality kind = {s = kind.s ++ quality.s} ;
@@ -1447,11 +1445,11 @@ linearizations in different languages:
   > gr -number=2 | l -treebank
 
   Is (That Cheese) (Very Boring)
-  quel formaggio è molto noioso
+  quel formaggio č molto noioso
   that cheese is very boring
 
   Is (That Cheese) Fresh
-  quel formaggio è fresco
+  quel formaggio č fresco
   that cheese is fresh
 ```
 
@@ -1473,14 +1471,14 @@ answer given in another language.
   You can interrupt the quiz by entering a line consisting of a dot ('.').
 
   this fish is warm
-  questo pesce è caldo
+  questo pesce č caldo
   > Yes.
   Score 1/1
 
   this cheese is Italian
-  questo formaggio è noioso
-  > No, not questo formaggio è noioso, but
-  questo formaggio è italiano
+  questo formaggio č noioso
+  > No, not questo formaggio č noioso, but
+  questo formaggio č italiano
 
   Score 1/2
   this fish is expensive
@@ -1757,7 +1755,7 @@ Simultaneous extension and opening:
     lincat
       Question = SS ;
     lin
-      QIs item quality = ss (item.s ++ "è" ++ quality.s) ;
+      QIs item quality = ss (item.s ++ "č" ++ quality.s) ;
       Pizza = ss "pizza" ;
   }
 ```
@@ -1798,10 +1796,9 @@ where
 
 #NEW
 
-#Lchapfour
-
 =Lesson 3: Grammars with parameters=
 
+#Lchapfour
 
 Goals:
 - implement sophisticated linguistic structures:
@@ -2366,10 +2363,10 @@ in English, with special care taken of variations with the suffix
 
 + Implement the German **Umlaut** operation on word stems.
 The operation changes the vowel of the stressed stem syllable as follows:
-//a// to //ä//, //au// to //äu//, //o// to //ö//, and //u// to //ü//. You
+//a// to //ä//, //au// to //äu//, //o// to //ö//, and //u// to //ü//. You
 can assume that the operation only takes syllables as arguments. Test the
-operation to see whether it correctly changes //Arzt// to //Ärzt//,
-//Baum// to //Bäum//, //Topf// to //Töpf//, and //Kuh// to //Küh//.
+operation to see whether it correctly changes //Arzt// to //Ärzt//,
+//Baum// to //Bäum//, //Topf// to //Töpf//, and //Kuh// to //Küh//.
 
 
 
@@ -2482,10 +2479,10 @@ The command ``morpho_quiz = mq`` generates inflection exercises.
   Welcome to GF Morphology Quiz.
   ...
 
-  réapparaître : VFin VCondit  Pl  P2
-  réapparaitriez
-  > No, not réapparaitriez, but
-  réapparaîtriez
+  réapparaître : VFin VCondit  Pl  P2
+  réapparaitriez
+  > No, not réapparaitriez, but
+  réapparaîtriez
   Score 0/1
 ```
 To create a list for later use, use the command ``morpho_list = ml``
@@ -2565,7 +2562,7 @@ We need only number variation for the copula.
 ```
     copula : Number -> Str =
       \n -> case n of {
-        Sg => "è" ;
+        Sg => "č" ;
         Pl => "sono"
         } ;
 ```
@@ -2774,10 +2771,9 @@ Thus
 
 #NEW
 
-#Lchapfive
-
 =Lesson 4: Using the resource grammar library=
 
+#Lchapfive
 
 Goals:
 - navigate in the GF resource grammar library and use it in applications
@@ -3308,13 +3304,13 @@ we can write a **functor instantiation**,
   oper
     wine_N = mkN "Wein" ;
     pizza_N = mkN "Pizza" "Pizzen" feminine ;
-    cheese_N = mkN "Käse" "Käsen" masculine ;
+    cheese_N = mkN "Käse" "Käsen" masculine ;
     fish_N = mkN "Fisch" ;
     fresh_A = mkA "frisch" ;
-    warm_A = mkA "warm" "wärmer" "wärmste" ;
+    warm_A = mkA "warm" "wärmer" "wärmste" ;
     italian_A = mkA "italienisch" ;
     expensive_A = mkA "teuer" ;
-    delicious_A = mkA "köstlich" ;
+    delicious_A = mkA "köstlich" ;
     boring_A = mkA "langweilig" ;
   }
 ```
@@ -3365,11 +3361,11 @@ Lexicon instance
     cheese_N = mkN "juusto" ;
     fish_N = mkN "kala" ;
     fresh_A = mkA "tuore" ;
-    warm_A = mkA "lämmin" ;
+    warm_A = mkA "lämmin" ;
     italian_A = mkA "italialainen" ;
     expensive_A = mkA "kallis" ;
     delicious_A = mkA "herkullinen" ;
-    boring_A = mkA "tylsä" ;
+    boring_A = mkA "tylsä" ;
   }
 ```
 Functor instantiation
@@ -3617,10 +3613,9 @@ tenses and moods, e.g. the Romance languages.
 
 #NEW
 
-#Lchapsix
-
 =Lesson 5: Refining semantics in abstract syntax=
 
+#Lchapsix
 
 Goals:
 - include semantic conditions in grammars, by using
@@ -3630,7 +3625,7 @@ Goals:
   - semantic definitions
 
 These concepts are inherited from **type theory** (more precisely:
-constructive type theory, or Martin-Löf type theory).
+constructive type theory, or Martin-Löf type theory).
 
 Type theory is the basis **logical frameworks**.
 
@@ -4181,11 +4176,11 @@ Type checking can be invoked with ``put_term -transform=solve``.
 
 #NEW
 
-#Lchapseven
-
 ==Lesson 6: Grammars of formal languages==
 
 
+#Lchapseven
+
 Goals:
 - write grammars for formal languages (mathematical notation, programming languages)
 - interface between formal and natural langauges
@@ -4520,10 +4515,9 @@ point literals as arguments.
 
 #NEW
 
-#Lchapeight
-
 =Lesson 7: Embedded grammars=
 
+#Lchapeight
 
 Goals:
 - use grammars as parts of programs written in Haskell and JavaScript
@@ -4644,7 +4638,7 @@ output. Therefore it can be a part of a pipe and read and write files.
 The simplest way to translate is to ``echo`` input to the program:
 ```
   % echo "this wine is delicious" | ./trans Food.pgf
-  questo vino è delizioso
+  questo vino č delizioso
 ```
 The result is given in all languages except the input language.
 
@@ -4816,7 +4810,7 @@ instance Gf GQuestion where
       DTr [] (AC (CId "Prime")) [x1] -> GPrime (fg x1)
       _ -> error ("no Question " ++ show t)
 ```
-For the programmer, it is enough to know:
+For the programmer, it is enougo to know:
 - all GF names are in Haskell prefixed with ``G``
 - ``gf`` translates from Haskell objects to GF trees
 - ``fg`` translates from GF trees to Haskell objects
@@ -4963,12 +4957,12 @@ syntax name. This file contains the multilingual grammar as a JavaScript object.
 ===Using the JavaScript grammar===
 
 To perform parsing and linearization, the run-time library
-``gflib.js`` is used. It is included in ``/src/runtime/javascript/``, together with
+``gflib.js`` is used. It is included in ``GF/lib/javascript/``, together with
 some other JavaScript and HTML files; these files can be used
 as templates for building applications.
 
 An example of usage is
-[``translator.html`` ../../src/runtime/javascript/translator.html],
+[``translator.html`` http://grammaticalframework.org:41296],
 which is in fact initialized with
 a pointer to the Food grammar, so that it provides translation between the English
 and Italian grammars:

doc/txt2html.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+FILES="darcs.txt transfer-reference.txt transfer-tutorial.txt \
+      transfer.txt"
+
+for f in $FILES; do
+  h=`basename "$f" ".txt"`.html
+  if [ "$f" -nt "$h" ]; then 
+    txt2tags $f
+  else
+    echo "$h is newer than $f, skipping"
+  fi
+done

download.html

@@ -0,0 +1,54 @@
+<html>
+<body>
+
+GF Version 2.8, released 8 July 2007; updated 12 September.
+<ul>
+<li> <a href="download/GF-2.8.tgz"><tt>GF-2.8.tgz</tt></a>, 
+Haskell and Java sources, grammar library sources, examples, documentation.
+To compile and install: read <a href="src/INSTALL"><tt>src/INSTALL</tt></a>.
+
+<li> <a href="download/GF-2.8-lib.tgz"><tt>GF-2.8-lib.tgz</tt></a>,
+Compiled grammar libraries</a>. To install: 
+unpack this in the directory pointed by <tt>GF_LIB_PATH</tt>.
+
+<li> <a href="download/GF-2.8-i386-pc-linux-gnu.tgz"><tt>GF-2.8-i386-pc-linux-gnu.tgz</tt></a>,
+Linux binary, with precompiled grammar libraries. To install:
+<pre>
+  tar xvfz GF-2.8-i386-pc-linux-gnu.tgz
+  cd GF-2.8-i386-pc-linux-gnu
+  ./configure
+  make install
+</pre>
+You may need <tt>sudo make install</tt>; if you cannot write in 
+<tt>/usr/local/</tt>, you can change the target directory
+by <tt>./configure --prefix=MYDIR</tt>.
+
+
+<li> <a href="download/GF-2.8-i386-apple-darwin8.9.1.tgz"><tt>GF-2.8-i386-apple-darwin8.9.1.tgz</tt></a>, Mac OS X binary (Intel), with precompiled grammar libraries. Requires Readline from
+<a href="http://www.macports.org/">MacPorts</a>. To install, see above item.
+
+<li> <a href="download/GF-2.8-windows-cygwin.tgz"><tt>GF-2.8-windows-cygwin.tgz</tt></a>, Windows Cygwin binary. Requires 
+<a href="http://www.cygwin.com/">Cygwin</a>. To install, see above item.
+
+</ul>
+The <a href=
+"http://sourceforge.net/project/showfiles.php?group_id=132285">Sourceforge GF site</a> 
+has currently only v 2.7 and older versions.
+
+<p>
+
+Don't forget that you can always get the current sources from the
+<a href="http://www.cs.chalmers.se/Cs/Research/Language-technology/darcs/GF/doc/darcs.html">GF Darcs Repository</a>. First time you do
+<pre>
+  darcs get --partial --set-scripts-executable http://www.cs.chalmers.se/Cs/Research/Language-technology/darcs/GF/
+</pre>
+and subsequent times
+<pre>
+  darcs pull -a
+</pre>
+Then compile and install as described in 
+<a href="src/INSTALL"><tt>GF/src/INSTALL</tt></a>.
+
+
+</body>
+</html>

download/encoding-change.t2t

@@ -1,6 +1,10 @@
 GF character encoding changes
 Thomas Hallgren
-2013-12-18
+%%mtime(%F)
+
+%!style:../css/style.css
+%!postproc(html): <TITLE> <meta charset="UTF-8"><meta name = "viewport" content = "width = device-width"> <TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
 
 ==Changes to character encodings in GF grammar files ==
 

download/index-3.1.6.html

@@ -0,0 +1,93 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+<META NAME="generator" CONTENT="http://txt2tags.sf.net">
+<TITLE>Grammatical Framework Download and Installation</TITLE>
+</HEAD><BODY BGCOLOR="white" TEXT="black">
+<P ALIGN="center"><CENTER><H1>Grammatical Framework Download and Installation</H1>
+<FONT SIZE="4">
+<I>Version 3.1.6, 23 April 2010</I><BR>
+</FONT></CENTER>
+
+<H2>Latest developer code</H2>
+<P>
+<A HREF="../doc/darcs.html">GF darcs repository</A>
+</P>
+<H2>Latest release</H2>
+<P>
+GF 3.1.6 released 23 April 2010.
+</P>
+<UL>
+<LI>MacOS X installer package:
+  <A HREF="gf-3.1.6-leopard.pkg"><CODE>gf-3.1.6-leopard.pkg</CODE></A> (7.7MB)
+<LI>MacOS X (gzipped executable, Leopard and Snow Leopard):
+  <A HREF="gf-3.1.6-bin-intel-mac.gz"><CODE>gf-3.1.6-bin-intel-mac.gz</CODE></A> (1.9MB)
+<LI>Windows (zipped executable):
+  <A HREF="gf-3.1.6-bin-i486-windows.zip"><CODE>gf-3.1.6-bin-i486-windows.zip</CODE></A>
+  (1.6 MB)
+<LI>Ubuntu Linux (gzipped executable): 
+  <A HREF="gf-3.1.6-bin-i486-linux.gz"><CODE>gf-3.1.6-bin-i486-linux.gz</CODE></A>
+  (1.7 MB)
+<LI>compiled library package:
+  <A HREF="gf-3.1.6-lib.tar.gz"><CODE>gf-3.1.6-lib.tar.gz</CODE></A>
+  (4.4 MB)
+<LI>full source package (GF system, libraries, examples, documentation):
+  <A HREF="gf-3.1.6-src.tar.gz"><CODE>gf-3.1.6-src.tar.gz</CODE></A>
+  (11 MB)
+<P></P>
+GF is also on <A HREF="http://hackage.haskell.org/package/gf">Hackage</A>
+</UL>
+
+<P>
+What's new? See the <A HREF="release-3.1.6.html">release notes</A>.
+</P>
+<H2>Previous releases</H2>
+<P>
+<A HREF="old-index.html">Follow this link</A>.
+</P>
+<H2>Installation instructions</H2>
+<P>
+The Windows package is installed by just unpacking it anywhere. 
+It finds the libraries relative to the <CODE>.exe</CODE> file.
+</P>
+<P>
+To install a binary package for MacOS X or Linux: uncompress the executable and
+put it somewhere on your path, renaming it to just <CODE>gf</CODE>. For instance:
+</P>
+<PRE>
+    gunzip gf-bin-[version].gz
+    sudo mv gf-bin-[version] /usr/local/bin/gf
+</PRE>
+<P>
+To install the libraries (if done separately), unpack them in the place to which your
+<CODE>GF_LIB_PATH</CODE> points.
+</P>
+<PRE>
+    cd $GF_LIB_PATH
+    gtar xvfz gf-lib-[VERSION].tgz
+</PRE>
+<P>
+If this variable hasn't been defined, it is useful define it, e.g.
+</P>
+<PRE>
+    export GF_LIB_PATH=/usr/local/lib/gf/
+</PRE>
+<P></P>
+<P>
+To compile and install from source on Mac or Linux, do:
+</P>
+<PRE>
+    tar xvfz gf-[VERSION].tgz
+    cd GF/src
+    runghc Setup configure --user
+    runghc Setup build
+    runghc Setup install
+</PRE>
+<P>
+The last command must be prefixed by <CODE>sudo</CODE>, if the installation is outside
+user-writeable area.
+</P>
+
+<!-- html code generated by txt2tags 2.5 (http://txt2tags.sf.net) -->
+<!-- cmdline: txt2tags -thtml ./download/index-3.1.6.t2t -->
+</BODY></HTML>

download/index-3.1.6.t2t

@@ -16,7 +16,7 @@ GF 3.1.6 released 23 April 2010.
 - Windows (zipped executable):
   [``gf-3.1.6-bin-i486-windows.zip`` gf-3.1.6-bin-i486-windows.zip]
   (1.6 MB)
-- Ubuntu Linux (gzipped executable):
+- Ubuntu Linux (gzipped executable): 
   [``gf-3.1.6-bin-i486-linux.gz`` gf-3.1.6-bin-i486-linux.gz]
   (1.7 MB)
 - compiled library package:
@@ -25,7 +25,7 @@ GF 3.1.6 released 23 April 2010.
 - full source package (GF system, libraries, examples, documentation):
   [``gf-3.1.6-src.tar.gz`` gf-3.1.6-src.tar.gz]
   (11 MB)
-
+  
 GF is also on [Hackage http://hackage.haskell.org/package/gf]
 
 
@@ -40,7 +40,7 @@ What's new? See the [release notes release-3.1.6.html].
 ==Installation instructions==
 
 
-The Windows package is installed by just unpacking it anywhere.
+The Windows package is installed by just unpacking it anywhere. 
 It finds the libraries relative to the ``.exe`` file.
 
 To install a binary package for MacOS X or Linux: uncompress the executable and

download/index-3.2.9.t2t

@@ -1,6 +1,11 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/style.css
+%!postproc(html): <TD><B> <TH>
+%!postproc(html): </B></TD> </TH>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 **GF 3.2.9** source-only snapshot was released on 12 September 2011.
 
 What's new? Faster grammar compilation!
@@ -72,3 +77,9 @@ The above notes for installing from source apply also in this case.
 - [GF 3.2 index-3.2.html] (December 2011).
 - [GF 3.1.6 index-3.1.6.html] (April 2010).
 - [GF 3.1 old-index.html] (December 2009).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]
+ 

download/index-3.2.t2t

@@ -1,6 +1,11 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/style.css
+%!postproc(html): <TD><B> <TH>
+%!postproc(html): </B></TD> </TH>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 **GF 3.2** was released on 23 December 2010.
 
 What's new? See the [Release notes release-3.2.html].
@@ -22,7 +27,7 @@ More packages might be added later.
 
 ===Notes===
 
-The Windows package is installed by just unpacking it anywhere.
+The Windows package is installed by just unpacking it anywhere. 
 It finds the libraries relative to the ``.exe`` file.
 
 The ``.deb`` packages work on Ubuntu 10.04 and 10.10.
@@ -100,3 +105,8 @@ Subsequently:
 ```
 
 The above notes for installing from source apply also in this case.
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]
+ 

download/index-3.3.3.t2t

@@ -1,6 +1,12 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/style.css
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <TD><B> <TH>
+%!postproc(html): </B></TD> </TH>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 **GF 3.3.3** was released on 3 March 2012.
 
 What's new? See the [Release notes release-3.3.3.html].
@@ -18,7 +24,7 @@ What's new? See the [Release notes release-3.3.3.html].
 
 ===Notes===
 
-The Windows package is installed by just unpacking it anywhere.
+The Windows package is installed by just unpacking it anywhere. 
 It finds the libraries relative to the ``.exe`` file.
 
 %The ``.deb`` packages work on Ubuntu 10.04 and 10.10.
@@ -121,3 +127,9 @@ For more info, see the [GF Developers Guide ../doc/gf-developers.html].
 - [GF 3.2 index-3.2.html] (December 2010).
 - [GF 3.1.6 index-3.1.6.html] (April 2010).
 - [GF 3.1 old-index.html] (December 2009).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]
+ 

download/index-3.3.t2t

@@ -1,6 +1,11 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/style.css
+%!postproc(html): <TD><B> <TH>
+%!postproc(html): </B></TD> </TH>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 **GF 3.3** was released on 27 October 2011.
 
 What's new? See the [Release notes release-3.3.html].
@@ -22,7 +27,7 @@ More packages might be added later.
 
 ===Notes===
 
-The Windows package is installed by just unpacking it anywhere.
+The Windows package is installed by just unpacking it anywhere. 
 It finds the libraries relative to the ``.exe`` file.
 
 %The ``.deb`` packages work on Ubuntu 10.04 and 10.10.
@@ -110,3 +115,9 @@ The above notes for installing from source apply also in this case.
 - [GF 3.2 index-3.2.html] (December 2010).
 - [GF 3.1.6 index-3.1.6.html] (April 2010).
 - [GF 3.1 old-index.html] (December 2009).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]
+ 

download/index-3.4.t2t

@@ -1,6 +1,13 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/style.css
+%!postproc(html): </HEAD> <STYLE>body { color: #333; } li>code,p>code,pre { color: #730; }</STYLE></HEAD>
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <TD><B> <TH>
+%!postproc(html): </B></TD> </TH>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 **GF 3.4** was released on 31 January 2013.
 
 What's new? See the [Release notes release-3.4.html].
@@ -13,11 +20,14 @@ What's new? See the [Release notes release-3.4.html].
 | Fedora (32-bit) | [Fedora RPMs /~hallgren/tmp/Fedora/] | ``sudo rpm -i ...``
 | Ubuntu (32-bit) | [gf_3.4-1_i386.deb gf_3.4-1_i386.deb] | ``sudo dpkg -i gf_3.4-1_i386.deb``
 | Ubuntu (64-bit) | [gf_3.4-1_amd64.deb gf_3.4-1_amd64.deb] | ``sudo dpkg -i gf_3.4-1_amd64.deb``
-| Windows | [gf-3.4-bin-windows.zip gf-3.4-bin-windows.zip] | -
+| Windows | [gf-3.4-bin-windows.zip gf-3.4-bin-windows.zip] | 
+%| ... | ... | ...
+
+%More binary packages might be added later.
 
 ===Notes===
 
-%The Windows package is installed by just unpacking it anywhere.
+%The Windows package is installed by just unpacking it anywhere. 
 %It finds the libraries relative to the ``.exe`` file.
 
 The ``.deb`` packages work on Ubuntu 12.04, 12.10 and 13.04.
@@ -143,3 +153,8 @@ For more info on working with the GF source code, see the
 - [GF 3.2 index-3.2.html] (December 2010).
 - [GF 3.1.6 index-3.1.6.html] (April 2010).
 - [GF 3.1 old-index.html] (December 2009).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/index-3.5.t2t

@@ -1,6 +1,13 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/style.css
+%!postproc(html): </HEAD> <STYLE>body { color: #333; } li>code,p>code,pre { color: #730; }</STYLE></HEAD>
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <TD><B> <TH>
+%!postproc(html): </B></TD> </TH>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 **GF 3.5** was released on 6 August 2013.
 
 What's new? See the [Release notes release-3.5.html].
@@ -150,3 +157,8 @@ For more info on working with the GF source code, see the
 - [GF 3.2 index-3.2.html] (December 2010).
 - [GF 3.1.6 index-3.1.6.html] (April 2010).
 - [GF 3.1 old-index.html] (December 2009).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/index-3.6.t2t

@@ -1,6 +1,13 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/style.css
+%!postproc(html): </HEAD> <STYLE>body { color: #333; } li>code,p>code,pre { color: #730; }</STYLE></HEAD>
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+%!postproc(html): <TD><I> <TD><small>
+%!postproc(html): </I></TD> </small></TD>
+
 **GF 3.6** was released on 23 June 2014.
 
 What's new? See the [Release notes release-3.6.html].
@@ -170,3 +177,8 @@ For more info on working with the GF source code, see the
 - [GF 3.2 index-3.2.html] (December 2010).
 - [GF 3.1.6 index-3.1.6.html] (April 2010).
 - [GF 3.1 old-index.html] (December 2009).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/index-3.7.1.t2t

@@ -1,6 +1,12 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/notes.css
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+%!postproc(html): <TD><I> <TD><small>
+%!postproc(html): </I></TD> </small></TD>
+
 **GF 3.7.1** was released on 2 October 2015.
 
 What's new? See the [Release notes release-3.7.1.html].
@@ -40,7 +46,7 @@ The ``.deb`` packages work on Ubuntu 12.04, 14.04 and 15.04.
 
 The packages for Mac OS X should work on at least 10.9, 10.10 and 10.11 (Mavericks, Yosemite and El Capitan).
 
-(*) **Note** that for compatibility with OS X 10.11,
+(*) **Note** that for compatibility with OS X 10.11, 
 ``gf-3.7.1.pkg`` will install the ``gf`` executable in ``/usr/local/bin``
 instead of ``/usr/bin``, so make sure ``/usr/local/bin`` is in your  ``$PATH``.
 Also, if you still have an older version of GF installed in ``/usr/bin``,
@@ -174,3 +180,8 @@ For more info on working with the GF source code, see the
 - [GF 3.2 index-3.2.html] (December 2010).
 - [GF 3.1.6 index-3.1.6.html] (April 2010).
 - [GF 3.1 old-index.html] (December 2009).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/index-3.7.t2t

@@ -1,6 +1,13 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/style.css
+%!postproc(html): </HEAD> <STYLE>body { color: #333; } li>code,p>code,pre { color: #730; }</STYLE></HEAD>
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+%!postproc(html): <TD><I> <TD><small>
+%!postproc(html): </I></TD> </small></TD>
+
 **GF 3.7** was released on 25 June 2015.
 
 What's new? See the [Release notes release-3.7.html].
@@ -166,3 +173,8 @@ For more info on working with the GF source code, see the
 - [GF 3.2 index-3.2.html] (December 2010).
 - [GF 3.1.6 index-3.1.6.html] (April 2010).
 - [GF 3.1 old-index.html] (December 2009).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/index-3.9.t2t

@@ -1,192 +0,0 @@
-Grammatical Framework Download and Installation
-
-
-**GF 3.9** was released on 11 August 2017.
-
-What's new? See the [Release notes release-3.9.html].
-
-
-== Binary packages ==
-
-|| Platform | Download | Features | How to install
-| macOS | [gf-3.9.pkg gf-3.9.pkg] | //GF+S+C+J+P// | Double-click on the package icon
-| macOS | [gf-3.9-bin-intel-mac.tar.gz gf-3.9-bin-intel-mac.tar.gz] | //GF+S+C+J+P// | ``sudo tar -C /usr/local -zxf gf-3.9-bin-intel-mac.tar.gz``
-%| Fedora (32-bit) | [Fedora RPMs /~hallgren/tmp/Fedora/] | //GF+S+C+J+P// | ``sudo rpm -i ...``
-| Raspbian 9.1 | [gf_3.9-1_armhf.deb gf_3.9-1_armhf.deb] | //GF+S+C+J+P// | ``sudo dpkg -i gf_3.9-1_armhf.deb``
-| Ubuntu (32-bit) | [gf_3.9-1_i386.deb gf_3.9-1_i386.deb] | //GF+S+C+J+P// | ``sudo dpkg -i gf_3.9-1_i386.deb``
-| Ubuntu (64-bit) | [gf_3.9-1_amd64.deb gf_3.9-1_amd64.deb] | //GF+S+C+J+P// | ``sudo dpkg -i gf_3.9-1_amd64.deb``
-| Windows | [gf-3.9-bin-windows.zip gf-3.9-bin-windows.zip] | //GF+S// | ``unzip gf-3.9-bin-windows.zip``
-
-%| MINGW | [gf-3.9-bin-i686-MINGW32_NT-6.1.tar.gz gf-3.9-bin-i686-MINGW32_NT-6.1.tar.gz] | //GF+S+C// | ``tar -C / gf-3.9-bin-i686-MINGW32_NT-6.1.tar.gz``
-%| ... | ... | ... | ...
-
-Features: GF = GF shell and grammar compiler and the Resource Grammar Library,
-S = ``gf -server`` mode,
-C = C run-time system,
-J/P = Java/Python binding to the C run-time system
-
-%More binary packages might be added later.
-
-===Notes===
-
-The Windows package is installed by just unpacking it anywhere.
-%It finds the libraries relative to the ``.exe`` file.
-You will probably need to set the ``PATH`` and ``GF_LIB_PATH`` environment
-variables, see Inari's notes on
-[Installing GF on Windows http://www.grammaticalframework.org/~inari/gf-windows.html#toc3].
-
-%The new experimental MINGW package is for use in the
-%[MINGW http://www.mingw.org] environment in Windows. Unpack it in the MSYS shell
-%(which is started with ``C:\MinGW\msys\1.0\msys.bat``).
-%It should work out of the box without any additional settings.
-
-The Ubuntu ``.deb`` packages should work on Ubuntu 16.04 and 17.04 and similar
-Linux distributions.
-
-The Raspian ``.deb`` package was created on a Raspberry Pi 3 and will probably
-work on other ARM-based systems running Debian 9 (stretch) or similar
-Linux distributions.
-
-The packages for macOS (Mac OS X) should work on at
-least 10.11 and 10.12 (El Capitan and Sierra).
-
-%(*) **Note** that for compatibility with OS X 10.11 and newer,
-%``gf-3.9.pkg`` will install the ``gf`` executable in ``/usr/local/bin``
-%instead of ``/usr/bin``, so make sure ``/usr/local/bin`` is in your  ``$PATH``.
-%Also, if you still have an older version of GF installed in ``/usr/bin``,
-%remove it and/or make sure ``/usr/local/bin`` comes before ``/usr/bin``
-%in your ``$PATH`` so you don't accidentally run the old version.
-
-The Mac OS and Linux ``.tar.gz`` packages are designed to be installed in
-``/usr/local``.
-You can install them in other locations, but then you need to set the
-``GF_LIB_PATH`` environment variable:
-
-```
-  export GF_LIB_PATH=/usr/local/share/gf-3.9/lib
-```
-
-where ``/usr/local`` should be replaced with the path to the location where you
-unpacked the package.
-
-
-==Installing the latest release from source==
-
-[GF is on Hackage http://hackage.haskell.org/package/gf], so under normal
-circumstances the prodedure is fairly simple:
-
-+ Install a recent version of the
-  [Haskell Platform http://hackage.haskell.org/platform],
-  e.g. version 7.10.3 (see note 2 below)
-+ ``cabal update``
-+ On Linux: install some C libraries from your Linux distribution
-  (see note 1 below)
-+ ``cabal install gf``
-
-
-You can also download the full source package from here:
-[``gf-3.9.tar.gz`` gf-3.9.tar.gz].
-
-=== Notes ===
-
-The above steps installs GF for a single user.
-% and does not require root privileges.
-The executables are put in ``$HOME/.cabal/bin``
-(or, with recent versions of the Haskell platform on Mac OS X,
-in ``$HOME/Library/Haskell/bin``), so it is a good
-idea to put a line in your ``.bash_profile`` or ``.profile``
-to add that directory to you path:
-
-```
-  PATH=$HOME/.cabal/bin:$PATH
-```
-or
-```
-  PATH=$HOME/Library/Haskell/bin:$PATH
-```
-
-**Note 1**.
-GF uses [``haskeline`` http://hackage.haskell.org/package/haskeline], which
-on Linux depends on some non-Haskell libraries that
-won't be installed automatically by cabal, and therefore need to be installed
-manually. Here is one way to do this:
-
-- On Ubuntu: ``sudo apt-get install libghc-haskeline-dev``
-- On Fedora: ``sudo yum install ghc-haskeline-devel``
-
-
-**Note 2**.
-The GF source code has been updated to compile with GHC 8.2.1. Using older
-versions of GHC (e.g. 8.0.x and 7.10.3) should still work too.
-
-%=== Known problems ===
-%
-%There seems to be a bug in some versions of Cabal that can cause
-%
-%```
-%  Distribution/Simple/PackageIndex.hs:124:8-13: Assertion failed
-%```
-%
-%if the same version of GF is
-%already installed. If you encounter this, you can use ``ghc-pkg unregister gf``
-%to remove the installed version of GF and ``ghc-pkg list gf`` to verify that
-%it is gone.
-
-==Installing from the latest developer source code==
-
-The first time:
-%, assuming you already have the Haskell Platform and darcs
-
-```
-  git clone https://github.com/GrammaticalFramework/gf-core.git
-  cd gf-core
-  cabal install
-```
-
-and
-
-```
-  git clone https://github.com/GrammaticalFramework/gf-rgl.git
-  cd gf-rgl
-  make
-```
-
-Subsequently:
-
-```
-  cd gf-core
-  git pull
-  cabal install
-```
-
-and
-
-```
-  cd gf-rgl
-  git pull
-  make
-```
-
-The above notes for installing from source apply also in these cases.
-For more info on working with the GF source code, see the
-[GF Developers Guide ../doc/gf-developers.html].
-
-==Using Stack==
-
-You can also use [Stack https://www.haskellstack.org] to compile GF, just replace ``cabal install`` above
-with ``stack install`` (assuming you already have Stack set up).
-
-==Older releases==
-
-- [GF 3.8 index-3.8.html] (June 2016)
-- [GF 3.7.1 index-3.7.1.html] (October 2015)
-- [GF 3.7 index-3.7.html] (June 2015)
-- [GF 3.6 index-3.6.html] (June 2014)
-- [GF 3.5 index-3.5.html] (August 2013)
-- [GF 3.4 index-3.4.html] (January 2013).
-- [GF 3.3.3 index-3.3.3.html] (March 2012).
-- [GF 3.3 index-3.3.html] (October 2011).
-- [GF 3.2.9 index-3.2.9.html] source-only snapshot (September 2011).
-- [GF 3.2 index-3.2.html] (December 2010).
-- [GF 3.1.6 index-3.1.6.html] (April 2010).
-- [GF 3.1 old-index.html] (December 2009).

download/index.md

@@ -1,187 +0,0 @@
----
-title: Grammatical Framework Download and Installation
-...
-
-**GF 3.10** was released on 2 December 2018.
-
-What's new? See the [release notes](release-3.10.html).
-
-## Binary packages
-
-These binary packages include both the GF core (compiler and runtime) as well as the pre-compiled RGL.
-
-| Platform        | Download                                           | Features       | How to install                     |
-|:----------------|:---------------------------------------------------|:---------------|:-----------------------------------|
-| macOS           | [gf-3.10.pkg](gf-3.10.pkg)                         | GF, S, C, J, P | Double-click on the package icon   |
-| Ubuntu (32-bit) | [gf\_3.10-2\_i386.deb](gf_3.10-2_i386.deb)         | GF, S, C, J, P | `sudo dpkg -i gf_3.10-2_i386.deb`  |
-| Ubuntu (64-bit) | [gf\_3.10-2\_amd64.deb](gf_3.10-2_amd64.deb)       | GF, S, C, J, P | `sudo dpkg -i gf_3.10-2_amd64.deb` |
-| Windows         | [gf-3.10-bin-windows.zip](gf-3.10-bin-windows.zip) | GF, S          | `unzip gf-3.10-bin-windows.zip`    |
-
-<!--
-| macOS           | [gf-3.10-bin-intel-mac.tar.gz](gf-3.10-bin-intel-mac.tar.gz) | GF,S,C,J,P | `sudo tar -C /usr/local -zxf gf-3.10-bin-intel-mac.tar.gz` |
-| Raspbian 9.1     | [gf\_3.10-1\_armhf.deb](gf_3.10-1_armhf.deb)                 | GF,S,C,J,P | `sudo dpkg -i gf_3.10-1_armhf.deb`                         |
--->
-
-**Features**
-
-- GF = GF shell and grammar compiler
-- S = `gf -server` mode
-- C = C run-time system
-- J/P = Java/Python binding to the C run-time system
-
-### Notes
-
-The Windows package is installed by just unpacking it anywhere. You will
-probably need to set the `PATH` and `GF_LIB_PATH` environment variables,
-see Inari's notes on [Installing GF on Windows](http://www.grammaticalframework.org/~inari/gf-windows.html#toc3).
-
-The Ubuntu `.deb` packages should work on Ubuntu 16.04 and 18.04 and
-similar Linux distributions. The `.deb` packages were updated
-to version 3.10-2 after the release of GF 3.10.
-(Because of a packaging bug the Resource Grammar Library was missing
-in the 3.10-1 packages.)
-
-<!-- The Raspbian `.deb` package was created on a Raspberry Pi 3 and will
-probably work on other ARM-based systems running Debian 9 (stretch) or
-similar Linux distributions. -->
-
-The packages for macOS (Mac OS X) should work on at least 10.13 and
-10.14 (High Sierra and Mojave)
-
-<!-- The Mac OS and Linux `.tar.gz` packages are designed to be installed in
-`/usr/local`. You can install them in other locations, but then you need
-to set the `GF_LIB_PATH` environment variable:
-
-```
-export GF_LIB_PATH=/usr/local/share/gf-3.10/lib
-```
-
-where `/usr/local` should be replaced with the path to the location
-where you unpacked the package. -->
-
-## Installing the latest release from source
-
-[GF is on Hackage](http://hackage.haskell.org/package/gf), so under
-normal circumstances the procedure is fairly simple:
-
-1.  Install a recent version of the [Haskell
-    Platform](http://hackage.haskell.org/platform) (see note below)
-2.  `cabal update`
-3.  On Linux: install some C libraries from your Linux distribution (see note below)
-4.  `cabal install gf`
-
-This installs the GF executable and Haskell libraries, but **does not include the RGL**.
-
-You can also download the source code release from [GitHub](https://github.com/GrammaticalFramework/gf-core/releases),
-and follow the instructions below under **Installing from the latest developer source code**.
-
-### Notes
-
-**Installation location**
-
-The above steps installs GF for a single user. The executables are put
-in `$HOME/.cabal/bin` (or, with recent versions of the Haskell platform
-on Mac OS X, in `$HOME/Library/Haskell/bin`), so it is a good idea to
-put a line in your `.bash_profile` or `.profile` to add that directory
-to you path:
-
-```
-PATH=$HOME/.cabal/bin:$PATH
-```
-
-or
-
-```
-PATH=$HOME/Library/Haskell/bin:$PATH
-```
-
-**Build tools**
-
-In order to compile GF you need the build tools **Alex** and **Happy**.
-These can be installed via Cabal, e.g.:
-
-```
-cabal install alex happy
-```
-
-or obtained by other means, depending on your OS.
-
-**Haskeline**
-
-GF uses [`haskeline`](http://hackage.haskell.org/package/haskeline), which
-on Linux depends on some non-Haskell libraries that won't be installed
-automatically by cabal, and therefore need to be installed manually.
-Here is one way to do this:
-
-- On Ubuntu: `sudo apt-get install libghc-haskeline-dev`
-- On Fedora: `sudo yum install ghc-haskeline-devel`
-
-**GHC version**
-
-The GF source code has been updated to compile with GHC 8.4.
-Using older versions of GHC (e.g. 8.2, 8.0 and 7.10) should still work too.
-
-## Installing from the latest developer source code
-
-If you haven't already, clone the repository with:
-
-```
-git clone https://github.com/GrammaticalFramework/gf-core.git
-```
-
-If you've already cloned the repository previously, update with:
-
-```
-git pull
-```
-
-Then install with:
-
-```
-cabal install
-```
-
-or, if you're a Stack user:
-
-```
-stack install
-```
-
-The above notes for installing from source apply also in these cases.
-For more info on working with the GF source code, see the
-[GF Developers Guide](../doc/gf-developers.html).
-
-## Installing the RGL from source
-
-To install the RGL from source,
-you can download a release from [GitHub](https://github.com/GrammaticalFramework/gf-rgl/releases)
-or get the latest version by cloning the repository:
-
-```
-git clone https://github.com/GrammaticalFramework/gf-rgl.git
-```
-
-In both cases, once you have the RGL sources you can install them by running:
-
-```
-make
-```
-
-in the RGL folder.
-This assumes that you already have GF installed.
-For more details about building the RGL, see the [RGL README](https://github.com/GrammaticalFramework/gf-rgl/blob/master/README.md).
-
-## Older releases
-
-- [GF 3.9](index-3.9.html) (August 2017)
-- [GF 3.8](index-3.8.html) (June 2016)
-- [GF 3.7.1](index-3.7.1.html) (October 2015)
-- [GF 3.7](index-3.7.html) (June 2015)
-- [GF 3.6](index-3.6.html) (June 2014)
-- [GF 3.5](index-3.5.html) (August 2013)
-- [GF 3.4](index-3.4.html) (January 2013)
-- [GF 3.3.3](index-3.3.3.html) (March 2012)
-- [GF 3.3](index-3.3.html) (October 2011)
-- [GF 3.2.9](index-3.2.9.html) source-only snapshot (September 2011)
-- [GF 3.2](index-3.2.html) (December 2010)
-- [GF 3.1.6](index-3.1.6.html) (April 2010)

download/index.t2t

@@ -1,6 +1,12 @@
 Grammatical Framework Download and Installation
 
 
+%!style:../css/notes.css
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+%!postproc(html): <TD><I> <TD><small>
+%!postproc(html): </I></TD> </small></TD>
+
 **GF 3.8** was released on 22 June 2016.
 
 What's new? See the [Release notes release-3.8.html].
@@ -43,7 +49,7 @@ Linux distributions.
 
 The packages for Mac OS X should work on at least 10.9, 10.10 and 10.11 (Mavericks, Yosemite and El Capitan).
 
-(*) **Note** that for compatibility with OS X 10.11,
+(*) **Note** that for compatibility with OS X 10.11, 
 ``gf-3.8.pkg`` will install the ``gf`` executable in ``/usr/local/bin``
 instead of ``/usr/bin``, so make sure ``/usr/local/bin`` is in your  ``$PATH``.
 Also, if you still have an older version of GF installed in ``/usr/bin``,
@@ -165,3 +171,8 @@ For more info on working with the GF source code, see the
 - [GF 3.2 index-3.2.html] (December 2010).
 - [GF 3.1.6 index-3.1.6.html] (April 2010).
 - [GF 3.1 old-index.html] (December 2009).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/old-index.html

@@ -0,0 +1,146 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<HTML>
+<HEAD>
+<META NAME="generator" CONTENT="http://txt2tags.sf.net">
+<TITLE>Grammatical Framework Download and Installation</TITLE>
+<style>
+h1 { text-align: center; }
+h1,h2,h3 { font-family: sans-serif; }
+ul.downloads a { font-family: monospace; }
+</style>
+</HEAD>
+
+<BODY BGCOLOR="white" TEXT="black">
+<H1>Grammatical Framework<br>Download and Installation</H1>
+
+<H2>Latest developer code</H2>
+<P>
+<A HREF="../doc/gf-developers.html">GF darcs repository</A>
+</P>
+
+<H2>Latest release</h2>
+
+<dl>
+<dt>GF 3.1, 15 December 2009
+<dd>
+<p>
+<ul class=downloads>
+  <li>For Linux (32-bit):
+    <a href="gf-3.1-bin-i486-linux.tar.gz">gf-3.1-bin-i468-linux.tar.gz</a>
+  <li>For Linux (64-bit):
+    <a href="gf-3.1-bin-x86_64-linux.tar.gz">gf-3.1-bin-x86_64-linux.tar.gz</a>
+  <li>For Mac:
+    <a href="gf-3.1-bin-intel-mac.tar.gz">gf-3.1-bin-intel-mac.tar.gz</a>
+    (Leopard &amp; Snow Leopard)
+  <li>For Windows:
+    <a href="gf-3.1-bin-i486-windows.zip">gf-3.1-bin-i486-windows.zip</a>
+  <li>Source package:
+    <a href="gf-3.1-src.tar.gz">gf-3.1-src.tar.gz</a>
+    (a dump of the darcs repo)
+  <li>Libraries: <a href="gf-lib-1.7.tar.gz">gf-lib-1.7.tar.gz</a>
+    (sources, compiled as alltenses/present, docs)
+</ul>
+
+<H3>Installation instructions</H3>
+
+<ul>
+<li>Linux &amp; Mac binaries: <tt>tar xvfz</tt> in /
+<li>Windows binary: unzip in c:\
+<li>Compiled library:
+  <tt>tar xvfz</tt> in some DIR and point the variable GF_LIB_PATH to DIR/lib.
+<li>
+Source package: <tt>tar xvfz</tt> somewhere and compile as follows:
+<P>
+<PRE>
+    tar xvfz gf-3.0.tgz
+    cd gf-3.0
+
+    # alternative 1:
+    runghc Setup configure
+    runghc Setup build
+    runghc Setup install
+
+    # alternative 2:
+    make
+    make install
+</PRE>
+</dl>
+
+<H2>Old releases</H2>
+
+<dl>
+<dt>GF 3.0, 24 June 2009.
+<dd>
+<P>
+<ul>
+<li><A HREF="gf-3.0-mac.gz">Mac OS X Leopard (intel) executable</A> 
+      (requires Readline from <A HREF="http://www.macports.org/">Mac Ports</A>)
+<li><A HREF="gf-3.0-mac-noreadline.gz">Mac OS X Leopard (Intel) executable</A> 
+      (doesn't require Readline)
+<li><A HREF="gf-linux.tar.gz">Linux (intel) binary package</A> 
+<li><A HREF="gf-win32.zip">Windows binary package</A> 
+<li><A HREF="gf-lib-1.6.tgz">Compiled libraries, v. 1.6</A> 
+<li><A HREF="gf-3.0-src.tgz">Source package for GF system (a dump of the darcs repo)</A> 
+</ul>
+
+<H3>Installation instructions</H3>
+
+<p>
+Mac binary: gunzip and put somewhere on your path.
+<P>
+Linux: <tt>tar xvfz</tt> in /
+<P>
+Windows: unzip in c:\
+<p>
+Compiled library: <tt>tar xvfz</tt> in some DIR and point the variable GF_LIB_PATH to DIR/lib.
+<p>
+Source package: <tt>tar xvfz</tt> somewhere and compile as follows:
+<P>
+<PRE>
+    tar xvfz gf-3.0.tgz
+    cd gf-3.0
+
+    # alternative 1:
+    runghc Setup configure
+    runghc Setup build
+    runghc Setup install
+
+    # alternative 2:
+    make
+    make install
+</PRE>
+</dl>
+
+
+GF 3.0 beta3, April 2009.
+<UL>
+<LI>
+  <A HREF="GF-3.0-beta3-i386-apple-darwin9.6.0.tgz">Mac OS X Leopard (intel) binary package</A> 
+<LI>
+  <A HREF="gf-3.0-beta3.zip">Windows binary</A> 
+
+<LI><A HREF="GF-3.0-beta3.tgz">GF 3.0 beta3 sources</A> (both system and library)
+</UL>
+3.0 beta2
+<UL>
+<LI><A HREF="GF-3.0-beta2-i686-pc-linux-gnu.tgz">GF 3.0 beta2 Linux binary package</A> (Intel, Ubuntu)
+<P></P>
+<LI>GF 3.0 beta2 MacOS X binary package: 
+  <A HREF="GF-3.0-beta2-i386-apple-darwin9.4.0.tgz">Leopard</A> (Intel Mac with MacOS X Leopard)
+  <A HREF="GF-3.0-beta2-i386-apple-darwin8.11.1.tgz">Tiger</A> (Intel Mac with MacOS X Tiger)
+<P></P>
+<LI><A HREF="gf-3.0-beta2.zip">GF 3.0 beta2 Windows package</A> (includes libraries)
+<P></P>
+<LI><A HREF="GF-3.0-beta2.tgz">GF 3.0 beta2 sources</A> (both system and library)
+<P></P>
+<LI><A HREF="gf-lib-1.4.tgz">GF libraries v 1.4</A> (compiled resource grammar libraries)
+</UL>
+<!--
+<UL>
+<LI><A HREF="../../GF2/download/index.html">GF 2.9 download page</A>
+</UL>
+-->
+
+<!-- html code generated by txt2tags 2.4 (http://txt2tags.sf.net) -->
+<!-- cmdline: txt2tags -thtml index.txt -->
+</BODY></HTML>

download/release-3.1.6.html

@@ -0,0 +1,87 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+<META NAME="generator" CONTENT="http://txt2tags.sf.net">
+<TITLE>GF Version 3.1.6 Release Notes</TITLE>
+</HEAD><BODY BGCOLOR="white" TEXT="black">
+<P ALIGN="center"><CENTER><H1>GF Version 3.1.6 Release Notes</H1>
+<FONT SIZE="4">
+<I>23 April 2010</I><BR>
+</FONT></CENTER>
+
+<H1>Installation</H1>
+<P>
+The binaries now work out of the box for each platform and support
+completions (file names and parsing), because readline has been 
+changed to haskeline.
+</P>
+<P>
+To compile from source, GHC 6.12 is now required. But GHC is not needed
+if the binary executables are used.
+</P>
+<P>
+Binaries (<CODE>.gfo</CODE> and <CODE>.pgf</CODE> files) compiled with GF 3.1 are incompatible 
+with 3.1.6 and must either be removed; alternatively, the <CODE>-src</CODE> flag can be
+used when compiling.
+</P>
+<P>
+Notice the new place to send bug reports (see GF's welcome message)!
+</P>
+<H1>New features</H1>
+<P>
+Grammar language
+</P>
+<UL>
+<LI>improved support for dependent types (see <CODE>SUMO</CODE>, <CODE>nqueens</CODE> in <CODE>examples</CODE>)
+</UL>
+
+<P>
+Shell commands and options (see <CODE>help</CODE> in GF for more information) 
+</P>
+<UL>
+<LI><CODE>eb</CODE>: example-based grammar file conversion 
+  (see <CODE>examples/animals/QuestionI.gf</CODE>)
+<LI><CODE>vd = visualize_dependency</CODE>: show dependency tree
+<LI><CODE>vp = visualize_parse</CODE>: show parse tree
+<LI><CODE>gr, gt, mq, tq</CODE>: use a seed tree with metavariables
+<LI><CODE>gr, p, tq</CODE>: use <CODE>-probs=FILE</CODE> to bias or rank generated trees
+<LI><CODE>gt</CODE> now tries the different alternatives in the order in which they appear in the source code
+<LI><CODE>dg</CODE>: hide modules when printing dependency graph
+<LI>-output-format=lambda_prolog let us to use Lambda Prolog for exhaustive generation with dependent types
+</UL>
+
+<P>
+Libraries
+</P>
+<UL>
+<LI>Urdu completed (Shafqat Virk)
+<LI>Turkish morphology + Zamberek's dictionary in GF (Server Cimen)
+</UL>
+
+<P>
+Examples
+</P>
+<UL>
+<LI>SUMO
+<LI>phrasebook
+<LI>nqueens
+</UL>
+
+<P>
+Internal
+</P>
+<UL>
+<LI>single PMCFG format for both linearization and parsing
+<LI>use of Haskeline for completion - more portable than Readline
+<LI>unicode support from Haskell 6.12 instead of home-made coding
+</UL>
+
+<H2>Issues</H2>
+<P>
+Javascript generation is not updated to the new PGF format.
+<A HREF="old-index.html">GF 3.1</A> should still be used for building Javascript applications.
+</P>
+
+<!-- html code generated by txt2tags 2.5 (http://txt2tags.sf.net) -->
+<!-- cmdline: txt2tags -thtml release-3.1.6.txt -->
+</BODY></HTML>

download/release-3.1.6.txt

@@ -5,13 +5,13 @@ GF Version 3.1.6 Release Notes
 =Installation=
 
 The binaries now work out of the box for each platform and support
-completions (file names and parsing), because readline has been
+completions (file names and parsing), because readline has been 
 changed to haskeline.
 
 To compile from source, GHC 6.12 is now required. But GHC is not needed
 if the binary executables are used.
 
-Binaries (``.gfo`` and ``.pgf`` files) compiled with GF 3.1 are incompatible
+Binaries (``.gfo`` and ``.pgf`` files) compiled with GF 3.1 are incompatible 
 with 3.1.6 and must either be removed; alternatively, the ``-src`` flag can be
 used when compiling.
 
@@ -24,8 +24,8 @@ Grammar language
 - improved support for dependent types (see ``SUMO``, ``nqueens`` in ``examples``)
 
 
-Shell commands and options (see ``help`` in GF for more information)
-- ``eb``: example-based grammar file conversion
+Shell commands and options (see ``help`` in GF for more information) 
+- ``eb``: example-based grammar file conversion 
   (see ``examples/animals/QuestionI.gf``)
 - ``vd = visualize_dependency``: show dependency tree
 - ``vp = visualize_parse``: show parse tree
@@ -57,3 +57,8 @@ Internal
 
 Javascript generation is not updated to the new PGF format.
 [GF 3.1 old-index.html] should still be used for building Javascript applications.
+
+
+
+
+

download/release-3.10.md

@@ -1,66 +0,0 @@
----
-title: GF 3.10 Release Notes
-date: 2 December 2018
-...
-
-## Installation
-
-See the [download page](index.html).
-
-## What's new
-
-In this release, the GF "core" (compiler and runtimes) and RGL have been split into separate repositories.
-The binary packages on the downloads page contain both GF and the RGL, but the sources are now separate:
-[gf-core](https://github.com/GrammaticalFramework/gf-core) and
-[gf-rgl](https://github.com/GrammaticalFramework/gf-rgl).
-
-Over 300 changes have been pushed to GF and over 600 changes have been made to the RGL
-since the release of GF 3.9 in August 2017.
-
-## General
-
-- Travis integration:
-GF [![Build Status](https://travis-ci.org/GrammaticalFramework/gf-core.svg?branch=master)](https://travis-ci.org/GrammaticalFramework/gf-core) and
-RGL [![Build Status](https://travis-ci.org/GrammaticalFramework/gf-rgl.svg?branch=master)](https://travis-ci.org/GrammaticalFramework/gf-rgl)
-- A lot of bug fixes and repository cleanup, including things moved to new repositories:
-    - [Phrasebook](https://github.com/GrammaticalFramework/gf-contrib/tree/master/phrasebook)
-    - [Wide coverage translator](https://github.com/GrammaticalFramework/wide-coverage)
-    - [Mobile apps](https://github.com/GrammaticalFramework/gf-offline-translator)
-    - [gftest](https://github.com/GrammaticalFramework/gftest)
-    - [gf-mode](https://github.com/GrammaticalFramework/gf-emacs-mode) for Emacs
-    - [RGL browser](https://github.com/GrammaticalFramework/rgl-source-browser) (live [here](http://www.grammaticalframework.org/~john/rgl-browser/))
-- A fresh look for the GF website.
-
-## GF compiler and run-time library
-
-- Extensive improvements in the C runtime and bindings to it from Python, Java, Haskell, C#
-- A GF shell which uses the C runtime
-- Better error messages
-- GF now has a Stack configuration file
-- The compiler source code has been updated for compatibility with GHC 8.4.3.
-- `GF_LIB_PATH` can now be `path1:path2:path3`, not just `path1`
-- Add TypeScript type definitions for `gflib.js`
-- New compiler/shell options
-    - added option `-output-format=java` for producing code for embedded grammars in Java
-    - `rf -paragraphs`
-    - `linearize -tabtreebank`
-    - A new function called `completions` is added in the Haskell runtime and used in PGFService. This makes the extraction of completions more platform independent
-
-## Resource Grammar Library
-
-- [Bash build script](https://github.com/GrammaticalFramework/gf-rgl/blob/master/Setup.sh), for building the RGL without Haskell
-- [Windows build script](https://github.com/GrammaticalFramework/gf-rgl/blob/master/Setup.bat), for building the RGL without Haskell on a regular Windows command shell
-- New languages:
-    - Basque
-    - Portuguese
-- Big progress with Arabic, Turkish, Persian
-- Introduction of `Extend` module to combine the functions of `Extra` and `Extensions` in a more disciplined way
-- Various fixes for several languages.
-- Various fixes in the translation dictionaries.
-
-## Apps and Cloud services
-
-- Sort list of public grammars by age by default
-- Browser compatibility fixes
-- Allow public grammars to be deleted in more cases
-- Show grammar comments in the list of public grammars

download/release-3.2.t2t

@@ -1,6 +1,9 @@
 GF Version 3.2 Release Notes
 December 2010
 
+%!style:../css/style.css
+%!postproc(html): <H1> <H1><IMG src="../doc/Logos/gf0.png">
+
 ==Installation==
 
 See the [download page http://www.grammaticalframework.org/download/index.html].
@@ -31,3 +34,8 @@ See the [download page http://www.grammaticalframework.org/download/index.html].
 
 - GF compiler: GPL
 - Run-time libraries and Resource Grammar Library: LGPL + BSD
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/release-3.3.3.t2t

@@ -1,6 +1,10 @@
 GF Version 3.3.3 Release Notes
 March 2012
 
+%!style:../css/style.css
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <H1> <H1><IMG src="../doc/Logos/gf0.png">
+
 ==Installation==
 
 See the [download page http://www.grammaticalframework.org/download/index.html].
@@ -21,3 +25,8 @@ See the [download page http://www.grammaticalframework.org/download/index.html].
 - Fix for a bug that prevented the shell commands ``abstract_info``,
   ``generate_random`` and ``generate_trees`` from working properly.
 - Various other small improvements and bug fixes.
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/release-3.3.t2t

@@ -1,13 +1,17 @@
 GF Version 3.3 Release Notes
 October 2011
 
+%!style:../css/style.css
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!postproc(html): <H1> <H1><IMG src="../doc/Logos/gf0.png">
+
 ==Installation==
 
 See the [download page http://www.grammaticalframework.org/download/index.html].
 
 ==New features==
 
-- Source language extension: it is now possible to override the oper definitions in an interface, by using the
+- Source language extension: it is now possible to override the oper definitions in an interface, by using the 
   header syntax ``instance Foo of Bar - [f,g,h]``.
 - New functionalities in GF shell commands (more information with ``help`` command-name).
   - ``aw`` = ``align_words`` option ``-giza`` prints word alignments in Giza++ format.
@@ -25,3 +29,8 @@ See the [download page http://www.grammaticalframework.org/download/index.html].
   and the web-based grammar editor.
 - Faster grammar compilation (also included in the GF 3.2.9 source-only
   snapshot).
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/release-3.4.t2t

@@ -1,6 +1,10 @@
 GF Version 3.4 Release Notes
 January 2013
 
+%!style:../css/style.css
+%!postproc(html): <TITLE> <meta charset="UTF-8"><meta name = "viewport" content = "width = device-width"> <TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 ==Installation==
 
 See the [download page http://www.grammaticalframework.org/download/index.html].
@@ -42,3 +46,8 @@ See the [download page http://www.grammaticalframework.org/download/index.html].
 - Some new functionality in the web-based grammar editor, e.g. preliminary
   support for public grammars.
 - Various other small improvements and bug fixes.
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/release-3.5.t2t

@@ -1,6 +1,10 @@
 GF 3.5 Release Notes
 August 2013
 
+%!style:../css/style.css
+%!postproc(html): <TITLE> <meta charset="UTF-8"><meta name = "viewport" content = "width = device-width"> <TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 ==Installation==
 
 See the [download page http://www.grammaticalframework.org/download/index.html].
@@ -66,3 +70,7 @@ of GF 3.4.
   [``network-2.4.1.1`` https://github.com/haskell/network/commit/f2168b1f8978b4ad9c504e545755f0795ac869ce].
 - Various other small improvements and bug fixes.
 %- [...]
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/release-3.6.t2t

@@ -1,6 +1,10 @@
 GF 3.6 Release Notes
 June 2014
 
+%!style:../css/style.css
+%!postproc(html): <TITLE> <meta charset="UTF-8"><meta name = "viewport" content = "width = device-width"> <TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 ==Installation==
 
 See the [download page http://www.grammaticalframework.org/download/index.html].
@@ -22,7 +26,7 @@ Closed [issues http://code.google.com/p/grammatical-framework/issues/list]:
   as ``--# -coding=``//enc//, instead of ``flags coding=``//enc//.
   See the separate document
   [GF character encoding changes encoding-change.html] for more details.
-- Record update: in record objects (but not types) of form ``r ** s``, the values assigned
+- Record update: in record objects (but not types) of form ``r ** s``, the values assigned 
   in ``s`` now overwrite those in ``r``. In previous versions, record extensions with
   overlapping assignments in ``r`` and ``s`` were not supported, and their behaviour was
   unpredictable.
@@ -103,3 +107,8 @@ Closed [issues http://code.google.com/p/grammatical-framework/issues/list]:
     - ``c-wordforword``: this works as ``c-translate`` but does a
       word-for-word lookup to create a (potentially very low quality)
       translation that can be used if all else fails.
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/release-3.7.1.t2t

@@ -1,6 +1,10 @@
 GF 3.7.1 Release Notes
 October 2015
 
+%!style:../css/notes.css
+%!postproc(html): <TITLE> <meta charset="UTF-8"><meta name = "viewport" content = "width = device-width"> <TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 ==Installation==
 
 See the [download page http://www.grammaticalframework.org/download/index.html].
@@ -14,10 +18,10 @@ Over 170 changes have been pushed to the source repository since
 
 ====New features and notable changes====
 
-- GF shell: ``cc -trace`` (preliminary): you can now do things like
-
+- GF shell: ``cc -trace`` (preliminary): you can now do things like 
+  
   	``cc -trace mkV "debug"``
-
+  
   to see a trace of all opers with their arguments and results during the
   computation of ``mkV "debug"``.
 
@@ -25,7 +29,7 @@ Over 170 changes have been pushed to the source repository since
   from the GF shell by starting GF with ``gf -cshell`` or ``gf -crun``.
   Only limited functionality is available when running the shell in these
   modes (use the ``help`` command in the shell for details):
-
+  
   - You can only import ``.pgf`` files, not source files.
   - The ``-retain`` flag can not be used and the commands that require it to
     work are not available.
@@ -73,3 +77,8 @@ Over 170 changes have been pushed to the source repository since
   you can leave ``&+`` uninterpreted instead of gluing the adjacent tokens.
   This means that the output is left in a format that can be parsed in
   a subsequent request.
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/release-3.7.t2t

@@ -1,6 +1,10 @@
 GF 3.7 Release Notes
 June 2015
 
+%!style:../css/style.css
+%!postproc(html): <TITLE> <meta charset="UTF-8"><meta name = "viewport" content = "width = device-width"> <TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 ==Installation==
 
 See the [download page http://www.grammaticalframework.org/download/index.html].
@@ -36,7 +40,7 @@ Over 800 changes have been pushed to the source repository since
   ``BIND``, ``SOFT_BIND``, ``SOFT_SPACE``, ``CAPIT``, ``ALL_CAPIT`` and
    ``nonExist``.
 - It is now possible to define callbacks for literals from the Haskell
-  binding to the C runtime. This is used for instance in
+  binding to the C runtime. This is used for instance in 
   the Wide Coverage translator on the Web.
 
 
@@ -99,3 +103,8 @@ Over 800 changes have been pushed to the source repository since
   unused for 24 hours, to keep memory use down in long running servers.
 - PGF service: limit the number of parallel calls to the C run-time parse
   function to 4 by default. The limit can be changed with the ``-j`` flag.
+
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/release-3.8.t2t

@@ -1,6 +1,10 @@
 GF 3.8 Release Notes
 June 2016
 
+%!style:../css/notes.css
+%!postproc(html): <TITLE> <meta charset="UTF-8"><meta name = "viewport" content = "width = device-width"> <TITLE>
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
 ==Installation==
 
 See the [download page http://www.grammaticalframework.org/download/index.html].
@@ -21,7 +25,7 @@ Roughly 400 changes have been pushed to the source repository since
   [universal dependency http://universaldependencies.org/] diagrams
   in various formats, see ``help vd``.
 - The C runtime now includes an experimental library for managing
-  and querying ontologies built on top of the abstract syntax of
+  and querying ontologies built on top of the abstract syntax of 
   a grammar. Since the ontology is based on an abstract syntax,
   it is language independent by design. For now the library is
   only used in the GF Offline Translator. The library uses
@@ -96,3 +100,7 @@ Roughly 400 changes have been pushed to the source repository since
   translations in the domain they cover.
   You can change the order in which the selected grammars are tried
   by dragging them up and down in the list.
+
+--------------------
+
+[www.grammaticalframework.org http://www.grammaticalframework.org]

download/release-3.9.t2t

@@ -1,64 +0,0 @@
-GF 3.9 Release Notes
-August 2017
-
-==Installation==
-
-See the [download page http://www.grammaticalframework.org/download/index.html].
-
-
-==What's new==
-
-The [GF  repository on GitHub https://github.com/GrammaticalFramework/GF/]
-is now our master source repository, not just a read-only mirror.
-Bug reports and feature requests can be submitted to the
-[issue tracker https://github.com/GrammaticalFramework/GF/issues],
-and we also accept pull requests.
-
-Over 200 changes have been pushed to the source repository since
-[the release of GF 3.8 release-3.8.html] in June 2016.
-
-
-===GF compiler and run-time library===
-
-
-====New features and notable changes====
-
-- Support for language-specific depencency configurations (in addition to abstract syntax based ones); see ``help vd`` in the GF shell
-
-- An experimental support for sentence lookup which makes it possible
-to find the sentence from the grammar that matches best a set of keywords.
-Right now it is usable only with controlled languages since it might be
-very innefficient for some grammars.
-
-- A new .NET binding for the GF runtime is available.
-
-- The API in the Java binding is extended and it covers more from
-the full functionality of the C runtime.
-
-
-====Changes of interest to compiler developers====
-
-- The compiler source code has been updated for compatibility with GHC 8.2.1.
-
-
-===Resource Grammar Library===
-
-- New languages:
-  - Icelandic
-  - Norwegian Nynorsk
-
-
-- API now usable for incomplete languages via ``Missing`` modules:
-  implemented for Arabic and Latin.
-- Punctuation with ``BIND`` and ``SOFT_BIND`` tokens for a number of languages
-
-
-- Various fixes for several languages.
-
-- Various fixes in the translation dictionaries.
-
-
-===Apps and Cloud services===
-
-- PGF service: support for language-specific depencency configurations in
-  ``command=deptree``.

eclipse/images/.htaccess

@@ -0,0 +1,5 @@
+# Images in this folder have moved, now hosted at GitHub
+# John 2013-01-10
+
+RewriteEngine On
+RewriteRule ^(.*)$ https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/$1 [L,R=301]

eclipse/index.html

@@ -0,0 +1,446 @@
+<html>
+<head>
+<title>
+GF Eclipse Plugin
+</title>
+<link rel="stylesheet" type="text/css" href="http://www.grammaticalframework.org/css/style.css" /> <meta name="viewport" content="width=device-width" />
+</head>
+<body>
+
+
+<h1 id="the-gf-eclipse-plugin">The GF Eclipse Plugin</h1>
+<p>John J. Camilleri<br />Updated: 22 February 2013</p>
+<p><em>The research leading to these results has received funding from the European Union's Seventh Framework Programme (FP7/2007-2013) under grant agreement no. FP7-ICT-247914 (the <a href="http://www.molto-project.eu/">MOLTO Project</a>).</em></p>
+<h2 id="introduction">Introduction</h2>
+<p>The aim behind developing a desktop IDE for GF is to provide more powerful tools than may be possible and/or practical in a web-based environment (the <a href="http://www.grammaticalframework.org/demos/gfse/">GF Web IDE</a>). In particular, the ability to resolve identifier cross-references and browse external libraries quickly during development time is one of the primary motivations for the project.</p>
+<p>The choice was made to develop this desktop IDE as a plugin for the Eclipse Platform as it emerged as the most popular choice among the GF developer community. Support for the platform is vast and many tools for adapting Eclipse to domain-specific languages already exist. Unlike the zero-click Web IDE approach, using the GF Eclipse plugin requires some manual installation and configuration on the development machine.</p>
+<h3 id="license">License</h3>
+<p>The GF Eclipse Plugin is open-source under the <strong><a href="http://www.gnu.org/licenses/gpl-3.0.txt">GNU General Public License (GPL)</a></strong>.<br /><em>The licenses that cover the rest of GF are listed <a href="http://www.grammaticalframework.org/LICENSE">here</a>.</em> <em>Xtext and Eclipse are released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License (EPL)</a>.</em></p>
+<h3 id="links">Links</h3>
+<ul>
+<li>This document shall contain all collected information about the plugin. The most up-to-date version of this file can always be found <a href="https://github.com/GrammaticalFramework/gf-eclipse-plugin/blob/master/README.md">here</a></li>
+<li>This documentation is also available at the <a href="http://www.grammaticalframework.org/eclipse/">GF website</a> and the <a href="http://www.molto-project.eu/node/1395">MOLTO Project Wiki</a>.</li>
+<li>Source code repository is at <a href="https://github.com/GrammaticalFramework/gf-eclipse-plugin">github.com/GrammaticalFramework/gf-eclipse-plugin</a></li>
+<li>For reporting bugs and requesting features, please use the <a href="https://github.com/GrammaticalFramework/gf-eclipse-plugin/issues">GitHub Issue Tracker</a></li>
+<li>Here are some <a href="https://github.com/GrammaticalFramework/gf-eclipse-plugin/tree/master/workspace-demo/GF%20Project">example GF projects</a> for testing out the plugin features.</li>
+<li>Software update site URL for installing through Eclipse: <code>http://www.grammaticalframework.org/eclipse/release/</code></li>
+</ul>
+<h3 id="publications">Publications</h3>
+<ul>
+<li><a href="http://academic.johnjcamilleri.com/presentations/2012-05%20EAMT%20poster.pdf">Poster</a> at EAMT 2012 in Trento, Italy</li>
+<li><a href="http://academic.johnjcamilleri.com/papers/freerbmt2012.pdf">Paper</a> presented at FreeRBMT 2012 in Gothenburg, Sweden.</li>
+</ul>
+<h2 id="features">Features</h2>
+<ul>
+<li>Syntax highlighting and error detection</li>
+<li>Code folding, quick block-commenting, automatic code formatting</li>
+<li>Definition outlining, jump to declaration, find usage</li>
+<li>Warnings for problems in module dependency hierarchy</li>
+<li>Launch configurations, i.e. compilation directly from IDE</li>
+<li>Use GF Shell from within Eclipse</li>
+<li>Auto-completion for declared identifiers</li>
+<li>Background compilation (shallow) using project builder</li>
+<li>Support for <em>Open Declaration</em> (F3), including qualified names</li>
+<li>Code generation for new languages in application grammars</li>
+<li>Inline documentation for function calls, overloads</li>
+<li>Proper cross-reference handling with qualified names</li>
+<li>Test management and testing tool</li>
+<li>External library browser</li>
+</ul>
+<h2 id="release-history">Release history</h2>
+<p><strong>22/02/13</strong> : (1.5.2.x) New option for specifying include/exclude build files. Progress indicators during build.</p>
+<p><strong>12/06/12</strong> : (1.5.1.x) Support for scoping when library sources not available. Performance and implementational improvements to External Library View.</p>
+<p><strong>19/04/12</strong> : (1.5.0.x) Removed need for <code>.gfexternal</code> folder. Much improved &quot;External Libraries&quot; view allows you to search in current scope. Memory usage improvements in scoping implementation. Validation now occurs on file open. Re-added GF Library Path field in preferences.</p>
+<p><strong>04/04/12</strong> : (1.4.3.x) Improvements to the Test Manager. Added support for arbitrary commands in launch. Made the license information clearer.</p>
+<p><strong>22/03/12</strong> : (1.4.2.x) Added wizard for context-free grammars (no syntax support, though). Context-menu option for toggling the GF Nature and Builder together. Test Manager now parses languages &amp; parameters, and includes filtering and toggling options.</p>
+<p><strong>14/03/12</strong> : (1.4.1.x) GF source files can now be anywhere in project, not necessarily at top level.</p>
+<p><strong>06/03/12</strong> : (1.4.0.x) Test manager view. Updated launch configurations. UI improvements, new icons. Inline contextual documentation. Correct resolution of qualified identifiers. Bug fixes and some refactoring.</p>
+<p><strong>07/02/12</strong> : (1.3.0.x) Re-written underlying GF grammar.</p>
+<p><strong>02/02/12</strong> : (1.2.5.x) Hugely improved scoping performance. New &quot;Clone to new language&quot; wizard. Improved code formatting. More efficient builder. Removed library path preference. GF runtime is now automatically found.</p>
+<p><strong>23/01/12</strong> : (1.2.4.x) Logging is now done to the Eclipse Platform Log (use &quot;Error Log&quot; view). Tested with Eclipse 3.6.2. Bug fixes.</p>
+<p><strong>11/01/12</strong> : (1.2.3.x) Updated to use Xtext 2.1.0. Links to external files now moved into new &quot;GF Library View&quot;.</p>
+<p><strong>24/11/11</strong> : (1.2.0.x) with support for &quot;Open Declaration&quot; (F3) function, including for external libraries.</p>
+<p><strong>18/11/11</strong> : Third BETA (1.1.0.x) released, overhauled to take advantage of new compiler features. Tag-based scoping with caching for better performance. Interactive console (GF Shell) for launch configs.</p>
+<p><strong>11/10/11</strong> : Second BETA (1.0.0.x) released, with improved support for qualified names, local variable bindings, selective inheritance, module outlining, and launch configurations. Also new GF Project type.</p>
+<p><strong>01/10/11</strong> : Initial BETA released.</p>
+<!----------------------------------------------------------------------------->
+
+<h2 id="installation-updating">Installation &amp; updating</h2>
+<h3 id="system-requirements">System requirements</h3>
+<ol style="list-style-type: decimal">
+<li><a href="http://www.eclipse.org/downloads/">Eclipse</a> 3.6 or above.</li>
+<li><a href="http://www.grammaticalframework.org/download/release-3.3.3.html">GF 3.3.3</a> or above. The path to GF must be set within the plugin preferences (see below).</li>
+</ol>
+<p>Using the GF Resource Grammar Library requires that the RGL binaries are also installed on your system. If you are using the <a href="http://www.grammaticalframework.org/download/index.html">pre-compiled binaries</a> but have separately downloaded the RGL sources to your system, you can optionally specify this path in the plugin preferences (see below).</p>
+<h3 id="installing-the-plugin-for-the-first-time">Installing the plugin for the first time</h3>
+<h4 id="available-software-sites">Available Software Sites</h4>
+<p>In order for dependencies to be satisfied, you need to ensure that your Eclipse has the following update site URLs set:</p>
+<ul>
+<li>Eclipse releases (change version name to match): <code>http://download.eclipse.org/releases/indigo</code></li>
+<li>Xtext: <code>http://download.eclipse.org/modeling/tmf/xtext/updates/composite/releases/</code></li>
+</ul>
+<p>You can set these from <strong>Preferences → Install/Update → Available Software Sites</strong>.</p>
+<h4 id="eclipse-preferences">Eclipse preferences</h4>
+<p>How to find the <strong>Eclipse preferences</strong> window depends on your Eclipse version and/or OS, and may be either of:</p>
+<ul>
+<li><strong>Window → Preferences</strong></li>
+<li><strong>Eclipse → Preferences</strong></li>
+</ul>
+<h3 id="installation">Installation</h3>
+<ol style="list-style-type: decimal">
+<li>Inside Eclipse, go to <strong>Help → Install New Software</strong>.</li>
+<li>Add new software site using the URL: <code>http://www.grammaticalframework.org/eclipse/release/</code></li>
+<li>Select the <strong>GF Eclipse Plugin</strong>, and make sure the <strong>Contact all update sites during install to find required software</strong> option is checked.</li>
+<li>Click Next, accept the license agreement and install.</li>
+<li>Accept the prompt warning that the software is unsigned.</li>
+<li>Restart Eclipse when prompted.</li>
+</ol>
+<h4 id="settings-preferences">Settings &amp; preferences</h4>
+<ol style="list-style-type: decimal">
+<li>Add the GF perspective by clicking <strong>Window → Open Perspective → Other</strong> and choosing <strong>GF</strong>.</li>
+<li>Open the plugin settings by going to <strong>Preferences → Grammatical Framework</strong> (image below).</li>
+<li>The plugin will try to determine the path to your GF executable automatically, but this may need to be corrected.<br />The path should include the name of the GF binary itself, e.g. <code>/home/john/.cabal/bin/gf</code> or <code>C:\Users\John\GF\bin\gf.exe</code>.</li>
+<li>The <em>Additional path directive</em> setting can be used if you want to avoid writing <code>--# -path=...</code> directives in your source files. By default it is set to <code>.:alltenses:prelude</code>, but can also be left blank. This is passed to GF using the <code>--path</code> flag.</li>
+<li>If you are using a pre-compiled version of the Resource Grammar Library (i.e. you didn't build it from source yourself) but you have the sources available on your system, then you can enter their path in the <em>Library source path</em> setting. This is optional and is only used for jumping to source definitions.<br />You should enter an absolute system path, up to and including the <code>src</code> folder, e.g. <code>/home/john/GF/lib/src/</code> or <code>C:\Users\John\GF\lib\src\</code>.</li>
+<li>You can also adjust the verbosity level of the GFEP console log in the preferences window.</li>
+</ol>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-preferences.png" alt="Plugin preferences window" /><p class="caption">Plugin preferences window</p>
+</div>
+<h3 id="updating-the-plugin">Updating the plugin</h3>
+<ol style="list-style-type: decimal">
+<li>In Eclipse, go to <strong>Help → Check for updates</strong>.</li>
+<li>Any available updates will appear in the dialog. Select them and follow the usual steps.</li>
+</ol>
+<p><em>Note:</em> You will probably want to uncheck the <strong>Contact all update sites during install to find required software</strong> option, which is not usually needed when simply updating the plugin (it makes things go a lot slower).</p>
+<h4 id="deprecations">Deprecations</h4>
+<ul>
+<li>Any folders <code>.gfexternal</code> can safely deleted as of GFEP ≥ 1.5. Using Eclipse's <strong>Clean</strong> function from the <strong>Run</strong> menu will do this for you automatically.</li>
+<li>If your project has a folder named <code>(External)</code> you can safely delete this <strong>via the Eclipse Project Explorer</strong>. It is no longer used in GFEP ≥ 1.2.3</li>
+<li>If your workspace contains a log file <code>gfep.log</code> then you can safely delete it from your system. As of version 1.2.4, GFEP uses Eclipse's standard log file at <code>&lt;workspace&gt;/.metadata/.log</code></li>
+</ul>
+<h3 id="project-settings">Project settings</h3>
+<p>Although the plugin should take care of your project settings for you, in case anything gets messed up you can always correct them manually as follows:</p>
+<h4 id="project-nature">Project nature</h4>
+<p>Your <code>.project</code> file should include the GF Project Nature as follows:</p>
+<pre><code>&lt;natures&gt;
+  &lt;nature&gt;org.grammaticalframework.eclipse.ui.natures.projectNatureID&lt;/nature&gt;
+&lt;/natures&gt;</code></pre>
+<h4 id="builder">Builder</h4>
+<p>Your <code>.project</code> file should include the GF Builder as follows:</p>
+<pre><code>&lt;buildSpec&gt;
+  &lt;buildCommand&gt;
+      &lt;name&gt;org.grammaticalframework.eclipse.ui.build.GFBuilderID&lt;/name&gt;
+      &lt;arguments&gt;
+      &lt;/arguments&gt;
+  &lt;/buildCommand&gt;
+&lt;/buildSpec&gt;</code></pre>
+<h4 id="specifying-build-files">Specifying build files</h4>
+<p>As of GFEP ≥ 1.5.2, you are now able to explicitly a set of modules in your GF project which should be either included or excluded from the build process. In the inclusive case, this would normally contain your &quot;top-level&quot; modules. This can be done right-clicking on your project in the Project Explorer and choosing <strong>Properties → GF Build Settings</strong>. From here you simply tick which modules in your project the GF builder should compile:</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-project-build-settings.png" alt="Project-specific build settings" /><p class="caption">Project-specific build settings</p>
+</div>
+<p>When doing this, GFEP will never attempt to compile any other files in the project. Whenever you add a new top-level module or change your module hierarchy, be sure to check these build settings again.</p>
+<!----------------------------------------------------------------------------->
+
+<h2 id="getting-started">Getting started</h2>
+<p>Some steps you can follow to get a feel of of the plugin's features.</p>
+<h3 id="video-tutorial">Video tutorial</h3>
+<p>A quick run through of the major features available in the GF Eclipse Plugin.</p>
+<iframe src="http://player.vimeo.com/video/38768382?byline=0&amp;portrait=0" width="693" height="512" frameborder="0" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>
+
+<p><em>If the video doesn't appear above, you can view it at <a href="https://vimeo.com/38768382">https://vimeo.com/38768382</a></em></p>
+<h3 id="the-eclipse-workspace-and-project-concepts">The Eclipse <em>workspace</em> and <em>project</em> concepts</h3>
+<p>When you run Eclipse, it asks you to create or specify a <em>workspace</em> on your system, which is essentially the top directory that Eclipse will &quot;see&quot;. Any code you wish to work on inside Eclipse must reside in this workspace. A workspace contains one or more <em>projects</em>, which may or may not be related to each other. Generally each folder under the top-level workspace directory is considered an individual project, i.e.:</p>
+<pre><code>workspace/
+    Project1/
+        file1-1.gf
+        file1-2.gf
+    Project2/
+        subdir2-1/
+            file2-1-1.gf
+            file2-1-2.gf
+        file2-1.gf
+        file2-2.gf</code></pre>
+<p>If you open an existing folder as your workspace in Eclipse, then your folders in that workspace <strong>do not</strong> automatically become Eclipse projects. To do this, you must follow the &quot;Create new GF Project&quot; wizard below, and give your project the exact name of the existing folder (e.g. <code>Project1</code> or <code>Project2</code> in the example above.)</p>
+<h4 id="gf-nature">GF Nature</h4>
+<p>The <em>GF Nature</em> is what makes a regular Eclipse project a <em>GF</em> project. If you create a new GF Project from scratch then you don't need to worry too much about them. If you already have some project set up in your Eclipse workspace, then you will need to associate the builder with your project in order for all the GF goodness to work. This will internally add the <em>GF Builder</em> to your project also.</p>
+<p>As of 1.4.2, this can be done very easily by right-clicking on your project in the explorer and clicking <strong>Add/Remove GF Nature</strong>. If your project has the GF icon overlayed on it, then the GF nature and builder are correctly associated with it.</p>
+<p>See the <strong>project settings</strong> section above if you want to mess with your <code>.project</code> file.</p>
+<h4 id="metadata-folders">Metadata folders</h4>
+<p>GFEP will create the following metadata directories within your project:</p>
+<ul>
+<li>A <code>.gfbuild</code> directory in every folder containing GF source code, containing <code>.gf-tags</code> files created using the GF <code>--tags</code> compiler flag.</li>
+</ul>
+<p>These can be removed manually at any time, as they will always be regenerated as necessary. You will probably want to ignore these directories in your version control system.</p>
+<h3 id="create-a-new-gf-project">Create a new GF Project</h3>
+<p>If you have a folder in your workspace which you want to convert into a GF Project, then you can select it from the drop-down. This folder will then appear as an Eclipse project in your workspace.</p>
+<p><img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-projectwizard-1.png" alt="New project wizard" /> <img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-projectwizard-2.png" alt="New project wizard" /></p>
+<h3 id="new-module-wizard">New module wizard</h3>
+<p>Use the <strong>GF Module</strong> wizard from <strong>File → New → Other → GF Module</strong>:</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-modulewizard-1.png" alt="New module wizard" /><p class="caption">New module wizard</p>
+</div>
+<p>You can find some small examples <a href="https://github.com/GrammaticalFramework/gf-eclipse-plugin/tree/master/workspace-demo/GF%20Project">here</a>. Download the files and manually add them to your Eclipse workspace to experiment with some of the plugin features.</p>
+<h3 id="clone-module-wizard">Clone module wizard</h3>
+<p>If you want to clone an existing module into a new language, you can now do so via the <strong>Clone GF Module</strong> wizard. This is also available as a context menu option in the <strong>Project Explorer</strong>, via <strong>&lt;Right click&gt; → Grammatical Framework → Compile for new language</strong>:</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-clonewizard.png" alt="Clone GF module to new language wizard" /><p class="caption">Clone GF module to new language wizard</p>
+</div>
+<p>This will create and open a new module with the relevant replacements made. Note how in this case string constants are replaced by the empty string <code>&quot;&quot;</code>. This wizard currently only works on <code>concrete</code> and <code>instance</code> modules.</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-clonewizard-newfile.png" alt="Newly cloned file" /><p class="caption">Newly cloned file</p>
+</div>
+<h3 id="workbench-editor-layout">Workbench editor layout</h3>
+<p>Use Eclipse' own features to drag and drop your editor tabs to suit your needs.</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-editor-general.png" alt="The editor and outline view" /><p class="caption">The editor and outline view</p>
+</div>
+<h3 id="outline-view">Outline view</h3>
+<p>The <strong>Outline</strong> view in the bottom-left offers a quite overview of your module structure. Clicking any of the terms will make your cursor jump to that point in the file.</p>
+<h3 id="cross-referencing-errors-and-warnings">Cross-referencing errors and warnings</h3>
+<p>Notice how changing a <code>cat</code> definition for example will produce warnings and/or errors in other the modules.</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-editor-cat.png" alt="Warnings and errors in the editor" /><p class="caption">Warnings and errors in the editor</p>
+</div>
+<h3 id="validation">Validation</h3>
+<p>The in-editor validation sometimes needs to be triggered/updated by a keystroke. If you can still see errors which you believe should be correct, try adding a space character to ensure the validation is re-triggered.</p>
+<p>Sometimes you may get an entire file marked with errors, even though in fact there is only a single error which is causing the internal builder to fail. In such cases referring to the <strong>Problems</strong> view should help you locate the cause. This issue is particularly relevant when changes made to one module may induce errors in its descendants (e.g. renaming a parameter in a resource module). This behaviour will hopefully be improved in future versions.</p>
+<h4 id="builder-1">Builder</h4>
+<p>For validation to work correctly, the project's <strong>Build Automatically</strong> option should be turned on. Each time you save a file (or some other change occurs in your project), the builder should get triggered which re-compiles any GF files which have changed. If the builder does not seem to get triggered, try to run a <em>clean</em> via <strong>Project → Clean...</strong></p>
+<h3 id="code-formatting">Code formatting</h3>
+<p>Use the built-in code formatter to tidy your code automatically. Right-click in the editor and choose <strong>Format</strong> or use the keyboard shortcut <strong>Ctrl+Shift+F</strong>.</p>
+<p><img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-before-format.png" alt="Before auto-formatting" /> <img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-after-format.png" alt="After auto-formatting" /></p>
+<h3 id="syntax-highlighting">Syntax highlighting</h3>
+<p>You can change your syntax colouring styles as you wish from <strong>Preferences → Grammatical Framework → Syntax Colouring</strong></p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-syntaxcoloring.png" alt="Syntax highlighting styles" /><p class="caption">Syntax highlighting styles</p>
+</div>
+<h3 id="launch-configurations">Launch configurations</h3>
+<p>Set up a launch configuration from <strong>Run → Run Configurations... → Grammatical Framework</strong>. You will see the dialog below with some fields automatically filled in for you.</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-launchconfig.png" alt="Launch configuration dialog" /><p class="caption">Launch configuration dialog</p>
+</div>
+<p>Run the launch config and you will see the output from the GF compiler in the console view within Eclipse.</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-compileroutput.png" alt="Output from the GF compiler" /><p class="caption">Output from the GF compiler</p>
+</div>
+<h4 id="run-as...-launch-shortcut">Run As... launch shortcut</h4>
+<p>Using the <strong>Run → Run As → Compile with GF</strong> shortcut will take the current selection or active editor and do one of two things:</p>
+<ol style="list-style-type: decimal">
+<li>If a launch configuration already exists which the current file in its <em>Source filenames</em> field, then that config will be launch directly.</li>
+<li>Otherwise, a new a launch configuration window is displayed where you will need to review and confirm the default settings before continuing.</li>
+</ol>
+<h3 id="consoles">Consoles</h3>
+<p>The plugin provides its own console view named <em>GFEP Log</em>, which shows log messages based on the <strong>Log Level</strong> preference (<strong>Preferences → Grammatical Framework</strong>).</p>
+<p>Additionally, every time a grammar is <strong>Run</strong> a <em>new</em> console is opened to display the output. This console may also serve as the interactive GF Shell, depending on the <strong>Interactive Mode</strong> checkbox in your <strong>Run Configuration</strong>.</p>
+<p>Eclipse does not make it obvious when multiple console windows open; click on the <strong>Display Selected Console</strong> button to switch between open consoles:</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-console-icon.png" alt="Display Selected Console icon" /><p class="caption">Display Selected Console icon</p>
+</div>
+<p>If the process associated with a console window has terminated, it will be indicated in the upper-left corner as below. Such console windows can then be closed using the grey cross button:</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-console-terminated.png" alt="Close terminated console icon" /><p class="caption">Close terminated console icon</p>
+</div>
+<p><em>The Eclipse console implementation does not support command history (up arrow) or auto-completion (tab).</em></p>
+<h3 id="external-libraries-view"><em>External Libraries</em> view</h3>
+<p>This view is automatically populated with a list of all the external modules referenced by the current file. Double-clicking on any item provides a quick way of opening GF files which are imported into your grammar from outside your Eclipse project, for example the GF Resource Grammar Library.</p>
+<p>This view also provides a text box for searching within the current module's scope, as shown in the image below. Clicking the small arrow on the right-hand side of the view provides options for case sensitive and/or regular-expression based search.</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-external-libraries.png" alt="External libraries view" /><p class="caption">External libraries view</p>
+</div>
+<h3 id="test-manager-view"><em>Test Manager</em> view</h3>
+<p>This feature works together with the launch configurations to make the process of running regression tests on your grammars quick and easy. As described in the <a href="http://www.grammaticalframework.org/gf-book/">GF Book</a> (Section 10.5), the general development-test cycle (independent of GFEP) is as follows:</p>
+<ol style="list-style-type: decimal">
+<li>Create a file <code>test.trees</code> which contains a bunch of abstract syntax trees, which you want to test</li>
+<li>Compile your grammar and linearise the trees one by one, using some command like <code>rf -lines -tree -file=test.trees | l -table | wf -file=test.trees.out</code></li>
+<li>Manually correct the output in <code>test.trees.out</code> and save it as your gold standard file <code>test.trees.gold</code>.</li>
+<li>Each time you update your grammar, repeat step 2, then compare your new output against the gold standard using <code>diff</code> or some other comparison tool.</li>
+</ol>
+<p>The <strong>Test Manager</strong> view follows this same pattern but provides a convenient graphical interface for running your test cases and also for looking at the output, just using a few clicks:</p>
+<div class="figure">
+<img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/eclipse-test-manager.png" alt="Test Manager view" /><p class="caption">Test Manager view</p>
+</div>
+<p>Note that GFEP assumes the following convention:</p>
+<table>
+<thead>
+<tr class="header">
+<th align="left">Extension</th>
+<th align="left">Description</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td align="left"><code>*.trees</code> or <code>*.sentences</code></td>
+<td align="left">Test input files: trees file (for testing linearisation) and sentences file (for testing parsing)</td>
+</tr>
+<tr class="even">
+<td align="left"><code>*.trees.out</code> or <code>*.sentences.out</code></td>
+<td align="left">Corresponding output files (generated each time a test is run)</td>
+</tr>
+<tr class="odd">
+<td align="left"><code>*.trees.gold</code> or <code>*.sentences.gold</code></td>
+<td align="left">Corresponding gold standard files (manually corrected from an output file)</td>
+</tr>
+</tbody>
+</table>
+<h3 id="logs">Logs</h3>
+<p>The GFEP writes to the Eclipse platform log. This can be accessed in two ways:</p>
+<ol style="list-style-type: decimal">
+<li>By opening the <strong>Error Log</strong> view in Eclipse</li>
+<li>Accessing the file directly at <code>&lt;workspace&gt;/.metadata/.log</code></li>
+</ol>
+<p>You can set the log verbosity from <strong>Preferences → Grammatical Framework</strong>.</p>
+<!----------------------------------------------------------------------------->
+
+<h2 id="common-issues-and-fixes">Common issues and fixes</h2>
+<h3 id="no-identifiers-are-resolved-and-my-log-contains-messages-saying-file-syntax.gf-does-not-exist.">No identifiers are resolved and my log contains messages saying &quot;File Syntax.gf does not exist.&quot;</h3>
+<p>In general, this means that something is wrong with your <em>library path</em> setting.</p>
+<p>GFEP attempts to compile all of your files individually with GF, which is not the usual way in which you would compile your grammar. As a result, when looking for the RGL files, GF needs a little help via the <code>path</code> argument.</p>
+<p>The normal way to do this is to specify the <em>Library path</em> setting from <strong>Preferences → Grammatical Framework</strong>, setting it to something like <code>.:alltenses:prelude</code> (this is the default setting). Note that these paths are relative to the true RGL directory, which GF should already be aware of. The value of this setting is passed to GF from GFEP using the <code>--path</code> flag.</p>
+<p>The <em>Library path</em> setting is the same for all your GF projects. If you want finer-grain control over the <code>path</code> compiler option then you should use compiler pragmas in your source files, e.g.:</p>
+<pre><code>--# -path=.:alltenses:prelude</code></pre>
+<p>The advantage of this method is that the information is bound to the file, so you can freely compile your modules outside of GFEP without having to specify the path as a command line option to GF. The disadvantage is that you need to specify such a pragma in every single file (at least if you want to continue to use the GFEP).</p>
+<h3 id="other-strange-behaviour">Other strange behaviour</h3>
+<p>When things seem strange, the very first step is always to clean the project via <strong>Project → Clean...</strong>. I only support the latest version of the plugin, so make sure you are up to date too.</p>
+<p>If problems persist, please contact me or better yet file an issue on the GitHub issue tracker (see below).</p>
+<!----------------------------------------------------------------------------->
+
+<h2 id="ontology-grammar-plugin">Ontology Grammar plugin</h2>
+<p>For information about the Ontology Grammar plugin developed by Ontotext AD, please refer <a href="https://github.com/GrammaticalFramework/gf-eclipse-plugin/blob/master/README_ontology-grammar.md">here</a>.</p>
+<!----------------------------------------------------------------------------->
+
+<h2 id="for-developers">For developers</h2>
+<h3 id="project-setup">Project setup</h3>
+<p>In order to build/run the GFEP from source, you need to have the Xtext libraries available in your Eclipse workspace. You have two choices:</p>
+<ol style="list-style-type: decimal">
+<li>Download the Xtext libraries from <a href="http://www.eclipse.org/Xtext/download/">http://www.eclipse.org/Xtext/download/</a> and add them to your existing Eclipse instance</li>
+<li>Download a release of Eclipse packaged together with Xtext from <a href="http://xtext.itemis.com/xtext/language=en/36553/downloads">http://xtext.itemis.com/xtext/language=en/36553/downloads</a></li>
+</ol>
+<p>In both cases make sure you get the correct version of Xtext (see below). Once you have Xtext set up, you can clone the repository locally with the following command:</p>
+<pre><code>git clone git://github.com/GrammaticalFramework/gf-eclipse-plugin.git</code></pre>
+<p>You can then add the projects under the <code>workspace</code> directory to your Eclipse workspace, by using the <strong>File → Import...</strong> wizard. The individual projects are:</p>
+<table>
+<thead>
+<tr class="header">
+<th align="left">Namespace</th>
+<th align="left">Description</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td align="left"><code>org.grammaticalframework.eclipse.ui</code></td>
+<td align="left">Covers all UI aspects of the plugin. Depends on <code>org.grammaticalframework.eclipse</code> (but the opposite is not true).</td>
+</tr>
+<tr class="even">
+<td align="left"><code>org.grammaticalframework.eclipse.tests</code></td>
+<td align="left">Contains unit tests for the plugin. Not required for running the plugin.</td>
+</tr>
+<tr class="odd">
+<td align="left"><code>org.grammaticalframework.eclipse.ontology-grammar</code></td>
+<td align="left">GF Ontology Grammar Plugin for Eclipse, developed separately by Ontotext AD.</td>
+</tr>
+<tr class="even">
+<td align="left"><code>org.grammaticalframework.feature</code></td>
+<td align="left">Feature project for the GF Eclipse Plugin. Exports <code>org.grammaticalframework.eclipse</code> and <code>org.grammaticalframework.eclipse.ui</code>.</td>
+</tr>
+<tr class="odd">
+<td align="left"><code>org.grammaticalframework.feature.ontology-grammar</code></td>
+<td align="left">Feature project for the GF Ontology Grammar Plugin. Exports <code>org.grammaticalframework.eclipse.ontology-grammar</code>.</td>
+</tr>
+<tr class="even">
+<td align="left"><code>org.grammaticalframework.updatesite</code></td>
+<td align="left">Update site project which exports both feature projects under the same category.</td>
+</tr>
+</tbody>
+</table>
+<h4 id="extra-dependencies-for-unit-testing-project">Extra dependencies for unit testing project</h4>
+<p>The unit testing project (<code>org.grammaticalframework.eclipse.tests</code>) has an extra requirement for the library <code>org.eclipselabs.xtext.utils.unittesting</code>, which you will probably get complaints about when importing your projects into Eclipse. You only need to worry about this if you want to run the unit tests; otherwise you can ignore these errors. You can get more information about this library <a href="http://code.google.com/a/eclipselabs.org/p/xtext-utils/wiki/Unit_Testing">here</a>, or just install it in Eclipse directly using the following update site URL: <a href="http://xtext-utils.eclipselabs.org.codespot.com/git.distribution/releases/unittesting-0.9.x/">http://xtext-utils.eclipselabs.org.codespot.com/git.distribution/releases/unittesting-0.9.x/</a></p>
+<h4 id="xtext-version">Xtext version</h4>
+<p>GFEP currently uses <strong>Xtext 2.1.0</strong>.</p>
+<h3 id="running-from-source">Running from source</h3>
+<p>Once you have set up your projects (see above), you can run/debug the GFEP by following the steps <a href="http://www.eclipse.org/Xtext/documentation/2_1_0/020-domainmodel-step-by-step.php#DomainmodelWalkThrough_7">here</a>. Note that this means you will be running <em>two</em> instances of Eclipse simultaneously; the first debugging the second.</p>
+<h3 id="building-plugin-package">Building plugin package</h3>
+<p>To package the GFEP sources as <code>.jar</code> files and install/update the GFEP in a separate Eclipse installation, do the following:</p>
+<ol style="list-style-type: decimal">
+<li>Open <code>site.xml</code> in the <code>org.grammaticalframework.updatesite</code> project with Eclipse's Site Manifest Editor (default).</li>
+<li><strong>Synchronize</strong> the feature versions with the update site project.</li>
+<li>Click <strong>Build All</strong> and the necessary <code>.jar</code> files should be created/updated in the project's folder. These can then be copied, along with <code>site.xml</code> to any local or web directory, which becomes the &quot;update site&quot;.</li>
+</ol>
+<h4 id="artifacts.jar-and-contents.jar"><code>artifacts.jar</code> and <code>contents.jar</code></h4>
+<p>These are two meta-data files created by the update site project. However there are known issues with categories sporadically not working in update sites, and it seems that if you delete these 2 files then the problems are solved. More about this can be found <a href="http://ekkescorner.wordpress.com/2010/04/18/who-eats-the-categories-from-update-sites/">here</a>.</p>
+<h4 id="other-notes">Other notes</h4>
+<p>Some have mentioned than when opening the GFEP sources, under Linux, they needed to install the following:</p>
+<pre><code>sudo apt-get install appmenu-gtk
+sudo apt-get install gtk2-engines-pixbuf</code></pre>
+<!----------------------------------------------------------------------------->
+
+<h2 id="evaluation-feedback">Evaluation &amp; feedback</h2>
+<p>Please try to use the plugin for developing your own GF projects and report any issues you come up against. Feedback (both negative and positive) on the following would be appreciated:</p>
+<ol style="list-style-type: decimal">
+<li>Issues encountered with installation</li>
+<li>Incorrect support of GF syntactic constructs, module hierarchy system</li>
+<li>Performance issues (speed, resources footprint)</li>
+<li>General intuitiveness of the UI</li>
+<li>Feature wish-list</li>
+<li>Compatibilities / conflicts with other Eclipse plugins</li>
+</ol>
+<p>For all bug reports and feature requests, please use the <a href="https://github.com/GrammaticalFramework/gf-eclipse-plugin/issues">GitHub Issue Tracker</a>.</p>
+<!----------------------------------------------------------------------------->
+
+<h2 id="appendix">Appendix</h2>
+<h3 id="module-types">Module types</h3>
+<p>Description of the GF module types and their icons within the GF Eclipse Plugin.</p>
+<table>
+<thead>
+<tr class="header">
+<th align="left">Icon</th>
+<th align="left">Description</th>
+<th align="left">Notes</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td align="left"><img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/module-abstract.png" /></td>
+<td align="left">Abstract module</td>
+<td align="left"><code>abstract Foods = {...}</code></td>
+</tr>
+<tr class="even">
+<td align="left"><img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/module-concrete.png" /></td>
+<td align="left">Concrete module</td>
+<td align="left"><code>concrete FoodsEng of Foods = {...}</code></td>
+</tr>
+<tr class="odd">
+<td align="left"><img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/module-resource.png" /></td>
+<td align="left">Resource module</td>
+<td align="left"><code>resource ResFoods = {...}</code></td>
+</tr>
+<tr class="even">
+<td align="left"><img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/module-interface.png" /></td>
+<td align="left">Interface</td>
+<td align="left"><code>interface LexFoods = {...}</code></td>
+</tr>
+<tr class="odd">
+<td align="left"><img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/module-instance.png" /></td>
+<td align="left">Instance</td>
+<td align="left"><code>instance LexFoodsEng of LexFoods = {...}</code></td>
+</tr>
+<tr class="even">
+<td align="left"><img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/module-functor.png" /></td>
+<td align="left">Functor</td>
+<td align="left"><code>incomplete concrete FoodsI of Foods = {...}</code></td>
+</tr>
+<tr class="odd">
+<td align="left"><img src="https://raw.github.com/GrammaticalFramework/gf-eclipse-plugin/master/doc/images/module-functor-instantiation.png" /></td>
+<td align="left">Functor instantiation</td>
+<td align="left"><code>concrete FoodsEng of Foods = FoodsI with (...) {...}</code></td>
+</tr>
+</tbody>
+</table>
+<h3 id="build-command">Build command</h3>
+<p>This is the GF command run by the builder:</p>
+<pre><code>gf --v=0 --tags --output-dir=.gfbuild [--path=PATH] FILE</code></pre>
+</body>
+</html>
+
+

examples/READ_ME

@@ -0,0 +1,14 @@
+All contributions (`contrib` and `examples` folders) have now been
+moved to a separate git repository at:
+
+https://github.com/GrammaticalFramework/gf-contrib
+
+This `examples` folder remains because its contents are compiled by
+SetupWeb, so that when you run the GF cloud server locally you already
+have some toy grammars to play with.
+
+Any updates to these grammars should be made at the gf-contrib repository
+above; changes will be copied from there to here manually.
+
+John J. Camilleri
+2013-09-16

examples/app/App.gf

@@ -0,0 +1,49 @@
+
+
+abstract App = 
+  Translate - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+--P  ,Phrasebook
+
+              ** {
+flags
+  startcat=Phr ;
+  heuristic_search_factor=0.80; -- doesn't seem to affect speed or quality much
+
+fun
+--P  PhrasePhr : Phrase -> Phr ;
+--P  Phrase_Chunk : Phrase -> Chunk ;
+
+  ComplV2 : V2 -> NP -> VP ;  -- sees him
+  
+  ComplV2V : V2V -> NP -> VP -> VP ;  -- forces him to leave
+--  ComplV2A : V2A -> NP -> AP -> VP ;
+--  ComplV2Q : V2Q -> NP -> QS -> VP ;
+--  ComplV2S : V2S -> NP -> S  -> VP ;
+  ComplV3  : V3  -> NP -> NP -> VP ;  -- gives him an apple
+
+  PassV2       : V2 -> VP ;  -- is seen
+  PassAgentV2  : V2 -> NP -> VP ;  -- is seen by her
+  RelV2        : RP -> NP -> V2 -> RCl ; -- that she sees
+  QuestV2      : IP -> NP -> V2 -> QCl ; -- whom does she see
+
+}

examples/app/AppBul.gf

@@ -0,0 +1,28 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppBul of App = 
+
+  TranslateBul - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxBul) ;
+

examples/app/AppCat.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppCat of App = 
+
+  TranslateCat - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxCat) ;

examples/app/AppChi.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppChi of App = 
+
+  TranslateChi - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxChi) ;

examples/app/AppDut.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppDut of App = 
+
+  TranslateDut - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxDut) ;

examples/app/AppEng.gf

@@ -0,0 +1,28 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppEng of App = 
+
+  TranslateEng - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxEng) ;
+

examples/app/AppEst.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../../lib/src/estonian:../phrasebook/gfos:alltenses
+
+concrete AppEst of App = 
+
+  TranslateEst - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxEst) ;

examples/app/AppFin.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/finnish/stemmed:../../lib/src/finnish:../../lib/src/api:../../lib/src/translator:../phrasebook/gfos:alltenses
+
+concrete AppFin of App = 
+
+  TranslateFin - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxFin) ;

examples/app/AppFre.gf

@@ -0,0 +1,26 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppFre of App = 
+  TranslateFre - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxFre) ;

examples/app/AppFunctor.gf

@@ -0,0 +1,46 @@
+incomplete concrete AppFunctor of App = 
+
+  Translate - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** open Syntax in {
+
+flags
+  literal=Symb ;
+
+lin
+  ComplV2 v np = mkVP v np ;
+
+  ComplV2V v np vp = mkVP v np vp ;
+--  ComplV2A v np vp = mkVP v np vp ;
+--  ComplV2Q v np vp = mkVP v np vp ;
+--  ComplV2S v np vp = mkVP v np vp ;
+  ComplV3  v np vp = mkVP v np vp ;
+
+
+
+  PassV2 v2 = passiveVP v2 ;
+  PassAgentV2 v2 np = mkVP (passiveVP v2) (mkAdv by8agent_Prep np) ;
+  RelV2 rp np v2 = mkRCl rp (mkClSlash np (mkVPSlash v2)) ;
+  QuestV2 ip np v2 = mkQCl ip (mkClSlash np (mkVPSlash v2)) ;
+
+}

examples/app/AppGer.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos:alltenses::../../lib/src/german
+
+concrete AppGer of App = 
+
+  TranslateGer - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxGer) ;

examples/app/AppHin.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppHin of App = 
+
+  TranslateHin - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxHin) ;

examples/app/AppIta.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppIta of App = 
+
+  TranslateIta - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxIta) ;

examples/app/AppJpn.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppJpn of App = 
+
+  TranslateJpn - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxJpn) ;

examples/app/AppRus.gf

@@ -0,0 +1,27 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppRus of App = 
+
+  TranslateRus - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxRus) ;

examples/app/AppSpa.gf

@@ -0,0 +1,28 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+
+concrete AppSpa of App = 
+
+  TranslateSpa - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxSpa) ;

examples/app/AppSwe.gf

@@ -0,0 +1,26 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppSwe of App = 
+  TranslateSwe - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxSwe) ;

examples/app/AppTha.gf

@@ -0,0 +1,28 @@
+--# -path=.:../../lib/src/chunk:../../lib/src/translator:../phrasebook/gfos
+
+concrete AppTha of App = 
+
+  TranslateTha - [
+  -- Verb
+    SlashV2a,ComplSlash, -- replaced by a more efficient inlined version
+    SlashV2V,             
+    Slash2V3, Slash3V3, SlashV2S, SlashV2Q, SlashV2A, 
+    SlashVV, SlashV2VNP,
+    AdvVPSlash, AdVVPSlash, VPSlashPrep,
+  -- Sentence
+    SlashVP, SlashVS,
+    PredSCVP, 
+    AdvSlash, SlashPrep, SlashVS,
+    EmbedS, EmbedQS, EmbedVP, RelS,
+  -- Question
+    ComplSlashIP,AdvQVP,AddAdvQVP,QuestQVP,
+  -- Idiom
+    CleftNP, CleftAdv,
+    ImpP3,
+  -- Construction
+  -- Extensions
+    PassVPSlash, PassAgentVPSlash -- not reachable anyway
+  ]
+
+   ** AppFunctor with (Syntax = SyntaxTha) ;
+

examples/app/Makefile

@@ -0,0 +1,69 @@
+all: App16.pgf
+
+PROBSFILE=./app.probs
+GFODIR=./gfos
+
+.Phony: Phrasebook
+
+Phrasebook:
+	cd ../phrasebook ; make forApp ; cd ../app
+
+S=-s
+GFMKT=mkdir -p $(GFODIR) && gf $S -make -literal=PN,Symb -probs=$(PROBSFILE) -gfo-dir $(GFODIR)
+
+APP11=AppEng.pgf AppBul.pgf AppChi.pgf AppGer.pgf AppSwe.pgf AppHin.pgf AppFin.pgf AppFre.pgf AppIta.pgf AppSpa.pgf AppDut.pgf
+APP12=$(APP11) AppCat.pgf
+APP13=$(APP12) AppJpn.pgf
+APP14=$(APP13) AppTha.pgf
+APP15=$(APP14) AppEst.pgf
+APP16=$(APP15) AppRus.pgf
+
+# With dependencies:
+App11.pgf: $(APP11)
+	$(GFMKT) -name=App11 $(APP11) +RTS -K200M
+App12.pgf: $(APP12)
+	$(GFMKT) -name=App12 $(APP12) +RTS -K200M
+App13.pgf: $(APP13)
+	$(GFMKT) -name=App13 $(APP13) +RTS -K200M
+App14.pgf: $(APP14)
+	$(GFMKT) -name=App14 $(APP14) +RTS -K200M
+App15.pgf: $(APP15)
+	$(GFMKT) -name=App15 $(APP15) +RTS -K200M
+App16.pgf: $(APP16)
+	$(GFMKT) -name=App16 $(APP16) +RTS -K200M
+
+# Without dependencies:
+App11:
+	$(GFMKT) -name=App12 $(APP11) +RTS -K200M
+App12:
+	$(GFMKT) -name=App12 $(APP12) +RTS -K200M
+App13:
+	$(GFMKT) -name=App13 $(APP13) +RTS -K200M
+App14:
+	$(GFMKT) -name=App14 $(APP14) +RTS -K200M
+App15:
+	$(GFMKT) -name=App15 $(APP15) +RTS -K200M
+
+# App grammars for individual languages
+AppEng.pgf:: ; $(GFMKT) -name=AppEng AppEng.gf
+AppBul.pgf:: ; $(GFMKT) -name=AppBul AppBul.gf
+AppCat.pgf:: ; $(GFMKT) -name=AppCat AppCat.gf +RTS -K100M
+AppChi.pgf:: ; $(GFMKT) -name=AppChi AppChi.gf +RTS -K100M
+AppDut.pgf:: ; $(GFMKT) -name=AppDut AppDut.gf +RTS -K64M
+AppEst.pgf:: ; $(GFMKT) -name=AppEst AppEst.gf +RTS -K64M
+AppFin.pgf:: ; $(GFMKT) -name=AppFin AppFin.gf +RTS -K64M
+AppGer.pgf:: ; $(GFMKT) -name=AppGer AppGer.gf +RTS -K64M
+AppHin.pgf:: ; $(GFMKT) -name=AppHin AppHin.gf
+AppFre.pgf:: ; $(GFMKT) -name=AppFre AppFre.gf +RTS -K64M
+AppIta.pgf:: ; $(GFMKT) -name=AppIta AppIta.gf +RTS -K64M
+AppJpn.pgf:: ; $(GFMKT) -name=AppJpn AppJpn.gf +RTS -K64M
+AppRus.pgf:: ; $(GFMKT) -name=AppRus AppRus.gf +RTS -K64M
+AppSpa.pgf:: ; $(GFMKT) -name=AppSpa AppSpa.gf +RTS -K64M
+AppSwe.pgf:: ; $(GFMKT) -name=AppSwe AppSwe.gf
+AppTha.pgf:: ; $(GFMKT) -name=AppTha AppTha.gf
+
+# language pairs to test
+AppEngSwe: ; $(GFMKT) -name=AppEngSwe AppEng.pgf AppSwe.pgf
+AppEngFin: ; $(GFMKT) -name=AppEngFin AppEng.pgf AppFin.pgf
+AppEngChi: ; $(GFMKT) -name=AppEngChi AppEng.pgf AppChi.pgf
+

examples/app/MkApp.hs

@@ -0,0 +1,27 @@
+-- update the import list of every language
+-- although possibly some extra definitions at the end
+-- the new files are produced in ./tmp/ which has to be created first
+-- usage: runghc MkApp.hs
+
+langs = words "Bul Cat Chi Dut Eng Est Fin Fre Ger Hin Ita Jpn Spa Swe Tha"
+appCnc lang = "App" ++ lang ++ ".gf"
+
+appAbs = "App.gf"
+
+main = do
+  imports <- readFile appAbs >>= return . getImports
+  mapM_ (\f -> readFile f >>= writeFile ("tmp/" ++ f) . (putImports imports)) (map appCnc langs)
+
+getImports = takeWhile (/= ']') . tail . dropWhile (/='[')
+
+putImports i s = 
+  let
+    (s1,_:s2) = span (/='[') s
+    (_,   s3) = span (/=']') s2
+  in s1 ++ "[" ++ i ++ extra s3
+
+extra s = unlines (init (lines s) ++ extraLines ++ ["}"])
+
+extraLines = [
+--  "  PassV2 v2 = passiveVP v2 ;"
+  ] -- default: no extra

examples/app/apertium.txt

@@ -0,0 +1,28 @@
+James and Mary are in the garden
+the weather is nice today
+it is very warm
+but yesterday it was very cold
+they could not play outside then
+James and Mary love to play
+they always play together in the garden in front of the big house
+James is a little boy and he is six years old
+the little girl is his sister
+she is five years old
+James has a small dog
+the dog is also in the garden now
+the dog likes to play with the two children
+the dog is very happy now
+does Mary also have a dog
+no , Mary does not have a dog
+she has a cat
+but the cat is in the house
+the cat is sleeping
+their mother is inside the house with the cat
+she looks through the window and sees James and Mary playing
+James quickly runs to a big old tree
+he is hiding from Mary
+do you know why
+Mary is sitting and has her hands in front of her eyes
+she can't see anything and she is counting
+why does she do that
+and what is James doing near the tree