mirror of
https://github.com/GrammaticalFramework/gf-core.git
synced 2026-04-09 04:59:31 -06:00
Latvian resource started by Normunds Gruzitis
This commit is contained in:
aarne
53
lib/src/latvian/AdjectiveLav.gf
Normal file
53
lib/src/latvian/AdjectiveLav.gf
Normal file
@@ -0,0 +1,53 @@
|
||||
concrete AdjectiveLav of Adjective = CatLav ** open ResLav, Prelude in {
|
||||
{-
|
||||
lin
|
||||
|
||||
PositA a = {
|
||||
s = \\_ => a.s ! AAdj Posit Nom ;
|
||||
isPre = True
|
||||
} ;
|
||||
ComparA a np = {
|
||||
s = \\_ => a.s ! AAdj Compar Nom ++ "than" ++ np.s ! Nom ;
|
||||
isPre = False
|
||||
} ;
|
||||
UseComparA a = {
|
||||
s = \\_ => a.s ! AAdj Compar Nom ;
|
||||
isPre = True
|
||||
} ;
|
||||
|
||||
AdjOrd ord = {
|
||||
s = \\_ => ord.s ! Nom ;
|
||||
isPre = True
|
||||
} ;
|
||||
|
||||
CAdvAP ad ap np = {
|
||||
s = \\a => ad.s ++ ap.s ! a ++ ad.p ++ np.s ! Nom ;
|
||||
isPre = False
|
||||
} ;
|
||||
|
||||
ComplA2 a np = {
|
||||
s = \\_ => a.s ! AAdj Posit Nom ++ a.c2 ++ np.s ! Acc ;
|
||||
isPre = False
|
||||
} ;
|
||||
|
||||
ReflA2 a = {
|
||||
s = \\ag => a.s ! AAdj Posit Nom ++ 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 = {
|
||||
s = \\_ => a.s ! AAdj Posit Nom ;
|
||||
isPre = True
|
||||
} ;
|
||||
-}
|
||||
}
|
||||
20
lib/src/latvian/AdverbLav.gf
Normal file
20
lib/src/latvian/AdverbLav.gf
Normal file
@@ -0,0 +1,20 @@
|
||||
concrete AdverbLav of Adverb = CatLav ** open ResLav, Prelude in {
|
||||
{-
|
||||
lin
|
||||
PositAdvAdj a = {s = a.s ! AAdv} ;
|
||||
ComparAdvAdj cadv a np = {
|
||||
s = cadv.s ++ a.s ! AAdv ++ cadv.p ++ np.s ! Nom
|
||||
} ;
|
||||
ComparAdvAdjS cadv a s = {
|
||||
s = cadv.s ++ a.s ! AAdv ++ cadv.p ++ s.s
|
||||
} ;
|
||||
|
||||
PrepNP prep np = {s = prep.s ++ np.s ! Acc} ;
|
||||
|
||||
AdAdv = cc2 ;
|
||||
|
||||
SubjS = cc2 ;
|
||||
|
||||
AdnCAdv cadv = {s = cadv.s ++ cadv.p} ;
|
||||
-}
|
||||
}
|
||||
9
lib/src/latvian/AllLav.gf
Normal file
9
lib/src/latvian/AllLav.gf
Normal file
@@ -0,0 +1,9 @@
|
||||
--# -path=.:../abstract:../common:prelude
|
||||
|
||||
concrete AllLav of AllLavAbs =
|
||||
LangLav,
|
||||
{- IrregLav-[
|
||||
blow_V,burn_V,come_V,dig_V,fall_V,fly_V,freeze_V,go_V,lie_V,run_V,
|
||||
sew_V,sing_V,sit_V,sleep_V,spit_V,stand_V,swell_V,swim_V,think_V], -}
|
||||
ExtraLav
|
||||
** {} ;
|
||||
9
lib/src/latvian/AllLavAbs.gf
Normal file
9
lib/src/latvian/AllLavAbs.gf
Normal file
@@ -0,0 +1,9 @@
|
||||
--# -path=.:../abstract:../common:prelude
|
||||
|
||||
abstract AllLavAbs =
|
||||
Lang,
|
||||
{- IrregLavAbs-[
|
||||
blow_V,burn_V,come_V,dig_V,fall_V,fly_V,freeze_V,go_V,lie_V,run_V,
|
||||
sew_V,sing_V,sit_V,sleep_V,spit_V,stand_V,swell_V,swim_V,think_V], -}
|
||||
ExtraLavAbs
|
||||
** {} ;
|
||||
104
lib/src/latvian/CatLav.gf
Normal file
104
lib/src/latvian/CatLav.gf
Normal file
@@ -0,0 +1,104 @@
|
||||
concrete CatLav of Cat = CommonX ** open ResLav, Prelude in {
|
||||
|
||||
flags optimize=all_subs ;
|
||||
|
||||
lincat
|
||||
N = {s : Number => Case => Str ; g : Gender} ;
|
||||
A = {s : Degree => Definite => Gender => Number => Case => Str} ;
|
||||
V = {s : Polarity => VerbForm => Str} ;
|
||||
V2 = V ; -- ** {c : ResLav.Case} - valence
|
||||
|
||||
|
||||
Cl = {s : VerbMood => Polarity => Str} ;
|
||||
|
||||
CN = {s : Definite => Number => Case => Str ; g : Gender} ;
|
||||
Det = {s : Gender => Case => Str ; n : Number ; d: Definite} ;
|
||||
NP = {s : Case => Str ; g : Gender ; n : Number; p : Person} ;
|
||||
VP = {v : V ; obj : ResLav.Agr => Str} ;
|
||||
--TODO - arî Quant jâpieliek
|
||||
|
||||
{-
|
||||
-- Tensed/Untensed
|
||||
|
||||
S = {s : Str} ;
|
||||
QS = {s : QForm => Str} ;
|
||||
RS = {s : Agr => Str ; c : Case} ; -- c for it clefts
|
||||
SSlash = {s : Str ; c2 : Str} ;
|
||||
|
||||
-- Sentence
|
||||
|
||||
Cl = {s : ResEng.Tense => Anteriority => CPolarity => Order => Str} ;
|
||||
ClSlash = {
|
||||
s : ResEng.Tense => Anteriority => CPolarity => Order => Str ;
|
||||
c2 : Str
|
||||
} ;
|
||||
Imp = {s : CPolarity => ImpForm => Str} ;
|
||||
|
||||
-- Question
|
||||
|
||||
QCl = {s : ResEng.Tense => Anteriority => CPolarity => QForm => Str} ;
|
||||
IP = {s : Case => Str ; n : Number} ;
|
||||
IComp = {s : Str} ;
|
||||
IDet = {s : Str ; n : Number} ;
|
||||
IQuant = {s : Number => Str} ;
|
||||
|
||||
-- Relative
|
||||
|
||||
RCl = {
|
||||
s : ResEng.Tense => Anteriority => CPolarity => Agr => Str ;
|
||||
c : Case
|
||||
} ;
|
||||
RP = {s : RCase => Str ; a : RAgr} ;
|
||||
|
||||
-- Verb
|
||||
|
||||
VP = ResEng.VP ;
|
||||
VPSlash = ResEng.VP ** {c2 : Str} ;
|
||||
Comp = {s : Agr => Str} ;
|
||||
|
||||
-- Adjective
|
||||
|
||||
AP = {s : Agr => Str ; isPre : Bool} ;
|
||||
|
||||
-- Noun
|
||||
|
||||
CN = {s : Number => Case => Str ; g : Gender} ;
|
||||
NP = {s : Case => Str ; a : Agr} ;
|
||||
Pron = {s : Case => Str ; sp : Case => Str ; a : Agr} ;
|
||||
Det = {s : Str ; sp : Case => Str ; n : Number} ;
|
||||
Predet = {s : Str} ;
|
||||
Ord = { s : Case => Str } ;
|
||||
Num = {s : Case => Str ; n : Number ; hasCard : Bool} ;
|
||||
Card = {s : Case => Str ; n : Number} ;
|
||||
Quant = {s : Bool => Number => Str ; sp : Bool => Number => Case => Str} ;
|
||||
|
||||
-- Numeral
|
||||
|
||||
Numeral = {s : CardOrd => Case => Str ; n : Number} ;
|
||||
Digits = {s : CardOrd => Case => Str ; n : Number ; tail : DTail} ;
|
||||
|
||||
-- Structural
|
||||
|
||||
Conj = {s1,s2 : Str ; n : Number} ;
|
||||
---b Conj = {s : Str ; n : Number} ;
|
||||
---b DConj = {s1,s2 : Str ; n : Number} ;
|
||||
Subj = {s : Str} ;
|
||||
Prep = {s : Str} ;
|
||||
|
||||
-- Open lexical classes, e.g. Lexicon
|
||||
|
||||
V, VS, VQ, VA = Verb ; -- = {s : VForm => Str} ;
|
||||
V2, V2A, V2Q, V2S = Verb ** {c2 : Str} ;
|
||||
V3 = Verb ** {c2, c3 : Str} ;
|
||||
VV = {s : VVForm => Str ; isAux : Bool} ;
|
||||
V2V = Verb ** {c2 : Str ; isAux : Bool} ;
|
||||
|
||||
A = {s : AForm => Str} ;
|
||||
A2 = {s : AForm => Str ; c2 : Str} ;
|
||||
|
||||
N = {s : Number => Case => Str ; g : Gender} ;
|
||||
N2 = {s : Number => Case => Str ; g : Gender} ** {c2 : Str} ;
|
||||
N3 = {s : Number => Case => Str ; g : Gender} ** {c2,c3 : Str} ;
|
||||
PN = {s : Case => Str ; g : Gender} ;
|
||||
-}
|
||||
}
|
||||
44
lib/src/latvian/ConjunctionLav.gf
Normal file
44
lib/src/latvian/ConjunctionLav.gf
Normal file
@@ -0,0 +1,44 @@
|
||||
concrete ConjunctionLav of Conjunction =
|
||||
CatLav ** open ResLav, Coordination, Prelude in {
|
||||
{-
|
||||
flags optimize=all_subs ;
|
||||
|
||||
lin
|
||||
|
||||
ConjS = conjunctDistrSS ;
|
||||
|
||||
ConjAdv = conjunctDistrSS ;
|
||||
|
||||
ConjNP conj ss = conjunctDistrTable Case conj ss ** {
|
||||
a = conjAgr (agrP3 conj.n) ss.a
|
||||
} ;
|
||||
|
||||
ConjAP conj ss = conjunctDistrTable Agr conj ss ** {
|
||||
isPre = ss.isPre
|
||||
} ;
|
||||
|
||||
ConjRS conj ss = conjunctDistrTable Agr conj ss ** {
|
||||
c = ss.c
|
||||
} ;
|
||||
|
||||
-- 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} ;
|
||||
BaseRS x y = twoTable Agr x y ** {c = y.c} ;
|
||||
ConsRS xs x = consrTable Agr comma xs x ** {c = xs.c} ;
|
||||
|
||||
lincat
|
||||
[S] = {s1,s2 : Str} ;
|
||||
[Adv] = {s1,s2 : Str} ;
|
||||
[NP] = {s1,s2 : Case => Str ; a : Agr} ;
|
||||
[AP] = {s1,s2 : Agr => Str ; isPre : Bool} ;
|
||||
[RS] = {s1,s2 : Agr => Str ; c : Case} ;
|
||||
-}
|
||||
}
|
||||
43786
lib/src/latvian/DictLatAbs.gf
Normal file
43786
lib/src/latvian/DictLatAbs.gf
Normal file
File diff suppressed because it is too large
Load Diff
43791
lib/src/latvian/DictLav.gf
Normal file
43791
lib/src/latvian/DictLav.gf
Normal file
File diff suppressed because it is too large
Load Diff
100
lib/src/latvian/ExtraLav.gf
Normal file
100
lib/src/latvian/ExtraLav.gf
Normal file
@@ -0,0 +1,100 @@
|
||||
concrete ExtraLav of ExtraLavAbs = CatLav **
|
||||
open ResLav, Coordination, Prelude, MorphoLav in {
|
||||
{-
|
||||
lin
|
||||
GenNP np = {s = \\_,_ => np.s ! Gen ; sp = \\_,_,_ => np.s ! Gen} ;
|
||||
ComplBareVS v s = insertObj (\\_ => s.s) (predV v) ;
|
||||
|
||||
StrandRelSlash rp slash = {
|
||||
s = \\t,a,p,ag =>
|
||||
rp.s ! RC (fromAgr ag).g Acc ++ slash.s ! t ! a ! p ! ODir ++ slash.c2 ;
|
||||
c = Acc
|
||||
} ;
|
||||
EmptyRelSlash slash = {
|
||||
s = \\t,a,p,_ => slash.s ! t ! a ! p ! ODir ++ slash.c2 ;
|
||||
c = Acc
|
||||
} ;
|
||||
|
||||
StrandQuestSlash ip slash =
|
||||
{s = \\t,a,b,q =>
|
||||
(mkQuestion (ss (ip.s ! Acc)) slash).s ! t ! a ! b ! q ++ slash.c2
|
||||
};
|
||||
|
||||
lincat
|
||||
VPI = {s : VPIForm => Agr => Str} ;
|
||||
[VPI] = {s1,s2 : VPIForm => Agr => Str} ;
|
||||
|
||||
lin
|
||||
BaseVPI = twoTable2 VPIForm Agr ;
|
||||
ConsVPI = consrTable2 VPIForm Agr comma ;
|
||||
|
||||
MkVPI vp = {
|
||||
s = \\v,a => vp.ad ++ vp.inf ++ vp.s2 ! a
|
||||
} ;
|
||||
ConjVPI = conjunctDistrTable2 VPIForm Agr ;
|
||||
ComplVPIVV vv vpi =
|
||||
insertObj (\\a => (if_then_Str vv.isAux [] "to") ++ vpi.s ! VPIInf ! a) (predVV vv) ;
|
||||
|
||||
UncNegCl t p cl = {
|
||||
s = t.s ++ p.s ++ cl.s ! t.t ! t.a ! unc p.p ! ODir
|
||||
} ;
|
||||
UncNegQCl t p cl = {
|
||||
s = \\q => t.s ++ p.s ++ cl.s ! t.t ! t.a ! unc p.p ! q
|
||||
} ;
|
||||
UncNegRCl t p cl = {
|
||||
s = \\r => t.s ++ p.s ++ cl.s ! t.t ! t.a ! unc p.p ! r ;
|
||||
c = cl.c
|
||||
} ;
|
||||
|
||||
UncNegImpSg p imp = {s = p.s ++ imp.s ! unc p.p ! ImpF Sg False} ;
|
||||
UncNegImpPl p imp = {s = p.s ++ imp.s ! unc p.p ! ImpF Pl False} ;
|
||||
|
||||
CompoundCN a b = {s = \\n,c => a.s ! Sg ! Nom ++ b.s ! n ! c ; g = b.g} ;
|
||||
|
||||
oper
|
||||
unc = contrNeg False ;
|
||||
|
||||
|
||||
lin
|
||||
that_RP =
|
||||
{ s = table {
|
||||
RC _ Gen => "whose" ;
|
||||
RC _ _ => "that" ;
|
||||
RPrep Neutr => "which" ;
|
||||
RPrep _ => "whom"
|
||||
} ;
|
||||
a = RNoAg
|
||||
} ;
|
||||
|
||||
each_Det = mkDeterminer Sg "each" ;
|
||||
|
||||
-- for VP conjunction
|
||||
|
||||
param
|
||||
VPIForm = VPIInf | VPIPPart ;
|
||||
|
||||
lincat
|
||||
VPS = {s : Agr => Str} ;
|
||||
[VPS] = {s1,s2 : Agr => Str} ;
|
||||
|
||||
lin
|
||||
BaseVPS = twoTable Agr ;
|
||||
ConsVPS = consrTable Agr comma ;
|
||||
|
||||
PredVPS np vpi = {s = np.s ! Nom ++ vpi.s ! np.a} ;
|
||||
|
||||
MkVPS t p vp = {
|
||||
s = \\a =>
|
||||
let
|
||||
verb = vp.s ! t.t ! t.a ! contrNeg True p.p ! ODir ! a ;
|
||||
verbf = verb.aux ++ verb.adv ++ verb.fin ++ verb.inf ;
|
||||
in t.s ++ p.s ++ vp.ad ++ verbf ++ vp.s2 ! a
|
||||
} ;
|
||||
|
||||
ConjVPS = conjunctDistrTable Agr ;
|
||||
|
||||
ICompAP ap = {s = "how" ++ ap.s ! agrP3 Sg} ; ---- IComp should have agr!
|
||||
|
||||
IAdvAdv adv = {s = "how" ++ adv.s} ;
|
||||
-}
|
||||
}
|
||||
20
lib/src/latvian/ExtraLavAbs.gf
Normal file
20
lib/src/latvian/ExtraLavAbs.gf
Normal file
@@ -0,0 +1,20 @@
|
||||
abstract ExtraLavAbs = Extra - [ProDrop] ** {
|
||||
{-
|
||||
-- uncontracted negations; contracted are the default
|
||||
fun
|
||||
UncNegCl : Temp -> Pol -> Cl -> S ;
|
||||
UncNegQCl : Temp -> Pol -> QCl -> QS ;
|
||||
UncNegRCl : Temp -> Pol -> RCl -> RS ;
|
||||
|
||||
UncNegImpSg : Pol -> Imp -> Utt; -- do not help yourself
|
||||
UncNegImpPl : Pol -> Imp -> Utt; -- do not help yourselves
|
||||
|
||||
-- freely compounded nouns
|
||||
|
||||
CompoundCN : CN -> CN -> CN ; -- rock album
|
||||
|
||||
that_RP : RP ; -- "that" as a relational pronoun (IdRP is "which" / "who")
|
||||
|
||||
each_Det : Det ;
|
||||
-}
|
||||
}
|
||||
22
lib/src/latvian/GrammarLav.gf
Normal file
22
lib/src/latvian/GrammarLav.gf
Normal file
@@ -0,0 +1,22 @@
|
||||
--# -path=.:../abstract:../common:prelude
|
||||
|
||||
concrete GrammarLav of Grammar =
|
||||
NounLav,
|
||||
VerbLav,
|
||||
AdjectiveLav,
|
||||
AdverbLav,
|
||||
NumeralLav,
|
||||
SentenceLav,
|
||||
QuestionLav,
|
||||
RelativeLav,
|
||||
ConjunctionLav,
|
||||
PhraseLav,
|
||||
TextX,
|
||||
StructuralLav,
|
||||
IdiomLav,
|
||||
TenseX
|
||||
** {
|
||||
|
||||
flags startcat = Phr ; unlexer = text ; lexer = text ;
|
||||
|
||||
} ;
|
||||
32
lib/src/latvian/IdiomLav.gf
Normal file
32
lib/src/latvian/IdiomLav.gf
Normal file
@@ -0,0 +1,32 @@
|
||||
concrete IdiomLav of Idiom = CatLav ** open Prelude, ResLav in {
|
||||
{-
|
||||
flags optimize=all_subs ;
|
||||
|
||||
lin
|
||||
ImpersCl vp = mkClause "it" (agrP3 Sg) vp ;
|
||||
GenericCl vp = mkClause "one" (agrP3 Sg) vp ;
|
||||
|
||||
CleftNP np rs = mkClause "it" (agrP3 Sg)
|
||||
(insertObj (\\_ => rs.s ! np.a)
|
||||
(insertObj (\\_ => np.s ! rs.c) (predAux auxBe))) ;
|
||||
|
||||
CleftAdv ad s = mkClause "it" (agrP3 Sg)
|
||||
(insertObj (\\_ => conjThat ++ s.s)
|
||||
(insertObj (\\_ => ad.s) (predAux auxBe))) ;
|
||||
|
||||
ExistNP np =
|
||||
mkClause "there" (agrP3 (fromAgr np.a).n)
|
||||
(insertObj (\\_ => np.s ! Acc) (predAux auxBe)) ;
|
||||
|
||||
ExistIP ip =
|
||||
mkQuestion (ss (ip.s ! Nom))
|
||||
(mkClause "there" (agrP3 ip.n) (predAux auxBe)) ;
|
||||
|
||||
ProgrVP vp = insertObj (\\a => vp.ad ++ vp.prp ++ vp.s2 ! a) (predAux auxBe) ;
|
||||
|
||||
ImpPl1 vp = {s = "let's" ++ infVP True vp (AgP1 Pl)} ;
|
||||
|
||||
ImpP3 np vp = {s = "let" ++ np.s ! Acc ++ infVP True vp np.a} ;
|
||||
-}
|
||||
}
|
||||
|
||||
182
lib/src/latvian/IrregLav.gf
Normal file
182
lib/src/latvian/IrregLav.gf
Normal file
@@ -0,0 +1,182 @@
|
||||
--# -path=.:prelude:../abstract:../common
|
||||
|
||||
concrete IrregLav of IrregLavAbs = CatLav ** open ParadigmsLav in {
|
||||
{-
|
||||
flags optimize=values ;
|
||||
|
||||
lin
|
||||
awake_V = irregV "awake" "awoke" "awoken" ;
|
||||
bear_V = irregV "bear" "bore" "born" ;
|
||||
beat_V = irregV "beat" "beat" "beat" ;
|
||||
become_V = irregV "become" "became" "become" ;
|
||||
begin_V = irregV "begin" "began" "begun" ;
|
||||
bend_V = irregV "bend" "bent" "bent" ;
|
||||
beset_V = irregV "beset" "beset" "beset" ;
|
||||
bet_V = irregDuplV "bet" "bet" "bet" ;
|
||||
bid_V = irregDuplV "bid" (variants {"bid" ; "bade"}) (variants {"bid" ; "bidden"}) ;
|
||||
bind_V = irregV "bind" "bound" "bound" ;
|
||||
bite_V = irregV "bite" "bit" "bitten" ;
|
||||
bleed_V = irregV "bleed" "bled" "bled" ;
|
||||
blow_V = irregV "blow" "blew" "blown" ;
|
||||
break_V = irregV "break" "broke" "broken" ;
|
||||
breed_V = irregV "breed" "bred" "bred" ;
|
||||
bring_V = irregV "bring" "brought" "brought" ;
|
||||
broadcast_V = irregV "broadcast" "broadcast" "broadcast" ;
|
||||
build_V = irregV "build" "built" "built" ;
|
||||
burn_V = irregV "burn" (variants {"burned" ; "burnt"}) (variants {"burned" ; "burnt"}) ;
|
||||
burst_V = irregV "burst" "burst" "burst" ;
|
||||
buy_V = irregV "buy" "bought" "bought" ;
|
||||
cast_V = irregV "cast" "cast" "cast" ;
|
||||
catch_V = irregV "catch" "caught" "caught" ;
|
||||
choose_V = irregV "choose" "chose" "chosen" ;
|
||||
cling_V = irregV "cling" "clung" "clung" ;
|
||||
come_V = irregV "come" "came" "come" ;
|
||||
cost_V = irregV "cost" "cost" "cost" ;
|
||||
creep_V = irregV "creep" "crept" "crept" ;
|
||||
cut_V = irregDuplV "cut" "cut" "cut" ;
|
||||
deal_V = irregV "deal" "dealt" "dealt" ;
|
||||
dig_V = irregDuplV "dig" "dug" "dug" ;
|
||||
dive_V = irregV "dive" (variants {"dived" ; "dove"}) "dived" ;
|
||||
do_V = mk5V "do" "does" "did" "done" "doing" ;
|
||||
draw_V = irregV "draw" "drew" "drawn" ;
|
||||
dream_V = irregV "dream" (variants {"dreamed" ; "dreamt"}) (variants {"dreamed" ; "dreamt"}) ;
|
||||
drive_V = irregV "drive" "drove" "driven" ;
|
||||
drink_V = irregV "drink" "drank" "drunk" ;
|
||||
eat_V = irregV "eat" "ate" "eaten" ;
|
||||
fall_V = irregV "fall" "fell" "fallen" ;
|
||||
feed_V = irregV "feed" "fed" "fed" ;
|
||||
feel_V = irregV "feel" "felt" "felt" ;
|
||||
fight_V = irregV "fight" "fought" "fought" ;
|
||||
find_V = irregV "find" "found" "found" ;
|
||||
fit_V = irregDuplV "fit" "fit" "fit" ;
|
||||
flee_V = irregV "flee" "fled" "fled" ;
|
||||
fling_V = irregV "fling" "flung" "flung" ;
|
||||
fly_V = irregV "fly" "flew" "flown" ;
|
||||
forbid_V = irregDuplV "forbid" "forbade" "forbidden" ;
|
||||
forget_V = irregDuplV "forget" "forgot" "forgotten" ;
|
||||
forgive_V = irregV "forgive" "forgave" "forgiven" ;
|
||||
forsake_V = irregV "forsake" "forsook" "forsaken" ;
|
||||
freeze_V = irregV "freeze" "froze" "frozen" ;
|
||||
get_V = irregDuplV "get" "got" "gotten" ;
|
||||
give_V = irregV "give" "gave" "given" ;
|
||||
go_V = mk5V "go" "goes" "went" "gone" "going" ;
|
||||
grind_V = irregV "grind" "ground" "ground" ;
|
||||
grow_V = irregV "grow" "grew" "grown" ;
|
||||
hang_V = irregV "hang" "hung" "hung" ;
|
||||
have_V = mk5V "have" "has" "had" "had" "having" ;
|
||||
hear_V = irregV "hear" "heard" "heard" ;
|
||||
hide_V = irregV "hide" "hid" "hidden" ;
|
||||
hit_V = irregDuplV "hit" "hit" "hit" ;
|
||||
hold_V = irregV "hold" "held" "held" ;
|
||||
hurt_V = irregV "hurt" "hurt" "hurt" ;
|
||||
keep_V = irregV "keep" "kept" "kept" ;
|
||||
kneel_V = irregV "kneel" "knelt" "knelt" ;
|
||||
knit_V = irregDuplV "knit" "knit" "knit" ;
|
||||
know_V = irregV "know" "knew" "know" ;
|
||||
lay_V = irregV "lay" "laid" "laid" ;
|
||||
lead_V = irregV "lead" "led" "led" ;
|
||||
leap_V = irregV "leap" (variants {"leaped" ; "lept"}) (variants {"leaped" ; "lept"}) ;
|
||||
learn_V = irregV "learn" (variants {"learned" ; "learnt"}) (variants {"learned" ; "learnt"}) ;
|
||||
leave_V = irregV "leave" "left" "left" ;
|
||||
lend_V = irregV "lend" "lent" "lent" ;
|
||||
let_V = irregDuplV "let" "let" "let" ;
|
||||
lie_V = irregV "lie" "lay" "lain" ;
|
||||
light_V = irregV "light" (variants {"lighted" ; "lit"}) "lighted" ;
|
||||
lose_V = irregV "lose" "lost" "lost" ;
|
||||
make_V = irregV "make" "made" "made" ;
|
||||
mean_V = irregV "mean" "meant" "meant" ;
|
||||
meet_V = irregV "meet" "met" "met" ;
|
||||
misspell_V = irregV "misspell" (variants {"misspelled" ; "misspelt"}) (variants {"misspelled" ; "misspelt"}) ;
|
||||
mistake_V = irregV "mistake" "mistook" "mistaken" ;
|
||||
mow_V = irregV "mow" "mowed" (variants {"mowed" ; "mown"}) ;
|
||||
overcome_V = irregV "overcome" "overcame" "overcome" ;
|
||||
overdo_V = mk5V "overdo" "overdoes" "overdid" "overdone" "overdoing" ;
|
||||
overtake_V = irregV "overtake" "overtook" "overtaken" ;
|
||||
overthrow_V = irregV "overthrow" "overthrew" "overthrown" ;
|
||||
pay_V = irregV "pay" "paid" "paid" ;
|
||||
plead_V = irregV "plead" "pled" "pled" ;
|
||||
prove_V = irregV "prove" "proved" (variants {"proved" ; "proven"}) ;
|
||||
put_V = irregDuplV "put" "put" "put" ;
|
||||
quit_V = irregDuplV "quit" "quit" "quit" ;
|
||||
read_V = irregV "read" "read" "read" ;
|
||||
rid_V = irregDuplV "rid" "rid" "rid" ;
|
||||
ride_V = irregV "ride" "rode" "ridden" ;
|
||||
ring_V = irregV "ring" "rang" "rung" ;
|
||||
rise_V = irregV "rise" "rose" "risen" ;
|
||||
run_V = irregDuplV "run" "ran" "run" ;
|
||||
saw_V = irregV "saw" "sawed" (variants {"sawed" ; "sawn"}) ;
|
||||
say_V = irregV "say" "said" "said" ;
|
||||
see_V = irregV "see" "saw" "seen" ;
|
||||
seek_V = irregV "seek" "sought" "sought" ;
|
||||
sell_V = irregV "sell" "sold" "sold" ;
|
||||
send_V = irregV "send" "sent" "sent" ;
|
||||
set_V = irregDuplV "set" "set" "set" ;
|
||||
sew_V = irregV "sew" "sewed" (variants {"sewed" ; "sewn"}) ;
|
||||
shake_V = irregV "shake" "shook" "shaken" ;
|
||||
shave_V = irregV "shave" "shaved" (variants {"shaved" ; "shaven"}) ;
|
||||
shear_V = irregV "shear" "shore" "shorn" ;
|
||||
shed_V = irregDuplV "shed" "shed" "shed" ;
|
||||
shine_V = irregV "shine" "shone" "shone" ;
|
||||
shoe_V = irregV "shoe" "shoed" (variants {"shoed" ; "shod"}) ;
|
||||
shoot_V = irregV "shoot" "shot" "shot" ;
|
||||
show_V = irregV "show" "showed" (variants {"showed" ; "shown"}) ;
|
||||
shrink_V = irregV "shrink" "shrank" "shrunk" ;
|
||||
shut_V = irregDuplV "shut" "shut" "shut" ;
|
||||
sing_V = irregV "sing" "sang" "sung" ;
|
||||
sink_V = irregV "sink" "sank" "sunk" ;
|
||||
sit_V = irregDuplV "sit" "sat" "sat" ;
|
||||
sleep_V = irregV "sleep" "slept" "slept" ;
|
||||
slay_V = irregV "slay" "slew" "slain" ;
|
||||
slide_V = irregV "slide" "slid" "slid" ;
|
||||
sling_V = irregV "sling" "slung" "slung" ;
|
||||
slit_V = irregDuplV "slit" "slit" "slit" ;
|
||||
smite_V = irregV "smite" "smote" "smitten" ;
|
||||
sow_V = irregV "sow" "sowed" (variants {"sowed" ; "sown"}) ;
|
||||
speak_V = irregV "speak" "spoke" "spoken" ;
|
||||
speed_V = irregV "speed" "sped" "sped" ;
|
||||
spend_V = irregV "spend" "spent" "spent" ;
|
||||
spill_V = irregV "spill" (variants {"spilled" ; "spilt"}) (variants {"spilled" ; "spilt"}) ;
|
||||
spin_V = irregDuplV "spin" "spun" "spun" ;
|
||||
spit_V = irregDuplV "spit" (variants {"spit" ; "spat"}) "spit" ;
|
||||
split_V = irregDuplV "split" "split" "split" ;
|
||||
spread_V = irregV "spread" "spread" "spread" ;
|
||||
spring_V = irregV "spring" (variants {"sprang" ; "sprung"}) "sprung" ;
|
||||
stand_V = irregV "stand" "stood" "stood" ;
|
||||
steal_V = irregV "steal" "stole" "stolen" ;
|
||||
stick_V = irregV "stick" "stuck" "stuck" ;
|
||||
sting_V = irregV "sting" "stung" "stung" ;
|
||||
stink_V = irregV "stink" "stank" "stunk" ;
|
||||
stride_V = irregV "stride" "strod" "stridden" ;
|
||||
strike_V = irregV "strike" "struck" "struck" ;
|
||||
string_V = irregV "string" "strung" "strung" ;
|
||||
strive_V = irregV "strive" "strove" "striven" ;
|
||||
swear_V = irregV "swear" "swore" "sworn" ;
|
||||
sweep_V = irregV "sweep" "swept" "swept" ;
|
||||
swell_V = irregV "swell" "swelled" (variants {"swelled" ; "swollen"}) ;
|
||||
swim_V = irregDuplV "swim" "swam" "swum" ;
|
||||
swing_V = irregV "swing" "swung" "swung" ;
|
||||
take_V = irregV "take" "took" "taken" ;
|
||||
teach_V = irregV "teach" "taught" "taught" ;
|
||||
tear_V = irregV "tear" "tore" "torn" ;
|
||||
tell_V = irregV "tell" "told" "told" ;
|
||||
think_V = irregV "think" "thought" "thought" ;
|
||||
thrive_V = irregV "thrive" (variants {"thrived" ; "throve"}) "thrived" ;
|
||||
throw_V = irregV "throw" "threw" "thrown" ;
|
||||
thrust_V = irregV "thrust" "thrust" "thrust" ;
|
||||
tread_V = irregV "tread" "trod" "trodden" ;
|
||||
understand_V = irregV "understand" "understood" "understood" ;
|
||||
uphold_V = irregV "uphold" "upheld" "upheld" ;
|
||||
upset_V = irregDuplV "upset" "upset" "upset" ;
|
||||
wake_V = irregV "wake" "woke" "woken" ;
|
||||
wear_V = irregV "wear" "wore" "worn" ;
|
||||
weave_V = irregV "weave" (variants {"weaved" ; "wove"}) (variants {"weaved" ; "woven"}) ;
|
||||
wed_V = irregDuplV "wed" "wed" "wed" ;
|
||||
weep_V = irregV "weep" "wept" "wept" ;
|
||||
wind_V = irregV "wind" "wound" "wound" ;
|
||||
win_V = irregDuplV "win" "won" "won" ;
|
||||
withhold_V = irregV "withhold" "withheld" "withheld" ;
|
||||
withstand_V = irregV "withstand" "withstood" "withstood" ;
|
||||
wring_V = irregV "wring" "wrung" "wrung" ;
|
||||
write_V = irregV "write" "wrote" "written" ;
|
||||
-}
|
||||
}
|
||||
178
lib/src/latvian/IrregLavAbs.gf
Normal file
178
lib/src/latvian/IrregLavAbs.gf
Normal file
@@ -0,0 +1,178 @@
|
||||
abstract IrregLavAbs = Cat ** {
|
||||
{-
|
||||
fun
|
||||
awake_V : V ;
|
||||
bear_V : V ;
|
||||
beat_V : V ;
|
||||
become_V : V ;
|
||||
begin_V : V ;
|
||||
bend_V : V ;
|
||||
beset_V : V ;
|
||||
bet_V : V ;
|
||||
bid_V : V ;
|
||||
bind_V : V ;
|
||||
bite_V : V ;
|
||||
bleed_V : V ;
|
||||
blow_V : V ;
|
||||
break_V : V ;
|
||||
breed_V : V ;
|
||||
bring_V : V ;
|
||||
broadcast_V : V ;
|
||||
build_V : V ;
|
||||
burn_V : V ;
|
||||
burst_V : V ;
|
||||
buy_V : V ;
|
||||
cast_V : V ;
|
||||
catch_V : V ;
|
||||
choose_V : V ;
|
||||
cling_V : V ;
|
||||
come_V : V ;
|
||||
cost_V : V ;
|
||||
creep_V : V ;
|
||||
cut_V : V ;
|
||||
deal_V : V ;
|
||||
dig_V : V ;
|
||||
dive_V : V ;
|
||||
do_V : V ;
|
||||
draw_V : V ;
|
||||
dream_V : V ;
|
||||
drive_V : V ;
|
||||
drink_V : V ;
|
||||
eat_V : V ;
|
||||
fall_V : V ;
|
||||
feed_V : V ;
|
||||
feel_V : V ;
|
||||
fight_V : V ;
|
||||
find_V : V ;
|
||||
fit_V : V ;
|
||||
flee_V : V ;
|
||||
fling_V : V ;
|
||||
fly_V : V ;
|
||||
forbid_V : V ;
|
||||
forget_V : V ;
|
||||
forgive_V : V ;
|
||||
forsake_V : V ;
|
||||
freeze_V : V ;
|
||||
get_V : V ;
|
||||
give_V : V ;
|
||||
go_V : V ;
|
||||
grind_V : V ;
|
||||
grow_V : V ;
|
||||
hang_V : V ;
|
||||
have_V : V ;
|
||||
hear_V : V ;
|
||||
hide_V : V ;
|
||||
hit_V : V ;
|
||||
hold_V : V ;
|
||||
hurt_V : V ;
|
||||
keep_V : V ;
|
||||
kneel_V : V ;
|
||||
knit_V : V ;
|
||||
know_V : V ;
|
||||
lay_V : V ;
|
||||
lead_V : V ;
|
||||
leap_V : V ;
|
||||
learn_V : V ;
|
||||
leave_V : V ;
|
||||
lend_V : V ;
|
||||
let_V : V ;
|
||||
lie_V : V ;
|
||||
light_V : V ;
|
||||
lose_V : V ;
|
||||
make_V : V ;
|
||||
mean_V : V ;
|
||||
meet_V : V ;
|
||||
misspell_V : V ;
|
||||
mistake_V : V ;
|
||||
mow_V : V ;
|
||||
overcome_V : V ;
|
||||
overdo_V : V ;
|
||||
overtake_V : V ;
|
||||
overthrow_V : V ;
|
||||
pay_V : V ;
|
||||
plead_V : V ;
|
||||
prove_V : V ;
|
||||
put_V : V ;
|
||||
quit_V : V ;
|
||||
read_V : V ;
|
||||
rid_V : V ;
|
||||
ride_V : V ;
|
||||
ring_V : V ;
|
||||
rise_V : V ;
|
||||
run_V : V ;
|
||||
saw_V : V ;
|
||||
say_V : V ;
|
||||
see_V : V ;
|
||||
seek_V : V ;
|
||||
sell_V : V ;
|
||||
send_V : V ;
|
||||
set_V : V ;
|
||||
sew_V : V ;
|
||||
shake_V : V ;
|
||||
shave_V : V ;
|
||||
shear_V : V ;
|
||||
shed_V : V ;
|
||||
shine_V : V ;
|
||||
shoe_V : V ;
|
||||
shoot_V : V ;
|
||||
show_V : V ;
|
||||
shrink_V : V ;
|
||||
shut_V : V ;
|
||||
sing_V : V ;
|
||||
sink_V : V ;
|
||||
sit_V : V ;
|
||||
sleep_V : V ;
|
||||
slay_V : V ;
|
||||
slide_V : V ;
|
||||
sling_V : V ;
|
||||
slit_V : V ;
|
||||
smite_V : V ;
|
||||
sow_V : V ;
|
||||
speak_V : V ;
|
||||
speed_V : V ;
|
||||
spend_V : V ;
|
||||
spill_V : V ;
|
||||
spin_V : V ;
|
||||
spit_V : V ;
|
||||
split_V : V ;
|
||||
spread_V : V ;
|
||||
spring_V : V ;
|
||||
stand_V : V ;
|
||||
steal_V : V ;
|
||||
stick_V : V ;
|
||||
sting_V : V ;
|
||||
stink_V : V ;
|
||||
stride_V : V ;
|
||||
strike_V : V ;
|
||||
string_V : V ;
|
||||
strive_V : V ;
|
||||
swear_V : V ;
|
||||
sweep_V : V ;
|
||||
swell_V : V ;
|
||||
swim_V : V ;
|
||||
swing_V : V ;
|
||||
take_V : V ;
|
||||
teach_V : V ;
|
||||
tear_V : V ;
|
||||
tell_V : V ;
|
||||
think_V : V ;
|
||||
thrive_V : V ;
|
||||
throw_V : V ;
|
||||
thrust_V : V ;
|
||||
tread_V : V ;
|
||||
understand_V : V ;
|
||||
uphold_V : V ;
|
||||
upset_V : V ;
|
||||
wake_V : V ;
|
||||
wear_V : V ;
|
||||
weave_V : V ;
|
||||
wed_V : V ;
|
||||
weep_V : V ;
|
||||
wind_V : V ;
|
||||
win_V : V ;
|
||||
withhold_V : V ;
|
||||
withstand_V : V ;
|
||||
wring_V : V ;
|
||||
write_V : V ;
|
||||
-}
|
||||
}
|
||||
10
lib/src/latvian/LangLav.gf
Normal file
10
lib/src/latvian/LangLav.gf
Normal file
@@ -0,0 +1,10 @@
|
||||
--# -path=.:../abstract:../common:../prelude
|
||||
|
||||
concrete LangLav of Lang =
|
||||
GrammarLav,
|
||||
LexiconLav
|
||||
** {
|
||||
|
||||
flags startcat = Phr ; unlexer = text ; lexer = text ;
|
||||
|
||||
} ;
|
||||
388
lib/src/latvian/LexiconLav.gf
Normal file
388
lib/src/latvian/LexiconLav.gf
Normal file
@@ -0,0 +1,388 @@
|
||||
--# -path=.:prelude
|
||||
|
||||
concrete LexiconLav of Lexicon = CatLav **
|
||||
open ParadigmsLav, IrregLav, Prelude in {
|
||||
|
||||
flags
|
||||
optimize=values ;
|
||||
coding = utf8 ;
|
||||
|
||||
lin
|
||||
airplane_N = mkN "lidmašīna" ;
|
||||
come_V = mkV "nākt" "nāku" "nācu" ;
|
||||
bad_A = mkA "slikts" ;
|
||||
|
||||
walk_V = mkV "doties" "dodos" "devos" ;
|
||||
-- please_V2 = mkV "priecēt" second_conjugation ;
|
||||
love_V2 = mkV "mīlēt" third_conjugation ;
|
||||
-- say_V = mkV "sacīt" third_conjugation ;
|
||||
-- be_V = mkV "būt" ;
|
||||
|
||||
{-
|
||||
answer_V2S = mkV2S (mkV "answer" "answered") toP ;
|
||||
apartment_N = regN "apartment" ;
|
||||
apple_N = regN "apple" ;
|
||||
art_N = regN "art" ;
|
||||
ask_V2Q = mkV2Q (regV "ask") noPrep ;
|
||||
baby_N = regN "baby" ;
|
||||
bad_A = mkADeg "bad" "worse" "worst" "badly" ;
|
||||
bank_N = regN "bank" ;
|
||||
beautiful_A = compoundADeg (regA "beautiful") ;
|
||||
become_VA = mkVA (irregV "become" "became" "become") ;
|
||||
beer_N = regN "beer" ;
|
||||
beg_V2V = mkV2V (regDuplV "beg") noPrep toP ;
|
||||
big_A = duplADeg "big" ;
|
||||
bike_N = regN "bike" ;
|
||||
bird_N = regN "bird" ;
|
||||
black_A = regADeg "black" ;
|
||||
blue_A = regADeg "blue" ;
|
||||
boat_N = regN "boat" ;
|
||||
book_N = regN "book" ;
|
||||
boot_N = regN "boot" ;
|
||||
boss_N = mkN human (regN "boss") ;
|
||||
boy_N = mkN masculine (regN "boy") ;
|
||||
bread_N = regN "bread" ;
|
||||
break_V2 = dirV2 (irregV "break" "broke" "broken") ;
|
||||
broad_A = regADeg "broad" ;
|
||||
brother_N2 = mkN2 (mkN masculine (mkN "brother")) (mkPrep "of") ;
|
||||
brown_A = regADeg "brown" ;
|
||||
butter_N = regN "butter" ;
|
||||
buy_V2 = dirV2 (irregV "buy" "bought" "bought") ;
|
||||
camera_N = regN "camera" ;
|
||||
cap_N = regN "cap" ;
|
||||
car_N = regN "car" ;
|
||||
carpet_N = regN "carpet" ;
|
||||
cat_N = regN "cat" ;
|
||||
ceiling_N = regN "ceiling" ;
|
||||
chair_N = regN "chair" ;
|
||||
cheese_N = regN "cheese" ;
|
||||
child_N = mk2N "child" "children" ;
|
||||
church_N = regN "church" ;
|
||||
city_N = regN "city" ;
|
||||
clean_A = regADeg "clean" ;
|
||||
clever_A = mkA "clever" "cleverer" ;
|
||||
close_V2 = dirV2 (regV "close") ;
|
||||
coat_N = regN "coat" ;
|
||||
cold_A = regADeg "cold" ;
|
||||
come_V = (irregV "come" "came" "come") ;
|
||||
computer_N = regN "computer" ;
|
||||
country_N = regN "country" ;
|
||||
cousin_N = mkN human (regN "cousin") ;
|
||||
cow_N = regN "cow" ;
|
||||
die_V = (regV "die") ;
|
||||
dirty_A = regADeg "dirty" ;
|
||||
distance_N3 = mkN3 (regN "distance") fromP toP ;
|
||||
doctor_N = mkN human (regN "doctor") ;
|
||||
dog_N = regN "dog" ;
|
||||
door_N = regN "door" ;
|
||||
drink_V2 = dirV2 (irregV "drink" "drank" "drunk") ;
|
||||
easy_A2V = mkA2V (regA "easy") forP ;
|
||||
eat_V2 = dirV2 (irregV "eat" "ate" "eaten") ;
|
||||
empty_A = regADeg "empty" ;
|
||||
enemy_N = regN "enemy" ;
|
||||
factory_N = regN "factory" ;
|
||||
father_N2 = mkN2 (mkN masculine (mkN "father")) (mkPrep "of") ;
|
||||
fear_VS = mkVS (regV "fear") ;
|
||||
find_V2 = dirV2 (irregV "find" "found" "found") ;
|
||||
fish_N = mk2N "fish" "fish" ;
|
||||
floor_N = regN "floor" ;
|
||||
forget_V2 = dirV2 (irregDuplV "forget" "forgot" "forgotten") ;
|
||||
fridge_N = regN "fridge" ;
|
||||
friend_N = mkN human (regN "friend") ;
|
||||
fruit_N = regN "fruit" ;
|
||||
fun_AV = mkAV (regA "fun") ;
|
||||
garden_N = regN "garden" ;
|
||||
girl_N = mkN feminine (regN "girl") ;
|
||||
glove_N = regN "glove" ;
|
||||
gold_N = regN "gold" ;
|
||||
good_A = mkADeg "good" "better" "best" "well" ;
|
||||
go_V = mk5V "go" "goes" "went" "gone" "going" ;
|
||||
green_A = regADeg "green" ;
|
||||
harbour_N = regN "harbour" ;
|
||||
hate_V2 = dirV2 (regV "hate") ;
|
||||
hat_N = regN "hat" ;
|
||||
hear_V2 = dirV2 (irregV "hear" "heard" "heard") ;
|
||||
hill_N = regN "hill" ;
|
||||
hope_VS = mkVS (regV "hope") ;
|
||||
horse_N = regN "horse" ;
|
||||
hot_A = duplADeg "hot" ;
|
||||
house_N = regN "house" ;
|
||||
important_A = compoundADeg (regA "important") ;
|
||||
industry_N = regN "industry" ;
|
||||
iron_N = regN "iron" ;
|
||||
king_N = mkN masculine (regN "king") ;
|
||||
know_V2 = dirV2 (irregV "know" "knew" "known") ;
|
||||
know_VS = mkVS (irregV "know" "knew" "known") ;
|
||||
lake_N = regN "lake" ;
|
||||
lamp_N = regN "lamp" ;
|
||||
learn_V2 = dirV2 (regV "learn") ;
|
||||
leather_N = regN "leather" ;
|
||||
leave_V2 = dirV2 (irregV "leave" "left" "left") ;
|
||||
like_V2 = dirV2 (regV "like") ;
|
||||
listen_V2 = prepV2 (regV "listen") toP ;
|
||||
live_V = (regV "live") ;
|
||||
long_A = regADeg "long" ;
|
||||
lose_V2 = dirV2 (irregV "lose" "lost" "lost") ;
|
||||
love_N = regN "love" ;
|
||||
love_V2 = dirV2 (regV "love") ;
|
||||
man_N = mkN masculine (mk2N "man" "men") ;
|
||||
married_A2 = mkA2 (regA "married") toP ;
|
||||
meat_N = regN "meat" ;
|
||||
milk_N = regN "milk" ;
|
||||
moon_N = regN "moon" ;
|
||||
mother_N2 = mkN2 (mkN feminine (mkN "mother")) (mkPrep "of") ;
|
||||
mountain_N = regN "mountain" ;
|
||||
music_N = regN "music" ;
|
||||
narrow_A = regADeg "narrow" ;
|
||||
new_A = regADeg "new" ;
|
||||
newspaper_N = regN "newspaper" ;
|
||||
oil_N = regN "oil" ;
|
||||
old_A = regADeg "old" ;
|
||||
open_V2 = dirV2 (regV "open") ;
|
||||
paint_V2A = mkV2A (regV "paint") noPrep ;
|
||||
paper_N = regN "paper" ;
|
||||
paris_PN = mkPN (mkN nonhuman (mkN "Paris")) ;
|
||||
peace_N = regN "peace" ;
|
||||
pen_N = regN "pen" ;
|
||||
planet_N = regN "planet" ;
|
||||
plastic_N = regN "plastic" ;
|
||||
play_V2 = dirV2 (regV "play") ;
|
||||
policeman_N = mkN masculine (mkN "policeman" "policemen") ;
|
||||
priest_N = mkN human (regN "priest") ;
|
||||
probable_AS = mkAS (regA "probable") ;
|
||||
queen_N = mkN feminine (regN "queen") ;
|
||||
radio_N = regN "radio" ;
|
||||
rain_V0 = mkV0 (regV "rain") ;
|
||||
read_V2 = dirV2 (irregV "read" "read" "read") ;
|
||||
red_A = duplADeg "red" ;
|
||||
religion_N = regN "religion" ;
|
||||
restaurant_N = regN "restaurant" ;
|
||||
river_N = regN "river" ;
|
||||
rock_N = regN "rock" ;
|
||||
roof_N = regN "roof" ;
|
||||
rubber_N = regN "rubber" ;
|
||||
run_V = (irregDuplV "run" "ran" "run") ;
|
||||
say_VS = mkVS (irregV "say" "said" "said") ;
|
||||
school_N = regN "school" ;
|
||||
science_N = regN "science" ;
|
||||
sea_N = regN "sea" ;
|
||||
seek_V2 = dirV2 (irregV "seek" "sought" "sought") ;
|
||||
see_V2 = dirV2 (irregV "see" "saw" "seen") ;
|
||||
sell_V3 = dirV3 (irregV "sell" "sold" "sold") toP ;
|
||||
send_V3 = dirV3 (irregV "send" "sent" "sent") toP ;
|
||||
sheep_N = mk2N "sheep" "sheep" ;
|
||||
ship_N = regN "ship" ;
|
||||
shirt_N = regN "shirt" ;
|
||||
shoe_N = regN "shoe" ;
|
||||
shop_N = regN "shop" ;
|
||||
short_A = regADeg "short" ;
|
||||
silver_N = regN "silver" ;
|
||||
sister_N = mkN feminine (mkN "sister") ;
|
||||
sleep_V = (irregV "sleep" "slept" "slept") ;
|
||||
small_A = regADeg "small" ;
|
||||
snake_N = regN "snake" ;
|
||||
sock_N = regN "sock" ;
|
||||
speak_V2 = dirV2 (irregV "speak" "spoke" "spoken") ;
|
||||
star_N = regN "star" ;
|
||||
steel_N = regN "steel" ;
|
||||
stone_N = regN "stone" ;
|
||||
stove_N = regN "stove" ;
|
||||
student_N = mkN human (regN "student") ;
|
||||
stupid_A = mkA "stupid" ;
|
||||
sun_N = regN "sun" ;
|
||||
switch8off_V2 = dirV2 (partV (regV "switch") "off") ;
|
||||
switch8on_V2 = dirV2 (partV (regV "switch") "on") ;
|
||||
table_N = regN "table" ;
|
||||
talk_V3 = mkV3 (regV "talk") toP aboutP ;
|
||||
teacher_N = mkN human (regN "teacher") ;
|
||||
teach_V2 = dirV2 (irregV "teach" "taught" "taught") ;
|
||||
television_N = regN "television" ;
|
||||
thick_A = regADeg "thick" ;
|
||||
thin_A = duplADeg "thin" ;
|
||||
train_N = regN "train" ;
|
||||
travel_V = (regDuplV "travel") ;
|
||||
tree_N = regN "tree" ;
|
||||
---- trousers_N = regN "trousers" ;
|
||||
ugly_A = mkA "ugly" ;
|
||||
understand_V2 = dirV2 (irregV "understand" "understood" "understood") ;
|
||||
university_N = regN "university" ;
|
||||
village_N = regN "village" ;
|
||||
wait_V2 = prepV2 (regV "wait") forP ;
|
||||
walk_V = (regV "walk") ;
|
||||
warm_A = regADeg "warm" ;
|
||||
war_N = regN "war" ;
|
||||
watch_V2 = dirV2 (regV "watch") ;
|
||||
water_N = regN "water" ;
|
||||
white_A = mkA "white" ;
|
||||
window_N = regN "window" ;
|
||||
wine_N = regN "wine" ;
|
||||
win_V2 = dirV2 (irregDuplV "win" "won" "won") ;
|
||||
woman_N = mkN feminine (mk2N "woman" "women") ;
|
||||
wonder_VQ = mkVQ (mkV "wonder" "wondered") ;
|
||||
wood_N = regN "wood" ;
|
||||
write_V2 = dirV2 (irregV "write" "wrote" "written") ;
|
||||
yellow_A = mkA "yellow" ;
|
||||
young_A = regADeg "young" ;
|
||||
|
||||
do_V2 = dirV2 (mk5V "do" "does" "did" "done" "doing") ;
|
||||
now_Adv = mkAdv "now" ;
|
||||
already_Adv = mkAdv "already" ;
|
||||
song_N = regN "song" ;
|
||||
add_V3 = dirV3 (regV "add") toP ;
|
||||
number_N = regN "number" ;
|
||||
put_V2 = prepV2 (irregDuplV "put" "put" "put") noPrep ;
|
||||
stop_V = regDuplV "stop" ;
|
||||
jump_V = regV "jump" ;
|
||||
|
||||
left_Ord = mkOrd "left" ;
|
||||
right_Ord = mkOrd "right" ;
|
||||
far_Adv = mkAdv "far" ;
|
||||
correct_A = (regA "correct") ;
|
||||
dry_A = regA "dry" ;
|
||||
dull_A = regA "dull" ;
|
||||
full_A = regA "full" ;
|
||||
heavy_A = regA "heavy" ;
|
||||
near_A = regA "near" ;
|
||||
rotten_A = (regA "rotten") ;
|
||||
round_A = regA "round" ;
|
||||
sharp_A = regA "sharp" ;
|
||||
smooth_A = regA "smooth" ;
|
||||
straight_A = regA "straight" ;
|
||||
wet_A = regA "wet" ; ----
|
||||
wide_A = regA "wide" ;
|
||||
animal_N = regN "animal" ;
|
||||
ashes_N = regN "ash" ; -- FIXME: plural only?
|
||||
back_N = regN "back" ;
|
||||
bark_N = regN "bark" ;
|
||||
belly_N = regN "belly" ;
|
||||
blood_N = regN "blood" ;
|
||||
bone_N = regN "bone" ;
|
||||
breast_N = regN "breast" ;
|
||||
cloud_N = regN "cloud" ;
|
||||
day_N = regN "day" ;
|
||||
dust_N = regN "dust" ;
|
||||
ear_N = regN "ear" ;
|
||||
earth_N = regN "earth" ;
|
||||
egg_N = regN "egg" ;
|
||||
eye_N = regN "eye" ;
|
||||
fat_N = regN "fat" ;
|
||||
feather_N = regN "feather" ;
|
||||
fingernail_N = regN "fingernail" ;
|
||||
fire_N = regN "fire" ;
|
||||
flower_N = regN "flower" ;
|
||||
fog_N = regN "fog" ;
|
||||
foot_N = mk2N "foot" "feet" ;
|
||||
forest_N = regN "forest" ;
|
||||
grass_N = regN "grass" ;
|
||||
guts_N = regN "gut" ; -- FIXME: no singular
|
||||
hair_N = regN "hair" ;
|
||||
hand_N = regN "hand" ;
|
||||
head_N = regN "head" ;
|
||||
heart_N = regN "heart" ;
|
||||
horn_N = regN "horn" ;
|
||||
husband_N = mkN masculine (regN "husband") ;
|
||||
ice_N = regN "ice" ;
|
||||
knee_N = regN "knee" ;
|
||||
leaf_N = mk2N "leaf" "leaves" ;
|
||||
leg_N = regN "leg" ;
|
||||
liver_N = regN "liver" ;
|
||||
louse_N = mk2N "louse" "lice" ;
|
||||
mouth_N = regN "mouth" ;
|
||||
name_N = regN "name" ;
|
||||
neck_N = regN "neck" ;
|
||||
night_N = regN "night" ;
|
||||
nose_N = regN "nose" ;
|
||||
person_N = mkN human (regN "person") ;
|
||||
rain_N = regN "rain" ;
|
||||
road_N = regN "road" ;
|
||||
root_N = regN "root" ;
|
||||
rope_N = regN "rope" ;
|
||||
salt_N = regN "salt" ;
|
||||
sand_N = regN "sand" ;
|
||||
seed_N = regN "seed" ;
|
||||
skin_N = regN "skin" ;
|
||||
sky_N = regN "sky" ;
|
||||
smoke_N = regN "smoke" ;
|
||||
snow_N = regN "snow" ;
|
||||
stick_N = regN "stick" ;
|
||||
tail_N = regN "tail" ;
|
||||
tongue_N = regN "tongue" ;
|
||||
tooth_N = mk2N "tooth" "teeth" ;
|
||||
wife_N = mkN feminine (mk2N "wife" "wives") ;
|
||||
wind_N = regN "wind" ;
|
||||
wing_N = regN "wing" ;
|
||||
worm_N = regN "worm" ;
|
||||
year_N = regN "year" ;
|
||||
blow_V = IrregEng.blow_V ;
|
||||
breathe_V = dirV2 (regV "breathe") ;
|
||||
burn_V = IrregEng.burn_V ;
|
||||
dig_V = IrregEng.dig_V ;
|
||||
fall_V = IrregEng.fall_V ;
|
||||
float_V = regV "float" ;
|
||||
flow_V = regV "flow" ;
|
||||
fly_V = IrregEng.fly_V ;
|
||||
freeze_V = IrregEng.freeze_V ;
|
||||
give_V3 = dirV3 give_V toP ;
|
||||
laugh_V = regV "laugh" ;
|
||||
lie_V = IrregEng.lie_V ;
|
||||
play_V = regV "play" ;
|
||||
sew_V = IrregEng.sew_V ;
|
||||
sing_V = IrregEng.sing_V ;
|
||||
sit_V = IrregEng.sit_V ;
|
||||
smell_V = regV "smell" ;
|
||||
spit_V = IrregEng.spit_V ;
|
||||
stand_V = IrregEng.stand_V ;
|
||||
swell_V = IrregEng.swell_V ;
|
||||
swim_V = IrregEng.swim_V ;
|
||||
think_V = IrregEng.think_V ;
|
||||
turn_V = regV "turn" ;
|
||||
vomit_V = mkV "vomit" "vomited" ;
|
||||
|
||||
bite_V2 = dirV2 IrregEng.bite_V ;
|
||||
count_V2 = dirV2 (regV "count") ;
|
||||
cut_V2 = dirV2 IrregEng.cut_V ;
|
||||
fear_V2 = dirV2 (regV "fear") ;
|
||||
fight_V2 = dirV2 fight_V ;
|
||||
hit_V2 = dirV2 hit_V ;
|
||||
hold_V2 = dirV2 hold_V ;
|
||||
hunt_V2 = dirV2 (regV "hunt") ;
|
||||
kill_V2 = dirV2 (regV "kill") ;
|
||||
pull_V2 = dirV2 (regV "pull") ;
|
||||
push_V2 = dirV2 (regV "push") ;
|
||||
rub_V2 = dirV2 (regDuplV "rub") ;
|
||||
scratch_V2 = dirV2 (regV "scratch") ;
|
||||
split_V2 = dirV2 split_V ;
|
||||
squeeze_V2 = dirV2 (regV "squeeze") ;
|
||||
stab_V2 = dirV2 (regDuplV "stab") ;
|
||||
suck_V2 = dirV2 (regV "suck") ;
|
||||
throw_V2 = dirV2 throw_V ;
|
||||
tie_V2 = dirV2 (regV "tie") ;
|
||||
wash_V2 = dirV2 (regV "wash") ;
|
||||
wipe_V2 = dirV2 (regV "wipe") ;
|
||||
|
||||
-- other_A = regA "other" ;
|
||||
|
||||
grammar_N = regN "grammar" ;
|
||||
language_N = regN "language" ;
|
||||
rule_N = regN "rule" ;
|
||||
|
||||
-- added 4/6/2007
|
||||
john_PN = mkPN (mkN masculine (mkN "John")) ;
|
||||
question_N = regN "question" ;
|
||||
ready_A = regA "ready" ;
|
||||
reason_N = regN "reason" ;
|
||||
today_Adv = mkAdv "today" ;
|
||||
uncertain_A = regA "uncertain" ;
|
||||
|
||||
oper
|
||||
aboutP = mkPrep "about" ;
|
||||
atP = mkPrep "at" ;
|
||||
forP = mkPrep "for" ;
|
||||
fromP = mkPrep "from" ;
|
||||
inP = mkPrep "in" ;
|
||||
onP = mkPrep "on" ;
|
||||
toP = mkPrep "to" ;
|
||||
|
||||
-}
|
||||
|
||||
} ;
|
||||
13
lib/src/latvian/MakeStructuralLav.gf
Normal file
13
lib/src/latvian/MakeStructuralLav.gf
Normal file
@@ -0,0 +1,13 @@
|
||||
--# -path=.:../common:../abstract
|
||||
|
||||
resource MakeStructuralLav = open CatLav, ParadigmsLav, ResLav, MorphoLav, Prelude in {
|
||||
{-
|
||||
oper
|
||||
mkSubj : Str -> Subj = \x ->
|
||||
lin Subj {s = x} ;
|
||||
mkNP : Str -> ParadigmsEng.Number -> NP = \s,n ->
|
||||
lin NP (regNP s n) ;
|
||||
mkIDet : Str -> ParadigmsEng.Number -> IDet = \s,n ->
|
||||
lin IDet {s = s ; n = n} ;
|
||||
-}
|
||||
}
|
||||
43
lib/src/latvian/MorphoLav.gf
Normal file
43
lib/src/latvian/MorphoLav.gf
Normal file
@@ -0,0 +1,43 @@
|
||||
--# -path=.:../../prelude
|
||||
|
||||
--1 A Simple English Resource Morphology
|
||||
--
|
||||
-- Aarne Ranta 2002 -- 2005
|
||||
--
|
||||
-- This resource morphology contains definitions needed in the resource
|
||||
-- syntax. To build a lexicon, it is better to use $ParadigmsEng$, which
|
||||
-- gives a higher-level access to this module.
|
||||
|
||||
resource MorphoLav = open Prelude, (Predef=Predef), ResLav in {
|
||||
|
||||
flags optimize=all ;
|
||||
|
||||
--2 Determiners
|
||||
{-
|
||||
oper
|
||||
|
||||
mkDeterminer : Number -> Str ->
|
||||
{s : Str ; sp : NPCase => Str; n : Number ; hasNum : Bool} = \n,s ->
|
||||
{s = s;
|
||||
sp = \\c => regGenitiveS s ! npcase2case c ;
|
||||
n = n ;
|
||||
hasNum = True ; -- doesn't matter since s = sp
|
||||
} ;
|
||||
|
||||
--2 Pronouns
|
||||
|
||||
|
||||
mkPron : (i,me,my,mine : Str) -> Number -> Person -> Gender ->
|
||||
{s : NPCase => Str ; sp : Case => Str ; a : Agr} =
|
||||
\i,me,my,mine,n,p,g -> {
|
||||
s = table {
|
||||
NCase Nom => i ;
|
||||
NPAcc => me ;
|
||||
NCase Gen => my
|
||||
} ;
|
||||
a = toAgr n p g ;
|
||||
sp = regGenitiveS mine
|
||||
} ;
|
||||
-}
|
||||
} ;
|
||||
|
||||
150
lib/src/latvian/NounLav.gf
Normal file
150
lib/src/latvian/NounLav.gf
Normal file
@@ -0,0 +1,150 @@
|
||||
concrete NounLav of Noun = CatLav ** open MorphoLav, ResLav, Prelude in {
|
||||
flags optimize=all_subs ;
|
||||
|
||||
lin
|
||||
|
||||
UseN n = {s = \\_ => n.s ; g = n.g} ;
|
||||
|
||||
DetCN det cn = {
|
||||
s = \\c => det.s ! cn.g ! c ++ cn.s ! det.d ! det.n ! c ;
|
||||
g = cn.g ;
|
||||
n = det.n ;
|
||||
p = P3 ;
|
||||
} ;
|
||||
|
||||
|
||||
|
||||
{-
|
||||
DetCN det cn = {
|
||||
s = \\c => det.s ++ cn.s ! det.n ! c ;
|
||||
a = agrgP3 det.n cn.g
|
||||
} ;
|
||||
|
||||
UsePN pn = pn ** {a = agrgP3 Sg pn.g} ;
|
||||
UsePron p = p ;
|
||||
|
||||
PredetNP pred np = {
|
||||
s = \\c => pred.s ++ np.s ! c ;
|
||||
a = np.a
|
||||
} ;
|
||||
|
||||
PPartNP np v2 = {
|
||||
s = \\c => np.s ! c ++ v2.s ! VPPart ;
|
||||
a = np.a
|
||||
} ;
|
||||
|
||||
RelNP np rs = {
|
||||
s = \\c => np.s ! c ++ "," ++ rs.s ! np.a ;
|
||||
a = np.a
|
||||
} ;
|
||||
|
||||
AdvNP np adv = {
|
||||
s = \\c => np.s ! c ++ adv.s ;
|
||||
a = np.a
|
||||
} ;
|
||||
|
||||
DetQuant quant num = {
|
||||
s = quant.s ! num.hasCard ! num.n ++ num.s ! Nom;
|
||||
sp = \\c => case num.hasCard of {
|
||||
False => quant.sp ! num.hasCard ! num.n ! c ++ num.s ! Nom ;
|
||||
True => quant.sp ! num.hasCard ! num.n ! Nom ++ num.s ! c
|
||||
} ;
|
||||
n = num.n
|
||||
} ;
|
||||
|
||||
DetQuantOrd quant num ord = {
|
||||
s = quant.s ! num.hasCard ! num.n ++ num.s ! Nom ++ ord.s ! Nom;
|
||||
sp = \\c => quant.sp ! num.hasCard ! num.n ! Nom ++ num.s ! Nom ++ ord.s ! c ;
|
||||
n = num.n
|
||||
} ;
|
||||
|
||||
DetNP det = {
|
||||
s = det.sp ;
|
||||
a = agrP3 det.n
|
||||
} ;
|
||||
|
||||
PossPron p = {
|
||||
s = \\_,_ => p.s ! Gen ;
|
||||
sp = \\_,_ => p.sp
|
||||
} ;
|
||||
|
||||
NumSg = {s = \\c => []; n = Sg ; hasCard = False} ;
|
||||
NumPl = {s = \\c => []; n = Pl ; hasCard = False} ;
|
||||
---b NoOrd = {s = []} ;
|
||||
|
||||
NumCard n = n ** {hasCard = True} ;
|
||||
|
||||
NumDigits n = {s = n.s ! NCard ; n = n.n} ;
|
||||
OrdDigits n = {s = n.s ! NOrd} ;
|
||||
|
||||
NumNumeral numeral = {s = numeral.s ! NCard; n = numeral.n} ;
|
||||
OrdNumeral numeral = {s = numeral.s ! NOrd} ;
|
||||
|
||||
AdNum adn num = {s = \\c => adn.s ++ num.s!c ; n = num.n} ;
|
||||
|
||||
OrdSuperl a = {s = \\c => a.s ! AAdj Superl c } ;
|
||||
|
||||
DefArt = {
|
||||
s = \\hasCard,n => artDef ;
|
||||
sp = \\hasCard,n => case <n,hasCard> of {
|
||||
<Sg,False> => table { Gen => "its"; _ => "it" } ;
|
||||
<Pl,False> => table { Nom => "they"; Acc => "them"; Gen => "theirs" } ;
|
||||
_ => \\c => artDef
|
||||
}
|
||||
} ;
|
||||
|
||||
IndefArt = {
|
||||
s = \\hasCard,n => case <n,hasCard> of {
|
||||
<Sg,False> => artIndef ;
|
||||
_ => []
|
||||
} ;
|
||||
sp = \\hasCard,n => case <n,hasCard> of {
|
||||
<Sg,False> => table { Gen => "one's"; _ => "one" };
|
||||
<Pl,False> => table { Gen => "ones'"; _ => "ones" } ;
|
||||
_ => \\c => []
|
||||
}
|
||||
} ;
|
||||
|
||||
MassNP cn = {
|
||||
s = cn.s ! Sg ;
|
||||
a = agrP3 Sg
|
||||
} ;
|
||||
|
||||
UseN n = n ;
|
||||
UseN2 n = n ;
|
||||
---b UseN3 n = n ;
|
||||
|
||||
Use2N3 f = {
|
||||
s = \\n,c => f.s ! n ! Nom ;
|
||||
g = f.g ;
|
||||
c2 = f.c2
|
||||
} ;
|
||||
|
||||
Use3N3 f = {
|
||||
s = \\n,c => f.s ! n ! Nom ;
|
||||
g = f.g ;
|
||||
c2 = f.c3
|
||||
} ;
|
||||
|
||||
ComplN2 f x = {s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c ; g = f.g} ;
|
||||
ComplN3 f x = {
|
||||
s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c ;
|
||||
g = f.g ;
|
||||
c2 = f.c3
|
||||
} ;
|
||||
|
||||
AdjCN ap cn = {
|
||||
s = \\n,c => preOrPost ap.isPre (ap.s ! agrgP3 n cn.g) (cn.s ! n ! c) ;
|
||||
g = cn.g
|
||||
} ;
|
||||
RelCN cn rs = {
|
||||
s = \\n,c => cn.s ! n ! c ++ rs.s ! agrgP3 n cn.g ;
|
||||
g = cn.g
|
||||
} ;
|
||||
AdvCN cn ad = {s = \\n,c => cn.s ! n ! c ++ ad.s ; g = cn.g} ;
|
||||
|
||||
SentCN cn sc = {s = \\n,c => cn.s ! n ! c ++ sc.s ; g = cn.g} ;
|
||||
|
||||
ApposCN cn np = {s = \\n,c => cn.s ! n ! Nom ++ np.s ! c ; g = cn.g} ;
|
||||
-}
|
||||
}
|
||||
95
lib/src/latvian/NumeralLav.gf
Normal file
95
lib/src/latvian/NumeralLav.gf
Normal file
@@ -0,0 +1,95 @@
|
||||
concrete NumeralLav of Numeral = CatLav ** open ResLav in {
|
||||
{-
|
||||
lincat
|
||||
Digit = {s : DForm => CardOrd => Case => Str} ;
|
||||
Sub10 = {s : DForm => CardOrd => Case => Str ; n : Number} ;
|
||||
Sub100 = {s : CardOrd => Case => Str ; n : Number} ;
|
||||
Sub1000 = {s : CardOrd => Case => Str ; n : Number} ;
|
||||
Sub1000000 = {s : CardOrd => Case => Str ; n : Number} ;
|
||||
|
||||
lin num x = x ;
|
||||
lin n2 = let two = mkNum "two" "twelve" "twenty" "second" in
|
||||
{s = \\f,o => case <f,o> of {
|
||||
<teen,NOrd> => regGenitiveS "twelfth" ;
|
||||
_ => two.s ! f ! o
|
||||
}
|
||||
} ;
|
||||
|
||||
lin n3 = mkNum "three" "thirteen" "thirty" "third" ;
|
||||
lin n4 = mkNum "four" "fourteen" "forty" "fourth" ;
|
||||
lin n5 = mkNum "five" "fifteen" "fifty" "fifth" ;
|
||||
lin n6 = regNum "six" ;
|
||||
lin n7 = regNum "seven" ;
|
||||
lin n8 = mkNum "eight" "eighteen" "eighty" "eighth" ;
|
||||
lin n9 = mkNum "nine" "nineteen" "ninety" "ninth" ;
|
||||
|
||||
lin pot01 = mkNum "one" "eleven" "ten" "first" ** {n = Sg} ;
|
||||
lin pot0 d = d ** {n = Pl} ;
|
||||
lin pot110 = regCardOrd "ten" ** {n = Pl} ;
|
||||
lin pot111 = regCardOrd "eleven" ** {n = Pl} ;
|
||||
lin pot1to19 d = {s = d.s ! teen} ** {n = Pl} ;
|
||||
lin pot0as1 n = {s = n.s ! unit} ** {n = n.n} ;
|
||||
lin pot1 d = {s = d.s ! ten} ** {n = Pl} ;
|
||||
lin pot1plus d e = {
|
||||
s = \\o,c => d.s ! ten ! NCard ! Nom ++ "-" ++ e.s ! unit ! o ! c ; n = Pl} ;
|
||||
lin pot1as2 n = n ;
|
||||
lin pot2 d = {s = \\o,c => d.s ! unit ! NCard ! Nom ++ mkCard o "hundred" ! c} ** {n = Pl} ;
|
||||
lin pot2plus d e = {
|
||||
s = \\o,c => d.s ! unit ! NCard ! Nom ++ "hundred" ++ "and" ++ e.s ! o ! c ; n = Pl} ;
|
||||
lin pot2as3 n = n ;
|
||||
lin pot3 n = {
|
||||
s = \\o,c => n.s ! NCard ! Nom ++ mkCard o "thousand" ! c ; n = Pl} ;
|
||||
lin pot3plus n m = {
|
||||
s = \\o,c => n.s ! NCard ! Nom ++ "thousand" ++ m.s ! o ! c; n = Pl} ;
|
||||
|
||||
-- numerals as sequences of digits
|
||||
|
||||
lincat
|
||||
Dig = TDigit ;
|
||||
|
||||
lin
|
||||
IDig d = d ** {tail = T1} ;
|
||||
|
||||
IIDig d i = {
|
||||
s = \\o,c => d.s ! NCard ! Nom ++ commaIf i.tail ++ i.s ! o ! c ;
|
||||
n = Pl ;
|
||||
tail = inc i.tail
|
||||
} ;
|
||||
|
||||
D_0 = mkDig "0" ;
|
||||
D_1 = mk3Dig "1" "1st" Sg ;
|
||||
D_2 = mk2Dig "2" "2nd" ;
|
||||
D_3 = mk2Dig "3" "3rd" ;
|
||||
D_4 = mkDig "4" ;
|
||||
D_5 = mkDig "5" ;
|
||||
D_6 = mkDig "6" ;
|
||||
D_7 = mkDig "7" ;
|
||||
D_8 = mkDig "8" ;
|
||||
D_9 = mkDig "9" ;
|
||||
|
||||
oper
|
||||
commaIf : DTail -> Str = \t -> case t of {
|
||||
T3 => "," ;
|
||||
_ => []
|
||||
} ;
|
||||
|
||||
inc : DTail -> DTail = \t -> case t of {
|
||||
T1 => T2 ;
|
||||
T2 => T3 ;
|
||||
T3 => T1
|
||||
} ;
|
||||
|
||||
mk2Dig : Str -> Str -> TDigit = \c,o -> mk3Dig c o Pl ;
|
||||
mkDig : Str -> TDigit = \c -> mk2Dig c (c + "th") ;
|
||||
|
||||
mk3Dig : Str -> Str -> Number -> TDigit = \c,o,n -> {
|
||||
s = table {NCard => regGenitiveS c ; NOrd => regGenitiveS o} ;
|
||||
n = n
|
||||
} ;
|
||||
|
||||
TDigit = {
|
||||
n : Number ;
|
||||
s : CardOrd => Case => Str
|
||||
} ;
|
||||
-}
|
||||
}
|
||||
1
lib/src/latvian/OverloadLav.gf
Normal file
1
lib/src/latvian/OverloadLav.gf
Normal file
@@ -0,0 +1 @@
|
||||
resource OverloadLav = Overload with (Grammar = GrammarLav) ;
|
||||
222
lib/src/latvian/ParadigmsAdjectivesLav.gf
Normal file
222
lib/src/latvian/ParadigmsAdjectivesLav.gf
Normal file
@@ -0,0 +1,222 @@
|
||||
-- Latvian adjective paradigms - by Normunds Grūzītis; copied off mini-grammar as of 2011-07-12
|
||||
|
||||
resource ParadigmsAdjectivesLav = open
|
||||
(Predef=Predef),
|
||||
Prelude,
|
||||
ResLav,
|
||||
CatLav
|
||||
in {
|
||||
|
||||
flags
|
||||
coding = utf8;
|
||||
|
||||
oper
|
||||
Adj : Type = {s : Degree => Definite => Gender => Number => Case => Str} ;
|
||||
|
||||
-- ADJECTIVES
|
||||
|
||||
-- TODO: Parameters and paradigms should be redesigned due to the many NON_EXISTENT forms..?
|
||||
|
||||
-- To keep the code and user interface (parameters) simple, Masc lemmas are expected.
|
||||
|
||||
-- No parameters - default assumptions (type)
|
||||
mkAdjective : Str -> Adj = \lemma ->
|
||||
case lemma of {
|
||||
s + "ais" => mkAdjective_Rel lemma ;
|
||||
s + ("s"|"š") => mkAdjective_Qual lemma ;
|
||||
s + #vowel => mkAdjective_Indecl lemma
|
||||
} ;
|
||||
|
||||
-- Specified type - no defaults
|
||||
mkAdjectiveByType : Str -> AdjType -> Adj = \lemma,type ->
|
||||
case type of {
|
||||
AdjQual => mkAdjective_Qual lemma ;
|
||||
AdjRel => mkAdjective_Rel lemma ;
|
||||
AdjIndecl => mkAdjective_Indecl lemma
|
||||
} ;
|
||||
|
||||
-- Indeclinable adjective: theoretically, any #vowel ending
|
||||
mkAdjective_Indecl : Str -> Adj = \lemma -> {
|
||||
s = table{
|
||||
Posit => \\_,_,_,_ => lemma ;
|
||||
Compar => \\_,_,_,_ => lemma ;
|
||||
Superl => table {Indef => \\_,_,_ => NON_EXISTENT ; Def => \\_,_,_ => lemma}
|
||||
}
|
||||
} ;
|
||||
|
||||
-- Qualitative adjective: -s, -š
|
||||
mkAdjective_Qual : Str -> Adj = \lemma -> {
|
||||
s = table {
|
||||
Posit => table {Indef => mkAdjective_Pos lemma Indef ; Def => mkAdjective_Pos lemma Def} ;
|
||||
Compar => table {Indef => mkAdjective_Comp lemma Indef ; Def => mkAdjective_Comp lemma Def} ;
|
||||
Superl => table {Indef => \\_,_,_ => NON_EXISTENT ; Def => mkAdjective_Sup lemma}
|
||||
}
|
||||
} ;
|
||||
|
||||
-- Relative adjective: -ais (Def only); -s, -š (Indef and Def)
|
||||
mkAdjective_Rel : Str -> Adj = \lemma -> {
|
||||
s = table {
|
||||
Posit => case lemma of {
|
||||
s + "ais" => table {Indef => \\_,_,_ => NON_EXISTENT ; Def => mkAdjective_Pos lemma Def} ;
|
||||
_ => table {Indef => mkAdjective_Pos lemma Indef ; Def => mkAdjective_Pos lemma Def}
|
||||
} ;
|
||||
Compar => table {Indef => \\_,_,_ => NON_EXISTENT ; Def => \\_,_,_ => NON_EXISTENT} ;
|
||||
Superl => table {Indef => \\_,_,_ => NON_EXISTENT ; Def => \\_,_,_ => NON_EXISTENT}
|
||||
}
|
||||
};
|
||||
|
||||
-- Positive degree: -s, -š (Indef and Def); -ais (Def only)
|
||||
mkAdjective_Pos : Str -> Definite -> Gender => Number => Case => Str = \lemma,defin ->
|
||||
let stem : Str = case lemma of {
|
||||
s + "ais" => s ;
|
||||
_ => Predef.tk 1 lemma
|
||||
}
|
||||
in case defin of {
|
||||
Indef => table {
|
||||
Masc => table {
|
||||
Sg => table {
|
||||
Nom => lemma ;
|
||||
Gen => stem + "a" ;
|
||||
Dat => stem + "am" ;
|
||||
Acc => stem + "u" ;
|
||||
Loc => stem + "ā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "i" ;
|
||||
Gen => stem + "us" ;
|
||||
Dat => stem + "iem" ;
|
||||
Acc => stem + "us" ;
|
||||
Loc => stem + "os"
|
||||
}
|
||||
} ;
|
||||
Fem => table {
|
||||
Sg => table {
|
||||
Nom => stem + "a" ;
|
||||
Gen => stem + "as" ;
|
||||
Dat => stem + "ai" ;
|
||||
Acc => stem + "u" ;
|
||||
Loc => stem + "ā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "as" ;
|
||||
Gen => stem + "u" ;
|
||||
Dat => stem + "ām" ;
|
||||
Acc => stem + "as" ;
|
||||
Loc => stem + "ās"
|
||||
}
|
||||
}
|
||||
} ;
|
||||
Def => table {
|
||||
Masc => table {
|
||||
Sg => table {
|
||||
Nom => stem + "ais" ;
|
||||
Gen => stem + "ā" ;
|
||||
Dat => case stem of {s + "ēj" => stem + "am" ; _ => stem + "ajam"} ;
|
||||
Acc => stem + "o" ;
|
||||
Loc => case stem of {s + "ēj" => stem + "ā" ; _ => stem + "ajā"}
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "ie" ;
|
||||
Gen => stem + "o" ;
|
||||
Dat => case stem of {s + "ēj" => stem + "iem" ; _ => stem + "ajiem"} ;
|
||||
Acc => stem + "os" ;
|
||||
Loc => case stem of {s + "ēj" => stem + "os" ; _ => stem + "ajos"}
|
||||
}
|
||||
} ;
|
||||
Fem => table {
|
||||
Sg => table {
|
||||
Nom => stem + "ā" ;
|
||||
Gen => stem + "ās" ;
|
||||
Dat => case stem of {s + "ēj" => stem + "ai" ; _ => stem + "ajai"} ;
|
||||
Acc => stem + "o" ;
|
||||
Loc => case stem of {s + "ēj" => stem + "ā" ; _ => stem + "ajā"}
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "ās" ;
|
||||
Gen => stem + "o" ;
|
||||
Dat => case stem of {s + "ēj" => stem + "ām" ; _ => stem + "ajām"} ;
|
||||
Acc => stem + "ās" ;
|
||||
Loc => case stem of {s + "ēj" => stem + "ās" ; _ => stem + "ajās"}
|
||||
}
|
||||
}
|
||||
}
|
||||
} ;
|
||||
|
||||
-- Comparative degree: Qual only
|
||||
mkAdjective_Comp : Str -> Definite -> Gender => Number => Case => Str = \lemma,defin ->
|
||||
let stem : Str = Predef.tk 1 lemma
|
||||
in case defin of {
|
||||
Indef => table {
|
||||
Masc => table {
|
||||
Sg => table {
|
||||
Nom => stem + "āks" ;
|
||||
Gen => stem + "āka" ;
|
||||
Dat => stem + "ākam" ;
|
||||
Acc => stem + "āku" ;
|
||||
Loc => stem + "ākā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "āki" ;
|
||||
Gen => stem + "āku" ;
|
||||
Dat => stem + "ākiem" ;
|
||||
Acc => stem + "ākus" ;
|
||||
Loc => stem + "ākos"
|
||||
}
|
||||
} ;
|
||||
Fem => table {
|
||||
Sg => table {
|
||||
Nom => stem + "āka" ;
|
||||
Gen => stem + "ākas" ;
|
||||
Dat => stem + "ākai" ;
|
||||
Acc => stem + "āku" ;
|
||||
Loc => stem + "ākā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "ākas" ;
|
||||
Gen => stem + "āku" ;
|
||||
Dat => stem + "ākām" ;
|
||||
Acc => stem + "ākas" ;
|
||||
Loc => stem + "ākās"
|
||||
}
|
||||
}
|
||||
} ;
|
||||
Def => table {
|
||||
Masc => table {
|
||||
Sg => table {
|
||||
Nom => stem + "ākais" ;
|
||||
Gen => stem + "ākā" ;
|
||||
Dat => stem + "ākajam" ;
|
||||
Acc => stem + "āko" ;
|
||||
Loc => stem + "ākajā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "ākie" ;
|
||||
Gen => stem + "āko" ;
|
||||
Dat => stem + "ākajiem" ;
|
||||
Acc => stem + "ākos" ;
|
||||
Loc => stem + "ākajos"
|
||||
}
|
||||
} ;
|
||||
Fem => table {
|
||||
Sg => table {
|
||||
Nom => stem + "ākā" ;
|
||||
Gen => stem + "ākās" ;
|
||||
Dat => stem + "ākajai" ;
|
||||
Acc => stem + "āko" ;
|
||||
Loc => stem + "ākajā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "ākās" ;
|
||||
Gen => stem + "āko" ;
|
||||
Dat => stem + "ākajām" ;
|
||||
Acc => stem + "ākās" ;
|
||||
Loc => stem + "ākajās"
|
||||
}
|
||||
}
|
||||
}
|
||||
} ;
|
||||
|
||||
-- Superlative degree: Qual only, Def only
|
||||
mkAdjective_Sup : Str -> Gender => Number => Case => Str = \lemma ->
|
||||
\\g,n,c => "vis" + (mkAdjective_Comp lemma Def) ! g ! n ! c ;
|
||||
} ;
|
||||
739
lib/src/latvian/ParadigmsLav.gf
Normal file
739
lib/src/latvian/ParadigmsLav.gf
Normal file
@@ -0,0 +1,739 @@
|
||||
--# -path=.:../abstract:../../prelude:../common
|
||||
|
||||
--1 English Lexical Paradigms
|
||||
--
|
||||
-- Aarne Ranta 2003--2005
|
||||
--
|
||||
-- This is an API for 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 $MorphoEng.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$.
|
||||
-- However, this function should only seldom be needed: we have a
|
||||
-- separate module [``IrregEng`` ../../english/IrregEng.gf],
|
||||
-- which covers irregular verbss.
|
||||
|
||||
resource ParadigmsLav = open
|
||||
(Predef=Predef),
|
||||
Prelude,
|
||||
ParadigmsNounsLav,
|
||||
ParadigmsAdjectivesLav,
|
||||
ParadigmsVerbsLav,
|
||||
ParadigmsPronounsLav,
|
||||
ResLav,
|
||||
CatLav
|
||||
in {
|
||||
|
||||
flags
|
||||
coding = utf8;
|
||||
|
||||
oper
|
||||
second_conjugation : VerbConj = C2 ;
|
||||
third_conjugation : VerbConj = C3 ;
|
||||
|
||||
mkN = overload {
|
||||
mkN : (lemma : Str) -> N = \l -> lin N (mkNoun l) ;
|
||||
|
||||
mkN : (lemma : Str) -> Bool -> N = \l,p -> lin N (mkNounByPal l p) ;
|
||||
mkN : (lemma : Str) -> Gender -> N = \l,g -> lin N (mkNounByGend l g) ;
|
||||
mkN : (lemma : Str) -> NounDecl -> N = \l,d -> lin N (mkNounByDecl l d) ;
|
||||
|
||||
mkN : (lemma : Str) -> Gender -> Bool -> N = \l,g,p -> lin N (mkNounByGendPal l g p) ;
|
||||
mkN : (lemma : Str) -> NounDecl -> Bool -> N = \l,d,p -> lin N (mkNounByDeclPal l d p) ;
|
||||
mkN : (lemma : Str) -> Gender -> NounDecl -> N = \l,g,d -> lin N (mkNounByGendDecl l g d) ;
|
||||
|
||||
mkN : (lemma : Str) -> Gender -> NounDecl -> Bool -> N = \l,g,d,p -> lin N (mkNounByGendDeclPal l g d p) ;
|
||||
} ;
|
||||
|
||||
mkA = overload {
|
||||
mkA : (lemma : Str) -> A = \s -> lin A (mkAdjective s) ;
|
||||
mkA : (lemma : Str) -> AdjType -> A = \s,t -> lin A (mkAdjectiveByType s t) ;
|
||||
} ;
|
||||
|
||||
mkV = overload {
|
||||
mkV : (lemma : Str) -> V = \l -> lin V (mkVerb_Irreg l) ;
|
||||
mkV : (lemma : Str) -> VerbConj -> V = \l,c -> lin V (mkVerb l c) ;
|
||||
mkV : (lemma : Str) -> Str -> Str -> V = \l1,l2,l3 -> lin V (mkVerbC1 l1 l2 l3) ;
|
||||
} ;
|
||||
|
||||
{-
|
||||
|
||||
--2 Parameters
|
||||
--
|
||||
-- To abstract over gender names, we define the following identifiers.
|
||||
|
||||
oper
|
||||
Gender : Type ;
|
||||
|
||||
human : Gender ;
|
||||
nonhuman : Gender ;
|
||||
masculine : Gender ;
|
||||
feminine : Gender ;
|
||||
|
||||
-- To abstract over number names, we define the following.
|
||||
|
||||
Number : Type ;
|
||||
|
||||
singular : Number ;
|
||||
plural : Number ;
|
||||
|
||||
-- To abstract over case names, we define the following.
|
||||
|
||||
Case : Type ;
|
||||
|
||||
nominative : Case ;
|
||||
genitive : Case ;
|
||||
|
||||
-- Prepositions are used in many-argument functions for rection.
|
||||
-- The resource category $Prep$ is used.
|
||||
|
||||
|
||||
|
||||
--2 Nouns
|
||||
|
||||
-- Nouns are constructed by the function $mkN$, which takes a varying
|
||||
-- number of arguments.
|
||||
|
||||
mkN : overload {
|
||||
|
||||
-- The regular function captures the variants for nouns ending with
|
||||
-- "s","sh","x","z" or "y": "kiss - kisses", "flash - flashes";
|
||||
-- "fly - flies" (but "toy - toys"),
|
||||
|
||||
mkN : (flash : Str) -> N ;
|
||||
|
||||
-- In practice the worst case is to give singular and plural nominative.
|
||||
|
||||
mkN : (man,men : Str) -> N ;
|
||||
|
||||
-- The theoretical worst case: give all four forms.
|
||||
|
||||
mkN : (man,men,man's,men's : Str) -> N ;
|
||||
|
||||
-- Change gender from the default $nonhuman$.
|
||||
|
||||
mkN : Gender -> N -> N ;
|
||||
|
||||
--3 Compound nouns
|
||||
--
|
||||
-- A compound noun is an uninflected string attached to an inflected noun,
|
||||
-- such as "baby boom", "chief executive officer".
|
||||
|
||||
mkN : Str -> N -> N
|
||||
} ;
|
||||
|
||||
|
||||
--3 Relational nouns
|
||||
|
||||
mkN2 : overload {
|
||||
mkN2 : N -> Prep -> N2 ; -- access to
|
||||
mkN2 : N -> Str -> N2 ; -- access to
|
||||
mkN2 : Str -> Str -> N2 ; -- access to
|
||||
mkN2 : N -> N2 ; -- wife of
|
||||
mkN2 : Str -> N2 -- daughter of
|
||||
} ;
|
||||
|
||||
-- Use the function $mkPrep$ or see the section on prepositions below to
|
||||
-- form other prepositions.
|
||||
--
|
||||
-- Three-place relational nouns ("the connection from x to y") need two prepositions.
|
||||
|
||||
mkN3 : N -> Prep -> Prep -> N3 ;
|
||||
|
||||
|
||||
|
||||
--3 Proper names and noun phrases
|
||||
--
|
||||
-- Proper names, with a regular genitive, are formed from strings.
|
||||
|
||||
mkPN : overload {
|
||||
|
||||
mkPN : Str -> PN ;
|
||||
|
||||
-- Sometimes a common noun can be reused as a proper name, e.g. "Bank"
|
||||
|
||||
mkPN : N -> PN
|
||||
} ;
|
||||
|
||||
--3 Determiners and quantifiers
|
||||
|
||||
mkQuant : overload {
|
||||
mkQuant : (this, these : Str) -> Quant ;
|
||||
mkQuant : (no_sg, no_pl, none_sg, non_pl : Str) -> Quant ;
|
||||
} ;
|
||||
|
||||
mkOrd : Str -> Ord ;
|
||||
|
||||
--2 Adjectives
|
||||
|
||||
mkA : overload {
|
||||
|
||||
-- For regular adjectives, the adverbial and comparison forms are derived. This holds
|
||||
-- even for cases with the variations "happy - happily - happier - happiest",
|
||||
-- "free - freely - freer - freest", and "rude - rudest".
|
||||
|
||||
mkA : (happy : Str) -> A ;
|
||||
|
||||
-- However, the duplication of the final consonant cannot be predicted,
|
||||
-- but a separate case is used to give the comparative
|
||||
|
||||
mkA : (fat,fatter : Str) -> A ;
|
||||
|
||||
-- As many as four forms may be needed.
|
||||
|
||||
mkA : (good,better,best,well : Str) -> A
|
||||
} ;
|
||||
|
||||
-- Regular comparison is formed by "more - most" for words with two vowels separated
|
||||
-- and terminated by some other letters. To force this or the opposite,
|
||||
-- the following can be used:
|
||||
|
||||
compoundA : A -> A ; -- -/more/most ditto
|
||||
simpleA : A -> A ; -- young,younger,youngest
|
||||
|
||||
|
||||
--3 Two-place adjectives
|
||||
|
||||
mkA2 : overload {
|
||||
mkA2 : A -> Prep -> A2 ; -- absent from
|
||||
mkA2 : A -> Str -> A2 ; -- absent from
|
||||
mkA2 : Str -> Prep -> A2 ; -- absent from
|
||||
mkA2 : Str -> Str -> A2 -- absent from
|
||||
|
||||
} ;
|
||||
|
||||
|
||||
--2 Adverbs
|
||||
|
||||
-- Adverbs are not inflected. Most lexical ones have position
|
||||
-- after the verb. Some can be preverbal (e.g. "always").
|
||||
|
||||
mkAdv : Str -> Adv ;
|
||||
mkAdV : Str -> AdV ;
|
||||
|
||||
-- Adverbs modifying adjectives and sentences can also be formed.
|
||||
|
||||
mkAdA : Str -> AdA ;
|
||||
|
||||
-- Adverbs modifying numerals
|
||||
|
||||
mkAdN : Str -> AdN ;
|
||||
|
||||
--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.
|
||||
|
||||
mkPrep : Str -> Prep ;
|
||||
noPrep : Prep ;
|
||||
|
||||
-- (These two functions are synonyms.)
|
||||
|
||||
--2 Conjunctions
|
||||
--
|
||||
|
||||
mkConj : overload {
|
||||
mkConj : Str -> Conj ; -- and (plural agreement)
|
||||
mkConj : Str -> Number -> Conj ; -- or (agrement number given as argument)
|
||||
mkConj : Str -> Str -> Conj ; -- both ... and (plural)
|
||||
mkConj : Str -> Str -> Number -> Conj ; -- either ... or (agrement number given as argument)
|
||||
} ;
|
||||
|
||||
--2 Verbs
|
||||
--
|
||||
|
||||
-- Verbs are constructed by the function $mkV$, which takes a varying
|
||||
-- number of arguments.
|
||||
|
||||
mkV : overload {
|
||||
|
||||
-- The regular verb function recognizes the special cases where the last
|
||||
-- character is "y" ("cry-cries" but "buy-buys") or a sibilant
|
||||
-- ("kiss-"kisses", "jazz-jazzes", "rush-rushes", "munch - munches",
|
||||
-- "fix - fixes").
|
||||
|
||||
mkV : (cry : Str) -> V ;
|
||||
|
||||
-- Give the present and past forms for regular verbs where
|
||||
-- the last letter is duplicated in some forms,
|
||||
-- e.g. "rip - ripped - ripping".
|
||||
|
||||
mkV : (stop, stopped : Str) -> V ;
|
||||
|
||||
-- There is an extensive list of irregular verbs in the module $IrregularEng$.
|
||||
-- In practice, it is enough to give three forms,
|
||||
-- e.g. "drink - drank - drunk".
|
||||
|
||||
mkV : (drink, drank, drunk : Str) -> V ;
|
||||
|
||||
-- Irregular verbs with duplicated consonant in the present participle.
|
||||
|
||||
mkV : (run, ran, run, running : Str) -> V ;
|
||||
|
||||
-- Except for "be", the worst case needs five forms: the infinitive and
|
||||
-- the third person singular present, the past indicative, and the
|
||||
-- past and present participles.
|
||||
|
||||
mkV : (go, goes, went, gone, going : Str) -> V ;
|
||||
|
||||
-- Adds a prefix to an exisiting verb. This is most useful to create
|
||||
-- prefix-variants of irregular verbs from $IrregEng$, e.g. "undertake".
|
||||
|
||||
mkV : Str -> V -> V ;
|
||||
};
|
||||
|
||||
-- Verbs with a particle.
|
||||
-- The particle, such as in "switch on", is given as a string.
|
||||
|
||||
partV : V -> Str -> V ;
|
||||
|
||||
-- Reflexive verbs.
|
||||
-- By default, verbs are not reflexive; this function makes them that.
|
||||
|
||||
reflV : V -> 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 : overload {
|
||||
mkV2 : Str -> V2 ; -- kill
|
||||
mkV2 : V -> V2 ; -- hit
|
||||
mkV2 : V -> Prep -> V2 ; -- believe in
|
||||
mkV2 : V -> Str -> V2 ; -- believe in
|
||||
mkV2 : Str -> Prep -> V2 ; -- believe in
|
||||
mkV2 : Str -> Str -> V2 -- believe in
|
||||
};
|
||||
|
||||
--3 Three-place verbs
|
||||
--
|
||||
-- Three-place (ditransitive) verbs need two prepositions, of which
|
||||
-- the first one or both can be absent.
|
||||
|
||||
mkV3 : overload {
|
||||
mkV3 : V -> Prep -> Prep -> V3 ; -- speak, with, about
|
||||
mkV3 : V -> Prep -> V3 ; -- give,_,to
|
||||
mkV3 : V -> Str -> V3 ; -- give,_,to
|
||||
mkV3 : Str -> Str -> V3 ; -- give,_,to
|
||||
mkV3 : V -> V3 ; -- give,_,_
|
||||
mkV3 : Str -> 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 -> Prep -> V2S ;
|
||||
mkVV : V -> VV ;
|
||||
mkV2V : V -> Prep -> Prep -> V2V ;
|
||||
mkVA : V -> VA ;
|
||||
mkV2A : V -> Prep -> V2A ;
|
||||
mkVQ : V -> VQ ;
|
||||
mkV2Q : V -> Prep -> V2Q ;
|
||||
|
||||
mkAS : A -> AS ;
|
||||
mkA2S : A -> Prep -> A2S ;
|
||||
mkAV : A -> AV ;
|
||||
mkA2V : A -> Prep -> A2V ;
|
||||
|
||||
-- Notice: Categories $V0, AS, A2S, AV, A2V$ are just $A$.
|
||||
-- $V0$ is just $V$; the second argument is treated as adverb.
|
||||
|
||||
V0 : Type ;
|
||||
AS, A2S, AV, A2V : Type ;
|
||||
|
||||
--2 Other categories
|
||||
|
||||
mkSubj : Str -> Subj = \s -> lin Subj {s = s} ;
|
||||
|
||||
--.
|
||||
--2 Definitions of paradigms
|
||||
--
|
||||
-- The definitions should not bother the user of the API. So they are
|
||||
-- hidden from the document.
|
||||
|
||||
Gender = ResEng.Gender ;
|
||||
Number = ResEng.Number ;
|
||||
Case = ResEng.Case ;
|
||||
human = Masc ;
|
||||
nonhuman = Neutr ;
|
||||
masculine = Masc ;
|
||||
feminine = Fem ;
|
||||
singular = Sg ;
|
||||
plural = Pl ;
|
||||
nominative = Nom ;
|
||||
genitive = Gen ;
|
||||
|
||||
Preposition : Type = Str ; -- obsolete
|
||||
|
||||
regN = \ray ->
|
||||
let rays = add_s ray
|
||||
in
|
||||
mk2N ray rays ;
|
||||
|
||||
|
||||
add_s : Str -> Str = \w -> case w of {
|
||||
_ + ("io" | "oo") => w + "s" ; -- radio, bamboo
|
||||
_ + ("s" | "z" | "x" | "sh" | "ch" | "o") => w + "es" ; -- bus, hero
|
||||
_ + ("a" | "o" | "u" | "e") + "y" => w + "s" ; -- boy
|
||||
x + "y" => x + "ies" ; -- fly
|
||||
_ => w + "s" -- car
|
||||
} ;
|
||||
|
||||
duplFinal : Str -> Str = \w -> case w of {
|
||||
_ + ("a" | "e" | "o") + ("a" | "e" | "i" | "o" | "u") + ? => w ; -- waited, needed
|
||||
_ + ("a" | "e" | "i" | "o" | "u") +
|
||||
c@("b"|"d"|"g"|"m"|"n"|"p"|"r"|"t") => w + c ; -- omitted, manned
|
||||
_ => w
|
||||
} ;
|
||||
|
||||
mk2N = \man,men ->
|
||||
let mens = case last men of {
|
||||
"s" => men + "'" ;
|
||||
_ => men + "'s"
|
||||
}
|
||||
in
|
||||
mk4N man men (man + "'s") mens ;
|
||||
|
||||
mk4N = \man,men,man's,men's ->
|
||||
lin N (mkNoun man man's men men's ** {g = Neutr}) ;
|
||||
|
||||
genderN g man = lin N {s = man.s ; g = g} ;
|
||||
|
||||
compoundN s n = lin N {s = \\x,y => s ++ n.s ! x ! y ; g=n.g} ;
|
||||
|
||||
mkPN = overload {
|
||||
mkPN : Str -> PN = regPN ;
|
||||
mkPN : N -> PN = nounPN
|
||||
} ;
|
||||
|
||||
mkN2 = overload {
|
||||
mkN2 : N -> Prep -> N2 = prepN2 ;
|
||||
mkN2 : N -> Str -> N2 = \n,s -> prepN2 n (mkPrep s);
|
||||
mkN2 : Str -> Str -> N2 = \n,s -> prepN2 (regN n) (mkPrep s);
|
||||
mkN2 : N -> N2 = \n -> prepN2 n (mkPrep "of") ;
|
||||
mkN2 : Str -> N2 = \s -> prepN2 (regN s) (mkPrep "of")
|
||||
} ;
|
||||
|
||||
prepN2 = \n,p -> lin N2 (n ** {c2 = p.s}) ;
|
||||
regN2 n = prepN2 (regN n) (mkPrep "of") ;
|
||||
|
||||
mkN3 = \n,p,q -> lin N3 (n ** {c2 = p.s ; c3 = q.s}) ;
|
||||
|
||||
--3 Relational common noun phrases
|
||||
--
|
||||
-- In some cases, you may want to make a complex $CN$ into a
|
||||
-- relational noun (e.g. "the old town hall of").
|
||||
|
||||
cnN2 : CN -> Prep -> N2 ;
|
||||
cnN3 : CN -> Prep -> Prep -> N3 ;
|
||||
|
||||
-- This is obsolete.
|
||||
cnN2 = \n,p -> lin N2 (n ** {c2 = p.s}) ;
|
||||
cnN3 = \n,p,q -> lin N3 (n ** {c2 = p.s ; c3 = q.s}) ;
|
||||
|
||||
regPN n = regGenPN n human ;
|
||||
regGenPN n g = lin PN {s = table {Gen => n + "'s" ; _ => n} ; g = g} ;
|
||||
nounPN n = lin PN {s = n.s ! singular ; g = n.g} ;
|
||||
|
||||
mkQuant = overload {
|
||||
mkQuant : (this, these : Str) -> Quant = \sg,pl -> mkQuantifier sg pl sg pl;
|
||||
mkQuant : (no_sg, no_pl, none_sg, non_pl : Str) -> Quant = mkQuantifier;
|
||||
} ;
|
||||
|
||||
mkQuantifier : Str -> Str -> Str -> Str -> Quant =
|
||||
\sg,pl,sg',pl' -> lin Quant {
|
||||
s = \\_ => table { Sg => sg ; Pl => pl } ;
|
||||
sp = \\_ => table { Sg => regGenitiveS sg' ; Pl => regGenitiveS pl'}
|
||||
} ;
|
||||
|
||||
mkOrd : Str -> Ord = \x -> lin Ord { s = regGenitiveS x};
|
||||
|
||||
mk2A a b = mkAdjective a a a b ;
|
||||
regA a = case a of {
|
||||
_ + ("a" | "e" | "i" | "o" | "u" | "y") + ? + _ +
|
||||
("a" | "e" | "i" | "o" | "u" | "y") + ? + _ =>
|
||||
lin A (compoundADeg (regADeg a)) ;
|
||||
_ => lin A (regADeg a)
|
||||
} ;
|
||||
|
||||
prepA2 a p = lin A2 (a ** {c2 = p.s}) ;
|
||||
|
||||
ADeg = A ; ----
|
||||
|
||||
mkADeg a b c d = mkAdjective a b c d ;
|
||||
|
||||
regADeg happy =
|
||||
let
|
||||
happ = init happy ;
|
||||
y = last happy ;
|
||||
happie = case y of {
|
||||
"y" => happ + "ie" ;
|
||||
"e" => happy ;
|
||||
_ => duplFinal happy + "e"
|
||||
} ;
|
||||
happily : Str = case happy of {
|
||||
_ + "ble" => init happy + "y" ;
|
||||
_ + "y" => happ + "ily" ;
|
||||
_ + "ll" => happy + "y" ;
|
||||
_ => happy + "ly"
|
||||
} ;
|
||||
in mkADeg happy (happie + "r") (happie + "st") happily ;
|
||||
|
||||
duplADeg fat =
|
||||
mkADeg fat
|
||||
(fat + last fat + "er") (fat + last fat + "est") (fat + "ly") ;
|
||||
|
||||
compoundADeg a =
|
||||
let ad = (a.s ! AAdj Posit Nom)
|
||||
in mkADeg ad ("more" ++ ad) ("most" ++ ad) (a.s ! AAdv) ;
|
||||
|
||||
adegA a = a ;
|
||||
|
||||
mkAdv x = lin Adv (ss x) ;
|
||||
mkAdV x = lin AdV (ss x) ;
|
||||
mkAdA x = lin AdA (ss x) ;
|
||||
mkAdN x = lin AdN (ss x) ;
|
||||
|
||||
mkPrep p = lin Prep (ss p) ;
|
||||
noPrep = mkPrep [] ;
|
||||
|
||||
mk5V a b c d e = lin V (mkVerb a b c d e ** {s1 = []}) ;
|
||||
|
||||
regV cry =
|
||||
let
|
||||
cries = (regN cry).s ! Pl ! Nom ; -- !
|
||||
cried : Str = case cries of {
|
||||
_ + "es" => init cries + "d" ;
|
||||
_ => duplFinal cry + "ed"
|
||||
} ;
|
||||
crying : Str = case cry of {
|
||||
_ + "ee" => cry + "ing" ;
|
||||
d + "ie" => d + "ying" ;
|
||||
us + "e" => us + "ing" ;
|
||||
_ => duplFinal cry + "ing"
|
||||
}
|
||||
in mk5V cry cries cried cried crying ;
|
||||
|
||||
reg2V fit fitted =
|
||||
let fitt = Predef.tk 2 fitted ;
|
||||
in mk5V fit (fit + "s") (fitt + "ed") (fitt + "ed") (fitt + "ing") ;
|
||||
|
||||
regDuplV fit =
|
||||
case last fit of {
|
||||
("a" | "e" | "i" | "o" | "u" | "y") =>
|
||||
Predef.error (["final duplication makes no sense for"] ++ fit) ;
|
||||
t =>
|
||||
let fitt = fit + t in
|
||||
mk5V fit (fit + "s") (fitt + "ed") (fitt + "ed") (fitt + "ing")
|
||||
} ;
|
||||
|
||||
irregV x y z = let reg = (regV x).s in
|
||||
mk5V x (reg ! VPres) y z (reg ! VPresPart) ** {s1 = []} ;
|
||||
|
||||
irreg4V x y z w = let reg = (regV x).s in
|
||||
mk5V x (reg ! VPres) y z w ** {s1 = []} ;
|
||||
|
||||
irregDuplV fit y z =
|
||||
let
|
||||
fitting = (regDuplV fit).s ! VPresPart
|
||||
in
|
||||
mk5V fit (fit + "s") y z fitting ;
|
||||
|
||||
partV v p = lin V {s = \\f => v.s ! f ++ p ; isRefl = v.isRefl} ;
|
||||
reflV v = lin V {s = v.s ; part = v.part ; isRefl = True} ;
|
||||
|
||||
prepV2 v p = lin V2 {s = v.s ; s1 = v.s1 ; c2 = p.s ; isRefl = v.isRefl} ;
|
||||
dirV2 v = prepV2 v noPrep ;
|
||||
|
||||
prepPrepV3 v p q =
|
||||
lin V3 {s = v.s ; s1 = v.s1 ; c2 = p.s ; c3 = q.s ; isRefl = v.isRefl} ;
|
||||
dirV3 v p = prepPrepV3 v noPrep p ;
|
||||
dirdirV3 v = dirV3 v noPrep ;
|
||||
|
||||
mkVS v = lin VS v ;
|
||||
mkVV v = lin VV {
|
||||
s = table {VVF vf => v.s ! vf ; _ => v.s ! VInf} ;
|
||||
--- variants {}} ; not used
|
||||
isAux = False
|
||||
} ;
|
||||
mkVQ v = lin VQ v ;
|
||||
|
||||
V0 : Type = V ;
|
||||
-- V2S, V2V, V2Q : Type = V2 ;
|
||||
AS, A2S, AV : Type = A ;
|
||||
A2V : Type = A2 ;
|
||||
|
||||
mkV0 v = v ;
|
||||
mkV2S v p = lin V2S (prepV2 v p) ;
|
||||
mkV2V v p t = lin V2V (prepV2 v p ** {isAux = False}) ;
|
||||
mkVA v = lin VA v ;
|
||||
mkV2A v p = lin V2A (prepV2 v p) ;
|
||||
mkV2Q v p = lin V2Q (prepV2 v p) ;
|
||||
|
||||
mkAS v = v ;
|
||||
mkA2S v p = lin A (prepA2 v p) ;
|
||||
mkAV v = v ;
|
||||
mkA2V v p = prepA2 v p ;
|
||||
|
||||
|
||||
-- pre-overload API and overload definitions
|
||||
|
||||
mk4N : (man,men,man's,men's : Str) -> N ;
|
||||
regN : Str -> N ;
|
||||
mk2N : (man,men : Str) -> N ;
|
||||
genderN : Gender -> N -> N ;
|
||||
compoundN : Str -> N -> N ;
|
||||
|
||||
mkN = overload {
|
||||
mkN : (man,men,man's,men's : Str) -> N = mk4N ;
|
||||
mkN : Str -> N = regN ;
|
||||
mkN : (man,men : Str) -> N = mk2N ;
|
||||
mkN : Gender -> N -> N = genderN ;
|
||||
mkN : Str -> N -> N = compoundN
|
||||
} ;
|
||||
|
||||
-- Relational nouns ("daughter of x") need a preposition.
|
||||
|
||||
prepN2 : N -> Prep -> N2 ;
|
||||
|
||||
-- The most common preposition is "of", and the following is a
|
||||
-- shortcut for regular relational nouns with "of".
|
||||
|
||||
regN2 : Str -> N2 ;
|
||||
|
||||
mk2A : (free,freely : Str) -> A ;
|
||||
regA : Str -> A ;
|
||||
|
||||
mkA = overload {
|
||||
mkA : Str -> A = regA ;
|
||||
mkA : (fat,fatter : Str) -> A = \fat,fatter ->
|
||||
mkAdjective fat fatter (init fatter + "st") (fat + "ly") ;
|
||||
mkA : (good,better,best,well : Str) -> A = \a,b,c,d ->
|
||||
mkAdjective a b c d
|
||||
} ;
|
||||
|
||||
compoundA = compoundADeg ;
|
||||
simpleA a =
|
||||
let ad = (a.s ! AAdj Posit Nom)
|
||||
in regADeg ad ;
|
||||
|
||||
prepA2 : A -> Prep -> A2 ;
|
||||
|
||||
mkA2 = overload {
|
||||
mkA2 : A -> Prep -> A2 = prepA2 ;
|
||||
mkA2 : A -> Str -> A2 = \a,p -> prepA2 a (mkPrep p) ;
|
||||
mkA2 : Str -> Prep -> A2 = \a,p -> prepA2 (regA a) p;
|
||||
mkA2 : Str -> Str -> A2 = \a,p -> prepA2 (regA a) (mkPrep p);
|
||||
} ;
|
||||
|
||||
mk5V : (go, goes, went, gone, going : Str) -> V ;
|
||||
regV : (cry : Str) -> V ;
|
||||
reg2V : (stop, stopped : Str) -> V;
|
||||
irregV : (drink, drank, drunk : Str) -> V ;
|
||||
irreg4V : (run, ran, run, running : Str) -> V ;
|
||||
|
||||
-- Use reg2V instead
|
||||
regDuplV : Str -> V ;
|
||||
-- Use irreg4V instead
|
||||
irregDuplV : (get, got, gotten : Str) -> V ;
|
||||
|
||||
mkV = overload {
|
||||
mkV : (cry : Str) -> V = regV ;
|
||||
mkV : (stop, stopped : Str) -> V = reg2V ;
|
||||
mkV : (drink, drank, drunk : Str) -> V = irregV ;
|
||||
mkV : (run, ran, run, running : Str) -> V = irreg4V ;
|
||||
mkV : (go, goes, went, gone, going : Str) -> V = mk5V ;
|
||||
mkV : Str -> V -> V = prefixV
|
||||
};
|
||||
|
||||
prepV2 : V -> Prep -> V2 ;
|
||||
dirV2 : V -> V2 ;
|
||||
prefixV : Str -> V -> V = \p,v -> v ** { s = p + v.s } ;
|
||||
|
||||
mkV2 = overload {
|
||||
mkV2 : V -> V2 = dirV2 ;
|
||||
mkV2 : Str -> V2 = \s -> dirV2 (regV s) ;
|
||||
mkV2 : V -> Prep -> V2 = prepV2 ;
|
||||
mkV2 : V -> Str -> V2 = \v,p -> prepV2 v (mkPrep p) ;
|
||||
mkV2 : Str -> Prep -> V2 = \v,p -> prepV2 (regV v) p ;
|
||||
mkV2 : Str -> Str -> V2 = \v,p -> prepV2 (regV v) (mkPrep p)
|
||||
};
|
||||
|
||||
prepPrepV3 : V -> Prep -> Prep -> V3 ;
|
||||
dirV3 : V -> Prep -> V3 ;
|
||||
dirdirV3 : V -> V3 ;
|
||||
|
||||
mkV3 = overload {
|
||||
mkV3 : V -> Prep -> Prep -> V3 = prepPrepV3 ;
|
||||
mkV3 : V -> Prep -> V3 = dirV3 ;
|
||||
mkV3 : V -> Str -> V3 = \v,s -> dirV3 v (mkPrep s);
|
||||
mkV3 : Str -> Str -> V3 = \v,s -> dirV3 (regV v) (mkPrep s);
|
||||
mkV3 : V -> V3 = dirdirV3 ;
|
||||
mkV3 : Str -> V3 = \v -> dirdirV3 (regV v) ;
|
||||
} ;
|
||||
|
||||
mkConj = overload {
|
||||
mkConj : Str -> Conj = \y -> mk2Conj [] y plural ;
|
||||
mkConj : Str -> Number -> Conj = \y,n -> mk2Conj [] y n ;
|
||||
mkConj : Str -> Str -> Conj = \x,y -> mk2Conj x y plural ;
|
||||
mkConj : Str -> Str -> Number -> Conj = mk2Conj ;
|
||||
} ;
|
||||
|
||||
mk2Conj : Str -> Str -> Number -> Conj = \x,y,n ->
|
||||
lin Conj (sd2 x y ** {n = n}) ;
|
||||
|
||||
---- obsolete
|
||||
|
||||
-- Comparison adjectives may two more forms.
|
||||
|
||||
ADeg : Type ;
|
||||
|
||||
mkADeg : (good,better,best,well : Str) -> ADeg ;
|
||||
|
||||
-- The regular pattern recognizes two common variations:
|
||||
-- "-e" ("rude" - "ruder" - "rudest") and
|
||||
-- "-y" ("happy - happier - happiest - happily")
|
||||
|
||||
regADeg : Str -> ADeg ; -- long, longer, longest
|
||||
|
||||
-- However, the duplication of the final consonant is nor predicted,
|
||||
-- but a separate pattern is used:
|
||||
|
||||
duplADeg : Str -> ADeg ; -- fat, fatter, fattest
|
||||
|
||||
-- If comparison is formed by "more", "most", as in general for
|
||||
-- long adjective, the following pattern is used:
|
||||
|
||||
compoundADeg : A -> ADeg ; -- -/more/most ridiculous
|
||||
|
||||
-- From a given $ADeg$, it is possible to get back to $A$.
|
||||
|
||||
adegA : ADeg -> A ;
|
||||
|
||||
|
||||
regPN : Str -> PN ;
|
||||
regGenPN : Str -> Gender -> PN ; -- John, John's
|
||||
|
||||
-- Sometimes you can reuse a common noun as a proper name, e.g. "Bank".
|
||||
|
||||
nounPN : N -> PN ;
|
||||
|
||||
|
||||
-}
|
||||
} ;
|
||||
333
lib/src/latvian/ParadigmsNounsLav.gf
Normal file
333
lib/src/latvian/ParadigmsNounsLav.gf
Normal file
@@ -0,0 +1,333 @@
|
||||
-- Latvian noun paradigms - by Normunds Grūzītis; copied off mini-grammar as of 2011-07-12
|
||||
|
||||
resource ParadigmsNounsLav = open
|
||||
(Predef=Predef),
|
||||
Prelude,
|
||||
ResLav,
|
||||
CatLav
|
||||
in {
|
||||
|
||||
flags
|
||||
coding = utf8;
|
||||
|
||||
oper
|
||||
Noun : Type = {s : Number => Case => Str ; g : Gender} ;
|
||||
|
||||
masculine : Gender = Masc ;
|
||||
feminine : Gender = Fem ;
|
||||
|
||||
-- NOUNS
|
||||
|
||||
-- No parameters - default assumptions (gender, declension, palatalization)
|
||||
mkNoun : Str -> Noun = \lemma ->
|
||||
mkNounByPal lemma True ;
|
||||
|
||||
-- Specified palatalization; default gender and declension
|
||||
mkNounByPal : Str -> Bool -> Noun = \lemma,pal ->
|
||||
case lemma of {
|
||||
#exception_D4 + ("a"|"as") => mkNounByGendPal lemma Masc pal ;
|
||||
#exception_D6 + "is" => mkNounByGendPal lemma Masc pal ;
|
||||
s + ("a"|"as"|"e"|"es"|"šanās") => mkNounByGendPal lemma Fem pal ;
|
||||
_ => mkNounByGendPal lemma Masc pal
|
||||
} ;
|
||||
|
||||
-- Specified gender; default declension and palatalization
|
||||
mkNounByGend : Str -> Gender -> Noun = \lemma,gend ->
|
||||
mkNounByGendPal lemma gend True ;
|
||||
|
||||
-- Specified gender and palatalization; default declension
|
||||
mkNounByGendPal : Str -> Gender -> Bool -> Noun = \lemma,gend,pal ->
|
||||
let decl : NounDecl = case lemma of {
|
||||
#exception_D2_1 + "s" => D2 ;
|
||||
#exception_D2_1_pal + "i" => D2 ;
|
||||
#exception_D2_2 + "s" => D2 ;
|
||||
#exception_D2_2_pal + "i" => D2 ;
|
||||
#exception_D6 + "is" => D6 ;
|
||||
s + "šanās" => DR ;
|
||||
s + ("š"|"i") => D1 ;
|
||||
s + "is" => case gend of {Masc => D2 ; Fem => D6} ;
|
||||
s + "us" => D3 ;
|
||||
s + "as" => D4 ;
|
||||
s + "es" => D5 ;
|
||||
s + "s" => case gend of {Masc => D1 ; Fem => D6} ;
|
||||
s + "a" => D4 ;
|
||||
s + "e" => D5 ;
|
||||
s + #vowel => D0
|
||||
}
|
||||
in mkNounByGendDeclPal lemma gend decl pal ;
|
||||
|
||||
-- Specified declension; default gender and palatalization
|
||||
mkNounByDecl : Str -> NounDecl -> Noun = \lemma,decl ->
|
||||
mkNounByDeclPal lemma decl True ;
|
||||
|
||||
-- Specified declension and palatalization; default gender
|
||||
mkNounByDeclPal : Str -> NounDecl -> Bool -> Noun = \lemma,decl,pal ->
|
||||
case decl of {
|
||||
D0|D1|D2|D3 => mkNounByGendDeclPal lemma Masc decl pal ;
|
||||
D4|D5|D6|DR => mkNounByGendDeclPal lemma Fem decl pal
|
||||
} ;
|
||||
|
||||
-- Specified gender and declension; default palatalization
|
||||
mkNounByGendDecl : Str -> Gender -> NounDecl -> Noun = \lemma,gend,decl ->
|
||||
mkNounByGendDeclPal lemma gend decl True ;
|
||||
|
||||
-- Specified gender, declension and palatalization - no defaults
|
||||
mkNounByGendDeclPal : Str -> Gender -> NounDecl -> Bool -> Noun = \lemma,gend,decl,pal ->
|
||||
case decl of {
|
||||
D0 => mkNoun_D0 lemma gend ;
|
||||
D1 => mkNoun_D1 lemma ;
|
||||
D2 => mkNoun_D2 lemma pal ;
|
||||
D3 => mkNoun_D3 lemma ;
|
||||
D4 => mkNoun_D4 lemma gend ;
|
||||
D5 => mkNoun_D5 lemma gend pal ;
|
||||
D6 => mkNoun_D6 lemma gend pal ;
|
||||
DR => mkNoun_DR lemma
|
||||
} ;
|
||||
|
||||
-- Indeclinable noun
|
||||
-- Expected endings: #vowel
|
||||
mkNoun_D0 : Str -> Gender -> Noun = \lemma,gend -> {
|
||||
s = \\_,_ => lemma ;
|
||||
g = gend
|
||||
} ;
|
||||
|
||||
-- Expected endings of a D1 lemma:
|
||||
-- Sg: -s, -š
|
||||
-- Pl: -i
|
||||
mkNoun_D1 : Str -> Noun = \lemma ->
|
||||
let stem : Str = cutStem lemma
|
||||
in {
|
||||
s = table {
|
||||
Sg => table {
|
||||
Nom => lemma ; -- FIXME: if Pl lemma (-i) => -s or -š?! (default rule, explicit parameter)
|
||||
Gen => stem + "a" ;
|
||||
Dat => stem + "am" ;
|
||||
Acc => stem + "u" ;
|
||||
Loc => stem + "ā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "i" ;
|
||||
Gen => stem + "u" ;
|
||||
Dat => stem + "iem" ;
|
||||
Acc => stem + "us" ;
|
||||
Loc => stem + "os"
|
||||
}
|
||||
} ;
|
||||
g = Masc
|
||||
} ;
|
||||
|
||||
-- Expected endings of a D2 lemma:
|
||||
-- Sg: -is, -s
|
||||
-- Pl: -i
|
||||
-- Note: ending -s is expected only in the case of few predefined exceptions
|
||||
mkNoun_D2 : Str -> Bool -> Noun = \lemma,pal ->
|
||||
let stem : Str = cutStem lemma
|
||||
in {
|
||||
s = table {
|
||||
Sg => table {
|
||||
Nom => lemma ; -- FIXME: if Pl lemma (-i) => -is or -s?! (exceptions only - default rules only?)
|
||||
Gen => case lemma of {#exception_D2_1 + "s" => lemma ; _ => palatalize stem pal + "a"} ;
|
||||
Dat => stem + "im" ;
|
||||
Acc => stem + "i" ;
|
||||
Loc => stem + "ī"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => palatalize stem pal + "i" ;
|
||||
Gen => palatalize stem pal + "u" ;
|
||||
Dat => palatalize stem pal + "iem" ;
|
||||
Acc => palatalize stem pal + "us" ;
|
||||
Loc => palatalize stem pal + "os"
|
||||
}
|
||||
} ;
|
||||
g = Masc
|
||||
} ;
|
||||
|
||||
-- Expected endings of a D3 lemma:
|
||||
-- Sg: -us
|
||||
-- Pl: -i
|
||||
mkNoun_D3 : Str -> Noun = \lemma ->
|
||||
let stem : Str = cutStem lemma
|
||||
in {
|
||||
s = table {
|
||||
Sg => table {
|
||||
Nom => stem + "us" ;
|
||||
Gen => stem + "us" ;
|
||||
Dat => stem + "um" ;
|
||||
Acc => stem + "u" ;
|
||||
Loc => stem + "ū"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "i" ;
|
||||
Gen => stem + "u" ;
|
||||
Dat => stem + "iem" ;
|
||||
Acc => stem + "us" ;
|
||||
Loc => stem + "os"
|
||||
}
|
||||
} ;
|
||||
g = Masc
|
||||
} ;
|
||||
|
||||
-- Expected endings of a D4 lemma:
|
||||
-- Sg: -a (incl. -šana)
|
||||
-- Pl: -as (incl. -šanas)
|
||||
mkNoun_D4 : Str -> Gender -> Noun = \lemma,gend ->
|
||||
let stem : Str = cutStem lemma
|
||||
in {
|
||||
s = table {
|
||||
Sg => table {
|
||||
Nom => stem + "a" ;
|
||||
Gen => stem + "as" ;
|
||||
Dat => case gend of {Fem => stem + "ai" ; Masc => stem + "am"} ;
|
||||
Acc => stem + "u" ;
|
||||
Loc => stem + "ā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "as" ;
|
||||
Gen => stem + "u" ;
|
||||
Dat => stem + "ām" ;
|
||||
Acc => stem + "as" ;
|
||||
Loc => stem + "ās"
|
||||
}
|
||||
} ;
|
||||
g = gend
|
||||
} ;
|
||||
|
||||
-- Expected endings of a D5 lemma:
|
||||
-- Sg: -e
|
||||
-- Pl: -es
|
||||
mkNoun_D5 : Str -> Gender -> Bool -> Noun = \lemma,gend,pal ->
|
||||
let stem : Str = cutStem lemma
|
||||
in {
|
||||
s = table {
|
||||
Sg => table {
|
||||
Nom => stem + "e" ;
|
||||
Gen => stem + "es" ;
|
||||
Dat => case gend of {Fem => stem + "ei" ; Masc => stem + "em"} ;
|
||||
Acc => stem + "i" ;
|
||||
Loc => stem + "ē"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "es" ;
|
||||
Gen => palatalize stem pal + "u" ;
|
||||
Dat => stem + "ēm" ;
|
||||
Acc => stem + "es" ;
|
||||
Loc => stem + "ēs"
|
||||
}
|
||||
} ;
|
||||
g = gend
|
||||
} ;
|
||||
|
||||
-- Expected endings of a D6 lemma:
|
||||
-- Sg: -s
|
||||
-- Pl: -is
|
||||
mkNoun_D6 : Str -> Gender -> Bool -> Noun = \lemma,gend,pal ->
|
||||
let stem : Str = cutStem lemma
|
||||
in {
|
||||
s = table {
|
||||
Sg => case stem of {
|
||||
#exception_D6 => \\_ => NON_EXISTENT ;
|
||||
_ => table {
|
||||
Nom => stem + "s" ;
|
||||
Gen => stem + "s" ;
|
||||
Dat => case gend of {Fem => stem + "ij" ; Masc => stem + "im"} ;
|
||||
Acc => stem + "i" ;
|
||||
Loc => stem + "ī"
|
||||
}
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "is" ;
|
||||
Gen => palatalize stem pal + "u" ;
|
||||
Dat => stem + "īm" ;
|
||||
Acc => stem + "is" ;
|
||||
Loc => stem + "īs"
|
||||
}
|
||||
} ;
|
||||
g = gend
|
||||
} ;
|
||||
|
||||
-- Reflexive noun
|
||||
-- Expected endings: -šanās
|
||||
mkNoun_DR : Str -> Noun = \lemma ->
|
||||
let stem : Str = cutStem lemma
|
||||
in {
|
||||
s = table {
|
||||
Sg => table {
|
||||
Nom => stem + "šanās" ;
|
||||
Gen => stem + "šanās" ;
|
||||
Dat => NON_EXISTENT ;
|
||||
Acc => stem + "šanos" ;
|
||||
Loc => NON_EXISTENT
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "šanās" ;
|
||||
Gen => stem + "šanos" ;
|
||||
Dat => NON_EXISTENT ;
|
||||
Acc => stem + "šanās" ;
|
||||
Loc => NON_EXISTENT
|
||||
}
|
||||
} ;
|
||||
g = Fem
|
||||
} ;
|
||||
|
||||
-- Exceptions
|
||||
|
||||
exception_D2_1 : pattern Str = #(_ + "akmen"|"asmen"|"mēnes"|"ruden"|"sāl"|"ūden"|"ziben") ;
|
||||
exception_D2_1_pal : pattern Str = #(_ + "akmeņ"|"asmeņ"|"mēneš"|"rudeņ"|"sāļ"|"ūdeņ"|"zibeņ") ;
|
||||
exception_D2_2 : pattern Str = #(_ + "sun") ;
|
||||
exception_D2_2_pal : pattern Str = #(_ + "suņ") ;
|
||||
exception_D4 : pattern Str = #(_ + "puik") ;
|
||||
exception_D6 : pattern Str = #(_ + "ļaud") ;
|
||||
|
||||
-- Auxiliaries
|
||||
|
||||
cutStem : Str -> Str = \lemma ->
|
||||
case lemma of {
|
||||
s + ("is"|"us"|"as"|"es") => s ;
|
||||
s + "šanās" => s ;
|
||||
_ => Predef.tk 1 lemma
|
||||
} ;
|
||||
|
||||
palatalize : Str -> Bool -> Str = \stem,pal ->
|
||||
case pal of {
|
||||
True => case stem of {
|
||||
s + "st" => case stem of {
|
||||
s + (#vowel|#sonantCons) + "st" => stem ;
|
||||
_ => doPalatalize stem
|
||||
} ;
|
||||
_ => doPalatalize stem
|
||||
} ;
|
||||
False => stem
|
||||
} ;
|
||||
|
||||
doPalatalize : Str -> Str = \stem ->
|
||||
case stem of {
|
||||
s + c@(#doubleCons) => s + changeDoubleCons c ;
|
||||
s + c@(#simpleCons) => s + changeSimpleCons c ;
|
||||
s + c@(#labialCons) => s + c + "j" ;
|
||||
_ => stem
|
||||
} ;
|
||||
|
||||
changeSimpleCons : Str -> Str = \cons ->
|
||||
case cons of {
|
||||
"c" => "č" ;
|
||||
"d" => "ž" ;
|
||||
"l" => "ļ" ;
|
||||
"n" => "ņ" ;
|
||||
"s" => "š" ;
|
||||
"t" => "š" ;
|
||||
"z" => "ž"
|
||||
} ;
|
||||
|
||||
changeDoubleCons : Str -> Str = \cons ->
|
||||
case cons of {
|
||||
"ll" => "ļļ" ;
|
||||
"ln" => "ļņ" ;
|
||||
"nn" => "ņņ" ;
|
||||
"sl" => "šļ" ;
|
||||
"sn" => "šņ" ;
|
||||
"st" => "š" ;
|
||||
"zl" => "žļ" ;
|
||||
"zn" => "žņ"
|
||||
} ;
|
||||
|
||||
} ;
|
||||
113
lib/src/latvian/ParadigmsPronounsLav.gf
Normal file
113
lib/src/latvian/ParadigmsPronounsLav.gf
Normal file
@@ -0,0 +1,113 @@
|
||||
-- Latvian pronoun paradigms - by Normunds Grūzītis; copied off mini-grammar as of 2011-07-12
|
||||
|
||||
resource ParadigmsPronounsLav = open
|
||||
(Predef=Predef),
|
||||
Prelude,
|
||||
ResLav,
|
||||
CatLav
|
||||
in {
|
||||
|
||||
flags
|
||||
coding = utf8;
|
||||
|
||||
oper
|
||||
Pron : Type = {s : Number => Case => Str ; p : Person} ;
|
||||
PronGend : Type = {s : Gender => Number => Case => Str ; p : Person} ;
|
||||
|
||||
-- PRONOUNS (incl. 'determiners')
|
||||
|
||||
-- Gender=>Number=>Case P3 pronouns
|
||||
-- Expected ending of a lemma: -s or -š (Masc=>Sg=>Nom)
|
||||
-- Examples:
|
||||
-- viņš (he/she)
|
||||
-- kāds (a/some)
|
||||
-- katrs, ikviens, jebkurš (every/everything/everyone/all)
|
||||
-- neviens (no/nothing/noone)
|
||||
-- viss (all)
|
||||
-- kurš (that-relative)
|
||||
mkPronoun_Gend : Str -> PronGend = \lemma ->
|
||||
let stem : Str = Predef.tk 1 lemma
|
||||
in {
|
||||
s = table {
|
||||
Masc => table {
|
||||
Sg => table {
|
||||
Nom => lemma ;
|
||||
Gen => stem + "a" ;
|
||||
Dat => stem + "am" ;
|
||||
Acc => stem + "u" ;
|
||||
Loc => stem + "ā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "i" ;
|
||||
Gen => stem + "u" ;
|
||||
Dat => stem + "iem" ;
|
||||
Acc => stem + "us" ;
|
||||
Loc => stem + "os"
|
||||
}
|
||||
} ;
|
||||
Fem => table {
|
||||
Sg => table {
|
||||
Nom => stem + "a" ;
|
||||
Gen => stem + "as" ;
|
||||
Dat => stem + "ai" ;
|
||||
Acc => stem + "u" ;
|
||||
Loc => stem + "ā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "as" ;
|
||||
Gen => stem + "u" ;
|
||||
Dat => stem + "ām" ;
|
||||
Acc => stem + "as" ;
|
||||
Loc => stem + "ās"
|
||||
}
|
||||
}
|
||||
} ;
|
||||
p = P3
|
||||
} ;
|
||||
|
||||
-- A special case (paradigm) of Gender=>Number=>Case P3 pronouns
|
||||
-- Returns the full paradigm of 'šis' (this) or 'tas' (that)
|
||||
mkPronoun_ThisThat : ThisOrThat -> PronGend = \tot ->
|
||||
let
|
||||
stem : Str = case tot of {This => "š" ; That => "t"} ;
|
||||
suff1 : Str = case tot of {This => "i" ; That => "a"} ;
|
||||
suff2 : Str = case tot of {This => "ī" ; That => "ā"}
|
||||
in {
|
||||
s = table {
|
||||
Masc => table {
|
||||
Sg => table {
|
||||
Nom => stem + suff1 + "s" ;
|
||||
Gen => stem + suff2 ;
|
||||
Dat => stem + suff1 + "m" ;
|
||||
Acc => stem + "o" ;
|
||||
Loc => stem + "ajā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + "ie" ;
|
||||
Gen => stem + "o" ;
|
||||
Dat => stem + "iem" ;
|
||||
Acc => stem + "os" ;
|
||||
Loc => stem + "ajos"
|
||||
}
|
||||
} ;
|
||||
Fem => table {
|
||||
Sg => table {
|
||||
Nom => stem + suff2 ;
|
||||
Gen => stem + suff2 + "s" ;
|
||||
Dat => stem + "ai" ;
|
||||
Acc => stem + "o" ;
|
||||
Loc => stem + "ajā"
|
||||
} ;
|
||||
Pl => table {
|
||||
Nom => stem + suff2 + "s" ;
|
||||
Gen => stem + "o" ;
|
||||
Dat => stem + suff2 + "m" ;
|
||||
Acc => stem + suff2 + "s" ;
|
||||
Loc => stem + "ajās"
|
||||
}
|
||||
}
|
||||
} ;
|
||||
p = P3
|
||||
} ;
|
||||
|
||||
} ;
|
||||
562
lib/src/latvian/ParadigmsVerbsLav.gf
Normal file
562
lib/src/latvian/ParadigmsVerbsLav.gf
Normal file
@@ -0,0 +1,562 @@
|
||||
-- Latvian verb paradigms - by Pēteris Paikens & Normunds Grūzītis, copied off mini-grammar as of 2011-07-12
|
||||
|
||||
resource ParadigmsVerbsLav = open
|
||||
(Predef=Predef),
|
||||
Prelude,
|
||||
ResLav,
|
||||
CatLav
|
||||
in {
|
||||
|
||||
flags
|
||||
coding = utf8;
|
||||
|
||||
oper
|
||||
Verb : Type = {s : Polarity => VerbForm => Str} ;
|
||||
Verb_TMP : Type = {s : VerbForm => Str} ;
|
||||
|
||||
-- VERBS
|
||||
|
||||
-- Second and third conjugations
|
||||
mkVerb : Str -> VerbConj -> Verb = \lemma,conj -> {
|
||||
s = table {
|
||||
Pos => (mkVerb_Pos lemma conj).s ;
|
||||
Neg => (filter_Neg (mkVerb_Pos ("ne"+lemma) conj)).s
|
||||
}
|
||||
} ;
|
||||
|
||||
-- First conjugation
|
||||
mkVerbC1 : Str -> Str -> Str -> Verb = \lemma,lemma2,lemma3 -> {
|
||||
s = table {
|
||||
Pos => (mkVerbC1_Pos lemma lemma2 lemma3).s ;
|
||||
Neg => (filter_Neg (mkVerbC1_Pos ("ne"+lemma) ("ne"+lemma2) ("ne"+lemma3))).s
|
||||
}
|
||||
} ;
|
||||
|
||||
mkVerb_Pos : Str -> VerbConj -> Verb_TMP = \lemma,conj ->
|
||||
case lemma of {
|
||||
-- TODO: "ir" =>
|
||||
s + ("t") => mkRegVerb lemma conj ;
|
||||
s + ("ties") => mkReflVerb lemma conj
|
||||
} ;
|
||||
|
||||
mkVerbC1_Pos : Str -> Str -> Str -> Verb_TMP = \lemma,lemma2,lemma3 ->
|
||||
case lemma of {
|
||||
-- TODO: "ir" =>
|
||||
s + ("t") => mkVerb_C1 lemma lemma2 lemma3 ;
|
||||
s + ("ties") => mkVerb_C1_R lemma lemma2 lemma3
|
||||
} ;
|
||||
|
||||
mkRegVerb : Str -> VerbConj -> Verb_TMP = \lemma,conj ->
|
||||
case conj of {
|
||||
C2 => mkVerb_C2 lemma ;
|
||||
C3 => mkVerb_C3 lemma
|
||||
} ;
|
||||
|
||||
mkReflVerb : Str -> VerbConj -> Verb_TMP = \lemma,conj ->
|
||||
case conj of {
|
||||
C2 => mkVerb_C2_R lemma ;
|
||||
C3 => mkVerb_C3_R lemma
|
||||
} ;
|
||||
|
||||
filter_Neg : Verb_TMP -> Verb_TMP = \full -> {
|
||||
s = table {
|
||||
Debitive => NON_EXISTENT ;
|
||||
DebitiveRelative => NON_EXISTENT ;
|
||||
x => full.s ! x
|
||||
}
|
||||
} ;
|
||||
|
||||
-- First conjugation
|
||||
-- Ref. to Lexicon.xml (revision 719): 15. paradigma
|
||||
mkVerb_C1 : Str -> Str -> Str -> Verb_TMP = \lemma,lemma2,lemma3 ->
|
||||
let
|
||||
stem : Str = Predef.tk 1 lemma ;
|
||||
stem2 : Str = Predef.tk 1 lemma2 ;
|
||||
stem3 : Str = Predef.tk 1 lemma3
|
||||
in {
|
||||
s = table {
|
||||
Infinitive => stem + "t" ;
|
||||
|
||||
Indicative P1 Sg Pres => stem2 + "u" ;
|
||||
Indicative P1 Sg Fut => pal_C1_1 stem3 stem + "šu" ;
|
||||
Indicative P1 Sg Past => stem3 + "u" ;
|
||||
Indicative P1 Pl Pres => stem2 + "am" ;
|
||||
Indicative P1 Pl Fut => pal_C1_1 stem3 stem + "sim" ;
|
||||
Indicative P1 Pl Past => stem3 + "ām" ;
|
||||
|
||||
Indicative P2 Sg Pres => pal_C1_2 stem3 stem2 ;
|
||||
Indicative P2 Sg Fut => pal_C1_1 stem3 stem + "si" ;
|
||||
Indicative P2 Sg Past => stem3 + "i" ;
|
||||
Indicative P2 Pl Pres => stem2 + "at" ;
|
||||
Indicative P2 Pl Fut => pal_C1_1 stem3 stem + ("siet"|"sit") ;
|
||||
Indicative P2 Pl Past => stem3 + "āt" ;
|
||||
|
||||
Indicative P3 _ Pres => stem2 ;
|
||||
Indicative P3 _ Fut => pal_C1_1 stem3 stem + "s" ;
|
||||
Indicative P3 _ Past => stem3 + "a" ;
|
||||
|
||||
Indicative _ _ Cond => stem + "tu";
|
||||
|
||||
Relative Pres => stem2 + "ot" ;
|
||||
Relative Fut => pal_C1_1 stem3 stem + "šot" ;
|
||||
Relative Past => NON_EXISTENT ;
|
||||
Relative Cond => NON_EXISTENT ;
|
||||
|
||||
Debitive => "jā" + stem2 ;
|
||||
DebitiveRelative => "jā" + stem2 + "ot" ;
|
||||
|
||||
Participle Masc Sg Nom => pal_C1_4 stem3 + "is" ;
|
||||
Participle Masc Sg Gen => pal_C1_3 stem3 + "uša" ;
|
||||
Participle Masc Sg Dat => pal_C1_3 stem3 + "ušam" ;
|
||||
Participle Masc Sg Acc => pal_C1_3 stem3 + "ušu" ;
|
||||
Participle Masc Sg Loc => pal_C1_3 stem3 + "ušā" ;
|
||||
Participle Masc Pl Nom => pal_C1_3 stem3 + "uši" ;
|
||||
Participle Masc Pl Gen => pal_C1_3 stem3 + "ušu" ;
|
||||
Participle Masc Pl Dat => pal_C1_3 stem3 + "ušiem" ;
|
||||
Participle Masc Pl Acc => pal_C1_3 stem3 + "ušus" ;
|
||||
Participle Masc Pl Loc => pal_C1_3 stem3 + "ušos" ;
|
||||
|
||||
Participle Fem Sg Nom => pal_C1_3 stem3 + "usi" ;
|
||||
Participle Fem Sg Gen => pal_C1_3 stem3 + "ušas" ;
|
||||
Participle Fem Sg Dat => pal_C1_3 stem3 + "ušai" ;
|
||||
Participle Fem Sg Acc => pal_C1_3 stem3 + "ušu" ;
|
||||
Participle Fem Sg Loc => pal_C1_3 stem3 + "ušā" ;
|
||||
Participle Fem Pl Nom => pal_C1_3 stem3 + "ušas" ;
|
||||
Participle Fem Pl Gen => pal_C1_3 stem3 + "ušu" ;
|
||||
Participle Fem Pl Dat => pal_C1_3 stem3 + "ušām" ;
|
||||
Participle Fem Pl Acc => pal_C1_3 stem3 + "ušas" ;
|
||||
Participle Fem Pl Loc => pal_C1_3 stem3 + "ušās"
|
||||
}
|
||||
} ;
|
||||
|
||||
-- Second conjugation
|
||||
-- Ref. to Lexicon.xml (revision 719): 16. paradigma
|
||||
mkVerb_C2 : Str -> Verb_TMP = \lemma ->
|
||||
let stem : Str = Predef.tk 1 lemma
|
||||
in {
|
||||
s = table {
|
||||
Infinitive => stem + "t" ;
|
||||
|
||||
Indicative P1 Sg Pres => stem + "ju" ;
|
||||
Indicative P1 Sg Fut => stem + "šu" ;
|
||||
Indicative P1 Sg Past => stem + "ju" ;
|
||||
Indicative P1 Pl Pres => stem + "jam" ;
|
||||
Indicative P1 Pl Fut => stem + "sim" ;
|
||||
Indicative P1 Pl Past => stem + "jām" ;
|
||||
|
||||
Indicative P2 Sg Pres => stem ;
|
||||
Indicative P2 Sg Fut => stem + "si" ;
|
||||
Indicative P2 Sg Past => stem + "ji" ;
|
||||
Indicative P2 Pl Pres => stem + "jat" ;
|
||||
Indicative P2 Pl Fut => stem + ("siet"|"sit") ;
|
||||
Indicative P2 Pl Past => stem + "jāt" ;
|
||||
|
||||
Indicative P3 _ Pres => stem ;
|
||||
Indicative P3 _ Fut => stem + "s" ;
|
||||
Indicative P3 _ Past => stem + "ja" ;
|
||||
|
||||
Indicative _ _ Cond => stem + "tu";
|
||||
|
||||
Relative Pres => stem + "jot" ;
|
||||
Relative Fut => stem + "šot" ;
|
||||
Relative Past => NON_EXISTENT ;
|
||||
Relative Cond => NON_EXISTENT ;
|
||||
|
||||
Debitive => "jā" + stem ;
|
||||
DebitiveRelative => "jā" + stem + "jot" ;
|
||||
|
||||
Participle Masc Sg Nom => stem + "jis" ;
|
||||
Participle Masc Sg Gen => stem + "juša" ;
|
||||
Participle Masc Sg Dat => stem + "jušam" ;
|
||||
Participle Masc Sg Acc => stem + "jušu" ;
|
||||
Participle Masc Sg Loc => stem + "jušā" ;
|
||||
Participle Masc Pl Nom => stem + "juši" ;
|
||||
Participle Masc Pl Gen => stem + "jušu" ;
|
||||
Participle Masc Pl Dat => stem + "jušiem" ;
|
||||
Participle Masc Pl Acc => stem + "jušus" ;
|
||||
Participle Masc Pl Loc => stem + "jušos" ;
|
||||
|
||||
Participle Fem Sg Nom => stem + "jusi" ;
|
||||
Participle Fem Sg Gen => stem + "jušas" ;
|
||||
Participle Fem Sg Dat => stem + "jušai" ;
|
||||
Participle Fem Sg Acc => stem + "jušu" ;
|
||||
Participle Fem Sg Loc => stem + "jušā" ;
|
||||
Participle Fem Pl Nom => stem + "jušas" ;
|
||||
Participle Fem Pl Gen => stem + "jušu" ;
|
||||
Participle Fem Pl Dat => stem + "jušām" ;
|
||||
Participle Fem Pl Acc => stem + "jušas" ;
|
||||
Participle Fem Pl Loc => stem + "jušās"
|
||||
}
|
||||
} ;
|
||||
|
||||
-- Third conjugation
|
||||
-- Ref. to Lexicon.xml (revision 719): 17. paradigma
|
||||
mkVerb_C3 : Str -> Verb_TMP = \lemma ->
|
||||
let stem : Str = Predef.tk 1 lemma
|
||||
in {
|
||||
s = table {
|
||||
Infinitive => stem + "t" ;
|
||||
|
||||
Indicative P1 Sg Pres => pal_C3_1 stem + "u" ;
|
||||
Indicative P1 Sg Fut => stem + "šu" ;
|
||||
Indicative P1 Sg Past => stem + "ju" ;
|
||||
Indicative P1 Pl Pres => pal_C3_1 stem + pal_C3_2 stem "am" ;
|
||||
Indicative P1 Pl Fut => stem + "sim" ;
|
||||
Indicative P1 Pl Past => stem + "jām" ;
|
||||
|
||||
Indicative P2 Sg Pres => pal_C3_1 stem + "i" ;
|
||||
Indicative P2 Sg Fut => stem + "si" ;
|
||||
Indicative P2 Sg Past => stem + "ji" ;
|
||||
Indicative P2 Pl Pres => pal_C3_1 stem + pal_C3_2 stem "at" ;
|
||||
Indicative P2 Pl Fut => stem + ("siet"|"sit") ;
|
||||
Indicative P2 Pl Past => stem + "jāt" ;
|
||||
|
||||
Indicative P3 _ Pres => pal_C3_5 stem ;
|
||||
Indicative P3 _ Fut => stem + "s" ;
|
||||
Indicative P3 _ Past => stem + "ja" ;
|
||||
|
||||
Indicative _ _ Cond => stem + "tu";
|
||||
|
||||
Relative Pres => pal_C3_1 stem + "ot" ;
|
||||
Relative Fut => stem + "šot" ;
|
||||
Relative Past => NON_EXISTENT ;
|
||||
Relative Cond => NON_EXISTENT ;
|
||||
|
||||
Debitive => pal_C3_3 stem ;
|
||||
DebitiveRelative => pal_C3_3 stem + "ot" ;
|
||||
|
||||
Participle Masc Sg Nom => stem + "jis" ;
|
||||
Participle Masc Sg Gen => stem + "juša" ;
|
||||
Participle Masc Sg Dat => stem + "jušam" ;
|
||||
Participle Masc Sg Acc => stem + "jušu" ;
|
||||
Participle Masc Sg Loc => stem + "jušā" ;
|
||||
Participle Masc Pl Nom => stem + "juši" ;
|
||||
Participle Masc Pl Gen => stem + "jušu" ;
|
||||
Participle Masc Pl Dat => stem + "jušiem" ;
|
||||
Participle Masc Pl Acc => stem + "jušus" ;
|
||||
Participle Masc Pl Loc => stem + "jušos" ;
|
||||
|
||||
Participle Fem Sg Nom => stem + "jusi" ;
|
||||
Participle Fem Sg Gen => stem + "jušas" ;
|
||||
Participle Fem Sg Dat => stem + "jušai" ;
|
||||
Participle Fem Sg Acc => stem + "jušu" ;
|
||||
Participle Fem Sg Loc => stem + "jušā" ;
|
||||
Participle Fem Pl Nom => stem + "jušas" ;
|
||||
Participle Fem Pl Gen => stem + "jušu" ;
|
||||
Participle Fem Pl Dat => stem + "jušām" ;
|
||||
Participle Fem Pl Acc => stem + "jušas" ;
|
||||
Participle Fem Pl Loc => stem + "jušās"
|
||||
}
|
||||
} ;
|
||||
|
||||
-- First conjugation: reflexive verbs
|
||||
-- Ref. to Lexicon.xml (revision 719): 18. paradigma
|
||||
mkVerb_C1_R : Str -> Str -> Str -> Verb_TMP = \lemma,lemma2,lemma3 ->
|
||||
let
|
||||
stem : Str = Predef.tk 4 lemma ;
|
||||
stem2 : Str = Predef.tk 2 lemma2 ;
|
||||
stem3 : Str = Predef.tk 2 lemma3
|
||||
in {
|
||||
s = table {
|
||||
Infinitive => stem + "ties" ;
|
||||
|
||||
Indicative P1 Sg Pres => stem2 + "os" ;
|
||||
Indicative P1 Sg Fut => pal_C1_1 stem3 stem + "šos" ;
|
||||
Indicative P1 Sg Past => stem3 + "os" ;
|
||||
Indicative P1 Pl Pres => stem2 + "amies" ;
|
||||
Indicative P1 Pl Fut => pal_C1_1 stem3 stem + "simies" ;
|
||||
Indicative P1 Pl Past => stem3 + "āmies" ;
|
||||
|
||||
Indicative P2 Sg Pres => pal_C1_2 stem3 stem2 + "ies" ;
|
||||
Indicative P2 Sg Fut => pal_C1_1 stem3 stem + "sies" ;
|
||||
Indicative P2 Sg Past => stem3 + "ies" ;
|
||||
Indicative P2 Pl Pres => stem2 + "aties" ;
|
||||
Indicative P2 Pl Fut => pal_C1_1 stem3 stem + ("sieties"|"sities") ;
|
||||
Indicative P2 Pl Past => stem3 + "āties" ;
|
||||
|
||||
Indicative P3 _ Pres => stem2 + "as" ;
|
||||
Indicative P3 _ Fut => pal_C1_1 stem3 stem + "sies" ;
|
||||
Indicative P3 _ Past => stem3 + "ās" ;
|
||||
|
||||
Indicative _ _ Cond => stem + "tos";
|
||||
|
||||
Relative Pres => stem2 + "oties" ;
|
||||
Relative Fut => pal_C1_1 stem3 stem + "šoties" ;
|
||||
Relative Past => NON_EXISTENT ;
|
||||
Relative Cond => NON_EXISTENT ;
|
||||
|
||||
Debitive => "jā" + stem2 + "as" ;
|
||||
DebitiveRelative => "jā" + stem2 + "oties" ;
|
||||
|
||||
Participle Masc Sg Nom => pal_C1_4 stem3 + "ies" ;
|
||||
Participle Masc Sg Gen => NON_EXISTENT ;
|
||||
Participle Masc Sg Dat => NON_EXISTENT ;
|
||||
Participle Masc Sg Acc => pal_C1_3 stem3 + "ušos" ;
|
||||
Participle Masc Sg Loc => NON_EXISTENT ;
|
||||
Participle Masc Pl Nom => pal_C1_3 stem3 + "ušies" ;
|
||||
Participle Masc Pl Gen => pal_C1_3 stem3 + "ušos" ;
|
||||
Participle Masc Pl Dat => NON_EXISTENT ;
|
||||
Participle Masc Pl Acc => pal_C1_3 stem3 + "ušos" ;
|
||||
Participle Masc Pl Loc => NON_EXISTENT ;
|
||||
|
||||
Participle Fem Sg Nom => pal_C1_3 stem3 + "usies" ;
|
||||
Participle Fem Sg Gen => pal_C1_3 stem3 + "ušās" ;
|
||||
Participle Fem Sg Dat => NON_EXISTENT ;
|
||||
Participle Fem Sg Acc => pal_C1_3 stem3 + "ušos" ;
|
||||
Participle Fem Sg Loc => NON_EXISTENT ;
|
||||
Participle Fem Pl Nom => pal_C1_3 stem3 + "ušās" ;
|
||||
Participle Fem Pl Gen => pal_C1_3 stem3 + "ušos" ;
|
||||
Participle Fem Pl Dat => NON_EXISTENT ;
|
||||
Participle Fem Pl Acc => pal_C1_3 stem3 + "ušos" ;
|
||||
Participle Fem Pl Loc => NON_EXISTENT
|
||||
}
|
||||
} ;
|
||||
|
||||
-- Second conjugation: reflexive verbs
|
||||
-- Ref. to Lexicon.xml (revision 719): 19. paradigma
|
||||
mkVerb_C2_R : Str -> Verb_TMP = \lemma ->
|
||||
let stem : Str = Predef.tk 4 lemma
|
||||
in {
|
||||
s = table {
|
||||
Infinitive => stem + "ties" ;
|
||||
|
||||
Indicative P1 Sg Pres => stem + "jos" ;
|
||||
Indicative P1 Sg Fut => stem + "šos" ;
|
||||
Indicative P1 Sg Past => stem + "jos" ;
|
||||
Indicative P1 Pl Pres => stem + "jamies" ;
|
||||
Indicative P1 Pl Fut => stem + "simies" ;
|
||||
Indicative P1 Pl Past => stem + "jāmies" ;
|
||||
|
||||
Indicative P2 Sg Pres => stem + "jies" ;
|
||||
Indicative P2 Sg Fut => stem + "sies" ;
|
||||
Indicative P2 Sg Past => stem + "jies" ;
|
||||
Indicative P2 Pl Pres => stem + "jaties" ;
|
||||
Indicative P2 Pl Fut => stem + ("sieties"|"sities") ;
|
||||
Indicative P2 Pl Past => stem + "jāties" ;
|
||||
|
||||
Indicative P3 _ Pres => stem + "jas" ;
|
||||
Indicative P3 _ Fut => stem + "sies" ;
|
||||
Indicative P3 _ Past => stem + "jās" ;
|
||||
|
||||
Indicative _ _ Cond => stem + "tos";
|
||||
|
||||
Relative Pres => stem + "joties" ;
|
||||
Relative Fut => stem + "šoties" ;
|
||||
Relative Past => NON_EXISTENT ;
|
||||
Relative Cond => NON_EXISTENT ;
|
||||
|
||||
Debitive => "jā" + stem + "jas" ;
|
||||
DebitiveRelative => "jā" + stem + "joties" ;
|
||||
|
||||
Participle Masc Sg Nom => stem + "jies" ;
|
||||
Participle Masc Sg Gen => NON_EXISTENT ;
|
||||
Participle Masc Sg Dat => NON_EXISTENT ;
|
||||
Participle Masc Sg Acc => stem + "jušos" ;
|
||||
Participle Masc Sg Loc => NON_EXISTENT ;
|
||||
Participle Masc Pl Nom => stem + "jušies" ;
|
||||
Participle Masc Pl Gen => stem + "jušos" ;
|
||||
Participle Masc Pl Dat => NON_EXISTENT ;
|
||||
Participle Masc Pl Acc => stem + "jušos" ;
|
||||
Participle Masc Pl Loc => NON_EXISTENT ;
|
||||
|
||||
Participle Fem Sg Nom => stem + "jusies" ;
|
||||
Participle Fem Sg Gen => stem + "jušās" ;
|
||||
Participle Fem Sg Dat => NON_EXISTENT ;
|
||||
Participle Fem Sg Acc => stem + "jušos" ;
|
||||
Participle Fem Sg Loc => NON_EXISTENT ;
|
||||
Participle Fem Pl Nom => stem + "jušās" ;
|
||||
Participle Fem Pl Gen => stem + "jušos" ;
|
||||
Participle Fem Pl Dat => NON_EXISTENT ;
|
||||
Participle Fem Pl Acc => stem + "jušās" ;
|
||||
Participle Fem Pl Loc => NON_EXISTENT
|
||||
}
|
||||
} ;
|
||||
|
||||
-- Third conjugation: reflexive verbs
|
||||
-- Ref. to Lexicon.xml (revision 719): 20. paradigma
|
||||
mkVerb_C3_R : Str -> Verb_TMP = \lemma ->
|
||||
let stem : Str = Predef.tk 4 lemma
|
||||
in {
|
||||
s = table {
|
||||
Infinitive => stem + "ties" ;
|
||||
|
||||
Indicative P1 Sg Pres => pal_C3_1 stem + "os" ;
|
||||
Indicative P1 Sg Fut => stem + "šos" ;
|
||||
Indicative P1 Sg Past => stem + "jos" ;
|
||||
Indicative P1 Pl Pres => pal_C3_4 stem + "mies" ;
|
||||
Indicative P1 Pl Fut => stem + "simies" ;
|
||||
Indicative P1 Pl Past => stem + "jāmies" ;
|
||||
|
||||
Indicative P2 Sg Pres => pal_C3_1 stem + "ies" ;
|
||||
Indicative P2 Sg Fut => stem + "sies" ;
|
||||
Indicative P2 Sg Past => stem + "jies" ;
|
||||
Indicative P2 Pl Pres => pal_C3_4 stem + "ties" ;
|
||||
Indicative P2 Pl Fut => stem + ("sieties"|"sities") ;
|
||||
Indicative P2 Pl Past => stem + "jāties" ;
|
||||
|
||||
Indicative P3 _ Pres => pal_C3_4 stem + "s" ;
|
||||
Indicative P3 _ Fut => stem + "sies" ;
|
||||
Indicative P3 _ Past => stem + "jās" ;
|
||||
|
||||
Indicative _ _ Cond => stem + "tos";
|
||||
|
||||
Relative Pres => pal_C3_1 stem + "oties" ;
|
||||
Relative Fut => stem + "šoties" ;
|
||||
Relative Past => NON_EXISTENT ;
|
||||
Relative Cond => NON_EXISTENT ;
|
||||
|
||||
Debitive => pal_C3_6 stem + "s" ;
|
||||
DebitiveRelative => pal_C3_6 stem + "oties" ;
|
||||
|
||||
Participle Masc Sg Nom => stem + "jies" ;
|
||||
Participle Masc Sg Gen => NON_EXISTENT ;
|
||||
Participle Masc Sg Dat => NON_EXISTENT ;
|
||||
Participle Masc Sg Acc => stem + "jušos" ;
|
||||
Participle Masc Sg Loc => NON_EXISTENT ;
|
||||
Participle Masc Pl Nom => stem + "jušies" ;
|
||||
Participle Masc Pl Gen => stem + "jušos" ;
|
||||
Participle Masc Pl Dat => NON_EXISTENT ;
|
||||
Participle Masc Pl Acc => stem + "jušos" ;
|
||||
Participle Masc Pl Loc => NON_EXISTENT ;
|
||||
|
||||
Participle Fem Sg Nom => stem + "jusies" ;
|
||||
Participle Fem Sg Gen => stem + "jušās" ;
|
||||
Participle Fem Sg Dat => NON_EXISTENT ;
|
||||
Participle Fem Sg Acc => stem + "jušos" ;
|
||||
Participle Fem Sg Loc => NON_EXISTENT ;
|
||||
Participle Fem Pl Nom => stem + "jušās" ;
|
||||
Participle Fem Pl Gen => stem + "jušos" ;
|
||||
Participle Fem Pl Dat => NON_EXISTENT ;
|
||||
Participle Fem Pl Acc => stem + "jušās" ;
|
||||
Participle Fem Pl Loc => NON_EXISTENT
|
||||
}
|
||||
} ;
|
||||
|
||||
mkVerb_Irreg : Str -> Verb = \lemma ->
|
||||
case lemma of {
|
||||
"būt" => mkVerb_toBe
|
||||
} ;
|
||||
|
||||
mkVerb_toBe : Verb = {
|
||||
s = table {
|
||||
Pos => table {
|
||||
Indicative P1 Sg Pres => "esmu" ;
|
||||
Indicative P2 Sg Pres => "esi" ;
|
||||
Indicative P3 _ Pres => "ir" ;
|
||||
Debitive => "jābūt" ;
|
||||
x => (mkVerb_C1 "būt" "esu" "biju").s ! x -- the incorrect form 'esu' will be overriden
|
||||
} ;
|
||||
Neg => table {
|
||||
Indicative P1 Sg Pres => "neesmu" ;
|
||||
Indicative P2 Sg Pres => "neesi" ;
|
||||
Indicative P3 _ Pres => "nav" ;
|
||||
Debitive => NON_EXISTENT;
|
||||
DebitiveRelative => NON_EXISTENT;
|
||||
x => (mkVerb_C1 "nebūt" "neesu" "nebiju").s ! x -- the incorrect form 'neesu' will be overriden
|
||||
}
|
||||
}
|
||||
} ;
|
||||
|
||||
-- Auxiliaries (palatalization rules)
|
||||
|
||||
-- Ref. to the Java implementation: mija6
|
||||
pal_C1_1 : Str -> Str -> Str = \stem3,stem ->
|
||||
case stem of {
|
||||
s + "s" => case stem3 of {
|
||||
_ + "d" => s + "dī" ;
|
||||
_ + "t" => s + "tī" ;
|
||||
_ + "s" => s + "sī" ;
|
||||
_ => stem
|
||||
} ;
|
||||
_ => stem
|
||||
} ;
|
||||
|
||||
-- Ref. to the Java implementation: mija7
|
||||
pal_C1_2 : Str -> Str -> Str = \stem3,stem ->
|
||||
case stem of {
|
||||
s + "š" => case stem3 of {
|
||||
_ + "s" => s + "s" ;
|
||||
_ => stem
|
||||
} ;
|
||||
s + "ž" => s + "d" ;
|
||||
s + "ļ" => s + "l" ;
|
||||
s + "mj" => s + "m" ;
|
||||
s + "bj" => s + "b" ;
|
||||
s + "pj" => s + "p" ;
|
||||
s + "k" => s + "c" ;
|
||||
s + "g" => s + "dz" ;
|
||||
_ => stem
|
||||
} ;
|
||||
|
||||
-- Ref. to the Java implementation: mija11
|
||||
pal_C1_3 : Str -> Str = \stem ->
|
||||
case stem of {
|
||||
s + "c" => s + "k" ;
|
||||
s + "dz" => s + "g" ;
|
||||
_ => stem
|
||||
} ;
|
||||
|
||||
-- Ref. to the Java implementation: mija14
|
||||
pal_C1_4 : Str -> Str = \stem ->
|
||||
case stem of {
|
||||
s + "k" => s + "c" ;
|
||||
_ => stem
|
||||
} ;
|
||||
|
||||
-- Ref. to the Java implementation: mija2
|
||||
pal_C3_1 : Str -> Str = \stem ->
|
||||
case stem of {
|
||||
s + "cī" => s + "k" ;
|
||||
_ => Predef.tk 1 stem
|
||||
} ;
|
||||
|
||||
-- Ref. to the Java implementation: mija2a
|
||||
pal_C3_2 : Str -> Str -> Str = \stem,ending ->
|
||||
case stem of {
|
||||
_ + "ī" => "ā" + Predef.dp 1 ending ;
|
||||
_ + "inā" => "ā" + Predef.dp 1 ending ;
|
||||
_ => ending
|
||||
} ;
|
||||
|
||||
-- Ref. to the Java implementation: mija5
|
||||
pal_C3_3 : Str -> Str = \stem ->
|
||||
"jā" +
|
||||
case stem of {
|
||||
s + "dā" => s + "d" ;
|
||||
s + "ā" => s + "a" ;
|
||||
s + "cī" => s + "ka" ;
|
||||
s + "ī" => s + "a" ;
|
||||
_ => Predef.tk 1 stem
|
||||
} ;
|
||||
|
||||
-- Ref. to the Java implementation: mija8
|
||||
pal_C3_4 : Str -> Str = \stem ->
|
||||
case stem of {
|
||||
s + "inā" => stem ;
|
||||
s + "cī" => s + "kā" ; -- e.g. 'sacīt'
|
||||
s + "ī" => s + "ā" ;
|
||||
s + "ē" => s + "a" ;
|
||||
_ => stem
|
||||
} ;
|
||||
|
||||
-- Ref. to the Java implementation: mija9
|
||||
pal_C3_5 : Str -> Str = \stem ->
|
||||
case stem of {
|
||||
s + "dā" => Predef.tk 1 stem ;
|
||||
s + "ā" => s + "a" ;
|
||||
s + "cī" => s + "ka" ; -- e.g. 'sacīt'
|
||||
s + "ī" => s + "a" ;
|
||||
_ => Predef.tk 1 stem
|
||||
} ;
|
||||
|
||||
-- Ref. to the Java implementation: mija12
|
||||
pal_C3_6 : Str -> Str = \stem ->
|
||||
"jā" +
|
||||
case stem of {
|
||||
s + "cī" => s + "kā" ;
|
||||
s + "ī" => s + "ā" ;
|
||||
s + "inā" => s + "inā" ;
|
||||
_ => Predef.tk 1 stem + "a"
|
||||
} ;
|
||||
|
||||
} ;
|
||||
29
lib/src/latvian/PhraseLav.gf
Normal file
29
lib/src/latvian/PhraseLav.gf
Normal file
@@ -0,0 +1,29 @@
|
||||
concrete PhraseLav of Phrase = CatLav ** open Prelude, ResLav in {
|
||||
lin
|
||||
PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ;
|
||||
UttS s = s ;
|
||||
|
||||
NoPConj = {s = []} ;
|
||||
NoVoc = {s = []} ;
|
||||
|
||||
{-
|
||||
|
||||
UttQS qs = {s = qs.s ! QDir} ;
|
||||
UttImpSg pol imp = {s = pol.s ++ imp.s ! contrNeg True pol.p ! ImpF Sg False} ;
|
||||
UttImpPl pol imp = {s = pol.s ++ imp.s ! contrNeg True pol.p ! ImpF Pl False} ;
|
||||
UttImpPol pol imp = {s = pol.s ++ imp.s ! contrNeg True pol.p ! ImpF Sg True} ;
|
||||
|
||||
UttIP ip = {s = ip.s ! Nom} ; --- Acc also
|
||||
UttIAdv iadv = iadv ;
|
||||
UttNP np = {s = np.s ! Nom} ;
|
||||
UttVP vp = {s = infVP False vp (agrP3 Sg)} ;
|
||||
UttAdv adv = adv ;
|
||||
UttCN n = {s = n.s ! Sg ! Nom} ;
|
||||
UttCard n = {s = n.s ! Nom} ;
|
||||
UttAP ap = {s = ap.s ! agrP3 Sg} ;
|
||||
|
||||
PConjConj conj = {s = conj.s2} ; ---
|
||||
|
||||
VocNP np = {s = "," ++ np.s ! Nom} ;
|
||||
-}
|
||||
}
|
||||
55
lib/src/latvian/QuestionLav.gf
Normal file
55
lib/src/latvian/QuestionLav.gf
Normal file
@@ -0,0 +1,55 @@
|
||||
concrete QuestionLav of Question = CatLav ** open ResLav, Prelude in {
|
||||
{-
|
||||
flags optimize=all_subs ;
|
||||
|
||||
lin
|
||||
|
||||
QuestCl cl = {
|
||||
s = \\t,a,p =>
|
||||
let cls = cl.s ! t ! a ! p
|
||||
in table {
|
||||
QDir => cls ! OQuest ;
|
||||
QIndir => "if" ++ cls ! ODir
|
||||
} ---- "whether" in ExtEng
|
||||
} ;
|
||||
|
||||
QuestVP qp vp =
|
||||
let cl = mkClause (qp.s ! Nom) (agrP3 qp.n) vp
|
||||
in {s = \\t,a,b,_ => cl.s ! t ! a ! b ! ODir} ;
|
||||
|
||||
QuestSlash ip slash =
|
||||
mkQuestion (ss (slash.c2 ++ ip.s ! Acc)) slash ;
|
||||
--- stranding in ExratEng
|
||||
|
||||
QuestIAdv iadv cl = mkQuestion iadv cl ;
|
||||
|
||||
QuestIComp icomp np =
|
||||
mkQuestion icomp (mkClause (np.s ! Nom) np.a (predAux auxBe)) ;
|
||||
|
||||
|
||||
PrepIP p ip = {s = p.s ++ ip.s ! Acc} ;
|
||||
|
||||
AdvIP ip adv = {
|
||||
s = \\c => ip.s ! c ++ adv.s ;
|
||||
n = ip.n
|
||||
} ;
|
||||
|
||||
IdetCN idet cn = {
|
||||
s = \\c => idet.s ++ cn.s ! idet.n ! c ;
|
||||
n = idet.n
|
||||
} ;
|
||||
|
||||
IdetIP idet = {
|
||||
s = \\c => idet.s ;
|
||||
n = idet.n
|
||||
} ;
|
||||
|
||||
IdetQuant idet num = {
|
||||
s = idet.s ! num.n ++ num.s ! Nom ;
|
||||
n = num.n
|
||||
} ;
|
||||
|
||||
CompIAdv a = a ;
|
||||
CompIP p = ss (p.s ! Nom) ;
|
||||
-}
|
||||
}
|
||||
52
lib/src/latvian/RelativeLav.gf
Normal file
52
lib/src/latvian/RelativeLav.gf
Normal file
@@ -0,0 +1,52 @@
|
||||
concrete RelativeLav of Relative = CatLav ** open ResLav in {
|
||||
{-
|
||||
flags optimize=all_subs ;
|
||||
|
||||
lin
|
||||
|
||||
RelCl cl = {
|
||||
s = \\t,a,p,_ => "such" ++ "that" ++ cl.s ! t ! a ! p ! ODir ;
|
||||
c = Nom
|
||||
} ;
|
||||
|
||||
RelVP rp vp = {
|
||||
s = \\t,ant,b,ag =>
|
||||
let
|
||||
agr = case rp.a of {
|
||||
RNoAg => ag ;
|
||||
RAg a => a
|
||||
} ;
|
||||
cl = mkClause (rp.s ! RC (fromAgr agr).g Nom) agr vp
|
||||
in
|
||||
cl.s ! t ! ant ! b ! ODir ;
|
||||
c = Nom
|
||||
} ;
|
||||
|
||||
-- Pied piping: "at which we are looking". Stranding and empty
|
||||
-- relative are defined in $ExtraEng.gf$ ("that we are looking at",
|
||||
-- "we are looking at").
|
||||
|
||||
RelSlash rp slash = {
|
||||
s = \\t,a,p,agr =>
|
||||
slash.c2 ++ rp.s ! RPrep (fromAgr agr).g ++ slash.s ! t ! a ! p ! ODir ;
|
||||
c = Acc
|
||||
} ;
|
||||
|
||||
FunRP p np rp = {
|
||||
s = \\c => np.s ! Acc ++ p.s ++ rp.s ! RPrep (fromAgr np.a).g ;
|
||||
a = RAg np.a
|
||||
} ;
|
||||
|
||||
IdRP =
|
||||
{ s = table {
|
||||
RC _ Gen => "whose" ;
|
||||
RC Neutr _ => "which" ;
|
||||
RC _ Acc => "whom" ;
|
||||
RC _ Nom => "who" ;
|
||||
RPrep Neutr => "which" ;
|
||||
RPrep _ => "whom"
|
||||
} ;
|
||||
a = RNoAg
|
||||
} ;
|
||||
-}
|
||||
}
|
||||
503
lib/src/latvian/ResLav.gf
Normal file
503
lib/src/latvian/ResLav.gf
Normal file
@@ -0,0 +1,503 @@
|
||||
-- This module contains operations that are needed to make the
|
||||
-- resource syntax work. To define everything that is needed to
|
||||
-- implement $Test$, it moreover contains regular lexical
|
||||
-- patterns needed for $Lex$.
|
||||
|
||||
resource ResLav = ParamX ** open Prelude in {
|
||||
flags optimize=all ;
|
||||
|
||||
|
||||
-- Some parameters, such as $Number$, are inherited from $ParamX$.
|
||||
--2 For $Noun$
|
||||
-- This is the worst-case $Case$ needed for pronouns.
|
||||
param
|
||||
|
||||
-- Nouns
|
||||
Case = Nom | Gen | Dat | Acc | Loc ;
|
||||
Gender = Masc | Fem ;
|
||||
Restriction = AllForms | SgOnly | PlOnly | SgGenOnly | PlGenOnly ;
|
||||
NounDecl = D0 | D1 | D2 | D3 | D4 | D5 | D6 | DR ;
|
||||
|
||||
-- Adjectives
|
||||
Definite = Indef | Def ;
|
||||
AdjType = AdjQual | AdjRel | AdjIndecl ;
|
||||
|
||||
-- Verbs
|
||||
-- Ind = Indicative
|
||||
-- Rel = Relative (Latvian specific: http://www.isocat.org/rest/dc/3836)
|
||||
-- Deb = Debitive (Latvian specific: http://www.isocat.org/rest/dc/3835)
|
||||
-- Condit = Conditional
|
||||
-- DebitiveRelative - the relative subtype of debitive
|
||||
VerbForm = Infinitive | Indicative Person Number Tense | Relative Tense | Debitive |
|
||||
DebitiveRelative | Participle Gender Number Case ; -- Imperative nav pielikts, bet tur ir kaut kâdas îpatnîbas globâlajâ ParamsX modulî par imperatîvu
|
||||
VerbMood = Ind Anteriority Tense | Rel Anteriority Tense | Deb Anteriority Tense | Condit Anteriority ;
|
||||
VerbConj = C2 | C3 ;
|
||||
|
||||
Agr = Ag Gender Number ;
|
||||
|
||||
ThisOrThat = This | That ;
|
||||
|
||||
oper
|
||||
|
||||
vowel : pattern Str = #("a"|"â"|"e"|"ç"|"i"|"î"|"o"|"u"|"û") ;
|
||||
|
||||
simpleCons : pattern Str = #("c"|"d"|"l"|"n"|"s"|"t"|"z") ;
|
||||
labialCons : pattern Str = #("b"|"m"|"p"|"v") ;
|
||||
sonantCons : pattern Str = #("l"|"m"|"n"|"r"|"ï"|"ò") ;
|
||||
doubleCons : pattern Str = #("ll"|"ln"|"nn"|"sl"|"sn"|"st"|"zl"|"zn") ;
|
||||
|
||||
NON_EXISTENT : Str = "NON_EXISTENT" ;
|
||||
|
||||
|
||||
{-
|
||||
-- Agreement of $NP$ has 8 values. $Gender$ is needed for "who"/"which" and
|
||||
-- for "himself"/"herself"/"itself".
|
||||
|
||||
param
|
||||
Agr = AgP1 Number | AgP2 Number | AgP3Sg Gender | AgP3Pl ;
|
||||
|
||||
param
|
||||
Gender = Neutr | Masc | Fem ;
|
||||
|
||||
|
||||
--2 For $Verb$
|
||||
|
||||
-- Only these five forms are needed for open-lexicon verbs.
|
||||
|
||||
param
|
||||
VForm =
|
||||
VInf
|
||||
| VPres
|
||||
| VPPart
|
||||
| VPresPart
|
||||
| VPast --# notpresent
|
||||
;
|
||||
|
||||
-- Auxiliary verbs have special negative forms.
|
||||
|
||||
VVForm =
|
||||
VVF VForm
|
||||
| VVPresNeg
|
||||
| VVPastNeg --# notpresent
|
||||
;
|
||||
|
||||
-- The order of sentence is needed already in $VP$.
|
||||
|
||||
Order = ODir | OQuest ;
|
||||
|
||||
|
||||
--2 For $Adjective$
|
||||
|
||||
AForm = AAdj Degree Case | AAdv ;
|
||||
|
||||
--2 For $Relative$
|
||||
|
||||
RAgr = RNoAg | RAg Agr ;
|
||||
RCase = RPrep Gender | RC Gender Case ;
|
||||
|
||||
--2 For $Numeral$
|
||||
|
||||
CardOrd = NCard | NOrd ;
|
||||
DForm = unit | teen | ten ;
|
||||
|
||||
--2 Transformations between parameter types
|
||||
|
||||
oper
|
||||
toAgr : Number -> Person -> Gender -> Agr = \n,p,g ->
|
||||
case p of {
|
||||
P1 => AgP1 n ;
|
||||
P2 => AgP2 n ;
|
||||
P3 => case n of {
|
||||
Sg => AgP3Sg g ;
|
||||
Pl => AgP3Pl
|
||||
}
|
||||
} ;
|
||||
|
||||
fromAgr : Agr -> {n : Number ; p : Person ; g : Gender} = \a -> case a of {
|
||||
AgP1 n => {n = n ; p = P1 ; g = Masc} ;
|
||||
AgP2 n => {n = n ; p = P2 ; g = Masc} ;
|
||||
AgP3Pl => {n = Pl ; p = P3 ; g = Masc} ;
|
||||
AgP3Sg g => {n = Sg ; p = P3 ; g = g}
|
||||
} ;
|
||||
|
||||
agrP3 : Number -> Agr = \n -> agrgP3 n Neutr ;
|
||||
|
||||
agrgP3 : Number -> Gender -> Agr = \n,g -> toAgr n P3 g ;
|
||||
|
||||
conjAgr : Agr -> Agr -> Agr = \a0,b0 ->
|
||||
let a = fromAgr a0 ; b = fromAgr b0
|
||||
in
|
||||
toAgr
|
||||
(conjNumber a.n b.n)
|
||||
(conjPerson a.p b.p) a.g ;
|
||||
|
||||
-- For $Lex$.
|
||||
|
||||
-- For each lexical category, here are the worst-case constructors.
|
||||
|
||||
mkNoun : (_,_,_,_ : Str) -> {s : Number => Case => Str} =
|
||||
\man,mans,men,mens -> {
|
||||
s = table {
|
||||
Sg => table {
|
||||
Gen => mans ;
|
||||
_ => man
|
||||
} ;
|
||||
Pl => table {
|
||||
Gen => mens ;
|
||||
_ => men
|
||||
}
|
||||
}
|
||||
} ;
|
||||
|
||||
mkAdjective : (_,_,_,_ : Str) -> {s : AForm => Str; lock_A : {}} =
|
||||
\good,better,best,well -> lin A {
|
||||
s = table {
|
||||
AAdj Posit c => (regGenitiveS good) ! c ;
|
||||
AAdj Compar c => (regGenitiveS better) ! c ;
|
||||
AAdj Superl c => (regGenitiveS best) ! c ;
|
||||
AAdv => well
|
||||
}
|
||||
} ;
|
||||
|
||||
mkVerb : (_,_,_,_,_ : Str) -> Verb =
|
||||
\go,goes,went,gone,going -> {
|
||||
s = table {
|
||||
VInf => go ;
|
||||
VPres => goes ;
|
||||
VPast => went ; --# notpresent
|
||||
VPPart => gone ;
|
||||
VPresPart => going
|
||||
} ;
|
||||
isRefl = False
|
||||
} ;
|
||||
|
||||
mkIP : (i,me,my : Str) -> Number -> {s : Case => Str ; n : Number} =
|
||||
\i,me,my,n -> let who = mkNP i me my n P3 Neutr in {
|
||||
s = who.s ;
|
||||
n = n
|
||||
} ;
|
||||
|
||||
mkNP : (i,me,my : Str) -> Number -> Person -> Gender ->
|
||||
{s : Case => Str ; a : Agr} = \i,me,my,n,p,g ->
|
||||
{ s = table {
|
||||
Nom => i ;
|
||||
Acc => me ;
|
||||
Gen => my
|
||||
} ;
|
||||
a = toAgr n p g ;
|
||||
};
|
||||
|
||||
regNP : Str -> Number -> {s : Case => Str ; a : Agr} = \that,n ->
|
||||
mkNP that that (that + "'s") n P3 Neutr ;
|
||||
|
||||
regGenitiveS : Str -> Case => Str = \s ->
|
||||
table { Gen => genitiveS s; _ => s } ;
|
||||
|
||||
genitiveS : Str -> Str = \dog ->
|
||||
case last dog of {
|
||||
"s" => dog + "'" ;
|
||||
_ => dog + "'s"
|
||||
};
|
||||
|
||||
-- We have just a heuristic definition of the indefinite article.
|
||||
-- There are lots of exceptions: consonantic "e" ("euphemism"), consonantic
|
||||
-- "o" ("one-sided"), vocalic "u" ("umbrella").
|
||||
|
||||
artIndef = pre {
|
||||
"eu" | "Eu" | "uni" | "up" => "a" ;
|
||||
"un" => "an" ;
|
||||
"a" | "e" | "i" | "o" | "A" | "E" | "I" | "O" => "an" ;
|
||||
_ => "a"
|
||||
} ;
|
||||
|
||||
artDef = "the" ;
|
||||
|
||||
-- For $Verb$.
|
||||
|
||||
Verb : Type = {
|
||||
s : VForm => Str ;
|
||||
isRefl : Bool
|
||||
} ;
|
||||
|
||||
param
|
||||
CPolarity =
|
||||
CPos
|
||||
| CNeg Bool ; -- contracted or not
|
||||
|
||||
oper
|
||||
contrNeg : Bool -> Polarity -> CPolarity = \b,p -> case p of {
|
||||
Pos => CPos ;
|
||||
Neg => CNeg b
|
||||
} ;
|
||||
|
||||
VerbForms : Type =
|
||||
Tense => Anteriority => CPolarity => Order => Agr =>
|
||||
{aux, adv, fin, inf : Str} ; -- would, not, sleeps, slept
|
||||
|
||||
VP : Type = {
|
||||
s : VerbForms ;
|
||||
prp : Str ; -- present participle
|
||||
inf : Str ; -- the infinitive form ; VerbForms would be the logical place
|
||||
ad : Str ; -- sentence adverb
|
||||
s2 : Agr => Str -- complement
|
||||
} ;
|
||||
|
||||
|
||||
SlashVP = VP ** {c2 : Str} ;
|
||||
|
||||
predVc : (Verb ** {c2 : Str}) -> SlashVP = \verb ->
|
||||
predV verb ** {c2 = verb.c2} ;
|
||||
|
||||
predV : Verb -> VP = \verb -> {
|
||||
s = \\t,ant,b,ord,agr =>
|
||||
let
|
||||
inf = verb.s ! VInf ;
|
||||
fin = presVerb verb agr ;
|
||||
part = verb.s ! VPPart ;
|
||||
in
|
||||
case <t,ant,b,ord> of {
|
||||
<Pres,Simul,CPos,ODir> => vff fin [] ;
|
||||
<Pres,Simul,CPos,OQuest> => vf (does agr) inf ;
|
||||
<Pres,Anter,CPos,_> => vf (have agr) part ; --# notpresent
|
||||
<Pres,Anter,CNeg c,_> => vfn c (have agr) (havent agr) part ; --# notpresent
|
||||
<Past,Simul,CPos,ODir> => vff (verb.s ! VPast) [] ; --# notpresent
|
||||
<Past,Simul,CPos,OQuest> => vf "did" inf ; --# notpresent
|
||||
<Past,Simul,CNeg c,_> => vfn c "did" "didn't" inf ; --# notpresent
|
||||
<Past,Anter,CPos,_> => vf "had" part ; --# notpresent
|
||||
<Past,Anter,CNeg c,_> => vfn c "had" "hadn't" part ; --# notpresent
|
||||
<Fut, Simul,CPos,_> => vf "will" inf ; --# notpresent
|
||||
<Fut, Simul,CNeg c,_> => vfn c "will" "won't" inf ; --# notpresent
|
||||
<Fut, Anter,CPos,_> => vf "will" ("have" ++ part) ; --# notpresent
|
||||
<Fut, Anter,CNeg c,_> => vfn c "will" "won't"("have" ++ part) ; --# notpresent
|
||||
<Cond,Simul,CPos,_> => vf "would" inf ; --# notpresent
|
||||
<Cond,Simul,CNeg c,_> => vfn c "would" "wouldn't" inf ; --# notpresent
|
||||
<Cond,Anter,CPos,_> => vf "would" ("have" ++ part) ; --# notpresent
|
||||
<Cond,Anter,CNeg c,_> => vfn c "would" "wouldn't" ("have" ++ part) ; --# notpresent
|
||||
<Pres,Simul,CNeg c,_> => vfn c (does agr) (doesnt agr) inf
|
||||
} ;
|
||||
prp = verb.s ! VPresPart ;
|
||||
inf = verb.s ! VInf ;
|
||||
ad = [] ;
|
||||
s2 = \\a => if_then_Str verb.isRefl (reflPron ! a) []
|
||||
} ;
|
||||
|
||||
predAux : Aux -> VP = \verb -> {
|
||||
s = \\t,ant,cb,ord,agr =>
|
||||
let
|
||||
b = case cb of {
|
||||
CPos => Pos ;
|
||||
_ => Neg
|
||||
} ;
|
||||
inf = verb.inf ;
|
||||
fin = verb.pres ! b ! agr ;
|
||||
finp = verb.pres ! Pos ! agr ;
|
||||
part = verb.ppart ;
|
||||
in
|
||||
case <t,ant,cb,ord> of {
|
||||
<Pres,Anter,CPos,_> => vf (have agr) part ; --# notpresent
|
||||
<Pres,Anter,CNeg c,_> => vfn c (have agr) (havent agr) part ; --# notpresent
|
||||
<Past,Simul,CPos, _> => vf (verb.past ! b ! agr) [] ; --# notpresent
|
||||
<Past,Simul,CNeg c, _> => vfn c (verb.past!Pos!agr)(verb.past!Neg!agr) [] ; --# notpresent
|
||||
<Past,Anter,CPos,_> => vf "had" part ; --# notpresent
|
||||
<Past,Anter,CNeg c,_> => vfn c "had" "hadn't" part ; --# notpresent
|
||||
<Fut, Simul,CPos,_> => vf "will" inf ; --# notpresent
|
||||
<Fut, Simul,CNeg c,_> => vfn c "will" "won't" inf ; --# notpresent
|
||||
<Fut, Anter,CPos,_> => vf "will" ("have" ++ part) ; --# notpresent
|
||||
<Fut, Anter,CNeg c,_> => vfn c "will" "won't"("have" ++ part) ; --# notpresent
|
||||
<Cond,Simul,CPos,_> => vf "would" inf ; --# notpresent
|
||||
<Cond,Simul,CNeg c,_> => vfn c "would" "wouldn't" inf ; --# notpresent
|
||||
<Cond,Anter,CPos,_> => vf "would" ("have" ++ part) ; --# notpresent
|
||||
<Cond,Anter,CNeg c,_> => vfn c "would" "wouldn't" ("have" ++ part) ; --# notpresent
|
||||
<Pres,Simul,CPos, _> => vf fin [] ;
|
||||
<Pres,Simul,CNeg c, _> => vfn c finp fin []
|
||||
} ;
|
||||
prp = verb.prpart ;
|
||||
inf = verb.inf ;
|
||||
ad = [] ;
|
||||
s2 = \\_ => []
|
||||
} ;
|
||||
|
||||
vff : Str -> Str -> {aux, adv, fin, inf : Str} = \x,y ->
|
||||
{aux = [] ; adv = [] ; fin = x ; inf = y} ;
|
||||
|
||||
vf : Str -> Str -> {aux, adv, fin, inf : Str} = \x,y -> vfn True x x y ;
|
||||
|
||||
vfn : Bool -> Str -> Str -> Str -> {aux, fin, adv, inf : Str} =
|
||||
\contr,x,y,z ->
|
||||
case contr of {
|
||||
True => {aux = y ; adv = [] ; fin = [] ; inf = z} ;
|
||||
False => {aux = x ; adv = "not" ; fin = [] ; inf = z}
|
||||
} ;
|
||||
|
||||
insertObj : (Agr => Str) -> VP -> VP = \obj,vp -> {
|
||||
s = vp.s ;
|
||||
prp = vp.prp ;
|
||||
inf = vp.inf ;
|
||||
ad = vp.ad ;
|
||||
s2 = \\a => vp.s2 ! a ++ obj ! a
|
||||
} ;
|
||||
|
||||
insertObjPre : (Agr => Str) -> VP -> VP = \obj,vp -> {
|
||||
s = vp.s ;
|
||||
prp = vp.prp ;
|
||||
inf = vp.inf ;
|
||||
ad = vp.ad ;
|
||||
s2 = \\a => obj ! a ++ vp.s2 ! a
|
||||
} ;
|
||||
|
||||
insertObjc : (Agr => Str) -> SlashVP -> SlashVP = \obj,vp ->
|
||||
insertObj obj vp ** {c2 = vp.c2} ;
|
||||
|
||||
--- The adverb should be before the finite verb.
|
||||
|
||||
insertAdV : Str -> VP -> VP = \ad,vp -> {
|
||||
s = vp.s ;
|
||||
prp = vp.prp ;
|
||||
inf = vp.inf ;
|
||||
ad = vp.ad ++ ad ;
|
||||
s2 = \\a => vp.s2 ! a
|
||||
} ;
|
||||
|
||||
--
|
||||
|
||||
predVV : {s : VVForm => Str ; isAux : Bool} -> VP = \verb ->
|
||||
let verbs = verb.s
|
||||
in
|
||||
case verb.isAux of {
|
||||
True => predAux {
|
||||
pres = table {
|
||||
Pos => \\_ => verbs ! VVF VPres ;
|
||||
Neg => \\_ => verbs ! VVPresNeg
|
||||
} ;
|
||||
past = table { --# notpresent
|
||||
Pos => \\_ => verbs ! VVF VPast ; --# notpresent
|
||||
Neg => \\_ => verbs ! VVPastNeg --# notpresent
|
||||
} ; --# notpresent
|
||||
inf = verbs ! VVF VInf ;
|
||||
ppart = verbs ! VVF VPPart ;
|
||||
prpart = verbs ! VVF VPresPart ;
|
||||
} ;
|
||||
_ => predV {s = \\vf => verbs ! VVF vf ; isRefl = False}
|
||||
} ;
|
||||
|
||||
presVerb : {s : VForm => Str} -> Agr -> Str = \verb ->
|
||||
agrVerb (verb.s ! VPres) (verb.s ! VInf) ;
|
||||
|
||||
infVP : Bool -> VP -> Agr -> Str = \isAux,vp,a ->
|
||||
vp.ad ++
|
||||
case isAux of {True => [] ; False => "to"} ++
|
||||
vp.inf ++ vp.s2 ! a ;
|
||||
|
||||
agrVerb : Str -> Str -> Agr -> Str = \has,have,agr ->
|
||||
case agr of {
|
||||
AgP3Sg _ => has ;
|
||||
_ => have
|
||||
} ;
|
||||
|
||||
have = agrVerb "has" "have" ;
|
||||
havent = agrVerb "hasn't" "haven't" ;
|
||||
does = agrVerb "does" "do" ;
|
||||
doesnt = agrVerb "doesn't" "don't" ;
|
||||
|
||||
Aux = {
|
||||
pres : Polarity => Agr => Str ;
|
||||
past : Polarity => Agr => Str ; --# notpresent
|
||||
inf,ppart,prpart : Str
|
||||
} ;
|
||||
|
||||
auxBe : Aux = {
|
||||
pres = \\b,a => case <b,a> of {
|
||||
<Pos,AgP1 Sg> => "am" ;
|
||||
<Neg,AgP1 Sg> => ["am not"] ; --- am not I
|
||||
_ => agrVerb (posneg b "is") (posneg b "are") a
|
||||
} ;
|
||||
past = \\b,a => case a of { --# notpresent
|
||||
AgP1 Sg | AgP3Sg _ => posneg b "was" ; --# notpresent
|
||||
_ => (posneg b "were") --# notpresent
|
||||
} ; --# notpresent
|
||||
inf = "be" ;
|
||||
ppart = "been" ;
|
||||
prpart = "being"
|
||||
} ;
|
||||
|
||||
posneg : Polarity -> Str -> Str = \p,s -> case p of {
|
||||
Pos => s ;
|
||||
Neg => s + "n't"
|
||||
} ;
|
||||
|
||||
conjThat : Str = "that" ;
|
||||
|
||||
reflPron : Agr => Str = table {
|
||||
AgP1 Sg => "myself" ;
|
||||
AgP2 Sg => "yourself" ;
|
||||
AgP3Sg Masc => "himself" ;
|
||||
AgP3Sg Fem => "herself" ;
|
||||
AgP3Sg Neutr => "itself" ;
|
||||
AgP1 Pl => "ourselves" ;
|
||||
AgP2 Pl => "yourselves" ;
|
||||
AgP3Pl => "themselves"
|
||||
} ;
|
||||
|
||||
-- For $Sentence$.
|
||||
|
||||
Clause : Type = {
|
||||
s : Tense => Anteriority => CPolarity => Order => Str
|
||||
} ;
|
||||
|
||||
mkClause : Str -> Agr -> VP -> Clause =
|
||||
\subj,agr,vp -> {
|
||||
s = \\t,a,b,o =>
|
||||
let
|
||||
verb = vp.s ! t ! a ! b ! o ! agr ;
|
||||
compl = vp.s2 ! agr
|
||||
in
|
||||
case o of {
|
||||
ODir => subj ++ verb.aux ++ verb.adv ++ vp.ad ++ verb.fin ++ verb.inf ++ compl ;
|
||||
OQuest => verb.aux ++ subj ++ verb.adv ++ vp.ad ++ verb.fin ++ verb.inf ++ compl
|
||||
}
|
||||
} ;
|
||||
|
||||
|
||||
-- For $Numeral$.
|
||||
|
||||
mkNum : Str -> Str -> Str -> Str -> {s : DForm => CardOrd => Case => Str} =
|
||||
\two, twelve, twenty, second ->
|
||||
{s = table {
|
||||
unit => table {NCard => regGenitiveS two ; NOrd => regGenitiveS second} ;
|
||||
teen => \\c => mkCard c twelve ;
|
||||
ten => \\c => mkCard c twenty
|
||||
}
|
||||
} ;
|
||||
|
||||
regNum : Str -> {s : DForm => CardOrd => Case => Str} =
|
||||
\six -> mkNum six (six + "teen") (six + "ty") (regOrd six) ;
|
||||
|
||||
regCardOrd : Str -> {s : CardOrd => Case => Str} = \ten ->
|
||||
{s = table {NCard => regGenitiveS ten ;
|
||||
NOrd => regGenitiveS (regOrd ten)} } ;
|
||||
|
||||
mkCard : CardOrd -> Str -> Case => Str = \o,ten ->
|
||||
(regCardOrd ten).s ! o ;
|
||||
|
||||
regOrd : Str -> Str = \ten ->
|
||||
case last ten of {
|
||||
"y" => init ten + "ieth" ;
|
||||
_ => ten + "th"
|
||||
} ;
|
||||
|
||||
mkQuestion :
|
||||
{s : Str} -> Clause ->
|
||||
{s : Tense => Anteriority => CPolarity => QForm => Str} = \wh,cl ->
|
||||
{
|
||||
s = \\t,a,p =>
|
||||
let
|
||||
cls = cl.s ! t ! a ! p ;
|
||||
why = wh.s
|
||||
in table {
|
||||
QDir => why ++ cls ! OQuest ;
|
||||
QIndir => why ++ cls ! ODir
|
||||
}
|
||||
} ;
|
||||
|
||||
-}
|
||||
}
|
||||
100
lib/src/latvian/SentenceLav.gf
Normal file
100
lib/src/latvian/SentenceLav.gf
Normal file
@@ -0,0 +1,100 @@
|
||||
concrete SentenceLav of Sentence = CatLav ** open Prelude, ResLav, ParadigmsVerbsLav in {
|
||||
flags optimize=all_subs ;
|
||||
|
||||
lin
|
||||
|
||||
UseCl t p cl = {s = t.s ++ p.s ++ cl.s ! (Ind t.a t.t) ! p.p} ;
|
||||
|
||||
PredVP np vp =
|
||||
let
|
||||
part = vp.v.s ! ResLav.Pos ! (Participle np.g np.n Nom) ;
|
||||
obj = vp.obj ! (Ag np.g np.n)
|
||||
in {
|
||||
s = \\mood,pol =>
|
||||
case mood of { -- Subject
|
||||
Deb _ _ => np.s ! Dat ;
|
||||
_ => np.s ! Nom
|
||||
} ++
|
||||
case mood of { -- Verb
|
||||
Ind Simul tense => vp.v.s ! pol ! (Indicative np.p np.n tense) ;
|
||||
Ind Anter tense => mkVerb_toBe.s ! pol ! (Indicative np.p np.n tense) ++ part ;
|
||||
|
||||
Rel _ Past => ResLav.NON_EXISTENT ; -- FIXME (?)
|
||||
Rel Simul tense => vp.v.s ! pol ! (Relative tense) ;
|
||||
Rel Anter tense => mkVerb_toBe.s ! pol ! (Relative tense) ++ part ;
|
||||
|
||||
Deb Simul tense => mkVerb_toBe.s ! pol ! (Indicative P3 Sg tense) ++
|
||||
vp.v.s ! ResLav.Pos ! Debitive ;
|
||||
Deb Anter tense => mkVerb_toBe.s ! pol ! (Indicative P3 Sg tense) ++
|
||||
mkVerb_toBe.s ! ResLav.Pos ! (Participle Masc Sg Nom) ++ vp.v.s ! ResLav.Pos ! Debitive ;
|
||||
|
||||
Condit Simul => vp.v.s ! pol ! (Indicative np.p np.n Cond) ;
|
||||
Condit Anter => mkVerb_toBe.s ! pol ! (Indicative np.p np.n Cond) ++ part
|
||||
} ++
|
||||
obj -- Object
|
||||
} ;
|
||||
|
||||
{-
|
||||
PredVP np vp = mkClause (np.s ! Nom) np.a vp ;
|
||||
|
||||
PredSCVP sc vp = mkClause sc.s (agrP3 Sg) vp ;
|
||||
|
||||
ImpVP vp = {
|
||||
s = \\pol,n =>
|
||||
let
|
||||
agr = AgP2 (numImp n) ;
|
||||
verb = infVP True vp agr ;
|
||||
dont = case pol of {
|
||||
CNeg True => "don't" ;
|
||||
CNeg False => "do" ++ "not" ;
|
||||
_ => []
|
||||
}
|
||||
in
|
||||
dont ++ verb
|
||||
} ;
|
||||
|
||||
SlashVP np vp =
|
||||
mkClause (np.s ! Nom) np.a vp ** {c2 = vp.c2} ;
|
||||
|
||||
AdvSlash slash adv = {
|
||||
s = \\t,a,b,o => slash.s ! t ! a ! b ! o ++ adv.s ;
|
||||
c2 = slash.c2
|
||||
} ;
|
||||
|
||||
SlashPrep cl prep = cl ** {c2 = prep.s} ;
|
||||
|
||||
SlashVS np vs slash =
|
||||
mkClause (np.s ! Nom) np.a
|
||||
(insertObj (\\_ => conjThat ++ slash.s) (predV vs)) **
|
||||
{c2 = slash.c2} ;
|
||||
|
||||
EmbedS s = {s = conjThat ++ s.s} ;
|
||||
EmbedQS qs = {s = qs.s ! QIndir} ;
|
||||
EmbedVP vp = {s = infVP False vp (agrP3 Sg)} ; --- agr
|
||||
|
||||
UseCl t p cl = {
|
||||
s = t.s ++ p.s ++ cl.s ! t.t ! t.a ! ctr p.p ! ODir
|
||||
} ;
|
||||
UseQCl t p cl = {
|
||||
s = \\q => t.s ++ p.s ++ cl.s ! t.t ! t.a ! ctr p.p ! q
|
||||
} ;
|
||||
UseRCl t p cl = {
|
||||
s = \\r => t.s ++ p.s ++ cl.s ! t.t ! t.a ! ctr p.p ! r ;
|
||||
c = cl.c
|
||||
} ;
|
||||
UseSlash t p cl = {
|
||||
s = t.s ++ p.s ++ cl.s ! t.t ! t.a ! ctr p.p ! ODir ;
|
||||
c2 = cl.c2
|
||||
} ;
|
||||
|
||||
AdvS a s = {s = a.s ++ "," ++ s.s} ;
|
||||
|
||||
SSubjS a s b = {s = a.s ++ s.s ++ b.s} ;
|
||||
|
||||
RelS s r = {s = s.s ++ "," ++ r.s ! agrP3 Sg} ;
|
||||
|
||||
oper
|
||||
ctr = contrNeg True ; -- contracted negations
|
||||
-}
|
||||
}
|
||||
|
||||
166
lib/src/latvian/StructuralLav.gf
Normal file
166
lib/src/latvian/StructuralLav.gf
Normal file
@@ -0,0 +1,166 @@
|
||||
concrete StructuralLav of Structural = CatLav **
|
||||
open MorphoLav, ResLav, ParadigmsLav, ParadigmsPronounsLav, MakeStructuralLav,
|
||||
(C = ConstructX), Prelude in {
|
||||
|
||||
flags
|
||||
optimize = all ;
|
||||
coding = utf8 ;
|
||||
|
||||
lin
|
||||
|
||||
every_Det = {
|
||||
s = (\\g,c => (mkPronoun_Gend "ikviens").s ! g ! Sg ! c) ; -- TODO - kā ar loģikā lietotajiem 'visi', 'katrs' ?
|
||||
n = Sg ;
|
||||
d = Indef
|
||||
} ;
|
||||
|
||||
someSg_Det = {
|
||||
s = (\\g,c => (mkPronoun_Gend "kāds").s ! g ! Sg ! c) ; -- lai atļautu arī tukšo, jāliek (\\_,_ => []) | klāt
|
||||
n = Sg ;
|
||||
d = Indef
|
||||
} ;
|
||||
somePl_Det = {
|
||||
s = (\\g,c => (mkPronoun_Gend "kāds").s ! g ! Pl ! c) ; -- lai atļautu arī tukšo, jāliek (\\_,_ => []) | klāt
|
||||
n = Pl ;
|
||||
d = Indef
|
||||
} ;
|
||||
|
||||
|
||||
{-
|
||||
above_Prep = mkPrep "above" ;
|
||||
after_Prep = mkPrep "after" ;
|
||||
all_Predet = ss "all" ;
|
||||
almost_AdA = mkAdA "almost" ;
|
||||
almost_AdN = mkAdN "almost" ;
|
||||
although_Subj = ss "although" ;
|
||||
always_AdV = mkAdV "always" ;
|
||||
and_Conj = mkConj "and" ;
|
||||
because_Subj = ss "because" ;
|
||||
before_Prep = mkPrep "before" ;
|
||||
behind_Prep = mkPrep "behind" ;
|
||||
between_Prep = mkPrep "between" ;
|
||||
both7and_DConj = mkConj "both" "and";
|
||||
but_PConj = ss "but" ;
|
||||
by8agent_Prep = mkPrep "by" ;
|
||||
by8means_Prep = mkPrep "by" ;
|
||||
can8know_VV, can_VV = {
|
||||
s = table {
|
||||
VVF VInf => ["be able to"] ;
|
||||
VVF VPres => "can" ;
|
||||
VVF VPPart => ["been able to"] ;
|
||||
VVF VPresPart => ["being able to"] ;
|
||||
VVF VPast => "could" ; --# notpresent
|
||||
VVPastNeg => "couldn't" ; --# notpresent
|
||||
VVPresNeg => "can't"
|
||||
} ;
|
||||
isAux = True
|
||||
} ;
|
||||
during_Prep = mkPrep "during" ;
|
||||
either7or_DConj = mkConj "either" "or" singular ;
|
||||
everybody_NP = regNP "everybody" singular ;
|
||||
every_Det = mkDeterminer singular "every" ;
|
||||
everything_NP = regNP "everything" singular ;
|
||||
everywhere_Adv = mkAdv "everywhere" ;
|
||||
few_Det = mkDeterminer plural "few" ;
|
||||
--- first_Ord = ss "first" ; DEPRECATED
|
||||
for_Prep = mkPrep "for" ;
|
||||
from_Prep = mkPrep "from" ;
|
||||
he_Pron = mkPron "he" "him" "his" "his" singular P3 masculine ;
|
||||
here_Adv = mkAdv "here" ;
|
||||
here7to_Adv = mkAdv ["to here"] ;
|
||||
here7from_Adv = mkAdv ["from here"] ;
|
||||
how_IAdv = ss "how" ;
|
||||
how8much_IAdv = ss "how much" ;
|
||||
how8many_IDet = mkDeterminer plural ["how many"] ;
|
||||
if_Subj = ss "if" ;
|
||||
in8front_Prep = mkPrep ["in front of"] ;
|
||||
i_Pron = mkPron "I" "me" "my" "mine" singular P1 human ;
|
||||
in_Prep = mkPrep "in" ;
|
||||
it_Pron = mkPron "it" "it" "its" "its" singular P3 nonhuman ;
|
||||
less_CAdv = C.mkCAdv "less" "than" ;
|
||||
many_Det = mkDeterminer plural "many" ;
|
||||
more_CAdv = C.mkCAdv "more" "than" ;
|
||||
most_Predet = ss "most" ;
|
||||
much_Det = mkDeterminer singular "much" ;
|
||||
must_VV = {
|
||||
s = table {
|
||||
VVF VInf => ["have to"] ;
|
||||
VVF VPres => "must" ;
|
||||
VVF VPPart => ["had to"] ;
|
||||
VVF VPresPart => ["having to"] ;
|
||||
VVF VPast => ["had to"] ; --# notpresent
|
||||
VVPastNeg => ["hadn't to"] ; --# notpresent
|
||||
VVPresNeg => "mustn't"
|
||||
} ;
|
||||
isAux = True
|
||||
} ;
|
||||
---b no_Phr = ss "no" ;
|
||||
no_Utt = ss "no" ;
|
||||
on_Prep = mkPrep "on" ;
|
||||
---- one_Quant = mkDeterminer singular "one" ; -- DEPRECATED
|
||||
only_Predet = ss "only" ;
|
||||
or_Conj = mkConj "or" singular ;
|
||||
otherwise_PConj = ss "otherwise" ;
|
||||
part_Prep = mkPrep "of" ;
|
||||
please_Voc = ss "please" ;
|
||||
possess_Prep = mkPrep "of" ;
|
||||
quite_Adv = mkAdv "quite" ;
|
||||
she_Pron = mkPron "she" "her" "her" "hers" singular P3 feminine ;
|
||||
so_AdA = mkAdA "so" ;
|
||||
somebody_NP = regNP "somebody" singular ;
|
||||
someSg_Det = mkDeterminer singular "some" ;
|
||||
somePl_Det = mkDeterminer plural "some" ;
|
||||
something_NP = regNP "something" singular ;
|
||||
somewhere_Adv = mkAdv "somewhere" ;
|
||||
that_Quant = mkQuant "that" "those" ;
|
||||
there_Adv = mkAdv "there" ;
|
||||
there7to_Adv = mkAdv "there" ;
|
||||
there7from_Adv = mkAdv ["from there"] ;
|
||||
therefore_PConj = ss "therefore" ;
|
||||
they_Pron = mkPron "they" "them" "their" "theirs" plural P3 human ;
|
||||
this_Quant = mkQuant "this" "these" ;
|
||||
through_Prep = mkPrep "through" ;
|
||||
too_AdA = mkAdA "too" ;
|
||||
to_Prep = mkPrep "to" ;
|
||||
under_Prep = mkPrep "under" ;
|
||||
very_AdA = mkAdA "very" ;
|
||||
want_VV = mkVV (regV "want") ;
|
||||
we_Pron = mkPron "we" "us" "our" "ours" plural P1 human ;
|
||||
whatPl_IP = mkIP "what" "what" "what's" plural ;
|
||||
whatSg_IP = mkIP "what" "what" "what's" singular ;
|
||||
when_IAdv = ss "when" ;
|
||||
when_Subj = ss "when" ;
|
||||
where_IAdv = ss "where" ;
|
||||
which_IQuant = {s = \\_ => "which"} ;
|
||||
---b whichPl_IDet = mkDeterminer plural ["which"] ;
|
||||
---b whichSg_IDet = mkDeterminer singular ["which"] ;
|
||||
whoPl_IP = mkIP "who" "whom" "whose" plural ;
|
||||
whoSg_IP = mkIP "who" "whom" "whose" singular ;
|
||||
why_IAdv = ss "why" ;
|
||||
without_Prep = mkPrep "without" ;
|
||||
with_Prep = mkPrep "with" ;
|
||||
---b yes_Phr = ss "yes" ;
|
||||
yes_Utt = ss "yes" ;
|
||||
youSg_Pron = mkPron "you" "you" "your" "yours" singular P2 human ;
|
||||
youPl_Pron = mkPron "you" "you" "your" "yours" plural P2 human ;
|
||||
youPol_Pron = mkPron "you" "you" "your" "yours" singular P2 human ;
|
||||
|
||||
not_Predet = {s = "not" ; lock_Predet = <>} ;
|
||||
no_Quant = mkQuant "no" "no" "none" "none" ;
|
||||
if_then_Conj = mkConj "if" "then" singular ;
|
||||
nobody_NP = regNP "nobody" singular ;
|
||||
nothing_NP = regNP "nothing" singular ;
|
||||
|
||||
at_least_AdN = mkAdN "at least" ;
|
||||
at_most_AdN = mkAdN "at most" ;
|
||||
|
||||
except_Prep = mkPrep "except" ;
|
||||
|
||||
as_CAdv = C.mkCAdv "as" "as" ;
|
||||
|
||||
have_V2 = dirV2 (mk5V "have" "has" "had" "had" "having") ;
|
||||
that_Subj = ss "that" ;
|
||||
lin language_title_Utt = ss "English" ;
|
||||
-}
|
||||
}
|
||||
|
||||
44
lib/src/latvian/SymbolLav.gf
Normal file
44
lib/src/latvian/SymbolLav.gf
Normal file
@@ -0,0 +1,44 @@
|
||||
--# -path=.:../abstract:../common
|
||||
|
||||
concrete SymbolLav of Symbol = CatLav ** open Prelude, ResLav in {
|
||||
{-
|
||||
lin
|
||||
SymbPN i = {s = addGenitiveS i.s ; g = Neutr} ;
|
||||
IntPN i = {s = addGenitiveS i.s ; g = Neutr} ;
|
||||
FloatPN i = {s = addGenitiveS i.s ; g = Neutr} ;
|
||||
NumPN i = {s = i.s ; g = Neutr} ;
|
||||
CNIntNP cn i = {
|
||||
s = \\c => cn.s ! Sg ! Nom ++ (addGenitiveS i.s) ! c ;
|
||||
a = agrgP3 Sg cn.g
|
||||
} ;
|
||||
CNSymbNP det cn xs = {
|
||||
s = \\c => det.s ++ cn.s ! det.n ! Nom ++ (addGenitiveS xs.s) ! c ;
|
||||
a = agrgP3 det.n cn.g
|
||||
} ;
|
||||
CNNumNP cn i = {
|
||||
s = \\c => cn.s ! Sg ! Nom ++ i.s ! c ;
|
||||
a = agrgP3 Sg cn.g
|
||||
} ;
|
||||
|
||||
SymbS sy = sy ;
|
||||
|
||||
SymbNum sy = { s = addGenitiveS sy.s ; n = Pl ; hasCard = True } ;
|
||||
SymbOrd sy = { s = \\c => sy.s ++ (regGenitiveS "th")!c} ;
|
||||
|
||||
lincat
|
||||
|
||||
Symb, [Symb] = SS ;
|
||||
|
||||
lin
|
||||
MkSymb s = s ;
|
||||
|
||||
BaseSymb = infixSS "and" ;
|
||||
ConsSymb = infixSS "," ;
|
||||
|
||||
oper
|
||||
-- Note: this results in a space before 's, but there's
|
||||
-- not mauch we can do about that.
|
||||
addGenitiveS : Str -> Case => Str = \s ->
|
||||
table { Gen => s ++ "'s"; _ => s } ;
|
||||
-}
|
||||
}
|
||||
52
lib/src/latvian/VerbLav.gf
Normal file
52
lib/src/latvian/VerbLav.gf
Normal file
@@ -0,0 +1,52 @@
|
||||
concrete VerbLav of Verb = CatLav ** open ResLav in {
|
||||
flags optimize=all_subs ;
|
||||
|
||||
lin
|
||||
|
||||
UseV v = {v = v ; obj = \\_ => []} ;
|
||||
{-
|
||||
UseV = predV ;
|
||||
|
||||
SlashV2a v = predVc v ;
|
||||
Slash2V3 v np =
|
||||
insertObjc (\\_ => v.c2 ++ np.s ! Acc) (predV v ** {c2 = v.c3}) ;
|
||||
Slash3V3 v np =
|
||||
insertObjc (\\_ => v.c3 ++ np.s ! Acc) (predVc v) ; ----
|
||||
|
||||
ComplVV v vp = insertObj (\\a => infVP v.isAux vp a) (predVV v) ;
|
||||
ComplVS v s = insertObj (\\_ => conjThat ++ s.s) (predV v) ;
|
||||
ComplVQ v q = insertObj (\\_ => q.s ! QIndir) (predV v) ;
|
||||
ComplVA v ap = insertObj (ap.s) (predV v) ;
|
||||
|
||||
SlashV2V v vp = insertObjc (\\a => infVP v.isAux vp a) (predVc v) ;
|
||||
SlashV2S v s = insertObjc (\\_ => conjThat ++ s.s) (predVc v) ;
|
||||
SlashV2Q v q = insertObjc (\\_ => q.s ! QIndir) (predVc v) ;
|
||||
SlashV2A v ap = insertObjc (\\a => ap.s ! a) (predVc v) ; ----
|
||||
|
||||
ComplSlash vp np = insertObjPre (\\_ => vp.c2 ++ np.s ! Acc) vp ;
|
||||
|
||||
SlashVV vv vp =
|
||||
insertObj (\\a => infVP vv.isAux vp a) (predVV vv) **
|
||||
{c2 = vp.c2} ;
|
||||
SlashV2VNP vv np vp =
|
||||
insertObjPre (\\_ => vv.c2 ++ np.s ! Acc)
|
||||
(insertObjc (\\a => infVP vv.isAux vp a) (predVc vv)) **
|
||||
{c2 = vp.c2} ;
|
||||
|
||||
UseComp comp = insertObj comp.s (predAux auxBe) ;
|
||||
|
||||
AdvVP vp adv = insertObj (\\_ => adv.s) vp ;
|
||||
|
||||
AdVVP adv vp = insertAdV adv.s vp ;
|
||||
|
||||
ReflVP v = insertObjPre (\\a => v.c2 ++ reflPron ! a) v ;
|
||||
|
||||
PassV2 v = insertObj (\\_ => v.s ! VPPart) (predAux auxBe) ;
|
||||
|
||||
---b UseVS, UseVQ = \vv -> {s = vv.s ; c2 = [] ; isRefl = vv.isRefl} ; -- no "to"
|
||||
|
||||
CompAP ap = ap ;
|
||||
CompNP np = {s = \\_ => np.s ! Acc} ;
|
||||
CompAdv a = {s = \\_ => a.s} ;
|
||||
-}
|
||||
}
|
||||
Reference in New Issue
Block a user