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,46 +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/
-src/ui/android/libs/
-src/ui/android/obj/
-.cabal-sandbox
-cabal.sandbox.config
-DATA_DIR

.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'"

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)
@@ -21,6 +21,9 @@ doc:
 clean:
 	cabal clean
 
+#sdist:
+#	cabal sdist
+
 gf:
 	cabal build rgl-none
 	strip dist/build/gf/gf
@@ -42,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,60 +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
-```
-
-This can be broken down into the usual sub-steps:
-```
-cabal configure
-cabal build
-cabal copy
-```
-
-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,77 +1,438 @@
-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
     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,13 +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
+      do let dst = grammars_dir</>pgf
          putStrLn $ "Installing "++dst
-         ex <- doesFileExist src
-         if ex then copyFile src dst else return ()
+         copyFile (gfo_dir</>pgf) dst
 
     gf_logo = "gf0.png"
 
@@ -114,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
-          _ -> ""
+          _ ->-} ""

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

@@ -17,10 +17,8 @@ h1 img.nofloat { float: none; }
 img.right { float: right; }
 
 ol.languages {
-    display: flex;
-    flex-direction: column;
-    flex-wrap: wrap;
-    height: 12em;
+    column-width: 12em;
+    -moz-column-width: 12em;
 }
 
 .grow {

debian/changelog

@@ -1,9 +1,3 @@
-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

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/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

@@ -23,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
@@ -40,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/
@@ -54,32 +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/].
 
-%=== 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.
+=== Darcs ===
 
+To get the GF source code, you also need //Darcs//, version 2 or later.
+Darcs 2.10 is recommended (July 2015).
 
-=== Git ===
+//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 ===
 
@@ -89,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 ==
@@ -105,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]
@@ -129,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
@@ -147,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 ==
@@ -178,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
 ```
 
@@ -411,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 Make.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 ``Make.sh``
-(or ``Make.bat`` for Windows).
-
 
 == Creating binary distribution packages ==
 
@@ -489,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
@@ -515,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

@@ -13,21 +13,19 @@ 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).
@@ -39,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
@@ -53,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-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

@@ -412,33 +412,21 @@ use on-line ``h -FLAG``.
 
 
 
-===File import search paths===
+===File paths===
 
-Colon-separated list of directories searched in the
+Colon-separated lists of directories searched in the
 given order: 
 ```
 --# -path=.:../abstract:../common:prelude
 ```
-This can be (in order of increasing priority), as
-first line in the file, as flag to ``gf``
+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.
 
-GF attempts to satisfy an ``import`` command by searching for the
-import filename in the above search paths, initially qualified
-relative to the current working directory. If the file is not found in
-that initial expansion, the search paths are re-qualified relative to
-the directories given in the ``GF_LIB_PATH`` environment variable. If
-``GF_LIB_PATH`` is not defined, its default value is
-``/usr/local/share/gf-3.9/lib`` (assuming you have GF version 3.9).
-
-If your GF resource grammar libraries are installed somewhere else,
-you will want to set ``GF_LIB_PATH`` to point there instead. In a
-pinch, you can point to the ``GF/lib/src/`` folder in your clone of
-the GF source code repository.
-
-Developers of resource grammars may find it useful to define multiple
-directories, colon-separated, in ``GF_LIB_PATH``.
+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===

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

@@ -9,7 +9,6 @@ December 2010 for GF 3.2
 
 %!target:html
 %!encoding: iso-8859-1
-%!options: --toc
 
 %!postproc(tex) : "\\subsection\*" "\\newslide"
 %!preproc(tex): "#NEW" ""
@@ -4811,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

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/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.8.t2t

@@ -1,178 +0,0 @@
-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].
-
-
-== Binary packages ==
-
-|| Platform | Download | Features | How to install
-| Mac OS X | [gf-3.8.pkg gf-3.8.pkg] | //GF+S+C+P// | Double-click on the package icon (*)
-| Mac OS X | [gf-3.8-bin-intel-mac.tar.gz gf-3.8-bin-intel-mac.tar.gz] | //GF+S+C+P// | ``sudo tar -C /usr/local -zxf gf-3.8-bin-intel-mac.tar.gz``
-%| Fedora (32-bit) | [Fedora RPMs /~hallgren/tmp/Fedora/] | //GF+S+C+J+P// | ``sudo rpm -i ...``
-| Ubuntu (32-bit) | [gf_3.8-1_i386.deb gf_3.8-1_i386.deb] | //GF+S+C+J+P// | ``sudo dpkg -i gf_3.8-1_i386.deb``
-| Ubuntu (64-bit) | [gf_3.8-1_amd64.deb gf_3.8-1_amd64.deb] | //GF+S+C+J+P// | ``sudo dpkg -i gf_3.8-1_amd64.deb``
-| Windows | [gf-3.8-bin-windows.zip gf-3.8-bin-windows.zip] | //GF+S// | ``unzip gf-3.8-bin-windows.zip``
-%| MINGW | [gf-3.8-bin-i686-MINGW32_NT-6.1.tar.gz gf-3.8-bin-i686-MINGW32_NT-6.1.tar.gz] | //GF+S+C// | ``tar -C / gf-3.8-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 ``.deb`` packages should work on Ubuntu 12.04, 14.04 and 16.04 and similar
-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, 
-``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``,
-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.8/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.8.tar.gz`` gf-3.8.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.0.1. Using older
-versions of GHC (7.10.3, 7.10.2, 7.8, 7.6) should 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
-
-```
-  darcs get --lazy http://www.grammaticalframework.org/ GF
-  cd GF
-  cabal install
-```
-
-Subsequently:
-
-```
-  cd GF
-  darcs pull -a
-  cabal install
-```
-
-Alternatively, you can get the code from the
-[GF GitHub https://github.com/GrammaticalFramework/GF/] mirror, which is
-updated nightly.
-
-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].
-
-==Older releases==
-
-- [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).
-
-
---------------------
-
-[www.grammaticalframework.org http://www.grammaticalframework.org]

download/index.t2t

@@ -7,22 +7,21 @@ Grammatical Framework Download and Installation
 %!postproc(html): <TD><I> <TD><small>
 %!postproc(html): </I></TD> </small></TD>
 
-**GF 3.9** was released on 11 August 2017.
+**GF 3.8** was released on 22 June 2016.
 
-What's new? See the [Release notes release-3.9.html].
+What's new? See the [Release notes release-3.8.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``
+| Mac OS X | [gf-3.8.pkg gf-3.8.pkg] | //GF+S+C+P// | Double-click on the package icon (*)
+| Mac OS X | [gf-3.8-bin-intel-mac.tar.gz gf-3.8-bin-intel-mac.tar.gz] | //GF+S+C+P// | ``sudo tar -C /usr/local -zxf gf-3.8-bin-intel-mac.tar.gz``
 %| Fedora (32-bit) | [Fedora RPMs /~hallgren/tmp/Fedora/] | //GF+S+C+J+P// | ``sudo rpm -i ...``
-| Raspian 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``
+| Ubuntu (32-bit) | [gf_3.8-1_i386.deb gf_3.8-1_i386.deb] | //GF+S+C+J+P// | ``sudo dpkg -i gf_3.8-1_i386.deb``
+| Ubuntu (64-bit) | [gf_3.8-1_amd64.deb gf_3.8-1_amd64.deb] | //GF+S+C+J+P// | ``sudo dpkg -i gf_3.8-1_amd64.deb``
+| Windows | [gf-3.8-bin-windows.zip gf-3.8-bin-windows.zip] | //GF+S// | ``unzip gf-3.8-bin-windows.zip``
+%| MINGW | [gf-3.8-bin-i686-MINGW32_NT-6.1.tar.gz gf-3.8-bin-i686-MINGW32_NT-6.1.tar.gz] | //GF+S+C// | ``tar -C / gf-3.8-bin-i686-MINGW32_NT-6.1.tar.gz``
 %| ... | ... | ... | ...
 
 Features: GF = GF shell and grammar compiler and the Resource Grammar Library,
@@ -45,22 +44,17 @@ variables, see Inari's notes on
 %(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
+The ``.deb`` packages should work on Ubuntu 12.04, 14.04 and 16.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 Mac OS X should work on at least 10.9, 10.10 and 10.11 (Mavericks, Yosemite and El Capitan).
 
-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.
+(*) **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``,
+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``.
@@ -68,7 +62,7 @@ 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
+  export GF_LIB_PATH=/usr/local/share/gf-3.8/lib
 ```
 
 where ``/usr/local`` should be replaced with the path to the location where you
@@ -90,7 +84,7 @@ circumstances the prodedure is fairly simple:
 
 
 You can also download the full source package from here:
-[``gf-3.9.tar.gz`` gf-3.9.tar.gz].
+[``gf-3.8.tar.gz`` gf-3.8.tar.gz].
 
 === Notes ===
 
@@ -121,21 +115,21 @@ manually. Here is one way to do this:
 
 
 **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.
+The GF source code has been updated to compile with GHC 8.0.1. Using older
+versions of GHC (7.10.3, 7.10.2, 7.8, 7.6) should 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.
+=== 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==
 
@@ -143,34 +137,22 @@ The first time:
 %, assuming you already have the Haskell Platform and darcs
 
 ```
-  git clone https://github.com/GrammaticalFramework/gf-core.git
-  cd gf-core
+  darcs get --lazy http://www.grammaticalframework.org/ GF
+  cd GF
   cabal install
 ```
 
-and
-
-```
-  git clone https://github.com/GrammaticalFramework/gf-rgl.git
-  cd gf-rgl
-  make
-```
-
 Subsequently:
 
 ```
-  cd gf-core
-  git pull
+  cd GF
+  darcs pull -a
   cabal install
 ```
 
-and
-
-```
-  cd gf-rgl
-  git pull
-  make
-```
+Alternatively, you can get the code from the
+[GF GitHub https://github.com/GrammaticalFramework/GF/] mirror, which is
+updated nightly.
 
 The above notes for installing from source apply also in these cases.
 For more info on working with the GF source code, see the
@@ -178,7 +160,6 @@ For more info on working with the GF source code, see the
 
 ==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)

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.9.t2t

@@ -1,73 +0,0 @@
-GF 3.9 Release Notes
-August 2017
-
-%!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].
-
-
-==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``.
-
-
---------------------
-
-[www.grammaticalframework.org http://www.grammaticalframework.org]

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

examples/app/fre.tmp

@@ -0,0 +1,4 @@
+je suis ici
+ma femme est allée a Nice
+où est la voiture
+personne ne vous aime

examples/foods/CharactersGla.gf

@@ -0,0 +1,13 @@
+--# -coding=latin1
+resource CharactersGla = {
+	
+	--Character classes
+	oper
+		vowel : pattern Str = #("a"|"e"|"i"|"o"|"u"|"à"|"è"|"ì"|"ò"|"ù") ;
+		vowelCap : pattern Str = #("A"|"E"|"I"|"O"|"U"|"À"|"É"|"Ì"|"Ò"|"Ù") ;
+		consonant : pattern Str = #("b"|"c"|"d"|"f"|"g"|"h"|"j"|"k"|"l"|"m"|"n"|"p"|"q"|"r"|"s"|"t"|"v"|"w"|"x"|"z") ;
+		consonantCap : pattern Str = #("B"|"C"|"D"|"F"|"G"|"H"|"J"|"K"|"L"|"M"|"N"|"P"|"Q"|"R"|"S"|"T"|"V"|"W"|"X"|"Z") ;
+		broadVowel : pattern Str = #("a"|"o"|"u"|"à"|"ò"|"ù") ;
+		slenderVowel : pattern Str = #("e"|"i"|"è"|"ì") ;
+	
+}

examples/foods/CharactersGle.gf

@@ -0,0 +1,13 @@
+--# -coding=latin1
+resource CharactersGle = {
+	
+	--Character classes
+	oper
+		vowel : pattern Str = #("a"|"e"|"i"|"o"|"u"|"á"|"é"|"í"|"ó"|"ú") ;
+		vowelCap : pattern Str = #("A"|"E"|"I"|"O"|"U"|"Á"|"É"|"Í"|"Ó"|"Ú") ;
+		consonant : pattern Str = #("b"|"c"|"d"|"f"|"g"|"h"|"j"|"k"|"l"|"m"|"n"|"p"|"q"|"r"|"s"|"t"|"v"|"w"|"x"|"z") ;
+		consonantCap : pattern Str = #("B"|"C"|"D"|"F"|"G"|"H"|"J"|"K"|"L"|"M"|"N"|"P"|"Q"|"R"|"S"|"T"|"V"|"W"|"X"|"Z") ;
+		broadVowel : pattern Str = #("a"|"o"|"u"|"á"|"ó"|"ú") ;
+		slenderVowel : pattern Str = #("e"|"i"|"é"|"í") ;
+	
+}

examples/foods/Foods.gf

@@ -0,0 +1,15 @@
+-- (c) 2009 Aarne Ranta under LGPL
+
+abstract Foods = {
+  flags startcat = Comment ;
+  cat
+    Comment ; Item ; Kind ; Quality ;
+  fun
+    Pred : Item -> Quality -> Comment ;
+    This, That, These, Those : Kind -> Item ;
+    Mod : Quality -> Kind -> Kind ;
+    Wine, Cheese, Fish, Pizza : Kind ;
+    Very : Quality -> Quality ;
+    Fresh, Warm, Italian, 
+      Expensive, Delicious, Boring : Quality ;
+}

examples/foods/FoodsAfr.gf

@@ -0,0 +1,77 @@
+-- (c) 2009 Laurette Pretorius Sr & Jr and Ansu Berg under LGPL
+--# -coding=latin1
+
+concrete FoodsAfr of Foods = open Prelude, Predef in{
+	lincat
+		Comment = {s: Str} ;
+		Kind = {s: Number => Str} ;
+		Item = {s: Str ; n: Number} ;
+		Quality = {s: AdjAP => Str} ;
+		
+	lin	
+		Pred item quality = {s = item.s ++ "is" ++ (quality.s ! Predic)};
+		This kind = {s = "hierdie" ++ (kind.s ! Sg); n = Sg};
+		That kind = {s = "daardie" ++ (kind.s ! Sg); n = Sg};
+		These kind = {s = "hierdie" ++ (kind.s ! Pl); n = Pl};
+		Those kind = {s = "daardie" ++ (kind.s ! Pl); n = Pl};
+		Mod quality kind = {s = table{n => (quality.s ! Attr) ++ (kind.s!n)}};
+		
+		Wine = declNoun_e "wyn";
+		Cheese = declNoun_aa "kaas";
+		Fish = declNoun_ss "vis";
+		Pizza = declNoun_s "pizza";
+		
+		Very quality = veryAdj quality;
+		
+		Fresh = regAdj "vars";
+		Warm = regAdj "warm";
+		Italian = smartAdj_e "Italiaans";
+		Expensive = regAdj "duur";
+		Delicious = smartAdj_e "heerlik";
+		Boring = smartAdj_e "vervelig";
+		
+	param
+		AdjAP = Attr | Predic ;
+		Number = Sg | Pl ;
+	
+	oper
+		--Noun operations (wyn, kaas, vis, pizza)
+		
+		declNoun_aa: Str -> {s: Number => Str} = \x ->
+		let v = tk 2 x
+		in
+		{s = table{Sg => x ; Pl => v + (last x) +"e"}}; 
+		
+		declNoun_e: Str -> {s: Number => Str} = \x -> {s = table{Sg => x ; Pl => x + "e"}} ;
+		declNoun_s: Str -> {s: Number => Str} = \x -> {s = table{Sg => x ; Pl => x + "s"}} ;
+		
+		declNoun_ss: Str -> {s: Number => Str} = \x -> {s = table{Sg => x ; Pl => x + (last x) + "e"}} ;
+
+		
+		--Adjective operations
+		
+		mkAdj : Str -> Str -> {s: AdjAP => Str} = \x,y -> {s = table{Attr => x; Predic => y}};
+		
+		declAdj_e : Str -> {s : AdjAP=> Str} = \x -> mkAdj (x + "e") x;
+		declAdj_g : Str -> {s : AdjAP=> Str} = \w ->
+			let v = init w
+			in mkAdj (v + "ë") w ;
+		
+		declAdj_oog : Str -> {s : AdjAP=> Str} = \w ->
+			let v = init w
+			in 
+				let i = init v
+				in mkAdj (i + "ë") w ;
+					
+		regAdj : Str -> {s : AdjAP=> Str} = \x -> mkAdj x x;
+		
+		veryAdj : {s: AdjAP => Str} -> {s : AdjAP=> Str} =  \x -> {s = table{a => "baie" ++ (x.s!a)}};
+		
+		
+		smartAdj_e : Str -> {s : AdjAP=> Str} = \a -> case a of 
+		{
+			_ + "oog" 			   		=> declAdj_oog a ;
+			_ + ("e" | "ie" | "o" | "oe") + "g" 	=> declAdj_g a ;
+			_					   	=> declAdj_e a 
+		};
+}

examples/foods/FoodsAmh.gf

@@ -0,0 +1,21 @@
+concrete FoodsAmh of Foods ={
+ flags coding = utf8;
+ lincat
+  Comment,Item,Kind,Quality = Str;
+ lin
+  Pred item quality = item ++ quality++ "ነው::" ;
+  This kind = "ይህ" ++ kind;
+  That kind = "ያ" ++ kind;
+  Mod quality kind = quality ++ kind;
+  Wine = "ወይን";
+  Cheese = "አይብ";
+  Fish = "ዓሳ";
+  Very quality = "በጣም" ++ quality;
+  Fresh = "አዲስ";
+  Warm = "ትኩስ";
+  Italian = "የጥልያን";
+  Expensive = "ውድ";
+  Delicious = "ጣፋጭ";
+  Boring = "አስቀያሚ";
+  
+}   

examples/foods/FoodsBul.gf

@@ -0,0 +1,43 @@
+-- (c) 2009 Krasimir Angelov under LGPL
+
+concrete FoodsBul of Foods = {
+  
+  flags
+    coding = utf8;
+
+  param
+    Gender = Masc | Fem | Neutr;
+    Number = Sg | Pl;
+    Agr    = ASg Gender | APl ;
+
+  lincat
+    Comment = Str ;
+    Quality = {s : Agr => Str} ;
+    Item = {s : Str; a : Agr} ;
+    Kind = {s : Number => Str; g : Gender} ;
+
+  lin
+    Pred item qual = item.s ++ case item.a of {ASg _ => "е"; APl => "са"} ++ qual.s ! item.a ;
+    
+    This  kind = {s=case kind.g of {Masc=>"този"; Fem=>"тази";  Neutr=>"това" } ++ kind.s ! Sg; a=ASg kind.g} ;
+    That  kind = {s=case kind.g of {Masc=>"онзи"; Fem=>"онази"; Neutr=>"онова"} ++ kind.s ! Sg; a=ASg kind.g} ;
+    These kind = {s="тези"  ++ kind.s ! Pl; a=APl} ;
+    Those kind = {s="онези" ++ kind.s ! Pl; a=APl} ;
+    
+    Mod qual kind = {s=\\n => qual.s ! (case n of {Sg => ASg kind.g; Pl => APl}) ++ kind.s ! n; g=kind.g} ;
+
+    Wine   = {s = table {Sg => "вино";   Pl => "вина"};   g = Neutr};
+    Cheese = {s = table {Sg => "сирене"; Pl => "сирена"}; g = Neutr};
+    Fish   = {s = table {Sg => "риба";   Pl => "риби"};   g = Fem};
+    Pizza  = {s = table {Sg => "пица";   Pl => "пици"};   g = Fem};
+
+    Very qual = {s = \\g => "много" ++ qual.s ! g};
+
+    Fresh     = {s = table {ASg Masc => "свеж";        ASg Fem => "свежа";       ASg Neutr => "свежо";       APl => "свежи"}};
+    Warm      = {s = table {ASg Masc => "горещ";       ASg Fem => "гореща";      ASg Neutr => "горещо";      APl => "горещи"}};
+    Italian   = {s = table {ASg Masc => "италиански";  ASg Fem => "италианска";  ASg Neutr => "италианско";  APl => "италиански"}}; 
+    Expensive = {s = table {ASg Masc => "скъп";        ASg Fem => "скъпа";       ASg Neutr => "скъпо";       APl => "скъпи"}};
+    Delicious = {s = table {ASg Masc => "превъзходен"; ASg Fem => "превъзходна"; ASg Neutr => "превъзходно"; APl => "превъзходни"}};
+    Boring    = {s = table {ASg Masc => "еднообразен"; ASg Fem => "еднообразна"; ASg Neutr => "еднообразно"; APl => "еднообразни"}};
+    
+}

examples/foods/FoodsCat.gf

@@ -0,0 +1,6 @@
+
+-- (c) 2009 Jordi Saludes under LGPL
+
+concrete FoodsCat of Foods = FoodsI with 
+  (Syntax = SyntaxCat),
+  (LexFoods = LexFoodsCat) ;

examples/foods/FoodsChi.gf

@@ -0,0 +1,35 @@
+concrete FoodsChi of Foods = {
+flags coding = utf8 ;
+lincat
+    Comment, Item = Str ;
+    Kind = {s,c : Str} ; 
+    Quality = {s,p : Str} ;
+lin
+    Pred item quality = item ++ "是" ++ quality.s ++ quality.p ;
+    This kind = "这" ++ kind.c ++ kind.s ;
+    That kind = "那" ++ kind.c ++ kind.s ;
+    These kind = "这" ++ "些" ++ kind.s ;
+    Those kind = "那" ++ "些" ++ kind.s ;
+    Mod quality kind = {
+      s = quality.s ++ quality.p ++ kind.s ;
+      c = kind.c
+      } ;
+    Wine  = geKind "酒" ;
+    Pizza = geKind "比 萨 饼" ;
+    Cheese  = geKind "奶 酪" ;
+    Fish  = geKind "鱼" ;
+    Very quality = longQuality ("非 常" ++ quality.s) ;
+    Fresh  = longQuality "新 鲜" ;
+    Warm  = longQuality "温 热" ;
+    Italian  = longQuality "意 大 利 式" ;
+    Expensive  = longQuality "昂 贵" ;
+    Delicious  = longQuality "美 味" ;
+    Boring  = longQuality "难 吃" ;
+oper
+    mkKind : Str -> Str -> {s,c : Str} = \s,c ->
+      {s = s ; c = c} ;
+    geKind : Str -> {s,c : Str} = \s ->
+      mkKind s "个" ;
+    longQuality : Str -> {s,p : Str} = \s ->
+      {s = s ; p = "的"} ;
+}

examples/foods/FoodsCze.gf

@@ -0,0 +1,35 @@
+-- (c) 2011 Katerina Bohmova under LGPL
+
+concrete FoodsCze of Foods = open ResCze in {
+  flags 
+    coding = utf8 ;
+  lincat
+    Comment = {s : Str} ; 
+    Quality = Adjective ; 
+    Kind = Noun ; 
+    Item = NounPhrase ;
+  lin
+    Pred item quality = 
+      {s = item.s ++ copula ! item.n ++ 
+           quality.s ! item.g ! item.n} ;
+    This  = det Sg "tento" "tato" "toto" ;
+    That  = det Sg "tamten" "tamta" "tamto" ;
+    These = det Pl "tyto" "tyto" "tato" ;
+    Those = det Pl "tamty" "tamty" "tamta" ;
+    Mod quality kind = {
+      s = \\n => quality.s ! kind.g ! n ++ kind.s ! n ;
+      g = kind.g
+      } ;
+    Wine = noun "víno" "vína" Neutr ;
+    Cheese = noun "sýr" "sýry" Masc ;
+    Fish = noun "ryba" "ryby" Fem ;
+    Pizza = noun "pizza" "pizzy" Fem ;
+    Very qual = {s = \\g,n => "velmi" ++ qual.s ! g ! n} ;
+    Fresh = regAdj "čerstv" ;
+    Warm = regAdj "tepl" ;
+    Italian = regAdj "italsk" ;
+    Expensive = regAdj "drah" ;
+    Delicious = regnfAdj "vynikající" ;
+    Boring = regAdj "nudn" ;
+}
+

examples/foods/FoodsDut.gf

@@ -0,0 +1,58 @@
+-- (c) 2009 Femke Johansson under LGPL
+
+concrete FoodsDut of Foods = {
+
+	lincat
+		Comment = {s : Str};
+		Quality = {s : AForm => Str};
+		Kind = { s : Number => Str};
+		Item = {s : Str ; n : Number};
+	
+	lin
+		Pred item quality = 
+			{s = item.s ++ copula ! item.n ++ quality.s ! APred};
+		This = det Sg "deze";
+		These = det Pl "deze";
+		That = det Sg "die";
+		Those = det Pl "die";
+		
+		Mod quality kind =
+			{s = \\n => quality.s ! AAttr ++ kind.s ! n};
+			Wine = regNoun "wijn";
+			Cheese = noun "kaas" "kazen";
+			Fish = noun "vis" "vissen";
+			Pizza = noun "pizza" "pizza's";
+			
+			Very a = {s = \\f => "erg" ++ a.s ! f};
+			
+			Fresh = regadj "vers";
+			Warm = regadj "warm";
+			Italian = regadj "Italiaans";
+			Expensive = adj "duur" "dure";
+			Delicious = regadj "lekker";
+			Boring = regadj "saai";
+		
+		param
+			Number = Sg | Pl;
+			AForm = APred | AAttr;
+		
+		oper
+			det : Number -> Str ->
+				{s : Number => Str} -> {s : Str ; n: Number} =
+				\n,det,noun -> {s = det ++ noun.s ! n ; n=n};
+				
+			noun : Str -> Str -> {s : Number => Str} = 
+				\man,men -> {s = table {Sg => man; Pl => men}};
+				
+			regNoun : Str -> {s : Number => Str} =
+				\wijn -> noun wijn (wijn + "en");
+				
+			regadj : Str -> {s : AForm => Str} =
+				\koud -> adj koud (koud+"e");
+			
+			adj : Str -> Str -> {s : AForm => Str} =
+				\duur, dure -> {s = table {APred => duur; AAttr => dure}};
+				
+			copula : Number => Str =
+				table {Sg => "is" ; Pl => "zijn"};
+}

examples/foods/FoodsEng.gf

@@ -0,0 +1,43 @@
+-- (c) 2009 Aarne Ranta under LGPL
+
+concrete FoodsEng of Foods = {
+  flags language = en_US;
+  lincat
+    Comment, Quality = {s : Str} ; 
+    Kind = {s : Number => Str} ; 
+    Item = {s : Str ; n : Number} ; 
+  lin
+    Pred item quality = 
+      {s = item.s ++ copula ! item.n ++ quality.s} ;
+    This  = det Sg "this" ;
+    That  = det Sg "that" ;
+    These = det Pl "these" ;
+    Those = det Pl "those" ;
+    Mod quality kind = 
+      {s = \\n => quality.s ++ kind.s ! n} ;
+    Wine = regNoun "wine" ;
+    Cheese = regNoun "cheese" ;
+    Fish = noun "fish" "fish" ;
+    Pizza = regNoun "pizza" ;
+    Very a = {s = "very" ++ a.s} ;
+    Fresh = adj "fresh" ;
+    Warm = adj "warm" ;
+    Italian = adj "Italian" ;
+    Expensive = adj "expensive" ;
+    Delicious = adj "delicious" ;
+    Boring = adj "boring" ;
+  param
+    Number = Sg | Pl ;
+  oper
+    det : Number -> Str -> 
+      {s : Number => Str} -> {s : Str ; n : Number} = 
+        \n,det,noun -> {s = det ++ noun.s ! n ; n = n} ;
+    noun : Str -> Str -> {s : Number => Str} = 
+      \man,men -> {s = table {Sg => man ; Pl => men}} ;
+    regNoun : Str -> {s : Number => Str} = 
+      \car -> noun car (car + "s") ;
+    adj : Str -> {s : Str} = 
+      \cold -> {s = cold} ;
+    copula : Number => Str = 
+      table {Sg => "is" ; Pl => "are"} ;
+}

examples/foods/FoodsEpo.gf

@@ -0,0 +1,48 @@
+-- (c) 2009 Julia Hammar under LGPL
+
+concrete FoodsEpo of Foods = open Prelude in {
+
+  flags coding =utf8 ;
+
+  lincat
+    Comment = SS ; 
+    Kind, Quality = {s : Number => Str} ; 
+    Item = {s : Str ; n : Number} ; 
+
+  lin
+    Pred item quality = ss (item.s ++ copula ! item.n ++ quality.s ! item.n) ;
+    This = det Sg "ĉi tiu" ;
+    That  = det Sg "tiu" ;
+    These = det Pl "ĉi tiuj" ;
+    Those = det Pl "tiuj" ;
+    Mod quality kind = {s = \\n => quality.s ! n ++ kind.s ! n} ;
+    Wine = regNoun "vino" ;
+    Cheese = regNoun "fromaĝo" ;
+    Fish = regNoun "fiŝo" ;
+    Pizza = regNoun "pico" ;
+    Very quality = {s = \\n => "tre" ++ quality.s ! n} ;
+    Fresh = regAdj "freŝa" ;
+    Warm = regAdj "varma" ;
+    Italian = regAdj "itala" ;
+    Expensive = regAdj "altekosta" ;
+    Delicious = regAdj "bongusta" ;
+    Boring = regAdj "enuiga" ;
+
+  param
+    Number = Sg | Pl ;
+
+  oper
+    det : Number -> Str -> {s : Number => Str} -> {s : Str ; n : Number} = 
+      \n,d,cn -> {
+        s = d ++ cn.s ! n ;
+        n = n
+      } ;
+    regNoun : Str -> {s : Number => Str} = 
+      \vino -> {s = table {Sg => vino ; Pl => vino + "j"}
+	} ;
+    regAdj : Str -> {s : Number => Str} =
+      \nova -> {s = table {Sg => nova ; Pl => nova + "j"}
+      } ;
+    copula : Number => Str = \\_ => "estas" ;
+}
+    

examples/foods/FoodsFin.gf

@@ -0,0 +1,6 @@
+
+-- (c) 2009 Aarne Ranta under LGPL
+
+concrete FoodsFin of Foods = FoodsI with 
+  (Syntax = SyntaxFin),
+  (LexFoods = LexFoodsFin) ;

examples/foods/FoodsFre.gf

@@ -0,0 +1,31 @@
+
+concrete FoodsFre of Foods = open SyntaxFre, ParadigmsFre in {
+
+	flags coding = utf8 ;
+	
+	lincat
+		Comment = Utt ;
+		Item = NP ;
+		Kind = CN ;
+		Quality = AP ;
+	
+	lin
+		Pred item quality = mkUtt (mkCl item quality) ;
+		This kind = mkNP this_QuantSg kind ;
+		That kind = mkNP that_QuantSg kind ;
+		These kind = mkNP these_QuantPl kind ;
+		Those kind = mkNP those_QuantPl kind ;
+		Mod quality kind = mkCN quality kind ;
+		Very quality = mkAP very_AdA quality ;
+		
+		Wine = mkCN (mkN "vin" masculine) ;
+		Pizza = mkCN (mkN "pizza" feminine) ;
+		Cheese = mkCN (mkN "fromage" masculine) ;
+		Fish = mkCN (mkN "poisson" masculine) ;
+		Fresh = mkAP (mkA "frais" "fraîche" "frais" "fraîchement") ;
+		Warm = mkAP (mkA "chaud") ;
+		Italian = mkAP (mkA "italien") ;
+		Expensive = mkAP (mkA "cher") ;
+		Delicious = mkAP (mkA "délicieux") ;
+		Boring = mkAP (mkA "ennuyeux") ;
+	}

examples/foods/FoodsGer.gf

@@ -0,0 +1,6 @@
+
+-- (c) 2009 Aarne Ranta under LGPL
+
+concrete FoodsGer of Foods = FoodsI with 
+  (Syntax = SyntaxGer),
+  (LexFoods = LexFoodsGer) ;

examples/foods/FoodsGla.gf

@@ -0,0 +1,67 @@
+--# -coding=latin1
+concrete FoodsGla of Foods = open MutationsGla, CharactersGla, Prelude in {
+	param Gender = Masc|Fem ;
+	param Number = Sg|Pl ;
+	param Breadth = Broad|Slender|NoBreadth ;
+	param Beginning = Bcgmp|Other ;
+	
+	lincat Comment = Str;
+	lin Pred item quality = "tha" ++ item ++ quality.s!Sg!Unmutated ;
+
+	lincat Item = Str;
+	lin
+		This kind = (addArticleSg kind) ++ "seo" ;
+		That kind = (addArticleSg kind) ++ "sin";
+		These kind = (addArticlePl kind) ++ "seo" ;
+		Those kind = (addArticlePl kind) ++ "sin" ;
+	oper addArticleSg : {s : Number => Mutation => Str; g : Gender} -> Str =
+						  \kind -> case kind.g of { Masc => "an" ++ kind.s!Sg!PrefixT; Fem => "a'" ++ kind.s!Sg!Lenition1DNTLS } ;
+	oper addArticlePl : {s : Number => Mutation => Str; g : Gender} -> Str =
+					    \kind -> "na" ++ kind.s!Pl!PrefixH ;
+	
+	oper Noun : Type = {s : Number => Mutation => Str; g : Gender; pe : Breadth; beginning: Beginning; };
+	lincat Kind = Noun;
+	lin
+		Mod quality kind = {
+			s = table{
+					Sg => table{mutation => kind.s!Sg!mutation ++ case kind.g of {Masc => quality.s!Sg!Unmutated; Fem => quality.s!Sg!Lenition1} };
+					Pl => table{mutation => kind.s!Pl!mutation ++ case kind.pe of {Slender => quality.s!Pl!Lenition1; _ => quality.s!Pl!Unmutated} }
+			};
+			g = kind.g;
+			pe = kind.pe;
+			beginning = kind.beginning
+		} ;
+		Wine = makeNoun "fìon" "fìontan" Masc ;
+		Cheese = makeNoun "càise" "càisean" Masc ;
+		Fish = makeNoun "iasg" "èisg" Masc ;
+		Pizza = makeNoun "pizza" "pizzathan" Masc ;
+	oper makeNoun : Str -> Str -> Gender -> Noun = \sg,pl,g -> {
+		s = table{Sg => (mutate sg); Pl => (mutate pl)};
+		g = g;
+		pe = pe;
+		beginning = Bcgmp
+	}
+	where {
+		pe : Breadth = case pl of {
+			_ + v@(#broadVowel) + c@(#consonant*) + #consonant => Broad;
+			_ + v@(#slenderVowel) + c@(#consonant*) + #consonant => Slender;
+			_ => NoBreadth
+		}
+	};
+
+	oper Adjective : Type = {s : Number => Mutation => Str; sVery : Number => Str};
+	lincat Quality = Adjective;
+	lin
+		Very quality = {s=table{number => table{_ => quality.sVery!number}}; sVery=quality.sVery } ;
+		Fresh = makeAdjective "úr" "ùra" ;
+		Warm = makeAdjective "blàth" "blàtha" ;
+		Italian = makeAdjective "Eadailteach" "Eadailteach" ;
+		Expensive = makeAdjective "daor" "daora" ;
+		Delicious = makeAdjective "blasta" "blasta" ;
+		Boring = makeAdjective "leamh" "leamha" ;
+	oper makeAdjective : Str -> Str -> Adjective =
+		\sg,pl -> {
+					s=table{Sg => (mutate sg); Pl => (mutate pl)};
+					sVery=table{Sg => "glè"++(lenition1dntls sg); Pl => "glè"++(lenition1dntls pl)}
+				  } ;
+}

examples/foods/FoodsGle.gf

@@ -0,0 +1,60 @@
+--# -coding=latin1
+concrete FoodsGle of Foods = open MutationsGle, CharactersGle in {
+	param Gender = Masc|Fem ;
+	param Number = Sg|Pl ;
+	param Breadth = Broad|Slender|NoBreadth ;
+	
+	lincat Comment = Str;
+	lin Pred item quality = "tá" ++ item ++ quality.s!Sg!Unmutated ;
+
+	lincat Item = Str;
+	lin
+		This kind = (addArticleSg kind) ++ "seo" ;
+		That kind = (addArticleSg kind) ++ "sin";
+		These kind = (addArticlePl kind) ++ "seo" ;
+		Those kind = (addArticlePl kind) ++ "sin" ;
+	oper addArticleSg : {s : Number => Mutation => Str; g : Gender} -> Str =
+					    \kind -> "an" ++ case kind.g of { Masc => kind.s!Sg!PrefixT; Fem => kind.s!Sg!Lenition1DNTLS } ;
+	oper addArticlePl : {s : Number => Mutation => Str; g : Gender} -> Str =
+					    \kind -> "na" ++ kind.s!Pl!PrefixH ;
+	
+	lincat Kind = {s : Number => Mutation => Str; g : Gender; pe : Breadth} ;
+	lin
+		Mod quality kind = {
+			s = table{
+					Sg => table{mutation => kind.s!Sg!mutation ++ case kind.g of {Masc => quality.s!Sg!Unmutated; Fem => quality.s!Sg!Lenition1} };
+					Pl => table{mutation => kind.s!Pl!mutation ++ case kind.pe of {Slender => quality.s!Pl!Lenition1; _ => quality.s!Pl!Unmutated} }
+			};
+			g = kind.g;
+			pe = kind.pe
+		} ;
+		Wine = makeNoun "fíon" "fíonta" Masc ;
+		Cheese = makeNoun "cáis" "cáiseanna" Fem ;
+		Fish = makeNoun "iasc" "éisc" Masc ;
+		Pizza = makeNoun "píotsa" "píotsaí" Masc ;
+	oper makeNoun : Str -> Str -> Gender -> {s : Number => Mutation => Str; g : Gender; pe : Breadth} =
+		\sg,pl,g -> {
+						s = table{Sg => (mutate sg); Pl => (mutate pl)};
+						g = g;
+						pe = case pl of {
+							_ + v@(#broadVowel) + c@(#consonant*) + #consonant => Broad;
+							_ + v@(#slenderVowel) + c@(#consonant*) + #consonant => Slender;
+							_ => NoBreadth
+						}
+					} ;
+
+	lincat Quality = {s : Number => Mutation => Str; sVery : Number => Str} ;
+	lin
+		Very quality = {s=table{number => table{_ => quality.sVery!number}}; sVery=quality.sVery } ;
+		Fresh = makeAdjective "úr" "úra" ;
+		Warm = makeAdjective "te" "te" ;
+		Italian = makeAdjective "Iodálach" "Iodálacha" ;
+		Expensive = makeAdjective "daor" "daora" ;
+		Delicious = makeAdjective "blasta" "blasta" ;
+		Boring = makeAdjective "leamh" "leamha" ;
+	oper makeAdjective : Str -> Str -> {s : Number => Mutation => Str; sVery : Number => Str} =
+		\sg,pl -> {
+					s=table{Sg => (mutate sg); Pl => (mutate pl)};
+					sVery=table{Sg => "an-"+(lenition1dntls sg); Pl => "an-"+(lenition1dntls pl)}
+				  } ;
+}

examples/foods/FoodsHeb.gf

@@ -0,0 +1,107 @@
+
+--(c) 2009 Dana Dannells
+-- Licensed under LGPL
+
+concrete FoodsHeb of Foods = open Prelude in {
+  
+  flags coding=utf8 ;
+
+    lincat
+      Comment = SS ;
+      Quality = {s: Number => Species => Gender =>  Str} ;  
+      Kind = {s : Number => Species => Str ; g : Gender ; mod : Modified} ; 
+      Item = {s : Str ; g : Gender ; n : Number ; sp : Species ; mod : Modified} ; 
+  
+ 
+    lin
+      Pred item quality = ss (item.s ++ quality.s ! item.n ! Indef ! item.g ) ; 
+      This  = det Sg Def "הזה" "הזאת"; 
+      That  = det Sg Def "ההוא" "ההיא" ; 
+      These = det Pl Def "האלה" "האלה" ; 
+      Those = det Pl Def "ההם" "ההן" ; 
+      Mod quality kind = {
+	s = \\n,sp => kind.s ! n ! sp ++ quality.s ! n ! sp ! kind.g;
+	g = kind.g ;
+	mod = T
+	} ;     
+      Wine = regNoun "יין" "יינות" Masc ; 
+      Cheese = regNoun "גבינה" "גבינות" Fem ;  
+      Fish = regNoun "דג" "דגים" Masc ; 
+      Pizza = regNoun "פיצה" "פיצות" Fem ; 
+      Very qual = {s = \\g,n,sp => "מאוד" ++  qual.s ! g ! n ! sp} ;
+      Fresh = regAdj "טרי" ; 
+      Warm = regAdj "חם" ;
+      Italian = regAdj2 "איטלקי" ;
+      Expensive = regAdj "יקר" ; 
+      Delicious = regAdj "טעים" ; 
+      Boring = regAdj2 "משעמם"; 
+
+    param 
+      Number = Sg | Pl ;
+      Gender = Masc | Fem ;
+      Species = Def | Indef ;  
+      Modified = T | F ;
+
+    oper
+	Noun : Type = {s : Number => Species => Str ; g : Gender ; mod : Modified } ;
+  	Adj : Type = {s : Number => Species => Gender => Str} ;
+
+      det : Number -> Species -> Str -> Str -> Noun -> 
+	{s : Str ; g :Gender ; n : Number ; sp : Species ; mod : Modified} = 
+        \n,sp,m,f,cn -> {
+	  s = case cn.mod of { _ => cn.s ! n ! sp ++ case cn.g of {Masc => m ; Fem  => f} };
+	  g = cn.g ; 
+          n = n ;
+	  sp = sp ;
+	  mod = cn.mod
+        } ;
+      
+	noun : (gvina,hagvina,gvinot,hagvinot : Str) ->  Gender -> Noun =  
+      		\gvina,hagvina,gvinot,hagvinot,g -> {
+        	s = table {
+          		Sg  => table {
+             			Indef => gvina ;
+             			Def =>  hagvina 
+            		} ;
+          		Pl => table {
+             			Indef => gvinot ;
+             			Def => hagvinot  
+            		} 
+       	  	} ;
+        	g = g ;
+		mod = F 
+      } ;
+
+	regNoun : Str -> Str -> Gender -> Noun = 
+	        \gvina,gvinot, g -> 
+		noun gvina (defH gvina) gvinot (defH gvinot) g ; 
+
+      defH : Str -> Str = \cn ->
+	case cn of {_ => "ה" + cn};	
+
+      replaceLastLetter : Str -> Str = \c ->
+	 case c of {"ף" => "פ" ; "ם" => "מ" ; "ן" => "נ" ; "ץ" => "צ" ; "ך" => "כ"; _ => c} ;
+	      
+      adjective : (_,_,_,_ : Str) -> Adj = 
+       \tov,tova,tovim,tovot -> {
+        s = table {
+          Sg => table { 
+			Indef => table { Masc => tov ; Fem => tova } ; 
+			Def => table { Masc => defH tov ; Fem => defH tova }  
+            		} ; 
+          Pl => table { 
+			Indef => table {Masc => tovim ; Fem  => tovot } ; 
+			Def => table { Masc => defH tovim ; Fem  => defH tovot }  
+            		}
+	}
+      } ;
+    
+      regAdj : Str -> Adj = \tov ->
+	case tov of { to + c@? =>
+	adjective tov (to + replaceLastLetter (c) + "ה" ) (to + replaceLastLetter (c) +"ים" ) (to + replaceLastLetter (c) + "ות" )};	 
+     
+     regAdj2 : Str -> Adj = \italki ->
+ 	case italki of { italk+ c@? => 
+    adjective italki (italk + replaceLastLetter (c)  +"ת" )  (italk + replaceLastLetter (c)+ "ים" ) (italk + replaceLastLetter (c)  + "ות" )};
+
+}  -- FoodsHeb  

examples/foods/FoodsHin.gf

@@ -0,0 +1,75 @@
+-- (c) 2010 Vikash Rauniyar under LGPL
+
+concrete FoodsHin of Foods = {
+
+  flags coding=utf8 ;
+
+  param
+    Gender = Masc | Fem ;
+    Number = Sg | Pl ;
+  lincat
+    Comment = {s : Str} ;
+    Item    = {s : Str ; g : Gender ; n : Number} ;
+    Kind    = {s : Number => Str ; g : Gender} ;
+    Quality = {s : Gender => Number => Str} ;
+  lin
+    Pred item quality = {
+      s = item.s ++ quality.s ! item.g ! item.n ++ copula item.n
+      } ;
+    This kind = {s = "यह" ++ kind.s ! Sg ; g = kind.g ; n = Sg} ;
+    That kind = {s = "वह" ++ kind.s ! Sg ; g = kind.g ; n = Sg} ;
+    These kind = {s = "ये" ++ kind.s ! Pl ; g = kind.g ; n = Pl} ;
+    Those kind = {s = "वे" ++ kind.s ! Pl ; g = kind.g ; n = Pl} ;
+    Mod quality kind = {
+      s = \\n => quality.s ! kind.g ! n ++ kind.s ! n ; 
+      g = kind.g
+      } ;
+    Wine = regN "मदिरा" ;
+    Cheese = regN "पनीर" ;
+    Fish = regN "मछली" ;
+    Pizza = regN "पिज़्ज़ा" ;
+    Very quality = {s = \\g,n => "अति" ++ quality.s ! g ! n} ;
+    Fresh = regAdj "ताज़ा" ;
+    Warm = regAdj "गरम" ;
+    Italian = regAdj "इटली" ; 
+    Expensive = regAdj "बहुमूल्य" ;
+    Delicious = regAdj "स्वादिष्ट" ;
+    Boring = regAdj "अरुचिकर" ;
+
+  oper
+    mkN : Str -> Str -> Gender -> {s : Number => Str ; g : Gender} = 
+      \s,p,g -> {
+        s = table {
+          Sg => s ;
+          Pl => p
+          } ;
+        g = g
+      } ;
+
+    regN : Str -> {s : Number => Str ; g : Gender} = \s -> case s of {
+      lark + "ा" => mkN s (lark + "े") Masc ;
+      lark + "ी" => mkN s (lark + "ीयँा") Fem ;
+      _           => mkN s s Masc 
+      } ;
+
+    mkAdj : Str -> Str -> Str -> {s : Gender => Number => Str} = \ms,mp,f -> {
+      s = table {
+        Masc => table {
+          Sg => ms ;
+          Pl => mp
+          } ;
+        Fem  => \\_ => f
+        }
+      } ;
+
+    regAdj : Str -> {s : Gender => Number => Str} = \a -> case a of {
+      acch + "ा" => mkAdj a (acch + "े") (acch + "ी") ;
+      _          => mkAdj a a a
+      } ;
+
+    copula : Number -> Str = \n -> case n of {
+      Sg => "है" ;
+      Pl => "हैं"
+      } ;
+
+  }

examples/foods/FoodsI.gf

@@ -0,0 +1,29 @@
+-- (c) 2009 Aarne Ranta under LGPL
+
+incomplete concrete FoodsI of Foods = 
+    open Syntax, LexFoods in {
+  lincat
+    Comment = Utt ; 
+    Item = NP ;
+    Kind = CN ;
+    Quality = AP ;
+  lin
+    Pred item quality = mkUtt (mkCl item quality) ;
+    This kind = mkNP this_Det kind ;
+    That kind = mkNP that_Det kind ;
+    These kind = mkNP these_Det kind ;
+    Those kind = mkNP those_Det kind ;
+    Mod quality kind = mkCN quality kind ;
+    Very quality = mkAP very_AdA quality ;
+
+    Wine = mkCN wine_N ;
+    Pizza = mkCN pizza_N ;
+    Cheese = mkCN cheese_N ;
+    Fish = mkCN fish_N ;
+    Fresh = mkAP fresh_A ;
+    Warm = mkAP warm_A ;
+    Italian = mkAP italian_A ;
+    Expensive = mkAP expensive_A ;
+    Delicious = mkAP delicious_A ;
+    Boring = mkAP boring_A ;
+}

examples/foods/FoodsIce.gf

@@ -0,0 +1,83 @@
+
+-- (c) 2009 Martha Dis Brandt under LGPL
+
+concrete FoodsIce of Foods = open Prelude in {
+
+  flags coding=utf8;
+
+  lincat
+    Comment = SS ; 
+    Quality = {s : Gender => Number => Defin => Str} ; 
+    Kind = {s : Number => Str ; g : Gender} ; 
+    Item = {s : Str ; g : Gender ; n : Number} ; 
+
+  lin
+    Pred item quality =  ss (item.s ++ copula item.n ++ quality.s ! item.g ! item.n ! Ind) ;
+         This, That  = det Sg "þessi"   "þessi"  "þetta" ;
+         These, Those = det Pl "þessir" "þessar" "þessi" ;
+    Mod quality kind = { s = \\n => quality.s ! kind.g ! n ! Def ++ kind.s ! n ; g = kind.g } ;
+         Wine = noun "vín" "vín" Neutr ;
+         Cheese = noun "ostur" "ostar" Masc ; 
+         Fish = noun "fiskur" "fiskar" Masc ; 
+         -- the word "pizza" is more commonly used in Iceland, but "flatbaka" is the Icelandic word for it
+         Pizza = noun "flatbaka" "flatbökur" Fem ;
+    Very qual = {s = \\g,n,defOrInd => "mjög" ++ qual.s ! g ! n ! defOrInd } ;
+         Fresh = regAdj "ferskur" ;
+         Warm = regAdj "heitur" ;
+         Boring = regAdj "leiðinlegur" ;
+         -- the order of the given adj forms is: mSg fSg nSg mPl fPl nPl mSgDef f/nSgDef _PlDef
+         Italian = adjective "ítalskur" "ítölsk" "ítalskt" "ítalskir" "ítalskar" "ítölsk" "ítalski" "ítalska" "ítalsku" ;
+         Expensive = adjective "dýr" "dýr" "dýrt" "dýrir" "dýrar" "dýr" "dýri" "dýra" "dýru" ; 
+         Delicious = adjective "ljúffengur" "ljúffeng" "ljúffengt" "ljúffengir" "ljúffengar" "ljúffeng" "ljúffengi" "ljúffenga" "ljúffengu" ;
+
+  param
+    Number = Sg | Pl ;
+    Gender = Masc | Fem | Neutr ;
+    Defin = Ind | Def ;
+
+  oper
+    det : Number -> Str -> Str -> Str -> {s : Number => Str ; g : Gender} -> 
+        {s : Str ; g : Gender ; n : Number} = 
+      \n,masc,fem,neutr,cn -> {
+        s = case cn.g of {Masc => masc ; Fem => fem; Neutr => neutr } ++ cn.s ! n ;
+        g = cn.g ;
+        n = n
+      } ;
+
+    noun : Str -> Str -> Gender -> {s : Number => Str ; g : Gender} = 
+      \man,men,g -> {
+        s = table {
+          Sg => man ;
+          Pl => men 
+          } ;
+        g = g
+      } ;
+
+    adjective : (x1,_,_,_,_,_,_,_,x9 : Str) -> {s : Gender => Number => Defin => Str} =
+      \ferskur,fersk,ferskt,ferskir,ferskar,fersk_pl,ferski,ferska,fersku -> {
+         s = \\g,n,t => case <g,n,t> of {
+            < Masc, Sg, Ind > => ferskur ;
+            < Masc, Pl, Ind > => ferskir ;
+            < Fem, Sg, Ind > => fersk ;
+            < Fem, Pl, Ind > => ferskar ;
+            < Neutr, Sg, Ind > => ferskt ;
+            < Neutr, Pl, Ind > => fersk_pl;
+            < Masc, Sg, Def > => ferski ;
+            < Fem, Sg, Def > | < Neutr, Sg, Def > => ferska ;
+            < _ , Pl, Def > => fersku 
+            }
+          } ;
+
+    regAdj : Str -> {s : Gender => Number => Defin => Str} = \ferskur ->
+      let fersk = Predef.tk 2 ferskur
+      in adjective
+        ferskur fersk (fersk + "t")
+        (fersk + "ir") (fersk + "ar") fersk
+        (fersk + "i") (fersk + "a") (fersk + "u") ;
+
+    copula : Number -> Str = 
+      \n -> case n of {
+        Sg => "er" ;
+        Pl => "eru"
+        } ;
+}

examples/foods/FoodsIta.gf

@@ -0,0 +1,7 @@
+
+-- (c) 2009 Aarne Ranta under LGPL
+
+concrete FoodsIta of Foods = FoodsI with 
+  (Syntax = SyntaxIta),
+  (LexFoods = LexFoodsIta) ;
+

examples/foods/FoodsJpn.gf

@@ -0,0 +1,71 @@
+
+-- (c) 2009 Zofia Stankiewicz under LGPL
+
+concrete FoodsJpn of Foods = open Prelude in {
+
+flags coding=utf8 ;
+
+  lincat
+    Comment = {s: Style => Str};
+    Quality = {s: AdjUse => Str ; t: AdjType} ;
+    Kind = {s : Number => Str} ; 
+    Item = {s : Str ; n : Number} ; 
+
+  lin
+    Pred item quality = {s = case quality.t of {
+      IAdj => table {Plain => item.s ++ quality.s ! APred ; Polite => item.s ++ quality.s ! APred ++ copula ! Polite ! item.n } ;
+      NaAdj => \\p => item.s ++ quality.s ! APred ++ copula ! p ! item.n } 
+      } ;
+    This  = det Sg "この" ;
+    That  = det Sg "その" ;
+    These = det Pl "この" ;
+    Those = det Pl "その" ;
+    Mod quality kind = {s = \\n => quality.s ! Attr ++ kind.s ! n} ;
+    Wine = regNoun "ワインは" ;
+    Cheese = regNoun "チーズは" ;
+    Fish = regNoun "魚は" ;
+    Pizza = regNoun "ピザは" ;
+    Very quality =  {s = \\a => "とても" ++ quality.s ! a ; t = quality.t } ;
+    Fresh = adj "新鮮な" "新鮮";
+    Warm = regAdj "あたたかい" ;
+    Italian = adj "イタリアの" "イタリアのもの";
+    Expensive = regAdj "たかい" ;
+    Delicious = regAdj "おいしい" ;
+    Boring = regAdj "つまらない" ;
+
+  param
+    Number = Sg | Pl ;
+    AdjUse = Attr | APred ;        -- na-adjectives have different forms as noun attributes and predicates
+    Style = Plain | Polite ;      -- for phrase types
+    AdjType = IAdj | NaAdj ;      -- IAdj can form predicates without the copula, NaAdj cannot
+
+  oper
+    det : Number -> Str -> {s : Number => Str} -> {s : Str ; n : Number} = 
+      \n,d,cn -> {
+        s = d ++ cn.s ! n ;
+        n = n
+      } ;
+   noun : Str -> Str -> {s : Number => Str} = 
+      \sakana,sakana -> {s = \\_ => sakana } ;
+
+   regNoun : Str -> {s : Number => Str} = 
+      \sakana -> noun sakana sakana ;
+
+   adj : Str -> Str -> {s : AdjUse => Str ; t : AdjType} =
+      \chosenna, chosen -> {
+       s = table { 
+         Attr => chosenna ;
+         APred => chosen
+       } ;
+       t = NaAdj 
+      } ;
+   
+   regAdj : Str -> {s: AdjUse => Str ; t : AdjType} =\akai -> {
+     s = \\_ => akai ; t = IAdj} ;
+
+    copula : Style => Number => Str = 
+      table { 
+        Plain => \\_ => "だ" ;
+        Polite => \\_ => "です" } ;
+
+}   

examples/foods/FoodsLav.gf

@@ -0,0 +1,90 @@
+
+-- (c) 2009 Inese Bernsone under LGPL
+
+concrete FoodsLav of Foods = open Prelude in {
+
+  flags
+    coding=utf8 ;
+    
+  lincat
+    Comment = SS ; 
+    Quality = {s : Q => Gender => Number => Defin => Str } ; 
+    Kind = {s : Number => Str ; g : Gender} ; 
+    Item = {s : Str ; g : Gender ; n : Number } ; 
+
+  lin
+    Pred item quality = ss (item.s ++ {- copula item.n -} "ir" ++ quality.s ! Q1 ! item.g ! item.n ! Ind ) ;
+      This  = det Sg "šis" "šī" ;
+      That  = det Sg "tas" "tā" ;
+      These = det Pl "šie" "šīs" ;
+      Those = det Pl "tie" "tās" ;
+    Mod quality kind = {s = \\n => quality.s ! Q1 ! kind.g ! n ! Def ++ kind.s ! n ; g = kind.g } ;
+      Wine = noun "vīns" "vīni" Masc ;
+      Cheese = noun "siers" "sieri" Masc ;
+      Fish = noun "zivs" "zivis" Fem ;
+      Pizza = noun "pica" "picas" Fem ;
+    Very qual = {s = \\q,g,n,spec => "ļoti" ++ qual.s ! Q2 ! g ! n ! spec }; 
+ 
+      Fresh = adjective "svaigs" "svaiga" "svaigi" "svaigas" "svaigais" "svaigā" "svaigie" "svaigās" ;
+      Warm = regAdj "silts" ;
+      Italian = specAdj "itāļu" (regAdj "itālisks") ;
+      Expensive = regAdj "dārgs" ;
+      Delicious = regAdj "garšīgs" ;
+      Boring = regAdj "garlaicīgs" ;
+
+  param
+    Number = Sg | Pl ;
+    Gender = Masc | Fem ;
+    Defin = Ind | Def ;
+    Q = Q1 | Q2 ;
+
+  oper
+   det : Number -> Str -> Str -> {s : Number => Str ; g : Gender} -> 
+        {s : Str ; g : Gender ; n : Number} = 
+      \n,m,f,cn -> {
+        s = case cn.g of {Masc => m ; Fem => f} ++ cn.s ! n ;
+        g = cn.g ;
+        n = n
+      } ;
+    noun : Str -> Str -> Gender -> {s : Number => Str ; g : Gender} = 
+      \man,men,g -> {
+        s = table {
+          Sg => man ;
+          Pl => men 
+          } ;
+        g = g
+      } ;
+    adjective : (_,_,_,_,_,_,_,_ : Str) -> {s : Q => Gender => Number => Defin => Str} = 
+      \skaists,skaista,skaisti,skaistas,skaistais,skaistaa,skaistie,skaistaas -> {
+        s = table {
+		  _ => table {
+            Masc => table {
+              Sg => table {Ind => skaists ; Def => skaistais} ;
+              Pl => table {Ind => skaisti ; Def => skaistie}
+              } ; 
+            Fem => table {
+              Sg => table {Ind => skaista ; Def => skaistaa} ;
+              Pl => table {Ind => skaistas ; Def => skaistaas} 
+              }
+            } 
+		  }
+        } ;
+      
+ {-   irregAdj : Str -> {s : Gender => Number => Defin => Str} = \itaalju ->
+     let itaalju = itaalju
+     in adjective itaalju (itaalju) (itaalju) (itaalju) (itaalju) (itaalju) (itaalju) (itaalju) ; -}
+     
+    regAdj : Str -> {s : Q => Gender => Number => Defin => Str} = \skaists ->
+      let skaist = init skaists 
+      in adjective skaists (skaist + "a") (skaist + "i") (skaist + "as") (skaist + "ais") (skaist + "ā") (skaist + "ie") (skaist + "ās");
+
+    Adjective : Type = {s : Q => Gender => Number => Defin => Str} ;
+
+	specAdj : Str -> Adjective -> Adjective = \s,a -> {
+      s = table {
+        Q2 => a.s ! Q1 ;
+        Q1 => \\_,_,_ => s
+        }		
+	  } ;
+	
+	}

examples/foods/FoodsMkd.gf

@@ -0,0 +1,120 @@
+-- (c) 2009 Krasimir Angelov under LGPL
+
+concrete FoodsMkd of Foods = {
+
+flags coding = utf8 ;
+
+lincat
+    Comment = Str;
+    Quality = {s : Agr => Str};
+    Item = {s : Str; a : Agr};
+    Kind = {s : Number => Str; g : Gender};
+
+lin
+    Pred item qual = 
+       item.s ++
+       case item.a of {
+         ASg _ => "е";
+         APl => "се"
+       } ++
+       qual.s ! item.a;
+    This kind = {
+       s = case kind.g of {
+             Masc  => "овоj";
+             Fem   => "оваа";
+             Neutr => "ова"
+           } ++
+           kind.s ! Sg;
+       a = ASg kind.g};
+    That kind = {
+       s = case kind.g of {
+             Masc  => "оноj";
+             Fem   => "онаа";
+             Neutr => "она"
+           } ++ 
+           kind.s ! Sg;
+       a = ASg kind.g};
+    These kind = {s = "овие" ++ kind.s ! Pl; a = APl};
+    Those kind = {s = "оние" ++ kind.s ! Pl; a = APl};
+    Mod qual kind = {
+       s = \\n => qual.s ! case n of {
+                             Sg => ASg kind.g;
+                             Pl => APl
+                           } ++
+                  kind.s ! n;
+       g = kind.g};
+    Wine  = {
+       s = table {
+             Sg => "вино";
+             Pl => "вина"
+       };
+       g = Neutr};
+    Cheese = {
+       s = table {
+             Sg => "сирење";
+             Pl => "сирењa"
+           };
+       g = Neutr};
+    Fish = {
+       s = table {
+             Sg => "риба";
+             Pl => "риби"
+       };
+       g = Fem};
+    Pizza = {
+       s = table {
+             Sg => "пица";
+             Pl => "пици"
+           };
+       g = Fem
+       };
+    Very qual = {s = \\g => "многу" ++ qual.s ! g};
+    Fresh = {
+       s = table {
+             ASg Masc  => "свеж";
+             ASg Fem   => "свежа";
+             ASg Neutr => "свежо";
+             APl       => "свежи"}
+       };
+    Warm  = {
+      s = table {
+            ASg Masc  => "топол";
+            ASg Fem   => "топла";
+            ASg Neutr => "топло";
+            APl       => "топли"}
+      };
+    Italian  = {
+      s = table {
+            ASg Masc  => "италијански";
+            ASg Fem   => "италијанска";
+            ASg Neutr => "италијанско";
+            APl       => "италијански"}
+      };
+    Expensive  = {
+       s = table {
+             ASg Masc  => "скап";
+             ASg Fem   => "скапа";
+             ASg Neutr => "скапо";
+             APl       => "скапи"}
+       };
+    Delicious  = {
+       s = table {
+             ASg Masc  => "вкусен";
+             ASg Fem   => "вкусна";
+             ASg Neutr => "вкусно";
+             APl       => "вкусни"}
+       };
+    Boring  = {
+       s = table {
+             ASg Masc  => "досаден";
+             ASg Fem   => "досадна";
+             ASg Neutr => "досадно";
+             APl       => "досадни"}
+       };
+
+param
+    Gender = Masc | Fem | Neutr;
+    Number = Sg | Pl;
+    Agr = ASg Gender | APl;
+
+}

examples/foods/FoodsMlt.gf

@@ -0,0 +1,105 @@
+-- (c) 2013 John J. Camilleri under LGPL
+
+concrete FoodsMlt of Foods = open Prelude in {
+  flags coding=utf8 ;
+
+  lincat
+    Comment = SS ;
+    Quality = {s : Gender => Number => Str} ;
+    Kind = {s : Number => Str ; g : Gender} ;
+    Item = {s : Str ; g : Gender ; n : Number} ;
+
+  lin
+    -- Pred item quality = ss (item.s ++ copula item.n item.g ++ quality.s ! item.g ! item.n) ;
+    Pred item quality = ss (item.s ++ quality.s ! item.g ! item.n) ;
+
+    This kind = det Sg "dan" "din" kind ;
+    That kind = det Sg "dak" "dik" kind ;
+    These kind = det Pl "dawn" "" kind ;
+    Those kind = det Pl "dawk" "" kind ;
+
+    Mod quality kind = {
+      s = \\n => kind.s ! n ++ quality.s ! kind.g ! n ;
+      g = kind.g
+      } ;
+
+    Wine = noun "inbid" "inbejjed" Masc ;
+    Cheese = noun "ġobon" "ġobniet" Masc ;
+    Fish = noun "ħuta" "ħut" Fem ;
+    Pizza = noun "pizza" "pizzez" Fem ;
+
+    Very qual = {s = \\g,n => qual.s ! g ! n ++ "ħafna"} ;
+
+    Warm = adjective "sħun" "sħuna" "sħan" ;
+    Expensive = adjective "għali" "għalja" "għaljin" ;
+    Delicious = adjective "tajjeb" "tajba" "tajbin" ;
+    Boring = uniAdj "tad-dwejjaq" ;
+    Fresh = regAdj "frisk" ;
+    Italian = regAdj "Taljan" ;
+
+  param
+    Number = Sg | Pl ;
+    Gender = Masc | Fem ;
+
+  oper
+    --Create an adjective (full function)
+    --Params: Sing Masc, Sing Fem, Plural
+    adjective : (_,_,_ : Str) -> {s : Gender => Number => Str} = \iswed,sewda,suwed -> {
+      s = table {
+	Masc => table {
+	  Sg => iswed ;
+	  Pl => suwed
+	  } ;
+	Fem => table {
+	  Sg => sewda ;
+	  Pl => suwed
+	  }
+	}
+      } ;
+
+    --Create a regular adjective
+    --Param: Sing Masc
+    regAdj : Str -> {s : Gender => Number => Str} = \frisk ->
+      adjective frisk (frisk + "a") (frisk + "i") ;
+
+    --Create a "uni-adjective" eg tal-buzz
+    --Param: Sing Masc
+    uniAdj : Str -> {s : Gender => Number => Str} = \uni ->
+      adjective uni uni uni ;
+
+    --Create a noun
+    --Params: Singular, Plural, Gender (inherent)
+    noun : Str -> Str -> Gender -> {s : Number => Str ; g : Gender} = \ktieb,kotba,g -> {
+      s = table {
+	Sg => ktieb ;
+	Pl => kotba
+	} ;
+      g = g
+      } ;
+
+    --Copula is a linking verb
+    --Params: Number, Gender
+    -- copula : Number -> Gender -> Str = \n,g -> case n of {
+    --   Sg => case g of { Masc => "huwa" ; Fem => "hija" } ;
+    --   Pl => "huma"
+    --   } ;
+
+    --Create an article, taking into account first letter of next word
+    article = pre {
+      "a"|"e"|"i"|"o"|"u" => "l-" ;
+      --cons@("ċ"|"d"|"n"|"r"|"s"|"t"|"x"|"ż") => "i" + cons + "-" ;
+      _ => "il-"
+      } ;
+
+    --Create a determinant
+    --Params: Sg/Pl, Masc, Fem
+    det : Number -> Str -> Str -> {s : Number => Str ; g : Gender} -> {s : Str ; g : Gender ; n : Number} = \n,m,f,cn -> {
+      s = case n of {
+	Sg => case cn.g of {Masc => m ; Fem => f}; --string
+	Pl => m --default to masc
+	} ++ article ++ cn.s ! n ;
+      g = cn.g ; --gender
+      n = n --number
+      } ;
+
+}

examples/foods/FoodsMon.gf

@@ -0,0 +1,48 @@
+
+-- (c) 2009 Nyamsuren Erdenebadrakh under LGPL
+
+concrete FoodsMon of Foods = open Prelude in {
+  flags coding=utf8;
+
+  lincat
+    Comment, Quality = SS ; 
+	Kind = {s : Number => Str} ; 
+    Item = {s : Str ; n : Number} ; 
+
+  lin
+	Pred item quality = ss (item.s ++ "бол" ++ quality.s) ;
+	This  = det Sg "энэ" ;
+	That  = det Sg "тэр" ;
+	These = det Pl "эдгээр" ;
+	Those = det Pl "тэдгээр" ;
+	Mod quality kind = {s = \\n => quality.s ++ kind.s ! n} ;
+	Wine = regNoun "дарс" ;
+	Cheese = regNoun "бяслаг" ;
+	Fish = regNoun "загас" ;
+	Pizza = regNoun "пицца" ;
+	Very = prefixSS "маш" ;
+	Fresh = ss "шинэ" ;
+	Warm = ss "халуун" ;
+	Italian = ss "итали" ;
+	Expensive = ss "үнэтэй" ;
+	Delicious = ss "амттай" ;
+	Boring = ss "амтгүй" ;
+
+  param
+    Number = Sg | Pl ;
+
+  oper
+	det : Number -> Str -> {s : Number => Str} -> {s : Str ; n : Number} = 
+	\n,d,cn -> {
+		s = d ++ cn.s ! n ;
+		n = n
+	} ;
+  	
+	regNoun : Str -> {s : Number => Str} = 
+	\x -> {s = table {
+		Sg => x ; 
+		Pl => x + "нууд"}
+		} ;
+	}
+	 
+    

examples/foods/FoodsNep.gf

@@ -0,0 +1,60 @@
+-- (c) 2011 Dinesh Simkhada under LGPL
+
+concrete FoodsNep of Foods = {
+
+  flags coding = utf8 ;
+
+  lincat
+    Comment, Quality = {s : Str} ; 
+    Kind = {s : Number => Str} ; 
+    Item = {s : Str ; n : Number} ; 
+    
+  lin
+    Pred item quality = 
+      {s = item.s ++ quality.s ++ copula ! item.n} ;
+      
+    This  = det Sg "यो" ;
+    That  = det Sg "त्यो" ;
+    These = det Pl "यी" ;
+    Those = det Pl "ती" ;
+    Mod quality kind = 
+      {s = \\n => quality.s ++ kind.s ! n} ;
+      
+    Wine = regNoun "रक्सी" ;
+    Cheese = regNoun "चिज" ;
+    Fish = regNoun "माछा" ;
+    Pizza = regNoun "पिज्जा" ;
+    Very a = {s = "धेरै" ++ a.s} ;
+    Fresh = adj "ताजा" ;
+    Warm = adj "तातो" ;
+    Italian = adj "इटालियन" ;
+    Expensive = adj "महँगो" | adj "बहुमूल्य" ;
+    Delicious = adj "स्वादिष्ट" | adj "मीठो" ;
+    Boring = adjPl "नमिठो" ;
+  
+  param
+    Number = Sg | Pl ;
+    
+  oper
+    det : Number -> Str -> 
+      {s : Number => Str} -> {s : Str ; n : Number} = 
+        \n,det,noun -> {s = det ++ noun.s ! n ; n = n} ;
+    
+    noun : Str -> Str -> {s : Number => Str} = 
+      \man,men -> {s = table {Sg => man ; Pl => men}} ;
+    
+    regNoun : Str -> {s : Number => Str} = 
+      \car -> noun car (car + "हरु") ;
+    
+    adjPl : Str -> {s : Str} = \a -> case a of {
+      bor + "ठो" => adj (bor + "ठा") ;
+      _ => adj a
+      } ;
+      
+    adj : Str -> {s : Str} = 
+      \cold -> {s = cold} ;
+    
+    copula : Number => Str = 
+      table {Sg => "छ" ; Pl => "छन्"} ;
+}
+

examples/foods/FoodsOri.gf

@@ -0,0 +1,30 @@
+concrete FoodsOri of Foods = {
+
+flags coding = utf8 ;
+
+lincat
+    Comment = Str;
+    Item = Str;
+    Kind = Str;
+    Quality = Str;
+
+lin
+    Pred item quality = item ++ quality ++ "ଅଟେ";
+    This kind = "ଏଇ" ++ kind;
+    That kind = "ସେଇ" ++ kind;
+    These kind = "ଏଇ" ++ kind ++ "ଗୁଡିକ" ;
+    Those kind = "ସେଇ" ++ kind ++ "ଗୁଡିକ" ;
+    Mod quality kind = quality ++ kind;
+    Wine  = "ମଦ";
+    Cheese  = "ଛେନା";
+    Fish  = "ମାଛ";
+    Pizza = "ପିଜଜ଼ା" ;
+    Very quality = "ଅତି" ++ quality;
+    Fresh  = "ତାଜା";
+    Warm  = "ଗରମ";
+    Italian  = "ଇଟାଲି";
+    Expensive  = "ମୁଲ୍ୟବାନ୍";
+    Delicious  = "ସ୍ଵାଦିସ୍ଟ ";
+    Boring  = "ଅରୁଚିକର";
+
+}

examples/foods/FoodsPes.gf

@@ -0,0 +1,65 @@
+concrete FoodsPes of Foods = {
+
+      flags optimize=noexpand ; coding=utf8 ;
+	  
+      lincat
+        Comment = {s : Str} ;
+		Quality = {s : Add => Str; prep : Str} ;
+        Kind = {s : Add => Number => Str ; prep : Str};
+        Item = {s : Str ; n : Number};
+      lin
+        Pred item quality = {s = item.s ++ quality.s ! Indep ++ copula ! item.n} ;
+        This = det Sg "این" ;
+        That = det Sg "آن" ;
+        These = det Pl "این" ;
+        Those = det Pl "آن" ;
+        
+        Mod quality kind = {s = \\a,n =>  kind.s ! Attr ! n ++ kind.prep ++ quality.s ! a ;                                  
+                            prep = quality.prep             
+                            };
+        Wine = regN "شراب" ; 
+        Cheese = regN "پنیر" ;
+        Fish = regN "ماهى" ;
+        Pizza = regN "پیتزا" ;
+        Very a = {s = \\at => "خیلی" ++ a.s ! at ; prep = a.prep} ;
+        Fresh = adj "تازه" ;
+        Warm = adj "گرم" ;
+        Italian = adj "ایتالیایی" ;
+        Expensive = adj "گران" ;
+        Delicious = adj "لذىذ" ;
+        Boring = adj "ملال آور" ;  -- it must be written as ملال آور. 
+     
+     param
+        Number = Sg | Pl ;
+		Add = Indep | Attr ;
+     oper
+        det : Number -> Str -> {s: Add => Number => Str ; prep : Str} -> {s : Str ; n: Number} =
+           \n,det,noun -> {s = det ++ noun.s ! Indep ! n ; n = n };
+           
+        noun : (x1,_,_,x4 : Str) -> {s : Add => Number => Str ; prep : Str} = \pytzA, pytzAy, pytzAhA,pr -> 
+         {s = \\a,n => case <a,n> of
+		        {<Indep,Sg> => pytzA ; <Indep,Pl> => pytzAhA ;
+  				 <Attr,Sg>  =>pytzA ; <Attr,Pl>  => pytzAhA + "ى" };
+		 prep = pr
+		 };		 
+         
+        regN : Str -> {s: Add => Number => Str ; prep : Str} = \mrd -> 
+		case mrd of 
+		{ _ + ("ا"|"ه"|"ى"|"و"|"") => noun mrd (mrd+"ى") (mrd + "ها") "";
+		  _                        => noun mrd mrd (mrd + "ها") "e"
+		};
+        
+        adj : Str -> {s : Add => Str; prep : Str} = \tAzh -> 
+		case tAzh of 
+		{ _ + ("ا"|"ه"|"ى"|"و"|"") => mkAdj tAzh (tAzh ++ "ى") "" ;
+		  _                        => mkAdj tAzh tAzh "ه"
+        };
+		
+		mkAdj : Str -> Str -> Str -> {s : Add => Str; prep : Str} = \tAzh, tAzhy, pr  ->
+		{s = table {Indep => tAzh;
+		            Attr => tAzhy};
+		 prep = pr 			
+		};
+        copula : Number => Str = table {Sg => "است"; Pl => "هستند"};
+      
+}

examples/foods/FoodsPor.gf

@@ -0,0 +1,78 @@
+-- (c) 2009 Rami Shashati under LGPL
+--# -coding=latin1
+
+concrete FoodsPor of Foods = open Prelude in {
+	lincat
+	  Comment = {s : Str} ;
+	  Quality = {s : Gender => Number => Str} ;
+	  Kind = {s : Number => Str ; g : Gender} ;
+	  Item = {s : Str ; n : Number ; g : Gender } ;
+	
+	lin 
+	  Pred item quality =
+	    {s = item.s ++ copula ! item.n ++ quality.s ! item.g ! item.n } ;
+	  This = det Sg (table {Masc => "este" ; Fem => "esta"}) ;
+	  That = det Sg (table {Masc => "esse" ; Fem => "essa"}) ;
+	  These = det Pl (table {Masc => "estes" ; Fem => "estas"}) ; 
+	  Those = det Pl (table {Masc => "esses" ; Fem => "essas"}) ;
+	 
+	  Mod quality kind = { s = \\n => kind.s ! n ++ quality.s ! kind.g ! n ; g = kind.g } ;
+	  
+	  Wine = regNoun "vinho" Masc ;
+	  Cheese = regNoun "queijo" Masc ;
+	  Fish = regNoun "peixe" Masc ;
+	  Pizza = regNoun "pizza" Fem ;
+	  
+      Very a = { s = \\g,n => "muito" ++ a.s ! g ! n } ;
+      
+      Fresh = mkAdjReg "fresco" ;
+      Warm = mkAdjReg "quente" ;
+      Italian = mkAdjReg "Italiano" ;
+      Expensive = mkAdjReg "caro" ;
+      Delicious = mkAdjReg "delicioso" ;
+      Boring = mkAdjReg "chato" ;
+	
+	param
+	  Number = Sg | Pl ;
+	  Gender = Masc | Fem ;
+	
+	oper
+	  QualityT : Type = {s : Gender => Number => Str} ;
+	  
+	  mkAdj : (_,_,_,_ : Str) -> QualityT = \bonito,bonita,bonitos,bonitas -> {
+	  	s = table {
+	  		Masc => table { Sg => bonito ; Pl => bonitos } ;
+	  		Fem => table { Sg => bonita ; Pl => bonitas }
+	    } ;
+	  } ;
+	  
+	  -- regular pattern
+	  adjSozinho : Str -> QualityT = \sozinho ->
+        let sozinh = Predef.tk 1 sozinho
+        in mkAdj sozinho (sozinh + "a") (sozinh + "os") (sozinh + "as") ;
+
+      -- for gender-independent adjectives
+      adjUtil : Str -> Str -> QualityT = \util,uteis ->
+        mkAdj util util uteis uteis ;
+
+      -- smart paradigm for adjcetives
+      mkAdjReg : Str -> QualityT = \a -> case last a of {
+      	"o" => adjSozinho a ;
+        "e" => adjUtil a (a + "s")
+      } ;
+      
+      ItemT : Type = {s : Str ; n : Number ; g : Gender } ;
+      
+      det : Number -> (Gender => Str) -> KindT -> ItemT =
+        \num,det,noun -> {s = det ! noun.g ++ noun.s ! num ; n = num ; g = noun.g } ;
+	    
+	  KindT : Type = {s : Number => Str ; g : Gender} ;
+	    
+	  noun : Str -> Str -> Gender -> KindT =
+	    \animal,animais,gen -> {s = table {Sg => animal ; Pl => animais} ; g = gen } ;
+	    
+	  regNoun : Str -> Gender -> KindT =
+	    \carro,gen -> noun carro (carro + "s") gen ;
+	  
+	  copula : Number => Str = table {Sg => "é" ; Pl => "são"} ;
+}

examples/foods/FoodsRon.gf

@@ -0,0 +1,72 @@
+-- (c) 2009 Ramona Enache under LGPL
+
+concrete FoodsRon of Foods = 
+{
+flags coding=utf8 ;
+
+param Number = Sg | Pl ;
+      Gender = Masc | Fem ;
+      NGender = NMasc | NFem | NNeut ;
+lincat 
+Comment = {s : Str};
+Quality = {s : Number => Gender => Str};
+Kind = {s : Number => Str; g : NGender};
+Item = {s : Str ; n : Number; g : Gender};
+
+lin
+
+This = det Sg (mkTab "acest" "această");
+That = det Sg (mkTab "acel" "acea");
+These = det Pl (mkTab "acești" "aceste");
+Those = det Pl (mkTab "acei" "acele");
+
+Wine = mkNoun "vin" "vinuri" NNeut ;
+Cheese = mkNoun "brânză" "brânzeturi" NFem ;
+Fish = mkNoun "peşte" "peşti" NMasc ;
+Pizza = mkNoun "pizza" "pizze" NFem;
+
+Very a = {s = \\n,g => "foarte" ++ a.s ! n ! g};
+
+Fresh = mkAdj "proaspăt" "proaspătă" "proaspeţi" "proaspete" ;
+Warm = mkAdj "cald" "caldă" "calzi" "calde" ;
+Italian = mkAdj "italian" "italiană" "italieni" "italiene" ;
+Expensive = mkAdj "scump" "scumpă" "scumpi" "scumpe" ;
+Delicious = mkAdj "delicios" "delcioasă" "delicioşi" "delicioase" ;
+Boring = mkAdj "plictisitor" "plictisitoare" "plictisitori" "plictisitoare" ;
+
+Pred item quality = {s = item.s ++ copula ! item.n ++ quality.s ! item.n ! item.g} ;
+
+Mod quality kind = {s = \\n => kind.s ! n ++ quality.s ! n ! (getAgrGender kind.g n) ; g = kind.g};
+
+oper 
+
+mkTab : Str -> Str -> {s : Gender => Str} = \acesta, aceasta ->
+{s = table{Masc => acesta;
+      Fem  => aceasta}};
+
+det : Number -> {s : Gender => Str} -> {s : Number => Str ; g : NGender} -> {s : Str; n : Number; g : Gender} =
+\n,det,noun -> let gg = getAgrGender noun.g n 
+  in
+   {s =  det.s ! gg  ++ noun.s ! n  ; n = n ; g = gg};
+
+mkNoun : Str -> Str -> NGender -> {s : Number => Str; g : NGender} = \peste, pesti,g ->
+{s = table {Sg => peste;
+            Pl => pesti};
+ g = g
+};
+
+oper mkAdj : (x1,_,_,x4 : Str) -> {s : Number => Gender => Str} = \scump, scumpa, scumpi, scumpe ->
+{s = \\n,g => case <n,g> of
+{<Sg,Masc> => scump ; <Sg,Fem> => scumpa;
+<Pl,Masc> => scumpi ; <Pl,Fem> => scumpe
+}};
+
+copula : Number => Str = table {Sg => "este" ; Pl => "sunt"};
+
+getAgrGender : NGender -> Number -> Gender = \ng,n ->
+case <ng,n> of
+{<NMasc,_> => Masc ; <NFem,_> => Fem;
+<NNeut,Sg> => Masc ; <NNeut,Pl> => Fem
+};
+
+}

examples/foods/FoodsSpa.gf

@@ -0,0 +1,30 @@
+
+concrete FoodsSpa of Foods = open SyntaxSpa, StructuralSpa, ParadigmsSpa in {
+
+	lincat
+		Comment = Utt ;
+		Item = NP ;
+		Kind = CN ;
+		Quality = AP ;
+
+	lin
+		Pred item quality = mkUtt (mkCl item quality) ;
+		This kind = mkNP this_QuantSg kind ;
+		That kind = mkNP that_QuantSg kind ;
+		These kind = mkNP these_QuantPl kind ;
+		Those kind = mkNP those_QuantPl kind ;
+		Mod quality kind = mkCN quality kind ;
+		Very quality = mkAP very_AdA quality ;
+		Wine = mkCN (mkN "vino") ;
+                Pizza = mkCN (mkN "pizza") ;
+                Cheese = mkCN (mkN "queso") ;
+                Fish = mkCN (mkN "pescado") ;
+                Fresh = mkAP (mkA "fresco") ;
+                Warm = mkAP (mkA "caliente") ;
+                Italian = mkAP (mkA "italiano") ;
+                Expensive = mkAP (mkA "caro") ;
+                Delicious = mkAP (mkA "delicioso") ;
+                Boring = mkAP (mkA "aburrido") ;
+
+}
+

examples/foods/FoodsSwe.gf

@@ -0,0 +1,6 @@
+
+-- (c) 2009 Aarne Ranta under LGPL
+
+concrete FoodsSwe of Foods = FoodsI with 
+  (Syntax = SyntaxSwe),
+  (LexFoods = LexFoodsSwe) ** {flags language = sv_SE;} ;

examples/foods/FoodsTha.gf

@@ -0,0 +1,32 @@
+
+concrete FoodsTha of Foods = open SyntaxTha, LexiconTha,
+  ParadigmsTha, (R=ResTha) in {
+
+        flags coding = utf8 ;
+
+	lincat
+		Comment = Utt ;
+		Item = NP ;
+		Kind = CN ;
+		Quality = AP ;
+
+	lin
+		Pred item quality = mkUtt (mkCl item quality) ;
+		This kind = mkNP this_Det kind ;
+		That kind = mkNP that_Det kind ;
+		These kind = mkNP these_Det kind ;
+		Those kind = mkNP those_Det kind ;
+		Mod quality kind = mkCN quality kind ;
+		Very quality = mkAP very_AdA quality ;
+		Wine = mkCN (mkN (R.thword "เหล้าอ" "งุ่น") "ขวด") ;
+                Pizza = mkCN (mkN (R.thword "พิซ" "ซา") "ถาด") ;
+                Cheese = mkCN (mkN (R.thword "เนย" "แข็ง") "ก้อน") ;
+                Fish = mkCN fish_N ;
+                Fresh = mkAP (mkA "สด") ;
+                Warm = mkAP warm_A ;
+                Italian = mkAP (mkA " อิตาลี") ;
+                Expensive = mkAP (mkA "แพง") ;
+                Delicious = mkAP (mkA "อร่อย") ;
+                Boring = mkAP (mkA (R.thword "น่า" "เบิ่อ")) ;
+
+}

examples/foods/FoodsTsn.gf

@@ -0,0 +1,177 @@
+
+-- (c) 2009 Laurette Pretorius Sr & Jr and Ansu Berg under LGPL
+
+concrete FoodsTsn of Foods = open Prelude, Predef in {
+	flags coding = utf8;
+	lincat
+		Comment = {s:Str};
+		Item = {s:Str; c:NounClass; n:Number};
+		Kind = {w: Number => Str; r: Str; c: NounClass; q: Number => Str; b: Bool};
+		Quality = {s: NounClass => Number => Str; p_form: Str; t: TType};
+	lin	
+		Pred item quality = {s = item.s ++ ((mkPredDescrCop quality.t) ! item.c ! item.n) ++ quality.p_form};
+
+		This kind = {s = (kind.w ! Sg) ++ (mkDemPron1 ! kind.c ! Sg) ++ (kind.q ! Sg); c = kind.c; n = Sg};
+		That kind = {s = (kind.w ! Sg) ++ (mkDemPron2 ! kind.c ! Sg) ++ (kind.q ! Sg); c = kind.c; n = Sg};
+		These kind = {s = (kind.w ! Pl) ++ (mkDemPron1 ! kind.c ! Pl) ++ (kind.q ! Pl); c = kind.c; n = Pl};
+		Those kind = {s = (kind.w ! Pl) ++ (mkDemPron2 ! kind.c ! Pl) ++ (kind.q ! Pl); c = kind.c; n = Pl};	
+		
+		Mod quality kind = mkMod quality kind;
+
+	-- Lexicon
+		Wine = mkNounNC14_6 "jalwa";
+		Cheese = mkNounNC9_10 "kase";
+		Fish = mkNounNC9_10 "thlapi";
+		Pizza = mkNounNC9_10 "pizza";
+		Very quality = smartVery quality; 
+		Fresh = mkVarAdj "ntsha";
+		Warm = mkOrdAdj "bothitho";
+		Italian = mkPerAdj "Itali";
+		Expensive = mkVerbRel "tura"; 
+		Delicious = mkOrdAdj "monate";
+		Boring = mkOrdAdj "bosula";
+		
+	param
+		NounClass = NC9_10 | NC14_6;
+		Number = Sg | Pl;
+		TType = P | V | ModV | R ;				
+	oper
+		mkMod : {s: NounClass => Number => Str; p_form: Str; t: TType} -> {w: Number => Str; r: Str; c: NounClass; q: Number => Str; b: Bool} -> {w: Number => Str; r: Str; c: NounClass; q: Number => Str; 
+		b: Bool} = \x,y -> case y.b of
+		{
+			True => {w = y.w; r = y.r; c = y.c; 
+				q = table {
+				Sg => ((y.q ! Sg) ++ "le" ++ ((smartQualRelPart (x.t)) ! y.c ! Sg) ++ ((smartDescrCop (x.t)) ! 					y.c ! Sg) ++ (x.s ! y.c ! Sg)); 
+				Pl => ((y.q ! Pl) ++ "le" ++ ((smartQualRelPart (x.t))! y.c ! Pl) ++ ((smartDescrCop (x.t)) ! 					y.c ! Pl) ++(x.s ! y.c ! Pl))
+				  }; b = True
+				};
+			False => {w = y.w; r = y.r; c = y.c; 
+				q = table {
+				Sg => ((y.q ! Sg) ++ ((smartQualRelPart (x.t)) ! y.c ! Sg) ++ ((smartDescrCop (x.t)) ! y.c ! Sg) 					++ (x.s ! y.c ! Sg)); 
+				Pl => ((y.q ! Pl) ++ ((smartQualRelPart (x.t)) ! y.c ! Pl) ++ ((smartDescrCop (x.t)) ! y.c ! Pl) 					++(x.s ! y.c ! Pl))
+				  }; b = True
+				}
+		};
+
+		mkNounNC14_6 : Str -> {w: Number => Str; r: Str; c: NounClass; q: Number => Str; b: Bool} = \x -> {w = table {Sg => "bo" + x; Pl => "ma" + x}; r = x; c = NC14_6; 
+		q = table {Sg => ""; Pl => ""}; b = False};
+		
+		mkNounNC9_10 : Str -> {w: Number => Str; r: Str; c: NounClass; q: Number => Str; b: Bool} = \x -> {w = table {Sg => "" + x; Pl => "di" + x}; r = x; c = NC9_10; 
+		q = table {Sg => ""; Pl => ""}; b = False};
+
+		mkVarAdj : Str -> {s: NounClass => Number => Str; p_form: Str; t: TType} = \x -> 
+		{
+			s = table {
+				NC9_10 => table {Sg => "" + x; Pl => "di" + x};
+				NC14_6 => table {Sg => "bo" + x; Pl => "ma" + x}
+				};
+			p_form = x;
+			t = R;
+		};
+
+		mkOrdAdj : Str -> {s: NounClass => Number => Str; p_form: Str; t: TType} = \x -> 
+		{
+			s = table {
+				NC9_10 => table {Sg => "" + x; Pl => "" + x};
+				NC14_6 => table {Sg => "" + x; Pl => "" + x}
+				};
+			p_form = x;
+			t = R;
+		};
+
+		mkVerbRel : Str -> {s: NounClass => Number => Str; p_form: Str; t: TType} = \x -> 
+		{
+			s = table {
+				NC9_10 => table {Sg => x + "ng"; Pl => x + "ng"};
+				NC14_6 => table {Sg => x + "ng"; Pl => x + "ng"}
+				};
+			p_form = x;
+			t = V;
+		};
+
+		mkPerAdj : Str -> {s: NounClass => Number => Str; p_form: Str; t: TType} = \x -> 
+		{
+			s = table {
+				NC9_10 => table {Sg => "" + x; Pl => "" + x};
+				NC14_6 => table {Sg => "" + x; Pl => "" + x}
+				};
+			p_form = "mo" ++ x;
+			t = P;
+		};
+
+		mkVeryAdj : {s: NounClass => Number => Str; p_form: Str; t: TType} -> {s: NounClass => Number => Str; p_form: Str; t: TType} = \x ->
+		{
+			s = table{c => table{n => (x.s!c!n) ++ "thata"}}; p_form = x.p_form ++ "thata"; t = x.t
+		};
+
+		mkVeryVerb : {s: NounClass => Number => Str; p_form: Str; t: TType} -> {s: NounClass => Number => Str; p_form: Str; t: TType} = \x ->
+		{
+			s = table{c => table{n => (x.s!c!n) ++ "thata"}}; p_form = x.p_form ++ "thata"; t = ModV
+		};
+
+		smartVery : {s: NounClass => Number => Str; p_form: Str; t: TType} -> {s: NounClass => Number => Str; p_form: Str; t: TType} = 
+\x -> case x.t of --(x.s!c!n)
+		{
+			(V | ModV)	=>	mkVeryVerb x;
+			--ModV	=>	mkVeryVerb x;
+			_	=>	mkVeryAdj x
+		};
+
+		mkDemPron1 : NounClass => Number => Str = table
+			{
+				NC9_10 => table {Sg => "e"; Pl => "tse"};
+				NC14_6 => table {Sg => "bo"; Pl => "a"}
+			};
+		
+		mkDemPron2 : NounClass => Number => Str = table
+			{
+				NC9_10 => table {Sg => "eo"; Pl => "tseo"};
+				NC14_6 => table {Sg => "boo"; Pl => "ao"}
+			};
+
+		smartQualRelPart : TType -> (NounClass => Number => Str) = \x -> case x of 
+		{
+			P	=> mkQualRelPart_PName;
+			_	=> mkQualRelPart
+		};
+
+		mkQualRelPart : NounClass => Number => Str = table
+			{
+				NC9_10 => table {Sg => "e"; Pl => "tse"};
+				NC14_6 => table {Sg => "bo"; Pl => "a"}
+			};
+
+		mkQualRelPart_PName : NounClass => Number => Str = table
+			{
+				NC9_10 => table {Sg => "ya"; Pl => "tsa"};
+				NC14_6 => table {Sg => "ba"; Pl => "a"}
+			};
+
+		smartDescrCop : TType -> (NounClass => Number => Str) = \x -> case x of
+		{
+			P	=> mkDescrCop_PName;
+			_	=> mkDescrCop
+		};
+
+		mkDescrCop : NounClass => Number => Str = table
+			{
+				NC9_10 => table {Sg => "e"; Pl => "di"};
+				NC14_6 => table {Sg => "bo"; Pl => "a"}
+			};
+
+		mkDescrCop_PName : NounClass => Number => Str = table
+			{
+				NC9_10 => table {Sg => "ga"; Pl => "ga"};
+				NC14_6 => table {Sg => "ga"; Pl => "ga"}
+			};
+
+		mkPredDescrCop : TType -> (NounClass => Number => Str) = \x -> case x of
+			{
+				V => table 	{NC9_10 => table {Sg => "e" ++ "a"; Pl => "di" ++ "a"};
+						NC14_6 => table {Sg => "bo" ++ "a"; Pl => "a" ++ "a"}};
+
+				_ => table	{NC9_10 => table {Sg => "e"; Pl => "di"};
+						NC14_6 => table {Sg => "bo"; Pl => "a"}}
+			};
+
+}

examples/foods/FoodsTur.gf

@@ -0,0 +1,140 @@
+{-
+  File      : FoodsTur.gf
+  Author    : Server Çimen
+  Version   : 1.0
+  Created on: August 26, 2009
+
+  This file contains concrete grammar of Foods abstract grammar for Turkish Language.
+  This grammar is to be used for Fridge demo and developed in the scope of GF Resource
+  Grammar Summer School.
+
+-}
+
+concrete FoodsTur of Foods = open Predef in {
+  flags
+    coding=utf8 ;
+  lincat
+    Comment = {s : Str} ;
+    Quality = {s : Str ; c : Case; softness : Softness; h : Harmony} ;
+    Kind = {s : Case => Number => Str} ;
+    Item = {s : Str; n : Number} ;
+  lin
+    This = det Sg "bu" ;
+    That = det Sg "şu" ;
+    These = det Pl "bu" ;
+    Those = det Pl "şu" ;
+    -- Reason for excluding plural form of copula: In Turkish if subject is not a human being,
+    -- then singular form of copula is used regardless of the number of subject. Since all
+    -- possible subjects are non human, copula do not need to have plural form.
+    Pred item quality = {s = item.s ++ quality.s ++ BIND ++ copula ! quality.softness ! quality.h} ;--! item.n} ;
+    Mod quality kind = {s = case quality.c of {
+                              Nom => \\t,n => quality.s ++ kind.s ! t ! n ;
+                              Gen => \\t,n => quality.s ++ kind.s ! Gen ! n
+                            }
+                       } ;
+    Wine = mkN "şarap" "şaraplar" "şarabı" "şarapları" ;
+    Cheese = mkN "peynir" "peynirler" "peyniri" "peynirleri" ;
+    Fish = mkN "balık" "balıklar" "balığı" "balıkları" ;
+    Pizza = mkN "pizza" "pizzalar" "pizzası" "pizzaları" ;
+    Very a = {s = "çok" ++ a.s ; c = a.c; softness = a.softness; h = a.h} ;
+    Fresh = adj "taze" Nom;
+    Warm = adj "ılık" Nom;
+    Italian = adj "İtalyan" Gen ;
+    Expensive = adj "pahalı" Nom;
+    Delicious = adj "lezzetli" Nom;
+    Boring = adj "sıkıcı" Nom;
+  param
+    Number = Sg | Pl ;
+    Case = Nom | Gen ;
+    Harmony = I_Har | Ih_Har | U_Har | Uh_Har ; --Ih = İ; Uh = Ü
+    Softness = Soft | Hard ;
+  oper
+    det : Number -> Str -> {s : Case => Number => Str} -> {s : Str; n : Number} =
+      \num,det,noun -> {s = det ++ noun.s ! Nom ! num; n = num} ;
+    mkN = overload {
+      mkN : Str -> Str -> {s : Case => Number => Str} = regNoun ;
+      mkn : Str -> Str -> Str -> Str-> {s : Case => Number => Str} = noun ;
+    } ;
+    regNoun : Str -> Str -> {s : Case => Number => Str} =
+      \peynir,peynirler -> noun peynir peynirler [] [] ;
+    noun : Str -> Str -> Str -> Str-> {s : Case => Number => Str} = 
+      \sarap,saraplar,sarabi,saraplari -> {
+        s = table {
+	      Nom =>  table {
+			Sg => sarap ;
+			Pl => saraplar
+	              } ;
+              Gen =>  table {
+                        Sg => sarabi ;
+			Pl => saraplari
+	              }
+              }
+      };
+  {-
+    Since there is a bug in overloading, this overload is useless.
+
+    mkA = overload {
+      mkA : Str -> {s : Str; c : Case; softness : Softness; h : Harmony} = \base -> adj base Nom ;
+      mkA : Str -> Case -> {s : Str; c : Case; softness : Softness; h : Harmony} = adj ;
+    } ;
+  -}
+    adj : Str -> Case -> {s : Str; c : Case; softness : Softness; h : Harmony} =
+      \italyan,ca -> {s = italyan ; c = ca; softness = (getSoftness italyan); h = (getHarmony italyan)} ;
+    -- See the comment at lines 26 and 27 for excluded plural form of copula.
+    copula : Softness => Harmony {-=> Number-} => Str =
+      table {
+        Soft => table {
+                  I_Har => "dır" ;--table {
+			   -- Sg => "dır" ;
+			   -- Pl => "dırlar"
+		  --} ;
+		  Ih_Har => "dir" ;--table {
+			    --Sg => "dir" ;
+			    --Pl => "dirler"
+		  --} ;
+		  U_Har => "dur" ;--table {
+			   -- Sg => "dur" ;
+			   -- Pl => "durlar"
+		  --} ;
+		  Uh_Har => "dür" --table {
+			    --Sg => "dür" ;
+			    --Pl => "dürler"
+		  --}
+        } ;
+        Hard => table {
+                  I_Har => "tır" ;--table {
+			    --Sg => "tır" ;
+			    --Pl => "tırlar"
+		  --} ;
+		  Ih_Har => "tir" ;--table {
+			    --Sg => "tir" ;
+			    --Pl => "tirler"
+		  --} ;
+		  U_Har => "tur" ;--table {
+			   -- Sg => "tur" ;
+			   -- Pl => "turlar"
+		  --} ;
+		  Uh_Har => "tür"--table {
+			    --Sg => "tür" ;
+			    --Pl => "türler"
+		  --}
+        }
+      } ;
+
+    getHarmony : Str -> Harmony
+      = \base -> case base of {
+                 _+c@("ı"|"a"|"i"|"e"|"u"|"o"|"ü"|"ö")+
+                 ("b"|"v"|"d"|"z"|"j"|"c"|"g"|"ğ"|"l"|"r"|"m"|"n"|"y"|"p"|"f"|"t"|"s"|"ş"|"ç"|"k"|"h")* =>
+                    case c of {
+                      ("ı"|"a") => I_Har ;
+                      ("i"|"e") => Ih_Har ;
+                      ("u"|"o") => U_Har  ;
+                      ("ü"|"ö") => Uh_Har
+                    }
+        } ;
+    getSoftness : Str -> Softness
+      = \base -> case base of {
+		   _+("f"|"s"|"t"|"k"|"ç"|"ş"|"h"|"p") => Hard ;
+		   _ => Soft
+		 } ;
+}

examples/foods/FoodsUrd.gf

@@ -0,0 +1,53 @@
+-- (c) 2009 Shafqat Virk under LGPL
+
+concrete FoodsUrd of Foods = {
+
+  flags coding=utf8 ;
+
+  
+	  param Number = Sg | Pl ;
+        param Gender = Masc | Fem;
+	  
+	 oper coupla : Number -> Str =\n -> case n of {Sg => "ہے" ; Pl => "ہیں"};
+	  
+	 	  
+      lincat
+        Comment = {s : Str} ; 
+	  Item = {s: Str ; n: Number ; g:Gender};
+	  Kind = {s: Number => Str ; g:Gender};
+        Quality = {s: Gender => Number => Str};
+  
+   lin
+    Pred item quality = {s = item.s ++ quality.s ! item.g ! item.n ++  coupla item.n} ;
+	This kind = {s = "یھ" ++ kind.s ! Sg; n= Sg ; g = kind.g } ;
+	These kind = {s = "یھ" ++ kind.s ! Pl; n = Pl ; g = kind.g} ;
+    That kind = {s = "وہ"  ++ kind.s ! Sg; n= Sg ; g = kind.g} ;
+	Those kind = {s = "وہ" ++ kind.s ! Pl; n=Pl ; g = kind.g} ;
+    Mod quality kind = {s = \\n => quality.s ! kind.g ! n  ++ kind.s ! n ;  g = kind.g};
+	Wine = {s = table { Sg => "شراب" ; Pl => "شرابیں"} ; g = Fem};
+    Cheese = {s = table { Sg => "پنیر" ; Pl => "پنیریں"} ; g = Fem};
+    Fish = {s = table { Sg => "مچھلی" ; Pl => "مچھلیاں"} ; g = Fem};
+    Pizza = {s = table { Sg => "پیزہ" ; Pl => "پیزے"} ; g = Masc};
+	Very quality = {s = \\g,n => "بہت" ++ quality.s ! g ! n} ;
+    Fresh = regAdj "تازہ" ;
+    Warm = regAdj "گرم" ;
+    Italian = regAdj "اٹا لوی" ;
+    Expensive = regAdj "مہنگا" ;
+    Delicious = regAdj "مزیدار" ;
+    Boring = regAdj "فضول" ;
+   
+   oper
+    regAdj : Str -> {s: Gender => Number => Str} = \a -> case a of {
+        x + "ا" => mkAdj a (x+"ے") (x+"ی");
+        _      => mkAdj a a a
+       };
+    mkAdj : Str -> Str -> Str -> {s: Gender => Number => Str} = \s,p,f -> {
+      s = table {
+           Masc => table {
+              Sg => s;
+              Pl => p
+              };
+           Fem => \\_ => f
+         }
+       };
+	}  

examples/foods/LexFoods.gf

@@ -0,0 +1,15 @@
+-- (c) 2009 Aarne Ranta under LGPL
+
+interface LexFoods = open Syntax in {
+  oper
+    wine_N : N ;
+    pizza_N : N ;
+    cheese_N : N ;
+    fish_N : N ;
+    fresh_A : A ;
+    warm_A : A ;
+    italian_A : A ;
+    expensive_A : A ;
+    delicious_A : A ;
+    boring_A : A ;
+}

examples/foods/LexFoodsCat.gf

@@ -0,0 +1,18 @@
+-- (c) 2009 Jordi Saludes under LGPL
+
+instance LexFoodsCat of LexFoods = 
+    open SyntaxCat, ParadigmsCat, (M = MorphoCat) in {
+  flags
+	coding = utf8 ;
+  oper
+    wine_N = mkN "vi" "vins" M.Masc ;
+    pizza_N = mkN "pizza" ;
+    cheese_N = mkN "formatge" ;
+    fish_N = mkN "peix" "peixos" M.Masc;
+    fresh_A = mkA "fresc" "fresca" "frescos" "fresques" "frescament";
+    warm_A = mkA "calent" ;
+    italian_A = mkA "italià" "italiana" "italians" "italianes" "italianament" ;
+    expensive_A = mkA "car" ;
+    delicious_A = mkA "deliciós" "deliciosa" "deliciosos" "delicioses" "deliciosament";
+    boring_A = mkA "aburrit" "aburrida" "aburrits" "aburrides" "aburridament" ;
+}