GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-04-09 04:59:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

remove the obsolete GF\Devel directory

Browse Source
This commit is contained in:
krasimir
2009-01-22 15:28:10 +00:00
parent 7f388d4f19
commit b0b0911a20
3 changed files with 0 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/GF/Devel/README-testgf3
View File

@@ -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

66
src/GF/Devel/gf-code.txt
View File

@@ -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==

84
src/GF/Devel/gf3.txt
View File

@@ -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