Updating the release notes and installation instructions for the next release

download/index-next.t2t

@@ -53,8 +53,8 @@ unpacked the package.
 
 ==Installing the latest release from source==
 
-[GF is on Hackage http://hackage.haskell.org/package/gf], so the prodedure is
+[GF is on Hackage http://hackage.haskell.org/package/gf], so under normal
-fairly simple:
+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)
@@ -74,7 +74,8 @@ 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`` to add that directory to you path:
+idea to put a line in your ``.bash_profile`` or ``.profile``
+to add that directory to you path:
 
 ```
   PATH=$HOME/.cabal/bin:$PATH
@@ -99,12 +100,20 @@ 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.)
+when compiled with GHC 7.0).
 Compilation with GHC 6.12 is no longer supported, because of multiple package
-version depenency problems.
+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://hackage.haskell.org/platform/mac.html]
+[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``.

download/release-next.t2t

@@ -11,14 +11,16 @@ See the [download page http://www.grammaticalframework.org/download/index.html].
 
 ==What's new==
 
-Over [...] changes have been pushed to the source repository since the release
+Over 1200 changes have been pushed to the source repository since the release
-of GF 3.5.
+of GF 3.5 in August 2013.
 
 Closed [issues http://code.google.com/p/grammatical-framework/issues/list]:
  25, 30, 41, 57, 60, 61, 68, 80, 81, 82.
 
 ===GF compiler and run-time library===
 
+====New features and notable changes====
+
 - Token gluing, BIND, SOFT_BIND [...]
 - ``nonExist`` now exists. [...]
 - The default character encoding in grammar files has been changed from
@@ -27,10 +29,20 @@ Closed [issues http://code.google.com/p/grammatical-framework/issues/list]:
   See the separate document
   [GF character encoding changes encoding-change.html] for more details.
 - Unicode characters in identifiers [...]
-- The PGF file format has changed in minor but backward incompatible ways
+- The PGF file format has changed in minor but backward incompatible ways.
   GF can still read the old format, thanks to a backward compatibility
-  module. Old PGF files can be converted to the new format by loading them
+  module. The C run-time system supports only the new format. Old PGF files
-  in the GF shell and writing out a new PGF file with the ``pg -pgf`` command.
+  can be converted to the new format by loading them in the GF shell and
+  writing out a new PGF file with the ``pg -pgf`` command.
+- The PGF run-time library includes some new modules, e.g.
+ ``PGF.Lexing`` which contains lexing and unlexing functions, and
+  ``PGF2``, which is a binding to the C run-time system. The latter is included
+  only if GF is configured with ``-fc-runtime``, which is not the default,
+  since the C run-time system still has to be compiled and installed
+  separately before installing GF.
+
+
+====Bug fixes and minor changes====
 
 - Nonlinear patterns (i.e., patterns where the same variable appears more than
   once) in concrete syntax are now detected and reported as errors.
@@ -39,24 +51,53 @@ Closed [issues http://code.google.com/p/grammatical-framework/issues/list]:
 - A pattern matching bug which prevented variables in patterns to be bound to
   table values has been fixed.
 - A bug with local variable name shadowing has been fixed.
+- Type checking fixes: record extension change, correction of
+  subtyping check for ``Ints n<=Ints m``, contravariance in table types [...]
 - The refresh pass
 % (and thus the command line option --dump-refresh)
   had become obsolete and has been removed.
 - The old partial evaluator
   (and thus the command line options ``--new-comp`` and ``--old-comp``)
   has been removed.
+- A missing rewrite rule has been added to the partial evaluator. It
+  can significantly reduce the compilation time for certain grammars.
+- Some additional datestamp checks have been added to ``gf -make`` to avoid
+  recreating a PGF file when an uptodate PGF file already exists.
 
 
 ===Resource Grammar Library===
 
 - New languages in the Resource Grammar Library: Estonian
   (see the [updated synopsis ../lib/doc/synopsis.html]).
+- Grammars and dictionaries for wide coverage translation [...]
 - [...]
 
 
 ===GF Cloud services===
 
-- [...]
+- There is a preliminary new [Wide Coverage Translation Demo http://cloud.grammaticalframework.org/wc.html] web app. [...] Wide coverage translation is also
+  availble in the Simple Translation Tool.
+- PGF web service API: the ``lookupmorpho`` request has been added. [...]
+- PGF web service API:
+  requests like ``parse`` and ``translate`` that parse text input now
+  accept a ``lexer`` parameter to apply a lexer to the input text before
+  parsing. The lexer can be ``text``, ``code`` or ``mixed``.
+- PGF web service API:
+  requests like ``linearize`` and ``translate`` that produce
+  linearizations now accept an ``unlexer`` parameter to apply an unlexer to the
+  linearizations. The unlexer can be ``text``, ``code`` or ``mixed``.
+- The PGF web service API has been extended with following new requests
+  to access the C run-time system:
+  - ``c-parse``, ``c-linearize``, ``c-translate``, ``c-lookupmorpho``,
+    ``c-grammar``. These work in the same way as the corresponding requests
+    without the ``c-`` prefix. Since the ``c-parse`` and ``c-translate`` can
+    produce very many (even infinitely many) results when used with large
+    grammars, there is a ``limit`` parameter to restrict number of results
+    to a given number, e.g. ``limit=10``.
+  - ``c-wordforword``: this works as ``c-translate`` but does a
+    word-for-word lookup to create a (potentially very low quality)
+    translation that can be used if all else fails.
+
 
 --------------------