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

Update top links and footer during hackathon

Browse Source
This commit is contained in:
John J. Camilleri
2018-11-28 15:42:11 +01:00
parent 6352799ccb
commit c7a14537c1
8 changed files with 77 additions and 710 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
bin/_template.html
View File

@@ -64,34 +64,47 @@ $body$
<i class="fas fa-home"></i>
Home
</a>
<h6 class="text-muted mt-3">Use</h6>
<h6 class="text-muted mt-3">Get started</h6>
<ul class="list-unstyled">
<li><a href="$rel-root$/demos">Demos</a></li>
<li><a href="https://www.youtube.com/watch?v=x1LFbDQhbso">Google Tech Talk</a></li>
<li><a href="http://cloud.grammaticalframework.org/">GF Cloud</a></li>
<li><a href="$rel-root$/doc/tutorial/gf-tutorial.html">Tutorial</a></li>
<li><a href="$rel-root$/download">Download GF</a></li>
</ul>
</div>
<div class="col-3">
<h6 class="text-muted">Documentation</h6>
<h6 class="text-muted">Learn more</h6>
<ul class="list-unstyled">
<li><a href="$rel-root$/doc/gf-shell-reference.html">GF Shell Reference</a></li>
<li><a href="$rel-root$/lib/doc/synopsis/index.html">RGL Library Synopsis</a></li>
<li><a href="$rel-root$/gf-book">The GF Book</a></li>
<li><a href="$rel-root$/doc/gf-refman.html">Reference Manual</a></li>
<li><a href="$rel-root$/doc/tutorial/gf-tutorial.html">Tutorial</a></li>
<li><a href="$rel-root$/doc/gf-shell-reference.html">GF Shell Reference</a></li>
<li><a href="http://www.molto-project.eu/sites/default/files/MOLTO_D2.3.pdf">Best Practices</a></li>
<li><a href="$rel-root$/lib/doc/synopsis/index.html">RGL Library Synopsis</a></li>
</ul>
</div>
<div class="col-3">
<h6 class="text-muted">Reference</h6>
<h6 class="text-muted">Develop</h6>
<ul class="list-unstyled">
<li><a href="$rel-root$/doc/gf-developers.html">Developers Guide</a></li>
<li><a href="http://hackage.haskell.org/package/gf/docs/PGF.html">PGF library API (Haskell runtime)</a></li>
<li><a href="$rel-root$/doc/runtime-api.html">PGF library API (C runtime)</a></li>
<li><a href="http://hackage.haskell.org/package/gf/docs/GF.html">GF compiler API</a></li>
<li><a href="$rel-root$/doc/gf-editor-modes.html">Text Editor Support</a></li>
</ul>
</div>
<div class="col-3">
<h6 class="text-muted">Contribute</i>
</h6>
<ul class="list-unstyled">
<li><a href="http://groups.google.com/group/gf-dev">Mailing List</a></li>
<li><a href="https://github.com/GrammaticalFramework/gf-core/issues">Issue Tracker</a></li>
<li><a href="$rel-root$/doc/gf-people.html">Authors</a></li>
<li><a href="http://school.grammaticalframework.org/2018/">Summer School</a></li>
</ul>
<h6 class="text-muted">
Repositories
<i class="fab fa-github"></i>
<i class="fab fa-github ml-1"></i>
</h6>
<ul class="list-unstyled">
<li><a href="https://github.com/GrammaticalFramework/gf-core">GF Core</a></li>

BIN
doc/gf-lrec-2010.pdf
View File

Binary file not shown.

7
doc/gf-people.md
View File

@@ -4,7 +4,7 @@ title: "Grammatical Framework: Authors and Acknowledgements"
## Current maintainers
The current developers and maintainers are
The current maintainers of GF are
[Krasimir Angelov](http://www.chalmers.se/cse/EN/organization/divisions/computing-science/people/angelov-krasimir),
[Thomas Hallgren](http://www.cse.chalmers.se/~hallgren/),
@@ -12,7 +12,8 @@ The current developers and maintainers are
[John J. Camilleri](http://johnjcamilleri.com), and
[Inari Listenmaa](https://inariksit.github.io/).
For detailed data about contributors to the code repositories, see
This page is otherwise not up to date.
For detailed data about contributors to the code repositories since 2007, see
[here (gf-core)](https://github.com/GrammaticalFramework/gf-core/graphs/contributors)
and
[here (gf-rgl)](https://github.com/GrammaticalFramework/gf-rgl/graphs/contributors).
@@ -43,7 +44,7 @@ reports, and other indirect contributions to the code.
- [Robin Cooper](http://www.cling.gu.se/~cooper) (Gothenburg)
- [Thierry Coquand](http://www.cse.chalmers.se/~coquand) (Chalmers)
- [Marc Dymetman](http://www.xrce.xerox.com/people/dymetman/dymetman.html) (XRCE)
- Bertrand Grégoire (Tudor Institure, Luxembourg)
- Bertrand Grégoire (Tudor Institute, Luxembourg)
- [Reiner Hähnle](http://www.cse.chalmers.se/~reiner) (Chalmers)
- [Gérard Huet](http://pauillac.inria.fr/~huet/) (INRIA)
- [Patrik Jansson](http://www.cse.chalmers.se/~patrikj) (Chalmers)

158
doc/gf-quickstart.html
View File

@@ -1,158 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<title>GF Quickstart</title>
<link rel=stylesheet href="../css/style.css">
<meta name = "viewport" content = "width = device-width">
</head>
<body>
<center>
<img src="Logos/gf0.png">
<p>
Aarne Ranta
<p>
October 2011 for GF 3.3
<p>
<h1>Grammatical Framework Quick Start</h1>
</center>
This Quick Start shows a few examples of how GF can be used.
We assume that you have downloaded and installed GF, so that
the command <tt>gf</tt> works for you. See download and install
instructions <a href="../download/index.html">here</a>.
<h2>Want to try without downloading?</h2>
<a href="../demos/phrasebook/">Using GF translation</a> with an existing grammar.
<p>
<a href="../demos/gfse/">Writing GF grammars</a> in the cloud, without installing GF.
<h2>Using GF for translation and generation</h2>
When you have downloaded and installed GF:
<ol>
<li> Copy the files
<a href="../examples/tutorial/food/Food.gf"><tt>Food.gf</tt></a>,
<a href="../examples/tutorial/food/FoodEng.gf"><tt>FoodEng.gf</tt></a>, and
<a href="../examples/tutorial/food/FoodIta.gf"><tt>FoodIta.gf</tt></a>.
Or go to <tt>GF/examples/tutorial/food/</tt>, if you have downloaded the
GF sources.
<li> Start GF with the shell command (without the prompt <tt>$</tt>)
<pre>
$ gf FoodIta.gf FoodEng.gf
</pre>
Alternatively, start GF with <tt>gf</tt> and give the GF command <tt>import FoodIta.gf FoodEng.gf</tt>.
<li> <b>Translation</b>. Try your first translation by giving the GF command
<pre>
parse "this cheese is very very Italian" | linearize
</pre>
Notice that the parser accept the tabulator for word completion.
<li> <b>Generation</b>. Random-generate sentences in two languages:
<pre>
generate_random | linearize
</pre>
<li> <b>Other commands</b>. Use the help command
<pre>
help
</pre>
<li> <b>More examples</b>. Go to <tt>GF/examples/phrasebook</tt> or some other
subdirectory of <tt>GF/examples/</tt>. Or try a resource grammar by, for instance,
<pre>
import alltenses/LangEng.gfo alltenses/LangGer.gfo
parse -lang=Eng "I love you" | linearize -treebank
</pre>
The resource grammars are found relative to the value of <tt>GF_LIB_PATH</tt>, which
you may have to set; see <a href="../download/index.html">here</a> for instructions.
</ol>
<h2>Grammar development</h2>
Add words to the <tt>Food</tt>
grammars and try the above commands again. For instance, add the following lines:
<pre>
Bread : Kind ; -- in Food.gf
Bread = {s = "bread"} ; -- in FoodEng.gf
Bread = {s = "pane"} ; -- in FoodIta.gf
</pre>
and start GF again with the same command. Now you can even translate
<i>this bread is very Italian</i>.
</ol>
To lear more on GF commands and
grammar development, go to the one of the tutorials:
<ul>
<li> <a href="tutorial/gf-tutorial.html">GF Tutorial</a>: older, more programmer-oriented
<li> <a href="gf-lrec-2010.pdf">GF Resource Tutorial</a>: newer, more linguist-oriented
</ul>
To learn about how GF is used for easily writing grammars for 16 languages, consult the
<ul>
<li> <a href="../lib/doc/synopsis.html">GF Resource Grammar Library</a>.
</ul>
<h2>Run-time grammars and web applications</h2>
GF has its own "machine language", PGF (Portable Grammar Format),
which is recommended for use in applications at run time. To produce a PGF file from
the two grammars above, do
<pre>
gf -make FoodIta.gf FoodEng.gf
wrote Food.pgf
</pre>
You can use this in Haskell and Java programs, and also on web services, such as
<ul>
<li> the
<a href="http://cloud.grammaticalframework.org/minibar/minibar.html">minibar</a>
fridge magnets
</ul>
The quickest way to provide a GF web service is to start GF with the <tt>-server</tt> option:
<pre>
$ gf -server
This is GF version 3.3
Built on linux/i386 with ghc-7.0, flags: interrupt server cclazy
Document root = /usr/local/share/gf-3.3/www
Starting HTTP server, open http://localhost:41296/ in your web browser.
</pre>
You can view it locally by pointing your
browser to the URL shown. You can add your own <tt>.pgf</tt> grammar to the service by
copying it over to the <tt>documentRoot</tt> directory. Just push "reload" in
your browser after each such update.
<p>
To build more customized web application, consult the
<a href="http://code.google.com/p/grammatical-framework/wiki/SideBar?tm=6">developer wiki</a>.
<h2>User group</h2>
You are welcome to join the <A HREF="http://groups.google.com/group/gf-dev">User Group</A>
to get help and discuss GF-related issues!
</body></html>

492
doc/gf-reference.t2t
View File

@@ -1,492 +0,0 @@
GF Quick Reference
Aarne Ranta
April 4, 2006
% NOTE: this is a txt2tags file.
% Create an html file from this file using:
% txt2tags -thtml gf-reference.t2t
%!style:../css/style.css
%!target:html
%!options: --toc
%!postproc(html): <TITLE> <meta name = "viewport" content = "width = device-width"><TITLE>
%!postproc(html): <H1> <H1><a href="../"><IMG src="../doc/Logos/gf0.png"></a>
This is a quick reference on GF grammars. It aims to
cover all forms of expression available when writing
grammars. It assumes basic knowledge of GF, which
can be acquired from the
[GF Tutorial http://www.grammaticalframework.org/doc/tutorial/gf-tutorial.html].
Help on GF commands is obtained on line by the
help command with ``help``, and help on invoking
GF with ``gf -help``.
===A complete example===
This is a complete example of a GF grammar divided
into three modules in files. The grammar recognizes the
phrases //one pizza// and //two pizzas//.
File ``Order.gf``:
```
abstract Order = {
cat
Order ;
Item ;
fun
One, Two : Item -> Order ;
Pizza : Item ;
}
```
File ``OrderEng.gf`` (the top file):
```
--# -path=.:prelude
concrete OrderEng of Order =
open Res, Prelude in {
flags startcat=Order ;
lincat
Order = SS ;
Item = {s : Num => Str} ;
lin
One it = ss ("one" ++ it.s ! Sg) ;
Two it = ss ("two" ++ it.s ! Pl) ;
Pizza = regNoun "pizza" ;
}
```
File ``Res.gf``:
```
resource Res = open Prelude in {
param Num = Sg | Pl ;
oper regNoun : Str -> {s : Num => Str} =
\dog -> {s = table {
Sg => dog ;
_ => dog + "s"
}
} ;
}
```
To use this example, do
```
% gf -- in shell: start GF
> i OrderEng.gf -- in GF: import grammar
> p "one pizza" -- parse string
> l Two Pizza -- linearize tree
```
===Modules and files===
One module per file.
File named ``Foo.gf`` contains module named
``Foo``.
Each module has the structure
```
moduletypename =
Inherits ** -- optional
open Opens in -- optional
{ Judgements }
```
Inherits are names of modules of the same type.
Inheritance can be restricted:
```
Mo[f,g], -- inherit only f,g from Mo
Lo-[f,g] -- inheris all but f,g from Lo
```
Opens are possible in ``concrete`` and ``resource``.
They are names of modules of these two types, possibly
qualified:
```
(M = Mo), -- refer to f as M.f or Mo.f
(Lo = Lo) -- refer to f as Lo.f
```
Module types and judgements in them:
```
abstract A -- cat, fun, def, data
concrete C of A -- lincat, lin, lindef, printname
resource R -- param, oper
interface I -- like resource, but can have
oper f : T without definition
instance J of I -- like resource, defines opers
that I leaves undefined
incomplete -- functor: concrete that opens
concrete CI of A = one or more interfaces
open I in ...
concrete CJ of A = -- completion: concrete that
CI with instantiates a functor by
(I = J) instances of open interfaces
```
The forms
``param``, ``oper``
may appear in ``concrete`` as well, but are then
not inherited to extensions.
All modules can moreover have ``flags`` and comments.
Comments have the forms
```
-- till the end of line
{- any number of lines between -}
--# used for compiler pragmas
```
A ``concrete`` can be opened like a ``resource``.
It is translated as follows:
```
cat C ---> oper C : Type =
lincat C = T T ** {lock_C : {}}
fun f : G -> C ---> oper f : A* -> C* = \g ->
lin f = t t g ** {lock_C = <>}
```
An ``abstract`` can be opened like an ``interface``.
Any ``concrete`` of it then works as an ``instance``.
===Judgements===
```
cat C -- declare category C
cat C (x:A)(y:B x) -- dependent category C
cat C A B -- same as C (x : A)(y : B)
fun f : T -- declare function f of type T
def f = t -- define f as t
def f p q = t -- define f by pattern matching
data C = f | g -- set f,g as constructors of C
data f : A -> C -- same as
fun f : A -> C; data C=f
lincat C = T -- define lin.type of cat C
lin f = t -- define lin. of fun f
lin f x y = t -- same as lin f = \x y -> t
lindef C = \s -> t -- default lin. of cat C
printname fun f = s -- printname shown in menus
printname cat C = s -- printname shown in menus
printname f = s -- same as printname fun f = s
param P = C | D Q R -- define parameter type P
with constructors
C : P, D : Q -> R -> P
oper h : T = t -- define oper h of type T
oper h = t -- omit type, if inferrable
flags p=v -- set value of flag p
```
Judgements are terminated by semicolons (``;``).
Subsequent judgments of the same form may share the
keyword:
```
cat C ; D ; -- same as cat C ; cat D ;
```
Judgements can also share RHS:
```
fun f,g : A -- same as fun f : A ; g : A
```
===Types===
Abstract syntax (in ``fun``):
```
C -- basic type, if cat C
C a b -- basic type for dep. category
(x : A) -> B -- dep. functions from A to B
(_ : A) -> B -- nondep. functions from A to B
(p,q : A) -> B -- same as (p : A)-> (q : A) -> B
A -> B -- same as (_ : A) -> B
Int -- predefined integer type
Float -- predefined float type
String -- predefined string type
```
Concrete syntax (in ``lincat``):
```
Str -- token lists
P -- parameter type, if param P
P => B -- table type, if P param. type
{s : Str ; p : P}-- record type
{s,t : Str} -- same as {s : Str ; t : Str}
{a : A} **{b : B}-- record type extension, same as
{a : A ; b : B}
A * B * C -- tuple type, same as
{p1 : A ; p2 : B ; p3 : C}
Ints n -- type of n first integers
```
Resource (in ``oper``): all those of concrete, plus
```
Tok -- tokens (subtype of Str)
A -> B -- functions from A to B
Int -- integers
Strs -- list of prefixes (for pre)
PType -- parameter type
Type -- any type
```
As parameter types, one can use any finite type:
``P`` defined in ``param P``,
``Ints n``, and record types of parameter types.
===Expressions===
Syntax trees = full function applications
```
f a b -- : C if fun f : A -> B -> C
1977 -- : Int
3.14 -- : Float
"foo" -- : String
```
Higher-Order Abstract syntax (HOAS): functions as arguments:
```
F a (\x -> c) -- : C if a : A, c : C (x : B),
fun F : A -> (B -> C) -> C
```
Tokens and token lists
```
"hello" -- : Tok, singleton Str
"hello" ++ "world" -- : Str
["hello world"] -- : Str, same as "hello" ++ "world"
"hello" + "world" -- : Tok, computes to "helloworld"
[] -- : Str, empty list
```
Parameters
```
Sg -- atomic constructor
VPres Sg P2 -- applied constructor
{n = Sg ; p = P3} -- record of parameters
```
Tables
```
table { -- by full branches
Sg => "mouse" ;
Pl => "mice"
}
table { -- by pattern matching
Pl => "mice" ;
_ => "mouse" -- wildcard pattern
}
table {
n => regn n "cat" -- variable pattern
}
table Num {...} -- table given with arg. type
table ["ox"; "oxen"] -- table as course of values
\\_ => "fish" -- same as table {_ => "fish"}
\\p,q => t -- same as \\p => \\q => t
t ! p -- select p from table t
case e of {...} -- same as table {...} ! e
```
Records
```
{s = "Liz"; g = Fem} -- record in full form
{s,t = "et"} -- same as {s = "et";t= "et"}
{s = "Liz"} ** -- record extension: same as
{g = Fem} {s = "Liz" ; g = Fem}
<a,b,c> -- tuple, same as {p1=a;p2=b;p3=c}
```
Functions
```
\x -> t -- lambda abstract
\x,y -> t -- same as \x -> \y -> t
\x,_ -> t -- binding not in t
```
Local definitions
```
let x : A = d in t -- let definition
let x = d in t -- let defin, type inferred
let x=d ; y=e in t -- same as
let x=d in let y=e in t
let {...} in t -- same as let ... in t
t where {...} -- same as let ... in t
```
Free variation
```
variants {x ; y} -- both x and y possible
variants {} -- nothing possible
```
Prefix-dependent choices
```
pre {"a" ; "an" / v} -- "an" before v, "a" otherw.
strs {"a" ; "i" ;"o"}-- list of condition prefixes
```
Typed expression
```
<t:T> -- same as t, to help type inference
```
Accessing bound variables in ``lin``: use fields ``$1, $2, $3,...``.
Example:
```
fun F : (A : Set) -> (El A -> Prop) -> Prop ;
lin F A B = {s = ["for all"] ++ A.s ++ B.$1 ++ B.s}
```
===Pattern matching===
These patterns can be used in branches of ``table`` and
``case`` expressions. Patterns are matched in the order in
which they appear in the grammar.
```
C -- atomic param constructor
C p q -- param constr. applied to patterns
x -- variable, matches anything
_ -- wildcard, matches anything
"foo" -- string
56 -- integer
{s = p ; y = q} -- record, matches extensions too
<p,q> -- tuple, same as {p1=p ; p2=q}
p | q -- disjunction, binds to first match
x@p -- binds x to what p matches
- p -- negation
p + "s" -- sequence of two string patterns
p* -- repetition of a string pattern
```
===Sample library functions===
```
-- lib/prelude/Predef.gf
drop : Int -> Tok -> Tok -- drop prefix of length
take : Int -> Tok -> Tok -- take prefix of length
tk : Int -> Tok -> Tok -- drop suffix of length
dp : Int -> Tok -> Tok -- take suffix of length
occur : Tok -> Tok -> PBool -- test if substring
occurs : Tok -> Tok -> PBool -- test if any char occurs
show : (P:Type) -> P ->Tok -- param to string
read : (P:Type) -> Tok-> P -- string to param
toStr : (L:Type) -> L ->Str -- find "first" string
-- lib/prelude/Prelude.gf
param Bool = True | False
oper
SS : Type -- the type {s : Str}
ss : Str -> SS -- construct SS
cc2 : (_,_ : SS) -> SS -- concat SS's
optStr : Str -> Str -- string or empty
strOpt : Str -> Str -- empty or string
bothWays : Str -> Str -> Str -- X++Y or Y++X
init : Tok -> Tok -- all but last char
last : Tok -> Tok -- last char
prefixSS : Str -> SS -> SS
postfixSS : Str -> SS -> SS
infixSS : Str -> SS -> SS -> SS
if_then_else : (A : Type) -> Bool -> A -> A -> A
if_then_Str : Bool -> Str -> Str -> Str
```
===Flags===
Flags can appear, with growing priority,
- in files, judgement ``flags`` and without dash (``-``)
- as flags to ``gf`` when invoked, with dash
- as flags to various GF commands, with dash
Some common flags used in grammars:
```
startcat=cat use this category as default
lexer=literals int and string literals recognized
lexer=code like program code
lexer=text like text: spacing, capitals
lexer=textlit text, unknowns as string lits
unlexer=code like program code
unlexer=codelit code, remove string lit quotes
unlexer=text like text: punctuation, capitals
unlexer=textlit text, remove string lit quotes
unlexer=concat remove all spaces
unlexer=bind remove spaces around "&+"
optimize=all_subs best for almost any concrete
optimize=values good for lexicon concrete
optimize=all usually good for resource
optimize=noexpand for resource, if =all too big
```
For the full set of values for ``FLAG``,
use on-line ``h -FLAG``.
===File import search paths===
Colon-separated list of directories searched in the
given order:
```
--# -path=.:../abstract:../common:prelude
```
This can be (in order of increasing priority), as
first line in the file, as flag to ``gf``
when invoked, or as flag to the ``i`` command.
The prefix ``--#`` is used only in files.
GF attempts to satisfy an ``import`` command by searching for the
import filename in the above search paths, initially qualified
relative to the current working directory. If the file is not found in
that initial expansion, the search paths are re-qualified relative to
the directories given in the ``GF_LIB_PATH`` environment variable. If
``GF_LIB_PATH`` is not defined, its default value is
``/usr/local/share/gf-3.9/lib`` (assuming you have GF version 3.9).
If your GF resource grammar libraries are installed somewhere else,
you will want to set ``GF_LIB_PATH`` to point there instead. In a
pinch, you can point to the ``GF/lib/src/`` folder in your clone of
the GF source code repository.
Developers of resource grammars may find it useful to define multiple
directories, colon-separated, in ``GF_LIB_PATH``.
===Alternative grammar formats===
**Old GF** (before GF 2.0):
all judgements in any kinds of modules,
division into files uses ``include``s.
A file ``Foo.gf`` is recognized as the old format
if it lacks a module header.
**Context-free** (file ``foo.cf``). The form of rules is e.g.
```
Fun. S ::= NP "is" AP ;
```
If ``Fun`` is omitted, it is generated automatically.
Rules must be one per line. The RHS can be empty.
**Extended BNF** (file ``foo.ebnf``). The form of rules is e.g.
```
S ::= (NP+ ("is" | "was") AP | V NP*) ;
```
where the RHS is a regular expression of categories
and quoted tokens: ``"foo", CAT, T U, T|U, T*, T+, T?``, or empty.
Rule labels are generated automatically.
**Probabilistic grammars** (not a separate format).
You can set the probability of a function ``f`` (in its value category) by
```
--# prob f 0.009
```
These are put into a file given to GF using the ``probs=File`` flag
on command line. This file can be the grammar file itself.
**Example-based grammars** (file ``foo.gfe``). Expressions of the form
```
in Cat "example string"
```
are preprocessed by using a parser given by the flag
```
--# -resource=File
```
and the result is written to ``foo.gf``.
===References===
[GF Homepage http://www.grammaticalframework.org/]
A. Ranta, Grammatical Framework: A Type-Theoretical Grammar Formalism.
//The Journal of Functional Programming//, vol. 14:2. 2004, pp. 145-189.

20
download/index.md
View File

@@ -2,23 +2,23 @@
title: Grammatical Framework Download and Installation
...
**GF 4.0.0** was released on 28 November 2018.
**GF 3.10** was released on 28 November 2018.
It is the first version of GF which _does not include the RGL_.
What's new? See the [release notes](release-4.0.0.html).
What's new? See the [release notes](release-3.10.html).
## Binary packages
All binary releases are now hosted on [GitHub](https://github.com/GrammaticalFramework/gf-core/releases).
| Platform | Download | Features | How to install |
|:----------------|:---------------------------------------------------------------|:-----------|:------------------------------------------------------------|
| macOS | [gf-4.0.0.pkg](gf-4.0.0.pkg) | GF,S,C,J,P | Double-click on the package icon |
| macOS | [gf-4.0.0-bin-intel-mac.tar.gz](gf-4.0.0-bin-intel-mac.tar.gz) | GF,S,C,J,P | `sudo tar -C /usr/local -zxf gf-4.0.0-bin-intel-mac.tar.gz` |
| Raspian 9.1 | [gf\_4.0.0-1\_armhf.deb](gf_4.0.0-1_armhf.deb) | GF,S,C,J,P | `sudo dpkg -i gf_4.0.0-1_armhf.deb` |
| Ubuntu (32-bit) | [gf\_4.0.0-1\_i386.deb](gf_4.0.0-1_i386.deb) | GF,S,C,J,P | `sudo dpkg -i gf_4.0.0-1_i386.deb` |
| Ubuntu (64-bit) | [gf\_4.0.0-1\_amd64.deb](gf_4.0.0-1_amd64.deb) | GF,S,C,J,P | `sudo dpkg -i gf_4.0.0-1_amd64.deb` |
| Windows | [gf-4.0.0-bin-windows.zip](gf-4.0.0-bin-windows.zip) | GF,S | `unzip gf-4.0.0-bin-windows.zip` |
| Platform | Download | Features | How to install |
|:----------------|:-------------------------------------------------------------|:-----------|:-----------------------------------------------------------|
| macOS | [gf-3.10.pkg](gf-3.10.pkg) | GF,S,C,J,P | Double-click on the package icon |
| macOS | [gf-3.10-bin-intel-mac.tar.gz](gf-3.10-bin-intel-mac.tar.gz) | GF,S,C,J,P | `sudo tar -C /usr/local -zxf gf-3.10-bin-intel-mac.tar.gz` |
| Raspian 9.1 | [gf\_3.10-1\_armhf.deb](gf_3.10-1_armhf.deb) | GF,S,C,J,P | `sudo dpkg -i gf_3.10-1_armhf.deb` |
| Ubuntu (32-bit) | [gf\_3.10-1\_i386.deb](gf_3.10-1_i386.deb) | GF,S,C,J,P | `sudo dpkg -i gf_3.10-1_i386.deb` |
| Ubuntu (64-bit) | [gf\_3.10-1\_amd64.deb](gf_3.10-1_amd64.deb) | GF,S,C,J,P | `sudo dpkg -i gf_3.10-1_amd64.deb` |
| Windows | [gf-3.10-bin-windows.zip](gf-3.10-bin-windows.zip) | GF,S | `unzip gf-3.10-bin-windows.zip` |
**Features**

0
download/release-4.0.0.md → download/release-3.10.md
View File

81
index.html
View File

@@ -24,55 +24,43 @@
<div class="row">
<div class="col-sm-6 col-md-3 offset-md-1">
<h3>Use</h3>
<a href="download/index.html" class="btn btn-primary mb-2">
<div class="col-sm-6 col-md-3">
<h3>Get started</h3>
<ul>
<li><a href="https://www.youtube.com/watch?v=x1LFbDQhbso">Google Tech Talk</a></li>
<li>
<a href="http://cloud.grammaticalframework.org/">
GF Cloud
<img src="http://www.grammaticalframework.org/src/www/P/gf-cloud.png" style="height:30px" class="ml-2">
</a>
</li>
<li><a href="doc/tutorial/gf-tutorial.html">Tutorial</a></li>
</ul>
<a href="download/index.html" class="btn btn-primary mb-3">
<i class="fas fa-download mr-1"></i>
Download GF
</a>
<ul>
<li><a href="http://cloud.grammaticalframework.org/">GF Cloud</a></li>
<!-- <li><a href="demos/index.html">Other Demos</a></li> -->
</ul>
<h4>Community</h4>
<ul>
<li><a href="http://groups.google.com/group/gf-dev">Mailing List</a></li>
<li><a href="https://github.com/GrammaticalFramework/gf-core/issues">Issue Tracker</a></li>
<li><a href="doc/gf-people.html">Authors</a></li>
<li><a href="http://school.grammaticalframework.org/2018/">Summer School</a></li>
</ul>
</div>
<div class="col-sm-6 col-md-4">
<h3>Learn</h3>
<div class="col-sm-6 col-md-3">
<h3>Learn more</h3>
<ul>
<li><a href="gf-book">The GF Book</a></li>
<li><a href="doc/gf-refman.html">Reference Manual</a></li>
<li><a href="doc/gf-shell-reference.html">Shell Reference</a></li>
<li><a href="http://www.molto-project.eu/sites/default/files/MOLTO_D2.3.pdf">Best Practices</a> <small>[PDF]</small></li>
</ul>
<a href="lib/doc/synopsis/index.html" class="btn btn-primary mb-2">
<i class="fab fa-readme mr-1"></i>
RGL Library Synopsis
</a>
<ul>
<li><a href="doc/tutorial/gf-tutorial.html">Tutorial</a></li>
<li><a href="gf-book">The GF Book</a></li>
<li><a href="doc/gf-refman.html">Reference Manual</a></li>
<li><a href="doc/gf-shell-reference.html">Shell Reference</a></li>
<li><a href="doc/gf-quickstart.html">Quick Start</a></li>
<li><a href="doc/gf-reference.html">Quick Reference</a></li>
</ul>
<h4>Other resources</h4>
<ul>
<li><a href="https://www.youtube.com/watch?v=x1LFbDQhbso">Google Tech Talk</a></li>
<li><a href="http://www.molto-project.eu/sites/default/files/MOLTO_D2.3.pdf">Best Practices</a> <small>[PDF]</small></li>
<li><a href="doc/gf-lrec-2010.pdf">Library Tutorial</a> <small>[PDF]</small></li>
</ul>
</div>
<div class="col-sm-6 col-md-4">
<div class="col-sm-6 col-md-3">
<h3>Develop</h3>
<a href="https://github.com/GrammaticalFramework/" class="btn btn-primary mb-2">
<i class="fab fa-github mr-1"></i>
GF on GitHub
</a>
<ul>
<li><a href="doc/gf-developers.html">Developers Guide</a></li>
<!-- <li><a href="/~hallgren/gf-experiment/browse/">Browse Source Code</a></li> -->
@@ -84,6 +72,21 @@
<li><a href="doc/gf-editor-modes.html">Text Editor Support</a></li>
</ul>
</div>
<div class="col-sm-6 col-md-3">
<h3>Contribute</h3>
<ul>
<li><a href="http://groups.google.com/group/gf-dev">Mailing List</a></li>
<li><a href="https://github.com/GrammaticalFramework/gf-core/issues">Issue Tracker</a></li>
<li><a href="doc/gf-people.html">Authors</a></li>
<li><a href="http://school.grammaticalframework.org/2018/">Summer School</a></li>
</ul>
<a href="https://github.com/GrammaticalFramework/" class="btn btn-primary mb-2">
<i class="fab fa-github mr-1"></i>
GF on GitHub
</a>
</div>
</div>
<!-- <div class=links>
@@ -231,8 +234,8 @@ least one, it may help you to get a first idea of what GF is.
</dd>
<dt class="col-sm-3 text-center">2018-11-28</dt>
<dd class="col-sm-9">
<strong>GF 4.0.0 released.</strong>
<a href="download/release-4.0.0.html">Release notes</a>
<strong>GF 3.10 released.</strong>
<a href="download/release-3.10.html">Release notes</a>
</dd>
<dt class="col-sm-3 text-center">2018-07-25</dt>
<dd class="col-sm-9">