next-lib renamed to lib, lib to old-lib

old-lib/resource/Make.hs

@@ -0,0 +1,193 @@
+module Main where
+
+import Control.Monad
+import Data.Maybe
+import System.Cmd
+import System.Directory
+import System.Environment
+import System.Exit
+
+-- Make commands for compiling and testing resource grammars.
+-- usage: runghc Make ((present? OPT?) | (clone FILE))? LANGS? 
+-- where 
+-- - OPT = (lang | api | math | pgf | test | demo | clean)
+-- - LANGS has the form e.g. langs=Eng,Fin,Rus
+-- - clone with a flag file=FILENAME clones the file to the specified languages,
+--   by replacing the 3-letter language name of the original in both 
+--   the filename and the body
+--   with each name in the list (default: all languages)
+-- With no argument, lang and api are done, in this order.
+-- See 'make' below for what is done by which command.
+
+default_gf = "../../dist/build/gf/gf"
+
+presApiPath = "-path=api:present"
+
+-- the languages have long directory names and short ISO codes (3 letters)
+-- we also give the decodings for postprocessing linearizations, as long as grammars
+-- don't support all flags needed; they are used in tests
+ 
+langsCoding = [
+  (("arabic",   "Ara"),""),
+  (("bulgarian","Bul"),""),
+  (("catalan",  "Cat"),""),
+  (("danish",   "Dan"),""),
+  (("english",  "Eng"),""),
+  (("finnish",  "Fin"),""),
+  (("french",   "Fre"),""),
+  (("hindi",    "Hin"),"to_devanagari"),
+  (("german",   "Ger"),""),
+  (("interlingua","Ina"),""),
+  (("italian",  "Ita"),""),
+  (("norwegian","Nor"),""),
+  (("russian",  "Rus"),""),
+  (("spanish",  "Spa"),""),
+  (("swedish",  "Swe"),""), 
+  (("thai",     "Tha"),"to_thai")
+  ]
+
+langs = map fst langsCoding
+
+-- languagues for which to compile Lang
+langsLang = langs `except` ["Ara"]
+
+-- languages for which to compile Try 
+langsAPI  = langsLang `except` ["Ara","Bul","Hin","Ina","Rus","Tha"]
+
+-- languages for which to compile Mathematical 
+langsMath = langsAPI
+
+-- languages for which to run treebank test
+langsTest = langsLang `except` ["Ara","Bul","Cat","Hin","Rus","Spa","Tha"]
+
+-- languages for which to run demo test
+langsDemo = langsLang `except` ["Ara","Hin","Ina","Tha"]
+
+-- languages for which langs.pgf is built
+langsPGF = langsTest `only` ["Eng","Fre","Swe"]
+
+-- languages for which Compatibility exists (to be extended)
+langsCompat = langsLang `only` ["Cat","Eng","Fin","Fre","Ita","Spa","Swe"]
+
+treebankExx = "exx-resource.gft"
+treebankResults = "exx-resource.gftb"
+
+main = do
+  xx <- getArgs
+  make xx
+
+make :: [String] -> IO ()
+make xx = do
+  let ifx  opt act = if null xx || elem opt xx then act >> return () else return () 
+  let ifxx opt act = if            elem opt xx then act >> return () else return () 
+  let pres = elem "present" xx
+  let dir = if pres then "../present" else "../alltenses"
+   
+  let optl ls = maybe ls id $ getOptLangs xx
+
+  ifx "lang" $ do
+    mapM_ (gfc pres [] . lang) (optl langsLang)
+    copy "*/*.gfo" dir
+  ifx "compat" $ do
+    mapM_ (gfc pres [] . compat) (optl langsCompat)
+    copy "*/Compatibility*.gfo" dir
+  ifx "api" $ do
+    mapM_ (gfc pres presApiPath . try) (optl langsAPI)
+    copy "*/*.gfo" dir
+  ifx "math" $ do
+    mapM_ (gfc False [] . math) (optl langsMath)
+    copy "mathematical/*.gfo" "../mathematical"
+    mapM_ (gfc False [] . symbolic) (optl langsMath)
+    copy "mathematical/Symbolic*.gfo" "../mathematical"
+  ifxx "pgf" $ do
+    run_gfc $ ["-s","--make","--name=langs","--parser=off",
+               "--output-dir=" ++ dir]
+               ++ [dir ++ "/Lang" ++ la ++ ".gfo" | (_,la) <- optl langsPGF]
+  ifxx "test" $ do
+    let ls = optl langsTest
+    gf (treeb "Lang" ls) $ unwords [dir ++ "/Lang" ++ la ++ ".gfo" | (_,la) <- ls] 
+  ifxx "demo" $ do
+    let ls = optl langsDemo
+    gf (demos "Demo" ls) $ unwords ["demo/Demo" ++ la ++ ".gf" | (_,la) <- ls]
+  ifxx "clean" $ do
+    system "rm -f */*.gfo ../alltenses/*.gfo ../present/*.gfo"
+  ifxx "clone" $ do
+    let (pref,lang) = case getLangName xx of
+          Just pl -> pl
+          _ -> error "expected flag option file=ppppppLLL.gf"
+    s <- readFile (pref ++ lang ++ ".gf")
+    mapM_ (\la -> writeFile (pref ++ la ++ ".gf") (replaceLang lang la s)) (map snd (optl langs))
+  return ()
+
+gfc pres ppath file = do
+  let preproc = if pres then "-preproc=./mkPresent" else ""
+  let path    = if pres then ppath else ""
+  putStrLn $ "Compiling " ++ file
+  run_gfc ["-s","-src", preproc, path, file]
+
+gf comm file = do
+  putStrLn $ "Reading " ++ file
+  let cmd = "echo \"" ++ comm ++ "\" | gf -s " ++ file
+  putStrLn cmd
+  system cmd
+
+treeb abstr ls = "rf -lines -tree -file=" ++ treebankExx ++ 
+        " | l -treebank " ++ unlexer abstr ls ++ " | wf -file=" ++ treebankResults
+
+demos abstr ls = "gr -number=100 | l -treebank " ++ unlexer abstr ls ++ 
+           " | ps -to_html | wf -file=resdemo.html"
+
+lang (lla,la) = lla ++ "/All" ++ la ++ ".gf"
+compat (lla,la) = lla ++ "/Compatibility" ++ la ++ ".gf"
+try  (lla,la) = "api/Try"  ++ la ++ ".gf"
+math (lla,la) = "mathematical/Mathematical"  ++ la ++ ".gf"
+symbolic (lla,la) = "mathematical/Symbolic"  ++ la ++ ".gf"
+
+except ls es = filter (flip notElem es . snd) ls
+only   ls es = filter (flip elem es . snd) ls
+
+-- list of languages overriding the definitions above
+getOptLangs args = case [ls | a <- args, let (f,ls) = splitAt 6 a, f=="langs="] of
+  ls:_ -> return $ findLangs $ seps ls
+  _ -> Nothing
+ where
+  seps = words . map (\c -> if c==',' then ' ' else c)
+  findLangs ls = [lang | lang@(_,la) <- langs, elem la ls]
+
+-- the file name has the form p....pLLL.gf, i.e. 3-letter lang name, suffix .gf
+getLangName args = case [ls | a <- args, let (f,ls) = splitAt 5 a, f=="file="] of
+  fi:_ -> let (nal,ferp) = splitAt 3 (drop 3 (reverse fi)) in return (reverse ferp,reverse nal)  
+  _ -> Nothing
+
+replaceLang s1 s2 = repl where
+  repl s = case s of
+    c:cs -> case splitAt lgs s of
+      (pre,rest) | pre == s1 -> s2 ++ repl rest
+      _                      -> c : repl cs
+    _ -> s
+  lgs = 3 -- length s1
+
+unlexer abstr ls = 
+  "-unlexer=\\\"" ++ unwords 
+      [abstr ++ la ++ "=" ++ unl | 
+        lla@(_,la) <- ls, let unl = unlex lla, not (null unl)] ++ 
+      "\\\""
+    where
+      unlex lla = maybe "" id $ lookup lla langsCoding
+
+-- | Runs the gf executable in compile mode with the given arguments.
+run_gfc :: [String] -> IO ()
+run_gfc args = 
+    do let args' = ["-batch","-gf-lib-path=../"] ++ filter (not . null) args ++ ["+RTS"] ++ rts_flags ++ ["-RTS"]
+       putStrLn $ "Running: " ++ default_gf ++ " " ++ unwords (map showArg args')
+       e <- rawSystem default_gf args'
+       case e of
+         ExitSuccess -> return ()
+         ExitFailure i -> putStrLn $ "gf exited with exit code: " ++ show i
+  where rts_flags = ["-K100M"]
+        showArg arg = "'" ++ arg ++ "'"
+
+copy :: String -> String -> IO ()
+copy from to = 
+    do system $ "cp " ++ from ++ " " ++ to
+       return ()

old-lib/resource/Makefile

@@ -0,0 +1,49 @@
+RUNGHC=runghc
+RUNMAKE=$(RUNGHC) Make.hs
+
+.PHONY: all present alltenses lang api math test demo synopsis link compiled clean
+
+all: link present alltenses math
+
+present:
+	$(RUNMAKE) present lang
+	$(RUNMAKE) present api
+
+alltenses: 
+	$(RUNMAKE) lang
+	$(RUNMAKE) api
+
+lang:
+	$(RUNMAKE) lang
+
+api:
+	$(RUNMAKE) api
+
+math:
+	$(RUNMAKE) math
+
+compat:
+	gf -batch */Compatibility*.gf
+	cp -p */Compatibility*.gfo ../alltenses/
+	cp -p */Compatibility*.gfo ../present/
+#	$(RUNMAKE) present compat
+#	$(RUNMAKE) compat
+
+test:
+	$(RUNMAKE) test
+
+demo:
+	$(RUNMAKE) demo
+
+synopsis:
+	cd doc ; $(RUNGHC) MkSynopsis ; cd ..
+
+link:
+	chmod a+x mkPresent
+
+compiled:
+	(cd .. && tar -zcf resource-compiled.tar.gz prelude alltenses present mathematical)
+
+clean:
+	$(RUNMAKE) clean
+

old-lib/resource/abstract/Adjective.gf

@@ -0,0 +1,30 @@
+--1 Adjective: Adjectives and Adjectival Phrases
+
+abstract Adjective = Cat ** {
+
+  fun
+
+-- The principal ways of forming an adjectival phrase are
+-- positive, comparative, relational, reflexive-relational, and
+-- elliptic-relational.
+-- (The superlative use is covered in [Noun Noun.html].$SuperlA$.)
+
+    PositA  : A  -> AP ;        -- warm
+    ComparA : A  -> NP -> AP ;  -- warmer than I
+    ComplA2 : A2 -> NP -> AP ;  -- married to her
+    ReflA2  : A2 -> AP ;        -- married to itself
+    UseA2   : A2 -> A ;         -- married
+
+-- Sentence and question complements defined for all adjectival
+-- phrases, although the semantics is only clear for some adjectives.
+ 
+    SentAP  : AP -> SC -> AP ;  -- good that she is here
+
+-- An adjectival phrase can be modified by an *adadjective*, such as "very".
+
+    AdAP    : AdA -> AP -> AP ; -- very warm
+
+-- The formation of adverbs from adjective (e.g. "quickly") is covered
+-- in [Adverb Adverb.html].
+
+}

old-lib/resource/abstract/Adverb.gf

@@ -0,0 +1,32 @@
+--1 Adverb: Adverbs and Adverbial Phrases
+
+abstract Adverb = Cat ** {
+
+  fun
+
+-- The two main ways of forming adverbs are from adjectives and by
+-- prepositions from noun phrases.
+
+    PositAdvAdj : A -> Adv ;                 -- warmly
+    PrepNP      : Prep -> NP -> Adv ;        -- in the house
+
+-- Comparative adverbs have a noun phrase or a sentence as object of
+-- comparison.
+
+    ComparAdvAdj  : CAdv -> A -> NP -> Adv ; -- more warmly than John
+    ComparAdvAdjS : CAdv -> A -> S  -> Adv ; -- more warmly than he runs
+
+-- Adverbs can be modified by 'adadjectives', just like adjectives.
+
+    AdAdv  : AdA -> Adv -> Adv ;             -- very quickly
+
+-- Subordinate clauses can function as adverbs.
+
+    SubjS  : Subj -> S -> Adv ;              -- when she sleeps
+
+-- Comparison adverbs also work as numeral adverbs.
+
+    AdnCAdv : CAdv -> AdN ;                  -- less (than five)
+
+
+}

old-lib/resource/abstract/Backward.gf

@@ -0,0 +1,63 @@
+--1 Obsolete constructs included for backward-compatibility
+
+abstract Backward = Cat ** {
+
+
+-- from Cat 
+
+cat 
+    Slash ;
+   
+fun
+
+-- from Verb 19/4/2008
+
+    ComplV2  : V2  -> NP -> VP ;        -- use it
+    ComplV3  : V3  -> NP -> NP -> VP ;  -- send a message to her
+    ComplV2V : V2V -> NP -> VP -> VP ;  -- cause it to burn
+    ComplV2S : V2S -> NP -> S  -> VP ;  -- tell me that it rains
+    ComplV2Q : V2Q -> NP -> QS -> VP ;  -- ask me who came
+    ComplV2A : V2A -> NP -> AP -> VP ;  -- paint it red
+
+    ReflV2   : V2 -> VP ;         -- use itself
+
+    UseVQ   : VQ -> V2 ;                -- ask (a question)
+    UseVS   : VS -> V2 ;                -- know (a secret)
+
+
+-- from Sentence 19/4/2008
+
+    SlashV2   : NP -> V2 -> Slash ;         -- (whom) he sees
+    SlashVVV2 : NP -> VV -> V2 -> Slash;    -- (whom) he wants to see 
+
+-- from Noun 19/4/2008
+
+    NumInt     : Int -> Num ;     -- 51
+    OrdInt     : Int -> Ord ;     -- 51st (DEPRECATED)
+    NoOrd : Ord ;
+
+    -- 20/4
+    DetSg : Quant ->        Ord -> Det ;  -- the best man
+    DetPl : Quant -> Num -> Ord -> Det ;  -- the five best men
+    NoNum : Num ;
+
+    -- 22/4
+    DefArt   : Quant ;       -- the (house), the (houses)
+    IndefArt : Quant ;       -- a (house), (houses)
+    MassDet  : Quant ;       -- (beer)
+
+-- from Structural 19/4/2008
+
+    that_NP : NP ;
+    these_NP : NP ;
+    this_NP : NP ;
+    those_NP : NP ;
+
+    whichPl_IDet : IDet ;
+    whichSg_IDet : IDet ;
+
+-- from Adverb
+
+    AdvSC : SC -> Adv ;     -- that he arrives ---- REMOVE?
+
+}

old-lib/resource/abstract/Cat.gf

@@ -0,0 +1,134 @@
+--1 Cat: the Category System
+
+-- The category system is central to the library in the sense
+-- that the other modules ($Adjective$, $Adverb$, $Noun$, $Verb$ etc)
+-- communicate through it. This means that a e.g. a function using
+-- $NP$s in $Verb$ need not know how $NP$s are constructed in $Noun$:
+-- it is enough that both $Verb$ and $Noun$ use the same type $NP$,
+-- which is given here in $Cat$.
+-- 
+-- Some categories are inherited from [``Common`` Common.html].
+-- The reason they are defined there is that they have the same
+-- implementation in all languages in the resource (typically,
+-- just a string). These categories are
+-- $AdA, AdN, AdV, Adv, Ant, CAdv, IAdv, PConj, Phr$, 
+-- $Pol, SC, Tense, Text, Utt, Voc$.
+--
+-- Moreover, the list categories $ListAdv, ListAP, ListNP, ListS$
+-- are defined on $Conjunction$ and only used locally there.
+
+
+abstract Cat = Common ** {
+
+  cat
+
+--2 Sentences and clauses
+
+-- Constructed in [Sentence Sentence.html], and also in
+-- [Idiom Idiom.html].
+
+    S ;     -- declarative sentence                e.g. "she lived here"
+    QS ;    -- question                            e.g. "where did she live"
+    RS ;    -- relative                            e.g. "in which she lived"
+    Cl ;    -- declarative clause, with all tenses e.g. "she looks at this"
+    ClSlash;-- clause missing NP (S/NP in GPSG)    e.g. "she looks at"
+    SSlash ;-- sentence missing NP                 e.g. "she has looked at"
+    Imp ;   -- imperative                          e.g. "look at this"
+
+--2 Questions and interrogatives
+
+-- Constructed in [Question Question.html].
+
+    QCl ;   -- question clause, with all tenses    e.g. "why does she walk"
+    IP ;    -- interrogative pronoun               e.g. "who"
+    IComp ; -- interrogative complement of copula  e.g. "where"
+    IDet ;  -- interrogative determiner            e.g. "how many"
+    IQuant; -- interrogative quantifier            e.g. "which"
+
+--2 Relative clauses and pronouns
+
+-- Constructed in [Relative Relative.html].
+
+    RCl ;   -- relative clause, with all tenses    e.g. "in which she lives"
+    RP ;    -- relative pronoun                    e.g. "in which"
+
+--2 Verb phrases
+
+-- Constructed in [Verb Verb.html].
+
+    VP ;      -- verb phrase                       e.g. "is very warm"
+    Comp ;    -- complement of copula, such as AP  e.g. "very warm"
+    VPSlash ; -- verb phrase missing complement    e.g. "give to John"
+
+--2 Adjectival phrases
+
+-- Constructed in [Adjective Adjective.html].
+
+    AP ;    -- adjectival phrase                   e.g. "very warm"
+
+--2 Nouns and noun phrases
+
+-- Constructed in [Noun Noun.html]. 
+-- Many atomic noun phrases e.g. "everybody"
+-- are constructed in [Structural Structural.html].
+-- The determiner structure is
+-- ``` Predet (QuantSg | QuantPl Num) Ord
+-- as defined in [Noun Noun.html].
+
+    CN ;     -- common noun (without determiner)    e.g. "red house"
+    NP ;     -- noun phrase (subject or object)     e.g. "the red house"
+    Pron ;   -- personal pronoun                    e.g. "she"
+    Det ;    -- determiner phrase                   e.g. "those seven"
+    Predet ; -- predeterminer (prefixed Quant)      e.g. "all"
+    Quant ;  -- quantifier ('nucleus' of Det)       e.g. "this/these"
+    Art ;    -- article                             e.g. "the"
+    Num ;    -- number determining element          e.g. "seven"
+    Card ;   -- cardinal number                     e.g. "seven"
+    Ord ;    -- ordinal number (used in Det)        e.g. "seventh"
+
+--2 Numerals
+
+-- Constructed in [Numeral Numeral.html].
+
+    Numeral ; -- cardinal or ordinal in words       e.g. "five/fifth"
+    Digits ;  -- cardinal or ordinal in digits      e.g. "1,000/1,000th"
+
+--2 Structural words
+
+-- Constructed in [Structural Structural.html].
+
+    Conj ;  -- conjunction                         e.g. "and"
+---b    DConj ; -- distributed conjunction             e.g. "both - and"
+    Subj ;  -- subjunction                         e.g. "if"
+    Prep ;  -- preposition, or just case           e.g. "in"
+
+--2 Words of open classes
+
+-- These are constructed in [Lexicon Lexicon.html] and in 
+-- additional lexicon modules.
+
+    V ;     -- one-place verb                      e.g. "sleep" 
+    V2 ;    -- two-place verb                      e.g. "love"
+    V3 ;    -- three-place verb                    e.g. "show"
+    VV ;    -- verb-phrase-complement verb         e.g. "want"
+    VS ;    -- sentence-complement verb            e.g. "claim"
+    VQ ;    -- question-complement verb            e.g. "wonder"
+    VA ;    -- adjective-complement verb           e.g. "look"
+    V2V ;   -- verb with NP and V complement       e.g. "cause"
+    V2S ;   -- verb with NP and S complement       e.g. "tell"
+    V2Q ;   -- verb with NP and Q complement       e.g. "ask"
+    V2A ;   -- verb with NP and AP complement      e.g. "paint"
+
+    A ;     -- one-place adjective                 e.g. "warm"
+    A2 ;    -- two-place adjective                 e.g. "divisible"
+
+    N ;     -- common noun                         e.g. "house"
+    N2 ;    -- relational noun                     e.g. "son"
+    N3 ;    -- three-place relational noun         e.g. "connection"
+    PN ;    -- proper name                         e.g. "Paris"
+
+-- DEPRECATED: QuantSg, QuantPl
+---    QuantSg ;-- quantifier ('nucleus' of sing. Det) e.g. "every"
+---    QuantPl ;-- quantifier ('nucleus' of plur. Det) e.g. "many"
+
+}

old-lib/resource/abstract/Common.gf

@@ -0,0 +1,61 @@
+--1 Common: Structures with Common Implementations.
+
+-- This module defines the categories that uniformly have the linearization
+-- ${s : Str}$ in all languages. 
+
+-- Moreover, this module defines the abstract parameters of tense, polarity, and
+-- anteriority, which are used in [``Phrase`` Phrase.html] to generate different
+-- forms of sentences. Together they give 4 x 2 x 2 = 16 sentence forms.
+
+-- These tenses are defined for all languages in the library. More tenses
+-- can be defined in the language extensions, e.g. the "passé simple" of
+-- Romance languages in [``ExtraRomance`` ../romance/ExtraRomance.gf].
+
+abstract Common = {
+
+  cat
+
+--2 Top-level units
+
+-- Constructed in [``Text`` Text.html]: $Text$.
+
+    Text ;  -- text consisting of several phrases  e.g. "He is here. Why?"
+
+-- Constructed in [``Phrase`` Phrase.html]:
+
+    Phr ;   -- phrase in a text                    e.g. "but be quiet please"
+    Utt ;   -- sentence, question, word...         e.g. "be quiet"
+    Voc ;   -- vocative or "please"                e.g. "my darling"
+    PConj ; -- phrase-beginning conjunction        e.g. "therefore"
+
+-- Constructed in [``Sentence`` Sentence.html]:
+
+    SC ;    -- embedded sentence or question       e.g. "that it rains"
+
+--2 Adverbs
+
+-- Constructed in [``Adverb`` Adverb.html].  
+-- Many adverbs are constructed in [``Structural`` Structural.html].
+
+    Adv ;   -- verb-phrase-modifying adverb        e.g. "in the house"
+    AdV ;   -- adverb directly attached to verb    e.g. "always"
+    AdA ;   -- adjective-modifying adverb          e.g. "very"
+    AdN ;   -- numeral-modifying adverb            e.g. "more than"
+    IAdv ;  -- interrogative adverb                e.g. "why"
+    CAdv ;  -- comparative adverb                  e.g. "more"
+
+--2 Tense, polarity, and anteriority
+
+    Tense ; -- tense                               e.g. present, past, future
+    Pol ;   -- polarity                            e.g. positive, negative
+    Ant ;   -- anteriority                         e.g. simultaneous, anterior
+
+  fun
+    PPos, PNeg : Pol ;           -- I sleep/don't sleep
+
+    TPres  : Tense ;                
+    ASimul : Ant ;
+    TPast, TFut, TCond : Tense ; -- I slept/will sleep/would sleep --# notpresent
+    AAnter : Ant ;               -- I have slept                   --# notpresent
+
+}

old-lib/resource/abstract/Compatibility.gf

@@ -0,0 +1,9 @@
+abstract Compatibility = Cat ** {
+
+-- from Noun 19/4/2008
+
+fun
+    NumInt     : Int -> Num ;     -- 57
+    OrdInt     : Int -> Ord ;     -- 57
+
+}

old-lib/resource/abstract/Conjunction.gf

@@ -0,0 +1,52 @@
+--1 Conjunction: Coordination
+
+-- Coordination is defined for many different categories; here is
+-- a sample. The rules apply to *lists* of two or more elements,
+-- and define two general patterns: 
+-- - ordinary conjunction: X,...X and X
+-- - distributed conjunction: both X,...,X and X
+--
+--
+-- $VP$ conjunctions are not covered here, because their applicability
+-- depends on language. Some special cases are defined in 
+-- [``Extra`` ../abstract/Extra.gf].
+
+
+abstract Conjunction = Cat ** {
+
+--2 Rules
+
+  fun
+    ConjS    : Conj -> [S] -> S ;     -- "he walks and she runs"
+    ConjAP   : Conj -> [AP] -> AP ;   -- "cold and warm"
+    ConjNP   : Conj -> [NP] -> NP ;   -- "she or we"
+    ConjAdv  : Conj -> [Adv] -> Adv ; -- "here or there"
+
+---b    DConjS   : DConj -> [S] -> S ;    -- "either he walks or she runs"
+---b    DConjAP  : DConj -> [AP] -> AP ;  -- "both warm and cold"
+---b    DConjNP  : DConj -> [NP] -> NP ;  -- "either he or she"
+---b    DConjAdv : DConj -> [Adv] -> Adv; -- "both here and there"
+
+--2 Categories
+
+-- These categories are only used in this module.
+
+  cat
+    [S]{2} ; 
+    [Adv]{2} ; 
+    [NP]{2} ; 
+    [AP]{2} ;
+
+--2 List constructors
+
+-- The list constructors are derived from the list notation and therefore
+-- not given explicitly. But here are their type signatures:
+
+  --  BaseC : C -> C   -> [C] ;  -- for C = S, AP, NP, Adv
+  --  ConsC : C -> [C] -> [C] ;
+}
+
+--.
+-- *Note*. This module uses right-recursive lists. If backward
+-- compatibility with API 0.9 is needed, use
+-- [SeqConjunction SeqConjunction.html].

old-lib/resource/abstract/Extra.gf

@@ -0,0 +1,30 @@
+--1 More syntax rules
+
+-- This module defines syntax rules that are not implemented in all
+-- languages, but in more than one, so that it makes sense to offer a
+-- common API.
+
+abstract Extra = Cat ** {
+
+  fun
+    GenNP       : NP -> Quant ;       -- this man's
+    ComplBareVS : VS -> S -> VP ;     -- know you go
+
+    StrandRelSlash   : RP -> ClSlash -> RCl ;   -- that he lives in
+    EmptyRelSlash    : RP -> ClSlash -> RCl ;   -- he lives in
+    StrandQuestSlash : IP -> ClSlash -> QCl ;   -- whom does John live with
+
+-- $VP$ conjunction, which has different fragments implemented in
+-- different languages - never a full $VP$, though.
+
+  cat
+    VPI ;
+    [VPI] {2} ;
+
+  fun
+    MkVPI : VP -> VPI ;
+    ConjVPI : Conj -> [VPI] -> VPI ;
+    ComplVPIVV : VV -> VPI -> VP ;
+
+
+}

old-lib/resource/abstract/Grammar.gf

@@ -0,0 +1,22 @@
+--1 Grammar: the Main Module of the Resource Grammar
+
+-- This grammar is a collection of the different grammar modules,
+-- To test the resource, import [``Lang`` Lang.html], which also contains
+-- a lexicon.
+
+abstract Grammar = 
+  Noun,
+  Verb, 
+  Adjective,
+  Adverb,
+  Numeral,
+  Sentence, 
+  Question,
+  Relative,
+  Conjunction,
+  Phrase,
+  Text,
+  Structural,
+  Idiom ;
+
+

old-lib/resource/abstract/Idiom.gf

@@ -0,0 +1,22 @@
+--1 Idiom: Idiomatic Expressions
+
+abstract Idiom = Cat ** {
+
+-- This module defines constructions that are formed in fixed ways,
+-- often different even in closely related languages.
+
+  fun
+    ImpersCl  : VP -> Cl ;        -- it is hot
+    GenericCl : VP -> Cl ;        -- one sleeps
+
+    CleftNP   : NP  -> RS -> Cl ; -- it is I who did it
+    CleftAdv  : Adv -> S  -> Cl ; -- it is here she slept
+
+    ExistNP   : NP -> Cl ;        -- there is a house
+    ExistIP   : IP -> QCl ;       -- which houses are there
+
+    ProgrVP   : VP -> VP ;        -- be sleeping
+
+    ImpPl1    : VP -> Utt ;       -- let's go
+
+}

old-lib/resource/abstract/Lang.gf

@@ -0,0 +1,13 @@
+--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 Lang = 
+  Grammar,
+  Lexicon
+  ** {
+  flags startcat=Phr ;
+  } ;

old-lib/resource/abstract/Lexicon.gf

@@ -0,0 +1,356 @@
+abstract Lexicon = Cat ** {
+fun
+  add_V3 : V3 ;
+  airplane_N : N ;
+  already_Adv : Adv ;
+  animal_N : N ;
+  answer_V2S : V2S ;
+  apartment_N : N ;
+  apple_N : N ;
+  art_N : N ;
+  ashes_N : N ;
+  ask_V2Q : V2Q ;
+  baby_N : N ;
+  back_N : N ;
+  bad_A : A ;
+  bank_N : N ;
+  bark_N : N ;
+  beautiful_A : A ;
+  become_VA : VA ;
+  beer_N : N ;
+  beg_V2V : V2V ;
+  belly_N : N ;
+  big_A : A ;
+  bike_N : N ;
+  bird_N : N ;
+  bite_V2 : V2 ;
+  black_A : A ;
+  blood_N : N ;
+  blow_V : V ;
+  blue_A : A ;
+  boat_N : N ;
+  bone_N : N ;
+  book_N : N ;
+  boot_N : N ;
+  boss_N : N ;
+  boy_N : N ;
+  bread_N : N ;
+  break_V2 : V2 ;
+  breast_N : N ;
+  breathe_V : V ;
+  broad_A : A ;
+  brother_N2 : N2 ;
+  brown_A : A ;
+  burn_V : V ;
+  butter_N : N ;
+  buy_V2 : V2 ;
+  camera_N : N ;
+  cap_N : N ;
+  car_N : N ;
+  carpet_N : N ;
+  cat_N : N ;
+  ceiling_N : N ;
+  chair_N : N ;
+  cheese_N : N ;
+  child_N : N ;
+  church_N : N ;
+  city_N : N ;
+  clean_A : A ;
+  clever_A : A ;
+  close_V2 : V2 ;
+  cloud_N : N ;
+  coat_N : N ;
+  cold_A : A ;
+  come_V : V ;
+  computer_N : N ;
+  correct_A : A ;
+  country_N : N ;
+  count_V2 : V2 ;
+  cousin_N : N ;
+  cow_N : N ;
+  cut_V2 : V2 ;
+  day_N : N ;
+  die_V : V ;
+  dig_V : V ;
+  dirty_A : A ;
+  distance_N3 : N3 ;
+  doctor_N : N ;
+  dog_N : N ;
+  door_N : N ;
+  do_V2 : V2 ;
+  drink_V2 : V2 ;
+  drink_V2 : V2 ;
+  dry_A : A ;
+  dull_A : A ;
+  dust_N : N ;
+  ear_N : N ;
+  earth_N : N ;
+  easy_A2V : A2 ;
+  eat_V2 : V2 ;
+  eat_V2 : V2 ;
+  egg_N : N ;
+  empty_A : A ;
+  enemy_N : N ;
+  eye_N : N ;
+  factory_N : N ;
+  fall_V : V ;
+  far_Adv : Adv ;
+  father_N2 : N2 ;
+  fat_N : N ;
+  fear_VS : VS ;
+  fear_V2 : V2 ;
+  feather_N : N ;
+  fight_V2 : V2 ;
+  find_V2 : V2 ;
+  fingernail_N : N ;
+  fire_N : N ;
+  fish_N : N ;
+  float_V : V ;
+  floor_N : N ;
+  flower_N : N ;
+  flow_V : V ;
+  fly_V : V ;
+  fog_N : N ;
+  foot_N : N ;
+  forest_N : N ;
+  forget_V2 : V2 ;
+  freeze_V : V ;
+  fridge_N : N ;
+  friend_N : N ;
+  fruit_N : N ;
+  full_A : A ;
+  fun
+  fun_AV : A ;
+  garden_N : N ;
+  girl_N : N ;
+  give_V3 : V3 ;
+  glove_N : N ;
+  gold_N : N ;
+  good_A : A ;
+  go_V : V ;
+  grammar_N : N ;
+  grass_N : N ;
+  green_A : A ;
+  guts_N : N ;
+  hair_N : N ;
+  hand_N : N ;
+  harbour_N : N ;
+  hate_V2 : V2 ;
+  hat_N : N ;
+  have_V2 : V2 ;
+  head_N : N ;
+  heart_N : N ;
+  hear_V2 : V2 ;
+  hear_V2 : V2 ;
+  heavy_A : A ;
+  hill_N : N ;
+  hit_V2 : V2 ;
+  hold_V2 : V2 ;
+  hope_VS : VS ;
+  horn_N : N ;
+  horse_N : N ;
+  hot_A : A ;
+  house_N : N ;
+  hunt_V2 : V2 ;
+  husband_N : N ;
+  ice_N : N ;
+  important_A : A ;
+  industry_N : N ;
+  iron_N : N ;
+  john_PN : PN ;
+  jump_V : V ;
+  kill_V2 : V2 ;
+  king_N : N ;
+  knee_N : N ;
+  know_V2 : V2 ;
+  know_V2 : V2 ;
+  lake_N : N ;
+  lamp_N : N ;
+  language_N : N ;
+  laugh_V : V ;
+  leaf_N : N ;
+  learn_V2 : V2 ;
+  leather_N : N ;
+  leave_V2 : V2 ;
+  left_Ord : Ord ;
+  leg_N : N ;
+  lie_V : V ;
+  like_V2 : V2 ;
+  listen_V2 : V2 ;
+  liver_N : N ;
+  live_V : V ;
+  long_A : A ;
+  lose_V2 : V2 ;
+  louse_N : N ;
+  love_N : N ;
+  love_V2 : V2 ;
+  man_N : N ;
+  married_A2 : A2 ;
+  meat_N : N ;
+  milk_N : N ;
+  moon_N : N ;
+  mother_N2 : N2 ;
+  mountain_N : N ;
+  mouth_N : N ;
+  music_N : N ;
+  name_N : N ;
+  narrow_A : A ;
+  near_A : A ;
+  neck_N : N ;
+  new_A : A ;
+  newspaper_N : N ;
+  night_N : N ;
+  nose_N : N ;
+  now_Adv : Adv ;
+  number_N : N ;
+  oil_N : N ;
+  old_A : A ;
+  open_V2 : V2 ;
+  paint_V2A : V2A ;
+  paper_N : N ;
+  paris_PN : PN ;
+  peace_N : N ;
+  pen_N : N ;
+  person_N : N ;
+  planet_N : N ;
+  plastic_N : N ;
+  play_V2 : V2 ;
+  play_V : V ;
+  policeman_N : N ;
+  priest_N : N ;
+  probable_AS : A ;
+  pull_V2 : V2 ;
+  push_V2 : V2 ;
+  put_V2 : V2 ;
+  queen_N : N ;
+  question_N : N ;
+  radio_N : N ;
+  rain_N : N ;
+  rain_V0 : V ;
+  read_V2 : V2 ;
+  ready_A : A ;
+  reason_N : N ;
+  red_A : A ;
+  religion_N : N ;
+  restaurant_N : N ;
+  right_Ord : Ord ;
+  river_N : N ;
+  road_N : N ;
+  rock_N : N ;
+  roof_N : N ;
+  root_N : N ;
+  rope_N : N ;
+  rotten_A : A ;
+  round_A : A ;
+  rubber_N : N ;
+  rub_V2 : V2 ;
+  rule_N : N ;
+  run_V : V ;
+  salt_N : N ;
+  sand_N : N ;
+  say_VS : VS ;
+  school_N : N ;
+  science_N : N ;
+  scratch_V2 : V2 ;
+  sea_N : N ;
+  seed_N : N ;
+  seek_V2 : V2 ;
+  see_V2 : V2 ;
+  see_V2 : V2 ;
+  sell_V3 : V3 ;
+  send_V3 : V3 ;
+  sew_V : V ;
+  sharp_A : A ;
+  sheep_N : N ;
+  ship_N : N ;
+  shirt_N : N ;
+  shoe_N : N ;
+  shop_N : N ;
+  short_A : A ;
+  silver_N : N ;
+  sing_V : V ;
+  sister_N : N ;
+  sit_V : V ;
+  skin_N : N ;
+  sky_N : N ;
+  sleep_V : V ;
+  small_A : A ;
+  smell_V : V ;
+  smoke_N : N ;
+  smooth_A : A ;
+  snake_N : N ;
+  snow_N : N ;
+  sock_N : N ;
+  song_N : N ;
+  speak_V2 : V2 ;
+  spit_V : V ;
+  split_V2 : V2 ;
+  squeeze_V2 : V2 ;
+  stab_V2 : V2 ;
+  stand_V : V ;
+  star_N : N ;
+  steel_N : N ;
+  stick_N : N ;
+  stone_N : N ;
+  stop_V : V ;
+  stove_N : N ;
+  straight_A : A ;
+  student_N : N ;
+  stupid_A : A ;
+  suck_V2 : V2 ;
+  sun_N : N ;
+  swell_V : V ;
+  swim_V : V ;
+  switch8off_V2 : V2 ;
+  switch8on_V2 : V2 ;
+  table_N : N ;
+  tail_N : N ;
+  talk_V3 : V3 ;
+  teacher_N : N ;
+  teach_V2 : V2 ;
+  television_N : N ;
+  thick_A : A ;
+  thin_A : A ;
+  think_V : V ;
+  throw_V2 : V2 ;
+  tie_V2 : V2 ;
+  today_Adv : Adv ;
+  tongue_N : N ;
+  tooth_N : N ;
+  train_N : N ;
+  travel_V : V ;
+  tree_N : N ;
+  turn_V : V ;
+  ugly_A : A ;
+  uncertain_A : A ;
+  understand_V2 : V2 ;
+  university_N : N ;
+  village_N : N ;
+  vomit_V : V ;
+  wait_V2 : V2 ;
+  walk_V : V ;
+  warm_A : A ;
+  war_N : N ;
+  wash_V2 : V2 ;
+  watch_V2 : V2 ;
+  water_N : N ;
+  wet_A : A ;
+  white_A : A ;
+  wide_A : A ;
+  wife_N : N ;
+  wind_N : N ;
+  window_N : N ;
+  wine_N : N ;
+  wing_N : N ;
+  win_V2 : V2 ;
+  wipe_V2 : V2 ;
+  woman_N : N ;
+  wonder_VQ : VQ ;
+  wood_N : N ;
+  worm_N : N ;
+  write_V2 : V2 ;
+  year_N : N ;
+  yellow_A : A ;
+  young_A : A ;
+
+}

old-lib/resource/abstract/Noun.gf

@@ -0,0 +1,144 @@
+--1 Noun: Nouns, noun phrases, and determiners
+
+abstract Noun = Cat ** {
+
+
+--2 Noun phrases
+
+-- The three main types of noun phrases are
+-- - common nouns with determiners
+-- - proper names
+-- - pronouns
+--
+--
+  fun
+    DetCN   : Det -> CN -> NP ;   -- the man
+    UsePN   : PN -> NP ;          -- John
+    UsePron : Pron -> NP ;        -- he
+
+-- Pronouns are defined in the module [``Structural`` Structural.html].
+
+-- A noun phrase already formed can be modified by a $Predet$erminer.
+
+    PredetNP : Predet -> NP -> NP; -- only the man 
+
+-- A noun phrase can also be postmodified by the past participle of a
+-- verb, by an adverb, or by a relative clause
+
+    PPartNP : NP -> V2  -> NP ;    -- the man seen
+    AdvNP   : NP -> Adv -> NP ;    -- Paris today
+    RelNP   : NP -> RS  -> NP ;    -- Paris, which is here
+
+-- Determiners can form noun phrases directly.
+
+    DetNP   : Det -> NP ;  -- these five
+
+
+--2 Determiners
+
+-- The determiner has a fine-grained structure, in which a 'nucleus'
+-- quantifier and two optional parts can be discerned: a cardinal and
+-- an ordinal numeral.
+
+    DetQuantOrd : Quant -> Num -> Ord -> Det ;  -- these five best
+    DetQuant    : Quant -> Num        -> Det ;  -- these five
+
+-- Whether the resulting determiner is singular or plural depends on the
+-- cardinal.
+
+-- All parts of the determiner can be empty, except $Quant$, which is
+-- the "kernel" of a determiner. It is, however, the $Num$ that determines
+-- the inherent number.
+
+    NumSg   : Num ;
+    NumPl   : Num ;
+    NumCard : Card -> Num ;
+
+-- $Card$ consists of either digits or numeral words.
+
+    NumDigits  : Digits  -> Card ;  -- 51
+    NumNumeral : Numeral -> Card ;  -- fifty-one
+
+-- The construction of numerals is defined in [Numeral Numeral.html].
+
+-- A $Card$ can  be modified by certain adverbs.
+
+    AdNum : AdN -> Card -> Card ;   -- almost 51
+
+-- An $Ord$ consists of either digits or numeral words.
+-- Also superlative forms of adjectives behave syntactically like ordinals.
+
+    OrdDigits  : Digits  -> Ord ;  -- 51st
+    OrdNumeral : Numeral -> Ord ;  -- fifty-first
+    OrdSuperl  : A       -> Ord ;  -- warmest
+
+-- Definite and indefinite noun phrases are sometimes realized as
+-- neatly distinct words (Spanish "un, unos ; el, los") but also without
+-- any particular word (Finnish; Swedish definites).
+
+    DetArtOrd  : Art -> Num  -> Ord -> Det ;  -- the (five) best
+    DetArtCard : Art -> Card        -> Det ;  -- the five
+
+    IndefArt   : Art ;
+    DefArt     : Art ;
+
+-- Articles cannot alone form noun phrases, but need a noun.
+
+    DetArtSg   : Art -> CN -> NP ;   -- the man
+    DetArtPl   : Art -> CN -> NP ;   -- the men
+
+-- Nouns can be used without an article as mass nouns. The resource does
+-- not distinguish mass nouns from other common nouns, which can result
+-- in semantically odd expressions.
+
+    MassNP    : CN -> NP ;            -- (beer)
+
+-- Pronouns have possessive forms. Genitives of other kinds
+-- of noun phrases are not given here, since they are not possible
+-- in e.g. Romance languages. They can be found in $Extra$ modules.
+
+    PossPron : Pron -> Quant ;    -- my (house)
+
+-- Other determiners are defined in [Structural Structural.html].
+
+
+
+--2 Common nouns
+
+-- Simple nouns can be used as nouns outright.
+
+    UseN : N -> CN ;              -- house
+
+-- Relational nouns take one or two arguments.
+
+    ComplN2 : N2 -> NP -> CN ;    -- mother of the king
+    ComplN3 : N3 -> NP -> N2 ;    -- distance from this city (to Paris)
+
+-- Relational nouns can also be used without their arguments.
+-- The semantics is typically derivative of the relational meaning.
+
+    UseN2   : N2 -> CN ;          -- mother
+    Use2N3  : N3 -> N2 ;          -- distance (from this city)
+    Use3N3  : N3 -> N2 ;          -- distance (to Paris)
+
+-- Nouns can be modified by adjectives, relative clauses, and adverbs
+-- (the last rule will give rise to many 'PP attachment' ambiguities
+-- when used in connection with verb phrases).
+
+    AdjCN   : AP -> CN  -> CN ;   -- big house
+    RelCN   : CN -> RS  -> CN ;   -- house that John bought
+    AdvCN   : CN -> Adv -> CN ;   -- house on the hill
+
+-- Nouns can also be modified by embedded sentences and questions.
+-- For some nouns this makes little sense, but we leave this for applications
+-- to decide. Sentential complements are defined in [Verb Verb.html].
+
+    SentCN  : CN -> SC  -> CN ;   -- question where she sleeps
+
+--2 Apposition
+
+-- This is certainly overgenerating.
+
+    ApposCN : CN -> NP -> CN ;    -- city Paris (, numbers x and y)
+
+} ;

old-lib/resource/abstract/Numeral.gf

@@ -0,0 +1,60 @@
+--1 Numerals
+
+-- This grammar defines numerals from 1 to 999999. 
+-- The implementations are adapted from the
+-- [numerals library http://www.cs.chalmers.se/~aarne/GF/examples/numerals/] 
+-- which defines numerals for 88 languages.
+-- The resource grammar implementations add to this inflection (if needed)
+-- and ordinal numbers.
+--
+-- *Note* 1. Number 1 as defined 
+-- in the category $Numeral$ here should not be used in the formation of
+-- noun phrases, and should therefore be removed. Instead, one should use
+-- [Structural Structural.html]$.one_Quant$. This makes the grammar simpler
+-- because we can assume that numbers form plural noun phrases.
+--
+-- *Note* 2. The implementations introduce spaces between
+-- parts of a numeral, which is often incorrect - more work on
+-- (un)lexing is needed to solve this problem.
+
+abstract Numeral = Cat ** {
+
+cat 
+  Digit ;       -- 2..9
+  Sub10 ;       -- 1..9
+  Sub100 ;      -- 1..99
+  Sub1000 ;     -- 1..999
+  Sub1000000 ;  -- 1..999999
+
+fun 
+  num : Sub1000000 -> Numeral ;
+
+  n2, n3, n4, n5, n6, n7, n8, n9 : Digit ;
+
+  pot01 : Sub10 ;                               -- 1
+  pot0 : Digit -> Sub10 ;                       -- d * 1
+  pot110 : Sub100 ;                             -- 10
+  pot111 : Sub100 ;                             -- 11
+  pot1to19 : Digit -> Sub100 ;                  -- 10 + d
+  pot0as1 : Sub10 -> Sub100 ;                   -- coercion of 1..9
+  pot1 : Digit -> Sub100 ;                      -- d * 10
+  pot1plus : Digit -> Sub10 -> Sub100 ;         -- d * 10 + n
+  pot1as2 : Sub100 -> Sub1000 ;                 -- coercion of 1..99
+  pot2 : Sub10 -> Sub1000 ;                     -- m * 100
+  pot2plus : Sub10 -> Sub100 -> Sub1000 ;       -- m * 100 + n
+  pot2as3 : Sub1000 -> Sub1000000 ;             -- coercion of 1..999
+  pot3 : Sub1000 -> Sub1000000 ;                -- m * 1000
+  pot3plus : Sub1000 -> Sub1000 -> Sub1000000 ; -- m * 1000 + n
+
+-- Numerals as sequences of digits have a separate, simpler grammar
+
+  cat 
+    Dig ;  -- single digit 0..9
+
+  fun
+    IDig  : Dig -> Digits ;       -- 8
+    IIDig : Dig -> Digits -> Digits ; -- 876
+
+    D_0, D_1, D_2, D_3, D_4, D_5, D_6, D_7, D_8, D_9 : Dig ;
+
+}

old-lib/resource/abstract/Phrase.gf

@@ -0,0 +1,44 @@
+--1 Phrase: Phrases and Utterances
+
+abstract Phrase = Cat ** {
+
+-- When a phrase is built from an utterance it can be prefixed
+-- with a phrasal conjunction (such as "but", "therefore")
+-- and suffixing with a vocative (typically a noun phrase).
+
+  fun
+    PhrUtt   : PConj -> Utt -> Voc -> Phr ; -- but come here, my friend
+
+-- Utterances are formed from sentences, questions, and imperatives.
+
+    UttS      : S   -> Utt ;                -- John walks
+    UttQS     : QS  -> Utt ;                -- is it good
+    UttImpSg  : Pol -> Imp -> Utt;          -- (don't) love yourself
+    UttImpPl  : Pol -> Imp -> Utt;          -- (don't) love yourselves
+    UttImpPol : Pol -> Imp -> Utt ;         -- (don't) sleep (polite)
+
+-- There are also 'one-word utterances'. A typical use of them is
+-- as answers to questions.
+-- *Note*. This list is incomplete. More categories could be covered.
+-- Moreover, in many languages e.g. noun phrases in different cases
+-- can be used.
+
+    UttIP   : IP   -> Utt ;                 -- who
+    UttIAdv : IAdv -> Utt ;                 -- why
+    UttNP   : NP   -> Utt ;                 -- this man
+    UttAdv  : Adv  -> Utt ;                 -- here
+    UttVP   : VP   -> Utt ;                 -- to sleep
+
+-- The phrasal conjunction is optional. A sentence conjunction
+-- can also used to prefix an utterance.
+
+    NoPConj   : PConj ;                      
+    PConjConj : Conj -> PConj ;             -- and
+
+-- The vocative is optional. Any noun phrase can be made into vocative,
+-- which may be overgenerating (e.g. "I").
+
+    NoVoc   : Voc ;
+    VocNP   : NP -> Voc ;                   -- my friend
+
+}

old-lib/resource/abstract/Question.gf

@@ -0,0 +1,41 @@
+--1 Question: Questions and Interrogative Pronouns
+
+abstract Question = Cat ** {
+
+-- A question can be formed from a clause ('yes-no question') or
+-- with an interrogative.
+
+  fun
+    QuestCl     : Cl -> QCl ;            -- does John walk
+    QuestVP     : IP -> VP -> QCl ;      -- who walks
+    QuestSlash  : IP -> ClSlash -> QCl ; -- whom does John love
+    QuestIAdv   : IAdv -> Cl -> QCl ;    -- why does John walk
+    QuestIComp  : IComp -> NP -> QCl ;   -- where is John
+
+-- Interrogative pronouns can be formed with interrogative
+-- determiners, with or without a noun.
+
+    IdetCN    : IDet -> CN -> IP ;       -- which five songs
+    IdetIP    : IDet       -> IP ;       -- which five
+
+-- They can be modified with adverbs.
+
+    AdvIP     : IP -> Adv -> IP ;        -- who in Paris
+
+-- Interrogative quantifiers have number forms and can take number modifiers.
+
+    IdetQuant : IQuant -> Num -> IDet ;  -- which (five)
+
+-- Interrogative adverbs can be formed prepositionally.
+
+    PrepIP    : Prep -> IP -> IAdv ;     -- with whom
+
+-- Interrogative complements to copulas can be both adverbs and
+-- pronouns.
+
+    CompIAdv  : IAdv -> IComp ;          -- where (is it)
+    CompIP    : IP   -> IComp ;          -- who (is it)
+
+-- More $IP$, $IDet$, and $IAdv$ are defined in $Structural$.
+
+}

old-lib/resource/abstract/Relative.gf

@@ -0,0 +1,26 @@
+--1 Relative clauses and pronouns
+
+abstract Relative = Cat ** {
+
+  fun
+
+-- The simplest way to form a relative clause is from a clause by
+-- a pronoun similar to "such that".
+
+    RelCl    : Cl -> RCl ;            -- such that John loves her
+
+-- The more proper ways are from a verb phrase 
+-- (formed in [``Verb`` Verb.html]) or a sentence 
+-- with a missing noun phrase (formed in [``Sentence`` Sentence.html]).
+
+    RelVP    : RP -> VP -> RCl ;      -- who loves John
+    RelSlash : RP -> ClSlash -> RCl ; -- whom John loves
+
+-- Relative pronouns are formed from an 'identity element' by prefixing
+-- or suffixing (depending on language) prepositional phrases.
+
+    IdRP  : RP ;                      -- which
+    FunRP : Prep -> NP -> RP -> RP ;  -- the mother of whom
+
+}
+

old-lib/resource/abstract/Sentence.gf

@@ -0,0 +1,95 @@
+--1 Sentence: Sentences, Clauses, and Imperatives
+
+abstract Sentence = Cat ** {
+
+--2 Clauses
+
+-- The $NP VP$ predication rule form a clause whose linearization
+-- gives a table of all tense variants, positive and negative.
+-- Clauses are converted to $S$ (with fixed tense) with the
+-- $UseCl$ function below.
+
+  fun
+    PredVP    : NP -> VP -> Cl ;         -- John walks
+
+-- Using an embedded sentence as a subject is treated separately.
+-- This can be overgenerating. E.g. "whether you go" as subject
+-- is only meaningful for some verb phrases.
+
+    PredSCVP  : SC -> VP -> Cl ;         -- that she goes is good
+
+--2 Clauses missing object noun phrases
+
+-- This category is a variant of the 'slash category' $S/NP$ of
+-- GPSG and categorial grammars, which in turn replaces
+-- movement transformations in the formation of questions
+-- and relative clauses. Except $SlashV2$, the construction 
+-- rules can be seen as special cases of function composition, in
+-- the style of CCG.
+-- *Note* the set is not complete and lacks e.g. verbs with more than 2 places.
+
+    SlashVP   : NP -> VPSlash -> ClSlash ;      -- (whom) he sees
+    AdvSlash  : ClSlash -> Adv -> ClSlash ;     -- (whom) he sees today
+    SlashPrep : Cl -> Prep -> ClSlash ;         -- (with whom) he walks 
+    SlashVS   : NP -> VS -> SSlash -> ClSlash ; -- (whom) she says that he loves
+
+--2 Imperatives
+
+-- An imperative is straightforwardly formed from a verb phrase.
+-- It has variation over positive and negative, singular and plural.
+-- To fix these parameters, see [Phrase Phrase.html].
+
+    ImpVP     : VP -> Imp ;              -- love yourselves
+
+--2 Embedded sentences
+
+-- Sentences, questions, and infinitival phrases can be used as
+-- subjects and (adverbial) complements.
+
+    EmbedS    : S  -> SC ;               -- that she goes
+    EmbedQS   : QS -> SC ;               -- who goes
+    EmbedVP   : VP -> SC ;               -- to go
+
+--2 Sentences
+
+-- These are the 2 x 4 x 4 = 16 forms generated by different
+-- combinations of tense, polarity, and
+-- anteriority, which are defined in [``Common`` Common.html].
+
+  fun
+    UseCl  : Tense -> Ant -> Pol -> Cl  -> S ;
+    UseQCl : Tense -> Ant -> Pol -> QCl -> QS ;
+    UseRCl : Tense -> Ant -> Pol -> RCl -> RS ;
+    UseSlash : Tense -> Ant -> Pol -> ClSlash -> SSlash ;
+
+-- An adverb can be added to the beginning of a sentence.
+
+    AdvS   : Adv -> S  -> S ;            -- today, I will go home
+
+-- A sentence can be modified by a relative clause referring to its contents.
+
+    RelS   : S -> RS -> S ;              -- she sleeps, which is good
+
+}
+
+--.
+
+-- Examples for English $S$/$Cl$:
+{-
+  Pres  Simul  Pos  ODir  : he sleeps
+  Pres  Simul  Neg  ODir  : he doesn't sleep
+  Pres  Anter  Pos  ODir  : he has slept
+  Pres  Anter  Neg  ODir  : he hasn't slept
+  Past  Simul  Pos  ODir  : he slept
+  Past  Simul  Neg  ODir  : he didn't sleep
+  Past  Anter  Pos  ODir  : he had slept
+  Past  Anter  Neg  ODir  : he hadn't slept
+  Fut   Simul  Pos  ODir  : he will sleep
+  Fut   Simul  Neg  ODir  : he won't sleep
+  Fut   Anter  Pos  ODir  : he will have slept
+  Fut   Anter  Neg  ODir  : he won't have slept
+  Cond  Simul  Pos  ODir  : he would sleep
+  Cond  Simul  Neg  ODir  : he wouldn't sleep
+  Cond  Anter  Pos  ODir  : he would have slept
+  Cond  Anter  Neg  ODir  : he wouldn't have slept
+-}

old-lib/resource/abstract/Structural.gf

@@ -0,0 +1,111 @@
+--1 Structural: Structural Words
+-- 
+-- Here we have some words belonging to closed classes and appearing
+-- in all languages we have considered.
+-- Sometimes more distinctions are needed, e.g. $we_Pron$ in Spanish
+-- should be replaced by masculine and feminine variants, found in
+-- [``ExtraSpa`` ../spanish/ExtraSpa.gf].
+
+abstract Structural = Cat ** {
+
+  fun
+
+-- This is an alphabetical list of structural words
+
+  above_Prep : Prep ;  
+  after_Prep : Prep ;
+  all_Predet : Predet ;
+  almost_AdA : AdA ;   
+  almost_AdN : AdN ;   
+  although_Subj : Subj ;
+  always_AdV : AdV ;
+  and_Conj : Conj ;
+  because_Subj : Subj ;
+  before_Prep : Prep ;
+  behind_Prep : Prep ;
+  between_Prep : Prep ;
+  both7and_DConj : Conj ; -- both...and
+---b  both7and_DConj : DConj ;
+  but_PConj : PConj ;
+  by8agent_Prep : Prep ; -- by (agent)
+  by8means_Prep : Prep ; -- by (means of)
+  can8know_VV : VV ; -- can (capacity)
+  can_VV : VV ;      -- can (possibility)
+  during_Prep : Prep ;
+  either7or_DConj : Conj ; -- either...or
+---b  either7or_DConj : DConj ;
+  every_Det : Det ;
+  everybody_NP : NP ;  -- everybody
+  everything_NP : NP ;
+  everywhere_Adv : Adv ;
+---  first_Ord : Ord ; DEPRECATED
+  few_Det : Det ;
+  for_Prep : Prep ;
+  from_Prep : Prep ;
+  he_Pron : Pron ;
+  here_Adv : Adv ;
+  here7to_Adv : Adv ; -- to here
+  here7from_Adv : Adv ;  -- from here
+  how_IAdv : IAdv ;
+  how8many_IDet : IDet ;
+  i_Pron : Pron ;
+  if_Subj : Subj ;
+  in8front_Prep : Prep ; -- in front of
+  in_Prep : Prep ;
+  it_Pron : Pron ;
+  less_CAdv : CAdv ;
+  many_Det : Det ;
+  more_CAdv : CAdv ;
+  most_Predet : Predet ;
+  much_Det : Det ;
+  must_VV : VV ;
+---b  no_Phr : Phr ;
+  no_Utt : Utt ;
+  on_Prep : Prep ;
+---  one_Quant : QuantSg ; DEPRECATED
+  only_Predet : Predet ;
+  or_Conj : Conj ;
+  otherwise_PConj : PConj ;
+  part_Prep : Prep ;
+  please_Voc : Voc ;
+  possess_Prep : Prep ; -- of (possessive)
+  quite_Adv : AdA ;
+  she_Pron : Pron ;
+  so_AdA : AdA ;
+  someSg_Det : Det ;
+  somePl_Det : Det ;
+  somebody_NP : NP ;
+  something_NP : NP ;
+  somewhere_Adv : Adv ;
+  that_Quant : Quant ;
+  there_Adv : Adv ;
+  there7to_Adv : Adv ; -- to there
+  there7from_Adv : Adv ; -- from there
+  therefore_PConj : PConj ;
+  they_Pron : Pron ; 
+  this_Quant : Quant ;
+  through_Prep : Prep ;
+  to_Prep : Prep ;
+  too_AdA : AdA ;
+  under_Prep : Prep ;
+  very_AdA : AdA ;
+  want_VV : VV ;
+  we_Pron : Pron ;
+  whatPl_IP : IP ; -- what (plural)
+  whatSg_IP : IP ; -- what (singular)
+  when_IAdv : IAdv ;
+  when_Subj : Subj ;
+  where_IAdv : IAdv ;
+  which_IQuant : IQuant ;
+  whoPl_IP : IP ;  -- who (plural)
+  whoSg_IP : IP ;  -- who (singular)
+  why_IAdv : IAdv ;
+  with_Prep : Prep ;
+  without_Prep : Prep ;
+---b  yes_Phr : Phr ;
+  yes_Utt : Utt ;
+  youSg_Pron : Pron ; -- you (singular)
+  youPl_Pron : Pron ; -- you (plural)
+  youPol_Pron : Pron ; -- you (polite)
+
+}

old-lib/resource/abstract/Text.gf

@@ -0,0 +1,15 @@
+--1 Text: Texts
+
+-- Texts are built from an empty text by adding $Phr$ases,
+-- using as constructors the punctuation marks ".", "?", and "!".
+-- Any punctuation mark can be attached to any kind of phrase.
+
+abstract Text = Common ** {
+
+  fun
+    TEmpty     : Text ;                 --
+    TFullStop  : Phr -> Text -> Text ;  -- John walks. ...
+    TQuestMark : Phr -> Text -> Text ;  -- Are they here? ...
+    TExclMark  : Phr -> Text -> Text ;  -- Let's go! ...
+
+}

old-lib/resource/abstract/Verb.gf

@@ -0,0 +1,71 @@
+--1 The construction of verb phrases
+
+abstract Verb = Cat ** {
+
+--2 Complementization rules
+
+-- Verb phrases are constructed from verbs by providing their
+-- complements. There is one rule for each verb category.
+
+  fun
+    UseV     : V   -> VP ;        -- sleep
+
+    ComplVV  : VV  -> VP -> VP ;  -- want to run
+    ComplVS  : VS  -> S  -> VP ;  -- say that she runs
+    ComplVQ  : VQ  -> QS -> VP ;  -- wonder who runs
+    ComplVA  : VA  -> AP -> VP ;  -- they become red
+
+    SlashV2a : V2        -> VPSlash ;  -- love (it)
+    Slash2V3 : V3  -> NP -> VPSlash ;  -- give it (to her)
+    Slash3V3 : V3  -> NP -> VPSlash ;  -- give (it) to her
+
+    SlashV2V : V2V -> VP -> VPSlash ;  -- beg (her) to go
+    SlashV2S : V2S -> S  -> VPSlash ;  -- answer (to him) that it is good
+    SlashV2Q : V2Q -> QS -> VPSlash ;  -- ask (him) who came
+    SlashV2A : V2A -> AP -> VPSlash ;  -- paint (it) red
+
+    ComplSlash : VPSlash -> NP -> VP ; -- love it
+
+    SlashVV    : VV  -> VPSlash -> VPSlash ;       -- want to buy
+    SlashV2VNP : V2V -> NP -> VPSlash -> VPSlash ; -- beg me to buy
+
+--2 Other ways of forming verb phrases
+
+-- Verb phrases can also be constructed reflexively and from
+-- copula-preceded complements.
+
+    ReflVP   : VPSlash -> VP ;         -- love himself
+    UseComp  : Comp -> VP ;            -- be warm
+
+-- Passivization of two-place verbs is another way to use
+-- them. In many languages, the result is a participle that
+-- is used as complement to a copula ("is used"), but other
+-- auxiliary verbs are possible (Ger. "wird angewendet", It.
+-- "viene usato"), as well as special verb forms (Fin. "käytetään",
+-- Swe. "används").
+--
+-- *Note*. the rule can be overgenerating, since the $V2$ need not
+-- take a direct object.
+
+    PassV2   : V2 -> VP ;               -- be loved
+
+-- Adverbs can be added to verb phrases. Many languages make
+-- a distinction between adverbs that are attached in the end
+-- vs. next to (or before) the verb.
+
+    AdvVP    : VP -> Adv -> VP ;        -- sleep here
+    AdVVP    : AdV -> VP -> VP ;        -- always sleep
+
+-- *Agents of passives* are constructed as adverbs with the
+-- preposition [Structural Structural.html]$.8agent_Prep$.
+
+
+--2 Complements to copula
+
+-- Adjectival phrases, noun phrases, and adverbs can be used.
+
+    CompAP   : AP  -> Comp ;            -- (be) small
+    CompNP   : NP  -> Comp ;            -- (be) a man
+    CompAdv  : Adv -> Comp ;            -- (be) here
+
+}

old-lib/resource/api/Combinators.gf

@@ -0,0 +1,199 @@
+--1 Combinators: a High-Level Syntax API
+
+-- This module defines some "grammatical functions" that give shortcuts to
+-- typical constructions. [``Constructors`` Constructors.html] and the
+-- language-specific ``Paradigms`` modules are usually needed
+-- to construct arguments of these functions.
+
+incomplete resource Combinators = open Grammar in {
+
+  oper
+
+--2 Predication
+
+    pred : overload {
+      pred : V  -> NP -> Cl ;             -- x converges
+      pred : V2 -> NP -> NP -> Cl ;       -- x intersects y
+      pred : V3 -> NP -> NP -> NP -> Cl ; -- x intersects y at z
+      pred : V  -> NP -> NP -> Cl ;       -- x and y intersect
+      pred : A  -> NP -> Cl ;             -- x is even
+      pred : A2 -> NP -> NP -> Cl ;       -- x is divisible by y
+      pred : A  -> NP -> NP -> Cl ;       -- x and y are equal
+      pred : N  -> NP -> Cl ;             -- x is a maximum
+      pred : CN -> NP -> Cl ;             -- x is a local maximum
+      pred : NP -> NP -> Cl ;             -- x is the neutral element
+      pred : N  -> NP -> NP -> Cl ;       -- x and y are inverses 
+      pred : Adv -> NP -> Cl ;            -- x is in scope
+      pred : Prep -> NP -> NP -> Cl       -- x is outside y
+      } ;
+
+--2 Function application
+
+    app : overload {
+      app : N  -> NP ;
+      app : N2 -> NP -> NP ; 
+      app : N3 -> NP -> NP -> NP ;
+      app : N2 -> NP -> NP -> NP ;
+      app : N2 -> N  -> CN ;
+
+      app : N2 -> NP -> CN ;         -- divisor of x
+      app : N3 -> NP -> NP -> CN ;   -- path from x to y
+      app : N2 -> NP -> NP -> CN ;   -- path between x and y
+      } ;
+
+--2 Coordination
+
+    coord : overload {
+      coord : Conj  -> Adv -> Adv -> Adv ;
+      coord : Conj  -> AP -> AP -> AP ;
+      coord : Conj  -> NP -> NP -> NP ;
+      coord : Conj  -> S  -> S  -> S ;
+      coord : Conj  -> ListAdv -> Adv ;
+      coord : Conj  -> ListAP -> AP ;
+      coord : Conj  -> ListNP -> NP ;
+      coord : Conj  -> ListS  -> S ;
+
+      } ;
+
+--2 Modification
+
+    mod : overload {
+      mod : A -> N -> CN ;
+      mod : AP -> CN -> CN ;
+      mod : AdA -> A -> AP ;
+      mod : Det -> N -> NP ;
+      mod : Det -> CN -> NP ;
+      mod : Quant -> N -> NP ;
+      mod : Quant -> CN -> NP ;
+      mod : Predet -> N -> NP ;
+      mod : Numeral -> N -> NP
+
+
+      } ;
+
+--2 Negation
+
+    neg : overload {
+      neg : Imp -> Utt ;
+      neg : Cl -> S ;
+      neg : QCl -> QS ;
+      neg : RCl -> RS 
+    };
+
+--2 Text append
+
+-- This is not in ground API, because it would destroy parsing.
+
+    appendText : Text -> Text -> Text ;
+
+--.
+
+    pred = overload {
+      pred : V  -> NP -> Cl
+                                       = \v,np -> PredVP np (UseV v) ;
+      pred : V2 -> NP -> NP -> Cl
+                                       = \v,np,ob -> PredVP np (ComplSlash (SlashV2a v) ob) ;
+      pred : V3 -> NP -> NP -> NP -> Cl 
+                                       = \v,np,ob,ob2 -> 
+                                          PredVP np (ComplSlash (Slash2V3 v ob) ob2) ;
+      pred : V  -> NP -> NP -> Cl
+                                       = \v,x,y -> PredVP (ConjNP and_Conj (BaseNP x y)) (UseV v) ;
+      pred : A  -> NP -> Cl 
+                                       = \a,np -> PredVP np (UseComp (CompAP (PositA a))) ;
+      pred : A2 -> NP -> NP -> Cl
+                                       = \a,x,y -> PredVP x (UseComp (CompAP (ComplA2 a y))) ;
+      pred : A  -> NP -> NP -> Cl      
+                                       = \a,x,y -> PredVP (ConjNP and_Conj (BaseNP x y)) (UseComp (CompAP (PositA a))) ;
+      pred : N -> NP -> Cl
+                                       = \n,x -> PredVP x (UseComp (CompNP (DetArtSg (IndefArt) (UseN n)))) ;
+      pred : CN -> NP -> Cl
+                                       = \n,x -> PredVP x (UseComp (CompNP (DetArtSg (IndefArt) n))) ;
+      pred : NP -> NP -> Cl
+                                       = \n,x -> PredVP x (UseComp (CompNP n)) ;      pred : N2 -> NP -> NP -> Cl 
+                                       = \n,x,y -> PredVP x (UseComp (CompNP (DetArtSg (IndefArt) (ComplN2 n y)))) ;
+      pred : N -> NP -> NP -> Cl 
+                                       = \n,x,y -> PredVP (ConjNP and_Conj (BaseNP x y)) (UseComp (CompNP (DetArtPl (IndefArt) (UseN n)))) ;
+      pred : Adv -> NP -> Cl 
+                                       = \a,x -> PredVP x (UseComp (CompAdv a)) ;
+      pred : Prep -> NP -> NP -> Cl        
+                                       = \p,x,y -> PredVP x (UseComp (CompAdv (PrepNP p y)))
+
+      } ;
+
+    app = overload {
+      app : N  -> NP
+                                       = \n -> (DetArtSg (DefArt) (UseN n)) ;
+      app : N2 -> NP -> NP 
+                                       = \n,x -> (DetArtSg (DefArt) (ComplN2 n x)) ;
+      app : N3 -> NP -> NP -> NP
+                                       = \n,x,y -> (DetArtSg (DefArt) (ComplN2 (ComplN3 n x) y)) ;
+      app : N2 -> NP -> NP -> NP
+                                       = \n,x,y -> (DetArtSg DefArt (ComplN2 n (ConjNP and_Conj (BaseNP x y)))) ;
+      app : N2 -> N -> CN
+                                       = \f,n -> ComplN2 f (DetArtPl (IndefArt) (UseN n)) ;
+
+      app : N2 -> NP -> CN = ComplN2 ;
+      app : N3 -> NP -> NP -> CN = \n,x,y -> ComplN2 (ComplN3 n x) y ; 
+      app : N2 -> NP -> NP -> CN = \n,x,y -> 
+        ComplN2 n (ConjNP and_Conj (BaseNP x y)) ;
+      } ;
+
+    coord = overload {
+      coord : Conj -> Adv -> Adv -> Adv
+                                        = \c,x,y -> ConjAdv c (BaseAdv x y) ;
+      coord : Conj -> AP -> AP -> AP
+                                        = \c,x,y -> ConjAP c (BaseAP x y) ;
+      coord : Conj -> NP -> NP -> NP
+                                        = \c,x,y -> ConjNP c (BaseNP x y) ;
+      coord : Conj -> S  -> S  -> S  
+                                        = \c,x,y -> ConjS c (BaseS x y) ;
+      coord : Conj -> ListAdv -> Adv
+                                        = \c,xy -> ConjAdv c xy ;
+      coord : Conj -> ListAP -> AP
+                                        = \c,xy -> ConjAP c xy ; 
+      coord : Conj -> ListNP -> NP
+                                        = \c,xy -> ConjNP c xy ;
+      coord : Conj -> ListS  -> S  
+                                        = \c,xy -> ConjS c xy
+      } ;
+
+    mod = overload {
+      mod : A -> N -> CN
+                                  = \a,n -> AdjCN (PositA a) (UseN n) ;
+      mod : AP -> CN -> CN
+                                  = \a,n -> AdjCN a n ;
+      mod : AdA -> A -> AP
+                                  = \m,a -> AdAP m (PositA a) ;
+
+      mod : Det -> N -> NP 
+	                          = \d,n -> DetCN d (UseN n) ;
+      mod : Det -> CN -> NP 
+	                          = \d,n -> DetCN d n ;
+      mod : Quant -> N -> NP
+                                  = \q,n -> DetCN (DetQuant (q) NumSg) (UseN n) ;
+      mod : Quant -> CN -> NP
+                                  = \q,n -> DetCN (DetQuant (q) NumSg) n ;
+      mod : Predet -> N -> NP 
+                                  = \q,n -> PredetNP q (DetArtPl (IndefArt)  (UseN n)) ;
+      mod : Numeral -> N -> NP
+                                  = \nu,n -> DetCN (DetArtCard (IndefArt) (NumNumeral nu)) (UseN n)
+
+      } ;
+
+    neg = overload {
+      neg : Imp -> Utt 
+	                 = UttImpSg PNeg ;
+      neg : Cl -> S 
+	                 = UseCl TPres ASimul PNeg;
+      neg : QCl -> QS 
+	                 = UseQCl TPres ASimul PNeg;
+      neg : RCl -> RS 
+	                 = UseRCl TPres ASimul PNeg
+    };
+
+-- This is not in ground API, because it would destroy parsing.
+
+    appendText : Text -> Text -> Text 
+                = \x,y -> {s = x.s ++ y.s ; lock_Text = <>} ;
+
+}

old-lib/resource/api/CombinatorsAra.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsAra = Combinators with (Grammar = GrammarAra) ;

old-lib/resource/api/CombinatorsBul.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsBul = Combinators with (Grammar = GrammarBul) ;

old-lib/resource/api/CombinatorsCat.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsCat = Combinators with (Grammar = GrammarCat) ;

old-lib/resource/api/CombinatorsDan.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsDan = Combinators with (Grammar = GrammarDan) ;

old-lib/resource/api/CombinatorsEng.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsEng = Combinators with (Grammar = GrammarEng) ;

old-lib/resource/api/CombinatorsFin.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsFin = Combinators with (Grammar = GrammarFin) ;

old-lib/resource/api/CombinatorsFre.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsFre = Combinators with (Grammar = GrammarFre) ;

old-lib/resource/api/CombinatorsGer.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsGer = Combinators with (Grammar = GrammarGer) ;

old-lib/resource/api/CombinatorsHin.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsHin = Combinators with (Grammar = GrammarHin) ;

old-lib/resource/api/CombinatorsIna.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsIna = Combinators with (Grammar = GrammarIna) ;

old-lib/resource/api/CombinatorsIta.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsIta = Combinators with (Grammar = GrammarIta) ;

old-lib/resource/api/CombinatorsNor.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsNor = Combinators with (Grammar = GrammarNor) ;

old-lib/resource/api/CombinatorsRus.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsRus = Combinators with (Grammar = GrammarRus) ;

old-lib/resource/api/CombinatorsSpa.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsSpa = Combinators with (Grammar = GrammarSpa) ;

old-lib/resource/api/CombinatorsSwe.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsSwe = Combinators with (Grammar = GrammarSwe) ;

old-lib/resource/api/CombinatorsTha.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsTha = Combinators with (Grammar = GrammarTha) ;

old-lib/resource/api/ConstructorsBul.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsBul = Constructors with (Grammar = GrammarBul) ;

old-lib/resource/api/ConstructorsCat.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsCat = Constructors with (Grammar = GrammarCat) ;

old-lib/resource/api/ConstructorsDan.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsDan = Constructors with (Grammar = GrammarDan) ;

old-lib/resource/api/ConstructorsEng.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsEng = Constructors with (Grammar = GrammarEng) ;

old-lib/resource/api/ConstructorsFin.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsFin = Constructors with (Grammar = GrammarFin) ;

old-lib/resource/api/ConstructorsFre.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsFre = Constructors with (Grammar = GrammarFre) ;

old-lib/resource/api/ConstructorsGer.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsGer = Constructors with (Grammar = GrammarGer) ;

old-lib/resource/api/ConstructorsIta.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsIta = Constructors with (Grammar = GrammarIta) ;

old-lib/resource/api/ConstructorsNor.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsNor = Constructors with (Grammar = GrammarNor) ;

old-lib/resource/api/ConstructorsRus.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsRus = Constructors with (Grammar = GrammarRus) ;

old-lib/resource/api/ConstructorsSpa.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsSpa = Constructors with (Grammar = GrammarSpa) ;

old-lib/resource/api/ConstructorsSwe.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsSwe = Constructors with (Grammar = GrammarSwe) ;

old-lib/resource/api/Syntax.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+interface Syntax = Constructors, Cat, Structural, Combinators ;
+

old-lib/resource/api/SyntaxBul.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxBul of Syntax = ConstructorsBul, CatBul, StructuralBul, CombinatorsBul ;
+

old-lib/resource/api/SyntaxCat.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxCat of Syntax = ConstructorsCat, CatCat, StructuralCat, CombinatorsCat ;
+

old-lib/resource/api/SyntaxDan.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxDan of Syntax = ConstructorsDan, CatDan, StructuralDan, CombinatorsDan ;
+

old-lib/resource/api/SyntaxEng.gf

@@ -0,0 +1,5 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxEng of Syntax = 
+  ConstructorsEng, CatEng, StructuralEng, CombinatorsEng ;
+

old-lib/resource/api/SyntaxFin.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxFin of Syntax = ConstructorsFin, CatFin, StructuralFin, CombinatorsFin ;
+

old-lib/resource/api/SyntaxFre.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxFre of Syntax = ConstructorsFre, CatFre, StructuralFre, CombinatorsFre ;
+

old-lib/resource/api/SyntaxGer.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxGer of Syntax = ConstructorsGer, CatGer, StructuralGer, CombinatorsGer ;
+

old-lib/resource/api/SyntaxIta.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxIta of Syntax = ConstructorsIta, CatIta, StructuralIta, CombinatorsIta ;
+

old-lib/resource/api/SyntaxNor.gf

@@ -0,0 +1,5 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxNor of Syntax = ConstructorsNor, CatNor, StructuralNor, CombinatorsNor
+ ;
+

old-lib/resource/api/SyntaxRus.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxRus of Syntax = ConstructorsRus, CatRus, StructuralRus, CombinatorsRus ;
+

old-lib/resource/api/SyntaxSpa.gf

@@ -0,0 +1,5 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxSpa of Syntax = 
+  ConstructorsSpa, CatSpa, StructuralSpa, CombinatorsSpa ;
+

old-lib/resource/api/SyntaxSwe.gf

@@ -0,0 +1,5 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxSwe of Syntax = 
+  ConstructorsSwe, CatSwe, StructuralSwe, CombinatorsSwe ;
+

old-lib/resource/api/TryBul.gf

@@ -0,0 +1,13 @@
+--# -path=.:alltenses:prelude
+
+resource TryBul = SyntaxBul, LexiconBul, ParadigmsBul - [mkAdv] ** 
+  open (P = ParadigmsBul) in {
+
+oper
+
+  mkAdv = overload SyntaxBul {
+    mkAdv : Str -> Adv = P.mkAdv ;
+  } ;
+
+
+}

old-lib/resource/api/TryCat.gf

@@ -0,0 +1,13 @@
+--# -path=.:alltenses:prelude
+
+resource TryCat = SyntaxCat, LexiconCat, ParadigmsCat - [mkAdv] ** 
+  open (P = ParadigmsCat) in {
+
+oper
+
+  mkAdv = overload SyntaxCat {
+    mkAdv : Str -> Adv = P.mkAdv ;
+  } ;
+
+
+}

old-lib/resource/api/TryDan.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryDan = SyntaxDan, LexiconDan, ParadigmsDan - [mkAdv] ;

old-lib/resource/api/TryEng.gf

@@ -0,0 +1,13 @@
+--# -path=.:alltenses:prelude
+
+resource TryEng = SyntaxEng, LexiconEng, ParadigmsEng - [mkAdv] ** 
+  open (P = ParadigmsEng) in {
+
+oper
+
+  mkAdv = overload SyntaxEng {
+    mkAdv : Str -> Adv = P.mkAdv ;
+  } ;
+
+
+}

old-lib/resource/api/TryFin.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryFin = SyntaxFin, LexiconFin-[mkOrd], ParadigmsFin - [mkAdv] ;

old-lib/resource/api/TryFre.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryFre = SyntaxFre, LexiconFre, ParadigmsFre - [mkAdv] ;

old-lib/resource/api/TryGer.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryGer = SyntaxGer, LexiconGer, ParadigmsGer - [mkAdv] ;

old-lib/resource/api/TryIta.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryIta = SyntaxIta, LexiconIta, ParadigmsIta - [mkAdv,in_Prep] ;

old-lib/resource/api/TryNor.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryNor = SyntaxNor, LexiconNor, ParadigmsNor - [mkAdv] ;

old-lib/resource/api/TryRus.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryRus = SyntaxRus, LexiconRus, ParadigmsRus - [mkAdv] ;

old-lib/resource/api/TrySpa.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TrySpa = SyntaxSpa, LexiconSpa, ParadigmsSpa - [mkAdv] ;

old-lib/resource/api/TrySwe.gf

@@ -0,0 +1,12 @@
+--# -path=.:alltenses:prelude
+
+resource TrySwe = SyntaxSwe, LexiconSwe, ParadigmsSwe - [mkAdv] ** 
+  open (P = ParadigmsSwe) in {
+
+oper
+
+  mkAdv = overload SyntaxSwe {
+    mkAdv : Str -> Adv = P.mkAdv ;
+  } ;
+
+}

old-lib/resource/arabic/AdjectiveAra.gf

@@ -0,0 +1,43 @@
+concrete AdjectiveAra of Adjective = CatAra ** open ResAra, Prelude in {
+
+  lin
+
+
+    PositA a = {
+      s = \\h,g,n,d,c => case h of {
+        Hum => a.s ! APosit g n d c;
+        NoHum => case n of {
+          Pl => a.s ! APosit Fem Sg d c ;
+          _  => a.s ! APosit g n d c
+          }
+        } 
+      };
+--  ComparA a np = {
+--    s = \\_ => a.s ! AAdj Compar ++ "مِنْ" ++ np.s ! Gen ; 
+--    } ;
+--
+-- $SuperlA$ belongs to determiner syntax in $Noun$.
+--
+--    ComplA2 a np = {
+--      s = \\_ => a.s ! AAdj Posit ++ a.c2 ++ np.s ! Acc ; 
+--      isPre = False
+--      } ;
+--
+--    ReflA2 a = {
+--      s = \\ag => a.s ! AAdj Posit ++ a.c2 ++ reflPron ! ag ; 
+--      isPre = False
+--      } ;
+--
+--    SentAP ap sc = {
+--      s = \\a => ap.s ! a ++ sc.s ; 
+--      isPre = False
+--      } ;
+--
+--    AdAP ada ap = {
+--      s = \\a => ada.s ++ ap.s ! a ;
+--      isPre = ap.isPre
+--      } ;
+--
+--    UseA2 a = a ;
+--
+}

old-lib/resource/arabic/AdverbAra.gf

@@ -0,0 +1,21 @@
+concrete AdverbAra of Adverb = CatAra ** open ResAra, Prelude in {
+
+  lin
+    PositAdvAdj a = {s = a.s ! APosit Masc Sg Indef Acc} ;
+--    ComparAdvAdj cadv a np = {
+--      s = cadv.s ++ a.s ! AAdv ++ "مِنْ" ++ np.s ! Gen
+--      } ;
+--    ComparAdvAdjS cadv a s = {
+--      s = cadv.s ++ a.s ! AAdv ++ "تهَن" ++ s.s
+--      } ;
+
+    PrepNP prep np = {s = prep.s ++ np.s ! Gen} ;
+
+--    AdAdv = cc2 ;
+--
+--    SubjS = cc2 ;
+--    AdvSC s = s ; --- this rule give stack overflow in ordinary parsing
+--
+--    AdnCAdv cadv = {s = cadv.s ++ "تهَن"} ;
+--
+}

old-lib/resource/arabic/AllAra.gf

@@ -0,0 +1,3 @@
+--# -path=.:../abstract:../common:prelude
+
+concrete AllAra of AllAraAbs = LangAra ;

old-lib/resource/arabic/AllAraAbs.gf

@@ -0,0 +1,3 @@
+--# -path=.:../abstract:../common:prelude
+
+abstract AllAraAbs = Lang ;

old-lib/resource/arabic/CatAra.gf

@@ -0,0 +1,103 @@
+concrete CatAra of Cat = CommonX - [Utt]  ** open ResAra, Prelude, ParamX in {
+
+  flags optimize=all_subs ;
+
+  lincat
+
+-- Phrase
+
+    Utt = {s : Gender => Str};
+
+-- Tensed/Untensed
+
+    S  = {s : Str} ;
+    QS = {s : QForm => Str} ;
+--    RS = {s : Agr => Str} ;
+
+-- Sentence
+
+    Cl = {s : ResAra.Tense => Polarity => Order => Str} ;
+--    Slash = {s : Tense => Anteriority => Polarity => Order => Str} ** {c2 : Str} ;
+    Imp = {s : Polarity => Gender => ResAra.Number => Str} ;
+
+-- Question
+
+    QCl = {s : ResAra.Tense => Polarity => QForm => Str} ;
+    IP = {s : Str ; n : ResAra.Number} ;
+--    IAdv = {s : Str} ;    
+--    IDet = {s : Str ; n : ResAra.Number} ;
+--
+---- Relative
+--
+--    RCl = {s : Tense => Anteriority => Polarity => Agr => Str} ;
+--    RP = {s : Case => Str ; a : RAgr} ;
+--
+-- Verb
+
+    VP = ResAra.VP ;
+    VPSlash = ResAra.VP ** {c2 : Str} ;
+    Comp = ResAra.Comp ; --{s : AAgr => Case => Str} ; 
+--    SC = {s : Str} ;
+--
+-- Adjective
+
+    AP = {s : Species => Gender => NTable } ; 
+
+-- Noun
+
+    CN = ResAra.Noun ** {adj : NTable};
+    NP, Pron = ResAra.NP; --{s : Case => Str ; a : Agr } ;
+    Num, Ord, Card = {s : Gender => State => Case => Str ;
+                n : Size };
+    Predet = ResAra.Predet ;
+
+-- DEPRECATED
+--    QuantSg, QuantPl = 
+--      {s : Species => Gender => Case => Str; 
+--       n : ResAra.Number; 
+--       d : State; 
+--       isNum : Bool;
+--       isPron : Bool} ;
+
+    Det = ResAra.Det ;
+--  {s : Species => Gender => Case => Str ; 
+--   d : State; n : Size; isNum : Bool } ;
+    Quant = {s : ResAra.Number => Species => Gender => Case => Str; 
+             d : State;
+             isNum : Bool;
+             isPron: Bool} ;
+    Art = {s : ResAra.Number => Species => Gender => Case => Str; 
+             d : State} ;
+
+-- Numeral
+
+    Numeral = {s : CardOrd => Gender => State => Case => Str ; 
+               n : Size } ;
+    Digits = {s : Str;
+              n : Size};
+
+-- Structural
+
+    Conj = {s : Str ; n : ResAra.Number} ;
+--    DConj = {s1,s2 : Str ; n : ResAra.Number} ;
+--    Subj = {s : Str} ;
+    Prep = {s : Str} ;
+
+-- Open lexical classes, e.g. Lexicon
+    
+    V, VS, VQ, VA = ResAra.Verb ; -- = {s : VForm => Str} ;
+    V2, V2A = ResAra.Verb ** {c2 : Str} ;
+    V2V, V2S, V2Q = ResAra.Verb ** {c2 : Str} ; --- AR
+    V3 = ResAra.Verb ** {c2, c3 : Str} ;
+--    VV = {s : VVForm => Str ; isAux : Bool} ;
+
+    A = ResAra.Adj ;
+    A2 = ResAra.Adj ** {c2 : Str} ;
+
+    N, N2 = ResAra.Noun ; 
+--{s : ResAra.Number => State => Case => Str; g : Gender ; h = Species} ;
+--    N2 = {s : ResAra.Number => Case => Str} ** {c2 : Str} ;??
+    N3 = ResAra.Noun ** {c2,c3 : Str} ;
+    PN = {s : Case => Str; g : Gender; h : Species} ;
+
+}

old-lib/resource/arabic/ConjunctionAra.gf

@@ -0,0 +1,45 @@
+concrete ConjunctionAra of Conjunction = 
+  CatAra ** open ResAra, Coordination, Prelude in {
+--
+--  flags optimize=all_subs ;
+--
+--  lin
+--
+--    ConjS = conjunctSS ;
+--    DConjS = conjunctDistrSS ;
+--
+--    ConjAdv = conjunctSS ;
+--    DConjAdv = conjunctDistrSS ;
+--
+--    ConjNP conj ss = conjunctTable Case conj ss ** {
+--      a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p}
+--      } ;
+--    DConjNP conj ss = conjunctDistrTable Case conj ss ** {
+--      a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p}
+--      } ;
+--
+--    ConjAP conj ss = conjunctTable Agr conj ss ** {
+--      isPre = ss.isPre
+--      } ;
+--    DConjAP conj ss = conjunctDistrTable Agr conj ss ** {
+--      isPre = ss.isPre
+--      } ;
+--
+---- These fun's are generated from the list cat's.
+--
+--    BaseS = twoSS ;
+--    ConsS = consrSS comma ;
+--    BaseAdv = twoSS ;
+--    ConsAdv = consrSS comma ;
+--    BaseNP x y = twoTable Case x y ** {a = conjAgr x.a y.a} ;
+--    ConsNP xs x = consrTable Case comma xs x ** {a = conjAgr xs.a x.a} ;
+--    BaseAP x y = twoTable Agr x y ** {isPre = andB x.isPre y.isPre} ;
+--    ConsAP xs x = consrTable Agr comma xs x ** {isPre = andB xs.isPre x.isPre} ;
+--
+--  lincat
+--    [S] = {s1,s2 : Str} ;
+--    [Adv] = {s1,s2 : Str} ;
+--    [NP] = {s1,s2 : Case => Str ; a : Agr} ;
+--    [AP] = {s1,s2 : Agr => Str ; isPre : Bool} ;
+--
+}

old-lib/resource/arabic/ExtAra.gf

@@ -0,0 +1,26 @@
+concrete ExtAra of ExtAraAbs = CatAra ** open ResAra in {
+--
+--  lincat
+--
+--    Aux = {s : Polarity => Str} ;
+--    
+--  lin
+-- 
+--    PredAux np aux vp = mkClause (np.s ! Nom) np.a {
+--      s = \\t,ant,b,ord,agr => 
+--        let 
+--          fin  = aux.s ! b ;
+--          vf : Str -> Str -> {fin, inf : Str} = \x,y -> 
+--            {fin = x ; inf = y} ;
+--        in
+--        case ant of {
+--          Simul => vf fin [] ;
+--          Anter => vf fin "هَثي"
+--          } ;
+--      s2 = \\agr => infVP vp agr
+--      } ;
+--
+--    can_Aux  = {s = \\p => posneg p "عَن"} ; ---- cannt
+--    must_Aux = {s = \\p => posneg p "مُست"} ;
+--
+}

old-lib/resource/arabic/GrammarAra.gf

@@ -0,0 +1,21 @@
+--# -path=.:../abstract:../common:prelude
+
+concrete GrammarAra of Grammar = 
+  NounAra, 
+  VerbAra, 
+  AdjectiveAra,
+  AdverbAra,
+  NumeralAra,
+  SentenceAra,
+  QuestionAra,
+  RelativeAra,
+  ConjunctionAra,
+  PhraseAra,
+  TextX - [Utt],
+  StructuralAra,
+  IdiomAra
+  ** {
+
+flags startcat = Phr ; unlexer = text ; lexer = text ;
+
+} ;

old-lib/resource/arabic/IdiomAra.gf

@@ -0,0 +1,14 @@
+concrete IdiomAra of Idiom = CatAra ** open Prelude, ResAra in {
+--
+--  flags optimize=all_subs ;
+--
+--  lin
+--    ExistNP np = 
+--      mkClause "تهري" (agrP3 np.a.n) (insertObj (\\_ => np.s ! Acc) (predAux auxBe)) ;
+--    ImpersCl vp = mkClause "ِت" (agrP3 Sg) vp ;
+--    GenericCl vp = mkClause "ْني" (agrP3 Sg) vp ;
+--
+--    ProgrVP vp = insertObj (\\a => vp.ad ++ vp.prp ++ vp.s2 ! a) (predAux auxBe) ;
+--
+}
+

old-lib/resource/arabic/IrregAra.gf

@@ -0,0 +1,181 @@
+--# -path=.:prelude:../abstract:../common
+--
+concrete IrregAra of IrregAraAbs = CatAra ** open ParadigmsAra in {
+--
+--flags optimize=values ;
+--
+--  lin
+--  awake_V = irregV "َوَكي" "َوْكي" "َوْكن" ;
+--  bear_V = irregV "بَر" "بْري" "بْرن" ;
+--  beat_V = irregV "بَت" "بَت" "بَت" ;
+--  become_V = irregV "بعْمي" "بعَمي" "بعْمي" ;
+--  begin_V = irregV "بغِن" "بغَن" "بغُن" ;
+--  bend_V = irregV "بند" "بنت" "بنت" ;
+--  beset_V = irregV "بست" "بست" "بست" ;
+--  bet_V = irregDuplV "بت" "بت" "بت" ;
+--  bid_V = irregDuplV "بِد" (variants {"بِد" ; "بَدي"}) (variants {"بِد" ; "بِدّن"}) ;
+--  bind_V = irregV "بِند" "بُْند" "بُْند" ;
+--  bite_V = irregV "بِتي" "بِت" "بِتّن" ;
+--  bleed_V = irregV "بلّد" "بلد" "بلد" ;
+--  blow_V = irregV "بلْو" "بلو" "بلْون" ;
+--  break_V = irregV "برَك" "برْكي" "برْكن" ;
+--  breed_V = irregV "برّد" "برد" "برد" ;
+--  bring_V = irregV "برِنغ" "برُْغهت" "برُْغهت" ;
+--  broadcast_V = irregV "برَْدعَست" "برَْدعَست" "برَْدعَست" ;
+--  build_V = irregV "بُِلد" "بُِلت" "بُِلت" ;
+--  burn_V = irregV "بُرن" (variants {"بُرند" ; "بُرنت"}) (variants {"بُرند" ; "بُرنت"}) ;
+--  burst_V = irregV "بُرست" "بُرست" "بُرست" ;
+--  buy_V = irregV "بُي" "بُْغهت" "بُْغهت" ;
+--  cast_V = irregV "عَست" "عَست" "عَست" ;
+--  catch_V = irregV "عَتعه" "عَُغهت" "عَُغهت" ;
+--  choose_V = irregV "عهّْسي" "عهْسي" "عهْسن" ;
+--  cling_V = irregV "علِنغ" "علُنغ" "علُنغ" ;
+--  come_V = irregV "عْمي" "عَمي" "عْمي" ;
+--  cost_V = irregV "عْست" "عْست" "عْست" ;
+--  creep_V = irregV "عرّة" "عرةت" "عرةت" ;
+--  cut_V = irregDuplV "عُت" "عُت" "عُت" ;
+--  deal_V = irregV "دَل" "دَلت" "دَلت" ;
+--  dig_V = irregDuplV "دِغ" "دُغ" "دُغ" ;
+--  dive_V = irregV "دِثي" (variants {"دِثد" ; "دْثي"}) "دِثد" ;
+--  do_V = mkV "دْ" "دْس" "دِد" "دْني" "دِْنغ" ;
+--  draw_V = irregV "درَو" "درو" "درَون" ;
+--  dream_V = irregV "درَم" (variants {"درَمد" ; "درَمت"}) (variants {"درَمد" ; "درَمت"}) ;
+--  drive_V = irregV "درِثي" "درْثي" "درِثن" ;
+--  drink_V = irregV "درِنك" "درَنك" "درُنك" ;
+--  eat_V = irregV "َت" "َتي" "َتن" ;
+--  fall_V = irregV "فَلّ" "فلّ" "فَلّن" ;
+--  feed_V = irregV "فّد" "فد" "فد" ;
+--  feel_V = irregV "فّل" "فلت" "فلت" ;
+--  fight_V = irregV "فِغهت" "فُْغهت" "فُْغهت" ;
+--  find_V = irregV "فِند" "فُْند" "فُْند" ;
+--  fit_V = irregDuplV "فِت" "فِت" "فِت" ;
+--  flee_V = irregV "فلّ" "فلد" "فلد" ;
+--  fling_V = irregV "فلِنغ" "فلُنغ" "فلُنغ" ;
+--  fly_V = irregV "فلي" "فلو" "فلْون" ;
+--  forbid_V = irregDuplV "فْربِد" "فْربَدي" "فْربِدّن" ;
+--  forget_V = irregDuplV "فْرغت" "فْرغْت" "فْرغْتّن" ;
+--  forgive_V = irregV "فْرغِثي" "فْرغَثي" "فْرغِثن" ;
+--  forsake_V = irregV "فْرسَكي" "فْرسّْك" "فْرسَكن" ;
+--  freeze_V = irregV "فرّزي" "فرْزي" "فرْزن" ;
+--  get_V = irregDuplV "غت" "غْت" "غْتّن" ;
+--  give_V = irregV "غِثي" "غَثي" "غِثن" ;
+--  go_V = irregV "غْ" "ونت" "غْني" ;
+--  grind_V = irregV "غرِند" "غرُْند" "غرُْند" ;
+--  grow_V = irregV "غرْو" "غرو" "غرْون" ;
+--  hang_V = irregV "هَنغ" "هُنغ" "هُنغ" ;
+--  have_V = mkV "هَثي" "هَس" "هَد" "هَد" "هَثِنغ" ;
+--  hear_V = irregV "هَر" "هَرد" "هَرد" ;
+--  hide_V = irregV "هِدي" "هِد" "هِدّن" ;
+--  hit_V = irregDuplV "هِت" "هِت" "هِت" ;
+--  hold_V = irregV "هْلد" "هلد" "هلد" ;
+--  hurt_V = irregV "هُرت" "هُرت" "هُرت" ;
+--  keep_V = irregV "كّة" "كةت" "كةت" ;
+--  kneel_V = irregV "كنّل" "كنلت" "كنلت" ;
+--  knit_V = irregDuplV "كنِت" "كنِت" "كنِت" ;
+--  know_V = irregV "كنْو" "كنو" "كنْو" ;
+--  lay_V = irregV "لَي" "لَِد" "لَِد" ;
+--  lead_V = irregV "لَد" "لد" "لد" ;
+--  leap_V = irregV "لَة" (variants {"لَةد" ; "لةت"}) (variants {"لَةد" ; "لةت"}) ;
+--  learn_V = irregV "لَرن" (variants {"لَرند" ; "لَرنت"}) (variants {"لَرند" ; "لَرنت"}) ;
+--  leave_V = irregV "لَثي" "لفت" "لفت" ;
+--  lend_V = irregV "لند" "لنت" "لنت" ;
+--  let_V = irregDuplV "لت" "لت" "لت" ;
+--  lie_V = irregV "لِي" "لَي" "لَِن" ;
+--  light_V = irregV "لِغهت" (variants {"لِغهتد" ; "لِت"}) "لِغهتد" ;
+--  lose_V = irregV "لْسي" "لْست" "لْست" ;
+--  make_V = irregV "مَكي" "مَدي" "مَدي" ;
+--  mean_V = irregV "مَن" "مَنت" "مَنت" ;
+--  meet_V = irregV "مّت" "مت" "مت" ;
+--  misspell_V = irregV "مِسّةلّ" (variants {"مِسّةلّد" ; "مِسّةلت"}) (variants {"مِسّةلّد" ; "مِسّةلت"}) ;
+--  mistake_V = irregV "مِستَكي" "مِستّْك" "مِستَكن" ;
+--  mow_V = irregV "مْو" "مْود" (variants {"مْود" ; "مْون"}) ;
+--  overcome_V = irregV "ْثرعْمي" "ْثرعَمي" "ْثرعْمي" ;
+--  overdo_V = mkV "ْثردْ" "ْثردْس" "ْثردِد" "ْثردْني" "ْثردِْنغ" ;
+--  overtake_V = irregV "ْثرتَكي" "ْثرتّْك" "ْثرتَكن" ;
+--  overthrow_V = irregV "ْثرتهرْو" "ْثرتهرو" "ْثرتهرْون" ;
+--  pay_V = irregV "ةَي" "ةَِد" "ةَِد" ;
+--  plead_V = irregV "ةلَد" "ةلد" "ةلد" ;
+--  prove_V = irregV "ةرْثي" "ةرْثد" (variants {"ةرْثد" ; "ةرْثن"}) ;
+--  put_V = irregDuplV "ةُت" "ةُت" "ةُت" ;
+--  quit_V = irregDuplV "قُِت" "قُِت" "قُِت" ;
+--  read_V = irregV "رَد" "رَد" "رَد" ;
+--  rid_V = irregDuplV "رِد" "رِد" "رِد" ;
+--  ride_V = irregV "رِدي" "رْدي" "رِدّن" ;
+--  ring_V = irregV "رِنغ" "رَنغ" "رُنغ" ;
+--  rise_V = irregV "رِسي" "رْسي" "رِسن" ;
+--  run_V = irregDuplV "رُن" "رَن" "رُن" ;
+--  saw_V = irregV "سَو" "سَود" (variants {"سَود" ; "سَون"}) ;
+--  say_V = irregV "سَي" "سَِد" "سَِد" ;
+--  see_V = irregV "سّ" "سَو" "سّن" ;
+--  seek_V = irregV "سّك" "سُْغهت" "سُْغهت" ;
+--  sell_V = irregV "سلّ" "سْلد" "سْلد" ;
+--  send_V = irregV "سند" "سنت" "سنت" ;
+--  set_V = irregDuplV "ست" "ست" "ست" ;
+--  sew_V = irregV "سو" "سود" (variants {"سود" ; "سون"}) ;
+--  shake_V = irregV "سهَكي" "سهّْك" "سهَكن" ;
+--  shave_V = irregV "سهَثي" "سهَثد" (variants {"سهَثد" ; "سهَثن"}) ;
+--  shear_V = irregV "سهَر" "سهْري" "سهْرن" ;
+--  shed_V = irregDuplV "سهد" "سهد" "سهد" ;
+--  shine_V = irregV "سهِني" "سهْني" "سهْني" ;
+--  shoe_V = irregV "سهْي" "سهْد" (variants {"سهْد" ; "سهْد"}) ;
+--  shoot_V = irregV "سهّْت" "سهْت" "سهْت" ;
+--  show_V = irregV "سهْو" "سهْود" (variants {"سهْود" ; "سهْون"}) ;
+--  shrink_V = irregV "سهرِنك" "سهرَنك" "سهرُنك" ;
+--  shut_V = irregDuplV "سهُت" "سهُت" "سهُت" ;
+--  sing_V = irregV "سِنغ" "سَنغ" "سُنغ" ;
+--  sink_V = irregV "سِنك" "سَنك" "سُنك" ;
+--  sit_V = irregDuplV "سِت" "سَت" "سَت" ;
+--  sleep_V = irregV "سلّة" "سلةت" "سلةت" ;
+--  slay_V = irregV "سلَي" "سلو" "سلَِن" ;
+--  slide_V = irregV "سلِدي" "سلِد" "سلِد" ;
+--  sling_V = irregV "سلِنغ" "سلُنغ" "سلُنغ" ;
+--  slit_V = irregDuplV "سلِت" "سلِت" "سلِت" ;
+--  smite_V = irregV "سمِتي" "سمْتي" "سمِتّن" ;
+--  sow_V = irregV "سْو" "سْود" (variants {"سْود" ; "سْون"}) ;
+--  speak_V = irregV "سةَك" "سةْكي" "سةْكن" ;
+--  speed_V = irregV "سةّد" "سةد" "سةد" ;
+--  spend_V = irregV "سةند" "سةنت" "سةنت" ;
+--  spill_V = irregV "سةِلّ" (variants {"سةِلّد" ; "سةِلت"}) (variants {"سةِلّد" ; "سةِلت"}) ;
+--  spin_V = irregDuplV "سةِن" "سةُن" "سةُن" ;
+--  spit_V = irregDuplV "سةِت" (variants {"سةِت" ; "سةَت"}) "سةِت" ;
+--  split_V = irregDuplV "سةلِت" "سةلِت" "سةلِت" ;
+--  spread_V = irregV "سةرَد" "سةرَد" "سةرَد" ;
+--  spring_V = irregV "سةرِنغ" (variants {"سةرَنغ" ; "سةرُنغ"}) "سةرُنغ" ;
+--  stand_V = irregV "ستَند" "ستّْد" "ستّْد" ;
+--  steal_V = irregV "ستَل" "ستْلي" "ستْلن" ;
+--  stick_V = irregV "ستِعك" "ستُعك" "ستُعك" ;
+--  sting_V = irregV "ستِنغ" "ستُنغ" "ستُنغ" ;
+--  stink_V = irregV "ستِنك" "ستَنك" "ستُنك" ;
+--  stride_V = irregV "سترِدي" "سترْد" "سترِدّن" ;
+--  strike_V = irregV "سترِكي" "سترُعك" "سترُعك" ;
+--  string_V = irregV "سترِنغ" "سترُنغ" "سترُنغ" ;
+--  strive_V = irregV "سترِثي" "سترْثي" "سترِثن" ;
+--  swear_V = irregV "سوَر" "سوْري" "سوْرن" ;
+--  sweep_V = irregV "سوّة" "سوةت" "سوةت" ;
+--  swell_V = irregV "سولّ" "سولّد" (variants {"سولّد" ; "سوْلّن"}) ;
+--  swim_V = irregDuplV "سوِم" "سوَم" "سوُم" ;
+--  swing_V = irregV "سوِنغ" "سوُنغ" "سوُنغ" ;
+--  take_V = irregV "تَكي" "تّْك" "تَكن" ;
+--  teach_V = irregV "تَعه" "تَُغهت" "تَُغهت" ;
+--  tear_V = irregV "تَر" "تْري" "تْرن" ;
+--  tell_V = irregV "تلّ" "تْلد" "تْلد" ;
+--  think_V = irregV "تهِنك" "تهُْغهت" "تهُْغهت" ;
+--  thrive_V = irregV "تهرِثي" (variants {"تهرِثد" ; "تهرْثي"}) "تهرِثد" ;
+--  throw_V = irregV "تهرْو" "تهرو" "تهرْون" ;
+--  thrust_V = irregV "تهرُست" "تهرُست" "تهرُست" ;
+--  tread_V = irregV "ترَد" "ترْد" "ترْدّن" ;
+--  understand_V = irregV "ُندرستَند" "ُندرستّْد" "ُندرستّْد" ;
+--  uphold_V = irregV "ُةهْلد" "ُةهلد" "ُةهلد" ;
+--  upset_V = irregDuplV "ُةست" "ُةست" "ُةست" ;
+--  wake_V = irregV "وَكي" "وْكي" "وْكن" ;
+--  wear_V = irregV "وَر" "وْري" "وْرن" ;
+--  weave_V = irregV "وَثي" (variants {"وَثد" ; "وْثي"}) (variants {"وَثد" ; "وْثن"}) ;
+--  wed_V = irregDuplV "ود" "ود" "ود" ;
+--  weep_V = irregV "وّة" "وةت" "وةت" ;
+--  wind_V = irregV "وِند" "وُْند" "وُْند" ;
+--  win_V = irregDuplV "وِن" "وْن" "وْن" ;
+--  withhold_V = irregV "وِتهّْلد" "وِتهّلد" "وِتهّلد" ;
+--  withstand_V = irregV "وِتهستَند" "وِتهستّْد" "وِتهستّْد" ;
+--  wring_V = irregV "ورِنغ" "ورُنغ" "ورُنغ" ;
+--  write_V = irregV "ورِتي" "ورْتي" "ورِتّن" ;
+}

old-lib/resource/arabic/LangAra.gf

@@ -0,0 +1,12 @@
+--# -path=.:../abstract:../common:prelude
+
+concrete LangAra of Lang = 
+  GrammarAra,
+  LexiconAra
+  ** {
+
+  flags startcat = Phr ; unlexer = text ; lexer = text ; coding = utf8 ;
+
+}
+
+

old-lib/resource/arabic/LexiconAra.gf

@@ -0,0 +1,384 @@
+--# -path=.:prelude
+--
+concrete LexiconAra of Lexicon = CatAra ** open 
+  ParadigmsAra, 
+  ResAra,
+  MorphoAra, --shouldn't open it here, only needed reg &sndf
+  Prelude in { 
+
+flags 
+  optimize=values ;  coding=utf8 ;
+
+  lin
+
+  airplane_N   = sdfN "ط؟ر" "فاعِلة" Fem NoHum ;
+  answer_V2S   = dirV2 (v3 "جوب") ;
+  apartment_N  = brkN "شقّ" "فِعّة" "فِعَل" Fem NoHum ;
+  apple_N      = sdfN "تفح" "فِعّالة" Fem NoHum ;
+  art_N        = brkN "فنّ" "فَعّ" "فُعُول" Masc NoHum ;
+  ask_V2Q      = dirV2 (regV "يَس؟َل") ;
+--  ask_V2Q      = dirV2 (v1 "س؟ل" a a) ;
+  baby_N       = brkN "طفل" "فِعل" "أَفعال" Masc Hum;
+  bad_A        = sndA "سو؟" "فَيِّع" ;
+  bank_N       = brkN "بنك" "فَعل" "فُعُول" Masc NoHum ;
+  beautiful_A  = sndA "جمل" "فَعِيل" ;
+  become_VA    = mkVA (v4 "صبح") ;
+  beer_N       = sdfN "بير" "فِعلة" Fem NoHum ;
+  beg_V2V      = dirV2 (v5 "وسل") ;
+  big_A        = sndA "كبر" "فَعِيل" ;
+  bike_N       = sdfN "درج" "فَعّالة" Fem NoHum ;
+  bird_N       = brkN "طير" "فَعل" "فُعُول" Masc NoHum; 
+  black_A      = clrA "سود" ;
+  blue_A       = clrA "زرق" ;
+  boat_N       = brkN "قرب" "فاعِل" "فَواعِل" Masc NoHum ;
+  book_N       = brkN "كتب" "فِعال" "فُعُل" Masc NoHum ;
+  boot_N       = sdfN "جزم" "فَعلة" Fem NoHum ;
+  boss_N       = brkN "دور" "مُفِيع" "مُفَعاء" Masc Hum ;
+  boy_N        = brkN "صبي" "فَعِل" "فُعلان" Masc Hum ;
+  bread_N      = brkN "خبز" "فُعل" "أَفعال" Masc NoHum ;
+  break_V2     = dirV2 (regV "يَكسُر") ;
+--  break_V2     = dirV2 (v1 "كسر" a u) ;
+  broad_A      = sndA "وسع" "فاعِل" ;
+  brother_N2   = brkN "؟خو" "فَع" "فِعلة" Masc Hum ; --FIXME
+  brown_A      = sndA "بني" "فُعِّل";
+  butter_N     = sdfN "سبد" "فُعلة" Fem NoHum ;
+  buy_V2       = dirV2 (v8 "شري") ;
+  camera_N     = sdfN "كمر" "فاعِيلا" Fem NoHum ; -- |Alö taSwIr
+  cap_N        = sdfN "قبع" "فُعَّلة" Fem NoHum ; --qalnUsö
+  car_N        = sdfN "سير" "فَعّالة" Fem NoHum ;
+  carpet_N     = sdfN "سجد" "فَعّالة" Fem NoHum ;
+  cat_N        = brkN "هرّ" "فِعّة" "فِعَل" Fem NoHum ;
+  ceiling_N    = brkN "سقف" "فَعل" "أَفعُل" Masc NoHum ;
+  chair_N      = brkN "كرس" "فُعلِي" "فَعالِي" Masc NoHum ;
+  cheese_N     = brkN "جبن" "فُعلة" "أَفعال" Fem NoHum ;
+  child_N      = brkN "ولد" "فَعَل" "أَفعال" Masc Hum ;
+  church_N     = brkN "كنس" "فَعِيلة" "فَعاٱِل" Fem Hum ;
+  city_N       = brkN "مدن" "فَعِيلة" "فُعُل" Fem NoHum ;
+  clean_A      = sndA "نظف" "فَعِيل" ;
+  clever_A     = sndA "جهد" "مُفتَعِل" ;
+  close_V2     = dirV2 (v4 "غلق") ;
+  coat_N       = brkN "عطف" "مِفعَل" "مَفاعِل" Masc NoHum ;
+  cold_A       = sndA "برد" "فاعِل" ;
+  come_V       = v1 "جي؟" a i ; --check
+  computer_N   = brkN "حسب" "فاعُول" "فَواعِيل" Masc NoHum ;
+  country_N    = brkN "بلد" "فَعَل" "فِعال" Masc NoHum ;
+  cousin_N     = brkN "قرب" "فَعِيل" "أَفعِلاء" Masc Hum ; -- (<bn / bnt) (cam[ö] / xAl[ö]) 
+  cow_N        = sdfN "بقر" "فَعلة" Fem NoHum ;
+  die_V        = v1 "موت" a u ; --check
+  dirty_A      = sndA "وسخ" "فَعِل" ;
+  distance_N3  = mkN3 (sdfN "سوف" "مَفاعة" Fem NoHum) "مِن" "إِلَى" ;
+  doctor_N     = brkN "طبّ" "فَعِيل" "أَفِعّاء" Masc Hum ;
+  dog_N        = brkN "كلب" "فَعل" "فِعال" Masc NoHum ;
+  door_N       = brkN "بوب" "فاع" "أَفعال" Masc NoHum ;
+  drink_V2     = dirV2 (regV "شَرِب") ;
+--  drink_V2     = dirV2 (v1 "شرب" i a) ;
+  easy_A2V     = mkA2 (sndA "سهل" "فَعل") "لِ" ;
+  eat_V2       = dirV2 (regV "يَ؟كُل") ;
+--  eat_V2       = dirV2 (v1 "؟كل" a u) ;
+  empty_A      = sndA "فرغ" "فاعِل" ;
+  enemy_N      = brkN "عدو" "فَعُلّ" "أَفعاء" Masc Hum ;
+  factory_N    = brkN "صنع" "مَفعَل" "مَفاعِل" Masc NoHum ;
+  father_N2    = brkN "؟ب" "فَع" "أَفعاء" Masc Hum;
+  fear_VS      = mkVS (v1 "خشي" i a );
+  find_V2      = dirV2 (v1 "وجد" a i ) ;
+  fish_N       = brkN "سمك" "فَعَلة" "أَفعال" Fem NoHum ;
+  floor_N      = brkN "؟رض" "فَعل" "فَعالِي" Fem NoHum;
+  forget_V2    = dirV2 (v1 "نسي" i a ) ;
+  fridge_N     = sdfN "برد" "فَعّال" Masc NoHum ;
+  friend_N     = brkN "صدق" "فَعِيل" "أَفعِلاء" Masc Hum ; --SadIqö
+  fruit_N      = brkN "فكه" "فاعِلة" "فَواعِل" Fem NoHum ;
+  fun_AV       = sndA "متع" "مُفعِل" ;
+  garden_N     = brkN "حدق" "فَعِيلة" "فَعاٱِل" Fem NoHum ;
+  girl_N       = brkN "بنت" "فِعل" "فَعال" Fem Hum ;
+  glove_N      = sdfN "قفز" "فُعّال" Masc NoHum ;
+  gold_N       = sdfN "ذهب" "فَعَل" Masc NoHum ;
+  good_A       = sndA "جود" "فَيِّع" ; -- Hasan, HisAn
+  go_V         = regV "يَذهَب" ;
+--  go_V         = v1 "ذهب" a a ;
+  green_A      = clrA "خضر" ;
+  harbour_N    = brkN "رف؟" "مَفعَل" "مَفاعِل" Masc NoHum ; --mInA', marsaY
+  hate_V2      = dirV2 (regV "كَرِه") ;
+  hat_N        = sdfN "قبع" "فُعَّلة" Fem NoHum ;
+  have_V2      = dirV2 (regV "يَملِك") ; 
+--  have_V2      = dirV2 (v1 "ملك" a i) ; 
+  hear_V2      = dirV2 (regV "سَمِع") ;
+--  hear_V2      = dirV2 (v1 "سمع" i a) ;
+  hill_N       = brkN "هضب" "فَعلة" "فِعال" Fem NoHum ; --tallö, rAbiyö
+  hope_VS      = mkVS (v1 "رجو" a u) ; --check
+  horse_N      = brkN "حصن" "فِعال" "أَفعِلة" Masc NoHum ;
+  hot_A        = sndA "سخن" "فاعِل" ; --HAr
+  house_N      = brkN "بيت" "فَعل" "فُعُول" Masc NoHum ; --manzil
+  important_A  = sndA "هيم" "فاعّ" ;
+  industry_N   = sdfN "صنع" "فِعالة" Fem NoHum ;
+  iron_N       = brkN "حدّ" "فَعِيل" "فَعائِل" Masc NoHum ;
+  king_N       = brkN "ملك" "فَعِل" "فُعُول" Masc Hum ;
+  know_V2      = dirV2 (regV "عَرِف") ;
+--  know_V2      = dirV2 (v1 "عرف" i a) ;
+  lake_N       = sdfN "بحر" "فُعَيلة" Fem NoHum ;
+  lamp_N       = brkN "صبح" "مِفعال" "مَفاعِيل" Masc NoHum ; --qanDIl, fAnUs
+  learn_V2     = dirV2 (v5 "علم") ;
+  leather_N    = brkN "جلد" "فِعل" "فُعُول" Masc NoHum ;
+  leave_V2     = dirV2 (regV "يَترُك") ;
+--  leave_V2     = dirV2 (v1 "ترك" a u) ;
+  like_V2      = dirV2 (regV "هَوِي") ; 
+--  like_V2      = dirV2 (v1 "هوي" i a) ; --check
+  listen_V2    = mkV2 (v8 "سمع") "إِلَى" ;
+  live_V       = v1 "عيش" a i ; --check
+  long_A       = sndA "طول" "فَعِيل" ;
+  lose_V2      = dirV2 (regV "خَسِر") ; --Dayyac, >aDAc
+--  lose_V2      = dirV2 (v1 "خسر" i a) ; --Dayyac, >aDAc
+  love_N       = brkN "حبّ" "فُعّ" "فُعّ" Masc NoHum ; -- no plur
+  love_V2      = dirV2 (v1 "حبّ" a i) ;
+  man_N        = brkN "رجل" "فَعُل" "فِعال" Masc Hum ;
+  married_A2   = mkA2 (sndA "زوج" "مُتَفَعِّل") "مِن" ;
+  meat_N       = brkN "لحم" "فَعلة" "فُعُول" Masc NoHum ;
+  milk_N       = brkN "حلب" "فَعِيل" "فَعِيل" Masc NoHum ; --no plur
+  moon_N       = brkN "قمر" "فَعَل" "أَفعال" Masc NoHum ;
+  mother_N2    = sdfN "؟م" "فُعّ" Fem Hum ;
+  mountain_N   = brkN "جبل" "فَعَل" "فِعال" Masc NoHum ;
+  music_N      = mkN (reg "مُوسِيقَى" "مُوسِيقَى") Fem NoHum ; --no plur
+  narrow_A     = sndA "ضيق" "فَعِّل" ;
+  new_A        = sndA "جدّ" "فَعِيل" ;
+  newspaper_N  = brkN "صحف" "فَعِيلة" "فُعُل" Fem NoHum ;
+  oil_N        = brkN "زيت" "فَعل" "فُعُول" Masc NoHum ;
+  old_A        = sndA "قدم" "فَعِيل" ;
+  open_V2      = dirV2 (regV "يَفتَح") ;
+--  open_V2      = dirV2 (v1 "فتح" a a ) ;
+  paint_V2A    = mkV2A (regV "يَدهَن" ) [] ;
+--  paint_V2A    = mkV2A (v1 "دهن" a a ) [] ;
+  paper_N      = brkN "ورق" "فَعَلة" "أَفعال" Fem NoHum ;
+  paris_PN     = mkPN "بارِيس" Fem NoHum  ;
+  peace_N      = brkN "سلم" "فَعال" "فَعال" Masc NoHum; --no plur
+  pen_N        = brkN "قلم" "فَعَل" "أَفعال" Masc NoHum;
+  planet_N     = mkN (reg "كَوكَب" "كَواكِب") Masc NoHum ; -- quadriconsonantal
+  plastic_N    = mkN (sndf "بلاستِيك") Masc NoHum ;
+  play_V2      = dirV2 (regV "لَعِب") ;
+--  play_V2      = dirV2 (v1 "لعب" i a) ;
+  policeman_N  = sdmN "شرط" "فِعلِي" Masc Hum ;
+  priest_N     = brkN "قسّ" "فِعِّيل" "أَفِعّة" Masc Hum ;
+  probable_AS  = mkAS (sndA "مكن" "مُفعِل") ;
+  queen_N      = sdfN "ملك" "فَعِلة" Fem Hum ;
+  radio_N      = mkN (sndf "راديُو") Masc NoHum ;
+  rain_V0      = mkV0 (regV "يَمطُر") ;
+--  rain_V0      = mkV0 (v1 "مطر" a u) ;
+  read_V2      = dirV2 (regV "يَقرَ؟") ;
+--  read_V2      = dirV2 (v1 "قر؟" a a ) ;
+  red_A        = clrA "حمر" ;
+  religion_N   = brkN "دين" "فِعل" "أَفعال" Masc NoHum ;
+  restaurant_N = brkN "طعم" "مَفعَل" "مَفاعِل" Masc NoHum ;
+  river_N      = brkN "نهر" "فَعل" "أَفعال" Masc NoHum ;
+  rock_N       = brkN "صخر" "فَعلة" "فُعُول" Fem NoHum ;
+  roof_N       = brkN "سطح" "فَعل" "أَفعُل" Masc NoHum ;
+  rubber_N     = brkN "مطّ" "فَعّال" "فَعّال" Masc NoHum ; -- no hum
+  run_V        = regV "يَركُض" ;
+--  run_V        = v1 "ركض" a u ;
+  say_VS       = mkVS (v1 "قول" a u) ; --check
+  school_N     = brkN "درس" "مَفعَلة" "مَفاعِل" Fem NoHum ;
+  science_N    = brkN "علم" "فِعل" "فُعُول" Masc NoHum ;
+  sea_N        = brkN "بحر" "فَعل" "فُعُول" Masc NoHum ;
+  seek_V2      = dirV2 (regV "يَطلُب") ; 
+--  seek_V2      = dirV2 (v1 "طلب" a u) ; 
+  see_V2       = dirV2 (v1 "ر؟ي" a a) ;
+  sell_V3      = dirdirV3 (v1 "بيع" a i) ; --check
+  send_V3      = dirdirV3 (v4 "رسل")  ;
+  sheep_N      = brkN "خرف" "فَعُول" "فِعال" Masc NoHum ;
+  ship_N       = brkN "سفن" "فَعِيلة" "فُعُل" Fem NoHum ;
+  shirt_N      = brkN "قمص" "فَعِيل" "فُعلان" Masc NoHum ;
+  shoe_N       = brkN "حذو" "فِعاء" "أَفعِية" Masc NoHum ;
+  shop_N       = brkN "تجر" "مَفعَل" "مَفاعِل" Masc NoHum ;
+  short_A      = sndA "قصر" "فَعِيل" ;
+  silver_N     = brkN "فضّ" "فِعّة" "فِعَل" Fem NoHum ;
+  sister_N     = brkN "؟خو" "فُعت" "فَعَوات" Fem Hum ; --FIXME
+  sleep_V      = v1 "نوم" i a ; --check
+  small_A      = sndA "صغر" "فَعِيل" ;
+  snake_N      = sdfN "حيّ" "فَعّة" Fem NoHum ;
+  sock_N       = brkN "جرب" "فَوعَل" "فَواعِل" Masc NoHum ;
+  speak_V2     = dirV2 (v5 "كلم") ;
+  star_N       = brkN "نجم" "فَعل" "فُعُول" Masc NoHum ; --najmö
+  steel_N      = brkN "فلذ" "فُوعال" "فَواعِل" Masc NoHum ;
+  stone_N      = brkN "حجر" "فَعَل" "أَفعال" Masc NoHum ;
+  stove_N      = brkN "وقد" "مَفعِل" "مَفاعِل" Masc NoHum ;
+  student_N    = brkN "طلب" "فاعِل" "فُعّال" Masc Hum ; --tilmI*
+  stupid_A     = clrA "بله" ;
+  sun_N        = brkN "شمس" "فَعل" "فُعُول" Fem NoHum ;
+  switch8off_V2 = dirV2 (v4 "طف؟") ;
+  switch8on_V2 = dirV2 (v4 "شعل") ;
+  table_N      = sdfN "طول" "فاعِلة" Fem NoHum ;
+  talk_V3      = mkV3 (v5 "حدث") "لِ" "عَن" ;
+  teacher_N    = sdmN "علم" "مُفَعِّل" Masc Hum ; --mucal~imö
+  teach_V2     = dirV2 (v2 "علم") ;
+  television_N = mkN (sndf "تِلِفِزيُون") Masc NoHum ;
+  thick_A      = sndA "سمك" "فَعِيل" ;
+  thin_A       = sndA "رفع" "فَعِيل" ;
+  train_N      = sdfN "قطر" "فِعال" Masc NoHum;
+  travel_V     = v3 "سفر" ;
+  tree_N       = brkN "شجر" "فَعلة" "أَفعال" Fem NoHum ;
+  ugly_A       = sndA "قبح" "فَعِيل" ;
+  understand_V2 = dirV2 (regV "فَهِم") ;
+--  understand_V2 = dirV2 (v1 "فهم" i a ) ;
+  university_N = sdfN "جمع" "فاعِلة" Fem NoHum ;
+  village_N    = brkN "قري" "فَعلة" "فُعَى" Fem NoHum ; --Daycö
+  wait_V2      = dirV2 (v8 "نظر")  ;
+  walk_V       = v1 "مشي" a i ; --check
+  warm_A       = sndA "دف؟" "فاعِل" ;
+  war_N        = brkN "حرب" "فَعل" "فُعُول" Fem NoHum ;
+  watch_V2     = dirV2 (v3 "شهد") ;
+  water_N      = mkN (reg "ماء" "مِياه") Fem NoHum ; --"موه" "فاء" "فِياع" ??
+  white_A      = clrA "بيض" ;
+  window_N     = brkN "نفذ" "فاعِلة" "فَواعِل" Fem NoHum ; --$ub~Ak
+  wine_N       = brkN "خمر" "فَعل" "فُعُول" Masc NoHum ;
+  win_V2       = dirV2 (regV "رَبِح") ;
+--  win_V2       = dirV2 (v1 "ربح" i a) ;
+  woman_N      = mkN (reg "إِمرَأَة" "نِسوَة") Fem Hum ;
+  wonder_VQ    = mkVQ (v6 "س؟ل") ;
+  wood_N       = brkN "خشب" "فَعَل" "أَفعال" Masc NoHum ;
+  write_V2     = dirV2 (regV "يَكتُب") ;
+--  write_V2     = dirV2 (v1 "كتب" a u) ;
+  yellow_A     = clrA "صفر" ;
+  young_A      = sndA "شبّ" "فاعّ" ;
+
+  do_V2        = dirV2 (regV "يَفعَل") ;
+--  do_V2        = dirV2 (v1 "فعل" a a ) ;
+  now_Adv      = mkAdv "الآن" ;
+  already_Adv  = mkAdv "سابِقاً" ; 
+  song_N       = brkN "غني" "أَفعِلة" "أَفاعِي" Fem NoHum ;
+  add_V3       = dirV3 (regV "يَجمَع") "وَ" ;
+--  add_V3       = dirV3 (v1 "جمع" a a) "وَ" ;
+  number_N     = brkN "رقم" "فَعل" "أَفعال" Masc NoHum ; --cadad
+  put_V2       = dirV2 (v1 "وضع" a a );
+  stop_V       = v5 "وقف" ;
+  jump_V       = regV "يَقفِز" ;
+--  jump_V       = v1 "قفز" a i ;
+
+  left_Ord     = mkOrd "أَيسَر" "يُسرَى";
+  right_Ord    = mkOrd "أَيمَن" "يُمنَى" ;
+
+  far_Adv      = mkAdv "بَعِيداً" ;
+  correct_A    = sndA "صحّ" "فَعِيل" ;
+  dry_A        = sndA "نشف" "فاعِل" ;
+  dull_A       = sndA "بهت" "فاعِل" ;
+  full_A       = sndA "مل؟" "فَعِيل" ;
+  heavy_A      = sndA "ثقل" "فَعِيل" ;
+  near_A       = sndA "قرب" "فَعِيل" ;
+  rotten_A     = sndA "فسد" "فاعِل" ;
+  round_A      = sndA "دور" "مُفَعَّل" ;
+  sharp_A      = sndA "حدّ" "فاعّ" ;
+  smooth_A     = sndA "نعم" "فاعِل" ;
+  straight_A   = sndA "قوم" "مُستَفِيع" ;
+  wet_A        = sndA "رطب" "فَعِل" ;
+  wide_A       = sndA "وسع" "فاعِل" ;
+
+  animal_N     = sdfN "حيّ" "فَعَوان"           Masc NoHum ;
+  ashes_N      = brkN "رمد" "فَعال" "أَفعِلة"   Masc NoHum;           
+  back_N       = brkN "ظهر" "فَعل" "فُعُول"      Masc NoHum;           
+  bark_N       = brkN "نبح" "فَعل" "فُعال"      Masc NoHum;           
+  belly_N      = brkN "بطن" "فَعل" "فُعُول"      Fem  NoHum;           
+  blood_N      = brkN "دم"  "فَع" "فِعاء"       Masc NoHum;           
+  bone_N       = brkN "عظم" "فَعلة" "فِعال"     Fem  NoHum;           
+  breast_N     = brkN "صدر" "فَعل" "فُعُول"      Masc NoHum;           
+  cloud_N      = brkN "غيم" "فَعلة" "فُعُول"     Fem  NoHum;           
+  day_N        = brkN "يوم" "فَعل" "أَفّاع"     Masc NoHum;           
+  dust_N       = brkN "غبر" "فُعال" "أَفعِلة"   Masc NoHum;           
+  ear_N        = brkN "؟ذن" "فُعل" "أَفعال"     Fem NoHum;            
+  earth_N      = brkN "ترب" "فُعلة" "فُعَل"     Fem NoHum;            
+  egg_N        = sdfN "بيض" "فَعلة"             Fem NoHum;            
+  eye_N        = brkN "عين" "فَعل" "فُعُول"      Fem NoHum;            
+  fat_N        = brkN "دهن" "فُعل" "فُعُول"      Masc NoHum ;          
+  feather_N    = sdfN "ريش" "فِعلة"             Fem NoHum;            
+  fingernail_N = brkN "ظفر" "فُعل" "أَفاعِل"    Masc NoHum;           
+  fire_N       = brkN "نور" "فاع" "فِيعان"       Fem NoHum;            
+  flower_N     = brkN "زهر" "فَعلة" "فُعُول"     Fem NoHum;            
+  fog_N        = brkN "ضبّ" "فَعال" "فَعال"     Masc NoHum; --no plural ?
+  foot_N       = brkN "قدم" "فَعَل" "أَفعال"    Fem NoHum;            
+  forest_N     = sdfN "غيب" "فاعة"              Fem NoHum;            
+  grass_N      = brkN "عشب" "فُعلة" "أَفعال"    Fem NoHum;            
+  guts_N       = brkN "حشو" "فَعا" "أَفعاء"     Fem NoHum;            
+  hair_N       = sdfN "شعر" "فَعلة"             Fem NoHum ;           
+  hand_N       = brkN "يد"  "فَع" "أَفاعِي"      Fem NoHum  ;  
+  head_N       = brkN "ر؟س" "فَعل" "فُعُول"      Masc NoHum;           
+  heart_N      = brkN "قلب" "فَعل" "فُعُول"      Masc NoHum;           
+  horn_N       = brkN "قرن" "فَعل" "فُعُول"      Masc NoHum;           
+  husband_N    = brkN "زوج" "فَعل" "أَفعال"     Masc NoHum;           
+  ice_N        = brkN "ثلج" "فَعل" "فُعُول"      Masc NoHum;           
+  knee_N       = brkN "ركب" "فُعلة" "فُعَل"     Fem NoHum;            
+  leaf_N       = brkN "ورق" "فَعَلة" "أَفعال"   Fem NoHum;             
+  leg_N        = brkN "رجل" "فِعل" "أَفعُل"     Fem NoHum;            
+  liver_N      = brkN "كبد" "فَعِل" "أَفعال"    Masc NoHum ;          
+  louse_N      = sdfN "قمل" "فَعلة"             Fem NoHum;            
+  mouth_N      = brkN "فوه" "فُعل" "أَفعال"     Masc NoHum ;          
+  name_N       = brkN "؟سم" "فِعل" "فَعالِي"     Masc NoHum;       
+  neck_N       = brkN "رقب" "فَعَلة" "فِعال"    Fem NoHum;        
+  night_N      = brkN "ليل" "فَعلة" "فَعالِي"    Fem NoHum;  --plural?
+  nose_N       = brkN "؟نف" "فَعل" "فُعُول"      Masc NoHum;           
+  person_N     = brkN "شخص" "فَعل" "أَفعال"     Masc Hum;             
+  rain_N       = brkN "مطر" "فَعَل" "أَفعال"    Masc NoHum;           
+  road_N       = brkN "طرق" "فَعِيل" "فُعُل"     Fem NoHum;            
+  root_N       = brkN "جذر" "فَعل" "فُعُول"      Masc NoHum ;          
+  rope_N       = brkN "حبل" "فَعل" "فِعال"      Masc NoHum;           
+  salt_N       = brkN "ملح" "فِعل" "أَفعال"     Masc NoHum;           
+  sand_N       = brkN "رمل" "فَعل" "فِعال"      Masc NoHum;           
+  seed_N       = brkN "بذر" "فَعل" "فُعُول"      Masc NoHum;           
+  skin_N       = brkN "جلد" "فِعل" "فُعُول"      Masc NoHum;           
+  sky_N        = sdfN "سمو" "فَعاء"             Fem NoHum;
+  smoke_N      = brkN "دخن" "فُعال" "أَفعِلة"   Masc NoHum;           
+  snow_N       = brkN "ثلج" "فَعل" "فُعُول"      Masc NoHum;           
+  stick_N      = brkN "عصو" "فَعا" "فِعِي"       Masc NoHum ; --"عصو"  
+  tail_N       = brkN "ذنب" "فَعَل" "أَفعال"    Masc NoHum;           
+  tongue_N     = brkN "لسن" "فِعال" "أَفعِلة"   Masc NoHum;           
+  tooth_N      = brkN "سنّ" "فِعل" "أَفعال"     Masc NoHum ;          
+  wife_N       = sdfN "زوج" "فَعلة"             Fem Hum;              
+  wind_N       = brkN "ريح" "فِعل" "فِعال"      Fem NoHum;            
+  wing_N       = brkN "جنح" "فَعال" "أَفعِلة"   Masc NoHum ;           
+  worm_N       = brkN "دود" "فُعلة" "فِيعان"     Fem NoHum ;                       
+  year_N       = sdfN "سن"  "فَعة"              Fem NoHum   ;              
+
+  blow_V       = regV "يَنفُخ" ;
+  breathe_V    = dirV2 (v5 "نفس") ;
+  burn_V       = regV "يَحرِق" ;
+  dig_V        = regV "يَحفِر" ;
+  fall_V       = v1 "وقع" a a ;
+  float_V      = v1 "عوم" a u ;
+  flow_V       = v1 "سيل" a i ;
+  fly_V        = v1 "طير" a i ;
+  freeze_V     = v2 "جمد" ;
+  give_V3      = dirdirV3 (v4 "عطي") ;
+  laugh_V      =  regV "ضَحِك" ;
+  lie_V        = regV "يَكذِب" ;
+  play_V       = regV "لَعِب" ;
+  sew_V        = v1 "خيط" a i ;
+  sing_V       = v2 "غني" ;
+  sit_V        = regV "يَقعُد" ;
+  smell_V      = v1 "شمّ" i a ;
+  spit_V       = regV "يَبصُق" ;
+  stand_V      = v1 "وقف" a i ;
+  swell_V      = v8 "نفخ" ;
+  swim_V       = regV "يَسبَح" ;
+  think_V      = v2 "فكر" ;
+  turn_V       = regV "يَبرُم" ;
+  vomit_V      = v5 "قي؟" ;
+
+  bite_V2      = dirV2 ( v1 "عضّ" a a ) ;
+  count_V2     = dirV2 (v1 "عدّ" a u) ;
+  cut_V2       = dirV2 (v1 "قصّ" a u) ;
+  fear_V2      = dirV2 (v1 "خوف" i a) ;
+  fight_V2     = dirV2 (v3 "قتل") ;
+  hit_V2       = dirV2 (regV "يَضرِب" ) ;
+  hold_V2      = dirV2 (regV "يَمسِك" ) ;
+  hunt_V2      = dirV2 (v1 "صيد" a i) ;
+  kill_V2      = dirV2 (regV "يَقتُل" ) ;
+  pull_V2      = dirV2 (regV "يَسحَب") ;
+  push_V2      = dirV2 (regV "يَدفَع" ) ;
+  rub_V2       = dirV2 ( regV "يَفرُك" ) ;
+  scratch_V2   = dirV2 (regV "يَخدِش" ) ;
+  split_V2     = dirV2 ( v2 "قسم" ) ;
+  squeeze_V2   = dirV2 (regV "يَعصِر" ) ;
+  stab_V2      = dirV2 ( regV "يَطعُن" ) ;
+  suck_V2      = dirV2 (v1 "مصّ" a u) ;
+  throw_V2     = dirV2 (v1 "رمي" a i) ;
+  tie_V2       = dirV2 (regV "يَربُط" ) ;
+  wash_V2      = dirV2 ( regV "يَغسِل" ) ;
+  wipe_V2      = dirV2 ( regV "يَمسَح" ) ;
+
+--  other_A = sndA "ْتهر" ;
+
+} ;

old-lib/resource/arabic/MorphoAra.gf

@@ -0,0 +1,49 @@
+resource MorphoAra = ResAra ** open Prelude in  {
+
+flags optimize = all ;--noexpand;  coding=utf8 ;
+
+  oper
+
+    mkDet : Str -> Number -> State -> Det 
+      = \word,num,state -> 
+      { s = \\_,_,c => word + vowel ! c ;
+        n = numberToSize num;
+        d = state;  --only Const is used now. check StructuralAra
+        isNum = False;
+        isPron = False
+      };
+    
+    mkPredet : Str -> Bool -> Predet 
+      = \word,decl ->
+      { s = \\c => 
+          case decl of {
+            True => word + vowel!c;
+            False => word
+          };
+        isDecl = decl
+      };
+
+   mkQuantNum : Str -> Number -> State -> { 
+      s: Species => Gender => Case => Str; n: Number; d : State; isPron: Bool; isNum : Bool} = 
+      \waHid,num,state -> 
+     let waHida = waHid + "َة" in 
+      { s = \\_,g,c => 
+          let word = 
+          case g of {
+            Masc => waHid;
+            Fem => waHida
+          } in Al ! state + word + dec1sg ! state ! c;
+        n = num;
+        d = state;
+        isPron = False;
+        isNum = True
+      };
+    
+    vowel : Case => Str = 
+      table {
+        Nom => "ُ";
+        Acc => "َ";
+        Gen => "ِ"
+      };
+
+}

old-lib/resource/arabic/NounAra.gf

@@ -0,0 +1,184 @@
+concrete NounAra of Noun = CatAra ** open ResAra, Prelude in {
+
+flags optimize=noexpand ;
+
+lin
+
+  DetCN det cn = let {
+    number = sizeToNumber det.n;
+    determiner : Case -> Str = \c -> 
+      det.s ! cn.h ! (detGender cn.g det.n) ! c;
+    noun : Case -> Str = \c -> cn.s ! 
+      number ! (nounState det.d number) ! (nounCase c det.n det.d)
+    } in { 
+      s = \\c => 
+        case cnB4det det.isPron det.isNum det.n det.d of {
+          False => determiner c ++ noun c;
+          --FIXME use the adj -> cn -> cn rule from below instead of 
+          --repeating code
+          True => cn.s ! number ! det.d ! c ++ det.s ! cn.h ! cn.g ! c 
+            ++ cn.adj ! number ! det.d ! c
+        };
+      a = { pgn = agrP3 cn.h cn.g number;
+            isPron = False }
+    };
+  
+  UsePN pn = { 
+    s =  pn.s; 
+    a = {pgn = (Per3 pn.g Sg); isPron = False } 
+    };
+  
+  UsePron p = p ;
+  
+  PredetNP pred np = {
+    s = \\c => case pred.isDecl of {
+      True => pred.s!c ++ np.s ! Gen ; -- akvaru l-awlAdi
+      False => pred.s!c ++ np.s ! c
+      };
+    a = np.a
+    } ;
+  {-
+  --should compile.. not working :( wierd error message.. bug?
+  PPartNP np v2 = 
+    let x = case np.a.pgn of {
+      Per3 g n =>  ( positAdj (v2.s ! VPPart) ) ! g ! n ! Indef ;
+  _ => \\_ => [] -- not occuring anyway
+    } in {
+      s = \\c => np.s ! c ++ x ! c ;
+  a = np.a
+    };
+  -}    
+  
+  -- FIXME try parsing something like "this house now" and you'll get
+  -- an internal compiler error, but it still works.. wierd..
+  AdvNP np adv = {
+    s = \\c => np.s ! c ++ adv.s;
+    a = np.a
+    };
+{-  
+  DetSg quant ord = {
+    s = \\h,g,c => 
+      quant.s ! Sg ! h ! g ! c ++ ord.s ! g ! quant.d ! c ;
+    n = One;
+    d = quant.d;
+    isPron = quant.isPron;
+    isNum = 
+      case ord.n of {
+        None => False;
+        _ => True
+      }
+    } ;
+-}  
+  
+  DetQuantOrd quant num ord = {
+    s = \\h,g,c => quant.s ! Pl ! h ! g ! c 
+      ++ num.s ! g ! (toDef quant.d num.n) ! c 
+      --FIXME check this:
+      ++ ord.s ! g ! (toDef quant.d num.n) ! c ;  
+    n = num.n;
+    d = quant.d;
+    isPron = quant.isPron;
+    isNum = 
+      case num.n of {
+        None => False;
+        _ => True
+      }
+    } ;
+  
+  DetQuant quant num = {
+    s = \\h,g,c => quant.s ! Pl ! h ! g ! c 
+      ++ num.s ! g ! (toDef quant.d num.n) ! c ;
+    n = num.n;
+    d = quant.d;
+    isPron = quant.isPron;
+    isNum = 
+      case num.n of {
+        None => False;
+        _ => True
+      }
+    } ;
+  
+
+  --DEPRECATED
+  --    SgQuant quant = {s = quant.s ! Sg ; d = quant.d; 
+  --                     isPron = quant.isPron; isNum = False} ;
+  --    PlQuant quant = {s = quant.s ! Pl ; d = quant.d; 
+  --                     isPron = quant.isPron; isNum = False} ;
+  
+  PossPron p = {
+    s = \\_,_,_,_ => p.s ! Gen; 
+    d = Const; 
+    isPron = True; 
+    isNum = False } ;
+  
+  NumSg = {
+    s = \\_,_,_ => [] ; 
+    n = One } ; 
+
+  NumPl = {
+    s = \\_,_,_ => [] ; 
+    n = None } ; 
+  
+  NumDigits digits = {
+    s = \\_,_,_ => digits.s;
+    n = digits.n
+    };
+  
+  NumNumeral numeral = {
+    s = numeral.s ! NCard ;
+    n = numeral.n
+    };
+  
+  AdNum adn num = {
+    s = \\g,d,c => adn.s ++ num.s ! g ! d ! c ;
+    n = num.n } ;
+  
+  OrdDigits digits = {
+    s = \\_,d,_ => Al ! d ++ digits.s;
+    n = digits.n
+    };
+  
+  -- OrdNumeral : Numeral -> Ord ; -- fifty-first
+  OrdNumeral numeral = {
+    s = numeral.s ! NOrd ;
+    n = numeral.n
+    };
+  
+  -- FIXME, "the biggest house" would better translate into
+  -- akbaru baytin rather than al-baytu l-2akbaru
+  -- DetCN (DetSg DefArt (OrdSuperl big_A)) (UseN house_N)
+  OrdSuperl a = {
+    s = \\_,d,c => a.s ! AComp d c;
+    n = One
+    } ;
+  
+  DefArt = {
+    s = \\_,_,_,_ => []; 
+    d = Def} ;
+  
+  IndefArt = {
+    s = \\_,_,_,_ => []; 
+    d = Indef} ;
+  
+--  MassDet = {s = \\_,_,_,_ => [] ; d = Indef; 
+--             isNum = False; isPron = False} ;
+  
+  UseN n = n ** {adj = \\_,_,_ => []};
+  --    ComplN2 f x = {s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c} ;
+  --    ComplN3 f x = {s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c ; c2 = f.c3} ;
+  --
+  --    UseN2 n = n ;
+  --    UseN3 n = n ;
+  --
+  AdjCN ap cn = {
+    s = \\n,d,c => cn.s ! n ! d ! c;
+    adj = \\n,d,c => ap.s ! cn.h ! cn.g ! n ! (definite ! d) ! c ;
+    g = cn.g;
+    h = cn.h
+    };
+  --    RelCN cn rs = {s = \\n,c => cn.s ! n ! c ++ rs.s ! {n = n ; p = P3}} ;
+  --    AdvCN cn ad = {s = \\n,c => cn.s ! n ! c ++ ad.s} ;
+  --
+  --    SentCN cn sc = {s = \\n,c => cn.s ! n ! c ++ sc.s} ;
+  --    ApposCN cn np =
+}

old-lib/resource/arabic/NumeralAra.gf

@@ -0,0 +1,154 @@
+concrete NumeralAra of Numeral = CatAra ** 
+  open Predef, Prelude, ResAra, MorphoAra in {
+
+
+
+lincat 
+
+  Digit = {s : DForm => CardOrd => Gender => State => Case => Str ;
+           n : Size } ;
+  Sub10 = {s : DForm => CardOrd => Gender => State => Case => Str ; 
+           n : Size } ;
+  Sub100 = {s : CardOrd => Gender => State => Case => Str ; 
+            n : Size} ;
+  Sub1000 = {s : CardOrd => Gender => State => Case => Str ; 
+             n : Size } ;
+  Sub1000000 = {s : CardOrd => Gender => State => Case => Str ; 
+                n : Size} ;
+  
+
+  
+  lin num x = x ;
+      
+  lin n2 = num2 ** {n = Two };
+
+  lin n3 = num3_10  "ثَلاث" "ثالِث";  
+  lin n4 = num3_10  "أَربَع" "رابِع"; 
+  lin n5 = num3_10  "خَمس"  "خامِس";   
+  lin n6 = num3_10  "سِتّ"   "سادِس";   
+  lin n7 = num3_10  "سَبع"  "سابِع";   
+  lin n8 = num3_10  "ثَمانِي" "ثامِن"; 
+  lin n9 = num3_10  "تِسع"  "تاسِع";   
+
+  lin pot01 = mkNum "واحِد" "أَوَّل" "أُولى" ** { n = One } ;
+
+  lin pot0 d = d ;
+
+  lin pot110 = { 
+        s= ((num3_10  "عَشر" "عاشِر").s ! unit ) ;
+        n = ThreeTen
+        };
+
+  lin pot111 = { 
+        s = \\_,g,d,_ => 
+          case g of {
+            Masc => Al ! d + "أَحَدَ" ++ teen ! Masc ;
+            Fem => Al ! d + "إِحدَى" ++ teen ! Fem
+          };
+        n = NonTeen
+        };
+      
+  lin pot1to19 dig = { 
+       s = \\co,g,d,c => case dig.n of {
+         Two => Al ! d + num2.s ! unit ! co ! g ! Const ! c ++ teen ! g ;
+         _ => dig.s ! unit ! co ! g ! (toDef d ThreeTen) ! Acc ++ 
+           teen ! (genPolarity ! g) 
+         };
+       n = case dig.n of {
+         Two => NonTeen;
+         _ => Teen
+         }
+       };
+      
+  lin pot0as1 num = { 
+        s= num.s ! unit;
+        n = num.n
+        } ;
+      
+  lin pot1 dig = { 
+        s = dig.s ! ten;
+        n = NonTeen
+        } ;
+      
+  lin pot1plus dig n = {
+        s = \\co,g,d,c => n.s ! unit ! co ! g ! d ! c 
+          ++ "وَ" ++ dig.s ! ten ! co ! g ! d ! c ;
+        n = NonTeen
+        };
+
+  lin pot1as2 n = n ;
+
+  lin pot2 dig = {
+      s = \\co,_,d,c => case dig.n of {
+        One => num100 ! d ! c ;
+        Two => num200 ! d ! c ;
+        _ => dig.s ! unit ! co ! Masc ! (toDef d ThreeTen) ! c ++ "مِٱَةِ"
+        };
+      n = Hundreds
+     };
+      
+  lin pot2plus m e = {
+       s = \\co,g,d,c => case m.n of {
+         One => num100 ! d ! c;
+         Two => num200 ! d ! c;
+         _ => m.s ! unit ! co ! Masc ! (toDef d ThreeTen) ! c ++ "مِٱَةٌ"
+         } ++ "وَ" ++ e.s ! co ! g ! d ! c ;
+       n = e.n 
+       };
+
+  lin pot2as3 n = n ;
+      
+  lin pot3 m = {
+        s = \\co,_,d,c => case m.n of {
+          One => num1000 ! (definite ! d) ! c;
+          Two => num2000 ! (definite ! d) ! c;
+          _ => m.s ! co ! Fem ! (toDef d ThreeTen) ! c ++ "آلافٌ"
+          } ;
+        n = m.n 
+        };
+--lin pot3plus n m = {
+--  s = \\c => n.s ! NCard ++ "تهُْسَند" ++ m.s ! c ; n = Pl} ;
+
+-- numerals as sequences of digits
+
+  lincat 
+    Dig = Digits ;  
+--   Numeral,Digits = {s : Gender => State => Case => Str ; 
+--               n : Size } ;
+
+
+  lin
+    IDig d = d ;
+
+    IIDig d i = {
+      s = d.s ++ i.s;
+      n = ThreeTen ;
+    } ;
+
+    D_0 = mk1Dig "0" ;
+    D_1 = mk2Dig "1" One ;
+    D_2 = mk2Dig "2" Two ;
+    D_3 = mk1Dig "3" ;
+    D_4 = mk1Dig "4" ;
+    D_5 = mk1Dig "5" ;
+    D_6 = mk1Dig "6" ;
+    D_7 = mk1Dig "7" ;
+    D_8 = mk1Dig "8" ;
+    D_9 = mk1Dig "9" ;
+
+  oper
+
+
+    mk2Dig : Str -> Size -> Digits = \str,sz -> {
+      s = str ;
+      n = sz ;
+      lock_Digits = <>
+      };
+
+    mk1Dig : Str -> Digits = \str -> {
+      s = str ;
+      n = ThreeTen;
+      lock_Digits = <>
+      };
+
+}

old-lib/resource/arabic/OrthoAra.gf

@@ -0,0 +1,41 @@
+resource OrthoAra = open Prelude, Predef in {
+
+flags coding=utf8 ;
+
+  oper
+    
+    rectifyHmz: Str -> Str = \word ->
+      case word of {
+        l@(""|"ال") + "؟" + v@("َ"|"ُ") + tail => l + "أ" + v + tail;
+        l@(""|"ال") + "؟" + v@("ِ") + tail => l + "إ" + v + tail;
+        head + v1@("ِ"|"ُ"|"َ"|"ْ"|"ا"|"ي"|"و") + "؟" + v2@(""|"ُ"|"َ"|"ْ"|"ِ") => head + v1 + (tHmz v1) + v2;
+        head + "؟" + tail => head + (bHmz (dp 2 head) (take 2 tail)) + tail; --last head , take 1 tail
+        _           => word
+      };
+    
+    --hamza at beginning of word (head)
+    hHmz : Str -> Str = \d ->
+      case d of {
+        "ِ" => "إ";
+	    _	 => "أ"
+      };
+    
+    --hamza in middle of word (body)
+    bHmz : Str -> Str -> Str = \d1,d2 ->
+      case <d1,d2> of {
+        <"ِ",_> | <_,"ِ"> => "ئ";
+	    <"ُ",_> | <_,"ُ"> => "ؤ";
+	    <"َ",_> | <_,"َ"> => "أ";
+	    _				   => "ء"
+      };
+    
+    --hamza carrier sequence
+    tHmz : Str -> Str = \d ->
+      case d of {
+        "ِ" => "ئ";
+	    "ُ" => "ؤ";
+	    "َ" => "أ";
+	    "ْ"|"ا"|"و"|"ي" => "ء"
+      };
+    
+}

old-lib/resource/arabic/ParadigmsAra.gf

@@ -0,0 +1,500 @@
+--# -path=.:../abstract:../../prelude:../common
+
+--1 Arabic Lexical Paradigms
+--
+-- Ali El Dada 2005--2006
+--
+-- This is an API to the user of the resource grammar 
+-- for adding lexical items. It gives functions for forming
+-- expressions of open categories: nouns, adjectives, verbs.
+-- 
+-- Closed categories (determiners, pronouns, conjunctions) are
+-- accessed through the resource syntax API, $Structural.gf$. 
+--
+-- The main difference with $MorphoAra.gf$ is that the types
+-- referred to are compiled resource grammar types. We have moreover
+-- had the design principle of always having existing forms, rather
+-- than stems, as string arguments of the paradigms.
+--
+-- The structure of functions for each word class $C$ is the following:
+-- first we give a handful of patterns that aim to cover all
+-- regular cases. Then we give a worst-case function $mkC$, which serves as an
+-- escape to construct the most irregular words of type $C$.
+-- 
+-- The following modules are presupposed:
+
+resource ParadigmsAra = open 
+  Predef, 
+  Prelude, 
+  MorphoAra,
+  OrthoAra,(ResAra=ResAra),
+  CatAra
+  in {
+
+  flags optimize = noexpand;  coding=utf8 ;
+
+  oper
+    
+-- Prepositions are used in many-argument functions for rection.
+
+  Preposition : Type ;
+
+--2 Nouns
+  
+--This is used for loan words or anything that has untreated irregularities
+--in the interdigitization process of its words
+  mkN : NTable -> Gender -> Species -> N ;
+  
+--Takes a root string, a singular pattern string, a broken plural 
+--pattern string, a gender, and species. Gives a noun.
+  brkN : Str -> Str -> Str -> Gender -> Species -> N ;
+  
+--Takes a root string, a singular pattern string, a gender, 
+--and species. Gives a noun whose plural is sound feminine.
+  sdfN : Str -> Str -> Gender -> Species -> N ;
+    
+--takes a root string, a singular pattern string, a gender, 
+--and species. Gives a noun whose plural is sound masculine
+  sdmN : Str -> Str -> Gender -> Species -> N ; 
+
+  mkPN : Str -> Gender -> Species -> PN ;
+  
+--3 Relational nouns 
+
+  mkN2 : N -> Preposition -> N2 ;
+
+  mkN3 : N -> Preposition -> Preposition -> N3 ;
+
+--2 Adjectives
+ 
+--Takes a root string and a pattern string
+  sndA : Str -> Str -> A ;
+    
+--Takes a root string only
+  clrA : Str -> A ;
+
+--3 Two-place adjectives
+--
+-- Two-place adjectives need a preposition for their second argument.
+
+  mkA2 : A -> Preposition -> A2 ;
+
+--2 Adverbs
+
+-- Adverbs are not inflected. Most lexical ones have position
+-- after the verb. Some can be preverbal.
+
+  mkAdv : Str -> Adv ;
+  mkAdV : Str -> AdV ;
+
+-- Adverbs modifying adjectives and sentences can also be formed.
+
+  mkAdA : Str -> AdA ;
+
+--2 Prepositions
+--
+-- A preposition as used for rection in the lexicon, as well as to
+-- build $PP$s in the resource API, just requires a string.
+
+  mkPreposition : Str -> Preposition ;
+
+-- (These two functions are synonyms.)
+
+--2 Verbs
+
+--The verb in the imperfect tense gives the most information
+
+  regV : Str -> V ;
+
+--Verb Form I : fa`ala, fa`ila, fa`ula
+
+  v1 : Str -> Vowel -> Vowel -> V ;
+  
+--Verb Form II : fa``ala
+  
+  v2 : Str -> V ;
+  
+--Verb Form III : faa`ala
+  
+  v3 : Str -> V ;
+  
+--Verb Form IV : 'af`ala
+  
+  v4 : Str -> V ;
+  
+--Verb Form V : tafa``ala 
+  
+  v5 : Str -> V ;
+  
+--Verb Form VI : tafaa`ala 
+  
+  v6 : Str -> V ;
+  
+--Verb Form VIII 'ifta`ala
+  
+  v8 : Str -> V ;
+
+--3 Two-place verbs
+
+-- Two-place verbs need a preposition, except the special case with direct object.
+-- (transitive verbs). Notice that a particle comes from the $V$.
+
+  mkV2  : V -> Preposition -> V2 ;
+
+  dirV2 : V -> V2 ;
+
+--3 Three-place verbs
+
+-- Three-place (ditransitive) verbs need two prepositions, of which
+-- the first one or both can be absent.
+
+  mkV3     : V -> Preposition -> Preposition -> V3 ; -- speak, with, about
+  dirV3    : V -> Preposition -> V3 ;                -- give,_,to
+  dirdirV3 : V -> V3 ;                               -- give,_,_
+
+--3 Other complement patterns
+--
+-- Verbs and adjectives can take complements such as sentences,
+-- questions, verb phrases, and adjectives.
+
+  mkV0  : V -> V0 ;
+  mkVS  : V -> VS ;
+  mkV2S : V -> Str -> V2S ;
+--  mkVV  : V -> VV ;
+  mkV2V : V -> Str -> Str -> V2V ;
+  mkVA  : V -> VA ;
+  mkV2A : V -> Str -> V2A ;
+  mkVQ  : V -> VQ ;
+  mkV2Q : V -> Str -> V2Q ;
+
+  mkAS  : A -> AS ;
+  mkA2S : A -> Str -> A2S ;
+  mkAV  : A -> AV ;
+  mkA2V : A -> Str -> A2V ;
+
+-- Notice: categories $AS, A2S, AV, A2V$ are just $A$,
+-- and the second argument is given
+-- as an adverb. Likewise 
+-- $V0$ is just $V$.
+
+  V0 : Type ;
+  AS, A2S, AV, A2V : Type ;
+
+
+--.
+--2 Definitions of paradigms
+
+-- The definitions should not bother the user of the API. So they are
+-- hidden from the document.
+
+{-
+-- AED's original definition of regV
+
+  regV = \word ->
+    case word of {
+      "يَ" + f@_ + c@_ + "ُ" + l@_ => v1 (f+c+l) a u ;
+      "يَ" + f@_ + c@_ + "ِ" + l@_ => v1 (f+c+l) a i ;
+      "يَ" + f@_ + c@_ + "َ" + l@_ => v1 (f+c+l) a a ;
+      f@_ + "َ" + c@_ + "ِ" + l@_   => v1 (f+c+l) i a 
+    };
+-}
+
+---- begin workaround for a problem with pattern matching, AR 27/6/2008
+
+  regV = \word ->
+    case Predef.eqStr (Predef.take 2 word) "يَ" of {
+      Predef.PTrue => vYa (Predef.drop 2 word) ; 
+      _ => vCo word
+    };
+
+  vYa : Str -> V = \word ->
+    let
+      fcl = Predef.take 2 word + Predef.drop 3 word ;
+      voc = case Predef.take 1 (Predef.drop 2 word) of {
+        "ُ" => u ;
+        "ِ" => i ;
+        _ => a 
+        }
+    in
+    v1 fcl a voc ;
+    
+  vCo : Str -> V = \word -> 
+    let 
+      f = Predef.take 1 word ;
+      c = Predef.take 1 (Predef.drop 2 word) ;
+      l = Predef.drop 4 word
+    in
+    v1 (f + c + l) i a ;
+
+---- end workaround definition
+
+  v1 = \rootStr,vPerf,vImpf -> 
+    let { raw = v1' rootStr vPerf vImpf } in
+    { s = \\vf => 
+        case rootStr of {
+          _ + "؟" + _ => rectifyHmz(raw.s ! vf);
+          _ => raw.s ! vf 
+        };
+      lock_V = <>
+    } ;
+  
+  va : Vowel = ResAra.a ;
+
+  v1' : Str ->  Vowel -> Vowel -> Verb = 
+    \rootStr,vPerf,vImpf ->
+    let { root = mkRoot3 rootStr ;
+          l = dp 2 rootStr } in --last rootStr
+    case <l, root.c> of {
+      <"ّ",_>     => v1geminate rootStr vPerf vImpf ;
+      <"و"|"ي",_> => v1defective root vImpf ;
+      <_,"و"|"ي"> => v1hollow root vImpf ;
+      _		    => v1sound root vPerf vImpf 
+    };
+  
+  v2 = 
+    \rootStr ->
+    let {
+      root = mkRoot3 rootStr 
+    } in {
+      s = 
+        case root.l of {
+          "و"|"ي" => (v2defective root).s;
+          _       => (v2sound root).s
+        };
+      lock_V = <>
+    };              
+  
+  v3 = 
+    \rootStr ->
+    let {
+      tbc = mkRoot3 rootStr ;
+    } in {
+      s = (v3sound tbc).s  ;
+      lock_V = <>
+    };
+  
+  v4 = 
+    \rootStr ->
+    let {
+      root = mkRoot3 rootStr 
+    } in {
+      s = 
+        case root.l of {
+          "و"|"ي" => (v4defective root).s;
+          _       => (v4sound root).s
+        }; 
+      lock_V = <>
+    };
+  
+  
+  v5 =
+    \rootStr ->
+    let { raw = v5' rootStr } in
+    { s = \\vf =>
+        case rootStr of {
+          _ + "؟" + _ => rectifyHmz(raw.s ! vf);
+          _ => raw.s ! vf
+        };
+      lock_V = <>
+    };
+  
+  v5' : Str -> V = 
+    \rootStr ->
+    let {
+      nfs = mkRoot3 rootStr ;
+    } in {
+      s = (v5sound nfs).s  ; lock_V = <>
+    };
+  
+  v6 = 
+    \rootStr ->
+    let {
+      fqm = mkRoot3 rootStr ;
+    } in {
+      s = (v6sound fqm).s  ;
+      lock_V = <>
+    };
+  
+  v8 = 
+    \rootStr ->
+    let {
+      rbT = mkRoot3 rootStr ;
+    } in {
+      s = (v8sound rbT).s ;
+      lock_V = <>
+    };
+  
+  Preposition = Str ;
+  
+  mkN nsc gen spec =
+    { s = nsc; --NTable
+      g = gen; 
+      h = spec;
+      lock_N = <>
+    };
+  
+  brkN' : Str -> Str -> Str -> Gender -> Species -> N =
+    \root,sg,pl,gen,spec ->
+    let { kitAb = mkWord sg root;
+          kutub = mkWord pl root
+    } in mkN (reg kitAb kutub) gen spec;
+  
+  brkN root sg pl gen spec =
+    let { raw = brkN' root sg pl gen spec} in
+    { s = \\n,d,c =>
+        case root of {
+          _ + "؟" + _ => rectifyHmz(raw.s ! n ! d ! c);
+          _ => raw.s ! n ! d ! c
+        };
+      g = gen;
+      h = spec ; lock_N = <>
+    };
+  
+  sdfN =
+    \root,sg,gen,spec ->
+    let { kalima = mkWord sg root;
+    } in mkN (sndf kalima) gen spec;
+  
+  sdmN =
+    \root,sg,gen,spec ->
+    let { mucallim = mkWord sg root;
+    } in mkN (sndm mucallim) gen spec;
+
+  mkPN = \str,gen,species -> 
+    { s = \\c => str + indecl!c ;
+      g = gen;
+      h = species;
+      lock_PN = <>
+    };
+    
+  
+  mkN2 = \n,p -> n ** {lock_N2 = <> ; c2 = p} ;
+  
+  mkN3 = \n,p,q -> n ** {lock_N3 = <> ; c2 = p ; c3 = q} ;
+  
+  mkPron : (_,_,_ : Str) -> PerGenNum -> NP = \ana,nI,I,pgn ->
+    { s = 
+        table {
+          Nom => ana;
+          Acc => nI;
+          Gen => I
+        };
+      a = {pgn = pgn; isPron = True };
+      lock_NP = <>
+    };
+
+  -- e.g. al-jamii3, 2a7ad
+  regNP : Str -> Number -> NP = \word,n ->
+    { s = \\c => word + vowel ! c ;
+      a = {pgn = Per3 Masc n; isPron = False };
+      lock_NP = <>
+    };
+
+  -- e.g. hadha, dhaalika
+  indeclNP : Str -> Number -> NP = \word,n ->
+    { s = \\c => word ;
+      a = {pgn = Per3 Masc n; isPron = False };
+      lock_NP = <>
+    };
+  
+  mkQuant7 : (_,_,_,_,_,_,_ : Str) -> State -> Quant =
+    \hava,havihi,havAn,havayn,hAtAn,hAtayn,hA'ulA,det ->
+    { s = \\n,s,g,c =>
+        case <s,g,c,n> of {
+          <_,Masc,_,Sg>  => hava;
+          <_,Fem,_,Sg>   => havihi;
+          <_,Masc,Nom,Dl>=> havAn;
+          <_,Masc,_,Dl>  => havayn;
+          <_,Fem,Nom,Dl> => hAtAn;
+          <_,Fem,_,Dl>   => hAtayn;
+          <Hum,_,_,Pl>   => hA'ulA;
+          _              => havihi
+        };
+      d = Def;
+      isPron = False;
+      isNum = False;
+      lock_Quant = <>
+    };
+  
+  mkQuant3 : (_,_,_ : Str) -> State -> Quant =
+    \dalika,tilka,ula'ika,det ->
+    { s = \\n,s,g,c =>
+        case <s,g,c,n> of {
+          <_,Masc,_,Sg>  => dalika;
+          <_,Fem,_,Sg>   => tilka;
+          <Hum,_,_,_>   => ula'ika;
+          _              => tilka
+        };
+      d = Def;
+      isPron = False;
+      isNum = False;
+      lock_Quant = <>
+    };
+  
+  sndA root pat =
+    let  raw = sndA' root pat in { 
+      s = \\af =>
+        case root of {
+          _ + "؟" + _ => rectifyHmz(raw.s ! af);
+        _ => raw.s ! af
+        };
+      lock_A = <>
+    };
+  
+  sndA' : Str -> Str -> A =
+    \root,pat ->
+    let { kabIr = mkWord pat root;
+          akbar = mkWord "أَفعَل" root
+    } in {
+      s = table {
+        APosit g n d c => (positAdj kabIr) ! g ! n ! d ! c ;
+        AComp d c => (indeclN akbar) ! d ! c
+        };
+      lock_A = <>
+    };
+  
+  clrA root =
+    let { eaHmar = mkWord "أَفعَل" root;
+          HamrA' = mkWord "فَعلاء" root;
+          Humr   = mkWord "فُعل" root
+    } in {
+      s = clr eaHmar HamrA' Humr;
+      lock_A = <>
+    };
+  
+  mkA2 a p = a ** {c2 = p ; lock_A2 = <>} ;
+  
+  mkAdv x = ss x ** {lock_Adv = <>} ;
+  mkAdV x = ss x ** {lock_AdV = <>} ;
+  mkAdA x = ss x ** {lock_AdA = <>} ;
+  
+  mkPreposition p = p ;
+  mkV2 v p = v ** {s = v.s ; c2 = p ; lock_V2 = <>} ;
+  dirV2 v = mkV2 v [] ;
+  
+  mkV3 v p q = v ** {s = v.s ; c2 = p ; c3 = q ; lock_V3 = <>} ;
+  dirV3 v p = mkV3 v [] p ;
+  dirdirV3 v = dirV3 v [] ;
+
+  mkVS  v = v ** {lock_VS = <>} ;
+  mkVQ  v = v ** {lock_VQ = <>} ;
+
+  V0 : Type = V ;
+----  V2S, V2V, V2Q, V2A : Type = V2 ;
+  AS, A2S, AV : Type = A ;
+  A2V : Type = A2 ;
+
+  mkV0  v = v ** {lock_V = <>} ;
+  mkV2S v p = mkV2 v p ** {lock_V2S = <>} ;
+  mkV2V v p t = mkV2 v p ** {s4 = t ; lock_V2V = <>} ;
+  mkVA  v = v ** {lock_VA = <>} ;
+  mkV2A v p = mkV2 v p ** {lock_V2A = <>} ;
+  mkV2Q v p = mkV2 v p ** {lock_V2Q = <>} ;
+
+  mkAS  v = v ** {lock_A = <>} ;
+  mkA2S v p = mkA2 v p ** {lock_A = <>} ;
+  mkAV  v = v ** {lock_A = <>} ;
+  mkA2V v p = mkA2 v p ** {lock_A2 = <>} ;
+
+
+} ;

old-lib/resource/arabic/PatternsAra.gf

@@ -0,0 +1,106 @@
+resource PatternsAra =  {
+
+flags coding=utf8 ;
+
+  oper
+    
+	fA'  = { h = "" ; m1 = ""; m2 = ""; t = "َاء"} ;
+
+	eafAcI = { h = "أَ"; m1 = "َا"; m2 = ""; t = "ِي" } ;
+	eafcA' = { h = "أَ"; m1 = "ْ" ; m2 = ""; t = "َاء"} ;
+	eafcI  = { h = "أَ"; m1 = "ْ" ; m2 = ""; t = "ِي" } ;
+	fac    = { h = ""  ; m1 = "َ" ; m2 = ""; t = ""   } ;
+	facc   = { h = ""  ; m1 = "َ" ; m2 = ""; t = "ّ"  } ;
+	facca  = { h = ""  ; m1 = "َ" ; m2 = ""; t = "َّ" } ;
+	facci  = { h = ""  ; m1 = "َ" ; m2 = ""; t = "ِّ" } ;
+	faccu  = { h = ""  ; m1 = "َ" ; m2 = ""; t = "ُّ" } ;
+	facp   = { h = ""  ; m1 = "َ" ; m2 = ""; t = "َة" } ;
+	faca   = { h = ""  ; m1 = "َ" ; m2 = ""; t = "َ"  } ;
+	facA   = { h = ""  ; m1 = "َ" ; m2 = ""; t = "َا" } ;
+	facA'  = { h = ""  ; m1 = "َ" ; m2 = ""; t = "َاء"} ;
+	fAc    = { h = ""  ; m1 = "َا"; m2 = ""; t = ""   } ;
+	fAcp   = { h = ""  ; m1 = "َا"; m2 = ""; t = "َة" } ;
+	fic    = { h = ""  ; m1 = "ِ" ; m2 = ""; t = ""   } ;
+	ficc   = { h = ""  ; m1 = "ِ" ; m2 = ""; t = "ّ"  } ;
+	ficA'  = { h = ""  ; m1 = "ِ" ; m2 = ""; t = "َاء"} ;
+	fIc    = { h = ""  ; m1 = "ِي"; m2 = ""; t = ""   } ;
+	fIcAn  = { h = ""  ; m1 = "ِي"; m2 = ""; t = "َان"} ;
+	fca    = { h = ""  ; m1 = "ْ" ; m2 = ""; t = "َ"  } ;
+	fci    = { h = ""  ; m1 = "ْ" ; m2 = ""; t = "ِ"  } ;
+	fcu    = { h = ""  ; m1 = "ْ" ; m2 = ""; t = "ُ"  } ;
+	fuc    = { h = ""  ; m1 = "ُ" ; m2 = ""; t = ""   } ;
+	fucc   = { h = ""  ; m1 = "ُ" ; m2 = ""; t = "ّ"  } ;
+	fucci  = { h = ""  ; m1 = "ُ" ; m2 = ""; t = "ِّ" } ;
+	fuccu  = { h = ""  ; m1 = "ُ" ; m2 = ""; t = "ُّ" } ;
+	fuci   = { h = ""  ; m1 = "ُ" ; m2 = ""; t = "ِ"  } ;
+	fucu   = { h = ""  ; m1 = "ُ" ; m2 = ""; t = "ُ"  } ;
+	fUc    = { h = ""  ; m1 = "ُو"; m2 = ""; t = ""   } ;
+	ufAc   = { h = "ُ" ; m1 = "َا"; m2 = ""; t = ""   } ;
+	ufca   = { h = "ُ" ; m1 = "ْ" ; m2 = ""; t = "َ"  } ;
+
+	eafAcil  = { h = "أَ"; m1 = "َا"  ; m2 = "ِ"   ; t = ""   } ;
+	eafAcIl  = { h = "أَ"; m1 = "َا"  ; m2 = "ِي"  ; t = ""   } ;
+	eafcilp  = { h = "أَ"; m1 = "ْ"   ; m2 = "ِ"   ; t = "َة" } ;
+	eafcal   = { h = "أَ"; m1 = "ْ"   ; m2 = "َ"   ; t = ""   } ;
+	eafcAl   = { h = "أَ"; m1 = "ْ"   ; m2 = "َا"  ; t = ""   } ;
+	eafcil   = { h = "أَ"; m1 = "ْ"   ; m2 = "ِ"   ; t = ""   } ;
+	eafcul   = { h = "أَ"; m1 = "ْ"   ; m2 = "ُ"   ; t = ""   } ;
+	eiftacal = { h = "إِ"; m1 = "ْتَ" ; m2 = "َ"   ; t = ""   } ;
+	eufcil   = { h = "أُ"; m1 = "ْ"   ; m2 = "ِ"   ; t = ""   } ;
+	euftucil = { h = "أُ"; m1 = "ْتُ" ; m2 = "ِ"   ; t = ""   } ;
+	afcul    = { h = "َ" ; m1 = "ْ"   ; m2 = "ُ"   ; t = ""   } ;
+	faccalo  = { h = ""  ; m1 = "َ"   ; m2 = "َّ"  ; t = "ْ"  } ;
+	facal    = { h = ""  ; m1 = "َ"   ; m2 = "َ"   ; t = ""   } ;
+	facalo   = { h = ""  ; m1 = "َ"   ; m2 = "َ"   ; t = "ْ"  } ;
+	facalp   = { h = ""  ; m1 = "َ"   ; m2 = "َ"   ; t = "َة" } ;
+	facA'il  = { h = ""  ; m1 = "َ"   ; m2 = "َائِ"; t = ""   } ;
+	facAl    = { h = ""  ; m1 = "َ"   ; m2 = "َا"  ; t = ""   } ;
+	facAlI   = { h = ""  ; m1 = "َ"   ; m2 = "َا"  ; t = "ِي" } ;
+	facil    = { h = ""  ; m1 = "َ"   ; m2 = "ِ"   ; t = ""   } ;
+	facIl    = { h = ""  ; m1 = "َ"   ; m2 = "ِي"  ; t = ""   } ;
+	facl     = { h = ""  ; m1 = "َ"   ; m2 = "ْ"   ; t = ""   } ;
+	faclp    = { h = ""  ; m1 = "َ"   ; m2 = "ْ"   ; t = "َة" } ;
+	facul    = { h = ""  ; m1 = "َ"   ; m2 = "ُ"   ; t = ""   } ;
+	fAcal    = { h = ""  ; m1 = "َا"  ; m2 = "َ"   ; t = ""   } ;
+	fAcil    = { h = ""  ; m1 = "َا"  ; m2 = "ِ"   ; t = ""   } ;
+	faccal   = { h = ""  ; m1 = "َ"   ; m2 = "َّ"  ; t = ""   } ;
+	faccil   = { h = ""  ; m1 = "َ"   ; m2 = "ِّ"  ; t = ""   } ;
+	faclA'   = { h = ""  ; m1 = "َ"   ; m2 = "ْ"   ; t = "َاء"} ;
+	fAcilp   = { h = ""  ; m1 = "َا"  ; m2 = "ِ"   ; t = "َة" } ;
+	fawAcil  = { h = ""  ; m1 = "َوَا"; m2 = "ِ"   ; t = ""   } ;
+	ficAlp   = { h = ""  ; m1 = "ِ"   ; m2 = "َا"  ; t = "َة" } ;
+	fcal     = { h = ""  ; m1 = "ْ"   ; m2 = "َ"   ; t = ""   } ;
+	fcil     = { h = ""  ; m1 = "ْ"   ; m2 = "ِ"   ; t = ""   } ;
+	fcul     = { h = ""  ; m1 = "ْ"   ; m2 = "ُ"   ; t = ""   } ;
+	ficl     = { h = ""  ; m1 = "ِ"   ; m2 = "ْ"   ; t = ""   } ;
+	ficAl    = { h = ""  ; m1 = "ِ"   ; m2 = "َا"  ; t = ""   } ;
+	ficlp    = { h = ""  ; m1 = "ِ"   ; m2 = "ْ"   ; t = "َة" } ;
+	ftacal   = { h = ""  ; m1 = "ْتَ" ; m2 = "َ"   ; t = ""   } ;
+	ftacil   = { h = ""  ; m1 = "ْتَ" ; m2 = "ِ"   ; t = ""   } ;
+	fuccAl   = { h = ""  ; m1 = "ُ"   ; m2 = "َّا" ; t = ""   } ;
+	fuccil   = { h = ""  ; m1 = "ُ"   ; m2 = "ِّ"  ; t = ""   } ;
+	fuccilo  = { h = ""  ; m1 = "ُ"   ; m2 = "ِّ"  ; t = "ْ"  } ;
+	fucal    = { h = ""  ; m1 = "ُ"   ; m2 = "َ"   ; t = ""   } ;
+	fucaylp  = { h = ""  ; m1 = "ُ"   ; m2 = "َيْ" ; t = "َة" } ;
+	fucAl    = { h = ""  ; m1 = "ُ"   ; m2 = "َا"  ; t = ""   } ;
+	fucl     = { h = ""  ; m1 = "ُ"   ; m2 = "ْ"   ; t = ""   } ;
+	fucil    = { h = ""  ; m1 = "ُ"   ; m2 = "ِ"   ; t = ""   } ;
+	fuclp    = { h = ""  ; m1 = "ُ"   ; m2 = "ْ"   ; t = "َة" } ;
+	fucilo   = { h = ""  ; m1 = "ُ"   ; m2 = "ِ"   ; t = "ْ"  } ;
+	fucul    = { h = ""  ; m1 = "ُ"   ; m2 = "ُ"   ; t = ""   } ;
+	fuculo   = { h = ""  ; m1 = "ُ"   ; m2 = "ُ"   ; t = "ْ"  } ;
+	fucUl    = { h = ""  ; m1 = "ُ"   ; m2 = "ُو"  ; t = ""   } ;
+	fUcil    = { h = ""  ; m1 = "ُو"  ; m2 = "ِ"   ; t = ""   } ;
+    mafcUl   = { h = "مَ"; m1 = "ْ"   ; m2 = "ُو"  ; t = ""   } ;
+    mafcil   = { h = "مَ"; m1 = "ْ"   ; m2 = "ِ"  ; t = ""   } ;
+	tafAcal  = { h = "تَ"; m1 = "َا"  ; m2 = "َ"   ; t = ""   } ;
+	tafaccal = { h = "تَ"; m1 = "َ"   ; m2 = "َّ"  ; t = ""   } ;
+	tufuccil = { h = "تُ"; m1 = "ُ"   ; m2 = "ِّ"  ; t = ""   } ;
+	tufUcil  = { h = "تُ"; m1 = "ُو"  ; m2 = "ِ"   ; t = ""   } ;
+	ufAcal   = { h = "ُ" ; m1 = "َا"  ; m2 = "َ"   ; t = ""   } ;
+	ufAcil   = { h = "ُ" ; m1 = "َا"  ; m2 = "ِ"   ; t = ""   } ;
+	ufcal    = { h = "ُ" ; m1 = "ْ"   ; m2 = "َ"   ; t = ""   } ;
+	ufcil    = { h = "ُ" ; m1 = "ْ"   ; m2 = "ِ"   ; t = ""   } ;
+	ufcul    = { h = "ُ" ; m1 = "ْ"   ; m2 = "ُ"   ; t = ""   } ;
+
+}

old-lib/resource/arabic/PhraseAra.gf

@@ -0,0 +1,26 @@
+concrete PhraseAra of Phrase = CatAra ** open 
+  ParamX, 
+  Prelude, 
+  ResAra in {
+
+  lin
+    PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ! Masc ++ voc.s} ;--FIXME
+
+--    UttS s = s ;
+--    UttQS qs = {s = qs.s ! QDir} ;
+    UttImpSg pol imp = {s = \\g => imp.s ! pol.p ! g ! ResAra.Sg} ;
+--    UttImpPl pol imp = {s = pol.s ++ imp.s ! pol.p ! Pl} ;
+--
+--    UttIP ip = {s = ip.s ! Nom} ; --- Acc also
+--    UttIAdv iadv = iadv ;
+--    UttNP np = {s = np.s ! Acc} ;
+--    UttVP vp = {s = infVP False vp (agrP3 Sg)} ;
+--    UttAdv adv = adv ;
+--
+    NoPConj = {s = []} ;
+--    PConjConj conj = conj ;
+--
+    NoVoc = {s = []} ;
+--    VocNP np = {s = "،" ++ np.s ! Nom} ;
+--
+}

old-lib/resource/arabic/QuestionAra.gf

@@ -0,0 +1,55 @@
+concrete QuestionAra of Question = CatAra ** open ResAra, ParamX in {
+
+  flags optimize=all_subs ;
+
+  lin
+
+    QuestCl cl = {
+      s = \\t,p => 
+        table {
+          QIndir => "إِذا" ++ cl.s ! t ! p ! Verbal ;
+          QDir => cl.s ! t ! p ! Verbal 
+        }
+      };
+
+
+--
+--    QuestVP qp vp = 
+--      let cl = mkClause (qp.s ! Nom) {n = qp.n ; p = P3} vp
+--      in {s = \\t,a,b,_ => cl.s ! t ! a ! b ! ODir} ;
+--
+--    QuestSlash ip slash = {
+--      s = \\t,a,p => 
+--            let 
+--              cls = slash.s ! t ! a ! p ;
+--              who = slash.c2 ++ ip.s ! Acc --- stranding in ExtAra 
+--            in table {
+--              QDir   => who ++ cls ! OQuest ;
+--              QIndir => who ++ cls ! ODir
+--              }
+--      } ;
+--
+--    QuestIAdv iadv cl = {
+--      s = \\t,a,p => 
+--            let 
+--              cls = cl.s ! t ! a ! p ;
+--              why = iadv.s
+--            in table {
+--              QDir   => why ++ cls ! OQuest ;
+--              QIndir => why ++ cls ! ODir
+--              }
+--      } ;
+--
+--    PrepIP p ip = {s = p.s ++ ip.s ! Nom} ;
+--
+--    AdvIP ip adv = {
+--      s = \\c => ip.s ! c ++ adv.s ;
+--      n = ip.n
+--      } ;
+-- 
+--    IDetCN idet num ord cn = {
+--      s = \\c => idet.s ++ num.s ++ ord.s ++ cn.s ! idet.n ! c ; 
+--      n = idet.n
+--      } ;
+--
+}

old-lib/resource/arabic/RelativeAra.gf

@@ -0,0 +1,34 @@
+concrete RelativeAra of Relative = CatAra ** open ResAra in {
+--
+--  flags optimize=all_subs ;
+--
+--  lin
+--
+--    RelCl cl = {
+--      s = \\t,a,p,_ => "سُعه" ++ "تهَت" ++ cl.s ! t ! a ! p ! ODir
+--      } ;
+--
+--    RelVP rp vp = {
+--      s = \\t,ant,b,ag => 
+--        let 
+--          agr = case rp.a of {
+--            RNoAg => ag ;
+--            RAg a => a
+--            } ;
+--          cl = mkClause (rp.s ! Nom) agr vp
+--        in
+--        cl.s ! t ! ant ! b ! ODir
+--      } ;
+--
+--    RelSlash rp slash = {
+--      s = \\t,a,p,_ => slash.c2 ++ rp.s ! Acc ++ slash.s ! t ! a ! p ! ODir
+--      } ;
+--
+--    FunRP p np rp = {
+--      s = \\c => np.s ! c ++ p.s ++ rp.s ! Acc ;
+--      a = RAg np.a
+--      } ;
+--
+--    IdRP = mkIP "وهِعه" "وهِعه" "وهْسي" Sg ** {a = RNoAg} ;
+--
+}