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

.github/workflows/build-all-versions.yml

@@ -1,108 +0,0 @@
-# Based on the template here: https://kodimensional.dev/github-actions
-name: Build with stack and cabal
-
-# Trigger the workflow on push or pull request, but only for the master branch
-on:
-  pull_request:
-  push:
-    branches: [master]
-
-jobs:
-  cabal:
-    name: ${{ matrix.os }} / ghc ${{ matrix.ghc }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-        cabal: ["latest"]
-        ghc:
-          - "8.6.5"
-          - "8.8.3"
-          - "8.10.7"
-          - "9.6.7"
-        exclude:
-          - os: macos-latest
-            ghc: 8.8.3
-          - os: macos-latest
-            ghc: 8.6.5
-          - os: macos-latest
-            ghc: 8.10.7
-          - os: windows-latest
-            ghc: 8.8.3
-          - os: windows-latest
-            ghc: 8.6.5
-          - os: windows-latest
-            ghc: 8.10.7
-
-    steps:
-    - uses: actions/checkout@v2
-      if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
-
-    - uses: haskell-actions/setup@v2
-      id: setup-haskell-cabal
-      name: Setup Haskell
-      with:
-        ghc-version: ${{ matrix.ghc }}
-        cabal-version: ${{ matrix.cabal }}
-
-    - name: Freeze
-      run: |
-        cabal freeze
-
-    - uses: actions/cache@v4
-      name: Cache ~/.cabal/store
-      with:
-        path: ${{ steps.setup-haskell-cabal.outputs.cabal-store }}
-        key: ${{ runner.os }}-${{ matrix.ghc }}
-        # key: ${{ runner.os }}-${{ matrix.ghc }}-${{ hashFiles('cabal.project.freeze') }}
-
-    - name: Build
-      run: |
-        cabal configure --enable-tests --enable-benchmarks --test-show-details=direct
-        cabal build all
-
-    # - name: Test
-    #   run: |
-    #     cabal test all
-
-  stack:
-    name: stack / ghc ${{ matrix.ghc }}
-    runs-on: ${{ matrix.ghc == '7.10.3' && 'ubuntu-20.04' || 'ubuntu-latest' }}
-    strategy:
-      fail-fast: false
-      matrix:
-        stack: ["latest"]
-        ghc: ["8.4.4", "8.6.5", "8.8.4", "8.10.7", "9.0.2", "9.6.7"]
-
-    steps:
-    - uses: actions/checkout@v2
-      if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
-
-    - uses: haskell-actions/setup@v2
-      name: Setup Haskell Stack
-      with:
-        ghc-version: ${{ matrix.ghc }}
-        stack-version: 'latest'
-        enable-stack: true
-
-
-    # Fix linker errrors on ghc-7.10.3 for ubuntu (see https://github.com/commercialhaskell/stack/blob/255cd830627870cdef34b5e54d670ef07882523e/doc/faq.md#i-get-strange-ld-errors-about-recompiling-with--fpic)
-    - run: sed -i.bak 's/"C compiler link flags", "/&-no-pie /' /home/runner/.ghcup/ghc/7.10.3/lib/ghc-7.10.3/settings
-      if: matrix.ghc == '7.10.3'
-
-    - uses: actions/cache@v4
-      name: Cache ~/.stack
-      with:
-        path: ~/.stack
-        key: ${{ runner.os }}-${{ matrix.ghc }}-stack--${{ hashFiles(format('stack-ghc{0}', matrix.ghc)) }}
-        restore-keys: |
-             ${{ runner.os }}-${{ matrix.ghc }}-stack
-
-    - name: Build
-      run: |
-        stack build --test --no-run-tests --system-ghc --stack-yaml stack-ghc${{ matrix.ghc }}.yaml
-
-    - name: Test
-      run: |
-        stack test --system-ghc --stack-yaml stack-ghc${{ matrix.ghc }}.yaml

.github/workflows/build-binary-packages.yml

@@ -1,240 +0,0 @@
-name: Build Binary Packages
-
-on:
-  workflow_dispatch:
-  release:
-    types: ["created"]
-
-jobs:
-
-# ---
-
-  ubuntu:
-    name: Build Ubuntu package
-    strategy:
-      matrix:
-        ghc: ["9.6"]
-        cabal: ["3.10"]
-        os: ["ubuntu-24.04"]
-
-    runs-on: ${{ matrix.os }}
-
-    steps:
-    - uses: actions/checkout@v2
-
-    # Note: `haskell-platform` is listed as requirement in debian/control,
-    # which is why it's installed using apt instead of the Setup Haskell action.
-
-    - name: Setup Haskell
-      uses: haskell-actions/setup@v2
-      id: setup-haskell-cabal
-      with:
-        ghc-version: ${{ matrix.ghc }}
-        cabal-version: ${{ matrix.cabal }}
-      if: matrix.os == 'ubuntu-24.04'
-
-    - name: Install build tools
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y \
-          make \
-          dpkg-dev \
-          debhelper \
-          libghc-json-dev \
-          default-jdk \
-          python-dev-is-python3 \
-          libtool-bin 
-        cabal install alex happy
-        
-    - name: Build package
-      run: |
-        export PYTHONPATH="/home/runner/work/gf-core/gf-core/debian/gf/usr/local/lib/python3.12/dist-packages/"
-        make deb
-
-    - name: Copy package
-      run: |
-        cp ../gf_*.deb dist/
-
-    - name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: gf-${{ github.event.release.tag_name }}-${{ matrix.os }}.deb
-        path: dist/gf_*.deb
-        if-no-files-found: error
-
-    - name: Rename package for specific ubuntu version
-      run: |
-        mv dist/gf_*.deb dist/gf-${{ github.event.release.tag_name }}-${{ matrix.os }}.deb
-
-    #- uses: actions/upload-release-asset@v1.0.2
-    #  env:
-    #    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    #  with:
-    #    upload_url: ${{ github.event.release.upload_url }}
-    #    asset_path: dist/gf-${{ github.event.release.tag_name }}-${{ matrix.os }}.deb
-    #    asset_name: gf-${{ github.event.release.tag_name }}-${{ matrix.os }}.deb
-    #    asset_content_type: application/octet-stream
-
-# ---
-
-  macos:
-    name: Build macOS package
-    strategy:
-      matrix:
-        ghc: ["9.6"]
-        cabal: ["3.10"]
-        os: ["macos-latest", "macos-13"]
-    runs-on: ${{ matrix.os }}
-
-    steps:
-    - uses: actions/checkout@v2
-
-    - name: Setup Haskell
-      uses: haskell-actions/setup@v2
-      id: setup-haskell-cabal
-      with:
-        ghc-version: ${{ matrix.ghc }}
-        cabal-version: ${{ matrix.cabal }}
-
-    - name: Install build tools
-      run: |
-        brew install \
-          automake \
-          libtool
-        cabal v1-install alex happy
-        pip install setuptools
-
-    - name: Build package
-      run: |
-        sudo mkdir -p /Library/Java/Home
-        sudo ln -s /usr/local/opt/openjdk/include /Library/Java/Home/include
-        make pkg
-
-    - name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: gf-${{ github.event.release.tag_name }}-${{ matrix.os }}
-        path: dist/gf-*.pkg
-        if-no-files-found: error
-
-    - name: Rename package
-      run: |
-        mv dist/gf-*.pkg dist/gf-${{ github.event.release.tag_name }}-macos.pkg
-
-    #- uses: actions/upload-release-asset@v1.0.2
-    #  env:
-    #    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    #  with:
-    #    upload_url: ${{ github.event.release.upload_url }}
-    #    asset_path: dist/gf-${{ github.event.release.tag_name }}-macos.pkg
-    #    asset_name: gf-${{ github.event.release.tag_name }}-macos.pkg
-    #    asset_content_type: application/octet-stream
-
-# ---
-
-  windows:
-    name: Build Windows package
-    strategy:
-      matrix:
-        ghc: ["9.6.7"]
-        cabal: ["3.10"]
-        os: ["windows-2022"]
-    runs-on: ${{ matrix.os }}
-
-    steps:
-    - uses: actions/checkout@v2
-
-    - name: Setup MSYS2
-      uses: msys2/setup-msys2@v2
-      with:
-        install: >-
-          base-devel
-          gcc
-          python-devel
-          autotools
-
-    - name: Prepare dist folder
-      shell: msys2 {0}
-      run: |
-        mkdir /c/tmp-dist
-        mkdir /c/tmp-dist/c
-        mkdir /c/tmp-dist/java
-        mkdir /c/tmp-dist/python
-
-    - name: Build C runtime
-      shell: msys2 {0}
-      run: |
-        cd src/runtime/c
-        autoreconf -i
-        ./configure
-        make
-        make install
-        cp /mingw64/bin/libpgf-0.dll /c/tmp-dist/c
-        cp /mingw64/bin/libgu-0.dll /c/tmp-dist/c
-
-    # JAVA_HOME_8_X64 = C:\hostedtoolcache\windows\Java_Adopt_jdk\8.0.292-10\x64
-    - name: Build Java bindings
-      shell: msys2 {0}
-      run: |
-        echo $JAVA_HOME_8_X64
-        export JDKPATH="$(cygpath -u "${JAVA_HOME_8_X64}")"
-        export PATH="${PATH}:${JDKPATH}/bin"
-        cd src/runtime/java
-        make \
-          JNI_INCLUDES="-I \"${JDKPATH}/include\" -I \"${JDKPATH}/include/win32\" -I \"/mingw64/include\" -D__int64=int64_t" \
-          WINDOWS_LDFLAGS="-L\"/mingw64/lib\" -no-undefined"
-        make install
-        cp .libs/msys-jpgf-0.dll /c/tmp-dist/java/jpgf.dll
-        cp jpgf.jar /c/tmp-dist/java
-      if: false
-    
-    # - uses: actions/setup-python@v5
-
-    - name: Build Python bindings
-      shell: msys2 {0}
-      env:
-        EXTRA_INCLUDE_DIRS: /mingw64/include
-        EXTRA_LIB_DIRS: /mingw64/lib
-      run: |
-        cd src/runtime/python
-        pacman --noconfirm -S python-setuptools
-        python setup.py build
-        python setup.py install
-        cp -r /usr/lib/python3.12/site-packages/pgf* /c/tmp-dist/python
-
-    - name: Setup Haskell
-      uses: haskell-actions/setup@v2
-      id: setup-haskell-cabal
-      with:
-        ghc-version: ${{ matrix.ghc }}
-        cabal-version: ${{ matrix.cabal }}
-
-    - name: Install Haskell build tools
-      run: |
-        cabal install alex happy
-
-    - name: Build GF
-      run: |
-        cabal install -fserver --only-dependencies 
-        cabal configure -fserver
-        cabal build
-        copy dist-newstyle/build/x86_64-windows/ghc-${{matrix.ghc}}/*/x/gf/build/gf/gf.exe C:/tmp-dist
-
-    - name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: gf-${{ github.event.release.tag_name }}-windows
-        path: C:\tmp-dist\*
-        if-no-files-found: error
-
-    - name: Create archive
-      run: |
-        Compress-Archive C:\tmp-dist C:\gf-${{ github.event.release.tag_name }}-windows.zip
-    #- uses: actions/upload-release-asset@v1.0.2
-    #  env:
-    #    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    #  with:
-    #    upload_url: ${{ github.event.release.upload_url }}
-    #    asset_path: C:\gf-${{ github.event.release.tag_name }}-windows.zip
-    #    asset_name: gf-${{ github.event.release.tag_name }}-windows.zip
-    #    asset_content_type: application/zip

.github/workflows/build-python-package.yml

@@ -1,102 +0,0 @@
-name: Build & Publish Python Package
-
-# Trigger the workflow on push or pull request, but only for the master branch
-on:
-  pull_request:
-  push:
-    branches: [master]
-
-jobs:
-  build_wheels:
-    name: Build wheel on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: true
-      matrix:
-        os: [ubuntu-latest, macos-latest, macos-13]
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - uses: actions/setup-python@v5
-      name: Install Python
-      with:
-        python-version: '3.x'
-
-    - name: Install cibuildwheel
-      run: |
-        python -m pip install cibuildwheel
-
-    - name: Install build tools for OSX
-      if: startsWith(matrix.os, 'macos')
-      run: |
-        brew install automake
-        brew install libtool
-
-    - name: Build wheels on Linux
-      if: startsWith(matrix.os, 'macos') != true
-      env:
-        CIBW_BEFORE_BUILD: cd src/runtime/c && autoreconf -i && ./configure && make && make install
-      run: |
-        python -m cibuildwheel src/runtime/python --output-dir wheelhouse
-
-    - name: Build wheels on OSX
-      if: startsWith(matrix.os, 'macos')
-      env:
-        CIBW_BEFORE_BUILD: cd src/runtime/c && glibtoolize && autoreconf -i && ./configure && make && sudo make install
-      run: |
-        python -m cibuildwheel src/runtime/python --output-dir wheelhouse
-
-    - uses: actions/upload-artifact@v4
-      with:
-        name: wheel-${{ matrix.os }}
-        path: ./wheelhouse
-
-  build_sdist:
-    name: Build source distribution
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        name: Install Python
-        with:
-          python-version: '3.10'
-
-      - name: Build sdist
-        run: cd src/runtime/python && python setup.py sdist
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: wheel-source
-          path: ./src/runtime/python/dist/*.tar.gz
-
-  upload_pypi:
-    name: Upload to PyPI
-    needs: [build_wheels, build_sdist]
-    runs-on: ubuntu-latest
-    if: github.ref == 'refs/heads/master' && github.event_name == 'push'
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.x'
-
-      - name: Install twine
-        run: pip install twine
-
-      - uses: actions/download-artifact@v4.1.7
-        with:
-          pattern: wheel-*
-          merge-multiple: true
-          path: ./dist
-
-      - name: Publish
-        env:
-          TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
-        run: |
-          twine upload --verbose --non-interactive --skip-existing dist/*

.gitignore

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

CHANGELOG.md

@@ -1,12 +0,0 @@
-### New since 3.12 (WIP)
-
-### 3.12
-See <https://www.grammaticalframework.org/download/release-3.12.html>
-
-### 3.11
-
-See <https://www.grammaticalframework.org/download/release-3.11.html>
-
-### 3.10
-
-See <https://www.grammaticalframework.org/download/release-3.10.html>

LICENSE

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

Makefile

@@ -1,47 +1,32 @@
-.PHONY: all build install doc clean 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)
 
-# Check if stack is installed
-STACK=$(shell if hash stack 2>/dev/null; then echo "1"; else echo "0"; fi)
-
-# Check if cabal >= 2.4 is installed (with v1- and v2- commands)
-CABAL_NEW=$(shell if cabal v1-repl --help >/dev/null 2>&1 ; then echo "1"; else echo "0"; fi)
-
-ifeq ($(STACK),1)
-  CMD=stack
-else
-  CMD=cabal
-  ifeq ($(CABAL_NEW),1)
-    CMD_PFX=v1-
-  endif
-endif
-
 all: build
 
 dist/setup-config: gf.cabal Setup.hs WebSetup.hs
-ifneq ($(STACK),1)
-	cabal ${CMD_PFX}configure
-endif
+	cabal configure
 
 build: dist/setup-config
-	${CMD} ${CMD_PFX}build
+	cabal build
 
 install:
-ifeq ($(STACK),1)
-	stack install
-else
-	cabal ${CMD_PFX}copy
-	cabal ${CMD_PFX}register
-endif
+	cabal copy
+	cabal register
 
 doc:
-	${CMD} ${CMD_PFX}haddock
+	cabal haddock
 
 clean:
-	${CMD} ${CMD_PFX}clean
-	bash bin/clean_html
+	cabal clean
+
+#sdist:
+#	cabal sdist
+
+gf:
+	cabal build rgl-none
+	strip dist/build/gf/gf
 
 html::
 	bash bin/update_html
@@ -50,9 +35,9 @@ html::
 # number to the top of debian/changelog.
 # (Tested on Ubuntu 15.04. You need to install dpkg-dev & debhelper.)
 deb:
-	dpkg-buildpackage -b -uc -d
+	dpkg-buildpackage -b
 
-# Make a macOS installer package
+# Make an OS X Installer package
 pkg:
 	FMT=pkg bash bin/build-binary-dist.sh
 
@@ -60,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`
-# sdist:
-# 	test -d dist || mkdir dist
-# 	git archive --format=tar.gz --output=dist/gf-${VERSION}.tar.gz HEAD
+# Make a source tar.gz distribution using darcs to make sure that everything
+# is included. We put the distribution in dist/ so it is removed on
+# `make clean`
+sdist:
+	test -d dist || mkdir dist
+	darcs dist -d dist/gf-${VERSION}

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,69 +0,0 @@
-![GF Logo](https://www.grammaticalframework.org/doc/Logos/gf1.svg)
-
-# Grammatical Framework (GF)
-
-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 from source is with the command:
-```
-cabal install
-```
-or:
-```
-stack install
-```
-Note that if you are unlucky to have Cabal 3.0 or later, then it uses
-the so-called Nix style commands. Using those for GF development is
-a pain. Every time when you change something in the source code, Cabal
-will generate a new folder for GF to look for the GF libraries and
-the GF cloud. Either reinstall everything with every change in the
-compiler, or be sane and stop using cabal-install. Instead you can do:
-```
-runghc Setup.hs configure
-runghc Setup.hs build
-sudo runghc Setup.hs install
-```
-The script will install the GF dependencies globally. The only solution
-to the Nix madness that I found is radical:
-
-  "No person, no problem" (Нет человека – нет проблемы).
-
-For more information, including links to precompiled binaries, see the [download page](https://www.grammaticalframework.org/download/index.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).

RELEASE.md

@@ -1,69 +0,0 @@
-# GF Core releases
-
-**Note:**
-The RGL is now released completely separately from GF Core.
-See the [RGL's RELEASE.md](https://github.com/GrammaticalFramework/gf-rgl/blob/master/RELEASE.md).
-
-## Creating a new release
-
-### 1. Prepare the repository
-
-**Web pages**
-
-1. Create `download/index-X.Y.md` with installation instructions.
-2. Create `download/release-X.Y.md` with changelog information.
-3. Update `download/index.html` to redirect to the new version.
-4. Add announcement in news section in `index.html`.
-
-**Version numbers**
-
-1. Update version number in `gf.cabal` (ommitting `-git` suffix).
-2. Add a new line in `debian/changelog`.
-
-### 2. Create GitHub release
-
-1. When the above changes are committed to the `master` branch in the repository
-  and pushed, check that all CI workflows are successful (fixing as necessary):
-  - <https://github.com/GrammaticalFramework/gf-core/actions>
-  - <https://travis-ci.org/github/GrammaticalFramework/gf-core>
-2. Create a GitHub release [here](https://github.com/GrammaticalFramework/gf-core/releases/new):
-  - Tag version format `RELEASE-X.Y`
-  - Title: "GF X.Y"
-  - Description: mention major changes since last release
-3. Publish the release to trigger the building of the binary packages (below).
-
-### 3. Binary packages
-
-The binaries will be built automatically by GitHub Actions when the release is created,
-but the generated _artifacts_ must be manually attached to the release as _assets_.
-
-1. Go to the [actions page](https://github.com/GrammaticalFramework/gf-core/actions) and click "Build Binary Packages" under _Workflows_.
-2. Choose the workflow run corresponding to the newly created release.
-3. Download the artifacts locally. Extract the Ubuntu and macOS ones to get the `.deb` and `.pkg` files.
-4. Go back to the [releases page](https://github.com/GrammaticalFramework/gf-core/releases) and click to edit the release information.
-5. Add the downloaded artifacts as release assets, giving them names with format `gf-X.Y-PLATFORM.EXT` (e.g. `gf-3.11-macos.pkg`).
-
-### 4. Upload to Hackage
-
-In order to do this you will need to be added the [GF maintainers](https://hackage.haskell.org/package/gf/maintainers/) on Hackage.
-
-1. Run `stack sdist --test-tarball` and address any issues.
-2. Upload the package, either:
-    1. **Manually**: visit <https://hackage.haskell.org/upload> and upload the file generated by the previous command.
-    2. **via Stack**: `stack upload . --candidate`
-3. After testing the candidate, publish it:
-    1. **Manually**: visit <https://hackage.haskell.org/package/gf-X.Y.Z/candidate/publish>
-    1. **via Stack**: `stack upload .`
-4. If the documentation-building fails on the Hackage server, do:
-```
-cabal v2-haddock --builddir=dist/docs --haddock-for-hackage --enable-doc
-cabal upload --documentation dist/docs/*-docs.tar.gz
-```
-
-## Miscellaneous
-
-### What is the tag `GF-3.10`?
-
-For GF 3.10, the Core and RGL repositories had already been separated, however
-the binary packages still included the RGL. `GF-3.10` is a tag that was created
-in both repositories ([gf-core](https://github.com/GrammaticalFramework/gf-core/releases/tag/GF-3.10) and [gf-rgl](https://github.com/GrammaticalFramework/gf-rgl/releases/tag/GF-3.10)) to indicate which versions of each went into the binaries.

Setup.hs

@@ -1,96 +1,438 @@
-import Distribution.System(Platform(..),OS(..))
-import Distribution.Simple(defaultMainWithHooks,UserHooks(..),simpleUserHooks)
-import Distribution.Simple.LocalBuildInfo(LocalBuildInfo(..),absoluteInstallDirs,datadir)
-import Distribution.Simple.Setup(BuildFlags(..),Flag(..),InstallFlags(..),CopyDest(..),CopyFlags(..),SDistFlags(..))
-import Distribution.PackageDescription(PackageDescription(..),emptyHookedBuildInfo)
+import Distribution.Simple
+import Distribution.Simple.LocalBuildInfo
 import Distribution.Simple.BuildPaths(exeExtension)
-import System.Directory
-import System.FilePath((</>),(<.>))
-import System.Process
-import Control.Monad(forM_,unless)
-import Control.Exception(bracket_)
+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
 
+tryIOE :: IO a -> IO (Either E.IOException a)
+tryIOE = E.try
+
 main :: IO ()
-main = defaultMainWithHooks simpleUserHooks
-  { preConf   = gfPreConf
-  , preBuild  = gfPreBuild
-  , postBuild = gfPostBuild
-  , preInst   = gfPreInst
-  , postInst  = gfPostInst
-  , postCopy  = gfPostCopy
-  }
+main = defaultMainWithHooks simpleUserHooks{ preBuild  = gfPreBuild
+                                           , postBuild = gfPostBuild
+                                           , preInst   = gfPreInst
+                                           , postInst  = gfPostInst
+                                           , preCopy   = const . checkRGLArgs
+                                           , postCopy  = gfPostCopy
+                                           , sDistHook = sdistError
+                                           }
   where
-    gfPreConf args flags = do
-      pkgs <- fmap (map (dropWhile isSpace) . tail . lines)
-                   (readProcess "ghc-pkg" ["list"] "")
-      forM_ dependencies $ \pkg -> do
-        let name = takeWhile (/='/') (drop 36 pkg)
-        unless (name `elem` pkgs) $ do
-          let fname = name <.> ".tar.gz"
-          callProcess "wget" [pkg,"-O",fname]
-          callProcess "tar"  ["-xzf",fname]
-          removeFile fname
-          bracket_ (setCurrentDirectory name) (setCurrentDirectory ".." >> removeDirectoryRecursive name) $ do
-            exists <- doesFileExist "Setup.hs"
-            unless exists $ do
-              writeFile "Setup.hs" (unlines [
-                  "import Distribution.Simple",
-                  "main = defaultMain"
-                ])
-            let to_descr = reverse .
-                           (++) (reverse ".cabal") . 
-                           drop 1 . 
-                           dropWhile (/='-') . 
-                           reverse
-            callProcess "wget"   [to_descr pkg, "-O", to_descr name]
-            callProcess "runghc" ["Setup.hs","configure"]
-            callProcess "runghc" ["Setup.hs","build"]
-            callProcess "sudo" ["runghc","Setup.hs","install"]
-          
-      preConf simpleUserHooks args flags
+    gfPreBuild args  = gfPre args . buildDistPref
+    gfPreInst args = gfPre args . installDistPref
 
-    gfPreBuild args = gfPre args . buildDistPref
-    gfPreInst  args = gfPre args . installDistPref
+    gfPre args distFlag =
+      do h <- checkRGLArgs args
+         extractDarcsVersion distFlag
+         return h
 
-    gfPre args distFlag = do
-      return emptyHookedBuildInfo
+    gfPostBuild args flags pkg lbi =
+      do --writeFile "running" ""
+         buildRGL args flags (flags,pkg,lbi)
+--       let gf = default_gf lbi
+--       buildWeb gf (pkg,lbi)
 
-    gfPostBuild args flags pkg lbi = do
-      let gf = default_gf lbi
-      buildWeb gf flags (pkg,lbi)
+    gfPostInst args flags pkg lbi =
+      do installRGL args flags (pkg,lbi)
+         let gf = default_gf lbi
+         installWeb (pkg,lbi)
 
-    gfPostInst args flags pkg lbi = do
-      installWeb (pkg,lbi)
+    gfPostCopy args flags  pkg lbi =
+      do let gf = default_gf lbi
+         copyRGL args flags (pkg,lbi)
+         copyWeb flags (pkg,lbi)
 
-    gfPostCopy args flags  pkg lbi = do
-      copyWeb flags (pkg,lbi)
+--------------------------------------------------------
+-- Commands for building the Resource Grammar Library
+--------------------------------------------------------
 
-    -- `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 ()
+data Mode = AllTenses | Present deriving Show
+all_modes = ["alltenses","present"]
+default_modes = [AllTenses,Present]
 
-dependencies = [
-  "https://hackage.haskell.org/package/utf8-string-1.0.2/utf8-string-1.0.2.tar.gz",
-  "https://hackage.haskell.org/package/json-0.10/json-0.10.tar.gz",
-  "https://hackage.haskell.org/package/network-bsd-2.8.1.0/network-bsd-2.8.1.0.tar.gz",
-  "https://hackage.haskell.org/package/httpd-shed-0.4.1.1/httpd-shed-0.4.1.1.tar.gz",
-  "https://hackage.haskell.org/package/exceptions-0.10.5/exceptions-0.10.5.tar.gz",
-  "https://hackage.haskell.org/package/stringsearch-0.3.6.6/stringsearch-0.3.6.6.tar.gz",
-  "https://hackage.haskell.org/package/multipart-0.2.1/multipart-0.2.1.tar.gz",
-  "https://hackage.haskell.org/package/cgi-3001.5.0.0/cgi-3001.5.0.0.tar.gz"
+data RGLCommand
+  = RGLCommand
+      { cmdName   :: String
+      , cmdIsDef  :: Bool
+      , cmdAction :: [Mode] -> [String] -> Info -> IO ()
+      }
+
+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"),"")
   ]
 
--- | Get path to locally-built gf
+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'
+
 default_gf :: LocalBuildInfo -> FilePath
 default_gf lbi = buildDir lbi </> exeName' </> exeNameReal
   where
-    -- shadows Distribution.Simple.BuildPaths.exeExtension, which changed type signature in Cabal 2.4
-    exeExtension = case hostPlatform lbi of
-      Platform arch Windows -> "exe"
-      _ -> ""
     exeName' = "gf"
     exeNameReal = exeName' <.> exeExtension
+    {- --old solution, could pick the wrong executable if there is more than one
+    exeName' = (exeName . head . executables) pkg
+    exeNameReal = exeName' <.> (if null $ takeExtension exeName' then exeExtension else "")
+    -}
+
+-- | Create autogen module with detailed version info by querying darcs
+extractDarcsVersion distFlag =
+  do info <- tryIOE askDarcs
+     createDirectoryIfMissing True autogenPath
+     updateFile versionModulePath $ unlines $
+       ["module "++modname++" where",
+        "{-# NOINLINE darcs_info #-}",
+        "darcs_info = "++show (either (const (Left ())) Right info)]
+  where
+    dist = fromFlagOrDefault "dist" distFlag
+    autogenPath = dist</>"build"</>"autogen"
+    versionModulePath = autogenPath</>"DarcsVersion_gf.hs"
+    modname = "DarcsVersion_gf"
+
+askDarcs =
+  do flip unless (fail "no _darcs") =<< doesDirectoryExist "_darcs"
+     tags <- lines `fmap` readProcess "darcs" ["show","tags"] ""
+     let from = case tags of
+                  [] -> []
+                  tag:_ -> ["--from-tag="++tag]
+     dates <- (init' . patches) `fmap` readProcess "darcs" ("changes":from) ""
+--   let dates = init' (filter ((`notElem` [""," "]).take 1) changes)
+     whatsnew <- tryIOE $ lines `fmap` readProcess "darcs" ["whatsnew","-s"] ""
+     return (listToMaybe tags,listToMaybe dates,
+             length dates,either (const 0) length whatsnew)
+  where
+    init' [] = []
+    init' xs = init xs
+
+-- | Only update the file if contents has changed
+updateFile path new =
+  do old <- tryIOE $ readFile path
+     when (Right new/=old) $ seq (either (const 0) length old) $
+                                 writeFile path new
+
+-- | List files, excluding "." and ".."
+list_files path = filter ((/=".").take 1) `fmap` getDirectoryContents path
+
+
+-- | For parallel RGL module compilation
+-- Unfortunately, this has no effect unless Setup.hs is compiled with -threaded
+parallel_ ms = sequence_ ms {-
+  do c <- newChan
+     ts <- sequence [ forkIO (m >> writeChan c ()) | m <- ms]
+     sequence_ [readChan c | _ <- ts]
+--}
+
+patches = paras . lines
+  where
+    paras = unfoldr para
+    para ls = case break null $ dropWhile null ls of
+                ([],[]) -> Nothing
+                (xs,ys) -> Just (info xs,ys)
+
+    info = unwords . map dropHeaders . filter (\l->not $ any (`isPrefixOf` l) [" ","patch "])
+    dropHeaders = dropWhile isSpace . dropPrefix "Author: " . dropPrefix "Date: "
+    dropPrefix pre l = maybe l id (stripPrefix pre l)

WebSetup.hs

@@ -1,12 +1,12 @@
 module WebSetup(buildWeb,installWeb,copyWeb,numJobs,execute) where
 
-import System.Directory(createDirectoryIfMissing,copyFile,doesDirectoryExist,doesFileExist)
+import System.Directory(createDirectoryIfMissing,copyFile)
 import System.FilePath((</>),dropExtension)
 import System.Process(rawSystem)
 import System.Exit(ExitCode(..))
-import Distribution.Simple.Setup(BuildFlags(..),Flag(..),CopyFlags(..),CopyDest(..),copyDest)
-import Distribution.Simple.LocalBuildInfo(LocalBuildInfo(..),datadir,buildDir,absoluteInstallDirs)
-import Distribution.PackageDescription(PackageDescription(..))
+import Distribution.Simple.Setup(BuildFlags(..),Flag(..),CopyDest(..),copyDest)
+import Distribution.Simple.LocalBuildInfo(datadir,buildDir,absoluteInstallDirs)
+import Distribution.Simple.Utils(die)
 
 {-
    To test the GF web services, the minibar and the grammar editor, use
@@ -16,88 +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.)
--}
-
--- | Notice about contrib grammars
-noContribMsg :: IO ()
-noContribMsg = putStr $ unlines
-  [ "Example grammars are no longer included in the main GF repository, but have moved to gf-contrib."
-  , "If you want them to be built, clone the following repository in the same directory as gf-core:"
-  , "https://github.com/GrammaticalFramework/gf-contrib.git"
-  ]
-
-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 noContribMsg
-  else return ()
+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
@@ -105,14 +74,10 @@ setupWeb dest (pkg,lbi) = do
     www_dir = datadir (absoluteInstallDirs pkg lbi dest) </> "www"
     gfo_dir = buildDir lbi </> "examples"
 
-    copy_pgf :: (String, String, [String]) -> IO ()
     copy_pgf (pgf,subdir,_) =
-      do let src = gfo_dir </> pgf
-         let dst = grammars_dir </> pgf
-         ex <- doesFileExist src
-         if ex then do putStrLn $ "Installing "++dst
-                       copyFile src dst
-               else putStrLn $ "Not installing "++dst
+      do let dst = grammars_dir</>pgf
+         putStrLn $ "Installing "++dst
+         copyFile (gfo_dir</>pgf) dst
 
     gf_logo = "gf0.png"
 
@@ -120,27 +85,27 @@ setupWeb dest (pkg,lbi) = do
       do createDirectoryIfMissing True logo_dir
          copyFile ("doc"</>"Logos"</>gf_logo) (logo_dir</>gf_logo)
 
--- | Run an arbitrary system command, returning False on failure
-execute :: String -> [String] -> IO Bool
 execute command args =
   do let cmdline = command ++ " " ++ unwords (map showArg args)
+--   putStrLn $ "Running: " ++ cmdline
+--   appendFile "running" (cmdline++"\n")
      e <- rawSystem command args
      case e of
-       ExitSuccess   -> return True
+       ExitSuccess   -> return ()
        ExitFailure i -> do putStrLn $ "Ran: " ++ cmdline
-                           putStrLn $ command++" exited with exit code: " ++ show i
-                           return False
+                           die $ command++" exited with exit code: " ++ show i
   where
     showArg arg = if ' ' `elem` arg then "'" ++ arg ++ "'" else arg
 
--- | This function is used to enable parallel compilation of the RGL and example grammars
-numJobs :: BuildFlags -> [String]
+-- | This function is used to enable parallel compilation of the RGL and
+-- example grammars, but it is commented out by default
+-- to avoid casing problems for developers using Cabal<1.20
 numJobs flags =
     if null n
     then ["-j","+RTS","-A20M","-N","-RTS"]
     else ["-j="++n,"+RTS","-A20M","-N"++n,"-RTS"]
   where
     -- buildNumJobs is only available in Cabal>=1.20
-    n = case buildNumJobs flags of
+    n = {-case buildNumJobs flags of
           Flag mn | mn/=Just 1-> maybe "" show mn
-          _ -> ""
+          _ ->-} ""

bin/build-binary-dist.sh

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

bin/clean_html

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

bin/template.html

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

bin/update_html

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

css/oldstyle.css

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

css/style0.css

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

debian/changelog

@@ -1,44 +1,3 @@
-gf (3.12) noble; urgency=low
-
-  * GF 3.12
-
- -- Inari Listenmaa <inari@digitalgrammars.com>  Fri, 8 Aug 2025 18:29:29 +0100
-gf (3.11) bionic focal; urgency=low
-
-  * GF 3.11
-
- -- Inari Listenmaa <inari@digitalgrammars.com>  Sun, 25 Jul 2021 10:27:40 +0800
-
-gf (3.10.4-1) xenial bionic cosmic; urgency=low
-
-  * GF 3.10.4
-
- -- Thomas Hallgren <hallgren@chalmers.se>  Fri, 18 Nov 2019 15:00:00 +0100
-
-gf (3.10.3-1) xenial bionic cosmic; urgency=low
-
-  * GF 3.10.3
-
- -- Thomas Hallgren <hallgren@chalmers.se>  Fri,  5 Mar 2019 19:30:00 +0100
-
-gf (3.10-2) xenial bionic cosmic; urgency=low
-
-  * GF 3.10
-
- -- Thomas Hallgren <hallgren@chalmers.se>  Fri,  5 Mar 2019 16:00:00 +0100
-
-gf (3.10-1) xenial bionic cosmic; urgency=low
-
-  * GF 3.10
-
- -- Thomas Hallgren <hallgren@chalmers.se>  Fri,  2 Dec 2018 15:00:00 +0100
-
-gf (3.9-1) vivid xenial zesty; urgency=low
-
-  * GF 3.9
-
- -- Thomas Hallgren <hallgren@chalmers.se>  Fri, 11 Aug 2017 20:00:00 +0200
-
 gf (3.8-1) precise trusty vivid; urgency=low
 
   * GF 3.8

debian/control

@@ -3,14 +3,14 @@ Section: devel
 Priority: optional
 Maintainer: Thomas Hallgren <hallgren@chalmers.se>
 Standards-Version: 3.9.2
-Build-Depends: debhelper (>= 5), libghc-haskeline-dev, libghc-mtl-dev, libghc-json-dev, autoconf, automake, libtool-bin, python-dev-is-python3, java-sdk
+Build-Depends: debhelper (>= 5), haskell-platform (>= 2011.2.0.1), libghc-haskeline-dev, libghc-mtl-dev, libghc-json-dev, autoconf, automake, libtool-bin, python-dev, java-sdk, txt2tags
 Homepage: http://www.grammaticalframework.org/
 
 Package: gf
 Architecture: any
 Depends: ${shlibs:Depends}
 Description: Tools for GF, a grammar formalism based on type theory
- Grammatical Framework (GF) is a grammar formalism based on type theory.
+ Grammatical Framework (GF) is a grammar formalism based on type theory. 
  It consists of a special-purpose programming language,
  a compiler of the language, and a generic grammar processor.
  .

debian/rules

@@ -1,6 +1,6 @@
 #!/usr/bin/make -f
 
-%:
+%: 
 	+dh $@
 
 #dh_shlibdeps has a problem finding which package some of the Haskell
@@ -13,36 +13,33 @@
 override_dh_shlibdeps:
 	dh_shlibdeps --dpkg-shlibdeps-params=--ignore-missing-info
 
-override_dh_auto_configure:
-	cd src/runtime/c && bash setup.sh configure --prefix=/usr
-	cd src/runtime/c && bash setup.sh build
-	cabal update
-	cabal v1-install --only-dependencies
-	cabal v1-configure --prefix=/usr -fserver -fc-runtime --extra-lib-dirs=$(CURDIR)/src/runtime/c/.libs --extra-include-dirs=$(CURDIR)/src/runtime/c
-
-SET_LDL=LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:$(CURDIR)/src/runtime/c/.libs
-
 override_dh_auto_build:
 	cd src/runtime/python && EXTRA_INCLUDE_DIRS=$(CURDIR)/src/runtime/c EXTRA_LIB_DIRS=$(CURDIR)/src/runtime/c/.libs python setup.py build
-	# cd src/runtime/java && make CFLAGS="-I$(CURDIR)/src/runtime/c -L$(CURDIR)/src/runtime/c/.libs" INSTALL_PATH=/usr
-	echo $(SET_LDL)
-	-$(SET_LDL) cabal v1-build
-
-override_dh_auto_install:
-	$(SET_LDL) cabal v1-copy --destdir=$(CURDIR)/debian/gf
-	cd src/runtime/c && bash setup.sh copy prefix=$(CURDIR)/debian/gf/usr
-	cd src/runtime/python && python setup.py install --prefix=$(CURDIR)/debian/gf/usr
-	# cd src/runtime/java && make INSTALL_PATH=$(CURDIR)/debian/gf/usr install
-	# D="`find debian/gf -name dist-packages`" && [ -n "$$D" ] && cd $$D && cd .. && mv dist-packages dist-packages
-
-override_dh_usrlocal:
+	cd src/runtime/java && make CFLAGS="-I$(CURDIR)/src/runtime/c -L$(CURDIR)/src/runtime/c/.libs" INSTALL_PATH=/usr/lib
+	echo LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:$(CURDIR)/src/runtime/c/.libs
+	LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:$(CURDIR)/src/runtime/c/.libs cabal build
+	make html
 
 override_dh_auto_clean:
 	rm -fr dist/build
 	-cd src/runtime/python && rm -fr build
-	# -cd src/runtime/java && make clean
+	-cd src/runtime/java && make clean
 	-cd src/runtime/c && make clean
 
+override_dh_auto_configure:
+	cd src/runtime/c && bash setup.sh configure --prefix=/usr
+	cd src/runtime/c && bash setup.sh build
+	cabal update
+	cabal install --only-dependencies
+	cabal configure --prefix=/usr -fserver -fc-runtime --extra-lib-dirs=$(CURDIR)/src/runtime/c/.libs --extra-include-dirs=$(CURDIR)/src/runtime/c
+
+override_dh_auto_install:
+	LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:$(CURDIR)/src/runtime/c/.libs cabal copy --destdir=$(CURDIR)/debian/gf
+	cd src/runtime/c && bash setup.sh copy prefix=$(CURDIR)/debian/gf/usr
+	cd src/runtime/python && python setup.py install --prefix=$(CURDIR)/debian/gf/usr
+	cd src/runtime/java && make INSTALL_PATH=$(CURDIR)/debian/gf/usr/lib install
+	D="`find debian/gf -name site-packages`" && [ -n "$$D" ] && cd $$D && cd .. && mv site-packages dist-packages
+
 override_dh_auto_test:
 ifneq (nocheck,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
 	true

demos/index-numbers.html

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

demos/index.html

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

doc/Makefile

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

doc/error-messages.txt

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

doc/errors/gluing.md

@@ -1,27 +0,0 @@
-## unsupported token gluing `foo + bar`
-
-There was a problem in an expression using +, e.g. `foo + bar`.
-This can be due to two causes, check which one applies in your case.
-
-1. You are trying to use + on runtime arguments. Even if you are using
-`foo + bar` in an oper, make sure that the oper isn't called in a
-linearization that takes arguments. Both of the following are illegal:
-
-    lin Test foo bar = foo.s + bar.s          -- explicit + in a lin
-    lin Test foo bar = opWithPlus foo bar     -- the oper uses +
-
-2. One of the arguments in `foo + bar` is a bound variable
-from pattern matching a string, but the cases are non-exhaustive.
-Example:
-    case "test" of {
-      x + "a" => x + "b"   -- no applicable case for "test", so x = ???
-    } ;
-
-You can fix this by adding a catch-all case in the end:
-    { x + "a" => x + "b" ;
-      _       => "default case" } ;
-
-3. If neither applies to your problem, submit a bug report and we
-will update the error message and this documentation.
-
-    https://github.com/GrammaticalFramework/gf-core/issues

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-old-cabal.t2t

@@ -1,201 +0,0 @@
-GF Developer's Guide: Old installation instructions with Cabal
-
-
-This page contains the old installation instructions from the [Developer's Guide ../doc/gf-developers.html].
-We recommend Stack as a primary installation method, because it's easier for a Haskell beginner, and we want to keep the main instructions short.
-But if you are an experienced Haskeller and want to keep using Cabal, here are the old instructions using ``cabal install``.
-
-Note that some of these instructions may be outdated. Other parts may still be useful.
-
-== Compilation from source with Cabal ==
-
-The build system of GF is based on //Cabal//, which is part of the
-Haskell Platform, so no extra steps are needed to install it. In the simplest
-case, all you need to do to compile and install GF, after downloading the
-source code as described above, is
-
-```
-$ cabal install
-```
-
-This will automatically download any additional Haskell libraries needed to
-build GF. If this is the first time you use Cabal, you might need to run
-``cabal update`` first, to update the list of available libraries.
-
-If you want more control, the process can also be split up into the usual
-//configure//, //build// and //install// steps.
-
-=== Configure ===
-
-During the configuration phase Cabal will check that you have all
-necessary tools and libraries needed for GF. The configuration is
-started by the command:
-
-```
-$ cabal configure
-```
-
-If you don't see any error message from the above command then you
-have everything that is needed for GF. You can also add the option
-``-v`` to see more details about the configuration.
-
-You can use ``cabal configure --help`` to get a list of configuration options.
-
-=== Build ===
-
-The build phase does two things. First it builds the GF compiler from
-the Haskell source code and after that it builds the GF Resource Grammar
-Library using the already build compiler.  The simplest command is:
-
-```
-$ cabal build
-```
-
-Again you can add the option ``-v`` if you want to see more details.
-
-==== Parallel builds ====
-
-If you have Cabal>=1.20 you can enable parallel compilation by using
-
-```
-$ cabal build -j
-```
-
-or by putting a line
-```
-jobs: $ncpus
-```
-in your ``.cabal/config`` file. Cabal
-will pass this option to GHC when building the GF compiler, if you
-have GHC>=7.8.
-
-Cabal also passes ``-j`` to GF to enable parallel compilation of the
-Resource Grammar Library. This is done unconditionally to avoid
-causing problems for developers with Cabal<1.20. You can disable this
-by editing the last few lines in ``WebSetup.hs``.
-
-=== Install ===
-
-After you have compiled GF you need to install the executable and libraries
-to make the system usable.
-
-```
-$ cabal copy
-$ cabal register
-```
-
-This command installs the GF compiler for a single user, in the standard
-place used by Cabal.
-On Linux and Mac this could be ``$HOME/.cabal/bin``.
-On Mac it could also be ``$HOME/Library/Haskell/bin``.
-On Windows this is ``C:\Program Files\Haskell\bin``.
-
-The compiled GF Resource Grammar Library will be installed
-under the same prefix, e.g. in
-``$HOME/.cabal/share/gf-3.3.3/lib`` on Linux and
-in ``C:\Program Files\Haskell\gf-3.3.3\lib`` on Windows.
-
-If you want to install in some other place then use the ``--prefix``
-option during the configuration phase.
-
-=== Clean ===
-
-Sometimes you want to clean up the compilation and start again from clean
-sources. Use the clean command for this purpose:
-
-```
-$ cabal clean
-```
-
-
-%=== SDist ===
-%
-%You can use the command:
-%
-%% This does *NOT* include everything that is needed // TH 2012-08-06
-%```
-%$ cabal sdist
-%```
-%
-%to prepare archive with all source codes needed to compile GF.
-
-=== Known problems with Cabal ===
-
-Some versions of Cabal (at least version 1.16) seem to have a bug that can
-cause the following error:
-
-```
-Configuring gf-3.x...
-setup: Distribution/Simple/PackageIndex.hs:124:8-13: Assertion failed
-```
-
-The exact cause of this problem is unclear, but it seems to happen
-during the configure phase if the same version of GF is already installed,
-so a workaround is to remove the existing installation with
-
-```
-ghc-pkg unregister gf
-```
-
-You can check with ``ghc-pkg list gf`` that it is gone.
-
-== Compilation with make ==
-
-If you feel more comfortable with Makefiles then there is a thin Makefile
-wrapper arround Cabal for you. If you just type:
-```
-$ make
-```
-the configuration phase will be run automatically if needed and after that
-the sources will be compiled.
-
-%% cabal build rgl-none does not work with recent versions of Cabal
-%If you don't want to compile the resource library
-%every time then you can use:
-%```
-%$ make gf
-%```
-
-For installation use:
-```
-$ make install
-```
-For cleaning:
-```
-$ make clean
-```
-%and to build source distribution archive run:
-%```
-%$ make sdist
-%```
-
-
-== Partial builds of RGL ==
-
-**NOTE**: The following doesn't work with recent versions of ``cabal``. //(This comment was left in 2015, so make your own conclusions.)//
-%% // TH 2015-06-22
-
-%Sometimes you just want to work on the GF compiler and don't want to
-%recompile the resource library after each change. In this case use
-%this extended command:
-
-%```
-%$ cabal build rgl-none
-%```
-
-The resource grammar library can be compiled in two modes: with present
-tense only and with all tenses. By default it is compiled with all
-tenses. If you want to use the library with only present tense you can
-compile it in this special mode with the command:
-
-```
-$ cabal build present
-```
-
-You could also control which languages you want to be recompiled by
-adding the option ``langs=list``. For example the following command
-will compile only the English and the Swedish language:
-
-```
-$ cabal build langs=Eng,Swe
-```

doc/gf-developers.t2t

@@ -1,8 +1,16 @@
 GF Developers Guide
+Authors: Björn Bringert, Krasimir Angelov and Thomas Hallgren
+Last update: %%mtime(%F, %H:%M)
 
-2021-07-15
+% NOTE: this is a txt2tags file.
+% Create an html file from this file using:
+% txt2tags -t html gf-developers.t2t
 
+%!style:../css/style.css
+%!target:html
 %!options(html): --toc
+%!encoding:utf-8
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
 
 == Before you start ==
 
@@ -15,370 +23,569 @@ 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 build tool //Stack//, the version control software //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.
+**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 Mac OS and Windows**, the tools can be downloaded from their respective
-%web sites, as described below.
-
-=== Stack ===
-The primary installation method is via //Stack//.
-(You can also use Cabal, but we recommend Stack to those who are new to Haskell.)
-
-To install Stack:
-
-- **On Linux and Mac OS**, do either
-
-    ``$ curl -sSL https://get.haskellstack.org/ | sh``
-
-  or
-
-    ``$ wget -qO- https://get.haskellstack.org/ | sh``
+- On Ubuntu: ``sudo apt-get install haskell-platform darcs libghc6-haskeline-dev``
+- On Fedora: ``sudo yum install haskell-platform darcs ghc-haskeline-devel``
 
 
-- **On other operating systems**, see the [installation guide https://docs.haskellstack.org/en/stable/install_and_upgrade].
+**On Mac OS and Windows**, the tools can be downloaded from their respective
+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 7.10.3. Downloads
+and installation instructions are available from here:
+
+    http://hackage.haskell.org/platform/
+
+Once you have installed the Haskell Platform, open a terminal
+(Command Prompt on Windows) and try to execute the following command:
+```
+$ ghc --version
+```
+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 7.8.3
+```
+
+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.
 
 
-%If you already have Stack installed, upgrade it to the latest version by running: ``stack upgrade``
-
-
-=== Git ===
-
-To get the GF source code, you also need //Git//, a distributed version control system.
-
-- **On Linux**, the best option is to install the tools via the standard
-software distribution channels:
-
-  - On Ubuntu: ``sudo apt-get install git-all``
-  - On Fedora: ``sudo dnf install git-all``
-
-
-- **On other operating systems**, see
-https://git-scm.com/book/en/v2/Getting-Started-Installing-Git for installation.
-
-
-
-=== Haskeline ===
+=== The haskeline library ===
 
 GF uses //haskeline// to enable command line editing in the GF shell.
+This should work automatically on Mac OS and Windows, but on Linux one
+extra step is needed to make sure the C libraries (terminfo)
+required by //haskeline// are installed.  Here is one way to do this:
 
-- **On Mac OS and Windows**, this should work automatically.
-
-- **On Linux**, an extra step is needed to make sure the C libraries (terminfo)
-required by //haskeline// are installed:
-
-  - On Ubuntu: ``sudo apt-get install libghc-haskeline-dev``
-  - On Fedora: ``sudo dnf install ghc-haskeline-devel``
+- On Ubuntu: ``sudo apt-get install libghc-haskeline-dev``
+- On Fedora: ``sudo yum install ghc-haskeline-devel``
 
 
-== Getting the source ==[getting-source]
+== Getting the source ==
 
-Once you have all tools in place you can get the GF source code from
-[GitHub https://github.com/GrammaticalFramework/]:
+Once you have all tools in place you can get the GF source code. If you
+just want to compile and use GF then it is enough to have read-only
+access. It is also possible to make changes in the source code but if you
+want these changes to be applied back to the main source repository you will
+have to send the changes to us.  If you plan to work continuously on
+GF then you should consider getting read-write access.
 
-- https://github.com/GrammaticalFramework/gf-core for the GF compiler
-- https://github.com/GrammaticalFramework/gf-rgl for the Resource Grammar Library
+=== Read-only access ===
 
+==== Getting a fresh copy for read-only access ====
 
-=== Read-only access: clone the main repository ===
-
-If you only want to compile and use GF, you can just clone the repositories as follows:
+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
 ```
 
-To get new updates, run the following anywhere in your local copy of the repository:
+This will create a directory called ``gf`` in the current
+directory.
+
+
+==== Updating your copy ====
+
+To get all new patches from the main repo:
+```
+$ darcs pull -a
+```
+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]
+
+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 
+keep them under revision control:
 
 ```
-  $ git pull
+$ darcs add file1 file2 ...
 ```
 
-=== Contribute your changes: fork the main repository ===
-
-If you want the possibility to contribute your changes,
-you should create your own fork, do your changes there,
-and then send a pull request to the main repository.
-
-+ **Creating and cloning a fork  —**
-See GitHub documentation for instructions how to [create your own fork https://docs.github.com/en/get-started/quickstart/fork-a-repo]
-of the repository. Once you've done it, clone the fork to your local computer.
+To record changes, use:
 
 ```
-  $ git clone https://github.com/<YOUR_USERNAME>/gf-core.git
+$ darcs record
 ```
 
-+ **Updating your copy —**
-Once you have cloned your fork, you need to set up the main repository as a remote:
+This creates a patch against the previous version and stores it in your
+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.
+
+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:
 
 ```
-  $ git remote add upstream https://github.com/GrammaticalFramework/gf-core.git
+$ darcs send -o mypatch.patch
+$ gzip mypatch.patch
 ```
 
-Then you can get the latest updates by running the following:
+(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 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 pull upstream master
+$ darcs get --lazy --set-scripts-executable user@www.grammaticalframework.org:/usr/local/www/GF/ gf
 ```
 
-+ **Recording local changes —**
-See Git tutorial on how to [record and push your changes https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository] to your fork.
-
-+ **Pull request —**
-When you want to contribute your changes to the main gf-core repository,
-[create a pull request https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request]
-from your fork.
+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.
 
 
+==== Updating your copy ====
 
-If you want to contribute to the RGL as well, do the same process for the RGL repository.
-
-
-== Compilation from source ==
-
-By now you should have installed Stack and Haskeline, and cloned the Git repository on your own computer, in a directory called ``gf-core``.
-
-=== Primary recommendation: use Stack ===
-
-Open a terminal, go to the top directory (``gf-core``), and type the following command.
+Get all new patches from the main repo:
 
 ```
-$ stack install
+$ darcs pull
 ```
 
-It will install GF and all necessary tools and libraries to do that.
+You can add ``-a`` to get all patches without answering yes/no to each patch.
 
 
-=== Alternative: use Cabal ===
-You can also install GF using Cabal, if you prefer Cabal to Stack. In that case, you may need to install some prerequisites yourself.
 
-The actual installation process is similar to Stack: open a terminal, go to the top directory (``gf-core``), and type the following command.
+==== 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 ==
+
+The build system of GF is based on //Cabal//, which is part of the
+Haskell Platform, so no extra steps are needed to install it. In the simplest
+case, all you need to do to compile and install GF, after downloading the
+source code as described above, is
+
+```
+$ cd gf
 $ cabal install
 ```
 
-//The old (potentially outdated) instructions for Cabal are moved to a [separate page ../doc/gf-developers-old-cabal.html]. If you run into trouble with ``cabal install``, you may want to take a look.//
+This will automatically download any additional Haskell libraries needed to
+build GF. If this is the first time you use Cabal, you might need to run
+``cabal update`` first, to update the list of available libraries.
 
-== Compiling GF with C runtime system support ==
+If you want more control, the process can also be split up into the usual
+//configure//, //build// and //install// steps.
 
-The C runtime system is a separate implementation of the PGF runtime services.
-It makes it possible to work with very large, ambiguous grammars, using
-probabilistic models to obtain probable parses. The C runtime system might
-also be easier to use than the Haskell runtime system on certain platforms,
-e.g. Android and iOS.
+=== Configure ===
 
-To install the C runtime system, go to the ``src/runtime/c`` directory.
-
-- **On Linux and Mac OS —**
-  You should have autoconf, automake, libtool and make.
-  If you are missing some of them, follow the
-  instructions in the [INSTALL https://github.com/GrammaticalFramework/gf-core/blob/master/src/runtime/c/INSTALL] file.
-
-  Once you have the required libraries, the easiest way to install the C runtime is to use the ``install.sh`` script. Just type
-
-  ``$ bash install.sh``
-
-  This will install the C header files and libraries need to write C programs
-  that use PGF grammars.
-
-%  If this doesn't work for you, follow the manual instructions in the [INSTALL https://github.com/GrammaticalFramework/gf-core/blob/master/src/runtime/c/INSTALL] file under your operating system.
-
-- **On other operating systems —** Follow the instructions in the
-[INSTALL https://github.com/GrammaticalFramework/gf-core/blob/master/src/runtime/c/INSTALL] file under your operating system.
-
-
-
-Depending on what you want to do with the C runtime, you can follow one or more of the following steps.
-
-=== Use the C runtime from another programming language ===[bindings]
-
-% **If you just want to use the C runtime from Python, Java, or Haskell, you don't need to change your GF installation.**
-
-- **What —**
-This is the most common use case for the C runtime: compile
-your GF grammars into PGF with the standard GF executable,
-and manipulate the PGFs from another programming language,
-using the bindings to the C runtime.
-
-
-- **How —**
-The Python, Java and Haskell bindings are found in the
-``src/runtime/{python,java,haskell-bind}`` directories,
-respecively. Compile them by following the instructions
-in the ``INSTALL`` or ``README`` files in those directories.
-
-The Python library can also be installed from PyPI using ``pip install pgf``.
-
-
-//If you are on Mac and get an error about ``clang`` version, you can try some of [these solutions https://stackoverflow.com/questions/63972113/big-sur-clang-invalid-version-error-due-to-macosx-deployment-target]—but be careful before removing any existing installations.//
-
-
-=== Use GF shell with C runtime support ===
-
-- **What —**
-If you want to use the GF shell with C runtime functionalities, then you need to (re)compile GF with special flags.
-
-The GF shell can be started with ``gf -cshell`` or ``gf -crun`` to use
-the C run-time system instead of the Haskell run-time system.
-Only limited functionality is available when running the shell in these
-modes (use the ``help`` command in the shell for details).
-
-(Re)compiling your GF with these flags will also give you
-Haskell bindings to the C runtime, as a library called ``PGF2``,
-but if you want Python or Java bindings, you need to do [the previous step #bindings].
-
-% ``PGF2``: a module to import in Haskell programs, providing a binding to the C run-time system.
-
-- **How —**
-If you use cabal, run the following command:
+During the configuration phase Cabal will check that you have all
+necessary tools and libraries needed for GF. The configuration is
+started by the command:
 
 ```
-cabal install -fc-runtime
+$ cabal configure
 ```
 
-from the top directory (``gf-core``).
+If you don't see any error message from the above command then you
+have everything that is needed for GF. You can also add the option
+``-v`` to see more details about the configuration.
 
-If you use stack, uncomment the following lines in the ``stack.yaml`` file:
+You can use ``cabal configure --help`` to get a list of configuration options.
+
+=== Build ===
+
+The build phase does two things. First it builds the GF compiler from
+the Haskell source code and after that it builds the GF Resource Grammar
+Library using the already build compiler.  The simplest command is:
 
 ```
-flags:
-   gf:
-     c-runtime: true
-extra-lib-dirs:
-   - /usr/local/lib
-```
-and then run ``stack install`` from the top directory (``gf-core``).
-
-
-//If you get an "``error while loading shared libraries``" when trying to run GF with C runtime, remember to declare your ``LD_LIBRARY_PATH``.//
-//Add ``export LD_LIBRARY_PATH="/usr/local/lib"`` to either your ``.bashrc`` or ``.profile``. You should now be able to start GF with C runtime.//
-
-
-=== Use GF server mode with C runtime ===
-
-- **What —**
-With this feature, ``gf -server`` mode is extended with new requests to call the C run-time
-system, e.g. ``c-parse``, ``c-linearize`` and ``c-translate``.
-
-- **How —**
-If you use cabal, run the following command:
-
-```
-cabal install -fc-runtime -fserver
-```
-from the top directory.
-
-If you use stack, add the following lines in the ``stack.yaml`` file:
-
-```
-flags:
-   gf:
-     c-runtime: true
-     server: true
-extra-lib-dirs:
-   - /usr/local/lib
+$ cabal build
 ```
 
-and then run ``stack install``, also from the top directory.
+Again you can add the option ``-v`` if you want to see more details.
+
+==== Parallel builds ====
+
+If you have Cabal>=1.20 you can enable parallel compilation by using
+
+```
+$ cabal build -j
+```
+
+or by putting a line
+```
+jobs: $ncpus
+```
+in your ``.cabal/config`` file. Cabal
+will pass this option to GHC when building the GF compiler, if you
+have GHC>=7.8.
+
+Cabal also passes ``-j`` to GF to enable parallel compilation of the
+Resource Grammar Library. This is done unconditionally to avoid
+causing problems for developers with Cabal<1.20. You can disable this
+by editing the last few lines in ``WebSetup.hs``.
 
 
+==== Partial builds ====
 
-== Compilation of RGL ==
+**NOTE**: The following doesn't work with recent versions of ``cabal``.
+%% // TH 2015-06-22
 
-As of 2018-07-26, the RGL is distributed separately from the GF compiler and runtimes.
+Sometimes you just want to work on the GF compiler and don't want to
+recompile the resource library after each change. In this case use
+this extended command:
 
-To get the source, follow the previous instructions on [how to clone a repository with Git #getting-source].
+```
+$ cabal build rgl-none
+```
 
-After cloning the RGL, you should have a directory named ``gf-rgl`` on your computer.
+The resource library could also be compiled in two modes: with present
+tense only and with all tenses. By default it is compiled with all
+tenses. If you want to use the library with only present tense you can
+compile it in this special mode with the command:
 
-=== Simple ===
-To install the RGL, you can use the following commands from within the ``gf-rgl`` repository:
+```
+$ cabal build present
+```
+
+You could also control which languages you want to be recompiled by
+adding the option ``langs=list``. For example the following command
+will compile only the English and the Swedish language:
+
+```
+$ cabal build langs=Eng,Swe
+```
+
+=== Install ===
+
+After you have compiled GF you need to install the executable and libraries
+to make the system usable.
+
+```
+$ cabal copy
+$ cabal register
+```
+
+This command installs the GF compiler for a single user, in the standard
+place used by Cabal.
+On Linux and Mac this could be ``$HOME/.cabal/bin``.
+On Mac it could also be ``$HOME/Library/Haskell/bin``.
+On Windows this is ``C:\Program Files\Haskell\bin``.
+
+The compiled GF Resource Grammar Library will be installed
+under the same prefix, e.g. in
+``$HOME/.cabal/share/gf-3.3.3/lib`` on Linux and
+in ``C:\Program Files\Haskell\gf-3.3.3\lib`` on Windows.
+
+If you want to install in some other place then use the ``--prefix``
+option during the configuration phase.
+
+=== Clean ===
+
+Sometimes you want to clean up the compilation and start again from clean
+sources. Use the clean command for this purpose:
+
+```
+$ cabal clean
+```
+
+
+%=== SDist ===
+%
+%You can use the command:
+%
+%% This does *NOT* include everything that is needed // TH 2012-08-06
+%```
+%$ cabal sdist
+%```
+%
+%to prepare archive with all source codes needed to compile GF.
+
+=== Known problems with Cabal ===
+
+Some versions of Cabal (at least version 1.16) seem to have a bug that can
+cause the following error:
+
+```
+Configuring gf-3.x...
+setup: Distribution/Simple/PackageIndex.hs:124:8-13: Assertion failed
+```
+
+The exact cause of this problem is unclear, but it seems to happen
+during the configure phase if the same version of GF is already installed,
+so a workaround is to remove the existing installation with
+
+```
+ghc-pkg unregister gf
+```
+
+You can check with ``ghc-pkg list gf`` that it is gone.
+
+== Compilation with make ==
+
+If you feel more comfortable with Makefiles then there is a thin Makefile
+wrapper arround Cabal for you. If you just type:
+```
+$ make
+```
+the configuration phase will be run automatically if needed and after that
+the sources will be compiled.
+
+%% cabal build rgl-none does not work with recent versions of Cabal
+%If you don't want to compile the resource library
+%every time then you can use:
+%```
+%$ make gf
+%```
+
+For installation use:
 ```
 $ 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:
+For cleaning:
 ```
-$ runghc Setup.hs ...
+$ make clean
 ```
-For more details see the [README https://github.com/GrammaticalFramework/gf-rgl/blob/master/README.md].
+%and to build source distribution archive run:
+%```
+%$ make sdist
+%```
 
-=== Haskell-free ===
-If you do not have Haskell installed, you can use the simple build script ``Setup.sh``
-(or ``Setup.bat`` for Windows).
+== Compiling GF with C run-time system support ==
+
+The C run-time system is a separate implementation of the PGF run-time services.
+It makes it possible to work with very large, ambiguous grammars, using
+probabilistic models to obtain probable parses. The C run-time system might
+also be easier to use than the Haskell run-time system on certain platforms,
+e.g. Android and iOS.
+
+To install the C run-time system, go to the ``src/runtime/c`` directory
+%and follow the instructions in the ``INSTALL`` file.
+and use the ``install.sh`` script:
+```
+bash setup.sh configure
+bash setup.sh build
+bash setup.sh install
+```
+This will install
+the C header files and libraries need to write C programs that use PGF grammars.
+Some example C programs are included in the ``utils`` subdirectory, e.g.
+``pgf-translate.c``.
+
+When the C run-time system is installed, you can install GF with C run-time
+support by doing
+
+```
+cabal install -fserver -fc-runtime
+```
+from the top directory. This give you three new things:
+
+- ``PGF2``: a module to import in Haskell programs, providing a binding to
+   the C run-time system.
+
+- The GF shell can be started with ``gf -cshell`` or ``gf -crun`` to use
+  the C run-time system instead of the Haskell run-time system.
+  Only limited functionality is available when running the shell in these
+  modes (use the ``help`` command in the shell for details).
+
+- ``gf -server`` mode is extended with new requests to call the C run-time
+   system, e.g. ``c-parse``, ``c-linearize`` and ``c-translate``.
+
+
+=== Python and Java bindings ===
+
+The C run-time system can also be used from Python and Java. Python and Java
+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.
 
 
 == Creating binary distribution packages ==
 
-The binaries are generated with Github Actions. More details can be viewed here:
+=== Creating .deb packages for Ubuntu ===
 
-https://github.com/GrammaticalFramework/gf-core/actions/workflows/build-binary-packages.yml
+This was tested on Ubuntu 14.04 for the release of GF 3.6, and the
+resulting ``.deb`` packages appears to work on Ubuntu 12.04, 13.10 and 14.04.
+For the release of GF 3.7, we generated ``.deb`` packages on Ubuntu 15.04 and
+tested them on Ubuntu 12.04 and 14.04.
 
+Under Ubuntu, Haskell executables are statically linked against other Haskell
+libraries, so the .deb packages are fairly self-contained.
 
-== Running the test suite ==
-
-The GF test suite is run with one of the following commands from the top directory:
+==== Preparations ====
 
 ```
-  $ cabal test
+sudo apt-get install dpkg-dev debhelper
 ```
 
-or
+==== Creating the package ====
+
+Make sure the ``debian/changelog`` starts with an entry that describes the
+version you are building. Then run
 
 ```
-  $ stack test
+make deb
 ```
 
+If get error messages about missing dependencies
+(e.g. ``autoconf``, ``automake``, ``libtool-bin``, ``python-dev``,
+``java-sdk``, ``txt2tags``)
+use ``apt-get intall`` to install them, then try again.
+
+
+=== Creating OS X Installer packages ===
+
+Run
+
+```
+make pkg
+```
+
+=== Creating binary tar distributions ===
+
+Run
+
+```
+make bintar
+```
+
+=== Creating .rpm packages for Fedora ===
+
+This is possible, but the procedure has not been automated.
+It involves using the cabal-rpm tool,
+
+```
+sudo yum install cabal-rpm
+```
+
+and following the Fedora guide
+[How to create an RPM package http://fedoraproject.org/wiki/How_to_create_an_RPM_package].
+
+Under Fedora, Haskell executables are dynamically linked against other Haskell
+libraries, so ``.rpm`` packages for all Haskell libraries that GF depends on
+are required. Most of them are already available in the Fedora distribution,
+but a few of them might have to be built and distributed along with
+the GF ``.rpm`` package.
+When building ``.rpm`` packages for GF 3.4, we also had to build ``.rpm``s for
+``fst`` and ``httpd-shed``.
+
+== Running the testsuite ==
+
+**NOTE:** The test suite has not been maintained recently, so expect many
+tests to fail.
+%% // TH 2012-08-06
+
+GF has testsuite. It is run with the following command:
+```
+$ 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
-testsuite is the ``testsuite/`` directory. It contains subdirectories
-which themselves contain GF batch files (with extension ``.gfs``).
-The above command searches the subdirectories of the ``testsuite/`` directory
-for files with extension ``.gfs`` and when it finds one, it is executed with
-the GF interpreter. The output of the script is stored in file with extension ``.out``
-and is compared with the content of the corresponding file with extension ``.gold``, if there is one.
+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
+.gfs and when it finds one it is executed with the GF interpreter.
+The output of the script is stored in file with extension .out and is compared
+with the content of the corresponding file with extension .gold, if there is one.
+If the contents are identical the command reports that the test was passed successfully.
+Otherwise the test had failed.
 
-Every time when you make some changes to GF that have to be tested,
-instead of writing the commands by hand in the GF shell, add them to one ``.gfs``
-file in the testsuite subdirectory where its ``.gf`` file resides and run the test.
-In this way you can use the same test later and we will be sure that we will not
-accidentally break your code later.
-
-**Test Outcome - Passed:** If the contents of the files with the ``.out`` extension
-are identical to their correspondingly-named files with the extension ``.gold``,
-the command will report that the tests passed successfully, e.g.
+Every time when you make some changes to GF that have to be tested, instead of
+writing the commands by hand in the GF shell, add them to one .gfs file in the testsuite
+and run the test. In this way you can use the same test later and we will be sure
+that we will not incidentaly break your code later.
 
+If you don't want to run the whole testsuite you can write the path to the subdirectory
+in which you are interested. For example:
 ```
- Running 1 test suites...
- Test suite gf-tests: RUNNING...
- Test suite gf-tests: PASS
- 1 of 1 test suites (1 of 1 test cases) passed.
+$ cabal test testsuite/compiler
 ```
-
-**Test Outcome - Failed:**  If there is a contents mismatch between the files
-with the ``.out`` extension and their corresponding files with the extension ``.gold``,
-the test diagnostics will show a fail and the areas that failed. e.g.
-
-```
-  testsuite/compiler/compute/Records.gfs: OK
-  testsuite/compiler/compute/Variants.gfs: FAIL
-  testsuite/compiler/params/params.gfs: OK
-  Test suite gf-tests: FAIL
-  0 of 1 test suites (0 of 1 test cases) passed.
-```
-
-The fail results overview is available in gf-tests.html which shows 4 columns:
-
-+ __Results__ - only areas that fail will appear. (Note: There are 3 failures in the gf-tests.html which are labelled as (expected). These failures should be ignored.)
-+ __Input__ - which is the test written in the .gfs file
-+ __Gold__ - the expected output from running the test set out in the .gfs file. This column refers to the contents from the .gold extension files.
-+ __Output__ - This column refers to the contents from the .out extension files which are generated as test output.
-After fixing the areas which fail, rerun the test command. Repeat the entire process of fix-and-test until the test suite passes before  submitting a pull request to include your changes.
+will run only the testsuite for the compiler.

doc/gf-editor-modes.md

@@ -1,75 +0,0 @@
-# Editor modes & IDE integration for GF
-
-We collect GF modes for various editors on this page. Contributions are welcome!
-
-## Emacs
-
-[gf.el](https://github.com/GrammaticalFramework/gf-emacs-mode) by Johan
-Bockgård provides syntax highlighting and automatic indentation and
-lets you run the GF Shell in an emacs buffer.  See installation
-instructions inside.
-
-## Atom
-
-[language-gf](https://atom.io/packages/language-gf), by John J. Camilleri
-
-## Visual Studio Code
-
-* [Grammatical Framework Language Server](https://marketplace.visualstudio.com/items?itemName=anka-213.gf-vscode) by Andreas Källberg.
-This provides syntax highlighting and a client for the Grammatical Framework language server. Follow the installation instructions in the link.
-* [Grammatical Framework](https://marketplace.visualstudio.com/items?itemName=GrammaticalFramework.gf-vscode) is a simpler extension
-without any external dependencies which provides only syntax highlighting.
-
-## Eclipse
-
-[GF Eclipse Plugin](https://github.com/GrammaticalFramework/gf-eclipse-plugin/), by John J. Camilleri
-
-## Gedit
-
-By John J. Camilleri
-
-Copy the file below to
-`~/.local/share/gtksourceview-3.0/language-specs/gf.lang` (under Ubuntu).
-
- * [gf.lang](../src/tools/gf.lang)
-
-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
-[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
-as a generic font (`application/x-tex-gf`) and I didn't want to risk
-messing any of that up.
- * This is a quick 5-minute job and might require some tweaking.
-[The GtkSourceView language definition tutorial](http://developer.gnome.org/gtksourceview/stable/lang-tutorial.html)
-is the place to start looking.
- * Contributions are welcome!
-
-## Geany
-
-By John J. Camilleri
-
-[Custom filetype](http://www.geany.org/manual/dev/index.html#custom-filetypes)
-config files for syntax highlighting in [Geany](http://www.geany.org/).
-
-For version 1.36 and above, copy one of the files below to
-`/usr/share/geany/filedefs/filetypes.GF.conf` (under Ubuntu).
-If you're using a version older than 1.36, copy the file to `/usr/share/geany/filetypes.GF.conf`.
-You will need to manually create the file.
-
- * [light-filetypes.GF.conf](../src/tools/light-filetypes.GF.conf)
- * [dark-filetypes.GF.conf](../src/tools/dark-filetypes.GF.conf)
-
-You will also need to edit the `filetype_extensions.conf` file and add the
-following line somewhere:
-
-```
-GF=*.gf
-```
-
-## Vim
-
-[vim-gf](https://github.com/gdetrez/vim-gf)

doc/gf-editor-modes.t2t

@@ -0,0 +1,75 @@
+Editor modes & IDE integration for GF
+
+
+%!style:../css/style.css
+%!options(html): --toc
+%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
+%!encoding:utf-8
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
+
+We collect GF modes for various editors on this page. Contributions are
+welcome!
+
+
+==Emacs==
+
+[gf.el ../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 http://www.grammaticalframework.org/eclipse/index.html]
+
+==Gedit==
+
+[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).
+
+- [gf.lang ../src/tools/gf.lang]
+
+
+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 
+  [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
+  as a generic font (``application/x-tex-gf``) and I didn't want to risk
+  messing any of that up.
+- This is a quick 5-minute job and might require some tweaking.
+  [The GtkSourceView language definition tutorial http://developer.gnome.org/gtksourceview/stable/lang-tutorial.html]
+  is the place to start looking.
+- Contributions are welcome!
+
+
+==Geany==
+
+[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``
+(under Ubuntu). You will need to manually create the file.
+
+- [light-filetypes.GF.conf ../src/tools/light-filetypes.GF.conf]
+- [dark-filetypes.GF.conf ../src/tools/dark-filetypes.GF.conf]
+
+
+You will also need to edit the ``filetype_extensions.conf`` file and add the
+following line somewhere:
+
+```
+GF=*.gf
+```
+
+
+==Vim==
+
+[vim-gf https://github.com/gdetrez/vim-gf]

doc/gf-faq.t2t

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

doc/gf-help-full.txt

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

doc/gf-people.html

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

doc/gf-people.md

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

doc/gf-quickstart.html

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

doc/gf-reference.html

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

doc/gf-reference.t2t

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

doc/gf-shell-reference.t2t

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

doc/gf-video-tutorials.md

@@ -1,35 +0,0 @@
----
-title: "Video tutorials"
----
-
-The GF [YouTube channel](https://www.youtube.com/channel/UCZ96DechSUVcXAhtOId9VVA) keeps a playlist of [all GF videos](https://www.youtube.com/playlist?list=PLrgqBB5thLeT15fUtJ8_Dtk8ppdtH90MK), and more specific playlists for narrower topics.
-If you make a video about GF, let us know and we'll add it to the suitable playlist(s)!
-
-- [General introduction to GF](#general-introduction-to-gf)
-- [Beginner resources](#beginner-resources)
-- [Resource grammar tutorials](#resource-grammar-tutorials)
-
-## General introduction to GF
-
-These videos introduce GF at a high level, and present some use cases.
-
-__Grammatical Framework: Formalizing the Grammars of the World__
-
-<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/x1LFbDQhbso" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
-
-__Aarne Ranta: Automatic Translation for Consumers and Producers__
-
-<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/An-AmFScw1o" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
-
-## Beginner resources
-
-These videos show how to install GF on your computer (Mac or Windows), and how to play with simple grammars in a [Jupyter notebook](https://github.com/GrammaticalFramework/gf-binder) (any platform, hosted at [mybinder.org](https://mybinder.org)).
-
-<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/videoseries?list=PLrgqBB5thLeRa8eViJJnjT8jBhxqCPMF2" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
-
-## Resource grammar tutorials
-
-These videos show incremental improvements to a [miniature version of the resource grammar](https://github.com/inariksit/comp-syntax-2020/tree/master/lab2/grammar/dummy#readme).
-They assume some prior knowledge of GF, roughly lessons 1-3 from the [GF tutorial](http://www.grammaticalframework.org/doc/tutorial/gf-tutorial.html).
-
-<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/videoseries?list=PLrgqBB5thLeTPkp88lnOmRtprCa8g0wX2" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

doc/index.html

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

doc/index.md

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

doc/python-api.html

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

doc/tutorial/gf-tutorial.t2t

@@ -8,8 +8,7 @@ December 2010 for GF 3.2
 % txt2tags --toc -ttex gf-tutorial.txt
 
 %!target:html
-%!encoding: utf-8
-%!options: --toc
+%!encoding: iso-8859-1
 
 %!postproc(tex) : "\\subsection\*" "\\newslide"
 %!preproc(tex): "#NEW" ""
@@ -618,32 +617,32 @@ and **semantic definitions**.
 
 
 
-% #NEW
-%
-% ==Slides==
-%
-% You can chop this tutorial into a set of slides by the command
-% ```
-%   htmls gf-tutorial.html
-% ```
-% where the program ``htmls`` is distributed with GF (see below), in
-%
-%   [``GF/src/tools/Htmls.hs`` http://grammaticalframework.org/src/tools/Htmls.hs]
-%
-% The slides will appear as a set of files beginning with ``01-gf-tutorial.htmls``.
-%
-% Internal links will not work in the slide format, except for those in the
-% upper left corner of each slide, and the links behind the "Contents" link.
+#NEW
+
+==Slides==
+
+You can chop this tutorial into a set of slides by the command
+```
+  htmls gf-tutorial.html
+```
+where the program ``htmls`` is distributed with GF (see below), in
+
+  [``GF/src/tools/Htmls.hs`` http://grammaticalframework.org/src/tools/Htmls.hs]
+
+The slides will appear as a set of files beginning with ``01-gf-tutorial.htmls``.
+
+Internal links will not work in the slide format, except for those in the
+upper left corner of each slide, and the links behind the "Contents" link.
 
 
 
 #NEW
 
-#Lchaptwo
-
 =Lesson 1: Getting Started with GF=
 
 
+#Lchaptwo
+
 Goals:
 - install and run GF
 - write the first GF grammar: a "Hello World" grammar in three languages
@@ -836,8 +835,8 @@ Finnish and an Italian concrete syntaxes:
     lin
       Hello recip = {s = "terve" ++ recip.s} ;
       World = {s = "maailma"} ;
-      Mum = {s = "äiti"} ;
-      Friends = {s = "ystävät"} ;
+      Mum = {s = "äiti"} ;
+      Friends = {s = "ystävät"} ;
   }
 
   concrete HelloIta of Hello = {
@@ -898,7 +897,7 @@ Parentheses are only needed for grouping.
 Parsing something that is not in grammar will fail:
 ```
   > parse "hello dad"
-  The parser failed at token 2: "dad"
+  Unknown words: dad
 
   > parse "world hello"
   no tree found
@@ -925,7 +924,7 @@ Default of the language flag (``-lang``): the last-imported concrete syntax.
 **Multilingual generation**:
 ```
   > parse -lang=HelloEng "hello friends" | linearize
-  terve ystävät
+  terve ystävät
   ciao amici
   hello friends
 ```
@@ -1037,10 +1036,9 @@ Application programs, using techniques from #Rchapeight:
 
 #NEW
 
-#Lchapthree
-
 =Lesson 2: Designing a grammar for complex phrases=
 
+#Lchapthree
 
 Goals:
 - build a larger grammar: phrases about food in English and Italian
@@ -1188,7 +1186,7 @@ use ``generate_trees = gt``.
   this wine is fresh
   this wine is warm
 ```
-The default **depth** is 5; the depth can be
+The default **depth** is 3; the depth can be
 set by using the ``depth`` flag:
 ```
   > generate_trees -depth=2 | l
@@ -1265,16 +1263,10 @@ Human eye may prefer to see a visualization: ``visualize_tree = vt``:
   > parse "this delicious cheese is very Italian" | visualize_tree
 ```
 The tree is generated in postscript (``.ps``) file. The ``-view`` option is used for
-telling what command to use to view the file.
-
-This works on Mac OS X:
+telling what command to use to view the file. Its default is ``"open"``, which works
+on Mac OS X. On Ubuntu Linux, one can write
 ```
-  > parse "this delicious cheese is very Italian" | visualize_tree -view=open
-```
-On Linux, one can use one of the following commands.
-```
-  > parse "this delicious cheese is very Italian" | visualize_tree -view=eog
-  > parse "this delicious cheese is very Italian" | visualize_tree -view=xdg-open
+  > parse "this delicious cheese is very Italian" | visualize_tree -view="eog"
 ```
 
 
@@ -1342,7 +1334,7 @@ Just (?) replace English words with their dictionary equivalents:
       Phrase, Item, Kind, Quality = {s : Str} ;
 
     lin
-      Is item quality = {s = item.s ++ "è" ++ quality.s} ;
+      Is item quality = {s = item.s ++ "č" ++ quality.s} ;
       This kind = {s = "questo" ++ kind.s} ;
       That kind = {s = "quel" ++ kind.s} ;
       QKind quality kind = {s = kind.s ++ quality.s} ;
@@ -1453,11 +1445,11 @@ linearizations in different languages:
   > gr -number=2 | l -treebank
 
   Is (That Cheese) (Very Boring)
-  quel formaggio è molto noioso
+  quel formaggio č molto noioso
   that cheese is very boring
 
   Is (That Cheese) Fresh
-  quel formaggio è fresco
+  quel formaggio č fresco
   that cheese is fresh
 ```
 
@@ -1479,14 +1471,14 @@ answer given in another language.
   You can interrupt the quiz by entering a line consisting of a dot ('.').
 
   this fish is warm
-  questo pesce è caldo
+  questo pesce č caldo
   > Yes.
   Score 1/1
 
   this cheese is Italian
-  questo formaggio è noioso
-  > No, not questo formaggio è noioso, but
-  questo formaggio è italiano
+  questo formaggio č noioso
+  > No, not questo formaggio č noioso, but
+  questo formaggio č italiano
 
   Score 1/2
   this fish is expensive
@@ -1739,13 +1731,6 @@ A new module can **extend** an old one:
       Pizza : Kind ;
   }
 ```
-Note that the extended grammar doesn't inherit the start
-category from the grammar it extends, so if you want to
-generate sentences with this grammar, you'll have to either
-add a startcat (e.g. ``flags startcat = Question ;``),
-or in the GF shell, specify the category to ``generate_random`` or ``geneate_trees``
-(e.g. ``gr -cat=Comment`` or ``gt -cat=Question``).
-
 Parallel to the abstract syntax, extensions can
 be built for concrete syntaxes:
 ```
@@ -1770,7 +1755,7 @@ Simultaneous extension and opening:
     lincat
       Question = SS ;
     lin
-      QIs item quality = ss (item.s ++ "è" ++ quality.s) ;
+      QIs item quality = ss (item.s ++ "č" ++ quality.s) ;
       Pizza = ss "pizza" ;
   }
 ```
@@ -1811,10 +1796,9 @@ where
 
 #NEW
 
-#Lchapfour
-
 =Lesson 3: Grammars with parameters=
 
+#Lchapfour
 
 Goals:
 - implement sophisticated linguistic structures:
@@ -2379,10 +2363,10 @@ in English, with special care taken of variations with the suffix
 
 + Implement the German **Umlaut** operation on word stems.
 The operation changes the vowel of the stressed stem syllable as follows:
-//a// to //ä//, //au// to //äu//, //o// to //ö//, and //u// to //ü//. You
+//a// to //ä//, //au// to //äu//, //o// to //ö//, and //u// to //ü//. You
 can assume that the operation only takes syllables as arguments. Test the
-operation to see whether it correctly changes //Arzt// to //Ärzt//,
-//Baum// to //Bäum//, //Topf// to //Töpf//, and //Kuh// to //Küh//.
+operation to see whether it correctly changes //Arzt// to //Ärzt//,
+//Baum// to //Bäum//, //Topf// to //Töpf//, and //Kuh// to //Küh//.
 
 
 
@@ -2488,19 +2472,24 @@ can be used to read a text and return for each word its analyses
 ```
 The command ``morpho_quiz = mq`` generates inflection exercises.
 ```
-  % gf alltenses/IrregFre.gfo
+  % gf -path=alltenses:prelude $GF_LIB_PATH/alltenses/IrregFre.gfo
 
   > morpho_quiz -cat=V
 
   Welcome to GF Morphology Quiz.
   ...
 
-  réapparaître : VFin VCondit  Pl  P2
-  réapparaitriez
-  > No, not réapparaitriez, but
-  réapparaîtriez
+  réapparaître : VFin VCondit  Pl  P2
+  réapparaitriez
+  > No, not réapparaitriez, but
+  réapparaîtriez
   Score 0/1
 ```
+To create a list for later use, use the command ``morpho_list = ml``
+```
+  > morpho_list -number=25 -cat=V | write_file exx.txt
+```
+
 
 
 
@@ -2573,7 +2562,7 @@ We need only number variation for the copula.
 ```
     copula : Number -> Str =
       \n -> case n of {
-        Sg => "è" ;
+        Sg => "č" ;
         Pl => "sono"
         } ;
 ```
@@ -2659,12 +2648,12 @@ The verb //switch off// is called a
 
 We can define transitive verbs and their combinations as follows:
 ```
-  lincat V2 = {s : Number => Str ; part : Str} ;
+  lincat TV = {s : Number => Str ; part : Str} ;
 
-  fun AppV2 : Item -> V2 -> Item -> Phrase ;
+  fun AppTV : Item -> TV -> Item -> Phrase ;
 
-  lin AppV2 subj v2 obj =
-    {s = subj.s ++ v2.s ! subj.n ++ obj.s ++ v2.part} ;
+  lin AppTV subj tv obj =
+    {s = subj.s ++ tv.s ! subj.n ++ obj.s ++ tv.part} ;
 ```
 
 **Exercise**. Define the language ``a^n b^n c^n`` in GF, i.e.
@@ -2730,11 +2719,11 @@ This topic will be covered in #Rseclexing.
 
 The symbol ``**`` is used for both record types and record objects.
 ```
-  lincat V2 = Verb ** {c : Case} ;
+  lincat TV = Verb ** {c : Case} ;
 
   lin Follow = regVerb "folgen" ** {c = Dative} ;
 ```
-``V2`` (transitive verb) becomes a **subtype** of ``Verb``.
+``TV`` becomes a **subtype** of ``Verb``.
 
 If //T// is a subtype of //R//, an object of //T// can be used whenever
 an object of //R// is required.
@@ -2765,11 +2754,7 @@ Thus the labels ``p1, p2,...`` are hard-coded.
 English indefinite article:
 ```
   oper artIndef : Str =
-     pre {
-       ("a" | "e" | "i" | "o") => "an" ;
-       _ => "a"
-     } ;
-
+    pre {"a" ; "an" / strs {"a" ; "e" ; "i" ; "o"}} ;
 ```
 Thus
 ```
@@ -2786,10 +2771,9 @@ Thus
 
 #NEW
 
-#Lchapfive
-
 =Lesson 4: Using the resource grammar library=
 
+#Lchapfive
 
 Goals:
 - navigate in the GF resource grammar library and use it in applications
@@ -2960,7 +2944,7 @@ We need the following combinations:
 ```
 We also need **lexical insertion**, to form phrases from single words:
 ```
-  mkCN : N -> CN ;
+  mkCN : N -> NP ;
   mkAP : A -> AP ;
 ```
 Naming convention: to construct a //C//, use a function ``mk``//C//.
@@ -2981,7 +2965,7 @@ can be built as follows:
 ```
   mkCl
     (mkNP these_Det
-       (mkCN (mkAP very_AdA (mkAP warm_A)) (mkCN pizza_N)))
+       (mkCN (mkAP very_AdA (mkAP warm_A)) (mkCN pizza_CN)))
     (mkAP italian_AP)
 ```
 The task now: to define the concrete syntax of ``Foods`` so that
@@ -3320,13 +3304,13 @@ we can write a **functor instantiation**,
   oper
     wine_N = mkN "Wein" ;
     pizza_N = mkN "Pizza" "Pizzen" feminine ;
-    cheese_N = mkN "Käse" "Käsen" masculine ;
+    cheese_N = mkN "Käse" "Käsen" masculine ;
     fish_N = mkN "Fisch" ;
     fresh_A = mkA "frisch" ;
-    warm_A = mkA "warm" "wärmer" "wärmste" ;
+    warm_A = mkA "warm" "wärmer" "wärmste" ;
     italian_A = mkA "italienisch" ;
     expensive_A = mkA "teuer" ;
-    delicious_A = mkA "köstlich" ;
+    delicious_A = mkA "köstlich" ;
     boring_A = mkA "langweilig" ;
   }
 ```
@@ -3377,11 +3361,11 @@ Lexicon instance
     cheese_N = mkN "juusto" ;
     fish_N = mkN "kala" ;
     fresh_A = mkA "tuore" ;
-    warm_A = mkA "lämmin" ;
+    warm_A = mkA "lämmin" ;
     italian_A = mkA "italialainen" ;
     expensive_A = mkA "kallis" ;
     delicious_A = mkA "herkullinen" ;
-    boring_A = mkA "tylsä" ;
+    boring_A = mkA "tylsä" ;
   }
 ```
 Functor instantiation
@@ -3629,10 +3613,9 @@ tenses and moods, e.g. the Romance languages.
 
 #NEW
 
-#Lchapsix
-
 =Lesson 5: Refining semantics in abstract syntax=
 
+#Lchapsix
 
 Goals:
 - include semantic conditions in grammars, by using
@@ -3642,7 +3625,7 @@ Goals:
   - semantic definitions
 
 These concepts are inherited from **type theory** (more precisely:
-constructive type theory, or Martin-Löf type theory).
+constructive type theory, or Martin-Löf type theory).
 
 Type theory is the basis **logical frameworks**.
 
@@ -3730,24 +3713,48 @@ Concrete syntax does not know if a category is a dependent type.
 ```
 Notice that the ``Kind`` argument is suppressed in linearization.
 
-Parsing with dependent types consists of two phases:
+Parsing with dependent types is performed in two phases:
 + context-free parsing
 + filtering through type checker
 
-Parsing a type-correct command works as expected:
 
+By just doing the first phase, the ``kind`` argument is not found:
 ```
   > parse "dim the light"
-  CAction light dim (DKindOne light)
+  CAction ? dim (DKindOne light)
 ```
-However, type-incorrect commands are rejected by the typecheck:
+Moreover, type-incorrect commands are not rejected:
 ```
   > parse "dim the fan"
-  The parsing is successful but the type checking failed with error(s):
-    Couldn't match expected type Device light
-       against the interred type Device fan
-    In the expression: DKindOne fan
+  CAction ? dim (DKindOne fan)
 ```
+The term ``?`` is a **metavariable**, returned by the parser
+for any subtree that is suppressed by a linearization rule.
+These are the same kind of metavariables as were used #Rsecediting
+to mark incomplete parts of trees in the syntax editor.
+
+
+
+#NEW
+
+===Solving metavariables===
+
+Use the command ``put_tree = pt`` with the option ``-typecheck``:
+```
+  > parse "dim the light" | put_tree -typecheck
+  CAction light dim (DKindOne light)
+```
+The ``typecheck`` process may fail, in which case an error message
+is shown and no tree is returned:
+```
+  > parse "dim the fan" | put_tree -typecheck
+
+  Error in tree UCommand (CAction ? 0 dim (DKindOne fan)) :
+    (? 0 <> fan) (? 0 <> light)
+```
+
+
+
 
 #NEW
 
@@ -3774,19 +3781,23 @@ to express Haskell-type library functions:
     \_,_,_,f,x,y -> f y x ;
 ```
 
+
 #NEW
 
 ===Dependent types: exercises===
 
 1. Write an abstract syntax module with above contents
 and an appropriate English concrete syntax. Try to parse the commands
-//dim the light// and //dim the fan//.
+//dim the light// and //dim the fan//, with and without ``solve`` filtering.
 
-2. Perform random and exhaustive generation.
+
+2. Perform random and exhaustive generation, with and without
+``solve`` filtering.
 
 3. Add some device kinds and actions to the grammar.
 
 
+
 #NEW
 
 ==Proof objects==
@@ -3896,6 +3907,7 @@ fun
 Classes for new actions can be added incrementally.
 
 
+
 #NEW
 
 ==Variable bindings==
@@ -4164,11 +4176,11 @@ Type checking can be invoked with ``put_term -transform=solve``.
 
 #NEW
 
-#Lchapseven
-
 ==Lesson 6: Grammars of formal languages==
 
 
+#Lchapseven
+
 Goals:
 - write grammars for formal languages (mathematical notation, programming languages)
 - interface between formal and natural langauges
@@ -4183,7 +4195,6 @@ We construct a calculator with addition, subtraction, multiplication, and
 division of integers.
 ```
   abstract Calculator = {
-  flags startcat = Exp ;
 
   cat Exp ;
 
@@ -4210,7 +4221,7 @@ We begin with a
 concrete syntax that always uses parentheses around binary
 operator applications:
 ```
-  concrete CalculatorP of Calculator = open Prelude in {
+  concrete CalculatorP of Calculator = {
 
   lincat
     Exp = SS ;
@@ -4504,10 +4515,9 @@ point literals as arguments.
 
 #NEW
 
-#Lchapeight
-
 =Lesson 7: Embedded grammars=
 
+#Lchapeight
 
 Goals:
 - use grammars as parts of programs written in Haskell and JavaScript
@@ -4591,7 +4601,7 @@ in any multilingual grammar between any languages in the grammar.
 module Main where
 
 import PGF
-import System.Environment (getArgs)
+import System (getArgs)
 
 main :: IO ()
 main = do
@@ -4628,7 +4638,7 @@ output. Therefore it can be a part of a pipe and read and write files.
 The simplest way to translate is to ``echo`` input to the program:
 ```
   % echo "this wine is delicious" | ./trans Food.pgf
-  questo vino è delizioso
+  questo vino č delizioso
 ```
 The result is given in all languages except the input language.
 
@@ -4721,6 +4731,10 @@ abstract Query = {
 
 To make it easy to define a transfer function, we export the
 abstract syntax to a system of Haskell datatypes:
+```
+  % gf --output-format=haskell Query.pgf
+```
+It is also possible to produce the Haskell file together with PGF, by
 ```
   % gf -make --output-format=haskell QueryEng.gf
 ```
@@ -4796,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
@@ -4943,12 +4957,12 @@ syntax name. This file contains the multilingual grammar as a JavaScript object.
 ===Using the JavaScript grammar===
 
 To perform parsing and linearization, the run-time library
-``gflib.js`` is used. It is included in ``/src/runtime/javascript/``, together with
+``gflib.js`` is used. It is included in ``GF/lib/javascript/``, together with
 some other JavaScript and HTML files; these files can be used
 as templates for building applications.
 
 An example of usage is
-[``translator.html`` ../../src/runtime/javascript/translator.html],
+[``translator.html`` http://grammaticalframework.org:41296],
 which is in fact initialized with
 a pointer to the Food grammar, so that it provides translation between the English
 and Italian grammars:

doc/txt2html.sh

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

download.html

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

download/encoding-change.t2t

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

download/gfc

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+prefix="/usr/local"
+
+case "i386-apple-darwin9.3.0" in
+      *-cygwin)
+          prefix=`cygpath -w "$prefix"`;;
+esac
+
+exec_prefix="${prefix}"
+GF_BIN_DIR="${exec_prefix}/bin"
+GF_DATA_DIR="${prefix}/share/GF-3.0-beta"
+
+GFBIN="$GF_BIN_DIR/gf"
+
+if [ ! -x "${GFBIN}" ]; then
+   GFBIN=`which gf`
+fi
+
+if [ ! -x "${GFBIN}" ]; then
+    echo "gf not found."
+    exit 1
+fi
+
+exec $GFBIN --batch "$@"

download/index-3.1.6.html

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

download/index-3.1.6.t2t

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

download/index-3.10.md

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

download/index-3.11.md

@@ -1,194 +0,0 @@
----
-title: Grammatical Framework Download and Installation
-date: 25 July 2021
----
-
-**GF 3.11** was released on 25 July 2021.
-
-What's new? See the [release notes](release-3.11.html).
-
-#### Note: GF core and the RGL
-
-The following instructions explain how to install **GF core**, i.e. the compiler, shell and run-time systems.
-Obtaining the **Resource Grammar Library (RGL)** is done separately; see the section at the bottom of this page.
-
----
-
-## Installing from a binary package
-
-Binary packages are available for Debian/Ubuntu, macOS, and Windows and include:
-
-- GF shell and grammar compiler
-- `gf -server` mode
-- C run-time system
-- Java & Python bindings to the C run-time system
-
-Unlike in previous versions, the binaries **do not** include the RGL.
-
-[Binary packages on GitHub](https://github.com/GrammaticalFramework/gf-core/releases/tag/3.11)
-
-#### Debian/Ubuntu
-
-There are two versions: `gf-3.11-ubuntu-18.04.deb` for Ubuntu 18.04 (Cosmic), and `gf-3.11-ubuntu-20.04.deb` for Ubuntu 20.04 (Focal).
-
-To install the package use:
-
-```
-sudo apt-get install ./gf-3.11-ubuntu-*.deb
-```
-
-<!-- The Ubuntu `.deb` packages should work on Ubuntu 16.04, 18.04 and similar Linux distributions. -->
-
-#### macOS
-
-To install the package, just double-click it and follow the installer instructions.
-
-The packages should work on at least Catalina and Big Sur.
-
-#### Windows
-
-To install the package, unpack it anywhere.
-
-You will probably need to update the `PATH` environment variable to include your chosen install location.
-
-For more information, see [Using GF on Windows](https://www.grammaticalframework.org/~inari/gf-windows.html) (latest updated for Windows 10).
-
-## Installing from Hackage
-
-_Instructions applicable for macOS, Linux, and WSL2 on Windows._
-
-[GF is on Hackage](http://hackage.haskell.org/package/gf), so under
-normal circumstances the procedure is fairly simple:
-
-```
-cabal update
-cabal install gf-3.11
-```
-
-### Notes
-
-**GHC version**
-
-The GF source code is known to be compilable with GHC versions 7.10 through to 8.10.
-
-**Obtaining Haskell**
-
-There are various ways of obtaining Haskell, including:
-
-- ghcup
-    1.  Install from https://www.haskell.org/ghcup/
-    2.  `ghcup install ghc 8.10.4`
-    3.  `ghcup set ghc 8.10.4`
-- Haskell Platform https://www.haskell.org/platform/
-- Stack https://haskellstack.org/
-
-
-**Installation location**
-
-The above steps install GF for a single user.
-The executables are put in `$HOME/.cabal/bin` (or on macOS in `$HOME/Library/Haskell/bin`),
-so you might want to add this directory to your path (in `.bash_profile` or similar):
-
-```
-PATH=$HOME/.cabal/bin:$PATH
-```
-
-**Haskeline**
-
-GF uses [`haskeline`](http://hackage.haskell.org/package/haskeline), which
-on Linux depends on some non-Haskell libraries that won't be installed
-automatically by Cabal, and therefore need to be installed manually.
-Here is one way to do this:
-
-- On Ubuntu: `sudo apt-get install libghc-haskeline-dev`
-- On Fedora: `sudo dnf install ghc-haskeline-devel`
-
-## Installing from source code
-
-**Obtaining**
-
-To obtain the source code for the **release**,
-download it from [GitHub](https://github.com/GrammaticalFramework/gf-core/releases).
-
-Alternatively, to obtain the **latest version** of the source code:
-
-1. If you haven't already, clone the repository with:
-```
-git clone https://github.com/GrammaticalFramework/gf-core.git
-```
-2. If you've already cloned the repository previously, update with:
-```
-git pull
-```
-
-
-**Installing**
-
-You can then install with:
-```
-cabal install
-```
-
-or, if you're a Stack user:
-
-```
-stack install
-```
-
-<!--The above notes for installing from source apply also in these cases.-->
-For more info on working with the GF source code, see the
-[GF Developers Guide](../doc/gf-developers.html).
-
-For macOS Sequoia, you need to downgrade the LLVM package, see instructions [here](https://github.com/GrammaticalFramework/gf-core/issues/172#issuecomment-2599365457).
-
-## Installing the Python bindings from PyPI
-
-The Python library is available on PyPI as `pgf`, so it can be installed using:
-
-```
-pip install pgf
-```
-
-We provide binary wheels for Linux and macOS, which include the C runtime and are ready-to-go.
-If there is no binary distribution for your platform, this will install the source tarball,
-which will attempt to build the binding during installation,
-and requires the GF C runtime to be installed on your system.
-
----
-
-## Installing the RGL from a binary release
-
-Binary releases of the RGL are made available on [GitHub](https://github.com/GrammaticalFramework/gf-rgl/releases).
-In general the steps to follow are:
-
-1. Download a binary release and extract it somewhere on your system.
-2. Set the environment variable `GF_LIB_PATH` to point to wherever you extracted the RGL.
-
-## Installing the RGL from source
-
-To compile the RGL, you will need to have GF already installed and in your path.
-
-1. Obtain the RGL source code, either by:
-  - cloning with `git clone https://github.com/GrammaticalFramework/gf-rgl.git`
-  - downloading a source archive [here](https://github.com/GrammaticalFramework/gf-rgl/archive/master.zip)
-2. Run `make` in the source code folder.
-
-For more options, see the [RGL README](https://github.com/GrammaticalFramework/gf-rgl/blob/master/README.md).
-
----
-
-## Older releases
-
-- [GF 3.10](index-3.10.html) (December 2018)
-- [GF 3.9](index-3.9.html) (August 2017)
-- [GF 3.8](index-3.8.html) (June 2016)
-- [GF 3.7.1](index-3.7.1.html) (October 2015)
-- [GF 3.7](index-3.7.html) (June 2015)
-- [GF 3.6](index-3.6.html) (June 2014)
-- [GF 3.5](index-3.5.html) (August 2013)
-- [GF 3.4](index-3.4.html) (January 2013)
-- [GF 3.3.3](index-3.3.3.html) (March 2012)
-- [GF 3.3](index-3.3.html) (October 2011)
-- [GF 3.2.9](index-3.2.9.html) source-only snapshot (September 2011)
-- [GF 3.2](index-3.2.html) (December 2010)
-- [GF 3.1.6](index-3.1.6.html) (April 2010)

download/index-3.12.md

@@ -1,184 +0,0 @@
----
-title: Grammatical Framework Download and Installation
-date: 8 August 2025
----
-
-**GF 3.12** was released on 8 August 2025.
-
-What's new? See the [release notes](release-3.12.html).
-
-#### Note: GF core and the RGL
-
-The following instructions explain how to install **GF core**, i.e. the compiler, shell and run-time systems.
-Obtaining the **Resource Grammar Library (RGL)** is done separately; see the section [at the bottom of this page](#installing-the-rgl-from-a-binary-release).
-
----
-
-## Installing from a binary package
-
-Binary packages are available for Debian/Ubuntu, macOS, and Windows and include:
-
-- GF shell and grammar compiler
-- `gf -server` mode
-- C run-time system
-- Python bindings to the C run-time system
-
-[Binary packages on GitHub](https://github.com/GrammaticalFramework/gf-core/releases/tag/3.12)
-
-#### Debian/Ubuntu
-
-The package targets Ubuntu 24.04 (Noble).
-To install it, use:
-
-```
-sudo apt install ./gf-3.12-ubuntu-24.04.deb 
-```
-
-#### macOS
-
-To install the package, just double-click it and follow the installer instructions.
-
-#### Windows
-
-To install the package:
-
-1. unpack it anywhere and take note of the full path to the folder containing the `.exe` file. 
-2. add it to the `PATH` environment variable
-
-For more information, see [Using GF on Windows](https://www.grammaticalframework.org/~inari/gf-windows.html) (latest updated for Windows 10).
-
-## Installing from Hackage
-
-_Instructions applicable for macOS, Linux, and WSL2 on Windows._
-
-[GF is on Hackage](http://hackage.haskell.org/package/gf), so under
-normal circumstances the procedure is fairly simple:
-
-```
-cabal update
-cabal install gf-3.12
-```
-
-### Notes
-
-#### GHC version
-
-The GF source code is known to be compilable with GHC versions 7.10 through to 9.6.7.
-
-#### Obtaining Haskell
-
-There are various ways of obtaining Haskell, including:
-
-- ghcup
-    1. Install from https://www.haskell.org/ghcup/
-    2. `ghcup install ghc 9.6.7`
-    3. `ghcup set ghc 9.6.7`
-- Stack: https://haskellstack.org/
-
-
-#### Installation location
-
-The above steps install GF for a single user.
-The executables are put in `$HOME/.cabal/bin` (or on macOS in `$HOME/Library/Haskell/bin`),
-so you might want to add this directory to your path (in `.bash_profile` or similar):
-
-```
-PATH=$HOME/.cabal/bin:$PATH
-```
-
-#### Haskeline
-
-GF uses [`haskeline`](http://hackage.haskell.org/package/haskeline), which
-on Linux depends on some non-Haskell libraries that won't be installed
-automatically by Cabal, and therefore need to be installed manually.
-Here is one way to do this:
-
-- On Ubuntu: `sudo apt-get install libghc-haskeline-dev`
-- On Fedora: `sudo dnf install ghc-haskeline-devel`
-
-## Installing from source code
-
-### Obtaining
-
-To obtain the source code for the **release**,
-download it from [GitHub](https://github.com/GrammaticalFramework/gf-core/releases).
-
-Alternatively, to obtain the **latest version** of the source code:
-
-1. If you haven't already, clone the repository with:
-```
-git clone https://github.com/GrammaticalFramework/gf-core.git
-```
-2. If you've already cloned the repository previously, update with:
-```
-git pull
-```
-
-### Installing
-
-You can then install with:
-```
-cabal install
-```
-
-or, if you're a Stack user:
-
-```
-stack install
-```
-
-<!--The above notes for installing from source apply also in these cases.-->
-For more info on working with the GF source code, see the
-[GF Developers Guide](../doc/gf-developers.html).
-
-## Installing the Python bindings from PyPI
-
-The Python library is available on PyPI as `pgf`, so it can be installed using:
-
-```
-pip install pgf
-```
-
-If this doesn't work, you will need to install the C runtime manually; see the instructions [here](https://www.grammaticalframework.org/doc/gf-developers.html#toc12).
-
----
-
-## Installing the RGL from a binary release
-
-Binary releases of the RGL are made available on [GitHub](https://github.com/GrammaticalFramework/gf-rgl/releases).
-In general the steps to follow are:
-
-1. Download a binary release and extract it somewhere on your system.
-2. Set the environment variable `GF_LIB_PATH` to point to wherever you extracted the RGL.
-
-For more information, see [Using GF on Windows](https://www.grammaticalframework.org/~inari/gf-windows.html) (latest updated for Windows 10).
-
-## Installing the RGL from source
-
-To compile the RGL, you will need to have GF already installed and in your path.
-
-1. Obtain the RGL source code, either by:
-  - cloning with `git clone https://github.com/GrammaticalFramework/gf-rgl.git`
-  - downloading a source archive [here](https://github.com/GrammaticalFramework/gf-rgl/archive/master.zip)
-2. Run `make` in the source code folder.
-
-For more options, see the [RGL README](https://github.com/GrammaticalFramework/gf-rgl/blob/master/README.md).
-
----
-
-## Older releases
-
-- [GF 3.11](index-3.11.html) (July 2021)
-- [GF 3.10](index-3.10.html) (December 2018)
-- [GF 3.9](index-3.9.html) (August 2017)
-- [GF 3.8](index-3.8.html) (June 2016)
-- [GF 3.7.1](index-3.7.1.html) (October 2015)
-- [GF 3.7](index-3.7.html) (June 2015)
-- [GF 3.6](index-3.6.html) (June 2014)
-- [GF 3.5](index-3.5.html) (August 2013)
-- [GF 3.4](index-3.4.html) (January 2013)
-- [GF 3.3.3](index-3.3.3.html) (March 2012)
-- [GF 3.3](index-3.3.html) (October 2011)
-- [GF 3.2.9](index-3.2.9.html) source-only snapshot (September 2011)
-- [GF 3.2](index-3.2.html) (December 2010)
-- [GF 3.1.6](index-3.1.6.html) (April 2010)

download/index-3.2.9.t2t

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

download/index-3.2.t2t

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

download/index-3.3.3.t2t

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

download/index-3.3.t2t

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

download/index-3.4.t2t

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

download/index-3.5.t2t

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

download/index-3.6.t2t

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

download/index-3.7.1.t2t

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

download/index-3.7.t2t

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

download/index-3.9.t2t

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

download/index.html

@@ -1,8 +0,0 @@
-<html>
-<head>
-  <meta http-equiv="refresh" content="0; URL=/download/index-3.11.html" />
-</head>
-<body>
-  You are being redirected to <a href="index-3.12.html">the current version</a> of this page.
-</body>
-</html>

download/index.t2t

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

download/old-index.html

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

download/release-3.1.6.html

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

download/release-3.1.6.txt

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

download/release-3.10.md

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

download/release-3.11.md

@@ -1,43 +0,0 @@
----
-title: GF 3.11 Release Notes
-date: 25 July 2021
----
-
-## Installation
-
-See the [download page](index-3.11.html).
-
-## What's new
-
-From this release, the binary GF core packages do not contain the RGL.
-The RGL's release cycle is now completely separate from GF's. See [RGL releases](https://github.com/GrammaticalFramework/gf-rgl/releases).
-
-Over 500 changes have been pushed to GF core
-since the release of GF 3.10 in December 2018.
-
-## General
-
-- Make the test suite work again.
-- Compatibility with new versions of GHC, including multiple Stack files for the different versions.
-- Support for newer version of Ubuntu 20.04 in the precompiled binaries.
-- Updates to build scripts and CI workflows.
-- Bug fixes and code cleanup.
-
-## GF compiler and run-time library
-
-- Add CoNLL output to `visualize_tree` shell command.
-- Add canonical GF as output format in the compiler.
-- Add PGF JSON as output format in the compiler.
-- Deprecate JavaScript runtime in favour of updated [TypeScript runtime](https://github.com/GrammaticalFramework/gf-typescript).
-- Improvements in time & space requirements when compiling certain grammars.
-- Improvements to Haskell export.
-- Improvements to the GF shell.
-- Improvements to canonical GF compilation.
-- Improvements to the C runtime.
-- Improvements to `gf -server` mode.
-- Clearer compiler error messages.
-
-## Other
-
-- Web page and documentation improvements.
-- Add WordNet module to GFSE.

download/release-3.12.md

@@ -1,37 +0,0 @@
----
-title: GF 3.12 Release Notes
-date: 08 August 2025
----
-
-## Installation
-
-See the [download page](index-3.12.html).
-
-## What's new
-This release adds support for Apple Silicon M1 Mac computers and newer versions of GHC, along with various improvements and bug fixes.
-
-Over 70 commits have been merged to gf-core since the release of GF 3.11 in July 2021.
-
-## General
-- Support for ARM, allowing to run GF on Mac computers with Apple Silicon M1
-- Support for newer versions of GHC (8.10.7, 9.0.2, 9.2.4, 9.4, 9.6.7)
-- Support compiling with Nix
-- Better error messages
-- Improvements to several GF shell commands
-- Several bug fixes and performance improvements
-- Temporarily dropped support for Java bindings
-
-## GF compiler and run-time library
-- Syntactic sugar for table update: `table {cases ; vvv => t \! vvv}.t` can now be written as `t ** { cases }`  
-- Adjust the `-view` command depending on the OS
-- Improve output of the `visualize_dependencies` (`vd`) command for large dependency trees
-- Reintroduce syntactic transfer with `pt -transfer` and fix a bug in `pt -compute`
-- Bug fix: apply `gt` to all arguments when piped
-- Fix many "Invalid character" messages by always encoding GF files in UTF-8
-- Improve performance with long extend-lists
-- Improve syntax error messages
-- Add support for BIND tokens in the Python bindings
-- Allow compilation with emscripten
-
-## Other
-- Add support for Visual Studio Code

download/release-3.2.t2t

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

download/release-3.3.3.t2t

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

download/release-3.3.t2t

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

download/release-3.4.t2t

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

download/release-3.5.t2t

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

download/release-3.6.t2t

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

download/release-3.7.1.t2t

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

download/release-3.7.t2t

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

download/release-3.8.t2t

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

download/release-3.9.t2t

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

eclipse/images/.htaccess

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

eclipse/index.html

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

examples/READ_ME

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

examples/app/App.gf

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

examples/app/AppBul.gf

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

examples/app/AppCat.gf

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

examples/app/AppChi.gf

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

examples/app/AppDut.gf

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

examples/app/AppEng.gf

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

examples/app/AppEst.gf

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

examples/app/AppFin.gf

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