Update documentation for release 3.11

Merge pull request #129 from anka-213/automate-release
Automatically upload release assets after building for release
2021-07-25 15:37:12 +08:00 · 2021-07-25 08:20:41 +02:00 · 2021-07-25 11:08:21 +08:00 · 2021-07-25 10:43:36 +08:00 · 2021-07-25 10:30:49 +08:00 · 2021-07-25 04:15:07 +02:00
1218 changed files with 251361 additions and 50178 deletions
--- a/.ghci
+++ b/.ghci
@@ -0,0 +1,2 @@
+:set -isrc/compiler -isrc/binary -isrc/runtime/haskell -isrc/server -isrc/example-based -isrc/server/transfer -idist/build/autogen -idist/build
+:set -fwarn-unused-imports -optP-DSERVER_MODE -optP-DUSE_INTERRUPT -optP-DCC_LAZY -optP-include -optPdist/build/autogen/cabal_macros.h -odir dist/build/gf/gf-tmp -hidir dist/build/gf/gf-tmp -stubdir dist/build/gf/gf-tmp
--- a/.github/workflows/build-all-versions.yml
+++ b/.github/workflows/build-all-versions.yml
@@ -0,0 +1,96 @@
+# 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:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        cabal: ["latest"]
+        ghc:
+          - "8.6.5"
+          - "8.8.3"
+          - "8.10.1"
+        exclude:
+          - os: macos-latest
+            ghc: 8.8.3
+          - os: macos-latest
+            ghc: 8.6.5
+          - os: windows-latest
+            ghc: 8.8.3
+          - os: windows-latest
+            ghc: 8.6.5
+
+    steps:
+    - uses: actions/checkout@v2
+      if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
+
+    - uses: haskell/actions/setup@v1
+      id: setup-haskell-cabal
+      name: Setup Haskell
+      with:
+        ghc-version: ${{ matrix.ghc }}
+        cabal-version: ${{ matrix.cabal }}
+
+    - name: Freeze
+      run: |
+        cabal freeze
+
+    - uses: actions/cache@v1
+      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: ubuntu-latest
+    strategy:
+      matrix:
+        stack: ["latest"]
+        ghc: ["7.10.3","8.0.2", "8.2.2", "8.4.4", "8.6.5", "8.8.4"]
+        # ghc: ["8.8.3"]
+
+    steps:
+    - uses: actions/checkout@v2
+      if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
+
+    - uses: haskell/actions/setup@v1
+      name: Setup Haskell Stack
+      with:
+        ghc-version: ${{ matrix.ghc }}
+        stack-version: 'latest'
+        enable-stack: true
+
+    - uses: actions/cache@v1
+      name: Cache ~/.stack
+      with:
+        path: ~/.stack
+        key: ${{ runner.os }}-${{ matrix.ghc }}-stack
+
+    - name: Build
+      run: |
+        stack build --system-ghc --stack-yaml stack-ghc${{ matrix.ghc }}.yaml
+        # stack build --system-ghc --test --bench --no-run-tests --no-run-benchmarks
+
+    - name: Test
+      run: |
+        stack test --system-ghc --stack-yaml stack-ghc${{ matrix.ghc }}.yaml
--- a/.github/workflows/build-binary-packages.yml
+++ b/.github/workflows/build-binary-packages.yml
@@ -0,0 +1,230 @@
+name: Build Binary Packages
+
+on:
+  workflow_dispatch:
+  release: 
+    types: ["created"]
+
+jobs:
+
+# ---
+
+  ubuntu:
+    name: Build Ubuntu package
+    strategy:
+      matrix:
+        os:
+        - ubuntu-18.04
+        - ubuntu-20.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: actions/setup-haskell@v1
+    #   id: setup-haskell-cabal
+    #   with:
+    #     ghc-version: ${{ matrix.ghc }}
+    #     cabal-version: ${{ matrix.cabal }}
+
+    - name: Install build tools
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y \
+          make \
+          dpkg-dev \
+          debhelper \
+          haskell-platform \
+          libghc-json-dev \
+          python-dev \
+          default-jdk \
+          libtool-bin
+
+    - name: Build package
+      run: |
+        make deb
+
+    - name: Copy package
+      run: |
+        cp ../gf_*.deb dist/
+
+    - name: Upload artifact
+      uses: actions/upload-artifact@v2
+      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: ["8.6.5"]
+        cabal: ["2.4"]
+        os: ["macos-10.15"]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Setup Haskell
+      uses: actions/setup-haskell@v1
+      id: setup-haskell-cabal
+      with:
+        ghc-version: ${{ matrix.ghc }}
+        cabal-version: ${{ matrix.cabal }}
+
+    - name: Install build tools
+      run: |
+        brew install \
+          automake
+        cabal v1-install alex happy
+
+    - 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@v2
+      with:
+        name: gf-${{ github.event.release.tag_name }}-macos
+        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: ["8.6.5"]
+        cabal: ["2.4"]
+        os: ["windows-2019"]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Setup MSYS2
+      uses: msys2/setup-msys2@v2
+      with:
+        install: >-
+          base-devel
+          gcc
+          python-devel
+
+    - 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: |
+        export JDKPATH=/c/hostedtoolcache/windows/Java_Adopt_jdk/8.0.292-10/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
+
+    - name: Build Python bindings
+      shell: msys2 {0}
+      env:
+        EXTRA_INCLUDE_DIRS: /mingw64/include
+        EXTRA_LIB_DIRS: /mingw64/lib
+      run: |
+        cd src/runtime/python
+        python setup.py build
+        python setup.py install
+        cp /usr/lib/python3.9/site-packages/pgf* /c/tmp-dist/python
+
+    - name: Setup Haskell
+      uses: actions/setup-haskell@v1
+      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 --only-dependencies -fserver
+        cabal configure -fserver
+        cabal build
+        copy dist\build\gf\gf.exe C:\tmp-dist
+
+    - name: Upload artifact
+      uses: actions/upload-artifact@v2
+      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
--- a/.github/workflows/build-python-package.yml
+++ b/.github/workflows/build-python-package.yml
@@ -0,0 +1,98 @@
+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-18.04, macos-10.15]
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - uses: actions/setup-python@v1
+      name: Install Python
+      with:
+        python-version: '3.7'
+
+    - name: Install cibuildwheel
+      run: |
+        python -m pip install git+https://github.com/joerick/cibuildwheel.git@main
+
+    - name: Install build tools for OSX
+      if: startsWith(matrix.os, 'macos')
+      run: |
+        brew install automake
+
+    - 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 && make install
+      run: |
+        python -m cibuildwheel src/runtime/python --output-dir wheelhouse
+
+    - uses: actions/upload-artifact@v2
+      with:
+        path: ./wheelhouse
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions/setup-python@v2
+        name: Install Python
+        with:
+          python-version: '3.7'
+
+      - name: Build sdist
+        run: cd src/runtime/python && python setup.py sdist
+
+      - uses: actions/upload-artifact@v2
+        with:
+          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@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.x'
+
+      - name: Install twine
+        run: pip install twine
+
+      - uses: actions/download-artifact@v2
+        with:
+          name: artifact
+          path: ./dist
+
+      - name: Publish
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.pypi_password }}
+        run: |
+          (cd ./src/runtime/python && curl -I --fail https://pypi.org/project/$(python setup.py --name)/$(python setup.py --version)/) || twine upload dist/*
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,75 @@
+*.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
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,14 @@
+sudo: required
+
+language: c
+
+services:
+  - docker
+
+before_install:
+  - docker pull odanoburu/gf-src:3.9
+
+script:
+  - |
+    docker run --mount src="$(pwd)",target=/home/gfer,type=bind odanoburu/gf-src:3.9 /bin/bash -c "cd /home/gfer/src/runtime/c &&
+    autoreconf -i && ./configure && make && make install ; cd /home/gfer ; cabal install -fserver -fc-runtime --extra-lib-dirs='/usr/local/lib'"
--- a/557
+++ b/557
@@ -0,0 +1,557 @@
+Grammatical Framework is a software package consisting of several different
+components. The common wish of the GF development team is to provide software
+that is easy to use for everyone with no restrictions. Still in some cases
+we want to reserve some rights, in other cases the software that we provide
+is derived from someone else's work and we have to respect the rights for the
+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.
+
+  - the GF runtime in src/runtime is under dual GNU LESSER GENERAL PUBLIC LICENSE and BSD LICENSE
+
+The rest of this document contains copies of the GPL, LGPL and BSD licenses
+which are applicable to the different components of Grammatical Framework
+as it is described above.
+
+
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
+
+
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+
+
+
+		    BSD LICENSE
+
+Copyright (c) 1998, Grammatical Framework
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/70
+++ b/70
@@ -0,0 +1,70 @@
+.PHONY: all build install doc clean html deb pkg bintar 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
+
+build: dist/setup-config
+	${CMD} ${CMD_PFX}build
+
+install:
+ifeq ($(STACK),1)
+	stack install
+else
+	cabal ${CMD_PFX}copy
+	cabal ${CMD_PFX}register
+endif
+
+doc:
+	${CMD} ${CMD_PFX}haddock
+
+clean:
+	${CMD} ${CMD_PFX}clean
+	bash bin/clean_html
+
+html::
+	bash bin/update_html
+
+# Make a debian package. First add a suitable entry with the correct GF version
+# number to the top of debian/changelog.
+# (Tested on Ubuntu 15.04. You need to install dpkg-dev & debhelper.)
+deb:
+	dpkg-buildpackage -b -uc
+
+# Make a macOS installer package
+pkg:
+	FMT=pkg bash bin/build-binary-dist.sh
+
+# Make a binary tar distribution
+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
--- a/README.md
+++ b/README.md
@@ -0,0 +1,54 @@
+![GF Logo](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
+```
+
+For more information, including links to precompiled binaries, see the [download page](http://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).
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -0,0 +1,66 @@
+# 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 `make sdist`
+2. Upload the package, either:
+    1. **Manually**: visit <https://hackage.haskell.org/upload> and upload the file `dist/gf-X.Y.tar.gz`
+    2. **via Cabal (≥2.4)**: `cabal upload dist/gf-X.Y.tar.gz`
+3. 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.
--- a/Setup.hs
+++ b/Setup.hs
@@ -0,0 +1,81 @@
+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.BuildPaths(exeExtension)
+import System.FilePath((</>),(<.>))
+
+import WebSetup
+
+-- | Notice about RGL not built anymore
+noRGLmsg :: IO ()
+noRGLmsg = putStrLn "Notice: the RGL is not built as part of GF anymore. See https://github.com/GrammaticalFramework/gf-rgl"
+
+main :: IO ()
+main = defaultMainWithHooks simpleUserHooks
+  { preBuild  = gfPreBuild
+  , postBuild = gfPostBuild
+  , preInst   = gfPreInst
+  , postInst  = gfPostInst
+  , postCopy  = gfPostCopy
+  }
+  where
+    gfPreBuild args  = gfPre args . buildDistPref
+    gfPreInst args = gfPre args . installDistPref
+
+    gfPre args distFlag = do
+      return emptyHookedBuildInfo
+
+    gfPostBuild args flags pkg lbi = do
+      -- noRGLmsg
+      let gf = default_gf lbi
+      buildWeb gf flags (pkg,lbi)
+
+    gfPostInst args flags pkg lbi = do
+      -- noRGLmsg
+      saveInstallPath args flags (pkg,lbi)
+      installWeb (pkg,lbi)
+
+    gfPostCopy args flags  pkg lbi = do
+      -- noRGLmsg
+      saveCopyPath args flags (pkg,lbi)
+      copyWeb flags (pkg,lbi)
+
+    -- `cabal sdist` will not make a proper dist archive, for that see `make sdist`
+    -- However this function should exit quietly to allow building gf in sandbox
+    gfSDist pkg lbi hooks flags = do
+      return ()
+
+saveInstallPath :: [String] -> InstallFlags -> (PackageDescription, LocalBuildInfo) -> IO ()
+saveInstallPath args flags bi = do
+  let
+    dest = NoCopyDest
+    dir = datadir (uncurry absoluteInstallDirs bi dest)
+  writeFile dataDirFile dir
+
+saveCopyPath :: [String] -> CopyFlags -> (PackageDescription, LocalBuildInfo) -> IO ()
+saveCopyPath args flags bi = do
+  let
+    dest = case copyDest flags of
+      NoFlag -> NoCopyDest
+      Flag d -> d
+    dir = datadir (uncurry absoluteInstallDirs bi dest)
+  writeFile dataDirFile dir
+
+-- | Name of file where installation's data directory is recording
+-- This is a last-resort way in which the seprate RGL build script
+-- can determine where to put the compiled RGL files
+dataDirFile :: String
+dataDirFile = "DATA_DIR"
+
+-- | Get path to locally-built gf
+default_gf :: LocalBuildInfo -> FilePath
+default_gf lbi = buildDir lbi </> exeName' </> exeNameReal
+  where
+    -- shadows Distribution.Simple.BuildPaths.exeExtension, which changed type signature in Cabal 2.4
+    exeExtension = case hostPlatform lbi of
+      Platform arch Windows -> "exe"
+      _ -> ""
+    exeName' = "gf"
+    exeNameReal = exeName' <.> exeExtension
--- a/WebSetup.hs
+++ b/WebSetup.hs
@@ -0,0 +1,146 @@
+module WebSetup(buildWeb,installWeb,copyWeb,numJobs,execute) where
+
+import System.Directory(createDirectoryIfMissing,copyFile,doesDirectoryExist,doesFileExist)
+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(..))
+
+{-
+   To test the GF web services, the minibar and the grammar editor, use
+   "cabal install" (or "runhaskell Setup.hs install") to install gf as usual.
+   Then start the server with the command "gf -server" and open
+   http://localhost:41296/ in your web browser (Firefox, Safari, Opera or
+   Chrome). The example grammars listed below will be available in the minibar.
+-}
+
+{-
+  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 =
+   [("Letter.pgf","letter",letterSrc)
+   ,("Foods.pgf","foods",foodsSrc)
+   ,("Phrasebook.pgf","phrasebook",phrasebookSrc)
+   ]
+  where
+    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"++lang++".gf"|lang<-phrasebookLangs]
+    phrasebookLangs = words "Bul Cat Chi Dan Dut Eng Lav Hin Nor Spa Swe Tha" -- only fastish languages
+
+    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 ()
+  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"
+        args = numJobs flags++["-make","-s"] -- ,"-optimize-pgf"
+               ++["--gfo-dir="++tmp_dir,
+                --"--gf-lib-path="++gf_lib_path,
+                  "--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
+  where
+    grammars_dir = www_dir </> "grammars"
+    cloud_dir = www_dir </> "tmp" -- hmm
+    logo_dir = www_dir </> "Logos"
+    www_dir = datadir (absoluteInstallDirs pkg lbi dest) </> "www"
+    gfo_dir = buildDir lbi </> "examples"
+
+    copy_pgf :: (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
+
+    gf_logo = "gf0.png"
+
+    copyGFLogo =
+      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)
+     e <- rawSystem command args
+     case e of
+       ExitSuccess   -> return True
+       ExitFailure i -> do putStrLn $ "Ran: " ++ cmdline
+                           putStrLn $ command++" exited with exit code: " ++ show i
+                           return False
+  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]
+numJobs flags =
+    if null n
+    then ["-j","+RTS","-A20M","-N","-RTS"]
+    else ["-j="++n,"+RTS","-A20M","-N"++n,"-RTS"]
+  where
+    -- buildNumJobs is only available in Cabal>=1.20
+    n = case buildNumJobs flags of
+          Flag mn | mn/=Just 1-> maybe "" show mn
+          _ -> ""
--- a/bin/build-binary-dist.sh
+++ b/bin/build-binary-dist.sh
@@ -0,0 +1,98 @@
+#! /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)
+
+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
+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
+
+## 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
+
+## Build the python binding to the C run-time system
+if which >/dev/null python; then
+    pushd src/runtime/python
+    EXTRA_INCLUDE_DIRS="$extrainclude" EXTRA_LIB_DIRS="$extralib" python setup.py build
+    python setup.py install --prefix="$destdir$prefix"
+    if [ "$fmt" == pkg ] ; then
+        # A hack for Python on 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* "$pydest"
+    fi
+    popd
+else
+    echo "Python is not installed, so the Python binding will not be included"
+fi
+
+## Build the Java binding to the C run-time system
+if which >/dev/null javac && which >/dev/null jar ; then
+    pushd src/runtime/java
+    rm -f libjpgf.la # In case it contains the wrong INSTALL_PATH
+    if make CFLAGS="-I$extrainclude -L$extralib" INSTALL_PATH="$prefix"
+    then
+        make INSTALL_PATH="$destdir$prefix" install
+    else
+        echo "Skipping the Java binding because of errors"
+    fi
+    popd
+else
+    echo "Java SDK is not installed, so the Java binding will not be included"
+fi
+
+## 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"
+libdir=$(dirname $(find "$destdir" -name PGF.hi))
+${cabal}register --gen-pkg-config="$libdir/gf-$ver.conf"
+
+## Create the binary distribution package
+case $fmt in
+    tar.gz)
+        targz="$name-bin-$hw-$os.tar.gz"     # the final tar file
+        tar --directory "$destdir/$prefix" --gzip --create --file "dist/$targz" .
+        echo "Created $targz"
+        ;;
+    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"
--- a/bin/clean_html
+++ b/bin/clean_html
@@ -0,0 +1,20 @@
+#!/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
--- a/bin/gfmap
+++ b/bin/gfmap
@@ -0,0 +1,31 @@
+#!/bin/sh
+
+GF="gf"
+DOT="dot" 
+
+BASE=$1
+shift
+
+if [ -z "$BASE" ]; then
+  echo "Usage: gfmap name module ..." 1>&2
+  echo
+  echo "Creates a clickable module dependency graph"
+  exit 2
+fi
+
+DOT_FILE="$BASE.dot"
+IMG_FILE="$BASE.gif"
+MAP_FILE="$BASE.map"
+HTML_FILE="$BASE.html"
+
+$GF -s -src "$@" <<COMMANDS
+sg | wf $DOT_FILE
+COMMANDS
+
+$DOT -Tgif -o $IMG_FILE $DOT_FILE
+$DOT -Tcmapx -o $MAP_FILE $DOT_FILE
+
+echo "<img src='$IMG_FILE' usemap='#_anonymous_0' />" > $HTML_FILE
+cat $MAP_FILE >> $HTML_FILE
+
+echo "Created $HTML_FILE and $IMG_FILE"
--- a/bin/jgf2
+++ b/bin/jgf2
@@ -1,12 +0,0 @@
-#! /bin/sh
-
-# change the value of GFHOME to the directory where you have the gf binary
-GFHOME=/home/aarne/GF2/bin
-       # /.../chalmers.se/fs/cab/cs/.users/markus/home/GF1
-
-JGUILIB=$GFHOME/java/
-GF=$GFHOME/gf2
-JGUI=GFEditor
-
-java -cp $JGUILIB $JGUI "$GF -java $*"
-
--- a/bin/jgf2+
+++ b/bin/jgf2+
@@ -1,12 +0,0 @@
-#! /bin/sh
-
-# change the value of GFHOME to the directory where you have the gf binary
-GFHOME=/home/aarne/GF2/bin
-       # /.../chalmers.se/fs/cab/cs/.users/markus/home/GF1
-
-JGUILIB=$GFHOME/java/
-GF=$GFHOME/gf2+
-JGUI=GFEditor2
-
-java -cp $JGUILIB $JGUI "$GF -java -new $*"
-
--- a/bin/template.html
+++ b/bin/template.html
@@ -0,0 +1,147 @@
+<!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>
--- a/bin/update_html
+++ b/bin/update_html
@@ -0,0 +1,156 @@
+#!/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.
+
+# 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
+  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
--- a/css/newstyle.css
+++ b/css/newstyle.css
@@ -0,0 +1,65 @@
+@import url(style.css);
+
+body.new { margin: 0 8px; }
+
+div.header { text-align: center; }
+
+div.sky {
+    margin: 0 -8px;
+    background-image: -webkit-linear-gradient(top, #a8d8ff, #f6f6f6 70%);
+    background-image: -moz-linear-gradient(top, #a8d8ff, #f6f6f6 70%);
+}
+
+div.header h1 {
+     margin: 0;
+     font-family: verdana, arial, sans-serif;
+     font-weight: normal; font-size: 200%;
+     /*text-decoration: underline;*/
+   }
+
+.tagline { font-family: sans-serif; }
+
+h2.noclear { clear: none; }
+
+
+div.red h1 {
+     color: #e80000;
+     text-shadow: rgba(232,0,0,0.25) 2px 2px 5px;
+}
+div.red .tagline { color: #e00000; }
+
+div.blue h1, div.blue .tagline { color: #06c; }
+
+div.links {
+    display: inline-block;
+    vertical-align: top;
+    margin-right: 1em;
+}
+
+.links h4 { margin: 0; }
+
+.links ul {
+    margin-top: 1ex;
+    margin-left: 2ex;
+    padding-left: 1ex;
+    font-family: sans-serif;
+}
+
+.links li { margin-top: 0.5ex; margin-bottom: 0.5ex; }
+
+div.menu {
+    font-size: 80%;
+    display: table;
+    margin-top: 3ex;
+    margin-right: auto;
+    margin-left: auto;
+    /*float: right;*/
+    /*border-radius: 5px;
+    margin-top: 1ex;
+    background: inherit;
+    border: 2px solid black;
+    padding-left: 0.3em;
+    box-shadow: 0px 0px 15px rgba(0,0,0,0.5);*/
+}
+
+.gflogo { width: 240px; }
--- a/css/notes.css
+++ b/css/notes.css
@@ -0,0 +1,4 @@
+@import url(style.css);
+
+body { color: #333; }
+li>code, p>code, pre { color: #730; }
--- a/css/style.css
+++ b/css/style.css
@@ -0,0 +1,20 @@
+@import url(style0.css);
+
+table { border-collapse: collapse; }
+
+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;
+}
+
+th,td { border: 1px solid #333; }
+
+td { background: white; }
+th { background: #9df; }
--- a/css/style0.css
+++ b/css/style0.css
@@ -0,0 +1,45 @@
+
+body { background-color: #f6f6f6; }
+
+
+h1,h2,h3,h4 { font-family: sans-serif; color: #303030;
+	      text-shadow: rgba(0,0,0,0.25) 2px 2px 5px;
+	    }
+h1 { text-align: center; }
+h2 { border-bottom: 2px solid #303030; clear: right; }
+
+div.mainlinks { font-size: 140%; }
+div.center { text-align: center; }
+div.news { font-size: small; }
+
+h1 img { float: right; border: 0; }
+h1 img.nofloat { float: none; }
+img.right { float: right; }
+
+ol.languages {
+    column-width: 12em;
+}
+
+.grow {
+  max-width: 75%;
+  animation-name: grow;
+  animation-duration: 2s;
+  animation-timing-function: ease-in-out;
+
+  -webkit-animation-name: grow;
+  -webkit-animation-duration: 2s;
+  -webkit-animation-timing-function: ease-in-out;
+
+}
+
+@keyframes grow {
+  from,50% { opacity: 0; transform: scale(0.1,0.1); }
+  80% { opacity: 1; transform: scale(1.1,1.1); }
+  to { transform: scale(1.0,1.0); }
+}
+
+@-webkit-keyframes grow {
+  from,50% { opacity: 0; -webkit-transform: scale(0.1,0.1); }
+  80% { opacity: 1; -webkit-transform: scale(1.1,1.1); }
+  to { -webkit-transform: scale(1.0,1.0); }
+}
--- a/debian/changelog
+++ b/debian/changelog
@@ -0,0 +1,95 @@
+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
+
+ -- Thomas Hallgren <hallgren@chalmers.se>  Wed, 22 Jun 2016 14:00:00 +0200
+
+gf (3.7.1-1) precise trusty vivid; urgency=low
+
+  * GF 3.7.1
+
+ -- Thomas Hallgren <hallgren@chalmers.se>  Fri,  2 Oct 2015 14:00:00 +0200
+
+gf (3.7-1) precise trusty vivid; urgency=low
+
+  * GF 3.7
+
+ -- Thomas Hallgren <hallgren@chalmers.se>  Tue,  25 Jun 2015 14:00:00 +0200
+
+gf (3.6-1) precise saucy trusty; urgency=low
+
+  * GF 3.6
+
+ -- Thomas Hallgren <hallgren@chalmers.se>  Tue,  21 Jun 2014 20:00:00 +0200
+
+gf (3.5-1) precise quantal; urgency=low
+
+  * GF 3.5
+
+ -- Thomas Hallgren <hallgren@chalmers.se>  Tue,  6 Aug 2013 17:30:00 +0200
+
+gf (3.4-1) precise quantal; urgency=low
+
+  * GF 3.4
+
+ -- Thomas Hallgren <hallgren@chalmers.se>  Wed,  31 Dec 2012 00:00:00 +0200
+
+gf (3.3.11-1) oneiric precise quantal; urgency=low
+
+  * GF 3.3.11
+
+ -- Thomas Hallgren <hallgren@chalmers.se>  Wed,  7 Dec 2012 16:50:00 +0200
+
+gf (3.3.3-1) oneiric precise; urgency=low
+
+  * GF 3.3.3
+
+ -- Thomas Hallgren <hallgren@chalmers.se>  Wed, 22 Aug 2012 16:50:00 +0200
+
+gf (3.3-1) natty; urgency=low
+
+  * GF 3.3.
+
+ -- Thomas Hallgren <th0907@altocumulus.org>  Wed, 26 Oct 2011 22:10:42 +0200
+
+gf (2.5-1) unstable; urgency=low
+
+  * Initial packaging.
+
+ -- Bjorn Bringert <bringert@cs.chalmers.se>  Tue, 21 Mar 2006 11:12:25 +0100
--- a/debian/compat
+++ b/debian/compat
@@ -0,0 +1 @@
+7
--- a/debian/control
+++ b/debian/control
@@ -0,0 +1,16 @@
+Source: gf
+Section: devel
+Priority: optional
+Maintainer: Thomas Hallgren <hallgren@chalmers.se>
+Standards-Version: 3.9.2
+Build-Depends: debhelper (>= 5), haskell-platform (>= 2011.2.0.1), libghc-haskeline-dev, libghc-mtl-dev, libghc-json-dev, autoconf, automake, libtool-bin, python-dev, java-sdk
+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.
+ It consists of a special-purpose programming language,
+ a compiler of the language, and a generic grammar processor.
+ .
--- a/debian/copyright
+++ b/debian/copyright
@@ -0,0 +1 @@
+/usr/share/common-licenses/GPL-2
--- a/debian/rules
+++ b/debian/rules
@@ -0,0 +1,48 @@
+#!/usr/bin/make -f
+
+%:
+	+dh $@
+
+#dh_shlibdeps has a problem finding which package some of the Haskell
+#libraries come from, even though dpkg-query -S has no problem finding them.
+#But the gf executable is statically linked against the Haskell libraries, so
+#it will work even if these shared libraries aren't installed. But there will
+#be a problem if other shared libraries are missing (.e.g. libtinfo, libgmp),
+#so we need a better solution than simply ignoring all dependency problems...
+#See also http://stackoverflow.com/questions/11238134/dpkg-shlibdeps-error-no-dependency-information-found-for
+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 v1-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 site-packages`" && [ -n "$$D" ] && cd $$D && cd .. && mv site-packages dist-packages
+
+override_dh_auto_clean:
+	rm -fr dist/build
+	-cd src/runtime/python && rm -fr build
+	-cd src/runtime/java && make clean
+	-cd src/runtime/c && make clean
+
+override_dh_auto_test:
+ifneq (nocheck,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
+	true
+#	cabal test
+endif
--- a/debian/source/format
+++ b/debian/source/format
@@ -0,0 +1 @@
+3.0 (native)
--- a/debian/watch
+++ b/debian/watch
@@ -0,0 +1,2 @@
+version=3
+http://hackage.haskell.org/packages/archive/gf/([\d\.]+)/gf-([\d\.]+).tar.gz
--- a/demos/app.html
+++ b/demos/app.html
@@ -0,0 +1,138 @@
+<!DOCTPYE html>
+<html>
+<head>
+<link rel=stylesheet href="../css/style0.css">
+<meta name = "viewport" content = "width = device-width">
+<link rel=top href="../" title="GF">
+</head>
+<body>
+
+<h1>GF Offline Translator - a mobile speech and text translation app
+for Android and iOS</h1>
+
+<center>
+<img src="images/app-trans.png" width=200>
+</center>
+
+<p>
+Android: download for free from <a
+href="https://play.google.com/store/apps/details?id=org.grammaticalframework.ui.android">Play
+Store</a>!
+Or take the <a
+href="http://www.grammaticalframework.org/~aarne/App14.apk">current
+development version</a>.
+<br>
+iOS (iPhone, iPad): coming in June 2015.
+</p>
+
+<p>
+Or try first a
+<a href="http://cloud.grammaticalframework.org/wc.html">web version of the translator</a>
+</p>
+
+
+<p>
+GF Offline Translator is based on grammar and semantics. It is compact in size
+and gives control on quality. Its technology is inspired by compilers, which are
+programs that translate computer languages.
+Most other translators for human language are based on
+statistics and have less control of quality and are much bigger, so that
+they require either an internet connection or a huge storage on your phone.
+</p>
+The app indicates translation confidence with colours:
+<ul>
+		<li><b>Green</b>:
+                 semantic translation, should be correct.
+                 But not necessarily the only correct one.
+                 You can tap the output to see alternatives.
+                </li>
+		<li><b>Yellow</b>:
+                 syntactic translation, should be grammatically correct.
+                 But can be very strange in its interpretation and choice of words.
+                </li>
+		<li><b>Light red</b>:
+                 chunk translation, probably incorrect.
+                 Builds the translation from small pieces.
+                </li>
+		<li><b>Dark red</b>:
+                 word-by-word translation, almost certainly incorrect.
+                 Builds the translation word by word.
+                </li>
+</ul>
+The green translations come from a tourist phrasebook, which allows
+you to translate things like "hello" and "how far is the airport from
+the hotel". 
+</p>
+
+<p>
+You can translate both speech and text, as selected in the menu in the
+upper right corner. Both kinds of input can be edited with the
+keyboard by first tapping at the input field. This is often needed 
+because of <b>speech recognition errors</b>. Changing words
+from <b>upper to lower case</b> may also be needed.
+At the moment, <b>Japanese</b> and <b>Thai</b> input must be separated
+to words, whereas Chinese works without spaces.
+</p>
+<p>
+Translation works between any of the 14 supported languages, which means 182
+language pairs in the current development version (the official
+Android version has 12 languages).
+But different languages are on different levels of development.
+The following table gives a rough idea of what to expect:
+</p>
+
+<p>
+<center>
+<table rules=all border=yes>
+<tr> <th></th>          <th>coverage</th> <th>quality</th> <th>speed</th> <th>speech</th> </tr>
+<tr> <th>Bulgarian</th> <td bgcolor=yellow></td> <td bgcolor=yellow></td><td bgcolor=palegreen></td> <td bgcolor=yellow>in only</td></tr>
+<tr> <th>Catalan</th>   <td bgcolor=pink></td> <td bgcolor=yellow></td><td bgcolor=pink></td> <td bgcolor=yellow>in only</td></tr>
+<tr> <th>Chinese</th>   <td bgcolor=pink></td> <td bgcolor=pink></td> <td bgcolor=palegreen></td> <td bgcolor=yellow></td> </tr>
+<tr> <th>Dutch</th>     <td bgcolor=yellow></td> <td bgcolor=yellow></td> <td bgcolor=yellow></td> <td bgcolor=palegreen></td> </tr>
+<tr> <th>English</th>   <td bgcolor=palegreen></td> <td bgcolor=palegreen></td> <td bgcolor=palegreen></td> <td bgcolor=palegreen></td> </tr>
+<tr> <th>Finnish</th>   <td bgcolor=yellow></td> <td bgcolor=yellow></td><td bgcolor=pink></td> <td bgcolor=yellow>in only</td></tr>
+<tr> <th>French</th>    <td bgcolor=pink></td> <td bgcolor=yellow></td><td bgcolor=pink></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>German</th>    <td bgcolor=pink></td> <td bgcolor=yellow></td><td bgcolor=pink></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>Hindi</th>     <td bgcolor=pink></td> <td bgcolor=red></td> <td bgcolor=yellow></td> <td bgcolor=yellow>in only</td> </tr>
+<tr> <th>Italian</th>   <td bgcolor=pink></td> <td bgcolor=pink></td><td bgcolor=pink></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>Japanese</th>  <td bgcolor=pink></td> <td bgcolor=pink></td><td bgcolor=yellow></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>Spanish</th>   <td bgcolor=pink></td> <td bgcolor=yellow></td><td bgcolor=pink></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>Swedish</th>   <td bgcolor=yellow></td> <td bgcolor=yellow></td> <td bgcolor=palegreen></td> <td bgcolor=yellow>in only</td></tr>
+<tr> <th>Thai</th>   <td bgcolor=pink></td> <td bgcolor=pink></td><td bgcolor=yellow></td> <td bgcolor=palegreen></td></tr>
+</table>
+</center>
+</p>
+<p>
+The speech input and output use Google's voice services. Their status
+can hence change without notice. You can make it more stable by
+installing third-party speech tools, such as SVOX, which provides
+output for most of the listed languages.
+</p>
+
+<p>
+When you tap on a translation you get a screen with <b>alternative translations</b>.
+Tapping on each of the alternatives
+gives you <b>grammatical information</b>:
+an inflection table, if it is a single word,
+and a syntax tree otherwise.
+</p>
+
+<p>
+Powered by <a href="http://www.grammaticalframework.org/">GF</a>,
+built by support from the GF community and from <a href="http://www.digitalgrammars.com/">Digital Grammars</a>.
+</p>
+
+<p>
+Publication: <a
+href="http://www.aclweb.org/anthology/E/E14/E14-2011.pdf">EACL 2014
+demo paper</a>
+</p>
+
+<center>
+<img src="images/app-table.png" width=160>
+<img src="images/app-disamb.png" width=160>
+</center>
+
+
+</body>
+</html>
--- a/demos/images/app-disamb.png
+++ b/demos/images/app-disamb.png
--- a/demos/images/app-table.png
+++ b/demos/images/app-table.png
--- a/demos/images/app-trans.png
+++ b/demos/images/app-trans.png
--- a/demos/index-numbers.t2t
+++ b/demos/index-numbers.t2t
@@ -0,0 +1,27 @@
+Portable Numeral Translator
+15 August 2008
+
+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).
+
+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.
+
+The 
+[full numeral translator http://www.cs.chalmers.se/~bringert/gf/translate/], which
+works in 88 language and permits arbitrary cross translations, cannot yet be ported
+to the iPhone because of memory problems.
+
+The current version has some encoding/font issues in Hebrew and Hindi.
+
+[Use the translator online numbers/numbers.html]
+
+[Download the translator numbers.tgz]. To install: unpack the file and move
+the directory ``numbers`` to your FileMagnet uploader.
+
+
+
--- a/demos/index.html
+++ b/demos/index.html
@@ -0,0 +1,89 @@
+<!DOCTYPE html>
+<HTML>
+<HEAD>
+<TITLE>Grammatical Framework Demos</TITLE>
+<link rel=stylesheet href="../css/style.css">
+<meta name = "viewport" content = "width = device-width">
+<link rel=top href="../" title="GF">
+</HEAD>
+
+<BODY>
+<H1><a href="../"><IMG SRC="../doc/Logos/gf0.png" alt=""></a>Grammatical Framework Demos</H1>
+
+<p><a href="translation.html">Wide coverage translation with GF</a>
+<p><a href="app.html">The GF Offline Translation App</a>:
+   a mobile speech and text translation app for Android and iOS.
+<p><a href="http://www.grammaticalframework.org/demos/phrasebook/">Tourist
+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>
+
+<p><a href="http://cloud.grammaticalframework.org/gfse/">GF online editor for simple multilingual grammars</a>
+<!--<br>(there is also an <a href="gfse/">older prototype</a>)-->
+
+<p><a href="http://www.grammaticalframework.org:41297/syllogism/syllogism.html">Online syllogism solver</a>
+
+<p><a href="../src/www/TransQuiz/translation_quiz.html">Translation Quiz</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:
+<a href="http://www.grammaticalframework.org:41296/fridge">Fridge poetry</A>
+ | <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>
+<A HREF="http://www.youtube.com/watch?v=1bfaYHWS6zU">Tramdemo on YouTube</A>: 
+find your way in Gothenburg public transport system, in six languages (film).
+
+<P>
+<A HREF="http://www.grammaticalframework.org/~meza/restWiki/wiki.cgi">Multilingual Wiki</A>.
+
+<P>
+<A HREF="index-numbers.html">Numeral translator for the iPhone</A>: number words in 15 languages.
+
+<P>
+<A HREF="http://www.cse.chalmers.se/alumni/bringert/gf/translate/">Numeral translator</A>:
+number words in 88 languages. (Java applet)
+
+<P>
+<A HREF="http://www.cse.chalmers.se/alumni/markus/gramlets/letter-applet.html">Letter editor</A>: compose
+a letter in a language you don't know. (Java applet)
+
+<P>
+<A HREF="http://www.cse.chalmers.se/alumni/bringert/xv/pizza/">Pizza</A>: order a pizza by speaking
+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>:
+translation quizzes in Arabic, English, Russian, Swedish. -->
+
+<P>
+<A HREF="resource-api/editor.html">Library API browser-editor</A>: construct phrases in
+the <A HREF="../lib/doc/synopsis.html">GF resource library</A>
+
+<!--
+<P>
+<A HREF="../old-lib/resource/doc/resdemo.html">Random library examples</A>
+
+-->
+<hr>
+<a href="http://www.grammaticalframework.org/">www.grammaticalframework.org</a>
--- a/demos/molto.html
+++ b/demos/molto.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>MOLTO Application Grammars</title>
+<link rel=stylesheet type="text/css" href="../src/www/minibar/minibar.css">
+<link rel=stylesheet type="text/css" href="../src/www/syntax-editor/editor.css">
+
+<link rel=author href="http://www.cse.chalmers.se/~hallgren/" title="Thomas Hallgren">
+
+<meta name = "viewport" content = "width = device-width">
+<meta charset="UTF-8">
+
+</head>
+
+<body class=minibar>
+<h2>MOLTO Application Grammars</h2>
+<div id=minibar></div>
+<div id=syntax_editor></div>
+
+<noscript>This page doesn't works unless JavaScript is enabled.</noscript>
+
+<hr>
+
+<small>
+[<a href="http://www.molto-project.eu/cloud/gf-application-grammars">GF
+ Application Grammars on the MOLTO web site</a>]
+</small>
+<small class=modtime>
+HTML <!-- hhmts start -->Last modified: Fri May 24, 2013 <!-- hhmts end -->
+</small>
+
+<div id="debug" class="hidden"></div>
+
+<script type="text/JavaScript" src="../src/www/js/grammar_manager.js"></script>
+<script type="text/JavaScript" src="../src/www/js/support.js"></script>
+<script type="text/JavaScript" src="../src/www/js/localstorage.js"></script>
+<script type="text/JavaScript" src="../src/www/minibar/minibar.js"></script>
+<script type="text/JavaScript" src="../src/www/minibar/minibar_input.js"></script>
+<script type="text/JavaScript" src="../src/www/minibar/minibar_translations.js"></script>
+<script type="text/JavaScript" src="../src/www/minibar/minibar_support.js"></script>
+<script type="text/JavaScript" src="../src/www/js/pgf_online.js"></script>
+<script type="text/javascript" src="../src/www/syntax-editor/ast.js"></script>
+<script type="text/javascript" src="../src/www/syntax-editor/editor_menu.js"></script>
+<script type="text/javascript" src="../src/www/syntax-editor/editor.js"></script>
+<script type="text/javascript" src="molto_grammars.js"></script>
+<script type="text/javascript" src="../src/www/gfse/gf_abs.js"></script>
+
+</body>
+</html>
--- a/demos/molto_grammars.js
+++ b/demos/molto_grammars.js
@@ -0,0 +1,19 @@
+var online_options={
+  grammars_url: "/grammars/molto/"
+}
+
+var minibar_options= {
+    show_abstract: true,
+    show_trees: true,
+    tree_img_format: "svg", // or "png"
+    show_grouped_translations: false,
+    to_multiple: false,
+    show_brackets: true,
+    word_replacements: true,
+    default_source_language: "Eng",
+    feedback_url: "feedback.html",
+    try_google: true
+}
+
+var server=pgf_online(online_options);
+var minibar=new Minibar(server,minibar_options);
--- a/demos/resource-api/code.js
+++ b/demos/resource-api/code.js
@@ -0,0 +1,947 @@
+
+//Variable and Constant definitions
+
+var expColImg = new Array(2);
+expColImg[0]     = new Image(12,12);
+expColImg[0].src = "minus.png";
+expColImg[1]     = new Image(12,12);
+expColImg[1].src = "plus.png";
+
+var selectedNode = "";
+var collapseBuffer = new Array();
+var abstractTree = new Fun ("?");
+
+var navigationControlString = new Array();
+var undoArray = new Array();
+var redoArray = new Array();
+var clipBoard;
+var refPageCounter = 0;
+
+var stringAbstractTree = undefined;
+
+var myTree = treeFromAbstract(myAbstract.annotate(abstractTree, myAbstract.startcat), "0");
+
+var keys = new Array();
+keys ["Z"] = function() { clickUndo('actUndo'); }
+keys ["Y"] = function() { clickRedo('actRedo'); }
+keys ["R"] = function() { clickRefine('actRefine'); };
+keys ["V"] = function() { clickPaste('actPaste'); };
+keys ["X"] = function() { clickCut('actCut'); };
+keys ["C"] = function() { clickCopy('actCopy'); };
+keys ["D"] = function() { clickDelete('actDelete'); };
+keys ["E"] = function() { clickReplace('actReplace'); };
+keys ["W"] = function() { clickWrap('actWrap'); };
+keys ["N"] = function() { clickRandomNode('actRandomNode'); };
+keys ["T"] = function() { clickRandomTree('actRandomTree'); };
+keys ["%"] = function() { leftArrowKey(); };
+keys ["&"] = function() { upDownArrowKey(-1); };
+keys ["'"] = function() { rightArrowKey(); };
+keys ["("] = function() { upDownArrowKey( 1); };
+keys ["27"] = function() { clickEsc(); };
+
+function state(selectedNode, tree, collapseBuffer) {
+	this.selectedNode = selectedNode;
+	this.tree = myAbstract.copyTree(tree);
+	this.collapseBuffer = collapseBuffer;
+	return this;
+}
+
+function treeNode(name, caption) {
+	this.name = name;
+	this.caption = caption;
+	this.cat = ""; 
+	this.children = new Array();
+	this.collapsed = false;
+	return this;
+}
+
+treeNode.prototype.addChild = function (i, c) {
+	this.children[i] = c;
+}
+
+treeNode.prototype.hasChildren = function() {
+	return this.children.length;	
+}
+
+// Generates a tree from the abstract tree contained in the element "stringTree"
+function parseStringTree(elementToParse) {
+	stringAbstractTree = elementToParse;
+	abstractTree = myAbstract.parseTree(document.getElementById(elementToParse).value, myAbstract.startcat);
+	myTree = treeFromAbstract(myAbstract.annotate(abstractTree, myAbstract.startcat), "0");
+	nodeClick("0");
+}
+
+// If a key is pressed and a function assigned to that key, calls the function
+function hotKeys(event) {
+	event = (event) ? event : ((window.event) ? event : null);
+	if (event) {
+		var charCode = (event.charCode) ? event.charCode : ((event.which) ? event.which : event.keyCode);
+		if (keys[String.fromCharCode(charCode).toUpperCase()] &&
+			!event.ctrlKey && !event.altKey && !event.shiftKey && !event.metaKey) {
+		    	keys[String.fromCharCode(charCode).toUpperCase()]();
+		}
+		else if (keys["" + charCode] &&
+			!event.ctrlKey && !event.altKey && !event.shiftKey && !event.metaKey) {
+				keys["" + charCode]();
+		}
+		else if (charCode >= "96" && charCode <= "105" &&
+			!event.ctrlKey && !event.altKey && !event.shiftKey && !event.metaKey) {
+				keys["" + (charCode - 96)]();
+		}
+	}
+}
+
+// Clears "numeric" hotkeys
+function clearHotKeys() {
+	for (var key in keys) {
+		if ((parseInt(key) + 1) && (key != "27")) { keys[key] = function() { }; }
+	}
+}
+
+// Action to be performed when the up/down arrow key is pressed
+function upDownArrowKey(pos) {
+	var nodePos = getNavPos(selectedNode);
+	if ((nodePos > 0 && pos < 0) || (nodePos < navigationControlString.length - 1 && pos > 0)) { 
+		nodeClick(navigationControlString[nodePos + pos]);
+	}
+}
+
+// Gets the position of a given node in the navigationControlString
+function getNavPos(nodeName) {
+	for (var i = 0, j = navigationControlString.length; i < j; i++) {
+		if (navigationControlString[i] == nodeName) { return i; };
+	}
+	return undefined;
+}
+
+// Given a name and a tree, gets the node in the tree with that name
+function getNode(nodeName, node) {
+	if (nodeName == node.name) {
+		return node;
+	}
+	else {	
+		for (var i = 0, j = node.children.length; i < j; i++) {
+			var found = getNode(nodeName, node.children[i]);
+			if (found) { return found; }
+		}
+	}
+}
+
+// Action to be performed when the left arrow key is pressed
+function leftArrowKey() {
+	var node = getNode(selectedNode, myTree);
+	if (!node.collapsed && node.hasChildren()) {
+		signClick(node.name, node.caption);
+	}
+	else {
+		var parentNode = getParent(node.name, myTree);
+		if (parentNode) { nodeClick(parentNode.name); }
+	}
+}
+
+// Gets the parent of the selected node
+function getParent(nodeName, node) {
+	if (node.name == nodeName) {	
+		return undefined;
+	}
+	else {
+		for (var i = 0, j = node.children.length; i < j; i++) {
+			if (node.children[i].name == nodeName) { return node; }
+		}
+		for (var i = 0, j = node.children.length; i < j; i++) {
+			var found = getParent(nodeName, node.children[i]);
+			if (found) { return found; }
+		}
+	}
+}
+
+// Action to be performed when the right arrow key is pressed
+function rightArrowKey() {
+	var node = getNode(selectedNode, myTree);
+	if (node.collapsed) {
+		signClick(node.name, node.caption);
+	}
+	else {
+		var firstDescendant = getfirstDescendant(node);
+		if (firstDescendant) {
+			nodeClick(firstDescendant.name);
+		}
+	}
+}
+
+// Gets the first descendant child of a node
+function getfirstDescendant(node) {
+	if (node.hasChildren() && !node.collapsed) { return node.children[0]; }
+	return undefined;
+}
+
+// Produces and displays an HTML representation of the tree
+function drawTree() {
+	var frame = document.getElementById("absFrame");
+	navigationControlString = new Array();
+	frame.innerHTML = "<ul id='tree'>" + getTree(myTree, 0) + "</ul>";
+	document.getElementById("link" + selectedNode).scrollIntoView(false);
+}
+
+// Produces an HTML representation of the tree
+function getTree(tree, level) {
+	navigationControlString[navigationControlString.length] = tree.name;
+	var htmlTree = "";
+	htmlTree += "<li>";
+	if (tree.hasChildren()) {	
+		htmlTree +=	"<img class='tree-menu'";
+		if (tree.collapsed) {
+			htmlTree += " src='plus.png'";
+		}
+		else { htmlTree += " src='minus.png'"; }
+		htmlTree += " onclick='signClick(\"" + tree.name + "\", \"" + tree.caption + "\")' />";
+	}
+	else {
+		htmlTree +=	"<img class='tree-menu' src='empty.png' />";
+	}
+	htmlTree += "<a id='link" + tree.name + "'";
+	if (document.getElementById("actRefine").className == "selected" ||
+		document.getElementById("actReplace").className == "selected" ||
+		document.getElementById("actWrap").className == "selected") {
+		htmlTree += "class='treeGray' "; }
+	else if (selectedNode == tree.name) { htmlTree += "class='treeSelected' "; }
+	else { htmlTree += "class='tree' "; }
+	htmlTree += "href='' onclick='nodeClick(\"" + tree.name + "\"); return false'>" + overl(tree.caption) +
+				"&nbsp;:&nbsp;" + tree.cat + "</a></li><ul>";
+	if (tree.hasChildren() && !tree.collapsed) {
+		for (var i = 0, j = tree.children.length; i < j; i++) {
+			htmlTree += getTree(tree.children[i], level + 1);
+		}
+	}
+	htmlTree += "</ul>";
+	return htmlTree;
+}
+
+// Linearizes and displays the abstract tree
+function drawLinearizedFrame() {
+	var frame = document.getElementById("conFrame");
+	frame.innerHTML = getLinearizedFrame();
+}
+
+// Linearizes the abstract tree and returns it in HTML form
+function getLinearizedFrame() {
+	var linearizedFrame = "";
+	for (var i = 0; i < myConcrete.length; i++) {	
+	  //		linearizedFrame += "<h4>" + myConcrete[i].concreteSyntaxName + "</h4>";
+		linearizedFrame += "<p id='line" + myConcrete[i].concreteSyntaxName +"'>";
+		var tokens = myConcrete[i].concreteSyntax.tagAndLinearize(abstractTree);
+		for (var j = 0, k = tokens.length; j < k; j++) {
+			linearizedFrame += createLinearized(tokens[j]);
+		}
+		linearizedFrame += "</p>";
+	}
+	linearizedFrame += abstractTree.printOverl();
+
+	return linearizedFrame;
+}
+
+// Creates an HTML representation of a linearization of an abstract tree
+function createLinearized(token) {
+	var node = getNode(token.tag, myTree);
+	var linearized = "<span id='" + token.tag + "' class=";
+	if (node.name.substr(0, selectedNode.length) == selectedNode) {
+		linearized += "'selected'";
+	}
+	else {
+		linearized += "'normal'";
+	}
+	if (token == "&-") { linearized += "<br />"; }
+	else { linearized += " onclick='nodeClick(\"" + node.name + "\");'>&nbsp;" + token + " </span>"; }
+	return linearized;
+}
+
+// Expands/Collapses node
+function signClick(name, caption) {
+	myTree = expandCollapse(myTree, name);
+	nodeClick(name);
+}
+
+// Sets the "collapsed" property of a given node
+function expandCollapse(node, name) {
+	if (node.name == name) {
+		if (wasCollapsed(node.name)) { removeFromCollapseBuffer(node.name); }
+		else { collapseBuffer[collapseBuffer.length] = node.name; }
+		node.collapsed ^= true;
+	}
+	else {
+		for (var i = 0, j = node.children.length; i < j; i++) {
+			expandCollapse(node.children[i], name);
+		}
+	}
+	return node;
+}
+
+// Checks if a node was collapsed on the previous cycle
+function wasCollapsed(nodeName) {
+	for (var i = 0, j = collapseBuffer.length; i < j; i++) {
+		if (nodeName == collapseBuffer[i]) {
+			return true;
+		}
+	}
+	return false;
+}
+
+// Removes a node from the collapseBuffer array
+function removeFromCollapseBuffer(nodeName) {
+	var newBuffer = new Array();
+	for (var i = 0, j = collapseBuffer.length; i < j; i++) {
+		if (nodeName != collapseBuffer[i]) {
+			newBuffer[newBuffer.length] = collapseBuffer[i];
+		}
+	}
+	collapseBuffer = newBuffer;
+}
+
+// Selects a node
+function nodeClick(name) {	
+	if ((document.getElementById("actRefine") && document.getElementById("actRefine").className == "selected") ||
+		(document.getElementById("actReplace") && document.getElementById("actReplace").className == "selected") ||
+		(document.getElementById("actWrap") && document.getElementById("actWrap").className == "selected")) {
+		return; }
+	selectedNode = name;
+	if (stringAbstractTree) {
+		document.getElementById(stringAbstractTree).value = abstractTree.show();
+	}
+	document.getElementById("actFrame").innerHTML = showActions();
+	document.getElementById("refFrame").innerHTML = "";
+	drawTree();
+	drawLinearizedFrame();
+}
+
+// Shows the available actions for a node
+function showActions(caption) {
+	var node = getNode(selectedNode, myTree);
+	var abstractNode = getNodeFromAbstract(abstractTree, node.name, "0");
+	var actions = "<table class='action'>";
+	if (undoArray.length) {
+		actions += createAction("Undo", "action", "Undo", "Z"); }
+	else { actions += createAction("Undo", "unavailable", "Undo", "Z"); };
+	if (redoArray.length) {
+		actions += createAction("Redo", "action", "Redo", "Y"); }
+	else { actions += createAction("Redo", "unavailable", "Redo", "Y"); }
+	if (node.caption == "?") {	
+		actions += createAction("Cut", "unavailable", "Cut", "X");
+		actions += createAction("Copy", "unavailable", "Copy", "C");
+		var AbsNodeType = abstractNode.type;
+		if (clipBoard && (AbsNodeType == myAbstract.getCat(clipBoard.name))) {
+			actions += createAction("Paste", "action", "Paste", "V");
+		}
+		else { actions += createAction("Paste", "unavailable", "Paste", "V"); }
+		actions += createAction("Delete", "unavailable", "Delete", "D");
+		actions += createAction("Refine", "action", "Refine", "R");
+		actions += createAction("Replace", "unavailable", "Replace", "E");
+		actions += createAction("Wrap", "unavailable", "Wrap", "W")
+	}
+	else if (node.caption) {	
+		actions += createAction("Cut", "action", "Cut", "X");
+		actions += createAction("Copy", "action", "Copy", "C");
+		actions += createAction("Paste", "unavailable", "Paste", "V");
+		actions += createAction("Delete", "action", "Delete", "D");
+		actions += createAction("Refine", "unavailable", "Refine", "R");
+		actions += createAction("Replace", "action", "Replace", "E");
+		actions += createAction("Wrap", "action", "Wrap", "W")
+	}
+	if (node && !abstractNode.isComplete()) {	
+		actions += createAction("RandomNode", "action", "Fill out the node at random", "N");
+	}
+	else {
+		actions += createAction("RandomNode", "unavailable", "Fill out the node at random", "N");
+	}
+	if (!abstractTree.isComplete()) {
+		actions += createAction("RandomTree", "action", "Fill out the tree at random", "T");
+	}
+	else {
+		actions += createAction("RandomTree", "unavailable", "Fill out the tree at random", "T");
+	}
+	actions += "</table>";
+	return actions;
+}
+
+// Gets a node from the abstract tree
+function getNodeFromAbstract(absNode, route, currRoute) {
+	if (route == currRoute) {
+		return absNode;
+	}
+	else {
+		for (var i = 0, j = absNode.args.length; i < j; i++) {
+			var found = getNodeFromAbstract(absNode.args[i], route, currRoute + "-" + i);
+			if (found) { return found }
+		}
+	}
+}
+
+// Creates an action
+function createAction(actionName, className, caption, hotKey) {
+	return "<tr id='act" + actionName + "' class='" + className +"' onclick='click" +
+			actionName + "(\"act" + actionName + "\")'><td class='action'>" + caption + 
+			"</td><td class='hotKey'>(" + hotKey + ")</td></tr>";
+}
+
+// When the "Refine" action is selected, gets the appropriate refinements for a node
+function clickRefine(actName) {
+	if (document.getElementById(actName).className == "action") {
+		highlightSelectedAction(actName);
+		pushUndoClearRedo();
+		if (selectedNode) {
+			refPageCounter = 0;
+			var node = getNodeFromAbstract(abstractTree, selectedNode, "0");
+			if (node.type == "String") {
+				var newType = prompt('Enter a String','String');
+				if (!newType) { newType = "AutoString" }
+				myAbstract.addType(newType,[], "String");
+				for (var i = 0, j = myConcrete.length; i < j; i++) {
+					myConcrete[i].concreteSyntax.addRule(newType, function(cs){ return new Arr(new Str(newType));});
+				}
+				node.name = newType;
+				abstractTree = insertNode(abstractTree, selectedNode, "0", node);
+				document.getElementById("actFrame").innerHTML = showActions();
+				document.getElementById("refFrame").innerHTML = "";
+				clearHotKeys();
+				concludeAction();
+			}
+			else {
+				document.getElementById("refFrame").innerHTML = showRefinements(selectedNode);
+			}
+		}
+	}
+}
+
+// Sets the className of actName to "selected" and grays out the other selections
+function highlightSelectedAction(actName) {
+	graySelections(actName);
+	document.getElementById(actName).className = "selected";
+	drawTree();
+}
+
+// Grays out all actions except one
+function graySelections(except) {
+	var refs = document.getElementById("actFrame").getElementsByTagName("tr");
+	for (var i = 0, j = refs.length; i < j; i++) {
+		if (refs[i].id != except) { refs[i].className = "closed"; }
+	}	
+}
+
+// Pushes the abstract tree into the undo array and clears the redo array
+function pushUndoClearRedo() {
+	undoArray.push(new state(selectedNode, abstractTree, collapseBuffer));
+	redoArray.length = 0;
+}
+
+// Gets the refinements to display
+function showRefinements(nodeName) {
+	var refs = getAvailableRefinements(nodeName);
+	var pages = 0;
+	if (refs.length > 9) { pages = Math.floor(refs.length / 9); }
+	var upperLimit;
+	if (pages != refPageCounter) { upperLimit = (9 * refPageCounter) + 9; }
+	else { upperLimit = refs.length; }
+	var refinements = "<table class='refinement'>";
+	var keyPos = 0;
+	refinements += ref_wrapToHtml("ref", "genRefRandom", "refinement", "", keyPos, "Choose at random");
+	keys["" + keyPos] = mkRefHotKey("genRefRandom");
+	keyPos++;
+	for (var i = (9 * refPageCounter), j = upperLimit; i < j; i++) {	
+		refinements += ref_wrapToHtml("ref", refs[i], "refinement", "", keyPos, "");
+		keys["" + keyPos] = mkRefHotKey(refs[i]);
+		keyPos++;
+	}
+	if (pages > refPageCounter) {
+		refinements += ref_wrapNextRefsToHtml("nextRefs", "Next", "refinement", "+", "Next Refinements");
+		keys["107"] = mkRefNextRefsHotKey("Next");
+	}
+	if (0 < refPageCounter) {
+		refinements += ref_wrapNextRefsToHtml("nextRefs", "Previous", "refinement", "-", "Previous Refinements");
+		keys["109"] = mkRefNextRefsHotKey("Previous");
+	}
+	refinements += "</table>";
+	return refinements;
+}
+
+// Gets the available refinements for a node
+function getAvailableRefinements(nodeName) {
+	var node = getNodeFromAbstract(abstractTree, nodeName, "0");
+	var metaType = node.type;
+	var refinements = new Array();
+	for (var fun in myAbstract.types) {
+		if (myAbstract.types[fun].cat == metaType) {
+			refinements[refinements.length] = fun;
+		}
+	}
+	return refinements;
+}
+
+// Creates an HTML representation of a Refinement/Wrap
+function ref_wrapToHtml(funct, name, className, arg, hotKeyPos, caption) {
+	var ref_wrapHtml = "<tr id='" + funct + name + "' class=" + className + " onclick='" + funct +
+						"Click(\"" + name + "\"" + arg + ")'><td class='" + className + "'>";
+	if (caption) { ref_wrapHtml += caption; }
+	else { ref_wrapHtml += overl(name) + "&nbsp;:&nbsp;" + refArgsToHtml(name) + myAbstract.getCat(name); }
+	ref_wrapHtml += "</td><td class='hotKey'>(" + hotKeyPos + ")</td></tr>";
+	return ref_wrapHtml
+}
+
+
+// Creates the function to be used by a "numeric" hot key
+function mkRefHotKey(refName) {
+	return function() { if (document.getElementById("ref" + refName)) { refClick(refName); } }
+}
+
+// Creates an HTML representation of a Refinement/Wrap
+function ref_wrapNextRefsToHtml(funct, name, className, hotKeyPos, caption) {
+	var ref_wrapHtml = "<tr id='" + funct + name + "' class=" + className + " onclick='" + funct +
+						"Click(\"" + name + "\")'><td class='" + className + "'>";
+	ref_wrapHtml += caption;
+	ref_wrapHtml += "</td><td class='hotKey'>(" + hotKeyPos + ")</td></tr>";
+	return ref_wrapHtml
+}
+
+// Creates the function to be used by a "+" hot key
+function mkRefNextRefsHotKey(refName) {
+	return function() { if (document.getElementById("nextRefs" + refName)) { nextRefsClick(refName); } }
+}
+
+// Creates a string representation of the arguments of a refinement
+function refArgsToHtml(fun) {
+	var args = "";
+	for (var i = 0, j = myAbstract.types[fun].args.length; i < j; i++) {
+		args += myAbstract.types[fun].args[i] + "&nbsp;->&nbsp;";
+	}
+	return args;
+}
+
+// Gets the type of a meta variable
+function getMetaType(absNode, route, currRoute) {
+	if (route == currRoute && absNode.isMeta()) {
+		return absNode.type;
+	}
+	else {
+		for (var i = 0, j = absNode.args.length; i < j; i++) {
+			var found = getMetaType(absNode.args[i], route, currRoute + "-" + i);
+			if (found) { return found };
+		}
+	}
+}
+
+// When the "Undo" action is selected, undoes the last action
+function clickUndo(actName) {
+	if (document.getElementById(actName).className == "action" && undoArray.length) {
+		highlightSelectedAction(actName);
+		redoArray.push(new state(selectedNode, abstractTree, collapseBuffer));
+		var prevState = undoArray.pop();
+		selectedNode = prevState.selectedNode;
+		abstractTree = myAbstract.copyTree(prevState.tree);
+		collapseBuffer = prevState.collapseBuffer;
+		if (abstractTree.isComplete()) { selectedNode = "0"; }		
+		abstractTree = myAbstract.annotate(abstractTree, myAbstract.startcat);
+		myTree = treeFromAbstract(abstractTree, "0");
+		nodeClick(selectedNode);
+	}
+}
+
+// When the "Redo" action is selected, redoes the last action
+function clickRedo(actName) {
+	if (document.getElementById(actName).className == "action" && redoArray.length) {
+		highlightSelectedAction(actName);
+		undoArray.push(new state(selectedNode, abstractTree, collapseBuffer));
+		var nextState = redoArray.pop();
+		selectedNode = nextState.selectedNode;
+		abstractTree = myAbstract.copyTree(nextState.tree);
+		collapseBuffer = nextState.collapseBuffer;
+		abstractTree = myAbstract.annotate(abstractTree, myAbstract.startcat);
+		myTree = treeFromAbstract(abstractTree, "0");
+		nodeClick(selectedNode);
+	}
+}
+
+// When the "Copy" action is selected, copies the selected node to the clipboard
+function clickCopy(actName) {
+	if (document.getElementById(actName).className == "action") {
+		highlightSelectedAction(actName);
+		if (selectedNode) {	
+			clipBoard = myAbstract.copyTree(getNodeFromAbstract(abstractTree, selectedNode, "0"));
+			document.getElementById("clipboardFrame").innerHTML = clipBoard.name + "&nbsp;:&nbsp;" +
+																	myAbstract.getCat(clipBoard.name);
+			nodeClick(selectedNode);
+		}
+	}
+}
+
+// When the "Cut" action is selected, deletes the selected node and copies it to the clipboard
+function clickCut(actName) {
+	if (document.getElementById(actName).className == "action") {
+		highlightSelectedAction(actName);
+		pushUndoClearRedo();
+		if (selectedNode) {
+			clipBoard = myAbstract.copyTree(getNodeFromAbstract(abstractTree, selectedNode, "0"));
+			document.getElementById("clipboardFrame").innerHTML = clipBoard.name + "&nbsp;:&nbsp;" +
+																	myAbstract.getCat(clipBoard.name);
+			abstractTree = deleteNode(abstractTree, selectedNode, "0");
+			concludeAction();
+		}
+	}
+}
+
+// Annotates the abstract tree, creates a tree from the abstract tree and selects the next meta variable
+function concludeAction() {
+	abstractTree = myAbstract.annotate(abstractTree, myAbstract.startcat);
+	myTree = treeFromAbstract(abstractTree, "0");
+	selectNextMeta();
+}
+
+// Selects the next meta variable available
+function selectNextMeta() {
+	nodeClick(selectedNode);
+	if (!abstractTree.isComplete()) {
+		var pathToNextMeta = "";
+		var nodePos = getNavPos(selectedNode);
+		while (1) {
+			if (nodePos == navigationControlString.length) { nodePos = 0; }
+			var node = getNode(navigationControlString[nodePos], myTree);
+			if (node.caption == "?") { pathToNextMeta = node.name; break; }
+			nodePos++;
+		}
+		expandAscendants(pathToNextMeta);
+		nodeClick(pathToNextMeta);
+	}
+}
+
+// Gets the first meta variable from an abstract tree
+function getNextMetaFromAbstract(node, route) {
+	if (node.isMeta()) { return route; }
+	for (var i = 0, j = node.args.length; i < j; i++) {
+		var found = getNextMetaFromAbstract(node.args[i], route + "-" + i);
+		if (found) { return found; }
+	}
+}
+
+// Expands the ascendants of a given node
+function expandAscendants(nodeName) {
+	var nodePath = nodeName.split("-");
+	var currAscendant = nodePath.shift();
+	while (nodePath.length > 0) {
+		var node = getNode(currAscendant, myTree);
+		if (node.collapsed) {
+			myTree = expandCollapse(myTree, currAscendant);
+		}
+		currAscendant += "-" + nodePath.shift();
+	}
+}
+
+// When the "Paste" action is selected, pastes the contents of the clipboard into the selected node
+function clickPaste(actName) {
+	if (document.getElementById(actName).className == "action") {
+		highlightSelectedAction(actName);
+		pushUndoClearRedo();
+		if (selectedNode) {
+			abstractTree = insertNode(abstractTree, selectedNode, "0", myAbstract.copyTree(clipBoard));
+			concludeAction();
+		}
+	}
+}
+
+// Inserts a node into a tree
+function insertNode(absNode, route, currRoute, node) {
+	if (route == currRoute) {
+		return node;
+	}
+	else {
+		for (var i = 0, j = absNode.args.length; i < j; i++) {
+			absNode.setArg(i, insertNode(absNode.args[i], route, currRoute + "-" + i, node));
+		}
+		return absNode;
+	}
+}
+
+// When the "Delete" action is selected, deletes the selected node
+function clickDelete(actName) {
+	if (document.getElementById(actName).className == "action") {
+		highlightSelectedAction(actName);
+		pushUndoClearRedo();
+		if (selectedNode) {	
+			abstractTree = deleteNode(abstractTree, selectedNode, "0");
+			abstractTree = myAbstract.annotate(abstractTree, myAbstract.startcat);
+			myTree = treeFromAbstract(abstractTree, "0");
+			nodeClick(selectedNode);
+		}
+	}
+}
+
+// Deletes a node from a tree
+function deleteNode(absNode, route, currRoute) {
+	if (route == currRoute) {
+		return new Fun("?");
+	}
+	else {
+		for (var i = 0, j = absNode.args.length; i < j; i++) {
+			absNode.setArg(i, deleteNode(absNode.args[i], route, currRoute + "-" + i));
+		}
+		return absNode;
+	}
+}
+
+// When the "Replace" action is selected, replaces the selected node with another refinement
+function clickReplace(actName) {
+	if (document.getElementById(actName).className == "action") {
+		highlightSelectedAction(actName);
+		pushUndoClearRedo();
+		if (selectedNode) {
+			abstractTree = deleteNode(abstractTree, selectedNode, "0");
+			abstractTree = myAbstract.annotate(abstractTree, myAbstract.startcat);
+			myTree = treeFromAbstract(abstractTree, "0");
+			drawTree();
+			document.getElementById("refFrame").innerHTML = showRefinements(selectedNode);
+		}
+	}
+}
+
+// When the "Wrap" action is selected, wraps around the selected node with another refinement
+function clickWrap(actName) {
+	if (document.getElementById(actName).className == "action") {
+		highlightSelectedAction(actName);
+		pushUndoClearRedo();
+		var node = getNode(selectedNode, myTree);
+		if (selectedNode) {
+			refPageCounter = 0;
+			var wrappers = getWrappers(node.caption);
+			document.getElementById("refFrame").innerHTML = wrappers;
+			if (wrappers.length <= 31) {
+				alert("No wrappers available");
+				document.getElementById("actFrame").innerHTML = showActions();
+				nodeClick(selectedNode);
+			}
+		}
+	}
+}
+
+// Gets the wrappers to display
+function getWrappers(nodeCaption) {
+	var nodeType = myAbstract.types[nodeCaption].cat;
+	var availWrappers = getAvailableWrappers(nodeType);
+	var pages = Math.floor(availWrappers.length / 9);
+	var upperLimit;
+	if (pages != refPageCounter) { upperLimit = (9 * refPageCounter) + 9; }
+	else { upperLimit = availWrappers.length - (9 * refPageCounter); }
+	var wrappers = "<table class='wrapper'>";
+	var keyPos = 0;
+	for (var i = (9 * refPageCounter), j = (9 * refPageCounter) + upperLimit; i < j; i++) {	
+		wrappers += ref_wrapToHtml("wrap", availWrappers[i][0], "wrapper", ", " + availWrappers[i][1], keyPos, "");
+		keys["" + keyPos] = mkWrapHotKey(availWrappers[i][0], availWrappers[i][1]);
+		keyPos++;
+	}
+	if (pages > (9 * refPageCounter)) {
+		refinements += ref_wrapNextRefsToHtml("nextWraps", "Next", "wrapper", "+", "Next Wrappers");
+		keys["107"] = mkWrapNextRefsHotKey("Next");
+	}
+	if (0 < (9 * refPageCounter)) {
+		refinements += ref_wrapNextRefsToHtml("nextWraps", "Previous", "wrapper", "-", "Previous Wrappers");
+		keys["109"] = mkWrapNextRefsHotKey("Previous");
+	}
+	wrappers += "</table>";
+	return wrappers;
+}
+
+// Gets the available wrappers for a node
+function getAvailableWrappers(nodeType) {
+	var wrappers = new Array();
+	for (var fun in myAbstract.types) {
+		for (var i = 0, j = myAbstract.types[fun].args.length; i < j; i++) {
+			if (myAbstract.types[fun].args[i] == nodeType && myAbstract.types[fun].cat == nodeType) {
+				wrappers[wrappers.length] = new Array(fun, i);
+				break;
+			}
+		}
+	}
+	return wrappers;
+}
+
+// Creates the function to be used by a "numeric" hot key
+function mkWrapHotKey(refName, argPos) {
+	return function() { if (document.getElementById("wrap" + refName)) { wrapClick(refName, argPos); } }
+}
+
+// Creates the function to be used by a "-" hot key
+function mkWrapNextRefsHotKey(refName) {
+	return function() { if (document.getElementById("nextWraps" + refName)) { nextRefsClick(refName); } }
+}
+
+// When the "RandomNode" action is selected, refines the node at random
+function clickRandomNode(actName) {
+	if (document.getElementById(actName).className == "action") {
+		highlightSelectedAction(actName);
+		pushUndoClearRedo();
+		if (selectedNode) {
+			var tempTree = myAbstract.copyTree(abstractTree);
+			abstractTree = myAbstract.copyTree(getNodeFromAbstract(abstractTree, selectedNode, "0"));
+			fillSubTree()
+			abstractTree = insertNode(tempTree, selectedNode, "0", myAbstract.copyTree(abstractTree));
+			concludeAction();
+		}
+	}
+}
+
+// Refines the sub tree
+function fillSubTree() {
+	while (!abstractTree.isComplete()) {
+		var nodeToRefine = getNextMetaFromAbstract(abstractTree, "0");
+		if (nodeToRefine) {
+			var refs = getAvailableRefinements(nodeToRefine);
+// FIX THIS ASAP!!!!
+			if (refs.length == 0) {
+				var node = getNodeFromAbstract(abstractTree, nodeToRefine, "0");
+				if (node.type == "String") {
+					var newType = "AutoString";
+					myAbstract.addType(newType,[], "String");
+					for (var i = 0, j = myConcrete.length; i < j; i++) {
+						myConcrete[i].concreteSyntax.addRule(newType, function(cs){ return new Arr(new Str(newType));});
+					}
+					node.name = newType;
+					abstractTree = insertNode(abstractTree, nodeToRefine, "0", node);
+					abstractTree = myAbstract.annotate(abstractTree, myAbstract.startcat);
+				}
+			}
+			else {
+				var selectedRef = refs[Math.floor(refs.length * Math.random())];
+				abstractTree = refineAbstractTree(abstractTree, nodeToRefine, "0", selectedRef);
+				abstractTree = myAbstract.annotate(abstractTree, myAbstract.startcat);
+			}
+/*
+			var selectedRef = refs[Math.floor(refs.length * Math.random())];
+			abstractTree = refineAbstractTree(abstractTree, nodeToRefine, "0", selectedRef);
+			abstractTree = myAbstract.annotate(abstractTree, myAbstract.startcat);
+*/
+		}
+	}
+}
+
+// When the "RandomTree" action is selected, refines the tree at random
+function clickRandomTree(actName) {
+	if (document.getElementById(actName).className == "action") {
+		highlightSelectedAction(actName);
+		pushUndoClearRedo();
+		fillSubTree();
+		concludeAction();
+	}
+}
+
+// If a node is selected and is of type meta, it refines the node with a type refName
+function refClick(refName) {
+	if (selectedNode) {
+		if (refName == "genRefRandom") {
+			var refs = getAvailableRefinements(selectedNode);
+			refName = refs[Math.floor(refs.length * Math.random())];
+		}
+		abstractTree = refineAbstractTree(abstractTree, selectedNode, "0", refName);
+		document.getElementById("actFrame").innerHTML = showActions();
+		document.getElementById("refFrame").innerHTML = "";
+		clearHotKeys();
+		concludeAction();
+	}
+}
+
+// If a refinement is selected, a node has the property "selected" set and the node is a meta variable,
+// it refines node. Returns the refined abstract tree
+function refineAbstractTree(absNode, route, currRoute, refName) {
+	if (route == currRoute && absNode.isMeta()) {
+		return createRefinement(refName);
+	}
+	else {
+		for (var i = 0, j = absNode.args.length; i < j; i++) {
+			absNode.setArg(i, refineAbstractTree(absNode.args[i], route, currRoute + "-" + i, refName));
+		}
+		return absNode;
+	}
+}
+
+// Creates a Fun of type refName object with the appropriate number of meta arguments
+function createRefinement(refName) {
+	var newRef = new Fun(refName);
+	for (var i = 0, j = myAbstract.types[refName].args.length; i < j; i++) {
+		newRef.setArg(i, new Fun("?"));
+	}
+	return newRef;
+}
+
+// Creates a tree from an abstract tree
+function treeFromAbstract(abstractNode, name) {
+  var node = new treeNode(name, abstractNode.name);
+	if (node.caption == "?") {
+		node.cat = abstractNode.type; }
+	else { node.cat = myAbstract.getCat(node.caption); }
+	if (wasCollapsed(node.name)) { node.collapsed = true; }
+	for (var i = 0, j = abstractNode.args.length; i < j; i++) {
+		node.addChild(i, treeFromAbstract(abstractNode.args[i], name + "-" + i));
+	}
+	return node
+}
+
+// Wraps a refinement around a node
+function wrapClick(refName, argPos) {
+	if (selectedNode) {
+		var tempNode = createRefinement(refName);
+		tempNode.setArg(argPos, myAbstract.copyTree(getNodeFromAbstract(abstractTree, selectedNode, "0")));
+		abstractTree = insertNode(abstractTree, selectedNode, "0", tempNode);
+		document.getElementById("actFrame").innerHTML = showActions();
+		document.getElementById("refFrame").innerHTML = "";
+		clearHotKeys();
+		concludeAction();
+	}
+}
+
+// Handler for the escape key
+function clickEsc() {
+	if ((document.getElementById("actRefine").className == "selected" ||
+		document.getElementById("actReplace").className == "selected" ||
+		document.getElementById("actWrap").className == "selected") && undoArray.length) {
+		var prevState = undoArray.pop();
+		selectedNode = prevState.selectedNode;
+		abstractTree = myAbstract.copyTree(prevState.tree);
+		collapseBuffer = prevState.collapseBuffer;
+		abstractTree = myAbstract.annotate(abstractTree, myAbstract.startcat);
+		myTree = treeFromAbstract(abstractTree, "0");
+		document.getElementById("actFrame").innerHTML = showActions();
+		if (selectedNode) { nodeClick(selectedNode) }
+	}
+}
+
+// If there are over ten refinements available shows only the selected nine
+function nextRefsClick(refName) {
+	if (refName == "Next") { refPageCounter++; } else { refPageCounter--; }
+	clearHotKeys();
+	document.getElementById("refFrame").innerHTML = showRefinements(selectedNode);
+}
+
+
+// show overloaded name: ignore prefix ovr*_
+function overl(name){
+  var nam = "";
+  if (name[0] + name[1] + name[2]=="ovr") {
+    i = 5 ; 
+    while (name[i] != '_') {++i}
+    for (j = i+1 ; j != name.length ; ++j){ nam += name[j] ;}
+  }
+  else nam = name ;
+  return nam;
+}
+
+Fun.prototype.printOverl = function () { return this.showOverl(0); } ;
+Fun.prototype.showOverl = function (prec) {
+	if (this.isMeta()) {
+			return '?';
+		
+	} else {
+	  var s = overl(this.name);
+		var cs = this.args;
+		for (var i in cs) {
+			s += " " + cs[i].showOverl(1);
+		}
+		if (prec > 0 && cs.length > 0) {
+			s = "(" + s + ")" ;
+		}
+		return s;
+	}
+};
--- a/demos/resource-api/editor.html
+++ b/demos/resource-api/editor.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+  		<link rel="stylesheet" type="text/css" href="style.css" />
+		<script type="text/javascript" src="gflib.js"></script>
+		<script type="text/javascript" src="grammar.js"></script>
+		<script type="text/javascript" src="grammarReference.js"></script>		
+		<script type="text/javascript" src="code.js"></script>
+  		<title>Syntax Editor for GF Resource Grammar Library</title>
+	</head>
+	<body onload="nodeClick('0', '?')" onkeydown="hotKeys(event)">
+        <h2>Syntax Editor for GF Resource Grammar Library</h2>
+		<div id="wrapper">
+   			<div id="absFrame">
+			</div>
+   			<div id="conFrame">
+			</div>
+   			<div id="actFrame">
+			</div>
+			<div id="refFrame">
+			</div>
+			<div id="messageFrame">
+			</div>
+			<div id="clipboardFrame">
+			</div>
+		</div>
+<p>
+
+Languages shown: English, Russian, Swedish.
+
+<p>
+
+Example: <i>I love you</i> is obtained by <tt>r7 r3 r+7 r2 r+++3 r+7 r9</tt>
+
+<p>
+
+More information: <a href="../../lib/resource/doc/synopsis.html">resource synopsis</a>.
+
+	</body>
+</html>
--- a/demos/resource-api/empty.png
+++ b/demos/resource-api/empty.png
--- a/demos/resource-api/gflib.js
+++ b/demos/resource-api/gflib.js
@@ -0,0 +1,333 @@
+
+/* Extension to the String object */
+
+String.prototype.tag = "";
+String.prototype.setTag = function (tag) { this.tag = tag; };
+
+/* Abstract syntax trees */
+function Fun(name) {
+	this.name = name;
+	this.args = copy_arguments(arguments, 1);
+}
+Fun.prototype.print = function () { return this.show(0); } ;
+Fun.prototype.show = function (prec) {
+	if (this.isMeta()) {
+		if (isUndefined(this.type)) {
+			return '?';
+		} else {
+			var s = '?:' + this.type;
+			if (prec > 0) {
+				s = "(" + s + ")" ;
+			}
+			return s;
+		}
+	} else {
+		var s = this.name;
+		var cs = this.args;
+		for (var i in cs) {
+			s += " " + cs[i].show(1);
+		}
+		if (prec > 0 && cs.length > 0) {
+			s = "(" + s + ")" ;
+		}
+		return s;
+	}
+};
+Fun.prototype.getArg = function (i) {
+	return this.args[i];
+};
+Fun.prototype.setArg = function (i,c) {
+	this.args[i] = c;
+};
+Fun.prototype.isMeta = function() {
+	return this.name == '?';
+} ;
+Fun.prototype.isComplete = function() {
+	if (this.isMeta()) {
+		return false;
+	} else {
+		for (var i in this.args) {
+			if (!this.args[i].isComplete()) {
+				return false;
+			}
+		}
+		return true;
+	}
+} ;
+
+/* Concrete syntax terms */
+
+function Arr() { this.arr = copy_arguments(arguments, 0); }
+Arr.prototype.tokens = function() { return this.arr[0].tokens(); };
+Arr.prototype.sel = function(i) { return this.arr[i.toIndex()]; };
+Arr.prototype.setTag = function(tag) {
+	for (var i = 0, j = this.arr.length; i < j; i++) {
+		this.arr[i].setTag(tag);
+	}
+};
+
+function Seq() { this.seq = copy_arguments(arguments, 0); }
+Seq.prototype.tokens = function() { 
+	var xs = new Array();
+	for (var i in this.seq) {
+		var ys = this.seq[i].tokens();
+		for (var j in ys) {
+			xs.push(ys[j]);
+		}		
+	}
+	return xs; 
+};
+Seq.prototype.setTag = function(tag) {
+	for (var i = 0, j = this.seq.length; i < j; i++) {
+		this.seq[i].setTag(tag);
+	}
+};
+
+function Variants() { this.variants = copy_arguments(arguments, 0); }
+Variants.prototype.tokens = function() { return this.variants[0].tokens(); };
+Variants.prototype.sel = function(i) { return this.variants[0].sel(i); };
+Variants.prototype.toIndex = function() { return this.variants[0].toIndex(); };
+Variants.prototype.setTag = function(tag) {
+	for (var i = 0, j = this.variants.length; i < j; i++) {
+		this.variants[i].setTag(tag);
+	}
+};
+
+function Rp(index,value) { this.index = index; this.value = value; }
+Rp.prototype.tokens = function() { return new Array(this.index.tokens()); };
+Rp.prototype.sel = function(i) { return this.value.arr[i.toIndex()]; };
+Rp.prototype.toIndex = function() { return this.index.toIndex(); };
+Rp.prototype.setTag = function(tag) { this.index.setTag(tag) };
+
+function Suffix(prefix,suffix) {
+	this.prefix = new String(prefix);
+	if (prefix.tag) { this.prefix.tag = prefix.tag; }
+	this.suffix = suffix;
+};
+Suffix.prototype.tokens = function() {
+	var xs = this.suffix.tokens();
+	for (var i in xs) {
+		xs[i] = new String(this.prefix + xs[i]);
+		xs[i].setTag(this.prefix.tag);
+	}
+	return xs;
+};
+Suffix.prototype.sel = function(i) { return new Suffix(this.prefix, this.suffix.sel(i)); };
+Suffix.prototype.setTag = function(tag) { if (!this.prefix.tag) { this.prefix.setTag(tag); } };
+
+function Meta() { }
+Meta.prototype.tokens = function() { 
+	var newString = new String("?");
+	newString.setTag(this.tag);
+	return new Array(newString);
+};
+Meta.prototype.toIndex = function() { return 0; };
+Meta.prototype.sel = function(i) { return this; };
+Meta.prototype.setTag = function(tag) { if (!this.tag) { this.tag = tag; } };
+
+function Str(value) { this.value = value; }
+Str.prototype.tokens = function() {
+	var newString = new String(this.value);	
+	newString.setTag(this.tag);
+	return new Array(newString);
+};
+Str.prototype.setTag = function(tag) { if (!this.tag) { this.tag = tag; } };
+
+function Int(value) { this.value = value; }
+Int.prototype.tokens = function() {
+	var newString = new String(this.value.toString());
+	newString.setTag(this.tag);
+	return new Array(newString);
+};
+Int.prototype.toIndex = function() { return this.value; };
+Int.prototype.setTag = function(tag) { if (!this.tag) { this.tag = tag; } };
+
+/* Type annotation */
+
+function Abstract(startcat) {
+	this.types = new Array();
+	this.startcat = startcat;
+}
+Abstract.prototype.addType = function(fun, args, cat) {
+	this.types[fun] = new Type(args, cat);
+} ;
+Abstract.prototype.getArgs = function(fun) {
+	return this.types[fun].args;
+}
+Abstract.prototype.getCat = function(fun) {
+	return this.types[fun].cat;
+};
+Abstract.prototype.annotate = function(tree, type) {
+	if (tree.name == '?') {
+		tree.type = type;
+	} else {
+		var typ = this.types[tree.name];
+		for (var i in tree.args) {
+			this.annotate(tree.args[i], typ.args[i]);
+		}
+	}
+	return tree;
+} ;
+/* Hack to get around the fact that our SISR doesn't build real Fun objects. */
+Abstract.prototype.copyTree = function(x) {
+	var t = new Fun(x.name);
+	if (!isUndefined(x.type)) {
+	  t.type = x.type;
+	}
+	var cs = x.args;
+	if (!isUndefined(cs)) {
+	  for (var i in cs) {
+	    t.setArg(i, this.copyTree(cs[i]));
+	  }
+	}
+	return t;
+} ;
+Abstract.prototype.parseTree = function(str, type) { 
+	return this.annotate(this.parseTree_(str.match(/[\w\']+|\(|\)|\?|\:/g), 0), type); 
+} ;
+Abstract.prototype.parseTree_ = function(tokens, prec) {
+	if (tokens.length == 0 || tokens[0] == ")") { return null; }
+	var t = tokens.shift();
+	if (t == "(") {
+		var tree = this.parseTree_(tokens, 0);
+		tokens.shift();
+		return tree;
+	} else if (t == '?') {
+		var tree = this.parseTree_(tokens, 0);
+		return new Fun('?');
+	} else {
+		var tree = new Fun(t);
+		if (prec == 0) {
+			var c, i;
+			for (i = 0; (c = this.parseTree_(tokens, 1)) !== null; i++) {
+				tree.setArg(i,c);
+			}
+		}
+		return tree;
+	}
+} ;
+
+function Type(args, cat) {
+	this.args = args;
+	this.cat = cat;
+}
+
+/* Linearization */
+
+function Concrete(abstr) {
+	this.abstr = abstr;
+	this.rules = new Array();
+}
+Concrete.prototype.rule = function (name, cs) { return this.rules[name](cs); };
+Concrete.prototype.addRule = function (name, f) { this.rules[name] = f; };
+Concrete.prototype.lindef = function (cat, v) {	return this.rules[cat]([new Str(v)]); } ;
+Concrete.prototype.linearize = function (tree) { 
+	return this.unlex(this.linearizeToTerm(tree).tokens());
+};
+Concrete.prototype.linearizeToTerm = function (tree) {
+	if (tree.isMeta()) {
+		if (isUndefined(tree.type)) {
+			return new Meta();
+		} else {
+			return this.lindef(tree.type, tree.name);
+		}
+	} else {
+	    var cs = new Array();
+		for (var i in tree.args) {
+		  cs.push(this.linearizeToTerm(tree.args[i]));
+		}
+		var newTerm = this.rule(tree.name, cs);
+		return newTerm;
+	}
+};
+Concrete.prototype.unlex = function (ts) {
+	if (ts.length == 0) {
+		return "";
+	}
+
+	var noSpaceAfter = /^[\(\-\[]/;
+	var noSpaceBefore = /^[\.\,\?\!\)\:\;\-\]]/;
+
+	var s = "";
+	for (var i = 0; i < ts.length; i++) {
+		var t = ts[i];
+		var after = i < ts.length-1 ? ts[i+1] : null;
+		s += t;
+		if (after != null && !t.match(noSpaceAfter) 
+				  && !after.match(noSpaceBefore)) {
+			s += " ";
+		}
+	}
+	return s;
+};
+Concrete.prototype.tagAndLinearize = function (tree) {
+//	return this.tagAndLinearizeToTerm(tree, "0").tokens();
+	var treeTerms = this.tagAndLinearizeToTerm(tree, "0");
+	var treeTokens = treeTerms.tokens();	
+	return treeTokens;
+};
+Concrete.prototype.tagAndLinearizeToTerm = function (tree, route) {
+	if (tree.isMeta()) {
+		if (isUndefined(tree.type)) {
+			var newMeta = new Meta();
+			newMeta.setTag(route);
+			return newMeta;
+		} else {
+			var newTerm = this.lindef(tree.type, tree.name);
+			newTerm.setTag(route);
+			return newTerm;
+		}
+	} else {
+	    var cs = new Array();
+		for (var i in tree.args) {
+		  cs.push(this.tagAndLinearizeToTerm(tree.args[i], route + "-" + i));
+		}
+		var newTerm = this.rule(tree.name, cs);
+		newTerm.setTag(route);
+		return newTerm;
+	}
+};
+
+/* Utilities */
+
+/* from Remedial JavaScript by Douglas Crockford, http://javascript.crockford.com/remedial.html */
+function isString(a) { return typeof a == 'string'; }
+function isArray(a) { return a && typeof a == 'object' && a.constructor == Array; }
+function isUndefined(a) { return typeof a == 'undefined'; }
+function isBoolean(a) { return typeof a == 'boolean'; }
+function isNumber(a) { return typeof a == 'number' && isFinite(a); }
+function isFunction(a) { return typeof a == 'function'; }
+
+function dumpObject (obj) {
+	if (isUndefined(obj)) {
+		return "undefined";
+	} else if (isString(obj)) {
+		return '"' + obj.toString() + '"'; // FIXME: escape
+	} else if (isBoolean(obj) || isNumber(obj)) {
+		return obj.toString();
+	} else if (isArray(obj)) {
+		var x = "[";
+		for (var i in obj) {
+			x += dumpObject(obj[i]);
+			if (i < obj.length-1) {
+				x += ",";
+			}
+		}
+		return x + "]";		
+	} else {
+		var x = "{";
+		for (var y in obj) {
+			x += y + "=" + dumpObject(obj[y]) + ";" ;
+		}
+		return x + "}";
+	}
+}
+
+
+function copy_arguments(args, start) {
+	var arr = new Array();
+	for (var i = 0; i < args.length - start; i++) {
+		arr[i] = args[i + start];
+	}
+	return arr;
+}
--- a/demos/resource-api/grammar.js
+++ b/demos/resource-api/grammar.js
--- a/demos/resource-api/grammarReference.js
+++ b/demos/resource-api/grammarReference.js
@@ -0,0 +1,10 @@
+// Grammar Reference
+function concreteReference(concreteSyntax, concreteSyntaxName) {
+this.concreteSyntax = concreteSyntax;
+this.concreteSyntaxName = concreteSyntaxName;
+}
+var myAbstract = OverLang ;
+var myConcrete = new Array();
+myConcrete.push(new concreteReference(OverLangEng,"OverLangEng"));
+myConcrete.push(new concreteReference(OverLangRus,"OverLangRus"));
+myConcrete.push(new concreteReference(OverLangSwe,"OverLangSwe"));
--- a/demos/resource-api/index.html
+++ b/demos/resource-api/index.html
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+ <HEAD>
+  <TITLE>Index of /~aarne/GF/demos/overl</TITLE>
+ </HEAD>
+ <BODY>
+<H1>Index of /~aarne/GF/demos/overl</H1>
+<PRE><IMG SRC="/icons/blank.gif" ALT="     "> <A HREF="?N=D">Name</A>                    <A HREF="?M=A">Last modified</A>       <A HREF="?S=A">Size</A>  <A HREF="?D=A">Description</A>
+<HR>
+<IMG SRC="/icons/back.gif" ALT="[DIR]"> <A HREF="/~aarne/GF/demos/">Parent Directory</A>        20-Dec-2007 23:44      -  
+<IMG SRC="/icons/unknown.gif" ALT="[   ]"> <A HREF="code.js">code.js</A>                 20-Dec-2007 22:46    33k  
+<IMG SRC="/icons/text.gif" ALT="[TXT]"> <A HREF="editor.html">editor.html</A>             29-Oct-2007 09:58     1k  
+<IMG SRC="/icons/image2.gif" ALT="[IMG]"> <A HREF="empty.png">empty.png</A>               04-Oct-2007 10:45     1k  
+<IMG SRC="/icons/unknown.gif" ALT="[   ]"> <A HREF="gflib.js">gflib.js</A>                20-Dec-2007 22:40     9k  
+<IMG SRC="/icons/unknown.gif" ALT="[   ]"> <A HREF="grammar.js">grammar.js</A>              20-Dec-2007 23:16   3.4M  
+<IMG SRC="/icons/unknown.gif" ALT="[   ]"> <A HREF="grammarReference.js">grammarReference.js</A>     20-Dec-2007 23:16     1k  
+<IMG SRC="/icons/image2.gif" ALT="[IMG]"> <A HREF="minus.png">minus.png</A>               04-Oct-2007 10:46     1k  
+<IMG SRC="/icons/image2.gif" ALT="[IMG]"> <A HREF="plus.png">plus.png</A>                04-Oct-2007 10:46     1k  
+<IMG SRC="/icons/text.gif" ALT="[TXT]"> <A HREF="style.css">style.css</A>               29-Oct-2007 10:05     3k  
+</PRE><HR>
+</BODY></HTML>
--- a/demos/resource-api/minus.png
+++ b/demos/resource-api/minus.png
--- a/demos/resource-api/plus.png
+++ b/demos/resource-api/plus.png
--- a/demos/resource-api/style.css
+++ b/demos/resource-api/style.css
@@ -0,0 +1,198 @@
+body {
+	font-family:arial,helvetica,sans-serif;
+	font-size:12px;
+	background-color: white;
+}
+
+#wrapper {
+	width:600px;
+	height:520px;
+	margin:auto 50px;
+	border:1px solid gray;
+	padding:10px;
+
+}
+
+#absFrame {
+ 	width:180px;
+ 	height:250px;
+	padding:10px;
+	border:1px solid gray;
+   	float:left;
+   	white-space: nowrap;
+}
+
+#conFrame {
+	width:366px;
+	height:250px;
+	margin-left:10px;
+	padding:10px;
+	border:1px solid gray;
+   	float:left;
+   	white-space: normal;
+   	overflow:auto;
+}
+
+#actFrame {
+	width:180px;
+	height:170px;
+	margin-top:10px;
+	padding:10px;
+	border:1px solid gray;
+   	float:left;
+   	overflow:auto;
+}
+
+#refFrame {
+	width:366px;
+	height:170px;
+	margin-left:10px;
+	margin-top:10px;
+	padding:10px;
+	border:1px solid gray;
+   	float:left;
+   	overflow:auto;
+}
+
+#messageFrame {
+	width:366px;
+	height:15px;
+	margin-top:10px;
+	margin-right:10px;
+	padding:10px;
+	border:1px solid gray;
+   	float:left;
+   	overflow:auto;
+}
+
+#clipboardFrame {
+	width:180px;
+	height:15px;
+	margin-top:10px;
+	padding:10px;
+	border:1px solid gray;
+   	float:left;
+   	overflow:auto;
+}
+
+#tree {
+	left: -10px;
+	top: -10px;	
+	width: 180px;
+	height: 250px;
+	margin: 0px;
+	padding: 10px;
+	overflow: auto;
+}
+
+ul {
+	position: relative;
+	list-style: none;
+	margin-left: 20px;
+	padding: 0px;
+}
+
+li {
+	position: relative;
+}
+
+img.tree-menu {
+	margin-right: 5px;
+}
+
+a.tree:link, a.tree:visited, a.tree:active {
+	color: black;
+	background-color: white;
+	text-decoration: none;
+	margin-right:10px;
+}
+
+a.tree:hover {
+	color: blue;
+	background-color: white;
+	text-decoration: underline;
+	margin-right:10px;
+}
+
+a.treeSelected:link, a.treeSelected:visited, a.treeSelected:active {
+	color: white;
+	background-color: #3366CC;
+	text-decoration: none;
+	margin-right:10px;
+}
+
+a.treeSelected:hover {
+	color: white;
+	background-color: #3366CC;
+	text-decoration: underline;
+	margin-right:10px;
+}
+
+table.action, table.refinement, table.wrapper {
+	margin: 0px;
+	padding: 0px;
+	border-style: none;
+	border-collapse: collapse;
+	border-spacing: 0px;
+}
+
+tr.selected {
+	color: white;
+	background-color: #3366CC;
+}
+
+tr.unavailable, tr.closed {
+	color: silver;
+	background-color: white;
+}
+
+tr.unavailable:hover {
+	color: silver;
+	background-color: #3366CC;
+}
+
+tr.action, tr.refinement, tr.wrapper {
+	color: black;
+	background-color: white;
+}
+
+tr.action:hover, tr.refinement:hover, tr.wrapper:hover {
+	color: white;
+	background-color: #3366CC;
+}
+
+td.action {
+	width: 220px;
+	margin: 0px;
+	padding: 0px;
+}
+
+td.refinement, td.wrapper {
+	width: 515px;
+	margin: 0px;
+	padding: 0px;
+}
+
+td.hotKey {
+	width: 30px;
+	margin: 0px;
+	padding: 0px;
+	text-align: right;
+}
+
+p {
+	margin-bottom: 40px;
+	text-align: justify;
+}
+
+span.normal {
+	color: black;
+	background-color: white;
+	text-decoration: none;
+}
+
+span.selected {
+	color: white;
+	background-color: #3366CC;
+	text-decoration: none;
+}
--- a/demos/resourcegrammars.t2t
+++ b/demos/resourcegrammars.t2t
@@ -0,0 +1,19 @@
+Computational Grammars for the World
+The GF Resource Grammar Library
+
+
+
+Did you ever struggle with the inflection of French verbs? Or with getting the words in a German sentence into the right order? 
+Don't worry: these problems are as easy for a computer as to calculate 2+2. This page will give you access to computer programs that
+- help you construct sentences and other expressions
+- help you inflect words
+- help you covert sentences to different tenses, and other similar operations
+- help you compare languages by translating them and linking corresponding parts
+- allow you to practice your language skills by automatically generated and graded exercises
+- explain grammar rules in a mathematically precise and shortest possible manner
+
+
+//Coming soon!// for 29 languages.
+
+Powered by [GF ..] and its [Resource Grammar Library ../lib/doc/synopsis.html]
+
--- a/demos/translation.t2t
+++ b/demos/translation.t2t
@@ -0,0 +1,100 @@
+Translation with GF
+Powered by multilingual grammars
+
+%!style:../css/style0.css
+%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.svg" alt=""></a>
+%!postproc(html): #GFWCT <iframe style="border: 0; width: 100%; height: 50ex;" src="http://cloud.grammaticalframework.org/wc.html#embed"></iframe>
+
+==Try it online==
+
+%**Coming soon**:
+%//Here you will be able to select your source and target language and translate% whatever you want.//
+#GFWCT
+
+
+==Download the app==
+
+[App description and download page ./app.html]
+
+
+==Colours==
+
+- **Green: semantic translation**, should be correct.
+                 But not necessarily the only correct one. 
+- **Yellow: syntactic translation**, should be grammatically correct.
+                 But can be very strange in its interpretation and choice of words.
+- **Light red: chunk translation**, probably incorrect.
+                 Builds the translation from small pieces.
+- **Dark red: word-by-word translation**, almost certainly incorrect.
+                 Builds the translation word by word and returns unknown words verbatim.
+
+
+The green translations currently come from a tourist phrasebook, which allows
+you to translate things like "hello" and "how far is the airport from
+the hotel". But this part can be easily adapted to other uses, such as
+technical language.
+
+
+==What you can expect==
+
+The program is designed to translate anything, just like Google translate and Bing. It has some advantages over them:
+- It uses **grammars** (as opposed to statistics), which makes it more correct in many cases.
+- It is **open source**, which means you can inspect, copy, and modify it in what ever way you want.
+- It is **light weight**, so that you can run it on your own computer and even on a smartphone.
+- It gives you **linguistic information**, such as word inflections.
+- It gives you **confidence information**, warning about translations that it is not so sure about.
+
+
+However, this is not a mature product but a research prototype. It therefore has some shortcomings:
+- It has **limited coverage**, which means that it misses many words and syntactic constructions.
+- It can be **clumsy**, for instance when it doesn't detect an idiom but translates too literally.
+- It can be **slow**, in particular with long sentences and with some input languages.
+
+
+Here are some hints to use it in a satisfactory way:
+- Start with short sentences (less than ten words), preferably from English or Swedish, to get an idea of the best performance.
+- Take a look at the alternative translations, in particular for sentences with low confidence level.
+- Send us feedback, and consider contributing to the improvement of the system!
+
+
+
+The following table gives a rough idea of what to expect for each
+language (the speech column refers to the Android app):
+'''
+<center>
+<table rules=all border=yes>
+<tr> <th></th>          <th>coverage</th> <th>quality</th> <th>speed</th> <th>speech</th> </tr>
+<tr> <th>Bulgarian</th> <td bgcolor=yellow></td> <td bgcolor=yellow></td><td bgcolor=palegreen></td> <td bgcolor=yellow>in only</td></tr>
+<tr> <th>Chinese</th>   <td bgcolor=pink></td> <td bgcolor=pink></td> <td bgcolor=palegreen></td> <td bgcolor=yellow>diff in/out</td> </tr>
+<tr> <th>Dutch</th>     <td bgcolor=yellow></td> <td bgcolor=yellow></td> <td bgcolor=yellow></td> <td bgcolor=palegreen></td> </tr>
+<tr> <th>English</th>   <td bgcolor=palegreen></td> <td bgcolor=palegreen></td> <td bgcolor=palegreen></td> <td bgcolor=palegreen></td> </tr>
+<tr> <th>Finnish</th>   <td bgcolor=yellow></td> <td bgcolor=yellow></td><td bgcolor=pink></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>French</th>    <td bgcolor=pink></td> <td bgcolor=yellow></td><td bgcolor=pink></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>German</th>    <td bgcolor=pink></td> <td bgcolor=yellow></td><td bgcolor=pink></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>Hindi</th>     <td bgcolor=pink></td> <td bgcolor=pink></td> <td bgcolor=yellow></td> <td bgcolor=yellow>out only</td> </tr>
+<tr> <th>Italian</th>    <td bgcolor=pink></td> <td bgcolor=pink></td><td bgcolor=pink></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>Spanish</th>    <td bgcolor=pink></td> <td bgcolor=yellow></td><td bgcolor=pink></td> <td bgcolor=palegreen></td></tr>
+<tr> <th>Swedish</th>   <td bgcolor=yellow></td> <td bgcolor=yellow></td> <td bgcolor=palegreen></td> <td bgcolor=palegreen></td> </tr>
+</table>
+</center>
+'''
+
+
+==How it works==
+
+Powered by [Grammatical Framework ../]
+
+[Slides https://docs.google.com/presentation/d/1545yYmTlWgzyV1uwUwuvAsOCzdD1AIUdV_NZbZ1qMEo/edit?usp=sharing]
+explaining the translation method:
+
+
+==Get the sources==
+
+Download from [here ../download/]
+
+
+==Send us feedback==
+
+
+
+
--- a/doc/GF-0.1.tgz
+++ b/doc/GF-0.1.tgz
--- a/doc/Logos/gf-logo.gif
+++ b/doc/Logos/gf-logo.gif
--- a/doc/Logos/gf-logo.png
+++ b/doc/Logos/gf-logo.png
--- a/doc/Logos/gf0.png
+++ b/doc/Logos/gf0.png
--- a/doc/Logos/gf0.svg
+++ b/doc/Logos/gf0.svg
@@ -0,0 +1 @@
+<?xml version="1.0" standalone="no"?>
--- a/doc/Logos/gf00.png
+++ b/doc/Logos/gf00.png
--- a/doc/Logos/gf00.svg
+++ b/doc/Logos/gf00.svg
@@ -0,0 +1 @@
+<?xml version="1.0" standalone="no"?>
--- a/doc/Logos/gf1.svg
+++ b/doc/Logos/gf1.svg
@@ -0,0 +1,14 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+
+<svg width="240" height="240" version="1.1" xmlns="http://www.w3.org/2000/svg">
+   <filter id="A"><feGaussianBlur stdDeviation="2"/></filter> 
+   <path filter="url(#A)"
+	 d="M120,227.5 v-51 h59 m-59,0 v-53 h114 a110.5,105 0 1,1 -24,-66"
+         fill="none" stroke="black" stroke-width="4" opacity="0.25"
+         stroke-linejoin="round" stroke-linecap="round"/>
+   <path d="M120,225.5 v-51 h59 m-59,0 v-53 h114 a110.5,105 0 1,1 -24,-66"
+         fill="none" stroke="red" stroke-width="4"
+         stroke-linejoin="round" stroke-linecap="round"/>
+</svg>
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -0,0 +1,12 @@
+gf-help-full.txt::
+	{ echo ; echo ; echo ; } > $@
+	echo help -full -t2t | gf -run >> $@
+
+### Converting SVG logos to PNG, using convert from ImageMagick
+logos:: Logos/gf00.png Logos/gf0.png
+
+Logos/gf00.png: Logos/gf00.svg Makefile
+	convert -background 'rgba(255,255,255,0)' -size 264x216 -depth 8 $< $@
+
+Logos/gf0.png: Logos/gf0.svg Makefile
+	convert -background 'rgba(255,255,255,0)' -size 320x240 -depth 8 $< $@
--- a/doc/align6.png
+++ b/doc/align6.png
--- a/doc/darcs-cm
+++ b/doc/darcs-cm
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+DARCS=`which darcs`
+SSH=`which ssh`
+REPOSERVER=gfreposerver
+
+if [ ! -x "$SSH" ]; then
+  echo "ssh ($SSH): command not found" 1>&2
+  exit 1
+fi
+
+if [ "$1" = "--stop" ]; then
+  $SSH -O exit "$REPOSERVER"
+  exit $?
+fi
+
+if [ ! -x "$DARCS" ]; then
+  echo "darcs ($DARCS): command not found" 1>&2
+  exit 1
+fi
+
+if ! $SSH -O check "$REPOSERVER" >& /dev/null; then
+  echo "Connection to $REPOSERVER is down, connecting..."
+  $SSH -f -M "$REPOSERVER" \
+     "bash -c 'while true; do echo -n .; sleep 30; done'" > /dev/null
+  sleep 1
+fi
+
+exec $DARCS "$@"
--- a/doc/error-messages.txt
+++ b/doc/error-messages.txt
@@ -0,0 +1,551 @@
+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"
+
--- a/doc/errors/gluing.md
+++ b/doc/errors/gluing.md
@@ -0,0 +1,27 @@
+## 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
--- a/doc/gf-bib.bib
+++ b/doc/gf-bib.bib
--- a/doc/gf-bibliography.t2t
+++ b/doc/gf-bibliography.t2t
@@ -0,0 +1,816 @@
+Grammatical Framework Bibliography
+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>
+
+==Publications on GF==
+
+In reverse temporal order:
+
+H. Burden and R. Heldal.
+Natural Language Generation from Class Diagrams.
+//Proceedings of the 8th International Workshop on Model-Driven Engineering, Verification and Validation (MoDeVVa 2011)//,
+Wellington, New Zealand,
+ACM,
+2011.
+[Draft PDF http://www.grammaticalframework.org/doc/archive/a9-burden.pdf]
+#BR
+//Using GF to verbalize platform-independent requirement specifications as a part of a software engineering tool chain.//
+
+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.
+[PDF http://www.lsi.upc.edu/~cristinae/CV/docs/MTS11PatEspanaetal.pdf]
+#BR
+//First steps to a hybrid GF-SMT system.//
+
+Seyed M. Montazeri, Nivir Roy, and Gerardo Schneider. 
+From Contracts in Structured English to CL Specifications. 
+//5th International Workshop on Formal Languages and Analysis of Contract-Oriented Software (FLACOS'11)//, 
+volume 68 of EPTCS, pages 55-69, 
+Málaga, Spain, 22-23 September 2011.
+[PDF/DOI http://dx.doi.org/10.4204/EPTCS.68.6]
+#BR
+//Formal analysis of contracts written in controlled English.//
+
+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.
+[PDF http://lml.bas.bg/~iva/ranlp2011/RANLR2011_Proceedings.PDF]
+#BR
+//Punjabi syntax, building on Humayoun and Ranta 2010.//
+
+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
+[PDF http://publications.lib.chalmers.se/cpl/record/index.xsql?pubid=145395]
+#BR
+//Representing and verbalizing in GF of an Cultural Heritage ontology.// 
+
+A. Ranta.
+Translating between Language and Logic: What Is Easy and What is Difficult?
+In N. Bjørner and V. Sofronie-Stokkermans (eds.),
+//CADE-23. Automated Deduction//,
+LNCS/LNAI 6803,
+pp. 5-25,
+2011.
+[PDF at Springer http://www.springerlink.com/content/42n685777k846810/]
+[Draft PDF http://www.cse.chalmers.se/~aarne/articles/cade2011.pdf]
+#BR
+//Invited talk at the CADE conference, showing how GF can help writing natural language interfaces// 
+//to proof systems, and also exploring how to make the language richer, e.g. how to get from//
+//"for all numbers x, x is even or x is odd" to "every number is even or odd".//
+
+A. Ranta. 
+//Grammatical Framework: Programming with Multilingual Grammars//, 
+  CSLI Publications, Stanford, 2011.
+  [Book web page http://www.grammaticalframework.org/gf-book/] 
+#BR
+//Meant as the standard reference and textbook on GF.//
+
+O. Caprotti, K. Angelov, R. Enache, T. Hallgren, A. Ranta.
+The MOLTO Phrasebook.
+Swedish Language Technology Conference SLTC 2010.
+[PDF http://publications.lib.chalmers.se/cpl/record/index.xsql?pubid=131251]
+#BR
+//Tourist Phrasebook grammar, available in 14 European languages.//
+
+
+G. Détrez and R. Enache.
+A Framework for Multilingual Applications on the Android Platform
+Swedish Language Technology Conference SLTC 2010.
+[PDF http://www.grammaticalframework.org/doc/archive/sltc10_submission_24.pdf]
+#BR
+//A description of the Java implementation of the GF runtime system, which makes it possible//
+to create grammar-based applications running on an Android phone.//
+
+Normunds Gruzitis and Guntis Barzdins.
+Towards a More Natural Multilingual Controlled Language Interface to OWL,
+//9th International Conference on Computational Semantics (IWCS)//,
+pp. 335-339,
+2011.
+[PDF http://www.aclweb.org/anthology/W/W11/W11-0138.pdf]
+#BR
+//Access to ontologies in English and Latvian.//
+
+M. Humayoun and A. Ranta. 
+Developing Punjabi Morphology, Corpus and Lexicon. 
+//The 24th Pacific Asia conference on Language, Information and Computation (PACLIC24)//,
+2010.
+#BR
+//Yet another South-East Asian language, spoken by 88 million people.//
+
+J. Camilleri, Gordon J. Pace, and Mike Rosner.
+Playing Nomic using a Controlled Natural Language.
+//CNL 2010, Controlled Natural Language//,
+Marettimo,
+2010.
+#BR
+//Using GF for defining the rules of a game.//
+
+R. Enache and K. Angelov
+Typeful Ontologies with Direct Multilingual Verbalization.
+//CNL 2010, Controlled Natural Language//,
+Marettimo, 
+2010.
+#BR
+//Investigating the benefits of using GF as a language for representing ontologies.//
+[PDF http://www.grammaticalframework.org/doc/archive/cnl2010_submission_2.pdf]
+
+S. Virk, M. Humayoun, and A. Ranta. 
+An Open Source Urdu Resource Grammar. 
+//Proceedings of the 8th Workshop on Asian Language Resources (Coling 2010 workshop)//,
+2010.
+#BR
+//The national language of Pakistan, spoken by 60 million people; almost the same as Hindi.//
+
+A. Ranta, K. Angelov, and T. Hallgren.
+Tools for multilingual grammar-based translation on the web.
+//Proceedings of the ACL 2010 System Demonstrations//,
+ACM Digital Library,
+2010.
+[PDF http://www.aclweb.org/anthology-new/P/P10/P10-4012.pdf]
+#BR
+//An overview of GF for developers and users of translation systems.//
+
+D. Dannélls and J. Camilleri. 
+Verb Morphology of Hebrew and Maltese - Towards an Open Source Type Theoretical Resource Grammar in GF.
+//Proceedings of the Language Resources (LRs) and Human Language Technologies (HLT) for Semitic Languages Status, Updates, and Prospects, LREC-2010 Workshop//,
+Malta, pp. 57-61.
+2010.
+[PDF http://spraakdata.gu.se/svedd/pub/lrec10.pdf]
+#BR
+//A study of Semitic non-concatenative morphology from the GF point of view.//
+
+M. Humayoun and C. Raffalli.
+MathNat - Mathematical Text in a Controlled Natural Language. 
+//Special issue: Natural Language Processing and its Applications. Journal on Research in Computing Science//, Volume 46. 
+2010.
+#BR
+//Natural language interface to a proof system, implemented in GF.//
+
+D. Dannélls.
+Discourse Generation from Formal Specifications Using the Grammatical Framework, GF. 
+//Special issue: Natural Language Processing and its Applications.  Journal on Research in Computing Science (RCS)//, 
+volume 46. pp. 167-178,
+2010.
+#BR
+//Interfacing GF with ontology, with a natural language generation perspective.//
+
+R. Enache, A. Ranta, and K. Angelov.
+An Open-Source Computational Grammar of Romanian.
+A. Gelbukh (ed.), //CiCLING-2010//,
+LNCS 6008,
+2010.
+#BR
+//A Romance language different enough not to follow the Romance functor.//
+
+K. Angelov and A. Ranta.
+Implementing Controlled Languages in GF.
+N. Fuchs (ed.), //CNL-2009 Controlled Natural Languages//,
+LNCS/LNAI 5972,
+2010.
+
+K. Angelov, B. Bringert and A. Ranta.
+PGF: A Portable Run-time Format for Type-theoretical Grammars,
+//Journal of Logic, Language and Information//,
+19(2),
+pp. 201-228,
+2009.
+[SpringerLink http://www.springerlink.com/content/y32q021028747k70/]
+
+A. Ranta.
+The GF Resource Grammar Library.
+//Linguistic Issues in Language Technology//, 
+2 (2),
+2009.
+[PDF http://elanguage.net/journals/index.php/lilt/article/viewFile/214/158]
+#BR
+//A systematic presentation of the library from the linguistic point of view.//
+
+A. Ranta.
+Grammatical Framework: A Multilingual Grammar Formalism, 
+//Language and Linguistics Compass//, 
+Vol. 3, [on-line http://www.blackwell-compass.com/subject/linguistics/article_view?parent=section&last_results=section%3Dlnco-computational&sortby=date&section=lnco-computational&browse_id=lnco_articles_bpl155&article_id=lnco_articles_bpl155]
+2009.
+#BR
+//An overview of GF for readers with a general academic brackground.//
+
+A. Ranta and K. Angelov.
+Implementing Controlled Languages in GF.
+//CNL-2009//,
+//CEUR Workshop Proceedings//,
+vol. 448,
+[on-line http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-448/],
+2009.
+#BR
+//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.//
+
+A. Ranta. Grammars as Software Libraries.
+In Y. Bertot, G. Huet, J-J. Lévy, and G. Plotkin (eds.),
+//From Semantics to Computer Science//,
+Cambridge University Press, Cambridge, 
+pp. 281-308,
+2009.
+[pdf (preliminary version) http://www.cse.chalmers.se/~aarne/articles/libraries-kahn.pdf]
+#BR
+//Grammar-libraries from the software engineering point of view, with an example application to mathematical language.//
+
+K. Angelov.
+Incremental Parsing in Parallel Multiple Context-Free Grammars.
+EACL 2009.
+#BR
+//Describes the algorithm used in parsing with GF.//
+
+A. Ranta, B. Bringert, and K. Angelov. 
+The GF Grammar Development Environment. 
+System demo. Proceedings of //EACL-2009//,
+2009.
+[PDF http://www.aclweb.org/anthology-new/E/E09/E09-2015.pdf]
+#BR
+//An overview of GF from the grammarian's point of view.//
+ 
+B. Bringert, K. Angelov, and A. Ranta. 
+Grammatical Framework Web Service,
+System demo. Proceedings of //EACL-2009//,
+2009.
+[PDF http://www.aclweb.org/anthology-new/E/E09/E09-2003.pdf]
+#BR
+//An overview of how to build web services on top of PGF using the Google Web Toolkit.//
+
+
+A. Ranta and K. Angelov. 
+Implementing Controlled Languages in GF,
+To appear in the proceedings of //CNL-2009//, LNCS, Springer,
+2009.
+#BR
+//On the use of GF for controlled languages, exemplified by an implementation of Attempto Controlled English then ported to three other language.//
+
+R. Cooper and A. Ranta. 
+Natural Languages as Collections of Resources. 
+In //Language in Flux: Dialogue Coordination, Language Variation, Change//, 
+ed. by R. Cooper and R. Kempson, pp. 109-120. London: College Publications,
+2008.
+#BR
+//The resource grammar idea applied to language learning and evolution.//
+
+Moisés Salvador Meza Moreno and B. Bringert.
+Interactive Multilingual Web Applications with Grammatical Framework.
+In B. Nordström and A. Ranta (eds), 
+//Advances in Natural Language Processing (GoTAL 2008)//, 
+LNCS/LNAI 5221, Springer,
+2008.
+#BR
+//Shows how GF compiled to JavaScript is used in dynamic multilingual web pages.//
+
+Peter Ljunglöf and Staffan Larsson. 
+A grammar formalism for specifying ISU-based dialogue systems.
+In B. Nordström and A. Ranta (eds), 
+//Advances in Natural Language Processing (GoTAL 2008)//, 
+LNCS/LNAI 5221, Springer,
+2008.
+[pdf http://www.ling.gu.se/~peb/pubs/LjunglofLarsson-2008a.pdf]
+#BR
+//Explains how GoDiS dialogue systems are specified by GF grammars.//
+
+K. Angelov.
+Type-Theoretical Bulgarian Grammar.
+In B. Nordström and A. Ranta (eds), 
+//Advances in Natural Language Processing (GoTAL 2008)//, 
+LNCS/LNAI 5221, Springer,
+2008.
+#BR
+//Explains the implementation of a Bulgarian resource grammar in GF.//
+
+B. Bringert.
+High-precision Domain-specific Interlingua-based Speech Translation
+with Grammatical Framework.
+//Coling 2008 Workshop on Speech Translation for Medical and Other Safety-Critical Applications//, 
+Manchester, UK, August 23, 
+2008.
+#BR
+//Shows how to build spoken language translators based on GF grammars and their compilation to Nuance.//
+
+A. Ranta.
+How predictable is Finnish morphology? An experiment on lexicon construction.
+In J. Nivre, M. Dahllöf and B. Megyesi (eds),
+//Resourceful Language Technology: Festschrift in Honor of Anna Sågvall Hein//,
+University of Uppsala,
+2008.
+Available from [series homepage http://publications.uu.se/abstract.xsql?dbid=8933]
+#BR
+//Presents an experiment on smart paradigms in Finnish.//
+
+A. Ranta.
+Example-based grammar writing.
+To appear in L. Borin and S. Larsson (eds),
+Festschrift for Robin Cooper,
+2007.
+#BR
+//Presents and discusses the ideas of grammar composition and example-based grammar writing.//
+
+B. Bringert.
+Rapid Development of Dialogue Systems by Grammar Compilation.
+//8th SIGdial Workshop on Discourse and Dialogue//, 
+Antwerp, Belgium, September 1-2, 
+2007.
+[pdf http://www.cse.chalmers.se/~bringert/publ/gf-voicexml/gf-voicexml.pdf]
+#BR
+//Shows how to build a web-based spoken dialogue system by generating VoiceXML and JavaScript.//
+
+A. El Dada and A. Ranta.
+Implementing an Open Source Arabic Resource Grammar in GF.
+In M. Mughazy (ed),
+//Perspectives on Arabic Linguistics XX. Papers from the Twentieth Annual Symposium on Arabic Linguistics, Kalamazoo, March 26//
+John Benjamins Publishing Company.
+2007.
+#BR
+//An outline of the Arabic resource grammar project, focusing on linguistic aspects.//
+
+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
+//A case study with the resource grammar, focusing on the morphosyntax//
+//and agreement of constructions with numerals.//
+
+A. Ranta.
+Modular Grammar Engineering in GF.
+//Research on Language and Computation//, 
+5:133-158, 2007.
+Draft available as [pdf http://www.cse.chalmers.se/~aarne/articles/multieng3.pdf].
+#BR
+//Adapts library-based software engineering methods to grammar writing// 
+//and introduces the module system of GF.//
+
+A. Ranta.
+The GF Grammar Compiler.
+//Workshop on New Directions in Type-theoretic Grammars//,
+Dublin, August 2007 (ESSLLI workshop).
+2007.
+[pdf http://www.cse.chalmers.se/~aarne/articles/ar-compiler.pdf]
+#BR
+//Describes the compilation of GF source code to lower-level run-time formats.//
+
+M. Humayoun, H. Hammarström, and A. Ranta.
+Urdu Morphology, Orthography and Lexicon Extraction.
+//CAASL-2: The Second Workshop on Computational Approaches to Arabic Script-based Languages//,
+July 21-22, 2007, LSA 2007 Linguistic Institute, Stanford University.
+2007.
+#BR
+//Fairly complete open-source Urdu morphology and elemenraty syntax in GF.//
+
+N. Perera and A. Ranta.
+Dialogue System Localization with the GF Resource Grammar Library.
+//SPEECHGRAM 2007: ACL Workshop on Grammar-Based Approaches to Spoken Language Processing//,
+June 29, 2007, Prague.
+2007.
+[pdf http://www.cse.chalmers.se/~aarne/articles/perera-ranta.pdf]
+#BR
+//An experiment in porting an in-car dialogue system from two to six languages.// 
+
+
+B. Bringert.
+Speech Recognition Grammar Compilation in Grammatical Framework
+//SPEECHGRAM 2007: ACL Workshop on Grammar-Based Approaches to Spoken Language Processing//,
+June 29, 2007, Prague.
+2007.
+#BR
+//Generation of speech recognition language models from GF in several formats:// 
+//GSL (Nuance), SRGS, JSGF, and HTK SLF, with embedded semantic interpretation.//
+
+A. Ranta.
+Features in Abstract and Concrete Syntax.
+//The 2nd International Workshop on Typed Feature Structure Grammars//,
+Tartu, 24 May 2007 (NODALIDA workshop).
+2007.
+[pdf http://www.cse.chalmers.se/~aarne/articles/ranta-tfsg2007.pdf]
+#BR
+//Explores the design choices of incorporating features in a GF-like grammar,//
+//with comparisons to feature-based unification grammars.//
+
+
+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.
+[pdf http://webalt.math.helsinki.fi/content/e16/e301/e785/MultilingualDeliveryofOnlineTestsinMathematics_eng.pdf]
+#BR
+//This papers shows screenshots of multilingual generation in the//
+//WebALT project, using GF and the resource grammar library.//
+
+J. Khegai. 
+Language engineering in Grammatical Framework (GF).
+Phd thesis, Computer Science, Chalmers University of Technology,
+2006.
+[pdf http://www.cse.chalmers.se/~janna/Janna_Khegai_phd.pdf]
+#BR
+//Collection of articles and technical reports on multilingual authoring//
+//and the Russian resource grammar.//
+
+B. Bringert and A. Ranta.
+A Pattern for Almost Compositional Functions.
+//ICFP 2006, The 11th ACM SIGPLAN International Conference on Functional Programming, Portland, Oregon, September 18-20, 2006//,
+2006.
+[pdf http://www.cse.chalmers.se/~bringert/publ/composOp/composOp.pdf].
+#BR
+//A method of generic programming useful for compiler construction//
+//and transfer-based translation.//
+
+M. Forsberg, H. Hammarstrom, and A. Ranta.
+Morphological Lexicon Extraction from Raw Text Data. 
+//FinTAL 2006//, 
+Turku, August 23-25, 2006.
+Springer LNCS/LNAI 4139,
+pp. 488-499,
+2006.
+#BR
+//A method for automatical production of morphological lexica based//
+//on inflection engines such as those of GF resource grammar library.//
+
+A. Ranta.
+Type Theory and Universal Grammar.
+//Philosophia Scientiae, Constructivism: Mathematics, Logic, Philosophy and Linguistics//,
+cahier spécial 6,
+pp. 115-131,
+2006.
+#BR
+//A philosophical study of the medieval thesis that//
+//grammar is the same in all languages and the difference is only in words.//
+
+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
+//Gives an outline of the Russian resource grammar project.//
+
+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
+//Shows how GF is used in controlled language translation.//
+
+
+
+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.
+[pdf http://webalt.math.helsinki.fi/content/e16/e301/e583/MultilingualContentDevelopmentforeLearninginAfrica-final1_eng.pdf]
+#BR
+//Presents a programme for producing educational material in African languages//
+//via multilingual generation in GF.//
+
+R. Jonson. 
+Generating statistical language models from interpretation grammars in dialogue system. 
+In Proceedings of EACL'06, Trento, Italy.
+2006.
+#BR
+//Uses GF grammars to generate statistical language models for speech recognition.//
+
+A. El Dada and A. Ranta.
+Arabic Resource Grammar.
+//Arabic Language Processing (JETALA)//, 
+5-6 June 2006, IERA, Rabat, Morocco,
+2006.
+#BR
+//An outline of the Arabic resource grammar project, focusing on software aspects.//
+
+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
+//A paper explaining how a multilingual GF grammar is completed with//
+//Natural Language Generation techniques to improve text quality.//
+
+
+B. Bringert, R. Cooper, P. Ljunglöf, A. Ranta, 
+Multimodal Dialogue System Grammars.
+//Proceedings of DIALOR'05, Ninth Workshop on the Semantics and Pragmatics of Dialogue, Nancy, France, June 9-11, 2005//,
+2005.
+[pdf http://www.cse.chalmers.se/~bringert/publ/mm-grammars-dialor/mm-grammars-dialor.pdf].
+#BR
+//Shows how mouse clicks can be integrated in GF grammars//
+//alongside with speech input.//
+
+
+
+K.  Johannisson,
+Formal and Informal Software Specifications.
+PhD thesis,
+Computer Science, Göteborg University, 
+2005.
+[http://www.cse.chalmers.se/~krijo/thesis/thesisA4.pdf]
+#BR
+//Collection of articles in the GF-KeY project, with an introduction.//
+
+P. Ljunglöf.
+Expressivity and Complexity of the  Grammatical Framework.
+PhD thesis, Computer Science, 
+Göteborg University, 
+2004.
+[pdf http://www.cse.chalmers.se/~peb/pubs/Ljunglof-2004a.pdf]
+#BR
+//Language-theoretical study of GF and its parsing problem.//
+
+A. Ranta.
+Grammatical Framework: A Type-Theoretical Grammar Formalism.
+//Journal of Functional Programming//, 14(2),
+pp. 145-189, 
+2004.
+Draft available as [ps.gz http://www.cse.chalmers.se/~aarne/articles/gf-jfp.ps.gz].
+#BR
+//Theoretical paper explaining the GF formalism and its implementation.//
+//The standard reference on GF, but doesn't cover the module system.//
+
+
+A. Ranta.
+Computational semantics in type theory.
+//Mathematics and Social Sciences//, 165,
+pp. 31-57, 
+2004.
+Draft available as [pdf http://www.cse.chalmers.se/~aarne/articles/3formsem.pdf].
+#BR
+// Shows how Montague-style grammars are implemented in GF and extends//
+//this to type-theoretical grammars for anaphoric expressions.//
+
+H. Hammarström and A. Ranta.
+Cardinal Numerals Revisited in GF.
+//Workshop on Numerals in the World's Languages//. 
+Dept. of Linguistics Max Planck Institute for Evolutionary Anthropology, Leipzig,
+2004.
+#BR
+//An overview of the numeral grammar project, covering 88 languages.//
+
+
+A. Ranta.
+Grammatical Framework Tutorial.
+In A. Beckmann and N. Preining, editors, 
+//ESSLLI 2003 Course Material I//, 
+//Collegium Logicum//, 
+volume V,
+pp. 1-86. 
+Kurt Gödel Society, 
+Vienna,
+2004.
+#BR
+//A revised version of the on-line GF tutorial, v1.0.//
+
+
+J. Khegai and A. Ranta.
+Building and Using a Russian Resource Grammar in GF.
+In A. Gelbukh (ed), 
+//Intelligent Text Processing and Computational Linguistics (CICLing-2004)//, 
+Seoul, Korea, February 2003,
+Springer LNCS 945, 
+pp. 38-41,
+2004.
+[ps.gz http://www.cse.chalmers.se/~aarne/articles/mexico.ps.gz].
+#BR
+//An introduction to the GF resource grammar project, with Russian as prime example.//
+
+
+A. Ranta and R. Cooper.
+Dialogue Systems as Proof Editors.
+ //Journal of Logic, Language and Information//, 13,
+pp. 225-240, 
+2004.
+Conference version (IJCAR/ICoS-3, Siena, June 2001) available as
+  [ps.gz http://www.cse.chalmers.se/~aarne/articles/dialogue3.ps.gz].
+//Shows a close analogy between task-oriented dialogue systems//
+//and metavariable-based proof editors.//
+
+
+J. Khegai and A. Ranta.
+Building and Using a Russian Resource Grammar in GF.
+In A. Gelbukh (ed), 
+//Intelligent Text Processing and Computational Linguistics (CICLing-2004)//, 
+Seoul, Korea, February 2003,
+Springer LNCS 945, 
+pp. 38-41,
+2004.
+[ps.gz http://www.cse.chalmers.se/~aarne/articles/mexico.ps.gz].
+#BR
+//Explains how the GF GUI is used in syntax editing and discusses//
+//how new grammars are created.//
+
+
+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),
+//ETAPS/FASE-2002: Fundamental Approaches to Software Engineering//,
+Springer LNCS, 
+vol. 2306,
+pp. 233--248, 
+2002.
+[pdf http://www.cse.chalmers.se/~krijo/GF/FASE.pdf]
+#BR
+//Describes a GF-based authoring tool for object-oriented//
+//specifications in OCL and English. Carries out in full//
+//the work proposed in the position paper (Hähnle & Ranta 2001).//
+
+
+
+K. Johannisson and A.Ranta,
+Formal Verification of Multilingual Instructions.
+//Proceedings of the Joint Winter Meeting 2001//.
+Departments of Computer Science and Computer Engineering,
+Chalmers University of Technology and Göteborg University.
+2001.
+[ps.gz http://www.cse.chalmers.se/~aarne/articles/aarne+krijo.ps.gz].
+#BR
+//Instructions for an alarm system in four languages, verified in the proof editor Alfa.//
+
+
+R. Hähnle and A. Ranta,
+Connecting OCL with the Rest of the World.
+//ETAPS 2001 Workshop on Transformations in UML (WTUML)//, 
+Genova, 
+2001.
+[ps.gz http://www.cse.chalmers.se/~reiner/papers/wtuml.ps.gz].
+#BR
+//A position paper explaining how GF can be used to help in object-oriented//
+//modelling, with some examples on natural-language interaction with//
+//OCL (Object Constraint Language)//.
+
+
+
+T. Hallgren, "The Correctness of Insertion Sort",
+Manuscript, Chalmers University, Göteborg, 2001.
+Available in
+[ps http://www.cse.chalmers.se/~hallgren/Papers/insertion_sort.ps]
+#BR
+//A seven-page text generated by GF-Alfa//.
+
+
+A. Ranta. "Bescherelle bricolé",
+[ps.gz ../../GF2.0/doc/BeschBric.ps.gz], 
+2001.
+#BR
+//A machine-generated book on French conjugation implemented in GF.//
+
+
+T. Hallgren and A. Ranta,
+An Extensible Proof Text Editor.
+In M. Parigot and A. Voronkov (eds),
+//Logic for Programming and Automated Reasoning (LPAR'2000)//,
+LNCS/LNAI 1955, 
+pp. 70-84,
+Springer Verlag, Heidelberg, 
+2000.
+[ps.gz http://www.cse.chalmers.se/~aarne/articles/lpar2000.ps.gz].
+#BR
+//Describes an interface to the proof editor Alfa written in GF//.
+
+
+M. Dymetman, V. Lux, and A. Ranta,
+XML and multilingual document authoring: converging trends.
+//Proceedings of the The 18th International Conference on Computational Linguistics (COLING 2000)//,
+pp. 243-249,
+Saarbruecken, 
+2000.
+[ps.gz http://www.cse.chalmers.se/~aarne/articles/coling2000.ps.gz].
+#BR
+//Relates GF not only with XML but also with definite clause grammars//.
+
+
+
+P. Mäenpää and A. Ranta.
+The type theory and type checker of GF.
+//Colloquium on Principles, Logics, and Implementations of High-Level Programming Languages, Workshop on Logical Frameworks and Meta-languages, Paris, 28 September 1999//.
+1999. 
+[ps.gz href=http://www.cse.chalmers.se/~aarne/papers/lfm1999.ps.gz].
+#BR
+//Concise theoretical presentation of GF, using the old notation prior to v0.9//.
+
+
+
+
+
+
+
+
+==Background for GF==
+
+In alphabetical order:
+
+
+
+L. Magnusson.
+//The Implementation of ALF - a Proof Editor based on Martin-Löf's//
+//Monomorphic Type Theory with Explicit Substitutions//.
+PhD Thesis, Department of Computing Science,
+Chalmers University of Technology and Göteborg University,
+1994.
+#BR
+//Back in 1992 the most wonderful program in the world, ALF is//
+//a model that GF directly follows: GF is Yet ALF.//
+
+
+
+P. Martin-Löf.
+//Intuitionistic Type Theory//.
+Bibliopolis, Naples, 1984.
+#BR
+//A very accessible book (if you have access to it!) on type theory directly from the source.//
+
+
+
+B. Nordström, K. Petersson, and J. Smith.
+//Programming in Martin-Löf's Type Theory: an Introduction//.
+Oxford University Press, 1990.
+ The book is out of print, but a free version can be picked up from
+[www.cse.chalmers.se/Cs/Research/Logic/book/ http://www.cse.chalmers.se/Cs/Research/Logic/book/]
+#BR
+//Standard reference on the subject//.
+
+
+A. Ranta.
+//Type Theoretical Grammar//.
+Oxford University Press, Oxford, 
+1994.
+#BR
+//Monograph on type theory in linguistics. Includes an introduction//
+//to type theory. Focused on semantics, in particular anaphora. A first,// 
+//very rudimentary implementation of linearization in the proof system ALF.//
+
+
+A. Ranta.
+Syntactic categories in the language of mathematics.
+In P. Dybjer, B. Nordström, and J. Smith, eds.,
+//Types for Proofs and Programs//, 
+pp. 162-182,
+Lecture Notes in Computer Science
+996,  
+Springer-Verlag, 
+Heidelberg, 
+1995.
+[ps.gz http://www.cse.chalmers.se/~aarne/articles/baastad.ps.gz]
+#BR
+//Predecessor of GF: grammar defined in type theory and implemented in ALF//. 
+
+A. Ranta.
+Context-relative syntactic categories and the formalization of mathematical text.
+In S. Berardi and M. Coppo, eds.,
+//Types for Proofs and Programs//, 
+pp. 231-248,
+Lecture Notes in Computer Science 
+1158, 
+Springer-Verlag, 
+Heidelberg, 
+1996.
+[ps.gz http://www.cse.chalmers.se/~aarne/articles/torino.ps.gz].
+#BR
+//Extending the theory of the previous paper. The implementation in ALF// 
+//eventually became so heavy that the need arose for GF.//
+
+
+A. Ranta.
+Structures grammaticales dans le français mathématique. 
+//Mathématiques, informatique et Sciences Humaines.//,
+vol. 138 pp. 5-56 and 139 pp. 5-36, 
+1997.
+#BR
+//A rather comprehensive French grammar presented in a type-theoretical style.//
+
+
+A. Ranta.
+ Syntactic calculus with dependent types.
+ //Journal of Logic, Language and Information//, vol. 4,
+  pp. 413-431, 1998.
+#BR
+//Interprets Lambek Calculus in type theory and defines some extensions//.
+
+
--- a/doc/gf-developers-old-cabal.t2t
+++ b/doc/gf-developers-old-cabal.t2t
@@ -0,0 +1,201 @@
+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
+```
--- a/doc/gf-developers.t2t
+++ b/doc/gf-developers.t2t
@@ -0,0 +1,384 @@
+GF Developers Guide
+
+2021-07-15
+
+%!options(html): --toc
+
+== Before you start ==
+
+This guide is intended for people who want to contribute to
+the development of the GF compiler or the Resource Grammar Library. If
+you are a GF user who just wants to download and install GF
+(e.g to develop your own grammars), the simpler guide on
+[the GF download page ../download/index.html] should be sufficient.
+
+== 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.
+
+%**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 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 other operating systems**, see the [installation guide https://docs.haskellstack.org/en/stable/install_and_upgrade].
+
+
+%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 ===
+
+GF uses //haskeline// to enable command line editing in the GF shell.
+
+- **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``
+
+
+== Getting the source ==[getting-source]
+
+Once you have all tools in place you can get the GF source code from
+[GitHub https://github.com/GrammaticalFramework/]:
+
+- https://github.com/GrammaticalFramework/gf-core for the GF compiler
+- https://github.com/GrammaticalFramework/gf-rgl for the Resource Grammar Library
+
+
+=== Read-only access: clone the main repository ===
+
+If you only want to compile and use GF, you can just clone the repositories as follows:
+
+```
+  $ git clone https://github.com/GrammaticalFramework/gf-core.git
+  $ git clone https://github.com/GrammaticalFramework/gf-rgl.git
+```
+
+To get new updates, run the following anywhere in your local copy of the repository:
+
+```
+  $ git pull
+```
+
+=== 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.
+
+```
+  $ git clone https://github.com/<YOUR_USERNAME>/gf-core.git
+```
+
+ **Updating your copy —**
+Once you have cloned your fork, you need to set up the main repository as a remote:
+
+```
+  $ git remote add upstream https://github.com/GrammaticalFramework/gf-core.git
+```
+
+Then you can get the latest updates by running the following:
+
+```
+  $ git pull upstream master
+```
+
+ **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.
+
+
+
+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.
+
+```
+$ stack install
+```
+
+It will install GF and all necessary tools and libraries to do that.
+
+
+=== 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.
+
+```
+$ 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.//
+
+== Compiling GF with C runtime system support ==
+
+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.
+
+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:
+
+```
+cabal install -fc-runtime
+```
+
+from the top directory (``gf-core``).
+
+If you use stack, uncomment the following lines in the ``stack.yaml`` file:
+
+```
+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
+```
+
+and then run ``stack install``, also from the top directory.
+
+
+
+== Compilation of RGL ==
+
+As of 2018-07-26, the RGL is distributed separately from the GF compiler and runtimes.
+
+To get the source, follow the previous instructions on [how to clone a repository with Git #getting-source].
+
+After cloning the RGL, you should have a directory named ``gf-rgl`` on your computer.
+
+=== Simple ===
+To install the RGL, you can use the following commands from within the ``gf-rgl`` repository:
+```
+$ make install
+```
+There is also ``make build``, ``make copy`` and ``make clean`` which do what you might expect.
+
+=== Advanced ===
+For advanced build options, call the Haskell build script directly:
+```
+$ runghc Setup.hs ...
+```
+For more details see the [README https://github.com/GrammaticalFramework/gf-rgl/blob/master/README.md].
+
+=== Haskell-free ===
+If you do not have Haskell installed, you can use the simple build script ``Setup.sh``
+(or ``Setup.bat`` for Windows).
+
+
+== Creating binary distribution packages ==
+
+The binaries are generated with Github Actions. More details can be viewed here:
+
+https://github.com/GrammaticalFramework/gf-core/actions/workflows/build-binary-packages.yml
+
+
+== Running the test suite ==
+
+The GF test suite is run with one of the following commands from the top directory:
+
+```
+  $ cabal test
+```
+
+or
+
+```
+  $ stack 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.
+
+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.
+
+```
+ 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.
+```
+
+**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.
--- a/doc/gf-editor-modes.t2t
+++ b/doc/gf-editor-modes.t2t
@@ -0,0 +1,72 @@
+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
+
+==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/].
+
+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]
--- a/doc/gf-help-full.txt
+++ b/doc/gf-help-full.txt
--- a/doc/gf-people.md
+++ b/doc/gf-people.md
@@ -0,0 +1,64 @@
+---
+title: "Grammatical Framework: Authors and Acknowledgements"
+---
+
+## Current maintainers
+
+The current maintainers of GF are
+
+[Krasimir Angelov](http://www.chalmers.se/cse/EN/organization/divisions/computing-science/people/angelov-krasimir),
+[Thomas Hallgren](http://www.cse.chalmers.se/~hallgren/),
+[Aarne Ranta](http://www.cse.chalmers.se/~aarne/),
+[John J. Camilleri](http://johnjcamilleri.com), and
+[Inari Listenmaa](https://inariksit.github.io/).
+
+This page is otherwise not up to date.
+For detailed data about contributors to the code repositories since 2007, see
+[here (gf-core)](https://github.com/GrammaticalFramework/gf-core/graphs/contributors)
+and
+[here (gf-rgl)](https://github.com/GrammaticalFramework/gf-rgl/graphs/contributors).
+
+## Previous contributors
+
+The following people have contributed code to some of the versions:
+
+- Grégoire Détrez (University of Gothenburg)
+- Ramona Enache (University of Gothenburg)
+- [Björn Bringert](http://www.cse.chalmers.se/alumni/bringert) (University of Gothenburg)
+- Håkan Burden (University of Gothenburg)
+- Hans-Joachim Daniels (Karlsruhe)
+- [Markus Forsberg](http://www.cs.chalmers.se/~markus) (Chalmers)
+- [Kristofer Johannisson](http://www.cs.chalmers.se/~krijo) (University of Gothenburg)
+- [Janna Khegai](http://www.cs.chalmers.se/~janna) (Chalmers)
+- [Peter Ljunglöf](http://www.cse.chalmers.se/~peb) (University of Gothenburg)
+- Petri Mäenpää (Nokia)
+- 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.
--- a/doc/gf-refman.md
+++ b/doc/gf-refman.md
--- a/doc/gf-shell-reference.t2t
+++ b/doc/gf-shell-reference.t2t
@@ -0,0 +1,106 @@
+The GF Software System
+
+
+%!options(html): --toc
+%!options(html): --toc-level=4
+%!postproc(html): "#VSPACE" "<hr>"
+%!postproc(html): "#NORMAL" ""
+%!postproc(html): "#TINY" ""
+%!postproc(html): "#NOINDENT" ""
+
+The GF software system implements the GF programming language. Its
+components are
+- the //compiler//,
+translating ``.gf`` source files to ``.gfo`` object files, to
+``.pgf`` run-time grammars, and to various other formats
+- the //run-time system//,
+performing parsing, generation, translation and other functions with
+``.pgf`` grammars
+- the //command interpreter//, also known as the //GF shell//,
+executing user commands by calling the compiler and the run-time system
+
+
+This page describes the commands of the GF shell,
+as well as the use of the compiler in batch mode.
+
+%%toc
+
+==The GF shell==
+
+The GF shell is invoked by the command ``gf``, which takes arguments and
+options according to the following syntax:
+```
+  gf (OPTION | FLAG)* FILE*
+```
+The shell maintains a  //state//, to which belong
+- a multilingual PGF grammar
+- optionally, a set of compiled GF modules (retaining ``oper`` definitions)
+- a history of previous commands
+- a set of string, tree, and command macros
+
+
+Unless file arguments are provided to the ``gf`` command, the shell starts in an
+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
+syntax of commands is given by the following BNF grammar:
+```
+  COMMAND_LINE ::= COMMAND_PIPE
+  COMMAND_LINE ::= COMMAND_PIPE ";" COMMAND_LINE
+  COMMAND_PIPE ::= COMMAND
+  COMMAND_PIPE ::= COMMAND "|" COMMAND_PIPE
+  COMMAND      ::= COMMAND_ID (OPTION | FLAG)* ARGUMENT?
+  OPTION       ::= "-"OPTION_ID
+  FLAG         ::= "-"OPTION_ID "=" VALUE
+  ARGUMENT     ::= QUOTED_STRING | TREE
+  VALUE        ::= IDENT | QUOTED_STRING
+```
+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.
+
+A command line is a sequence of pipes separated by ``;``. These pipes are
+executed one by one, in the order of appearance.
+
+===GF shell commands===
+
+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
+
+==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.
+```
+  $ 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
+the size of the ``.pgf`` file, and is recommended for grammars to be shipped.
+```
+  $ gf -make -optimize-pgf LangIta.gf LangEng.gf LangGer.gf
+```
+The flag ``-output-format`` changes the output format from ``.pgf`` to
+some other format. For instance
+```
+  $ gf -make -output-format=js LangEng.pgf LangGer.pgf
+```
+Notice that the arguments can be ``.pgf`` files, which in this case
+are merged and written into a JavaScript grammar file.
+
+More options and instructions are obtained with
+```
+  $ gf -help
+```
+To run GF from a //script//, redirection of standard input can be used:
+```
+  $ gf <script.gfs
+```
+The file ``script.gfs`` should then contain a sequence of GF commands, one per line.
+Unrecognized command lines are skipped without terminating GF.
--- a/doc/gf-video-tutorials.md
+++ b/doc/gf-video-tutorials.md
@@ -0,0 +1,35 @@
+---
+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>
--- a/doc/gf2-highlights.html
+++ b/doc/gf2-highlights.html
@@ -1,301 +0,0 @@
-<html>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<center>
-
-<h1>Grammatical Framework Version 2</h1>
-
-Highlights, preliminary version
-
-<p>
-
-13/10/2003
-
-<p>
-
-<a href="http://www.cs.chalmers.se/~aarne">Aarne Ranta</a>
-
-</center>
-
-<h2>Summary of novelties</h2>
-
-<h4>Module system</h4>
-
-<li> Separate modules for <tt>abstract</tt>, 
-     <tt>concrete</tt>, and <tt>resource</tt>.
-<li> Replaces the file-based <tt>include</tt> system
-<li> Name space handling with qualified names
-<li> Hierarchic structure (<tt>extend</tt>) + cross-cutting reuse (<tt>open</tt>)
-<li> Separate compilation, one module per file
-<li> Reuse of <tt>abstract</tt>+<tt>concrete</tt> as <tt>resource</tt>
-<li> New (experimental) module types: <tt>transfer</tt>, 
-     <tt>interface</tt>, <tt>instance</tt>, <tt>incomplete</tt>.
-
-<h4>Canonical format GFC</h4>
-
-<li> The target of GF compiler; to reuse, just read in
-<li> Readable by Haskell/Java/C++/C applications
-
-<h4>New features in expression language</h4>
-
-<li> Disjunctive patterns <tt>P | ... | Q</tt>.
-<li> Binding token <tt>&+</tt> to glue separate tokens at unlexing phase, 
-     and unlexer to resolve this.
-<li> New syntax alternatives for local definitions: <tt>let</tt> without
-     braces and <tt>where</tt>.
-<li> Pattern variables can be used on lhs's of <tt>oper</tt> definitions.
-<li> New Unicode transliterations (by Harad Hammarström).
-
-<h4>New parser (forthcoming)</h4>
-
-<li> By Peter Ljunglöf, based on MCFG
-<li> Much more efficient for morphology and discontinuous constituents
-<li> Treatment of cyclic rules
-
-<h4>New editor features</h4>
-
-<li> Active text field (forthcoming, by Janna Khegai)
-<li> Clipboard
-
-<h4>Improved implementation</h4>
-
-<li> Haskell source code organized into subdirectories.
-<li> BNF Converter used for defining the languages GF and GFC, which also
-     give reliable LaTeX documentation.
-<li> Lexican rules sorted out by option <tt>-cflexer</tt> for efficient
-     parsing with large lexica.     
-
-
-<!-- NEW -->
-
-<h2>Status (14/11/2003)</h2>
-
-Grammar compiler, editor GUIs, and shell work.
-
-<p>
-
-GF1 grammars can be automatically translated to GF2 (although result not as good
-as manual). The results can be saved in GF2 files, but this is not necessary.
-
-<p>
-
-Example grammars and resource libraries are in the process of 
-be converted. At the same time, their API has grown with
-new constructions.
-English and German resources are up-to-date.
-Finnish and Swedish are also, but their derived libraries
-have not been adapted to the use of security-bringing lock fields.
-
-
-<p>
-
-A make facility works, finding out which modules have to be recompiled.
-There is some room for improvement.
-
-<p>
-
-The module type <tt>grammar</tt> (to build multilingual grammars) not yet 
-implemented.
-
-<il> <tt>transfer</tt> modules have to be called by flags
-
-<p>
-
-Abstract modules (<tt>interface</tt>, <tt>instance</tt>, and <tt>incomplete</tt>)
-have not been stress-tested, but work in the examples in
-<tt>resource/romance</tt> and <tt>resource/french</tt>.
-
-<p>
-
-Soundness checking of module depencencies and completeness is not
-complete.
-
-
-<!-- NEW -->
-
-<h2>How to use GF 1.* files</h2>
-
-The import command <tt>i</tt> is given the option <tt>-old</tt>. E.g.
-<pre>
-  i -old tut1.Eng.g2
-</pre>
-This generates, internally, three modules:
-<pre>
-  abstract tut1 = ...
-  resource ResEng = ...
-  concrete Eng of tut1 = open ResEng in ...
-</pre>
-(The names are different if the file name has fewer parts.)
-
-<p>
-
-The option <tt>-o</tt> causes GF2 to write these modules into files.
-
-<p>
-
-The flags <tt>-abs</tt>, <tt>-cnc</tt>, and <tt>-res</tt> can be used
-to give custom names to the modules. In particular, it is good to use
-the <tt>-abs</tt> flag to guarantee that the abstract syntax module
-has the same name for all grammars in a multilingual environmens:
-<pre>
-  i -old -abs=Numerals hungarian.gf
-  i -old -abs=Numerals tamil.gf
-  i -old -abs=Numerals sanskrit.gf
-</pre>
-
-<p>
-
-The same flags as in the import command can be used when invoking
-GF2 from the system shell. Many grammars can be imported on the same command
-line, e.g.
-<pre>
-  % gf2 -old -abs=Tutorial tut1.Eng.gf tut1.Fin.gf tut1.Fra.gf
-</pre>
-
-
-
-
-<!-- NEW -->
-
-<h2>Abstract, concrete, and resource modules</h2>
-
-Judgement forms are sorted as follows:
-<ul>
-<li> abstract: 
-  <tt>cat</tt>, <tt>fun</tt>, <tt>def</tt>, <tt>data</tt>, <tt>flags</tt>
-<li> concrete: 
-  <tt>lincat</tt>, <tt>cat</tt>, <tt>printname</tt>, <tt>flags</tt>
-<li> resource: 
-  <tt>param</tt>, <tt>oper</tt>, <tt>flags</tt>
-<li> 
-</ul>
-Example:
-<pre>
-  abstract Sums = {
-    cat 
-      Exp ;
-    fun 
-      One : Exp ;
-      plus : Exp -> Exp -> Exp ;
-  }
-
-  concrete EnglishSums of Sums = open ResEng in {
-    lincat 
-      Exp = {s : Str ; n : Number} ;
-    lin
-      One = expSg "one" ;
-      sum x y = expSg ("the" ++ "sum" ++ "of" ++ x.s ++ "and" ++ y.s) ;
-  }
-
-  resource ResEng = {
-    param 
-      Number = Sg | Pl ;
-    oper 
-      expSG : Str -> {s : Str ; n : Number} = \s -> {s = s ; n = Sg} ;
-  }
-</pre>
-
-
-
-<!-- NEW -->
-
-<h2>Opening and extending modules</h2>
-
-A <tt>concrete</tt> or <tt>resource</tt> can <b>open</b> a
-<tt>resource</tt>. This means that
-<ul>
-<li> the names defined in <tt>resource</tt> can be used ("become visible")
-<li> but: these names are not included in ("exported from") the opening module
-</ul>
-A module of any type can moreover <b>extend</b> a module of the same type.
-This means that
-<ul>
-<li> the names defined in the extended module can be used ("become visible")
-<li> and also: these names are included in ("exported from") the extending module
-</ul>
-Examples of extension:
-<pre>
-  abstract Products = Sums ** {
-    fun times : Exp -> Exp -> Exp ;
-  }
-  -- names exported: Exp, plus, times
-
-  concrete English of Products = EnglishSums ** open ResEng in {
-    lin times x y = expSg ("the" ++ "product" ++ "of" ++ x.s ++ "and" ++ y.s) ;
-  }
-</pre>
-Another important difference:
-<li> extension is single
-<li> opening can be multiple: <tt>open Foo, Bar, Baz in {...}</tt>
-
-<p>
-
-Moreover:
-<li> opening can be <b>qualified</b>
-<p>
-Example of qualified opening:
-<pre>
-  concrete NumberSystems of Systems = open (Bin = Binary), (Dec = Decimal) in {
-    lin 
-      BZero = Bin.Zero ;
-      DZero = Dec.Zero
-  }
-</pre>
-  
-
-<!-- NEW -->
-
-<h2>Compiling modules</h2>
-
-Separate compilation assumes there is <b>one module per file</b>.
-
-<p>
-
-The <b>module header</b> is the beginning of the module code up to the
-first left bracket (<tt>{</tt>). The header gives
-<ul>
-<li> the module type: <tt>abstract</tt>, <tt>concrete</tt> (<tt>of</tt> <i>A</i>), 
-  or <tt>resource</tt>
-<li> the name of the module (next to the module type keyword)
-<li> the name of extended module (between <tt>=</tt> and <tt>**</tt>)
-<li> the names of opened modules
-</ul>
-
-<p>
-
-<b>filename</b> = <b>modulename</b> <tt>.</tt> <b>extension</b>
-
-<p>
-
-File name extensions:
-<ul>
-<li> <tt>gf</tt>: GF source file (uses GF syntax, is type checked and compiled)
-<li> <tt>gfc</tt>: canonical GF file (uses GFC syntax, is only read in; produced 
-from all kinds of modules)
-<li> <tt>gfr</tt>: GF resource file (uses GF syntax, is only read in; produced from
-<tt>resource</tt> modules)
-</ul>
-Only <tt>gf</tt> files should ever be written/edited manually!
-
-<p>
-
-What the make facility does when compiling <tt>Foo.gf</tt>
-<ol>
-<li> read the module header of <tt>Foo.gf</tt>, and recursively all headers from
-the modules it <b>depends</b> on (i.e. extends or opens) 
-<li> build a dependency graph of these modules, and do topological sorting
-<li> starting from the first module in topological order,
-compare the modification times of each <tt>gf</tt> and <tt>gfc</tt> file:
-<ul>
-<li> if <tt>gf</tt> is later, compile the module and all modules depending on it
-<li> if <tt>gfc</tt> is later, just read in the module
-</ul>
-</ol>
-
-<!-- NEW -->
-
-<!-- NEW -->
-
-</body>
-</html>
--- a/doc/icfp-2012.t2t
+++ b/doc/icfp-2012.t2t
@@ -0,0 +1,67 @@
+Grammatical Framework Tutorial
+ICFP 2012, Copenhagen 9-15 September 2012
+
+%!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>
+%!postproc(html): 'ICFP 2012' '<a href="http://icfpconference.org/icfp2012/">ICFP 2012</a>'
+
+
+==Goals==
+
+This tutorial gives a hands-on introduction to GF (Grammatical Framework), 
+a special-purpose functional language 
+for writing grammars (http://grammaticalframework.org).
+
+We will show how techniques from compiler construction and functional 
+programming can be used in the processing of natural languages, 
+but also for formal languages and interfacing 
+the two. An emerging use is DSL's, where GF provides high expressive 
+power in terms of both
+linguistic expressivity (beyond context-free) and semantics (dependent types).
+
+GF activities are rapidly growing: there is an on-going EU project 
+MOLTO (molto-project.eu), as well as a new textbook 
+(Aarne Ranta, Grammatical Framework: Programming with Multilingual Grammars, 
+CSLI Publications, Stanford, 2011). 
+GF also has users in companies (Galois, Ontotext, BeInformed, Google).
+Interestingly, GF has been the first functional language for many people, 
+in particular those with a linguistic background. It has a unique 
+combination of advanced features such as parametrized modules, regular 
+expression pattern matching, and dependent types - all of which are 
+amply motivated by practical applications.
+
+The [GF Resource Grammar Library http://www.grammaticalframework.org/lib/doc/synopsis.html]
+is an open-source international project 
+now comprising 24 languages, with 5 to 10 more under construction.
+It makes it possible to develop grammar applications without linguistic knowledge.
+
+At the same time, it is an experiment on using a common abstract syntax for
+the languages of the world. We don't claim it to be a universal grammar
+with no exceptions, but so far we haven't met any unsurmountable problems.
+If you want to contribute a new language, let us know! It is a job of
+2 to 6 months.
+
+
+==Structure of the tutorial==
+
+Hour 1. Writing multilingual grammars in GF (Aarne Ranta)
+[Slides http://www.cse.chalmers.se/~aarne/talks/gf-icfp-2012-1.pdf]
+
+Hour 2. Applications for the web, mobile phones, and as embedded Haskell programs 
+(Thomas Hallgren)
+[Slides /~hallgren/Talks/GF/Tutorial2012/tutorial2012.html]
+
+Hour 3. Internals of GF, theoretical aspects, and future trends (Krasimir Angelov)
+
+
+==Organizers==
+
+
+[Krasimir Angelov http://www.chalmers.se/cse/EN/organization/divisions/computing-science/people/angelov-krasimir]
+
+[Thomas Hallgren http://www.cse.chalmers.se/~hallgren/]
+
+[Aarne Ranta http://www.cse.chalmers.se/~aarne/]
+
--- a/doc/index.md
+++ b/doc/index.md
@@ -0,0 +1,13 @@
+---
+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.
--- a/doc/nancy-slides.pdf
+++ b/doc/nancy-slides.pdf
--- a/doc/new-gf-bib.bib
+++ b/doc/new-gf-bib.bib
--- a/doc/runtime-api.html
+++ b/doc/runtime-api.html
--- a/doc/tutorial/10lang-small.png
+++ b/doc/tutorial/10lang-small.png
--- a/doc/tutorial/align2.png
+++ b/doc/tutorial/align2.png
--- a/doc/tutorial/categories.png
+++ b/doc/tutorial/categories.png
--- a/doc/tutorial/food-js.png
+++ b/doc/tutorial/food-js.png
--- a/doc/tutorial/food-magnet.png
+++ b/doc/tutorial/food-magnet.png
--- a/doc/tutorial/foodmarket.png
+++ b/doc/tutorial/foodmarket.png
--- a/doc/tutorial/gf-tutorial.t2t
+++ b/doc/tutorial/gf-tutorial.t2t
--- a/doc/tutorial/iphone.jpg
+++ b/doc/tutorial/iphone.jpg
--- a/doc/tutorial/myparse.png
+++ b/doc/tutorial/myparse.png
--- a/doc/tutorial/mytree.png
+++ b/doc/tutorial/mytree.png
--- a/download/encoding-change.t2t
+++ b/download/encoding-change.t2t
@@ -0,0 +1,85 @@
+GF character encoding changes
+Thomas Hallgren
+2013-12-18
+
+==Changes to character encodings in GF grammar files ==
+
+Between the release of GF 3.5 and the next version, two changes were made
+relating to character encodings in GF grammar files:
+
+ The default character encoding was changed from Latin-1
+(also known as iso-8859-1, cp1252) to UTF-8.
+
+ They way you specify alternate character encodings was changed. Instead of
+  using a ``flags coding = ...`` declaration in the source file, you should now
+  use a pragma ``--# -coding=...`` at the top of the file instead.
+
+
+== Advantages ==
+
+UTF-8 is the default encoding for text files on many systems these days, so
+it makes sense to use it as the default for GF grammar files too.
+
+Changing how alternate encodings are specified allows conversion to Unicode
+to be done before parsing, which means that
+
+- we can allow Unicode characters in identifiers, not just in string literals,
+- it makes accurate column positions in error messages possible,
+- and (an implementation detail) we can use Alex to generate the lexer again.
+
+
+== How are my grammar files affected? ==
+
+If your files still compile without errors after the change, you don't need
+to do anything. (But see Known problems below!)
+If you get one of the following errors,
+
+- ``lexical error``,
+- ``encoding mismatch``,
+- ``Warning: default encoding has changed from Latin-1 to UTF-8``
+
+
+ you need to add a
+``--# -coding=...`` pragma to your file (or convert it to UTF-8).
+
+- For files containing only ASCII characters, no change is needed.
+- For files encoded in UTF-8 (and thus using a ``flags coding=utf8``
+  declaration), no change is needed.
+- For files containing Latin-1 characters (e.g. characters like
+  å ä ö ü é), add a ``#-- -coding=latin1`` pragma at the top of the file.
+- For files using other encodings, copy the encoding specified in the
+  ``flags coding=``//enc// to a corresponding ``--# -coding=``//enc//.
+
+
+Grammars will still compile with GF-3.5 after these changes.
+
+
+Note that GF only understands one option per pragma line. If you already
+have a ``--path=...`` pragma, you can not put the ``-coding=...`` option on
+the same line. Add it on a separate line:
+
+```
+	--# -path=...
+	--# -coding=...
+```
+
+The recommendation for the future is to use UTF-8 for all source files.
+
+
+== Known problems ==
+
+The intention is that if a grammar file is affected by the changed default
+encoding, then you will see one of the messages listed in the previous
+section when you compile the grammar. But there are a couple if issues to be
+aware of:
+
+- Alex 3.0 seems to be confused about the length of matched strings sometimes.
+  This can cause it to skip more than one line when it encounters a one-line
+  comment in a grammar file with character encoding problems. So instead of a
+  lexical error in the comment, you can get an odd syntax error
+  on a subsequent line.
+
+- If you explicitly specify -coding=utf8 for a file that is not in UTF-8, you
+  will not get an error, because the UTF-8 decoding function we currently use is
+  forgiving, substituting the Unicode replacement character <20>, instead of
+  reporting an error. Hopefully, we will be able to change this.
--- a/download/index-3.1.6.t2t
+++ b/download/index-3.1.6.t2t
@@ -0,0 +1,72 @@
+Grammatical Framework Download and Installation
+Version 3.1.6, 23 April 2010
+
+
+==Latest developer code==
+
+[GF darcs repository  ../doc/darcs.html]
+
+==Latest release==
+
+GF 3.1.6 released 23 April 2010.
+- MacOS X installer package:
+  [``gf-3.1.6-leopard.pkg`` gf-3.1.6-leopard.pkg] (7.7MB)
+- MacOS X (gzipped executable, Leopard and Snow Leopard):
+  [``gf-3.1.6-bin-intel-mac.gz`` gf-3.1.6-bin-intel-mac.gz] (1.9MB)
+- 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):
+  [``gf-3.1.6-bin-i486-linux.gz`` gf-3.1.6-bin-i486-linux.gz]
+  (1.7 MB)
+- compiled library package:
+  [``gf-3.1.6-lib.tar.gz`` gf-3.1.6-lib.tar.gz]
+  (4.4 MB)
+- 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]
+
+
+What's new? See the [release notes release-3.1.6.html].
+
+
+==Previous releases==
+
+[Follow this link old-index.html].
+
+
+==Installation instructions==
+
+
+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
+put it somewhere on your path, renaming it to just ``gf``. For instance:
+```
+  gunzip gf-bin-[version].gz
+  sudo mv gf-bin-[version] /usr/local/bin/gf
+```
+To install the libraries (if done separately), unpack them in the place to which your
+``GF_LIB_PATH`` points.
+```
+  cd $GF_LIB_PATH
+  gtar xvfz gf-lib-[VERSION].tgz
+```
+If this variable hasn't been defined, it is useful define it, e.g.
+```
+  export GF_LIB_PATH=/usr/local/lib/gf/
+```
+
+To compile and install from source on Mac or Linux, do:
+```
+  tar xvfz gf-[VERSION].tgz
+  cd GF/src
+  runghc Setup configure --user
+  runghc Setup build
+  runghc Setup install
+```
+The last command must be prefixed by ``sudo``, if the installation is outside
+user-writeable area.
--- a/download/index-3.10.md
+++ b/download/index-3.10.md
@@ -0,0 +1,201 @@
+---
+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)
--- a/download/index-3.11.md
+++ b/download/index-3.11.md
@@ -0,0 +1,177 @@
+---
+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 the latest Hackage release (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:
+
+1.  Install ghcup https://www.haskell.org/ghcup/
+2.  `ghcup install ghc 8.10.4`
+3.  `ghcup set ghc 8.10.4`
+4.  `cabal update`
+5.  On Linux: install some C libraries from your Linux distribution (see note below)
+6.  `cabal install gf-3.11`
+
+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 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`
+
+**GHC version**
+
+The GF source code has been updated to compile with GHC versions 7.10 through to 8.8.
+-->
+## 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 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)
--- a/download/index-3.2.9.t2t
+++ b/download/index-3.2.9.t2t
@@ -0,0 +1,74 @@
+Grammatical Framework Download and Installation
+
+
+**GF 3.2.9** source-only snapshot was released on 12 September 2011.
+
+What's new? Faster grammar compilation!
+
+
+== Binary packages ==
+
+
+No binary packages were created for this release.
+
+
+==Installing from source==
+
+[GF is on Hackage http://hackage.haskell.org/package/gf], so the prodedure is
+fairly simple:
+
+ Install the
+  [Haskell Platform 2010.2.0.0 (July 2010) http://hackage.haskell.org/platform]
+  or newer.
+ ``cabal update``
+ On Linux: install some C libraries from your Linux distribution (see below)
+ ``cabal install gf``
+
+
+You can also download the full source package from here:
+[``gf-3.2.9.tar.gz`` gf-3.2.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``, so it is a good
+idea to put a line in your ``.bash_profile`` to add that directory to you path:
+
+```
+  PATH=$HOME/.cabal/bin:$PATH
+```
+
+GF uses ``haskeline``, which depends some non-Haskell libraries that
+won't be installed automatically by cabal, so you need to install
+them manually. Here is one way to do this:
+
+- On Ubuntu: ``sudo apt-get install libghc6-terminfo-dev``
+- On Fedora: ``sudo yum install ghc-terminfo-devel``
+
+
+==Installing from the latest developer code==
+
+The first time:
+
+```
+  darcs get --lazy http://www.grammaticalframework.org/ GF
+  cd GF
+  cabal install
+```
+
+Subsequently:
+
+```
+  cd GF
+  darcs pull -a
+  cabal install
+```
+
+The above notes for installing from source apply also in this case.
+
+
+==Older releases==
+
+- [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).
--- a/download/index-3.2.t2t
+++ b/download/index-3.2.t2t
@@ -0,0 +1,102 @@
+Grammatical Framework Download and Installation
+
+
+**GF 3.2** was released on 23 December 2010.
+
+What's new? See the [Release notes release-3.2.html].
+
+
+== Binary packages for the latest release ==
+
+
+| **Platform** | **Download** | **How to install**
+| Ubuntu (32-bit) | [gf_3.2-4_i386.deb gf_3.2-4_i386.deb] | Double-click on the package icon, or use ``sudo dpkg -i gf_3.2-4_i386.deb``
+| Ubuntu (64-bit) | [gf_3.2-4_amd64.deb gf_3.2-4_amd64.deb] | Double-click on the package icon, or use ``sudo dpkg -i gf_3.2-4_amd64.deb``
+| Linux (32-bit) | [gf-3.2-bin-i386-linux.tar.gz gf-3.2-bin-i386-linux.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.2-bin-i386-linux.tar.gz``
+| Linux (64-bit) | [gf-3.2-bin-x86_64-linux.tar.gz gf-3.2-bin-x86_64-linux.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.2-bin-x86_64-linux.tar.gz``
+| MacOS X | [gf-3.2-snowleopard.pkg gf-3.2-snowleopard.pkg] | Double-click on the package icon and follow the instructions
+| MacOS X | [gf-3.2-bin-intel-mac.tar.gz gf-3.2-bin-intel-mac.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.2-bin-intel-mac.tar.gz``
+| Windows | [gf-3.2-bin-i386-windows.zip gf-3.2-bin-i386-windows.zip] | ``unzip gf-3.2-bin-i386-windows.zip``
+
+More 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.
+
+The ``.deb`` packages work on Ubuntu 10.04 and 10.10.
+
+The ``.pkg`` package works on MacOS X 10.6 (Snow Leopard). The MacOS tar
+package works on 10.5 (Leopard) and 10.6 (Snow Leopard).
+
+The MacOS and Linux tar 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.2/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 the prodedure is
+fairly simple:
+
+ Install the
+  [Haskell Platform 2010.2.0.0 (July 2010) http://hackage.haskell.org/platform].
+ ``cabal update``
+ On Linux: install some C libraries from your Linux distribution (see below)
+ ``cabal install gf``
+
+
+You can also download the full source package from here:
+[``gf-3.2.tar.gz`` gf-3.2.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``, so it is a good
+idea to put a line in your ``.bash_profile`` to add that directory to you path:
+
+```
+  PATH=$HOME/.cabal/bin:$PATH
+```
+
+GF uses ``haskeline``, which depends some non-Haskell libraries that
+won't be installed automatically by cabal, so you need to install
+them manually. Here is one way to do this:
+
+- On Ubuntu: ``sudo apt-get install libghc6-terminfo-dev``
+- On Fedora: ``sudo yum install ghc-terminfo-devel``
+
+
+==Older releases==
+
+- [GF 3.1.6 index-3.1.6.html] (April 2010).
+- [GF 3.1 old-index.html] (December 2009).
+
+
+==Installing from the latest developer code==
+
+The first time:
+
+```
+  darcs get --lazy http://www.grammaticalframework.org/ GF
+  cd GF
+  cabal install
+```
+
+Subsequently:
+
+```
+  cd GF
+  darcs pull -a
+  cabal install
+```
+
+The above notes for installing from source apply also in this case.
--- a/download/index-3.3.3.t2t
+++ b/download/index-3.3.3.t2t
@@ -0,0 +1,123 @@
+Grammatical Framework Download and Installation
+
+
+**GF 3.3.3** was released on 3 March 2012.
+
+What's new? See the [Release notes release-3.3.3.html].
+
+
+== Binary packages ==
+
+| **Platform** | **Download** | **How to install**
+| Linux (32-bit) | [gf-3.3.3-bin-i386-linux.tar.gz gf-3.3.3-bin-i386-linux.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.3.3-bin-i386-linux.tar.gz``
+| Linux (64-bit) | [gf-3.3.3-bin-amd64-linux.tar.gz gf-3.3.3-bin-amd64-linux.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.3.3-bin-amd64-linux.tar.gz``
+| MacOS X | [gf-3.3.3-bin-intel-mac.tar.gz gf-3.3.3-bin-intel-mac.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.3.3-bin-intel-mac.tar.gz``
+| Windows | [gf-3.3.3-bin-windows.zip gf-3.3.3-bin-windows.zip] | ``unzip gf-3.3.3-bin-windows.zip``
+
+%More 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.
+
+%The ``.deb`` packages work on Ubuntu 10.04 and 10.10.
+
+%The ``.pkg`` package works on MacOS X 10.6 (Snow Leopard).
+The MacOS tar package works on 10.5 (Leopard), 10.6 (Snow Leopard) and probably
+also 10.7 (Lion).
+
+The MacOS 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.3.3/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 the prodedure is
+fairly simple:
+
+ Install the [Haskell Platform http://hackage.haskell.org/platform]
+  (versions 2010.2.0.0 - 2011.4.0.0 should work) (see notes 2&3 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.3.3.tar.gz`` gf-3.3.3.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`` 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 libghc6-terminfo-dev``
+- On Fedora: ``sudo yum install ghc-terminfo-devel``
+
+
+**Note 2**.
+GF (<=3.3.3) does **not** compile with the most recent versions of GHC (>=7.2).
+GF does **not** compile with the most recent versions of Alex (>=3.0).
+
+**Note 3**.
+[The Haskell Platform for Mac OS X http://hackage.haskell.org/platform/mac.html]
+page states that you need Xcode 3.2 or later, but in fact it appears you need
+Xcode 3.2.3 or later. If you have Xcode 3.2.2, you can get an error from the
+linker: ``ld: unknown option: -no_pie``.
+
+==Installing from the latest developer code==
+
+The first time:
+%, assuming you already have the Haskell Platform and darcs
+
+```
+  darcs get --lazy http://www.grammaticalframework.org/ GF
+  cd GF
+  cabal install
+```
+
+Subsequently:
+
+```
+  cd GF
+  darcs pull -a
+  cabal install
+```
+
+The above notes for installing from source apply also in this case.
+For more info, see the [GF Developers Guide ../doc/gf-developers.html].
+
+==Older releases==
+
+- [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).
--- a/download/index-3.3.t2t
+++ b/download/index-3.3.t2t
@@ -0,0 +1,112 @@
+Grammatical Framework Download and Installation
+
+
+**GF 3.3** was released on 27 October 2011.
+
+What's new? See the [Release notes release-3.3.html].
+
+
+== Binary packages ==
+
+| **Platform** | **Download** | **How to install**
+| Linux (32-bit) | [gf-3.3-bin-i386-linux.tar.gz gf-3.3-bin-i386-linux.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.3-bin-i386-linux.tar.gz``
+| Linux (64-bit) | [gf-3.3-bin-amd64-linux.tar.gz gf-3.3-bin-amd64-linux.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.3-bin-amd64-linux.tar.gz``
+| MacOS X | [gf-3.3-bin-intel-mac.tar.gz gf-3.3-bin-intel-mac.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.3-bin-intel-mac.tar.gz``
+| Ubuntu 11.10 (32-bit) | [gf_3.3-1_i386-oneiric.deb gf_3.3-1_i386-oneiric.deb] | Double-click on the package icon, or use ``sudo dpkg -i gf_3.3-1_i386-oneiric.deb``
+| Ubuntu 11.10 (64-bit) | [gf_3.3-1_amd64-oneiric.deb gf_3.3-1_amd64-oneiric.deb] | Double-click on the package icon, or use ``sudo dpkg -i gf_3.3-1_amd64-oneiric.deb``
+| Ubuntu 11.04 (32-bit) | [gf_3.3-1_i386-natty.deb gf_3.3-1_i386-natty.deb] | Double-click on the package icon, or use ``sudo dpkg -i gf_3.3-1_i386-natty.deb``
+| Ubuntu 11.04 (64-bit) | [gf_3.3-1_amd64-natty.deb  gf_3.3-1_amd64-natty.deb] | Double-click on the package icon, or use ``sudo dpkg -i gf_3.3-1_amd64-natty.deb``
+| Windows | [gf-3.3-bin-i386-windows.zip gf-3.3-bin-i386-windows.zip] | ``unzip gf-3.3-bin-i386-windows.zip``
+
+More 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.
+
+%The ``.deb`` packages work on Ubuntu 10.04 and 10.10.
+
+%The ``.pkg`` package works on MacOS X 10.6 (Snow Leopard).
+The MacOS tar package works on 10.5 (Leopard), 10.6 (Snow Leopard) and probably
+also 10.7 (Lion).
+
+The MacOS 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.3/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 the prodedure is
+fairly simple:
+
+ Install the
+  [Haskell Platform 2010.2.0.0 (July 2010) http://hackage.haskell.org/platform]
+  or newer.
+ ``cabal update``
+ On Linux: install some C libraries from your Linux distribution (see below)
+ ``cabal install gf``
+
+
+You can also download the full source package from here:
+[``gf-3.3.tar.gz`` gf-3.3.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`` to add that directory to you path:
+
+```
+  PATH=$HOME/.cabal/bin:$PATH
+```
+or
+```
+  PATH=$HOME/Library/Haskell/bin:$PATH
+```
+
+GF uses ``haskeline``, which depends some non-Haskell libraries that
+won't be installed automatically by cabal, so you need to install
+them manually. Here is one way to do this:
+
+- On Ubuntu: ``sudo apt-get install libghc6-terminfo-dev``
+- On Fedora: ``sudo yum install ghc-terminfo-devel``
+
+
+==Installing from the latest developer code==
+
+The first time:
+
+```
+  darcs get --lazy http://www.grammaticalframework.org/ GF
+  cd GF
+  cabal install
+```
+
+Subsequently:
+
+```
+  cd GF
+  darcs pull -a
+  cabal install
+```
+
+The above notes for installing from source apply also in this case.
+
+
+==Older releases==
+
+- [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).
--- a/download/index-3.4.t2t
+++ b/download/index-3.4.t2t
@@ -0,0 +1,145 @@
+Grammatical Framework Download and Installation
+
+
+**GF 3.4** was released on 31 January 2013.
+
+What's new? See the [Release notes release-3.4.html].
+
+
+== Binary packages ==
+
+| **Platform** | **Download** | **How to install**
+| MacOS X | [gf-3.4-bin-intel-mac.tar.gz gf-3.4-bin-intel-mac.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.4-bin-intel-mac.tar.gz``
+| 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] | -
+
+===Notes===
+
+%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.
+
+%The ``.pkg`` package works on MacOS X 10.6 (Snow Leopard).
+The MacOS tar package works on 10.6 (Leopard), 10.7 (Lion)
+and 10.8 (Mountain Lion).
+
+The MacOS 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.4/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 the prodedure is
+fairly simple:
+
+ Install the [Haskell Platform http://hackage.haskell.org/platform]
+  version 2012.4.0.0 (see notes 2&3 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.4.tar.gz`` gf-3.4.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`` 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 libghc6-terminfo-dev``
+- On Fedora: ``sudo yum install ghc-terminfo-devel``
+
+
+**Note 2**.
+GF 3.4 does **not** compile with the most recent versions of GHC (>=7.6).
+We recommend using GHC 7.4 (which is part of the Haskell Platform 2012.4.0.0).
+Older versions of GHC (6.12 and 7.0) still works for the most part.
+(For example, there is a issue with error reporting in ``gf -server``
+when compiled with GHC 7.0.)
+%GF does **not** compile with the most recent versions of Alex (>=3.0).
+
+**Note 3**.
+[The Haskell Platform for Mac OS X http://hackage.haskell.org/platform/mac.html]
+page states that you need Xcode 3.2 or later, but in fact it appears you need
+Xcode 3.2.3 or later. If you have Xcode 3.2.2, you can get an error from the
+linker: ``ld: unknown option: -no_pie``.
+
+=== 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 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 code==
+
+The first time:
+%, assuming you already have the Haskell Platform and darcs
+
+```
+  darcs get --lazy http://www.grammaticalframework.org/ GF
+  cd GF
+  cabal install
+```
+
+Subsequently:
+
+```
+  cd GF
+  darcs pull -a
+  cabal install
+```
+
+Alternatively, you can get the code from the
+[GF GitHub https://github.com/GrammaticalFramework/GF/] mirror, which is
+updated nightly.
+
+The above notes for installing from source apply also in these cases.
+For more info on working with the GF source code, see the
+[GF Developers Guide ../doc/gf-developers.html].
+
+==Older releases==
+
+- [GF 3.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).
--- a/download/index-3.5.t2t
+++ b/download/index-3.5.t2t
@@ -0,0 +1,152 @@
+Grammatical Framework Download and Installation
+
+
+**GF 3.5** was released on 6 August 2013.
+
+What's new? See the [Release notes release-3.5.html].
+
+
+== Binary packages ==
+
+| **Platform** | **Download** | **How to install**
+| MacOS X | [gf-3.5-bin-intel-mac.tar.gz gf-3.5-bin-intel-mac.tar.gz] | ``sudo tar -C /usr/local -zxf gf-3.5-bin-intel-mac.tar.gz``
+%| Fedora (32-bit) | [Fedora RPMs /~hallgren/tmp/Fedora/] | ``sudo rpm -i ...``
+| Ubuntu (32-bit) | [gf_3.5-1_i386.deb gf_3.5-1_i386.deb] | ``sudo dpkg -i gf_3.5-1_i386.deb``
+| Ubuntu (64-bit) | [gf_3.5-1_amd64.deb gf_3.5-1_amd64.deb] | ``sudo dpkg -i gf_3.5-1_amd64.deb``
+| Windows | [gf-3.5-bin-windows.zip gf-3.5-bin-windows.zip] | ``unzip gf-3.5-bin-windows.zip``
+%| ... | ... | ...
+
+%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 ``.deb`` packages work on Ubuntu 12.04, 12.10 and 13.04.
+
+%The ``.pkg`` package works on MacOS X 10.6 (Snow Leopard).
+The MacOS tar package works on 10.6 (Leopard), 10.7 (Lion)
+and 10.8 (Mountain Lion).
+
+The MacOS 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.5/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 the prodedure is
+fairly simple:
+
+ Install the [Haskell Platform http://hackage.haskell.org/platform]
+  version 2013.2.0.0 or 2012.4.0.0 (see notes 2&3 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.5.tar.gz`` gf-3.5.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`` 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**.
+We recommend using GHC 7.6 (which is part of the Haskell Platform 2013.2.0.0)
+or GHC 7.4 (which is part of the Haskell Platform 2012.4.0.0).
+Older versions of GHC (6.12 and 7.0) probably still work for the most part.
+(For example, there is a issue with error reporting in ``gf -server``
+when compiled with GHC 7.0.)
+%GF does **not** compile with the most recent versions of Alex (>=3.0).
+
+**Note 3**.
+[The Haskell Platform for Mac OS X http://hackage.haskell.org/platform/mac.html]
+page states that you need Xcode 3.2 or later, but in fact it appears you need
+Xcode 3.2.3 or later. If you have Xcode 3.2.2, you can get an error from the
+linker: ``ld: unknown option: -no_pie``.
+
+=== 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 code==
+
+The first time:
+%, assuming you already have the Haskell Platform and darcs
+
+```
+  darcs get --lazy http://www.grammaticalframework.org/ GF
+  cd GF
+  cabal install
+```
+
+Subsequently:
+
+```
+  cd GF
+  darcs pull -a
+  cabal install
+```
+
+Alternatively, you can get the code from the
+[GF GitHub https://github.com/GrammaticalFramework/GF/] mirror, which is
+updated nightly.
+
+The above notes for installing from source apply also in these cases.
+For more info on working with the GF source code, see the
+[GF Developers Guide ../doc/gf-developers.html].
+
+==Older releases==
+
+- [GF 3.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).
--- a/download/index-3.6.t2t
+++ b/download/index-3.6.t2t
@@ -0,0 +1,172 @@
+Grammatical Framework Download and Installation
+
+
+**GF 3.6** was released on 23 June 2014.
+
+What's new? See the [Release notes release-3.6.html].
+
+
+== Binary packages ==
+
+|| Platform | Download | Features | How to install
+| Mac OS X | [gf-3.6.pkg gf-3.6.pkg] | //GF+S+C// | Double-click on the package icon
+| Mac OS X | [gf-3.6-bin-intel-mac.tar.gz gf-3.6-bin-intel-mac.tar.gz] | //GF+S+C+P// | ``sudo tar -C /usr/local -zxf gf-3.6-bin-intel-mac.tar.gz``
+%| Fedora (32-bit) | [Fedora RPMs /~hallgren/tmp/Fedora/] | //GF+S+C+P// | ``sudo rpm -i ...``
+| Ubuntu (32-bit) | [gf_3.6-1_i386.deb gf_3.6-1_i386.deb] | //GF+S+C+P// | ``sudo dpkg -i gf_3.6-1_i386.deb``
+| Ubuntu (64-bit) | [gf_3.6-1_amd64.deb gf_3.6-1_amd64.deb] | //GF+S+C+P// | ``sudo dpkg -i gf_3.6-1_amd64.deb``
+| Windows | [gf-3.6-bin-windows.zip gf-3.6-bin-windows.zip] | //GF+S// | ``unzip gf-3.6-bin-windows.zip``
+| MINGW | [gf-3.6-bin-i686-MINGW32_NT-6.1.tar.gz gf-3.6-bin-i686-MINGW32_NT-6.1.tar.gz] | //GF+S+C// | ``tar -C / gf-3.6-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, P = Python binding to the C run-time system
+
+%More binary packages might be added later.
+
+===Notes===
+
+The Windows package is installed by just unpacking it anywhere.
+%It finds the libraries relative to the ``.exe`` file.
+You will probably need to set the ``PATH`` and ``GF_LIB_PATH`` environment
+variables, see Inari's notes on
+[Installing GF on Windows http://www.grammaticalframework.org/~inari/gf-windows.html#toc3].
+
+The new experimental MINGW package is for use in the
+[MINGW http://www.mingw.org] environment in Windows. Unpack it in the MSYS shell
+(which is started with ``C:\MinGW\msys\1.0\msys.bat``).
+It should work out of the box without any additional settings.
+
+The ``.deb`` packages work on Ubuntu 12.04, 13.10 and 14.04.
+
+The packages for Mac OS work on 10.8 (Mountain Lion) and on 10.9 (Mavericks).
+
+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.6/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 the [Haskell Platform http://hackage.haskell.org/platform]
+  version 2013.2.0.0 or 2012.4.0.0 (see notes 2&3 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.6.tar.gz`` gf-3.6.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**.
+We recommend using GHC 7.6 (which is part of the Haskell Platform 2013.2.0.0)
+or GHC 7.4 (which is part of the Haskell Platform 2012.4.0.0).
+Using GHC 7.0 will probably still work for the most part
+(but there is an issue with error reporting in ``gf -server``
+when compiled with GHC 7.0).
+Compilation with GHC 6.12 is no longer supported, because of multiple package
+version dependency problems.
+
+The GF source code has been updated to be compilable with GHC 7.8,
+unlike the [cgi http://hackage.haskell.org/package/cgi] package on Hackage,
+which is needed to compile GF with ``gf -server`` mode support.
+If you want to compile GF with GHC 7.8 and need ``gf -server`` mode,
+there is
+[a patched version of the cgi package on github https://github.com/jhenahan/haskell-cgi]
+that you can install instead of the version on Hackage.
+
+**Note 3**.
+[The Haskell Platform for Mac OS X http://www.haskell.org/platform/mac.html]
+page states that you need Xcode 3.2 or later, but in fact it appears you need
+Xcode 3.2.3 or later. If you have Xcode 3.2.2, you can get an error from the
+linker: ``ld: unknown option: -no_pie``.
+
+=== Known problems ===
+
+There seems to be a bug in some versions of Cabal that can cause
+
+```
+  Distribution/Simple/PackageIndex.hs:124:8-13: Assertion failed
+```
+
+if the same version of GF is
+already installed. If you encounter this, you can use ``ghc-pkg unregister gf``
+to remove the installed version of GF and ``ghc-pkg list gf`` to verify that
+it is gone.
+
+==Installing from the latest developer source code==
+
+The first time:
+%, assuming you already have the Haskell Platform and darcs
+
+```
+  darcs get --lazy http://www.grammaticalframework.org/ GF
+  cd GF
+  cabal install
+```
+
+Subsequently:
+
+```
+  cd GF
+  darcs pull -a
+  cabal install
+```
+
+Alternatively, you can get the code from the
+[GF GitHub https://github.com/GrammaticalFramework/GF/] mirror, which is
+updated nightly.
+
+The above notes for installing from source apply also in these cases.
+For more info on working with the GF source code, see the
+[GF Developers Guide ../doc/gf-developers.html].
+
+==Older releases==
+
+- [GF 3.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).
--- a/Show More
+++ b/Show More