remove the obsolete GF\Devel directory

src/GF/Devel/README-testgf3

@@ -1,49 +0,0 @@
-GF3, the next version of GF
-Aarne Ranta 
-
-
-Version 1: 20/2/2008
-
-To compile:
-
-  make testgf3
-
-To run:
-
-  testgf3 <options>
-
-Options:
-
-  -src      -- read from source
-  -doemit   -- emit gfn files
-
-More options (debugging flags):
-
-  -show_gf         -- show compiled source module after parsing
-  -show_extend     -- ... after extension
-  -show_rename     -- ... after renaming
-  -show_typecheck  -- ... after type checking
-  -show_refreshing -- ... after refreshing variables
-  -show_optimize   -- ... after partial evaluation
-  -show_factorize  -- ... after factoring optimization
-  -show_all        -- show all phases
-
-  -1  -- stop after parsing
-  -2  -- ... extending
-  -3  -- ... renaming
-  -4  -- ... type checking
-  -5  -- ... refreshing
-
-==Compiler Phases==
-
-LexGF
-ParGF
-SourceToGF
-Extend
-Rename
-CheckGrammar
-Refresh
-Optimize
-Factorize
-GFtoGFCC
-

src/GF/Devel/gf-code.txt

@@ -1,66 +0,0 @@
-Guide to GF Implementation Code
-Aarne Ranta
-
-
-
-This document describes the code in GF grammar compiler and interactive
-environment. It is aimed to cover well the implementation of the forthcoming
-GF3. In comparison to GF 2.8, this implementation uses
-- the same source language, GF (only slightly modified)
-- a different run-time target language, GFCC (instead of GFCM)
-- a different separate compilation target language (a fragment GF itself, 
-  instead of GFC)
-- a different internal representation of source code
-
-
-Apart from GFCC, the goal of GF3 is simplification and consolidation, rather
-than innovation. This is shown in particular in the abolition of GFC, and in
-the streamlined internal source code format. The insight needed to achieve
-these simplifications would not have been possible (at least for us) without
-years of experimenting with the more messy formats; those formats moreover
-grew organically when features were added to the GF language, and the old
-implementation was thus a result of evolution rather than careful planning.
-
-GF3 is planned to be released in an Alpha version in the end of 2007, its
-sources forming a part of GF release 2.9.
-
-There are currently two versions of GF3, as regards executables and ``make`` 
-items:
-- ``gf3``, using the old internal representation of source language, and
-  integrating a compiler from GF to GFCC and an interpreter of GFCC
-- ``testgf3``, using the new formats everywhere but implementing the compiler
-  only; this program does not yet yield reasonable output
-
-
-The descriptions below will target the newest ideas, that is, ``textgf3`` 
-whenever it differs from ``gf3``.
-
-
-==The structure of the code==
-
-Code that is not shared with GF 2.8 is located in subdirectories of 
-``GF/Devel/``. Those subdirectories will, however, be moved one level
-up. Currently they include
-- ``GF/Devel/Grammar``: the datatypes and basic operations of source code
-- ``GF/Devel/Compile``: the phases of compiling GF to GFCC
-
-
-The other directories involved are
-- ``GF/GFCC``: data types and functionalities of GFCC
-- ``GF/Infra``: infrastructure utilities for the implementation
-- ``GF/Data``: datastructures belonging to infrastructure
-
-
-==The source code implementation==
-
-==The compiler==
-
-==The GFCC interpreter==
-
-==The GF command interpreter==
-
-
-
-
-
-

src/GF/Devel/gf3.txt

@@ -1,84 +0,0 @@
-GF Version 3.0
-Aarne Ranta
-7 November 2007
-
-
-This document summarizes the goals and status of the forthcoming
-GF version 3.0.
-
-==Overview==
-
-GF 3 results from the following needs:
-- refactor GF to make it more maintainable
-- provide a simple command-line batch compiler
-- replace gfc by the much simpler gfcc format for embedded grammars
-
-
-The current implementation of GF 3 has three binaries:
-- gfc, batch compiler, for building grammar applications
-- gfi, interpreter for gfcc grammars, for using grammars
-- gf, interactive compiler with interpreter, for developing grammars
-
-
-Thus, roughly, gf = gfc + gfi.
-
-Question: should we have, like current GF, just one binary, gf, and
-implement the others by shell scripts calling gf with suitable options?
-- +: one binary is less code altogether
-- +: one binary is easier to distribute and update
-- -: each of the components is less code by itself
-- -: many users might only need either the compiler or the interpreter
-- -: those users could avoid installation problems such as readline
-
-
-There are some analogies in other languages:
-
-  || GF    | Haskell | Java   ||
-  |  gfc   | ghc     | javac   |
-  |  gfi   | ghci*   | java    |
-  |  gf    | ghci*   | -       |
-
-In Haskell, ghci makes more than gfi since it reads source files, but
-less than gf since it does not compile them to externally usable target
-code.
-
-
-
-
-==Status of code and functionalities==
-
-GF executable v. 2.8
-- gf: 263 modules, executable 7+ MB (on MacOS i386)
-
-
-Current status of GF 3.0 alpha:
-- gf3: 94 modules, executable 4+ MB
-- gfc: 71 modules, executable 3+ MB
-- gfi: 35 modules, executable 1+ MB
-
-
-Missing functionalities
-- in gfc:
-  - input formats: cf, ebnf, gfe, old gf
-  - output formats: speech grammars, bnfc
-  - integrating options for input, output, and debugging information
-    (as described in Devel/GFC/Options.hs)
-
-
-- in gfi:
-  - command cc (computing with resource)
-  - morphological analysis, linearization with tables
-  - quizzes, treebanks
-  - syntax editor
-  - readline
-
-
-==Additional feature options==
-
-Native Haskell readline
-
-Binary formats for gfo and gfcc
-
-Parallel compilation on multicore machines
-
-