diff --git a/lib/src/maltese/AdjectiveMlt.gf b/lib/src/maltese/AdjectiveMlt.gf new file mode 100644 index 000000000..3f4a380ad --- /dev/null +++ b/lib/src/maltese/AdjectiveMlt.gf @@ -0,0 +1,11 @@ +-- AdjectiveMlt.gf: adjectives +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete AdjectiveMlt of Adjective = CatMlt ** open ResMlt, Prelude in { + +-- AP + +} diff --git a/lib/src/maltese/AdverbMlt.gf b/lib/src/maltese/AdverbMlt.gf new file mode 100644 index 000000000..62bd7fe4f --- /dev/null +++ b/lib/src/maltese/AdverbMlt.gf @@ -0,0 +1,12 @@ +-- AdverbMlt.gf: adverbial phrases +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete AdverbMlt of Adverb = CatMlt ** open ResMlt, Prelude in { + +-- AdN +-- Adv + +} diff --git a/lib/src/maltese/AllMlt.gf b/lib/src/maltese/AllMlt.gf new file mode 100644 index 000000000..dc0c27c0c --- /dev/null +++ b/lib/src/maltese/AllMlt.gf @@ -0,0 +1,19 @@ +-- AllMlt.gf: common grammar plus language-dependent extensions +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:prelude:../abstract:../common + +concrete AllMlt of AllMltAbs = + LangMlt, + IrregMlt, + ExtraMlt + ** {} ; + +{- + IrregMlt-[ + 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], +-} diff --git a/lib/src/maltese/AllMltAbs.gf b/lib/src/maltese/AllMltAbs.gf new file mode 100644 index 000000000..f1c8a6333 --- /dev/null +++ b/lib/src/maltese/AllMltAbs.gf @@ -0,0 +1,19 @@ +-- AllMlt.gf: common grammar plus language-dependent extensions +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:prelude:../abstract:../common + +abstract AllMltAbs = + Lang, + IrregMltAbs, + ExtraMltAbs + ** {} ; + +{- + IrregMltAbs-[ + 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], +-} diff --git a/lib/src/maltese/CatMlt.gf b/lib/src/maltese/CatMlt.gf new file mode 100644 index 000000000..43af27ea0 --- /dev/null +++ b/lib/src/maltese/CatMlt.gf @@ -0,0 +1,66 @@ +-- CatMlt.gf: the common type system +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--concrete CatMlt of Cat = CommonX ** open ResMlt, Prelude, ParamX in { +concrete CatMlt of Cat = CommonX ** open ResMlt, Prelude in { + + flags optimize=all_subs ; + + + lincat +-- S = {s : Str} ; +-- Cl = {s : ResMlt.Tense => Bool => Str} ; +-- NP = ResMlt.NP ; -- {s : Case => {clit,obj : Str ; isClit : Bool} ; a : Agr} ; +-- VP = ResMlt.VP ; -- {v : Verb ; clit : Str ; clitAgr : ClitAgr ; obj : Agr => Str} ; +-- AP = {s : Gender => Number => Str ; isPre : Bool} ; +-- CN = ResMlt.Noun ; -- {s : Number => Str ; g : Gender} ; +-- Det = {s : Gender => Case => Str ; n : Number} ; + N = ResMlt.Noun ; + N2 = ResMlt.Noun ; + N3 = ResMlt.Noun ; + A = ResMlt.Adj ; + V = ResMlt.Verb ; +-- V2 = ResMlt.Verb ** {c : Case} ; +-- AdA = {s : Str} ; +-- Pol = {s : Str ; b : Bool} ; +-- Tense = {s : Str ; t : ResMlt.Tense} ; +-- Conj = {s : Str ; n : Number} ; + + + -- Cardinal or ordinal in WORDS (not digits) + Numeral = { + s : CardOrd => Num_Case => Str ; + n : Num_Number + } ; + + -- Cardinal or ordinal in DIGITS (not words) + Digits = { + s : Str ; -- No need for CardOrd, i.e. no 1st, 2nd etc in Maltese + n : Num_Number ; + tail : DTail + }; + +{- +-- These below are just examples, I believe they came form Italian. + S = {s : Str} ; + Cl = {s : ResMlt.Tense => Bool => Str} ; + NP = {s : Case => {clit,obj : Str ; isClit : Bool} ; a : Agr} ; + VP = {v : Verb ; clit : Str ; clitAgr : ClitAgr ; obj : Agr => Str} ; + AP = {s : Gender => Number => Str ; isPre : Bool} ; + CN = {s : Number => Str ; g : Gender} ; + Det = {s : Gender => Case => Str ; n : Number} ; + N = {s : Number => Str ; g : Gender} ; + N2 = {s : Number => Str ; g : Gender} ; + A = {s : Number => Str ; isPre : Bool} ; + V = ResMlt.Verb ; + V2 = ResMlt.Verb ** {c : Case} ; + AdA = {s : Str} ; + Pol = {s : Str ; b : Bool} ; + Tense = {s : Str ; t : ResMlt.Tense} ; + Conj = {s : Str ; n : Number} ; +-} + +} diff --git a/lib/src/maltese/ConjunctionMlt.gf b/lib/src/maltese/ConjunctionMlt.gf new file mode 100644 index 000000000..a1f6e203a --- /dev/null +++ b/lib/src/maltese/ConjunctionMlt.gf @@ -0,0 +1,15 @@ +-- ConjunctionMlt.gf: co-ordination +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete ConjunctionMlt of Conjunction = CatMlt ** open ResMlt, Coordination, Prelude in { + +-- Adv +-- AP +-- NP +-- RS +-- S + +} diff --git a/lib/src/maltese/ExtraMlt.gf b/lib/src/maltese/ExtraMlt.gf new file mode 100644 index 000000000..b9f8b8c5b --- /dev/null +++ b/lib/src/maltese/ExtraMlt.gf @@ -0,0 +1,17 @@ +-- ExtraMlt.gf: extra stuff +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete ExtraMlt of ExtraMltAbs = CatMlt ** + open ResMlt, ParadigmsMlt in { + + flags coding=utf8 ; + + +-- lin +-- thigh_N = mkNounDual "koxxa" ; +-- sailor_N = mkNoun "baħri" ; + +} diff --git a/lib/src/maltese/ExtraMltAbs.gf b/lib/src/maltese/ExtraMltAbs.gf new file mode 100644 index 000000000..815d23def --- /dev/null +++ b/lib/src/maltese/ExtraMltAbs.gf @@ -0,0 +1,13 @@ +-- ExtraMltAbs.gf: abstract grammar for extra stuff +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +abstract ExtraMltAbs = Cat ** { + +-- fun +-- thigh_N : N ; +-- sailor_N : N ; + +} diff --git a/lib/src/maltese/GrammarMlt.gf b/lib/src/maltese/GrammarMlt.gf new file mode 100644 index 000000000..9fc9de7d4 --- /dev/null +++ b/lib/src/maltese/GrammarMlt.gf @@ -0,0 +1,27 @@ +-- GrammarMlt.gf: common syntax +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:../abstract:../common:../prelude + +concrete GrammarMlt of Grammar = + NounMlt, + VerbMlt, + AdjectiveMlt, + AdverbMlt, + NumeralMlt, + SentenceMlt, + QuestionMlt, + RelativeMlt, + ConjunctionMlt, + PhraseMlt, + TextX - [Utt], + StructuralMlt, + IdiomMlt + ** { + + flags coding=utf8 ; + +} diff --git a/lib/src/maltese/IdiomMlt.gf b/lib/src/maltese/IdiomMlt.gf new file mode 100644 index 000000000..71913ed21 --- /dev/null +++ b/lib/src/maltese/IdiomMlt.gf @@ -0,0 +1,14 @@ +-- IdiomMlt.gf: idiomatic expressions +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete IdiomMlt of Idiom = CatMlt ** open Prelude, ResMlt in { + +-- Cl +-- QCl +-- VP +-- Utt + +} diff --git a/lib/src/maltese/IrregMlt.gf b/lib/src/maltese/IrregMlt.gf new file mode 100644 index 000000000..cfd40ee4c --- /dev/null +++ b/lib/src/maltese/IrregMlt.gf @@ -0,0 +1,13 @@ +-- IrregMlt.gf: irregularly inflected words (mostly verbs) +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:prelude:../abstract:../common + +concrete IrregMlt of IrregMltAbs = CatMlt ** open ParadigmsMlt in { + + + +} diff --git a/lib/src/maltese/IrregMltAbs.gf b/lib/src/maltese/IrregMltAbs.gf new file mode 100644 index 000000000..015963a61 --- /dev/null +++ b/lib/src/maltese/IrregMltAbs.gf @@ -0,0 +1,19 @@ +-- IrregMltAbs.gf: abstract grammar for irregularly inflected words (mostly verbs) +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:prelude:../abstract:../common + +abstract IrregMltAbs = Cat ** { + +{- +fun + + awake_V : V ; + bear_V : V ; + beat_V : V ; +-} + +} diff --git a/lib/src/maltese/LangMlt.gf b/lib/src/maltese/LangMlt.gf new file mode 100644 index 000000000..199c8c5e9 --- /dev/null +++ b/lib/src/maltese/LangMlt.gf @@ -0,0 +1,16 @@ +-- LangMlt.gf: common syntax and lexicon +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:../abstract:../common:../prelude + +concrete LangMlt of Lang = + GrammarMlt, + LexiconMlt + ** { + + flags startcat = Phr ; unlexer = text ; lexer = text ; coding = utf8 ; + +} diff --git a/lib/src/maltese/LexiconMlt.gf b/lib/src/maltese/LexiconMlt.gf new file mode 100644 index 000000000..e9a3b5d80 --- /dev/null +++ b/lib/src/maltese/LexiconMlt.gf @@ -0,0 +1,396 @@ +-- LexiconMlt.gf: test lexicon of 300 content words +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:../abstract:../common:../prelude + +concrete LexiconMlt of Lexicon = CatMlt ** + --open ParadigmsMlt, ResMlt, Prelude in { + open ParadigmsMlt, IrregMlt, ResMlt in { + + flags optimize=values ; coding=utf8 ; + + lin + + {- ===== My Verbs ===== -} + + {- + cut_V2 = mkVerb "qata'" "aqta'" "aqtgħu" ; + write_V2 = mkVerb "kiteb" ; + break_V2 = mkVerb "kiser" ; + find_V2 = mkVerb "sab" ; + throw_V2 = mkVerb "tefa'" ; + hear_V2 = mkVerb "sama'" "isma'" "isimgħu" ; + fear_V2 = mkVerb "beża'" ; + pray_V = mkVerb "talab" "itlob" "itolbu" ; + understand_V2 = mkVerb "fehem" ; + pull_V2 = mkVerb "ġibed" ; + walk_V = mkVerb "mexa'" ; + -} + -- die_V = mkVerb "miet" ; + die_V = mkVerb "qarmeċ" ; + + + {- ===== My Nouns ===== -} + + --airplane_N = mkNoun "ajruplan" Masc ; + airplane_N = mkNoun "ajruplan" ; + --apple_N = mkNoun "tuffieħa" Fem ; + apple_N = mkNounColl "tuffieħ" ; + + bench_N = mkNoun "bank" "bankijiet" ; + + + + {- ===== Required by RGL ===== -} + + +-- add_V3 +-- alas_Interj +-- already_Adv + animal_N = mkNoun "annimal" ; +-- answer_V2S + apartment_N = mkNoun "appartament" ; + art_N = mkNounNoPlural "arti" Fem ; +-- ashes_N = mkNoun "rmied" ; +-- ask_V2Q + baby_N = mkNoun "tarbija" "trabi" ; + back_N = mkNoun "dahar" "dhur" ; +-- bad_A + bank_N = mkNoun "bank" "bankijiet" ; -- BANEK is for lotto booths! + bark_N = mkNoun "qoxra" "qoxriet" ; +-- beautiful_A +-- become_VA + beer_N = mkNoun "birra" "birer" ; +-- beg_V2V + belly_N = mkNoun "żaqq" "żquq" ; +-- big_A + bike_N = mkNoun "rota" ; + bird_N = mkNoun "għasfur" "għasafar" ; -- what about GĦASFURA? +-- bite_V2 +-- black_A + blood_N = mkNoun [] "demm" [] "dmija" [] ; +-- blow_V +-- blue_A + boat_N = mkNoun "dgħajsa" "dgħajjes" ; + bone_N = mkNounColl "għadam" ; + book_N = mkNoun "ktieb" "kotba" ; + boot_N = mkNoun "żarbun" "żraben" ; -- what about ŻARBUNA? + boss_N = mkNoun "mgħallem" "mgħallmin" ; + boy_N = mkNoun "tifel" "tfal" ; + bread_N = mkNounColl "ħobż" ; +-- break_V2 + breast_N = mkNoun "sider" "sdur" ; -- also ISDRA +-- breathe_V +-- broad_A + brother_N2 = mkNoun "ħu" "aħwa" ; +-- brown_A +-- burn_V + butter_N = mkNoun [] "butir" [] "butirijiet" [] ; +-- buy_V2 + camera_N = mkNoun "kamera" "kameras" ; + cap_N = mkNoun "beritta" ; + car_N = mkNoun "karozza" ; + carpet_N = mkNoun "tapit" ; -- TAPITI or TWAPET ? + cat_N = mkNoun "qattus" "qtates" ; -- what about QATTUSA ? + ceiling_N = mkNoun "saqaf" "soqfa"; + chair_N = mkNoun "siġġu" "siġġijiet" ; + cheese_N = mkNounColl "ġobon" ; +-- child_N = mkNoun "tfajjel" ; -- Not an easy one... + church_N = mkNoun "knisja" "knejjes" ; + city_N = mkNoun "belt" "bliet" Fem ; +-- clean_A +-- clever_A +-- close_V2 + cloud_N = mkNounColl "sħab" ; + coat_N = mkNoun "kowt" "kowtijiet" ; +-- cold_A +-- come_V + computer_N = mkNoun "kompjuter" "kompjuters" ; +-- correct_A +-- count_V2 + country_N = mkNoun "pajjiż" ; + cousin_N = mkNoun "kuġin" ; + cow_N = mkNoun "baqra" "baqar" "baqartejn" [] [] ; +-- cut_V2 + day_N = mkNoun "ġurnata" "ġranet" ; +-- dig_V +-- dirty_A + distance_N3 = mkNoun "distanza" ; +-- do_V2 + doctor_N = mkNoun "tabib" "tobba" ; -- what about TABIBA ? + dog_N = mkNoun "kelb" "klieb" ; + door_N = mkNoun "bieb" "bibien" ; -- what about BIEBA ? +-- drink_V2 +-- dry_A +-- dull_A + dust_N = mkNounColl "trab" ; -- not sure but sounds right + ear_N = mkNounDual "widna" ; + earth_N = mkNoun "art" "artijiet" Fem ; +-- easy_A2V +-- eat_V2 + egg_N = mkNounColl "bajd" ; +-- empty_A + enemy_N = mkNoun "għadu" "għedewwa" ; + eye_N = mkNounWorst "għajn" [] "għajnejn" "għajnejn" "għejun" Fem ; + factory_N = mkNoun "fabbrika" ; +-- fall_V +-- far_Adv + fat_N = mkNounColl "xaħam" ; + father_N2 = mkNoun "missier" "missierijiet" ; +-- fear_V2 +-- fear_VS + feather_N = mkNounColl "rix" ; +-- fight_V2 +-- find_V2 + fingernail_N = mkNoun "difer" [] "difrejn" "dwiefer" [] ; + fire_N = mkNoun "nar" "nirien" ; + fish_N = mkNounColl "ħut" ; +-- float_V + earth_N = mkNoun "art" "artijiet" Fem ; +-- flow_V + flower_N = mkNoun "fjura" ; +-- fly_V + fog_N = mkNoun [] "ċpar" [] [] [] ; + foot_N = mkNounWorst "sieq" [] "saqajn" "saqajn" [] Fem ; + forest_N = mkNoun "foresta" ; -- also MASĠAR +-- forget_V2 +-- freeze_V + fridge_N = mkNoun "friġġ" "friġġijiet" ; + friend_N = mkNoun "ħabib" "ħbieb" ; + fruit_N = mkNounColl "frott" ; +-- full_A +-- fun_AV + garden_N = mkNoun "ġnien" "ġonna" ; + girl_N = mkNoun "tifla" "tfal" ; +-- give_V3 + glove_N = mkNoun "ingwanta" ; +-- go_V + gold_N = mkNoun [] "deheb" [] "dehbijiet" [] ; +-- good_A + grammar_N = mkNoun "grammatika" ; + grass_N = mkNounWorst "ħaxixa" "ħaxix" [] [] "ħxejjex" Masc ; -- Dict says ĦAXIX = n.koll.m.s., f. -a, pl.ind. ĦXEJJEX +-- green_A + guts_N = mkNoun "musrana" [] [] "musraniet" "msaren" ; + hair_N = mkNoun "xagħar" [] [] "xagħariet" "xgħur" ; + hand_N = mkNounWorst "id" [] "idejn" "idejn" [] Fem ; + harbour_N = mkNoun "port" "portijiet" ; + hat_N = mkNoun "kappell" "kpiepel" ; +-- hate_V2 + head_N = mkNoun "ras" "rjus" Fem ; +-- hear_V2 + heart_N = mkNoun "qalb" "qlub" Fem ; +-- heavy_A + hill_N = mkNoun "għolja" "għoljiet" ; +-- hit_V2 +-- hold_V2 +-- hope_VS + horn_N = mkNoun "ħorn" "ħornijiet" ; + horse_N = mkNoun "żiemel" "żwiemel" ; +-- hot_A + house_N = mkNoun "dar" "djar" Fem ; +-- hunt_V2 + husband_N = mkNoun "raġel" "rġiel" ; + ice_N = mkNoun "silġ" "silġiet" ; +-- important_A + industry_N = mkNoun "industrija" ; + iron_N = mkNounWorst "ħadida" "ħadid" [] "ħadidiet" "ħdejjed" Masc ; +-- john_PN +-- jump_V +-- kill_V2 + king_N = mkNoun "re" "rejjiet" ; + knee_N = mkNoun "rkoppa" [] "rkopptejn" "rkoppiet" [] ; -- TODO use mkNounDual +-- know_V2 +-- know_VQ +-- know_VS + lake_N = mkNoun "għadira" "għadajjar" ; + lamp_N = mkNoun "lampa" ; + language_N = mkNoun "lingwa" ; -- lsien? +-- laugh_V + leaf_N = mkNoun "werqa" "weraq" "werqtejn" "werqiet" [] ; +-- learn_V2 + leather_N = mkNoun "ġilda" "ġild" [] "ġildiet" "ġlud" ; -- mkNounColl "ġild" ; +-- leave_V2 +-- left_Ord + leg_N = mkNoun "riġel" [] "riġlejn" [] [] ; -- sieq? +-- lie_V +-- like_V2 +-- listen_V2 +-- live_V + liver_N = mkNoun "fwied" [] [] [] "ifdwa" ; +-- long_A +-- lose_V2 + louse_N = mkNoun "qamla" "qamliet" ; + love_N = mkNoun "mħabba" "mħabbiet" ; -- hmmm +-- love_V2 + man_N = mkNoun "raġel" "rġiel" ; +-- married_A2 + meat_N = mkNoun "laħam" [] [] "laħmiet" "laħmijiet" ; + milk_N = mkNoun [] "ħalib" [] "ħalibijiet" "ħlejjeb" ; + moon_N = mkNoun "qamar" "oqmra" ; -- qmura? + mother_N2 = mkNoun "omm" "ommijiet" Fem ; + mountain_N = mkNoun "muntanja" ; + mouth_N = mkNoun "ħalq" "ħluq" ; + music_N = mkNoun "musika" ; -- plural? + name_N = mkNoun "isem" "ismijiet" ; +-- narrow_A +-- near_A + neck_N = mkNoun "għonq" "għenuq" ; +-- new_A + newspaper_N = mkNoun "gazzetta" ; + night_N = mkNoun "lejl" "ljieli" ; + nose_N = mkNoun "mnieħer" "mniħrijiet" ; +-- now_Adv + number_N = mkNoun "numru" ; + oil_N = mkNoun "żejt" "żjut" ; +-- old_A +-- open_V2 +-- paint_V2A + paper_N = mkNoun "karta" ; +-- paris_PN + peace_N = mkNoun "paċi" "paċijiet" Fem ; + pen_N = mkNoun "pinna" "pinen" ; + person_N = mkNounWorst [] "persuna" [] "persuni" [] Masc ; + planet_N = mkNoun "pjaneta" ; + plastic_N = mkNounNoPlural "plastik" ; +-- play_V +-- play_V2 + policeman_N = mkNounNoPlural "pulizija" ; + priest_N = mkNoun "qassis" "qassisin" ; +-- probable_AS +-- pull_V2 +-- push_V2 +-- put_V2 + queen_N = mkNoun "reġina" "rġejjen" ; + question_N = mkNoun "mistoqsija" "mistoqsijiet" ; -- domanda? + radio_N = mkNoun "radju" "radjijiet" ; + rain_N = mkNounNoPlural "xita" ; +-- rain_V0 +-- read_V2 +-- ready_A + reason_N = mkNoun "raġun" "raġunijiet" ; +-- red_A + religion_N = mkNoun "reliġjon" "reliġjonijiet" ; + restaurant_N = mkNoun "restorant" ; +-- right_Ord + river_N = mkNoun "xmara" "xmajjar" ; + road_N = mkNounWorst "triq" [] [] "triqat" "toroq" Fem ; + rock_N = mkNoun "blata" "blat" [] "blatiet" "blajjiet" ; -- in dictionary BLAT and BLATA are separate! + roof_N = mkNoun "saqaf" "soqfa" ; + root_N = mkNoun "qħerq" "qħeruq" ; + rope_N = mkNoun "ħabel" "ħbula" ; +-- rotten_A +-- round_A +-- rub_V2 + rubber_N = mkNoun "gomma" "gomom" ; + rule_N = mkNoun "regola" ; +-- run_V + salt_N = mkNoun "melħ" "melħiet" ; + sand_N = mkNoun "ramla" "ramel" [] "ramliet" "rmiel" ; +-- say_VS + school_N = mkNoun "skola" "skejjel" ; + science_N = mkNoun "xjenza" ; +-- scratch_V2 + sea_N = mkNoun "baħar" [] "baħrejn" "ibħra" [] ; +-- see_V2 + seed_N = mkNoun "żerriegħa" "żerrigħat" ; +-- seek_V2 +-- sell_V3 +-- send_V3 +-- sew_V +-- sharp_A + sheep_N = mkNoun "nagħġa" "nagħaġ" [] "nagħġiet" [] ; + ship_N = mkNoun "vapur" ; + shirt_N = mkNoun "qmis" "qomos" Fem ; + shoe_N = mkNoun "żarbun" "żraben" ; + shop_N = mkNoun "ħanut" "ħwienet" ; +-- short_A + silver_N = mkNoun "fidda" "fided" ; +-- sing_V + sister_N = mkNoun "oħt" "aħwa" Fem ; +-- sit_V + skin_N = mkNoun "ġilda" "ġildiet" ; + sky_N = mkNoun "sema" "smewwiet" Masc ; +-- sleep_V +-- small_A +-- smell_V + smoke_N = mkNoun "duħħan" "dħaħen" ; +-- smooth_A + snake_N = mkNoun "serp" "sriep" ; + snow_N = mkNoun [] "borra" [] [] [] ; + sock_N = mkNoun "kalzetta" ; + song_N = mkNoun "kanzunetta" ; +-- speak_V2 +-- spit_V +-- split_V2 +-- squeeze_V2 +-- stab_V2 +-- stand_V + star_N = mkNoun "stilla" "stilel" ; + steel_N = mkNounNoPlural "azzar" ; + stick_N = mkNoun "lasta" ; + stone_N = mkNoun "ġebla" "ġebel" [] "ġebliet" "ġbiel" ; +-- stop_V + stove_N = mkNoun "kuker" "kukers" ; -- fuklar? +-- straight_A + student_N = mkNoun "student" ; +-- stupid_A +-- suck_V2 + sun_N = mkNoun "xemx" "xmux" Fem ; +-- swell_V +-- swim_V +-- switch8off_V2 +-- switch8on_V2 + table_N = mkNoun "mejda" "mwejjed" ; + tail_N = mkNoun "denb" "dnieb" ; +-- talk_V3 +-- teach_V2 + teacher_N = mkNoun "għalliem" "għalliema" ; -- għalliema ? + television_N = mkNoun "televixin" "televixins" ; +-- thick_A +-- thin_A +-- think_V +-- throw_V2 +-- tie_V2 +-- today_Adv + tongue_N = mkNoun "lsien" "ilsna" ; + tooth_N = mkNoun "sinna" [] [] "sinniet" "snien" ; -- darsa? + train_N = mkNoun "ferrovija" ; +-- travel_V + tree_N = mkNoun "siġra" "siġar" [] "siġriet" [] ; +-- turn_V +-- ugly_A +-- uncertain_A +-- understand_V2 + university_N = mkNoun "università" "universitàjiet" ; + village_N = mkNoun "raħal" "rħula" ; -- villaġġ ? +-- vomit_V +-- wait_V2 +-- walk_V + war_N = mkNoun "gwerra" "gwerrer" ; +-- warm_A +-- wash_V2 +-- watch_V2 + water_N = mkNoun "ilma" "ilmijiet" Masc ; +-- wet_A +-- white_A +-- wide_A + wife_N = mkNoun "mara" "nisa" ; +-- win_V2 + wind_N = mkNoun "riħ" [] [] "rjieħ" "rjiħat" ; + window_N = mkNoun "tieqa" "twieqi" ; + wine_N = mkNoun [] "nbid" [] [] "nbejjed" ; + wing_N = mkNoun "ġewnaħ" "ġwienaħ" ; +-- wipe_V2 + woman_N = mkNoun "mara" "nisa" ; +-- wonder_VQ + wood_N = mkNoun "injam" "injamiet" ; + worm_N = mkNoun "dudu" "dud" [] "dudiet" "dwied" ; -- duda +-- write_V2 + year_N = mkNoun "sena" [] "sentejn" "snin" [] ; +-- yellow_A +-- young_A + +} ; diff --git a/lib/src/maltese/MorphoMlt.gf b/lib/src/maltese/MorphoMlt.gf new file mode 100644 index 000000000..c76a3120c --- /dev/null +++ b/lib/src/maltese/MorphoMlt.gf @@ -0,0 +1,10 @@ +-- MorphoMlt.gf: morphology +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +resource MorphoMlt = ResMlt ** open Prelude in { + flags optimize=all ; coding=utf8 ; + +} diff --git a/lib/src/maltese/NounMlt.gf b/lib/src/maltese/NounMlt.gf new file mode 100644 index 000000000..9ce40890a --- /dev/null +++ b/lib/src/maltese/NounMlt.gf @@ -0,0 +1,17 @@ +-- NounMlt.gf: noun phrases and nouns +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete NounMlt of Noun = CatMlt ** open ResMlt, Prelude in { + flags optimize=noexpand ; + +-- Card +-- CN +-- Det +-- NP +-- Num +-- Ord + +} diff --git a/lib/src/maltese/NumeralMlt.gf b/lib/src/maltese/NumeralMlt.gf new file mode 100644 index 000000000..c65947e09 --- /dev/null +++ b/lib/src/maltese/NumeralMlt.gf @@ -0,0 +1,495 @@ +-- NumeralMlt.gf: cardinals and ordinals +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete NumeralMlt of Numeral = CatMlt [Numeral,Digits] ** open Prelude,ResMlt in { + + flags coding=utf8 ; + +-- Numeral, Digit +-- Dig, Digits + +{- + -- This code taken from examples/numerals/maltese.sty in GF darcs repository, July 2011. + -- Original author unknown + + -- ABSTRACT definitions copied from lib/src/abstract/Numeral.gf + + -- Numerals from 1 to 999999 in decimal notation + cat + Numeral ; -- 0.. + Digit ; -- 2..9 + Sub10 ; -- 1..9 + Sub100 ; -- 1..99 + Sub1000 ; -- 1..999 + Sub1000000 ; -- 1..999999 + + data + num : Sub1000000 -> Numeral ; + + n2, n3, n4, n5, n6, n7, n8, n9 : Digit ; + + pot01 : Sub10 ; -- 1 + pot0 : Digit -> Sub10 ; -- d * 1 + pot110 : Sub100 ; -- 10 + pot111 : Sub100 ; -- 11 + pot1to19 : Digit -> Sub100 ; -- 10 + d + pot0as1 : Sub10 -> Sub100 ; -- coercion of 1..9 + pot1 : Digit -> Sub100 ; -- d * 10 + pot1plus : Digit -> Sub10 -> Sub100 ; -- d * 10 + n + pot1as2 : Sub100 -> Sub1000 ; -- coercion of 1..99 + pot2 : Sub10 -> Sub1000 ; -- m * 100 + pot2plus : Sub10 -> Sub100 -> Sub1000 ; -- m * 100 + n + pot2as3 : Sub1000 -> Sub1000000 ; -- coercion of 1..999 + pot3 : Sub1000 -> Sub1000000 ; -- m * 1000 + pot3plus : Sub1000 -> Sub1000 -> Sub1000000 ; -- m * 1000 + n +-} + oper + Form1 = { + s : DForm => CardOrd => Num_Case => Str ; + --thou : CardOrd => Str ; + thou : { s : Str ; treatAs : DForm } ; + n : Num_Number ; + } ; + Form2 = { + s : CardOrd => Num_Case => Str ; + --thou : CardOrd => Str ; + thou : { s : Str ; treatAs : DForm } ; + n : Num_Number ; + f : DForm ; + } ; + + + lincat + Digit = Form1 ; + Sub10 = Form1 ; + Sub100 = Form2 ; + Sub1000 = Form2 ; + Sub1000000 = Form2 ; + + oper + + -- Make a "number" (in this case a Form1) + -- Should be moved to ResMlt ? + -- Params: + -- unit, eg TNEJN + -- ordinal unit (without article), eg TIENI + -- adjectival, eg ŻEWĠ + -- teen, eg TNAX + -- ten, eg GĦOXRIN + -- number, eg NumDual + --mkNum : Str -> Str -> Str -> Str -> Str -> Str -> Str -> Num_Number -> Form1 = \unit,ordunit,adjectival,teen,ten,hundred,thousand,num -> { + mkNum : Str -> Str -> Str -> Str -> Str -> Num_Number -> Form1 = \unit,ordunit,adjectival,teen,ten,num -> + let + hundred = case num of { + NumSg => "mija" ; + NumDual => "mitejn" ; + _ => adjectival + } ; + thousand = case num of { + NumSg => "wieħed" ; + NumDual => "elfejn" ; + _ => case adjectival of { + _ + "'" => (init adjectival) + "t" ; -- eg SEBA' -> SEBAT + _ + "t" => adjectival ; -- eg SITT -> SITT + _ => adjectival + "t" -- eg ĦAMES -> ĦAMEST + } + } + in { + s = table { + Unit => table { + NCard => table { + NumNominative => unit ; -- eg TNEJN + NumAdjectival => adjectival -- eg ŻEWĠ + } ; + NOrd => \\numcase => definiteArticle ++ ordunit -- eg IT-TIENI + } ; + Teen => table { + NCard => table { + NumNominative => teen ; -- eg TNAX + NumAdjectival => teen + "-il" -- eg TNAX-IL + } ; + NOrd => table { + NumNominative => definiteArticle ++ teen ; -- eg IT-TNAX + NumAdjectival => definiteArticle ++ (teen + "-il") -- eg IT-TNAX-IL + } + } ; + Ten => table { + NCard => \\numcase => ten ; -- eg TLETIN + NOrd => \\numcase => definiteArticle ++ ten -- eg IT-TLETIN + } ; + Hund => table { + NCard => case num of { + NumSg => table { + NumNominative => "mija" ; -- ie MIJA + NumAdjectival => "mitt" -- ie MITT suldat + } ; + NumDual => \\numcase => hundred ; -- ie MITEJN + _ => table { + NumNominative => hundred ++ "mija" ; -- eg MIJA, SEBA' MIJA + NumAdjectival => hundred ++ "mitt" -- eg MITT, SEBA' MITT suldat + } + } ; + NOrd => case num of { + NumSg => table { + NumNominative => definiteArticle ++ "mija" ; -- ie IL-MIJA + NumAdjectival => definiteArticle ++ "mitt" -- ie IL-MITT suldat + } ; + NumDual => \\numcase => definiteArticle ++ hundred ; -- ie IL-MITEJN, IL-MITEJN suldat + _ => table { + NumNominative => definiteArticle ++ hundred ++ "mija" ; -- eg IS-SEBA' MIJA + NumAdjectival => definiteArticle ++ hundred ++ "mitt" -- eg IS-SEBA' MITT suldat + } + } + } + } ; +-- thou = thousand ; + thou = { s = thousand ; treatAs = Unit } ; + n = num ; + } ; + + lin + -- Unit Ord.Unit Adjectival Teen Ten Number + n2 = mkNum "tnejn" "tieni" "żewġ" "tnax" "għoxrin" NumDual ; + n3 = mkNum "tlieta" "tielet" "tlett" "tlettax" "tletin" NumPl ; -- TODO tlett / tliet ? + n4 = mkNum "erbgħa" "raba'" "erba'" "erbatax" "erbgħin" NumPl ; + n5 = mkNum "ħamsa" "ħames" "ħames" "ħmistax" "ħamsin" NumPl ; + n6 = mkNum "sitta" "sitt" "sitt" "sittax" "sittin" NumPl ; + n7 = mkNum "sebgħa" "seba'" "seba'" "sbatax" "sebgħin" NumPl ; + n8 = mkNum "tmienja" "tmin" "tmin" "tmintax" "tmenin" NumPl ; + n9 = mkNum "disgħa" "disa'" "disa'" "dsatax" "disgħin" NumPl ; + + oper + -- Helper functions for below + mkForm2 : Form2 = overload { + + -- Infer adjectival, thousands + mkForm2 : Str -> Str -> DForm -> Form2 = \card,ord,form -> { + s = table { + NCard => \\numcase => card ; + NOrd => \\numcase => ord + } ; + --thou = card ; + thou = { s = card ; treatAs = form } ; + n = NumPl ; + f = form ; + } ; + + -- Explicit everything + mkForm2 : Str -> Str -> Str -> Str -> DForm -> Form2 = \card,ord,adj,thousand,form -> { + s = table { + NCard => table { + NumNominative => card ; + NumAdjectival => adj + } ; + --NOrd => \\numcase => addDefiniteArticle ord + NOrd => table { + NumNominative => definiteArticle ++ ord ; + NumAdjectival => definiteArticle ++ adj + } + } ; + --thou = thousand ; + thou = { s = thousand ; treatAs = form } ; + n = NumPl ; + f = form ; + } ; + + -- Given an existing table + mkForm2 : (CardOrd => Num_Case => Str) -> DForm -> Form2 = \tab,form -> { + s = tab ; + thou = { + s = case form of { + Teen => tab ! NCard ! NumAdjectival ; + _ => tab ! NCard ! NumNominative + } ; + treatAs = form ; + } ; + n = NumPl ; + f = form ; + } ; + + }; -- end of mkForm2 overload + + lin + + -- Sub1000000 -> Numeral + num x = x ; + + -- Sub10 ; 1 + -- Unit Ord.Unit Adjectival Teen Ten Number + pot01 = mkNum "wieħed" "ewwel" "wieħed" [] [] NumSg ; + + -- Digit -> Sub10 ; d * 1 + pot0 d = d ** {n = case d.n of { NumDual => NumDual ; _ => NumPl } } ; + + -- Sub100 ; 10, 11 + -- Cardinal Ordinal Adjectival Thousand Form + pot110 = mkForm2 "għaxra" "għaxar" "għaxar" "għaxart" Unit ; + pot111 = mkForm2 "ħdax" "ħdax" "ħdax-il" "ħdax-il" Teen ; +{- + pot110 = { + s = table { + NCard => table { + NumNominative => "għaxra" ; + NumAdjectival => "għaxar" + } ; + NOrd => \\numcase => addDefiniteArticle "għaxar" + } ; + thou = table { + NCard => "għaxart" ; + NOrd => addDefiniteArticle "għaxart" + } ; + n = NumPl ; + f = Ten ; + } ; +-} + + -- Digit -> Sub100 ; 10 + d + pot1to19 d = + mkForm2 + (d.s ! Teen) + Teen + ; + + -- Sub10 -> Sub100 ; coercion of 1..9 + pot0as1 d = { + s = d.s ! Unit ; + thou = d.thou ; + n = d.n ; + f = Unit ; + } ; + + -- Digit -> Sub100 ; d * 10 + pot1 d = + mkForm2 + (d.s ! Ten) + Ten + ; + + -- Digit -> Sub10 -> Sub100 ; d * 10 + n + pot1plus d n = + let unit = (n.s ! Unit ! NCard ! NumNominative) in + mkForm2 + (unit ++ "u" ++ (d.s ! Ten ! NCard ! NumNominative)) + (definiteArticle ++ unit ++ "u" ++ (d.s ! Ten ! NCard ! NumNominative)) + Ten + ; + + -- Sub100 -> Sub1000 ; coercion of 1..99 + pot1as2 m = m ; + + -- Sub10 -> Sub1000 ; m * 100 + pot2 m = { + s = m.s ! Hund ; + thou = { + s = case m.n of { + NumSg => "mitt" ; -- Special case for "mitt elf" + NumDual => "mitejn" ; -- Special case for "mitejn elf" + _ => m.thou.s + } ; + treatAs = Hund ; + } ; + n = NumPl ; + f = Hund ; + } ; + + -- Sub10 -> Sub100 -> Sub1000 ; m * 100 + n + pot2plus m n = + let + hund : Str = m.s ! Hund ! NCard ! NumNominative + in { + s = table { + NCard => table { + NumNominative => hund ++ "u" ++ n.s ! NCard ! NumNominative ; + NumAdjectival => hund ++ "u" ++ n.s ! NCard ! NumAdjectival + } ; + NOrd => table { + NumNominative => definiteArticle ++ hund ++ "u" ++ n.s ! NCard ! NumNominative ; + NumAdjectival => definiteArticle ++ hund ++ "u" ++ n.s ! NCard ! NumAdjectival + } + } ; + thou = { + s = hund ++ "u" ++ n.thou.s ; + treatAs = case n.n of { + NumSg => Ten ; -- specific case for mija u wiehed elf + _ => n.f -- eg So that "106,000" is treated as "6,000" + } ; + } ; + n = NumPl ; + f = Hund ; + } ; + + -- Sub1000 -> Sub1000000 ; coercion of 1..999 + pot2as3 m = m ; + + -- Sub1000 -> Sub1000000 ; m * 1000 + pot3 m = { + s = + case m.n of { + NumSg => numTable "elf" ; -- 1 * 1000 + NumDual => numTable "elfejn" ; -- 2 * 2000 + NumPl => case m.thou.treatAs of { + Unit => numTable m.thou.s "elef" ; -- 3-10 * 1000 + _ => numTable m.thou.s "elf" -- 11+ * 1000 + } + } ; +{- + case m.f of { + Unit => numTable m.thou "elef" ; -- + _ => case m.n of { + NumSg => numTable "elf" ; -- + NumDual => numTable "elfejn" ; -- + NumPl => numTable m.thou "elf" -- + } + } ; +-} + thou = { + s = m.thou.s ; + treatAs = m.f ; + } ; + n = NumPl ; + f = Hund ; -- NOT IMPORTANT + } ; + + -- Sub1000 -> Sub1000 -> Sub1000000 ; m * 1000 + n + pot3plus m n = { + s = + let + ukemm = table { + NumNominative => "u" ++ (n.s ! NCard ! NumNominative) ; + NumAdjectival => "u" ++ (n.s ! NCard ! NumAdjectival) + } + in + case m.n of { +{- + NumSg => elf2 "elf" ukemm ; + NumDual => elf2 "elfejn" ukemm ; + NumPl => case m.f of { + Unit => elf2 m.thou ("elef" ++ ukemm) ; + _ => elf2 m.thou ("elf" ++ ukemm) + } +-} + NumSg => numTable "elf" ukemm ; + NumDual => numTable "elfejn" ukemm ; + NumPl => case m.thou.treatAs of { + Unit => numTable (m.thou.s ++ "elef") ukemm ; + _ => numTable (m.thou.s ++ "elf") ukemm + } + } ; + thou = { + s = m.thou.s ; + treatAs = m.f ; + } ; + n = NumPl ; + f = Hund ; -- NOT IMPORTANT + } ; + + oper + -- Build "x thousand" table + numTable : (CardOrd => Num_Case => Str) = overload { + + numTable : Str -> (CardOrd => Num_Case => Str) = \thou -> table { + NCard => \\numcase => thou ; + NOrd => \\numcase => definiteArticle ++ thou + } ; + + numTable : Str -> Str -> (CardOrd => Num_Case => Str) = \thou,attach -> table { + NCard => \\numcase => thou ++ attach ; + NOrd => \\numcase => definiteArticle ++ thou ++ attach + } ; + + numTable : Str -> (Num_Case => Str) -> (CardOrd => Num_Case => Str) = \thou,attach -> table { + NCard => table { + NumNominative => thou ++ (attach ! NumNominative) ; + NumAdjectival => thou ++ (attach ! NumAdjectival) + } ; + NOrd => table { + NumNominative => definiteArticle ++ thou ++ (attach ! NumNominative) ; + NumAdjectival => definiteArticle ++ thou ++ (attach ! NumAdjectival) + } + } ; + + } ; +{- +-- elf : (CardOrd => Str) = overload { + elf : Str -> (CardOrd => Num_Case => Str) = \m -> table { + NCard => \\numcase => m ; + NOrd => \\numcase => addDefiniteArticle m + } ; + elf2 : Str -> Str -> (CardOrd => Num_Case => Str) = \m,n -> table { + NCard => \\numcase => m ++ n ; + NOrd => \\numcase => (addDefiniteArticle m) ++ n + } ; +-} +-- } ; + +{- + Numerals as sequences of digits have a separate, simpler grammar + ================================================================ + + cat + Dig ; -- single digit 0..9 + + data + IDig : Dig -> Digits ; -- 8 + IIDig : Dig -> Digits -> Digits ; -- 876 + + D_0, D_1, D_2, D_3, D_4, D_5, D_6, D_7, D_8, D_9 : Dig ; +-} + + lincat + + Dig = { + s : Str ; + n : Num_Number + } ; + + oper + -- Helper for making a Dig object. Specifying no number inplies plural. + mkDig : Dig = overload { + mkDig : Str -> Dig = \digit -> lin Dig { + s = digit ; + n = NumPl + } ; + mkDig : Str -> Num_Number -> Dig = \digit,num -> lin Dig { + s = digit ; + n = num + } ; + } ; + + -- For correct comma placement in Digits + commaIf : DTail -> Str = \t -> case t of { + T3 => "," ; + _ => [] + } ; + inc : DTail -> DTail = \t -> case t of { + T1 => T2 ; + T2 => T3 ; + T3 => T1 + } ; + + lin + D_0 = mkDig "0" ; + D_1 = mkDig "1" NumSg ; + D_2 = mkDig "2" NumDual ; + D_3 = mkDig "3" ; + D_4 = mkDig "4" ; + D_5 = mkDig "5" ; + D_6 = mkDig "6" ; + D_7 = mkDig "7" ; + D_8 = mkDig "8" ; + D_9 = mkDig "9" ; + + -- Create Digits from a Dig + IDig d = d ** {tail = T1} ; + + -- Create Digits from combining Dig with Digits + IIDig d i = { + s = d.s ++ (commaIf i.tail) ++ i.s ; + n = NumPl ; + tail = inc i.tail + } ; + +} diff --git a/lib/src/maltese/OrthoMlt.gf b/lib/src/maltese/OrthoMlt.gf new file mode 100644 index 000000000..93117031d --- /dev/null +++ b/lib/src/maltese/OrthoMlt.gf @@ -0,0 +1,9 @@ +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +resource OrthoMlt = open Prelude, Predef in { + flags coding=utf8 ; + + +} diff --git a/lib/src/maltese/ParadigmsMlt.gf b/lib/src/maltese/ParadigmsMlt.gf new file mode 100644 index 000000000..6593794d6 --- /dev/null +++ b/lib/src/maltese/ParadigmsMlt.gf @@ -0,0 +1,604 @@ +-- ParadigmsMlt.gf: morphological paradigms +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:../abstract:../../prelude:../common + +resource ParadigmsMlt = open + Predef, + Prelude, + MorphoMlt, + OrthoMlt,(ResMlt=ResMlt), + CatMlt + in { + + flags optimize=noexpand ; coding=utf8 ; + + oper + + {- ===== Noun Paradigms ===== -} + + -- Helper function for inferring noun plural from singulative + -- Nouns with collective & determinate forms should not use this... + inferNounPlural : Str -> Str = \sing -> + case sing of { + _ + "na" => init sing + "iet" ; -- eg WIDNIET + _ + "i" => sing + "n" ; -- eg BAĦRIN, DĦULIN, RAĦLIN + _ + ("a"|"u") => init(sing) + "i" ; -- eg ROTI + _ + "q" => sing + "at" ; -- eg TRIQAT + _ => sing + "i" + } ; + + -- Helper function for inferring noun gender from singulative + -- Refer Maltese (Descriptive Grammars) pg190 + inferNounGender : Str -> Gender = \sing -> + case sing of { + _ + "aġni" => Fem ; + _ + "anti" => Fem ; + _ + "zzjoni" => Fem ; + _ + "ġenesi" => Fem ; + _ + "ite" => Fem ; + _ + "itù" => Fem ; + _ + "joni" => Fem ; + _ + "ojde" => Fem ; + _ + "udni" => Fem ; + _ + ("a"|"à") => Fem ; + _ => Masc + } ; + + + -- Overloaded function for building a noun + -- Return: Noun + mkNoun : Noun = overload { + + -- Take the singular and infer gender & plural. + -- Assume no special plural forms. + -- Params: + -- Singular, eg AJRUPLAN + mkNoun : Str -> Noun = \sing -> + let + plural = inferNounPlural sing ; + gender = inferNounGender sing ; + in + mkNounWorst sing [] [] plural [] gender ; + + -- Take an explicit gender. + -- Assume no special plural forms. + -- Params: + -- Singular, eg AJRUPLAN + -- Gender + mkNoun : Str -> Gender -> Noun = \sing,gender -> + let + plural = inferNounPlural sing ; + in + mkNounWorst sing [] [] plural [] gender ; + + -- Take the singular, plural. Infer gender. + -- Assume no special plural forms. + -- Params: + -- Singular, eg KTIEB + -- Plural, eg KOTBA + mkNoun : Str -> Str -> Noun = \sing,plural -> + let + gender = inferNounGender sing ; + in + mkNounWorst sing [] [] plural [] gender ; + + -- Take the singular, plural and gender. + -- Assume no special plural forms. + -- Params: + -- Singular, eg KTIEB + -- Plural, eg KOTBA + -- Gender + mkNoun : Str -> Str -> Gender -> Noun = \sing,plural,gender -> + mkNounWorst sing [] [] plural [] gender ; + + + -- Takes all 5 forms, inferring gender + -- Params: + -- Singulative, eg KOXXA + -- Collective, eg KOXXOX + -- Double, eg KOXXTEJN + -- Determinate Plural, eg KOXXIET + -- Indeterminate Plural + mkNoun : Str -> Str -> Str -> Str -> Str -> Noun = \sing,coll,dual,det,ind -> + let + gender = if_then_else (Gender) (isNil sing) (inferNounGender coll) (inferNounGender sing) ; + in + { + s = table { + Singular Singulative => buildCaseTable sing ; + Singular Collective => buildCaseTable coll ; + Dual => buildCaseTable dual ; + Plural Determinate => buildCaseTable det ; + Plural Indeterminate => buildCaseTable ind + } ; + g = gender ; + } ; + + + } ; --end of mkNoun overload + + + -- Take the singular and infer gender. + -- No other plural forms. + -- Params: + -- Singular, eg ARTI + mkNounNoPlural : Noun = overload { + + mkNounNoPlural : Str -> Noun = \sing -> + let gender = inferNounGender sing ; + in mkNounWorst sing [] [] [] [] gender + ; + + mkNounNoPlural : Str -> Gender -> Noun = \sing,gender -> + mkNounWorst sing [] [] [] [] gender + ; + + } ; --end of mkNounNoPlural overload + + + -- Take the singular and infer dual, plural & gender + -- Params: + -- Singular, eg AJRUPLAN + mkNounDual : Str -> Noun = \sing -> + let + dual : Str = case sing of { + _ + ("għ"|"'") => sing + "ajn" ; + _ + ("a") => init(sing) + "ejn" ; + _ => sing + "ejn" + } ; + plural = inferNounPlural sing ; + gender = inferNounGender sing ; + in + mkNounWorst sing [] dual plural [] gender ; + + + -- Take the collective, and infer singulative, determinate plural, and gender. + -- Params: + -- Collective Plural, eg TUFFIEĦ + mkNounColl : Str -> Noun = \coll -> + let + stem : Str = case coll of { + -- This can only apply when there are 2 syllables in the word + _ + #Vowel + #Consonant + #Vowel + K@#Consonant => tk 2 coll + K ; -- eg GĦADAM -> GĦADM- + + _ => coll + } ; + ------- + sing : Str = case stem of { + _ => stem + "a" + } ; + det : Str = case stem of { + _ => stem + "iet" + } ; + -- gender = inferNounGender sing ; + gender = Masc ; -- Collective noun is always treated as Masculine + in + mkNounWorst sing coll [] det [] gender ; + + + -- Worst case + -- Takes all forms and a gender + -- Params: + -- Singulative, eg KOXXA + -- Collective, eg KOXXOX + -- Double, eg KOXXTEJN + -- Determinate Plural, eg KOXXIET + -- Indeterminate Plural + -- Gender + mkNounWorst : Str -> Str -> Str -> Str -> Str -> Gender -> Noun = \sing,coll,dual,det,ind,gen -> { + s = table { + Singular Singulative => buildCaseTable sing ; + Singular Collective => buildCaseTable coll ; + Dual => buildCaseTable dual ; + Plural Determinate => buildCaseTable det ; + Plural Indeterminate => buildCaseTable ind + } ; + g = gen ; + } ; + + + -- Build a definiteness/case table for a single noun number form + -- Params: + -- noun form (eg NEMLA, NEMEL, NEMLIET) + buildCaseTable : Str -> (Definiteness => Case => Str) = \noun -> + table { + Definite => table { + Benefactive => addDefinitePreposition "għall" noun; + Comitative => addDefinitePreposition "mal" noun ; + Dative => addDefinitePreposition "lill" noun ; + Elative => addDefinitePreposition "mill" noun ; + Equative => addDefinitePreposition "bħall" noun ; + Genitive => addDefinitePreposition "tal" noun ; + Inessive => addDefinitePreposition "fil" noun; + Instrumental=> addDefinitePreposition "bil" noun; + Lative => addDefinitePreposition "sal" noun ; + Nominative => addDefinitePreposition "il" noun + } ; + Indefinite => table { + Benefactive => abbrevPrepositionIndef "għal" noun; + Comitative => abbrevPrepositionIndef "ma'" noun ; + Dative => abbrevPrepositionIndef "lil" noun ; + Elative => abbrevPrepositionIndef "minn" noun ; + Equative => abbrevPrepositionIndef "bħal" noun ; + Genitive => abbrevPrepositionIndef "ta'" noun ; + Inessive => abbrevPrepositionIndef "fi" noun; + Instrumental=> abbrevPrepositionIndef "bi" noun; + Lative => abbrevPrepositionIndef "sa" noun ; + Nominative => noun + } + }; + +{- + -- Correctly abbreviate definite prepositions and join with noun + -- Params: + -- preposition (eg TAL, MAL, BĦALL) + -- noun + abbrevPrepositionDef : Str -> Str -> Str = \prep,noun -> + let + -- Remove either 1 or 2 l's + prepStem : Str = case prep of { + _ + "ll" => tk 2 prep ; + _ + "l" => tk 1 prep ; + _ => prep -- this should never happen, I don't think + } + in + case noun of { + ("s"|#LiquidCons) + #Consonant + _ => prep + "-i" + noun ; + ("għ" | #Vowel) + _ => case prep of { + ("fil"|"bil") => (take 1 prep) + "l-" + noun ; + _ => prep + "-" + noun + }; + K@#CoronalConsonant + _ => prepStem + K + "-" + noun ; + #Consonant + _ => prep + "-" + noun ; + _ => [] + } ; +-} + -- Correctly abbreviate indefinite prepositions and join with noun + -- Params: + -- preposition (eg TA', MA', BĦAL) + -- noun + abbrevPrepositionIndef : Str -> Str -> Str = \prep,noun -> + let + initPrepLetter = take 1 prep ; + initNounLetter = take 1 noun + in + if_then_Str (isNil noun) [] ( + case prep of { + + -- TA', MA', SA + _ + ("a'"|"a") => + case noun of { + #Vowel + _ => initPrepLetter + "'" + noun ; + ("għ" | "h") + #Vowel + _ => initPrepLetter + "'" + noun ; + _ => prep ++ noun + } ; + + -- FI, BI + _ + "i" => + if_then_Str (pbool2bool (eqStr initPrepLetter initNounLetter)) + (prep ++ noun) + (case noun of { + -- initPrepLetter + _ => prep ++ noun ; + #Vowel + _ => initPrepLetter + "'" + noun ; + #Consonant + #Vowel + _ => initPrepLetter + "'" + noun ; + #Consonant + "r" + #Vowel + _ => initPrepLetter + "'" + noun ; + _ => prep ++ noun + }) ; + + -- Else leave untouched + _ => prep ++ noun + + }); + + + {- ========== Verb paradigms ========== -} + + -- Takes a verb as a string and returns the VType and root/pattern. + -- Used in smart paradigm below and elsewhere. + -- Params: "Mamma" (Perf Per3 Sg Masc) as string (eg KITEB or ĦAREĠ) + -- Return: Record with v:VType, r:Root, p:Pattern + classifyVerb : Str -> { t:VType ; r:Root ; p:Pattern } = \mamma -> case mamma of { + -- Quad + K@#Consonant + v1@#Vowel + T@#Consonant + B@#Consonant + v2@#Vowel + L@#Consonant => { t=Quad ; r={ K=K ; T=T ; B=B ; L=L } ; p={ v1=v1 ; v2=v2 } } ; + + -- Hollow + K@#Consonant + v1@"a" + B@#Consonant => { t=Hollow ; r={ K=K ; T="w" ; B=B ; L=[] } ; p={ v1=v1 ; v2="" } } ; + K@#Consonant + v1@"ie" + B@#Consonant => { t=Hollow ; r={ K=K ; T="j" ; B=B ; L=[] } ; p={ v1=v1 ; v2="" } } ; + + -- Double + K@#Consonant + v1@#Vowel + T@#Consonant + B@#Consonant => { t=Double ; r={ K=K ; T=T ; B="j" ; L=[] } ; p={ v1=v1 ; v2="" } } ; + + -- Weak + K@#Consonant + v1@#Vowel + T@#Consonant + v2@#Vowel => { t=Weak ; r={ K=K ; T=T ; B="j" ; L=[] } ; p={ v1=v1 ; v2=v2 } } ; + + -- Defective + K@#Consonant + v1@#Vowel + T@#Consonant + v2@#Vowel + B@( "għ" | "'" ) => { t=Defective ; r={ K=K ; T=T ; B="għ" ; L=[] } ; p={ v1=v1 ; v2=v2 } } ; + + -- Strong + K@#Consonant + v1@#Vowel + T@#Consonant + v2@#Vowel + B@(#Consonant | "ġ") => { t=Strong ; r={ K=K ; T=T ; B=B ; L=[] } ; p={ v1=v1 ; v2=v2 } } ; + + -- Error :( + _ => Predef.error ( "Unable to parse verb" ) + } ; + + -- Smart paradigm for building a Verb, by calling correct corresponding mkXXX functions + -- Return: Verb + mkVerb : Verb = overload { + + -- Tries to do everything just from the mamma of the verb + -- Params: + -- "Mamma" (Perf Per3 Sg Masc) as string (eg KITEB or ĦAREĠ) + mkVerb : Str -> Verb = \mamma -> + let + class = classifyVerb mamma + in + case class.t of { + Strong => mkStrong class.r class.p ; + Defective => mkDefective class.r class.p ; + Weak => Predef.error ( "WEAK" ) ; + Hollow => Predef.error ( "HOLLOW" ) ; + Double => Predef.error ( "DOUBLE" ) ; + Quad => mkQuad class.r class.p + } ; + + -- Same as above but also takes an Imperative of the word for when it behaves less predictably + -- Params: + -- "Mamma" (Perf Per3 Sg Masc) as string (eg KITEB or ĦAREĠ ) + -- Imperative Singular as a string (eg IKTEB or OĦROĠ ) + -- Imperative Plural as a string (eg IKTBU or OĦORĠU ) + mkVerb : Str -> Str -> Str -> Verb = \mamma,imp_sg,imp_pl -> + let + class = classifyVerb mamma + in + case class.t of { + Strong => { + s = table { + VPerf pgn => ( conjStrongPerf class.r class.p ) ! pgn ; + VImpf pgn => ( conjStrongImpf imp_sg imp_pl ) ! pgn ; + VImp n => table { Sg => imp_sg ; Pl => imp_pl } ! n + } ; + o = Semitic ; + t = Strong ; + } ; + Defective => { + s = table { + VPerf pgn => ( conjDefectivePerf class.r class.p ) ! pgn ; + VImpf pgn => ( conjDefectiveImpf imp_sg imp_pl ) ! pgn ; + VImp n => table { Sg => imp_sg ; Pl => imp_pl } ! n + } ; + o = Semitic ; + t = Defective ; + } ; + Weak => Predef.error ( "WEAK" ) ; + Hollow => Predef.error ( "HOLLOW" ) ; + Double => Predef.error ( "DOUBLE" ) ; + Quad => { + s = table { + VPerf pgn => ( conjQuadPerf class.r class.p ) ! pgn ; + VImpf pgn => ( conjQuadImpf imp_sg imp_pl ) ! pgn ; + VImp n => table { Sg => imp_sg ; Pl => imp_pl } ! n + } ; + o = Semitic ; + t = Quad ; + } + } ; + + } ; --end of mkVerb overload + + + {- ===== STRONG VERB ===== -} + + -- Strong verb, eg ĦAREĠ (Ħ-R-Ġ) + -- Make a verb by calling generate functions for each tense + -- Params: Root, Pattern + -- Return: Verb + mkStrong : Root -> Pattern -> Verb = \r,p -> + let + imp = conjStrongImp r p ; + in { + s = table { + VPerf pgn => ( conjStrongPerf r p ) ! pgn ; + VImpf pgn => ( conjStrongImpf (imp ! Sg) (imp ! Pl) ) ! pgn ; + VImp n => imp ! n + } ; + t = Strong ; + o = Semitic + } ; + + -- Conjugate entire verb in PERFECT tense + -- Params: Root, Pattern + -- Return: Lookup table of Agr against Str + conjStrongPerf : Root -> Pattern -> ( Agr => Str ) = \root,p -> + let + stem_12 = root.K + root.T + (case p.v2 of {"e" => "i" ; _ => p.v2 }) + root.B ; + stem_3 = root.K + p.v1 + root.T + root.B ; + in + table { + Per1 Sg => stem_12 + "t" ; -- Jiena KTIBT + Per2 Sg => stem_12 + "t" ; -- Inti KTIBT + Per3Sg Masc => root.K + p.v1 + root.T + p.v2 + root.B ; -- Huwa KITEB + Per3Sg Fem => stem_3 + (case p.v2 of {"o" => "o" ; _ => "e"}) + "t" ; -- Hija KITBET + Per1 Pl => stem_12 + "na" ; -- Aħna KTIBNA + Per2 Pl => stem_12 + "tu" ; -- Intom KTIBTU + Per3Pl => stem_3 + "u" -- Huma KITBU + } ; + + -- Conjugate entire verb in IMPERFECT tense, given the IMPERATIVE + -- Params: Imperative Singular (eg IKTEB), Imperative Plural (eg IKTBU) + -- Return: Lookup table of Agr against Str + conjStrongImpf : Str -> Str -> ( Agr => Str ) = \stem_sg,stem_pl -> + table { + Per1 Sg => "n" + stem_sg ; -- Jiena NIKTEB + Per2 Sg => "t" + stem_sg ; -- Inti TIKTEB + Per3Sg Masc => "j" + stem_sg ; -- Huwa JIKTEB + Per3Sg Fem => "t" + stem_sg ; -- Hija TIKTEB + Per1 Pl => "n" + stem_pl ; -- Aħna NIKTBU + Per2 Pl => "t" + stem_pl ; -- Intom TIKTBU + Per3Pl => "j" + stem_pl -- Huma JIKTBU + } ; + + -- Conjugate entire verb in IMPERATIVE tense, infers vowel patterns + -- Params: Root, Pattern + -- Return: Lookup table of Number against Str + conjStrongImp : Root -> Pattern -> ( Person_Number => Str ) = \root,p -> + let + stem_sg = case (p.v1 + p.v2) of { + "aa" => "i" + root.K + root.T + "o" + root.B ; + "ae" => "o" + root.K + root.T + "o" + root.B ; + "ee" => "i" + root.K + root.T + "e" + root.B ; + "ea" => "i" + root.K + root.T + "a" + root.B ; + "ie" => "i" + root.K + root.T + "e" + root.B ; + "oo" => "o" + root.K + root.T + "o" + root.B + } ; + stem_pl = case (p.v1 + p.v2) of { + "aa" => "i" + root.K + "o" + root.T + root.B ; + "ae" => "o" + root.K + "o" + root.T + root.B ; + "ee" => "i" + root.K + "e" + root.T + root.B ; + "ea" => "i" + root.K + "i" + root.T + root.B ; + "ie" => "i" + root.K + "e" + root.T + root.B ; + "oo" => "o" + root.K + "o" + root.T + root.B + } ; + in + table { + Sg => stem_sg ; -- Inti: IKTEB + Pl => stem_pl + "u" -- Intom: IKTBU + } ; + + + {- ===== DEFECTIVE VERB ===== -} + + -- Defective verb, eg SAMA' (S-M-GĦ) + -- Make a verb by calling generate functions for each tense + -- Params: Root, Pattern + -- Return: Verb + mkDefective : Root -> Pattern -> Verb = \r,p -> + let + imp = conjDefectiveImp r p ; + in { + s = table { + VPerf pgn => ( conjDefectivePerf r p ) ! pgn ; + VImpf pgn => ( conjDefectiveImpf (imp ! Sg) (imp ! Pl) ) ! pgn ; + VImp n => imp ! n + } ; + t = Defective ; + o = Semitic + } ; + + -- Conjugate entire verb in PERFECT tense + -- Params: Root, Pattern + -- Return: Lookup table of Agr against Str + conjDefectivePerf : Root -> Pattern -> ( Agr => Str ) = \root,p -> + let + stem_12 = root.K + root.T + (case p.v2 of {"e" => "i" ; _ => p.v2 }) + "j" ; -- "AGĦ" -> "AJ" + stem_3 = root.K + p.v1 + root.T + root.B ; + in + table { + Per1 Sg => stem_12 + "t" ; -- Jiena QLAJT + Per2 Sg => stem_12 + "t" ; -- Inti QLAJT + Per3Sg Masc => root.K + p.v1 + root.T + p.v2 + "'" ; -- Huwa QALA' + Per3Sg Fem => stem_3 + (case p.v2 of {"o" => "o" ; _ => "e"}) + "t" ; -- Hija QALGĦET + Per1 Pl => stem_12 + "na" ; -- Aħna QLAJNA + Per2 Pl => stem_12 + "tu" ; -- Intom QLAJTU + Per3Pl => stem_3 + "u" -- Huma QALGĦU + } ; + + -- Conjugate entire verb in IMPERFECT tense, given the IMPERATIVE + -- Params: Imperative Singular (eg IKTEB), Imperative Plural (eg IKTBU) + -- Return: Lookup table of Agr against Str + conjDefectiveImpf : Str -> Str -> ( Agr => Str ) = \stem_sg,stem_pl -> + table { + Per1 Sg => "n" + stem_sg ; -- Jiena NIKTEB + Per2 Sg => "t" + stem_sg ; -- Inti TIKTEB + Per3Sg Masc => "j" + stem_sg ; -- Huwa JIKTEB + Per3Sg Fem => "t" + stem_sg ; -- Hija TIKTEB + Per1 Pl => "n" + stem_pl ; -- Aħna NIKTBU + Per2 Pl => "t" + stem_pl ; -- Intom TIKTBU + Per3Pl => "j" + stem_pl -- Huma JIKTBU + } ; + + -- Conjugate entire verb in IMPERATIVE tense, infers vowel patterns + -- Params: Root, Pattern + -- Return: Lookup table of Number against Str + conjDefectiveImp : Root -> Pattern -> ( Person_Number => Str ) = \root,p -> + let + v1 = case p.v1 of { "e" => "i" ; _ => p.v1 } ; + v_pl = case p.v1 of { "a" => "i" ; _ => "" } ; -- some verbs require "i" insertion in middle (eg AQILGĦU) + in + table { + Sg => v1 + root.K + root.T + p.v2 + "'" ; -- Inti: AQLA' / IBŻA' + Pl => v1 + root.K + v_pl + root.T + root.B + "u" -- Intom: AQILGĦU / IBŻGĦU + } ; + + {- ===== QUADRILITERAL VERB ===== -} + + -- Make a Quad verb, eg QARMEĊ (Q-R-M-Ċ) + -- Make a verb by calling generate functions for each tense + -- Params: Root, Pattern + -- Return: Verb + mkQuad : Root -> Pattern -> Verb = \r,p -> + let + imp = conjQuadImp r p ; + in { + s = table { + VPerf pgn => ( conjQuadPerf r p ) ! pgn ; + VImpf pgn => ( conjQuadImpf (imp ! Sg) (imp ! Pl) ) ! pgn ; + VImp n => imp ! n + } ; + t = Quad ; + o = Semitic ; + } ; + + -- Conjugate entire verb in PERFECT tense + -- Params: Root, Pattern + -- Return: Lookup table of Agr against Str + conjQuadPerf : Root -> Pattern -> ( Agr => Str ) = \root,p -> + let + stem_12 = root.K + p.v1 + root.T + root.B + (case p.v2 of {"e" => "i" ; _ => p.v2 }) + root.L ; + stem_3 = root.K + p.v1 + root.T + root.B + root.L ; + in + table { + Per1 Sg => stem_12 + "t" ; -- Jiena DARDART + Per2 Sg => stem_12 + "t" ; -- Inti DARDART + Per3Sg Masc => root.K + p.v1 + root.T + root.B + p.v2 + root.L ; -- Huwa DARDAR + Per3Sg Fem => stem_3 + (case p.v2 of {"o" => "o" ; _ => "e"}) + "t" ; -- Hija DARDRET + Per1 Pl => stem_12 + "na" ; -- Aħna DARDARNA + Per2 Pl => stem_12 + "tu" ; -- Intom DARDARTU + Per3Pl => stem_3 + "u" -- Huma DARDRU + } ; + + -- Conjugate entire verb in IMPERFECT tense, given the IMPERATIVE + -- Params: Imperative Singular (eg ____), Imperative Plural (eg ___) + -- Return: Lookup table of Agr against Str + conjQuadImpf : Str -> Str -> ( Agr => Str ) = \stem_sg,stem_pl -> + let + prefix_dbl:Str = case stem_sg of { + X@( "d" | "t" ) + _ => "i" + X ; + _ => "t" + } ; + in + table { + Per1 Sg => "in" + stem_sg ; -- Jiena INDARDAR + Per2 Sg => prefix_dbl + stem_sg ; -- Inti IDDARDAR + Per3Sg Masc => "i" + stem_sg ; -- Huwa IDARDAR + Per3Sg Fem => prefix_dbl + stem_sg ; -- Hija IDDARDAR + Per1 Pl => "in" + stem_pl ; -- Aħna INDARDRU + Per2 Pl => prefix_dbl + stem_pl ; -- Intom IDDARDRU + Per3Pl => "i" + stem_pl -- Huma IDARDRU + } ; + + -- Conjugate entire verb in IMPERATIVE tense, infers vowel patterns + -- Params: Root, Pattern + -- Return: Lookup table of Number against Str + conjQuadImp : Root -> Pattern -> ( Person_Number => Str ) = \root,p -> + table { + Sg => root.K + p.v1 + root.T + root.B + p.v2 + root.L ; -- Inti: DARDAR + Pl => root.K + p.v1 + root.T + root.B + root.L + "u" -- Intom: DARDRU + } ; + + + +} diff --git a/lib/src/maltese/PatternsMlt.gf b/lib/src/maltese/PatternsMlt.gf new file mode 100644 index 000000000..65ee04b82 --- /dev/null +++ b/lib/src/maltese/PatternsMlt.gf @@ -0,0 +1,8 @@ +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +resource PatternsMlt = { + flags coding=utf8 ; + +} diff --git a/lib/src/maltese/PhraseMlt.gf b/lib/src/maltese/PhraseMlt.gf new file mode 100644 index 000000000..0709ec218 --- /dev/null +++ b/lib/src/maltese/PhraseMlt.gf @@ -0,0 +1,14 @@ +-- PhraseMlt.gf: suprasentential phrases +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete PhraseMlt of Phrase = CatMlt ** open ParamX, Prelude, ResMlt in { + +-- PConj +-- Phr +-- Utt +-- Voc + +} diff --git a/lib/src/maltese/QuestionMlt.gf b/lib/src/maltese/QuestionMlt.gf new file mode 100644 index 000000000..4a43edc84 --- /dev/null +++ b/lib/src/maltese/QuestionMlt.gf @@ -0,0 +1,17 @@ +-- QuestionMlt.gf: questions and interrogatives +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete QuestionMlt of Question = CatMlt ** open ResMlt, ParamX, Prelude in { + + flags optimize=all_subs ; + +-- IAdv +-- IComp +-- IDet +-- IP +-- QCl + +} diff --git a/lib/src/maltese/RelativeMlt.gf b/lib/src/maltese/RelativeMlt.gf new file mode 100644 index 000000000..426a06cfd --- /dev/null +++ b/lib/src/maltese/RelativeMlt.gf @@ -0,0 +1,12 @@ +-- RelativeMlt.gf: relational clauses and pronouns +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete RelativeMlt of Relative = CatMlt ** open ResMlt in { + +-- RCl +-- RP + +} diff --git a/lib/src/maltese/ResMlt.gf b/lib/src/maltese/ResMlt.gf new file mode 100644 index 000000000..c7e865828 --- /dev/null +++ b/lib/src/maltese/ResMlt.gf @@ -0,0 +1,311 @@ +-- ResMlt.gf: Language-specific parameter types, morphology, VP formation +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:../abstract:../common:../prelude + +{- + Verb types summary: + =================== + - Strong verb: none of radicals are semi-vowels eg ĦAREĠ (Ħ-R-Ġ) + - Defective verb: third radical is semivowel GĦ eg QATA' (Q-T-GĦ) + - Weak verb: third radical is semivowel J eg MEXA (M-X-J) + - Hollow verb: long A or IE btw radicals 1 & 3 eg QAL (Q-W-L) or SAB (S-J-B) + - Double/Geminated verb: radicals 2 & 3 identical eg ĦABB (Ħ-B-B) + - Quadriliteral verb: 4 radicals eg QARMEĊ (Q-R-M-Ċ) +-} + + +resource ResMlt = PatternsMlt ** open Prelude in { + + flags coding=utf8 ; + + param + + -- Used in the NumeralMlt module + CardOrd = NCard | NOrd ; + DTail = T1 | T2 | T3 ; -- This is already defined in ParamX... + Num_Number = + NumSg + | NumDual + | NumPl + ; + DForm = + Unit -- 0..10 + | Teen -- 11-19 + --| TeenIl -- 11-19 + | Ten -- 20-99 + | Hund -- 100..999 + --| Thou -- 1000+ + ; + Num_Case = + NumNominative + | NumAdjectival ; + + +{- + Note: NNQ = Non-numerically quantifiable + + Nouns can have the following forms: + o Singular + - Singulative (1, >10) + - Collective (NNQ) + o Dual (2) + o Plural + - Determinate (2-10) + - Indeterminate (NNQ) + - Sound + - Broken + - Plural of Plural + + Typical combinations thereof (* marks base form): + - Singulative, no plural! + - Singulative*, Plural + - Singulative* (1), Dual (2), Plural (>2) + - Singulative (1, >10), Collective* (NNQ), Determinate Plural (2-10) + - Singulative, Collective*, Determinate Plural, Indeterminate Plural -> very few nouns have these 4 forms +-} + Noun_Sg_Type = + Singulative -- eg ĦUTA + | Collective -- eg ĦUT + ; + Noun_Pl_Type = + Determinate -- eg ĦUTIET + | Indeterminate -- eg ĦWIET + ; + Noun_Number = + Singular Noun_Sg_Type -- eg ĦUTA / ĦUT + | Dual -- eg WIDNEJN + | Plural Noun_Pl_Type -- eg ĦUTIET / ĦWIET + ; + +{- + Noun_PluralType = + Sound -- External (affix), eg FERGĦA -> FERGĦAT + | Broken -- Internal, eg FERGĦA -> FRIEGĦI + | Irregular -- eg MARA -> NISA + | PluralOfPlural -- eg TARF -> TRUF -> TRUFIJIET + | Foreign -- eg KARTI, PRATTIĊI, TELEVIXINS + ; +-} + + Gender = Masc | Fem ; + + Animacy = + Animate + | Inanimate + ; + + Definiteness = + Definite -- eg IL-KARTA. In this context same as Determinate + | Indefinite -- eg KARTA + ; + +{- + -- CASE AS DEFINED BY GRAMMATIKA MALTIJA, p132 + -- Noun cases + Case = + Nominative -- referent as subject, eg IT-TARBIJA ... + | Genitive -- referent as possessor, eg ... TAT-TARBIJA + | Accusative -- referent as direct object + | Dative -- referent as indirect object, eg ... LIT-TARBIJA + | Ablative -- referent as instrument, cause, location, source or time, eg ... MINN TARBIJA + | Vocative -- referent being adressed, eg AA TARBIJA (lol) + ; +-} + + -- CASE AS DEFINED BY ME + -- Noun cases (note my examples include DEFINITE ARTICLE) + -- Commented lines mean that noun iflection is unchanged, not that the case does not occur in Maltese! + Case = +-- Absessive -- lack or absence of referent (MINGĦAJR) +-- | Ablative -- referent as instrument, cause, location, source or time +-- | Absolutive -- subject of intransitive or object of transitive verb (in ergative-absolutive languages) +-- | Accusative -- referent as direct object (in nominative-accusative languages) +-- | Allative -- motion towards referent (LEJN) +-- | Additive -- synonym of Allative (above) + Benefactive -- referent as recipient, eg GĦAT-TARBIJA. cf Dative. +-- | Causative -- referent as the cause of a situation (MINĦABBA) + | Comitative -- with, eg MAT-TARBIJA + | Dative -- referent as indirect object, eg LIT-TARBIJA. cf Benefactive. +-- | Delative -- motion downward from referent + | Elative -- motion away from referent, eg MIT-TARBIJA + | Equative -- likeness or identity, eg BĦAT-TARBIJA +-- | Ergative -- subject of transitive verb (in ergative-absolutive languages) +-- | Essive -- temporary state / while / in capacity of (BĦALA) + | Genitive -- referent as possessor, eg TAT-TARBIJA +-- | Illative -- motion into / towards referent, eg SAT-TARBIJA. cf Allative. + | Inessive -- within referent, eg ĠOT-TARBIJA, FIT-TARBIJA + | Instrumental -- referent as instrument, eg BIT-TARBIJA. cf Ablative. + | Lative -- motion up to referent, eg SAT-TARBIJA +-- | Locative -- location at referent + | Nominative -- referent as subject, eg IT-TARBIJA +-- | Partitive -- partial nature of referent +-- | Prolative -- motion along / beside referent +-- | Superessive -- on / upon (FUQ) +-- | Translative -- referent noun or adjective as result of process of change +-- | Vocative -- referent being adressed, eg AA TARBIJA (lol) + ; + +-- Person = P1 | P2 | P3 ; +-- State = Def | Indef | Const ; +-- Mood = Ind | Cnj | Jus ; +-- Voice = Act | Pas ; + Origin = + Semitic + | Romance + | English + ; +-- Order = Verbal | Nominal ; + + -- Just for my own use + -- Mamma = Per3 Sg Masc ; + + -- Shortcut type + -- GenNum = gn Gender Number2 ; + + + Person_Number = Sg | Pl ; + + -- Agreement features + Agr = + Per1 Person_Number -- Jiena, Aħna + | Per2 Person_Number -- Inti, Intom + | Per3Sg Gender -- Huwa, Hija + | Per3Pl -- Huma + ; + + -- Possible tenses + Tense = + Perf -- Perfect tense, eg SERAQ + | Impf -- Imperfect tense, eg JISRAQ + | Imp -- Imperative, eg ISRAQ + -- | PresPart -- Present Particible. Intransitive and 'motion' verbs only, eg NIEŻEL + -- | PastPart -- Past Particible. Both verbal & adjectival function, eg MISRUQ + -- | VerbalNoun -- Verbal Noun, eg SERQ + ; + + -- Possible verb forms (tense + person) + VForm = + VPerf Agr -- Perfect tense in all pronoun cases + | VImpf Agr -- Imperfect tense in all pronoun cases + | VImp Person_Number -- Imperative is always Per2, Sg & Pl + -- | VPresPart GenNum -- Present Particible for Gender/Number + -- | VPastPart GenNum -- Past Particible for Gender/Number + -- | VVerbalNoun -- Verbal Noun + ; + + -- Possible verb types + VType = + Strong -- Strong verb: none of radicals are semi-vowels eg ĦAREĠ (Ħ-R-Ġ) + | Defective -- Defective verb: third radical is semivowel GĦ eg QATA' (Q-T-GĦ) + | Weak -- Weak verb: third radicl is semivowel J eg MEXA (M-X-J) + | Hollow -- Hollow verb: long A or IE btw radicals 1 & 3 eg QAL (Q-W-L) or SAB (S-J-B) + | Double -- Double/Geminated verb: radicals 2 & 3 identical eg ĦABB (Ħ-B-B) + | Quad -- Quadliteral verb eg KARKAR (K-R-K-R), MAQDAR (M-Q-D-R), LEMBEB (L-M-B-B) + ; + + oper + + -- Roots & Patterns + Pattern : Type = {v1, v2 : Str} ; -- vowel1, vowel2 + -- Root3 : Type = {K, T, B : Str} ; + -- Root4 : Type = Root3 ** {L : Str} ; + Root : Type = {K, T, B, L : Str} ; + + -- Some classes. I need to include "c" because currently "ċ" gets downgraded to "c" in input :/ + Consonant : pattern Str = #( "b" | "c" | "ċ" | "d" | "f" | "ġ" | "g" | "għ" | "ħ" | "h" | "j" | "k" | "l" | "m" | "n" | "p" | "q" | "r" | "s" | "t" | "v" | "w" | "x" | "ż" | "z" ); + CoronalConsonant : pattern Str = #( "c" | "ċ" | "d" | "n" | "r" | "s" | "t" | "x" | "ż" | "z" ); -- "konsonanti xemxin" + LiquidCons : pattern Str = #( "l" | "m" | "n" | "r" | "għ" ); + Vowel : pattern Str = #( "a" | "e" | "i" | "o" | "u" ); + Digraph : pattern Str = #( "ie" ); + SemiVowel : pattern Str = #( "għ" | "j" ); + + {- ===== Type declarations ===== -} + + -- VP = { + -- v : Verb ; + -- clit : Str ; + -- clitAgr : ClitAgr ; + -- obj : Agr => Str + -- } ; + + -- NP = { + -- s : Case => {clit,obj : Str ; isClit : Bool} ; + -- a : Agr + -- } ; + +{- + Noun : Type = { + s : Number5 => Str ; + g : Gender ; + } ; +-} + Noun : Type = { + s : Noun_Number => Definiteness => Case => Str ; + g : Gender ; + } ; + + Adj : Type = { + s : Gender => Person_Number => Str ; + -- isPre : Bool ; + } ; + + Verb : Type = { + s : VForm => Str ; -- Give me the form (tense, person etc) and I'll give you the string + t : VType ; -- Inherent - Strong/Hollow etc + o : Origin ; -- Inherent - a verb of Semitic or Romance origins? + } ; + + + {- ===== Useful helper functions ===== -} + + addDefinitePreposition : Str -> Str -> Str = \prep,n -> (getDefinitePreposition prep n) ++ n ; + addDefiniteArticle = addDefinitePreposition "il" ; + getDefiniteArticle = getDefinitePreposition "il" ; + + -- Correctly inflect definite preposition + -- A more generic version of getDefiniteArticle + -- Params: + -- preposition (eg TAL, MAL, BĦALL) + -- noun + -- NOTE trying to call this with a runtime string will cause a world of pain. Design around it. + getDefinitePreposition : Str -> Str -> Str = \prep,noun -> + let + -- Remove either 1 or 2 l's + prepStem : Str = case prep of { + _ + "ll" => Predef.tk 2 prep ; + _ + "l" => Predef.tk 1 prep ; + _ => prep -- this should never happen, I don't think + } + in + case noun of { + ("s"|#LiquidCons) + #Consonant + _ => prep + "-i" ; -- L-ISKOLA + ("għ" | #Vowel) + _ => case prep of { -- L-GĦATBA... + ("fil"|"bil") => (Predef.take 1 prep) + "l-" ; + "il" => "l" + "-" ; + _ => prep + "-" + }; + K@#CoronalConsonant + _ => prepStem + K + "-" ; -- IĊ-ĊISK + #Consonant + _ => prep + "-" ; -- IL-QADDIS + _ => [] -- ? + } ; + + definiteArticle : Str = + pre { + "il-" ; + "l-" / strs { "a" ; "e" ; "i" ; "o" ; "u" ; "h" ; "għ" } ; + "iċ-" / strs { "ċ" } ; + "id-" / strs { "d" } ; + "in-" / strs { "n" } ; + "ir-" / strs { "r" } ; + "is-" / strs { "s" } ; + "it-" / strs { "t" } ; + "ix-" / strs { "x" } ; + "iż-" / strs { "ż" } ; + "iz-" / strs { "z" } + } ; + +} diff --git a/lib/src/maltese/SentenceMlt.gf b/lib/src/maltese/SentenceMlt.gf new file mode 100644 index 000000000..e40077184 --- /dev/null +++ b/lib/src/maltese/SentenceMlt.gf @@ -0,0 +1,26 @@ +-- SentenceMlt.gf: clauses and sentences +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:abstract:common:prelude + +concrete SentenceMlt of Sentence = CatMlt ** open + ResMlt, + Prelude, + ResMlt, + ParamX, + CommonX in { + + flags optimize=all_subs ; + +-- Cl +-- Imp +-- QS +-- RS +-- S +-- SC +-- SSlash + +} diff --git a/lib/src/maltese/StructuralMlt.gf b/lib/src/maltese/StructuralMlt.gf new file mode 100644 index 000000000..9e587ceb2 --- /dev/null +++ b/lib/src/maltese/StructuralMlt.gf @@ -0,0 +1,12 @@ +-- StructuralMlt.gf: lexicon of structural words +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete StructuralMlt of Structural = CatMlt ** + open MorphoMlt, ResMlt, ParadigmsMlt, Prelude in { + + flags optimize=all ; coding=utf8 ; + +} diff --git a/lib/src/maltese/SymbolMlt.gf b/lib/src/maltese/SymbolMlt.gf new file mode 100644 index 000000000..1c00bddab --- /dev/null +++ b/lib/src/maltese/SymbolMlt.gf @@ -0,0 +1,11 @@ +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +--# -path=.:abstract:common + +concrete SymbolMlt of Symbol = CatMlt ** open Prelude, ResMlt in { + + +} + diff --git a/lib/src/maltese/TextMlt.gf b/lib/src/maltese/TextMlt.gf new file mode 100644 index 000000000..b3f94df3d --- /dev/null +++ b/lib/src/maltese/TextMlt.gf @@ -0,0 +1,12 @@ +-- TextMlt.gf: many-phrase texts +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete IdiomMlt of Idiom = CatMlt ** open Prelude, ResMlt in { + +-- Text + +} + diff --git a/lib/src/maltese/VerbMlt.gf b/lib/src/maltese/VerbMlt.gf new file mode 100644 index 000000000..60f21b975 --- /dev/null +++ b/lib/src/maltese/VerbMlt.gf @@ -0,0 +1,14 @@ +-- VerbMlt.gf: verb phrases +-- +-- Maltese Resource Grammar Library +-- John J. Camilleri, 2011 +-- Licensed under LGPL + +concrete VerbMlt of Verb = CatMlt ** open Prelude, ResMlt in { + flags optimize=all_subs ; + +-- Comp +-- VP +-- VPSplash + +}