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 contribs and examples

Browse Source 
Everything has now been moved to a separate repository at
https://github.com/GrammaticalFramework/gf-contrib
The contents of the examples folder are build during SetupWeb
This commit is contained in:
john.j.camilleri
2013-09-16 07:17:27 +00:00
parent 8e1c6cca40
commit f5461eb3d4
816 changed files with 14 additions and 410648 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
WebSetup.hs
View File

@@ -16,14 +16,21 @@ import Distribution.Simple.LocalBuildInfo(datadir,buildDir,absoluteInstallDirs)
-}
example_grammars = -- :: [(pgf, tmp, src)]
[("Foods.pgf","foods",foodsSrc),
("Letter.pgf","letter",letterSrc)]
[("Foods.pgf","foods",foodsSrc)
,("Phrasebook.pgf","phrasebook",phrasebookSrc)
,("Letter.pgf","letter",letterSrc)
]
where
foodsDir ="contrib"</>"summerschool"</>"foods"
foodsDir ="examples"</>"foods"
--foodsSrc = foodsDir</>"Foods???.gf" -- doesn't work on Win32
foodsSrc = unwords [foodsDir</>"Foods"++lang++".gf"|lang<-foodsLangs]
foodsLangs = words "Afr Amh Bul Cat Cze Dut Eng Epo Fin Fre Ger Gle Heb Hin Ice Ita Jpn Lav Mlt Mon Nep Pes Por Ron Spa Swe Tha Tsn Tur Urd"
phrasebookDir ="examples"</>"phrasebook"
--phrasebookSrc = phrasebookDir</>"Phrasebook???.gf" -- doesn't work on Win32
phrasebookSrc = unwords [phrasebookDir</>"Phrasebook"++lang++".gf"|lang<-phrasebookLangs]
phrasebookLangs = words "Bul Cat Dan Dut Eng Hin Lav Nor Spa Swe Tha" -- only fastish languages
letterDir = "examples"</>"letter"
--letterSrc = letterDir</>"Letter???.gf"
letterSrc = unwords [letterDir</>"Letter"++lang++".gf"|lang<-letterLangs]

232
contrib/c-bindings/PGFFFI.hs
View File

@@ -1,232 +0,0 @@
-- GF C Bindings
-- Copyright (C) 2008-2010 Kevin Kofler
--
-- This library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public
-- License as published by the Free Software Foundation; either
-- version 2.1 of the License, or (at your option) any later version.
--
-- This library 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
-- Lesser General Public License for more details.
--
-- You should have received a copy of the GNU Lesser General Public
-- License along with this library; if not, see <http://www.gnu.org/licenses/>.
module PGFFFI where
import PGF
import CString
import Foreign
import Foreign.C.Types
import Control.Exception
import IO
import Data.Maybe
-- import GF.Text.Lexing
-- Utility functions used in the implementation (not exported):
-- This is a kind of a hack, the FFI spec doesn't guarantee that this will work.
-- The alternative would be to use Ptr () instead of StablePtr a everywhere.
nullStablePtr :: StablePtr a
nullStablePtr = (castPtrToStablePtr nullPtr)
sizeOfStablePtr :: Int
sizeOfStablePtr = (sizeOf (nullStablePtr))
storeList :: [a] -> Ptr (StablePtr a) -> IO ()
storeList list buf = do
case list of
carlist:cdrlist -> do
sptr <- (newStablePtr carlist)
(poke buf sptr)
(storeList cdrlist (plusPtr buf sizeOfStablePtr))
[] -> (poke buf nullStablePtr)
listToArray :: [a] -> IO (Ptr (StablePtr a))
listToArray list = do
buf <- (mallocBytes ((sizeOfStablePtr) * ((length list) + 1)))
(storeList list buf)
return buf
-- * PGF
foreign export ccall "gf_freePGF" freeStablePtr :: StablePtr PGF -> IO ()
foreign export ccall gf_readPGF :: CString -> IO (StablePtr PGF)
gf_readPGF path = do
p <- (peekCString path)
result <- (readPGF p)
(newStablePtr result)
-- * Identifiers
foreign export ccall "gf_freeCId" freeStablePtr :: StablePtr CId -> IO ()
foreign export ccall gf_mkCId :: CString -> IO (StablePtr CId)
gf_mkCId str = do
s <- (peekCString str)
(newStablePtr (mkCId s))
foreign export ccall gf_wildCId :: IO (StablePtr CId)
gf_wildCId = do
(newStablePtr (wildCId))
foreign export ccall gf_showCId :: StablePtr CId -> IO CString
gf_showCId cid = do
c <- (deRefStablePtr cid)
(newCString (showCId c))
foreign export ccall gf_readCId :: CString -> IO (StablePtr CId)
gf_readCId str = do
s <- (peekCString str)
case (readCId s) of
Just x -> (newStablePtr x)
Nothing -> (return (nullStablePtr))
-- TODO: So we can create, print and free a CId, but can we do anything useful with it?
-- We need some kind of C wrapper for the tree datastructures.
-- * Languages
foreign export ccall "gf_freeLanguage" freeStablePtr :: StablePtr Language -> IO ()
foreign export ccall gf_showLanguage :: StablePtr Language -> IO CString
gf_showLanguage lang = do
l <- (deRefStablePtr lang)
(newCString (showLanguage l))
foreign export ccall gf_readLanguage :: CString -> IO (StablePtr Language)
gf_readLanguage str = do
s <- (peekCString str)
case (readLanguage s) of
Just x -> (newStablePtr x)
Nothing -> (return (nullStablePtr))
foreign export ccall gf_languages :: StablePtr PGF -> IO (Ptr (StablePtr Language))
gf_languages pgf = do
p <- (deRefStablePtr pgf)
(listToArray (languages p))
foreign export ccall gf_abstractName :: StablePtr PGF -> IO (StablePtr Language)
gf_abstractName pgf = do
p <- (deRefStablePtr pgf)
(newStablePtr (abstractName p))
foreign export ccall gf_languageCode :: StablePtr PGF -> StablePtr Language -> IO CString
gf_languageCode pgf lang = do
p <- (deRefStablePtr pgf)
l <- (deRefStablePtr lang)
case (languageCode p l) of
Just s -> (newCString s)
Nothing -> (return nullPtr)
-- * Types
foreign export ccall "gf_freeType" freeStablePtr :: StablePtr Type -> IO ()
-- TODO: Hypo
-- TODO: allow nonempty scope
foreign export ccall gf_showType :: StablePtr Type -> IO CString
gf_showType tp = do
t <- (deRefStablePtr tp)
(newCString (showType [] t))
foreign export ccall gf_readType :: CString -> IO (StablePtr Type)
gf_readType str = do
s <- (peekCString str)
case (readType s) of
Just x -> (newStablePtr x)
Nothing -> (return (nullStablePtr))
-- TODO: mkType, mkHypo, mkDepHypo, mkImplHypo
foreign export ccall gf_categories :: StablePtr PGF -> IO (Ptr (StablePtr CId))
gf_categories pgf = do
p <- (deRefStablePtr pgf)
(listToArray (categories p))
foreign export ccall gf_startCat :: StablePtr PGF -> IO (StablePtr Type)
gf_startCat pgf = do
p <- (deRefStablePtr pgf)
(newStablePtr (startCat p))
-- TODO: * Functions
-- * Expressions & Trees
-- ** Tree
foreign export ccall "gf_freeTree" freeStablePtr :: StablePtr Tree -> IO ()
-- ** Expr
foreign export ccall "gf_freeExpr" freeStablePtr :: StablePtr Expr -> IO ()
-- TODO: allow nonempty scope
foreign export ccall gf_showExpr :: StablePtr Expr -> IO CString
gf_showExpr expr = do
e <- (deRefStablePtr expr)
(newCString (showExpr [] e))
foreign export ccall gf_readExpr :: CString -> IO (StablePtr Expr)
gf_readExpr str = do
s <- (peekCString str)
case (readExpr s) of
Just x -> (newStablePtr x)
Nothing -> (return (nullStablePtr))
-- * Operations
-- ** Linearization
foreign export ccall gf_linearize :: StablePtr PGF -> StablePtr Language -> StablePtr Tree -> IO CString
gf_linearize pgf lang tree = do
p <- (deRefStablePtr pgf)
l <- (deRefStablePtr lang)
t <- (deRefStablePtr tree)
(newCString (linearize p l t))
-- TODO: linearizeAllLang, linearizeAll, bracketedLinearize, tabularLinearizes
-- TODO: groupResults
foreign export ccall gf_showPrintName :: StablePtr PGF -> StablePtr Language -> StablePtr CId -> IO CString
gf_showPrintName pgf lang cid = do
p <- (deRefStablePtr pgf)
l <- (deRefStablePtr lang)
c <- (deRefStablePtr cid)
(newCString (showPrintName p l c))
-- TODO: BracketedString(..), FId, LIndex, Forest.showBracketedString
-- ** Parsing
foreign export ccall gf_parse :: StablePtr PGF -> StablePtr Language -> StablePtr Type -> CString -> IO (Ptr (StablePtr Tree))
gf_parse pgf lang cat input = do
p <- (deRefStablePtr pgf)
l <- (deRefStablePtr lang)
c <- (deRefStablePtr cat)
i <- (peekCString input)
(listToArray (parse p l c i))
-- TODO: parseAllLang, parseAll, parse_, parseWithRecovery
-- TODO: ** Evaluation
-- TODO: ** Type Checking
-- TODO: ** Low level parsing API
-- TODO: ** Generation
-- TODO: ** Morphological Analysis
-- TODO: ** Visualizations
-- TODO: * Browsing
-- GF.Text.Lexing:
-- foreign export ccall gf_stringOp :: CString -> CString -> IO CString
-- gf_stringOp op str = do
-- o <- (peekCString op)
-- s <- (peekCString str)
-- case (stringOp o) of
-- Just fn -> (newCString (fn s))
-- Nothing -> (return nullPtr)
-- Unused (exception handling):
-- (Control.Exception.catch (listToArray (parse p l c i)) (\(e::SomeException) -> do
-- (hPutStr stderr ("error: " ++ show e))
-- (return nullPtr)))

22
contrib/c-bindings/build-gfctest.sh
View File

@@ -1,22 +0,0 @@
#!/bin/sh
# GF C Bindings
# Copyright (C) 2008-2010 Kevin Kofler
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, see <http://www.gnu.org/licenses/>.
src=../../src
import=-i$src/runtime/haskell:$src/compiler
gf --make ../../examples/tutorial/embedded/QueryEng.gf &&
ghc $import --make -fglasgow-exts -O2 -no-hs-main $* -c PGFFFI.hs &&
ghc $import --make -fglasgow-exts -O2 -no-hs-main $* gfctest.c gf_lexing.c PGFFFI.hs -o gfctest

287
contrib/c-bindings/gf_lexing.c
View File

@@ -1,287 +0,0 @@
/* GF C Bindings
Copyright (C) 2010 Kevin Kofler
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "gf_lexing.h"
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
typedef char **(*GF_Lexer)(const char *str);
typedef char *(*GF_Unlexer)(char **arr);
static inline void freev(char **p)
{
char **q = p;
while (*q)
free(*(q++));
free(p);
}
static char **words(const char *str)
{
unsigned char *buf = (unsigned char *) strdup(str);
unsigned char *p = buf, *q;
char **result, **r;
size_t count = 0u;
while (isspace(*p)) p++;
q = p;
if (*p) count++;
while (*p) {
if (isspace(*p)) {
*(p++) = 0;
while (isspace(*p)) *(p++) = 0;
if (*p) count++;
} else p++;
}
r = result = malloc((count+1)*sizeof(char *));
if (count) while (1) {
*(r++) = strdup((char *) q);
if (!--count) break;
while (*q) q++;
while (!*q) q++;
}
*r = NULL;
return result;
}
static char *unwords(char **arr)
{
size_t len = 0u;
char **p = arr, *result, *r;
while (*p)
len += strlen(*(p++)) + 1u;
if (!len) return calloc(1, 1);
r = result = malloc(len);
p = arr;
while (1) {
size_t l = strlen(*p);
strcpy(r, *(p++));
if (!*p) break;
r += l;
*(r++) = ' ';
}
return result;
}
static char **lines(const char *str)
{
unsigned char *buf = (unsigned char *) strdup(str);
unsigned char *p = buf, *q;
char **result, **r;
size_t count = 0u;
while (*p == '\n') p++;
q = p;
if (*p) count++;
while (*p) {
if (*p == '\n') {
*(p++) = 0;
while (*p == '\n') *(p++) = 0;
if (*p) count++;
} else p++;
}
r = result = malloc((count+1)*sizeof(char *));
if (count) while (1) {
*(r++) = strdup((char *) q);
if (!--count) break;
while (*q) q++;
while (!*q) q++;
}
*r = NULL;
return result;
}
static char *unlines(char **arr)
{
size_t len = 0u;
char **p = arr, *result, *r;
while (*p)
len += strlen(*(p++)) + 1u;
if (!len) return calloc(1, 1);
r = result = malloc(len);
p = arr;
while (1) {
size_t l = strlen(*p);
strcpy(r, *(p++));
if (!*p) break;
r += l;
*(r++) = '\n';
}
return result;
}
static char *appLexer(GF_Lexer f, const char *str)
{
char **arr = f(str), **p = arr, *result;
int ofs = 0;
while (*p && **p) p++;
while (*p) {
if (**p) p[-ofs] = *p; else ofs++;
p++;
}
p[-ofs] = NULL;
result = unwords(arr);
freev(arr);
return result;
}
static char *appUnlexer(GF_Unlexer f, const char *str)
{
char **arr = lines(str), **p = arr, *result;
while (*p) {
char **warr = words(*p);
free(*p);
*(p++) = f(warr);
freev(warr);
}
result = unlines(arr);
freev(arr);
return result;
}
static inline int isPunct(char c)
{
return c && strchr(".?!,:;", c);
}
static inline int isMajorPunct(char c)
{
return c && strchr(".?!", c);
}
static inline int isMinorPunct(char c)
{
return c && strchr(",:;", c);
}
static char *charToStr(char c)
{
char *result = malloc(2), *p = result;
*(p++) = c;
*p = 0;
return result;
}
static char **lexChars(const char *str)
{
char **result = malloc((strlen(str)+1)*sizeof(char *)), **r = result;
const char *p = str;
while (*p) {
if (!isspace(*p)) *(r++) = charToStr(*p);
p++;
}
*r = NULL;
return result;
}
static char **lexText(const char *str)
{
char **result = malloc((strlen(str)+1)*sizeof(char *)), **r = result;
const char *p = str;
int uncap = 1;
while (*p) {
if (isMajorPunct(*p)) {
*(r++) = charToStr(*(p++));
uncap = 1;
} else if (isMinorPunct(*p)) {
*(r++) = charToStr(*(p++));
uncap = 0;
} else if (isspace(*p)) {
p++;
uncap = 0;
} else {
const char *q = p;
char *word;
size_t l;
while (*p && !isspace(*p) && !isPunct(*p)) p++;
l = p - q;
word = malloc(l + 1);
strncpy(word, q, l);
word[l] = 0;
if (uncap) *word = tolower(*word);
*(r++) = word;
uncap = 0;
}
}
*r = NULL;
return result;
}
static char *unlexText(char **arr)
{
size_t len = 0u;
char **p = arr, *result, *r;
int cap = 1;
while (*p)
len += strlen(*(p++)) + 1u;
if (!len) return calloc(1, 1);
r = result = malloc(len);
p = arr;
while (1) {
size_t l = strlen(*p);
char *word = *(p++);
if (*word == '"' && word[l-1] == '"') word++, l--;
strncpy(r, word, l);
if (cap) *r = toupper(*r);
if (!*p) break;
r += l;
if (isPunct(**p) && !(*p)[1]) {
*(r++) = **p;
if (!p[1]) break;
cap = isMajorPunct(**(p++));
} else cap = 0;
*(r++) = ' ';
}
*r = 0;
return result;
}
static char *stringop_chars(const char *str)
{
return appLexer(lexChars, str);
}
static char *stringop_lextext(const char *str)
{
return appLexer(lexText, str);
}
static char *stringop_words(const char *str)
{
return appLexer(words, str);
}
static char *stringop_unlextext(const char *str)
{
return appUnlexer(unlexText, str);
}
static char *stringop_unwords(const char *str)
{
return appUnlexer(unwords, str);
}
GF_StringOp gf_stringOp(const char *op)
{
if (!strcmp(op, "chars")) return stringop_chars;
if (!strcmp(op, "lextext")) return stringop_lextext;
if (!strcmp(op, "words")) return stringop_words;
if (!strcmp(op, "unlextext")) return stringop_unlextext;
if (!strcmp(op, "unwords")) return stringop_unwords;
return NULL;
}

26
contrib/c-bindings/gf_lexing.h
View File

@@ -1,26 +0,0 @@
/* GF C Bindings
Copyright (C) 2010 Kevin Kofler
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
/* Function pointer type which applies a string operation to str, which is
assumed to be non-NULL.
The resulting string can be assumed to be non-NULL and must be freed using
free. */
typedef char *(*GF_StringOp)(const char *str);
/* Returns a GF_StringOp applying the operation op if available, otherwise
NULL. op is assumed to be non-NULL. The GF_StringOp MUST NOT be freed. */
GF_StringOp gf_stringOp(const char *op);

50
contrib/c-bindings/gfctest.c
View File

@@ -1,50 +0,0 @@
/* GF C Bindings
Copyright (C) 2008-2009 Kevin Kofler
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include "pgf.h"
#include "gf_lexing.h"
int main(int argc, char *argv[])
{
gf_init(&argc, &argv);
GF_PGF pgf = gf_readPGF("Query.pgf");
GF_Language lang = gf_readLanguage("QueryEng");
GF_Type cat = gf_startCat(pgf);
char *lexed = gf_stringOp("lextext")("Is 2 prime");
// char *lexed = "is 23 odd";
GF_Tree *result = gf_parse(pgf, lang, cat, lexed);
free(lexed);
GF_Tree *p = result;
if (*p) {
do {
char *str = gf_showExpr(*(p++));
puts(str);
free(str);
} while (*p);
} else
puts("no match");
gf_freeTrees(result);
gf_freeType(cat);
gf_freeLanguage(lang);
gf_freePGF(pgf);
gf_exit();
return 0;
}

674
contrib/c-bindings/gpl-3.0.txt
View File

@@ -1,674 +0,0 @@
GNU 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.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. 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
them 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 prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. 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.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey 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;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If 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 convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU 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 that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
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.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
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.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
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
state 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 3 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, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program 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, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU 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 Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

504
contrib/c-bindings/lgpl-2.1.txt
View File

@@ -1,504 +0,0 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
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 and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, 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 library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete 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 distribute a copy of this License along with the
Library.
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 Library or any portion
of it, thus forming a work based on the Library, 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) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
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 Library, 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 Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you 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.
If distribution of 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 satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be 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.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. 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 not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library 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.
9. 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 Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
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 with
this License.
11. 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 Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library 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 Library.
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.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library 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.
13. The Free Software Foundation may publish revised and/or new
versions of the 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
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 Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
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
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "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
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. 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 LIBRARY 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
LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), 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 Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. 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 library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

165
contrib/c-bindings/lgpl-3.0.txt
View File

@@ -1,165 +0,0 @@
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.

68
contrib/c-bindings/pgf.h
View File

@@ -1,68 +0,0 @@
/* GF C Bindings
Copyright (C) 2008-2009 Kevin Kofler
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "HsFFI.h"
#ifdef __GLASGOW_HASKELL__
#include "PGFFFI_stub.h"
extern void __stginit_PGFFFI ( void );
#endif
static inline void gf_init(int *argc, char ***argv)
{
hs_init(argc, argv);
#ifdef __GLASGOW_HASKELL__
hs_add_root(__stginit_PGFFFI);
#endif
}
static inline void gf_exit(void)
{
hs_exit();
}
typedef HsStablePtr GF_PGF;
typedef HsStablePtr GF_CId;
typedef HsStablePtr GF_Language;
typedef HsStablePtr GF_Type;
typedef HsStablePtr GF_Tree;
typedef HsStablePtr GF_Expr;
static inline void gf_freeCIds(GF_CId *p)
{
GF_CId *q = p;
while (*q)
gf_freeCId(*(q++));
free(p);
}
static inline void gf_freeLanguages(GF_Language *p)
{
GF_Language *q = p;
while (*q)
gf_freeLanguage(*(q++));
free(p);
}
static inline void gf_freeTrees(GF_Tree *p)
{
GF_Type *q = p;
while (*q)
gf_freeTree(*(q++));
free(p);
}

120
contrib/c-bindings/readme-ffi.txt
View File

@@ -1,120 +0,0 @@
GF C Bindings
Copyright (C) 2008-2010 Kevin Kofler
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see <http://www.gnu.org/licenses/>.
This library provides access to the GF embedded grammars (PGF) API to C/C++
applications. To use it:
1. #include "pgf.h"
2. call gf_init(&argc, &argv); at the beginning of main()
3. call gf_exit(); before exiting the program
4. build with: ghc --make -fglasgow-exts -O2 -no-hs-main $* x.c PGFFFI.hs -o x
Currently, the following functions from PGF are wrapped:
readPGF :: FilePath -> IO PGF
mkCId :: String -> CId
wildCId :: CId
showCId :: CId -> String
readCId :: String -> Maybe CId
showLanguage :: Language -> String
readLanguage :: String -> Maybe Language
languages :: PGF -> [Language]
abstractName :: PGF -> Language
languageCode :: PGF -> Language -> Maybe String
showType :: Type -> [CId] -> String (*)
readType :: String -> Maybe Type
categories :: PGF -> [CId]
startCat :: PGF -> Type
showExpr :: Expr -> [CId] -> String (*)
readExpr :: String -> Maybe Expr
linearize :: PGF -> Language -> Tree -> String
showPrintName :: PGF -> Language -> CId -> String
parse :: PGF -> Language -> Type -> String -> [Tree]
(*) The [CId] parameter is currently not mapped; instead, [] is always passed.
Some notes about the wrapping:
* "gf_" is prepended to the wrapped functions as a form of namespacing.
* Object types T are mapped to opaque C types GF_T which are handles to the
object. Whenever returned by a function, they get marked as used (so the
Haskell garbage collection won't delete them), so when you are done using
them, you should free them (assuming they're non-NULL) with the corresponding
gf_freeT function (i.e. one of: gf_freePGF, gf_freeLanguage, gf_freeType,
gf_freeCId, gf_freeTree, gf_freeExpr). (Internally, they are all Haskell
StablePtr handles, but this is subject to change.)
* Strings are mapped to char *. Strings returned by functions, when not NULL,
are allocated with malloc and should thus be freed with free when no longer
needed.
* A FilePath is a string.
* A type Maybe T is mapped the same way as just T, except that the returned
handle or char * can be NULL, so you should test them with a test like if (p).
Otherwise functions can be expected to always return non-NULL
handles/pointers. Conversely, arguments to functions are always assumed to be
non-NULL.
* Lists [T] are mapped to null-terminated arrays GF_T[], passed/returned as
pointers GF_T *. All objects in the array should be freed with the correct
gf_freeT function when no longer needed, the array itself with free. For your
convenience, the C header defines inline functions gf_freeLanguages,
gf_freeTypes and gf_freeTrees which free an entire array.
* Bool is wrapped to int using the usual C convention of 1 = True, 0 = False.
* A constant like wildCId is mapped to a function with no arguments, e.g.
GF_CId wildCId(void). The returned handle has to be freed as for any other
function.
Thus, the C prototypes for the wrapped functions are:
GF_PGF *gf_readPGF(char *path);
GF_CId gf_mkCId(char *str);
GF_CId wildCId(void);
char *gf_showCId(GF_CID cid);
GF_CId gf_readCId(char *str); /* may return NULL */
char *gf_showLanguage(GF_Language lang);
GF_Language gf_readLanguage(char *str); /* may return NULL */
GF_Language *gf_languages(GF_PGF pgf);
GF_Language gf_abstractName(GF_PGF pgf);
char *gf_languageCode(GF_PGF pgf, GF_Language lang); /* may return NULL */
char *gf_showType(GF_Type tp);
GF_Type gf_readType(char *str); /* may return NULL */
GF_CId *gf_categories(GF_PGF pgf);
GF_Type gf_startCat(GF_PGF pgf);
char *gf_showExpr(GF_Expr expr);
GF_Expr gf_readExpr(char *str); /* may return NULL */
char *gf_linearize(GF_PGF pgf, GF_Language lang, GF_Tree tree);
char *gf_showPrintName(GF_PGF pgf, GF_Language lang, GF_CId cid);
GF_Tree *gf_parse(GF_PGF pgf, GF_Language lang, GF_Type cat, char *input);
The C prototypes for the freeing functions are:
void gf_freePGF(GF_PGF pgf);
void gf_freeCId(GF_CId cid);
void gf_freeLanguage(GF_Language lang);
void gf_freeType(GF_Type tp);
void gf_freeTree(GF_Tree tree);
void gf_freeExpr(GF_Expr expr);
void gf_freeCIds(GF_Type *p);
void gf_freeLanguages(GF_Language *p);
void gf_freeTrees(GF_Tree *p);
In addition, a C equivalent to the following function from GF.Text.Lexing:
stringOp :: String -> Maybe (String -> String)
is provided as:
typedef char *(*GF_StringOp)(const char *str);
GF_StringOp gf_stringOp(const char *op); /* may return NULL */
which returns NULL if op is not a valid operation name, otherwise a pointer to a
function which applies the function corresponding to op to the string str. The
resulting string must be freed with free. The function pointer MUST NOT be
freed.

28
contrib/eaglesconv/CollectLemmas.hs
View File

@@ -1,28 +0,0 @@
-- Copyright (C) 2011 Nikita Frolov
import qualified Data.Text as T
import qualified Data.Text.IO as UTF8
import System.IO
import System.Environment
import Control.Monad
import Control.Monad.State
main :: IO ()
main = do
args <- getArgs
forM_ args $ \ f -> do
entries <- UTF8.readFile f >>= (return . T.lines)
forM_ entries $ \ entry ->
do
let ws = T.words entry
form = head ws
tags = toPairs $ tail ws
forM_ tags $ \ (lemma, tag) ->
do
UTF8.putStrLn $ T.concat [lemma, sp, form, sp, tag]
where sp = T.singleton ' '
toPairs xs = zip (stride 2 xs) (stride 2 (drop 1 xs))
where stride _ [] = []
stride n (x:xs) = x : stride n (drop (n-1) xs)

135
contrib/eaglesconv/EaglesConv.hs
View File

@@ -1,135 +0,0 @@
-- Copyright (C) 2011 Nikita Frolov
-- No, we can't pipeline parsing and generation, because there is no guarantee
-- that we have collected all forms for a lemma before we've scanned the
-- complete file.
import qualified Data.Text as T
import qualified Data.Text.IO as UTF8
import System.IO
import System.Environment
import Control.Monad
import Control.Monad.State
import qualified Data.Map as M
import Codec.Text.IConv
import qualified Data.ByteString.Lazy as BS
import qualified Data.ByteString.Internal as BSI
import EaglesMatcher
type Lemmas = M.Map T.Text Forms
main :: IO ()
main = do
args <- getArgs
forM_ args $ \ f -> do
entries <- UTF8.readFile f >>= (return . T.lines)
lemmas <- return $ execState (collectLemmas entries) (M.empty :: Lemmas)
mapM_ generateLin (M.assocs lemmas)
collectLemmas entries = do
forM_ entries $ \ entry -> do
let ws = T.words entry
lemma = head ws
tags = toPairs $ tail ws
lemmas <- get
forM_ tags $ \ (form, tag) -> do
let forms = (case M.lookup lemma lemmas of
Just f -> f
Nothing -> M.empty) :: Forms
if isOpenCat . T.unpack $ tag
then put $ M.insert lemma (M.insert tag form forms) lemmas
else return ()
generateLin :: (T.Text, Forms) -> IO ()
generateLin (lemma, forms) = do
let lemma' = myVeryOwnCyrillicRomanizationIConvSucks lemma
UTF8.putStr $ T.concat [T.pack "lin ", lemma']
UTF8.putStr $ case T.unpack . head . M.keys $ forms of
('N':_:_:_:g:a:'0':_) ->
T.concat $ [T.pack "_N = mkN "]
++ map (quote . noun forms) [ ('N','S'), ('G','S')
, ('D','S'), ('F','S'), ('C','S'), ('O','S')
, ('L','S'), ('N','P'), ('G','P'), ('D','P')
, ('F','P'), ('C','P'), ('O','P') ]
++ [showG g, sp, showAni a, ln]
('N':_:c:n:g:a:_) ->
T.concat $ [T.pack "_PN = mkPN "
, quote $ noun forms ('N', 'S')
, showG g, sp
, showN n, sp, showAni a, ln]
('A':_) ->
T.concat $ [T.pack "_A = mkA ", quote $ adj forms 'P',
if adj forms 'P' /= adj forms 'C'
then quote $ adj forms 'C'
else T.pack ""
, ln]
('V':t) ->
let a = case t of
(_:_:_:_:'P':_:a':_) -> a'
(_:_:_:_:_:a':_) -> a'
in
T.concat $ [T.pack "_V = mkV ", showAsp a, sp]
++ map (quote . verbPres forms) [ ('S','1'), ('S','2')
, ('S','3'), ('P','1')
, ('P','2'), ('P','3')]
++ [ quote $ verbPast forms ('S', 'M')
, quote $ verbImp forms, quote $ verbInf forms, ln]
('D':_) ->
T.concat $ [T.pack "_Adv = mkAdv "
, quote . adv $ forms, ln]
putStrLn ""
hFlush stdout
where quote x = T.concat [T.pack "\"", x, T.pack "\" "]
showG 'F' = T.pack "Fem"
showG 'A' = T.pack "Neut"
showG _ = T.pack "Masc"
showAni 'I' = T.pack "Inanimate"
showAni _ = T.pack "Animate"
showN 'P' = T.pack "Pl"
showN _ = T.pack "Sg"
showAsp 'F' = T.pack "Perfective"
showAsp _ = T.pack "Imperfective"
sp = T.singleton ' '
ln = T.pack " ;"
toPairs xs = zip (stride 2 xs) (stride 2 (drop 1 xs))
where stride _ [] = []
stride n (x:xs) = x : stride n (drop (n-1) xs)
myVeryOwnCyrillicRomanizationIConvSucks s = T.pack . concatMap r . T.unpack $ s
where r 'а' = "a"
r 'б' = "b"
r 'в' = "v"
r 'г' = "g"
r 'д' = "d"
r 'е' = "je"
r 'ё' = "jo"
r 'ж' = "zh"
r 'з' = "z"
r 'и' = "i"
r 'й' = "jj"
r 'к' = "k"
r 'л' = "l"
r 'м' = "m"
r 'н' = "n"
r 'о' = "o"
r 'п' = "p"
r 'р' = "r"
r 'с' = "s"
r 'т' = "t"
r 'у' = "u"
r 'ф' = "f"
r 'х' = "kh"
r 'ц' = "c"
r 'ч' = "ch"
r 'ш' = "sh"
r 'щ' = "shc"
r 'ъ' = "yy"
r 'ы' = "y"
r 'ь' = "q"
r 'э' = "e"
r 'ю' = "ju"
r 'я' = "ja"
r '-' = "_"
r o = [o]

63
contrib/eaglesconv/EaglesMatcher.hs
View File

@@ -1,63 +0,0 @@
-- Copyright (C) 2011 Nikita Frolov
-- The format specification can be found at
-- http://devel.cpl.upc.edu/freeling/svn/trunk/doc/tagsets/tagset-ru.html
-- Bugs in the specification:
-- Participle, 2nd field: case, not mood
-- Participle, 6th field: field, not person
-- Verb, persons can be denoted both with 'Pnumber' or just 'number'
-- Noun, 10th field can be absent
-- No, it wouldn't be simpler to implement this grammar with Parsec or another
-- parser combinator library.
module EaglesMatcher where
import qualified Data.Text as T
import Data.List
import qualified Data.Map as M
type Forms = M.Map T.Text T.Text
isOpenCat ('A':_) = True
isOpenCat ('N':_) = True
isOpenCat ('V':_) = True
isOpenCat ('D':_) = True
isOpenCat _ = False
noun forms (c, n) = findForm (matchNoun . T.unpack) forms
where matchNoun ('N':_:c':n':_) = c == c' && n == n'
matchNoun _ = False
adj forms d = findForm (matchAdj . T.unpack) forms
where matchAdj ('A':'N':'S':'M':_:'F':d':_) = d == d
matchAdj _ = False
verbPres forms (n, p) = findForm (matchPres . T.unpack) forms
where matchPres ('V':'D':n':_:'P':'P':p':_:'A':_) = n == n' && p == p'
matchPres ('V':'D':n':_:'F':'P':p':_:'A':_) = n == n' && p == p'
matchPres ('V':'D':n':_:'P':'P':p':_) = n == n' && p == p'
matchPres ('V':'D':n':_:'F':'P':p':_) = n == n' && p == p'
matchPres _ = False
verbPast forms (n, g) = findForm (matchPast . T.unpack) forms
where matchPast ('V':'D':n':g':'S':_:_:'A':_) = n == n' && g == g'
matchPast _ = False
verbImp forms = findForm (matchImp . T.unpack) forms
where matchImp ('V':'M':_) = True
matchImp _ = False
verbInf forms = findForm (matchInf . T.unpack) forms
where matchInf ('V':'I':_) = True
matchInf _ = False
adv forms = findForm (matchAdv . T.unpack) forms
where matchAdv ('D':d:_) = d == 'P'
matchAdv _ = False
findForm match forms = case find match (M.keys forms) of
Just tag -> forms M.! tag
Nothing -> findForm (\ _ -> True) forms

239
contrib/eaglesconv/EaglesParser.hs
View File

@@ -1,239 +0,0 @@
-- Copyright (C) 2011 Nikita Frolov
-- An early version of the parser that requires somewhat more memory. Kept for
-- nostalgic reasons.
module EaglesParser where
import qualified Data.Text as T
import Data.List
import qualified Data.Map as M
type Forms = M.Map Tag T.Text
data Tag = A Case Number Gender Animacy Form Degree Extra Obscene
| Adv Degree Extra Obscene
| AdvPron Extra
| Ord Case Number Gender Animacy
| AdjPron Case Number Gender Animacy Extra
| Frag Extra
| Conj Extra
| Inter Extra Obscene
| Num Case Number Gender Animacy Extra
| Part Extra
| Prep Extra
| N Case Number Gender Animacy Name Extra Obscene
| Pron Case Number Gender Animacy Extra
| V Mood Number Gender Tense Person Aspect Voice Trans Extra Obscene
| P Case Number Gender Tense Form Aspect Voice Trans Extra Obscene
deriving (Show, Ord, Eq)
parseTag :: T.Text -> Tag
parseTag tag = case (T.unpack tag) of {
('A':c:n:g:a:f:cmp:e:o:[]) -> A (readCase c) (readNumber n)
(readGender g) (readAnimacy a)
(readForm f) (readDegree cmp)
(readExtra e) (readObscene o) ;
('D':cmp:e:o:[]) -> Adv (readDegree cmp)
(readExtra e) (readObscene o) ;
('P':e:[]) -> AdvPron (readExtra e) ;
('Y':c:n:g:a:[]) -> Ord (readCase c) (readNumber n)
(readGender g) (readAnimacy a) ;
('R':c:n:g:a:e:[]) -> AdjPron (readCase c) (readNumber n)
(readGender g) (readAnimacy a) (readExtra e) ;
('M':e:[]) -> Frag (readExtra e) ;
('C':e:[]) -> Conj (readExtra e) ;
('J':e:o:[]) -> Inter (readExtra e) (readObscene o) ;
('Z':c:n:g:a:e:[]) -> Num (readCase c) (readNumber n)
(readGender g) (readAnimacy a) (readExtra e) ;
('T':e:[]) -> Part (readExtra e) ;
('B':e:[]) -> Prep (readExtra e) ;
('N':_:c:n:g:a:name:e:o:_:[]) -> N (readCase c) (readNumber n)
(readGender g) (readAnimacy a)
(readName name)
(readExtra e) (readObscene o) ;
('N':_:c:n:g:a:name:e:o:[]) -> N (readCase c) (readNumber n)
(readGender g) (readAnimacy a)
(readName name)
(readExtra e) (readObscene o) ;
('E':c:n:g:a:e:[]) -> Pron (readCase c) (readNumber n)
(readGender g) (readAnimacy a) (readExtra e) ;
('V':m:n:g:t:'P':p:a:v:tr:e:o:[]) -> V (readMood m) (readNumber n)
(readGender g) (readTense t)
(readPerson p) (readAspect a)
(readVoice v) (readTrans tr)
(readExtra e) (readObscene o) ;
('V':m:n:g:t:'0':a:v:tr:e:o:[]) -> V (readMood m) (readNumber n)
(readGender g) (readTense t)
NP (readAspect a)
(readVoice v) (readTrans tr)
(readExtra e) (readObscene o) ;
('V':m:n:g:t:p:a:v:tr:e:o:[]) -> V (readMood m) (readNumber n)
(readGender g) (readTense t)
(readPerson p) (readAspect a)
(readVoice v) (readTrans tr)
(readExtra e) (readObscene o) ;
('Q':c:n:g:t:f:a:v:tr:e:o:[]) -> P (readCase c) (readNumber n)
(readGender g) (readTense t)
(readForm f) (readAspect a)
(readVoice v) (readTrans tr)
(readExtra e) (readObscene o) ;
_ -> error $ "Parse error: " ++ T.unpack tag }
data Case = Nom | Gen | Dat | Acc | Inst | Prepos | Partit | Loc | Voc | NC
deriving (Show, Ord, Eq)
readCase 'N' = Nom
readCase 'G' = Gen
readCase 'D' = Dat
readCase 'F' = Acc
readCase 'C' = Inst
readCase 'O' = Prepos
readCase 'P' = Partit
readCase 'L' = Loc
readCase 'V' = Voc
readCase '0' = NC
data Number = Sg | Pl | NN deriving (Show, Ord, Eq)
readNumber 'S' = Sg
readNumber 'P' = Pl
readNumber '0' = NN
data Gender = Masc | Fem | Neut | Common | NG deriving (Show, Ord, Eq)
readGender 'F' = Fem
readGender 'M' = Masc
readGender 'A' = Neut
readGender 'C' = Common
readGender '0' = NG
data Animacy = Animate | Inanimate | NA deriving (Show, Ord, Eq)
readAnimacy 'A' = Animate
readAnimacy 'I' = Inanimate
readAnimacy '0' = NA
data Form = Short | Full | NF deriving (Show, Ord, Eq)
readForm 'S' = Short
readForm 'F' = Full
readForm '0' = NF
data Degree = Pos | Comp | Super | ND deriving (Show, Ord, Eq)
readDegree 'E' = Super
readDegree 'C' = Comp
readDegree 'P' = Pos
readDegree '0' = ND
data Extra = Introductory | Difficult | Distorted | Predicative
| Colloquial | Rare | Abbreviation | Obsolete | NE deriving (Show, Ord, Eq)
readExtra 'P' = Introductory
readExtra 'D' = Difficult
readExtra 'V' = Distorted
readExtra 'R' = Predicative
readExtra 'I' = Colloquial
readExtra 'A' = Rare
readExtra 'B' = Abbreviation
readExtra 'E' = Obsolete
readExtra '0' = NE
data Obscene = Obscene | NO deriving (Show, Ord, Eq)
readObscene 'H' = Obscene
readObscene '0' = NO
data Name = Topo | Proper | Patro | Family | NNa deriving (Show, Ord, Eq)
readName 'G' = Topo
readName 'N' = Proper
readName 'S' = Patro
readName 'F' = Family
readName '0' = NNa
data Mood = Gerund | Inf | Ind | Imp | NM deriving (Show, Ord, Eq)
readMood 'G' = Gerund
readMood 'I' = Inf
readMood 'D' = Ind
readMood 'M' = Imp
readMood '0' = NM
data Tense = Pres | Fut | Past | NT deriving (Show, Ord, Eq)
readTense 'P' = Pres
readTense 'F' = Fut
readTense 'S' = Past
readTense '0' = NT
data Person = P1 | P2 | P3 | NP deriving (Show, Ord, Eq)
readPerson '1' = P1
readPerson '2' = P2
readPerson '3' = P3
data Aspect = Perf | Imperf | NAs deriving (Show, Ord, Eq)
readAspect 'F' = Perf
readAspect 'N' = Imperf
readAspect '0' = NAs
data Voice = Act | Pass | NV deriving (Show, Ord, Eq)
readVoice 'A' = Act
readVoice 'S' = Pass
readVoice '0' = NV
data Trans = Trans | Intrans | NTr deriving (Show, Ord, Eq)
readTrans 'M' = Trans
readTrans 'A' = Intrans
readTrans '0' = NTr
isOpenCat :: Tag -> Bool
isOpenCat (A _ _ _ _ _ _ _ _) = True
isOpenCat (N _ _ _ _ _ _ _) = True
isOpenCat (V _ _ _ _ _ _ _ _ _ _) = True
isOpenCat (Adv _ _ _) = True
isOpenCat _ = False
noun :: Forms -> (Case, Number) -> T.Text
noun forms (c, n) = findForm matchNoun forms
where matchNoun (N c' n' _ _ _ _ _) = c == c' && n == n'
matchNoun _ = False
adj :: Forms -> Degree -> T.Text
adj forms d = findForm matchAdj forms
where matchAdj (A _ _ _ _ _ d' _ _) = d == d
matchAdj _ = False
verbPres :: Forms -> (Number, Person) -> T.Text
verbPres forms (n, p) = findForm matchPres forms
where matchPres (V Ind n' _ Pres p' _ Act _ _ _) = n == n' && p == p'
matchPres _ = False
verbPast :: Forms -> (Number, Gender) -> T.Text
verbPast forms (n, g) = findForm matchPast forms
where matchPast (V Ind n' g' Past _ _ Act _ _ _) = n == n' && g == g'
matchPast _ = False
verbImp :: Forms -> T.Text
verbImp forms = findForm matchImp forms
where matchImp (V Imp _ _ _ _ _ _ _ _ _) = True
matchImp _ = False
verbInf :: Forms -> T.Text
verbInf forms = findForm matchInf forms
where matchInf (V Inf _ _ _ _ _ _ _ _ _) = True
matchInf _ = False
adv :: Forms -> T.Text
adv forms = findForm matchAdv forms
where matchAdv (Adv d _ _) = d == Pos
matchAdv _ = False
findForm match forms = case find match (M.keys forms) of
Just tag -> forms M.! tag
Nothing -> findForm (\ _ -> True) forms

24
contrib/eaglesconv/README
View File

@@ -1,24 +0,0 @@
How to use:
1) Sort the wordlist so it can be split into sublists. It is necessary because
the converter is quite memory-hungry, and you might not have enough RAM to
process the whole wordlist at once.
./CollectLemmas dicc.src | sort > lemmas.src
2) Split the sorted wordlist.
split -l 500000 lemmas.src
3) Splitting has probably left forms of some lemmas spread across two
sublists. Manually edit sublists so all forms for a lemma are present in just
one sublist.
4) Run the converter.
./run_conv.sh xa*
5) The converter has produced abstract and concrete syntaxes for the
dictionary. You can try them out with GF:
gf DictRus.gf

8
contrib/eaglesconv/mkAbstract.sh
View File

@@ -1,8 +0,0 @@
#!/bin/sh
echo "abstract DictRusAbs = Cat ** {
"
cat $1 | sed 's/^lin/fun/g;s/=.*$//g;s/\_N/\_N : N\;/g;s/\_PN/\_PN : PN\;/g;s/\_A /\_A : A\;/g;s/\_V/\_V : V\;/g;s/\_Adv/\_Adv : Adv\;/g'
echo "
}"

12
contrib/eaglesconv/mkConcrete.sh
View File

@@ -1,12 +0,0 @@
#!/bin/sh
echo "--# -path=.:../prelude:../abstract:../common
concrete DictRus of DictRusAbs = CatRus **
open ParadigmsRus, Prelude, StructuralRus, MorphoRus in {
flags
optimize=values ;
coding=utf8 ;
"
cat $1
echo "}"

4
contrib/eaglesconv/run_conv.sh
View File

@@ -1,4 +0,0 @@
#!/bin/sh
./EaglesConv "$@" +RTS -K256M -RTS > convtmp
./mkConcrete.sh convtmp > DictRus.gf
./mkAbstract.sh convtmp > DictRusAbs.gf

37
contrib/py-bindings/Makefile
View File

@@ -1,37 +0,0 @@
src=../../src
import=-i$(src)/runtime/haskell:$(src)/compiler
cbind=../c-bindings
pyversion = $(shell python -c 'import sys; print ".".join(`t` for t in sys.version_info[:2])')
pythoninc=/usr/include/python$(pyversion)
debug= #-optc '-DDEBUG=1'
exdir=../../examples/tutorial/embedded
build: gf.so
test:
python test.py
gf.so: PyGF.hs gfmodule.c Query.pgf
ghc $(import) --make -fglasgow-exts -O2 -no-hs-main -c $<
ghc -O2 --make -fglasgow-exts -no-hs-main -optl '-shared' \
-optc '-DMODULE=$(basename $<)' $(debug) -optc '-I$(pythoninc)' -o $@ \
$(filter-out %.pgf, $^)
clean:
rm -f *.hi *.o
rm -f *_stub.*
rm -f PyGF.hs
superclean:
make clean
rm -f Query.pgf
rm -f gf.so
rm -f mtest
PyGF.hs: PyGF.hsc
hsc2hs -I$(pythoninc) $<
Query.pgf:
gf --make $(exdir)/QueryEng.gf $(exdir)/QuerySpa.gf

304
contrib/py-bindings/PyGF.hsc
View File

@@ -1,304 +0,0 @@
{-# LANGUAGE ForeignFunctionInterface #-}
--
-- GF Python bindings
-- Jordi Saludes, upc.edu 2010, 2011
--
module PyGF where
import PGF
import Foreign
import CString
import Foreign.C.Types
import Control.Monad
import Data.Map (keys, (!))
import Data.Char (isSpace)
#include "pygf.h"
freeSp :: String -> Ptr a -> IO ()
freeSp tname p = do
--DEBUG putStrLn $ "about to free pointer " ++ tname ++ " at " ++ (show p)
sp <- (#peek PyGF, sp) p
--DEBUG putStrLn "peeked"
freeStablePtr sp
--DEBUG putStrLn $ "freeing " ++ tname ++ " at " ++ (show p)
instance Storable PGF where
sizeOf _ = (#size PyGF)
alignment _ = alignment (undefined::CInt)
poke p o = do
sp <- newStablePtr o
(#poke PyGF, sp) p sp
peek p = do
sp <- (#peek PyGF, sp) p
deRefStablePtr sp
instance Storable Type where
sizeOf _ = (#size PyGF)
alignment _ = alignment (undefined::CInt)
poke p o = do
sp <- newStablePtr o
(#poke PyGF, sp) p sp
peek p = do
sp <- (#peek PyGF, sp) p
deRefStablePtr sp
instance Storable Language where
sizeOf _ = (#size PyGF)
alignment _ = alignment (undefined::CInt)
poke p o = do
sp <- newStablePtr o
(#poke PyGF, sp) p sp
peek p = do
sp <- (#peek PyGF, sp) p
deRefStablePtr sp
instance Storable Tree where
sizeOf _ = (#size PyGF)
alignment _ = alignment (undefined::CInt)
poke p o = do
sp <- newStablePtr o
(#poke PyGF, sp) p sp
peek p = do
sp <- (#peek PyGF, sp) p
deRefStablePtr sp
-- It is CId the same as Tree?
{- instance Storable CId where
sizeOf _ = (#size PyGF)
alignment _ = alignment (undefined::CInt)
poke p o = do
sp <- newStablePtr o
(#poke PyGF, sp) p sp
peek p = do
sp <- (#peek PyGF, sp) p
deRefStablePtr sp
-}
foreign export ccall gf_freePGF :: Ptr PGF -> IO ()
foreign export ccall gf_freeType :: Ptr Type -> IO ()
foreign export ccall gf_freeLanguage :: Ptr Language -> IO ()
foreign export ccall gf_freeTree :: Ptr Tree -> IO ()
foreign export ccall gf_freeExpr :: Ptr Expr -> IO ()
foreign export ccall gf_freeCId :: Ptr CId -> IO ()
gf_freePGF = freeSp "pgf"
gf_freeType = freeSp "type"
gf_freeLanguage = freeSp "language"
gf_freeTree = freeSp "tree"
gf_freeExpr = freeSp "expression"
gf_freeCId = freeSp "CId"
{-foreign export ccall gf_printCId :: Ptr CId-> IO CString
gf_printCId p = do
c <- peek p
newCString (showCId c)
-}
foreign export ccall gf_readPGF :: CString -> IO (Ptr PGF)
gf_readPGF path = do
ppgf <- pyPGF
p <- peekCString path
readPGF p >>= poke ppgf
return ppgf
foreign export ccall gf_readLanguage :: Ptr Language -> CString -> IO Bool
gf_readLanguage pt str = do
s <- (peekCString str)
case (readLanguage s) of
Just x -> do
poke pt x
return True
Nothing -> return False
foreign export ccall gf_startCat :: Ptr PGF -> IO (Ptr Type)
gf_startCat ppgf = do
pgf <- peek ppgf
pcat <- pyType
poke pcat (startCat pgf)
return pcat
foreign export ccall gf_parse :: Ptr PGF -> Ptr Language -> Ptr Type -> CString -> IO (Ptr ())
gf_parse ppgf plang pcat input = do
p <- peek ppgf
c <- peek pcat
i <- peekCString input
l <- peek plang
let parsed = parse p l c i
--DEBUG putStrLn $ (show $ length parsed) ++ " parsings"
listToPy pyTree parsed
foreign export ccall gf_showExpr :: Ptr Expr -> IO CString
gf_showExpr pexpr = do
e <- peek pexpr
newCString (showExpr [] e)
listToPy :: Storable a => IO (Ptr a) -> [a] -> IO (Ptr ()) -- opaque -- IO (Ptr (Ptr Language))
listToPy mk ls = do
pyls <- pyList
mapM_ (mpoke pyls) ls
return pyls
where mpoke pyl l = do
pl <- mk
poke pl l
pyl << pl
listToPyStrings :: [String] -> IO (Ptr ())
listToPyStrings ss = do
pyls <- pyList
mapM_ (mpoke pyls) ss
return pyls
where mpoke pyl s = do
cs <- newCString s
pcs <- pyString cs
pyl << pcs
foreign export ccall gf_showLanguage :: Ptr Language -> IO CString
gf_showLanguage plang = do
l <- peek plang
newCString $ showLanguage l
foreign export ccall gf_showType :: Ptr Type -> IO CString
gf_showType ptp = do
t <- peek ptp
newCString $ showType [] t
foreign export ccall gf_showPrintName :: Ptr PGF -> Ptr Language -> Ptr CId -> IO CString
gf_showPrintName ppgf plang pcid = do
pgf <- peek ppgf
lang <- peek plang
cid <- peek pcid
newCString (showPrintName pgf lang cid)
foreign export ccall gf_abstractName :: Ptr PGF -> IO (Ptr Language)
gf_abstractName ppgf = do
pabs <- pyLang
pgf <- peek ppgf
poke pabs $ abstractName pgf
return pabs
foreign export ccall gf_linearize :: Ptr PGF -> Ptr Language -> Ptr Tree -> IO CString
gf_linearize ppgf plang ptree = do
pgf <- peek ppgf
lang <- peek plang
tree <- peek ptree
newCString $ linearize pgf lang tree
foreign export ccall gf_languageCode :: Ptr PGF -> Ptr Language -> IO CString
gf_languageCode ppgf plang = do
pgf <- peek ppgf
lang <- peek plang
case languageCode pgf lang of
Just s -> newCString s
Nothing -> return nullPtr
foreign export ccall gf_languages :: Ptr PGF -> IO (Ptr ()) -- (Ptr (Ptr Language))
gf_languages ppgf = do
pgf <- peek ppgf
listToPy pyLang $ languages pgf
foreign export ccall gf_categories :: Ptr PGF -> IO (Ptr ())
gf_categories ppgf = do
pgf <- peek ppgf
listToPy pyCId $ categories pgf
foreign export ccall gf_showCId :: Ptr CId -> IO CString
gf_showCId pcid = do
cid <- peek pcid
newCString $ showCId cid
foreign export ccall gf_unapp :: Ptr Expr -> IO (Ptr ())
foreign export ccall gf_unint :: Ptr Expr -> IO CInt
foreign export ccall gf_unstr :: Ptr Expr -> IO CString
gf_unapp pexp = do
exp <- peek pexp
case unApp exp of
Just (f,args) -> do
puexp <- pyList
pf <- pyCId
poke pf f
puexp << pf
mapM_ (\e -> do
pe <- pyExpr
poke pe e
puexp << pe) args
return puexp
Nothing -> return nullPtr
gf_unint pexp = do
exp <- peek pexp
return $ fromIntegral $ case unInt exp of
Just n -> n
_ -> (-9)
gf_unstr pexp = do
exp <- peek pexp
case unStr exp of
Just s -> newCString s
_ -> return nullPtr
foreign export ccall gf_inferexpr :: Ptr PGF -> Ptr Expr -> IO (Ptr Type)
gf_inferexpr ppgf pexp = do
pgf <- peek ppgf
exp <- peek pexp
case inferExpr pgf exp of
Right (_,t) -> do
ptype <- pyType
poke ptype t
return ptype
Left _ -> return nullPtr
foreign export ccall gf_functions :: Ptr PGF -> IO (Ptr ())
gf_functions ppgf = do
pgf <- peek ppgf
listToPy pyCId $ functions pgf
foreign export ccall gf_functiontype :: Ptr PGF -> Ptr CId -> IO (Ptr Type)
gf_functiontype ppgf pcid = do
pgf <- peek ppgf
cid <- peek pcid
case functionType pgf cid of
Just t -> do
ptp <- pyType
poke ptp t
return ptp
_ -> return nullPtr
foreign export ccall gf_completions :: Ptr PGF -> Ptr Language -> Ptr Type -> CString -> IO (Ptr ())
gf_completions ppgf plang pcat ctoks = do
pgf <- peek ppgf
lang <- peek plang
cat <- peek pcat
toks <- peekCString ctoks
let (rpre,rs) = break isSpace (reverse toks)
pre = reverse rpre
ws = words (reverse rs)
state0 = initState pgf lang cat
completions =
case loop state0 ws of
Nothing -> []
Just state -> keys $ getCompletions state pre
listToPyStrings completions
where
loop ps [] = Just ps
loop ps (w:ws) =
case nextState ps (simpleParseInput w) of
Left _ -> Nothing
Right ps -> loop ps ws
foreign import ccall "newLang" pyLang :: IO (Ptr Language)
foreign import ccall "newPGF" pyPGF :: IO (Ptr PGF)
foreign import ccall "newTree" pyTree :: IO (Ptr Tree)
foreign import ccall "newgfType" pyType :: IO (Ptr Type)
foreign import ccall "newCId" pyCId :: IO (Ptr CId)
foreign import ccall "newExpr" pyExpr :: IO (Ptr Expr)
foreign import ccall "newList" pyList :: IO (Ptr ())
foreign import ccall "newString" pyString :: CString -> IO (Ptr ())
foreign import ccall "append" (<<) :: Ptr () -> Ptr a -> IO ()

147
contrib/py-bindings/example.rst
View File

@@ -1,147 +0,0 @@
Using the GF python bindings
============================
This is how to use some of the functionalities of the GF shell inside Python.
Loading a pgf file
------------------
First you must import the library:
>>> import gf
then load a PGF file, like this tiny example:
>>> pgf = gf.read_pgf("Query.pgf")
We could ask for the supported languages:
>>> pgf.languages()
[QueryEng, QuerySpa]
The *start category* of the PGF module is:
>>> pgf.startcat()
Question
Parsing and linearizing
-----------------------
Let's us save the languages for later:
>>> eng,spa = pgf.languages()
These are opaque objects, not strings:
>>> type(eng)
<type 'gf.lang'>
and must be used when parsing:
>>> pgf.parse(eng, "is 42 prime")
[Prime (Number 42)]
Yes, I know it should have a '?' at the end, but there is not support for other lexers at this time.
Notice that parsing returns a list of gf trees.
Let's save it and linearize it in Spanish:
>>> t = pgf.parse(eng, "is 42 prime")
>>> pgf.linearize(spa, t[0])
'42 es primo'
(which is not, but there is a '?' lacking at the end, remember?)
Getting parsing completions
---------------------------
One of the good things of the GF shell is that it suggests you which tokens can continue the line you are composing.
We got this also in the bindings.
Suppose we have no idea on how to start:
>>> pgf.complete(eng, "")
['is']
so, there is only a sensible thing to put in. Let's continue:
>>> pgf.complete(eng, "is ")
[]
Is it important to note the blank space at the end, otherwise we get it again:
>>> pgf.complete(eng, "is")
['is']
But, how come that nothing is suggested at "is "?
At the current point, a literal integer is expected so GF would have to present an infinite list of alternatives. I cannot blame it for refusing to do so.
>>> pgf.complete(eng, "is 42 ")
['even', 'odd', 'prime']
Good. I will go for 'even', just to be in the safe side:
>>> pgf.complete(eng, "is 42 even ")
[]
Nothin again, but this time the phrase is complete. Let us check it by parsing:
>>> pgf.parse(eng, "is 42 even")
[Even (Number 42)]
Deconstructing gf trees
-----------------------
We store the last result and ask for its type:
>>> t = pgf.parse(eng, "is 42 even")[0]
>>> type(t)
<type 'gf.tree'>
What's inside this tree? We use ``unapply`` for that:
>>> t.unapply()
[Even, Number 42]
This method returns a list with the head of the **fun** judgement and its arguments:
>>> map(type, _)
[<type 'gf.cid'>, <type 'gf.expr'>]
Notice the argument is again a tree (``gf.tree`` or ``gf.expr``, it is all the same here.)
>>> t.unapply()[1]
Number 42
We will repeat the trick with it now:
>>> t.unapply()[1].unapply()
[Number, 42]
and again, the same structure shows up:
>>> map(type, _)
[<type 'gf.cid'>, <type 'gf.expr'>]
One more time, just to get to the bottom of it:
>>> t.unapply()[1].unapply()[1].unapply()
42
but now it is an actual number:
>>> type(_)
<type 'int'>
We ended with a full decomposed **fun** judgement.
Note
----
This file can be used to test the bindings: ::
python -m doctest example.rst

339
contrib/py-bindings/gfmodule.c
View File

@@ -1,339 +0,0 @@
// GF Python bindings
// Jordi Saludes, upc.edu 2010, 2011
//
#include <Python.h>
#include <sys/stat.h>
#include "pygf.h"
/* utilities */
int
checkType(void* obj, PyTypeObject* tp)
{
int isRight = PyObject_TypeCheck((PyObject*)obj, tp);
if (!isRight)
PyErr_Format(PyExc_TypeError, "Expecting a %s.", tp->tp_doc);
return isRight;
}
/* new types and declarations */
NEWGF(CId,GF_CId,CIdType,"gf.cid","identifier")
NEWGF(Lang,GF_Language,LangType,"gf.lang","language")
NEWGF(gfType,GF_Type,gfTypeType,"gf.type","gf type")
NEWGF(PGF,GF_PGF,PGFType,"gf.pgf","PGF module")
NEWGF(Expr,GF_Expr,ExprType,"gf.expr","gf expression")
NEWGF(Tree,GF_Tree,TreeType,"gf.tree","gf tree")
/* CId methods, constructor and destructor */
DEALLOCFN(CId_dealloc, CId, gf_freeCId, "freeCId")
/* PGF methods, constructor and destructor */
DEALLOCFN(PGF_dealloc, PGF, gf_freePGF, "freePGF")
static PyObject*
pgf_repr(PGF *self) {
Lang* lang = gf_abstractName(self);
char* abs = gf_showLanguage(lang);
Py_DECREF(lang);
PyObject* str = PyString_FromFormat("<gf.pgf with abstract %s>", abs);
free(abs);
return str;
}
static PyObject*
languageCode(PGF *self, PyObject *args)
{
Lang *lang;
if (!PyArg_ParseTuple(args, "O", &lang))
return NULL;
if (!checkType(lang, &LangType)) return NULL;
char* scode = gf_languageCode(self, lang);
if (scode) {
PyObject* result = PyString_FromString(scode);
free(scode);
return result;
} else {
Py_INCREF(Py_None);
return Py_None;
}
}
static PyObject*
linearize(PGF *self, PyObject *args)
{
Lang *lang;
Tree *tree;
if (!PyArg_ParseTuple(args, "OO", &lang, &tree))
return NULL;
if (!checkType(lang,&LangType)) return NULL;
if (!checkType(tree,&TreeType)) return NULL;
char* c_lin = gf_linearize(self, lang, tree);
PyObject* lin = PyString_FromString(c_lin);
free(c_lin);
return lin;
}
static Lang*
abstractName(PGF *self)
{
if (!checkType(self,&PGFType)) return NULL;
return gf_abstractName(self);
}
static PyObject*
printName(PGF *self, PyObject *args)
{
Lang* lang;
CId* id;
if (!PyArg_ParseTuple(args, "OO", &lang, &id))
return NULL;
if (!checkType(lang,&LangType)) return NULL;
if (!checkType(id,&CIdType)) return NULL;
char *pname = gf_showPrintName(self, lang, id);
PyObject* result = PyString_FromString(pname);
free(pname);
return result;
}
static gfType*
functiontype(PGF *self, PyObject* args)
{
CId* cid;
gfType* gftp;
if (!PyArg_ParseTuple(args, "O", &cid))
return NULL;
if (!checkType(cid,&CIdType)) {
PyErr_Format(PyExc_TypeError, "Must be a gf identifier.");
return NULL;
}
return gf_functiontype(self, cid);
}
static PyObject*
parse(PGF *self, PyObject *args, PyObject *kws)
{
Lang *lang;
gfType *cat = NULL;
char *lexed;
static char *kwlist[] = {"lang", "lexed", "cat", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kws, "Os|O", kwlist, &lang, &lexed, &cat))
return NULL;
if (!checkType(self, &PGFType)) return NULL;
if (!checkType(lang, &LangType)) return NULL;
if (cat) {
if (!checkType(cat, &gfTypeType)) return NULL;
} else {
cat = gf_startCat(self);
}
return gf_parse(self, lang, cat, lexed);
}
static PGF*
readPGF(PyObject *self, PyObject *args)
{
char *path;
struct stat info;
if (!PyArg_ParseTuple(args, "s", &path))
return NULL;
if (stat(path, &info) == 0) {
PGF* pgf = gf_readPGF(path);
return pgf;
} else {
PyErr_Format(PyExc_IOError, "No such file: %s", path);
return NULL;
}
}
static PyObject*
completions(PGF *self, PyObject *args, PyObject *kws)
{ char *tokens;
Lang *lang;
gfType *cat = NULL;
static char *kwlist[] = {"lang", "tokens", "category", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kws, "Os|O", kwlist, &lang, &tokens, &cat))
return NULL;
if (!checkType(self, &PGFType)) return NULL;
if (!checkType(lang, &LangType)) return NULL;
if (cat) {
if (!checkType(cat, &gfTypeType)) return NULL;
} else {
cat = gf_startCat(self);
}
return gf_completions(self, lang, cat, tokens);
}
static PyMethodDef pgf_methods[] = {
{"parse", (PyCFunction)parse, METH_VARARGS|METH_KEYWORDS, "Parse a string."},
{"linearize", (PyCFunction)linearize, METH_VARARGS,"Linearize tree."},
{"lang_code", (PyCFunction)languageCode, METH_VARARGS,"Get the language code."},
{"print_name", (PyCFunction)printName, METH_VARARGS,"Get the print name for a id."},
{"fun_type", (PyCFunction)functiontype, METH_VARARGS,"Get the type of a fun expression."},
{"startcat", (PyCFunction)gf_startCat, METH_NOARGS,"Get the start category."},
{"categories", (PyCFunction)gf_categories, METH_NOARGS,"Get all categories."},
{"functions", (PyCFunction)gf_functions, METH_NOARGS,"Get all functions."},
{"abstract", (PyCFunction)abstractName, METH_NOARGS,"Get the module abstract name."},
{"languages", (PyCFunction)gf_languages, METH_NOARGS,"Get the module languages."},
{"complete", (PyCFunction)completions, METH_VARARGS|METH_KEYWORDS, "Get completions for tokens."},
{NULL, NULL, 0, NULL} /* Sentinel */
};
REPRCB(CId_repr, CId, gf_showCId)
/* Language methods, constructor and destructor */
REPRCB(lang_repr, Lang, gf_showLanguage)
DEALLOCFN(Lang_dealloc, Lang, gf_freeLanguage, "freeLanguage")
static Lang*
readLang(PyObject *self, PyObject *args)
{
char *langName;
Lang *l;
if (!PyArg_ParseTuple(args,"s",&langName))
return NULL;
l = (Lang*)LangType.tp_new(&LangType,NULL,NULL);
if(!l) return NULL;
gf_readLanguage(l,langName);
return l;
}
/* gf types: methods, constructor and destructor */
DEALLOCFN(gfType_dealloc, gfType, gf_freeType, "freeType")
REPRCB(gfType_repr, gfType, gf_showType)
/* expression type: methods, destructor */
DEALLOCFN(expr_dealloc, Expr, gf_freeExpr, "freeExpr")
REPRCB(expr_repr, Expr, gf_showExpr)
static PyObject*
unapp(Expr *self) {
PyObject* obj = gf_unapp(self);
if (!obj) {
char* s = gf_unstr(self);
if (s) {
obj = PyString_FromString(s);
free(s);
} else {
long n = gf_unint(self);
if (n != -9) {
obj = PyInt_FromLong(n);
} else {
PyErr_Format(PyExc_TypeError, "Cannot unapply expr.");
}
}
}
return obj;
}
static PyObject*
infer_expr(Expr *self, PyObject* args) {
PGF* pgf;
if (!PyArg_ParseTuple(args, "O", &pgf))
return NULL;
if (!checkType(pgf, &PGFType)) {
PyErr_Format(PyExc_ValueError, "Must be a pgf module.");
return NULL;
}
return gf_inferexpr(pgf, self);
}
/* todo: Is Tree == Expr ? */
static PyMethodDef expr_methods[] = {
{"unapply", (PyCFunction)unapp, METH_NOARGS, "Unapply an expression."},
{"infer", (PyCFunction)infer_expr, METH_VARARGS, "Infer the type of an expression."},
{NULL, NULL, 0, NULL} /* Sentinel */
};
/* tree type: methods, constructor and destructor */
// Are Expr and Tree equivalent ?
REPRCB(tree_repr, Tree, gf_showExpr)
DEALLOCFN(Tree_dealloc, Tree, gf_freeTree, "freeTree")
/* gf module methods */
static PyMethodDef gf_methods[] = {
{"read_pgf", (PyCFunction)readPGF, METH_VARARGS,"Read pgf file."},
{"read_language", (PyCFunction)readLang, METH_VARARGS,"Get the language."},
{NULL, NULL, 0, NULL} /* Sentinel */
};
#ifndef PyMODINIT_FUNC/* declarations for DLL import/export */
#define PyMODINIT_FUNC void
#endif
PyMODINIT_FUNC
initgf(void)
{
PyObject* m;
#define READYTYPE(t,trepr,tdealloc) t.tp_new = PyType_GenericNew; \
t.tp_repr = (reprfunc)trepr; \
t.tp_dealloc = (destructor)tdealloc; \
if (PyType_Ready(&t) < 0) return;
READYTYPE(CIdType, CId_repr, CId_dealloc)
PGFType.tp_methods = pgf_methods;
READYTYPE(PGFType, pgf_repr, PGF_dealloc)
READYTYPE(LangType, lang_repr, Lang_dealloc)
READYTYPE(gfTypeType, gfType_repr, gfType_dealloc)
ExprType.tp_methods = expr_methods;
READYTYPE(ExprType, expr_repr, expr_dealloc)
TreeType.tp_methods = expr_methods; // Tree == Expr ?
READYTYPE(TreeType, tree_repr, Tree_dealloc)
m = Py_InitModule3("gf", gf_methods,
"Grammatical Framework.");
static char *argv[] = {"gf.so", 0}, **argv_ = argv;
static int argc = 1;
gf_init (&argc, &argv_);
hs_add_root (__stginit_PyGF);
#define ADDTYPE(t) Py_INCREF(&t);\
PyModule_AddObject(m, "gf", (PyObject *)&t);
ADDTYPE(PGFType)
ADDTYPE(LangType)
ADDTYPE(gfTypeType)
ADDTYPE(TreeType)
ADDTYPE(ExprType)
}
/* List utilities to be imported by FFI */
inline PyObject* newList() { return PyList_New(0); }
inline PyObject* newString(const char *s) { return PyString_FromString(s); }
inline void append(PyObject* l, PyObject* ob) { PyList_Append(l, ob); }

165
contrib/py-bindings/lgpl-3.0.txt
View File

@@ -1,165 +0,0 @@
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.

96
contrib/py-bindings/pygf.h
View File

@@ -1,96 +0,0 @@
#include <Python.h>
#include "HsFFI.h"
#ifdef __GLASGOW_HASKELL__
#include "PyGF_stub.h"
extern void __stginit_PyGF ( void );
#endif
static inline void gf_init(int *argc, char ***argv)
{
hs_init(argc, argv);
#ifdef __GLASGOW_HASKELL__
hs_add_root(__stginit_PyGF);
#endif
}
static inline void gf_exit(void)
{
hs_exit();
}
typedef HsStablePtr GF_PGF;
typedef HsStablePtr GF_CId;
typedef HsStablePtr GF_Language;
typedef HsStablePtr GF_Type;
typedef HsStablePtr GF_Tree;
typedef HsStablePtr GF_Expr;
typedef struct {
PyObject_HEAD;
HsStablePtr sp;
} PyGF;
#define NEWOBJECT(OBJ, GFTYPE) typedef struct {\
PyObject_HEAD \
GFTYPE obj; \
} OBJ;
#define PYTYPE(OBJ) OBJ ## Type
#define NEWCONSTRUCTOR(OBJ) inline OBJ* new ## OBJ () {\
return (OBJ*)PYTYPE(OBJ).tp_new(&PYTYPE(OBJ),NULL,NULL); }
#define NEWTYPE(TYPE,NAME,OBJECT,DOC) static PyTypeObject TYPE = {\
PyObject_HEAD_INIT(NULL)\
0, /*ob_size*/\
NAME, /*tp_name*/\
sizeof(OBJECT), /*tp_basicsize*/\
0, /*tp_itemsize*/\
0, /*tp_dealloc*/\
0, /*tp_print*/\
0, /*tp_getattr*/\
0, /*tp_setattr*/\
0, /*tp_compare*/\
0, /*tp_repr*/\
0, /*tp_as_number*/\
0, /*tp_as_sequence*/\
0, /*tp_as_mapping*/\
0, /*tp_hash */\
0, /*tp_call*/\
0, /*tp_str*/\
0, /*tp_getattro*/\
0, /*tp_setattro*/\
0, /*tp_as_buffer*/\
Py_TPFLAGS_DEFAULT, /*tp_flags*/\
DOC, /* tp_doc */\
};
#define NEWGF(OBJ,GFTYPE,TYPE,NAME,DOC) NEWOBJECT(OBJ,GFTYPE) \
NEWTYPE(TYPE,NAME,OBJ,DOC)\
NEWCONSTRUCTOR(OBJ)
// NEWOBJECT(CID, GF_CId)
#ifdef DEBUG
#define DEALLOCFN(delname,t,cb,cbname) static void \
delname(t *self){ cb(self);\
printf("gf_%s has been called for stable pointer 0x%x\n", cbname, self->obj);\
self->ob_type->tp_free((PyObject*)self); }
#else
#define DEALLOCFN(delname,t,cb,cbname) static void \
delname(t *self){ cb(self);\
self->ob_type->tp_free((PyObject*)self); }
#endif
#ifdef DEBUG
#define REPRCB(cbid,t,gfcb) static PyObject* \
cbid(t *self) { \
const char *str = gfcb(self); \
return PyString_FromFormat("0x%x: %s", self->obj, str); }
#else
#define REPRCB(cbid,t,gfcb) static PyObject* \
cbid(t *self) { \
const char *str = gfcb(self); \
return PyString_FromString(str); }
#endif

187
contrib/py-bindings/test.py
View File

@@ -1,187 +0,0 @@
#!/usr/bin/env python
# GF Python bindings
# Jordi Saludes 2010
#
import gf
import unittest
samples = [
(['Odd', ['Number', 89]],
{'eng': "is 89 odd",
'spa': "89 es impar"}),
(['Prime', ['Number', 21]],
{'eng': "is 21 prime",
'spa': "21 es primo"})]
def lang2iso(l):
s = rmprefix(l)
assert s[:5]=="Query"
return s[5:].lower()
def exp2str(e):
def e2s(e,n):
if type(e) == type([2]):
f = e[0]
sr = ' '.join([e2s(arg,n+1) for arg in e[1:]])
ret =f + ' ' + sr
return n and '('+ret+')' or ret
elif type(e) == type('2'):
return e
elif type(e) == type(2):
return `e`
else:
raise ValueError, "Do not know how to render " + `e`
return e2s(e,0)
import re
hexre = re.compile('0x[0-9a-f]+:[ ]*')
def rmprefix(obj):
return `obj`
# s = `obj`
# m = hexre.match(s)
# return m and s[m.end(0):]
class TestPgfInfo(unittest.TestCase):
def pgf(self, path=None):
path = path or self.path
return gf.read_pgf(path)
def setUp(self):
self.path = 'Query.pgf'
def test_readPgf(self):
pgf = self.pgf()
self.assertNotEqual(pgf,None)
def test_readNonExistent(self):
nopath = 'x' + self.path
self.assertRaises(IOError, self.pgf, nopath)
def test_startcat(self):
pgf = self.pgf()
cat = pgf.startcat()
self.assertEqual(rmprefix(cat),'Question')
def test_categories(self):
pgf = self.pgf()
cats = [`c` for c in pgf.categories()]
self.failUnless('Float' in cats)
self.failUnless('Int' in cats)
self.failUnless('String' in cats)
def test_createLanguage(self):
pgf = self.pgf()
for lang in 'QueryEng QuerySpa'.split():
l = gf.read_language(lang)
self.assertEqual(rmprefix(l),lang)
def test_functions(self):
pgf = self.pgf()
self.assertTrue('Even' in [`f` for f in pgf.functions()])
def test_function_types(self):
pgf = self.pgf()
gftypes = dict((`f`,`pgf.fun_type(f)`) for f in pgf.functions())
for p in "Prime : Object -> Question; Yes : Answer".split(';'):
lhs,rhs = [s.strip() for s in p.split(':')]
self.assertEqual(gftypes[lhs],rhs)
class TestParsing(unittest.TestCase):
def setUp(self):
self.lexed = samples
self.lang = 'QueryEng'
self.pgf = "Query.pgf"
def test_parse(self):
pgf = gf.read_pgf(self.pgf)
l = gf.read_language(self.lang)
for abs,cnc in self.lexed:
rabs = exp2str(abs)
ps = pgf.parse(l, cnc['eng'])
self.failUnless(ps)
pt = rmprefix(ps[0])
self.assertEqual(pt,rabs)
class TestLinearize(unittest.TestCase):
def setUp(self):
self.samples = samples
self.pgf = gf.read_pgf('Query.pgf')
self.lang = gf.read_language('QueryEng')
def test_Linearize(self):
l = self.lang
for abs,cnc in self.samples:
ts = self.pgf.parse(l, cnc['eng'])
self.assertEqual(cnc['eng'],self.pgf.linearize(l,ts[0]))
class TestTranslate(unittest.TestCase):
def setUp(self):
self.samples = samples
self.pgf = gf.read_pgf('Query.pgf')
self.langs = [(lang2iso(l),l) for l in self.pgf.languages()]
def test_translate(self):
for abs,cnc in self.samples:
for i,l in self.langs:
for j,m in self.langs:
if i==j: continue
parsed = self.pgf.parse(l, cnc[i])
assert len(parsed) == 1
lin = self.pgf.linearize(m,parsed[0])
self.assertEqual(lin,cnc[j])
class TestUnapplyExpr(unittest.TestCase):
def setUp(self):
self.samples = samples
self.pgf = gf.read_pgf('Query.pgf')
self.langs = dict([(lang2iso(l),l) for l in self.pgf.languages()])
def deep_unapp(self,exp):
exp = exp.unapply()
if type(exp) == type([2]):
f = exp[0]
return [`f`] + map(self.deep_unapp,exp[1:])
else:
return exp
def test_unapply(self):
lg = 'eng'
lang = self.langs[lg]
for abs,cnc in self.samples:
parsed = self.pgf.parse(lang, cnc[lg])
uparsed = self.deep_unapp(parsed[0])
self.assertEqual(abs,uparsed)
def test_infer(self):
lg = 'eng'
lang = self.langs[lg]
cnc = self.samples[0][1]
parsed = self.pgf.parse(lang, cnc[lg])
exp = parsed[0]
for t in 'Question Object Int'.split():
self.assertEqual(`exp.infer(self.pgf)`, t)
uexp = exp.unapply()
if type(uexp) != type(2) and type(uexp) != type('2'):
exp = uexp[1]
class TestComplete(unittest.TestCase):
def setUp(self):
self.lexed = samples
self.pgf = gf.read_pgf('Query.pgf')
self.langs = dict([(lang2iso(l),l) for l in self.pgf.languages()])
def test_complete(self):
for (_,d) in self.lexed:
for l,text in d.items():
lang = self.langs[l]
for k in range(len(text)):
if text[k].isdigit() or text[k-1].isdigit(): # No completion for integer literals
continue
comps = self.pgf.complete(lang,text[:k])
self.assertNotEqual(comps, [],
msg="while completing '%s^%s'" % (text[:k],text[k:]))
self.assertTrue(any(w in text for w in comps),
msg="None of %s is in '%s'" % (comps,text))
if __name__ == '__main__':
unittest.main()

35
contrib/summerschool/2013/bestPractices/Facebook.gf
View File

@@ -1,35 +0,0 @@
abstract Facebook = {
flags startcat = Action ;
cat
SPerson;
Person;
Place;
Page;
Action;
Item ;
fun
CheckIn : SPerson -> Place -> Action ;
BeFriends : SPerson -> Person -> Action ;
Like : SPerson -> Item -> Action ;
SPersonToPerson : SPerson -> Person ;
MorePersons : SPerson -> Person -> Person ;
PlaceToItem : Place -> Item ;
PageToItem : Page -> Item ;
ActionToItem : Action -> Item ;
---------
You : SPerson ;
John : SPerson;
Mary : SPerson;
Frauinsel : Place;
GF : Page;
}

14
contrib/summerschool/2013/bestPractices/FacebookEng.gf
View File

@@ -1,14 +0,0 @@
concrete FacebookEng of Facebook = FacebookI with
(Syntax = SyntaxEng),
(LexFacebook = LexFacebookEng) **
open ParadigmsEng in {
lin
You = you_NP ;
John = mkNP (mkPN "John") ;
Mary = mkNP (mkPN "Mary") ;
Frauinsel = mkNP (mkPN "Frauinsel") ;
GF = mkNP (mkPN "GF") ;
}

29
contrib/summerschool/2013/bestPractices/FacebookI.gf
View File

@@ -1,29 +0,0 @@
incomplete concrete FacebookI of Facebook =
open
Syntax,
Prelude,
LexFacebook
in
{
lincat
SPerson = NP ;
Person = NP ;
Place = NP ;
Page = NP ;
Action = S ;
Item = NP ;
lin
SPersonToPerson sperson = sperson ;
MorePersons sperson person = mkNP and_Conj sperson person ;
PlaceToItem place = place ;
PageToItem page = page ;
ActionToItem action = nounFromS action ;
CheckIn sperson place = mkS pastTense (mkCl sperson (checkIn place)) ;
BeFriends sperson person = mkS pastTense (mkCl sperson (beFriends person)) ;
Like sperson item = like sperson item ;
}

8
contrib/summerschool/2013/bestPractices/LexFacebook.gf
View File

@@ -1,8 +0,0 @@
interface LexFacebook = open Syntax in
{
oper
nounFromS : S -> NP ;
checkIn : NP -> VP ;
beFriends : NP -> VP ;
like : NP -> NP -> S ;
}

16
contrib/summerschool/2013/bestPractices/LexFacebookEng.gf
View File

@@ -1,16 +0,0 @@
instance LexFacebookEng of LexFacebook =
open SyntaxEng,
ParadigmsEng,
--ExtraEng,
IrregEng in
{
oper
nounFromS s = mkNP (mkNP the_Det (mkCN (mkN "fact"))) (SyntaxEng.mkAdv that_Subj s) ;
checkIn np = mkVP (mkV2 (partV (mkV "check") "in") (mkPrep "to")) np ;
beFriends np = mkVP (mkVP (dirV2 become_V) (mkNP a_Art plNum (mkCN (mkN "friend")))) (SyntaxEng.mkAdv (mkPrep "with") np) ;
like np1 np2 = mkS (mkCl np1 (mkVP (dirV2 (mkV "like")) np2)) ;
}

7
contrib/summerschool/2013/bestPractices/corpus.txt
View File

@@ -1,7 +0,0 @@
You and John are now friends. You became friends with John.
You became friends with John and Mary.
You checked in to Frauinsel.
You like GF.
You like Frauinsel.
You like that John checked in to Frauinsel.
You like that you became friends with John and Mary.

36
contrib/summerschool/mini/Grammar.gf
View File

@@ -1,36 +0,0 @@
abstract Grammar = {
flags startcat = S ;
cat
S ; Cl ; NP ; VP ; AP ; CN ;
Det ; N ; A ; V ; V2 ; AdA ;
Tense ; Pol ;
Conj ;
fun
UseCl : Tense -> Pol -> Cl -> S ;
PredVP : NP -> VP -> Cl ;
ComplV2 : V2 -> NP -> VP ;
DetCN : Det -> CN -> NP ;
ModCN : AP -> CN -> CN ;
CompAP : AP -> VP ;
AdAP : AdA -> AP -> AP ;
ConjNP : Conj -> NP -> NP -> NP ;
UseV : V -> VP ;
UseN : N -> CN ;
UseA : A -> AP ;
a_Det, the_Det : Det ;
this_Det, these_Det : Det ;
that_Det, those_Det : Det ;
i_NP, she_NP, we_NP : NP ;
very_AdA : AdA ;
Pos, Neg : Pol ;
Pres, Perf : Tense ;
and_Conj, or_Conj : Conj ;
}

137
contrib/summerschool/mini/GrammarIta.gf
View File

@@ -1,137 +0,0 @@
concrete GrammarIta of Grammar = open ResIta, Prelude in {
lincat
S = {s : Str} ;
Cl = {s : ResIta.Tense => Bool => Str} ;
NP = ResIta.NP ;
-- {s : Case => {clit,obj : Str ; isClit : Bool} ; a : Agr} ;
VP = ResIta.VP ;
-- {v : Verb ; clit : Str ; clitAgr : ClitAgr ; obj : Agr => Str} ;
AP = {s : Gender => Number => Str ; isPre : Bool} ;
CN = Noun ; -- {s : Number => Str ; g : Gender} ;
Det = {s : Gender => Case => Str ; n : Number} ;
N = Noun ; -- {s : Number => Str ; g : Gender} ;
A = Adj ; -- {s : Gender => Number => Str ; isPre : Bool} ;
V = Verb ; -- {s : VForm => Str ; aux : Aux} ;
V2 = Verb ** {c : Case} ;
AdA = {s : Str} ;
Pol = {s : Str ; b : Bool} ;
Tense = {s : Str ; t : ResIta.Tense} ;
Conj = {s : Str ; n : Number} ;
lin
UseCl t p cl = {s = t.s ++ p.s ++ cl.s ! t.t ! p.b} ;
PredVP np vp =
let
subj = (np.s ! Nom).obj ;
obj = vp.obj ! np.a ;
clit = vp.clit ;
verb = table {
Pres => agrV vp.v np.a ;
Perf => agrV (auxVerb vp.v.aux) np.a ++ agrPart vp.v np.a vp.clitAgr
}
in {
s = \\t,b => subj ++ neg b ++ clit ++ verb ! t ++ obj
} ;
ComplV2 v2 np =
let
nps = np.s ! v2.c
in {
v = {s = v2.s ; aux = v2.aux} ;
clit = nps.clit ;
clitAgr = case <nps.isClit,v2.c> of {
<True,Acc> => CAgr np.a ;
_ => CAgrNo
} ;
obj = \\_ => nps.obj
} ;
UseV v = {
v = v ;
clit = [] ;
clitAgr = CAgrNo ;
obj = \\_ => []
} ;
DetCN det cn = {
s = \\c => {
obj = det.s ! cn.g ! c ++ cn.s ! det.n ;
clit = [] ;
isClit = False
} ;
a = Ag cn.g det.n Per3
} ;
ModCN ap cn = {
s = \\n => preOrPost ap.isPre (ap.s ! cn.g ! n) (cn.s ! n) ;
g = cn.g
} ;
CompAP ap = {
v = essere_V ;
clit = [] ;
clitAgr = CAgrNo ;
obj = \\ag => case ag of {
Ag g n _ => ap.s ! g ! n
}
} ;
AdAP ada ap = {
s = \\g,n => ada.s ++ ap.s ! g ! n ;
isPre = ap.isPre ;
} ;
ConjNP co nx ny = {
s = \\c => {
obj = (nx.s ! c).obj ++ co.s ++ (ny.s ! c).obj ;
clit = [] ;
isClit = False
} ;
a = ny.a ; ---- should be conjAgr co.n nx.a ny.a
} ;
UseN n = n ;
UseA adj = adj ;
a_Det = adjDet (mkAdj "un" "una" [] [] True) Sg ;
the_Det = {
s = table {
Masc => table {
Nom | Acc => elisForms "lo" "l'" "il" ;
Dat => elisForms "allo" "all'" "al"
} ;
Fem => table {
Nom | Acc => elisForms "la" "'l" "la" ;
Dat => elisForms "alla" "all'" "alla"
}
} ;
n = Sg
} ;
this_Det = adjDet (regAdj "questo") Sg ;
these_Det = adjDet (regAdj "questo") Pl ;
that_Det = adjDet quello_A Sg ;
those_Det = adjDet quello_A Pl ;
i_NP = pronNP "io" "mi" "mi" Masc Sg Per1 ;
she_NP = pronNP "lei" "la" "le" Fem Sg Per3 ;
we_NP = pronNP "noi" "ci" "ci" Masc Pl Per1 ;
very_AdA = ss "molto" ;
Pos = {s = [] ; b = True} ;
Neg = {s = [] ; b = False} ;
Pres = {s = [] ; t = ResIta.Pres} ;
Perf = {s = [] ; t = ResIta.Perf} ;
and_Conj = {s = "e" ; n = Pl} ;
or_Conj = {s = "o" ; n = Sg} ;
oper
quello_A : Adj = mkAdj
(elisForms "quello" "quell'" "quel") "quella"
(elisForms "quegli" "quegli" "quei") "quelle"
True ;
}

47
contrib/summerschool/mini/ParadigmsIta.gf
View File

@@ -1,47 +0,0 @@
resource ParadigmsIta = GrammarIta [N,A,V] **
open ResIta, GrammarIta, Prelude in {
oper
masculine : Gender = Masc ;
feminine : Gender = Fem ;
accusative : Case = Acc ;
dative : Case = Dat ;
mkN = overload {
mkN : (vino : Str) -> N
= \n -> lin N (regNoun n) ;
mkN : (uomo, uomini : Str) -> Gender -> N
= \s,p,g -> lin N (mkNoun s p g) ;
} ;
mkA = overload {
mkA : (nero : Str) -> A
= \a -> lin A (regAdj a) ;
mkA : (buono,buona,buoni,buone : Str) -> Bool -> A
= \sm,sf,pm,pf,p -> lin A (mkAdj sm sf pm pf False) ;
} ;
preA : A -> A
= \a -> lin A {s = a.s ; isPre = True} ;
mkV = overload {
mkV : (finire : Str) -> V
= \v -> lin V (regVerb v) ;
mkV : (andare,vado,vadi,va,andiamo,andate,vanno,andato : Str) -> V
= \i,p1,p2,p3,p4,p5,p6,p -> lin V (mkVerb i p1 p2 p3 p4 p5 p6 p Avere) ;
} ;
essereV : V -> V
= \v -> lin V {s = v.s ; aux = Essere} ;
mkV2 = overload {
mkV2 : Str -> V2
= \s -> lin V2 (regVerb s ** {c = accusative}) ;
mkV2 : V -> V2
= \v -> lin V2 (v ** {c = accusative}) ;
mkV2 : V -> Case -> V2
= \v,c -> lin V2 (v ** {c = c}) ;
} ;
}

178
contrib/summerschool/mini/ResIta.gf
View File

@@ -1,178 +0,0 @@
resource ResIta = open Prelude in {
-- parameters
param
Number = Sg | Pl ;
Gender = Masc | Fem ;
Case = Nom | Acc | Dat ;
Agr = Ag Gender Number Person ;
Aux = Avere | Essere ;
Tense = Pres | Perf ;
Person = Per1 | Per2 | Per3 ;
VForm = VInf | VPres Number Person | VPart Gender Number ;
ClitAgr = CAgrNo | CAgr Agr ;
-- parts of speech
oper
VP = {
v : Verb ;
clit : Str ;
clitAgr : ClitAgr ;
obj : Agr => Str
} ;
NP = {
s : Case => {clit,obj : Str ; isClit : Bool} ;
a : Agr
} ;
-- the preposition word of an abstract case
prepCase : Case -> Str = \c -> case c of {
Dat => "a" ;
_ => []
} ;
-- for predication
agrV : Verb -> Agr -> Str = \v,a -> case a of {
Ag _ n p => v.s ! VPres n p
} ;
auxVerb : Aux -> Verb = \a -> case a of {
Avere =>
mkVerb "avere" "ho" "hai" "ha" "abbiamo" "avete" "hanno" "avuto" Avere ;
Essere =>
mkVerb "essere" "sono" "sei" "è" "siamo" "siete" "sono" "stato" Essere
} ;
agrPart : Verb -> Agr -> ClitAgr -> Str = \v,a,c -> case v.aux of {
Avere => case c of {
CAgr (Ag g n _) => v.s ! VPart g n ;
_ => v.s ! VPart Masc Sg
} ;
Essere => case a of {
Ag g n _ => v.s ! VPart g n
}
} ;
neg : Bool -> Str = \b -> case b of {True => [] ; False => "non"} ;
essere_V = auxVerb Essere ;
-- for coordination
conjAgr : Number -> Agr -> Agr -> Agr = \n,xa,ya ->
let
x = agrFeatures xa ; y = agrFeatures ya
in Ag
(conjGender x.g y.g)
(conjNumber (conjNumber x.n y.n) n)
(conjPerson x.p y.p) ;
agrFeatures : Agr -> {g : Gender ; n : Number ; p : Person} = \a ->
case a of {Ag g n p => {g = g ; n = n ; p = p}} ;
conjGender : Gender -> Gender -> Gender = \g,h ->
case g of {Masc => Masc ; _ => h} ;
conjNumber : Number -> Number -> Number = \m,n ->
case m of {Pl => Pl ; _ => n} ;
conjPerson : Person -> Person -> Person = \p,q ->
case <p,q> of {
<Per1,_> | <_,Per1> => Per1 ;
<Per2,_> | <_,Per2> => Per2 ;
_ => Per3
} ;
-- for morphology
Noun : Type = {s : Number => Str ; g : Gender} ;
Adj : Type = {s : Gender => Number => Str ; isPre : Bool} ;
Verb : Type = {s : VForm => Str ; aux : Aux} ;
mkNoun : Str -> Str -> Gender -> Noun = \vino,vini,g -> {
s = table {Sg => vino ; Pl => vini} ;
g = g
} ;
regNoun : Str -> Noun = \vino -> case vino of {
fuo + c@("c"|"g") + "o" => mkNoun vino (fuo + c + "hi") Masc ;
ol + "io" => mkNoun vino (ol + "i") Masc ;
vin + "o" => mkNoun vino (vin + "i") Masc ;
cas + "a" => mkNoun vino (cas + "e") Fem ;
pan + "e" => mkNoun vino (pan + "i") Masc ;
_ => mkNoun vino vino Masc
} ;
mkAdj : (_,_,_,_ : Str) -> Bool -> Adj = \buono,buona,buoni,buone,p -> {
s = table {
Masc => table {Sg => buono ; Pl => buoni} ;
Fem => table {Sg => buona ; Pl => buone}
} ;
isPre = p
} ;
regAdj : Str -> Adj = \nero -> case nero of {
ner + "o" => mkAdj nero (ner + "a") (ner + "i") (ner + "e") False ;
verd + "e" => mkAdj nero nero (verd + "i") (verd + "i") False ;
_ => mkAdj nero nero nero nero False
} ;
mkVerb : (_,_,_,_,_,_,_,_ : Str) -> Aux -> Verb =
\amare,amo,ami,ama,amiamo,amate,amano,amato,aux -> {
s = table {
VInf => amare ;
VPres Sg Per1 => amo ;
VPres Sg Per2 => ami ;
VPres Sg Per3 => ama ;
VPres Pl Per1 => amiamo ;
VPres Pl Per2 => amate ;
VPres Pl Per3 => amano ;
VPart g n => (regAdj amato).s ! g ! n
} ;
aux = aux
} ;
regVerb : Str -> Verb = \amare -> case amare of {
am + "are" => mkVerb amare (am+"o") (am+"i") (am+"a")
(am+"iamo") (am+"ate") (am+"ano") (am+"ato") Avere ;
tem + "ere" => mkVerb amare (tem+"o") (tem+"i") (tem+"e")
(tem+"iamo") (tem+"ete") (tem+"ono") (tem+"uto") Avere ;
fin + "ire" => mkVerb amare (fin+"isco") (fin+"isci") (fin+"isce")
(fin+"iamo") (fin+"ite") (fin+"iscono") (fin+"ito") Avere
} ;
-- for structural words
adjDet : Adj -> Number -> {s : Gender => Case => Str ; n : Number} =
\adj,n -> {
s = \\g,c => prepCase c ++ adj.s ! g ! n ;
n = n
} ;
pronNP : (s,a,d : Str) -> Gender -> Number -> Person -> NP =
\s,a,d,g,n,p -> {
s = table {
Nom => {clit = [] ; obj = s ; isClit = False} ;
Acc => {clit = a ; obj = [] ; isClit = True} ;
Dat => {clit = d ; obj = [] ; isClit = True}
} ;
a = Ag g n p
} ;
-- phonological auxiliaries
vowel : pattern Str = #("a" | "e" | "i" | "o" | "u" | "h") ;
s_impuro : pattern Str = #("z" | "s" + ("b"|"c"|"d"|"f"|"m"|"p"|"q"|"t")) ;
elisForms : (_,_,_ : Str) -> Str = \lo,l',il ->
pre {#s_impuro => lo ; #vowel => l' ; _ => il} ;
}

45
contrib/summerschool/mini/Syntax.gf
View File

@@ -1,45 +0,0 @@
interface Syntax = Grammar -
[UseCl,PredVP,ComplV2,UseV,DetCN,ModCN,CompAP,AdAP,
UseN,UseA,Pres,Perf,Pos,Neg] **
open Grammar in {
oper
mkS = overload {
mkS : Cl -> S = UseCl Pres Pos ;
mkS : Tense -> Cl -> S = \t -> UseCl t Pos ;
mkS : Pol -> Cl -> S = UseCl Pres ;
mkS : Tense -> Pol -> Cl -> S = UseCl ;
} ;
mkCl = overload {
mkCl : NP -> V -> Cl = \np,v -> PredVP np (UseV v) ;
mkCl : NP -> V2 -> NP -> Cl = \np,v,o -> PredVP np (ComplV2 v o) ;
mkCl : NP -> A -> Cl = \np,a -> PredVP np (CompAP (UseA a)) ;
mkCl : NP -> AP -> Cl = \np,ap -> PredVP np (CompAP ap) ;
mkCl : NP -> VP -> Cl = PredVP ;
} ;
mkAP = overload {
mkAP : A -> AP = UseA ;
mkAP : AdA -> AP -> AP = AdAP ;
} ;
mkNP = overload {
mkNP : Det -> N -> NP = \d,n -> DetCN d (UseN n) ;
mkNP : Det -> CN -> NP = \d,n -> DetCN d n ;
} ;
mkCN = overload {
mkCN : N -> CN = UseN ;
mkCN : A -> N -> CN = \a,n -> ModCN (UseA a) (UseN n) ;
mkCN : A -> CN -> CN = \a,n -> ModCN (UseA a) n ;
mkCN : AP -> N -> CN = \a,n -> ModCN a (UseN n) ;
mkCN : AP -> CN -> CN = \a,n -> ModCN a n ;
} ;
presTense : Tense = Pres ;
perfTense : Tense = Perf ;
posPol : Pol = Pos ;
negPol : Pol = Neg ;
}

3
contrib/summerschool/mini/SyntaxIta.gf
View File

@@ -1,3 +0,0 @@
instance SyntaxIta of Syntax = GrammarIta -
[PredVP,ComplV2,UseV,DetCN,ModCN,CompAP,AdAP,UseN,UseA] **
open GrammarIta in {} ;

9
contrib/summerschool/mini/Test.gf
View File

@@ -1,9 +0,0 @@
abstract Test = Grammar ** {
fun
man_N, woman_N, house_N, tree_N : N ;
big_A, small_A, green_A : A ;
walk_V, arrive_V : V ;
love_V2, please_V2 : V2 ;
} ;

17
contrib/summerschool/mini/TestIta.gf
View File

@@ -1,17 +0,0 @@
concrete TestIta of Test = GrammarIta ** open ParadigmsIta in {
lin
man_N = mkN "uomo" "uomini" masculine ;
woman_N = mkN "donna" ;
house_N = mkN "casa" ;
tree_N = mkN "albero" ;
big_A = preA (mkA "grande") ;
small_A = preA (mkA "piccolo") ;
green_A = mkA "verde" ;
walk_V = mkV "camminare" ;
arrive_V = essereV (mkV "arrivare") ;
love_V2 = mkV2 "amare" ;
please_V2 = mkV2 (essereV (mkV "piacere" "piaccio" "piaci" "piace"
"piacciamo" "piacete" "piacciono" "piaciuto")) dative ;
} ;

77
examples/RDF/RDF.gf
View File

@@ -1,77 +0,0 @@
-------------------------------------------------------------------------
--
-- Abstract Syntax for RDF according to the RDF and RDFS specifications
--
-- (c) Krasimir Angelov
--
-------------------------------------------------------------------------
abstract RDF = {
cat Value (class : Class) ;
cat Resource (class : Class) ;
fun res : (c : Class) -> Resource c -> Value c ;
cat [Resource (class : Class)] ;
cat URI ;
fun uri : (c : Class) -> URI -> Resource c ;
cat BNode ;
fun bnode : (c : Class) -> BNode -> Resource c ;
nodeId : String -> BNode ;
cat DataType ;
fun datatype : DataType -> URI ;
cat Literal ;
fun lit : Literal -> Value literal_C ;
int : Int -> Literal ;
float : Float -> Literal ;
string : String -> DataType -> Literal ;
cat Property (domain, range : Class) ;
fun property : (d, r : Class) -> Property d r -> URI ;
cat Container (class : Class) ;
fun container : (c : Class) -> Container c -> Resource c ;
bag : Resource bag_C -> [Resource resource_C] -> Container bag_C ;
seq : Resource seq_C -> [Resource resource_C] -> Container seq_C ;
alt : Resource alt_C -> [Resource resource_C] -> Container alt_C ;
cat Statement ;
fun statement : Statement -> Resource statement_C ;
assert : (d,r : Class) -> Resource d -> Property d r -> Value r -> Statement ;
r_assert : (d,r : Class) -> Resource statement_C -> Resource d -> Property d r -> Value r -> Statement ;
cat Attribute (class : Class) (subject : Resource class) ;
fun assign : (d,r : Class) -> (s : Resource d) -> Property d r -> Value r -> Attribute d s ;
r_assign : (d,r : Class) -> Resource statement_C -> (s : Resource d) -> Property d r -> Value r -> Attribute d s ;
cat [Attribute (class : Class) (subject : Resource class)] ;
cat Description ;
fun description : Description -> Resource bag_C ;
describe : (c : Class) -> (s : Resource c) -> [Attribute c s] -> Description ;
r_describe : Resource bag_C -> (c : Class) -> (s : Resource c) -> [Attribute c s] -> Description ;
cat Class ;
fun class : Class -> Resource class_C ;
fun resource_C : Class ;
class_C : Class ;
property_C : Class ;
constraintResource_C : Class ;
constraintProperty_C : Class ;
literal_C : Class ;
statement_C : Class ;
bag_C : Class ;
seq_C : Class ;
alt_C : Class ;
cat Inheritance (c1,c2 : Class) ;
fun inheritance : (c1,c2 : Class) -> Inheritance c1 c2 -> Statement ;
upcast : (c1,c2 : Class) -> Inheritance c1 c2 -> Resource c1 -> Resource c2 ;
}

98
examples/SUMO/Basic.gf
View File

@@ -1,98 +0,0 @@
--# -path=.:englishExtended:common:prelude:abstract
abstract Basic = {
cat
Class;
El Class;
Ind Class;
SubClass (c1,c2 : Class);
Inherits Class Class ;
[El Class];
[Class];
Formula;
Desc Class;
Var Class;
Stmt ;
-- class-forming operations
data
both : Class -> Class -> Class ;
either : Class -> Class -> Class ;
KappaFn : (c : Class) -> (Var c -> Formula) -> Class ;
-- inheritance between classes
data
-- simple sub-class relations
inhz : (c : Class) -> Inherits c c;
inhs : (c1, c2, c3 : Class) -> SubClass c1 c2 -> Inherits c2 c3 -> Inherits c1 c3;
-- (both c1 c2) is subclass of c1 and of c2
bothL : (c1, c2 : Class) -> SubClass (both c1 c2) c1 ;
bothR : (c1, c2 : Class) -> SubClass (both c1 c2) c2 ;
-- relationship with other subclasses
bothC : (c1, c2, c3 : Class) -> Inherits c3 c1 -> Inherits c3 c2 -> Inherits c3 (both c1 c2);
-- (either c1 c2) is superclass of c1 and of c2
eitherL : (c1, c2 : Class) -> Inherits c1 (either c1 c2);
eitherR : (c1, c2 : Class) -> Inherits c2 (either c1 c2);
-- relationship with other subclasses
eitherC : (c1,c2,c3 : Class) -> SubClass c1 c3 -> SubClass c2 c3 -> SubClass (either c1 c2) c3 ;
-- sub-class axiom for KappaFn
kappa : (c : Class) -> (p : Var c -> Formula) -> Inherits (KappaFn c p) c ;
-- coercion from Var to El
data
var : (c1 , c2 : Class) -> Inherits c1 c2 -> Var c1 -> El c2 ;
-- coercion from Ind to El
data
el : (c1, c2 : Class) -> Inherits c1 c2 -> Ind c1 -> El c2;
-- first-order logic operations for Formula
data
not : Formula -> Formula;
and : Formula -> Formula -> Formula;
or : Formula -> Formula -> Formula;
impl : Formula -> Formula -> Formula;
equiv : Formula -> Formula -> Formula;
-- quantification over instances of a Class
data
exists : (c : Class) -> (Var c -> Formula) -> Formula;
forall : (c : Class) -> (Var c -> Formula) -> Formula;
-- Desc category
data
desc : (c1,c2 : Class) -> Inherits c1 c2 -> Desc c2 ;
fun descClass : (c : Class) -> Desc c -> Class ;
def descClass _ (desc c _ _) = c ;
fun descInh : (c : Class) -> (p : Desc c) -> Inherits (descClass c p) c ;
--def descInh c1 (desc c2 c1 i) = i ;
fun desc2desc : (c1,c2 : Class) -> Inherits c1 c2 -> Desc c1 -> Desc c2 ;
--def desc2desc _ _ inh dsc = desc ? ? (plusInh ? ? ? inh (descInh ? dsc)) ;
--fun plusInh : (c1,c2,c3 : Class) -> Inherits c1 c2 -> Inherits c2 c3 -> Inherits c1 c3 ;
--def plusInh _ _ _ inhz inh2 = inh2 ;
-- plusInh _ _ _ (inhs _ _ _ sc inh1) inh2 = inhs ? ? ? sc (plusInh ? ? ? inh1 inh2) ;
-- statements
data
subClassStm : (c1,c2 : Class) -> SubClass c1 c2 -> Stmt ;
instStm : (c : Class) -> Ind c -> Stmt ;
formStm : Formula -> Stmt ;
};

6
examples/SUMO/BasicBul.gf
View File

@@ -1,6 +0,0 @@
concrete BasicBul of Basic = open SyntaxBul in {
lincat
Class = CN ;
};

99
examples/SUMO/BasicEng.gf
View File

@@ -1,99 +0,0 @@
--# -path=.:englishExtended:abstract:common:
concrete BasicEng of Basic = open CatEng, ExtensionEng, DictLangEng, DictEng, ParadigmsEng, ResEng, Coordination, Prelude, ParamBasic, ConjunctionEng, NounEng in {
lincat
Class = CatEng.CN ;
El = CatEng.NP ;
Ind = CatEng.NP ;
Var = CatEng.PN ;
SubClass = {} ;
Inherits = {} ;
Desc = CatEng.CN ;
Formula = ExtensionEng.PolSentence;
[El] = ConjunctionEng.ListNP;
[Class] =ExtensionEng.ListCN ;
Stmt = ExtensionEng.StmtS ;
lin
BaseClass = {s1,s2 = \\_,_ => "";
g = Neutr;
lock_ListCN=<>};
ConsClass xs x = ExtensionEng.ConsCN xs x ;
BaseEl c = {s1,s2 = \\_ => "";
a = agrP3 Sg;
lock_ListNP=<>};
ConsEl c xs x = ConjunctionEng.ConsNP xs x ;
and f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "and" ++ f2.s ! Indep ! c; flag = NothingS; lock_PolSentence = <>};
or f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "or" ++ f2.s ! Indep ! c; flag = NothingS; lock_PolSentence = <>};
not f1 = {s = \\f => table {
CNeg _ => "it is not true that" ++ f1.s ! f ! CPos ;
CPos => f1.s ! Indep ! CNeg False
};
flag = f1.flag;
lock_PolSentence = <>
};
impl f1 f2 = {s = \\f,c => "if" ++ f1.s ! Indep ! c ++ "then" ++ f2.s ! Indep ! c; flag = NothingS; lock_PolSentence = <>};
equiv f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "is" ++ "equivalent" ++ "to" ++ f2.s ! Indep ! c; flag = NothingS;
lock_PolSentence = <>};
el c1 c2 i e = e;
var c1 c2 i e = UsePN e;
exists C f = let np = DetCN (DetQuant IndefArt NumSg) C
in { s = \\form,c => case <form, f.flag> of {
<Indep, ExistS _> => "there" ++ "exists" ++ np.s ! npNom ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib, ExistS One> => "and" ++ np.s ! npNom ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib, ExistS _> => "," ++ np.s ! npNom ++ f.$0 ++ f.s ! Attrib ! c ;
<Indep,_> => "there" ++ "exists" ++ np.s ! npNom ++ f.$0 ++ "such" ++ "that" ++ f.s ! Indep ! c ;
_ => "and" ++ np.s ! npNom ++ f.$0 ++ "such" ++ "that" ++ f.s ! Indep ! c
};
flag = case f.flag of {
ExistS _ => ExistS Many;
_ => ExistS One
};
lock_PolSentence=<>
};
forall C f = { s = \\form, c => case <form,f.flag> of {
<Indep,ForallS _> => "for" ++ "every" ++ C.s ! Sg ! Nom ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib,ForallS One> => "," ++ "every" ++ C.s ! Sg ! Nom ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib, ForallS _> => "," ++ "every" ++ C.s ! Sg ! Nom ++ f.$0 ++ f.s ! Attrib ! c ;
<Indep,ExistS _> => "for" ++"every"++ C.s ! Sg ! Nom ++ f.$0 ++ f.s ! Indep ! c ;
<Indep,_> => "for" ++"every"++ C.s ! Sg ! Nom ++ f.$0 ++ "we"++"have" ++ "that" ++ f.s ! Indep ! c ;
<Attrib,ExistS _> => "and" ++ "every" ++ C.s ! Sg ! Nom ++ f.$0 ++ f.s ! Indep ! c;
_ => "and" ++ "every" ++ C.s ! Sg ! Nom ++ f.$0 ++ "we" ++ "have" ++ "that" ++f.s ! Indep ! c };
flag = case f.flag of {
ForallS _ => ForallS Many;
_ => ForallS One
};
lock_PolSentence=<>
};
both c1 c2 = { s = \\c,n => c1.s ! c ! n ++ "and" ++ c2.s ! c ! n;
g = c2.g; lock_CN = <>
};
either c1 c2 = { s = \\c,n => c1.s ! c ! n ++ "or" ++ c2.s ! c ! n;
g = c2.g; lock_CN = <>
};
KappaFn c ob2 = ApposCN (AdvCN (AdvCN (UseN class_N) (PrepNP part_Prep (DetCN (DetQuant IndefArt NumPl) c))) where_Adv) (sentToNoun ob2) ;
desc c1 c2 i = c2 ;
descClass c dc = c;
desc2desc c1 c2 i d = d;
subClassStm c1 c2 sc = lin StmtS (ss (c1. s ! Sg ! Nom ++ "is a subclass of" ++ c2.s ! Sg ! Nom)) ;
instStm c i = lin StmtS (ss (i.s ! npNom ++ "is an instance of" ++ c.s ! Sg ! Nom)) ;
formStm f = lin StmtS (ss (f.s ! Indep ! CPos)) ;
lindef
Ind = \x -> {s = \\_ => x; a = agrP3 Sg; lock_NP = <>} ;
El = \x -> {s = \\_ => x; a = agrP3 Sg; lock_NP = <>} ;
Class = \x -> {s = \\_,_ => x; g = Neutr; lock_CN =<>};
};

107
examples/SUMO/BasicFre.gf
View File

@@ -1,107 +0,0 @@
--# -path=.:french:romance:abstract:prelude:common
concrete BasicFre of Basic = CatFre - [Text] ** open DictLangFre, CommonRomance, Prelude, ParamBasic,Coordination, ParamX, ResFre,ParadigmsFre in{
lincat
Class = CN ;
El = NP ;
Ind = NP ;
Var = PN ;
SubClass = {} ;
Inherits = {} ;
Desc = CN ;
Formula = PolSentence;
[El] = {s1,s2 : Case => Str ; a : Agr};
[Class] = {s1,s2 : Number => Str ; g : Gender};
Stmt = StmtS;
lin
BaseClass = {s1,s2 = \\_ => "";
g = Masc} ;
ConsClass xs x = consrTable Number comma xs x ** {g = x.g} ;
BaseEl c = {s1,s2 = \\_ => "";
a = agrP3 Masc Sg};
ConsEl cl x xs = {
s1 = \\c => (x.s ! c).comp ++ comma ++ xs.s1 ! c ;
s2 = \\c => xs.s2 ! c ;
a = conjAgr x.a xs.a
} ;
and f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "et" ++ f2.s ! Indep ! c; flag = NothingS; lock_PolSentence = <>};
or f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "ou" ++ f2.s ! Indep ! c; flag = NothingS; lock_PolSentence = <>};
not f1 = {s = \\f,c => case c of
{Pos => f1.s ! Indep ! Neg ;
_ => f1.s ! Indep ! Pos };
flag = NothingS; lock_PolSentence = <>};
impl f1 f2 = {s = \\f,c => "si" ++ f1.s ! Indep ! c ++ "alors" ++ f2.s ! Indep ! c; flag = NothingS; lock_PolSentence = <>};
equiv f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "est" ++ "equivalent" ++ "à" ++ f2.s ! Indep ! c; flag = NothingS;
lock_PolSentence = <>};
var c1 c2 i e = let np = UsePN e in
{s = np.s;
a = agrP3 c1.g Sg; isPol = False;
hasClit = False; lock_NP = <>};
el c1 c2 i e = e ;
exists C f = let np = DetCN (DetQuant IndefArt NumSg) C ;
tel = case C.g of
{Masc => "tel";
_ => "telle"
}
in
{s = \\form,c => case <form, f.flag> of
{ <Indep, ExistS _> => "il" ++ "existe" ++ (np.s ! Nom).comp ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib, ExistS One> => "et" ++ (np.s ! Nom).comp ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib, ExistS _> => "," ++ (np.s ! Nom).comp ++ f.$0 ++ f.s ! Attrib ! c ;
<Indep,_> => "il" ++ "existe" ++ (np.s ! Nom).comp ++ f.$0 ++ tel ++ "que" ++ f.s ! Indep ! c ;
_ => "et" ++ (np.s ! Nom).comp ++ f.$0 ++ tel ++ "que" ++ f.s ! Indep ! c };
flag = case f.flag of
{ExistS _ => ExistS Many;
_ => ExistS One };
lock_PolSentence=<>};
forall C f = {s = \\form, c => case <form,f.flag> of
{<Indep,ForallS _> => "pour" ++ "chaque" ++ C.s ! Sg ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib,ForallS One> => "," ++ "chaque" ++ C.s ! Sg ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib, ForallS _> => "," ++ "chaque" ++ C.s ! Sg ++ f.$0 ++ f.s ! Attrib ! c ;
<Indep,ExistS _> => "pour" ++"chaque"++ C.s ! Sg ++ f.$0 ++ f.s ! Indep ! c ;
<Indep,_> => "pour" ++"chaque"++ C.s ! Sg ++ f.$0 ++ "il"++ "y" ++ "a" ++ "que" ++ f.s ! Indep ! c ;
<Attrib,ExistS _> => "et" ++ "chaque" ++ C.s ! Sg ++ f.$0 ++ f.s ! Indep ! c;
_ => "and" ++ "every" ++ C.s ! Sg ++ f.$0 ++ "il" ++ "y" ++ "a" ++ "que" ++f.s ! Indep ! c };
flag = case f.flag of
{ForallS _ => ForallS Many;
_ => ForallS One };
lock_PolSentence=<>};
both c1 c2 = {s = \\n => c1.s ! n ++ "et" ++ c2.s ! n;
g = c2.g; lock_CN = <>};
either c1 c2 = {s = \\n => c1.s ! n ++ "ou" ++ c2.s ! n;
g = c2.g; lock_CN = <>};
desc c1 c2 i = c2 ;
descClass c dc = c;
desc2desc c1 c2 i d = d;
subClassStm c1 c2 sc = ss (c1. s ! Sg ++ "est" ++ "une" ++ "sous-classe" ++ "de" ++ c2.s ! Sg) ;
instStm c i = ss ((i.s ! Nom).comp ++ "est" ++ "une" ++ "instance" ++ "de" ++ c.s ! Sg) ;
formStm f = ss (f.s ! Indep ! Pos) ;
-- lindef
lindef Ind = \x -> heavyNP {s = \\_ => x ; a = agrP3 Masc Sg} ;
lindef El = \x -> heavyNP {s = \\_ => x ; a = agrP3 Masc Sg} ;
lindef Class = \x -> {s = \\n => x;
g = Masc; lock_CN =<>};
};

120
examples/SUMO/BasicRon.gf
View File

@@ -1,120 +0,0 @@
--# -path=.:RGLExt:alltenses
concrete BasicRon of Basic = CatRon - [Text] ** open DictLangRon,ResRon, Prelude, ParamBasic,Coordination, ParadigmsRon in {
flags
coding=utf8 ;
lincat
Class = CN ;
El = NP ;
Ind = NP ;
Var = PN ;
SubClass = {} ;
Inherits = {} ;
Desc = CN ;
Formula = PolSentence;
Stmt = StmtS ;
[El] = {s1,s2 : NCase => Str ; a : Agr; nForm : NForm};
[Class] = {s1,s2 : Number => Species => ACase => Str; g : NGender; a : Animacy ; isComp : Bool; needsRefForm : Bool};
lin
BaseClass = {s1,s2 = \\_,_,_ => ""; needsRefForm = False ;
g = NNeut; a = Inanimate; isComp = False} ;
ConsClass xs x = consrTable3 Number Species ACase comma xs x ** {g = x.g; a = x.a; needsRefForm = False; isComp = x.isComp} ;
BaseEl c = {s1,s2 = \\_ => "";
a = agrP3 Masc Sg; nForm = HasRef False};
ConsEl cl x xs = {
s1 = \\c => (x.s ! c).comp ++ comma ++ xs.s1 ! c ;
s2 = \\c => xs.s2 ! c ;
a = conjAgr x.a xs.a ;
nForm = case x.nForm of
{HasClit => xs.nForm ;
_ => HasRef False}
} ;
and f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "şi" ++ f2.s ! Indep ! c; flag = NothingS; lock_PolSentence = <>};
or f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "sau" ++ f2.s ! Indep ! c; flag = NothingS; lock_PolSentence = <>};
not f1 = {s = \\f,c => case c of
{Pos => f1.s ! Indep ! Neg ;
_ => f1.s ! Indep ! Pos };
flag = NothingS; lock_PolSentence = <>};
impl f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "implică" ++ f2.s ! Indep ! c; flag = NothingS; lock_PolSentence = <>};
equiv f1 f2 = {s = \\f,c => f1.s ! Indep ! c ++ "este" ++ "echivalent" ++ "cu" ++ f2.s ! Indep ! c; flag = NothingS;
lock_PolSentence = <>};
el c1 c2 i e = e ;
var c1 c2 i e = let np = UsePN e in
{s = np.s;
a = agrP3 (agrGender c1.g Sg) Sg; indForm = np.indForm ; isPol = False;
nForm = np.nForm; ss = np.ss; isComp = np.isComp ; isPronoun = False;
lock_NP = <>};
exists C f = let np = DetCN (DetQuant IndefArt NumSg) C
in
{s = \\form,c => case <form, f.flag> of
{ <Indep, ExistS _> => "există" ++ (np.s ! No).comp ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib, ExistS One> => "şi" ++ (np.s ! No).comp ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib, ExistS _> => "," ++ (np.s ! No).comp ++ f.$0 ++ f.s ! Attrib ! c ;
<Indep,_> => "există" ++ (np.s ! No).comp ++ f.$0 ++ "astfel" ++ "ca" ++ f.s ! Indep ! Pos ;
_ => "şi" ++ (np.s ! No).comp ++ f.$0 ++ "astfel" ++ "ca" ++ f.s ! Indep ! Pos };
flag = case f.flag of
{ExistS _ => ExistS Many;
_ => ExistS One };
lock_PolSentence=<>};
forall C f = {s = \\form, c => case <form,f.flag> of
{<Indep,ForallS _> => "pentru" ++ "orice" ++ C.s ! Sg ! Indef ! ANomAcc ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib,ForallS One > => "şi" ++ "orice" ++ C.s ! Sg ! Indef ! ANomAcc ++ f.$0 ++ f.s ! Attrib ! c ;
<Attrib, ForallS _> => "," ++ "orice" ++ C.s ! Sg ! Indef ! ANomAcc ++ f.$0 ++ f.s ! Attrib ! c ;
<Indep,ExistS _> => "pentru" ++"orice"++ C.s ! Sg ! Indef ! ANomAcc ++ f.$0 ++ f.s ! Indep ! c ;
<Indep,_> => "pentru" ++"orice"++ C.s ! Sg ! Indef ! ANomAcc ++ f.$0 ++ "avem" ++ "că" ++ f.s ! Indep ! c ;
<Attrib,ExistS _> => "şi" ++ "orice" ++ C.s ! Sg ! Indef ! ANomAcc ++ f.$0 ++ f.s ! Indep ! c;
_ => "şi" ++ "orice" ++ C.s ! Sg ! Indef ! ANomAcc ++ f.$0 ++ "avem" ++ "că" ++f.s ! Indep ! c };
flag = case f.flag of
{ForallS _ => ForallS Many;
_ => ForallS One };
lock_PolSentence=<>};
both c1 c2 = {s = \\c,sp,n => c1.s ! c ! sp ! n ++ "şi" ++ c2.s ! c ! sp ! n;
g = c2.g; a = case c1.a of
{Inanimate => Inanimate;
_ => c2.a };
isComp = orB c1.isComp c2.isComp; needsRefForm = False; lock_CN = <>};
either c1 c2 = {s = \\c,sp,n => c1.s ! c ! sp ! n ++ "sau" ++ c2.s ! c ! sp ! n;
g = c2.g; a = case c1.a of
{Inanimate => Inanimate;
_ => c2.a };
isComp = orB c1.isComp c2.isComp; needsRefForm = False; lock_CN = <>};
subClassStm c1 c2 sc = ss (c1. s ! Sg ! Def ! ANomAcc ++ "este" ++ "o" ++ "subclasã" ++ "a" ++ c2.s ! Sg ! Def ! AGenDat) ;
instStm c i = ss ((i.s ! No).comp ++ "este" ++ "o" ++ "instanþiere" ++ "a" ++ c.s ! Sg ! Def ! AGenDat) ;
formStm f = ss (f.s ! Indep ! Pos) ;
desc c1 c2 i = c2 ;
descClass c dc = c;
desc2desc c1 c2 i d = d;
-- lindef
lindef Ind = \x -> mkNP x ("lui" ++ x) x Sg Masc;
lindef El = \x -> mkNP x ("lui" ++ x) x Sg Masc;
lindef Class = \x -> {s = \\n,sp,c => case c of
{AGenDat => "lui" ++ x ;
_ => x};
g = NMasc; a = Animate; isComp=False; needsRefForm = False; lock_CN =<>};
};

6
examples/SUMO/BasicSwe.gf
View File

@@ -1,6 +0,0 @@
concrete BasicSwe of Basic = open SyntaxSwe in {
lincat
Class = CN ;
};

451
examples/SUMO/Birds.gf
View File

@@ -1,451 +0,0 @@
abstract Birds = Merge ** {
fun
GaviaStellata : Class ;
GaviaStellata_Class : SubClass GaviaStellata Bird ;
GaviaArctica : Class ;
GaviaArctica_Class : SubClass GaviaArctica Bird ;
PodicepsCristatus : Class ;
PodicepsCristatus_Class : SubClass PodicepsCristatus Bird ;
PodicepsAuritus : Class ;
PodicepsAuritus_Class : SubClass PodicepsAuritus Bird ;
ArdeaCinerea : Class ;
ArdeaCinerea_Class : SubClass ArdeaCinerea Bird ;
BotaurusStellaris : Class ;
BotaurusStellaris_Class : SubClass BotaurusStellaris Bird ;
CygnusOlor : Class ;
CygnusOlor_Class : SubClass CygnusOlor Bird ;
CygnusCygnus : Class ;
CygnusCygnus_Class : SubClass CygnusCygnus Bird ;
AnserFabalis : Class ;
AnserFabalis_Class : SubClass AnserFabalis Bird ;
AnserAnser : Class ;
AnserAnser_Class : SubClass AnserAnser Bird ;
BrantaCanadensis : Class ;
BrantaCanadensis_Class : SubClass BrantaCanadensis Bird ;
BrantaLeucopsis : Class ;
BrantaLeucopsis_Class : SubClass BrantaLeucopsis Bird ;
TadornaTadorna : Class ;
TadornaTadorna_Class : SubClass TadornaTadorna Bird ;
AnasPlatyrhynchos : Class ;
AnasPlatyrhynchos_Class : SubClass AnasPlatyrhynchos Bird ;
AnasPenelope : Class ;
AnasPenelope_Class : SubClass AnasPenelope Bird ;
AnasCrecca : Class ;
AnasCrecca_Class : SubClass AnasCrecca Bird ;
BucephalaClangula : Class ;
BucephalaClangula_Class : SubClass BucephalaClangula Bird ;
ClangulaHyemalis : Class ;
ClangulaHyemalis_Class : SubClass ClangulaHyemalis Bird ;
SomateriaMollissima : Class ;
SomateriaMollissima_Class : SubClass SomateriaMollissima Bird ;
MergusMerganser : Class ;
MergusMerganser_Class : SubClass MergusMerganser Bird ;
MelanittaNigra : Class ;
MelanittaNigra_Class : SubClass MelanittaNigra Bird ;
HaliaeetusAlbicilla : Class ;
HaliaeetusAlbicilla_Class : SubClass HaliaeetusAlbicilla Bird ;
PandionHaliaetus : Class ;
PandionHaliaetus_Class : SubClass PandionHaliaetus Bird ;
ButeoButeo : Class ;
ButeoButeo_Class : SubClass ButeoButeo Bird ;
AccipiterGentilis : Class ;
AccipiterGentilis_Class : SubClass AccipiterGentilis Bird ;
AccipiterNisus : Class ;
AccipiterNisus_Class : SubClass AccipiterNisus Bird ;
FalcoTinnunculus : Class ;
FalcoTinnunculus_Class : SubClass FalcoTinnunculus Bird ;
LagopusLagopus : Class ;
LagopusLagopus_Class : SubClass LagopusLagopus Bird ;
LagopusMutus : Class ;
LagopusMutus_Class : SubClass LagopusMutus Bird ;
TetraoUrogallus : Class ;
TetraoUrogallus_Class : SubClass TetraoUrogallus Bird ;
LyrurusTetrix : Class ;
LyrurusTetrix_Class : SubClass LyrurusTetrix Bird ;
PhasianusColchicus : Class ;
PhasianusColchicus_Class : SubClass PhasianusColchicus Bird ;
RallusAquaticus : Class ;
RallusAquaticus_Class : SubClass RallusAquaticus Bird ;
FulicaAtra : Class ;
FulicaAtra_Class : SubClass FulicaAtra Bird ;
GallinulaChloropus : Class ;
GallinulaChloropus_Class : SubClass GallinulaChloropus Bird ;
GrusGrus : Class ;
GrusGrus_Class : SubClass GrusGrus Bird ;
HaematopusOstralegus : Class ;
HaematopusOstralegus_Class : SubClass HaematopusOstralegus Bird ;
CharadriusHiaticula : Class ;
CharadriusHiaticula_Class : SubClass CharadriusHiaticula Bird ;
PluvialisApricaria : Class ;
PluvialisApricaria_Class : SubClass PluvialisApricaria Bird ;
VanellusVanellus : Class ;
VanellusVanellus_Class : SubClass VanellusVanellus Bird ;
CalidrisAlpina : Class ;
CalidrisAlpina_Class : SubClass CalidrisAlpina Bird ;
TringaGlareola : Class ;
TringaGlareola_Class : SubClass TringaGlareola Bird ;
TringaOchropus : Class ;
TringaOchropus_Class : SubClass TringaOchropus Bird ;
NumeniusArquata : Class ;
NumeniusArquata_Class : SubClass NumeniusArquata Bird ;
ScolopaxRusticola : Class ;
ScolopaxRusticola_Class : SubClass ScolopaxRusticola Bird ;
GallinagoGallinago : Class ;
GallinagoGallinago_Class : SubClass GallinagoGallinago Bird ;
LymnocryptesMinimus : Class ;
LymnocryptesMinimus_Class : SubClass LymnocryptesMinimus Bird ;
TringaTotanus : Class ;
TringaTotanus_Class : SubClass TringaTotanus Bird ;
TringaErythropus : Class ;
TringaErythropus_Class : SubClass TringaErythropus Bird ;
TringaNebularia : Class ;
TringaNebularia_Class : SubClass TringaNebularia Bird ;
StercorariusParasiticus : Class ;
StercorariusParasiticus_Class : SubClass StercorariusParasiticus Bird ;
LarusRidibundus : Class ;
LarusRidibundus_Class : SubClass LarusRidibundus Bird ;
LarusCanus : Class ;
LarusCanus_Class : SubClass LarusCanus Bird ;
LarusArgentatus : Class ;
LarusArgentatus_Class : SubClass LarusArgentatus Bird ;
LarusFuscus : Class ;
LarusFuscus_Class : SubClass LarusFuscus Bird ;
LarusMarinus : Class ;
LarusMarinus_Class : SubClass LarusMarinus Bird ;
SternaSandvicensis : Class ;
SternaSandvicensis_Class : SubClass SternaSandvicensis Bird ;
SternaCaspia : Class ;
SternaCaspia_Class : SubClass SternaCaspia Bird ;
SternaHirundo : Class ;
SternaHirundo_Class : SubClass SternaHirundo Bird ;
SternaParadisaea : Class ;
SternaParadisaea_Class : SubClass SternaParadisaea Bird ;
AlcaTorda : Class ;
AlcaTorda_Class : SubClass AlcaTorda Bird ;
ColumbaOenas : Class ;
ColumbaOenas_Class : SubClass ColumbaOenas Bird ;
ColumbaPalumnbus : Class ;
ColumbaPalumnbus_Class : SubClass ColumbaPalumnbus Bird ;
StreptopeliaDecaocto : Class ;
StreptopeliaDecaocto_Class : SubClass StreptopeliaDecaocto Bird ;
StrixAluco : Class ;
StrixAluco_Class : SubClass StrixAluco Bird ;
StrixUralensis : Class ;
StrixUralensis_Class : SubClass StrixUralensis Bird ;
BuboBubo : Class ;
BuboBubo_Class : SubClass BuboBubo Bird ;
AsioFlammeus : Class ;
AsioFlammeus_Class : SubClass AsioFlammeus Bird ;
AsioOtus : Class ;
AsioOtus_Class : SubClass AsioOtus Bird ;
AegoliusFunereus : Class ;
AegoliusFunereus_Class : SubClass AegoliusFunereus Bird ;
GlaucidiumPasserinum : Class ;
GlaucidiumPasserinum_Class : SubClass GlaucidiumPasserinum Bird ;
CuculusCanorus : Class ;
CuculusCanorus_Class : SubClass CuculusCanorus Bird ;
CaprimulgusEuropaeus : Class ;
CaprimulgusEuropaeus_Class : SubClass CaprimulgusEuropaeus Bird ;
PicusViridis : Class ;
PicusViridis_Class : SubClass PicusViridis Bird ;
DryocopusMartius : Class ;
DryocopusMartius_Class : SubClass DryocopusMartius Bird ;
JynxTorquilla : Class ;
JynxTorquilla_Class : SubClass JynxTorquilla Bird ;
DendrocoposMajor : Class ;
DendrocoposMajor_Class : SubClass DendrocoposMajor Bird ;
DendrocoposMinor : Class ;
DendrocoposMinor_Class : SubClass DendrocoposMinor Bird ;
AlaudaArvensis : Class ;
AlaudaArvensis_Class : SubClass AlaudaArvensis Bird ;
LullulaArborea : Class ;
LullulaArborea_Class : SubClass LullulaArborea Bird ;
ApusApus : Class ;
ApusApus_Class : SubClass ApusApus Bird ;
HirundoRustica : Class ;
HirundoRustica_Class : SubClass HirundoRustica Bird ;
DelichonUrbicum : Class ;
DelichonUrbicum_Class : SubClass DelichonUrbicum Bird ;
AnthusPratensis : Class ;
AnthusPratensis_Class : SubClass AnthusPratensis Bird ;
AnthusTrivialis : Class ;
AnthusTrivialis_Class : SubClass AnthusTrivialis Bird ;
MotacillaAlba : Class ;
MotacillaAlba_Class : SubClass MotacillaAlba Bird ;
MotacillaFlava : Class ;
MotacillaFlava_Class : SubClass MotacillaFlava Bird ;
TroglodytesTroglodytes : Class ;
TroglodytesTroglodytes_Class : SubClass TroglodytesTroglodytes Bird ;
BombycillaGarrulus : Class ;
BombycillaGarrulus_Class : SubClass BombycillaGarrulus Bird ;
PrunellaModularis : Class ;
PrunellaModularis_Class : SubClass PrunellaModularis Bird ;
LusciniaLuscinia : Class ;
LusciniaLuscinia_Class : SubClass LusciniaLuscinia Bird ;
ErithacusRubecula : Class ;
ErithacusRubecula_Class : SubClass ErithacusRubecula Bird ;
LusciniaSvecica : Class ;
LusciniaSvecica_Class : SubClass LusciniaSvecica Bird ;
PhoenicurusPhoenicurus : Class ;
PhoenicurusPhoenicurus_Class : SubClass PhoenicurusPhoenicurus Bird ;
OenantheOenanthe : Class ;
OenantheOenanthe_Class : SubClass OenantheOenanthe Bird ;
SaxicollaRubetra : Class ;
SaxicollaRubetra_Class : SubClass SaxicollaRubetra Bird ;
TurdusPhilomelos : Class ;
TurdusPhilomelos_Class : SubClass TurdusPhilomelos Bird ;
TurdusIliacus : Class ;
TurdusIliacus_Class : SubClass TurdusIliacus Bird ;
TurdusViscivorus : Class ;
TurdusViscivorus_Class : SubClass TurdusViscivorus Bird ;
TurdusPilaris : Class ;
TurdusPilaris_Class : SubClass TurdusPilaris Bird ;
TurdusMerula : Class ;
TurdusMerula_Class : SubClass TurdusMerula Bird ;
SylviaBorin : Class ;
SylviaBorin_Class : SubClass SylviaBorin Bird ;
SylviaAtricapilla : Class ;
SylviaAtricapilla_Class : SubClass SylviaAtricapilla Bird ;
SylviaCurruca : Class ;
SylviaCurruca_Class : SubClass SylviaCurruca Bird ;
SylviaCommunis : Class ;
SylviaCommunis_Class : SubClass SylviaCommunis Bird ;
AcrocephalusSchoenobaenus : Class ;
AcrocephalusSchoenobaenus_Class : SubClass AcrocephalusSchoenobaenus Bird ;
AcrocephalusScirpaceus : Class ;
AcrocephalusScirpaceus_Class : SubClass AcrocephalusScirpaceus Bird ;
AcrocephalusPalustris : Class ;
AcrocephalusPalustris_Class : SubClass AcrocephalusPalustris Bird ;
PhylloscopusTrochilus : Class ;
PhylloscopusTrochilus_Class : SubClass PhylloscopusTrochilus Bird ;
PhylloscopusCollybita : Class ;
PhylloscopusCollybita_Class : SubClass PhylloscopusCollybita Bird ;
PhylloscopusSibilatrix : Class ;
PhylloscopusSibilatrix_Class : SubClass PhylloscopusSibilatrix Bird ;
HippolaisIcterina : Class ;
HippolaisIcterina_Class : SubClass HippolaisIcterina Bird ;
RegulusRegulus : Class ;
RegulusRegulus_Class : SubClass RegulusRegulus Bird ;
FicedulaHypoleuca : Class ;
FicedulaHypoleuca_Class : SubClass FicedulaHypoleuca Bird ;
ParisMajor : Class ;
ParisMajor_Class : SubClass ParisMajor Bird ;
ParisCaeruleus : Class ;
ParisCaeruleus_Class : SubClass ParisCaeruleus Bird ;
SittaEuropaea : Class ;
SittaEuropaea_Class : SubClass SittaEuropaea Bird ;
ParisCristatus : Class ;
ParisCristatus_Class : SubClass ParisCristatus Bird ;
ParusAter : Class ;
ParusAter_Class : SubClass ParusAter Bird ;
ParusMontanus : Class ;
ParusMontanus_Class : SubClass ParusMontanus Bird ;
ParusPalustris : Class ;
ParusPalustris_Class : SubClass ParusPalustris Bird ;
AegithalosCaudatis : Class ;
AegithalosCaudatis_Class : SubClass AegithalosCaudatis Bird ;
PanururBiarmicus : Class ;
PanururBiarmicus_Class : SubClass PanururBiarmicus Bird ;
LaniusCollurio : Class ;
LaniusCollurio_Class : SubClass LaniusCollurio Bird ;
GarrulusGlandarius : Class ;
GarrulusGlandarius_Class : SubClass GarrulusGlandarius Bird ;
PicaPica : Class ;
PicaPica_Class : SubClass PicaPica Bird ;
NucifragaCaryocatactes : Class ;
NucifragaCaryocatactes_Class : SubClass NucifragaCaryocatactes Bird ;
CorvusMonedula : Class ;
CorvusMonedula_Class : SubClass CorvusMonedula Bird ;
CorvusFrugilegus : Class ;
CorvusFrugilegus_Class : SubClass CorvusFrugilegus Bird ;
CorvusCorone : Class ;
CorvusCorone_Class : SubClass CorvusCorone Bird ;
CorvusCorax : Class ;
CorvusCorax_Class : SubClass CorvusCorax Bird ;
SturnusVulgaris : Class ;
SturnusVulgaris_Class : SubClass SturnusVulgaris Bird ;
PasserDomesticus : Class ;
PasserDomesticus_Class : SubClass PasserDomesticus Bird ;
PasserMontanus : Class ;
PasserMontanus_Class : SubClass PasserMontanus Bird ;
FringillaCoelebs : Class ;
FringillaCoelebs_Class : SubClass FringillaCoelebs Bird ;
FringillaMontifringilla : Class ;
FringillaMontifringilla_Class : SubClass FringillaMontifringilla Bird ;
CarpodacusErythrinus : Class ;
CarpodacusErythrinus_Class : SubClass CarpodacusErythrinus Bird ;
CarduelisCannabina : Class ;
CarduelisCannabina_Class : SubClass CarduelisCannabina Bird ;
CarduelisFlammea : Class ;
CarduelisFlammea_Class : SubClass CarduelisFlammea Bird ;
CarduelisCarduelis : Class ;
CarduelisCarduelis_Class : SubClass CarduelisCarduelis Bird ;
CarduelisChloris : Class ;
CarduelisChloris_Class : SubClass CarduelisChloris Bird ;
CarduelisSpinus : Class ;
CarduelisSpinus_Class : SubClass CarduelisSpinus Bird ;
PyrrhulaPyrrhula : Class ;
PyrrhulaPyrrhula_Class : SubClass PyrrhulaPyrrhula Bird ;
LoxiaCurvirostra : Class ;
LoxiaCurvirostra_Class : SubClass LoxiaCurvirostra Bird ;
EmberizaSchoeniclus : Class ;
EmberizaSchoeniclus_Class : SubClass EmberizaSchoeniclus Bird ;
PlectrophenaxNivalis : Class ;
PlectrophenaxNivalis_Class : SubClass PlectrophenaxNivalis Bird ;
CalcariusLapponicus : Class ;
CalcariusLapponicus_Class : SubClass CalcariusLapponicus Bird ;
EmberizaHortulana : Class ;
EmberizaHortulana_Class : SubClass EmberizaHortulana Bird ;
EmberizaCitrinella : Class ;
EmberizaCitrinella_Class : SubClass EmberizaCitrinella Bird ;
}

157
examples/SUMO/BirdsBul.gf
View File

@@ -1,157 +0,0 @@
concrete BirdsBul of Birds = MergeBul ** open SyntaxBul, ParadigmsBul, ResBul in {
flags
coding=utf8 ;
lin
GaviaStellata = mkCN (mkA076 "червеногуш") (mkN007b "гмуркач") ;
GaviaArctica = mkCN (mkA076 "черногуш") (mkN007b "гмуркач") ;
PodicepsCristatus = mkCN (mkA081 "голям") (mkN008a "гмурец") ;
PodicepsAuritus = mkCN (mkA076 "ушат") (mkN008a "гмурец") ;
ArdeaCinerea = mkCN (mkA076 "сив") (mkN041 "чапла") ;
BotaurusStellaris = mkCN (mkA081 "голям") (mkCN (mkA079 "воден") (mkN001 "бик")) ;
CygnusOlor = mkCN (mkA081 "ням") (mkN007 "лебед") ;
CygnusCygnus = mkCN (mkA085 "поен") (mkN007 "лебед") ;
AnserFabalis = mkCN (mkA079 "посевен") (mkN041 "гъска") ;
AnserAnser = mkCN (mkA076 "сив") (mkN041 "гъска") ;
BrantaCanadensis = mkCN (mkA078 "канадски") (mkN041 "гъска") ;
BrantaLeucopsis = mkCN (mkA076 "белобуз") (mkN041 "гъска") ;
TadornaTadorna = mkCN (mkA081 "бял") (mkN007 "ангъч") ;
AnasPlatyrhynchos = mkCN (mkA076 "зеленоглав") (mkN041 "патица") ;
AnasPenelope = mkCN (mkN001 "фиш") ;
AnasCrecca = mkCN (mkA079 "зимен") (mkN065 "бърне") ;
BucephalaClangula = mkCN (mkN041 "звънарка") ;
ClangulaHyemalis = mkCN (mkA076 "леден") (mkN041 "потапница") ;
SomateriaMollissima = mkCN (mkA076 "обикновен") (mkN041 "гага") ;
MergusMerganser = mkCN (mkA081 "голям") (mkN008 "нирец") ;
MelanittaNigra = mkCN (mkA079 "траурен") (mkN041 "потапница") ;
HaliaeetusAlbicilla = mkCN (mkA078 "морски") (mkN008 "орел") ;
PandionHaliaetus = mkCN (compoundN (mkN008 "орел") (mkN031a "рибар")) ;
ButeoButeo = mkCN (mkA076 "обикновен") (mkN007 "мишелов") ;
AccipiterGentilis = mkCN (mkA081 "голям") (mkN007 "ястреб") ;
AccipiterNisus = mkCN (mkA080 "малък") (mkN007 "ястреб") ;
FalcoTinnunculus = mkCN (mkN007 "керкенез") ;
LagopusLagopus = mkCN (mkA081 "бял") (mkN041 "яребица") ;
LagopusMutus = mkCN (mkA076 "тундров") (mkN041 "яребица") ;
TetraoUrogallus = mkCN (mkN031 "глухар") ;
LyrurusTetrix = mkCN (mkA079 "черен") (mkN041 "яребица") ;
PhasianusColchicus = mkCN (mkA078 "колхидски") (mkN007 "фазан") ;
RallusAquaticus = mkCN (mkN008 "крещалец") ;
FulicaAtra = mkCN (mkN041 "лиска") ;
GallinulaChloropus = mkCN (mkN041 "зеленоножка") ;
GrusGrus = mkCN (mkA076 "сив") (mkN007 "жерав") ;
HaematopusOstralegus = mkCN (mkN007 "стридояд") ;
CharadriusHiaticula = mkCN (mkA079 "пясъчен") (mkN008 "дъждосвирец") ;
PluvialisApricaria = mkCN (mkA076 "златист") (mkN041 "булка") ;
VanellusVanellus = mkCN (mkA076 "обикновен") (mkN041 "калугерица") ;
CalidrisAlpina = mkCN (mkA076 "тъмногръд") (mkN007 "брегобегач") ;
TringaGlareola = mkCN (mkA080 "малък") (mkCN (mkA078 "горски") (mkCN (mkN007 "водобегач"))) ;
TringaOchropus = mkCN (mkA081 "голям") (mkCN (mkA078 "горски") (mkCN (mkN007 "водобегач"))) ;
NumeniusArquata = mkCN (mkA081 "голям") (mkN008 "свирец") ;
ScolopaxRusticola = mkCN (mkA078 "горски") (mkN007 "бекас") ;
GallinagoGallinago = mkCN (mkA079 "среден") (mkN041 "бекасина") ;
LymnocryptesMinimus = mkCN (mkA080 "малък") (mkN041 "бекасина") ;
TringaTotanus = mkCN (mkA080 "малък") (mkCN (mkA076 "червенокрак") (mkCN (mkN007 "водобегач"))) ;
TringaErythropus = mkCN (mkA081 "голям") (mkCN (mkA076 "червенокрак") (mkCN (mkN007 "водобегач"))) ;
TringaNebularia = mkCN (mkA081 "голям") (mkCN (mkA076 "зеленокрак") (mkCN (mkN007 "водобегач"))) ;
StercorariusParasiticus = mkCN (mkA079 "среден") (mkN014 "морелетник") ;
LarusRidibundus = mkCN (mkA079 "речен") (mkN041 "чайка") ;
LarusCanus = mkCN (compoundN (mkN041 "чайка") (mkN041 "буревестница")) ;
LarusArgentatus = mkCN (mkA076 "сребрист") (mkN041 "чайка") ;
LarusFuscus = mkCN (mkA080 "малък") (mkCN (mkA076 "черногърб") (mkCN (mkN041 "чайка"))) ;
LarusMarinus = mkCN (mkA081 "голям") (mkCN (mkA076 "черногърб") (mkCN (mkN041 "чайка"))) ;
SternaSandvicensis = mkCN (mkA076 "гривест") (mkN041 "рибарка") ;
SternaCaspia = mkCN (mkA078 "каспийски") (mkN041 "рибарка") ;
SternaHirundo = mkCN (mkA079 "речен") (mkN041 "рибарка") ;
SternaParadisaea = mkCN (mkA079 "полярен") (mkN041 "рибарка") ;
AlcaTorda = mkCN (mkN041a "гагарка") ;
ColumbaOenas = mkCN (compoundN (mkN007 "гълъб") (mkN007 "хралупар")) ;
ColumbaPalumnbus = mkCN (mkN014 "гривяк") ;
StreptopeliaDecaocto = mkCN (mkN041 "гугутка") ;
StrixAluco = mkCN (mkA078 "горски") (mkN041 "улулица") ;
StrixUralensis = mkCN (mkA078 "уралски") (mkN041 "улулица") ;
BuboBubo = mkCN (mkN007 "бухал") ;
AsioFlammeus = mkCN (mkA079 "блатен") (mkN041 "сова") ;
AsioOtus = mkCN (mkA078 "горски") (mkCN (mkA076 "ушат") (mkCN (mkN041 "сова"))) ;
AegoliusFunereus = mkCN (mkA076 "пернатоног") (mkN041 "кукумявка") ;
GlaucidiumPasserinum = mkCN (mkA080 "малък") (mkN041 "кукумявка") ;
CuculusCanorus = mkCN (mkA076 "обикновен") (mkN041 "кукувица") ;
CaprimulgusEuropaeus = mkCN (mkN032 "козодой") ;
PicusViridis = mkCN (mkA076 "зелен") (mkN007 "кълвач") ;
DryocopusMartius = mkCN (mkA079 "черен") (mkN007 "кълвач") ;
JynxTorquilla = mkCN (mkN041 "въртошийка") ;
DendrocoposMajor = mkCN (mkA081 "голям") (mkCN (mkA080 "пъстър") (mkCN (mkN007 "кълвач"))) ;
DendrocoposMinor = mkCN (mkA080 "малък") (mkCN (mkA080 "пъстър") (mkCN (mkN007 "кълвач"))) ;
AlaudaArvensis = mkCN (mkA078 "полски") (mkN041 "чучулига") ;
LullulaArborea = mkCN (mkA078 "горски") (mkN041 "чучулига") ;
ApusApus = mkCN (mkA079 "черен") (mkN007 "бързолет") ;
HirundoRustica = mkCN (mkA078 "селски") (mkN041 "лястовица") ;
DelichonUrbicum = mkCN (mkA078 "градски") (mkN041 "лястовица") ;
AnthusPratensis = mkCN (mkA079 "ливаден") (mkN041 "бъбрица") ;
AnthusTrivialis = mkCN (mkA078 "горски") (mkN041 "бъбрица") ;
MotacillaAlba = mkCN (mkA081 "бял") (mkN041 "стърчиопашка") ;
MotacillaFlava = mkCN (mkA076 "жълт") (mkN041 "стърчиопашка") ;
TroglodytesTroglodytes = mkCN (mkN065 "орехче") ;
BombycillaGarrulus = mkCN (mkN041 "копринарка") ;
PrunellaModularis = mkCN (mkA076 "сивогуш") (mkN041 "завирушка") ;
LusciniaLuscinia = mkCN (mkA079 "северен") (mkN032 "славей") ;
ErithacusRubecula = mkCN (mkN041 "червеногръдка") ;
LusciniaSvecica = mkCN (mkN041 "синьогушка") ;
PhoenicurusPhoenicurus = mkCN (mkA078 "градски") (mkN041 "червеноопашка") ;
OenantheOenanthe = mkCN (mkA076 "сив") (mkN065 "каменарче") ;
SaxicollaRubetra = mkCN (mkA076 "ръждивогуш") (mkN065 "ливадарче") ;
TurdusPhilomelos = mkCN (mkA085 "поен") (mkN001 "дрозд") ;
TurdusIliacus = mkCN (mkA076 "беловежд") (mkN001 "дрозд") ;
TurdusViscivorus = mkCN (mkA076 "имелов") (mkN001 "дрозд") ;
TurdusPilaris = mkCN (mkA076 "хвойнов") (mkN001 "дрозд") ;
TurdusMerula = mkCN (mkN001 "кос") ;
SylviaBorin = mkCN (mkA078 "градски") (mkN065 "коприварче") ;
SylviaAtricapilla = mkCN (mkA081 "голям") (mkCN (mkA076 "черноглав") (mkCN (mkN065 "коприварче"))) ;
SylviaCurruca = mkCN (mkA080 "малък") (mkCN (mkA076 "белогуш") (mkCN (mkN065 "коприварче"))) ;
SylviaCommunis = mkCN (mkA081 "голям") (mkCN (mkA076 "белогуш") (mkCN (mkN065 "коприварче"))) ;
AcrocephalusSchoenobaenus = mkCN (mkA079 "крайбрежен") (mkN065 "шаварче") ;
AcrocephalusScirpaceus = mkCN (mkA079 "блатен") (mkN065 "шаварче") ;
AcrocephalusPalustris = mkCN (mkA079 "мочурен") (mkN065 "шаварче") ;
PhylloscopusTrochilus = mkCN (mkA076 "брезов") (mkN008 "певец") ;
PhylloscopusCollybita = mkCN (mkA076 "елов") (mkN008 "певец") ;
PhylloscopusSibilatrix = mkCN (mkA076 "буков") (mkN008 "певец") ;
HippolaisIcterina = mkCN (mkA078 "градски") (mkN014 "присмехулник") ;
RegulusRegulus = mkCN (mkA076 "жълтоглав") (mkN065 "кралче") ;
FicedulaHypoleuca = mkCN (mkA079 "жалобен") (mkN041 "мухоловка") ;
ParisMajor = mkCN (mkA081 "голям") (mkN007 "синигер") ;
ParisCaeruleus = mkCN (mkA086 "син") (mkN007 "синигер") ;
SittaEuropaea = mkCN (mkA078 "горски") (mkN041 "зидарка") ;
ParisCristatus = mkCN (mkA076 "качулат") (mkN007 "синигер") ;
ParusAter = mkCN (mkA079 "черен") (mkN007 "синигер") ;
ParusMontanus = mkCN (mkA076 "матовоглав") (mkN007 "синигер") ;
ParusPalustris = mkCN (mkA076 "лъскавоглав") (mkN007 "синигер") ;
AegithalosCaudatis = mkCN (mkA076 "дългоопашат") (mkN007 "синигер") ;
PanururBiarmicus = mkCN (mkA076 "мустакат") (mkN007 "синигер") ;
LaniusCollurio = mkCN (mkA076 "червеногърб") (mkN041 "сврачка") ;
GarrulusGlandarius = mkCN (mkN041 "сойка") ;
PicaPica = mkCN (mkN041 "сврака") ;
NucifragaCaryocatactes = mkCN (mkN041 "сокерица") ;
CorvusMonedula = mkCN (mkN041 "гарга") ;
CorvusFrugilegus = mkCN (mkA079 "посевен") (mkN041 "врана") ;
CorvusCorone = mkCN (mkA079 "черен") (mkN041 "врана") ;
CorvusCorax = mkCN (compoundN (mkN007 "гарван") (mkN031 "гробар")) ;
SturnusVulgaris = mkCN (mkA076 "обикновен") (mkN008 "скорец") ;
PasserDomesticus = mkCN (mkA079 "домашен") (mkN065 "врабче") ;
PasserMontanus = mkCN (mkA078 "полски") (mkN065 "врабче") ;
FringillaCoelebs = mkCN (mkA076 "обикновен") (mkN041 "чинка") ;
FringillaMontifringilla = mkCN (mkA078 "планински") (mkN041 "чинка") ;
CarpodacusErythrinus = mkCN (mkA076 "червен") (mkN041 "чинка") ;
CarduelisCannabina = mkCN (mkA076 "обикновен") (mkN065 "конопарче") ;
CarduelisFlammea = mkCN (mkA076 "брезов") (mkN047 "скатия") ;
CarduelisCarduelis = mkCN (mkN041 "кадънка") ;
CarduelisChloris = mkCN (mkN041 "зеленика") ;
CarduelisSpinus = mkCN (mkA076 "елхов") (mkN047 "скатия") ;
PyrrhulaPyrrhula = mkCN (mkN041 "червенушка") ;
LoxiaCurvirostra = mkCN (mkA076 "обикновен") (mkN041 "кръсточовка") ;
EmberizaSchoeniclus = mkCN (mkA076 "тръстиков") (mkN041 "овесарка") ;
PlectrophenaxNivalis = mkCN (mkA079 "снежен") (mkN041 "овесарка") ;
CalcariusLapponicus = mkCN (mkA078 "Лапландски") (mkN041 "овесарка") ;
EmberizaHortulana = mkCN (mkA078 "градински") (mkN041 "овесарка") ;
EmberizaCitrinella = mkCN (mkA076 "жълт") (mkN041 "овесарка") ;
}

158
examples/SUMO/BirdsEng.gf
View File

@@ -1,158 +0,0 @@
concrete BirdsEng of Birds = MergeEng ** open SyntaxEng, ParadigmsEng in {
flags
coding=utf8 ;
lin
GaviaStellata = mkCN (compoundN "red-throated" (mkN "loon")) ;
GaviaArctica = mkCN (compoundN "black-throated" (mkN "loon")) ;
PodicepsCristatus = mkCN (compoundN "great crested" (mkN "grebe")) ;
PodicepsAuritus = mkCN (compoundN "horned" (mkN "grebe")) ;
ArdeaCinerea = mkCN (compoundN "grey" (mkN "heron")) ;
BotaurusStellaris = mkCN (compoundN "eurasian" (mkN "bittern")) ;
CygnusOlor = mkCN (compoundN "mute" (mkN "swan")) ;
CygnusCygnus = mkCN (compoundN "whooper" (mkN "swan")) ;
AnserFabalis = mkCN (compoundN "bean" (mkN "goose")) ;
AnserAnser = mkCN (compoundN "greylag" (mkN "goose")) ;
BrantaCanadensis = mkCN (compoundN "canada" (mkN "goose")) ;
BrantaLeucopsis = mkCN (compoundN "barnacle" (mkN "goose")) ;
TadornaTadorna = mkCN (compoundN "common" (mkN "shelduck")) ;
AnasPlatyrhynchos = mkCN (mkN "mallard") ;
AnasPenelope = mkCN (compoundN "eurasian" (mkN "wigeon")) ;
AnasCrecca = mkCN (compoundN "common" (mkN "teal")) ;
BucephalaClangula = mkCN (compoundN "common" (mkN "goldeneye")) ;
ClangulaHyemalis = mkCN (compoundN "long-tailed" (mkN "duck")) ;
SomateriaMollissima = mkCN (compoundN "common" (mkN "eider")) ;
MergusMerganser = mkCN (compoundN "common" (mkN "merganser")) ;
MelanittaNigra = mkCN (compoundN "common" (mkN "scoter")) ;
HaliaeetusAlbicilla = mkCN (compoundN "white-tailed" (mkN "eagle")) ;
PandionHaliaetus = mkCN (mkN "osprey") ;
ButeoButeo = mkCN (compoundN "common" (mkN "buzzard")) ;
AccipiterGentilis = mkCN (compoundN "northern" (mkN "goshawk")) ;
AccipiterNisus = mkCN (compoundN "eurasian" (mkN "sparrowhawk")) ;
FalcoTinnunculus = mkCN (compoundN "common" (mkN "kestrel")) ;
LagopusLagopus = mkCN (compoundN "willow" (mkN "grouse")) ;
LagopusMutus = mkCN (compoundN "rock" (mkN "ptarmigan")) ;
TetraoUrogallus = mkCN (compoundN "western" (mkN "capercaillie")) ;
LyrurusTetrix = mkCN (compoundN "black" (mkN "grouse")) ;
PhasianusColchicus = mkCN (compoundN "common" (mkN "pheasant")) ;
RallusAquaticus = mkCN (compoundN "water" (mkN "rail")) ;
FulicaAtra = mkCN (compoundN "eurasian" (mkN "coot")) ;
GallinulaChloropus = mkCN (compoundN "common" (mkN "moorhen")) ;
GrusGrus = mkCN (compoundN "common" (mkN "crane")) ;
HaematopusOstralegus = mkCN (compoundN "eurasian" (mkN "oystercatcher")) ;
CharadriusHiaticula = mkCN (compoundN "ringed" (mkN "plover")) ;
PluvialisApricaria = mkCN (compoundN "eurasian Golden" (mkN "plover")) ;
VanellusVanellus = mkCN (compoundN "northern" (mkN "lapwing")) ;
CalidrisAlpina = mkCN (mkN "dunlin") ;
TringaGlareola = mkCN (compoundN "wood" (mkN "sandpiper")) ;
TringaOchropus = mkCN (compoundN "green" (mkN "sandpiper")) ;
NumeniusArquata = mkCN (compoundN "eurasian" (mkN "curlew")) ;
ScolopaxRusticola = mkCN (compoundN "eurasian" (mkN "woodcock")) ;
GallinagoGallinago = mkCN (compoundN "common" (mkN "snipe")) ;
LymnocryptesMinimus = mkCN (compoundN "jack" (mkN "snipe")) ;
TringaTotanus = mkCN (compoundN "common" (mkN "redshank")) ;
TringaErythropus = mkCN (compoundN "spotted" (mkN "redshank")) ;
TringaNebularia = mkCN (mkN "greenshank") ;
StercorariusParasiticus = mkCN (compoundN "parasitic" (mkN "jaeger")) ;
LarusRidibundus = mkCN (compoundN "black-headed" (mkN "gull")) ;
LarusCanus = mkCN (compoundN "common" (mkN "gull")) ;
LarusArgentatus = mkCN (compoundN "european Herring" (mkN "gull")) ;
LarusFuscus = mkCN (compoundN "lesser Black-backed" (mkN "gull")) ;
LarusMarinus = mkCN (compoundN "great Black-backed" (mkN "gull")) ;
SternaSandvicensis = mkCN (compoundN "sandwich" (mkN "tern")) ;
SternaCaspia = mkCN (compoundN "caspian" (mkN "tern")) ;
SternaHirundo = mkCN (compoundN "common" (mkN "tern")) ;
SternaParadisaea = mkCN (compoundN "arctic" (mkN "tern")) ;
AlcaTorda = mkCN (mkN "razorbill") ;
ColumbaOenas = mkCN (compoundN "stock" (mkN "pigeon")) ;
ColumbaPalumnbus = mkCN (compoundN "common Wood" (mkN "pigeon")) ;
StreptopeliaDecaocto = mkCN (compoundN "eurasian Collared" (mkN "dove")) ;
StrixAluco = mkCN (compoundN "tawny" (mkN "owl")) ;
StrixUralensis = mkCN (compoundN "ural" (mkN "owl")) ;
BuboBubo = mkCN (compoundN "eurasian" (mkN "eagle-owl")) ;
AsioFlammeus = mkCN (compoundN "short-eared" (mkN "owl")) ;
AsioOtus = mkCN (compoundN "long-eared" (mkN "owl")) ;
AegoliusFunereus = mkCN (compoundN "tengmalm's" (mkN "owl")) ;
GlaucidiumPasserinum = mkCN (compoundN "eurasian" (mkN "pygmy-owl")) ;
CuculusCanorus = mkCN (compoundN "common" (mkN "cuckoo")) ;
CaprimulgusEuropaeus = mkCN (compoundN "european" (mkN "nightjar")) ;
PicusViridis = mkCN (compoundN "green" (mkN "woodpecker")) ;
DryocopusMartius = mkCN (compoundN "black" (mkN "woodpecker")) ;
JynxTorquilla = mkCN (compoundN "eurasian" (mkN "wryneck")) ;
DendrocoposMajor = mkCN (compoundN "great Spotted" (mkN "woodpecker")) ;
DendrocoposMinor = mkCN (compoundN "lesser Spotted" (mkN "woodpecker")) ;
AlaudaArvensis = mkCN (mkN "skylark") ;
LullulaArborea = mkCN (mkN "woodlark") ;
ApusApus = mkCN (compoundN "common" (mkN "swift")) ;
HirundoRustica = mkCN (compoundN "barn" (mkN "swallow")) ;
DelichonUrbicum = mkCN (compoundN "common House" (mkN "martin")) ;
AnthusPratensis = mkCN (compoundN "meadow" (mkN "pipit")) ;
AnthusTrivialis = mkCN (compoundN "tree" (mkN "pipit")) ;
MotacillaAlba = mkCN (compoundN "white" (mkN "wagtail")) ;
MotacillaFlava = mkCN (compoundN "yellow" (mkN "wagtail")) ;
TroglodytesTroglodytes = mkCN (compoundN "winter" (mkN "wren")) ;
BombycillaGarrulus = mkCN (compoundN "bohemian" (mkN "waxwing")) ;
PrunellaModularis = mkCN (mkN "dunnock") ;
LusciniaLuscinia = mkCN (compoundN "thrush" (mkN "nightingale")) ;
ErithacusRubecula = mkCN (compoundN "european" (mkN "robin")) ;
LusciniaSvecica = mkCN (mkN "bluethroat") ;
PhoenicurusPhoenicurus = mkCN (compoundN "common" (mkN "redstart")) ;
OenantheOenanthe = mkCN (compoundN "northern" (mkN "wheatear")) ;
SaxicollaRubetra = mkCN (mkN "whinchat") ;
TurdusPhilomelos = mkCN (compoundN "song" (mkN "thrush")) ;
TurdusIliacus = mkCN (mkN "redwing") ;
TurdusViscivorus = mkCN (compoundN "mistle" (mkN "thrush")) ;
TurdusPilaris = mkCN (mkN "fieldfare") ;
TurdusMerula = mkCN (compoundN "common" (mkN "blackbird")) ;
SylviaBorin = mkCN (compoundN "garden" (mkN "warbler")) ;
SylviaAtricapilla = mkCN (mkN "blackcap") ;
SylviaCurruca = mkCN (compoundN "lesser" (mkN "whitethroat")) ;
SylviaCommunis = mkCN (mkN "whitethroat") ;
AcrocephalusSchoenobaenus = mkCN (compoundN "sedge" (mkN "warbler")) ;
AcrocephalusScirpaceus = mkCN (compoundN "eurasian Reed" (mkN "warbler")) ;
AcrocephalusPalustris = mkCN (compoundN "marsh" (mkN "warbler")) ;
PhylloscopusTrochilus = mkCN (compoundN "willow" (mkN "warbler")) ;
PhylloscopusCollybita = mkCN (mkN "chiffchaff") ;
PhylloscopusSibilatrix = mkCN (compoundN "wood" (mkN "warbler")) ;
HippolaisIcterina = mkCN (compoundN "icterine" (mkN "warbler")) ;
RegulusRegulus = mkCN (mkN "goldcrest") ;
FicedulaHypoleuca = mkCN (compoundN "european Pied" (mkN "flycatcher")) ;
ParisMajor = mkCN (compoundN "great" (mkN "tit")) ;
ParisCaeruleus = mkCN (compoundN "blue" (mkN "tit")) ;
SittaEuropaea = mkCN (compoundN "eurasian" (mkN "nuthatch")) ;
ParisCristatus = mkCN (compoundN "crested" (mkN "tit")) ;
ParusAter = mkCN (compoundN "coal" (mkN "tit")) ;
ParusMontanus = mkCN (compoundN "willow" (mkN "tit")) ;
ParusPalustris = mkCN (compoundN "marsh" (mkN "tit")) ;
AegithalosCaudatis = mkCN (compoundN "long-tailed" (mkN "tit")) ;
PanururBiarmicus = mkCN (compoundN "bearded" (mkN "reedling")) ;
LaniusCollurio = mkCN (compoundN "red-backed" (mkN "shrike")) ;
GarrulusGlandarius = mkCN (compoundN "eurasian" (mkN "jay")) ;
PicaPica = mkCN (compoundN "european" (mkN "magpie")) ;
NucifragaCaryocatactes = mkCN (compoundN "spotted" (mkN "nutcracker")) ;
CorvusMonedula = mkCN (mkN "jackdaw") ;
CorvusFrugilegus = mkCN (mkN "rook") ;
CorvusCorone = mkCN (compoundN "carrion" (mkN "crow")) ;
CorvusCorax = mkCN (compoundN "common" (mkN "raven")) ;
SturnusVulgaris = mkCN (compoundN "european" (mkN "starling")) ;
PasserDomesticus = mkCN (compoundN "house" (mkN "sparrow")) ;
PasserMontanus = mkCN (compoundN "eurasian Tree" (mkN "sparrow")) ;
FringillaCoelebs = mkCN (mkN "chaffinch") ;
FringillaMontifringilla = mkCN (mkN "brambling") ;
CarpodacusErythrinus = mkCN (compoundN "common" (mkN "rosefinch")) ;
CarduelisCannabina = mkCN (mkN "linnet") ;
CarduelisFlammea = mkCN (compoundN "common" (mkN "redpoll")) ;
CarduelisCarduelis = mkCN (compoundN "european" (mkN "goldfinch")) ;
CarduelisChloris = mkCN (compoundN "european" (mkN "greenfinch")) ;
CarduelisSpinus = mkCN (compoundN "eurasian" (mkN "siskin")) ;
PyrrhulaPyrrhula = mkCN (compoundN "eurasian" (mkN "bullfinch")) ;
LoxiaCurvirostra = mkCN (compoundN "common" (mkN "crossbill")) ;
EmberizaSchoeniclus = mkCN (compoundN "reed" (mkN "bunting")) ;
PlectrophenaxNivalis = mkCN (compoundN "snow" (mkN "bunting")) ;
CalcariusLapponicus = mkCN (compoundN "lapland" (mkN "longspur")) ;
EmberizaHortulana = mkCN (compoundN "ortolan" (mkN "bunting")) ;
EmberizaCitrinella = mkCN (mkN "yellowhammer") ;
}

157
examples/SUMO/BirdsSwe.gf
View File

@@ -1,157 +0,0 @@
concrete BirdsSwe of Birds = MergeSwe ** open SyntaxSwe, ParadigmsSwe, Prelude in {
flags
coding=utf8 ;
lin
GaviaStellata = mkCN (mkN "smålom") ;
GaviaArctica = mkCN (mkN "storlom") ;
PodicepsCristatus = mkCN (mkN "skäggdopping") ;
PodicepsAuritus = mkCN (mkN "svarthakedopping") ;
ArdeaCinerea = mkCN (mkN "gråhäger") ;
BotaurusStellaris = mkCN (mkN "rördrom") ;
CygnusOlor = mkCN (mkN "knölsvan") ;
CygnusCygnus = mkCN (mkN "sångsvan") ;
AnserFabalis = mkCN (mkN "sädgås") ;
AnserAnser = mkCN (mkN "grågås") ;
BrantaCanadensis = mkCN (mkN "kanadagås") ;
BrantaLeucopsis = mkCN (mkA "vitkindad") (mkN "gås") ; -- fixme vitkindada -> vitkindade
TadornaTadorna = mkCN (mkN "gravand") ;
AnasPlatyrhynchos = mkCN (mkN "gräsand") ;
AnasPenelope = mkCN (mkN "bläsand") ;
AnasCrecca = mkCN (mkN "kricka") ;
BucephalaClangula = mkCN (mkN "knipa") ;
ClangulaHyemalis = mkCN (mkN "alfågel") ;
SomateriaMollissima = mkCN (mkN "ejder") ;
MergusMerganser = mkCN (mkN "storskrake") ;
MelanittaNigra = mkCN (mkN "sjöorre") ;
HaliaeetusAlbicilla = mkCN (mkN "havsörn") ;
PandionHaliaetus = mkCN (mkN "fiskgjuse") ;
ButeoButeo = mkCN (mkN "ormvråk") ;
AccipiterGentilis = mkCN (mkN "duvhök") ;
AccipiterNisus = mkCN (mkN "sparvhök") ;
FalcoTinnunculus = mkCN (mkN "tornfalk") ;
LagopusLagopus = mkCN (mkN "dalripa") ;
LagopusMutus = mkCN (mkN "fjällripa") ;
TetraoUrogallus = mkCN (mkN "tjäder") ;
LyrurusTetrix = mkCN (mkN "orre") ;
PhasianusColchicus = mkCN (mkN "fasan") ;
RallusAquaticus = mkCN (mkN "vattenral") ;
FulicaAtra = mkCN (mkN "sothöna") ;
GallinulaChloropus = mkCN (mkN "rörhöna") ;
GrusGrus = mkCN (mkN "trana") ;
HaematopusOstralegus = mkCN (mkN "strandskata") ;
CharadriusHiaticula = mkCN (mkA "större") (mkN "strandpipare" utrum) ;
PluvialisApricaria = mkCN (mkN "ljungpipare") ;
VanellusVanellus = mkCN (mkN "tofsvipa") ;
CalidrisAlpina = mkCN (mkN "kärrsnäppa") ;
TringaGlareola = mkCN (mkN "grönbena") ;
TringaOchropus = mkCN (mkN "skogssnäppa") ;
NumeniusArquata = mkCN (mkN "storspov") ;
ScolopaxRusticola = mkCN (mkN "morkulla") ;
GallinagoGallinago = mkCN (mkN "enkelbeckasin") ;
LymnocryptesMinimus = mkCN (mkN "dvärgbeckasin") ;
TringaTotanus = mkCN (mkN "rödbena") ;
TringaErythropus = mkCN (mkN "svartsnäppa") ;
TringaNebularia = mkCN (mkN "gluttsnäppa") ;
StercorariusParasiticus = mkCN (mkN "kustlabb") ;
LarusRidibundus = mkCN (mkN "skrattmås") ;
LarusCanus = mkCN (mkN "fiskmås") ;
LarusArgentatus = mkCN (mkN "gråtrut") ;
LarusFuscus = mkCN (mkN "silltrut") ;
LarusMarinus = mkCN (mkN "havstrut") ;
SternaSandvicensis = mkCN (mkA "kentsk") (mkN "tärna") ;
SternaCaspia = mkCN (mkN "skräntärna") ;
SternaHirundo = mkCN (mkN "fisktärna") ;
SternaParadisaea = mkCN (mkN "silvertärna") ;
AlcaTorda = mkCN (mkN "tordmule") ;
ColumbaOenas = mkCN (mkN "skogsduva") ;
ColumbaPalumnbus = mkCN (mkN "ringduva") ;
StreptopeliaDecaocto = mkCN (mkN "turkduva") ;
StrixAluco = mkCN (mkN "kattuggla") ;
StrixUralensis = mkCN (mkN "slaguggla") ;
BuboBubo = mkCN (mkN "berguv") ;
AsioFlammeus = mkCN (mkN "jorduggla") ;
AsioOtus = mkCN (mkN "hornuggla") ;
AegoliusFunereus = mkCN (mkN "pärluggla") ;
GlaucidiumPasserinum = mkCN (mkN "sparvuggla") ;
CuculusCanorus = mkCN (mkN "gök") ;
CaprimulgusEuropaeus = mkCN (mkN "nattskärra") ;
PicusViridis = mkCN (mkN "gröngöling") ;
DryocopusMartius = mkCN (mkN "spillkråka") ;
JynxTorquilla = mkCN (mkN "göktyta") ;
DendrocoposMajor = mkCN (lin AP {s=(comparAP (irregA "stor" "större" "störst")).s; isPre=True}) (mkN "hackspett") ;
DendrocoposMinor = mkCN (lin AP {s=(comparAP (mkA "liten" "litet" "lilla" "små" "mindre" "minst" "minsta")).s; isPre=True}) (mkN "hackspett") ;
AlaudaArvensis = mkCN (mkN "sånglärka") ;
LullulaArborea = mkCN (mkN "trädlärka") ;
ApusApus = mkCN (mkN "tornseglare") ;
HirundoRustica = mkCN (mkN "ladusvala") ;
DelichonUrbicum = mkCN (mkN "hussvala") ;
AnthusPratensis = mkCN (mkN "ängspiplärka") ;
AnthusTrivialis = mkCN (mkN "trädpiplärka") ;
MotacillaAlba = mkCN (mkN "sädesärla") ;
MotacillaFlava = mkCN (mkN "gulärla") ;
TroglodytesTroglodytes = mkCN (mkN "gärdsmyg") ;
BombycillaGarrulus = mkCN (mkN "sidensvans") ;
PrunellaModularis = mkCN (mkN "järnsparv") ;
LusciniaLuscinia = mkCN (mkN "näktergal") ;
ErithacusRubecula = mkCN (mkN "rödhake") ;
LusciniaSvecica = mkCN (mkN "blåhake") ;
PhoenicurusPhoenicurus = mkCN (mkN "rödstjärt") ;
OenantheOenanthe = mkCN (mkN "stenskvätta") ;
SaxicollaRubetra = mkCN (mkN "buskskvätta") ;
TurdusPhilomelos = mkCN (mkN "taltrast") ;
TurdusIliacus = mkCN (mkN "rödvingetrast") ;
TurdusViscivorus = mkCN (mkN "dubbeltrast") ;
TurdusPilaris = mkCN (mkN "björktrast") ;
TurdusMerula = mkCN (mkN "koltrast") ;
SylviaBorin = mkCN (mkN "trädgårdssångare") ;
SylviaAtricapilla = mkCN (mkN "svarthätta") ;
SylviaCurruca = mkCN (mkN "ärtsångare") ;
SylviaCommunis = mkCN (mkN "törnsångare") ;
AcrocephalusSchoenobaenus = mkCN (mkN "sävsångare") ;
AcrocephalusScirpaceus = mkCN (mkN "rörsångare") ;
AcrocephalusPalustris = mkCN (mkN "kärrsångare") ;
PhylloscopusTrochilus = mkCN (mkN "lövsångare") ;
PhylloscopusCollybita = mkCN (mkN "gransångare") ;
PhylloscopusSibilatrix = mkCN (mkN "grönsångare") ;
HippolaisIcterina = mkCN (mkN "härmsångare") ;
RegulusRegulus = mkCN (mkN "kungsfågel") ;
FicedulaHypoleuca = mkCN (mkA "svartvit") (mkN "flugsnappare" utrum) ;
ParisMajor = mkCN (mkN "talgoxe" utrum) ;
ParisCaeruleus = mkCN (mkN "blåmes") ;
SittaEuropaea = mkCN (mkN "nötväcka") ;
ParisCristatus = mkCN (mkN "tofsmes") ;
ParusAter = mkCN (mkN "svartmes") ;
ParusMontanus = mkCN (mkN "talltita") ;
ParusPalustris = mkCN (mkN "entita") ;
AegithalosCaudatis = mkCN (mkN "stjärtmes") ;
PanururBiarmicus = mkCN (mkN "skäggmes") ;
LaniusCollurio = mkCN (mkN "törnskata") ;
GarrulusGlandarius = mkCN (mkN "nötskrika") ;
PicaPica = mkCN (mkN "skata") ;
NucifragaCaryocatactes = mkCN (mkN "nötkråka") ;
CorvusMonedula = mkCN (mkN "kaja") ;
CorvusFrugilegus = mkCN (mkN "råka") ;
CorvusCorone = mkCN (mkN "kråka") ;
CorvusCorax = mkCN (mkN "korp") ;
SturnusVulgaris = mkCN (mkN "stare") ;
PasserDomesticus = mkCN (mkN "gråsparv") ;
PasserMontanus = mkCN (mkN "pilfink") ;
FringillaCoelebs = mkCN (mkN "bofink") ;
FringillaMontifringilla = mkCN (mkN "bergfink") ;
CarpodacusErythrinus = mkCN (mkN "rosenfink") ;
CarduelisCannabina = mkCN (mkN "hämpling") ;
CarduelisFlammea = mkCN (mkN "gråsiska") ;
CarduelisCarduelis = mkCN (mkN "steglits") ;
CarduelisChloris = mkCN (mkN "grönfink") ;
CarduelisSpinus = mkCN (mkN "grönsiska") ;
PyrrhulaPyrrhula = mkCN (mkN "domherre") ;
LoxiaCurvirostra = mkCN (lin AP {s=(comparAP (mkA "liten" "litet" "lilla" "små" "mindre" "minst" "minsta")).s; isPre=True}) (mkN "korsnäbb") ;
EmberizaSchoeniclus = mkCN (mkN "sävsparv") ;
PlectrophenaxNivalis = mkCN (mkN "snösparv") ;
CalcariusLapponicus = mkCN (mkN "lappsparv") ;
EmberizaHortulana = mkCN (mkN "ortolansparv") ;
EmberizaCitrinella = mkCN (mkN "gulsparv") ;
}

157
examples/SUMO/Communications.gf
View File

@@ -1,157 +0,0 @@
abstract Communications = MidLevelOntology, Geography ** {
-- An AMRadioStation is an
-- engineeringSubcomponent of an AMRadioSystem.
fun AMRadioStation : Class ;
fun AMRadioStation_Class : SubClass AMRadioStation RadioStation ;
-- An AMRadioSystem consists of Radios,
-- AMRadioStations, and other components that work together to make
-- AM radio broadcasting possible in a given area.
fun AMRadioSystem : Class ;
fun AMRadioSystem_Class : SubClass AMRadioSystem RadioSystem ;
-- An ArtificialSatellite is a Device
-- that orbits the earth in space and performs various functions such as
-- aiding in communication, photographing the earth's surface, and others.
fun ArtificialSatellite : Class ;
fun ArtificialSatellite_Class : SubClass ArtificialSatellite (both EngineeringComponent Satellite) ;
-- A BroadcastingStation is
-- an engineeringSubcomponent of either a TelevisionSystem or
-- a RadioStation.
fun BroadcastingStation : Class ;
fun BroadcastingStation_Class : SubClass BroadcastingStation (both CommunicationDevice (both EngineeringComponent StationaryArtifact)) ;
-- A CableTelevisionSystem
-- is a CommunicationSystem for cable television.
fun CableTelevisionSystem : Class ;
fun CableTelevisionSystem_Class : SubClass CableTelevisionSystem CommunicationSystem ;
-- Relatively low power broadcasting
-- devices designed for voice communication among specialized groups
-- in which each receiver also has the power to transmit, unlike
-- broadcast radio where most components transmitting or receiving on
-- a given frequency or set of frequencies are receivers only. This
-- includes unlicensed walkie_talkies, public safety radios, military
-- communication systems and CB radios.
fun CommunicationRadio : Class ;
fun CommunicationRadio_Class : SubClass CommunicationRadio CommunicationDevice ;
-- A CommunicationSatellite is an
-- ArtificialSatellite that serves as one engineeringSubcomponent of a
-- CommunicationSystem.
fun CommunicationSatellite : Class ;
fun CommunicationSatellite_Class : SubClass CommunicationSatellite (both ArtificialSatellite CommunicationDevice) ;
-- An Eutelsat is one type of
-- CommunicationSatellite.
fun Eutelsat : Class ;
fun Eutelsat_Class : SubClass Eutelsat CommunicationSatellite ;
-- A FMRadioStation is an
-- engineeringSubcomponent of an FMRadioSystem.
fun FMRadioStation : Class ;
fun FMRadioStation_Class : SubClass FMRadioStation RadioStation ;
-- A FMRadioSystem consists of Radios,
-- FMRadioStations, and other components that work together to make
-- FM radio broadcasting possible in a given area.
fun FMRadioSystem : Class ;
fun FMRadioSystem_Class : SubClass FMRadioSystem RadioSystem ;
-- An Inmarsat is one type of
-- CommunicationSatellite.
fun Inmarsat : Class ;
fun Inmarsat_Class : SubClass Inmarsat CommunicationSatellite ;
-- An Intelsat is one type of
-- CommunicationSatellite.
fun Intelsat : Class ;
fun Intelsat_Class : SubClass Intelsat CommunicationSatellite ;
-- The Internet is a CommunicationSystem
-- for the rapid delivery of information between computers.
fun Internet : Ind CommunicationSystem ;
-- An InternetServiceProvider serves as an engineeringSubcomponent of
-- the Internet for a given area.
fun InternetServiceProvider : Class ;
fun InternetServiceProvider_Class : SubClass InternetServiceProvider CommunicationSystem ;
-- An InternetUser is an individual who
-- uses the Internet.
fun InternetUser : Ind SocialRole ;
-- An Intersputnik is one type of
-- CommunicationSatellite.
fun Intersputnik : Class ;
fun Intersputnik_Class : SubClass Intersputnik CommunicationSatellite ;
-- A MainTelephoneLine is one
-- engineeringSubcomponent of a TelephoneSystem used for voice communication
-- or computer data transfer.
fun MainTelephoneLine : Class ;
fun MainTelephoneLine_Class : SubClass MainTelephoneLine CommunicationDevice ;
-- A Telephone that can be used without
-- connection to a MainTelephoneLine.
fun MobileCellPhone : Class ;
fun MobileCellPhone_Class : SubClass MobileCellPhone Telephone ;
-- An Orbita is one type of
-- CommunicationSatellite.
fun Orbita : Class ;
fun Orbita_Class : SubClass Orbita CommunicationSatellite ;
-- A RadioStation is an
-- engineeringSubcomponent of a RadioSystem.
fun RadioStation : Class ;
fun RadioStation_Class : SubClass RadioStation BroadcastingStation ;
-- A RadioSystem consists of Radios,
-- RadioStations, and other components that work together to make
-- radio broadcasting possible in a given area.
fun RadioSystem : Class ;
fun RadioSystem_Class : SubClass RadioSystem CommunicationSystem ;
-- A ShortwaveRadioStation
-- is an engineeringSubcomponent of a ShortwaveRadioSystem.
fun ShortwaveRadioStation : Class ;
fun ShortwaveRadioStation_Class : SubClass ShortwaveRadioStation RadioStation ;
-- A ShortwaveRadioSystem consists
-- of Radios, ShortwaveRadioStations, and other components that work
-- together to make shortwave radio broadcasting possible in a given area.
fun ShortwaveRadioSystem : Class ;
fun ShortwaveRadioSystem_Class : SubClass ShortwaveRadioSystem RadioSystem ;
-- A TelephoneSystem consists of a complete
-- interconnection of Telephones, MainTelephoneLines, and other components
-- that work together to make telephonic communication possible from point to
-- point in a given area.
fun TelephoneSystem : Class ;
fun TelephoneSystem_Class : SubClass TelephoneSystem CommunicationSystem ;
-- A TelevisionStation is an
-- engineeringSubcomponent of a TelevisionSystem.
fun TelevisionStation : Class ;
fun TelevisionStation_Class : SubClass TelevisionStation BroadcastingStation ;
-- A system for Broadcasting and
-- receiving television signals.
fun TelevisionSystem : Class ;
fun TelevisionSystem_Class : SubClass TelevisionSystem CommunicationSystem ;
-- The expression
-- (communicationSatelliteForArea ?AREA ?SATELLITE ?INTEGER) means that
-- ?INTEGER number of CommunicationSatellites of the type ?SATELLITE serve
-- as an engineeringSubcomponent of a TelephoneSystem of the GeopoliticalArea ?AREA.
fun communicationSatelliteForArea: El GeopoliticalArea -> Desc Satellite -> El Integer -> Formula ;-- replaced--
-- (internetCountryCode ?AREA ?CODE)
-- relates a GeopoliticalArea to the SymbolicString ?CODE used to
-- identify the ?AREA on internet websites.
fun internetCountryCode : El GeopoliticalArea -> El SymbolicString -> Formula ;
}

2685
examples/SUMO/CountriesAndRegions.gf
View File

File diff suppressed because it is too large Load Diff

848
examples/SUMO/CountriesAndRegionsEng.gf
View File

@@ -1,848 +0,0 @@
--# -path=.:englishExtended
concrete CountriesAndRegionsEng of CountriesAndRegions = MidLevelOntologyEng ** open ParadigmsEng,NounEng in {
lin
NewJersey = UsePN (mkPN "New Jersey") ;
NewYorkState = UsePN (mkPN "New York") ;
Texas = UsePN (mkPN "Texas") ;
AdanaTurkey = UsePN (mkPN "Adana") ;
AddisAbabaEthiopia = UsePN (mkPN "Addis Ababa") ;
AdenYemen = UsePN (mkPN "Aden") ;
AdoraWestBank = UsePN (mkPN "Adora") ;
AfulaIsrael = UsePN (mkPN "Afula") ;
AgriTurkey = UsePN (mkPN "Agri") ;
AinDeflaAlgeria = UsePN (mkPN "Ain Defla") ;
AinElHajarAlgeria = UsePN (mkPN "Ain el Hajar") ;
AjaccioFrance = UsePN (mkPN "Ajaccio") ;
AlBalamandLebanon = UsePN (mkPN "Al-Balamand") ;
AleiSinaiGazaStrip = UsePN (mkPN "Alei Sinai") ;
AleiZahavWestBank = UsePN (mkPN "Alei Zahav") ;
AleyLebanon = UsePN (mkPN "Aley") ;
AlgiersAlgeria = UsePN (mkPN "Algiers") ;
AlkhanYurtRussia = UsePN (mkPN "Alkhan-Yurt") ;
AlonMorehWestBank = UsePN (mkPN "Alon Moreh") ;
AmbonIndonesia = UsePN (mkPN "Ambon") ;
AmmanJordan = UsePN (mkPN "Amman") ;
AnNuwaydiratBahrain = UsePN (mkPN "An Nuwaydirat") ;
AndeanSpain = UsePN (mkPN "Andean") ;
AngkorWatCambodia = UsePN (mkPN "Angkor Wat") ;
AnkaraTurkey = UsePN (mkPN "Ankara") ;
AntalyaTurkey = UsePN (mkPN "Antalya") ;
AntioquiaColombia = UsePN (mkPN "Antioquia") ;
AntwerpBelgium = UsePN (mkPN "Antwerp") ;
ApumiracPeru = UsePN (mkPN "Apumirac") ;
ApureVenezuela = UsePN (mkPN "Apure") ;
AraucaColombia = UsePN (mkPN "Arauca") ;
ArgunRussia = UsePN (mkPN "Argun") ;
ArielWestBank = UsePN (mkPN "Ariel") ;
ArmaghNorthernIreland = UsePN (mkPN "Armagh") ;
ArzewAlgeria = UsePN (mkPN "Arzew") ;
AshdodIsrael = UsePN (mkPN "Ashdod") ;
AskelonIsrael = UsePN (mkPN "Askelon") ;
AsmaraEritrea = UsePN (mkPN "Asmara") ;
AssamIndia = UsePN (mkPN "Assam") ;
AswanEgypt = UsePN (mkPN "Aswan") ;
AsyutEgypt = UsePN (mkPN "Asyut") ;
AthensGreece = UsePN (mkPN "Athens") ;
AtrushIraq = UsePN (mkPN "Atrush") ;
AtzmonaGazaStrip = UsePN (mkPN "Atzmona") ;
AvneiHefetzIsrael = UsePN (mkPN "Avnei Hefetz") ;
AyacuchoPeru = UsePN (mkPN "Ayacucho") ;
AzorIsrael = UsePN (mkPN "Azor") ;
BadVilbelGermany = UsePN (mkPN "Bad Vilbel") ;
BaghdadIraq = UsePN (mkPN "Baghdad") ;
BagreColombia = UsePN (mkPN "Bagre") ;
Bahamas = UsePN (mkPN "Bahamas") ;
BahawalpurPakistan = UsePN (mkPN "Bahawalpur") ;
BakaAlGarbiyehIsrael = UsePN (mkPN "Baka al-Garbiyeh") ;
BakkaAlSharkiyaWestBank = UsePN (mkPN "Bakka al-Sharkiya") ;
BakuAzerbaijan = UsePN (mkPN "Baku") ;
BaleEthiopia = UsePN (mkPN "Bale") ;
BanbridgeNorthernIreland = UsePN (mkPN "Banbridge") ;
BangkokThailand = UsePN (mkPN "Bangkok") ;
BangorNorthernIreland = UsePN (mkPN "Bangor") ;
BanguiCentralAfricanRepublic = UsePN (mkPN "Bangui") ;
BarcelonaSpain = UsePN (mkPN "Barcelona") ;
BarkeoCambodia = UsePN (mkPN "Barkeo") ;
BarrancabermejaColombia = UsePN (mkPN "Barrancabermeja") ;
BasraIsrael = UsePN (mkPN "Basra") ;
BatYamIsrael = UsePN (mkPN "Bat Yam") ;
BatmanTurkey = UsePN (mkPN "Batman") ;
BeasainSpain = UsePN (mkPN "Beasain") ;
BeErShevaIsrael = UsePN (mkPN "Be'er Sheva") ;
BeirutLebanon = UsePN (mkPN "Beirut") ;
BeitElWestBank = UsePN (mkPN "Beit El") ;
BeitHaggaiWestBank = UsePN (mkPN "Beit Haggai") ;
BeitSahurWestBank = UsePN (mkPN "Beit Sahur") ;
BeitSheAnIsrael = UsePN (mkPN "Beit She'an") ;
BeitShemeshIsrael = UsePN (mkPN "Beit Shemesh") ;
BeledweyneSomalia = UsePN (mkPN "Beledweyne") ;
BelfastNorthernIreland = UsePN (mkPN "Belfast") ;
BelgradeSerbiaAndMontenegro = UsePN (mkPN "Belgrade") ;
BerlinGermany = UsePN (mkPN "Berlin") ;
BetLeHiyehGazaStrip = UsePN (mkPN "Bet LeHiyeh") ;
BetLidJunctionIsrael = UsePN (mkPN "Bet Lid Junction") ;
BethElIsrael = UsePN (mkPN "Beth El") ;
BethlehemWestBank = UsePN (mkPN "Bethlehem") ;
BidyaWestBank = UsePN (mkPN "Bidya") ;
BilbaoSpain = UsePN (mkPN "Bilbao") ;
BillabonaSpain = UsePN (mkPN "Billabona") ;
BinyaminaIsrael = UsePN (mkPN "Binyamina") ;
BKaotWestBank = UsePN (mkPN "B'kaot") ;
BneiAyishIsrael = UsePN (mkPN "Bnei Ayish") ;
BogotaColombia = UsePN (mkPN "Bogota") ;
BolognaItaly = UsePN (mkPN "Bologna") ;
BonnGermany = UsePN (mkPN "Bonn") ;
BosphorousStraitsTurkey = UsePN (mkPN "BosphorousStraits") ;
BouiraAlgeria = UsePN (mkPN "Bouira") ;
BouzeGueneAlgeria = UsePN (mkPN "Bouze-guene") ;
BrusselsBelgium = UsePN (mkPN "Brussels") ;
BucaramangaColombia = UsePN (mkPN "Bucaramanga") ;
BucharestRomania = UsePN (mkPN "Bucharest") ;
BuenosAiresArgentina = UsePN (mkPN "Buenos Aires") ;
BuinakskRussia = UsePN (mkPN "Buinaksk") ;
Burma = UsePN (mkPN "Burma") ;
BwindiforestUganda = UsePN (mkPN "Bwindi forest") ;
CabindaAngola = UsePN (mkPN "Cabinda") ;
CaglayanTurkey = UsePN (mkPN "Caglayan") ;
CairoEgypt = UsePN (mkPN "Cairo") ;
CalcuttaIndia = UsePN (mkPN "Calcutta") ;
CaliColombia = UsePN (mkPN "Cali") ;
CampZamaJapan = UsePN (mkPN "Camp Zama") ;
CankiriTurkey = UsePN (mkPN "Cankiri") ;
CapeTownSouthAfrica = UsePN (mkPN "Cape Town") ;
CaritasPolandChechnya = UsePN (mkPN "Caritas Poland") ;
CarmelIsrael = UsePN (mkPN "Carmel") ;
CarmenDeBolivarColombia = UsePN (mkPN "Carmen de Bolivar") ;
CarrejonColombia = UsePN (mkPN "Carrejon") ;
ChamanPakistan = UsePN (mkPN "Chaman") ;
ChararESharifIndia = UsePN (mkPN "Charar-e-Sharif") ;
CharsaadaPakistan = UsePN (mkPN "Charsaada") ;
ChernoRechyeRussia = UsePN (mkPN "Cherno-rechye") ;
ChicagoUnitedStates = UsePN (mkPN "Chicago") ;
ChisimayuSomalia = UsePN (mkPN "Chisimayu") ;
ChittagongBangladesh = UsePN (mkPN "Chittagong") ;
ChobaAngola = UsePN (mkPN "Choba") ;
ChocoColombia = UsePN (mkPN "Choco") ;
ChorrosQueroVenezuela = UsePN (mkPN "Chorros-quero") ;
ClarkAirbasePhilippines = UsePN (mkPN "Clark Airbase") ;
CoimbatoreIndia = UsePN (mkPN "Coimbatore") ;
CologneGermany = UsePN (mkPN "Cologne") ;
ColombiaCityColombia = UsePN (mkPN "Colombia City") ;
ColombiaPanama = UsePN (mkPN "Colombia") ;
ColomboSriLanka = UsePN (mkPN "Colombo") ;
ComayaguaHonduras = UsePN (mkPN "Comayagua") ;
Congo = UsePN (mkPN "Congo") ;
CopacaBanaCuba = UsePN (mkPN "Copaca-bana") ;
CopenhagenDenmark = UsePN (mkPN "Copenhagen") ;
CorsicaFrance = UsePN (mkPN "Corsica") ;
CorteFrance = UsePN (mkPN "Corte") ;
CorumTurkey = UsePN (mkPN "Corum") ;
CundiNamarcaColombia = UsePN (mkPN "Cundi-namarca") ;
CupiaguaColombia = UsePN (mkPN "Cupiagua") ;
CuzcoPeru = UsePN (mkPN "Cuzco") ;
DagestanRussia = UsePN (mkPN "Dagestan") ;
DahukIraq = UsePN (mkPN "Dahuk") ;
DangDistrictNepal = UsePN (mkPN "Dang district") ;
DarEsSalaAmTanzania = UsePN (mkPN "Dar es Sala'am") ;
DarvazTajikistan = UsePN (mkPN "Darvaz") ;
DebaSpain = UsePN (mkPN "Deba") ;
DelhiIndia = UsePN (mkPN "Delhi") ;
DhahranSaudiArabia = UsePN (mkPN "Dhahran") ;
DhakaBangladesh = UsePN (mkPN "Dhaka") ;
DinanFrance = UsePN (mkPN "Dinan") ;
DirNaballahWestBank = UsePN (mkPN "Dir Naballah") ;
DireDawaEthiopia = UsePN (mkPN "Dire Dawa") ;
DistrictOfMansehraPakistan = UsePN (mkPN "district of Mansehra") ;
DjakashariGeorgia = UsePN (mkPN "Djakashari") ;
DjerbaTunisia = UsePN (mkPN "Djerba") ;
DodaIndia = UsePN (mkPN "Doda") ;
DortmundGermany = UsePN (mkPN "Dortmund") ;
DublinIreland = UsePN (mkPN "Dublin") ;
DuesseldorfGermany = UsePN (mkPN "Duesseldorf") ;
DugitGazaStrip = UsePN (mkPN "Dugit") ;
DurangoSpain = UsePN (mkPN "Durango") ;
DushanbeTajikistan = UsePN (mkPN "Dushanbe") ;
DushanbeAirportTajikistan = UsePN (mkPN "Dushanbe airport") ;
DushanbeGarmTajikistan = UsePN (mkPN "Dushanbe Garm") ;
EastJerusalemIsrael = UsePN (mkPN "East Jerusalem") ;
EfratWestBank = UsePN (mkPN "Efrat") ;
EilatIsrael = UsePN (mkPN "Eilat") ;
EinavWestBank = UsePN (mkPN "Einav") ;
ElBagreColombia = UsePN (mkPN "El Bagre") ;
ElBirehWestBank = UsePN (mkPN "El Bireh") ;
ElPlayonColombia = UsePN (mkPN "El Playon") ;
ElRipialApureVenezuela = UsePN (mkPN "El Ripial Apure") ;
ElayoSomalia = UsePN (mkPN "Elayo") ;
ElAzzariyaWestBank = UsePN (mkPN "el-Azzariya") ;
EleiSinaiGazaStrip = UsePN (mkPN "Elei Sinai") ;
EmmanuelWestBank = UsePN (mkPN "Emmanuel") ;
ErezGazaStrip = UsePN (mkPN "Erez") ;
FethiyeAndMarmarisTurkey = UsePN (mkPN "Fethiye and Marmaris") ;
FloridaUnitedStates = UsePN (mkPN "Florida") ;
FormequeColombia = UsePN (mkPN "Formeque") ;
FrankfurtGermany = UsePN (mkPN "Frankfurt") ;
FrenchHillIsrael = UsePN (mkPN "French Hill") ;
FuengirolaSpain = UsePN (mkPN "Fuengirola") ;
FusagasusaColombia = UsePN (mkPN "Fusagasusa") ;
GaliAbkhaziaGeorgia = UsePN (mkPN "Gali Abkhazia") ;
GanimWestBank = UsePN (mkPN "Ganim") ;
GashuriIsrael = UsePN (mkPN "Gashuri") ;
GeneralSantosPhilippines = UsePN (mkPN "General Santos") ;
GenevaSwitzerland = UsePN (mkPN "Geneva") ;
Georgia = UsePN (mkPN "Georgia") ;
GetxoSpain = UsePN (mkPN "Getxo") ;
GhalebiehIraq = UsePN (mkPN "Ghalebieh") ;
GhaziabadUttarPradeshIndia = UsePN (mkPN "Ghaziabad Uttar Pradesh") ;
GiloIsrael = UsePN (mkPN "Gilo") ;
GivatZeEvWestBank = UsePN (mkPN "Givat Ze'ev") ;
GizaEgypt = UsePN (mkPN "Giza") ;
GonegalleSriLanka = UsePN (mkPN "Gonegalle") ;
GranadaSpain = UsePN (mkPN "Granada") ;
GrazAustria = UsePN (mkPN "Graz") ;
GroznyChechnya = UsePN (mkPN "Grozny") ;
GuilinChina = UsePN (mkPN "Guilin") ;
GujaratIndia = UsePN (mkPN "Gujarat") ;
GushEtzionWestBank = UsePN (mkPN "Gush Etzion") ;
GushKatifGazaStrip = UsePN (mkPN "Gush Katif") ;
HaderaIsrael = UsePN (mkPN "Hadera") ;
HaifaIsrael = UsePN (mkPN "Haifa") ;
HamburgGermany = UsePN (mkPN "Hamburg") ;
HamisMiliyanaAlgeria = UsePN (mkPN "Hamis Miliyana") ;
HamraWestBank = UsePN (mkPN "Hamra") ;
HannoverGermany = UsePN (mkPN "Hannover") ;
HarBrachaWestBank = UsePN (mkPN "Har Bracha") ;
HarerEthiopia = UsePN (mkPN "Harer") ;
HavanaCuba = UsePN (mkPN "Havana") ;
HawanaIraq = UsePN (mkPN "Hawana") ;
HeartAfghanistan = UsePN (mkPN "Heart") ;
HebronWestBank = UsePN (mkPN "Hebron") ;
HermeshIsrael = UsePN (mkPN "Hermesh") ;
HernaniSpain = UsePN (mkPN "Hernani") ;
HerzliyaIsrael = UsePN (mkPN "Herzliya") ;
HilversumNetherlands = UsePN (mkPN "Hilversum") ;
HizmaWestBank = UsePN (mkPN "Hizma") ;
HodayaJunctionIsrael = UsePN (mkPN "Hodaya Junction") ;
HolonJunctionIsrael = UsePN (mkPN "Holon Junction") ;
HuallgaPeru = UsePN (mkPN "Huallga") ;
HurghadaEgypt = UsePN (mkPN "Hurghada") ;
HyderabadPakistan = UsePN (mkPN "Hyderabad") ;
IbsrilIraq = UsePN (mkPN "Ibsril") ;
IncirlikAirbaseTurkey = UsePN (mkPN "Incirlik Airbase") ;
IpilPhilippines = UsePN (mkPN "Ipil") ;
IrbilIraq = UsePN (mkPN "Irbil") ;
IslamabadPakistan = UsePN (mkPN "Islamabad") ;
IslandOfBaliIndonesia = UsePN (mkPN "Island of Bali") ;
IstanbulTurkey = UsePN (mkPN "Istanbul") ;
ItamarWestBank = UsePN (mkPN "Itamar") ;
IzmirTurkey = UsePN (mkPN "Izmir") ;
JaffaIsrael = UsePN (mkPN "Jaffa") ;
JaffnaSriLanka = UsePN (mkPN "Jaffna") ;
JakartaIndonesia = UsePN (mkPN "Jakarta") ;
JalahIndia = UsePN (mkPN "Jalah") ;
JalpaiguriRailwayStationIndia = UsePN (mkPN "Jalpaiguri Railway Station") ;
JammuIndia = UsePN (mkPN "Jammu") ;
JangasPeru = UsePN (mkPN "Jangas") ;
JeninWestBank = UsePN (mkPN "Jenin") ;
JerusalemIsrael = UsePN (mkPN "Jerusalem") ;
JMainWestBank = UsePN (mkPN "J'main") ;
JohannesburgSouthAfrica = UsePN (mkPN "Johannesburg") ;
JoloPhilippines = UsePN (mkPN "Jolo") ;
JubialSaudiArabia = UsePN (mkPN "Jubial") ;
JullundurIndia = UsePN (mkPN "Jullundur") ;
KabacanPhilippines = UsePN (mkPN "Kabacan") ;
KabulAfghanistan = UsePN (mkPN "Kabul") ;
KafrAkabWestBank = UsePN (mkPN "Kafr Akab") ;
KafrIdnaWestBank = UsePN (mkPN "Kafr Idna") ;
KalkilyaWestBank = UsePN (mkPN "Kalkilya") ;
KalmunaiSriLanka = UsePN (mkPN "Kalmunai") ;
KampalaUganda = UsePN (mkPN "Kampala") ;
KandySriLanka = UsePN (mkPN "Kandy") ;
KanihamaIndia = UsePN (mkPN "Kanihama") ;
KarachiPakistan = UsePN (mkPN "Karachi") ;
KarkurIsrael = UsePN (mkPN "Karkur") ;
KarmeiTzurWestBank = UsePN (mkPN "Karmei Tzur") ;
KarneiShomronWestBank = UsePN (mkPN "Karnei Shomron") ;
KashmirIndia = UsePN (mkPN "Kashmir") ;
KatmanduAirportNepal = UsePN (mkPN "Katmandu Airport") ;
KedumimWestBank = UsePN (mkPN "Kedumim") ;
KedumimSettlementWestBank = UsePN (mkPN "Kedumim Settlement") ;
KfarBaAnehIsrael = UsePN (mkPN "Kfar Ba'aneh") ;
KfarDaromGazaStrip = UsePN (mkPN "Kfar Darom") ;
KfarHessIsrael = UsePN (mkPN "Kfar Hess") ;
KfarSabaIsrael = UsePN (mkPN "Kfar Saba") ;
KfarTzurifWestBank = UsePN (mkPN "Kfar Tzurif") ;
KfarYamGazaStrip = UsePN (mkPN "Kfar Yam") ;
KfarDaromNetzarimIsrael = UsePN (mkPN "Kfar-Darom Netzarim") ;
KhankalaChechnya = UsePN (mkPN "Khankala") ;
KhartoumSudan = UsePN (mkPN "Khartoum") ;
KhelilAlgeria = UsePN (mkPN "Khelil") ;
KhobarSaudiArabia = UsePN (mkPN "Khobar") ;
KibbutzGalEdIsrael = UsePN (mkPN "Kibbutz Gal 'Ed") ;
KibbutzMeravIsrael = UsePN (mkPN "Kibbutz Merav") ;
KibbutzSheluhotIsrael = UsePN (mkPN "Kibbutz Sheluhot") ;
KidapawanPhilippines = UsePN (mkPN "Kidapawan") ;
KigaliRwanda = UsePN (mkPN "Kigali") ;
KirikkaleTurkey = UsePN (mkPN "Kirikkale") ;
KiryatArbaWestBank = UsePN (mkPN "Kiryat Arba") ;
KiryatMotzkinIsrael = UsePN (mkPN "Kiryat Motzkin") ;
KiryatNetafimWestBank = UsePN (mkPN "Kiryat Netafim") ;
KissufimGazaStrip = UsePN (mkPN "Kissufim") ;
KiursehirBoztepTurkey = UsePN (mkPN "Kiursehir-Boztep") ;
KlaiyatLebanon = UsePN (mkPN "Klaiyat") ;
KohlanYemen = UsePN (mkPN "Kohlan") ;
KomsomoLabadTajikistan = UsePN (mkPN "Komsomo-labad") ;
KuwaitCityKuwait = UsePN (mkPN "Kuwait City") ;
LaCeibaHonduras = UsePN (mkPN "La Ceiba") ;
LaGabarraVenezuela = UsePN (mkPN "La Gabarra") ;
LaGuajiraColombia = UsePN (mkPN "La Guajira") ;
LaPazBolivia = UsePN (mkPN "La Paz") ;
LaVictoriaVenezuela = UsePN (mkPN "La Victoria") ;
LahorePakistan = UsePN (mkPN "Lahore") ;
LarbaAlgeria = UsePN (mkPN "Larba") ;
LarnacaCyprus = UsePN (mkPN "Larnaca") ;
LasarteSpain = UsePN (mkPN "Lasarte") ;
LeizaSpain = UsePN (mkPN "Leiza") ;
LesEucalyptusDistrictAlgeria = UsePN (mkPN "Les Eucalyptus district") ;
LibertadorVenezuela = UsePN (mkPN "Libertador") ;
LiceTurkey = UsePN (mkPN "Lice") ;
LIleRousseFrance = UsePN (mkPN "L'Ile-Rousse") ;
LimaPeru = UsePN (mkPN "Lima") ;
LindosRhodes = UsePN (mkPN "Lindos") ;
LinzAustralia = UsePN (mkPN "Linz") ;
LockerbieUnitedKingdom = UsePN (mkPN "Lockerbie") ;
LogornoSpain = UsePN (mkPN "Logorno") ;
LondonUnitedKingdom = UsePN (mkPN "London") ;
LondonberryNorthernIreland = UsePN (mkPN "Londonberry") ;
LosAngelesUnitedStates = UsePN (mkPN "Los Angeles") ;
LosAngelesInternationalAirportUnitedStates = UsePN (mkPN "Los Angeles International Airport") ;
LosBancosVenezuela = UsePN (mkPN "Los Bancos") ;
LosKatiosNationalParkColombia = UsePN (mkPN "Los Katios National Park") ;
LuandaAngola = UsePN (mkPN "Luanda") ;
LuebeckGermany = UsePN (mkPN "Luebeck") ;
LundaNorteAngola = UsePN (mkPN "Lunda Norte") ;
LuxorEgypt = UsePN (mkPN "Luxor") ;
LyonsFrance = UsePN (mkPN "Lyons") ;
MaAlehMichmashWestBank = UsePN (mkPN "Ma'aleh Michmash") ;
MaccabimIsrael = UsePN (mkPN "Maccabim") ;
MadhuSriLanka = UsePN (mkPN "Madhu") ;
MadrasIndia = UsePN (mkPN "Madras") ;
MadridSpain = UsePN (mkPN "Madrid") ;
MagdalenaColombia = UsePN (mkPN "Magdalena") ;
MaidanSharAfghanistan = UsePN (mkPN "Maidan Shar") ;
MakhachkalaRussia = UsePN (mkPN "Makhachkala") ;
MalagaSpain = UsePN (mkPN "Malaga") ;
MalukkaIslandsIndonesia = UsePN (mkPN "Malukka islands") ;
ManaguaNigeria = UsePN (mkPN "Managua") ;
ManamaBahrain = UsePN (mkPN "Manama") ;
ManchesterUnitedKingdom = UsePN (mkPN "Manchester") ;
MangalsenAndSanpheBagarNepal = UsePN (mkPN "Mangalsen and Sanphe Bagar") ;
ManilaPhilippines = UsePN (mkPN "Manila") ;
MaonIsrael = UsePN (mkPN "Maon") ;
MapourditSudan = UsePN (mkPN "Mapourdit") ;
MarSabaWestBank = UsePN (mkPN "Mar Saba") ;
MarawiPhilippines = UsePN (mkPN "Marawi") ;
MardanPakistan = UsePN (mkPN "Mardan") ;
MarmarisTurkey = UsePN (mkPN "Marmaris") ;
MarseillesFrance = UsePN (mkPN "Marseilles") ;
MashaWestBank = UsePN (mkPN "Masha") ;
MatsumotoJapan = UsePN (mkPN "Matsumoto") ;
MawdiyahYemen = UsePN (mkPN "Mawdiyah") ;
MeaShearimIsrael = UsePN (mkPN "Mea Shearim") ;
MeccaSaudiArabia = UsePN (mkPN "Mecca") ;
MechoraWestBank = UsePN (mkPN "Mechora") ;
MedanIndonesia = UsePN (mkPN "Medan") ;
MedellinColombia = UsePN (mkPN "Medellin") ;
MegidoIsrael = UsePN (mkPN "Megido") ;
MeholaIsrael = UsePN (mkPN "Mehola") ;
MekholahIsrael = UsePN (mkPN "Mekholah") ;
MersinTurkey = UsePN (mkPN "Mersin") ;
MetaColombia = UsePN (mkPN "Meta") ;
MetullaIsrael = UsePN (mkPN "Metulla") ;
MetzerIsrael = UsePN (mkPN "Metzer") ;
MilanItaly = UsePN (mkPN "Milan") ;
MindanaoPhilippines = UsePN (mkPN "Mindanao") ;
MinharotRoadWestBank = UsePN (mkPN "Minharot Road") ;
MiranShahPakistan = UsePN (mkPN "Miran Shah") ;
MituColombia = UsePN (mkPN "Mitu") ;
ModiinIllitWestBank = UsePN (mkPN "Modiin Illit") ;
MombassaKenya = UsePN (mkPN "Mombassa") ;
MoragJunctionGazaStrip = UsePN (mkPN "Morag Junction") ;
MoscowRussia = UsePN (mkPN "Moscow") ;
MoshavHagorIsrael = UsePN (mkPN "Moshav Hagor") ;
MoshavTomerWestBank = UsePN (mkPN "Moshav Tomer") ;
MukallahAdenYemen = UsePN (mkPN "Mukallah-Aden") ;
MunchenGladbachGermany = UsePN (mkPN "Munchen-Gladbach") ;
MunsterGermany = UsePN (mkPN "Munster") ;
MurloughNorthernIreland = UsePN (mkPN "Murlough") ;
MusMusIsrael = UsePN (mkPN "Mus Mus") ;
MutataColombia = UsePN (mkPN "Mutata") ;
MutturSriLanka = UsePN (mkPN "Muttur") ;
NaAlinWestBank = UsePN (mkPN "Na'alin") ;
NablusWestBank = UsePN (mkPN "Nablus") ;
NahalOzGazaStrip = UsePN (mkPN "Nahal Oz") ;
NaharaimIsrael = UsePN (mkPN "Naharaim") ;
NahariyaIsrael = UsePN (mkPN "Nahariya") ;
NairobiKenya = UsePN (mkPN "Nairobi") ;
NajafIraq = UsePN (mkPN "Najaf") ;
NallurAreaSriLanka = UsePN (mkPN "Nallur Area") ;
NaquraLebanon = UsePN (mkPN "Naqura") ;
NarayangangBangladesh = UsePN (mkPN "Narayangang") ;
NetanyaIsrael = UsePN (mkPN "Netanya") ;
NetzarimGazaStrip = UsePN (mkPN "Netzarim") ;
NetzerHazaniGazaStrip = UsePN (mkPN "Netzer Hazani") ;
NeveDanielWestBank = UsePN (mkPN "Neve Daniel") ;
NeveYaminIsrael = UsePN (mkPN "Neve Yamin") ;
NewDelhiIndia = UsePN (mkPN "New Delhi") ;
NewYorkCityUnitedStates = UsePN (mkPN "New York City") ;
NeztarimSettlementGazaStrip = UsePN (mkPN "Neztarim Settlement") ;
NiameyNiger = UsePN (mkPN "Niamey") ;
NissanitGazaStrip = UsePN (mkPN "Nissanit") ;
NitzaneiOzWestBank = UsePN (mkPN "Nitzanei Oz") ;
NitzanimIsrael = UsePN (mkPN "Nitzanim") ;
NokdimTekoaRdWestBank = UsePN (mkPN "Nokdim-Tekoa Rd.") ;
NorteDeSantanderColombia = UsePN (mkPN "Norte de Santander") ;
NorthernCaucasiusChechnya = UsePN (mkPN "Northern Caucasius") ;
NovogroznyRussia = UsePN (mkPN "Novogrozny") ;
NovyyAtagiRussia = UsePN (mkPN "Novyy Atagi") ;
OberwartAustria = UsePN (mkPN "Oberwart") ;
OfraWestBank = UsePN (mkPN "Ofra") ;
OilbaseAlgeria = UsePN (mkPN "Oil base") ;
oilfieldsVenezuela = UsePN (mkPN "oilfields") ;
OkaraPakistan = UsePN (mkPN "Okara") ;
OlayaHerreraColombia = UsePN (mkPN "Olaya Herrera") ;
OmaghNorthernIreland = UsePN (mkPN "Omagh") ;
OrYehudaIsrael = UsePN (mkPN "Or Yehuda") ;
OranAlgeria = UsePN (mkPN "Oran") ;
OsakaJapan = UsePN (mkPN "Osaka") ;
OsloNorway = UsePN (mkPN "Oslo") ;
OssnabruckGermany = UsePN (mkPN "Ossnabruck") ;
OthnielJunctionIsrael = UsePN (mkPN "Othniel Junction") ;
OtnielWestBank = UsePN (mkPN "Otniel") ;
OtzarinWestBank = UsePN (mkPN "Otzarin") ;
OzamisPhilippines = UsePN (mkPN "Ozamis") ;
PahalgamIndia = UsePN (mkPN "Pahalgam") ;
PalorinyaUganda = UsePN (mkPN "Palorinya") ;
PamplonaSpain = UsePN (mkPN "Pamplona") ;
PanamaCityPanama = UsePN (mkPN "Panama City") ;
PantrasGreece = UsePN (mkPN "Pantras") ;
PapayinColombia = UsePN (mkPN "Papayin") ;
PapuaIndonesia = UsePN (mkPN "Papua") ;
ParisFrance = UsePN (mkPN "Paris") ;
PatikulPhilippines = UsePN (mkPN "Patikul") ;
PauFrance = UsePN (mkPN "Pau") ;
PeAtSadehGazaStrip = UsePN (mkPN "Pe'at Sadeh") ;
PeshawarPakistan = UsePN (mkPN "Peshawar") ;
PetahTikvahIsrael = UsePN (mkPN "Petah Tikvah") ;
PhnomPenhCambodia = UsePN (mkPN "Phnom Penh") ;
PortadownIreland = UsePN (mkPN "Portadown") ;
PragueCzechRepublic = UsePN (mkPN "Prague") ;
PuertoAlviraColombia = UsePN (mkPN "Puerto Alvira") ;
PuertoLlerasColombia = UsePN (mkPN "Puerto Lleras") ;
PunjabPakistan = UsePN (mkPN "Punjab") ;
QuettaPakistan = UsePN (mkPN "Quetta") ;
QuitoEcuador = UsePN (mkPN "Quito") ;
RadaAmanYemen = UsePN (mkPN "Rada-Aman") ;
RafahGazaStrip = UsePN (mkPN "Rafah") ;
RamaJunctionWestBank = UsePN (mkPN "Rama Junction") ;
RamalDeAspusanaPeru = UsePN (mkPN "Ramal de Aspusana") ;
RamallahWestBank = UsePN (mkPN "Ramallah") ;
RamatGanIsrael = UsePN (mkPN "Ramat Gan") ;
RaminWestBank = UsePN (mkPN "Ramin") ;
RamleIsrael = UsePN (mkPN "Ramle") ;
RawalpindiPakistan = UsePN (mkPN "Rawalpindi") ;
ReusSpain = UsePN (mkPN "Reus") ;
RigaLatvia = UsePN (mkPN "Riga") ;
RijekaCroatia = UsePN (mkPN "Rijeka") ;
RimalDistrictGazaStrip = UsePN (mkPN "Rimal district") ;
RishonLeZionIsrael = UsePN (mkPN "Rishon Le Zion") ;
RiyadhSaudiArabia = UsePN (mkPN "Riyadh") ;
RoermondNetherlands = UsePN (mkPN "Roermond") ;
RomeItaly = UsePN (mkPN "Rome") ;
RosasSpain = UsePN (mkPN "Rosas") ;
RostovOnDonRussia = UsePN (mkPN "Rostov-on-Don") ;
RuhengeriRwanda = UsePN (mkPN "Ruhengeri") ;
SaadaYemen = UsePN (mkPN "Saada") ;
SabatenaColombia = UsePN (mkPN "Sabatena") ;
SacramentoUnitedStates = UsePN (mkPN "Sacramento") ;
SaintAvoldFrance = UsePN (mkPN "Saint Avold") ;
SaintSebastianSpain = UsePN (mkPN "Saint Sebastian") ;
SaintJeanDeLuzFrance = UsePN (mkPN "Saint-Jean-de-Luz") ;
SairanbarIraq = UsePN (mkPN "Sairanbar") ;
SajaIAGazaStrip = UsePN (mkPN "Saja'i'a") ;
SallentDeGallegoSpain = UsePN (mkPN "Sallent de Gallego") ;
SamariaWestBank = UsePN (mkPN "Samaria") ;
SamashkiRussia = UsePN (mkPN "Samashki") ;
SanDiegoColombia = UsePN (mkPN "San Diego") ;
SanJoseCostaRica = UsePN (mkPN "San Jose") ;
SanLuisColombia = UsePN (mkPN "San Luis") ;
SanMiguelElSalvador = UsePN (mkPN "San Miguel") ;
SanPabloColombia = UsePN (mkPN "San Pablo") ;
SanSabatianSpain = UsePN (mkPN "San Sabatian") ;
SanaaYemen = UsePN (mkPN "Sanaa") ;
SangaldanIndia = UsePN (mkPN "Sangaldan") ;
SantaMartaColombia = UsePN (mkPN "Santa Marta") ;
SantaPolaSpain = UsePN (mkPN "Santa Pola") ;
SantaRitaMountainsPanama = UsePN (mkPN "Santa Rita Mountains") ;
SantiagoChile = UsePN (mkPN "Santiago") ;
SanurIsrael = UsePN (mkPN "Sanur") ;
SarajevoBosniaAndHerzegovina = UsePN (mkPN "Sarajevo") ;
SatkhiraBangladesh = UsePN (mkPN "Satkhira") ;
SegoviaColombia = UsePN (mkPN "Segovia") ;
SeoulSouthKorea = UsePN (mkPN "Seoul") ;
SevilleSpain = UsePN (mkPN "Seville") ;
ShadmotMeholaWestBank = UsePN (mkPN "Shadmot Mehola") ;
ShaveiShomronWestBank = UsePN (mkPN "Shavei Shomron") ;
SheikhAjlunGazaStrip = UsePN (mkPN "Sheikh Ajlun") ;
ShiloWestBank = UsePN (mkPN "Shilo") ;
ShimiEcuador = UsePN (mkPN "Shimi") ;
ShlomiIsrael = UsePN (mkPN "Shlomi") ;
SidiHalifahLibya = UsePN (mkPN "Sidi Halifah") ;
SidonLebanon = UsePN (mkPN "Sidon") ;
SiirtTurkey = UsePN (mkPN "Siirt") ;
SilatADaharWestBank = UsePN (mkPN "Silat a-Dahar") ;
SipadanIslandMalaysia = UsePN (mkPN "Sipadan Island") ;
SitrahBahrain = UsePN (mkPN "Sitrah") ;
SoporeIndia = UsePN (mkPN "Sopore") ;
SrinagarIndia = UsePN (mkPN "Srinagar") ;
SrinigarIndia = UsePN (mkPN "Srinigar") ;
SriperumbudurIndia = UsePN (mkPN "Sriperumbudur") ;
StewartstownNorthernIreland = UsePN (mkPN "Stewartstown") ;
StockholmSweden = UsePN (mkPN "Stockholm") ;
StrasbourgFrance = UsePN (mkPN "Strasbourg") ;
SukaimaniyahIraq = UsePN (mkPN "Sukai-maniyah") ;
SulawesiIndonesia = UsePN (mkPN "Sulawesi") ;
SulaymaniyahIraq = UsePN (mkPN "Sulaymaniyah") ;
SumayrYemen = UsePN (mkPN "Sumayr") ;
SusiyaWestBank = UsePN (mkPN "Susiya") ;
TailaPakistan = UsePN (mkPN "Taila") ;
TamezGuidaAlgeria = UsePN (mkPN "Tamez-guida") ;
TandySriLanka = UsePN (mkPN "Tandy") ;
TaxilaPakistan = UsePN (mkPN "Taxila") ;
TBilisiGeorgia = UsePN (mkPN "T'bilisi") ;
TegucigalpaHonduras = UsePN (mkPN "Tegucigalpa") ;
TeheranIran = UsePN (mkPN "Teheran") ;
TekoaWestBank = UsePN (mkPN "Tekoa") ;
TelAvivIsrael = UsePN (mkPN "Tel Aviv" | mkPN "Tel-Aviv") ;
TelHaShomerJunctionIsrael = UsePN (mkPN "Tel HaShomer Junction") ;
TelQateifaGazaStrip = UsePN (mkPN "Tel Qateifa") ;
TelRumeiydaIsrael = UsePN (mkPN "Tel Rumeiyda") ;
TelemIsrael = UsePN (mkPN "Telem") ;
TenaWestBank = UsePN (mkPN "Tena") ;
TheHagueNetherlands = UsePN (mkPN "The Hague") ;
TheKyrgyzCapitalBishkekChina = UsePN (mkPN "The Kyrgyz capital Bishkek.") ;
ThekraguriIndia = UsePN (mkPN "Thekraguri") ;
TiaretAlgeria = UsePN (mkPN "Tiaret") ;
TiratAlgeria = UsePN (mkPN "Tirat") ;
TokyoJapan = UsePN (mkPN "Tokyo") ;
TolosaSpain = UsePN (mkPN "Tolosa") ;
TopkakiTurkey = UsePN (mkPN "Topkaki") ;
TrabzonTurkey = UsePN (mkPN "Trabzon") ;
TrincomaleeHarborSriLanka = UsePN (mkPN "Trincomalee Harbor") ;
TripoliLibya = UsePN (mkPN "Tripoli") ;
TulkaremWestBank = UsePN (mkPN "Tulkarem") ;
TulkarmWestBank = UsePN (mkPN "Tulkarm") ;
TunceliTurkey = UsePN (mkPN "Tunceli") ;
TurbatPakistan = UsePN (mkPN "Turbat") ;
UmAlFahmIsrael = UsePN (mkPN "Um al-Fahm") ;
UmmQasrIraq = UsePN (mkPN "Umm Qasr") ;
UrenaVenezuela = UsePN (mkPN "Urena") ;
UrraColombia = UsePN (mkPN "Urra") ;
UrsMartanRussia = UsePN (mkPN "Urs-Martan") ;
UWaIndianReservationColombia = UsePN (mkPN "U'wa Indian reservation") ;
ValenciaSpain = UsePN (mkPN "Valencia") ;
ValleduparColombia = UsePN (mkPN "Valledupar") ;
VanTurkey = UsePN (mkPN "Van") ;
VavuniyaSriLanka = UsePN (mkPN "Vavuniya") ;
ViennaAustria = UsePN (mkPN "Vienna") ;
VientianeLaos = UsePN (mkPN "Vientiane") ;
VillavicencioColombia = UsePN (mkPN "Villavicencio") ;
VitoriaSpain = UsePN (mkPN "Vitoria") ;
VitrollesFrance = UsePN (mkPN "Vitrolles") ;
VladikavkazRussia = UsePN (mkPN "Vladikavkaz") ;
VladivostokRussia = UsePN (mkPN "Vladivostok") ;
VolgodonskRussia = UsePN (mkPN "Volgodonsk") ;
WadiAlDabaatYemen = UsePN (mkPN "Wadi al-Dabaat") ;
WadiAraIsrael = UsePN (mkPN "Wadi Ara") ;
WadiKeltWestBank = UsePN (mkPN "Wadi Kelt") ;
WarsawPoland = UsePN (mkPN "Warsaw") ;
WashingtonDCUnitedStates = UsePN (mkPN "Washington DC.") ;
WattyanBahrain = UsePN (mkPN "Wattyan") ;
WestBeirutLebanon = UsePN (mkPN "West Beirut") ;
XiAnChina = UsePN (mkPN "Xi'an") ;
YaAbadWestBank = UsePN (mkPN "Ya'abad") ;
YagurJunctionIsrael = UsePN (mkPN "Yagur Junction") ;
YehudIsrael = UsePN (mkPN "Yehud") ;
YerevanArmenia = UsePN (mkPN "Yerevan") ;
YitzharWestBank = UsePN (mkPN "Yitzhar") ;
YokotaJapan = UsePN (mkPN "Yokota") ;
YopalColombia = UsePN (mkPN "Yopal") ;
YuksekovaTurkey = UsePN (mkPN "Yuksekova") ;
ZaitaIsrael = UsePN (mkPN "Zaita") ;
ZamarYemen = UsePN (mkPN "Zamar") ;
ZamboangaPhilippines = UsePN (mkPN "Zamboanga") ;
ZaragozaSpain = UsePN (mkPN "Zaragoza") ;
ZarauzSpain = UsePN (mkPN "Zarauz") ;
ZeifIntersectionWestBank = UsePN (mkPN "Zeif intersection") ;
ZekharyaIsrael = UsePN (mkPN "Zekharya") ;
ZuliaColombia = UsePN (mkPN "Zulia") ;
ZumaiaSpain = UsePN (mkPN "Zumaia") ;
ZumarragaSpain = UsePN (mkPN "Zumarraga") ;
Burundi = UsePN (mkPN "Burundi") ;
CentralAfricanRepublic = UsePN (mkPN "Central African Republic") ;
Chad = UsePN (mkPN "Chad") ;
DemocraticRepublicOfTheCongo = UsePN (mkPN "Democratic Republic of the Congo") ;
Rwanda = UsePN (mkPN "Rwanda") ;
Djibouti = UsePN (mkPN "Djibouti") ;
Eritrea = UsePN (mkPN "Eritrea") ;
Ethiopia = UsePN (mkPN "Ethiopia") ;
Kenya = UsePN (mkPN "Kenya") ;
Seychelles = UsePN (mkPN "Seychelles") ;
Somalia = UsePN (mkPN "Somalia") ;
Tanzania = UsePN (mkPN "Tanzania") ;
Uganda = UsePN (mkPN "Uganda") ;
Algeria = UsePN (mkPN "Algeria") ;
Egypt = UsePN (mkPN "Egypt") ;
Libya = UsePN (mkPN "Libya") ;
Mauritania = UsePN (mkPN "Mauritania") ;
Morocco = UsePN (mkPN "Morocco") ;
Sudan = UsePN (mkPN "Sudan") ;
Tunisia = UsePN (mkPN "Tunisia") ;
WesternSahara = UsePN (mkPN "Western Sahara") ;
Angola = UsePN (mkPN "Angola") ;
BassasDaIndia = UsePN (mkPN "Bassas da India") ;
Botswana = UsePN (mkPN "Botswana") ;
BouvetIsland = UsePN (mkPN "Bouvet Island") ;
Comoros = UsePN (mkPN "Comoros") ;
EuropaIsland = UsePN (mkPN "Europa Island") ;
GloriosoIslands = UsePN (mkPN "Glorioso Islands") ;
HeardIslandAndMcDonaldIslands = UsePN (mkPN "Heard Island and McDonald Islands") ;
JuanDeNovaIsland = UsePN (mkPN "Juan de Nova Island") ;
Lesotho = UsePN (mkPN "Lesotho" | mkPN "Basutoland") ;
Madagascar = UsePN (mkPN "Madagascar") ;
Malawi = UsePN (mkPN "Malawi") ;
Mauritius = UsePN (mkPN "Mauritius") ;
Mayotte = UsePN (mkPN "Mayotte") ;
Mozambique = UsePN (mkPN "Mozambique") ;
Namibia = UsePN (mkPN "Namibia") ;
Reunion = UsePN (mkPN "Reunion") ;
SouthAfrica = UsePN (mkPN "South Africa") ;
Swaziland = UsePN (mkPN "Swaziland") ;
TromelinIsland = UsePN (mkPN "Tromelin Island") ;
Zambia = UsePN (mkPN "Zambia") ;
Zimbabwe = UsePN (mkPN "Zimbabwe") ;
Benin = UsePN (mkPN "Benin") ;
BurkinaFaso = UsePN (mkPN "Burkina Faso") ;
Cameroon = UsePN (mkPN "Cameroon") ;
CapeVerde = UsePN (mkPN "Cape Verde") ;
CoteDIvoire = UsePN (mkPN "Cote d'Ivoire") ;
EquatorialGuinea = UsePN (mkPN "Equatorial Guinea") ;
Gabon = UsePN (mkPN "Gabon") ;
Gambia = UsePN (mkPN "Gambia") ;
Ghana = UsePN (mkPN "Ghana") ;
Guinea = UsePN (mkPN "Guinea") ;
GuineaBissau = UsePN (mkPN "Guinea Bissau") ;
Liberia = UsePN (mkPN "Liberia") ;
Mali = UsePN (mkPN "Mali") ;
Niger = UsePN (mkPN "Niger") ;
Nigeria = UsePN (mkPN "Nigeria") ;
Senegal = UsePN (mkPN "Senegal") ;
SierraLeone = UsePN (mkPN "Sierra Leone") ;
Togo = UsePN (mkPN "Togo") ;
SaintHelena = UsePN (mkPN "Saint Helena") ;
Bahrain = UsePN (mkPN "Bahrain") ;
Cyprus = UsePN (mkPN "Cyprus") ;
GazaStrip = UsePN (mkPN "Gaza Strip") ;
Iran = UsePN (mkPN "Iran") ;
Iraq = UsePN (mkPN "Iraq") ;
Israel = UsePN (mkPN "Israel") ;
Jordan = UsePN (mkPN "Jordan") ;
Kuwait = UsePN (mkPN "Kuwait") ;
Lebanon = UsePN (mkPN "Lebanon") ;
Oman = UsePN (mkPN "Oman") ;
Qatar = UsePN (mkPN "Qatar") ;
SaudiArabia = UsePN (mkPN "Saudi Arabia") ;
Syria = UsePN (mkPN "Syria") ;
UnitedArabEmirates = UsePN (mkPN "United Arab Emirates") ;
WestBank = UsePN (mkPN "West Bank") ;
Yemen = UsePN (mkPN "Yemen") ;
Austria = UsePN (mkPN "Austria") ;
CzechRepublic = UsePN (mkPN "Czech Republic") ;
Germany = UsePN (mkPN "Germany") ;
Hungary = UsePN (mkPN "Hungary") ;
Liechtenstein = UsePN (mkPN "Liechtenstein") ;
Poland = UsePN (mkPN "Poland") ;
Slovakia = UsePN (mkPN "Slovakia") ;
Slovenia = UsePN (mkPN "Slovenia") ;
Switzerland = UsePN (mkPN "Switzerland") ;
Belarus = UsePN (mkPN "Belarus") ;
Estonia = UsePN (mkPN "Estonia") ;
Latvia = UsePN (mkPN "Latvia") ;
Lithuania = UsePN (mkPN "Lithuania") ;
Moldova = UsePN (mkPN "Moldova") ;
Ukraine = UsePN (mkPN "Ukraine") ;
Denmark = UsePN (mkPN "Denmark") ;
FaroeIslands = UsePN (mkPN "Faroe Islands") ;
Finland = UsePN (mkPN "Finland") ;
Iceland = UsePN (mkPN "Iceland") ;
JanMayenIsland = UsePN (mkPN "Jan Mayen Island") ;
Norway = UsePN (mkPN "Norway") ;
Svalbard = UsePN (mkPN "Svalbard") ;
Sweden = UsePN (mkPN "Sweden") ;
Greece = UsePN (mkPN "Greece") ;
HolySee = UsePN (mkPN "Holy See") ;
Italy = UsePN (mkPN "Italy") ;
Malta = UsePN (mkPN "Malta") ;
SanMarino = UsePN (mkPN "San Marino") ;
Belgium = UsePN (mkPN "Belgium") ;
France = UsePN (mkPN "France") ;
Guernsey = UsePN (mkPN "Guernsey") ;
Ireland = UsePN (mkPN "Ireland") ;
Jersey = UsePN (mkPN "Jersey") ;
Luxembourg = UsePN (mkPN "Luxembourg") ;
IsleOfMan = UsePN (mkPN "Isle of Man") ;
Monaco = UsePN (mkPN "Monaco") ;
Netherlands = UsePN (mkPN "Netherlands") ;
UnitedKingdom = UsePN (mkPN "United Kingdom of Great Britain and Northern Ireland" | mkPN "United Kingdom" | mkPN "Great Britain") ;
Albania = UsePN (mkPN "Albania") ;
BosniaAndHerzegovina = UsePN (mkPN "Bosnia and Herzegovina") ;
Bulgaria = UsePN (mkPN "Bulgaria") ;
Croatia = UsePN (mkPN "Croatia") ;
Macedonia = UsePN (mkPN "Macedonia") ;
Romania = UsePN (mkPN "Romania") ;
Turkey = UsePN (mkPN "Turkey") ;
Andorra = UsePN (mkPN "Andorra") ;
Gibraltar = UsePN (mkPN "Gibraltar") ;
Portugal = UsePN (mkPN "Portugal") ;
Spain = UsePN (mkPN "Spain") ;
Bermuda = UsePN (mkPN "Bermuda") ;
UnitedStates = UsePN (mkPN "United States") ;
Canada = UsePN (mkPN "Canada") ;
Greenland = UsePN (mkPN "Greenland") ;
SaintPierreAndMiquelon = UsePN (mkPN "Saint Pierre and Miquelon") ;
Anguilla = UsePN (mkPN "Anguilla") ;
AntiguaAndBarbuda = UsePN (mkPN "Antigua and Barbuda") ;
Aruba = UsePN (mkPN "Aruba") ;
TheBahamas = UsePN (mkPN "Bahamas") ;
Barbados = UsePN (mkPN "Barbados") ;
BritishVirginIslands = UsePN (mkPN "British Virgin Islands") ;
CaymanIslands = UsePN (mkPN "Cayman Islands") ;
Cuba = UsePN (mkPN "Cuba") ;
Dominica = UsePN (mkPN "Dominica") ;
DominicanRepublic = UsePN (mkPN "Dominican Republic") ;
Grenada = UsePN (mkPN "Grenada") ;
Guadeloupe = UsePN (mkPN "Guadeloupe") ;
Haiti = UsePN (mkPN "Haiti") ;
Jamaica = UsePN (mkPN "Jamaica") ;
Martinique = UsePN (mkPN "Martinique") ;
Montserrat = UsePN (mkPN "Montserrat") ;
NavassaIsland = UsePN (mkPN "Navassa Island") ;
NetherlandsAntilles = UsePN (mkPN "Netherlands Antilles") ;
PuertoRico = UsePN (mkPN "Puerto Rico") ;
SaintLucia = UsePN (mkPN "Saint Lucia") ;
TurksAndCaicosIslands = UsePN (mkPN "Turks and Caicos Islands") ;
VirginIslands = UsePN (mkPN "Virgin Islands") ;
Belize = UsePN (mkPN "Belize") ;
ClippertonIsland = UsePN (mkPN "Clipperton Island") ;
CostaRica = UsePN (mkPN "Costa Rica") ;
ElSalvador = UsePN (mkPN "El Salvador") ;
Guatemala = UsePN (mkPN "Guatemala") ;
Honduras = UsePN (mkPN "Honduras") ;
Mexico = UsePN (mkPN "Mexico") ;
Nicaragua = UsePN (mkPN "Nicaragua") ;
Panama = UsePN (mkPN "Panama") ;
Bolivia = UsePN (mkPN "Bolivia") ;
Paraguay = UsePN (mkPN "Paraguay") ;
Brazil = UsePN (mkPN "Brazil") ;
Colombia = UsePN (mkPN "Colombia") ;
FrenchGuiana = UsePN (mkPN "French Guiana") ;
Guyana = UsePN (mkPN "Guyana") ;
Suriname = UsePN (mkPN "Suriname") ;
Venezuela = UsePN (mkPN "Venezuela") ;
Argentina = UsePN (mkPN "Argentina") ;
Chile = UsePN (mkPN "Chile") ;
FalklandIslands = UsePN (mkPN "Falkland Islands") ;
SouthGeorgiaAndTheSouthSandwichIslands = UsePN (mkPN "South Georgia and the South Sandwich Islands") ;
Uruguay = UsePN (mkPN "Uruguay") ;
Ecuador = UsePN (mkPN "Ecuador") ;
Peru = UsePN (mkPN "Peru") ;
Kazakhstan = UsePN (mkPN "Kazakhstan") ;
Kyrgyzstan = UsePN (mkPN "Kyrgyzstan") ;
Tajikistan = UsePN (mkPN "Tajikistan") ;
Turkmenistan = UsePN (mkPN "Turkmenistan") ;
Uzbekistan = UsePN (mkPN "Uzbekistan") ;
China = UsePN (mkPN "China") ;
HongKong = UsePN (mkPN "Hong Kong") ;
Japan = UsePN (mkPN "Japan") ;
NorthKorea = UsePN (mkPN "NorthKorea") ;
SouthKorea = UsePN (mkPN "SouthKorea") ;
Macau = UsePN (mkPN "Macau") ;
Taiwan = UsePN (mkPN "Taiwan" | mkPN "Republic of China") ;
Mongolia = UsePN (mkPN "Mongolia") ;
Russia = UsePN (mkPN "Russia") ;
Afghanistan = UsePN (mkPN "Afghanistan") ;
Bangladesh = UsePN (mkPN "Bangladesh") ;
Bhutan = UsePN (mkPN "Bhutan") ;
BritishIndianOceanTerritory = UsePN (mkPN "British Indian Ocean Territory") ;
India = UsePN (mkPN "India") ;
Maldives = UsePN (mkPN "Maldives") ;
Nepal = UsePN (mkPN "Nepal") ;
Pakistan = UsePN (mkPN "Pakistan") ;
SriLanka = UsePN (mkPN "Sri Lanka") ;
FrenchSouthernAndAntarcticLands = UsePN (mkPN "French Southern and Antarctic Lands") ;
AshmoreAndCartierIslands = UsePN (mkPN "Ashmore and Cartier Islands") ;
Brunei = UsePN (mkPN "Brunei") ;
Cambodia = UsePN (mkPN "Cambodia") ;
ChristmasIsland = UsePN (mkPN "Christmas Island") ;
CocosKeelingIslands = UsePN (mkPN "Cocos Keeling Islands") ;
EastTimor = UsePN (mkPN "East Timor") ;
Indonesia = UsePN (mkPN "Indonesia") ;
Laos = UsePN (mkPN "Laos") ;
Malaysia = UsePN (mkPN "Malaysia") ;
Myanmar = UsePN (mkPN "Myanmar") ;
PapuaNewGuinea = UsePN (mkPN "Papua New Guinea") ;
ParacelIslands = UsePN (mkPN "Paracel Islands") ;
Philippines = UsePN (mkPN "Philippines") ;
Singapore = UsePN (mkPN "Singapore") ;
SpratlyIslands = UsePN (mkPN "Spratly Islands") ;
Thailand = UsePN (mkPN "Thailand") ;
Vietnam = UsePN (mkPN "Vietnam") ;
Armenia = UsePN (mkPN "Armenia") ;
Azerbaijan = UsePN (mkPN "Azerbaijan") ;
RepublicOfGeorgia = UsePN (mkPN "Republic Of Georgia") ;
AmericanSamoa = UsePN (mkPN "American Samoa") ;
Australia = UsePN (mkPN "Australia") ;
BakerIsland = UsePN (mkPN "Baker Island") ;
CookIslands = UsePN (mkPN "Cook Islands") ;
CoralSeaIslands = UsePN (mkPN "Coral Sea Islands") ;
Fiji = UsePN (mkPN "Fiji") ;
FrenchPolynesia = UsePN (mkPN "French Polynesia") ;
Guam = UsePN (mkPN "Guam") ;
HowlandIsland = UsePN (mkPN "Howland Island") ;
JarvisIsland = UsePN (mkPN "Jarvis Island") ;
JohnstonAtoll = UsePN (mkPN "Johnston Atoll") ;
KingmanReef = UsePN (mkPN "Kingman Reef") ;
Kiribati = UsePN (mkPN "Kiribati") ;
MarshallIslands = UsePN (mkPN "Marshall Islands") ;
Micronesia = UsePN (mkPN "Micronesia") ;
MidwayIslands = UsePN (mkPN "Midway Islands") ;
Nauru = UsePN (mkPN "Nauru") ;
NewCaledonia = UsePN (mkPN "New Caledonia") ;
NewZealand = UsePN (mkPN "New Zealand") ;
Niue = UsePN (mkPN "Niue") ;
NorfolkIsland = UsePN (mkPN "Norfolk Island") ;
NorthernMarianaIslands = UsePN (mkPN "Northern Mariana Islands") ;
Palau = UsePN (mkPN "Palau") ;
PalmyraAtoll = UsePN (mkPN "Palmyra Atoll") ;
PitcairnIslands = UsePN (mkPN "Pitcairn Islands") ;
Samoa = UsePN (mkPN "Samoa") ;
SolomonIslands = UsePN (mkPN "Solomon Islands") ;
Tokelau = UsePN (mkPN "Tokelau") ;
Tonga = UsePN (mkPN "Tonga") ;
Tuvalu = UsePN (mkPN "Tuvalu") ;
Vanuatu = UsePN (mkPN "Vanuatu") ;
WakeIsland = UsePN (mkPN "Wake Island") ;
WallisAndFutuna = UsePN (mkPN "Wallis and Futuna") ;
Zaire = UsePN (mkPN "Zaire") ;
};

269
examples/SUMO/CountriesAndRegionsRon.gf
View File

@@ -1,269 +0,0 @@
--# -path=.:englishExtended
concrete CountriesAndRegionsRon of CountriesAndRegions = MidLevelOntologyRon ** open ParadigmsRon,NounRon in {
flags
coding = utf8 ;
lin
Afghanistan = UsePN (mkPN "Afghanistan" | mkPN "Afganistan") ;
Albania = UsePN (mkPN "Albania") ;
Algeria = UsePN (mkPN "Algeria") ;
AlgiersAlgeria = UsePN (mkPN "Alger") ;
AmericanSamoa = UsePN (mkPN "Samoa Americană") ;
AmmanJordan = UsePN (mkPN "Amman") ;
Andorra = UsePN (mkPN "Andorra" | mkPN "Andora") ;
Angola = UsePN (mkPN "Angola") ;
Anguilla = UsePN (mkPN "Anguilla") ;
AnkaraTurkey = UsePN (mkPN "Ankara") ;
AntiguaAndBarbuda = UsePN (mkPN "Antigua şi Barbuda") ;
Argentina = UsePN (mkPN "Argentina") ;
ArmaghNorthernIreland = UsePN (mkPN "Armagh") ;
Armenia = UsePN (mkPN "Armenia") ;
Aruba = UsePN (mkPN "Aruba") ;
AshdodIsrael = UsePN (mkPN "Aşdod") ;
AskelonIsrael = UsePN (mkPN "Aşkelon") ;
AsmaraEritrea = UsePN (mkPN "Asmara") ;
AswanEgypt = UsePN (mkPN "Assuan" | mkPN "Aswan") ;
AthensGreece = UsePN (mkPN "Atena") ;
Australia = UsePN (mkPN "Australia") ;
Austria = UsePN (mkPN "Austria") ;
Azerbaijan = UsePN (mkPN "Azerbaijan" | mkPN "Azerbaidjan") ;
Bahamas = UsePN (mkPN "Bahamas") ;
Bahrain = UsePN (mkPN "Bahrain") ;
BangkokThailand = UsePN (mkPN "Bangkok") ;
Bangladesh = UsePN (mkPN "Bangladeş" | mkPN "Bangladesh") ;
Barbados = UsePN (mkPN "Barbados") ;
BeirutLebanon = UsePN (mkPN "Beirut") ;
Belarus = UsePN (mkPN "Belarus" | mkPN "Bielorusia") ;
BelfastNorthernIreland = UsePN (mkPN "Belfast") ;
Belgium = UsePN (mkPN "Belgia") ;
Belize = UsePN (mkPN "Belize") ;
Benin = UsePN (mkPN "Benin") ;
Bermuda = UsePN (mkPN "Insulele Bermude") ;
Bhutan = UsePN (mkPN "Bhutan") ;
Bolivia = UsePN (mkPN "Bolivia") ;
Botswana = UsePN (mkPN "Botswana") ;
BouvetIsland = UsePN (mkPN "Insula Bouvet") ;
Brazil = UsePN (mkPN "Brazilia") ;
BritishIndianOceanTerritory = UsePN (mkPN "Teritoriile Britanice din Oceanul Indian") ;
BritishVirginIslands = UsePN (mkPN "Insulele Virgine, Britanice") ;
Brunei = UsePN (mkPN "Brunei") ;
BrusselsBelgium = UsePN (mkPN "Bruxelles") ;
BucharestRomania = UsePN (mkPN "Bucureşti") ;
Bulgaria = UsePN (mkPN "Bulgaria") ;
BurkinaFaso = UsePN (mkPN "Burkina Fasso" | mkPN "Burkina Faso") ;
Burundi = UsePN (mkPN "Burundi") ;
CairoEgypt = UsePN (mkPN "Cairo") ;
Cambodia = UsePN (mkPN "Cambodgia") ;
Cameroon = UsePN (mkPN "Camerun") ;
Canada = UsePN (mkPN "Canada") ;
CapeVerde = UsePN (mkPN "Capul Verde") ;
CaymanIslands = UsePN (mkPN "Insulele Cayman") ;
CentralAfricanRepublic = UsePN (mkPN "Republica Central Africană" | mkPN "Republica Centrafricană") ;
Chad = UsePN (mkPN "Ciad") ;
Chile = UsePN (mkPN "Chile") ;
China = UsePN (mkPN "Republica Populară Chineză" | mkPN "China") ;
ChristmasIsland = UsePN (mkPN "Insula Christmas") ;
CocosKeelingIslands = UsePN (mkPN "Insulele Cocos (Keeling)") ;
Colombia = UsePN (mkPN "Columbia") ;
Comoros = UsePN (mkPN "Comore" | mkPN "Comoros") ;
Congo = UsePN (mkPN "Republica Congo" | mkPN "Congo") ;
CookIslands = UsePN (mkPN "Insulele Cook") ;
CopenhagenDenmark = UsePN (mkPN "Copenhaga") ;
CostaRica = UsePN (mkPN "Costa Rica") ;
Croatia = UsePN (mkPN "Croaţia") ;
Cuba = UsePN (mkPN "Cuba") ;
Cyprus = UsePN (mkPN "Cipru") ;
CzechRepublic = UsePN (mkPN "Republica Cehă" | mkPN "Cehia") ;
DelhiIndia = UsePN (mkPN "Delhi") ;
DemocraticRepublicOfTheCongo = UsePN (mkPN "Zair" | mkPN "Congo, Republica Democratică" | mkPN "Republica Democrată Congo") ;
Denmark = UsePN (mkPN "Danemarca") ;
Djibouti = UsePN (mkPN "Djibouti") ;
Dominica = UsePN (mkPN "Dominica") ;
DominicanRepublic = UsePN (mkPN "Republica Dominicană") ;
DortmundGermany = UsePN (mkPN "Dortmund") ;
DublinIreland = UsePN (mkPN "Dublin") ;
DuesseldorfGermany = UsePN (mkPN "Düsseldorf") ;
EastJerusalemIsrael = UsePN (mkPN "Ierusalim") ;
EastTimor = UsePN (mkPN "Timorul de Est") ;
Ecuador = UsePN (mkPN "Ecuador") ;
Egypt = UsePN (mkPN "Egipt") ;
ElSalvador = UsePN (mkPN "El Salvador") ;
EquatorialGuinea = UsePN (mkPN "Guineea Ecuatorială") ;
Eritrea = UsePN (mkPN "Eritreea" | mkPN "Eritrea") ;
Estonia = UsePN (mkPN "Estonia") ;
Ethiopia = UsePN (mkPN "Etiopia") ;
FalklandIslands = UsePN (mkPN "Insulele Falkland") ;
FaroeIslands = UsePN (mkPN "Insulele Feroe" | mkPN "Insulele Faroe") ;
Fiji = UsePN (mkPN "Fiji") ;
Finland = UsePN (mkPN "Finlanda") ;
France = UsePN (mkPN "Franţa") ;
FrenchGuiana = UsePN (mkPN "Guiana Franceză") ;
Gabon = UsePN (mkPN "Gabon") ;
Gambia = UsePN (mkPN "Gambia") ;
Georgia = UsePN (mkPN "Georgia") ;
Germany = UsePN (mkPN "Germania") ;
Ghana = UsePN (mkPN "Ghana") ;
Gibraltar = UsePN (mkPN "Gibraltar") ;
GrazAustria = UsePN (mkPN "Graz") ;
Greece = UsePN (mkPN "Grecia") ;
Greenland = UsePN (mkPN "Groenlanda") ;
Grenada = UsePN (mkPN "Grenada") ;
Guadeloupe = UsePN (mkPN "Guadeloupe") ;
Guam = UsePN (mkPN "Guam") ;
Guatemala = UsePN (mkPN "Guatemala") ;
Guernsey = UsePN (mkPN "Guernsey") ;
Guinea = UsePN (mkPN "Guinea" | mkPN "Guineea") ;
Guyana = UsePN (mkPN "Guiana" | mkPN "Guyana") ;
HaderaIsrael = UsePN (mkPN "Hadera") ;
HaifaIsrael = UsePN (mkPN "Haifa") ;
Haiti = UsePN (mkPN "Haiti") ;
HavanaCuba = UsePN (mkPN "Havana") ;
HilversumNetherlands = UsePN (mkPN "Hilversum") ;
Honduras = UsePN (mkPN "Honduras") ;
HongKong = UsePN (mkPN "Hong Kong") ;
Hungary = UsePN (mkPN "Ungaria") ;
Iceland = UsePN (mkPN "Islanda") ;
India = UsePN (mkPN "India") ;
Indonesia = UsePN (mkPN "Indonezia") ;
Iran = UsePN (mkPN "Iran (Republica islamică)" | mkPN "Iran") ;
Iraq = UsePN (mkPN "Irak" | mkPN "Iraq") ;
Ireland = UsePN (mkPN "Republica Irlanda" | mkPN "Irlanda") ;
Israel = UsePN (mkPN "Israel") ;
Italy = UsePN (mkPN "Italia") ;
Jamaica = UsePN (mkPN "Jamaica") ;
Japan = UsePN (mkPN "Japonia") ;
Jersey = UsePN (mkPN "Insula Jersey") ;
JerusalemIsrael = UsePN (mkPN "Ierusalim") ;
Jordan = UsePN (mkPN "Iordania") ;
Kazakhstan = UsePN (mkPN "Kazahstan") ;
Kenya = UsePN (mkPN "Kenya") ;
Kiribati = UsePN (mkPN "Kiribati") ;
Kuwait = UsePN (mkPN "Kuweit") ;
Kyrgyzstan = UsePN (mkPN "Kârgâzstan" | mkPN "Kirghizia") ;
LahorePakistan = UsePN (mkPN "Lahore") ;
Laos = UsePN (mkPN "Lao, Republica Democratică Populară" | mkPN "Laos") ;
Latvia = UsePN (mkPN "Letonia") ;
Lebanon = UsePN (mkPN "Liban") ;
Lesotho = UsePN (mkPN "Lesotho") ;
Liberia = UsePN (mkPN "Liberia") ;
Libya = UsePN (mkPN "Libia, Jamahiriya Arabă" | mkPN "Libia") ;
Liechtenstein = UsePN (mkPN "Liechtenstein") ;
Lithuania = UsePN (mkPN "Lituania") ;
LondonUnitedKingdom = UsePN (mkPN "Londra") ;
LosAngelesUnitedStates = UsePN (mkPN "Los Angeles") ;
Luxembourg = UsePN (mkPN "Luxemburg") ;
Macedonia = UsePN (mkPN "Fosta Republică Iugoslavă Macedonia" | mkPN "Republica Macedonia" | mkPN "Macedonia") ;
Madagascar = UsePN (mkPN "Madagascar") ;
Malawi = UsePN (mkPN "Malawi") ;
Malaysia = UsePN (mkPN "Malaiezia" | mkPN "Malaysia" | mkPN "Malaezia") ;
Maldives = UsePN (mkPN "Maldive") ;
Mali = UsePN (mkPN "Mali") ;
Malta = UsePN (mkPN "Insula Malta" | mkPN "Malta") ;
ManamaBahrain = UsePN (mkPN "Manama") ;
ManchesterUnitedKingdom = UsePN (mkPN "Manchester") ;
MarshallIslands = UsePN (mkPN "Insulele Marshall") ;
Martinique = UsePN (mkPN "Martinica") ;
Mauritania = UsePN (mkPN "Mauritania") ;
Mauritius = UsePN (mkPN "Mauriţius" | mkPN "Mauritius") ;
Mayotte = UsePN (mkPN "Mayotte") ;
MeccaSaudiArabia = UsePN (mkPN "Mecca") ;
Mexico = UsePN (mkPN "Mexic") ;
Micronesia = UsePN (mkPN "Micronezia, Republica Federală") ;
Moldova = UsePN (mkPN "Moldova, Republica" | mkPN "Republica Moldova") ;
Monaco = UsePN (mkPN "Monaco") ;
Mongolia = UsePN (mkPN "Mongolia") ;
Montserrat = UsePN (mkPN "Montserrat") ;
Morocco = UsePN (mkPN "Maroc") ;
MoscowRussia = UsePN (mkPN "Moscova") ;
Mozambique = UsePN (mkPN "Mozambic") ;
Myanmar = UsePN (mkPN "Myanmar") ;
NairobiKenya = UsePN (mkPN "Nairobi") ;
Namibia = UsePN (mkPN "Namibia") ;
Nauru = UsePN (mkPN "Nauru") ;
Nepal = UsePN (mkPN "Nepal") ;
NetanyaIsrael = UsePN (mkPN "Netania" | mkPN "Natania") ;
Netherlands = UsePN (mkPN "Ţările de Jos" | mkPN "Olanda") ;
NetherlandsAntilles = UsePN (mkPN "Antilele Olandeze") ;
NewCaledonia = UsePN (mkPN "Noua Caledonie") ;
NewDelhiIndia = UsePN (mkPN "New Delhi") ;
NewYorkCityUnitedStates = UsePN (mkPN "New York" | mkPN "New York City") ;
NewZealand = UsePN (mkPN "Noua Zeelandă") ;
Nicaragua = UsePN (mkPN "Nicaragua") ;
Niger = UsePN (mkPN "Niger") ;
Nigeria = UsePN (mkPN "Nigeria") ;
Niue = UsePN (mkPN "Niue") ;
NorfolkIsland = UsePN (mkPN "Insula Norfolk") ;
NorthKorea = UsePN (mkPN "Coreea de Nord") ;
NorthernMarianaIslands = UsePN (mkPN "Insulele Northern Mariana") ;
Norway = UsePN (mkPN "Norvegia") ;
Oman = UsePN (mkPN "Oman") ;
OranAlgeria = UsePN (mkPN "Oran") ;
Pakistan = UsePN (mkPN "Pakistan") ;
Palau = UsePN (mkPN "Palau") ;
Panama = UsePN (mkPN "Panama") ;
PapuaNewGuinea = UsePN (mkPN "Papua Noua Guinee") ;
Paraguay = UsePN (mkPN "Paraguay") ;
Peru = UsePN (mkPN "Peru") ;
Philippines = UsePN (mkPN "Filipine") ;
Poland = UsePN (mkPN "Polonia") ;
Portugal = UsePN (mkPN "Portugalia") ;
PuertoRico = UsePN (mkPN "Porto Rico") ;
Qatar = UsePN (mkPN "Qatar") ;
Reunion = UsePN (mkPN "Reunion") ;
RoermondNetherlands = UsePN (mkPN "Roermond") ;
Romania = UsePN (mkPN "România") ;
Russia = UsePN (mkPN "Federația Rusă" | mkPN "Rusia") ;
Rwanda = UsePN (mkPN "Ruanda" | mkPN "Rwanda") ;
SaintHelena = UsePN (mkPN "Saint Helena") ;
SaintLucia = UsePN (mkPN "Saint Lucia") ;
Samoa = UsePN (mkPN "Samoa") ;
SanMarino = UsePN (mkPN "San Marino") ;
SantiagoChile = UsePN (mkPN "Santiago de Chile") ;
SaudiArabia = UsePN (mkPN "Arabia Saudită") ;
Senegal = UsePN (mkPN "Senegal") ;
Seychelles = UsePN (mkPN "Seychelles") ;
SierraLeone = UsePN (mkPN "Sierra Leone") ;
Singapore = UsePN (mkPN "Singapore") ;
Slovakia = UsePN (mkPN "Slovacia") ;
Slovenia = UsePN (mkPN "Slovenia") ;
SolomonIslands = UsePN (mkPN "Insulele Solomon") ;
Somalia = UsePN (mkPN "Somalia") ;
SouthAfrica = UsePN (mkPN "Africa de Sud") ;
SouthKorea = UsePN (mkPN "Coreea de Sud") ;
Spain = UsePN (mkPN "Spania") ;
SriLanka = UsePN (mkPN "Sri Lanka") ;
Sudan = UsePN (mkPN "Sudan") ;
Suriname = UsePN (mkPN "Surinam") ;
Swaziland = UsePN (mkPN "Swaziland") ;
Sweden = UsePN (mkPN "Suedia") ;
Switzerland = UsePN (mkPN "Elveţia" | mkPN "Eleveţia") ;
Syria = UsePN (mkPN "Siria") ;
Taiwan = UsePN (mkPN "Taiwan") ;
Tajikistan = UsePN (mkPN "Tajikistan" | mkPN "Tadjikistan") ;
Tanzania = UsePN (mkPN "Tanzania") ;
TelAvivIsrael = UsePN (mkPN "Tel Aviv") ;
Thailand = UsePN (mkPN "Thailanda" | mkPN "Tailanda") ;
Togo = UsePN (mkPN "Togo") ;
Tokelau = UsePN (mkPN "Tokelau") ;
Tonga = UsePN (mkPN "Tonga") ;
Tunisia = UsePN (mkPN "Tunisia") ;
Turkey = UsePN (mkPN "Turcia") ;
Turkmenistan = UsePN (mkPN "Turkmenia" | mkPN "Turkmenistan") ;
Tuvalu = UsePN (mkPN "Tuvalu") ;
Uganda = UsePN (mkPN "Uganda") ;
Ukraine = UsePN (mkPN "Ucraina") ;
UnitedArabEmirates = UsePN (mkPN "Emiratele Arabe Unite") ;
UnitedKingdom = UsePN (mkPN "Regatul Unit" | mkPN "Marea Britanie") ;
UnitedStates = UsePN (mkPN "Statele Unite" | mkPN "Statele Unite ale Americii") ;
Uruguay = UsePN (mkPN "Uruguay") ;
Uzbekistan = UsePN (mkPN "Uzbekistan") ;
Vanuatu = UsePN (mkPN "Vanuatu") ;
Venezuela = UsePN (mkPN "Venezuela") ;
Vietnam = UsePN (mkPN "Vietnam") ;
WesternSahara = UsePN (mkPN "Sahara de Vest") ;
Yemen = UsePN (mkPN "Yemen") ;
Zambia = UsePN (mkPN "Zambia") ;
Zimbabwe = UsePN (mkPN "Zimbabwe") ;
};

2328
examples/SUMO/Economy.gf
View File

File diff suppressed because it is too large Load Diff

13
examples/SUMO/EconomyEng.gf
View File

@@ -1,13 +0,0 @@
concrete EconomyEng of Economy = MidLevelOntologyEng ** open DictLangEng, DictEng, ParadigmsEng in {
lin
Apple = UseN apple_N ;
Avocado = UseN avocado_N ;
Coconut = UseN coconut_N ;
DateFruit = ApposCN (UseN date_N) (MassNP (UseN fruit_N)) ;
Fodder = UseN fodder_N ;
Hay = UseN hay_N ;
Opium = UseN opium_N ;
Pea = UseN pea_N ;
}

6
examples/SUMO/EconomyFre.gf
View File

@@ -1,6 +0,0 @@
concrete EconomyFre of Economy = MidLevelOntologyFre ** open DictLangFre, LexiconFre in {
lin
Apple = UseN apple_N ;
}

6
examples/SUMO/EconomyRon.gf
View File

@@ -1,6 +0,0 @@
concrete EconomyRon of Economy = MidLevelOntologyRon ** open DictLangRon, LexiconRon in {
lin
Apple = UseN apple_N ;
}

929
examples/SUMO/Elements.gf
View File

@@ -1,929 +0,0 @@
abstract Elements = Merge ** {
-- Silvery radioactive metallic element, belongs to
-- group 3 of the periodic table. The most stable isotope, Ac_227, has a
-- half_life of 217 years. Ac_228 (half_life of 6.13 hours) also occurs in
-- nature. There are 22 other artificial isotopes, all radioactive and
-- having very short half_lives. Chemistry similar to lanthanum. Used as a
-- source of alpha particles. Discovered by A. Debierne in 1899.
fun Actinium : Class ;
fun Actinium_Class : SubClass Actinium ElementalSubstance ;
-- Silvery_white lustrous metallic element of group
-- 3 of the periodic table. Highly reactive but protected by a thin
-- transparent layer of the oxide which quickly forms in air. There are many
-- alloys of aluminum, as well as a good number of industrial uses. Makes up
-- 8.1 percent of the Earth's crust, by weight. Isolated in 1825 by H.C.
-- Oersted.
fun Aluminum : Class ;
fun Aluminum_Class : SubClass Aluminum ElementalSubstance ;
-- Radioactive metallic transuranic element,
-- belongs to the actinoids. Ten known isotopes. Am_243 is the most stable
-- isotope, with a half_life of 7.95*10^3 years. Discovered by Glenn T.
-- Seaborg and associates in 1945, it was obtained by bombarding
-- {uranium}_238 with alpha particles.
fun Americium : Class ;
fun Americium_Class : SubClass Americium ElementalSubstance ;
-- Element of group 15. Multiple allotropic forms.
-- The stable form of antimony is a blue_white metal. Yellow and black
-- antimony are unstable non_metals. Used in flame_proofing, paints,
-- ceramics, enamels, and rubber. Attacked by oxidizing acids and halogens.
-- First reported by Tholden in 1450.
fun Antimony : Class ;
fun Antimony_Class : SubClass Antimony ElementalSubstance ;
-- Monatomic noble gas. Makes up 0.93 percent of the
-- air. Colourless, odorless. Is inert and has no true compounds. Lord
-- Rayleigh and Sir william Ramsey identified argon in 1894.
fun Argon : Class ;
fun Argon_Class : SubClass Argon ElementalSubstance ;
-- Metalloid element of group 15. There are three
-- allotropes, yellow, black, and grey. Reacts with halogens, concentrated
-- oxidizing acids and hot alkalis. Albertus Magnus is believed to have been
-- the first to isolate the element in 1250.
fun Arsenic : Class ;
fun Arsenic_Class : SubClass Arsenic ElementalSubstance ;
-- Radioactive halogen element. Occurs naturally
-- from uranium and thorium decay. At least 20 known isotopes. At_210, the
-- most stable, has a half_life of 8.3 hours. Synthesized by nuclear
-- bombardment in 1940 by D.R. Corson, K.R. MacKenzie and E. Segre at the
-- University of California.
fun Astatine : Class ;
fun Astatine_Class : SubClass Astatine ElementalSubstance ;
-- Silvery_white reactive element, belonging to group
-- 2 of the periodic table. Soluble barium compounds are extremely
-- poisonous. Identified in 1774 by Karl Scheele and extracted in 1808 by
-- Humphry Davy.
fun Barium : Class ;
fun Barium_Class : SubClass Barium ElementalSubstance ;
-- Radioactive metallic transuranic element.
-- Belongs to actinoid series. Eight known isotopes, the most common Bk_247,
-- has a half_life of 1.4*10^3 years. First produced by Glenn T. Seaborg
-- and associates in 1949 by bombarding americium_241 with alpha
-- particles.
fun Berkelium : Class ;
fun Berkelium_Class : SubClass Berkelium ElementalSubstance ;
-- Grey metallic element of group 2 of the periodic
-- table. Is toxic and can cause severe lung diseases and dermatitis. Shows
-- high covalent character. It was isolated independently by F. Wohler and
-- A.A. Bussy in 1828.
fun Beryllium : Class ;
fun Beryllium_Class : SubClass Beryllium ElementalSubstance ;
-- White crystalline metal with a pink tinge, belongs
-- to group 15. Most diamagnetic of all metals and has the lowest thermal
-- conductivity of all the elements except mercury. Lead_free bismuth
-- compounds are used in cosmetics and medical procedures. Burns in the air
-- and produces a blue flame. In 1753, C.G. Junine first demonstrated that
-- it was different from lead.
fun Bismuth : Class ;
fun Bismuth_Class : SubClass Bismuth ElementalSubstance ;
-- An element of group 13 of the periodic table. There
-- are two allotropes, amorphous boron is a brown power, but metallic boron
-- is black. The metallic form is hard (9.3 on Mohs' scale) and a bad
-- conductor in room temperatures. It is never found free in nature.
-- Boron_10 is used in nuclear reactor control rods and shields. It was
-- discovered in 1808 by Sir Humphry Davy and by J.L. Gay_Lussac and L.J.
-- Thenard.
fun Boron : Class ;
fun Boron_Class : SubClass Boron ElementalSubstance ;
-- Halogen element. Red volatile liquid at room
-- temperature. Its reactivity is somewhere between chlorine and iodine.
-- Harmful to human tissue in a liquid state, the vapour irritates eyes and
-- throat. Discovered in 1826 by Antoine Balard.
fun Bromine : Class ;
fun Bromine_Class : SubClass Bromine ElementalSubstance ;
-- Soft bluish metal belonging to group 12 of the
-- periodic table. Extremely toxic even in low concentrations. Chemically
-- similar to zinc, but lends itself to more complex compounds. Discovered
-- in 1817 by F. Stromeyer.
fun Cadmium : Class ;
fun Cadmium_Class : SubClass Cadmium ElementalSubstance ;
-- Soft silvery_white metallic element belonging to
-- group 1 of the periodic table. One of the three metals which are liquid
-- at room temperature. Cs_133 is the natural, and only stable, isotope.
-- Fifteen other radioisotopes exist. Caesium reacts explosively with cold
-- water, and ice at temperatures above 157K. Caesium hydroxide is the
-- strongest base known. Caesium is the most electropositive, most alkaline
-- and has the least ionization potential of all the elements. Known uses
-- include the basis of atomic clocks, catalyst for the hydrogenation of some
-- organic compounds, and in photoelectric cells. Caesium was discovered by
-- Gustav Kirchoff and Robert Bunsen in Germany in 1860 spectroscopically.
-- Its identification was based upon the bright blue lines in its spectrum.
-- The name comes from the latin word caesius, which means sky blue. Caesium
-- should be considered highly toxic. Some of the radioisotopes are even
-- more toxic.
fun Caesium : Class ;
fun Caesium_Class : SubClass Caesium ElementalSubstance ;
-- Soft grey metallic element belonging to group 2 of
-- the periodic table. Used a reducing agent in the extraction of thorium,
-- zirconium and uranium. Essential element for living organisms.
fun Calcium : Class ;
fun Calcium_Class : SubClass Calcium ElementalSubstance ;
-- Radioactive metallic transuranic element.
-- Belongs to actinoid series. Cf_251 has a half life of about 700 years.
-- Nine isotopes are known. Cf_252 is an intense {neutron} source, which
-- makes it an intense {neutron} source and gives it a use in {neutron}
-- activation analysis and a possible use as a radiation source in medicine.
-- First produced by Glenn T. Seaborg and associates in 1950.
fun Californium : Class ;
fun Californium_Class : SubClass Californium ElementalSubstance ;
-- Carbon is a member of group 14 of the periodic
-- table. It has three allotropic forms of it, diamonds, graphite and
-- fullerite. Carbon_14 is commonly used in radioactive dating. Carbon
-- occurs in all organic life and is the basis of organic chemistry. Carbon
-- has the interesting chemical property of being able to bond with itself,
-- and a wide variety of other elements.
fun Carbon : Class ;
fun Carbon_Class : SubClass Carbon ElementalSubstance ;
-- Silvery metallic element, belongs to the
-- lanthanoids. Four natural isotopes exist, and fifteen radioactive
-- isotopes have been identified. Used in some rare_earth alloys. The
-- oxidized form is used in the glass industry. Discovered by Martin .H.
-- Klaproth in 1803.
fun Cerium : Class ;
fun Cerium_Class : SubClass Cerium ElementalSubstance ;
-- Halogen element. Poisonous greenish_yellow gas.
-- Occurs widely in nature as sodium chloride in seawater. Reacts directly
-- with many elements and compounds, strong oxidizing agent. Discovered by
-- Karl Scheele in 1774. Humphrey David confirmed it as an element in
-- 1810.
fun Chlorine : Class ;
fun Chlorine_Class : SubClass Chlorine ElementalSubstance ;
-- Hard silvery transition element. Used in
-- decorative electroplating. Discovered in 1797 by Vauquelin.
fun Chromium : Class ;
fun Chromium_Class : SubClass Chromium ElementalSubstance ;
-- Light grey transition element. Some meteorites
-- contain small amounts of metallic cobalt. Generally alloyed for use.
-- Mammals require small amounts of cobalt salts. Cobalt_60, an artificially
-- produced radioactive isotope of Cobalt is an important radioactive tracer
-- and cancer_treatment agent. Discovered by G. Brandt in 1737.
fun Cobalt : Class ;
fun Cobalt_Class : SubClass Cobalt ElementalSubstance ;
-- Red_brown transition element. Known by the Romans
-- as 'cuprum.' Extracted and used for thousands of years. Malleable,
-- ductile and an excellent conductor of heat and electricity. When in moist
-- conditions, a greenish layer forms on the outside.
fun Copper : Class ;
fun Copper_Class : SubClass Copper ElementalSubstance ;
-- Radioactive metallic transuranic element. Belongs
-- to actinoid series. Nine known isotopes, Cm_247 has a half_life of
-- 1.64*10^7 years. First identified by Glenn T. Seaborg and associates in
-- 1944, first produced by L.B. Werner and I. Perlman in 1947 by bombarding
-- americium_241 with {neutron}s. Named for Marie Curie.
fun Curium : Class ;
fun Curium_Class : SubClass Curium ElementalSubstance ;
-- Metallic with a bright silvery_white lustre.
-- Dysprosium belongs to the lanthanoids. It is relatively stable in air at
-- room temperatures, it will however dissolve in mineral acids, evolving
-- hydrogen. It is found in from rare_earth minerals. There are seven
-- natural isotopes of dysprosium, and eight radioisotopes, Dy_154 being the
-- most stable with a half_life of 3*10^6 years. Dysprosium is used as a
-- neutron absorber in nuclear fission reactions, and in compact disks. It
-- was discovered by Paul Emile Lecoq de Boisbaudran in 1886 in France. Its
-- name comes from the Greek word dysprositos, which means hard to obtain.
fun Dysprosium : Class ;
fun Dysprosium_Class : SubClass Dysprosium ElementalSubstance ;
-- Appearance is unknown, however it is most
-- probably metallic and silver or gray in color. Radioactive metallic
-- transuranic element belonging to the actinoids. Es_254 has the longest
-- half_life of the eleven known isotopes at 270 days. First identified by
-- Albert Ghiorso and associates in the debris of the 1952 hydrogen bomb
-- explosion. In 1961 the first microgram quantities of Es_232 were
-- separated. While einsteinium never exists naturally, if a sufficient
-- amount was assembled, it would pose a radiation hazard.
fun Einsteinium : Class ;
fun Einsteinium_Class : SubClass Einsteinium ElementalSubstance ;
-- Soft silvery metallic element which belongs to the
-- lanthanoids. Six natural isotopes that are stable. Twelve artificial
-- isotopes are known. Used in nuclear technology as a neutron absorber. It
-- is being investigated for other possible uses. Discovered by Carl G.
-- Mosander in 1843.
fun Erbium : Class ;
fun Erbium_Class : SubClass Erbium ElementalSubstance ;
-- Soft silvery metallic element belonging to the
-- lanthanoids. Eu_151 and Eu_153 are the only two stable isotopes, both of
-- which are {neutron} absorbers. Discovered in 1889 by Sir William
-- Crookes.
fun Europium : Class ;
fun Europium_Class : SubClass Europium ElementalSubstance ;
-- Radioactive metallic transuranic element, belongs
-- to the actinoids. Ten known isotopes, most stable is Fm_257 with a
-- half_life of 10 days. First identified by Albert Ghiorso and associates
-- in the debris of the first hydrogen_bomb explosion in 1952.
fun Fermium : Class ;
fun Fermium_Class : SubClass Fermium ElementalSubstance ;
-- A poisonous pale yellow gaseous element belonging
-- to group 17 of the periodic table (The halogens). It is the most
-- chemically reactive and electronegative element. It is highly dangerous,
-- causing severe chemical burns on contact with flesh. Fluorine was
-- identified by Scheele in 1771 and first isolated by Moissan in 1886.
fun Fluorine : Class ;
fun Fluorine_Class : SubClass Fluorine ElementalSubstance ;
-- Radioactive element, belongs to group 1 of the
-- periodic table. Found in uranium and thorium ores. The 22 known isotopes
-- are all radioactive, with the most stable being Fr_223. Its existence was
-- confirmed in 1939 by Marguerite Perey.
fun Francium : Class ;
fun Francium_Class : SubClass Francium ElementalSubstance ;
-- Soft silvery metallic element belonging to the
-- lanthanoids. Seven natural, stable isotopes are known in addition to
-- eleven artificial isotopes. Gd_155 and Gd_157 and the best neutron
-- absorbers of all elements. Gadolinium compounds are used in electronics.
-- Discovered by J.C.G Marignac in 1880.
fun Gadolinium : Class ;
fun Gadolinium_Class : SubClass Gadolinium ElementalSubstance ;
-- Soft silvery metallic element, belongs to group 13
-- of the periodic table. The two stable isotopes are Ga_69 and Ga_71.
-- Eight radioactive isotopes are known, all having short half_lives.
-- Gallium Arsenide is used as a semiconductor. Corrodes most other metals
-- by diffusing into their lattice. First identified by Francois Lecoq de
-- Boisbaudran in 1875.
fun Gallium : Class ;
fun Gallium_Class : SubClass Gallium ElementalSubstance ;
-- Lustrous hard metalloid element, belongs to
-- group 14 of the periodic table. Forms a large number of organometallic
-- compounds. Predicted by Mendeleev in 1871, it was actually found in 1886
-- by Winkler.
fun Germanium : Class ;
fun Germanium_Class : SubClass Germanium ElementalSubstance ;
-- Gold is gold colored. It is the most malleable and
-- ductile metal known. There is only one stable isotope of gold, and five
-- radioisotopes of gold, Au_195 being the most stable with a half_life of
-- 186 days. Gold is used as a monetary standard, in jewelry, dentistry,
-- electronics. Au_198 is used in treating cancer and some other medical
-- conditions. Gold has been known to exist as far back as 2600 BC. Gold
-- comes from the Anglo_Saxon word gold. Its symbol, Au, comes from the
-- Latin word aurum, which means gold. Gold is not particularly toxic,
-- however it is known to cause damage to the liver and kidneys in some.
fun Gold : Class ;
fun Gold_Class : SubClass Gold ElementalSubstance ;
-- Silvery lustrous metallic transition element.
-- Used in tungsten alloys in filaments and electrodes, also acts as a
-- neutron absorber. First reported by Urbain in 1911, existence was finally
-- established in 1923 by D. Coster, G.C. de Hevesy in 1923.
fun Hafnium : Class ;
fun Hafnium_Class : SubClass Hafnium ElementalSubstance ;
-- Colourless, odourless gaseous nonmetallic element.
-- Belongs to group 18 of the periodic table. Lowest boiling point of all
-- elements and can only be solidified under pressure. Chemically inert, no
-- known compounds. Discovered in the solar spectrum in 1868 by Lockyer.
fun Helium : Class ;
fun Helium_Class : SubClass Helium ElementalSubstance ;
-- Relatively soft and malleable silvery_white
-- metallic element, which is stable in dry air at room temperature. It
-- oxidizes in moist air and at high temperatures. It belongs to the
-- lanthanoids. A rare_earth metal, it is found in the minerals monazite and
-- gadolinite. It possesses unusual magnetic properties. One natural
-- isotope, Ho_165 exists, six radioisotopes exist, the most stable being
-- Ho_163 with a half_life of 4570 years. Holmium is used in some metal
-- alloys, it is also said to stimulate the metabolism. Discovered by Per
-- Theodor Cleve and J.L. Soret in Switzerland in 1879. The name homium
-- comes from the Greek word Holmia which means Sweden. While all holmium
-- compounds should be considered highly toxic, initial evidence seems to
-- indicate that they do not pose much danger. The metal's dust however, is
-- a fire hazard.
fun Holmium : Class ;
fun Holmium_Class : SubClass Holmium ElementalSubstance ;
-- Colourless, odourless gaseous chemical element.
-- Lightest and most abundant element in the universe. Present in water and
-- in all organic compounds. Chemically reacts with most elements.
-- Discovered by Henry Cavendish in 1776.
fun Hydrogen : Class ;
fun Hydrogen_Class : SubClass Hydrogen ElementalSubstance ;
-- Soft silvery element belonging to group 13 of the
-- periodic table. The most common natural isotope is In_115, which has a
-- half_life of 6*10^4 years. Five other radioisotopes exist. Discovered in
-- 1863 by Reich and Richter.
fun Indium : Class ;
fun Indium_Class : SubClass Indium ElementalSubstance ;
-- Dark violet nonmetallic element, belongs to group
-- 17 of the periodic table. Insoluble in water. Required as a trace
-- element for living organisms. One stable isotope, I_127 exists, in
-- addition to fourteen radioactive isotopes. Chemically the least reactive
-- of the halogens, and the most electropositive metallic halogen.
-- Discovered in 1812 by Courtois.
fun Iodine : Class ;
fun Iodine_Class : SubClass Iodine ElementalSubstance ;
-- Very hard and brittle, silvery metallic transition
-- element. It has a yellowish cast to it. Salts of iridium are highly
-- colored. It is the most corrosion resistant metal known, not attacked by
-- any acid, but is attacked by molten salts. There are two natural isotopes
-- of iridium, and 4 radioisotopes, the most stable being Ir_192 with a
-- half_life of 73.83 days. Ir_192 decays into {platinum}, while the other
-- radioisotopes decay into {osmium}. Iridium is used in high temperature
-- apparatus, electrical contacts, and as a hardening agent for platinum.
-- Discovered in 1803 by Smithson Tennant in England. The name comes from
-- the Greek word iris, which means rainbow. Iridium metal is generally
-- non_toxic due to its relative unreactivity, but iridium compounds should
-- be considered highly toxic.
fun Iridium : Class ;
fun Iridium_Class : SubClass Iridium ElementalSubstance ;
-- Silvery malleable and ductile metallic transition
-- element. Has nine isotopes and is the fourth most abundant element in the
-- earth's crust. Required by living organisms as a trace element (used in
-- hemoglobin in humans.) Quite reactive, oxidizes in moist air, displaces
-- hydrogen from dilute acids and combines with nonmetallic elements.
fun Iron : Class ;
fun Iron_Class : SubClass Iron ElementalSubstance ;
-- Colorless gaseous element, belongs to the noble
-- gases. Occurs in the air, 0.0001 percent by volume. It can be extracted
-- from liquid air by fractional distillation. Generally not isolated, but
-- used with other inert gases in fluorescent lamps. Five natural isotopes,
-- and five radioactive isotopes. Kr_85, the most stable radioactive
-- isotope, has a half_life of 10.76 years and is produced in fission
-- reactors. Practically inert, though known to form compounds with
-- {fluorine}.
fun Krypton : Class ;
fun Krypton_Class : SubClass Krypton ElementalSubstance ;
-- (From the Greek word lanthanein, to line hidden)
-- Silvery metallic element belonging to group 3 of the periodic table and
-- oft considered to be one of the lanthanoids. Found in some rare_earth
-- minerals. Twenty_five natural isotopes exist. La_139 which is stable,
-- and La_138 which has a half_life of 10^10 to 10^15 years. The other
-- twenty_three isotopes are radioactive. It resembles the lanthanoids
-- chemically. Lanthanum has a low to moderate level of toxicity, and should
-- be handled with care. Discovered in 1839 by C.G. Mosander.
fun Lanthanum : Class ;
fun Lanthanum_Class : SubClass Lanthanum ElementalSubstance ;
-- Appearance unknown, however it is most likely
-- silvery_white or grey and metallic. Lawrencium is a synthetic rare_earth
-- metal. There are eight known radioisotopes, the most stable being Lr_262
-- with a half_life of 3.6 hours. Due to the short half_life of lawrencium,
-- and its radioactivity, there are no known uses for it. Identified by
-- Albert Ghiorso in 1961 at Berkeley. It was produced by bombarding
-- californium with boron ions. The name is temporary {IUPAC} nomenclature,
-- the origin of the name comes from Ernest O. Lawrence, the inventor of the
-- cyclotron. If sufficient amounts of lawrencium were produced, it would
-- pose a radiation hazard.
fun Lawrencium : Class ;
fun Lawrencium_Class : SubClass Lawrencium ElementalSubstance ;
-- Heavy dull grey ductile metallic element, belongs to
-- group 14. Used in building construction, lead_place accumulators, bullets
-- and shot, and is part of solder, pewter, bearing metals, type metals and
-- fusible alloys.
fun Lead : Class ;
fun Lead_Class : SubClass Lead ElementalSubstance ;
-- Socket silvery metal. First member of group 1 of
-- the periodic table. Lithium salts are used in psychomedicine.
fun Lithium : Class ;
fun Lithium_Class : SubClass Lithium ElementalSubstance ;
-- Silvery_white rare_earth metal which is
-- relatively stable in air. It happens to be the most expensive rare_earth
-- metal. Its found with almost all rare_earth metals, but is very difficult
-- to separate from other elements. Least abundant of all natural elements.
-- Used in metal alloys, and as a catalyst in various processes. There are
-- two natural, stable isotopes, and seven radioisotopes, the most stable
-- being Lu_174 with a half_life of 3.3 years. The separation of lutetium
-- from {ytterbium} was described by Georges Urbain in 1907. It was
-- discovered at approximately the same time by Carl Auer von Welsbach. The
-- name comes from the Greek word lutetia which means Paris.
fun Lutetium : Class ;
fun Lutetium_Class : SubClass Lutetium ElementalSubstance ;
-- Silvery metallic element belonging to group 2 of
-- the periodic table (alkaline_earth metals). It is essential for living
-- organisms, and is used in a number of light alloys. Chemically very
-- reactive, it forms a protective oxide coating when exposed to air and
-- burns with an intense white flame. It also reacts with sulphur, nitrogen
-- and the halogens. First isolated by Bussy in 1828.
fun Magnesium : Class ;
fun Magnesium_Class : SubClass Magnesium ElementalSubstance ;
-- Grey brittle metallic transition element.
-- Rather electropositive, combines with some non_metals when heated.
-- Discovered in 1774 by Scheele.
fun Manganese : Class ;
fun Manganese_Class : SubClass Manganese ElementalSubstance ;
-- Half_life of approximately 5ms. The creation
-- of this element demonstrated that fusion techniques could indeed be used
-- to make new, heavy nuclei. Made and identified by physicists of the Heavy
-- Ion Research Laboratory, Darmstadt, West Germany in 1982. Named in honor
-- of Lise Meitner the Austrian physicist.
fun Meitnerium : Class ;
fun Meitnerium_Class : SubClass Meitnerium ElementalSubstance ;
-- Radioactive metallic transuranic element.
-- Belongs to the actinoid series. Only known isotope, Md_256 has a
-- half_life of 1.3 hours. First identified by Glenn T. Seaborg, Albert
-- Ghiorso and associates in 1955. Alternative name {unnilunium} has been
-- proposed. Named after the 'inventor' of the periodic table, Dmitri
-- Mendeleev.
fun Mendelevium : Class ;
fun Mendelevium_Class : SubClass Mendelevium ElementalSubstance ;
-- Heavy silvery liquid metallic element, belongs to
-- the zinc group. Used in thermometers, barometers and other scientific
-- apparatus. Less reactive than zinc and cadmium, does not displace
-- hydrogen from acids. Forms a number of complexes and organomercury
-- compounds.
fun Mercury : Class ;
fun Mercury_Class : SubClass Mercury ElementalSubstance ;
-- Silvery_white, hard metallic transition
-- element. It is chemically unreactive and is not affected by most acids.
-- It oxidizes at high temperatures. There are seven natural isotopes, and
-- four radioisotopes, Mo_93 being the most stable with a half_life of 3500
-- years. Molybdenum is used in almost all high_strength steels, it has
-- nuclear applications, and is a catalyst in petroleum refining. Discovered
-- in 1778 by Carl Welhelm Scheele of Sweden. Impure metal was prepared in
-- 1782 by Peter Jacob Hjelm. The name comes from the Greek word molybdos
-- which means lead. Trace amounts of molybdenum are required for all known
-- forms of life. All molybdenum compounds should be considered highly
-- toxic, and will also cause severe birth defects.
fun Molybdenum : Class ;
fun Molybdenum_Class : SubClass Molybdenum ElementalSubstance ;
-- Soft bright silvery metallic element, belongs to
-- the lanthanoids. Seven natural isotopes, Nd_144 being the only
-- radioactive one with a half_life of 10^10 to 10^15 years. Six artificial
-- radioisotopes have been produced. The metal is used in glass works to
-- color class a shade of violet_purple and make it dichroic. One of the
-- more reactive rare_earth metals, quickly reacts with air. Used in some
-- rare_earth alloys. Neodymium is used to color the glass used in welder's
-- glasses. Neodymium is also used in very powerful, permanent magnets
-- (Nd2Fe14B). Discovered by Carl F. Auer von Welsbach in Austria in 1885
-- by separating didymium into its elemental components {praseodymium} and
-- neodymium. The name comes from the Greek words 'neos didymos' which means
-- 'new twin'. Neodymium should be considered highly toxic, however evidence
-- would seem to show that it acts as little more than a skin and eye
-- irritant. The dust however, presents a fire and explosion hazard.
fun Neodymium : Class ;
fun Neodymium_Class : SubClass Neodymium ElementalSubstance ;
-- Colourless gaseous element of group 18 on the
-- periodic table (noble gases). Neon occurs in the atmosphere, and
-- comprises 0.0018 percent of the volume of the atmosphere. It has a
-- distinct reddish glow when used in discharge tubes and neon based lamps.
-- It forms almost no chemical compounds. Neon was discovered in 1898 by Sir
-- William Ramsey and M.W. Travers.
fun Neon : Class ;
fun Neon_Class : SubClass Neon ElementalSubstance ;
-- Radioactive metallic transuranic element,
-- belongs to the actinoids. Np_237, the most stable isotope, has a
-- half_life of 2.2*10^6 years and is a by product of nuclear reactors. The
-- other known isotopes have mass numbers 229 through 236, and 238 through
-- 241. Np_236 has a half_life of 5*10^3 years. First produced by Edwin M.
-- McMillan and P.H. Abelson in 1940.
fun Neptunium : Class ;
fun Neptunium_Class : SubClass Neptunium ElementalSubstance ;
-- Malleable ductile silvery metallic transition
-- element. Discovered by A.F. Cronstedt in 1751.
fun Nickel : Class ;
fun Nickel_Class : SubClass Nickel ElementalSubstance ;
-- Soft, ductile grey_blue metallic transition
-- element. Used in special steels and in welded joints to increase
-- strength. Combines with halogens and oxidizes in air at 200 degrees
-- celsius. Discovered by Charles Hatchett in 1801 and isolated by
-- Blomstrand in 1864. Called {columbium} originally.
fun Niobium : Class ;
fun Niobium_Class : SubClass Niobium ElementalSubstance ;
-- Colourless, gaseous element which belongs to
-- group 15 of the periodic table. Constitutes ~78 percent of the atmosphere
-- and is an essential part of the ecosystem. Nitrogen for industrial
-- purposes is acquired by the fractional distillation of liquid air.
-- Chemically inactive, reactive generally only at high temperatures or in
-- electrical discharges. It was discovered in 1772 by D. Rutherford.
fun Nitrogen : Class ;
fun Nitrogen_Class : SubClass Nitrogen ElementalSubstance ;
-- Radioactive metallic transuranic element, belongs
-- to the actinoids. Seven known isotopes exist, the most stable being
-- No_254 with a half_life of 255 seconds. First identified with certainty
-- by Albert Ghiorso and Glenn T. Seaborg in 1966. {Unnilbium} has been
-- proposed as an alternative name.
fun Nobelium : Class ;
fun Nobelium_Class : SubClass Nobelium ElementalSubstance ;
-- Hard blue_white metallic transition element. Found
-- with platinum and used in some alloys with platinum and iridium.
fun Osmium : Class ;
fun Osmium_Class : SubClass Osmium ElementalSubstance ;
-- A colourless, odourless gaseous element belonging
-- to group 16 of the periodic table. It is the most abundant element
-- present in the earth's crust. It also makes up 20.8 percent of the
-- Earth's atmosphere. For industrial purposes, it is separated from liquid
-- air by fractional distillation. It is used in high temperature welding,
-- and in breathing. It commonly comes in the form of Oxygen, but is found
-- as Ozone in the upper atmosphere. It was discovered by Priestley in
-- 1774.
fun Oxygen : Class ;
fun Oxygen_Class : SubClass Oxygen ElementalSubstance ;
-- Soft white ductile transition element. Found
-- with some copper and nickel ores. Does not react with oxygen at normal
-- temperatures. Dissolves slowly in hydrochloric acid. Discovered in 1803
-- by W.H. Wollaston.
fun Palladium : Class ;
fun Palladium_Class : SubClass Palladium ElementalSubstance ;
-- Non_metallic element belonging to group 15 of
-- the periodic table. Has a multiple allotropic forms. Essential element
-- for living organisms. It was discovered by Brandt in 1669.
fun Phosphorus : Class ;
fun Phosphorus_Class : SubClass Phosphorus ElementalSubstance ;
-- Attractive greyish_white metal. When pure, it is
-- malleable and ductile. Does not oxidize in air, insoluble in hydrochloric
-- and nitric acid. Corroded by halogens, cyandies, sulphur and alkalis.
-- {Hydrogen} and {oxygen} react explosively in the presence of platinum.
-- There are six stable isotopes and three radioisotopes, the most stable
-- being Pt_193 with a half_life of 60 years. Platinum is used in jewelry,
-- laboratory equipment, electrical contacts, dentistry, and anti_pollution
-- devices in cars. PtCl2(NH3)2 is used to treat some forms of cancer.
-- Platinum_{cobalt} alloys have magnetic properties. It is also used in the
-- definition of the Standard Hydrogen Electrode. Discovered by Antonio de
-- Ulloa in South America in 1735. The name comes from the Spanish word
-- platina which means silver. Platinum metal is generally not a health
-- concern due to its unreactivity, however platinum compounds should be
-- considered highly toxic.
fun Platinum : Class ;
fun Platinum_Class : SubClass Platinum ElementalSubstance ;
-- Dense silvery radioactive metallic transuranic
-- element, belongs to the actinoids. Pu_244 is the most stable isotope with
-- a half_life of 7.6*10^7 years. Thirteen isotopes are known. Pu_239 is
-- the most important, it undergoes nuclear fission with slow neutrons and is
-- hence important to nuclear weapons and reactors. Plutonium production is
-- monitored down to the gram to prevent military misuse. First produced by
-- Gleen T. Seaborg, Edwin M. McMillan, J.W. Kennedy and A.C. Wahl in
-- 1940.
fun Plutonium : Class ;
fun Plutonium_Class : SubClass Plutonium ElementalSubstance ;
-- Rare radioactive metallic element, belongs to
-- group 16 of the periodic table. Over 30 known isotopes exist, the most of
-- all elements. Po_209 has a half_life of 103 years. Possible uses in
-- heating spacecraft. Discovered by Marie Curie in 1898 in a sample of
-- pitchblende.
fun Polonium : Class ;
fun Polonium_Class : SubClass Polonium ElementalSubstance ;
-- Soft silvery metallic element belonging to group
-- 1 of the periodic table (alkali metals). Occurs naturally in seawater and
-- a many minerals. Highly reactive, chemically, it resembles sodium in its
-- behavior and compounds. Discovered by Sir Humphry Davy in 1807.
fun Potassium : Class ;
fun Potassium_Class : SubClass Potassium ElementalSubstance ;
-- Soft silvery metallic element, belongs to the
-- lanthanoids. Only natural isotope is Pr_141 which is not radioactive.
-- Fourteen radioactive isotopes have been artificially produced. Used in
-- rare_earth alloys. Discovered in 1885 by C.A. von Welsbach.
fun Praseodymium : Class ;
fun Praseodymium_Class : SubClass Praseodymium ElementalSubstance ;
-- Soft silvery metallic element, belongs to the
-- lanthanoids. Pm_147, the only natural isotope, is radioactive and has a
-- half_life of 252 years. Eighteen radioisotopes have been produced, but
-- all have very short half_lives. Found only in nuclear decay waste.
-- Pm_147 is of interest as a beta_decay source, however Pm_146 and Pm_148
-- have to be removed from it first, as they generate gamma radiation.
-- Discovered by J.A. Marinsky, L.E. Glendenin and C.D. Coryell in
-- 1947.
fun Promethium : Class ;
fun Promethium_Class : SubClass Promethium ElementalSubstance ;
-- Radioactive metallic element, belongs to the
-- actinoids. The most stable isotope, Pa_231 has a half_life of 2.43*10^4
-- years. At least 10 other radioactive isotopes are known. No practical
-- applications are known. Discovered in 1917 by Lise Meitner and Otto
-- Hahn.
fun Protactinium : Class ;
fun Protactinium_Class : SubClass Protactinium ElementalSubstance ;
-- Radioactive metallic transuranic element, belongs
-- to group 2 of the periodic table. Most stable isotope, Ra_226 has a
-- half_life of 1602 years, which decays into radon. Isolated from
-- pitchblende in 1898 Marie and Pierre Curie.
fun Radium : Class ;
fun Radium_Class : SubClass Radium ElementalSubstance ;
-- Colorless radioactive gaseous element, belongs to
-- the noble gases. Of the twenty known isotopes, the most stable is Rn_222
-- with a half_life of 3.8 days. Formed by the radioactive decay of
-- {Radium}_226. Radon itself decays into {polonium}. Used in radiotherapy.
-- As a noble gas, it is effectively inert, though radon fluoride has been
-- synthesized. First isolated in 1908 by Ramsey and Gray.
fun Radon : Class ;
fun Radon_Class : SubClass Radon ElementalSubstance ;
-- Silvery_white metallic transition element.
-- Obtained as a by_product of molybdenum refinement. Rhenium_molybdenum
-- alloys are superconducting.
fun Rhenium : Class ;
fun Rhenium_Class : SubClass Rhenium ElementalSubstance ;
-- Silvery white metallic transition element. Found
-- with platinum and used in some platinum alloys. Not attacked by acids,
-- dissolves only in aqua regia. Discovered in 1803 by W.H. Wollaston.
fun Rhodium : Class ;
fun Rhodium_Class : SubClass Rhodium ElementalSubstance ;
-- Soft silvery metallic element, belongs to group 1
-- of the periodic table. Rb_97, the naturally occurring isotope, is
-- radioactive. It is highly reactive, with properties similar to other
-- elements in group 1, like igniting spontaneously in air. Discovered
-- spectroscopically in 1861 by W. Bunsen and G.R. Kirchoff.
fun Rubidium : Class ;
fun Rubidium_Class : SubClass Rubidium ElementalSubstance ;
-- Hard white metallic transition element. Found
-- with platinum, used as a catalyst in some platinum alloys. Dissolves in
-- fused alkalis, and is not attacked by acids. Reacts with halogens and
-- oxygen at high temperatures. Isolated in 1844 by K.K. Klaus.
fun Ruthenium : Class ;
fun Ruthenium_Class : SubClass Ruthenium ElementalSubstance ;
-- Soft silvery metallic element, belongs to the
-- lanthanoids. Seven natural isotopes, Sm_147 is the only radioisotope, and
-- has a half_life of 2.5*10^11 years. Used for making special alloys needed
-- in the production of nuclear reactors. Also used as a neutron absorber.
-- Small quantities of samarium oxide is used in special optical glasses.
-- The largest use of the element is its ferromagnetic alloy which produces
-- permanent magnets that are five times stronger than magnets produced by
-- any other material. Discovered by Francois Lecoq de Boisbaudran in
-- 1879.
fun Samarium : Class ;
fun Samarium_Class : SubClass Samarium ElementalSubstance ;
-- Rare soft silvery metallic element belonging to
-- group 3 of the periodic table. There are ten isotopes, nine of which are
-- radioactive and have short half_lives. Predicted in 1869 by Mendeleev,
-- isolated by Nilson in 1879.
fun Scandium : Class ;
fun Scandium_Class : SubClass Scandium ElementalSubstance ;
-- Metalloid element, belongs to group 16 of the
-- periodic table. Multiple allotropic forms exist. Chemically resembles
-- sulphur. Discovered in 1817 by Jons J. Berzelius.
fun Selenium : Class ;
fun Selenium_Class : SubClass Selenium ElementalSubstance ;
-- Metalloid element belonging to group 14 of the
-- periodic table. It is the second most abundant element in the Earth's
-- crust, making up 25.7 percent of it by weight. Chemically less reactive
-- than carbon. First identified by Lavoisier in 1787 and first isolated in
-- 1823 by Berzelius.
fun Silicon : Class ;
fun Silicon_Class : SubClass Silicon ElementalSubstance ;
-- White lustrous soft metallic transition element.
-- Found in both its elemental form and in minerals. Used in jewellery,
-- tableware and so on. Less reactive than silver, chemically.
fun Silver : Class ;
fun Silver_Class : SubClass Silver ElementalSubstance ;
-- Soft silvery reactive element belonging to group 1
-- of the periodic table (alkali metals). It is highly reactive, oxidizing
-- in air and reacting violently with water, forcing it to be kept under oil.
-- It was first isolated by Humphrey Davy in 1807.
fun Sodium : Class ;
fun Sodium_Class : SubClass Sodium ElementalSubstance ;
-- Soft yellowish metallic element, belongs to
-- group 2 of the periodic table. Highly reactive chemically. Sr_90 is
-- present in radioactive fallout and has a half_life of 28 years.
-- Discovered in 1798 by Klaproth and Hope, isolated in 1808 by Humphry
-- Davy.
fun Strontium : Class ;
fun Strontium_Class : SubClass Strontium ElementalSubstance ;
-- Yellow, nonmetallic element belonging to group 16
-- of the periodic table. It is an essential element in living organisms,
-- needed in the amino acids cysteine and methionine, and hence in many
-- proteins. Absorbed by plants from the soil as sulphate ion.
fun Sulphur : Class ;
fun Sulphur_Class : SubClass Sulphur ElementalSubstance ;
-- Heavy blue_grey metallic transition element.
-- Ta_181 is a stable isotope, and Ta_180 is a radioactive isotope, with a
-- half_life in excess of 10^7 years. Used in surgery as it is unreactive.
-- Forms a passive oxide layer in air. Identified in 1802 by Ekeberg and
-- isolated in 1820 by Jons J. Berzelius.
fun Tantalum : Class ;
fun Tantalum_Class : SubClass Tantalum ElementalSubstance ;
-- Radioactive metallic transition element. Can
-- be detected in some stars and the fission products of uranium. First made
-- by Perrier and Segre by bombarding molybdenum with deutrons, giving them
-- Tc_97. Tc_99 is the most stable isotope with a half_life of 2.6*10^6
-- years. Sixteen isotopes are known. Organic technetium compounds are used
-- in bone imaging. Chemical properties are intermediate between rhenium and
-- manganese.
fun Technetium : Class ;
fun Technetium_Class : SubClass Technetium ElementalSubstance ;
-- Silvery metalloid element of group 16. Eight
-- natural isotopes, nine radioactive isotopes. Used in semiconductors and
-- to a degree in some steels. Chemistry is similar to {sulphur}.
-- Discovered in 1782 by Franz Miller.
fun Tellurium : Class ;
fun Tellurium_Class : SubClass Tellurium ElementalSubstance ;
-- Silvery metallic element belonging to the
-- lanthanoids. Tb_159 is the only stable isotope, there are seventeen
-- artificial isotopes. Discovered by G.G. Mosander in 1843.
fun Terbium : Class ;
fun Terbium_Class : SubClass Terbium ElementalSubstance ;
-- Pure, unreacted thallium appears silvery_white
-- and exhibits a metallic lustre. Upon reacting with air, it begins to turn
-- bluish_grey and looks like lead. It is very malleable, and can be cut
-- with a knife. There are two stable isotopes, and four radioisotopes,
-- Tl_204 being the most stable with a half_life of 3.78 years. Thallium
-- sulphate was used as a rodenticide. Thallium sulphine's conductivity
-- changes with exposure to infrared light, this gives it a use in infrared
-- detectors. Discovered by Sir William Crookes via spectroscopy. Its name
-- comes from the Greek word thallos, which means green twig. Thallium and
-- its compounds are toxic and can cause cancer.
fun Thallium : Class ;
fun Thallium_Class : SubClass Thallium ElementalSubstance ;
-- Grey radioactive metallic element. Belongs to
-- actinoids. Found in monazite sand in Brazil, India and the US.
-- Thorium_232 has a half_life of 1.39x10^10 years. Can be used as a nuclear
-- fuel for breeder reactors. Thorium_232 captures slow {neutron}s and
-- breeds uranium_233. Discovered by Jons J. Berzelius in 1829.
fun Thorium : Class ;
fun Thorium_Class : SubClass Thorium ElementalSubstance ;
-- Soft grey metallic element that belongs to the
-- lanthanoids. One natural isotope exists, Tm_169, and seventeen artificial
-- isotopes have been produced. No known uses for the element. Discovered
-- in 1879 by Per Theodor Cleve.
fun Thulium : Class ;
fun Thulium_Class : SubClass Thulium ElementalSubstance ;
-- Silvery malleable metallic element belonging to group
-- 14 of the periodic table. Twenty_six isotopes are known, five of which
-- are radioactive. Chemically reactive. Combines directly with chlorine
-- and oxygen and displaces hydrogen from dilute acids.
fun Tin : Class ;
fun Tin_Class : SubClass Tin ElementalSubstance ;
-- White metallic transition element. Occurs in
-- numerous minerals. Used in strong, light corrosion_resistant alloys.
-- Forms a passive oxide coating when exposed to air. First discovered by
-- Gregor in 1789.
fun Titanium : Class ;
fun Titanium_Class : SubClass Titanium ElementalSubstance ;
-- White or grey metallic transition element,
-- formerly called {wolfram}. Forms a protective oxide in air and can be
-- oxidized at high temperature. First isolated by Jose and Fausto de
-- Elhuyer in 1783.
fun Tungsten : Class ;
fun Tungsten_Class : SubClass Tungsten ElementalSubstance ;
-- Half_life of approximately 10ms. Reported in
-- 1994 by German researchers at Darmstadt, Germany.
fun Unnildecium : Class ;
fun Unnildecium_Class : SubClass Unnildecium ElementalSubstance ;
-- Half_life of 0.9 +/_ 0.2 s. Discovered by the
-- Joint Institute for Nuclear Research at Dubna (U.S.S.R.) in June of 1974.
-- Its existence was confirmed by the Lawrence Berkeley Laboratory and
-- Livermore National Laboratory in September of 1974.
fun Unnilhexium : Class ;
fun Unnilhexium_Class : SubClass Unnilhexium ElementalSubstance ;
-- Radioactive transition metal.
fun Unniloctium : Class ;
fun Unniloctium_Class : SubClass Unniloctium ElementalSubstance ;
-- Radioactive transactinide element. Half_life
-- of 1.6s. Discovered in 1970 by Berkeley researchers. So far, seven
-- isotopes have been discovered.
fun Unnilpentium : Class ;
fun Unnilpentium_Class : SubClass Unnilpentium ElementalSubstance ;
-- Radioactive transactinide element. Expected
-- to have similar chemical properties to those displayed by hafnium. Rf_260
-- was discovered by the Joint Nuclear Research Institute at Dubna (U.S.S.R.)
-- in 1964. Researchers at Berkeley discovered Unq_257 and Unq_258 in
-- 1964.
fun Unnilquadium : Class ;
fun Unnilquadium_Class : SubClass Unnilquadium ElementalSubstance ;
-- Radioactive transition metal. Half_life of
-- approximately 1/500 s. Discovered by the Joint Institute for Nuclear
-- Research at Dubna (U.S.S.R.) in 1976. Confirmed by West German physicists
-- at the Heavy Ion Research Laboratory at Darmstadt.
fun Unnilseptium : Class ;
fun Unnilseptium_Class : SubClass Unnilseptium ElementalSubstance ;
-- White radioactive metallic element belonging to
-- the actinoids. Three natural isotopes, U_238, U_235 and U_234.
-- Uranium_235 is used as the fuel for nuclear reactors and weapons.
-- Discovered by Martin H. Klaproth in 1789.
fun Uranium : Class ;
fun Uranium_Class : SubClass Uranium ElementalSubstance ;
-- Soft and ductile, bright white metal. Good
-- resistance to corrosion by alkalis, sulphuric and hydrochloric acid. It
-- oxidizes readily about 933K. There are two naturally occurring isotopes
-- of vanadium, and 5 radioisotopes, V_49 having the longest half_life at 337
-- days. Vanadium has nuclear applications, the foil is used in cladding
-- titanium to steel, and vanadium_gallium tape is used to produce a
-- superconductive magnet. Originally discovered by Andres Manuel del Rio of
-- Mexico City in 1801. His discovery went unheeded, however, and in 1820,
-- Nils Gabriel Sefstron of Sweden rediscovered it. Metallic vanadium was
-- isolated by Henry Enfield Roscoe in 1867. The name vanadium comes from
-- {Vanadis}, a goddess of Scandinavian mythology. Silvery_white metallic
-- transition element. Vanadium is essential to {ascidian}s. Rats and
-- chickens are also known to require it. Metal powder is a fire hazard, and
-- vanadium compounds should be considered highly toxic. May cause lung
-- cancer if inhaled.
fun Vanadium : Class ;
fun Vanadium_Class : SubClass Vanadium ElementalSubstance ;
-- Colourless, odourless gas belonging to group 18 on
-- the periodic table (the noble gases.) Nine natural isotopes and seven
-- radioactive isotopes are known. Xenon was part of the first noble_gas
-- compound synthesized. Several others involving Xenon have been found
-- since then. Xenon was discovered by Ramsey and Travers in 1898.
fun Xenon : Class ;
fun Xenon_Class : SubClass Xenon ElementalSubstance ;
-- Silvery metallic element of the lanthanoids.
-- Seven natural isotopes and ten artificial isotopes are known. Used in
-- certain steels. Discovered by J.D.G. Marignac in 1878.
fun Ytterbium : Class ;
fun Ytterbium_Class : SubClass Ytterbium ElementalSubstance ;
-- Silvery_grey metallic element of group 3 on the
-- periodic table. Found in uranium ores. The only natural isotope is Y_89,
-- there are 14 other artificial isotopes. Chemically resembles the
-- lanthanoids. Stable in the air below 400 degrees, celsius. Discovered in
-- 1828 by Friedrich Wohler.
fun Yttrium : Class ;
fun Yttrium_Class : SubClass Yttrium ElementalSubstance ;
-- Blue_white metallic element. Occurs in multiple
-- compounds naturally. Five stable isotopes are six radioactive isotopes
-- have been found. Chemically a reactive metal, combines with oxygen and
-- other non_metals, reacts with dilute acids to release hydrogen.
fun Zinc : Class ;
fun Zinc_Class : SubClass Zinc ElementalSubstance ;
-- Grey_white metallic transition element. Five
-- natural isotopes and six radioactive isotopes are known. Used in nuclear
-- reactors for a {neutron} absorber. Discovered in 1789 by Martin Klaproth,
-- isolated in 1824 by Berzelius.
fun Zirconium : Class ;
fun Zirconium_Class : SubClass Zirconium ElementalSubstance ;
}

116
examples/SUMO/ElementsEng.gf
View File

@@ -1,116 +0,0 @@
--# -path=.:englishExtended
concrete ElementsEng of Elements = MergeEng ** open ParadigmsEng,NounEng in {
lin
Hydrogen = UseN (mkN "Hydrogen") ;
Helium = UseN (mkN "Helium") ;
Lithium = UseN (mkN "Lithium") ;
Beryllium = UseN (mkN "Beryllium") ;
Boron = UseN (mkN "Boron") ;
Carbon = UseN (mkN "Carbon") ;
Nitrogen = UseN (mkN "Nitrogen") ;
Oxygen = UseN (mkN "Oxygen") ;
Fluorine = UseN (mkN "Fluorine") ;
Neon = UseN (mkN "Neon") ;
Sodium = UseN (mkN "Sodium") ;
Magnesium = UseN (mkN "Magnesium") ;
Aluminum = UseN (mkN "Aluminum") ;
Silicon = UseN (mkN "Silicon") ;
Phosphorus = UseN (mkN "Phosphorus") ;
Sulphur = UseN (mkN "Sulphur") ;
Chlorine = UseN (mkN "Chlorine") ;
Argon = UseN (mkN "Argon") ;
Potassium = UseN (mkN "Potassium") ;
Calcium = UseN (mkN "Calcium") ;
Scandium = UseN (mkN "Scandium") ;
Titanium = UseN (mkN "Titanium") ;
Vanadium = UseN (mkN "Vanadium") ;
Chromium = UseN (mkN "Chromium") ;
Manganese = UseN (mkN "Manganese") ;
Iron = UseN (mkN "Iron") ;
Cobalt = UseN (mkN "Cobalt") ;
Nickel = UseN (mkN "Nickel") ;
Copper = UseN (mkN "Copper") ;
Zinc = UseN (mkN "Zinc") ;
Gallium = UseN (mkN "Gallium") ;
Germanium = UseN (mkN "Germanium") ;
Arsenic = UseN (mkN "Arsenic") ;
Selenium = UseN (mkN "Selenium") ;
Bromine = UseN (mkN "Bromine") ;
Krypton = UseN (mkN "Krypton") ;
Rubidium = UseN (mkN "Rubidium") ;
Strontium = UseN (mkN "Strontium") ;
Yttrium = UseN (mkN "Yttrium") ;
Zirconium = UseN (mkN "Zirconium") ;
Niobium = UseN (mkN "Niobium") ;
Molybdenum = UseN (mkN "Molybdenum") ;
Technetium = UseN (mkN "Technetium") ;
Ruthenium = UseN (mkN "Ruthenium") ;
Rhodium = UseN (mkN "Rhodium") ;
Palladium = UseN (mkN "Palladium") ;
Silver = UseN (mkN "Silver") ;
Cadmium = UseN (mkN "Cadmium") ;
Indium = UseN (mkN "Indium") ;
Tin = UseN (mkN "Tin") ;
Antimony = UseN (mkN "Antimony") ;
Tellurium = UseN (mkN "Tellurium") ;
Iodine = UseN (mkN "Iodine") ;
Xenon = UseN (mkN "Xenon") ;
Caesium = UseN (mkN "Caesium") ;
Barium = UseN (mkN "Barium") ;
Lanthanum = UseN (mkN "Lanthanum") ;
Cerium = UseN (mkN "Cerium") ;
Praseodymium = UseN (mkN "Praseodymium") ;
Neodymium = UseN (mkN "Neodymium") ;
Promethium = UseN (mkN "Promethium") ;
Samarium = UseN (mkN "Samarium") ;
Europium = UseN (mkN "Europium") ;
Gadolinium = UseN (mkN "Gadolinium") ;
Terbium = UseN (mkN "Terbium") ;
Dysprosium = UseN (mkN "Dysprosium") ;
Holmium = UseN (mkN "Holmium") ;
Erbium = UseN (mkN "Erbium") ;
Thulium = UseN (mkN "Thulium") ;
Ytterbium = UseN (mkN "Ytterbium") ;
Lutetium = UseN (mkN "Lutetium") ;
Hafnium = UseN (mkN "Hafnium") ;
Tantalum = UseN (mkN "Tantalum") ;
Tungsten = UseN (mkN "Tungsten") ;
Rhenium = UseN (mkN "Rhenium") ;
Osmium = UseN (mkN "Osmium") ;
Iridium = UseN (mkN "Iridium") ;
Platinum = UseN (mkN "Platinum") ;
Gold = UseN (mkN "Gold") ;
Mercury = UseN (mkN "Mercury") ;
Thallium = UseN (mkN "Thallium") ;
Lead = UseN (mkN "Lead") ;
Bismuth = UseN (mkN "Bismuth") ;
Polonium = UseN (mkN "Polonium") ;
Astatine = UseN (mkN "Astatine") ;
Radon = UseN (mkN "Radon") ;
Francium = UseN (mkN "Francium") ;
Radium = UseN (mkN "Radium") ;
Actinium = UseN (mkN "Actinium") ;
Thorium = UseN (mkN "Thorium") ;
Protactinium = UseN (mkN "Protactinium") ;
Uranium = UseN (mkN "Uranium") ;
Neptunium = UseN (mkN "Neptunium") ;
Plutonium = UseN (mkN "Plutonium") ;
Americium = UseN (mkN "Americium") ;
Curium = UseN (mkN "Curium") ;
Berkelium = UseN (mkN "Berkelium") ;
Californium = UseN (mkN "Californium") ;
Einsteinium = UseN (mkN "Einsteinium") ;
Fermium = UseN (mkN "Fermium") ;
Mendelevium = UseN (mkN "Mendelevium") ;
Nobelium = UseN (mkN "Nobelium") ;
Lawrencium = UseN (mkN "Lawrencium") ;
Unnilquadium = UseN (mkN "Unnilquadium") ;
Unnilpentium = UseN (mkN "Unnilpentium") ;
Unnilhexium = UseN (mkN "Unnilhexium") ;
Unnilseptium = UseN (mkN "Unnilseptium") ;
Unniloctium = UseN (mkN "Unniloctium") ;
Meitnerium = UseN (mkN "Meitnerium") ;
Unnildecium = UseN (mkN "Unnildecium") ;
}

1007
examples/SUMO/Engineering.gf
View File

File diff suppressed because it is too large Load Diff

9
examples/SUMO/EngineeringEng.gf
View File

@@ -1,9 +0,0 @@
concrete EngineeringEng of Engineering = MidLevelOntologyEng ** open DictLangEng, DictEng, ParadigmsEng in {
lin
Battery = UseN battery_N ;
Method = UseN method_N ;
Model = UseN model_N ;
Rotor = UseN rotor_N ;
}

7
examples/SUMO/EngineeringFre.gf
View File

@@ -1,7 +0,0 @@
--# -path=.:french:romance:abstract:prelude:common
concrete EngineeringFre of Engineering = BasicFre ** open DictLangFre, ParadigmsFre, ResFre, LexiconFre, ExtraLexiconFre, ParamBasic,StructuralFre in {
lin
Model = UseN model_N ; -- FIX ME
};

7
examples/SUMO/EngineeringRon.gf
View File

@@ -1,7 +0,0 @@
--# -path=.:romanian:romance:abstract:prelude:common
concrete EngineeringRon of Engineering = BasicRon ** open DictLangRon, ParadigmsRon, ResRon, LexiconRon, ExtraLexiconRon, ParamBasic,StructuralRon in {
lin
Model = UseN model_N ; -- FIX ME
};

1586
examples/SUMO/FinancialOntology.gf
View File

File diff suppressed because it is too large Load Diff

2887
examples/SUMO/Geography.gf
View File

File diff suppressed because it is too large Load Diff

8
examples/SUMO/GeographyEng.gf
View File

@@ -1,8 +0,0 @@
concrete GeographyEng of Geography = MidLevelOntologyEng ** open DictLangEng, DictEng, ParadigmsEng in {
lin
NaturalSatellite = AdjCN (PositA natural_A) (UseN satellite_N) ;
Planet = UseN planet_N ;
Satellite = UseN satellite_N ;
}

1649
examples/SUMO/Government.gf
View File

File diff suppressed because it is too large Load Diff

6379
examples/SUMO/Merge.gf
View File

File diff suppressed because it is too large Load Diff

16
examples/SUMO/MergeBul.gf
View File

@@ -1,16 +0,0 @@
concrete MergeBul of Merge = BasicBul ** open SyntaxBul, ParadigmsBul in {
flags
coding=utf8 ;
lin
Bird = mkCN (mkN041 "птица") ;
Monday = mkCN (mkN014 "понеделник") ;
Tuesday = mkCN (mkN014 "вторник") ;
Wednesday = mkCN (mkN043 "сряда") ;
Thursday = mkCN (mkN014 "четвъртък") ;
Friday = mkCN (mkN014 "петък") ;
Saturday = mkCN (mkN041 "събота") ;
Sunday = mkCN (mkN047 "неделя") ;
};

1006
examples/SUMO/MergeEng.gf
View File

File diff suppressed because it is too large Load Diff

67
examples/SUMO/MergeFre.gf
View File

@@ -1,67 +0,0 @@
--# -path=.:french:romance:abstract:prelude:common
concrete MergeFre of Merge = BasicFre ** open DictLangFre, ParadigmsFre, ResFre, LexiconFre, ExtraLexiconFre, ParamBasic,StructuralFre in {
lin
-- single instances
-- subclass declarations :
Animal = UseN animal_N ;
AnimalLanguage = ApposCN (UseN animal_N) (MassNP (UseN language_N)) ;
Blood = UseN blood_N ;
Bone = UseN bone_N ;
Book = UseN book_N ;
Buying = UseN2 (VerbToNounV2 buy_V2) ;
Day = UseN day_N ;
Eating = UseN2 (VerbToNounV2 eat_V2) ;
Egg = UseN egg_N ;
House = UseN house_N ;
Man = UseN man_N ;
Meat = UseN meat_N ;
WaterCloud = ApposCN (UseN water_N) (MassNP (UseN cloud_N)) ;
Wind = UseN wind_N ;
Woman = UseN woman_N ;
Worm = UseN worm_N ;
Year = UseN year_N ;
-- unary functions
FloorFn ob = AdvNP (DetCN (DetQuant DefArt NumSg) (UseN floor_N)) (PrepNP part_Prep ob) ;
YearFn ob = AdvCN (UseN year_N) (PrepNP part_Prep ob) ;
SquareRootFn ob = AdvNP (DetCN (DetQuant DefArt NumSg) (AdjCN (PositA square_A) (UseN root_N))) (PrepNP part_Prep ob) ;
RoundFn ob = AdvNP (DetCN (DetQuant DefArt NumSg) (AdjCN (PositA round_A) (UseN value_N))) (PrepNP possess_Prep ob) ;
-- binary functions
DayFn ob1 ob2 = AdvCN (ApposCN (UseN day_N) ob1) (PrepNP part_Prep (MassNP ob2)) ;
knows ob1 ob2 = mkPolSent (PredVP ob1 (ComplSlash (SlashV2a know_V2) (sentToNoun ob2))) ;
smaller ob1 ob2 = mkPolSent (PredVP ob1 (UseComp (CompAP (ComparA small_A ob2)))) ;
husband ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN husband_N)))) (PrepNP part_Prep ob2))) ;
wife ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN wife_N)))) (PrepNP part_Prep ob2))) ;
sister ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN sister_N)))) (PrepNP part_Prep ob2))) ;
-- ternary predicate
---------------- CNL demo
Entity = UseN entity_N ;
Abstract = UseN abstract_N ;
Attribute = UseN attribute_N ;
Graph = UseN graph_N ;
GraphElement = AdvCN (UseN element_N) (PrepNP part_Prep (MassNP (UseN graph_N))) ;
Proposition = UseN proposition_N ;
Quantity = UseN quantity_N ;
SetOrClass = ConjCN or_Conj (BaseCN (UseN set_N) (UseN class_N)) ;
Physical = UseN physical_N ;
ContentBearingPhysical = AdvCN (UseN physical_N) (PrepNP with_Prep (MassNP (UseN content_N))) ;
Object = UseN object_N ;
PhysicalSystem = AdjCN (PositA physical_A) (UseN system_N) ;
Process = UseN process_N ;
};

72
examples/SUMO/MergeRon.gf
View File

@@ -1,72 +0,0 @@
--# -path=.:romanian:abstract:prelude:common
concrete MergeRon of Merge = BasicRon ** open DictLangRon, ParadigmsRon, ResRon, LexiconRon, ExtraLexiconRon, ParamBasic,StructuralRon in {
lin
-- single instances
-- subclass declarations :
Animal = UseN animal_N ;
AnimalLanguage = ApposCN (UseN animal_N) (MassNP (UseN language_N)) ;
Blood = UseN blood_N ;
Bone = UseN bone_N ;
Book = UseN book_N ;
Buying = UseN2 (VerbToNounV2 buy_V2) ;
Day = UseN day_N ;
Eating = UseN2 (VerbToNounV2 eat_V2) ;
Egg = UseN egg_N ;
House = UseN house_N ;
Man = UseN man_N ;
Meat = UseN meat_N ;
WaterCloud = ApposCN (UseN water_N) (MassNP (UseN cloud_N)) ;
Wind = UseN wind_N ;
Woman = UseN woman_N ;
Worm = UseN worm_N ;
Year = UseN year_N ;
-- unary functions
FloorFn ob = AdvNP (DetCN (DetQuant DefArt NumSg) (UseN floor_N)) (PrepNP part_Prep ob) ;
YearFn ob = AdvCN (UseN year_N) (PrepNP part_Prep ob) ;
SquareRootFn ob = AdvNP (DetCN (DetQuant DefArt NumSg) (AdjCN (PositA square_A) (UseN root_N))) (PrepNP part_Prep ob) ;
RoundFn ob = AdvNP (DetCN (DetQuant DefArt NumSg) (AdjCN (PositA round_A) (UseN value_N))) (PrepNP possess_Prep ob) ;
-- binary functions
DayFn ob1 ob2 = AdvCN (ApposCN (UseN day_N) ob1) (PrepNP part_Prep (MassNP ob2)) ;
knows ob1 ob2 = mkPolSent (PredVP ob1 (ComplSlash (SlashV2a know_V2) (sentToNoun ob2))) ;
smaller ob1 ob2 = mkPolSent (PredVP ob1 (UseComp (CompAP (ComparA small_A ob2)))) ;
husband ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN husband_N)))) (PrepNP part_Prep ob2))) ;
wife ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN wife_N)))) (PrepNP part_Prep ob2))) ;
sister ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN sister_N)))) (PrepNP part_Prep ob2))) ;
-- ternary predicate
--others
toInt x = mkNP x.s ("lui" ++ x.s) x.s Sg Masc;
toRealNum x = mkNP x.s ("lui" ++ x.s) x.s Sg Masc;
---------------- CNL demo
Entity = UseN entity_N ;
Abstract = UseN abstract_N ;
Attribute = UseN attribute_N ;
Graph = UseN graph_N ;
GraphElement = AdvCN (UseN element_N) (PrepNP part_Prep (MassNP (UseN graph_N))) ;
Proposition = UseN proposition_N ;
Quantity = UseN quantity_N ;
SetOrClass = ConjCN or_Conj (BaseCN (UseN set_N) (UseN class_N)) ;
Physical = UseN physical_N ;
ContentBearingPhysical = AdvCN (UseN physical_N) (PrepNP with_Prep (MassNP (UseN content_N))) ;
Object = UseN object_N ;
PhysicalSystem = AdjCN (PositA physical_A) (UseN system_N) ;
Process = UseN process_N ;
};

16
examples/SUMO/MergeSwe.gf
View File

@@ -1,16 +0,0 @@
concrete MergeSwe of Merge = BasicSwe ** open SyntaxSwe, ParadigmsSwe in {
flags
coding=utf8 ;
lin
Bird = mkCN (mkN "fågel") ;
Monday = mkCN (mkN "måndag") ;
Tuesday = mkCN (mkN "tisdag") ;
Wednesday = mkCN (mkN "onsdag") ;
Thursday = mkCN (mkN "torsdag") ;
Friday = mkCN (mkN "fredag") ;
Saturday = mkCN (mkN "lördag") ;
Sunday = mkCN (mkN "söndag") ;
};

7979
examples/SUMO/MidLevelOntology.gf
View File

File diff suppressed because it is too large Load Diff

1488
examples/SUMO/MidLevelOntologyEng.gf
View File

File diff suppressed because it is too large Load Diff

41
examples/SUMO/MidLevelOntologyFre.gf
View File

@@ -1,41 +0,0 @@
--# -path=.:french:romance:abstract:prelude:common
concrete MidLevelOntologyFre of MidLevelOntology = MergeFre ** open DictLangFre, ParadigmsFre, LexiconFre, ExtraLexiconFre in {
lin
-- individual instances :
Student = MassNP (UseN student_N) ;
Teacher = MassNP (UseN teacher_N) ;
-- subclasses
ArtSchool = ApposCN (UseN art_N) (MassNP (UseN school_N)) ;
Beer = UseN beer_N ;
BirdEgg = ApposCN (UseN bird_N) (MassNP (UseN egg_N)) ;
Boy = UseN boy_N ;
Closing = UseN2 (VerbToNounV2 close_V2) ;
DaySchool = ApposCN (UseN day_N) (MassNP (UseN school_N)) ;
Eye = UseN eye_N ;
Girl = UseN girl_N ;
Grass = UseN grass_N ;
Head = UseN head_N ;
Heart = UseN heart_N ;
Knee = UseN knee_N ;
Milk = UseN milk_N ;
Restaurant = UseN restaurant_N ;
-- unary functions :
FirstFn ob = AdvNP (DetCN (DetQuantOrd DefArt NumSg (OrdNumeral (num (pot2as3 (pot1as2 (pot0as1 pot01)))))) (UseN element_N)) (PrepNP part_Prep ob) ;
--bespeak_V2
speaksLanguage ob1 ob2 = mkPolSent (PredVP ob1 (ComplSlash (SlashV2a speak_V2) (DetCN (DetQuant DefArt NumSg) (ApposCN (UseN language_N) ob2)))) ;
student ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN student_N)))) (PrepNP part_Prep ob2))) ;
teacher ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN teacher_N)))) (PrepNP part_Prep ob2))) ;
friend ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN friend_N)))) (PrepNP part_Prep ob2))) ;
cousin ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN cousin_N)))) (PrepNP part_Prep ob2))) ;
fears ob1 ob2 = mkPolSent (PredVP ob1 (ComplSlash (SlashV2a fear_V2) (sentToNoun ob2))) ;
};

42
examples/SUMO/MidLevelOntologyRon.gf
View File

@@ -1,42 +0,0 @@
--# -path=.:romanian:abstract:prelude:common
concrete MidLevelOntologyRon of MidLevelOntology = MergeRon ** open DictLangRon, ParadigmsRon, LexiconRon, ExtraLexiconRon in {
lin
-- individual instances :
Student = MassNP (UseN student_N) ;
Teacher = MassNP (UseN teacher_N) ;
-- subclasses
ArtSchool = ApposCN (UseN art_N) (MassNP (UseN school_N)) ;
Beer = UseN beer_N ;
BirdEgg = ApposCN (UseN bird_N) (MassNP (UseN egg_N)) ;
Boy = UseN boy_N ;
Closing = UseN2 (VerbToNounV2 close_V2) ;
DaySchool = ApposCN (UseN day_N) (MassNP (UseN school_N)) ;
Eye = UseN eye_N ;
Girl = UseN girl_N ;
Grass = UseN grass_N ;
Head = UseN head_N ;
Heart = UseN heart_N ;
Knee = UseN knee_N ;
Milk = UseN milk_N ;
Restaurant = UseN restaurant_N ;
-- unary functions :
FirstFn ob = AdvNP (DetCN (DetQuantOrd DefArt NumSg (OrdNumeral (num (pot2as3 (pot1as2 (pot0as1 pot01)))))) (UseN element_N)) (PrepNP part_Prep ob) ;
--LastFn ob = AdvNP (DetCN (DetQuant DefArt NumSg) (AdjCN (PositA last_A) (UseN element_N))) (PrepNP part_Prep ob);
--bespeak_V2
speaksLanguage ob1 ob2 = mkPolSent (PredVP ob1 (ComplSlash (SlashV2a speak_V2) (DetCN (DetQuant DefArt NumSg) (ApposCN (UseN language_N) ob2)))) ;
student ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN student_N)))) (PrepNP part_Prep ob2))) ;
teacher ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN teacher_N)))) (PrepNP part_Prep ob2))) ;
friend ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN friend_N)))) (PrepNP part_Prep ob2))) ;
cousin ob1 ob2 = mkPolSent (PredVP ob1 (AdvVP (UseComp (CompNP (DetCN (DetQuant DefArt NumSg) (UseN cousin_N)))) (PrepNP part_Prep ob2))) ;
fears ob1 ob2 = mkPolSent (PredVP ob1 (ComplSlash (SlashV2a fear_V2) (sentToNoun ob2))) ;
};

397
examples/SUMO/Military.gf
View File

@@ -1,397 +0,0 @@
abstract Military = MidLevelOntology ** {
-- A modern nation_states' air forces
-- (the whole branch of service) and not a subdivision thereof.
fun AirForce_BranchOfService : Class ;
fun AirForce_BranchOfService_Class : SubClass AirForce_BranchOfService MilitaryOrganization ;
-- (AvailableForMilitaryServiceMaleFn
-- ?AREA) denotes the Integer that represents the count of the population of
-- males of military age in the GeopoliticalArea ?AREA.
fun AvailableForMilitaryServiceMaleFn : El GeopoliticalArea -> Ind Integer ;
-- In military terminology, a battalion consists of
-- two to six companies typically commanded by a lieutenant colonel. The
-- nomenclature varies by nationality and by branch of arms, e.g. some
-- armies organize their infantry into battalions, but call battalion_sized
-- cavalry, reconnaissance, or tank units a squadron or a regiment instead.
-- There may even be subtle distinctions within a nation's branches of arms,
-- such a distinction between a tank battalion and an armored squadron,
-- depending on how the unit's operational role is perceived to fit into the
-- army's historical organization. A battalion is potentially the smallest
-- military unit capable of independent operations (i.e. not attached to a
-- higher command), but is usually part of a regiment or a brigade or both,
-- depending on the organizational model used by that service. Battalions
-- are ordinarily homogeneous with respect to type (e.g. an infantry
-- battalion or a tank battalion), although there are occasional
-- exceptions. (from Wikipedia)
fun Battalion : Class ;
fun Battalion_Class : SubClass Battalion MilitaryUnit ;
-- Brigade is a term from military science which
-- refers to a group of several battalions (typically two to four), and
-- directly attached supporting units (normally including at least an
-- artillery battery and additional logistic support). A brigade is smaller
-- than a division and roughly equal to or a little larger than a regiment.
-- Strength typically ranges between 1,500 and 3,500 personnel. (from Wikipedia)
fun Brigade : Class ;
fun Brigade_Class : SubClass Brigade MilitaryUnit ;
-- In military organizations, an officer
-- is a member of the service who holds a position of responsibility.
-- Commissioned officers derive authority directly from a sovereign power
-- and, as such, hold a commission charging them with the duties and
-- responsibilities of a specific office or position. Commissioned officers
-- are typically the only persons in a military able to exercise command
-- (according to the most technical definition of the word) over a military
-- unit. Non_commissioned officers in positions of authority can be said to
-- have control or charge rather than command per se, although the use of the
-- word command to describe any use of authority is widespread and often
-- official. (from Wikipedia)
fun CommissionedOfficerRank : Class ;
fun CommissionedOfficerRank_Class : SubClass CommissionedOfficerRank MilitaryRank ;
-- The ranks of junior officers are the
-- three or four lowest ranks of officers, possibily complicated by the
-- status of trainee officers. Their units are generally not expected to
-- operate independently for any significant length of time. Typical ranks
-- for this level are captains, who typically lead companies and smaller
-- units Lieutenant. Company grade officers will also fill staff roles in
-- some units. (from Wikipedia)
fun CompanyGradeRank : Class ;
fun CompanyGradeRank_Class : SubClass CompanyGradeRank CommissionedOfficerRank ;
-- A company is a military unit, typically
-- consisting of 100_200 soldiers. Most companies are formed of three or
-- four platoons although the exact number may vary by country, unit type and
-- structure. (from Wikipedia)
fun Company_Military : Class ;
fun Company_Military_Class : SubClass Company_Military MilitaryUnit ;
-- Soldiers who are enlisted in some
-- military and have no command.
fun EnlistedSoldierRank : Class ;
fun EnlistedSoldierRank_Class : SubClass EnlistedSoldierRank MilitaryRank ;
-- Senior officers who typically
-- command units that can be expected to operate independently for short
-- periods of time (battalions and regiments, large warships). Field Grade
-- officers also commonly fill staff positions. (from Wikipedia)
fun FieldGradeOfficerRank : Class ;
fun FieldGradeOfficerRank_Class : SubClass FieldGradeOfficerRank CommissionedOfficerRank ;
-- (FitForMilitaryServiceMaleFn
-- ?AREA) denotes the Integer that represents the count of the population of
-- males of military age in the GeopoliticalArea ?AREA that is also capable
-- of being a member of the military.
fun FitForMilitaryServiceMaleFn : El GeopoliticalArea -> Ind Integer ;
-- Admirals (Navy), Generals (Army) and
-- Marshals who typically command units that are expected to operate
-- independently for extended periods of time (brigades and larger, fleets of
-- ships). (from Wikipedia)
fun FlagOfficerRank : Class ;
fun FlagOfficerRank_Class : SubClass FlagOfficerRank CommissionedOfficerRank ;
-- Military operations conducted to distribute food to the friendly force. (from FM 100_40)
fun FoodDistributionOperation : Class ;
fun FoodDistributionOperation_Class : SubClass FoodDistributionOperation (both Getting (both Giving MilitaryOperation)) ;
-- A MilitaryUnit composed primarily of Soldiers
-- who fight on foot, i.e. without the use of heavy artillery.
fun InfantryUnit : Class ;
fun InfantryUnit_Class : SubClass InfantryUnit MilitaryUnit ;
-- Ranks with grade E5 or E6.
fun JuniorNCORank : Class ;
fun JuniorNCORank_Class : SubClass JuniorNCORank NonCommissionedOfficerRank ;
-- Modern nation_states' marine units (the
-- whole branch of service) and not a subdivision thereof.
fun Marines_BranchOfService : Class ;
fun Marines_BranchOfService_Class : SubClass Marines_BranchOfService MilitaryOrganization ;
-- A Convoy of MilitaryVehicles, travelling to the same
-- at least intermediate destination, in relatively close proximity.
fun MilitaryConvoy : Class ;
fun MilitaryConvoy_Class : SubClass MilitaryConvoy Convoy ;
-- Trucks used by a military to transport food.
fun MilitaryFoodTruck : Class ;
fun MilitaryFoodTruck_Class : SubClass MilitaryFoodTruck MilitarySupportVehicle ;
-- A MilitaryOperation is distinguished
-- from the broader class of MilitaryProcess in that it is planned in
-- advance.
fun MilitaryOperation : Class ;
fun MilitaryOperation_Class : SubClass MilitaryOperation MilitaryProcess ;
-- Military platforms. These are usually mobile
-- entities which can carry military equipment such as Weapons and
-- communications equipment. Often, as with a tank outfitted with a gun, a
-- MilitaryPlatform carrying some Weapon comprises a WeaponSystem.
fun MilitaryPlatform : Class ;
fun MilitaryPlatform_Class : SubClass MilitaryPlatform TransportationDevice ;
-- The class of Positions in a Military. Rank is usually commensurate
-- with degrees of power, prestige and pay.
fun MilitaryRank : Class ;
fun MilitaryRank_Class : SubClass MilitaryRank SkilledOccupation ;
-- Trucks used by a military to transport supplies.
fun MilitarySupplyTruck : Class ;
fun MilitarySupplyTruck_Class : SubClass MilitarySupplyTruck (both MilitarySupportVehicle Truck) ;
-- Vehicles meant to be used for support, rather
-- than combat in a military context.
fun MilitarySupportVehicle : Class ;
fun MilitarySupportVehicle_Class : SubClass MilitarySupportVehicle MilitaryVehicle ;
fun MilitaryVehicle_MilitaryPlatform : SubClass MilitaryVehicle MilitaryPlatform ;
-- Modern nation_states' naval air
-- forces (the whole branch of service) and not a subdivision thereof.
fun NavalAirForce_BranchOfService : Class ;
fun NavalAirForce_BranchOfService_Class : SubClass NavalAirForce_BranchOfService MilitaryOrganization ;
-- MilitaryOrganizations that are sea forces.
fun Navy_BranchOfService : Class ;
fun Navy_BranchOfService_Class : SubClass Navy_BranchOfService MilitaryOrganization ;
-- Non_commissioned officers, or NCOs, in
-- positions of authority can be said to have control or charge rather than
-- command per se, although the use of the word command to describe any use
-- of authority is widespread and often official. This is distinguished from
-- the official responsibility for command entrusted to a
-- CommissionedOfficer. NCOs are enlisted positions. (from Wikipedia)
fun NonCommissionedOfficerRank : Class ;
fun NonCommissionedOfficerRank_Class : SubClass NonCommissionedOfficerRank EnlistedSoldierRank ;
-- A MilitaryUnit, the purpose of which is
-- to prevent violent actions but providing deterrent to such actions through
-- the threat of overwhelming retaliation.
fun PeacekeepingUnit : Class ;
fun PeacekeepingUnit_Class : SubClass PeacekeepingUnit MilitaryUnit ;
-- Platoon is a term from military science. In an
-- army, a platoon is a unit of thirty to forty soldiers typically commanded
-- by a Lieutenant assisted by a non_commissioned officer. A platoon is
-- formed by at least two squads (usually 3 or 4) and is smaller than a
-- company (typically there are 3 or 4 platoons per company). Most platoons
-- are infantry platoons, some carry other designations such as mortar or
-- heavy weapons platoons. A platoon is the smallest military unit led by a
-- commissioned officer. (from Wikipedia)
fun Platoon : Class ;
fun Platoon_Class : SubClass Platoon MilitaryUnit ;
-- The lowest group of ranks in the military
-- (Grade E1 through E4). These Soldiers usually have no authority
-- based on their ranks.
fun PrivateRank : Class ;
fun PrivateRank_Class : SubClass PrivateRank EnlistedSoldierRank ;
-- (equal (ReachingMilitaryAgeAnnuallyMaleFn ?AREA ?YEAR) ?COUNT) means that in the
-- GeopoliticalArea ?AREA, there are ?COUNT number of male individuals who for
-- that year ?YEAR come to be of militaryAge.
fun ReachingMilitaryAgeAnnuallyMaleFn : El GeopoliticalArea -> El Year -> Ind Integer ;
-- Military operations conducted to protect the friendly
-- force by providing early and accurate warning of enemy operations, to provide the force
-- being protected with time and maneuver space within which to react to the enemy, and to
-- develop the situation to allow the commander to effectively use the protected force.
-- Security operations orient on the force or facility to be protected, rather than on the
-- enemy. (from FM 100_40).
fun SecurityOperation : Class ;
fun SecurityOperation_Class : SubClass SecurityOperation MilitaryOperation ;
-- Ranks with grade E7 through E9.
fun SeniorNCORank : Class ;
fun SeniorNCORank_Class : SubClass SeniorNCORank NonCommissionedOfficerRank ;
-- Any Soldier who is tasked with carrying the colors of his/her unit in Battles and parades.
fun StandardBearer : Class ;
fun StandardBearer_Class : SubClass StandardBearer Soldier ;
-- Any Soldier who served during the American Civil War
fun USCivilWarSoldier : Ind Soldier ;
-- The class of Positions in the USMilitary.
fun USMilitaryRank : Class ;
fun USMilitaryRank_Class : SubClass USMilitaryRank MilitaryRank ;
-- A USMilitaryRank that is variously called
-- Airman Basic in the Air Force, Private in the USArmy,
-- Private in the USMarineCorps, and Seaman Recruit in the USNavy.
fun USMilitaryRankE1 : Ind (both PrivateRank USMilitaryRank) ;
-- A USMilitaryRank that is variously called
-- Airman in the Air Force, Private in the USArmy,
-- Private First Class in the USMarineCorps, and Seaman Apprentice in the USNavy.
fun USMilitaryRankE2 : Ind (both PrivateRank USMilitaryRank) ;
-- A USMilitaryRank that is variously called
-- Airman First Class in the Air Force, Private First Class in the USArmy,
-- Lance Corporal in the USMarineCorps, and Seaman in the USNavy.
fun USMilitaryRankE3 : Ind (both PrivateRank USMilitaryRank) ;
-- A USMilitaryRank that is variously called
-- Senior Airman in the Air Force, Specialist or Corporal in the USArmy,
-- Corporal in the USMarineCorps, and Petty Officer 3rd Class in the USNavy.
fun USMilitaryRankE4 : Ind (both PrivateRank USMilitaryRank) ;
-- A USMilitaryRank that is variously called
-- Staff Sergeant in the Air Force, Sergeant in the USArmy,
-- Sergeant in the USMarineCorps, and Petty Officer 2nd Class in the USNavy.
fun USMilitaryRankE5 : Ind (both JuniorNCORank USMilitaryRank) ;
-- A USMilitaryRank that is variously called
-- Technical Sergeant in the Air Force, Staff Sergeant in the USArmy,
-- Staff Sergeant in the USMarineCorps, and Petty Officer 1st Class in the USNavy.
fun USMilitaryRankE6 : Ind (both JuniorNCORank USMilitaryRank) ;
-- A USMilitaryRank that is variously called
-- Master Sergeant in the Air Force, Sergeant First Class in the USArmy,
-- Gunnery Sergeant in the USMarineCorps, and Chief Petty Officer in the USNavy.
fun USMilitaryRankE7 : Ind (both SeniorNCORank USMilitaryRank) ;
-- A USMilitaryRank that is variously called
-- Senior Master Sergeant in the Air Force, Master Sergeant or First Sergeant in the USArmy,
-- Master Sergeant or First Sergeant in the USMarineCorps, and Senior Chief Petty Officer in the USNavy.
fun USMilitaryRankE8 : Ind (both SeniorNCORank USMilitaryRank) ;
-- A USMilitaryRank that is variously
-- called Chief Master Sergeant or Command Chief Master Sergeant or Chief
-- Master Sergeant of the Air Force in the Air Force, Sergeant Major or
-- Command Sergeant Major or Sergeant Major of the Army in the USArmy,
-- Master Gunnery Sergeant or Sergeant Major or Sergeant Major of the Marine
-- Corps in the USMarineCorps, and Master Chief Petty Officer or Command
-- Master Chief Petty Officer or Master Chief Petty Officer of the Navy in
-- the USNavy.
fun USMilitaryRankE9 : Ind (both SeniorNCORank USMilitaryRank) ;
-- A special USMilitaryRank above E9 that marks usually the end of
-- carrier of non_commissioned officers.
fun USMilitaryRankE9special : Ind (both USMilitaryRank SeniorNCORank) ;
fun USMilitaryRankO1 : Ind (both CompanyGradeRank USMilitaryRank) ;
fun USMilitaryRankO10 : Ind (both FlagOfficerRank USMilitaryRank) ;
fun USMilitaryRankO2 : Ind (both CompanyGradeRank USMilitaryRank) ;
fun USMilitaryRankO3 : Ind (both CompanyGradeRank USMilitaryRank) ;
fun USMilitaryRankO4 : Ind (both FieldGradeOfficerRank USMilitaryRank) ;
fun USMilitaryRankO5 : Ind (both FieldGradeOfficerRank USMilitaryRank) ;
fun USMilitaryRankO6 : Ind (both FieldGradeOfficerRank USMilitaryRank) ;
fun USMilitaryRankO7 : Ind (both FlagOfficerRank USMilitaryRank) ;
fun USMilitaryRankO8 : Ind (both FlagOfficerRank USMilitaryRank) ;
fun USMilitaryRankO9 : Ind (both FlagOfficerRank USMilitaryRank) ;
fun USMilitaryRankSpecial : Ind (both FlagOfficerRank USMilitaryRank) ;
fun USMilitaryRankWO1 : Ind (both USWarrantOfficerRank USMilitaryRank) ;
fun USMilitaryRankWO2 : Ind (both USWarrantOfficerRank (both USMilitaryRank CommissionedOfficerRank)) ;
fun USMilitaryRankWO3 : Ind (both USWarrantOfficerRank (both USMilitaryRank CommissionedOfficerRank)) ;
fun USMilitaryRankWO4 : Ind (both USWarrantOfficerRank (both USMilitaryRank CommissionedOfficerRank)) ;
fun USMilitaryRankWO5 : Ind (both USWarrantOfficerRank (both USMilitaryRank CommissionedOfficerRank)) ;
-- Any Soldier who served
-- during the American Revolutionary War
fun USRevolutionaryWarSoldier : Ind Soldier ;
-- In the United States military, a
-- warrant officer was originally, and strictly, a highly skilled,
-- single_track specialty officer. But as many chief warrant officers assume
-- positions as officer in charge or department head, along with the high
-- number of bachelor's and master’s degrees held within the community, their
-- contribution and expertise as a community is ever_increasing. There are
-- no 'warrant officers' per se in the U.S. Navy, but rather the term 'chief
-- warrant officer' is correct. In the U.S. Navy, a sailor must be in one
-- of the top three enlisted ranks to be eligible to become a Chief Warrant
-- Officer. In the U.S. Army, a person can progress to the warrant officer
-- rank at a grade lower than E_7 thus having a longer career and greater
-- opportunity to serve and grow. In the U.S. Marine Corps, after serving
-- at least eight years of enlisted service, and reaching the grade of E_5
-- (sergeant), an enlisted Marine can apply for the Warrant Officer program.
-- Upon the initial appointment to WO1 a warrant is given by the secretary of
-- the service, and upon promotion to chief warrant officer (CW2 and above)
-- they are commissioned by the President of the United States, take the same
-- oath and receive the same commission and charges as commissioned officers,
-- thus deriving their authority from the same source.
fun USWarrantOfficerRank : Class ;
fun USWarrantOfficerRank_Class : SubClass USWarrantOfficerRank CommissionedOfficerRank ;
-- (betweenOnPath ?OBJ1 ?OBJ2 ?OBJ3 ?PATH)
-- means that ?OBJ2 is spatially located between ?OBJ1 and ?OBJ3 on the path
-- ?PATH. Note that this is a more specialized relation of between since any
-- object that is between others with respect to a particular path is also
-- simply between them.
fun betweenOnPath : El Object -> El Object -> El Object -> Formula ;
-- The typical MilitaryRank of
-- the leader of an instance of the given MilitaryEchelon.
fun commandRankOfEchelon: Desc MilitaryUnit -> El MilitaryRank -> Formula ;
-- (fitForMilitaryService ?AGENT ?PROCESS)
-- means that ?AGENT is capable of carrying out the MilitaryProcess ?PROCESS as
-- the agent of the ?PROCESS.
fun fitForMilitaryService: El CognitiveAgent -> Desc MilitaryProcess -> Formula ;
-- (militaryAge ?AREA ?AGE) means that in the
-- GeopoliticalArea ?AREA, a person must be ?AGE or older in order to be a
-- member of the military of the ?AREA.
fun militaryAge : El GeopoliticalArea -> El TimeDuration -> Formula ;
-- (militaryExpendituresFractionOfGDP ?AREA ?FRACTION) means
-- that the estimated military spending of the GeopoliticalArea ?AREA is
-- ?FRACTION of the gross domestic product (GDP) of that area.
fun militaryExpendituresFractionOfGDP : El GeopoliticalArea -> El RationalNumber -> Formula ;
-- (militaryExpendituresFractionOfGDPInPeriod ?AREA ?FRACTION ?PERIOD)
-- means that the estimated military spending of the GeopoliticalArea ?AREA
-- was ?FRACTION of the gross domestic product (GDP) of that area during the
-- TimeInterval indicated by ?PERIOD.
fun militaryExpendituresFractionOfGDPInPeriod : El GeopoliticalArea -> El RationalNumber -> El TimeInterval -> Formula ;
-- (militaryExpendituresInUSDollars ?AREA ?AMOUNT) means that the
-- estimated military spending of the GeopoliticalArea ?AREA is ?AMOUNT
-- in UnitedStatesDollars. Note: This predicate was created to represent
-- data from the CIA World Fact Book, which calculates ?AMOUNT by multiplying
-- estimated percentage of ?AREA's budget spent on defense by its gross
-- domestic product (GDP) expressed in U.S. dollars. Note that this GDP is
-- calculated by the exchange rate method rather than by
-- PPPBasedEconomicValuation. Military expenditures data is approximate.
fun militaryExpendituresInUSDollars : El GeopoliticalArea -> El CurrencyMeasure -> Formula ;
-- (militaryExpendituresInUSDollarsInPeriod ?AREA ?AMOUNT ?PERIOD) means
-- that the estimated military spending of the GeopoliticalArea ?AREA was
-- ?AMOUNT in UnitedStatesDollars during the TimeInterval indicated by
-- ?PERIOD. Note: This predicate was created to represent data from the CIA
-- World Fact Book, which calculates ?AMOUNT by multiplying estimated defense
-- spending of an ?AREA in percentage terms by the gross domestic product (GDP)
-- for ?PERIOD. Note that for this figure, GDP is calculated by the exchange
-- rate method rather than by PPPBasedEconomicValuation. In any case,
-- military expenditures data should be treated as only approximate.
fun militaryExpendituresInUSDollarsInPeriod : El GeopoliticalArea -> El CurrencyMeasure -> El TimeInterval -> Formula ;
-- (militaryOfArea ?MILITARY ?AREA)
-- denotes that ?MILITARY is a MilitaryOrganization serving in defense of
-- the GeopoliticalArea ?AREA.
fun militaryOfArea : El MilitaryOrganization -> El GeopoliticalArea -> Formula ;
-- A subEchelon is a relationship between
-- named organizational unit types in which a unit of one type is a
-- subOrganization of the other.
fun subEchelon: Desc MilitaryUnit -> Desc MilitaryUnit -> Formula ;
}

10727
examples/SUMO/Mondial.gf
View File

File diff suppressed because it is too large Load Diff

5363
examples/SUMO/MondialEng.gf
View File

File diff suppressed because it is too large Load Diff

1229
examples/SUMO/QoSontology.gf
View File

File diff suppressed because it is too large Load Diff

7
examples/SUMO/QoSontologyEng.gf
View File

@@ -1,7 +0,0 @@
--# -path=.:english:abstract:prelude:common
concrete QoSontologyEng of QoSontology = BasicEng ** open DictLangEng, DictEng, ParamBasic, StructuralEng in {
lin
ProcessTask = AdvCN (UseN task_N) (PrepNP possess_Prep (MassNP (UseN process_N))) ;
}

8
examples/SUMO/QoSontologyFre.gf
View File

@@ -1,8 +0,0 @@
--# -path=.:french:romance:abstract:prelude:common
concrete QoSontologyFre of QoSontology = BasicFre ** open DictLangFre, ParadigmsFre, ResFre, LexiconFre, ExtraLexiconFre, ParamBasic,StructuralFre in {
lin
ProcessTask = AdvCN (UseN task_N) (PrepNP possess_Prep (MassNP (UseN process_N))) ;
}

8
examples/SUMO/QoSontologyRon.gf
View File

@@ -1,8 +0,0 @@
--# -path=.:french:romance:abstract:prelude:common
concrete QoSontologyRon of QoSontology = BasicRon ** open DictLangRon, ParadigmsRon, ResRon, LexiconRon, ExtraLexiconRon, ParamBasic,StructuralRon in {
lin
ProcessTask = AdvCN (UseN task_N) (PrepNP by8means_Prep (MassNP (UseN process_N))) ;
}

12
examples/SUMO/RGLExt/DictLang.gf
View File

@@ -1,12 +0,0 @@
--1 Lang: a Test Module for the Resource Grammar
-- This grammar is for testing the resource as included in the
-- language-independent API, consisting of a grammar and a lexicon.
-- The grammar without a lexicon is [``Grammar`` Grammar.html],
-- which may be more suitable to open in applications.
abstract DictLang =
Grammar
** open Extension in {
-- flags startcat=NP ;
} ;

9
examples/SUMO/RGLExt/DictLangEng.gf
View File

@@ -1,9 +0,0 @@
--# -path=.:../../../lib/src/abstract:../../../lib/src/english:../../../lib/src/common
concrete DictLangEng of DictLang =
GrammarEng
** open ExtensionEng in {
flags unlexer = text ; lexer = text ;
} ;

10
examples/SUMO/RGLExt/DictLangFre.gf
View File

@@ -1,10 +0,0 @@
--# -path=.:../abstract:../common:../prelude:../romance:
concrete DictLangFre of DictLang =
GrammarFre,
ExtensionFre
** {
flags unlexer = text ; lexer = text ;
} ;

10
examples/SUMO/RGLExt/DictLangRon.gf
View File

@@ -1,10 +0,0 @@
--# -path=.:../abstract:../common:../prelude
concrete DictLangRon of DictLang =
GrammarRon,
ExtensionRon
** {
flags unlexer = text ; lexer = text ;
} ;

31
examples/SUMO/RGLExt/Extension.gf
View File

@@ -1,31 +0,0 @@
-- other functions needed for parsing
abstract Extension = Cat ** {
cat
PolSentence;
StmtS ;
[CN]{2};
fun
VerbToNounV2 : V2 -> N2 ; -- discovering
VerbToNoun : V -> N ; -- walking is healthy
VerbToGerundA : V -> A ; -- singing bird
VerbToParticipeA : V -> A ; -- the required number
ConjCN : Conj -> [CN] -> CN ; -- set or class
mkPolSent : Cl -> PolSentence ;
getSent : PolSentence -> S ;
sentToNoun : PolSentence -> NP ;
UsePolSentence : Pol -> PolSentence -> StmtS ;
at_Prep : Prep ;
per_Prep : Prep ;
O1 : NP ;
O2 : NP ;
O3 : NP ;
O4 : NP ;
O5 : NP ;
};

62
examples/SUMO/RGLExt/ExtensionEng.gf
View File

@@ -1,62 +0,0 @@
--# -path=.:RGLExt:alltenses:../../lib/src/english
concrete ExtensionEng of Extension = CatEng ** open MorphoEng, ResEng, ConjunctionEng, StructuralEng, Prelude, ParadigmsEng, Coordination, ParamBasic in {
lincat
PolSentence = {s : SentForm => CPolarity => Str ; flag : Flag};
[CN] = {s1,s2 : Number => ResEng.Case => Str ; g : Gender} ;
StmtS = {s : Str};
lin
VerbToNounV2 vs = VerbToNoun vs ** {c2 = vs.c2; lock_N2=<>};
VerbToNoun v = {s = \\_,_ => v.s ! VPresPart;
g = Masc; lock_N=<>};
VerbToGerundA v = {s = \\_ => v.s ! VPresPart; lock_A=<>};
VerbToParticipeA v = {s = \\_ => v.s ! VPPart; lock_A=<>};
mkPolSent cl = {s = \\f,b => case b of
{CPos => cl.s ! Pres ! Simul ! CPos ! ODir;
_ => cl.s ! Pres ! Simul ! CNeg False ! ODir};
flag = NothingS ;
lock_PolSentence = <>};
getSent psel = {s = psel.s ! Indep ! CPos} ;
sentToNoun ps = {s = \\_ => "\"" ++ ps.s ! Indep ! CPos ++ "\"";
a = agrP3 Sg; lock_NP=<>};
ConjCN conj ss = conjunctDistrTable2 Number ResEng.Case conj ss ** {g = ss.g;lock_CN=<>};
BaseCN x y ={s1 = \\n,c => x.s ! n ! c ;
s2 = \\n,c => y.s ! n ! c ;
g = x.g} ;
ConsCN xs x = consrTable2 Number ResEng.Case comma xs x ** {g = Masc} ;
UsePolSentence p ps = {s = ps.s ! Indep ! p.p};
at_Prep = mkPrep "at" ;
per_Prep = mkPrep "per" ;
O1 = {s = \\_ => "o1" ;
a = agrP3 Sg}**{lock_NP=<>};
O2 = {s = \\_ => "o2" ;
a = agrP3 Sg}**{lock_NP=<>};
O3 = {s = \\_ => "o3" ;
a = agrP3 Sg}**{lock_NP=<>};
O4 = {s = \\_ => "o4" ;
a = agrP3 Sg}**{lock_NP=<>};
O5 = {s = \\_ => "o5" ;
a = agrP3 Sg}**{lock_NP=<>};
}

64
examples/SUMO/RGLExt/ExtensionFre.gf
View File

@@ -1,64 +0,0 @@
--# -path=.:../romance:../common:../abstract:../prelude:
concrete ExtensionFre of Extension = CatFre ** open MorphoFre, Prelude, Coordination,ParamBasic, ResFre, GrammarFre, ParadigmsFre in {
lincat
PolSentence = {s : SentForm => Polarity => Str ; flag : Flag};
[CN] = {s1,s2 : Number => Str ; g : Gender} ;
SS = {s : Str};
lin
VerbToNoun v = {s = \\_ => v.s ! (VInfin True);
g = Masc};
VerbToNounV2 v2 = VerbToNoun v2 ** {c2 = v2.c2};
VerbToGerundA v = {s = \\_,af => case af of
{AF g n => v.s ! VGer; -- need more data for feminine and plural forms
AA => "en" ++ v.s ! VGer
};
isPre = False};
VerbToParticipeA v = {s = \\_,af => case af of
{AF g n => v.s ! (VPart g n);
AA => "en" ++ v.s ! VGer
};
isPre = False} ;
mkPolSent cl = {s = \\f,b => cl.s ! DDir ! RPres ! Simul ! b ! Indic ;
flag = NothingS ;
lock_PolSentence = <>
};
sentToNoun ps = heavyNP {s = \\_ => "\"" ++ ps.s ! Indep ! Pos ++ "\"";
a = agrP3 Masc Sg
};
at_Prep = mkPreposition "à" ;
per_Prep = mkPreposition "per" ;
ConjCN conj ss = conjunctDistrTable Number conj ss ** {
g = ss.g
};
BaseCN x y ={
s1 = \\n => x.s ! n ;
s2 = \\n => y.s ! n ;
g = x.g};
ConsCN xs x = consrTable Number comma xs x ** {g = x.g} ;
UsePolSentence p ps = {s = ps.s ! Indep ! p.p};
O1 = UsePN (mkPN "o1") ;
O2 = UsePN (mkPN "o2") ;
O3 = UsePN (mkPN "o3") ;
O4 = UsePN (mkPN "o4") ;
O5 = UsePN (mkPN "o5") ;
}

62
examples/SUMO/RGLExt/ExtensionRon.gf
View File

@@ -1,62 +0,0 @@
concrete ExtensionRon of Extension = CatRon ** open MorphoRon, ResRon, ConjunctionRon, StructuralRon, Prelude, Coordination,ParamBasic, ParadigmsRon, NounRon in {
lincat
PolSentence = {s : SentForm => Polarity => Str ; flag : Flag};
[CN] = {s1,s2 : Number => Species => ACase => Str; g : NGender; a : Animacy ; isComp : Bool} ;
StmtS = {s : Str};
lin
VerbToNounV2 v2 = VerbToNoun v2 ** {c2 = v2.c2};
VerbToNoun vp = { s = \\n,sp,c => vp.s ! PPasse Masc n sp c ;
g = NNeut ; a = Inanimate };
VerbToGerundA vp = {s = \\af => vp.s ! Ger;
isPre = False
};
VerbToParticipeA v = {s = \\af => case af of
{AF g n sp c => v.s ! PPasse g n sp c;
AA => v.s ! PPasse Masc Sg Indef ANomAcc
};
isPre = False
};
mkPolSent cl = {s = \\f,b => cl.s ! DDir ! RPres ! Simul ! b ! Indic ;
flag = NothingS ;
lock_PolSentence = <>
};
sentToNoun ps = heavyNP {s = \\_ => "\"" ++ ps.s ! Indep ! Pos ++ "\"";
a = agrP3 Masc Sg; hasClit = HasClit ; isComp = True ;
ss = "\"" ++ ps.s ! Indep ! Pos ++ "\""
};
ConjCN conj ss = conjunctDistrTable3 Number Species ACase conj ss ** {
g = ss.g; a = ss.a; isComp = ss.isComp; needsRefForm = False
};
BaseCN x y ={
s1 = \\n,sp,c => x.s ! n ! sp ! c ;
s2 = \\n,sp,c => y.s ! n ! sp ! c ;
g = x.g; a = x.a ; isComp = x.isComp;
needsRefForm = False};
ConsCN xs x = consrTable3 Number Species ACase comma xs x ** {g = x.g; a = x.a; isComp = x.isComp; needsRefForm = False} ;
at_Prep = mkPrep "la" Ac True;
per_Prep = mkPrep "per" Ac True;
UsePolSentence p ps = {s = ps.s ! Indep ! p.p};
O1 = UsePN (mkPN "o1") ;
O2 = UsePN (mkPN "o2") ;
O3 = UsePN (mkPN "o3") ;
O4 = UsePN (mkPN "o4") ;
O5 = UsePN (mkPN "o5") ;
}

29
examples/SUMO/RGLExt/ExtraLexicon.gf
View File

@@ -1,29 +0,0 @@
abstract ExtraLexicon = Cat ** {
fun
time_N : N ;
square_A : A ;
value_N : N ;
element_N : N ;
--------------------------
--CNL presentation
entity_N : N ;
abstract_N : N ;
attribute_N : N ;
graph_N : N ;
model_N : N ;
process_N : N ;
task_N : N ;
proposition_N : N ;
quantity_N : N ;
set_N : N ;
class_N : N ;
physical_N : N ;
content_N : N ;
object_N : N ;
system_N : N ;
physical_A : A ;
}

34
examples/SUMO/RGLExt/ExtraLexiconFre.gf
View File

@@ -1,34 +0,0 @@
--# -path=.:../romance:../common:../abstract:../../prelude
concrete ExtraLexiconFre of ExtraLexicon = CatFre **
open ParadigmsFre,MorphoFre,BeschFre in {
flags
optimize=values ; coding=utf8 ;
lin
value_N = regGenN "valeur" feminine ;
square_A = regA "caré" ;
time_N = regN "heure" ;
element_N = mkN "élément" ;
entity_N = regGenN "entité" feminine;
abstract_N = mkN "abstrait" ;
attribute_N = mkN "attribut" ;
graph_N = regGenN "graph" masculine ;
model_N = regGenN "modèle" masculine;
process_N = mkN "processus" ;
task_N = regGenN "tâche" feminine;
proposition_N = regGenN "proposition" feminine ;
quantity_N = regGenN "quantité" feminine;
set_N = regGenN "ensemble" masculine;
class_N = regGenN "classe" feminine;
physical_N = regGenN "physique" masculine;
content_N = mkN "sens" ;
object_N = mkN "objet" ;
system_N = mkN "système" ;
physical_A = regA "physique" ;
} ;

34
examples/SUMO/RGLExt/ExtraLexiconRon.gf
View File

@@ -1,34 +0,0 @@
--# -path=.:../romance:../common:../abstract:../../prelude
concrete ExtraLexiconRon of ExtraLexicon = CatRon **
open ParadigmsRon,MorphoRon,BeschRon in {
flags
optimize=values ; coding=utf8 ;
lin
value_N = mkN "valoare" "valori" ;
square_A = regA "patrat" ;
time_N = mkNR "timp" ;
element_N = mkN "element" ;
entity_N = mkN "entitate" ;
abstract_N = mkN "abstract" ;
attribute_N = mkN "atribut" ;
graph_N = mkNR "graf" ;
model_N = mkN "model" neuter;
process_N = mkN "proces" ;
task_N = mkN "sarcină" ;
proposition_N = mkN "propoziție" ;
quantity_N = mkN "cantitate" ;
set_N = mkN "mulțime" ;
class_N = mkN "clasă" ;
physical_N = mkN "concret" ;
content_N = mkN "conținut" ;
object_N = mkN "obiect" ;
system_N = mkN "sistem" ;
physical_A = regA "concret" ;
} ;

5
examples/SUMO/RGLExt/ParamBasic.gf
View File

@@ -1,5 +0,0 @@
resource ParamBasic = {
param Flag = ExistS NumQuant | ForallS NumQuant | NothingS ;
param SentForm = Indep | Attrib ;
param NumQuant = One | Many ;
}

26
examples/SUMO/SUMO.gf
View File

@@ -1,26 +0,0 @@
--# -path=.:alltenses:
abstract SUMO =
Basic,
Merge,
Elements,
MidLevelOntology,
Transportation,
Geography,
Communications,
Government,
CountriesAndRegions,
Economy,
Engineering,
FinancialOntology,
Military,
Mondial,
QoSontology,
WMD,
WorldAirportsA_K,
WorldAirportsL_Z,
Birds
** {
flags startcat = Stmt ;
}

10
examples/SUMO/SUMOBul.gf
View File

@@ -1,10 +0,0 @@
--# -path=.:alltenses
concrete SUMOBul of SUMO =
BasicBul,
BirdsBul
** {
flags unlexer = text ; lexer = text ;
} ;

Some files were not shown because too many files have changed in this diff Show More