msyds/gf-core
1
0
Fork 0
forked from GitHub/gf-core
Code Pull Requests Activity

PersianRG

Browse Source
This commit is contained in:
virk.shafqat
2011-06-13 18:23:30 +00:00
parent 525bf8f410
commit 052c75a71c
39 changed files with 5728 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
lib/src/persian/src/AdjectivePes.gf Normal file
View File

@@ -0,0 +1,48 @@
concrete AdjectivePes of Adjective = CatPes ** open ResPes, Prelude in {
flags coding = utf8;
lin
PositA a = a ;
UseComparA a = a;
ComparA a np = {
s =\\ez => a.s ! ez ++ "tr" ++ "Az" ++ np.s ! NPC bEzafa ;
adv = a.adv
} ;
---- $SuperlA$ belongs to determiner syntax in $Noun$.
ComplA2 a np = {
s =\\ez => np.s ! NPC bEzafa ++ a.c2 ++ a.s ! ez ;
adv = a.adv
} ;
ReflA2 a = {
s =\\ez => a.s ! ez ++ "" ; -- need to be fixed
adv = a.adv
} ;
SentAP ap sc = {
s =\\ez => ap.s! ez ++ sc.s ;
adv = ap.adv
} ;
AdAP ada ap = {
s =\\ez => ada.s ++ ap.s ! ez ;
adv = ap.adv
} ;
UseA2 a = a ;
CAdvAP cadv ap np = {
s =\\ez => cadv.s ++ np.s ! NPC bEzafa ++ ap.s ! ez ;
adv = ap.adv
};
AdjOrd ord = { s =\\_ => ord.s ; adv = ""};
AdvAP ap adv = {s =\\ez => ap.s ! ez ++ adv.s ; adv = ap.adv};
}

22
lib/src/persian/src/AdverbPes.gf Normal file
View File

@@ -0,0 +1,22 @@
concrete AdverbPes of Adverb = CatPes ** open ResPes, Prelude in {
flags coding = utf8;
lin
-- PositAdvAdj a = {s = a.s ! bEzafa } ;
PositAdvAdj a = {s = a.adv } ;
ComparAdvAdj cadv a np = {
s = a.adv ++ cadv.p ++ cadv.s ++ np.s ! NPC bEzafa ;
} ;
ComparAdvAdjS cadv a s = {
s = a.adv ++ cadv.p ++ cadv.s ++ s.s;
} ;
PrepNP prep np = {s = prep.s ++ np.s ! NPC aEzafa } ;
AdAdv ada adv = { s = ada.s ++ adv.s} ;
-- SubjS = cc2 ;
SubjS sub snt = {s = sub.s ++ "kh" ++ snt.s } ;
AdnCAdv cadv = {s = cadv.s ++ "Az"} ;
}

40
lib/src/persian/src/IdiomPes.gf Normal file
View File

@@ -0,0 +1,40 @@
concrete IdiomPes of Idiom = CatPes ** open Prelude,Predef, ResPes in {
flags optimize=all_subs ;
flags coding = utf8;
lin
ImpersCl vp = mkSClause " " (agrPesP3 Sg) vp ;
GenericCl vp = mkSClause "A:dm" (agrPesP3 Sg) vp ;
CleftNP np rs =
let cl = mkSClause (np.s ! NPC bEzafa) (np.a) (predAux auxBe);
in
{s = \\t,p,o => cl.s ! t ! p ! o ++ rs.s ! np.a };
CleftAdv ad ss = { s = \\t,b,o => ad.s ++ ss.s};
ExistNP np =
mkSClause " " (agrPesP3 (fromAgr np.a).n)
(insertObj (\\_ => np.s ! NPC bEzafa) (predAux auxBe)) ;
ExistIP ip =
let cl = mkSClause ( ip.s ) (agrPesP3 ip.n) (predAux auxBe);
in {
s = \\t,p,qf => case qf of {
QDir => cl.s ! t ! p ! ODir;
QIndir => cl.s ! t! p ! ODir
}
};
-- ProgrVP vp = insertObj (\\a => vp.obj.s ++ vp.ad ++ vp.comp ! a ++ (vp.s ! VPStem).inf ++ raha (fromAgr a).g (fromAgr a).n ) (predAux auxBe) ;
ProgrVP vp = (predProg vp) ;
ImpPl1 vp = {s = "byAyyd" ++ (vp.s ! VVForm (agrPesP1 Pl)).inf} ;
ImpP3 np vp = {s = "bgWAryd" ++ np.s!NPC bEzafa ++ (vp.s ! VVForm (AgPes (fromAgr np.a).n (fromAgr np.a).p)).inf};
}

374
lib/src/persian/src/LexiconPes.gf Normal file
View File

@@ -0,0 +1,374 @@
--# -path=.:prelude:alltenses
concrete LexiconPes of Lexicon = CatPes **
--open ResPnb, Prelude in {
open ParadigmsPes,MorphoPes, Prelude in {
flags
optimize=values ;
coding = utf8;
lin
airplane_N = mkN01 "hvApymA" inanimate ;
answer_V2S = mkV2 (compoundV "jvAb" (mkV "dAdn" "dh")) "bh" False;
apartment_N = mkN01 "A:pArtmAn" inanimate;
apple_N = mkN01 "syb" inanimate;
art_N = mkN01 "hnr" inanimate;
ask_V2Q = mkV2 (mkV_1 "prsydn") "Az" False;
baby_N = mkN01 "bc^h" animate; -- has variant "kvdk"
bad_A = mkA "bd" ;
bank_N = mkN01 "bAnk" inanimate;
beautiful_A = mkA "zybA" ;
become_VA = mkV "Cdn" "Cv";
beer_N = mkN01 "A:bjv" inanimate;
beg_V2V = mkV2V (compoundV "KvAhC" (mkV "krdn" "kn")) "Az" "" False;
big_A = mkA "bzrg" ;
bike_N = mkN01 "dvc^rKh" inanimate;
bird_N = mkN02 "prndh" animate;
black_A = mkA "syAh" ;
blue_A = mkA "A:by" ;
boat_N = mkN01 "qAyq" inanimate;
book_N = mkN01 "ktAb" inanimate;
boot_N = mkN01 "c^kmh" inanimate; -- has variant "pvtyn"
boss_N = mkN02 "kArfrmA" animate;
boy_N = mkN02 "psr" animate;
bread_N = mkN01 "nAn" inanimate;
break_V2 = mkV2 (mkV "Ckstn" "Ckn") "rA";
broad_A = mkA "vsyc" ;
brother_N2 = (mkN01 "brAdr" animate) ** {c=""};
brown_A = mkA ["qhvh Ay"] ;
butter_N = mkN01 "krh" inanimate;
buy_V2 = mkV2 (mkV_1 "Krydn") "rA";
camera_N = mkN01 "dvrbyn" inanimate;
cap_N = mkCmpdNoun1 "klAh" (mkN01 "kp" animate);
car_N = mkN01 "mACyn" inanimate; -- has variant "Atvmbyl"
carpet_N = mkN01 "frC" inanimate;
cat_N = mkN01 "grbh" animate;
ceiling_N = mkN01 "sqf" inanimate;
chair_N = mkN01 "Sndly" inanimate;
cheese_N = mkN01 "pnyr" inanimate;
child_N = mkN02 "frznd" animate; -- has variant "bc^h"
church_N = mkN01 "klysA" inanimate;
city_N = mkN01 "Chr" inanimate;
clean_A = mkA "tmyz" ;
clever_A = mkA "bAhvC" ["bA hvCmndy"];
close_V2 = mkV2 (mkV "bstn" "bnd") "rA";
coat_N = mkN01 "kt" inanimate;
cold_A = mkA "srd" ;
come_V = mkV "A:mdn" "A:y" ;
computer_N = mkN01 "kAmpyvtr" inanimate; -- also vaiant "rAyAnh"
country_N = mkN01 "kCvr" inanimate;
-- Note: cousin inflects for gender and for being a mother's or a father's relatives in persian
-- The following is an example which is the daughter of your mom's brother
cousin_N = mkCmpdNoun1 "dKtr" (mkN01 "dAyy" animate);
cow_N = mkN01 "gAv" animate;
die_V = mkV "mrdn" "myr" ;
dirty_A = mkA "kt-yf" ;
distance_N3 = (mkN "fASlh" "fvASl" inanimate ) ** {c2="Az" ; c3 = "tA"};
doctor_N = mkN01 "dktr" animate; -- has variant "pzCk", but only a doctor in medicine
dog_N = mkN01 "sg" animate;
door_N = mkN01 "dr" inanimate;
drink_V2 = mkV2 (mkV_1 "nvCydn") "rA";
-- easy_A2V = mkA "A:sAn" "" ;
eat_V2 = mkV2 (mkV_2 "Kvrdn") "rA" ;
empty_A = mkA "KAly" ;
enemy_N = mkN02 "dCmn" animate;
factory_N = mkN01 "kArKAnh" inanimate;
father_N2 = (mkN02 "pdr" animate) ** {c=""};
fear_VS = mkV_1 "trsydn";
find_V2 = mkV2 (compoundV "pydA" (mkV "krdn" "kn") ) "rA";
fish_N = mkN01 "mAhy" animate;
floor_N = mkN01 "zmyn" inanimate; -- Note: floor in persian can have 3 different translations
forget_V2 = mkV2 (compoundV "frAmvC" (mkV "krdn" "kn")) "rA" ;
fridge_N = mkN01 "yKc^Al" inanimate;
friend_N = mkN02 "dvst" animate;
fruit_N = mkN01 "myvh" inanimate;
-- fun_AV = mkAV "jAlb" ;
garden_N = mkN01 "bAG" inanimate;
girl_N = mkN02 "dKtr" animate;
glove_N = mkN01 "dstkC" inanimate;
gold_N = mkN01 "TlA" inanimate;
good_A = mkA "Kvb" ;
go_V = mkV "rftn" "rv";
green_A = mkA "sbz" ;
harbour_N = mkN "bndr" "bnAdr" inanimate;
-- hate_V2 = mkV2 (compoundV "mtnfr" (mkToBe "bvdn" "bAC" "hst")) "Az" False; -- needs from/ verb to be
hat_N = mkN01 "klAh" inanimate;
have_V2 = mkV2 haveVerb "rA" ;
hear_V2 = mkV2 (mkV "Cnydn" "Cnv") "rA" ;
hill_N = mkN01 "tph" inanimate;
-- hope_VS = compoundV "AmydvAr" (mkToBe "bvdn" "bAC" "hst");
horse_N = mkN01 "Asb" animate;
hot_A = mkA "dAG" ["dAG dAG"] ;
house_N = mkN01 "KAnh" inanimate;
important_A = mkA "mhm" ["bA Ahmyt"];
industry_N = mkN "Snct" "SnAyc" inanimate;
iron_N = mkN01 "A:hn" inanimate;
king_N = mkN "pAdCAh" "pAdCAhAn" animate;
know_V2 = mkV2 (mkV "CnAKtn" "CnAs") "rA";
know_VS = (mkV_1 "dAnstn");
know_VQ = (mkV_1 "dAnstn") ;
lake_N = mkN01 "dryAc^h" inanimate;
lamp_N = mkN01 "c^rAG" inanimate; -- also "lAmp", but they have different usage
learn_V2 = mkV2 (compoundV "yAd"(mkV "grftn" "gyr")) "rA";
leather_N = mkN01 "c^rm" inanimate; -- is uncountable
leave_V2 = mkV2 (compoundV "trk"(mkV "krdn" "kn")) "rA";
like_V2 = mkV2 (compoundV "dvst" haveVerb) "rA";
listen_V2 = mkV2 (compoundV "gvC" (mkV "dAdn" "dh")) "bh" False; -- has a diferent preposition :"bh"
live_V = compoundV "zndgy" (mkV "krdn" "kn");
long_A = mkA "blnd" ;
lose_V2 = mkV2 (compoundV "gm" (mkV "krdn" "kn")) "rA" ;
love_N = mkN01 "cCq" inanimate;
love_V2 = mkV2 (compoundV "dvst" haveVerb) "rA"; -- also possible: love_V2 = mkV2 (compoundV "cACq" (mkToBe "bvdn" "bAC" "hst"));
man_N = mkN02 "mrd" animate;
married_A2 = mkA "mtA?hl" "";
meat_N = mkN01 "gvCt" inanimate;
milk_N = mkN01 "Cyr" inanimate;
moon_N = mkN01 "mAh" inanimate; -- is this not a proper noun?
mother_N2 = (mkN02 "mAdr" animate) ** {c=""};
mountain_N = mkN01 "kvh" inanimate;
music_N = mkN "mvsyqy" "mvsyqy" animate;
narrow_A = mkA "bAryk" ;
new_A = mkA "nv" "tAzh";
newspaper_N = mkN01 "rvznAmh" inanimate;
oil_N = mkN "nft" "nft" inanimate; -- also "rvGn"
old_A = mkA "pyr" "pyrAnh";
open_V2 = mkV2 (compoundV "bAz" (mkV "krdn" "kn")) "rA";
paint_V2A = mkV2 (compoundV "rng" (mkV "krdn" "kn")) "rA" ;
paper_N = mkN01 "kAGW" inanimate;
paris_PN = mkPN "pArys" inanimate;
peace_N = mkN01 "SlH" inanimate; -- also "A:rAmC"
pen_N = mkN01 "qlm" inanimate; -- has variant "KvdkAr"
planet_N = mkN01 "syv2Arh" inanimate;
plastic_N = mkN01 "plAstyk" inanimate; -- is uncountable
play_V2 = mkV2 (mkV "nvAKtn" "nvAz") "rA" ;
policeman_N = mkCmpdNoun2 (mkN02 "mA?mvr" animate) "plys";
priest_N = mkN01 "kCyC" animate;
-- probable_AS = mkAS (regA "mHtml") ;
queen_N = mkN01 "mlkh" animate;
radio_N = mkN01 "rAdyv" inanimate;
rain_V0 = compoundV "bArAn" (mkV "A:mdn" "A:y" ) ;
read_V2 = mkV2 (mkV_2 "KvAndn") "rA";
red_A = mkA "qrmz" ;
religion_N = mkN "mWhb" "mWAhb" inanimate;
restaurant_N = mkN01 "rstvrAn" inanimate;
river_N = mkN01 "rvdKAnh" inanimate;
rock_N = mkN01 "SKrh" inanimate;
roof_N = mkN01 "bAm" inanimate; -- has variant "sqf"
rubber_N = mkN01 "pAkkn" inanimate; -- also "lAstyk"
run_V = mkV_1 "dvydn" ;
say_VS = mkV "gftn" "gvy" ;
school_N = mkN "mdrsh" "mdArs" inanimate;
science_N = mkN "clm" "clvm" inanimate; -- also "dAnC"
sea_N = mkN01 "dryA" inanimate;
seek_V2 = mkV2 (compoundV "jstjv" (mkV "krdn" "kn")) "rA";
see_V2 = mkV2 (mkV "dydn" "byn") "rA" ;
sell_V3 = mkV3 (mkV "frvKtn" "frvC") "rA" "bh";
send_V3 = mkV3 (mkV_1 "frstAdn") "rA" "brAy";
sheep_N = mkN01 "gvsfnd" animate;
ship_N = mkN01 "kCty" inanimate;
shirt_N = mkN01 "pyrAhn" inanimate;
shoe_N = mkN01 "kfC" inanimate;
shop_N = mkN01 "frvCgAh" inanimate; -- has variant "mGAzh"
short_A = mkA "kvtAh" ;
silver_N = mkN "nqrh" ["nqrh jAt"] inanimate; -- add new function which applies + "jAt"
sister_N = mkN02 "KvAhr" animate;
sleep_V = mkV_1 "KvAbydn" ;
small_A = mkA "kvc^k" ;
snake_N = mkN01 "mAr" animate;
sock_N = mkN01 "jvrAb" inanimate;
speak_V2 = mkV2 (compoundV "SHbt" (mkV "krdn" "kn")) "bA" False;
star_N = mkN01 "stArh" animate;
steel_N = mkN01 "fvlAd" inanimate; -- also "Astyl"
stone_N = mkN01 "sng" inanimate;
stove_N = mkN01 "AjAq" inanimate;
student_N = mkCmpdNoun1 "dAnC" (mkN02 "A:mvz" animate); -- also "dAnCjv"
stupid_A = mkA "Ablh" "AblhAnh" ;
sun_N = mkN01 "KvrCyd" inanimate; -- is this not a proper noun?!!!
switch8off_V2 = mkV2 (compoundV "KAmvC" (mkV "krdn" "kn")) "rA";
switch8on_V2 = mkV2 (compoundV "rvCn" (mkV "krdn" "kn")) "rA";
table_N = mkN01 "myz" inanimate;
talk_V3 = mkV3 (compoundV "Hrf" (mkV "zdn" "zn")) "bA" [" drbArh y"];
teacher_N = mkN02 "mclm" animate;
teach_V2 = mkV2 (compoundV "A:mvzC" (mkV "dAdn" "dh")) "rA";
television_N = mkN01 "tlvzyvn" inanimate;
thick_A = mkA "klft" ;
thin_A = mkA "nAzk" ;
train_N = mkN01 "qTAr" inanimate;
travel_V = compoundV "sfr" (mkV "krdn" "kn");
tree_N = mkN02 "drKt" animate;
trousers_N = mkN01 "ClvAr" inanimate;
ugly_A = mkA "zCt" ;
understand_V2 = mkV2 (mkV_1 "fhmydn") "rA";
university_N = mkN01 "dAnCgAh" inanimate;
village_N = mkN01 "rvstA" inanimate;
-- wait_V2 = mkV2 (compoundV "mntZr" (mkVToBe "bvdn" "bAC"));
walk_V = compoundV "rAh" (mkV "rftn" "rv");
warm_A = mkA "grm" ;
war_N = mkN01 "jng" inanimate;
-- watch_V2 = mkV2 (compoundV "mrAqb" (mkVToBe "bvdn" "bAC")); -- check harfe rabt!!!
water_N = mkN01 "A:b" inanimate;
white_A = mkA "sfyd" ;
window_N = mkN01 "pnjrh" inanimate;
wine_N = mkN01 "CrAb" inanimate;
win_V2 = mkV2 (compoundV "brndh" (mkV "Cdn" "Cv")) "rA"; -- also possible with simple verb: mkV_2 "brdn"
woman_N = mkN02 "zn" animate;
-- wonder_VQ = compoundV "mtcjb" (mkVToBe "bvdn" "bAC") ;
wood_N = mkN01 "c^vb" inanimate;
write_V2 = mkV2 (mkV "nvCtn" "nvys") "rA" ;
yellow_A = mkA "zrd" ;
young_A = mkA "jvAn""jvAnAnh" ;
do_V2 = mkV2 (compoundV "AnjAm" (mkV "dAdn" "dh")) "rA";
now_Adv = ss "HAlA" ;
already_Adv = ss "qblAa." ;
song_N = mkN01 "A:vAz" inanimate;
add_V3 = mkV3 (compoundV "ADAfh" (mkV "krdn" "kn")) "rA" "bh" ;
number_N = mkN01 "cdd" inanimate; -- also "tcdAd"
put_V2 = mkV2 (mkV "gWACtn" "gWAr") "rA";
stop_V = compoundV "tvqf" (mkV "krdn" "kn");
jump_V = mkV_1 "prydn";
{-
left_Ord = {s = "c^p" ; n = singular};
right_Ord = {s= "rAst" ; n = singular};
-}
far_Adv = ss "dvr" ;
correct_A = mkA "drst" ;
dry_A = mkA "KCk" ["bh KCky"] ;
dull_A = mkA ["mlAl A:vr"] ["bh Trzy mlAl A:vr"] ;
full_A = mkA "pr" ;
heavy_A = mkA "sngyn" ;
near_A = mkA "nzdyk" ;
rotten_A = mkA "KrAb" ;
round_A = mkA "grd" ;
sharp_A = mkA "tyz" ;
smooth_A = mkA "nrm" ;
straight_A = mkA "mstqym" "mstqymAa.";
wet_A = mkA "Kys" ;
wide_A = mkA "phn" ;
animal_N = mkN "HyvAn" "HyvAnAt" animate;
ashes_N = mkN01 "KAkstr" inanimate;
back_N = mkN01 "kmr" inanimate;
bark_N = mkN01 "cvcv" inanimate;
belly_N = mkN01 "Ckm" inanimate;
blood_N = mkN01 "Kvn" inanimate;
bone_N = mkN01 "AstKvAn" inanimate;
breast_N = mkN01 "synh" inanimate;
cloud_N = mkN01 "Abr" inanimate;
day_N = mkN01 "rvz" inanimate;
dust_N = mkN01 "GbAr" inanimate;
ear_N = mkN01 "gvC" inanimate;
earth_N = mkN01 "zmyn" inanimate; -- also "KAk"
egg_N = mkCmpdNoun1 "tKm" (mkN01 "mrG" inanimate);
eye_N = mkN01 "c^Cm" inanimate ;
fat_N = mkN01 "c^rby" inanimate;
feather_N = mkN01 "pr" inanimate;
fingernail_N = mkN01 "nAKn" inanimate;
fire_N = mkN01 "A:tC" inanimate;
flower_N = mkN01 "gl" inanimate;
fog_N = mkN01 "mh" inanimate;
foot_N = mkN01 "pA" inanimate;
forest_N = mkN01 "jngl" inanimate;
grass_N = mkN01 "c^mn" inanimate;
guts_N = mkN01 "ChAmt" inanimate;
hair_N = mkN01 "mv" inanimate;
hand_N = mkN01 "dst" inanimate;
head_N = mkN01 "sr" inanimate;
heart_N = mkN01 "qlb" inanimate;
horn_N = mkN01 "bvq" inanimate; -- also "CAK"
husband_N = mkN02 "Cvhr" animate;
ice_N = mkN01 "yK" inanimate;
knee_N = mkN01 "zAnv" inanimate;
leaf_N = mkN01 "brg" inanimate;
leg_N = mkN01 "pA" inanimate;
liver_N = mkN01 "rvdKAnh" inanimate;
louse_N = mkN01 "CpC" inanimate;
mouth_N = mkN01 "dhAn" inanimate;
name_N = mkN01 "nAm" inanimate; -- has variant "Asm"
neck_N = mkN01 "grdn" inanimate;
night_N = mkN01 "Cb" inanimate;
nose_N = mkN01 "byny" inanimate;
person_N = mkN "CKS" "ACKAS" animate;
rain_N = mkN01 "bArAn" inanimate;
road_N = mkN01 "jAdh" inanimate;
root_N = mkN01 "ryCh" inanimate;
rope_N = mkN01 "TnAb" inanimate;
salt_N = mkN01 "nmk" inanimate;
sand_N = mkN01 "mAsh" inanimate;
seed_N = mkN01 "dAnh" inanimate;
skin_N = mkN01 "pvst" inanimate;
sky_N = mkN01 "A:smAn" inanimate;
smoke_N = mkN01 "dvd" inanimate;
snow_N = mkN01 "brf" inanimate;
stick_N = mkN01 "trkh" inanimate;
tail_N = mkN01 "dm" inanimate;
tongue_N = mkN01 "zbAn" inanimate;
tooth_N = mkN01 "dndAn" inanimate;
wife_N = mkN02 "hmsr" animate;
wind_N = mkN01 "bAd" inanimate;
wing_N = mkN01 "bAl" inanimate;
worm_N = mkN01 "krm" inanimate;
year_N = mkN01 "sAl" inanimate;
blow_V = mkV_1 "dmydn" ;
breathe_V = compoundV "nfs" (mkV_1 "kCydn");
burn_V = mkV "svKtn" "svz" ;
dig_V = mkV_2 "kndn" ;
fall_V = mkV_1 "AftAdn" ;
-- float_V = compoundV "CnAvr" (mkToBe "bvdn" "bAC" "hst") ;
flow_V = compoundV "jAry" (mkV "Cdn" "Cv") ;
fly_V = compoundV "prvAz" (mkV "krdn" "kn") ;
freeze_V = compoundV "yK" (mkV "zdn" "zn") ;
give_V3 = mkV3 (mkV "dAdn" "dh") "rA" "bh";
laugh_V = mkV_1 "Kndydn" ;
lie_N = mkN01 "drvG" inanimate;
lie_V = compoundV "drvG" (mkV "gftn" "gv" );
play_V = compoundV "bAzy" (mkV "krdn" "kn");
sew_V = mkV "dvKtn" "dvz" ;
sing_V = compoundV "A:vAz" (mkV_2 "KvAndn");
sit_V = mkV "nCstn" "nCyn" ;
smell_V = compoundV "bv" (mkV "dAdn" "dh");
spit_V = compoundV "tf" (mkV "krdn" "kn");
stand_V = mkV_1 "AystAdn";
swell_V = compoundV "vrm" (mkV "krdn" "kn");
swim_V = compoundV "CnA" (mkV "krdn" "kn");
think_V = compoundV "fkr" (mkV "krdn" "kn");
turn_V = mkV_1 "c^rKydn" ;
vomit_V = compoundV "AstfrAG" (mkV "krdn" "kn");
bite_V2 = mkV2 (compoundV "gAz" (mkV "grftn" "gyr")) "rA";
count_V2 = mkV2 (mkV_2 "CmArdn") "rA";
cut_V2 = mkV2 (mkV_1 "brydn") ;
fear_V2 = mkV2 (mkV_1 "trsydn") "Az";
fight_V2 = mkV2 (mkV_1 "jngydn") "bA" False;
hit_V2 = mkV2 (compoundV "Drbh" (mkV "zdn" "zn")) "bh" False;
hold_V2 = mkV2 (compoundV "ngh" haveVerb) "rA";
hunt_V2 = mkV2 (compoundV "CkAr" (mkV "krdn" "kn")) "rA";
kill_V2 = mkV2 ( mkV_2 "kCtn") "rA";
pull_V2 = mkV2 (mkV_1 "kCydn") "rA";
push_V2 = mkV2 (compoundV "hl" (mkV "dAdn" "dh")) "rA" ;
rub_V2 = mkV2 (mkV_1 "mAlydn") "rA";
scratch_V2 = mkV2 (mkV_1 "KrACydn") "rA" ;
split_V2 = mkV2 (compoundV "tqsym" (mkV "krdn" "kn")) "rA";
squeeze_V2 = mkV2 (compoundV "lh" (mkV "krdn" "kn")) "rA";
stab_V2 = mkV2 (compoundV "c^Aqv" (mkV "zdn" "zn")) "bh" False;
suck_V2 = mkV2 (mkV_1 "mkydn") "rA" ;
throw_V2 = mkV2 (compoundV "prtAb" (mkV "krdn" "kn")) "rA";
tie_V2 = mkV2 (compoundV "grh" (mkV "zdn" "zn")) "rA";
wash_V2 = mkV2 (mkV "Cstn" "Cvr") "rA" ; -- also "Cvy" which is the very formal form of the present root
wipe_V2 = mkV2 (compoundV "pAk" (mkV "krdn" "kn")) "rA";
---- other_A = regA "dygr" ;
grammar_N = mkCmpdNoun1 "dstvr" (mkN01 "zbAn" inanimate);
language_N = mkN01 "zbAn" inanimate;
rule_N = mkN "qAnvn" "qvAnyn" inanimate;
---- added 4/6/2007
john_PN = mkPN "jAn" inanimate;
question_N = mkN01 "sw?Al" inanimate; -- has variant "prsC"
ready_A = mkA "A:mAdh" ["bA A:mAdgy"] ;
reason_N = mkN "dlyl" "dlAyl" inanimate;
today_Adv = ss "Amrvz" ;
uncertain_A = mkA "nAmclvm" ["bA trdyd"];
}

507
lib/src/persian/src/MorphoPes.gf Normal file
View File

@@ -0,0 +1,507 @@
--# -path=.:../../prelude
--
----1 A Simple Punjabi Resource Morphology
----
---- Shafqat Virk, Aarne Ranta,2010
----
---- This resource morphology contains definitions needed in the resource
---- syntax. To build a lexicon, it is better to use $ParadigmsPnb$, which
---- gives a higher-level access to this module.
--
resource MorphoPes = ResPes ** open Prelude,Predef in {
flags optimize=all ;
coding = utf8;
----2 Nouns
oper
mkN : (x1,x2 : Str) -> Animacy -> Noun =
\sg,pl,ani -> {
s = table {
bEzafa => table { Sg => sg ;
Pl => pl
} ;
aEzafa => table { Sg => mkEzafa sg ;
Pl => mkEzafa pl
} ;
enClic => table { Sg => mkEnclic sg ;
Pl => mkEnclic pl
}
};
animacy = ani ;
definitness = True
} ;
-- masculine nouns end with alif, choTi_hay, ain Translitration: (a, h, e)
-- Arabic nouns ends with h. also taken as Masc
------------------------------------------------------------------
----Verbs
------------------------------------------------------------------
{-
mkVerb : (x1,x2 : Str) -> Verb = \inf,root2 ->
let root1 = (tk 1 inf) ;
in {
s = table {
Root1 => root1 ;
Root2 => root2 ;
Inf => inf ;
VF tense aspect person number => (mkCmnVF root1 root2 tense aspect person number).s
-- Caus1 tense person number gender => (mkCmnVF root1 tense person number gender).s ;
-- Caus2 tense person number gender => (mkCmnVF root2 tense person number gender).s
}
} ;
--1. Basic stem form, direct & indirect causatives exists
-- v1 nechna nechaana nechwana
mkVerb1 : (_: Str) -> Verb = \inf ->
let root1 = (tk 1 inf) ;
root2 = (tk 3 inf) ;
in {
s = table {
Root1 => root1 ;
Root2 => root2 ;
Inf => inf ;
VF tense aspect person number => (mkCmnVF root1 root2 tense aspect person number).s
-- Caus1 tense person number gender => (mkCmnVF root1 tense person number gender).s ;
-- Caus2 tense person number gender => (mkCmnVF root2 tense person number gender).s
}
} ;
mkVerb2 : (_: Str) -> Verb = \inf ->
let root1 = (tk 1 inf) ;
root2 = (tk 2 inf) ;
in {
s = table {
Root1 => root1 ;
Root2 => root2 ;
Inf => inf ;
VF tense aspect person number => (mkCmnVF root1 root2 tense aspect person number).s
-- Caus1 tense person number gender => (mkCmnVF root1 tense person number gender).s ;
-- Caus2 tense person number gender => (mkCmnVF root2 tense person number gender).s
}
} ;
mkCmnVF : Str -> Str -> VTense -> PAspect -> PPerson -> Number -> {s:Str}= \root1,root2,t,a,p,n ->
{s = (mkCmnVF1 root1 root2 t a p n).s ;
};
mkCmnVF1 : Str -> Str -> VTense -> PAspect -> PPerson -> Number -> {s:Str}= \root1,root2,t,a,p,n ->
{s = let khordh = root1 + "h";
mekhor = "my" ++ root2 ;
mekhord = "my" ++ root1 ;
mekhordh = "my" ++ khordh ;
khah = "KvAh" ;
mekhah = "my" ++ khah ;
bvdh = "bvdh"
in
case <t,a,p,n> of {
<PPresent,PPerf,PPers1,Sg> => khordh ++ "Am" ;
<PPresent,PPerf,PPers1,Pl> => khordh ++ "Aym" ;
<PPresent,PPerf,PPers2,Sg> => khordh ++ "Ay" ;
<PPresent,PPerf,PPers2,Pl> => khordh ++ "Ayd" ;
<PPresent,PPerf,PPers3,Sg> => khordh ++ "Ast" ;
<PPresent,PPerf,PPers3,Pl> => khordh ++ "And" ;
<PPresent,PImperf,PPers1,Sg> => mekhor + "m" ; -- toHave need to have khor instead of mekhor
<PPresent,PImperf,PPers1,Pl> => mekhor + "ym" ;
<PPresent,PImperf,PPers2,Sg> => mekhor + "y" ;
<PPresent,PImperf,PPers2,Pl> => mekhor + "yd" ;
<PPresent,PImperf,PPers3,Sg> => mekhor + "d" ;
<PPresent,PImperf,PPers3,Pl> => mekhor + "nd" ;
<PPresent,Aorist,PPers1,Sg> => "" ;
<PPresent,Aorist,PPers1,Pl> => "" ;
<PPresent,Aorist,PPers2,Sg> => "" ;
<PPresent,Aorist,PPers2,Pl> => "" ;
<PPresent,Aorist,PPers3,Sg> => "" ;
<PPresent,Aorist,PPers3,Pl> => "" ;
<PPast,PPerf,PPers1,Sg> => khordh ++ "bvdm" ;
<PPast,PPerf,PPers1,Pl> => khordh ++ "bvdym" ;
<PPast,PPerf,PPers2,Sg> => khordh ++ "bvdy" ;
<PPast,PPerf,PPers2,Pl> => khordh ++ "bvdyd" ;
<PPast,PPerf,PPers3,Sg> => khordh ++ "bvd" ;
<PPast,PPerf,PPers3,Pl> => khordh ++ "bvdnd" ;
<PPast,PImperf,PPers1,Sg> => mekhord + "m" ; -- toHave need to have khor instead of mekhor
<PPast,PImperf,PPers1,Pl> => mekhord + "ym" ;
<PPast,PImperf,PPers2,Sg> => mekhord + "y";
<PPast,PImperf,PPers2,Pl> => mekhord + "yd" ;
<PPast,PImperf,PPers3,Sg> => mekhord ;
<PPast,PImperf,PPers3,Pl> => mekhord + "nd" ;
<PPast,Aorist,PPers1,Sg> => root1 + "m" ;
<PPast,Aorist,PPers1,Pl> => root1 + "ym" ;
<PPast,Aorist,PPers2,Sg> => root1 + "y";
<PPast,Aorist,PPers2,Pl> => root1 + "yd" ;
<PPast,Aorist,PPers3,Sg> => root1 ;
<PPast,Aorist,PPers3,Pl> => root1 + "nd" ;
-- check this one
<PFut,PPerf,PPers1,Sg> => "" ;
<PFut,PPerf,PPers1,Pl> => "" ;
<PFut,PPerf,PPers2,Sg> => "" ;
<PFut,PPerf,PPers2,Pl> => "" ;
<PFut,PPerf,PPers3,Sg> => "" ;
<PFut,PPerf,PPers3,Pl> => "" ;
<PFut,PImperf,PPers1,Sg> => mekhah + "m" ++ addBh root2 + "m" ;
<PFut,PImperf,PPers1,Pl> => mekhah + "ym" ++ addBh root2 + "ym" ;
<PFut,PImperf,PPers2,Sg> => mekhah + "y" ++ addBh root2 + "y" ;
<PFut,PImperf,PPers2,Pl> => mekhah + "yd" ++ addBh root2 + "yd" ;
<PFut,PImperf,PPers3,Sg> => mekhah + "d" ++ addBh root2 + "d" ;
<PFut,PImperf,PPers3,Pl> => mekhah + "nd" ++ addBh root2 + "nd" ;
<PFut,Aorist,PPers1,Sg> => khah + "m" ++ root1 ;
<PFut,Aorist,PPers1,Pl> => khah + "ym" ++ root1 ;
<PFut,Aorist,PPers2,Sg> => khah + "y" ++ root1 ;
<PFut,Aorist,PPers2,Pl> => khah + "yd" ++ root1 ;
<PFut,Aorist,PPers3,Sg> => khah + "d" ++ root1 ;
<PFut,Aorist,PPers3,Pl> => khah + "nd" ++ root1 ;
<Infr_Past,PPerf,PPers1,Sg> => khordh ++ bvdh ++ "Am" ;
<Infr_Past,PPerf,PPers1,Pl> => khordh ++ bvdh ++ "Aym" ;
<Infr_Past,PPerf,PPers2,Sg> => khordh ++ bvdh ++ "Ay" ;
<Infr_Past,PPerf,PPers2,Pl> => khordh ++ bvdh ++ "Ayd" ;
<Infr_Past,PPerf,PPers3,Sg> => khordh ++ bvdh ++ "Ast" ;
<Infr_Past,PPerf,PPers3,Pl> => khordh ++ bvdh ++ "And" ;
<Infr_Past,PImperf,PPers1,Sg> => mekhordh ++ "Am" ; -- toHave need to have khordh instead of mekhor
<Infr_Past,PImperf,PPers1,Pl> => mekhordh ++ "Aym" ;
<Infr_Past,PImperf,PPers2,Sg> => mekhordh ++ "Ay" ;
<Infr_Past,PImperf,PPers2,Pl> => mekhordh ++ "Ayd" ;
<Infr_Past,PImperf,PPers3,Sg> => mekhordh ++ "Ast" ;
<Infr_Past,PImperf,PPers3,Pl> => mekhordh ++ "And" ;
-- check this one
<Infr_Past,Aorist,PPers1,Sg> => "" ;
<Infr_Past,Aorist,PPers1,Pl> => "" ;
<Infr_Past,Aorist,PPers2,Sg> => "" ;
<Infr_Past,Aorist,PPers2,Pl> => "" ;
<Infr_Past,Aorist,PPers3,Sg> => "" ;
<Infr_Past,Aorist,PPers3,Pl> => ""
}
} ;
-}
mkVerb : (x1,x2 : Str) -> Verb = \inf,root2 ->
let root1 = (tk 1 inf) ;
impRoot = mkimpRoot root2;
in {
s = table {
Root1 => root1 ;
Root2 => root2 ;
Inf => inf ;
Imp Pos Sg => addBh impRoot ;
Imp Pos Pl => (addBh impRoot) + "yd" ;
Imp Neg Sg => "n" + impRoot ;
Imp Neg Pl => "n" + impRoot + "yd" ;
VF pol tense person number => (mkCmnVF root1 root2 pol tense person number).s ;
-- VF Neg tense person number => addN (mkCmnVF root1 root2 tense person number).s ;
Vvform (AgPes number person) => (mkvVform root2 number person).s
}
} ;
mkVerb1 : (_: Str) -> Verb = \inf ->
let root1 = (tk 1 inf) ;
root2 = (tk 3 inf) ;
impRoot = mkimpRoot root2 ;
in {
s = table {
Root1 => root1 ;
Root2 => root2 ;
Inf => inf ;
Imp Pos Sg => addBh impRoot ;
Imp Pos Pl => (addBh impRoot) + "yd" ;
Imp Neg Sg => "n" + impRoot ;
Imp Neg Pl => "n" + impRoot + "yd" ;
VF pol tense person number => (mkCmnVF root1 root2 pol tense person number).s ;
-- VF Neg tense person number => addN (mkCmnVF root1 root2 tense person number).s ;
Vvform (AgPes number person) => (mkvVform root2 number person).s
}
};
mkVerb2 : (_: Str) -> Verb = \inf ->
let root1 = (tk 1 inf) ;
root2 = (tk 2 inf) ;
impRoot = mkimpRoot root2 ;
in {
s = table {
Root1 => root1 ;
Root2 => root2 ;
Inf => inf ;
Imp Pos Sg => addBh impRoot ;
Imp Pos Pl => (addBh impRoot) + "yd" ;
Imp Neg Sg => "n" + impRoot ;
Imp Neg Pl => "n" + impRoot + "yd" ;
VF pol tense person number => (mkCmnVF root1 root2 pol tense person number).s ;
-- VF Neg tense person number => addN (mkCmnVF root1 root2 tense person number).s ;
Vvform (AgPes number person) => (mkvVform root2 number person).s
}
} ;
mkHave : Verb =
{
s = table {
Root1 => "dACt" ;
Root2 => "dAr" ;
Inf => "dACtn" ;
Imp Pos Sg => ["dACth bAC"] ;
Imp Pos Pl => ["dACth bACyd"];
Imp Neg Sg => ["ndACth bAC"] ;
Imp Neg Pl => ["ndACth bACyd"] ;
VF pol tense person number => (toHave pol tense number person).s ;
-- VF Neg tense person number => addN (mkCmnVF root1 root2 tense person number).s ;
Vvform (AgPes Sg PPers1) => ["dACth bACm"] ;
Vvform (AgPes Sg PPers2) => ["dACth bACy"] ;
Vvform (AgPes Sg PPers3) => ["dACth bACd"] ;
Vvform (AgPes Pl PPers1) => ["dACth bACym"] ;
Vvform (AgPes Pl PPers2) => ["dACth bACyd"] ;
Vvform (AgPes Pl PPers3) => ["dACth bACnd"]
}
} ;
mkCmnVF : Str -> Str -> Polarity -> VTense2 -> PPerson -> Number -> {s:Str}= \root1,root2,pol,t,p,n ->
{s = (mkCmnVF1 root1 root2 pol t p n).s ;
};
mkCmnVF1 : Str -> Str -> Polarity -> VTense2 -> PPerson -> Number -> {s:Str}= \root1,root2,pol,t,p,n ->
{s = let khordh = root1 + "h";
nkhordh = (addN root1) + "h" ;
mekhor = "my" ++ root2 ;
nmekhor = "nmy" ++ root2 ;
mekhord = "my" ++ root1 ;
nmekhord = "nmy" ++ root1 ;
mekhordh = "my" ++ khordh ;
nmekhordh = "nmy" ++ khordh ;
khah = "KvAh" ;
nkhah = "nKvAh" ;
mekhah = "my" ++ khah ;
nmekhah = "nmy" ++ khah ;
bvdh = "bvdh"
in
case <pol,t,p,n> of {
<Pos,PPresent2 PrPerf,PPers1,Sg> => khordh ++ "Am" ;
<Pos,PPresent2 PrPerf,PPers1,Pl> => khordh ++ "Aym" ;
<Pos,PPresent2 PrPerf,PPers2,Sg> => khordh ++ "Ay" ;
<Pos,PPresent2 PrPerf,PPers2,Pl> => khordh ++ "Ayd" ;
<Pos,PPresent2 PrPerf,PPers3,Sg> => khordh ++ "Ast" ;
<Pos,PPresent2 PrPerf,PPers3,Pl> => khordh ++ "And" ;
<Pos,PPresent2 PrImperf,PPers1,Sg> => mekhor + "m" ;
<Pos,PPresent2 PrImperf,PPers1,Pl> => mekhor + "ym" ;
<Pos,PPresent2 PrImperf,PPers2,Sg> => mekhor + "y" ;
<Pos,PPresent2 PrImperf,PPers2,Pl> => mekhor + "yd" ;
<Pos,PPresent2 PrImperf,PPers3,Sg> => mekhor + "d" ;
<Pos,PPresent2 PrImperf,PPers3,Pl> => mekhor + "nd" ;
<Pos,PPast2 PstPerf,PPers1,Sg> => khordh ++ "bvdm" ;
<Pos,PPast2 PstPerf,PPers1,Pl> => khordh ++ "bvdym" ;
<Pos,PPast2 PstPerf,PPers2,Sg> => khordh ++ "bvdy" ;
<Pos,PPast2 PstPerf,PPers2,Pl> => khordh ++ "bvdyd" ;
<Pos,PPast2 PstPerf,PPers3,Sg> => khordh ++ "bvd" ;
<Pos,PPast2 PstPerf,PPers3,Pl> => khordh ++ "bvdnd" ;
<Pos,PPast2 PstImperf,PPers1,Sg> => mekhord + "m" ;
<Pos,PPast2 PstImperf,PPers1,Pl> => mekhord + "ym" ;
<Pos,PPast2 PstImperf,PPers2,Sg> => mekhord + "y";
<Pos,PPast2 PstImperf,PPers2,Pl> => mekhord + "yd" ;
<Pos,PPast2 PstImperf,PPers3,Sg> => mekhord ;
<Pos,PPast2 PstImperf,PPers3,Pl> => mekhord + "nd" ;
<Pos,PPast2 PstAorist,PPers1,Sg> => root1 + "m" ;
<Pos,PPast2 PstAorist,PPers1,Pl> => root1 + "ym" ;
<Pos,PPast2 PstAorist,PPers2,Sg> => root1 + "y";
<Pos,PPast2 PstAorist,PPers2,Pl> => root1 + "yd" ;
<Pos,PPast2 PstAorist,PPers3,Sg> => root1 ;
<Pos,PPast2 PstAorist,PPers3,Pl> => root1 + "nd" ;
{-
<Pos,PFut2 FtImperf,PPers1,Sg> => mekhah + "m" ++ addBh root2 + "m" ;
<Pos,PFut2 FtImperf,PPers1,Pl> => mekhah + "ym" ++ addBh root2 + "ym" ;
<Pos,PFut2 FtImperf,PPers2,Sg> => mekhah + "y" ++ addBh root2 + "y" ;
<Pos,PFut2 FtImperf,PPers2,Pl> => mekhah + "yd" ++ addBh root2 + "yd" ;
<Pos,PFut2 FtImperf,PPers3,Sg> => mekhah + "d" ++ addBh root2 + "d" ;
<Pos,PFut2 FtImperf,PPers3,Pl> => mekhah + "nd" ++ addBh root2 + "nd" ;
-}
<Pos,PFut2 FtAorist,PPers1,Sg> => khah + "m" ++ root1 ;
<Pos,PFut2 FtAorist,PPers1,Pl> => khah + "ym" ++ root1 ;
<Pos,PFut2 Ftorist,PPers2,Sg> => khah + "y" ++ root1 ;
<Pos,PFut2 FtAorist,PPers2,Pl> => khah + "yd" ++ root1 ;
<Pos,PFut2 FtAorist,PPers3,Sg> => khah + "d" ++ root1 ;
<Pos,PFut2 FtAorist,PPers3,Pl> => khah + "nd" ++ root1 ;
<Pos,Infr_Past2 InfrPerf,PPers1,Sg> => khordh ++ bvdh ++ "Am" ;
<Pos,Infr_Past2 InfrPerf,PPers1,Pl> => khordh ++ bvdh ++ "Aym" ;
<Pos,Infr_Past2 InfrPerf,PPers2,Sg> => khordh ++ bvdh ++ "Ay" ;
<Pos,Infr_Past2 InfrPerf,PPers2,Pl> => khordh ++ bvdh ++ "Ayd" ;
<Pos,Infr_Past2 InfrPerf,PPers3,Sg> => khordh ++ bvdh ++ "Ast" ;
<Pos,Infr_Past2 InfrPerf,PPers3,Pl> => khordh ++ bvdh ++ "And" ;
<Pos,Infr_Past2 InfrImperf,PPers1,Sg> => mekhordh ++ "Am" ;
<Pos,Infr_Past2 InfrImperf,PPers1,Pl> => mekhordh ++ "Aym" ;
<Pos,Infr_Past2 InfrImperf,PPers2,Sg> => mekhordh ++ "Ay" ;
<Pos,Infr_Past2 InfrImperf,PPers2,Pl> => mekhordh ++ "Ayd" ;
<Pos,Infr_Past2 InfrImperf,PPers3,Sg> => mekhordh ++ "Ast" ;
<Pos,Infr_Past2 InfrImperf,PPers3,Pl> => mekhordh ++ "And" ;
-- negatives
<Neg,PPresent2 PrPerf,PPers1,Sg> => addN khordh ++ "Am" ;
<Neg,PPresent2 PrPerf,PPers1,Pl> => addN khordh ++ "Aym" ;
<Neg,PPresent2 PrPerf,PPers2,Sg> => addN khordh ++ "Ay" ;
<Neg,PPresent2 PrPerf,PPers2,Pl> => addN khordh ++ "Ayd" ;
<Neg,PPresent2 PrPerf,PPers3,Sg> => addN khordh ++ "Ast" ;
<Neg,PPresent2 PrPerf,PPers3,Pl> => addN khordh ++ "And" ;
<Neg,PPresent2 PrImperf,PPers1,Sg> => nmekhor + "m" ;
<Neg,PPresent2 PrImperf,PPers1,Pl> => nmekhor + "ym" ;
<Neg,PPresent2 PrImperf,PPers2,Sg> => nmekhor + "y" ;
<Neg,PPresent2 PrImperf,PPers2,Pl> => nmekhor + "yd" ;
<Neg,PPresent2 PrImperf,PPers3,Sg> => nmekhor + "d" ;
<Neg,PPresent2 PrImperf,PPers3,Pl> => nmekhor + "nd" ;
<Neg,PPast2 PstPerf,PPers1,Sg> => nkhordh ++ "bvdm" ;
<Neg,PPast2 PstPerf,PPers1,Pl> => nkhordh ++ "bvdym" ;
<Neg,PPast2 PstPerf,PPers2,Sg> => nkhordh ++ "bvdy" ;
<Neg,PPast2 PstPerf,PPers2,Pl> => nkhordh ++ "bvdyd" ;
<Neg,PPast2 PstPerf,PPers3,Sg> => nkhordh ++ "bvd" ;
<Neg,PPast2 PstPerf,PPers3,Pl> => nkhordh ++ "bvdnd" ;
<Neg,PPast2 PstImperf,PPers1,Sg> => nmekhord + "m" ;
<Neg,PPast2 PstImperf,PPers1,Pl> => nmekhord + "ym" ;
<Neg,PPast2 PstImperf,PPers2,Sg> => nmekhord + "y";
<Neg,PPast2 PstImperf,PPers2,Pl> => nmekhord + "yd" ;
<Neg,PPast2 PstImperf,PPers3,Sg> => nmekhord ;
<Neg,PPast2 PstImperf,PPers3,Pl> => nmekhord + "nd" ;
<Neg,PPast2 PstAorist,PPers1,Sg> => addN root1 + "m" ;
<Neg,PPast2 PstAorist,PPers1,Pl> => addN root1 + "ym" ;
<Neg,PPast2 PstAorist,PPers2,Sg> => addN root1 + "y";
<Neg,PPast2 PstAorist,PPers2,Pl> => addN root1 + "yd" ;
<Neg,PPast2 PstAorist,PPers3,Sg> => addN root1 ;
<Neg,PPast2 PstAorist,PPers3,Pl> => addN root1 + "nd" ;
{-
<Neg,PFut2 FtImperf,PPers1,Sg> => nmekhah + "m" ++ addBh root2 + "m" ;
<Neg,PFut2 FtImperf,PPers1,Pl> => nmekhah + "ym" ++ addBh root2 + "ym" ;
<Neg,PFut2 FtImperf,PPers2,Sg> => nmekhah + "y" ++ addBh root2 + "y" ;
<Neg,PFut2 FtImperf,PPers2,Pl> => nmekhah + "yd" ++ addBh root2 + "yd" ;
<Neg,PFut2 FtImperf,PPers3,Sg> => nmekhah + "d" ++ addBh root2 + "d" ;
<Neg,PFut2 FtImperf,PPers3,Pl> => nmekhah + "nd" ++ addBh root2 + "nd" ;
-}
<Neg,PFut2 FtAorist,PPers1,Sg> => nkhah + "m" ++ root1 ;
<Neg,PFut2 FtAorist,PPers1,Pl> => nkhah + "ym" ++ root1 ;
<Neg,PFut2 Ftorist,PPers2,Sg> => nkhah + "y" ++ root1 ;
<Neg,PFut2 FtAorist,PPers2,Pl> => nkhah + "yd" ++ root1 ;
<Neg,PFut2 FtAorist,PPers3,Sg> => nkhah + "d" ++ root1 ;
<Neg,PFut2 FtAorist,PPers3,Pl> => nkhah + "nd" ++ root1 ;
<Neg,Infr_Past2 InfrPerf,PPers1,Sg> => nkhordh ++ bvdh ++ "Am" ;
<Neg,Infr_Past2 InfrPerf,PPers1,Pl> => nkhordh ++ bvdh ++ "Aym" ;
<Neg,Infr_Past2 InfrPerf,PPers2,Sg> => nkhordh ++ bvdh ++ "Ay" ;
<Neg,Infr_Past2 InfrPerf,PPers2,Pl> => nkhordh ++ bvdh ++ "Ayd" ;
<Neg,Infr_Past2 InfrPerf,PPers3,Sg> => nkhordh ++ bvdh ++ "Ast" ;
<Neg,Infr_Past2 InfrPerf,PPers3,Pl> => nkhordh ++ bvdh ++ "And" ;
<Neg,Infr_Past2 InfrImperf,PPers1,Sg> => nmekhordh ++ "Am" ;
<Neg,Infr_Past2 InfrImperf,PPers1,Pl> => nmekhordh ++ "Aym" ;
<Neg,Infr_Past2 InfrImperf,PPers2,Sg> => nmekhordh ++ "Ay" ;
<Neg,Infr_Past2 InfrImperf,PPers2,Pl> => nmekhordh ++ "Ayd" ;
<Neg,Infr_Past2 InfrImperf,PPers3,Sg> => nmekhordh ++ "Ast" ;
<Neg,Infr_Past2 InfrImperf,PPers3,Pl> => nmekhordh ++ "And"
}
} ;
mkvVform : Str -> Number -> PPerson -> {s: Str} = \root2,n,p ->
{s =
case <n,p> of {
<Sg,PPers1> => addBh root2 + "m" ;
<Sg,PPers2> => addBh root2 + "y" ;
<Sg,PPers3> => addBh root2 + "d" ;
<Pl,PPers1> => addBh root2 + "ym" ;
<Pl,PPers2> => addBh root2 + "yd" ;
<Pl,PPers3> => addBh root2 + "nd"
}
};
mkimpRoot : Str -> Str ;
mkimpRoot root =
case root of {
st + "y" => st ;
_ => root
};
addBh : Str -> Str ;
addBh str =
case (take 1 str) of {
"A" => "by" + str ;
"A:" => "byA" + (drop 1 str) ;
_ => "b" + str
};
---------------------
--Determiners
--------------------
makeDet : Str -> Number -> Bool -> {s: Str ; n : Number ; isNum : Bool ; fromPron : Bool} =\str,n,b -> {
s = str;
isNum = b;
fromPron = False ;
n = n
};
makeQuant : Str -> Str -> {s : Number => Str ; a : AgrPes ; fromPron : Bool } = \sg,pl -> {
s = table {Sg => sg ; Pl => pl} ;
fromPron = False ;
a = agrPesP3 Sg
};
---------------------------
-- Adjectives
--------------------------
mkAdj : Str -> Str -> Adjective = \adj,adv -> {
s = table { bEzafa => adj;
aEzafa => mkEzafa adj ;
enClic => mkEnclic adj
} ;
adv = adv
};
}

140
lib/src/persian/src/NumeralPes.gf Normal file
View File

@@ -0,0 +1,140 @@
--# -path=.:../abstract:../common:
concrete NumeralPes of Numeral = CatPes [Numeral,Digits] ** open ResPes,Prelude in {
flags coding = utf8;
param DForm = unit | teen | ten | hundreds |thousands;
param DSize = sg | r2 | r3 | r4 | r5 | r6 | r7 | r8 | r9 ;
param Size = singl | less100 | more100 ;
lincat
Digit = {s : DForm => CardOrd => Str} ;
Sub10 = {s : DForm => CardOrd => Str ; n : Number} ;
Sub100 = {s : CardOrd => Str ; n : Number} ;
Sub1000 = {s : CardOrd => Str ; n : Number} ;
Sub1000000 = {s : CardOrd => Str ; n : Number} ;
lin num x = x ;
-- 2 12 20 200
lin n2 = mkNum "dv" "dvAzdh" "byst" "dvyst" ;
lin n3 = mkNum3 "sh" "syzdh" "sy" "sySd" "svm" ;
lin n4 = mkNum "c^hAr" "c^hArdh" "c^hl" "c^hArSd" ;
lin n5 = mkNum "pnj" "pAnzdh" "pnjAh" "pAnSd" ;
lin n6 = mkNum "CC" "CAnzdh" "CSt" "CCSd" ;
lin n7 = mkNum "hft" "hfdh" "hftAd" "hftSd" ;
lin n8 = mkNum "hCt" "hjdh" "hCtAd" "hCtSd" ;
lin n9 = mkNum "nh" "nvzdh" "nvd" "nhSd" ;
lin pot01 = mkNum3 "yk" "yAzdh" "dh" "ykSd" "hzAr" ** {n = Sg} ;
lin pot0 d = d ** {n = Pl} ;
lin pot110 = {s = table { NCard => "dh" ;
NOrd => "dhm" };
n = Pl} ;
lin pot111 = {s = table { NCard => "yAzdh" ;
NOrd => "yAzdhm" };
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 => d.s ! ten ! NCard ++"v" ++e.s ! unit ! o ; n = Pl} ;
lin pot1as2 n = n ;
lin pot2 d = {s = d.s ! hundreds} ** {n = Pl} ;
lin pot2plus d e = {
s = \\o => d.s ! hundreds ! NCard ++ "v" ++ e.s ! o ; n = Pl} ; -- remove "??"
lin pot2as3 n = n ;
lin pot3 n = { s = \\o => n.s ! NCard ++ "hzAr" ; n = Pl} ;
lin pot3plus n m = {
s = \\o => n.s ! NCard ++ "hzAr" ++ "v" ++ m.s ! o; n = Pl} ; -- missing word "????????" after NCard
-- numerals as sequences of digits
lincat
Dig = TDigit ;
lin
IDig d = d ** {tail = T1} ;
{-
IIDig d i = {
s = \\o,c => d.s ! NCard ++ commaIf i.tail ++ i.s ! o ! c ;
n = Pl ;
-- tail = inc i.tail
} ;
-}
D_0 = mkDig "?" ;
D_1 = mk3Dig "?" "" Pl;
D_2 = mk2Dig "?" "";
D_3 = mk2Dig "?" "svm" ;
D_4 = mkDig "?" ;
D_5 = mkDig "?" ;
D_6 = mkDig "?" ;
D_7 = mkDig "?" ;
D_8 = mkDig "?" ;
D_9 = mkDig "?" ;
-- lin IDig d = { s = \\_ => d.s ; n = Sg} ;
lin IIDig d dg = { s = \\df => d.s ! NCard ++ dg.s ! df ; n = Pl};
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 + "m") ;
mk3Dig : Str -> Str -> Number -> TDigit = \c,o,n -> {
-- s = table {NCard => regGenitiveS c ; NOrd => regGenitiveS o} ;
s = table {NCard => c ; NOrd => o} ;
n = n
} ;
oper TDigit = {
n : Number ;
s : CardOrd => Str
} ;
oper
mkNum : Str -> Str -> Str -> Str -> {s : DForm => CardOrd => Str} =
\two, twelve, twenty, twohundred->
{s = table {
unit => table {NCard => two ; NOrd => (two + "myn") | (two + "m")};
teen => table {NCard => twelve ; NOrd => (twelve + "myn") | (twelve + "m")} ;
ten => table {NCard => twenty ; NOrd => (twenty + "myn") | (twenty + "m")};
hundreds => table {NCard => twohundred ; NOrd => (twohundred +"myn") | (twohundred + "m")};
thousands => table {NCard => (two + "hzAr" ); NOrd => (two + "hzAr" + "m") | (two + "hzAr" +"myn" )}
}};
mkNum3 : Str -> Str -> Str -> Str -> Str -> {s : DForm => CardOrd => Str} =
\two, twelve, twenty, twohundred, second->
{s = table {
unit => table {NCard => two ; NOrd => second};
teen => table {NCard => twelve ; NOrd => (twelve + "myn") | (twelve + "m")} ;
ten => table {NCard => twenty ; NOrd => (twenty + "myn") | (twenty + "m")};
hundreds => table {NCard => twohundred ; NOrd => (twohundred +"myn") | (twohundred + "m")};
thousands => table {NCard => (two + "hzAr" ); NOrd => (two + "hzAr" + "m") | (two + "hzAr"+ "myn" )}
}};
}

206
lib/src/persian/src/ParadigmsPes.gf Normal file
View File

@@ -0,0 +1,206 @@
--# -path=.:../abstract:../../prelude:../common
--
----1 Pnbu Lexical Paradigms
resource ParadigmsPes = open
Predef,
Prelude,
MorphoPes,
CatPes
in {
flags optimize=all ;
coding = utf8;
--2 Parameters
oper
animate : Animacy ;
inanimate : Animacy ;
singular : Number;
plural : Number;
singular = Sg ; plural = Pl;
animate = Animate ; inanimate = Inanimate ; --i
mkN01 : Str -> Animacy -> Noun ;
mkN01 str ani = mkN str (str ++ "hA") ani;
mkN02 : Str -> Animacy -> Noun ;
mkN02 str ani = case (last str) of {
"h" => mkN str ((init str) + "gAn") ani ;
("A"|"v") => mkN str (str + "yAn") ani ;
_ => mkN str (str+"An") ani
};
{-
--2 Nouns
mkN2 : N -> Prep -> Str -> N2;
mkN2 = \n,p,c -> n ** {lock_N2 = <> ; c2 = p.s ; c3 = c } ;
mkN3 : N -> Prep -> Str -> Str-> N3 ;
mkN3 = \n,p,q,r -> n ** {lock_N3 = <> ; c2 = p.s ; c3 = q ; c4 = r} ;
-}
-- Compound Nouns
mkCmpdNoun1 : Str -> N -> N
= \s,noun -> {s =\\ez,n => s ++ noun.s ! ez ! n ; animacy = noun.animacy ; definitness = noun.definitness ; lock_N = <>};
mkCmpdNoun2 : N -> Str -> N
= \noun,s -> {s =\\ez,n => noun.s ! ez ! n ++ s ; animacy = noun.animacy ; definitness =noun.definitness ; lock_N = <>};
-- Proper names
mkPN : Str -> Animacy -> PN =
\str,ani -> {s = str ; animacy = ani ; lock_PN = <>} ;
-- Personal Pronouns
personalPN : Str -> Number -> PPerson -> Pron =
\str,nn,p -> {s = str ; a = AgPes nn p ; ps = str ; lock_Pron = <>};
{-
-- Demonstration Pronouns
demoPN : Str -> Str -> Str -> Quant =
\s1,s2,s3 -> let n = makeDemonPronForm s1 s2 s3 in {s = n.s ; a = defaultAgr ; lock_Quant = <>};
-- Determiner
-}
mkDet = overload {
mkDet : Str -> Number -> Det =
\s1,n -> makeDet s1 n False ** { lock_Det = <>};
mkDet : Str -> Number -> Bool -> Det =
\s1,n,b -> makeDet s1 n b ** { lock_Det = <>};
};
{-
-- Intergative pronouns
mkIP : (x1,x2,x3,x4:Str) -> Number -> Gender -> IP =
\s1,s2,s3,s4,n,g -> let p = mkIntPronForm s1 s2 s3 s4 in { s = p.s ; n = n ; g = g ; lock_IP = <>};
-- AdN
mkAdN : Str -> AdN = \s -> ss s ;
-}
--2 Adjectives
mkA = overload {
mkA : Str-> A
= \str -> mkAdj str str ** { lock_A = <>} ;
mkA : Str-> Str -> A
= \str,adv -> mkAdj str adv ** { lock_A = <>} ;
mkA : Str -> Str -> A2
= \a,c -> mkAdj a a ** { c2 = c ; lock_A2 = <>} ;
} ;
--2 Verbs
mkV : Str -> Str -> V
= \s1, s2 -> mkVerb s1 s2 ** {lock_V = <>} ;
-- mkVerb takes both the Infinitive and the present root(root2) and is applied for iregular verbs
haveVerb : V = mkHave ;
mkV_1 : Str -> V
= \s -> mkVerb1 s ** {lock_V = <>} ;
mkV_2 : Str -> V
= \s -> mkVerb2 s ** {lock_V = <>} ;
mkV2 = overload {
-- mkV2 : Str -> V2
-- = \s -> mkV s ** {c2 = {s = [] ; c = VTrans} ; lock_V2 = <>} ;
mkV2 : V -> V2
= \v -> v ** {c2 = {s = [] ; ra = [] ; c = VTrans} ; lock_V2 = <>} ;
mkV2 : V -> Str -> V2
= \v,ra -> v ** {c2 = {ra = ra ; s = [] ; c = VTrans} ; lock_V2 = <>} ;
mkV2 : V -> Str -> Bool -> V2
= \v,p,b -> v ** {c2 = {ra = [] ; s = p ; c = VTrans} ; lock_V2 = <>} ;
} ;
mkV3 : V -> Str -> Str -> V3;
mkV3 v p q = v ** { c2 = p ; c3 = q ; lock_V3 = <>} ;
mkV2V : V -> Str -> Str -> Bool -> V2V ;
mkV2V v s1 s2 b = v ** {isAux = b ; c1 = s1 ; c2 = s2 ; lock_V2V = <>} ;
-- compund verbs
compoundV = overload {
compoundV : Str -> V -> V = \s,v -> {s = \\vf => s ++ v.s ! vf ; lock_V = <>} ;
compoundV : Str -> V2 -> V = \s,v -> {s = \\vf => s ++ v.s ! vf ; lock_V = <>} ;
};
{-
----2 Adverbs
mkAdv : Str -> Adv = \str -> {s =\\ _ => str ; lock_Adv = <>};
----2 Prepositions
mkPrep : Str -> Prep ;
mkPrep str = makePrep str ** {lock_Prep = <>};
--3 Determiners and quantifiers
-- mkQuant : overload {
-- mkQuant : Pron -> Quant ;
-- mkQuant : (no_sg, no_pl, none_sg, : Str) -> Quant ;
-- } ;
-}
mkQuant = overload {
-- mkQuant : Pron -> Quant = \p -> {s = \\_,_,c => p.s!c ;a = p.a ; lock_Quant = <>};
mkQuant : Str -> Str -> Quant = \sg,pl -> makeQuant sg pl;
} ;
{-
--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)
} ;
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}) ;
-- mkV0 : V -> V0 ;
-- mkVS : V -> VS ;
-- mkV2S : V -> Prep -> V2S ;
mkVV : V -> VV = \v -> lin VV (v ** {isAux = False});
-- 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 ;
-- mkA2V a p = a ** {c2 = p.s } ;
--
---- 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 Definitions of paradigms
----
---- The definitions should not bother the user of the API. So they are
---- hidden from the document.
--
-- Gender = MorphoHin.Gender ;
-- Number = MorphoHin.Number ;
-- Case = MorphoHin.Case ;
-- human = Masc ;
-- nonhuman = Neutr ;
-- masculine = Masc ;
-- feminine = Fem ;
-- singular = Sg ;
-- plural = Pl ;
-- nominative = Nom ;
-- genitive = Gen ;
-}
}

54
lib/src/persian/src/RelativePes.gf Normal file
View File

@@ -0,0 +1,54 @@
concrete RelativePes of Relative = CatPes ** open ResPes in {
flags optimize=all_subs ;
coding = utf8;
lin
RelCl cl = {
s = \\t,p,o,agr => "kh" ++ cl.s ! t ! p ! o ;
};
-- RelVP and RelSlash slows the linking process a lot this is why it is commented for test purposes
RelVP rp vp = {
s = \\t,p,o,ag =>
let
agr = case rp.a of {
RNoAg => ag ;
RAg a => a
} ;
cl = mkSClause (rp.s) agr vp;
-- cl = case t of {
-- VPImpPast => mkSClause (rp.s ! (giveNumber agr) ! Obl) agr vp;
-- _ => mkSClause (rp.s ! (giveNumber agr) ! Dir) agr vp
-- };
in
cl.s ! t ! p ! ODir ;
-- c = Dir
} ;
---- Pied piping: "at which we are looking". Stranding and empty
---- relative are defined in $ExtraHin.gf$ ("that we are looking at",
---- "we are looking at").
--
RelSlash rp slash = {
s = \\t,p,o,agr => rp.s ++ slash.c2.s ++ slash.s ! t ! p ! o ;--case t of {
-- VPImpPast => rp.s ! (giveNumber agr) Obl ++ slash.c2.s ++ slash.s ! t ! p ! o ;
-- _ => rp.s ! (giveNumber agr) Dir ++ slash.c2.s ++ slash.s ! t ! p ! o
-- };
-- c = Dir
} ;
FunRP p np rp = {
s = np.s ! NPC enClic ++ rp.s ++ p.s ++ getPron np.animacy (fromAgr np.a).n ; -- need to make a special form of relative np by addY
a = RAg np.a
} ;
IdRP = {
s = "kh" ;
a = RNoAg
} ;
}

863
lib/src/persian/src/ResPes.gf Normal file
View File

@@ -0,0 +1,863 @@
--# -path=.:../abstract:../common:../../prelude
--
--1 Pnbu auxiliary operations.
--
-- This module contains operations that are needed to make the
-- resource syntax work.
resource ResPes = ParamX ** open Prelude,Predef in {
flags optimize=all ;
coding = utf8;
param
Order = ODir | OQuest ;
Animacy = Animate | Inanimate ;
PMood = Del | Imper | PCond ;
PPerson = PPers1
| PPers2
| PPers3;
VerbForm1 = VF Polarity VTense2 PPerson Number
| Vvform AgrPes
| Imp Polarity Number
| Inf
| Root1 | Root2 ;
VTense2 = PPresent2 PrAspect | PPast2 PstAspect | PFut2 FtAspect| Infr_Past2 InfrAspect;
PrAspect = PrPerf | PrImperf ;
PstAspect = PstPerf | PstImperf | PstAorist ;
FtAspect = FtAorist ; -- just keep FtAorist
InfrAspect = InfrPerf | InfrImperf ;
AgrPes = AgPes Number PPerson;
Ezafa = bEzafa | aEzafa | enClic;
NPCase = NPC Ezafa ;
CardOrd = NCard | NOrd ;
RAgr = RNoAg | RAg AgrPes ;
-- RCase = RC Number Case ;
param
CPolarity =
CPos
|CNeg Bool; -- contracted or not
oper
Noun = {s : Ezafa => Number => Str ; animacy : Animacy ; definitness : Bool } ;
Verb = {s : VerbForm1 => Str} ;
Compl : Type = {s : Str ; ra : Str ; c : VType} ;
Adjective = {s:Ezafa => Str ; adv : Str} ;
NP : Type = {s : NPCase => Str ; a : AgrPes ; animacy : Animacy } ;
Determiner = {s : Str ; n :Number ; isNum : Bool ; fromPron : Bool} ;
VPHSlash = VPH ** {c2 : Compl} ;
oper
contrNeg : Bool -> Polarity -> CPolarity = \b,p -> case p of {
Pos => CPos ;
Neg => CNeg b
} ;
-----------------------
--- Verb Phrase
-----------------------
oper
VPH : Type = {
s : VPHForm => {inf : Str} ;
obj : {s : Str ; a : AgrPes} ;
subj : VType ;
comp : AgrPes => Str;
vComp : AgrPes => Str;
inf : Str;
ad : Str;
embComp : Str ;
wish : Bool ;
} ;
param
VPHForm =
VPTense Polarity VPPTense AgrPes -- 9 * 12
-- | VPReq
| VPImp Polarity Number
-- | VPReqFut
| VVForm AgrPes
| VPStem1
| VPStem2
;
VPHTense =
VPres -- impf hum nahim "I go"
| VPast -- impf Ta nahim "I went"
| VFut -- fut na/nahim "I shall go"
| VPerfPres -- perf hum na/nahim "I have gone"
| VPerfPast -- perf Ta na/nahim "I had gone"
| VPerfFut
| VCondSimul
| VCondAnter -- subj na "I may go"
;
VType = VIntrans | VTrans | VTransPost ;
VPPTense =
VPPres Anteriority
|VPPast Anteriority
|VPFutr Anteriority
|VPCond Anteriority ;
oper
predV : Verb -> VPH = \verb -> {
s = \\vh =>
case vh of {
VPTense pol (VPPres Simul) (AgPes n p) => { inf = verb.s ! VF pol (PPresent2 PrImperf) p n } ;
VPTense pol (VPPres Anter) (AgPes n p) => { inf = verb.s ! VF pol (PPresent2 PrPerf) p n } ;
VPTense pol (VPPast Simul) (AgPes n p) => { inf =verb.s ! VF pol (PPast2 PstAorist) p n } ;
VPTense pol (VPPast Anter) (AgPes n p) => { inf =verb.s ! VF pol (PPast2 PstPerf) p n } ;
VPTense pol (VPFutr Simul) (AgPes n p) => { inf = verb.s ! VF pol (PFut2 FtAorist) p n } ;
VPTense pol (VPFutr Anter) (AgPes n p) => { inf = verb.s ! VF pol (PPresent2 PrPerf) p n } ; -- this is to be confirmed
VPTense pol (VPCond Simul) (AgPes n p) => { inf = verb.s ! VF pol (PPast2 PstImperf) p n } ;
VPTense pol (VPCond Anter) (AgPes n p) => { inf = verb.s ! VF pol (PPast2 PstImperf) p n } ;
VVForm (AgPes n p) => {inf = verb.s ! Vvform (AgPes n p)} ;
VPStem1 => { inf = verb.s ! Root1};
VPStem2 => { inf = verb.s ! Root2} ;
VPImp pol n => { inf = verb.s ! Imp pol n}
};
obj = {s = [] ; a = defaultAgrPes} ;
subj = VIntrans ;
inf = verb.s ! Inf;
ad = [];
embComp = [];
wish = False ;
vComp = \\_ => [] ;
comp = \\_ => []
} ;
predVc : (Verb ** {c2,c1 : Str}) -> VPHSlash = \verb ->
predV verb ** {c2 = {s = verb.c1 ; ra = [] ; c = VTrans} } ;
----------------------
-- Verb Phrase complimantation
------------------------
{-
insertObject : NP -> VPHSlash -> VPH = \np,vps -> {
s = vps.s ;
-- obj = {s = variants { vps.obj.s ++ np.s ++ vps.c2.s ; vps.obj.s ++ np.s } ; a = np.a} ;
obj = {s = case vps.c2.s of {
"rA" => np.s ++ vps.c2.s ++ vps.obj.s;
_ => vps.c2.s ++ np.s ++ vps.obj.s
};
a = np.a} ;
subj = vps.c2.c ;
inf = vps.inf;
ad = vps.ad;
embComp = vps.embComp;
-- wish = vps.wish ;
comp = vps.comp
} ;
-}
insertObjc : (AgrPes => Str) -> VPHSlash -> VPHSlash = \obj,vp ->
insertObj obj vp ** {c2 = vp.c2} ;
insertVVc : (AgrPes => Str) -> VPHSlash -> VPHSlash = \obj,vp ->
insertVV obj vp ** {c2 = vp.c2} ;
{-
insertSubj : PPerson -> Str -> Str = \p,s ->
case p of { Pers1 => s ++ "wN" ; _ => s ++ "E"};
-}
insertObj : (AgrPes => Str) -> VPH -> VPH = \obj1,vp -> {
s = vp.s ;
obj = vp.obj ;
subj = vp.subj ;
inf = vp.inf;
ad = vp.ad;
embComp = vp.embComp;
wish = vp.wish ;
vComp = vp.vComp ;
comp = \\a => vp.comp ! a ++ obj1 ! a
} ;
insertVV : (AgrPes => Str) -> VPH -> VPH = \obj1,vp -> {
s = vp.s ;
-- obj = vp.obj ;
obj = vp.obj ;
subj = vp.subj ;
inf = vp.inf;
ad = vp.ad;
embComp = vp.embComp;
wish = True ;
vComp = \\a => vp.comp ! a ++ obj1 ! a ;
comp = vp.comp
} ;
insertObj2 : (Str) -> VPH -> VPH = \obj1,vp -> {
s = vp.s;
obj = vp.obj ;
subj = vp.subj ;
inf = vp.inf;
ad = vp.ad;
embComp = vp.embComp ++ obj1;
wish = vp.wish ;
vComp = vp.vComp ;
comp = \\a => vp.comp ! a -- ++ obj1
} ;
insertObj3 : (Str) -> VPH -> VPH = \obj1,vp -> {
s = vp.s;
obj = {s = obj1 ++ vp.obj.s ; a = vp.obj.a };
subj = vp.subj ;
inf = vp.inf;
ad = vp.ad;
embComp = vp.embComp;
wish = vp.wish ;
vComp = vp.vComp ;
comp = vp.comp
} ;
insertObjc2 : Str -> VPHSlash -> VPHSlash = \obj,vp ->
insertObj2 obj vp ** {c2 = vp.c2} ;
insertObjc3 : Str -> VPHSlash -> VPHSlash = \obj,vp ->
insertObj3 obj vp ** {c2 = vp.c2} ;
{-
infVP : Bool -> VPH -> Agr -> Str = \isAux,vp,a ->
vp.obj.s ++ vp.inf ++ vp.comp ! a ;
-}
infVV : Bool -> VPH -> {s : AgrPes => Str} = \isAux,vp ->
{s = \\agr => case agr of {
AgPes n p => (vp.comp ! (toAgr n p)) ++ (vp.s ! VVForm (AgPes n p)).inf }};
insertObjPre : (AgrPes => Str) -> VPHSlash -> VPH = \obj,vp -> {
s = vp.s ;
obj = vp.obj ;
inf = vp.inf ;
subj = vp.subj ;
ad = vp.ad ;
embComp = vp.embComp;
wish = vp.wish ;
vComp = vp.vComp ;
-- comp = \\a => case vp.c2.s of {"rA" => obj ! a ++ vp.c2.s ++ vp.comp ! a ; _ => vp.c2.s ++ obj ! a ++ vp.comp ! a} -- gives linking error
comp = \\a => vp.c2.s ++ obj ! a ++ vp.c2.ra ++ vp.comp ! a
} ;
insertAdV : Str -> VPH -> VPH = \ad,vp -> {
s = vp.s ;
obj = vp.obj ;
inf = vp.inf ;
subj = vp.subj;
ad = vp.ad ++ ad ;
embComp = vp.embComp;
wish = vp.wish ;
vComp = vp.vComp ;
comp = vp.comp
} ;
conjThat : Str = "kh" ;
{- checkPron : NP -> Str -> Str = \np,str -> case (np.isPron) of {
True => np.s ! NPC Obl;
False => np.s ! NPC Obl ++ str} ;
insertEmbCompl : VPH -> Str -> VPH = \vp,emb -> {
s = vp.s ;
obj = vp.obj ;
inf = vp.inf ;
subj = vp.subj;
ad = vp.ad;
embComp = vp.embComp ++ emb;
wish = vp.wish ;
comp = vp.comp
} ;
insertTrans : VPH -> VType -> VPH = \vp,vtype -> {
s = vp.s ;
obj = vp.obj ;
inf = vp.inf ;
subj = case vtype of {VIntrans => VTransPost ; VTrans => VTrans ; _ => vtype} ; -- still some problem not working properly
ad = vp.ad;
embComp = vp.embComp ;
wish = vp.wish ;
comp = vp.comp
} ;
-}
---------------------------
--- Clauses
---------------------------
Clause : Type = {s : VPHTense => Polarity => Order => Str} ;
mkClause : NP -> VPH -> Clause = \np,vp -> {
s = \\vt,b,ord =>
let
subj = np.s ! NPC bEzafa;
agr = np.a ;
n = (fromAgr agr).n;
p = (fromAgr agr).p;
vps = case <b,vt> of {
<Pos,VPres> => vp.s ! VPTense Pos (VPPres Simul) (AgPes n p) ;
<Neg,VPres> => vp.s ! VPTense Neg (VPPres Simul) (AgPes n p) ;
<Pos,VPerfPres> => vp.s ! VPTense Pos (VPPres Anter) (AgPes n p) ;
<Neg,VPerfPres> => vp.s ! VPTense Neg (VPPres Anter) (AgPes n p) ;
<Pos,VPast> => vp.s ! VPTense Pos (VPPast Simul) (AgPes n p) ;
<Neg,VPast> => vp.s ! VPTense Neg (VPPast Simul) (AgPes n p) ;
<Pos,VPerfPast> => vp.s ! VPTense Pos (VPPast Anter) (AgPes n p) ;
<Pos,VFut> => case vp.wish of
{True => vp.s ! VPTense Pos (VPPres Simul) (AgPes n p) ;
False => vp.s ! VPTense Pos (VPFutr Simul) (AgPes n p) };
<Pos,VPerfFut> => case vp.wish of
{True => vp.s ! VPTense Pos (VPPres Anter) (AgPes n p) ;
False => vp.s ! VPTense Pos (VPFutr Anter) (AgPes n p) }; -- verb form need to be confirmed
<Pos,VCondSimul> => vp.s ! VPTense Pos (VPCond Simul) (AgPes n p) ;
<Pos,VCondAnter> => vp.s ! VPTense Pos (VPCond Anter) (AgPes n p); -- verb form to be confirmed
<Neg,VPerfPast> => vp.s ! VPTense Neg (VPPast Anter) (AgPes n p) ;
<Neg,VFut> => case vp.wish of
{True => vp.s ! VPTense Neg (VPPres Simul) (AgPes n p) ;
False => vp.s ! VPTense Neg (VPFutr Simul) (AgPes n p) };
<Neg,VPerfFut> => case vp.wish of
{True => vp.s ! VPTense Neg (VPPres Anter) (AgPes n p) ;
False => vp.s ! VPTense Neg (VPFutr Anter) (AgPes n p) }; -- verb form need to be confirmed
<Neg,VCondSimul> => vp.s ! VPTense Neg (VPCond Simul) (AgPes n p) ;
<Neg,VCondAnter> => vp.s ! VPTense Neg (VPCond Anter) (AgPes n p) -- verb form to be confirmed
};
quest =
case ord of
{ ODir => [];
OQuest => "A:yA" };
in
quest ++ subj ++ vp.ad ++ vp.comp ! np.a ++ vp.obj.s ++ vps.inf ++ vp.vComp ! np.a ++ vp.embComp
};
--Clause : Type = {s : VPHTense => Polarity => Order => Str} ;
mkSClause : Str -> AgrPes -> VPH -> Clause = \subj,agr,vp -> {
s = \\vt,b,ord =>
let
n = (fromAgr agr).n;
p = (fromAgr agr).p;
vps = case <b,vt> of {
<Pos,VPres> => vp.s ! VPTense Pos (VPPres Simul) (AgPes n p) ;
<Neg,VPres> => vp.s ! VPTense Neg (VPPres Simul) (AgPes n p) ;
<Pos,VPerfPres> => vp.s ! VPTense Pos (VPPres Anter) (AgPes n p) ;
<Neg,VPerfPres> => vp.s ! VPTense Neg (VPPres Anter) (AgPes n p) ;
<Pos,VPast> => vp.s ! VPTense Pos (VPPast Simul) (AgPes n p) ;
<Neg,VPast> => vp.s ! VPTense Neg (VPPast Simul) (AgPes n p) ;
<Pos,VPerfPast> => vp.s ! VPTense Pos (VPPast Anter) (AgPes n p) ;
<Pos,VFut> => case vp.wish of
{True => vp.s ! VPTense Pos (VPPres Simul) (AgPes n p) ;
False => vp.s ! VPTense Pos (VPFutr Simul) (AgPes n p) };
<Pos,VPerfFut> => case vp.wish of
{True => vp.s ! VPTense Pos (VPPres Anter) (AgPes n p) ;
False => vp.s ! VPTense Pos (VPFutr Anter) (AgPes n p) }; -- verb form need to be confirmed
<Pos,VCondSimul> => vp.s ! VPTense Pos (VPCond Simul) (AgPes n p) ;
<Pos,VCondAnter> => vp.s ! VPTense Pos (VPCond Anter) (AgPes n p); -- verb form to be confirmed
<Neg,VPerfPast> => vp.s ! VPTense Neg (VPPast Anter) (AgPes n p) ;
<Neg,VFut> => case vp.wish of
{True => vp.s ! VPTense Neg (VPPres Simul) (AgPes n p) ;
False => vp.s ! VPTense Neg (VPFutr Simul) (AgPes n p) };
<Neg,VPerfFut> => case vp.wish of
{True => vp.s ! VPTense Neg (VPPres Anter) (AgPes n p) ;
False => vp.s ! VPTense Neg (VPFutr Anter) (AgPes n p) }; -- verb form need to be confirmed
<Neg,VCondSimul> => vp.s ! VPTense Neg (VPCond Simul) (AgPes n p) ;
<Neg,VCondAnter> => vp.s ! VPTense Neg (VPCond Anter) (AgPes n p) -- verb form to be confirmed
};
quest =
case ord of
{ ODir => [];
OQuest => "A:yA" };
in
quest ++ subj ++ vp.ad ++ vp.comp ! agr ++ vp.obj.s ++ vps.inf ++ vp.vComp ! agr ++ vp.embComp
};
predAux : Aux -> VPH = \verb -> {
s = \\vh =>
case vh of {
VPTense pol (VPPres Simul) (AgPes n p) => { inf = verb.inf ! AX pol (AuxPresent PrImperf) p n } ;
VPTense pol (VPPres Anter) (AgPes n p) => { inf = verb.inf ! AX pol (AuxPresent PrPerf) p n } ;
VPTense pol (VPPast Simul) (AgPes n p) => { inf = verb.inf ! AX pol (AuxPast PstAorist) p n } ;
VPTense pol (VPPast Anter) (AgPes n p) => { inf = verb.inf ! AX pol (AuxPresent PrPerf) p n } ;
VPTense pol (VPFutr Simul) (AgPes n p) => { inf = verb.inf ! AX pol (AuxFut FtAorist) p n } ;
VPTense pol (VPFutr Anter) (AgPes n p) => { inf = verb.inf ! AX pol (AuxFut FtAorist) p n } ; -- this is to be confirmed
VPTense pol (VPCond Simul) (AgPes n p) => { inf = verb.inf ! AX pol (AuxFut FtAorist) p n } ;
VPTense pol (VPCond Anter) (AgPes n p) => { inf = verb.inf ! AX pol (AuxPast PstImperf) p n } ;
VVForm (AgPes n p) => {inf = ""} ; -- to be checked
VPStem1 => { inf = ""};
VPStem2 => { inf = "bvd"} ;
VPImp _ _ => { inf = ""} -- need to be confirmed
-- _ => { inf = ""}
};
obj = {s = [] ; a = defaultAgrPes} ;
subj = VIntrans ;
inf = "bvdn";
ad = [];
embComp = [];
wish = False ;
vComp = \\_ => [] ;
comp = \\_ => []
} ;
Aux = {
inf : AuxForm => Str ;
} ;
auxBe : Aux = {
inf = table {
AX pol tense person number => (mkAux pol tense person number).s
} ;
} ;
mkAux : Polarity -> AuxTense -> PPerson -> Number -> {s:Str}= \pol,t,p,n ->
{s =
let bodh = "bvdh" ;
nbodh = "nbvdh" ;
hast = "hst" ;
nhast = "nyst" ;
bod = "bvd" ;
khah = "KvAh" ;
mekhah = "my" ++ khah ;
bash = "bAC" ;
nbod = "nbvd" ;
nkhah = "nKvAh" ;
nmekhah = "nmy" ++ khah ;
nbash = "nbAC"
in
case <pol,t,p,n> of {
<Pos,AuxPresent PrPerf,PPers1,Sg> => bodh ++ "Am" ;
<Pos,AuxPresent PrPerf,PPers1,Pl> => bodh ++ "Aym" ;
<Pos,AuxPresent PrPerf,PPers2,Sg> => bodh ++ "Ay" ;
<Pos,AuxPresent PrPerf,PPers2,Pl> => bodh ++ "Ayd" ;
<Pos,AuxPresent PrPerf,PPers3,Sg> => bodh ++ "Ast" ;
<Pos,AuxPresent PrPerf,PPers3,Pl> => bodh ++ "And" ;
<Pos,AuxPresent PrImperf,PPers1,Sg> => hast + "m" ;
<Pos,AuxPresent PrImperf,PPers1,Pl> => hast + "ym" ;
<Pos,AuxPresent PrImperf,PPers2,Sg> => hast + "y" ;
<Pos,AuxPresent PrImperf,PPers2,Pl> => hast + "yd" ;
<Pos,AuxPresent PrImperf,PPers3,Sg> => "Ast" ;
<Pos,AuxPresent PrImperf,PPers3,Pl> => hast + "nd" ;
<Pos,AuxPast PstPerf,PPers1,Sg> => "";
<Pos,AuxPast PstPerf,PPers1,Pl> => "" ;
<Pos,AuxPast PstPerf,PPers2,Sg> => "" ;
<Pos,AuxPast PstPerf,PPers2,Pl> => "" ;
<Pos,AuxPast PstPerf,PPers3,Sg> => "" ;
<Pos,AuxPast PstPerf,PPers3,Pl> => "" ;
<Pos,AuxPast PstImperf,PPers1,Sg> => "my" ++ bod + "m" ;
<Pos,AuxPast PstImperf,PPers1,Pl> => "my" ++ bod + "ym" ;
<Pos,AuxPast PstImperf,PPers2,Sg> => "my" ++ bod + "y";
<Pos,AuxPast PstImperf,PPers2,Pl> => "my" ++ bod + "yd" ;
<Pos,AuxPast PstImperf,PPers3,Sg> => "my" ++ bod ;
<Pos,AuxPast PstImperf,PPers3,Pl> => "my" ++ bod + "nd" ;
<Pos,AuxPast PstAorist,PPers1,Sg> => bod + "m" ;
<Pos,AuxPast PstAorist,PPers1,Pl> => bod + "ym" ;
<Pos,AuxPast PstAorist,PPers2,Sg> => bod + "y";
<Pos,AuxPast PstAorist,PPers2,Pl> => bod + "yd" ;
<Pos,AuxPast PstAorist,PPers3,Sg> => bod ;
<Pos,AuxPast PstAorist,PPers3,Pl> => bod + "nd" ;
{-
<Pos,AuxFut FtImperf,PPers1,Sg> => mekhah + "m" ++ bash + "m" ;
<Pos,AuxFut FtImperf,PPers1,Pl> => mekhah + "ym" ++ bash + "ym" ;
<Pos,AuxFut FtImperf,PPers2,Sg> => mekhah + "y" ++ bash + "y" ;
<Pos,AuxFut FtImperf,PPers2,Pl> => mekhah + "yd" ++ bash + "yd" ;
<Pos,AuxFut FtImperf,PPers3,Sg> => mekhah + "d" ++ bash + "d" ;
<Pos,AuxFut FtImperf,PPers3,Pl> => mekhah + "nd" ++ bash + "nd" ;
-}
<Pos,AuxFut FtAorist,PPers1,Sg> => khah + "m" ++ bod ;
<Pos,AuxFut FtAorist,PPers1,Pl> => khah + "ym" ++ bod ;
<Pos,AuxFut Ftorist,PPers2,Sg> => khah + "y" ++ bod ;
<Pos,AuxFut FtAorist,PPers2,Pl> => khah + "yd" ++ bod ;
<Pos,AuxFut FtAorist,PPers3,Sg> => khah + "d" ++ bod ;
<Pos,AuxFut FtAorist,PPers3,Pl> => khah + "nd" ++ bod ;
-- nagatives
<Neg,AuxPresent PrPerf,PPers1,Sg> => nbodh ++ "Am" ;
<Neg,AuxPresent PrPerf,PPers1,Pl> => nbodh ++ "Aym" ;
<Neg,AuxPresent PrPerf,PPers2,Sg> => nbodh ++ "Ay" ;
<Neg,AuxPresent PrPerf,PPers2,Pl> => nbodh ++ "Ayd" ;
<Neg,AuxPresent PrPerf,PPers3,Sg> => nbodh ++ "Ast" ;
<Neg,AuxPresent PrPerf,PPers3,Pl> => nbodh ++ "And" ;
<Neg,AuxPresent PrImperf,PPers1,Sg> => nhast + "m" ;
<Neg,AuxPresent PrImperf,PPers1,Pl> => nhast + "ym" ;
<Neg,AuxPresent PrImperf,PPers2,Sg> => nhast + "y" ;
<Neg,AuxPresent PrImperf,PPers2,Pl> => nhast + "yd" ;
<Neg,AuxPresent PrImperf,PPers3,Sg> => "nyst" ;
<Neg,AuxPresent PrImperf,PPers3,Pl> => nhast + "nd" ;
<Neg,AuxPast PstPerf,PPers1,Sg> => "";
<Neg,AuxPast PstPerf,PPers1,Pl> => "" ;
<Neg,AuxPast PstPerf,PPers2,Sg> => "" ;
<Neg,AuxPast PstPerf,PPers2,Pl> => "" ;
<Neg,AuxPast PstPerf,PPers3,Sg> => "" ;
<Neg,AuxPast PstPerf,PPers3,Pl> => "" ;
<Neg,AuxPast PstImperf,PPers1,Sg> => "nmy" ++ bod + "m" ;
<Neg,AuxPast PstImperf,PPers1,Pl> => "nmy" ++ bod + "ym" ;
<Neg,AuxPast PstImperf,PPers2,Sg> => "nmy" ++ bod + "y";
<Neg,AuxPast PstImperf,PPers2,Pl> => "nmy" ++ bod + "yd" ;
<Neg,AuxPast PstImperf,PPers3,Sg> => "nmy" ++ bod ;
<Neg,AuxPast PstImperf,PPers3,Pl> => "nmy" ++ bod + "nd" ;
<Neg,AuxPast PstAorist,PPers1,Sg> => nbod + "m" ;
<Neg,AuxPast PstAorist,PPers1,Pl> => nbod + "ym" ;
<Neg,AuxPast PstAorist,PPers2,Sg> => nbod + "y";
<Neg,AuxPast PstAorist,PPers2,Pl> => nbod + "yd" ;
<Neg,AuxPast PstAorist,PPers3,Sg> => nbod ;
<Neg,AuxPast PstAorist,PPers3,Pl> => nbod + "nd" ;
{-
<Neg,AuxFut FtImperf,PPers1,Sg> => nmekhah + "m" ++ bash + "m" ;
<Neg,AuxFut FtImperf,PPers1,Pl> => nmekhah + "ym" ++ bash + "ym" ;
<Neg,AuxFut FtImperf,PPers2,Sg> => nmekhah + "y" ++ bash + "y" ;
<Neg,AuxFut FtImperf,PPers2,Pl> => nmekhah + "yd" ++ bash + "yd" ;
<Neg,AuxFut FtImperf,PPers3,Sg> => nmekhah + "d" ++ bash + "d" ;
<Neg,AuxFut FtImperf,PPers3,Pl> => nmekhah + "nd" ++ bash + "nd" ;
-}
<Neg,AuxFut FtAorist,PPers1,Sg> => nkhah + "m" ++ bod ;
<Neg,AuxFut FtAorist,PPers1,Pl> => nkhah + "ym" ++ bod ;
<Neg,AuxFut Ftorist,PPers2,Sg> => nkhah + "y" ++ bod ;
<Neg,AuxFut FtAorist,PPers2,Pl> => nkhah + "yd" ++ bod ;
<Neg,AuxFut FtAorist,PPers3,Sg> => nkhah + "d" ++ bod ;
<Neg,AuxFut FtAorist,PPers3,Pl> => nkhah + "nd" ++ bod
{-
<Infr_Past2 InfrPerf,PPers1,Sg> => khordh ++ bvdh ++ "Am" ;
<Infr_Past2 InfrPerf,PPers1,Pl> => khordh ++ bvdh ++ "Aym" ;
<Infr_Past2 InfrPerf,PPers2,Sg> => khordh ++ bvdh ++ "Ay" ;
<Infr_Past2 InfrPerf,PPers2,Pl> => khordh ++ bvdh ++ "Ayd" ;
<Infr_Past2 InfrPerf,PPers3,Sg> => khordh ++ bvdh ++ "Ast" ;
<Infr_Past2 InfrPerf,PPers3,Pl> => khordh ++ bvdh ++ "And" ;
<Infr_Past2 InfrImperf,PPers1,Sg> => mekhordh ++ "Am" ;
<Infr_Past2 InfrImperf,PPers1,Pl> => mekhordh ++ "Aym" ;
<Infr_Past2 InfrImperf,PPers2,Sg> => mekhordh ++ "Ay" ;
<Infr_Past2 InfrImperf,PPers2,Pl> => mekhordh ++ "Ayd" ;
<Infr_Past2 InfrImperf,PPers3,Sg> => mekhordh ++ "Ast" ;
<Infr_Past2 InfrImperf,PPers3,Pl> => mekhordh ++ "And"
-}
}
} ;
param
AuxTense = AuxPresent PrAspect | AuxPast PstAspect | AuxFut FtAspect ;
AuxForm = AX Polarity AuxTense PPerson Number ;
oper
toHave : Polarity -> VTense2 -> Number -> PPerson -> {s:Str} = \pol,t,n,p -> {
s = let dasht = "dACt";
ndasht = "ndACt" ;
dashteh = "dACth";
ndashteh = "ndACth" ;
dar = "dAr" ;
ndar = "ndAr" ;
khah = "KvAh" ;
nkhah = "nKvAh" ;
bvdh = "bvdh" ;
in case <pol,t,p,n> of {
<Pos,PPresent2 PrPerf,PPers1,Sg> => dashteh ++ "Am" ;
<Pos,PPresent2 PrPerf,PPers1,Pl> => dashteh ++ "Aym" ;
<Pos,PPresent2 PrPerf,PPers2,Sg> => dashteh ++ "Ay" ;
<Pos,PPresent2 PrPerf,PPers2,Pl> => dashteh ++ "Ayd" ;
<Pos,PPresent2 PrPerf,PPers3,Sg> => dashteh ++ "Ast" ;
<Pos,PPresent2 PrPerf,PPers3,Pl> => dashteh ++ "And" ;
<Pos,PPresent2 PrImperf,PPers1,Sg> => dar + "m" ;
<Pos,PPresent2 PrImperf,PPers1,Pl> => dar + "ym" ;
<Pos,PPresent2 PrImperf,PPers2,Sg> => dar + "y" ;
<Pos,PPresent2 PrImperf,PPers2,Pl> => dar + "yd" ;
<Pos,PPresent2 PrImperf,PPers3,Sg> => dar + "d" ;
<Pos,PPresent2 PrImperf,PPers3,Pl> => dar + "nd" ;
<Pos,PPast2 PstPerf,PPers1,Sg> => dashteh ++ "bvdm" ;
<Pos,PPast2 PstPerf,PPers1,Pl> => dashteh ++ "bvdym" ;
<Pos,PPast2 PstPerf,PPers2,Sg> => dashteh ++ "bvdy" ;
<Pos,PPast2 PstPerf,PPers2,Pl> => dashteh ++ "bvdyd" ;
<Pos,PPast2 PstPerf,PPers3,Sg> => dashteh ++ "bvd" ;
<Pos,PPast2 PstPerf,PPers3,Pl> => dashteh ++ "bvdnd" ;
<Pos,PPast2 PstImperf,PPers1,Sg> => dasht + "m" ;
<Pos,PPast2 PstImperf,PPers1,Pl> => dasht + "ym" ;
<Pos,PPast2 PstImperf,PPers2,Sg> => dasht + "y";
<Pos,PPast2 PstImperf,PPers2,Pl> => dasht + "yd" ;
<Pos,PPast2 PstImperf,PPers3,Sg> => dasht ;
<Pos,PPast2 PstImperf,PPers3,Pl> => dasht + "nd" ;
<Pos,PPast2 PstAorist,PPers1,Sg> => dasht + "m" ;
<Pos,PPast2 PstAorist,PPers1,Pl> => dasht + "ym" ;
<Pos,PPast2 PstAorist,PPers2,Sg> => dasht + "y";
<Pos,PPast2 PstAorist,PPers2,Pl> => dasht + "yd" ;
<Pos,PPast2 PstAorist,PPers3,Sg> => dasht ;
<Pos,PPast2 PstAorist,PPers3,Pl> => dasht + "nd" ;
<Pos,PFut2 FtAorist,PPers1,Sg> => khah + "m" ++ dasht ;
<Pos,PFut2 FtAorist,PPers1,Pl> => khah + "ym" ++ dasht ;
<Pos,PFut2 Ftorist,PPers2,Sg> => khah + "y" ++ dasht ;
<Pos,PFut2 FtAorist,PPers2,Pl> => khah + "yd" ++ dasht ;
<Pos,PFut2 FtAorist,PPers3,Sg> => khah + "d" ++ dasht ;
<Pos,PFut2 FtAorist,PPers3,Pl> => khah + "nd" ++ dasht ;
<Pos,Infr_Past2 InfrPerf,PPers1,Sg> => dashteh ++ bvdh ++ "Am" ;
<Pos,Infr_Past2 InfrPerf,PPers1,Pl> => dashteh ++ bvdh ++ "Aym" ;
<Pos,Infr_Past2 InfrPerf,PPers2,Sg> => dashteh ++ bvdh ++ "Ay" ;
<Pos,Infr_Past2 InfrPerf,PPers2,Pl> => dashteh ++ bvdh ++ "Ayd" ;
<Pos,Infr_Past2 InfrPerf,PPers3,Sg> => dashteh ++ bvdh ++ "Ast" ;
<Pos,Infr_Past2 InfrPerf,PPers3,Pl> => dashteh ++ bvdh ++ "And" ;
<Pos,Infr_Past2 InfrImperf,PPers1,Sg> => dashteh ++ "Am" ;
<Pos,Infr_Past2 InfrImperf,PPers1,Pl> => dashteh ++ "Aym" ;
<Pos,Infr_Past2 InfrImperf,PPers2,Sg> => dashteh ++ "Ay" ;
<Pos,Infr_Past2 InfrImperf,PPers2,Pl> => dashteh ++ "Ayd" ;
<Pos,Infr_Past2 InfrImperf,PPers3,Sg> => dashteh ++ "Ast" ;
<Pos,Infr_Past2 InfrImperf,PPers3,Pl> => dashteh ++ "And" ;
-- negatives
<Neg,PPresent2 PrPerf,PPers1,Sg> => ndashteh ++ "Am" ;
<Neg,PPresent2 PrPerf,PPers1,Pl> => ndashteh ++ "Aym" ;
<Neg,PPresent2 PrPerf,PPers2,Sg> => ndashteh ++ "Ay" ;
<Neg,PPresent2 PrPerf,PPers2,Pl> => ndashteh ++ "Ayd" ;
<Neg,PPresent2 PrPerf,PPers3,Sg> => ndashteh ++ "Ast" ;
<Neg,PPresent2 PrPerf,PPers3,Pl> => ndashteh ++ "And" ;
<Neg,PPresent2 PrImperf,PPers1,Sg> => ndar + "m" ;
<Neg,PPresent2 PrImperf,PPers1,Pl> => ndar + "ym" ;
<Neg,PPresent2 PrImperf,PPers2,Sg> => ndar + "y" ;
<Neg,PPresent2 PrImperf,PPers2,Pl> => ndar + "yd" ;
<Neg,PPresent2 PrImperf,PPers3,Sg> => ndar + "d" ;
<Neg,PPresent2 PrImperf,PPers3,Pl> => ndar + "nd" ;
<Neg,PPast2 PstPerf,PPers1,Sg> => ndashteh ++ "bvdm" ;
<Neg,PPast2 PstPerf,PPers1,Pl> => ndashteh ++ "bvdym" ;
<Neg,PPast2 PstPerf,PPers2,Sg> => ndashteh ++ "bvdy" ;
<Neg,PPast2 PstPerf,PPers2,Pl> => ndashteh ++ "bvdyd" ;
<Neg,PPast2 PstPerf,PPers3,Sg> => ndashteh ++ "bvd" ;
<Neg,PPast2 PstPerf,PPers3,Pl> => ndashteh ++ "bvdnd" ;
<Neg,PPast2 PstImperf,PPers1,Sg> => ndasht + "m" ;
<Neg,PPast2 PstImperf,PPers1,Pl> => ndasht + "ym" ;
<Neg,PPast2 PstImperf,PPers2,Sg> => ndasht + "y";
<Neg,PPast2 PstImperf,PPers2,Pl> => ndasht + "yd" ;
<Neg,PPast2 PstImperf,PPers3,Sg> => ndasht ;
<Neg,PPast2 PstImperf,PPers3,Pl> => ndasht + "nd" ;
<Neg,PPast2 PstAorist,PPers1,Sg> => ndasht + "m" ;
<Neg,PPast2 PstAorist,PPers1,Pl> => ndasht + "ym" ;
<Neg,PPast2 PstAorist,PPers2,Sg> => ndasht + "y";
<Neg,PPast2 PstAorist,PPers2,Pl> => ndasht + "yd" ;
<Neg,PPast2 PstAorist,PPers3,Sg> => ndasht ;
<Neg,PPast2 PstAorist,PPers3,Pl> => ndasht + "nd" ;
<Neg,PFut2 FtAorist,PPers1,Sg> => nkhah + "m" ++ dasht ;
<Neg,PFut2 FtAorist,PPers1,Pl> => nkhah + "ym" ++ dasht ;
<Neg,PFut2 Ftorist,PPers2,Sg> => nkhah + "y" ++ dasht ;
<Neg,PFut2 FtAorist,PPers2,Pl> => nkhah + "yd" ++ dasht ;
<Neg,PFut2 FtAorist,PPers3,Sg> => nkhah + "d" ++ dasht ;
<Neg,PFut2 FtAorist,PPers3,Pl> => nkhah + "nd" ++ dasht ;
<Neg,Infr_Past2 InfrPerf,PPers1,Sg> => ndashteh ++ bvdh ++ "Am" ;
<Neg,Infr_Past2 InfrPerf,PPers1,Pl> => ndashteh ++ bvdh ++ "Aym" ;
<Neg,Infr_Past2 InfrPerf,PPers2,Sg> => ndashteh ++ bvdh ++ "Ay" ;
<Neg,Infr_Past2 InfrPerf,PPers2,Pl> => ndashteh ++ bvdh ++ "Ayd" ;
<Neg,Infr_Past2 InfrPerf,PPers3,Sg> => ndashteh ++ bvdh ++ "Ast" ;
<Neg,Infr_Past2 InfrPerf,PPers3,Pl> => ndashteh ++ bvdh ++ "And" ;
<Neg,Infr_Past2 InfrImperf,PPers1,Sg> => ndashteh ++ "Am" ;
<Neg,Infr_Past2 InfrImperf,PPers1,Pl> => ndashteh ++ "Aym" ;
<Neg,Infr_Past2 InfrImperf,PPers2,Sg> => ndashteh ++ "Ay" ;
<Neg,Infr_Past2 InfrImperf,PPers2,Pl> => ndashteh ++ "Ayd" ;
<Neg,Infr_Past2 InfrImperf,PPers3,Sg> => ndashteh ++ "Ast" ;
<Neg,Infr_Past2 InfrImperf,PPers3,Pl> => ndashteh ++ "And"
};
} ;
predProg : VPH -> VPH = \verb -> {
s = \\vh =>
case vh of {
VPTense pol (VPPres Simul) (AgPes n p) => { inf = (toHave Pos (PPresent2 PrImperf) n p).s ++ (verb.s ! VPTense pol (VPPres Simul) (AgPes n p)).inf } ;
VPTense pol (VPPres Anter) (AgPes n p) => { inf = (verb.s ! VPTense pol (VPPres Anter) (AgPes n p)).inf } ;
VPTense pol (VPPast Simul) (AgPes n p) => { inf = (toHave Pos (PPast2 PstAorist) n p).s ++ (verb.s ! VPTense pol (VPCond Simul) (AgPes n p)).inf } ;
VPTense pol (VPPast Anter) (AgPes n p) => { inf = (verb.s ! VPTense pol (VPPast Anter) (AgPes n p)).inf } ;
VPTense pol (VPFutr Simul) (AgPes n p) => { inf = (verb.s ! VPTense pol (VPFutr Simul) (AgPes n p)).inf } ;
VPTense pol (VPFutr Anter) (AgPes n p) => { inf = (verb.s ! VPTense pol (VPFutr Anter) (AgPes n p)).inf } ; -- this is to be confirmed
VPTense pol (VPCond Simul) (AgPes n p) => { inf = (toHave Pos (PPast2 PstAorist) n p).s ++ (verb.s ! VPTense pol (VPCond Simul) (AgPes n p)).inf } ;
VPTense pol (VPCond Anter) (AgPes n p) => { inf = (toHave Pos (PPast2 PstAorist) n p).s ++ (verb.s ! VPTense pol (VPCond Anter) (AgPes n p)).inf } ;
VVForm (AgPes n p) => {inf = (verb.s ! VVForm (AgPes n p)).inf} ;
VPStem1 => { inf = (verb.s ! VPStem1).inf};
VPStem2 => { inf = (verb.s ! VPStem2).inf} ;
VPImp pol n => { inf = (verb.s ! VPImp pol n).inf} -- need to be confirmed
-- _ => { inf = (verb.s ! VPStem1).inf}
};
obj = verb.obj ;
subj = VIntrans ;
inf = verb.inf;
ad = verb.ad;
wish = verb.wish;
vComp = verb.vComp ;
embComp = verb.embComp ;
comp = verb.comp
} ;
-------------------------
-- Ezafa construction
------------------------
oper
mkEzafa : Str -> Str ;
mkEzafa str = case str of {
st + "Ah" => str ;
st + "vh" => str ;
st + "h" => str ++ "y" ;
st + "Av" => str ;
st + "vv" => str ;
st + "v" => str + "y" ;
st + "A" => str + "y" ;
_ => str
};
mkEnclic : Str -> Str ;
mkEnclic str = case str of {
st + "A" => str ++ "yy" ;
st + "v" => str ++ "yy" ;
st + "y" => str ++ "yy" ;
st + "h" => str ++ "yy" ;
_ => str + "y"
};
IndefArticle : Str ;
IndefArticle = "yk";
taryn : Str ;
taryn = "tryn" ;
---------------
-- making negatives
---------------
addN : Str -> Str ;
addN str =
case str of {
"A" + st => "ny" + str ;
"A:" + st => "nyA" + st ;
_ => "n" + str
};
addBh2 : Str -> Str ; -- should use drop instead but it gives linking error
addBh2 str1 =
case str1 of {
"my" + str =>
case str of {
"A" + st => Prelude.glue "by" str ; -- need to use '+' but it gives linking error
"A:" + st => Prelude.glue "byA" st ;
_ => Prelude.glue "b" str
};
_ => ""
};
-----------------------------
-- Noun Phrase
-----------------------------
{-toNP : Str -> Str = \pn, npc -> case npc of {
NPC c => pn ! c ;
NPObj => pn ! Dir ;
NPErg => pn ! Obl
} ;
-}
partNP : Str -> Str = \str -> (Prelude.glue str "h") ++ "Cdh" ;
-- partNP : Str -> Str = \str -> str + "h" ++ "Cdh" ;
------------------------------------------
-- Agreement transformations
-----------------------------------------
toAgr : Number -> PPerson -> AgrPes = \n,p ->
AgPes n p;
fromAgr : AgrPes -> {n : Number ; p : PPerson } = \agr -> case agr of {
AgPes n p => {n = n ; p = p }
} ;
conjAgrPes : AgrPes -> AgrPes -> AgrPes = \a0,b0 ->
let a = fromAgr a0 ; b = fromAgr b0
in
toAgr
(conjNumber a.n b.n)
b.p;
giveNumber : AgrPes -> Number =\a -> case a of {
AgPes n _ => n
};
-- defaultAgr : Agr = agrP3 Sg Inanimate ;
-- agrP3 : Number -> Animacy -> Agr = \n,a -> Ag n PPers3 a ;
defaultAgrPes : AgrPes = agrPesP3 Sg ;
agrPesP3 : Number -> AgrPes = \n -> AgPes n PPers3 ;
-- personalAgr : Agr = agrP1 Sg ;
agrPesP1 : Number -> AgrPes = \n -> AgPes n PPers1 ;
--------------------------------------------------------
-- Reflexive Pronouns
-----------------------------------
reflPron : AgrPes => Str = table {
AgPes Sg PPers1 => "Kvdm" ;
AgPes Sg PPers2 => "Kvdt" ;
AgPes Sg PPers3 => "KvdC" ;
AgPes Pl PPers1 => "KvdmAn" ;
AgPes Pl PPers2 => "KvdtAn" ;
AgPes Pl PPers3 => "KvdCAn"
} ;
getPron : Animacy -> Number -> Str = \ani,number ->
case <ani,number> of {
<Animate,Sg> => "Av" ;
<Animate,Pl> => ["A:n hA"] ;
<Inanimate,Sg> => "A:n" ;
<Inanimate,Pl> => ["A:n hA"]
};
}

103
lib/src/persian/src/SentencePes.gf Normal file
View File

@@ -0,0 +1,103 @@
concrete SentencePes of Sentence = CatPes ** open Prelude, ResPes,Predef in {
flags optimize=all_subs ;
coding = utf8;
lin
PredVP np vp = mkClause np vp ;
PredSCVP sc vp = mkSClause ("Ayn" ++ sc.s) (defaultAgrPes) vp ;
ImpVP vp = {
s = \\pol,n =>
let
agr = AgPes (numImp n) PPers2 ;
in case pol of {
CPos => vp.ad ++ vp.comp ! agr ++ vp.obj.s ++ vp.vComp ! agr ++ ((vp.s ! VPImp Pos (numImp n)).inf) ++ vp.embComp;
CNeg _ => vp.ad ++ vp.comp ! agr ++ vp.obj.s ++ vp.vComp ! agr ++ ((vp.s ! VPImp Neg (numImp n)).inf) ++ vp.embComp
} ;
} ;
SlashVP np vp =
mkClause np vp ** {c2 = vp.c2} ;
AdvSlash slash adv = {
s = \\t,p,o => adv.s ++ slash.s ! t ! p ! o ;
c2 = slash.c2
} ;
SlashPrep cl prep = cl ** {c2 = { s = prep.s ; ra = [] ; c = VIntrans}} ;
SlashVS np vs slash =
mkClause np
(insertObj2 (conjThat ++ slash.s) (predV vs)) **
{c2 = slash.c2} ;
EmbedS s = {s = conjThat ++ s.s} ;
EmbedQS qs = {s = qs.s ! QIndir} ;
EmbedVP vp = {s = vp.obj.s ++ vp.inf ++ vp.comp ! defaultAgrPes} ; --- agr
UseCl temp p cl =
{ s = case <temp.t,temp.a> of {
<Pres,Simul> => temp.s ++ p.s ++ cl.s ! VPres ! p.p ! ODir;
<Pres,Anter> => temp.s ++ p.s ++ cl.s ! VPerfPres ! p.p ! ODir;
<Past,Simul> => temp.s ++ p.s ++ cl.s ! VPast ! p.p ! ODir;
<Past,Anter> => temp.s ++ p.s ++ cl.s ! VPerfPast ! p.p ! ODir;
<Fut,Simul> => temp.s ++ p.s ++ cl.s ! VFut ! p.p ! ODir;
<Fut,Anter> => temp.s ++ p.s ++ cl.s ! VPerfFut ! p.p ! ODir;
<Cond,Simul> => temp.s ++ p.s ++ cl.s ! VCondSimul ! p.p ! ODir;
<Cond,Anter> => temp.s ++ p.s ++ cl.s ! VCondAnter ! p.p ! ODir -- this needs to be fixed by making SubjPerf in ResPnb
};
} ;
UseQCl temp p cl = {
s = \\q => case <temp.t,temp.a> of {
<Pres,Simul> => temp.s ++ p.s ++ cl.s ! VPres ! p.p ! q;
<Pres,Anter> => temp.s ++ p.s ++ cl.s ! VPerfPres ! p.p ! q;
<Past,Simul> => temp.s ++ p.s ++ cl.s ! VPast ! p.p ! q;
<Past,Anter> => temp.s ++ p.s ++ cl.s ! VPerfPast ! p.p ! q;
<Fut,Simul> => temp.s ++ p.s ++ cl.s ! VFut ! p.p ! q;
<Fut,Anter> => temp.s ++ p.s ++ cl.s ! VPerfFut ! p.p ! q;
<Cond,Simul> => temp.s ++ p.s ++ cl.s ! VCondSimul ! p.p ! q;
<Cond,Anter> => temp.s ++ p.s ++ cl.s ! VCondAnter ! p.p ! q
};
} ;
UseRCl temp p rcl = {
s = \\q => case <temp.t,temp.a> of {
<Pres,Simul> => temp.s ++ p.s ++ rcl.s ! VPres ! p.p ! ODir ! q;
<Pres,Anter> => temp.s ++ p.s ++ rcl.s ! VPerfPres ! p.p ! ODir ! q;
<Past,Simul> => temp.s ++ p.s ++ rcl.s ! VPast ! p.p ! ODir ! q;
<Past,Anter> => temp.s ++ p.s ++ rcl.s ! VPerfPast ! p.p ! ODir ! q;
<Fut,Simul> => temp.s ++ p.s ++ rcl.s ! VFut ! p.p ! ODir ! q;
<Fut,Anter> => temp.s ++ p.s ++ rcl.s ! VPerfFut ! p.p ! ODir ! q;
<Cond,Simul> => temp.s ++ p.s ++ rcl.s ! VCondSimul ! p.p ! ODir ! q;
<Cond,Anter> => temp.s ++ p.s ++ rcl.s ! VCondAnter ! p.p ! ODir ! q
};
c = rcl.c
} ;
UseSlash temp p clslash = {
s = case <temp.t,temp.a> of {
<Pres,Simul> => temp.s ++ p.s ++ clslash.s ! VPres ! p.p ! ODir;
<Pres,Anter> => temp.s ++ p.s ++ clslash.s ! VPerfPres ! p.p ! ODir;
<Past,Simul> => temp.s ++ p.s ++ clslash.s ! VPast ! p.p ! ODir ;
<Past,Anter> => temp.s ++ p.s ++ clslash.s ! VPerfPast ! p.p ! ODir;
<Fut,Simul> => temp.s ++ p.s ++ clslash.s ! VFut ! p.p ! ODir;
<Fut,Anter> => temp.s ++ p.s ++ clslash.s ! VPerfFut ! p.p ! ODir;
<Cond,Simul> => temp.s ++ p.s ++ clslash.s ! VCondSimul ! p.p ! ODir;
<Cond,Anter> => temp.s ++ p.s ++ clslash.s ! VCondSimul ! p.p ! ODir
};
c2 = clslash.c2
} ;
AdvS a s = {s = a.s ++ s.s} ;
RelS s r = {s = s.s ++ r.s ! agrPesP3 Sg} ;
SSubjS s sj s = { s = s.s ++ sj.s ++ s.s};
}

133
lib/src/persian/src/StructuralPes.gf Normal file
View File

@@ -0,0 +1,133 @@
concrete StructuralPes of Structural = CatPes **
open MorphoPes, ParadigmsPes, Prelude, NounPes in {
flags optimize=all ;
coding = utf8;
lin
above_Prep = ss "bAlAy" ;
after_Prep = ss ["bcd Az"] ;
all_Predet = ss ["hmh y"] ;
almost_AdA, almost_AdN = ss "tqrybAa." ;
although_Subj = ss ["bA vjvd Ayn"] ;
always_AdV = ss "hmyCh" ;
and_Conj = sd2 [] "v" ** {n = Pl} ;
because_Subj = ss ["brAy Ayn"] ;
before_Prep = ss ["qbl Az"] ;
behind_Prep = ss "pCt" ;
between_Prep = ss "byn" ;
both7and_DConj = sd2 "hm" ["v hm"] ** {n = Pl} ;
but_PConj = ss "AmA" ;
by8agent_Prep = ss "tvsT" ;
by8means_Prep = ss "bA" ;
-- can8know_VV,can_VV = mkV "skna" ** { isAux = True} ;
during_Prep = ss ["dr Tvl"] ;
either7or_DConj = sd2 "yA" "yA" ** {n = Sg} ;
-- everybody_NP = MassNP (UseN (MorphoPnb.mkN11 ["hr kwy"])); -- not a good way coz need to include NounPnb
every_Det = mkDet "hr" Sg ;
-- everything_NP = MassNP (UseN (MorphoPnb.mkN11 ["hr XE"]));
everywhere_Adv = ss ["hr jA"] ;
few_Det = mkDet ["tcdAd kmy"] Pl True; -- check
-- first_Ord = {s = "Avlyn" ; n = Sg} ; --DEPRECATED
for_Prep = ss "brAy" ;
from_Prep = ss "Az" ;
he_Pron = personalPN "Av" Sg PPers3 ;
here_Adv = ss "AynjA" ;
here7to_Adv = ss "AynjA" ;
here7from_Adv = ss "AynjA" ;
how_IAdv = ss "c^Tvr" ;
how8many_IDet = {s = "c^nd" ; n = Pl ; isNum = True} ;
how8much_IAdv = ss "c^qdr" ;
if_Subj = ss "Agr" ;
in8front_Prep = ss "jlvy" ;
i_Pron = personalPN "mn" Sg PPers1;
in_Prep = ss "dr" ;
it_Pron = personalPN "A:n" Sg PPers3;
less_CAdv = {s = "kmtr" ; p = ""} ;
many_Det = mkDet ["tcdAd zyAdy"] Pl True; -- check
more_CAdv = {s = "byCtr" ; p = "" } ;
most_Predet = ss "Akt-r";
much_Det = mkDet ["mqdAr zyAdy"] Pl ;
-- 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 "nh" ;
on_Prep = ss "rvy" ;
-- one_Quant = demoPN "yk" ; -- DEPRECATED
only_Predet = ss "fqT" ;
or_Conj = sd2 [] "yA" ** {n = Sg} ;
otherwise_PConj = ss ["drGyrAyn Svrt"] ;
part_Prep = ss "Az" ; -- the object following it should be in Ezafa form
please_Voc = ss "lTfAa." ;
possess_Prep = ss "" ; -- will be handeled in Ezafeh
quite_Adv = ss "kAmlAa." ;
she_Pron = personalPN "Av" Sg PPers3 ;
so_AdA = ss "bsyAr" ;
-- somebody_NP = MassNP (UseN (MorphoPnb.mkN11 "kwy" ));
someSg_Det = mkDet "mqdAry" Sg True ;
somePl_Det = mkDet "c^nd" Pl True ;
-- something_NP = MassNP (UseN (MorphoPnb.mkN11 "c^yzy"));
somewhere_Adv = ss "jAyy" ;
that_Quant = mkQuant "A:n" "A:n";
that_Subj = ss "A:n";
there_Adv = ss "A:njA" ;
there7to_Adv = ss "A:njA" ;
there7from_Adv = ss "A:njA" ;
therefore_PConj = ss ["bh hmyn dlyl"] ;
they_Pron = personalPN ["A:n hA"] Pl PPers3 ;
this_Quant = mkQuant "Ayn" "Ayn" ;
through_Prep = ss ["Az Tryq"] ;
too_AdA = ss "Kyly" ;
to_Prep = ss "bh" ** {lock_Prep = <>};
under_Prep = ss "zyr" ** {lock_Prep = <>};
very_AdA = ss "Kyly" ;
want_VV = mkV "KvAstn" "KvAh" ** { isAux = False} ;
we_Pron = personalPN "mA" Pl PPers1 ;
whatSg_IP = {s = ["c^h c^yzy"] ; n = Sg } ;
whatPl_IP = {s = ["c^h c^yzhAyy"] ; n = Pl } ;
when_IAdv = ss "ky" ;
when_Subj = ss "vqty" ;
where_IAdv = ss "kjA" ;
which_IQuant = {s = "kdAm" ; n = Sg} ;
whichPl_IDet = {s = "kdAm" ; n = Pl ; isNum = False} ;
whichSg_IDet = { s = "kdAm" ; n = Sg ; isNum = False} ;
whoSg_IP = {s = ["c^h ksy"] ; n = Sg} ;
whoPl_IP = {s = ["c^h ksAny"] ;n = Pl} ;
why_IAdv = ss "c^rA" ;
without_Prep = ss "bdvn" ;
with_Prep = ss "bA";
-- yes_Phr = ss "blh" ;
yes_Utt = ss "blh" ;
youSg_Pron = personalPN "tv" Sg PPers2 ;
youPl_Pron = personalPN "CmA" Pl PPers2 ;
youPol_Pron = personalPN "CmA" Sg PPers2 ;
-- no_Quant = demoPN "hyc^" ;
not_Predet = {s="nh"} ;
if_then_Conj = sd2 "Agr" "A:ngAh" ** {n = Sg} ;
at_least_AdN = ss "HdAql" ;
at_most_AdN = ss "HdAkt-r";
-- nothing_NP = MassNP (UseN (MorphoPnb.mkN11 "hyc^ c^yz" ));
except_Prep = ss ["bh jz"] ;
-- nobody_NP = MassNP (UseN (MorphoPnb.mkN11 "hyc^ ks"));
as_CAdv = {s = ["bh AndAzh y"] ; p = ""} ;
-- have_V2 = mkV2 (mkV "dACtn" "dAr") "rA" ;
language_title_Utt = ss "persian" ;
}