added testsuite for the parser

Code freeze for generation of binary distribution packages is imminent.

.authorspellings

@@ -0,0 +1,22 @@
+-- Use darcs show authors to see the number of patches per person
+
+Aarne Ranta		<aarne@chalmers.se>,		aarne@cs.chalmers.se, aarne
+Björn Bringert		<bjorn@bringert.net>,		bringert@cs.chalmers.se, bringert
+Krasimir Angelov	<krasimir@chalmers.se>,		kr.angelov@chalmers.se,kr.angelov@gmail.com,kr_angelov@gmail.com
+Peter Ljunglöf		<peb@ling.gu.se>,		peb,peb@cs.chalmers.se
+Thomas Hallgren		<hallgren@chalmers.se>,		hallgren@altocumulus.org
+Janna Khegai		<janna@cs.chalmer.se>,		janna,janna@cs.chalmers.se
+Jordi Saludes 		<jordi.saludes@upc.edu>
+Ramona Enache		<ramona.enache@chalmers.se>,	ra.monique@gmail.com
+Hans-Joachim Daniels	<hdaniels>
+Jean-Philippe Bernardy	<bernardy@chalmers.se>
+Kevin Kofler		<kevin.kofler@chello.at>
+Harald Hammarström	<harald2>
+Olga Caprotti		<caprotti@chalmers.se>,		olga.caprotti@gmail.com
+Adam Slaski		<adam.slaski@gmail.com>,	Adam Slaski <adam.slaski@gmail.com>
+Moisés Salvador Meza Moreno<meza@student.chalmers.se>,	'Moises Meza <meza@student.chalmers.se>'
+Ali El Dada		<eldada@student.chalmers.se>,	'ali.eldada@gmail.com'
+Markus Forsberg		<markus>
+Server Cimen		<e1560697@ceng.metu.edu.tr>
+Grégoire Détrez		<gdetrez@crans.org>
+Ketil Malde <ketil@ii.uib.no>

LICENSE

@@ -0,0 +1,572 @@
+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 resource grammar library in lib/src is under GNU LESSER GENERAL PUBLIC LICENSE.
+However the user have the right to choose any license for any application grammar
+derived from the resource grammar by using the grammar API.
+
+  - the resource grammar library also includes large coverage lexicons for some languages.
+Since these lexicons are derived from external sources they might be under different licenses.
+Look at the source file for every lexicon for details. The lexicons that we currently have
+are:
+
+       lib/src/bulgarian/    DictBul.gf DictBulAbs.gf    for Bulgarian
+       lib/src/english/      DictEng.gf DictEngAbs.gf    for English
+       lib/src/turkish/      DictTur.gf DictTurAbs.gf    for Turkish
+       lib/src/swedish/      DictSwe.gf DictSweAbs.gf    for Swedish
+
+The rest of this document contains copies of the GPL, LGPL and BSD licenses
+which are applicable to the different components of Grammatical Framework
+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.

Makefile

@@ -0,0 +1,29 @@
+.PHONY: all build install doc clean sdist
+
+all: build
+
+dist/setup-config: gf.cabal
+	chmod u+x lib/src/mkPresent
+	chmod u+x lib/src/mkMinimal
+	runghc Setup.hs configure
+
+build: dist/setup-config
+	runghc Setup.hs build
+
+install:
+	runghc Setup.hs install
+
+doc:
+	runghc Setup.hs haddock
+
+clean:
+	runghc Setup.hs clean
+
+sdist:
+	runghc Setup.hs sdist
+gf:
+	runghc Setup.hs build rgl-none
+	strip dist/build/gf/gf
+
+html::
+	bash bin/update_html

README

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

Setup.hs

@@ -0,0 +1,342 @@
+module Main where
+
+import Distribution.Simple
+import Distribution.Simple.LocalBuildInfo
+import Distribution.Simple.BuildPaths
+import Distribution.Simple.Utils
+import Distribution.Simple.Setup
+import Distribution.PackageDescription hiding (Flag)
+import Control.Monad
+import Data.Maybe
+import Data.List(isPrefixOf)
+import System.IO
+import System.Cmd
+import System.FilePath
+import System.Directory
+import System.Environment
+import System.Process
+import System.Exit
+
+main :: IO ()
+main = defaultMainWithHooks simpleUserHooks{ preBuild =checkRGLArgs
+                                           , postBuild=buildRGL
+                                           , preInst  =checkRGLArgs
+                                           , postInst =installRGL
+                                           , preCopy  =checkRGLArgs
+                                           , postCopy =copyRGL
+                                           , sDistHook=sdistRGL
+                                           , runTests =testRGL
+                                           }
+
+--------------------------------------------------------
+-- Commands for building the Resource Grammar Library
+--------------------------------------------------------
+
+data Mode = AllTenses | Present | Minimal deriving Show
+all_modes = ["minimal","present","alltenses"]
+default_modes = [Present,AllTenses]
+
+data RGLCommand
+  = RGLCommand
+      { cmdName   :: String
+      , cmdIsDef  :: Bool
+      , cmdAction :: [Mode] -> [String] -> PackageDescription -> LocalBuildInfo -> IO ()
+      }
+
+rglCommands =
+  [ RGLCommand "prelude" True  $ \mode args pkg lbi -> do
+       putStrLn $ "Compiling [prelude]"
+       let prelude_src_dir = rgl_src_dir     </> "prelude"
+           prelude_dst_dir = rgl_dst_dir lbi </> "prelude"
+       createDirectoryIfMissing True prelude_dst_dir
+       files <- getDirectoryContents prelude_src_dir
+       run_gfc pkg lbi (["-s", "--gfo-dir="++prelude_dst_dir] ++ [prelude_src_dir </> file | file <- files, take 1 file /= "."])
+  , RGLCommand "lang"    True  $ \mode args pkg lbi -> do
+       mapM_ (gfc mode pkg lbi . lang) (optl langsLang args)
+       mapM_ (gfc mode pkg lbi . symbol) (optl langsAPI args)
+  , RGLCommand "compat"  True  $ \mode args pkg lbi -> do
+       mapM_ (gfc mode pkg lbi . compat) (optl langsCompat args)
+  , RGLCommand "api"     True  $ \mode args pkg lbi -> do
+       mapM_ (gfc mode pkg lbi . try) (optl langsAPI args)
+       mapM_ (gfc mode pkg lbi . symbolic) (optl langsSymbolic args)
+  , RGLCommand "pgf"     False $ \modes args pkg lbi ->
+     sequence_ [
+       do let dir = getRGLBuildDir lbi mode
+          createDirectoryIfMissing True dir
+          sequence_ [run_gfc pkg lbi ["-s","-make","-name=Lang"++la,
+                                       dir ++ "/Lang" ++ la ++ ".gfo"] 
+                      | (_,la) <- optl langsPGF args]
+          run_gfc pkg lbi (["-s","-make","-name=Lang"]++
+                           ["Lang" ++ la ++ ".pgf"|(_,la)<-optl langsPGF args])
+       | mode <- modes]
+  , RGLCommand "demo"    False $ \mode args pkg lbi -> do
+       let ls = optl langsDemo args
+       gf (demos "Demo" ls) ["demo/Demo" ++ la ++ ".gf" | (_,la) <- ls] pkg lbi
+       return ()
+  , RGLCommand "parse"   False $ \mode args pkg lbi -> do
+       mapM_ (gfc mode pkg lbi . parse) (optl langsParse args)
+  , RGLCommand "none"    False $ \mode args pkg lbi -> do
+       return ()
+  ]
+  where
+    optl ls args = getOptLangs ls args
+
+--------------------------------------------------------
+
+checkRGLArgs args flags = do
+  let args' = filter (\arg -> not (arg `elem` all_modes ||
+                                   rgl_prefix `isPrefixOf` arg ||
+                                   langs_prefix `isPrefixOf` arg)) args
+  if null args'
+    then return emptyHookedBuildInfo
+    else die $ "Unrecognised flags: " ++ intercalate ", " args'
+
+buildRGL args flags pkg lbi = do
+  let cmds = getRGLCommands args
+  let modes = getOptMode args
+  mapM_ (\cmd -> cmdAction cmd modes args pkg lbi) cmds
+
+installRGL args flags pkg lbi = do
+  let modes = getOptMode args
+  let inst_gf_lib_dir = datadir (absoluteInstallDirs pkg lbi NoCopyDest) </> "lib"
+  copyAll "prelude"   (rgl_dst_dir lbi </> "prelude") (inst_gf_lib_dir </> "prelude")
+  sequence_ [copyAll (show mode) (getRGLBuildDir lbi mode) (inst_gf_lib_dir </> getRGLBuildSubDir lbi mode)|mode<-modes]
+
+copyRGL args flags pkg lbi = do
+  let modes = getOptMode args
+      dest = case copyDest flags of
+               NoFlag -> NoCopyDest
+               Flag d -> d
+  let inst_gf_lib_dir = datadir (absoluteInstallDirs pkg lbi dest) </> "lib"
+  copyAll "prelude"   (rgl_dst_dir lbi </> "prelude") (inst_gf_lib_dir </> "prelude")
+  sequence_ [copyAll (show mode) (getRGLBuildDir lbi mode) (inst_gf_lib_dir </> getRGLBuildSubDir lbi mode)|mode<-modes]
+
+copyAll s from to = do
+  putStrLn $ "Installing [" ++ s ++ "] " ++ to
+  createDirectoryIfMissing True to
+  files <- fmap (filter (\f -> take 1 f /= ".")) $ getDirectoryContents from
+  mapM_ (\file -> copyFile (from </> file) (to </> file)) files
+
+sdistRGL pkg mb_lbi hooks flags = do
+  paths <- getRGLFiles rgl_src_dir []
+  let pkg' = pkg{dataFiles=paths}
+  sDistHook simpleUserHooks pkg' mb_lbi hooks flags
+  where
+    getRGLFiles dir paths = do
+      files <- getDirectoryContents dir
+      foldM (processFile dir) paths [file | file <- files, file /= "." && file /= ".."]
+
+    processFile dir paths file = do
+      let path = dir </> file
+      print path
+      isFile <- doesFileExist path
+      if isFile
+        then if takeExtension file == ".gf" || file == "LICENSE"
+               then return (path : paths)
+               else return paths
+        else getRGLFiles path paths
+
+testRGL args _ pkg lbi = do
+  let paths = case args of
+                []    -> ["testsuite"]
+                paths -> paths
+  sequence_ [walk path | path <- paths]
+  where
+    walk path = do
+      files <- getDirectoryContents path
+      sequence_ [walkFile (path </> file) | file <- files, file /= "." && file /= ".."]
+
+    walkFile fpath = do
+      exists <- doesFileExist fpath
+      if exists
+        then if takeExtension fpath == ".gfs"
+               then do let in_file   = fpath
+                           gold_file = addExtension fpath ".gold"
+                           out_file  = addExtension fpath ".out"
+                       putStr (in_file++" ... ")
+                       hFlush stdout
+                       res <- runTest in_file out_file gold_file
+                       putStrLn (if res then "OK" else "FAIL")
+               else return ()
+        else walk fpath
+
+    runTest in_file out_file gold_file = do
+      inp <- readFile in_file
+      out <- readProcess (default_gf pkg lbi) ["-run"] inp
+      writeFile out_file out
+      exists <- doesFileExist gold_file
+      if exists
+        then do gold <- readFile gold_file
+                return $! (out == gold)
+        else return False
+
+
+rgl_src_dir     = "lib" </> "src"
+rgl_dst_dir lbi = buildDir lbi </> "rgl"
+
+-- the languages have long directory names and short ISO codes (3 letters)
+-- we also give the decodings for postprocessing linearizations, as long as grammars
+-- don't support all flags needed; they are used in tests
+ 
+langsCoding = [
+  (("amharic",  "Amh"),""),
+  (("arabic",   "Ara"),""),
+  (("bulgarian","Bul"),""),
+  (("catalan",  "Cat"),""),
+  (("danish",   "Dan"),""),
+  (("dutch",    "Dut"),""),
+  (("english",  "Eng"),""),
+  (("finnish",  "Fin"),""),
+  (("french",   "Fre"),""),
+  (("hindi",    "Hin"),"to_devanagari"),
+  (("german",   "Ger"),""),
+  (("interlingua","Ina"),""),
+  (("italian",  "Ita"),""),
+  (("latin",    "Lat"),""),
+  (("norwegian","Nor"),""),
+  (("polish",   "Pol"),""),
+  (("romanian", "Ron"),""),
+  (("russian",  "Rus"),""),
+  (("spanish",  "Spa"),""),
+  (("swedish",  "Swe"),""), 
+  (("thai",     "Tha"),"to_thai"),
+  (("turkish",  "Tur"),""),
+  (("urdu",     "Urd"),"")
+  ]
+
+langs = map fst langsCoding
+
+-- default set of languages to compile
+-- defaultLangs = langs `only` words "Eng Fre Ger Ita Spa Swe"
+
+-- languagues for which to compile Lang
+langsLang = langs `except` ["Amh","Ara","Lat","Hin","Tha","Tur"]
+--langsLang = langs `only` ["Fin"] --test
+
+-- languages for which to compile Try 
+langsAPI  = langsLang `except` ["Hin","Ina","Tha"]
+
+-- languages for which to compile Symbolic 
+langsSymbolic  = langsAPI `except` ["Rus"]
+
+-- languages for which to run demo test
+langsDemo = langsLang `except` ["Ara","Hin","Ina","Tha"]
+
+-- languages for which to compile parsing grammars
+langsParse = langs `only` ["Eng"]
+
+-- languages for which langs.pgf is built
+langsPGF = langsLang `except` ["Ara","Hin","Ron","Tha"]
+
+-- languages for which Compatibility exists (to be extended)
+langsCompat = langsLang `only` ["Cat","Eng","Fin","Fre","Ita","Spa","Swe"]
+
+gfc modes pkg lbi file = sequence_ [gfc1 mode pkg lbi file | mode<-modes]
+gfc1 mode pkg lbi file = do
+  let dir = getRGLBuildDir lbi mode
+      preproc = case mode of
+                  AllTenses -> ""
+                  Present   -> "-preproc="++({-rgl_src_dir </>-} "mkPresent")
+                  Minimal   -> "-preproc="++({-rgl_src_dir </>-} "mkMinimal")
+  createDirectoryIfMissing True dir
+  putStrLn $ "Compiling [" ++ show mode ++ "] " ++ file
+  run_gfc pkg lbi ["-s", preproc, "--gfo-dir="++dir, file]
+
+gf comm files pkg lbi = do
+  putStrLn $ "Reading " ++ unwords files
+  let gf = default_gf pkg lbi
+  putStrLn ("executing: " ++ comm ++ "\n" ++
+            "in " ++ gf)
+  out <- readProcess gf ("-s":files) comm
+  putStrLn out
+
+demos abstr ls = "gr -number=100 | l -treebank " ++ unlexer abstr ls ++ 
+           " | ps -to_html | wf -file=resdemo.html"
+
+lang   (lla,la) = rgl_src_dir </> lla </> ("All"           ++ la ++ ".gf")
+compat (lla,la) = rgl_src_dir </> lla </> ("Compatibility" ++ la ++ ".gf")
+symbol (lla,la) = rgl_src_dir </> lla </> ("Symbol"        ++ la ++ ".gf")
+
+try    (lla,la) = rgl_src_dir </> "api" </> ("Try"    ++ la ++ ".gf")
+syntax (lla,la) = rgl_src_dir </> "api" </> ("Syntax" ++ la ++ ".gf")
+
+symbolic (lla,la) = rgl_src_dir </> "api"   </> ("Symbolic" ++ la ++ ".gf")
+parse    (lla,la) = rgl_src_dir </> "parse" </> ("Parse"    ++ la ++ ".gf")
+
+except ls es = filter (flip notElem es . snd) ls
+only   ls es = filter (flip elem es . snd) ls
+
+getOptMode args =
+    if null explicit_modes
+    then default_modes
+    else explicit_modes
+  where
+    explicit_modes = 
+      [Minimal|have "minimal"]++
+      [Present|have "present"]++
+      [AllTenses|have "alltenses"]
+
+    have mode = mode `elem` args
+
+-- list of languages overriding the definitions above
+getOptLangs defaultLangs args =
+    case [ls | arg <- args,
+               let (f,ls) = splitAt (length langs_prefix) arg,
+               f==langs_prefix] of
+      ('+':ls):_ -> foldr addLang defaultLangs (seps ls)
+      ('-':ls):_ -> foldr removeLang defaultLangs (seps ls)
+      ls:_ -> findLangs langs (seps ls)
+      _    -> defaultLangs
+  where
+    seps = words . map (\c -> if c==',' then ' ' else c)
+    findLangs langs ls = [lang | lang@(_,la) <- langs, la `elem` ls]
+    removeLang l ls = [lang | lang@(_,la) <- ls, la/=l]
+    addLang l ls = if null (findLangs ls [l])
+                   then findLangs langs [l]++ls
+                   else ls
+
+getRGLBuildSubDir lbi mode =
+  case mode of
+    AllTenses -> "alltenses"
+    Present   -> "present"
+    Minimal   -> "minimal"
+
+getRGLBuildDir lbi mode = rgl_dst_dir lbi </> getRGLBuildSubDir lbi mode
+
+getRGLCommands args =
+  let cmds0 = [cmd | arg <- args,
+                     let (prefix,name) = splitAt (length rgl_prefix) arg,
+                     prefix == rgl_prefix,
+                     cmd <- rglCommands,
+                     cmdName cmd == name]
+  in if null cmds0
+       then [cmd | cmd <- rglCommands, cmdIsDef cmd]
+       else cmds0
+
+langs_prefix = "langs="
+rgl_prefix = "rgl-"
+
+unlexer abstr ls = 
+  "-unlexer=\\\"" ++ unwords 
+      [abstr ++ la ++ "=" ++ unl | 
+        lla@(_,la) <- ls, let unl = unlex lla, not (null unl)] ++ 
+      "\\\""
+    where
+      unlex lla = maybe "" id $ lookup lla langsCoding
+
+-- | Runs the gf executable in compile mode with the given arguments.
+run_gfc :: PackageDescription -> LocalBuildInfo -> [String] -> IO ()
+run_gfc pkg lbi args = 
+    do let args' = ["-batch","-gf-lib-path="++rgl_src_dir,"+RTS","-K32M","-RTS"] ++ filter (not . null) args
+           gf = default_gf pkg lbi
+       putStrLn $ "Running: " ++ gf ++ " " ++ unwords (map showArg args')
+       e <- rawSystem gf args'
+       case e of
+         ExitSuccess   -> return ()
+         ExitFailure i -> die $ "gf exited with exit code: " ++ show i
+  where showArg arg = "'" ++ arg ++ "'"
+
+default_gf pkg lbi = buildDir lbi </> exeName' </> exeNameReal
+  where
+    exeName' = (exeName . head . executables) pkg
+    exeNameReal = exeName' <.> (if null $ takeExtension exeName' then exeExtension else "")

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"

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 $*"
-

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 $*"
-

bin/update_html

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+### This script finds all .t2t (txt2tags) files and updates the corresponding
+### .html file, if it is out-of-date.
+
+find . -name '*.t2t' | while read t2t ; do
+  html="${t2t%.t2t}.html"
+  if [ "$t2t" -nt "$html" ] ; then
+    txt2tags -thtml "$t2t"
+  fi
+done

book/examples/chapter2/Copy.gf

@@ -0,0 +1,7 @@
+concrete Copy of CopyAbs = {
+  lincat S, AB = Str ;
+  lin s x = x ++ x ;
+      end = [] ;
+      a x = "a" ++ x ;
+      b x = "b" ++ x ;
+}

book/examples/chapter2/CopyAbs.gf

@@ -0,0 +1,6 @@
+abstract CopyAbs = {
+  cat S ; AB ;
+  fun s   : AB -> S ;
+      end : AB ;
+      a,b : AB -> AB ;
+}

book/examples/chapter2/Food.gf

@@ -0,0 +1,13 @@
+abstract Food = {
+  flags startcat = Comment ;
+  cat
+    Comment ; Item ; Kind ; Quality ; 
+  fun
+    Pred : Item -> Quality -> Comment ;
+    This, That : Kind -> Item ;
+    Mod : Quality -> Kind -> Kind ;
+    Wine, Cheese, Fish : Kind ;
+    Very : Quality -> Quality ;
+    Fresh, Warm, Italian, 
+      Expensive, Delicious, Boring : Quality ;
+}

book/examples/chapter2/Food.probs

@@ -0,0 +1,4 @@
+  This  0.8
+  Mod   0.2
+  Wine  0.0
+  Fresh 0.4

book/examples/chapter2/FoodEng.gf

@@ -0,0 +1,19 @@
+concrete FoodEng of Food = {
+  lincat
+    Comment, Item, Kind, Quality = Str ;
+  lin
+    Pred item quality = item ++ "is" ++ quality ;
+    This kind = "this" ++ kind ;
+    That kind = "that" ++ kind ;
+    Mod quality kind = quality ++ kind ;
+    Wine = "wine" ;
+    Cheese = "cheese" ;
+    Fish = "fish" ;
+    Very quality = "very" ++ quality ;
+    Fresh = "fresh" ;
+    Warm = "warm" ;
+    Italian = "Italian" ;
+    Expensive = "expensive" ;
+    Delicious = "delicious" ;
+    Boring = "boring" ;
+}  

book/examples/chapter2/FoodHin.gf

@@ -0,0 +1,24 @@
+
+ concrete FoodHin of Food = {
+   flags coding = utf8 ;
+   lincat Comment, Item, Kind, Quality = Str ;
+   lin
+     Pred item quality = item ++ quality ++ "है" ;
+     This kind = "यह" ++ kind ;
+     That kind = "वह" ++ kind ;
+     Mod quality kind = quality ++ kind ;
+     Wine = "मदिरा" ;
+     Cheese = "पनीर" ;
+     Fish = "मछली" ;
+     Very quality = "अति" ++ quality ;
+     Fresh = "ताज़ा" ;
+     Warm = "गरम" ;
+     Italian = "इटली" ; 
+     Expensive = "बहुमूल्य" ;
+     Delicious = "स्वादिष्ट" ;
+     Boring = "अरुचिकर" ;
+ }
+
+
+
+

book/examples/chapter2/FoodIta.gf

@@ -0,0 +1,19 @@
+concrete FoodIta of Food = {
+  lincat
+    Comment, Item, Kind, Quality = Str ;
+  lin
+    Pred item quality = item ++ "è" ++ quality ;
+    This kind = "questo" ++ kind ;
+    That kind = "quel" ++ kind ;
+    Mod quality kind = kind ++ quality ;
+    Wine = "vino" ;
+    Cheese = "formaggio" ;
+    Fish = "pesce" ;
+    Very quality = "molto" ++ quality ;
+    Fresh = "fresco" ;
+    Warm = "caldo" ;
+    Italian = "italiano" ;
+    Expensive = "caro" ;
+    Delicious = "delizioso" ;
+    Boring = "noioso" ;
+}

book/examples/chapter2/Letters.gf

@@ -0,0 +1,8 @@
+abstract Letters = {
+
+cat L ;
+fun 
+  a, b, c, d, e, f, g, h, i, j, k, l, m, 
+  n, o, p, q, r, s, t, u, v, w, x, y, z : L ;
+
+}

book/examples/chapter2/LettersCnc.gf

@@ -0,0 +1,31 @@
+concrete LettersCnc of Letters = {
+
+  lincat L = Str ;
+  lin 
+    a = "a" ;
+    b = "b" ;
+    c = "c" ;
+    d = "d" ;
+    e = "e" ;
+    f = "f" ;
+    g = "g" ;
+    h = "h" ;
+    i = "i" ;
+    j = "j" ;
+    k = "k" ;
+    l = "l" ;
+    m = "m" ;
+    n = "n" ;
+    o = "o" ;
+    p = "p" ;
+    q = "q" ;
+    r = "r" ;
+    s = "s" ;
+    t = "t" ;
+    u = "u" ;
+    v = "v" ;
+    w = "w" ;
+    x = "x" ;
+    y = "y" ;
+    z = "z" ;
+}

book/examples/chapter2/Strings.gf

@@ -0,0 +1,7 @@
+abstract Strings = Letters ** {
+
+cat S ;
+fun 
+  E : S ;
+  C : L -> S -> S ;
+}

book/examples/chapter2/StringsBW.gf

@@ -0,0 +1,5 @@
+concrete StringsBW of Strings = LettersCnc ** {
+  lincat S = Str ;
+  lin E = [] ;
+  lin C head tail = tail ++ head ;
+}

book/examples/chapter2/StringsFW.gf

@@ -0,0 +1,5 @@
+concrete StringsFW of Strings = LettersCnc ** {
+  lincat S = Str ;
+  lin E = [] ;
+  lin C head tail = head ++ tail ;
+}

book/examples/chapter2/Ticket.gf

@@ -0,0 +1,10 @@
+abstract Ticket = {
+
+flags startcat = Request ;
+cat
+  Request ; Station ;
+fun 
+  Ticket : Station -> Station -> Request ;
+  Hamburg, Paris : Station ;
+
+}

book/examples/chapter2/TicketEng.gf

@@ -0,0 +1,19 @@
+concrete TicketEng of Ticket = {
+
+lincat
+  Request, Station = Str ;
+lin 
+  Ticket X Y = 
+    ((("I" ++ ("would like" | "want") ++ "to get" |
+      ("may" | "can") ++ "I get" | 
+      "can you give me" |
+      []) ++ 
+        "a ticket") | 
+     []) ++ 
+     "from" ++ X ++ "to" ++ Y ++ 
+     ("please" | []) ;
+
+  Hamburg = "Hamburg" ;
+  Paris = "Paris" ;
+
+}

book/examples/chapter2/foodEng.cf

@@ -0,0 +1,14 @@
+Pred.      Comment ::= Item "is" Quality
+This.      Item    ::= "this" Kind 
+That.      Item    ::= "that" Kind
+Mod.       Kind    ::= Quality Kind 
+Wine.      Kind    ::= "wine" 
+Cheese.    Kind    ::= "cheese" 
+Fish.      Kind    ::= "fish"
+Very.      Quality ::= "very" Quality
+Fresh.     Quality ::= "fresh" 
+Warm.      Quality ::= "warm" 
+Italian.   Quality ::= "Italian" 
+Expensive. Quality ::= "expensive" 
+Delicious. Quality ::= "delicious" 
+Boring.    Quality ::= "boring"

book/examples/chapter2/foodIta.cf

@@ -0,0 +1,14 @@
+Pred.      Comment ::= Item "è" Quality
+This.      Item    ::= "questo" Kind 
+That.      Item    ::= "quel" Kind
+Mod.       Kind    ::= Kind Quality
+Wine.      Kind    ::= "vino" 
+Cheese.    Kind    ::= "formaggio"
+Fish.      Kind    ::= "pesce"
+Very.      Quality ::= "molto" Quality
+Fresh.     Quality ::= "fresco" 
+Warm.      Quality ::= "caldo" 
+Italian.   Quality ::= "italiano" 
+Expensive. Quality ::= "caro" 
+Delicious. Quality ::= "delizioso" 
+Boring.    Quality ::= "noioso"

book/examples/chapter3/Arabic.gf

@@ -0,0 +1,118 @@
+resource Arabic = {
+oper
+  Root    : Type = {F,C,L : Str} ;
+  Pattern : Type = Root -> Str ;
+
+  Filling : Type = {F,FC,CL,L : Str} ;
+
+  fill : Filling -> Root -> Str = \p,r ->
+    p.F + r.F + p.FC + r.C + p.CL + r.L + p.L ;
+
+  dfill : Filling -> Root -> Str = \p,r ->
+    p.F + r.F + p.FC + r.C + r.C + p.CL + r.L + p.L ;
+
+  getRoot : Str -> Root = \s -> case s of {
+    F@? + C@? + L@? => {F = F ; C = C ; L = L} ;
+    _ => Predef.error ("cannot get root from" ++ s)
+    } ;
+
+  getPattern : Str -> Pattern = \s -> case s of {
+    F + "F" + FC + "CC" + CL + "L" + L => 
+      dfill {F = F ; FC = FC ; CL = CL ; L = L} ;
+    F + "F" + FC + "C" + CL + "L" + L => 
+      fill {F = F ; FC = FC ; CL = CL ; L = L} ;
+    _ => Predef.error ("cannot get pattern from" ++ s)
+    } ;
+
+  word : Str -> Str -> Str = \p,r ->
+    getPattern p (getRoot r) ;
+
+param
+  Number = Sg | Dl | Pl ;
+  Gender = Masc | Fem ;
+  Tense  = Perf | Impf ;
+
+  VPer = Vp3 Number Gender | Vp2Sg Gender | Vp2Dl | Vp2Pl Gender | Vp1Sg | Vp1Pl ;
+
+oper
+  Verb : Type = {s : Tense => VPer => Str} ;  
+
+  pattV_u : Tense -> VPer -> Pattern = \t,v -> getPattern (case t of {
+    Perf => case v of {
+      Vp3 Sg Masc => "FaCaLa" ;
+      Vp3 Sg Fem  => "FaCaLat" ;
+      Vp3 Dl Masc => "FaCaLaA" ;
+      Vp3 Dl Fem  => "FaCaLataA" ;
+      Vp3 Pl Masc => "FaCaLuwA" ;
+      Vp3 Pl Fem  => "FaCaLona" ;
+
+      Vp2Sg  Masc => "FaCaLota" ;
+      Vp2Sg  Fem  => "FaCaLoti" ;
+      Vp2Dl       => "FaCaLotumaA" ;
+      Vp2Pl  Masc => "FaCaLotum" ;
+      Vp2Pl  Fem  => "FaCaLotunv2a" ;
+       
+      Vp1Sg       => "FaCaLotu" ;
+      Vp1Pl       => "FaCaLonaA"
+      } ;
+    Impf => case v of {
+      Vp3 Sg Masc => "yaFoCuLu" ;
+      Vp3 Sg Fem  => "taFoCuLu" ;
+      Vp3 Dl Masc => "yaFoCuLaAni" ;
+      Vp3 Dl Fem  => "taFoCuLaAni" ;
+      Vp3 Pl Masc => "yaFoCuLuwna" ;
+      Vp3 Pl Fem  => "yaFoCuLna" ;
+
+      Vp2Sg  Masc => "taFoCuLu" ;
+      Vp2Sg  Fem  => "taFoCuLiyna" ;
+      Vp2Dl       => "taFoCuLaAni" ;
+      Vp2Pl  Masc => "taFoCuLuwna" ;
+      Vp2Pl  Fem  => "taFoCuLona" ;
+       
+      Vp1Sg       => "A?aFoCuLu" ;
+      Vp1Pl       => "naFoCuLu"
+      }
+   }) ;
+
+  u_Verb : Str -> Verb = \s -> {
+    s = \\t,p => pattV_u t p (getRoot s) ;
+    } ;
+
+-- for html
+
+  tag : Str -> Str = \t -> "<" + t + ">" ;
+  etag : Str -> Str = \t -> "</" + t + ">" ;
+  atag : Str -> Str -> Str = \t,a -> "<" + t ++ a + ">" ;
+
+  intag : Str -> Str -> Str = \t,s -> tag t ++ s ++ etag t ;
+  intagAttr : Str -> Str -> Str -> Str = \t,a,s -> atag t a ++ s ++ etag t ;
+
+  verbTable : Verb -> Str = \v -> 
+    let 
+      vsp = v.s ! Perf ;
+      vsi = v.s ! Impf ;
+      tr : Str -> Str = intag "tr" ;
+      td : Str -> Str = intag "td" ;
+      ts : Str -> Str = \s -> td ("\"" ++ s ++ "\"") ;
+      trs : Str -> Str -> VPer -> Str = \s,n,v -> 
+        tr (td s ++ td n ++ ts (vsp ! v) ++ ts (vsi ! v))
+    in 
+    intagAttr "table" "border=1" (
+       tr ((td "Persona") ++ (td "Numerus") ++ (td "Perfectum") ++ (td "Imperfectum")) ++
+       trs "3. masc." "sing." (Vp3 Sg Masc) ++
+       trs "3. fem."  "sing." (Vp3 Sg Fem) ++
+       trs "2. masc." "sing." (Vp2Sg Masc) ++
+       trs "2. fem."  "sing." (Vp2Sg Fem) ++
+       trs "1."       "sing." (Vp1Sg) ++
+       trs "3. masc." "dual." (Vp3 Dl Masc) ++
+       trs "3. fem."  "dual." (Vp3 Dl Fem) ++
+       trs "2."       "dual." (Vp2Dl) ++
+       trs "3. masc." "plur." (Vp3 Pl Masc) ++
+       trs "3. fem."  "plur." (Vp3 Pl Fem) ++
+       trs "2. masc." "plur." (Vp2Pl Masc) ++
+       trs "2. fem."  "plur." (Vp2Pl Fem) ++
+       trs "1."       "plur." (Vp1Pl)
+      ) ;
+
+
+}

book/examples/chapter3/Discont.gf

@@ -0,0 +1,11 @@
+abstract Discont = {
+  cat 
+    S ; Cl ; NP ; VP ; AP ; 
+  fun 
+    DeclCl  : Cl -> S ;
+    QuestCl : Cl -> S ;
+    PredVP  : NP -> VP -> Cl ; 
+    CompAP  : AP -> VP ;
+    John : NP ;
+    Old : AP ;
+}

book/examples/chapter3/DiscontEng.gf

@@ -0,0 +1,21 @@
+concrete DiscontEng of Discont = {
+  param
+    SForm = SDecl | SQuest ;
+  lincat 
+    S, NP, AP = Str ;
+    Cl = SForm => Str ;
+    VP = {verb,comp : Str} ; 
+  lin 
+    DeclCl  cl = cl ! SDecl ;
+    QuestCl cl = cl ! SQuest ;
+    PredVP np vp = table {
+      SDecl  => np ++ vp.verb ++ vp.comp ;
+      SQuest => vp.verb ++ np ++ vp.comp
+      } ;
+    CompAP ap = {
+      verb = "is" ;
+      comp = ap
+      } ;
+    John = "John" ;
+    Old = "old" ;
+}

book/examples/chapter3/Foods.gf

@@ -0,0 +1,13 @@
+abstract Foods = {
+  flags startcat = Comment ;
+  cat
+    Comment ; Item ; Kind ; Quality ;
+  fun
+    Pred : Item -> Quality -> Comment ;
+    This, That, These, Those : Kind -> Item ;
+    Mod : Quality -> Kind -> Kind ;
+    Wine, Cheese, Fish, Pizza : Kind ;
+    Very : Quality -> Quality ;
+    Fresh, Warm, Italian, 
+      Expensive, Delicious, Boring : Quality ;
+}

book/examples/chapter3/FoodsEng.gf

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

book/examples/chapter3/FoodsIta.gf

@@ -0,0 +1,32 @@
+concrete FoodsIta of Foods = open ResIta in {
+  lincat
+    Comment = {s : Str} ; 
+    Quality = Adjective ; 
+    Kind = Noun ; 
+    Item = NounPhrase ;
+  lin
+    Pred item quality = 
+      {s = item.s ++ copula ! item.n ++ 
+           quality.s ! item.g ! item.n} ;
+    This  = det Sg "questo" "questa" ;
+    That  = det Sg "quel"   "quella" ;
+    These = det Pl "questi" "queste" ;
+    Those = det Pl "quei"   "quelle" ;
+    Mod quality kind = {
+      s = \\n => kind.s ! n ++ quality.s ! kind.g ! n ;
+      g = kind.g
+      } ;
+    Wine = noun "vino" "vini" Masc ;
+    Cheese = noun "formaggio" "formaggi" Masc ;
+    Fish = noun "pesce" "pesci" Masc ;
+    Pizza = noun "pizza" "pizze" Fem ;
+    Very qual = {s = \\g,n => "molto" ++ qual.s ! g ! n} ;
+    Fresh = 
+      adjective "fresco" "fresca" "freschi" "fresche" ;
+    Warm = regAdj "caldo" ;
+    Italian = regAdj "italiano" ;
+    Expensive = regAdj "caro" ;
+    Delicious = regAdj "delizioso" ;
+    Boring = regAdj "noioso" ;
+}
+

book/examples/chapter3/ResIta.gf

@@ -0,0 +1,36 @@
+resource ResIta = open Prelude in {
+  param
+    Number = Sg | Pl ;
+    Gender = Masc | Fem ;
+  oper
+    NounPhrase : Type = 
+      {s : Str ; g : Gender ; n : Number} ; 
+    Noun : Type = {s : Number => Str ; g : Gender} ;
+    Adjective : Type = {s : Gender => Number => Str} ;
+
+    det : Number -> Str -> Str -> Noun -> NounPhrase =
+      \n,m,f,cn -> {
+        s = table {Masc => m ; Fem => f} ! cn.g ++ 
+            cn.s ! n ;
+        g = cn.g ;
+        n = n
+      } ;
+    noun : Str -> Str -> Gender -> Noun =
+      \vino,vini,g -> {
+        s = table {Sg => vino ; Pl => vini} ;
+        g = g
+      } ;
+    adjective : (nero,nera,neri,nere : Str) -> Adjective =
+      \nero,nera,neri,nere -> {
+        s = table {
+          Masc => table {Sg => nero ; Pl => neri} ; 
+          Fem => table {Sg => nera ; Pl => nere}
+          }
+        } ;
+    regAdj : Str -> Adjective = \nero ->
+      let ner : Str = init nero 
+      in 
+      adjective nero (ner+"a") (ner+"i") (ner+"e") ;
+    copula : Number => Str = 
+      table {Sg => "è" ; Pl => "sono"} ;
+}

book/examples/chapter4/Clothes.gf

@@ -0,0 +1,5 @@
+abstract Clothes = Comments ** {
+  fun
+    Shirt, Jacket : Kind ;
+    Comfortable, Elegant : Quality ;
+}

book/examples/chapter4/ClothesEng.gf

@@ -0,0 +1,10 @@
+--# -path=.:present
+
+concrete ClothesEng of Clothes = CommentsEng ** 
+    open SyntaxEng, ParadigmsEng in {
+  lin
+    Shirt = mkCN (mkN "shirt") ;
+    Jacket = mkCN (mkN "jacket") ;
+    Comfortable = mkAP (mkA "comfortable") ;
+    Elegant = mkAP (mkA "elegant") ;
+}

book/examples/chapter4/ClothesIta.gf

@@ -0,0 +1,8 @@
+concrete ClothesIta of Clothes = CommentsIta ** 
+    open SyntaxIta, ParadigmsIta in {
+  lin
+    Shirt = mkCN (mkN "camicia") ;
+    Jacket = mkCN (mkN "giacca") ;
+    Comfortable = mkAP (mkA "comodo") ;
+    Elegant = mkAP (mkA "elegante") ;
+}

book/examples/chapter4/Comment.gf

@@ -0,0 +1,13 @@
+abstract Comment = {
+  flags startcat = Comment ;
+  cat
+    Comment ; Item ; Kind ; Quality ;
+  fun
+    Pred : Item -> Quality -> Comment ;
+    This, That, These, Those : Kind -> Item ;
+    Mod : Quality -> Kind -> Kind ;
+    Wine, Cheese, Fish, Pizza : Kind ;
+    Very : Quality -> Quality ;
+    Fresh, Warm, Italian, 
+      Expensive, Delicious, Boring : Quality ;
+}

book/examples/chapter4/Comments.gf

@@ -0,0 +1,10 @@
+abstract Comments = {
+  flags startcat = Comment ;
+  cat
+    Comment ; Item ; Kind ; Quality ;
+  fun
+    Pred : Item -> Quality -> Comment ;
+    This, That, These, Those : Kind -> Item ;
+    Mod : Quality -> Kind -> Kind ;
+    Very : Quality -> Quality ;
+}

book/examples/chapter4/CommentsEng.gf

@@ -0,0 +1,4 @@
+--# -path=.:present
+
+concrete CommentsEng of Comments = CommentsI with 
+  (Syntax = SyntaxEng) ;

book/examples/chapter4/CommentsI.gf

@@ -0,0 +1,15 @@
+incomplete concrete CommentsI of Comments = open Syntax in {
+  lincat
+    Comment = Cl ; 
+    Item = NP ;
+    Kind = CN ;
+    Quality = AP ;
+  lin
+    Pred item quality = mkCl item quality ;
+    This kind = mkNP this_QuantSg kind ;
+    That kind = mkNP that_QuantSg kind ;
+    These kind = mkNP these_QuantPl kind ;
+    Those kind = mkNP those_QuantPl kind ;
+    Mod quality kind = mkCN quality kind ;
+    Very quality = mkAP very_AdA quality ;
+}

book/examples/chapter4/CommentsIta.gf

@@ -0,0 +1,4 @@
+--# -path=.:present
+
+concrete CommentsIta of Comments = CommentsI with 
+  (Syntax = SyntaxIta) ;

book/examples/chapter4/Computers.gf

@@ -0,0 +1,5 @@
+abstract Computers = Comments ** {
+  fun
+    Computer, HardDisk : Kind ;
+    Efficient, Slow : Quality ;
+}

book/examples/chapter4/ComputersEng.gf

@@ -0,0 +1,10 @@
+--# -path=.:present
+
+concrete ComputersEng of Computers = CommentsEng ** 
+    open SyntaxEng, ParadigmsEng in {
+  lin
+    Computer = mkCN (mkN "computer") ;
+    HardDisk = mkCN (mkA "hard") (mkN "disk") ;
+    Efficient = mkAP (mkA "efficient") ;
+    Slow = mkAP (mkA "slow") ;
+}

book/examples/chapter4/ComputersIta.gf

@@ -0,0 +1,9 @@
+concrete ComputersIta of Computers = 
+    CommentsIta ** open ResIta in {
+  lin
+    Computer = noun "computer" "computer" Masc ;
+    HardDisk = noun "disco rigido" "dischi rigidi" Masc ;
+    Efficient = adjective "efficiente" "efficiente" 
+                          "efficienti" "efficienti" ;
+    Slow = regAdj "lento" ;
+}

book/examples/chapter4/DefArtGer.gf

@@ -0,0 +1,16 @@
+resource DefArtGer = {
+
+  param DetForm = DSg Gender Case | DPl Case ;
+  param Gender = Masc | Fem | Neutr ;
+  param Case = Nom | Acc | Dat | Gen ;
+
+  oper artDef : DetForm => Str = table {
+    DSg Masc Acc | DPl Dat => "den" ;
+    DSg (Masc | Neutr) Dat => "dem" ;
+    DSg (Masc | Neutr) Gen => "des" ;
+    DSg Neutr _ => "das" ;
+    DSg Fem (Nom | Acc) | DPl (Nom | Acc) => "die" ; 
+    _ => "der"
+    } ;
+
+}

book/examples/chapter4/Foods.gf

@@ -0,0 +1,6 @@
+abstract Foods = Comments ** {
+  fun
+    Wine, Cheese, Fish, Pizza : Kind ;
+    Fresh, Warm, Italian, 
+      Expensive, Delicious, Boring : Quality ;
+}

book/examples/chapter4/FoodsEng.gf

@@ -0,0 +1,16 @@
+--# -path=.:present
+
+concrete FoodsEng of Foods = CommentsEng ** 
+    open SyntaxEng, ParadigmsEng in {
+  lin
+    Wine = mkCN (mkN "wine") ;
+    Pizza = mkCN (mkN "pizza") ;
+    Cheese = mkCN (mkN "cheese") ;
+    Fish = mkCN (mkN "fish" "fish") ;
+    Fresh = mkAP (mkA "fresh") ;
+    Warm = mkAP (mkA "warm") ;
+    Italian = mkAP (mkA "Italian") ;
+    Expensive = mkAP (mkA "expensive") ;
+    Delicious = mkAP (mkA "delicious") ;
+    Boring = mkAP (mkA "boring") ;
+}

book/examples/chapter4/FoodsIta.gf

@@ -0,0 +1,16 @@
+--# -path=.:present
+
+concrete FoodsIta of Foods = CommentsIta ** 
+    open SyntaxIta, ParadigmsIta in {
+  lin
+    Wine = mkCN (mkN "vino") ;
+    Pizza = mkCN (mkN "pizza") ;
+    Cheese = mkCN (mkN "formaggio") ;
+    Fish = mkCN (mkN "pesce") ;
+    Fresh = mkAP (mkA "fresco") ;
+    Warm = mkAP (mkA "caldo") ;
+    Italian = mkAP (mkA "italiano") ;
+    Expensive = mkAP (mkA "caro") ;
+    Delicious = mkAP (mkA "delizioso") ;
+    Boring = mkAP (mkA "noioso") ;
+}

book/examples/chapter4/Shopping.gf

@@ -0,0 +1,2 @@
+abstract Shopping = Foods, Clothes ;
+

book/examples/chapter4/ShoppingEng.gf

@@ -0,0 +1,4 @@
+--# -path=.:present
+
+concrete ShoppingEng of Shopping = FoodsEng, ClothesEng ;
+

book/examples/chapter4/ShoppingIta.gf

@@ -0,0 +1,4 @@
+--# -path=.:present
+
+concrete ShoppingIta of Shopping = FoodsIta, ClothesIta ;
+

book/examples/chapter4/SmallShopping.gf

@@ -0,0 +1,3 @@
+abstract SmallShopping = 
+  Foods - [Wine], 
+  Clothes [Kind,Quality,Shirt,Elegant] ;

book/examples/chapter5/Foods.gf

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

book/examples/chapter5/FoodsCat.gf

@@ -0,0 +1,7 @@
+--# -path=.:present
+
+-- (c) 2009 Jordi Saludes under LGPL
+
+concrete FoodsCat of Foods = FoodsI with 
+  (Syntax = SyntaxCat),
+  (LexFoods = LexFoodsCat) ;

book/examples/chapter5/FoodsEng.gf

@@ -0,0 +1,28 @@
+--# -path=.:present
+
+concrete FoodsEng of Foods = 
+    open SyntaxEng,ParadigmsEng in {
+  lincat
+    Comment = Utt ; 
+    Item = NP ;
+    Kind = CN ;
+    Quality = AP ;
+  lin
+    Pred item quality = mkUtt (mkCl item quality) ;
+    This kind = mkNP this_Quant kind ;
+    That kind = mkNP that_Quant kind ;
+    These kind = mkNP this_Quant plNum kind ;
+    Those kind = mkNP that_Quant plNum kind ;
+    Mod quality kind = mkCN quality kind ;
+    Wine = mkCN (mkN "wine") ;
+    Pizza = mkCN (mkN "pizza") ;
+    Cheese = mkCN (mkN "cheese") ;
+    Fish = mkCN (mkN "fish" "fish") ;
+    Very quality = mkAP very_AdA quality ;
+    Fresh = mkAP (mkA "fresh") ;
+    Warm = mkAP (mkA "warm") ;
+    Italian = mkAP (mkA "Italian") ;
+    Expensive = mkAP (mkA "expensive") ;
+    Delicious = mkAP (mkA "delicious") ;
+    Boring = mkAP (mkA "boring") ;
+}

book/examples/chapter5/FoodsFin.gf

@@ -0,0 +1,7 @@
+--# -path=.:present
+
+-- (c) 2009 Aarne Ranta under LGPL
+
+concrete FoodsFin of Foods = FoodsI with 
+  (Syntax = SyntaxFin),
+  (LexFoods = LexFoodsFin) ;

book/examples/chapter5/FoodsGer.gf

@@ -0,0 +1,7 @@
+--# -path=.:present
+
+-- (c) 2009 Aarne Ranta under LGPL
+
+concrete FoodsGer of Foods = FoodsI with 
+  (Syntax = SyntaxGer),
+  (LexFoods = LexFoodsGer) ;

book/examples/chapter5/FoodsI.gf

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

book/examples/chapter5/FoodsIta.gf

@@ -0,0 +1,8 @@
+--# -path=.:present
+
+-- (c) 2009 Aarne Ranta under LGPL
+
+concrete FoodsIta of Foods = FoodsI with 
+  (Syntax = SyntaxIta),
+  (LexFoods = LexFoodsIta) ;
+

book/examples/chapter5/FoodsSwe.gf

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

book/examples/chapter5/LexFoods.gf

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

book/examples/chapter5/LexFoodsCat.gf

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

book/examples/chapter5/LexFoodsEng.gf

@@ -0,0 +1,20 @@
+instance LexFoodsEng of LexFoods = open SyntaxEng, ParadigmsEng, IrregEng in {
+  oper
+    wine_N = mkN "wine" ;
+    pizza_N = mkN "pizza" ;
+    cheese_N = mkN "cheese" ;
+    fish_N = mkN "fish" "fish" ;
+    fresh_A = mkA "fresh" ;
+    warm_A = mkA "warm" ;
+    italian_A = mkA "Italian" ;
+    expensive_A = mkA "expensive" ;
+    delicious_A = mkA "delicious" ;
+    boring_A = mkA "boring" ;
+
+    eat_V2 = mkV2 eat_V ;
+    drink_V2 = mkV2 drink_V ;
+    pay_V2 = mkV2 pay_V ;
+    lady_N = mkN "lady" ;
+    gentleman_N = mkN "gentleman" "gentlemen" ;
+
+}

book/examples/chapter5/LexFoodsFin.gf

@@ -0,0 +1,20 @@
+-- (c) 2009 Aarne Ranta under LGPL
+
+instance LexFoodsFin of LexFoods = 
+    open SyntaxFin, ParadigmsFin in {
+  oper
+    wine_N = mkN "viini" ;
+    pizza_N = mkN "pizza" ;
+    cheese_N = mkN "juusto" ;
+    fish_N = mkN "kala" ;
+    fresh_A = mkA "tuore" ;
+    warm_A = mkA 
+    (mkN "lämmin" "lämpimän" "lämmintä" "lämpimänä" "lämpimään" 
+         "lämpiminä" "lämpimiä" "lämpimien" "lämpimissä" "lämpimiin"
+	 ) 
+    "lämpimämpi" "lämpimin" ;
+    italian_A = mkA "italialainen" ;
+    expensive_A = mkA "kallis" ;
+    delicious_A = mkA "herkullinen" ;
+    boring_A = mkA "tylsä" ;
+}

book/examples/chapter5/LexFoodsGer.gf

@@ -0,0 +1,16 @@
+-- (c) 2009 Aarne Ranta under LGPL
+
+instance LexFoodsGer of LexFoods = 
+    open SyntaxGer, ParadigmsGer in {
+  oper
+    wine_N = mkN "Wein" ;
+    pizza_N = mkN "Pizza" "Pizzen" feminine ;
+    cheese_N = mkN "Käse" "Käse" masculine ;
+    fish_N = mkN "Fisch" ;
+    fresh_A = mkA "frisch" ;
+    warm_A = mkA "warm" "wärmer" "wärmste" ;
+    italian_A = mkA "italienisch" ;
+    expensive_A = mkA "teuer" ;
+    delicious_A = mkA "köstlich" ;
+    boring_A = mkA "langweilig" ;
+}

book/examples/chapter5/LexFoodsIta.gf

@@ -0,0 +1,16 @@
+-- (c) 2009 Aarne Ranta under LGPL
+
+instance LexFoodsIta of LexFoods = 
+    open SyntaxIta, ParadigmsIta in {
+  oper
+    wine_N = mkN "vino" ;
+    pizza_N = mkN "pizza" ;
+    cheese_N = mkN "formaggio" ;
+    fish_N = mkN "pesce" ;
+    fresh_A = mkA "fresco" ;
+    warm_A = mkA "caldo" ;
+    italian_A = mkA "italiano" ;
+    expensive_A = mkA "caro" ;
+    delicious_A = mkA "delizioso" ;
+    boring_A = mkA "noioso" ;
+}

book/examples/chapter5/LexFoodsSwe.gf

@@ -0,0 +1,16 @@
+-- (c) 2009 Aarne Ranta under LGPL
+
+instance LexFoodsSwe of LexFoods = 
+    open SyntaxSwe, ParadigmsSwe in {
+  oper
+    wine_N = mkN "vin" "vinet" "viner" "vinerna" ;
+    pizza_N = mkN "pizza" ;
+    cheese_N = mkN "ost" ;
+    fish_N = mkN "fisk" ;
+    fresh_A = mkA "färsk" ;
+    warm_A = mkA "varm" ;
+    italian_A = mkA "italiensk" ;
+    expensive_A = mkA "dyr" ;
+    delicious_A = mkA "läcker" ;
+    boring_A = mkA "tråkig" ;
+}

book/examples/chapter6/Aggregation.gf

@@ -0,0 +1,33 @@
+abstract Aggregation = {
+  cat S ; NP ; VP ;
+  data 
+    PredVP : NP -> VP -> S ;
+    ConjS  : S -> S -> S ;
+    ConjVP : VP -> VP -> VP ;
+    ConjNP : NP -> NP -> NP ;
+    Run, Walk : VP ;
+    John, Mary : NP ;
+
+  fun aggr : S -> S ; -- main aggregation function
+  def aggr (ConjS (PredVP x X) (PredVP y Y)) = 
+    ifS (eqNP x y) 
+      (PredVP x (ConjVP X Y)) 
+      (ifS (eqVP X Y) 
+         (PredVP (ConjNP x y) X)
+         (ConjS (PredVP x X) (PredVP y Y))) ;
+  fun ifS : Bool -> S -> S -> S ; -- if b then x else y 
+  def
+    ifS True  x _ = x ;
+    ifS False _ y = y ;
+  fun eqNP : NP -> NP -> Bool ;  -- x == y
+  def 
+    eqNP John John = True ;
+    eqNP Mary Mary = True ;
+    eqNP _ _ = False ;
+  fun eqVP : VP -> VP -> Bool ;  -- X == Y
+  def 
+    eqVP Run  Run  = True ;
+    eqVP Walk Walk = True ;
+    eqVP _ _ = False ;
+  cat Bool ; data True, False : Bool ;
+}

book/examples/chapter6/AggregationEng.gf

@@ -0,0 +1,17 @@
+concrete AggregationEng of Aggregation = {
+
+lincat S, NP, VP = Str ;
+
+lin 
+  PredVP x y = x ++ y ;
+  ConjS  a b = a ++ "or" ++ b ;
+  ConjVP a b = a ++ "or" ++ b ;
+  ConjNP a b = a ++ "or" ++ b ;
+
+  Run = "runs" ;
+  Walk = "walks" ;
+  John = "John" ;
+  Mary = "Mary" ;
+
+}
+

book/examples/chapter6/Arithm.gf

@@ -0,0 +1,30 @@
+abstract Arithm = {
+  cat
+    Prop ;                        -- proposition
+    Nat ;                         -- natural number
+  data
+    Zero : Nat ;                  -- 0
+    Succ : Nat -> Nat ;           -- the successor of x
+  fun
+    Even : Nat -> Prop ;          -- x is even
+    And  : Prop -> Prop -> Prop ; -- A and B
+
+  cat Less Nat Nat ; 
+  data LessZ : (y : Nat) -> Less Zero (Succ y) ;
+  data LessS : (x,y : Nat) -> Less x y -> Less (Succ x) (Succ y) ;
+
+  cat Span ;
+  data FromTo : (m,n : Nat) -> Less m n -> Span ;
+
+  fun one : Nat ;
+  def one = Succ Zero ;
+
+  fun twice : Nat -> Nat ;
+  def twice x = plus x x ;
+
+  fun plus : Nat -> Nat -> Nat ;
+  def 
+    plus x Zero = x ;
+    plus x (Succ y) = Succ (plus x y) ;
+
+} 

book/examples/chapter6/Bin.gf

@@ -0,0 +1,50 @@
+abstract Bin = {
+
+cat Nat ; Bin ; Pos ;
+
+data 
+  Zero : Nat ; 
+  Succ : Nat -> Nat ;
+
+  BZero : Bin ;         -- 0
+  BPos  : Pos -> Bin ;  -- p
+  BOne  : Pos ;         -- 1
+  AZero : Pos -> Pos ;  -- p0
+  AOne  : Pos -> Pos ;  -- p1
+
+fun
+  bin2nat : Bin -> Nat ;
+def
+  bin2nat BZero = Zero ;
+  bin2nat (BPos p) = pos2nat p ;
+fun 
+  pos2nat : Pos -> Nat ;
+def
+  pos2nat BOne = one ;
+  pos2nat (AZero p) = twice (pos2nat p) ;
+  pos2nat (AOne  p) = Succ (twice (pos2nat p)) ;
+fun one : Nat ;
+def one = Succ Zero ;
+fun twice : Nat -> Nat ;
+def 
+  twice Zero = Zero ;
+  twice (Succ n) = Succ (Succ (twice n)) ;
+
+fun
+  nat2bin : Nat -> Bin ;
+def
+  nat2bin Zero = BZero ;
+  nat2bin (Succ n) = bSucc (nat2bin n) ;
+fun
+  bSucc : Bin -> Bin ;
+def
+  bSucc BZero = BPos BOne ;
+  bSucc (BPos p) = BPos (pSucc p) ;
+fun
+  pSucc : Pos -> Pos ;
+def
+  pSucc BOne = AZero BOne ;
+  pSucc (AZero p) = AOne p ;
+  pSucc (AOne p) = AZero (pSucc p) ;
+
+}

book/examples/chapter6/Classes.gf

@@ -0,0 +1,28 @@
+abstract Classes = {
+
+flags 
+  startcat = Command ;
+
+cat
+  Command ;
+  Kind ;
+  Class ;
+  Instance Class Kind ;
+  Action Class ;
+  Device Kind ;
+
+fun
+  Act  : (c : Class) -> (k : Kind) -> Instance c k -> Action c -> Device k -> Command ;
+  The : (k : Kind) -> Device k ;
+
+  Light, Fan : Kind ;
+  Switchable, Dimmable : Class ;
+  
+  SwitchOn, SwitchOff : Action Switchable ;
+  Dim : Action Dimmable ;
+
+  switchable_Light : Instance Switchable Light ;
+  switchable_Fan : Instance Switchable Fan ;
+  dimmable_Light : Instance Dimmable Light ;
+
+}

book/examples/chapter6/ClassesEng.gf

@@ -0,0 +1,29 @@
+--# -path=.:present
+
+concrete ClassesEng of Classes = open SyntaxEng, ParadigmsEng in {
+
+lincat
+  Command = Utt ;
+  Kind = CN ;
+  Class = {} ;
+  Instance = {} ;
+  Action = V2 ;
+  Device = NP ;
+
+lin
+  Act _ _ _ a d = mkUtt (mkImp a d) ;
+  The k = mkNP the_Det k ;
+
+  Light = mkCN (mkN "light") ;
+  Fan = mkCN (mkN "fan") ;
+  Switchable, Dimmable = <> ;
+  
+  SwitchOn = mkV2 (partV (mkV "switch") "on") ;
+  SwitchOff = mkV2 (partV (mkV "switch") "off") ;
+  Dim = mkV2 (mkV "dim") ;
+
+  switchable_Light = <> ;
+  switchable_Fan = <> ;
+  dimmable_Light = <> ;
+
+}

book/examples/chapter6/DShopping.gf

@@ -0,0 +1,24 @@
+abstract DShopping = {
+  flags startcat = Comment ;
+  cat
+    Comment ; 
+    Dom ;
+    Item Dom ; 
+    Kind Dom ; 
+    Quality Dom ;
+  fun
+    DFood, DCloth : Dom ;
+
+    Pred : (d : Dom) -> Item d -> Quality d -> Comment ;
+    This, That : (d : Dom) -> Kind d -> Item d ;
+    Mod : (d : Dom) -> Quality d -> Kind d -> Kind d ;
+    Wine, Cheese, Fish : Kind DFood ;
+    Very : (d : Dom) -> Quality d -> Quality d ;
+    Fresh, Warm, Delicious, Boring : Quality DFood ;
+
+    Shirt, Jacket : Kind DCloth ;
+    Comfortable : Quality DCloth ;
+
+    Italian, Expensive, Elegant : (d : Dom) -> Quality d ;
+
+}

book/examples/chapter6/DShoppingEng.gf

@@ -0,0 +1,33 @@
+--# -path=.:present
+
+concrete DShoppingEng of DShopping = open SyntaxEng, ParadigmsEng in {
+
+  lincat
+    Comment = Cl ; 
+    Item = NP ;
+    Kind = CN ;
+    Quality = AP ;
+  lin
+    Pred _ item quality = mkCl item quality ;
+    This _ kind = mkNP this_QuantSg kind ;
+    That _ kind = mkNP that_QuantSg kind ;
+    Mod _ quality kind = mkCN quality kind ;
+    Very _ quality = mkAP very_AdA quality ;
+
+    Shirt = mkCN (mkN "shirt") ;
+    Jacket = mkCN (mkN "jacket") ;
+    Wine = mkCN (mkN "wine") ;
+    Cheese = mkCN (mkN "cheese") ;
+    Fish = mkCN (mkN "fish" "fish") ;
+    Fresh = mkAP (mkA "fresh") ;
+    Warm = mkAP (mkA "warm") ;
+    Italian _ = mkAP (mkA "Italian") ;
+    Expensive _ = mkAP (mkA "expensive") ;
+    Elegant _ = mkAP (mkA "elegant") ;
+    Delicious = mkAP (mkA "delicious") ;
+    Boring = mkAP (mkA "boring") ;
+    Comfortable = mkAP (mkA "comfortable") ;
+
+    DFood, DCloth = {s = []} ;
+
+}

book/examples/chapter6/Nat.gf

@@ -0,0 +1,22 @@
+abstract Nat = {
+  cat
+    Prop ;                        -- proposition
+    Nat ;                         -- natural number
+  data
+    Zero : Nat ;                  -- 0
+    Succ : Nat -> Nat ;           -- the successor of x
+  fun
+    Even : Nat -> Prop ;          -- x is even
+    And  : Prop -> Prop -> Prop ; -- A and B
+
+  fun one : Nat ;
+  def one = Succ Zero ;
+
+  fun twice : Nat -> Nat ;
+  def twice x = plus x x ;
+
+  fun plus : Nat -> Nat -> Nat ;
+  def 
+    plus x Zero = x ;
+    plus x (Succ y) = Succ (plus x y) ;
+}

book/examples/chapter6/Smart.gf

@@ -0,0 +1,16 @@
+abstract Smart = {
+
+  cat
+    Command ;
+    Kind ; 
+    Device Kind ; 
+    Action Kind ; 
+
+  fun 
+    Act : (k : Kind) -> Action k -> Device k -> Command ;
+    The : (k : Kind) -> Device k ;  -- the light
+    Light, Fan : Kind ;
+    Dim : Action Light ;
+    SwitchOn, SwitchOff : (k : Kind) -> Action k ;
+
+}

book/examples/chapter6/Verbs.gf

@@ -0,0 +1,22 @@
+abstract Verbs = {
+
+cat
+  S ; NP ; Subcat ; V Subcat ; Args Subcat ;
+
+fun
+  cIntr : Subcat ;
+  cTr   : Subcat ;
+  cS    : Subcat ;
+
+  aIntr : NP -> Args cIntr ;
+  aTr   : NP -> NP -> Args cTr ;
+  aS    : NP -> S  -> Args cS ;
+
+  pred  : (s : Subcat) -> V s -> Args s -> S ;
+
+  john, mary : NP ;
+  walk : V cIntr ;
+  love : V cTr ;
+  know : V cS ;
+
+}

book/examples/chapter6/VerbsEng.gf

@@ -0,0 +1,22 @@
+concrete VerbsEng of Verbs = {
+
+lincat
+  S, NP, Subcat, V = Str ; Args = Str * Str ;
+
+lin
+  cIntr = [] ;
+  cTr   = [] ;
+  cS    = [] ;
+
+  aIntr su    = <su,[]> ;
+  aTr   su ob = <su,ob> ;
+  aS    su s  = <su,"that" ++ s> ;
+
+  pred _ v xs = xs.p1 ++ v ++ xs.p2 ;
+
+  john = "John" ; mary = "Mary" ;
+  walk = "walks" ;
+  love = "loves" ;
+  know = "knows" ;
+
+}

book/examples/chapter7/Map.gf

@@ -0,0 +1,10 @@
+abstract Map = {
+flags startcat = Query ;
+cat
+  Query ; Input ; Place ; Click ;
+fun
+  GoFromTo   : Place -> Place -> Input ;
+  ThisPlace  : Click -> Place ;
+  QueryInput : Input -> Query ;
+  ClickCoord : Int -> Int -> Click ;
+}

book/examples/chapter7/MapEng.gf

@@ -0,0 +1,17 @@
+concrete MapEng of Map = {
+lincat
+  Query        = {s : Str} ;
+  Input, Place = {s : Str ; p : Str} ;
+  Click        = {p : Str} ;
+lin
+  GoFromTo x y = {
+    s = "I want to go from" ++ x.s ++ "to" ++ y.s ; 
+    p = x.p ++ y.p
+    } ;
+  ThisPlace c = {
+    s = "this place" ; 
+    p = c.p
+    } ;
+  QueryInput i = {s = i.s ++ ";" ++ i.p} ;
+  ClickCoord x y = {p = "(" ++ x.s ++ "," ++ y.s ++ ")"} ;
+}

book/examples/chapter7/Query.gf

@@ -0,0 +1,12 @@
+abstract Query = {
+  flags startcat=Question ;
+  cat 
+    Answer ; Question ; Object ;
+  fun 
+    Even   : Object -> Question ;
+    Odd    : Object -> Question ;
+    Prime  : Object -> Question ;
+    Number : Int -> Object ;
+    Yes    : Answer ;
+    No     : Answer ;
+}

book/examples/chapter7/QueryEng.gf

@@ -0,0 +1,13 @@
+concrete QueryEng of Query = {
+  lincat 
+    Answer, Question, Object = Str ;
+  lin 
+    Even  = pred "even" ;
+    Odd   = pred "odd" ;
+    Prime = pred "prime" ;
+    Number i = i.s ;
+    Yes = "yes" ;
+    No = "no" ;
+  oper
+    pred : Str -> Str -> Str = \f,x -> "is" ++ x ++ f ;
+}

book/examples/chapter7/QueryFin.gf

@@ -0,0 +1,13 @@
+concrete QueryFin of Query = {
+  lincat 
+    Answer, Question, Object = Str ;
+  lin 
+    Even  = pred "parillinen" ;
+    Odd   = pred "pariton" ;
+    Prime = pred "alkuluku" ;
+    Number i = i.s ;
+    Yes = "kyllä" ;
+    No = "ei" ;
+  oper
+    pred : Str -> Str -> Str = \f,x -> "onko" ++ x ++ f ;
+}

book/examples/chapter8/Calculator.gf

@@ -0,0 +1,7 @@
+abstract Calculator = {
+flags startcat = Exp ;
+cat Exp ;
+fun
+  EPlus, EMinus, ETimes, EDiv : Exp -> Exp -> Exp ;
+  EInt : Int -> Exp ;
+}

book/examples/chapter8/CalculatorC.gf

@@ -0,0 +1,10 @@
+concrete CalculatorC of Calculator = open Formal, Prelude in {
+lincat 
+  Exp = TermPrec ;
+lin
+  EPlus  = infixl 0 "+" ;
+  EMinus = infixl 0 "-" ;
+  ETimes = infixl 1 "*" ;
+  EDiv   = infixl 1 "/" ;
+  EInt i = constant i.s ;
+}

book/examples/chapter8/CalculatorJ.gf

@@ -0,0 +1,13 @@
+concrete CalculatorJ of Calculator = open Prelude in {
+lincat 
+  Exp = SS ;
+lin
+  EPlus  = postfix "iadd" ;
+  EMinus = postfix "isub" ;
+  ETimes = postfix "imul" ;
+  EDiv   = postfix "idiv" ;
+  EInt i = ss ("ldc" ++ i.s) ;
+oper
+  postfix : Str -> SS -> SS -> SS = \op,x,y -> 
+    ss (x.s ++ ";" ++ y.s ++ ";" ++ op) ;
+}

book/examples/chapter8/CalculatorP.gf

@@ -0,0 +1,14 @@
+concrete CalculatorP of Calculator = open Prelude in {
+
+lincat 
+  Exp = SS ;
+lin
+  EPlus  = infix "+" ;
+  EMinus = infix "-" ;
+  ETimes = infix "*" ;
+  EDiv   = infix "/" ;
+  EInt i = i ;
+oper
+  infix : Str -> SS -> SS -> SS = \f,x,y -> 
+    ss ("(" ++ x.s ++ f ++ y.s ++ ")") ;
+}

book/examples/chapter8/CalculatorS.gf

@@ -0,0 +1,11 @@
+concrete CalculatorS of Calculator = open Prelude in {
+  lin
+    EPlus  = infix "plus" ;
+    EMinus = infix "minus" ;
+    ETimes = infix "times" ;
+    EDiv   = infix ["divided by"] ;
+    EInt i = i ;
+  oper
+    infix : Str -> SS -> SS -> SS = \op,x,y -> 
+      ss (x.s ++ op ++ y.s ++ "PAUSE") ;
+}

book/examples/chapter8/Geometry.gf

@@ -0,0 +1,7 @@
+abstract Geometry = Logic ** {
+fun
+  Line, Point, Circle : Dom ;
+  Intersect, Parallel : Ind -> Ind -> Atom ;
+  Vertical : Ind -> Atom ;
+  Centre : Ind -> Ind ;
+}

book/examples/chapter8/GeometryEng.gf

@@ -0,0 +1,13 @@
+--# -path=.:present
+
+concrete GeometryEng of Geometry = LogicEng ** 
+  open SyntaxEng, ParadigmsEng in {
+lin
+  Line = mkCN (mkN "line") ;
+  Point = mkCN (mkN "point") ; 
+  Circle = mkCN (mkN "circle") ;
+  Intersect = pred (mkV2 "intersect") ;
+  Parallel = pred (mkA2 (mkA "parallel") (mkPrep "to")) ;
+  Vertical = pred (mkA "vertical") ;
+  Centre = app (mkN2 (mkN "centre") (mkPrep "of")) ;
+}

book/examples/chapter8/GeometryEngb.gf

@@ -0,0 +1,11 @@
+concrete GeometryEng of Geometry = LogicEng ** 
+  open SyntaxEng, ParadigmsEng in {
+lin
+  Line = mkN "line" ;
+  Point = mkN "point" ; 
+  Circle = mkN "circle" ;
+  Intersect = pred (mkV2 "intersect") ;
+  Parallel = pred (mkA2 (mkA "parallel") (mkPrep "to")) ;
+  Vertical = pred (mkA "vertical") ;
+  Centre = app (mkN2 (mkN "centre") (mkPrep "of")) ;
+}

book/examples/chapter8/Geometryb.gf

@@ -0,0 +1,7 @@
+abstract Geometry = Logic ** {
+fun
+  Line, Point, Circle : Dom ;
+  Intersect, Parallel : Ind -> Ind -> Prop ;
+  Vertical : Ind -> Prop ;
+  Centre : Ind -> Ind ;
+}

book/examples/chapter8/Graftal.gf

@@ -0,0 +1,7 @@
+-- (c) Krasimir Angelov 2009
+abstract Graftal = {
+  cat N; S;
+  fun z : N ;
+      s : N -> N ;
+      c : N -> S ;
+  }

book/examples/chapter8/Logic.gf

@@ -0,0 +1,21 @@
+abstract Logic = {
+flags startcat = Stm ;
+cat
+  Stm ;        -- top-level statement 
+  Prop ;       -- proposition 
+  Atom ;       -- atomic formula
+  Ind ;        -- individual term 
+  Dom ;        -- domain expression
+  Var ;        -- variable
+  [Prop] {2} ; -- list of propositions, 2 or more
+  [Var] {1} ;  -- list of variables, 1 or more
+fun
+  SProp : Prop -> Stm ;
+  And, Or : [Prop] -> Prop ;
+  If  : Prop -> Prop -> Prop ;
+  Not : Prop -> Prop ;
+  PAtom : Atom -> Prop ;
+  All, Exist : [Var] -> Dom -> Prop -> Prop ;
+  IVar : Var -> Ind ;
+  VString : String -> Var ;
+}

book/examples/chapter8/LogicBEng.gf

@@ -0,0 +1,38 @@
+concrete LogicEng of Logic = open 
+  SyntaxEng, (P = ParadigmsEng), SymbolicEng, Prelude in {
+lincat
+  Stm  = Text ;
+  Prop = S ;
+  Atom = Cl ; 
+  Ind  = NP ; 
+  Dom  = CN ; 
+  Var  = NP ; 
+  [Prop] = [S] ; 
+  [Var]  = NP ; 
+lin
+  SProp = mkText ;
+  And = mkS and_Conj ;      -- A, B ... and C
+  Or = mkS or_Conj ;        -- A, B ... or C
+  If A B =                  -- if A B
+    mkS (mkAdv if_Subj A) B ;  
+  Not A =                   -- it is not the case that A
+    mkS negativePol (mkCl 
+      (mkVP (mkNP the_Quant 
+         (mkCN case_CN A)))) ; 
+  All xs A B =              -- for all A's xs, B
+    mkS (mkAdv for_Prep 
+      (mkNP all_Predet (mkNP a_Quant 
+         plNum (mkCN A xs)))) B ;
+  Exist xs A B =            -- for some A's xs, B
+    mkS (mkAdv for_Prep 
+      (mkNP somePl_Det (mkCN A xs))) B ;
+  PAtom = mkS ;
+  IVar x = x ;
+  VString s = symb s ;
+  BaseProp A B = mkListS A B ; 
+  ConsProp A As = mkListS A As ;
+  BaseVar x = x ;
+  ConsVar x xs = mkNP and_Conj (mkListNP x xs) ;
+oper
+  case_CN : CN = mkCN (P.mkN "case") ;
+}

book/examples/chapter8/LogicEng.gf

@@ -0,0 +1,39 @@
+concrete LogicEng of Logic = open 
+  SyntaxEng, (P = ParadigmsEng), SymbolicEng, Prelude in {
+lincat
+  Stm  = Text ;
+  Prop = {pos,neg : S ; isAtom : Bool} ; 
+  Atom = Cl ; 
+  Ind  = NP ; 
+  Dom  = CN ; 
+  Var  = NP ; 
+  [Prop] = ListS ; 
+  [Var]  = NP ; 
+lin
+  SProp p = mkText p.pos ;
+  And ps = complexProp (mkS and_Conj ps) ;
+  Or ps = complexProp (mkS or_Conj ps) ;
+  If A B = complexProp (mkS if_then_Conj (mkListS A.pos B.pos)) ;
+  Not A = complexProp A.neg ;
+  All xs A B = complexProp (mkS (mkAdv for_Prep 
+    (mkNP all_Predet (mkNP a_Quant plNum (mkCN A xs)))) B.pos) ;
+  Exist xs A B = complexProp (mkS (mkAdv for_Prep 
+    (mkNP somePl_Det (mkCN A xs))) B.pos) ;
+  PAtom p = 
+    {pos = mkS p ; neg = mkS negativePol p ; isAtom = True} ;
+  IVar x = x ;
+  VString s = symb s ;
+  BaseProp A B = mkListS A.pos B.pos ; 
+  ConsProp A As = mkListS A.pos As ;
+  BaseVar x = x ;
+  ConsVar x xs = mkNP and_Conj (mkListNP x xs) ;
+oper 
+  complexProp : S -> {pos,neg : S ; isAtom : Bool} = \s -> {
+    pos = s ; 
+    neg = negS s ; 
+    isAtom = False 
+    } ;
+  negS : S -> S = \s -> mkS negativePol (mkCl (mkNP it_Pron) 
+      (mkNP the_Quant (mkCN (mkCN (P.mkN "case")) s))) ; 
+  if_Then_Conj : Conj = P.mkConj "if" "then" ;
+}

book/examples/chapter8/Logicb.gf

@@ -0,0 +1,11 @@
+abstract Logic = {
+cat
+  Prop ; Ind ; Dom ; Var ; [Prop] {2} ; [Var] {1} ;
+fun
+  And, Or : [Prop] -> Prop ;
+  If : Prop -> Prop -> Prop ;
+  Not : Prop -> Prop ;
+  All, Exist : [Var] -> Dom -> Prop -> Prop ;
+  IVar : Var -> Ind ;
+  VString : String -> Var ;
+}

book/examples/chapter8/Sierpinski.gf

@@ -0,0 +1,16 @@
+concrete Sierpinski of Graftal = {
+  lincat N = {a : Str; b : Str} ;
+  lincat S = {s : Str} ;
+
+  lin z = {a = A; b = B} ;
+  lin s x = {
+    a = x.b ++ R ++ x.a ++ R ++ x.b ; 
+    b = x.a ++ L ++ x.b ++ L ++ x.a
+    } ;
+  lin c x = {s = "newpath 300 550 moveto" ++ x.a ++ "stroke showpage"} ;
+
+  oper A : Str = "0 2 rlineto" ;
+  oper B : Str = "0 2 rlineto" ;
+  oper L : Str = "+60 rotate" ;
+  oper R : Str = "-60 rotate" ;
+}

book/examples/chapter9/Anaphora.gf

@@ -0,0 +1,17 @@
+abstract Anaphora = TestSemantics - [she_NP] ** {
+
+cat
+  Proof Prop ;
+
+fun
+  IfS : (A : S) -> (Proof (iS A) -> S) -> S ;
+
+  AnaNP : (A : CN) -> (a : Ind) -> Proof (iCN A a) -> NP ;
+
+  pe : (B : Ind -> Prop) -> Proof (Exist B) -> Ind ;
+  qe : (B : Ind -> Prop) -> (c : Proof (Exist B)) -> Proof (B (pe B c)) ;
+
+  pc : (A,B : Prop) -> Proof (And A B) -> Proof A ;
+  qc : (A,B : Prop) -> Proof (And A B) -> Proof B ;
+
+}

book/examples/chapter9/AnaphoraIta.gf

@@ -0,0 +1,17 @@
+concrete AnaphoraIta of Anaphora = TestSemanticsIta - [she_NP] ** 
+  open ResIta, Prelude, Formal in {
+
+lincat
+  Proof = {} ;
+
+lin
+  IfS A B = {s = "se" ++ A.s ++ B.s} ;
+
+  AnaNP cn _ _ = case cn.g of {
+    Masc => pronNP "lui" "lo" "gli" Masc  Sg Per3 ;
+    Fem  => pronNP "lei" "la" "le" Fem  Sg Per3
+    } ;
+
+  pe _ _ = constant [] ; ----
+
+}