GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-04-23 19:42:50 -06:00
Code Issues Packages Projects Releases Wiki Activity

romanian_modified

Browse Source
This commit is contained in:
ra.monique
2009-09-14 01:33:06 +00:00
parent a81def4168
commit 18d01be869
15 changed files with 928 additions and 938 deletions
Download Patch File Download Diff File Expand all files Collapse all files

292
lib/src/romanian/BeschRon.gf
View File

@@ -1,11 +1,10 @@
resource BeschRon = open Prelude, MorphoRon,CatRon in { resource BeschRon = open Prelude, MorphoRon,CatRon in {
flags optimize=noexpand ; -- faster and smaller than =all flags optimize=noexpand ;
oper VerbeN = {s: VForm => Str ; isRefl : Agr => RAgr; nrClit : VClit} ; oper mkNV : Verbe -> V = \ve -> {s = ve.s ; isRefl = \\_ => RNoAg ; nrClit = VNone; pReflClit = Composite ;lock_V = <> } ;
oper mkNV : Verbe -> V = \ve -> {s = ve.s ; isRefl = \\_ => RNoAg ; nrClit = VNone ;lock_V = <> } ; oper mkRVAcc : Verbe -> V = \ve -> {s = ve.s ; isRefl = \\a => aRefl a; nrClit = VRefl; pReflClit = Short ;lock_V = <>} ;
oper mkRVAcc : Verbe -> V = \ve -> {s = ve.s ; isRefl = \\a => aRefl a; nrClit = VRefl ;lock_V = <>} ; oper mkRVDat : Verbe -> V = \ve -> {s = ve.s ; isRefl = \\a => dRefl a; nrClit = VRefl; pReflClit = Composite ;lock_V = <>};
oper mkRVDat : Verbe -> V = \ve -> {s = ve.s ; isRefl = \\a => dRefl a; nrClit = VRefl ;lock_V = <>};
-- for Group 1 - verbs ending in a (last sylablle) - the default behaviour is conjugation with "ez" -- for Group 1 - verbs ending in a (last sylablle) - the default behaviour is conjugation with "ez"
-- with small mutation, depending on the second last letter (80 % verbs - especially neological) -- with small mutation, depending on the second last letter (80 % verbs - especially neological)
@@ -23,149 +22,146 @@ oper mkRVDat : Verbe -> V = \ve -> {s = ve.s ; isRefl = \\a => dRefl a; nrClit =
oper conj : Str -> Verbe = mkV6 ; oper conj : Str -> Verbe = mkV6 ;
oper v_besch6 : Str -> V = \s -> mkNV (mkV6 s) ;
oper v_besch7 : Str -> V = \s -> mkNV (mkV7 s) ;
oper v_besch8 : Str -> V = \s -> mkNV (mkV8 s) ;
oper v_besch6 : Str -> VerbeN = \s -> mkNV (mkV6 s) ; oper v_besch9 : Str -> V = \s -> mkNV (mkV9 s) ;
oper v_besch7 : Str -> VerbeN = \s -> mkNV (mkV7 s) ; oper v_besch10 : Str -> V = \s -> mkNV (mkV10 s) ;
oper v_besch8 : Str -> VerbeN = \s -> mkNV (mkV8 s) ; oper v_besch11 : Str -> V = \s -> mkNV (mkV11 s) ;
oper v_besch9 : Str -> VerbeN = \s -> mkNV (mkV9 s) ; oper v_besch12 : Str -> V = \s -> mkNV (mkV12 s) ;
oper v_besch10 : Str -> VerbeN = \s -> mkNV (mkV10 s) ; oper v_besch13 : Str -> V = \s -> mkNV (mkV13 s) ;
oper v_besch11 : Str -> VerbeN = \s -> mkNV (mkV11 s) ; oper v_besch14 : Str -> V = \s -> mkNV (mkV14 s) ;
oper v_besch12 : Str -> VerbeN = \s -> mkNV (mkV12 s) ; oper v_besch15 : Str -> V = \s -> mkNV (mkV15 s) ;
oper v_besch13 : Str -> VerbeN = \s -> mkNV (mkV13 s) ; oper v_besch16 : Str -> V = \s -> mkNV (mkV16 s) ;
oper v_besch14 : Str -> VerbeN = \s -> mkNV (mkV14 s) ; oper v_besch17 : Str -> V = \s -> mkNV (mkV17 s) ;
oper v_besch15 : Str -> VerbeN = \s -> mkNV (mkV15 s) ; oper v_besch18 : Str -> V = \s -> mkNV (mkV18 s) ;
oper v_besch16 : Str -> VerbeN = \s -> mkNV (mkV16 s) ; oper v_besch19 : Str -> V = \s -> mkNV (mkV19 s) ;
oper v_besch17 : Str -> VerbeN = \s -> mkNV (mkV17 s) ; oper v_besch20 : Str -> V = \s -> mkNV (mkV20 s) ;
oper v_besch18 : Str -> VerbeN = \s -> mkNV (mkV18 s) ; oper v_besch21 : Str -> V = \s -> mkNV (mkV21 s) ;
oper v_besch19 : Str -> VerbeN = \s -> mkNV (mkV19 s) ; oper v_besch22 : Str -> V = \s -> mkNV (mkV22 s) ;
oper v_besch20 : Str -> VerbeN = \s -> mkNV (mkV20 s) ; oper v_besch23 : Str -> V = \s -> mkNV (mkV23 s) ;
oper v_besch21 : Str -> VerbeN = \s -> mkNV (mkV21 s) ; oper v_besch24 : Str -> V = \s -> mkNV (mkV24 s) ;
oper v_besch22 : Str -> VerbeN = \s -> mkNV (mkV22 s) ; oper v_besch25 : Str -> V = \s -> mkNV (mkV25 s) ;
oper v_besch23 : Str -> VerbeN = \s -> mkNV (mkV23 s) ; oper v_besch26 : Str -> V = \s -> mkNV (mkV26 s) ;
oper v_besch24 : Str -> VerbeN = \s -> mkNV (mkV24 s) ; oper v_besch27 : Str -> V = \s -> mkNV (mkV27 s) ;
oper v_besch25 : Str -> VerbeN = \s -> mkNV (mkV25 s) ; oper v_besch28 : Str -> V = \s -> mkNV (mkV28 s) ;
oper v_besch26 : Str -> VerbeN = \s -> mkNV (mkV26 s) ; oper v_besch29 : Str -> V = \s -> mkNV (mkV29 s) ;
oper v_besch27 : Str -> VerbeN = \s -> mkNV (mkV27 s) ; oper v_besch30 : Str -> V = \s -> mkNV (mkV30 s) ;
oper v_besch28 : Str -> VerbeN = \s -> mkNV (mkV28 s) ; oper v_besch31 : Str -> V = \s -> mkNV (mkV31 s) ;
oper v_besch29 : Str -> VerbeN = \s -> mkNV (mkV29 s) ; oper v_besch32 : Str -> V = \s -> mkNV (mkV32 s) ;
oper v_besch30 : Str -> VerbeN = \s -> mkNV (mkV30 s) ; oper v_besch33 : Str -> V = \s -> mkNV (mkV33 s) ;
oper v_besch31 : Str -> VerbeN = \s -> mkNV (mkV31 s) ; oper v_besch34 : Str -> V = \s -> mkNV (mkV34 s) ;
oper v_besch32 : Str -> VerbeN = \s -> mkNV (mkV32 s) ; oper v_besch35 : Str -> V = \s -> mkNV (mkV35 s) ;
oper v_besch33 : Str -> VerbeN = \s -> mkNV (mkV33 s) ; oper v_besch36 : Str -> V = \s -> mkNV (mkV36 s) ;
oper v_besch34 : Str -> VerbeN = \s -> mkNV (mkV34 s) ; oper v_besch37 : Str -> V = \s -> mkNV (mkV37 s) ;
oper v_besch35 : Str -> VerbeN = \s -> mkNV (mkV35 s) ; oper v_besch38 : Str -> V = \s -> mkNV (mkV38 s) ;
oper v_besch36 : Str -> VerbeN = \s -> mkNV (mkV36 s) ; oper v_besch39 : Str -> V = \s -> mkNV (mkV39 s) ;
oper v_besch37 : Str -> VerbeN = \s -> mkNV (mkV37 s) ; oper v_besch40 : Str -> V = \s -> mkNV (mkV40 s) ;
oper v_besch38 : Str -> VerbeN = \s -> mkNV (mkV38 s) ; oper v_besch41 : Str -> V = \s -> mkNV (mkV41 s) ;
oper v_besch39 : Str -> VerbeN = \s -> mkNV (mkV39 s) ; oper v_besch42 : Str -> V = \s -> mkNV (mkV42 s) ;
oper v_besch40 : Str -> VerbeN = \s -> mkNV (mkV40 s) ; oper v_besch43 : Str -> V = \s -> mkNV (mkV43 s) ;
oper v_besch41 : Str -> VerbeN = \s -> mkNV (mkV41 s) ; oper v_besch44 : Str -> V = \s -> mkNV (mkV44 s) ;
oper v_besch42 : Str -> VerbeN = \s -> mkNV (mkV42 s) ; oper v_besch45 : Str -> V = \s -> mkNV (mkV45 s) ;
oper v_besch43 : Str -> VerbeN = \s -> mkNV (mkV43 s) ; oper v_besch46 : Str -> V = \s -> mkNV (mkV46 s) ;
oper v_besch44 : Str -> VerbeN = \s -> mkNV (mkV44 s) ; oper v_besch47 : Str -> V = \s -> mkNV (mkV47 s) ;
oper v_besch45 : Str -> VerbeN = \s -> mkNV (mkV45 s) ; oper v_besch48 : Str -> V = \s -> mkNV (mkV48 s) ;
oper v_besch46 : Str -> VerbeN = \s -> mkNV (mkV46 s) ; oper v_besch49 : Str -> V = \s -> mkNV (mkV49 s) ;
oper v_besch47 : Str -> VerbeN = \s -> mkNV (mkV47 s) ; oper v_besch50 : Str -> V = \s -> mkNV (mkV50 s) ;
oper v_besch48 : Str -> VerbeN = \s -> mkNV (mkV48 s) ; oper v_besch51 : Str -> V = \s -> mkNV (mkV51 s) ;
oper v_besch49 : Str -> VerbeN = \s -> mkNV (mkV49 s) ; oper v_besch52 : Str -> V = \s -> mkNV (mkV52 s) ;
oper v_besch50 : Str -> VerbeN = \s -> mkNV (mkV50 s) ; oper v_besch53 : Str -> V = \s -> mkNV (mkV53 s) ;
oper v_besch51 : Str -> VerbeN = \s -> mkNV (mkV51 s) ; oper v_besch54 : Str -> V = \s -> mkNV (mkV54 s) ;
oper v_besch52 : Str -> VerbeN = \s -> mkNV (mkV52 s) ; oper v_besch55 : Str -> V = \s -> mkNV (mkV55 s) ;
oper v_besch53 : Str -> VerbeN = \s -> mkNV (mkV53 s) ; oper v_besch56 : Str -> V = \s -> mkNV (mkV56 s) ;
oper v_besch54 : Str -> VerbeN = \s -> mkNV (mkV54 s) ; oper v_besch57 : Str -> V = \s -> mkNV (mkV57 s) ;
oper v_besch55 : Str -> VerbeN = \s -> mkNV (mkV55 s) ; oper v_besch58 : Str -> V = \s -> mkNV (mkV58 s) ;
oper v_besch56 : Str -> VerbeN = \s -> mkNV (mkV56 s) ; oper v_besch59 : Str -> V = \s -> mkNV (mkV59 s) ;
oper v_besch57 : Str -> VerbeN = \s -> mkNV (mkV57 s) ; oper v_besch60 : Str -> V = \s -> mkNV (mkV60 s) ;
oper v_besch58 : Str -> VerbeN = \s -> mkNV (mkV58 s) ; oper v_besch61 : Str -> V = \s -> mkNV (mkV61 s) ;
oper v_besch59 : Str -> VerbeN = \s -> mkNV (mkV59 s) ; oper v_besch62 : Str -> V = \s -> mkNV (mkV62 s) ;
oper v_besch60 : Str -> VerbeN = \s -> mkNV (mkV60 s) ; --oper v_besch63 : Str -> V = \s -> mkNV (mkV63 s) ;
oper v_besch61 : Str -> VerbeN = \s -> mkNV (mkV61 s) ; oper v_besch64 : Str -> V = \s -> mkNV (mkV64 s) ;
oper v_besch62 : Str -> VerbeN = \s -> mkNV (mkV62 s) ; oper v_besch65 : Str -> V = \s -> mkNV (mkV65 s) ;
--oper v_besch63 : Str -> VerbeN = \s -> mkNV (mkV63 s) ; oper v_besch66 : Str -> V = \s -> mkNV (mkV66 s) ;
oper v_besch64 : Str -> VerbeN = \s -> mkNV (mkV64 s) ; oper v_besch67 : Str -> V = \s -> mkNV (mkV67 s) ;
oper v_besch65 : Str -> VerbeN = \s -> mkNV (mkV65 s) ; oper v_besch68 : Str -> V = \s -> mkNV (mkV68 s) ;
oper v_besch66 : Str -> VerbeN = \s -> mkNV (mkV66 s) ; oper v_besch69 : Str -> V = \s -> mkNV (mkV69 s) ;
oper v_besch67 : Str -> VerbeN = \s -> mkNV (mkV67 s) ; oper v_besch70 : Str -> V = \s -> mkNV (mkV70 s) ;
oper v_besch68 : Str -> VerbeN = \s -> mkNV (mkV68 s) ; oper v_besch71 : Str -> V = \s -> mkNV (mkV71 s) ;
oper v_besch69 : Str -> VerbeN = \s -> mkNV (mkV69 s) ; oper v_besch72 : Str -> V = \s -> mkNV (mkV72 s) ;
oper v_besch70 : Str -> VerbeN = \s -> mkNV (mkV70 s) ; oper v_besch73 : Str -> V = \s -> mkNV (mkV73 s) ;
oper v_besch71 : Str -> VerbeN = \s -> mkNV (mkV71 s) ; oper v_besch74 : Str -> V = \s -> mkNV (mkV74 s) ;
oper v_besch72 : Str -> VerbeN = \s -> mkNV (mkV72 s) ; --oper v_besch75 : Str -> V = \s -> mkNV (mkV75 s) ;
oper v_besch73 : Str -> VerbeN = \s -> mkNV (mkV73 s) ; oper v_besch76 : Str -> V = \s -> mkNV (mkV76 s) ;
oper v_besch74 : Str -> VerbeN = \s -> mkNV (mkV74 s) ; oper v_besch77 : Str -> V = \s -> mkNV (mkV77 s) ;
--oper v_besch75 : Str -> VerbeN = \s -> mkNV (mkV75 s) ; oper v_besch78 : Str -> V = \s -> mkNV (mkV78 s) ;
oper v_besch76 : Str -> VerbeN = \s -> mkNV (mkV76 s) ; oper v_besch79 : Str -> V = \s -> mkNV (mkV79 s) ;
oper v_besch77 : Str -> VerbeN = \s -> mkNV (mkV77 s) ; oper v_besch80 : Str -> V = \s -> mkNV (mkV80 s) ;
oper v_besch78 : Str -> VerbeN = \s -> mkNV (mkV78 s) ; oper v_besch81 : Str -> V = \s -> mkNV (mkV81 s) ;
oper v_besch79 : Str -> VerbeN = \s -> mkNV (mkV79 s) ; oper v_besch82 : Str -> V = \s -> mkNV (mkV82 s) ;
oper v_besch80 : Str -> VerbeN = \s -> mkNV (mkV80 s) ; oper v_besch83 : Str -> V = \s -> mkNV (mkV83 s) ;
oper v_besch81 : Str -> VerbeN = \s -> mkNV (mkV81 s) ; oper v_besch84 : Str -> V = \s -> mkNV (mkV84 s) ;
oper v_besch82 : Str -> VerbeN = \s -> mkNV (mkV82 s) ; oper v_besch85 : Str -> V = \s -> mkNV (mkV85 s) ;
oper v_besch83 : Str -> VerbeN = \s -> mkNV (mkV83 s) ; oper v_besch86 : Str -> V = \s -> mkNV (mkV86 s) ;
oper v_besch84 : Str -> VerbeN = \s -> mkNV (mkV84 s) ; oper v_besch87 : Str -> V = \s -> mkNV (mkV87 s) ;
oper v_besch85 : Str -> VerbeN = \s -> mkNV (mkV85 s) ; oper v_besch88 : Str -> V = \s -> mkNV (mkV88 s) ;
oper v_besch86 : Str -> VerbeN = \s -> mkNV (mkV86 s) ; oper v_besch89 : Str -> V = \s -> mkNV (mkV89 s) ;
oper v_besch87 : Str -> VerbeN = \s -> mkNV (mkV87 s) ; oper v_besch90 : Str -> V = \s -> mkNV (mkV90 s) ;
oper v_besch88 : Str -> VerbeN = \s -> mkNV (mkV88 s) ; oper v_besch91 : Str -> V = \s -> mkNV (mkV91 s) ;
oper v_besch89 : Str -> VerbeN = \s -> mkNV (mkV89 s) ; oper v_besch92 : Str -> V = \s -> mkNV (mkV92 s) ;
oper v_besch90 : Str -> VerbeN = \s -> mkNV (mkV90 s) ; oper v_besch93 : Str -> V = \s -> mkNV (mkV93 s) ;
oper v_besch91 : Str -> VerbeN = \s -> mkNV (mkV91 s) ; oper v_besch94 : Str -> V = \s -> mkNV (mkV94 s) ;
oper v_besch92 : Str -> VerbeN = \s -> mkNV (mkV92 s) ; oper v_besch95 : Str -> V = \s -> mkNV (mkV95 s) ;
oper v_besch93 : Str -> VerbeN = \s -> mkNV (mkV93 s) ; oper v_besch96 : Str -> V = \s -> mkNV (mkV96 s) ;
oper v_besch94 : Str -> VerbeN = \s -> mkNV (mkV94 s) ; oper v_besch97 : Str -> V = \s -> mkNV (mkV97 s) ;
oper v_besch95 : Str -> VerbeN = \s -> mkNV (mkV95 s) ; oper v_besch98 : Str -> V = \s -> mkNV (mkV98 s) ;
oper v_besch96 : Str -> VerbeN = \s -> mkNV (mkV96 s) ; oper v_besch99 : Str -> V = \s -> mkNV (mkV99 s) ;
oper v_besch97 : Str -> VerbeN = \s -> mkNV (mkV97 s) ; oper v_besch100 : Str -> V = \s -> mkNV (mkV100 s) ;
oper v_besch98 : Str -> VerbeN = \s -> mkNV (mkV98 s) ; oper v_besch101 : Str -> V = \s -> mkNV (mkV101 s) ;
oper v_besch99 : Str -> VerbeN = \s -> mkNV (mkV99 s) ; oper v_besch102 : Str -> V = \s -> mkNV (mkV102 s) ;
oper v_besch100 : Str -> VerbeN = \s -> mkNV (mkV100 s) ; oper v_besch103 : Str -> V = \s -> mkNV (mkV103 s) ;
oper v_besch101 : Str -> VerbeN = \s -> mkNV (mkV101 s) ; oper v_besch104 : Str -> V = \s -> mkNV (mkV104 s) ;
oper v_besch102 : Str -> VerbeN = \s -> mkNV (mkV102 s) ; oper v_besch105 : Str -> V = \s -> mkNV (mkV105 s) ;
oper v_besch103 : Str -> VerbeN = \s -> mkNV (mkV103 s) ; oper v_besch106 : Str -> V = \s -> mkNV (mkV106 s) ;
oper v_besch104 : Str -> VerbeN = \s -> mkNV (mkV104 s) ; --oper v_besch107 : Str -> V = \s -> mkNV (mkV107 s) ;
oper v_besch105 : Str -> VerbeN = \s -> mkNV (mkV105 s) ; oper v_besch108 : Str -> V = \s -> mkNV (mkV108 s) ;
oper v_besch106 : Str -> VerbeN = \s -> mkNV (mkV106 s) ; oper v_besch109 : Str -> V = \s -> mkNV (mkV109 s) ;
--oper v_besch107 : Str -> VerbeN = \s -> mkNV (mkV107 s) ; oper v_besch110 : Str -> V = \s -> mkNV (mkV110 s) ;
oper v_besch108 : Str -> VerbeN = \s -> mkNV (mkV108 s) ; --oper v_besch111 : Str -> V = \s -> mkNV (mkV111 s) ;
oper v_besch109 : Str -> VerbeN = \s -> mkNV (mkV109 s) ; oper v_besch112 : Str -> V = \s -> mkNV (mkV112 s) ;
oper v_besch110 : Str -> VerbeN = \s -> mkNV (mkV110 s) ; oper v_besch113 : Str -> V = \s -> mkNV (mkV113 s) ;
--oper v_besch111 : Str -> VerbeN = \s -> mkNV (mkV111 s) ; --oper v_besch114 : Str -> V = \s -> mkNV (mkV114 s) ;
oper v_besch112 : Str -> VerbeN = \s -> mkNV (mkV112 s) ; oper v_besch115 : Str -> V = \s -> mkNV (mkV115 s) ;
oper v_besch113 : Str -> VerbeN = \s -> mkNV (mkV113 s) ; oper v_besch116 : Str -> V = \s -> mkNV (mkV116 s) ;
--oper v_besch114 : Str -> VerbeN = \s -> mkNV (mkV114 s) ; oper v_besch117 : Str -> V = \s -> mkNV (mkV117 s) ;
oper v_besch115 : Str -> VerbeN = \s -> mkNV (mkV115 s) ; oper v_besch118 : Str -> V = \s -> mkNV (mkV118 s) ;
oper v_besch116 : Str -> VerbeN = \s -> mkNV (mkV116 s) ; oper v_besch119 : Str -> V = \s -> mkNV (mkV119 s) ;
oper v_besch117 : Str -> VerbeN = \s -> mkNV (mkV117 s) ; oper v_besch120 : Str -> V = \s -> mkNV (mkV120 s) ;
oper v_besch118 : Str -> VerbeN = \s -> mkNV (mkV118 s) ; oper v_besch121 : Str -> V = \s -> mkNV (mkV121 s) ;
oper v_besch119 : Str -> VerbeN = \s -> mkNV (mkV119 s) ; oper v_besch122 : Str -> V = \s -> mkNV (mkV122 s) ;
oper v_besch120 : Str -> VerbeN = \s -> mkNV (mkV120 s) ; oper v_besch123 : Str -> V = \s -> mkNV (mkV123 s) ;
oper v_besch121 : Str -> VerbeN = \s -> mkNV (mkV121 s) ; oper v_besch124 : Str -> V = \s -> mkNV (mkV124 s) ;
oper v_besch122 : Str -> VerbeN = \s -> mkNV (mkV122 s) ; oper v_besch125 : Str -> V = \s -> mkNV (mkV125 s) ;
oper v_besch123 : Str -> VerbeN = \s -> mkNV (mkV123 s) ; oper v_besch126 : Str -> V = \s -> mkNV (mkV126 s) ;
oper v_besch124 : Str -> VerbeN = \s -> mkNV (mkV124 s) ; oper v_besch127 : Str -> V = \s -> mkNV (mkV127 s) ;
oper v_besch125 : Str -> VerbeN = \s -> mkNV (mkV125 s) ; oper v_besch128 : Str -> V = \s -> mkNV (mkV128 s) ;
oper v_besch126 : Str -> VerbeN = \s -> mkNV (mkV126 s) ; oper v_besch129 : Str -> V = \s -> mkNV (mkV129 s) ;
oper v_besch127 : Str -> VerbeN = \s -> mkNV (mkV127 s) ; oper v_besch130 : Str -> V = \s -> mkNV (mkV130 s) ;
oper v_besch128 : Str -> VerbeN = \s -> mkNV (mkV128 s) ; oper v_besch131 : Str -> V = \s -> mkNV (mkV131 s) ;
oper v_besch129 : Str -> VerbeN = \s -> mkNV (mkV129 s) ; oper v_besch132 : Str -> V = \s -> mkNV (mkV132 s) ;
oper v_besch130 : Str -> VerbeN = \s -> mkNV (mkV130 s) ; oper v_besch133 : Str -> V = \s -> mkNV (mkV133 s) ;
oper v_besch131 : Str -> VerbeN = \s -> mkNV (mkV131 s) ; oper v_besch134 : Str -> V = \s -> mkNV (mkV134 s) ;
oper v_besch132 : Str -> VerbeN = \s -> mkNV (mkV132 s) ; oper v_besch135 : Str -> V = \s -> mkNV (mkV135 s) ;
oper v_besch133 : Str -> VerbeN = \s -> mkNV (mkV133 s) ; oper v_besch136 : Str -> V = \s -> mkNV (mkV136 s) ;
oper v_besch134 : Str -> VerbeN = \s -> mkNV (mkV134 s) ; oper v_besch137 : Str -> V = \s -> mkNV (mkV137 s) ;
oper v_besch135 : Str -> VerbeN = \s -> mkNV (mkV135 s) ; oper v_besch138 : Str -> V = \s -> mkNV (mkV138 s) ;
oper v_besch136 : Str -> VerbeN = \s -> mkNV (mkV136 s) ; oper v_besch139 : Str -> V = \s -> mkNV (mkV139 s) ;
oper v_besch137 : Str -> VerbeN = \s -> mkNV (mkV137 s) ; oper v_besch140 : Str -> V = \s -> mkNV (mkV140 s) ;
oper v_besch138 : Str -> VerbeN = \s -> mkNV (mkV138 s) ; oper v_besch141 : Str -> V = \s -> mkNV (mkV141 s) ;
oper v_besch139 : Str -> VerbeN = \s -> mkNV (mkV139 s) ; oper v_besch142 : Str -> V = \s -> mkNV (mkV142 s) ;
oper v_besch140 : Str -> VerbeN = \s -> mkNV (mkV140 s) ; oper v_besch143 : Str -> V = \s -> mkNV (mkV143 s) ;
oper v_besch141 : Str -> VerbeN = \s -> mkNV (mkV141 s) ; oper v_besch144 : Str -> V = \s -> mkNV (mkV144 s) ;
oper v_besch142 : Str -> VerbeN = \s -> mkNV (mkV142 s) ; oper v_have : V = mkNV (mkV1 "avea") ;
oper v_besch143 : Str -> VerbeN = \s -> mkNV (mkV143 s) ;
oper v_besch144 : Str -> VerbeN = \s -> mkNV (mkV144 s) ;
oper v_have : VerbeN = mkNV (mkV1 "avea") ;
} }

116
lib/src/romanian/CatRon.gf
View File

@@ -15,98 +15,85 @@ concrete CatRon of Cat =
S = {s : Mood => Str} ; S = {s : Mood => Str} ;
QS = {s : QForm => Str} ; QS = {s : QForm => Str} ;
RS = {s : Mood => Agr => Str ; c : NCase} ; RS = {s : Mood => Agr => Str ; c : NCase} ;
SSlash = { SSlash = {s : AAgr => Mood => Str ;
s : AAgr => Mood => Str ; c2 : Compl} ;
c2 : Compl
} ;
-- Sentence -- Sentence
Cl = {s : Direct => RTense => Anteriority => Polarity => Mood => Str} ; Cl = {s : Direct => RTense => Anteriority => Polarity => Mood => Str} ;
ClSlash = { ClSlash = {s : Bool => AAgr => Direct => RTense => Anteriority => Polarity => Mood => Str ;
s : AAgr => Direct => RTense => Anteriority => Polarity => Mood => Str ; c2 : Compl} ;
c2 : Compl
} ;
Imp = {s : Polarity => ImpForm => Gender => Str} ; Imp = {s : Polarity => ImpForm => Gender => Str} ;
-- Relative -- Relative
RCl = { RCl = {s : Agr => RTense => Anteriority => Polarity => Mood => Str ;
s : Agr => RTense => Anteriority => Polarity => Mood => Str ; c : NCase } ;
c : NCase
} ;
RP = {s : AAgr => NCase => Str ; a : AAgr ; hasAgr : Bool; hasRef : Bool} ; RP = {s : AAgr => NCase => Str ; a : AAgr ; hasAgr : Bool; hasRef : Bool} ;
-- Verb -- Verb
VP = { VP = ResRon.VerbPhrase ;
s : VForm => Str ;
isRefl : Agr => RAgr ; VPSlash = ResRon.VerbPhrase ** {c2 : Compl; needAgr : Bool; needClit : Bool} ;
nrClit : VClit ;
isFemSg : Bool ; -- needed for the correct placement of the Accusative clitic
neg : Polarity => Str ; -- ne-pas not needed - just "nu"
clAcc : RAgr ; -- le/se -- not needed if they are used in the noun
clDat : RAgr ; -- lui -- not needed if they are used in the noun
comp : Agr => Str ; -- content(e) ; à ma mère ; hier -
ext : Polarity => Str ; -- que je dors / que je dorme - so that it always comes after all the complements
} ;
VPSlash = VP ** {c2 : Compl; needAgr : Bool} ;
-- Comp = {s : Agr => Str} ;
-- Adjective -- Adjective
AP = {s : AForm => Str ; isPre : Bool} ; AP = {s : AForm => Str ; isPre : Bool} ;
-- Noun -- Noun
lincat
CN = {s : Number => Species => ACase => Str; g : NGender; a : Animacy } ; CN = {s : Number => Species => ACase => Str; g : NGender; a : Animacy } ;
Pron = {s : NCase => Str ; Pron = {s : NCase => Str ;
c1, c2 : Clitics => Str ; c1, c2 : Clitics => Str ;
a : Agr ; a : Agr ;
poss : Number => Gender => Str poss : Number => Gender => Str } ;
} ;
NP = NounPhrase ; NP = NounPhrase ;
--NCase because of the pronoun
Det = {s : Gender => NCase => Str ; n : Number ; Det = {s : Gender => NCase => Str ; n : Number ;
isDef : Bool ; isDef : Bool ;
post : Gender => NCase => Str ; post : Gender => NCase => Str ;
sp : Gender => NCase => Str ; -- pentru Lexicon e aceeasi forma totusi ! posibil sp : Gender => NCase => Str ;
-- probabil pentru ca orice Quant -> Det size : Str ; --because of the numerals
size : Str ; --because of the numerals hasRef : Bool };
hasRef : Bool
};
Predet = {s : AAgr => ACase => Str ; c : NCase} ; Predet = {s : AAgr => ACase => Str ; c : NCase} ;
-- Art = {s : Bool => Number => Gender => NCase => Str ; isDef : Bool } ;
Quant = { Quant = {s : Bool => Number => Gender => ACase => Str ;
s : Bool => Number => Gender => ACase => Str ; sp : Number => Gender => ACase => Str ;
sp : Number => Gender => ACase => Str ; -- diferente si in Lexicon, ex : acesta, aceasta isDef : Bool ;
isDef : Bool ; isPost : Bool ;
isPost : Bool ; hasRef : Bool };
hasRef : Bool
};
-- Numeral -- Numeral
Numeral = {s : ACase => CardOrd => NumF => Str ; Numeral = {s : ACase => CardOrd => NumF => Str ;
sp : ACase => CardOrd => NumF => Str ; size : Size } ; sp : ACase => CardOrd => NumF => Str ; size : Size } ;
Digits = {s : CardOrd => Str ; n : Size ; isDig : Bool} ; Digits = {s : CardOrd => Str ; n : Size ; isDig : Bool} ;
Num = {s : Gender => Str ; sp : Gender => Str ; Num = {s : Gender => Str ; sp : Gender => Str ;
isNum : Bool ; n : Number; size : Str } ; isNum : Bool ; n : Number; size : Str } ;
Card = {s : Gender => Str ; sp : Gender => Str ; Card = {s : Gender => Str ; sp : Gender => Str ;
n : Number; size : Size} ; n : Number; size : Size} ;
Ord = {s : Number => Gender => NCase => Str; isPre : Bool} ; Ord = {s : Number => Gender => NCase => Str; isPre : Bool} ;
--Question --Question
-- Question
QCl = {s : RTense => Anteriority => Polarity => QForm => Str} ; QCl = {s : RTense => Anteriority => Polarity => QForm => Str} ;
IComp = {s : AAgr => Str} ; IComp = {s : AAgr => Str} ;
IDet = {s : Gender => ACase => Str ; n : Number} ; IDet = {s : Gender => ACase => Str ; n : Number} ;
IQuant = {s : Number => Gender => ACase => Str } ; IQuant = {s : Number => Gender => ACase => Str } ;
IP = {s : NCase => Str ; a : AAgr ; hasRef : Bool} ; IP = {s : NCase => Str ; a : AAgr ; hasRef : Bool} ;
-- Structural -- Structural
Conj = {s1,s2 : Str ; n : Number} ; Conj = {s1,s2 : Str ; n : Number} ;
@@ -114,25 +101,37 @@ concrete CatRon of Cat =
Prep = {s : Str ; c : NCase ; isDir : PrepDir ; needIndef : Bool ; prepDir : Str} ; Prep = {s : Str ; c : NCase ; isDir : PrepDir ; needIndef : Bool ; prepDir : Str} ;
-- Open lexical classes, e.g. Lexicon -- Open lexical classes, e.g. Lexicon
--Verb = {s : VForm => Str } ;
V ={s : VForm => Str ; isRefl : Agr => RAgr; nrClit : VClit} ; V = ResRon.Verb;
VQ, VA = V ;
V2,V2S, V2Q = V ** {c2 : Compl} ; VQ, VA = ResRon.Verb ;
V3,V2A, V2V = V ** {c2,c3 : Compl} ;
VS = V ** {m : Polarity => Mood} ; V2,V2S, V2Q = ResRon.Verb ** {c2 : Compl} ;
VV = V ** {c2 : Agr => Str} ;
V3,V2A, V2V = ResRon.Verb ** {c2,c3 : Compl} ;
VS = ResRon.Verb ** {m : Polarity => Mood} ;
VV = ResRon.Verb ** {c2 : Agr => Str} ;
A = {s : AForm => Str ; isPre : Bool} ; A = {s : AForm => Str ; isPre : Bool} ;
A2 = {s : AForm => Str ; c2 : Compl} ; A2 = {s : AForm => Str ; c2 : Compl} ;
N = Noun ; N = Noun ;
N2 = Noun ** {c2 : Compl} ; N2 = Noun ** {c2 : Compl} ;
N3 = Noun ** {c2,c3 : Compl} ; N3 = Noun ** {c2,c3 : Compl} ;
PN = {s : NCase => Str ; g : Gender ; n : Number; a : Animacy} ; PN = {s : NCase => Str ; g : Gender ; n : Number; a : Animacy} ;
Comp = {s : Agr => Str} ; Comp = {s : Agr => Str} ;
Temp = {s : Str ; t : RTense ; a : Anteriority} ; Temp = {s : Str ; t : RTense ; a : Anteriority} ;
Tense = {s : Str ; t : RTense} ; Tense = {s : Str ; t : RTense} ;
lin lin
TTAnt t a = {s = a.s ++ t.s ; a = a.a ; t = t.t} ; TTAnt t a = {s = a.s ++ t.s ; a = a.a ; t = t.t} ;
TPres = {s = []} ** {t = RPres} ; TPres = {s = []} ** {t = RPres} ;
@@ -146,6 +145,7 @@ concrete CatRon of Cat =
oper oper
aagr : Gender -> Number -> AAgr = \g,n -> aagr : Gender -> Number -> AAgr = \g,n ->
{g = g ; n = n} ; {g = g ; n = n} ;
agrP3 : Gender -> Number -> Agr = \g,n -> agrP3 : Gender -> Number -> Agr = \g,n ->
aagr g n ** {p = P3} ; aagr g n ** {p = P3} ;
@@ -162,10 +162,8 @@ oper
} ; } ;
--Conjuctions --Conjuctions
conjThan : Str = "decât" ; conjThan : Str = "decât" ;
conjThat : Str = "cã" ; conjThat : Str = "cã" ;
} }

6
lib/src/romanian/GrammarRon.gf
View File

@@ -5,15 +5,15 @@ concrete GrammarRon of Grammar =
VerbRon, VerbRon,
AdjectiveRon, AdjectiveRon,
AdverbRon, AdverbRon,
NumeralRon, NumeralRonn,
SentenceRon, SentenceRon,
IdiomRon, IdiomRon,
QuestionRon, QuestionRon,
RelativeRon, RelativeRon,
ConjunctionRon, ConjunctionRon,
PhraseRon, PhraseRon,
TextX - [Temp,TTAnt,Tense,TPres,TPast,TFut,TCond], Coordination, TextX - [Temp,TTAnt,Tense,TPres,TPast,TFut,TCond],
Prelude, MorphoRon, BeschRon, Prelude, MorphoRon, Coordination,
StructuralRon StructuralRon
** { ** {

33
lib/src/romanian/IdiomRon.gf
View File

@@ -1,4 +1,4 @@
incomplete concrete IdiomRon of Idiom = concrete IdiomRon of Idiom =
-- CatRon ** open (P = ParamX), MorphoRon, ParadigmsRon,Prelude -- CatRon ** open (P = ParamX), MorphoRon, ParadigmsRon,Prelude
CatRon ** open Prelude, ResRon CatRon ** open Prelude, ResRon
in { in {
@@ -8,36 +8,35 @@ in {
lin lin
ImpersCl vp = mkClause "" True (agrP3 Masc Sg) vp ; ImpersCl vp = mkClause "" (agrP3 Masc Sg) vp ;
GenericCl vp = mkClause "" True (agrP3 Masc Sg) vp ; -- an exact correspondent does not exist !
GenericCl vp = mkClause "" (agrP3 Masc Sg) vp ; -- an exact correspondent does not exist !
ExistNP np = ExistNP np =
mkClause "" True np.a (insertSimpObj (\\ag => (np.s ! No ).comp) (UseV copula)) ; mkClause "" np.a (insertSimpObj (\\ag => (np.s ! No ).comp) copula) ;
-- v_besch20 "exista" -- v_besch20 "exista"
ExistIP ip = { ExistIP ip = {
s = \\t,a,p,_ => s = \\t,a,p,_ =>
ip.s ! No ++ ip.s ! No ++
(mkClause "" True (agrP3 (ip.a.g) (ip.a.n)) (mkClause "" (agrP3 (ip.a.g) (ip.a.n))
(UseV copula)).s copula).s
! DDir ! t ! a ! p ! Indic } ; ! DDir ! t ! a ! p ! Indic } ;
CleftNP np rs = mkClause "" True np.a CleftNP np rs = mkClause "" np.a
(insertSimpObj (\\_ => rs.s ! Indic ! np.a) (insertSimpObj (\\_ => rs.s ! Indic ! np.a)
(insertSimpObj (\\_ => (np.s ! rs.c).comp) (predV copula))) ; (insertSimpObj (\\_ => (np.s ! rs.c).comp) copula)) ;
--need adverb for --need adverb for
CleftAdv ad s = mkClause "" True (agrP3 Masc Sg)
CleftAdv ad s = mkClause "" (agrP3 Masc Sg)
(insertSimpObj (\\_ => conjThat ++ s.s ! Indic) (insertSimpObj (\\_ => conjThat ++ s.s ! Indic)
(insertSimpObj (\\_ => ad.s) (predV copula))) ; (insertSimpObj (\\_ => ad.s) copula)) ;
ProgrVP vp = vp; -- for the moment, since there is no particular way to express continuous action, except for the imperfect, which wouldn't work for all tenses ProgrVP vp = vp; -- for the moment, since there is no particular way to express continuous action, except for the imperfect, which wouldn't work for all tenses
{-
ImpPl1 vpr = let vp = useVP vpr in {s = ImpPl1 vp = let a = {p = P1 ; n = Pl ; g = Masc} in
(mkImperative False P1 vp).s ! Pos ! {n = Pl ; g = Masc} --- fem { s = "sã" ++ (flattenSimpleClitics vp.nrClit vp.clAcc vp.clDat (vp.isRefl ! a)) ++ conjVP vp a ++vp.comp ! a ++ vp.ext ! Pos };
} ;
-- insert clitics here also
-}
} }

2
lib/src/romanian/LangRon.gf
View File

@@ -1,4 +1,4 @@
--# -path=.:../abstract:../common:../prelude --# -path=.:../romance:../abstract:../common
concrete LangRon of Lang = concrete LangRon of Lang =
GrammarRon, GrammarRon,

97
lib/src/romanian/MorphoRon.gf
View File

@@ -19,7 +19,7 @@ case <g,n,a> of
{ <Masc,Sg,ANomAcc> => case last bun of { <Masc,Sg,ANomAcc> => case last bun of
{ "u" => bun + "l"; { "u" => bun + "l";
"e" => bun + "le"; "e" => bun + "le";
"ã" => init bun + "a"; "ã" => bun + "l";
_ => bun + "ul" _ => bun + "ul"
}; };
<Masc,Sg,AGenDat> => case last bun of <Masc,Sg,AGenDat> => case last bun of
@@ -57,41 +57,11 @@ case <g,n,a> of
<Fem,Pl,_> => buni + "lor" <Fem,Pl,_> => buni + "lor"
}; };
--Undefined article (proclitical) --
--we keep the non-articled form of the noun and glue it with the article on syntactical level
oper artUndef : Gender -> Number -> NCase -> Str = \g,n,a ->
case <g,n,a> of
{<Masc,Sg,No> => "un"; <Masc,Sg,Ac> => "un" ; <Masc,Sg,Ge> => "unui"; <Masc,Sg,Da> => "unui" ;<_,_,Vo> => "" ;
<_,Pl,No> => "niºte"; <_,Pl,Ac> => "niºte"; <_,Pl,Da> => "unor"; <_,Pl,Ge> => "unor" ;
<Fem,Sg,No> => "o"; <Fem,Sg,Ac> => "o"; <Fem,Sg,Da> => "unei"; <Fem,Sg,Ge> => "unei"
};
--Articles
--possesive article
-- used for Cardinals and for Genitive case
oper artPos : Gender -> Number -> ACase -> Str = \g,n,c ->
case <g,n,c> of
{ <Masc,Sg,AGenDat> => "alui"; <Masc,Sg,_> => "al";
<Masc,Pl,AGenDat> => "alor"; <Masc,Pl,_> => "ai";
<Fem,Sg,AGenDat> => "alei"; <Fem,Sg,_> => "a";
<Fem,Pl,AGenDat> => "ale"; <Fem,Pl,_> => "ale"
};
--demonstrative article
-- used as Determined article in order to emphasise on the noun/adjective, and for Dative/Genitive for of ordinals
oper artDem : Gender -> Number -> ACase -> Str = \g,n,c ->
case <g,n,c> of
{<Masc,Sg,ANomAcc> => "cel"; <Masc,Pl,ANomAcc> => "cei"; <Masc,Sg,AGenDat> => "celui";
<Fem,Sg,ANomAcc> => "cea"; <Fem,Pl,ANomAcc> => "cele"; <Fem,Sg,AGenDat> => "celei";
<_,Pl,AGenDat> => "celor";
<Masc,Sg,AVoc> => "cel";
<Masc,Pl,AVoc> => "cei"; <Fem,Sg,AVoc> => "cea"; <Fem,Pl,AVoc> => "cele"
};
--flexion forms of a noun without article --flexion forms of a noun without article
@@ -541,7 +511,7 @@ mkSpecMut : Str -> Adj = \s ->
-- Gerund - 1 form -- Gerund - 1 form
-- 2nd person Singular form for Imperative - 1 form -- 2nd person Singular form for Imperative - 1 form
Verbe : Type = { s : VForm => Str};
verbAffixes : verbAffixes :
Str-> (a,b,c,d: Number => Person => Str) -> Str -> Adj -> Str -> Str -> Verbe = Str-> (a,b,c,d: Number => Person => Str) -> Str -> Adj -> Str -> Str -> Verbe =
@@ -562,7 +532,7 @@ mkSpecMut : Str -> Adj = \s ->
} in } in
{s = t}; {s = t};
{-
-- syntactical verb : -- syntactical verb :
-- obtains all the verb forms present in Romanian, based on the primitive forms found in Verbe -- obtains all the verb forms present in Romanian, based on the primitive forms found in Verbe
@@ -605,25 +575,8 @@ table {
TPPasse g n a d => vb.s ! (PPasse g n a d) TPPasse g n a d => vb.s ! (PPasse g n a d)
}; };
-- auxiliary for Past Composite (to have - as auxiliary) : -- auxiliary for Past Composite (to have - as auxiliary) :
-}
pComp : Number => Person => Str = table {Sg => table {P1 => "am" ; P2 => "ai" ; P3 => "a"} ;
Pl => table {P1 => "am" ; P2 => "aþi"; P3 => "au"}
};
-- auxiliary for Future Simple :
pFut : Number => Person => Str = table {Sg => table {P1 => "voi" ; P2 => "vei" ; P3 => "va"} ;
Pl => table {P1 => "vom" ; P2 => "veþi"; P3 => "vor"}
};
--auxiliary for Condional Present :
pCond : Number => Person => Str = table {Sg => table {P1 => "aº" ; P2 => "ai" ; P3 => "ar"} ;
Pl => table {P1 => "am" ; P2 => "aþi"; P3 => "ar"}
};
-- make Reflexive verbe : ? with variants ?
-- syntactical category of reflexive verbs based on the primitive forms in Verbe
-- reflexive pronouns - full form -- reflexive pronouns - full form
@@ -2357,7 +2310,7 @@ in
verbAffixes trebui (mkFromAffix root affixSgGr411 affixPlGr411) verbAffixes trebui (mkFromAffix root affixSgGr411 affixPlGr411)
(mkFromAffix root affixSgI4 affixPlI4) (mkFromAffix root affixSgPS8 affixPlPS8) (mkFromAffix root affixSgI4 affixPlI4) (mkFromAffix root affixSgPS8 affixPlPS8)
(mkFromAffix root affixSgPP8 affixPlPP8) (root +"iascã") (mkAdjReg (root + "it")) (mkFromAffix root affixSgPP8 affixPlPP8) (root +"iascã") (mkAdjReg (root + "it"))
(root + "ind") nonExist ; (root + "ind") "" ;
--subGroup 12 --subGroup 12
mkV141 : Str -> Verbe = \uri -> mkV141 : Str -> Verbe = \uri ->
@@ -2410,47 +2363,7 @@ verbAffixes avea (mkTab root "am" "ai" "are" "au" affixPlGr21)
(mkFromAffix root affixSgPP2 affixPlPP2) "aibã" (mkAdjReg (root + "ut")) (mkFromAffix root affixSgPP2 affixPlPP2) "aibã" (mkAdjReg (root + "ut"))
(root + "ând") "ai" ; (root + "ând") "ai" ;
--to be :
{-
mkV2 : Str -> Verbe = \fi ->
let root = init fi ;
pres : Number => Person => Str = table {Sg => table {P1 => "sunt"; P2 => "eºti"; P3 => "este"};
Pl => table {P1 => "suntem"; P2 => "sunteþi"; P3 => "sunt"}
};
ps : Number => Person => Str = table {Sg => table {P1 => "fusei"; P2 => "fuseºi"; P3 => "fuse"};
Pl => table {P1 => "fuserãm"; P2 => "fuserãþi"; P3 => "fuserã"}
};
pp : Number => Person => Str = table {Sg => table {P1 => "fusesem"; P2 => "fuseseºi"; P3 => "fusese"};
Pl => table {P1 => "fuseserãm"; P2 => "fuseserãþi"; P3 => "fuseserã"}
}
in
verbAffixes fi pres (mkFromAffix "er" affixSgI affixPlI) ps pp
-}
--------------Reflexive pronouns
oper reflPron : Number -> Person -> ACase -> Str =
\n,p,c -> case <n,p,c> of
{<Sg,P1,AGenDat> => "mie" ; <Sg,P1,_> => "mine";
<Sg,P2,AGenDat> => "þie" ; <Sg,P2,_> => "tine";
<_,P3,AGenDat> => "sieºi" ; <_,P3,_> => "sine" ;
<Pl,P1,AGenDat> => "nouã" ; <Pl,P1,_> => "noi" ;
<Pl,P2,AGenDat> => "vouã" ; <Pl,P2,_> => "voi"
};
oper reflPronHard : Gender -> Number -> Person -> Str =
\g,n,p -> case <g,n,p> of
{<Masc,Sg,P1> => "însumi" ; <Fem,Sg,P1> => "însãmi";
<Masc,Sg,P2> => "însuþi" ; <Fem,Sg,P2> => "însãþi";
<Masc,Sg,P3> => "însuºi" ; <Fem,Sg,P3> => "însãºi";
<Masc,Pl,P1> => "înºine" ; <Fem,Pl,P1> => "însene";
<Masc,Pl,P2> => "înºivã"; <Fem,Pl,P2> => "înseva";
<Masc,Pl,P3> => "înºiºi"; <Fem,Pl,P3> => "înseºi"
};
}; };

26
lib/src/romanian/NounRon.gf
View File

@@ -1,4 +1,4 @@
incomplete concrete NounRon of Noun = concrete NounRon of Noun =
CatRon ** open ResRon,Prelude in { CatRon ** open ResRon,Prelude in {
flags optimize=all_subs ; flags optimize=all_subs ;
@@ -182,7 +182,7 @@ in {
sp = \\a => adn.s ++ num.sp ! a ; sp = \\a => adn.s ++ num.sp ! a ;
isNum = num.isNum ; n = num.n; size = num.size} ; isNum = num.isNum ; n = num.n; size = num.size} ;
OrdSuperl adj = {s = \\n,g,c => artDem g n (convCase c) ++ more_CAdv.s ++ adj.s ! AF g n Indef (convCase c); OrdSuperl adj = {s = \\n,g,c => artDem g n (convCase c) ++ "mai" ++ adj.s ! AF g n Indef (convCase c);
isPre = True; isPre = True;
}; };
@@ -298,25 +298,7 @@ in {
} ; } ;
oper };
agrGender : NGender -> Number -> Gender =
\ng,n ->
case <ng,n> of
{<NMasc,_> => Masc ;
<NFem,_> => Fem ;
<NNeut, Sg> => Masc ;
_ => Fem
};
oper getNumber : Size -> Number =
\n -> case n of
{sg => Sg;
_ => Pl };
oper getClit : Animacy -> Bool =
\a -> case a of
{Animate => True;
_ => False};
};

238
lib/src/romanian/NumeralRon.gf
View File

@@ -1,14 +1,14 @@
concrete NumeralRon of Numeral = CatRon ** concrete NumeralRon of Numeral = CatRon **
open MorphoRon, CatRon, Prelude in { open MorphoRon, CatRon, Prelude in {
param DForm = unit | teen | ten | teen_inf ; param DForm = unit | teen | ten | attr ;
param Place = indep | attr ;
lincat Digit = {s : CardOrd => DForm => Str ; size : Size} ;
lincat Sub10 = {s : CardOrd => DForm => Place => Str ; size : Size} ; lincat Digit = {s : NumF => CardOrd => DForm => Str ; size : Size} ;
lincat Sub100 = {s : CardOrd => NumF => Place => Str ; size : Size} ; lincat Sub10 = {s : NumF => CardOrd => DForm => Str ; size : Size} ;
lincat Sub1000 = {s : CardOrd => NumF => Place => Str ; size : Size} ; lincat Sub100 = {s : NumF => CardOrd => Str ; size : Size} ;
lincat Sub1000000 = { s : CardOrd => NumF => Place => Str; size : Size } ; lincat Sub1000 = {s : NumF => CardOrd => Str ; size : Size} ;
lincat Sub1000000 = { s : NumF => CardOrd => Str; size : Size } ;
@@ -21,9 +21,9 @@ oper mkOrdinalForm : Str -> Gender -> Str =
}; };
Fem => case two of Fem => case two of
{ x + ("ã"|"u") => x +"a"; { x + ("ã"|"u") => x +"a";
x + "ei" => two + "a"; x + "ie" => x +"ia";
x + "ii" => x + "ia" ; x + ("ii"|"îi") => x + "a" ;
x + "i" => x + "ea"; x + "i" => two + "a";
x + "ie" => x +"a" ; x + "ie" => x +"a" ;
_ => two +"a" _ => two +"a"
} }
@@ -34,8 +34,9 @@ oper mkOrdinal : Str -> Gender -> ACase -> Str =
\two, g, fl -> mkOrd (mkOrdinalForm two g) g fl; \two, g, fl -> mkOrd (mkOrdinalForm two g) g fl;
oper mkOrd : Str -> Gender -> ACase -> Str = oper mkOrd : Str -> Gender -> ACase -> Str =
\two, g, fl -> let cc = (artPos g Sg ANomAcc) ++ two \two, g, fl -> let cc = variants{(artPos g Sg ANomAcc)++ two ;
in (artDem g Sg ANomAcc) ++ "de-"+(artPos g Sg ANomAcc) ++ two
} in
case fl of case fl of
{ ANomAcc => cc ; { ANomAcc => cc ;
AGenDat => (artDem g Sg AGenDat)++"de-"+(artPos g Sg ANomAcc)++ two ; AGenDat => (artDem g Sg AGenDat)++"de-"+(artPos g Sg ANomAcc)++ two ;
@@ -44,29 +45,49 @@ oper mkOrd : Str -> Gender -> ACase -> Str =
oper mkNum : Str -> Str -> Str -> Str -> Digit = oper mkNum : Str -> Str -> Str -> Str -> Digit =
\two -> \twelve -> \twenty -> \doispe -> mkNumVSpc two twelve twelve twenty two doispe doispe (mkOrdinalForm two Masc) (mkOrdinalForm two Fem); \two -> \twelve -> \twenty -> \doispe -> mkNumVSpc two twelve twelve twenty two doispe doispe two (mkOrdinalForm two Fem);
oper mkNumVSpc : Str -> Str -> Str -> Str -> Str -> Str -> Str -> Str -> Str -> Digit = oper mkNumVSpc : Str -> Str -> Str -> Str -> Str -> Str -> Str -> Str -> Str -> Digit =
\two -> \twelve -> \douasprezece -> \twenty -> \dou -> \doispe -> \douaspe -> \doilea -> \doua -> \two -> \twelve -> \douasprezece -> \twenty -> \doua -> \doispe -> \douaspe -> \o -> \una->
{s = table { {s = table { Formal => table {
NCard Masc => table {unit => two ; teen => twelve ; NCard Masc => table {unit => two ; teen => twelve ;
ten => twenty ; teen_inf => doispe ten => twenty ; attr => two
} ; } ;
NCard Fem => table {unit => dou ; teen => douasprezece ; NCard Fem => table {unit => doua ; teen => douasprezece ;
ten => twenty ; teen_inf => douaspe ten => twenty ; attr => o
} ; } ;
NOrd Masc => table {unit => doilea ; NOrd Masc => table {unit => mkOrdinalForm two Masc ;
teen => mkOrdinalForm twelve Masc ; teen => mkOrdinalForm twelve Masc ;
ten => mkOrdinalForm twenty Masc ; ten => mkOrdinalForm twenty Masc ;
teen_inf => mkOrdinalForm doispe Masc attr => mkOrdinalForm two Masc
} ; } ;
NOrd Fem => table {unit => doua ; NOrd Fem => table {unit => mkOrdinalForm doua Fem ;
teen => mkOrdinalForm douasprezece Fem ; teen => mkOrdinalForm douasprezece Fem ;
ten => mkOrdinalForm twenty Fem ; ten => mkOrdinalForm twenty Fem ;
teen_inf => mkOrdinalForm douaspe Fem attr => una
} }
} ; } ;
Informal => table {
NCard Masc => table {unit => two ; teen => doispe ;
ten => twenty ; attr => two
} ;
NCard Fem => table {unit => doua ; teen => douaspe ;
ten => twenty ; attr => o
} ;
NOrd Masc => table {unit => mkOrdinalForm two Masc ;
teen => mkOrdinalForm doispe Masc ;
ten => mkOrdinalForm twenty Masc ;
attr => mkOrdinalForm two Masc
} ;
NOrd Fem => table {unit => mkOrdinalForm doua Fem ;
teen => mkOrdinalForm douaspe Fem ;
ten => mkOrdinalForm twenty Fem ;
attr => una
}
}
};
size = less20 ; size = less20 ;
lock_Digit = <> lock_Digit = <>
} ; } ;
@@ -77,41 +98,35 @@ oper regNum : Str -> Digit =
oper mkMidF : Str -> Str -> Sub100 = oper mkMidF : Str -> Str -> Sub100 =
\unsprezece, unspe -> \unsprezece, unspe ->
{ s = table {NCard g => table { Formal => \\_ => unsprezece ; { s = table { Formal =>table {
Informal => \\_ => unspe NCard g => unsprezece ;
}; NOrd g => mkOrdinalForm unsprezece g
NOrd g => table {Formal => \\_ => mkOrdinalForm unsprezece g; };
Informal => \\_ => mkOrdinalForm unspe g Informal => table{
} NCard g => unspe;
}; NOrd g => mkOrdinalForm unspe g
}
size = less20 ; } ;
lock_Sub100 = <> size = less20 ;
}; lock_Sub100 = <>
};
lin num = \d -> lin num = \d ->
{ s = \\cse => table { NCard g => \\f => d.s ! (NCard g) ! f ! indep ; { s = \\o => \\c => table { NCard g => d.s ! o ! (NCard g) ;
NOrd g => \\f => let ss = d.s ! (NOrd g) ! f ! indep NOrd g => let ss = d.s ! o ! (NOrd g)
in in
case d.size of case d.size of
{ sg => (artDem g Sg cse) ++ ss ; { sg => (artDem g Sg c) ++ ss ;
_ => mkOrd ss g cse _ => mkOrd ss g c
} }
}; };
sp = \\cse => table { NCard g => \\f => d.s ! (NCard g) ! f ! attr ;
NOrd g => \\f => let ss = d.s ! (NOrd g) ! f ! indep
in
case d.size of
{ sg => (artDem g Sg cse) ++ ss ;
_ => mkOrd ss g cse
}
};
size = d.size size = d.size
} ; } ;
-- Latin A Supplement chars -- Latin A Supplement chars
lin n2 = mkNumVSpc "doi" "doispreze" "douãsprezece" "douãzeci" "douã" "doiºpe" "douãºpe" "doilea" "doua"; lin n2 = mkNumVSpc "doi" "doispreze" "douãsprezece" "douãzeci" "douã" "doiºpe" "douãºpe" "douã" "doua";
lin n3 = regNum "trei"; lin n3 = regNum "trei";
lin n4 = mkNum "patru" "paisprezece" "patruzeci" "paiºpe"; lin n4 = mkNum "patru" "paisprezece" "patruzeci" "paiºpe";
lin n5 = mkNum "cinci" "cinsprezece" "cincizeci" "cinºpe"; lin n5 = mkNum "cinci" "cinsprezece" "cincizeci" "cinºpe";
@@ -120,78 +135,70 @@ lin n7 = mkNum "
lin n8 = mkNum "opt" "optsprezece" "optzeci" "optiºpe"; lin n8 = mkNum "opt" "optsprezece" "optzeci" "optiºpe";
lin n9 = regNum "nouã"; lin n9 = regNum "nouã";
lin pot01 = let num = mkNumVSpc "un" "unsprezece" "unsprezece" "zece" "o" "unºpe" "unºpe" "dintâi" "dintâi" ; lin pot01 = let num = mkNumVSpc "unu" "unsprezece" "unsprezece" "zece" "o" "unºpe" "unºpe" "una" "una"
dep = mkNumVSpc "unu" "unsprezece" "unsprezece" "zece" "una" "unºpe" "unºpe" "unulea" "una"
in in
{ s = \\o,c => table {indep => num.s ! o ! c ; { s = num.s ;
attr => dep.s ! o ! c
} ;
size = sg size = sg
}; };
lin pot0 d = { s = \\o, c => \\_ => d.s ! o ! c ; lin pot0 d = d ;
size = less20
};
lin pot110 = mkMidF "zece" "zece" ; lin pot110 = mkMidF "zece" "zece" ;
lin pot111 = mkMidF "unsprezece" "unºpe" ; lin pot111 = mkMidF "unsprezece" "unºpe" ;
lin pot1to19 = \d -> lin pot1to19 = \d ->
{s = \\c => table { Formal => \\_ => d.s ! c ! teen ; {s = \\o,c => d.s ! o ! c ! teen ;
Informal => \\_ => d.s ! c ! teen_inf size = less20} ;
};
size = less20
};
lin pot0as1 = \d -> lin pot0as1 = \d ->
{s = \\c,_,p => d.s ! c ! unit ! p ; {s = \\o,c => d.s ! o ! c ! unit;
size = d.size size = d.size} ;
};
lin pot1 = \d -> lin pot1 = \d ->
{s = \\c => \\_,_ => d.s ! c ! ten ; {s = \\o,c => d.s ! o ! c ! ten ;
size = pl size = pl} ;
};
lin pot1plus d e = lin pot1plus d e =
{s = table { {s = \\o => table {
NCard g => \\_,_ => d.s ! (NCard g) ! ten ++ "ºi" ++ e.s ! (NCard g) ! unit ! attr ; NCard g => d.s ! o ! (NCard g) ! ten ++ "ºi" ++ e.s ! o ! (NCard g) ! attr ;
NOrd g => \\_,_ => d.s ! (NCard g) ! ten ++ "ºi" ++ e.s ! (NOrd g) ! unit ! attr NOrd g => d.s ! o ! (NCard g) ! ten ++ "ºi" ++e.s ! o ! (NOrd g) ! attr
}; };
size = pl
}; size = pl} ;
lin pot1as2 n = n ; lin pot1as2 n = n ;
lin pot2 d = lin pot2 d =
{s = table { {s = \\o => table {
NCard g => \\_,_ => d.s ! (NCard Fem) ! unit ! indep ++ (mksute d.size) ; NCard g => d.s ! o ! (NCard Fem) ! unit ++ (mksute d.size) ;
NOrd g => \\_,_ => d.s ! (NCard Fem) ! unit ! indep ++ (mkSute d.size g) NOrd g => d.s ! o ! (NCard Fem)! unit ++ (mkSute d.size g)
}; };
size = pl} ; size = pl} ;
lin pot2plus d e = lin pot2plus d e =
{s = \\c,f,_ => d.s ! (NCard Fem) ! unit ! indep ++ (mksute d.size) ++ e.s ! c ! f ! attr ; {s = \\o, c => d.s ! o ! (NCard Fem) ! unit ++ (mksute d.size) ++ e.s ! o ! c ;
size = pl} ; size = pl} ;
lin pot2as3 n = n ; lin pot2as3 n =
{s = \\o, c => n.s ! o ! c ;
size = n.size
};
lin pot3 n = lin pot3 n =
{s = table { {s = \\o => table {
NCard g => \\f,p => mkmie n.size (n.s ! (NCard Fem) ! f ! indep) ; NCard g => mkmie n.size (n.s ! o ! (NCard Fem)) (n.s ! o ! (NCard Fem)) ;
NOrd g => \\f,p => mkMie n.size g (n.s ! (NCard Fem) ! f ! indep) NOrd g => mkMie n.size g (n.s ! o ! (NCard Fem)) (n.s ! o ! (NCard Fem))
}; };
size = pl size = n.size
} ; } ;
lin pot3plus n m = lin pot3plus n m =
{s = \\c, f, p => mkmie n.size (n.s ! (NCard Fem) ! f ! indep) ++ m.s ! c ! f ! attr; {s = \\o, c => (mkmie n.size (n.s ! o ! (NCard Fem)) (n.s ! o ! (NCard Fem))) ++ m.s ! Formal ! c;
size = pl size = pl
}; };
@@ -200,38 +207,34 @@ oper mkSute : Size -> Gender -> Str = \sz, g ->
table {sg => mkOrdinalForm "sutã" g ; table {sg => mkOrdinalForm "sutã" g ;
_ => mkOrdinalForm "sute" g } ! sz ; _ => mkOrdinalForm "sute" g } ! sz ;
oper mkmie : Size -> Str -> Str = \sz, attr -> oper mkmie : Size -> Str -> Str -> Str = \sz, attr, indep ->
table {sg => "o" ++ "mie" ; table {sg => "o" ++ "mie" ;
less20 => attr ++ "mii" ; less20 => attr ++ "mii" ;
pl => attr ++ "de" ++ "mii"} ! sz ; pl => indep ++ "de" ++ "mii"} ! sz ;
oper mkMie : Size -> Gender -> Str -> Str = \sz, g, attr -> oper mkMie : Size -> Gender -> Str -> Str -> Str = \sz, g, attr, indep ->
table { sg => "o" ++ mkOrdinalForm "mie" g ; table { sg => "o" ++ mkOrdinalForm "mie" g ;
less20 => attr ++ mkOrdinalForm "mii" g ; less20 => attr ++ mkOrdinalForm "mii" g ;
pl => attr ++ "de" ++ mkOrdinalForm "mii" g } ! sz ; pl => indep ++ "de" ++ mkOrdinalForm "mii" g } ! sz ;
--numerals as sequences of digits : --numerals as sequences of digits :
lincat lincat
Dig = {s : CardOrd => Str; n : Size ; isDig : Bool} ; Dig = {s : CardOrd => Str; n : Number} ;
lin lin
IDig d = d ; IDig d = d ;
IIDig d i = { IIDig d i = {
s = \\o => d.s ! NCard Masc ++ i.s ! o ; s = \\o => d.s ! NCard Masc ++ i.s ! o ;
n = case d.n of n = Pl
{ sg => if_then_else Size (i.isDig) less20 pl ;
_ => pl
};
isDig = False
} ; } ;
lin lin
D_0 = mkDig "0" ; D_0 = mkDig "0" ;
D_1 = mk3Dig "1" "1ul" "1a" sg ; ---- gender D_1 = mk3Dig "1" "1ul" "1a" Sg ; ---- gender
D_2 = mkDig "2"; D_2 = mkDig "2";
D_3 = mkDig "3" ; D_3 = mkDig "3" ;
D_4 = mkDig "4" ; D_4 = mkDig "4" ;
@@ -242,16 +245,15 @@ lin
D_9 = mkDig "9" ; D_9 = mkDig "9" ;
oper mkDig : Str -> Dig = \c -> mk3Dig c (c + "lea") (c + "a") less20 ; oper mkDig : Str -> Dig = \c -> mk3Dig c (c + "lea") (c + "a") Pl ;
oper mk3Dig : Str -> Str -> Str-> Size -> Dig = \c,u,o,n -> { oper mk3Dig : Str -> Str -> Str-> Number -> Dig = \c,u,o,n -> {
s = table {NCard g => c ; NOrd Masc => u ; NOrd Fem => o } ; s = table {NCard g => c ; NOrd Masc => u ; NOrd Fem => o } ;
n = n; n = n;
isDig = True ;
lock_Dig = <> lock_Dig = <>
} ; } ;
TDigit = {s : CardOrd => Str; n : Size ; isDig : Bool} ; TDigit = {s : CardOrd => Str; n : Number} ;
} }

28
lib/src/romanian/ParadigmsRon.gf
View File

@@ -148,9 +148,7 @@ lock_PN = <>
--. --.
--2 Definitions of the paradigms --2 Definitions of the paradigms
--
-- The definitions should not bother the user of the API. So they are
-- hidden from the document.
NGender = MorphoRon.NGender ; NGender = MorphoRon.NGender ;
@@ -347,8 +345,7 @@ oper mkV : Str -> V = \s -> mkNV (regV s) ;
mkV2S : V -> Prep -> V2S ; mkV2S : V -> Prep -> V2S ;
-- mkVV : V -> VV ;
mkV2V : V -> Prep -> Prep -> V2V ; mkV2V : V -> Prep -> Prep -> V2V ;
mkVA : V -> VA ; mkVA : V -> VA ;
mkV2A : V -> Prep -> Prep -> V2A ; mkV2A : V -> Prep -> Prep -> V2A ;
@@ -384,9 +381,6 @@ oper mkV : Str -> V = \s -> mkNV (regV s) ;
dirV2 : V -> V2 ; dirV2 : V -> V2 ;
dirV2 v = mmkV2 v (noPrep Ac) ; dirV2 v = mmkV2 v (noPrep Ac) ;
--mmkV3 : V -> Prep -> Prep -> Bool -> V3 ;
--mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ;
mkVS : V -> VS ; mkVS : V -> VS ;
mkVS v = v ** {m = \\_ => Indic ; lock_VS = <>} ; mkVS v = v ** {m = \\_ => Indic ; lock_VS = <>} ;
@@ -414,22 +408,6 @@ mkOrd a = {s = \\n,g,c => a.s ! AF g n Indef (convCase c) ; isPre = a.isPre ; l
--mkComp a =
--let adj = a.s ! Posit in
--{ s = table {Posit => adj ;
-- Compar => \\f => "mai" ++ adj ! f ++ "decât";
-- Superl => table {AF g n a c => (artDem g n c) ++ "mai" ++ adj ! (AF g n a c);
-- AA => "cel"++"mai" ++ adj ! AA
-- }
-- };
-- isPre = a.isPre ;
-- lock_A = <>
-- };
----
mkDet = overload { mkDet = overload {
mkDet : (_,_,_,_ : Str) -> Number -> Det = mkDetS ; mkDet : (_,_,_,_ : Str) -> Number -> Det = mkDetS ;
mkDet : (_,_,_,_,_,_,_,_ : Str) -> Number -> Det = mkD mkDet : (_,_,_,_,_,_,_,_ : Str) -> Number -> Det = mkD
@@ -552,4 +530,6 @@ mkPronoun :(_,_,_,_,_,_,_,_,_ : Str) -> Gender -> Number -> Person -> Pron =\eu,
-- in this case we add a case to the complement, so that the right gender is chosen. -- in this case we add a case to the complement, so that the right gender is chosen.
} ; } ;

7
lib/src/romanian/PhraseRon.gf
View File

@@ -1,4 +1,4 @@
incomplete concrete PhraseRon of Phrase = concrete PhraseRon of Phrase =
CatRon ** open ResRon, Prelude in { CatRon ** open ResRon, Prelude in {
flags optimize = all_subs ; flags optimize = all_subs ;
@@ -12,10 +12,11 @@ incomplete concrete PhraseRon of Phrase =
UttImpPl pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Pl False ! Fem} ; UttImpPl pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Pl False ! Fem} ;
UttImpPol pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg True ! Fem} ; UttImpPol pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg True ! Fem} ;
UttIP ip = {s = ip.s ! No} ; --- Acc also UttIP ip = {s = ip.s ! No} ;
UttIAdv iadv = iadv ; UttIAdv iadv = iadv ;
UttNP np = {s = (np.s ! No).comp} ; UttNP np = {s = (np.s ! No).comp} ;
-- UttVP vp = {s = infVP vp (agrP3 Fem Sg)} ; --- Agr UttVP vp = let a = agrP3 Masc Sg in
{s = "sã" ++ (flattenSimpleClitics vp.nrClit vp.clAcc vp.clDat (vp.isRefl ! a)) ++ conjVP vp a ++vp.comp ! a ++ vp.ext ! Pos} ;
UttAdv adv = adv ; UttAdv adv = adv ;
NoPConj = {s = []} ; NoPConj = {s = []} ;

8
lib/src/romanian/QuestionRon.gf
View File

@@ -1,4 +1,4 @@
incomplete concrete QuestionRon of Question = concrete QuestionRon of Question =
CatRon ** open ResRon, Prelude in { CatRon ** open ResRon, Prelude in {
flags optimize=all_subs ; flags optimize=all_subs ;
@@ -18,7 +18,7 @@ incomplete concrete QuestionRon of Question =
QuestVP qp vp = { QuestVP qp vp = {
s = \\t,a,b,_ => s = \\t,a,b,_ =>
let let
cl = mkClause (qp.s ! No) False (agrP3 qp.a.g qp.a.n) vp cl = mkClause (qp.s ! No) (agrP3 qp.a.g qp.a.n) vp
in in
cl.s ! DDir ! t ! a ! b ! Indic cl.s ! DDir ! t ! a ! b ! Indic
} ; } ;
@@ -27,7 +27,7 @@ incomplete concrete QuestionRon of Question =
s = \\t,a,p => s = \\t,a,p =>
let let
cls : Direct -> Str = cls : Direct -> Str =
\d -> slash.s ! ip.a ! d ! t ! a ! p ! Indic ; \d -> slash.s ! False ! ip.a ! d ! t ! a ! p ! Indic ;
prep = if_then_Str ip.hasRef slash.c2.prepDir "" ; prep = if_then_Str ip.hasRef slash.c2.prepDir "" ;
who = prep ++ slash.c2.s ++ ip.s ! slash.c2.c who = prep ++ slash.c2.s ++ ip.s ! slash.c2.c
in table { in table {
@@ -52,7 +52,7 @@ incomplete concrete QuestionRon of Question =
s = \\t,a,p,_ => s = \\t,a,p,_ =>
let let
vp = predV copula ; vp = predV copula ;
cls = (mkClause (np.s ! No).comp np.hasClit np.a vp).s ! cls = (mkClause (np.s ! No).comp np.a vp).s !
DInv ! t ! a ! p ! Indic ; DInv ! t ! a ! p ! Indic ;
why = icomp.s ! {g = np.a.g ; n = np.a.n} why = icomp.s ! {g = np.a.g ; n = np.a.n}
in why ++ cls in why ++ cls

14
lib/src/romanian/RelativeRon.gf
View File

@@ -1,4 +1,4 @@
incomplete concrete RelativeRon of Relative = concrete RelativeRon of Relative =
CatRon ** open Prelude, ResRon in { CatRon ** open Prelude, ResRon in {
flags optimize=all_subs ; flags optimize=all_subs ;
@@ -6,7 +6,7 @@ incomplete concrete RelativeRon of Relative =
lin lin
RelCl cl = { RelCl cl = {
s = \\ag,t,a,p,m => therefore_PConj.s ++ conjThat ++ s = \\ag,t,a,p,m => "astfel" ++ "cã" ++
cl.s ! DDir ! t ! a ! p ! m ; cl.s ! DDir ! t ! a ! p ! m ;
c = No c = No
} ; } ;
@@ -15,12 +15,12 @@ incomplete concrete RelativeRon of Relative =
RelVP rp vp = case rp.hasAgr of { RelVP rp vp = case rp.hasAgr of {
True => {s = \\ag => True => {s = \\ag =>
(mkClause (mkClause
(rp.s ! {g = ag.g ; n = ag.n} ! No) False (rp.s ! {g = ag.g ; n = ag.n} ! No)
{g = rp.a.g ; n = rp.a.n ; p = P3} {g = rp.a.g ; n = rp.a.n ; p = P3}
vp).s ! DDir ; c = No} ; vp).s ! DDir ; c = No} ;
False => {s = \\ag => False => {s = \\ag =>
(mkClause (mkClause
(rp.s ! {g = ag.g ; n = ag.n} ! No) False (rp.s ! {g = ag.g ; n = ag.n} ! No)
ag ag
vp).s ! DDir ; c = No vp).s ! DDir ; c = No
} }
@@ -31,7 +31,7 @@ incomplete concrete RelativeRon of Relative =
let aag = {g = ag.g ; n = ag.n} --add Clitics in this case also ! let aag = {g = ag.g ; n = ag.n} --add Clitics in this case also !
in in
slash.c2.s ++ slash.c2.prepDir ++ rp.s ! aag ! slash.c2.c ++ slash.c2.s ++ slash.c2.prepDir ++ rp.s ! aag ! slash.c2.c ++
slash.s ! aag ! DInv ! t ! a ! p ! m ; slash.s ! True ! aag ! DInv ! t ! a ! p ! m ;
c = No c = No
} ; } ;
@@ -46,8 +46,8 @@ incomplete concrete RelativeRon of Relative =
-- Ac => if_then_Str p.isDir (ss ++ p.s ++ rp.s ! a ! p.c) (ss ++ p.s ++ rp.s ! a ! No) -- Ac => if_then_Str p.isDir (ss ++ p.s ++ rp.s ! a ! p.c) (ss ++ p.s ++ rp.s ! a ! No)
IdRP = { IdRP = {
s = \\ag,c => case c of { Da | Ge => case <ag.g, ag.n > of s = \\ag,c => case c of { Da | Ge => case <ag.g, ag.n > of
{<Fem,Sg> => "careia" ; <Masc,Sg> => "caruia" ; {<Fem,Sg> => "cãreia" ; <Masc,Sg> => "cãruia" ;
<_Pl> => "carora" <_Pl> => "cãrora"
}; };
_ => "care" _ => "care"
} }

717
lib/src/romanian/ResRon.gf
View File

@@ -1,90 +1,93 @@
--1 Romance auxiliary operations. --1 Romance auxiliary operations.
-- --
resource ResRon = ParamX - [Temp,TTAnt,Tense,TPres,TPast,TFut,TCond], PhonoRon ** open Prelude in { resource ResRon = ParamX - [Temp,TTAnt,Tense,TPres,TPast,TFut,TCond] ** open Prelude in {
flags optimize= all ; flags optimize= all ;
--------------------------------------------------------------------------
----------------------- 1 BASIC PARAMETERS--------------------------------
--------------------------------------------------------------------------
--2 Enumerated parameter types for morphology
--
-- These types are the ones found in school grammars.
-- Their parameter values are atomic.
param param
Gender = Masc | Fem ;
NGender = NMasc | NFem | NNeut ;
Mood = Indic | Conjunct ; Mood = Indic | Conjunct ;
Direct = DDir | DInv ; Direct = DDir | DInv ;
-- there are 3 genders in Romanian, the Neuter is a combination of Masculine for Sg and Feminine for Pl
NGender = NMasc | NFem | NNeut ;
-- genders for Agreement, to which the 3 genders ultimately reduce
Gender = Masc | Fem ;
-- formal and informal form for numerals (the formal form is used as default)
NumF = Formal | Informal ; NumF = Formal | Informal ;
-- animacy feature of the nouns, which has consequences on syntactical level
Animacy = Animate | Inanimate ; Animacy = Animate | Inanimate ;
-- basic forms of the clitics
Clitics = Normal | Composite | Short | Imperative ;
-- Refl = NoRefl | ARefl | DRefl ; -- special size parameter used for Numerals
Clitics = Normal | Composite | Short | Vocative ;
Size = sg | less20 | pl ; Size = sg | less20 | pl ;
-- the cases that require clitics :
ParClit = PAcc | PDat ; ParClit = PAcc | PDat ;
-- parameter that counts the number of clitics in a verb phrase
VClit = VNone | VOne ParClit | VRefl | VMany ; VClit = VNone | VOne ParClit | VRefl | VMany ;
-- parameter that specifies whether a preposition would require clitics or not
PrepDir = Dir ParClit | NoDir ; PrepDir = Dir ParClit | NoDir ;
-- the 5 cases in Romanian
NCase = No | Da | Ac | Ge | Vo ;
-- the 3 distinct forms of the declension a noun/adjective, based on the syncretism Nominative-Accusative and Dative-Genitive
ACase = ANomAcc | AGenDat | AVoc ;
-- due to the enclitical defined article, a parameter for species is needed
Species = Indef | Def ;
-- Adjectives are inflected in number, gender, have specific form for enclitic determined -- Adjectives are inflected in number, gender, have specific form for enclitic determined
--article, and specific forms for Nominative-Accusative/Dative-Genitive/Voccative --article, and specific forms for Nominative-Accusative/Dative-Genitive/Voccative
AForm = AF Gender Number Species ACase | AA ; AForm = AF Gender Number Species ACase | AA ;
-- Gender is not morphologically determined for first and second person pronouns.
PronGen = PGen Gender | PNoGen ;
-- Cardinal numerals have gender, ordinal numerals have full number as well. -- Cardinal numerals have gender, ordinal numerals have full number as well.
ACase = ANomAcc | AGenDat | AVoc ;
Species = Indef | Def ;
NCase = No | Da | Ac | Ge | Vo ;
CardOrd = NCard Gender | NOrd Gender; CardOrd = NCard Gender | NOrd Gender;
-------------------------------------------------
--------------------2 Verbs ---------------------
-------------------------------------------------
--3 Verbs
-- the form we build on syntactical level, based on VForm -- the form we build on syntactical level, based on VForm
-- it represents the main verb forms in Romanian -- it represents the main verb forms in Romanian
param param
Temps1 = TPresn | TImparf | TPComp | TPSimple | TPPerfect | TFutur ;
TSubj1 = TSPres | TSPast ;
-- TPart1 = TGer | TPPasse Gender Number Species ACase;
VerbForm = TInf
| TIndi Temps1 Number Person
| TCondi Number Person
| TSubjo TSubj1 Number Person
| TImper NumPersI
| TGer
| TPPasse Gender Number Species ACase ;
-- the form we build on morphological level :
Temps = Presn | Imparf | PSimple | PPerfect ; Temps = Presn | Imparf | PSimple | PPerfect ;
TSubj = SPres ; TSubj = SPres ;
--TPart = PPasse Gender Number Species ACase;
-- the form we build on morphological level :
VForm = Inf VForm = Inf
| Indi Temps Number Person | Indi Temps Number Person
@@ -93,224 +96,490 @@ param
| Ger | Ger
| PPasse Gender Number Species ACase ; | PPasse Gender Number Species ACase ;
-- form for compatibility with the other Romance languages, to be used in case that TMood = VPres Mood | VImperff | VPasse Mood | VFut | VCondit ;
-- Romanian will be integrated in the Romance category
{-
param
VF =
VInfin Bool
| VFin TMood Number Person
| VImper NumPersI
| VPart Gender Number Species ACase
| VGer
;
-}
TMood =
VPres Mood
| VImperff --# notpresent
| VPasse Mood --# notpresent
| VFut --# notpresent
| VCondit --# notpresent
;
NumPersI = SgP2 | PlP1 | PlP2 ; NumPersI = SgP2 | PlP1 | PlP2 ;
VPForm = VPFinite TMood Anteriority
| VPImperat
| VPGerund
| VPInfinit Anteriority Bool ;
VPForm = RTense = RPres | RPast | RFut | RCond ;
VPFinite TMood Anteriority
| VPImperat
| VPGerund
| VPInfinit Anteriority Bool ;
RTense =
RPres
| RPast --# notpresent
| RFut --# notpresent
| RCond --# notpresent
;
-- Agreement of adjectives, verb phrases, and relative pronouns.
oper
AAgr : Type = {g : Gender ; n : Number} ;
Agr : Type = AAgr ** {p : Person} ;
RAgr : Type = {s : Clitics => Str} ;
oper
-- clitics : Gender -> Number
genForms : Str -> Str -> Gender => Str = \bon,bonne ->
table {
Masc => bon ;
Fem => bonne
} ;
RNoAg : RAgr = genClit "" "" "" "";
aagrForms : (x1,_,_,x4 : Str) -> (AAgr => Str) = \tout,toute,tous,toutes ->
table {
{g = g ; n = Sg} => genForms tout toute ! g ;
{g = g ; n = Pl} => genForms tous toutes ! g
} ;
Noun = {s : Number => Species => ACase => Str; g : NGender; a : Animacy} ;
Adj = {s : AForm => Str} ;
Compl : Type = {s : Str ; c : NCase ; isDir : PrepDir ; needIndef : Bool ; prepDir : Str} ;
oper oper
NounPhrase : Type = { copula : VerbPhrase =
s : NCase => {comp : Str ; let t = table {Inf => "fi" ;
clit : Clitics => Str} ; Indi Presn Sg P1 => "sunt" ; Indi Presn Sg P2 => "eºti" ; Indi Presn Sg P3 => "este" ;
a : Agr ; Indi Presn Pl P1 => "suntem" ; Indi Presn Pl P2 => "sunteþi" ; Indi Presn Pl P3 => "sunt" ;
indForm : Str ; Indi PSimple Sg P1 => "fusei" ; Indi PSimple Sg P2 => "fuseºi" ; Indi PSimple Sg P3 => "fuse" ;
hasClit : Bool ; Indi PSimple Pl P1 => "fuserãm" ; Indi PSimple Pl P2 => "fuserãþi" ; Indi PSimple Pl P3 => "fuserã" ;
hasRef : Bool ; Indi Imparf Sg P1 => "eram" ; Indi Imparf Sg P2 => "erai" ; Indi Imparf Sg P3 => "era" ;
isPronoun : Bool Indi Imparf Pl P1 => "eram" ; Indi Imparf Pl P2 => "eraþi" ; Indi Imparf Pl P3 => "erau" ;
} ; Indi PPerfect Sg P1 => "fusesem" ; Indi PPerfect Sg P2 => "fuseseºi" ; Indi PPerfect Sg P3 => "fusese" ;
Indi PPerfect Pl P1 => "fusesem" ; Indi PPerfect Pl P2 => "fuseseþi" ; Indi PPerfect Pl P3 => "fuseserã" ;
Pronoun : Type = {s : NCase => {comp, c1, c2 : Str}; Subjo SPres Sg P1 => "fiu" ; Subjo SPres Sg P2 => "fii" ; Subjo SPres Sg P3 => "fie" ;
a : Agr ; Subjo SPres Pl P1 => "fim" ; Subjo SPres Pl P2 => "fiþi" ; Subjo SPres Pl P3 => "fie" ;
poss : Number => Gender => Str Imper SgP2 => "fii" ; Imper PlP2 => "fiþi" ; Imper PlP1 => "fim" ;
}; Ger => "fiind";
PPasse g n a d => case <g,n,d,a> of
{<Masc,Sg,ANomAcc,Def> => "fostul"; <Masc,Sg,_,Indef> => "fost"; <Masc,Sg,AGenDat,Def> => "fostului"; <Masc,Sg,AVoc,Def> => "fostule";
<Masc,Pl,ANomAcc,Def> => "foºtii"; <Masc,Pl,_,Indef> => "foºti"; <Masc,Pl,_,Def> => "foºtilor";
<Fem,Sg,ANomAcc,Def> => "fosta"; <Fem,Sg,ANomAcc,Indef> => "fostã"; <Fem,Sg,AGenDat,Def> => "fostei"; <Fem,Sg,AGenDat,Indef> => "foste";<Fem,Sg,AVoc,Def> => "fosto"; <Fem,Sg,AVoc,Indef> => "fostã";
<Fem,Pl,ANomAcc,Def> => "fostele"; <Fem,Pl,_,Indef> => "foste";<Fem,Pl,_,Def> => "fostelor"
}
} in
{s = t; isRefl = \\_ => RNoAg; nrClit = VNone ; pReflClit = Composite ;
isFemSg = False ; neg = table {Pos => "" ; Neg => "nu"} ;
clAcc = RNoAg ; clDat = RNoAg ;
comp = \\_ => "";
ext = \\_ => ""
} ;
-- auxiliary for Past Tense :
pComp : Number => Person => Str = table {Sg => table {P1 => "am" ; P2 => "ai" ; P3 => "a"} ;
Pl => table {P1 => "am" ; P2 => "aþi"; P3 => "au"}
};
-- auxiliary for Future Simple :
pFut : Number => Person => Str = table {Sg => table {P1 => "voi" ; P2 => "vei" ; P3 => "va"} ;
Pl => table {P1 => "vom" ; P2 => "veþi"; P3 => "vor"}
};
--auxiliary for Condional Present :
heavyNP : {s : NCase => Str ; a : Agr; hasClit : Bool; ss : Str} -> NounPhrase = \np -> { pCond : Number => Person => Str = table {Sg => table {P1 => "aº" ; P2 => "ai" ; P3 => "ar"} ;
s = \\c => {comp = np.s ! c ; Pl => table {P1 => "am" ; P2 => "aþi"; P3 => "ar"}
clit = \\cs => if_then_Str np.hasClit ((genCliticsCase np.a c).s ! cs) [] }; };
-- short form of the verb, conjunctive present, without the auxiliary
conjVP : VerbPhrase -> Agr -> Str = \vp,agr ->
let
inf = vp.s ! Subjo SPres agr.n agr.p ;
neg = vp.neg ! Pos ;
in
neg ++ inf ;
a = np.a ; -- VPC form of the verb, needed for building a clause
indForm = np.ss ;
hasClit = np.hasClit ; useVP : VerbPhrase -> VPC = \vp ->
isPronoun = False; let
hasRef = False verb = vp.s ;
vinf : Bool -> Str = \b -> verb ! Inf ;
} ; vger = verb ! Ger ;
vimp : Agr -> Str = \a -> case <a.n,a.p> of
{<Sg,P2> => verb ! Imper SgP2 ;
<Pl,P2> => verb ! Imper PlP2 ;
_ => verb ! Subjo SPres a.n a.p
} ;
vf : Str -> (Agr -> Str) -> {
sa : Str ;
sv : Agr => Str
} =
\fin,inf -> {
sa = fin ;
sv = \\a => inf a
} ;
in {
s = table {
VPFinite tm Simul => case tm of
{VPres Indic => vf "" (\a -> verb ! Indi Presn a.n a.p) ;
VPres Conjunct => vf "sã" (\a -> verb ! Subjo SPres a.n a.p) ;
VImperff => vf "" (\a -> verb ! Indi Imparf a.n a.p) ;
VPasse Indic => vf "" (\a -> pComp ! a.n ! a.p ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
VPasse Conjunct => vf "sã" (\a -> copula.s! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
VFut => vf "" (\a -> pFut ! a.n ! a.p ++ verb ! Inf) ;
VCondit => vf "" (\a -> pCond ! a.n ! a.p ++ verb ! Inf)
} ;
VPFinite tm Anter => case tm of
{VPres Indic => vf "" (\a -> pComp ! a.n ! a.p ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
(VPres Conjunct | VPasse Conjunct) => vf "sã" (\a -> copula.s! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
VFut => vf "" (\a -> pFut !a.n ! a.p ++ copula.s! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
VCondit => vf "" (\a -> pCond ! a.n ! a.p ++ copula.s ! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc);
_ => vf "" (\a -> verb ! Indi PPerfect a.n a.p)
};
VPInfinit Anter b=> vf "a" (\a -> copula.s ! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc);
VPImperat => vf "sã" (\a -> verb ! Subjo SPres a.n a.p) ; -- fix it later !
VPGerund => vf "" (\a -> vger) ;
VPInfinit Simul b => vf "a" (\a -> verb ! Inf)
} ;
agr = vp.agr ;
neg = vp.neg ;
clitAc = vp.clAcc ;
clitDa = vp.clDat ;
clitRe = RNoAg ;
nrClit = vp.nrClit ;
pReflClit = vp.pReflClit;
comp = vp.comp ;
ext = vp.ext
} ;
-- basic UseV function
appCompl : Compl -> NounPhrase -> Str = \comp,np ->
comp.s ++ (np.s ! comp.c).comp ;
oper convCase : NCase -> ACase = predV : Verb -> VerbPhrase = \verb ->
\nc -> case nc of {
{Da | Ge => AGenDat; s = verb.s ;
No | Ac => ANomAcc; isRefl = verb.isRefl;
_ => AVoc} ; isFemSg = False ;
oper convACase : ACase -> NCase = nrClit = verb.nrClit ; pReflClit = verb.pReflClit;
\ac -> case ac of neg = table {Pos => ""; Neg => "nu"} ;
{ANomAcc => No ; clAcc = RNoAg ;
AGenDat => Ge ; clDat = RNoAg ;
_ => Vo}; comp = \\a => [] ;
ext = \\p => []
} ;
-- various helper functions for VerbRon
insertExtrapos : (Polarity => Str) -> VerbPhrase -> VerbPhrase = \co,vp -> {
s = vp.s ;
isFemSg = vp.isFemSg ;
clAcc = vp.clAcc ; isRefl = vp.isRefl;
clDat = vp.clDat ; pReflClit = vp.pReflClit ;
neg = vp.neg ;
comp = vp.comp ; nrClit = vp.nrClit ;
ext = \\p => vp.ext ! p ++ co ! p
} ;
insertObje : (Agr => Str) -> RAgr -> RAgr -> Bool -> VClit -> VerbPhrase -> VerbPhrase = \obj,clA, clD, agg, vc, vp -> {
s = vp.s ; isRefl = vp.isRefl;
isFemSg= orB agg vp.isFemSg ;
nrClit = vc; pReflClit = vp.pReflClit;
neg = table {Pos => ""; Neg => "nu"} ;
clAcc = {s = \\cs => vp.clAcc.s ! cs ++ clA.s ! cs };
clDat = {s = \\cs => vp.clDat.s ! cs ++ clD.s ! cs };
comp = \\a => obj ! a ++ vp.comp ! a ;
ext = vp.ext
};
--oper genRAgr : (x1,_,x3 : Str) -> RAgr = \ma,m,me -> genClit ma m me ** {hasClit = True}; insertSimpObj : (Agr => Str) -> VerbPhrase -> VerbPhrase = \obj,vp -> {
s = vp.s ; isRefl = vp.isRefl; isFemSg = vp.isFemSg ; neg = vp.neg ;
clAcc = vp.clAcc ; clDat = vp.clDat ;
nrClit = vp.nrClit ; pReflClit = vp.pReflClit ;
comp = \\a => vp.comp ! a ++ obj ! a ;
ext = vp.ext
};
oper genClit : (x1,_,_,x4 : Str) -> {s : Clitics => Str} = \ma, m, me, mma -> insertSimpObjPre : (Agr => Str) -> VerbPhrase -> VerbPhrase = \obj,vp -> {
{s = table {Normal => ma; s = vp.s ; isRefl = vp.isRefl; isFemSg = vp.isFemSg ; neg = vp.neg ;
Short => m; clAcc = vp.clAcc ; clDat = vp.clDat ; pReflClit = vp.pReflClit ;
Composite => me ; nrClit = vp.nrClit ;
Vocative => mma comp = \\a => obj ! a ++ vp.comp ! a ;
}}; ext = vp.ext
};
-----------------------------------------------------------------
---------------3 CATEGORY DEFINITIONS ---------------------------
-----------------------------------------------------------------
oper
oper genCliticsCase : Agr -> NCase -> {s : Clitics => Str} = \agr, c -> Noun = {s : Number => Species => ACase => Str; g : NGender; a : Animacy} ;
case c of Adj = {s : AForm => Str} ;
{Da => cliticsDa agr.g agr.n agr.p ;
Ac => cliticsAc agr.g agr.n agr.p ; Verbe : Type = { s : VForm => Str};
_ => {s = \\_ => []} Verb : Type = {s : VForm => Str ; isRefl : Agr => RAgr; nrClit : VClit ; pReflClit : Clitics};
}; Compl : Type = {s : Str ; c : NCase ; isDir : PrepDir ; needIndef : Bool ; prepDir : Str} ;
NounPhrase : Type = {s : NCase => {comp : Str ; clit : Clitics => Str} ;
oper aRefl : Agr -> RAgr = a : Agr ;
\a -> case <a.g,a.n,a.p> of indForm : Str ; --needed for prepositions that demand the indefinite form of a NP
{<_,_,P3> => {s = (genClit "se" "s-" "se" "").s } ; hasClit : Bool ; --
_ => {s = (cliticsAc a.g a.n a.p).s } hasRef : Bool ; -- needed to indicate if the NP is referenced or not - for the use of clitics
}; isPronoun : Bool -- in the case of pronouns, just the clitics are used, and not the comp form
} ;
oper dRefl : Agr -> RAgr = VerbPhrase :Type = {
\a -> case <a.g,a.n,a.p> of s : VForm => Str ;
{<_,_,P3> => {s = (genClit "îºi" "-ºi" "ºi" "").s } ; isRefl : Agr => RAgr ; -- the clitics for reflexive verbs
_ => {s = (cliticsDa a.g a.n a.p).s } nrClit : VClit ; -- number of clitics of the verb phrase
}; pReflClit : Clitics ; -- clitic parameter for reflexive clitic, in case it is present in the verb phrase, along with another clitic
isFemSg : Bool ; -- needed for the correct placement of the Accusative clitic
oper cliticsAc : Gender -> Number -> Person -> {s: Clitics => Str} = neg : Polarity => Str ; -- negation
\g,n,p -> case <g,n,p> of clAcc : RAgr ; -- clitic for the Accusative case (direct object)
{<_,Sg,P1> => genClit "mã" "m-" "mã" "-mã"; <_,Pl,P1> => genClit "ne" "ne-" "ne" "-ne"; clDat : RAgr ; -- clitic for the Dative case (indirect object without preposition)
<_,Sg,P2> => genClit "te" "te-" "te" "-te"; <_,Pl,P2> => genClit "vã" "v-" "vã" "-vã"; comp : Agr => Str ; -- object of the verb phraes
<Masc,Sg,P3> => genClit "îl" "l-" "-l" "-l"; <Masc,Pl,P3> => genClit "îi" "i-" "-i" "-i"; ext : Polarity => Str ; -- object sentece of the verb phrase
<Fem,Sg,P3> => genClit "o" "-o" "-o" "-o"; <Fem,Pl,P3> => genClit "le" "le-" "le" "-le" } ;
}; VPC : Type = {
oper cliticsDa : Gender -> Number -> Person -> {s : Clitics => Str} =
\g,n,p -> case <g,n,p> of
{<_,Sg,P1> => genClit "îmi" "mi-" "mi" "-mi"; <_,Pl,P1> => genClit "ne" "ne-" "ni" "-ne";
<_,Sg,P2> => genClit "îþi" "þi-" "þi" "-þi"; <_,Pl,P2> => genClit "vã" "v-" "vi" "-vã";
<_,Sg,P3> => genClit "îi" "i-" "i" "-i"; <_,Pl,P3> => genClit "le" "le-" "li" "-le"
};
oper
VPC : Type = {
-- for conjunctive mood where the negation comes
s : VPForm => { s : VPForm => {
sa : Str ; -- sa sa : Str ;
sv : Agr => Str -- merge sv : Agr => Str
} ; } ;
neg : Polarity => Str ; neg : Polarity => Str ;
clitAc : RAgr ; clitAc : RAgr ;
clitDa : RAgr ; clitDa : RAgr ;
clitRe : RAgr ; clitRe : RAgr ;
nrClit : VClit ; nrClit : VClit ;
comp : Agr => Str ; -- content(e) ; à ma mère ; hier comp : Agr => Str ;
ext : Polarity => Str ; -- que je dors / que je dorme ext : Polarity => Str ;
} ; } ;
-----------------------------------------------------------------------------
------------------------- 4 CLITICS -----------------------------------------
-----------------------------------------------------------------------------
oper
-- for the treatment of clitics
RAgr : Type = {s : Clitics => Str} ;
-- fix for Refl + Dat RNoAg : RAgr = genClit "" "" "" "";
flattenClitics : VClit -> RAgr -> RAgr -> RAgr -> Bool -> Bool -> {s1 : Str ; s2 : Str } = genClit : (x1,_,_,x4 : Str) -> {s : Clitics => Str} = \ma, m, me, mma ->
\vc, clA, clD, clR, isFemSg, b -> {s = table {Normal => ma;
Short => m;
Composite => me ;
Imperative => mma
}};
genCliticsCase : Agr -> NCase -> {s : Clitics => Str} = \agr, c ->
case c of
{Da => cliticsDa agr.g agr.n agr.p ;
Ac => cliticsAc agr.g agr.n agr.p ;
_ => {s = \\_ => []}
};
aRefl : Agr -> RAgr = \a ->
case <a.g,a.n,a.p> of
{<_,_,P3> => {s = (genClit "se" "s-" "se" "").s } ;
_ => {s = (cliticsAc a.g a.n a.p).s }
};
dRefl : Agr -> RAgr = \a ->
case <a.g,a.n,a.p> of
{<_,_,P3> => {s = (genClit "îºi" "-ºi" "ºi" "").s } ;
_ => {s = (cliticsDa a.g a.n a.p).s }
};
cliticsAc : Gender -> Number -> Person -> {s: Clitics => Str} = \g,n,p ->
case <g,n,p> of
{<_,Sg,P1> => genClit "mã" "m-" "mã" "-mã"; <_,Pl,P1> => genClit "ne" "ne-" "ne" "-ne";
<_,Sg,P2> => genClit "te" "te-" "te" "-te"; <_,Pl,P2> => genClit "vã" "v-" "vã" "-vã";
<Masc,Sg,P3> => genClit "îl" "l-" "-l" "-l"; <Masc,Pl,P3> => genClit "îi" "i-" "-i" "-i";
<Fem,Sg,P3> => genClit "o" "-o" "-o" "-o"; <Fem,Pl,P3> => genClit "le" "le-" "le" "-le"
};
cliticsDa : Gender -> Number -> Person -> {s : Clitics => Str} = \g,n,p ->
case <g,n,p> of
{<_,Sg,P1> => genClit "îmi" "mi-" "mi" "-mi"; <_,Pl,P1> => genClit "ne" "ne-" "ni" "-ne";
<_,Sg,P2> => genClit "îþi" "þi-" "þi" "-þi"; <_,Pl,P2> => genClit "vã" "v-" "vi" "-vã";
<_,Sg,P3> => genClit "îi" "i-" "i" "-i"; <_,Pl,P3> => genClit "le" "le-" "li" "-le"
};
flattenClitics : VClit -> RAgr -> RAgr -> RAgr -> Bool -> Bool -> Clitics -> {s1 : Str ; s2 : Str } = \vc, clA, clD, clR, isFemSg, b, pReflClit ->
let par = if_then_else Clitics b Short Normal; let par = if_then_else Clitics b Short Normal;
pcomb = if_then_else Clitics b Short Composite pcomb = if_then_else Clitics b Short Composite ;
pRefl = if_then_else Clitics b pReflClit Composite
in in
case isFemSg of case isFemSg of
{True => {s1 = clD.s ! par ++ clR.s ! par ; s2 = clA.s ! Short}; {True => {s1 = clD.s ! par ++ clR.s ! par ; s2 = clA.s ! Short};
_ => case vc of _ => case vc of
{VOne PAcc => {s1 = clA.s ! par ; s2 = ""}; {VOne PAcc => {s1 = clA.s ! par ; s2 = ""};
VOne PDat => {s1 = clD.s ! par ; s2 = ""}; VOne PDat => {s1 = clD.s ! par ; s2 = ""};
VRefl => {s1 = clR.s ! par ; s2 = ""}; VRefl => {s1 = clR.s ! par ; s2 = ""};
_ => {s1 = clD.s ! Composite ++ clR.s ! pcomb ++ clA.s ! pcomb ; s2 = ""} _ => {s1 = clD.s ! Composite ++ clR.s ! pRefl ++ clA.s ! pcomb ; s2 = ""}
} }
}; };
{-
{<False,_,False,_> => {s1 = clD.s ! par ; s2 = ""};
<False,False,_,_> => {s1 = clR.s ! par ; s2 = ""};
<_,_,_,True> => {s1 = clD.s ! par ++ clR.s ! par ; s2 = clA.s ! Short};
<_,False,False,_> => {s1 = clA.s ! par ; s2 = ""};
_ => {s1 = clD.s ! Composite ++ clR.s ! Composite ++ clA.s ! pcomb ; s2 = ""}
};
-}
flattenSimpleClitics : VClit -> RAgr -> RAgr -> RAgr -> Str =
\vc, clA, clD, clR ->case vc of
{VOne _ => clD.s ! Normal ++ clA.s ! Normal;
_ => clD.s ! Composite ++ clR.s ! Composite ++ clA.s ! Composite
};
flattenSimpleClitics : VClit -> RAgr -> RAgr -> RAgr -> Str = \vc, clA, clD, clR ->
case vc of
{VOne _ => clD.s ! Normal ++ clA.s ! Normal;
_ => clD.s ! Composite ++ clR.s ! Composite ++ clA.s ! Composite
};
-- we rely on the fact that there are not more than 2 clitics for a verb -- we rely on the fact that there are not more than 2 clitics for a verb
oper getSize : Size -> Str =
\s -> case s of -----------------------------------------------------------------------------
{ pl => "de" ; ------------------------- 5 ARTICLES ----------------------------------------
_ => "" -----------------------------------------------------------------------------
}; oper
-- demonstrative article
-- used as Determined article in order to emphasise on the noun/adjective, and for Dative/Genitive for of ordinals
artDem : Gender -> Number -> ACase -> Str = \g,n,c ->
case <g,n,c> of
{<Masc,Sg,ANomAcc> => "cel"; <Masc,Pl,ANomAcc> => "cei"; <Masc,Sg,AGenDat> => "celui";
<Fem,Sg,ANomAcc> => "cea"; <Fem,Pl,ANomAcc> => "cele"; <Fem,Sg,AGenDat> => "celei";
<_,Pl,AGenDat> => "celor";
<Masc,Sg,AVoc> => "cel";
<Masc,Pl,AVoc> => "cei"; <Fem,Sg,AVoc> => "cea"; <Fem,Pl,AVoc> => "cele"
};
-- undefined article (proclitical) --
-- we keep the non-articled form of the noun and glue it with the article on syntactical level
artUndef : Gender -> Number -> NCase -> Str = \g,n,a ->
case <g,n,a> of
{<Masc,Sg,No> => "un"; <Masc,Sg,Ac> => "un" ; <Masc,Sg,Ge> => "unui"; <Masc,Sg,Da> => "unui" ;<_,_,Vo> => "" ;
<_,Pl,No> => "niºte"; <_,Pl,Ac> => "niºte"; <_,Pl,Da> => "unor"; <_,Pl,Ge> => "unor" ;
<Fem,Sg,No> => "o"; <Fem,Sg,Ac> => "o"; <Fem,Sg,Da> => "unei"; <Fem,Sg,Ge> => "unei"
};
-- possesive article
-- used for Cardinals and for Genitive case
artPos : Gender -> Number -> ACase -> Str = \g,n,c ->
case <g,n,c> of
{<Masc,Sg,AGenDat> => "alui"; <Masc,Sg,_> => "al";
<Masc,Pl,AGenDat> => "alor"; <Masc,Pl,_> => "ai";
<Fem,Sg,AGenDat> => "alei"; <Fem,Sg,_> => "a";
<Fem,Pl,AGenDat> => "ale"; <Fem,Pl,_> => "ale"
};
-----------------------------------------------------------------------------
------------------------- 6 VARIOUS HELPER FUNCTIONS ------------------------
-----------------------------------------------------------------------------
oper
--Reflexive pronouns
reflPron : Number -> Person -> ACase -> Str = \n,p,c ->
case <n,p,c> of
{<Sg,P1,AGenDat> => "mie" ; <Sg,P1,_> => "mine";
<Sg,P2,AGenDat> => "þie" ; <Sg,P2,_> => "tine";
<_,P3,AGenDat> => "sieºi" ; <_,P3,_> => "sine" ;
<Pl,P1,AGenDat> => "nouã" ; <Pl,P1,_> => "noi" ;
<Pl,P2,AGenDat> => "vouã" ; <Pl,P2,_> => "voi"
};
reflPronHard : Gender -> Number -> Person -> Str = \g,n,p ->
case <g,n,p> of
{<Masc,Sg,P1> => "însumi" ; <Fem,Sg,P1> => "însãmi";
<Masc,Sg,P2> => "însuþi" ; <Fem,Sg,P2> => "însãþi";
<Masc,Sg,P3> => "însuºi" ; <Fem,Sg,P3> => "însãºi";
<Masc,Pl,P1> => "înºine" ; <Fem,Pl,P1> => "însene";
<Masc,Pl,P2> => "înºivã"; <Fem,Pl,P2> => "înseva";
<Masc,Pl,P3> => "înºiºi"; <Fem,Pl,P3> => "înseºi"};
-- Agreements :
-- for relatives
AAgr : Type = {g : Gender ; n : Number} ;
-- for agreement between subject and predicate
Agr : Type = AAgr ** {p : Person} ;
-- clause building function :
mkClause : Str -> Agr -> VerbPhrase ->
{s : Direct => RTense => Anteriority => Polarity => Mood => Str} =
\subj,agr,vpr -> {
s = \\d,t,a,b,m =>
let
tm = case t of {
RPast => VPasse m ;
RFut => VFut ;
RCond => VCondit ;
RPres => VPres m
} ;
cmp = case <t,a,m> of
{<RPast,Simul,Indic> | <RPres, Anter,Indic> => True ;
<RCond, _, _> => True;
_ => False
} ;
vp = useVP vpr ;
vps = (vp.s ! VPFinite tm a).sv ;
sa = (vp.s ! VPFinite tm a ).sa ;
verb = vps ! agr ;
neg = vp.neg ! b ;
clpr = flattenClitics vpr.nrClit vpr.clAcc vpr.clDat (vpr.isRefl ! agr) (andB vpr.isFemSg cmp) cmp vpr.pReflClit;
compl = vp.comp ! agr ++ vp.ext ! b
in
case d of {
DDir =>
subj ++ sa ++ neg ++ clpr.s1 ++ verb ++ clpr.s2;
DInv =>
sa ++ neg ++ clpr.s1 ++verb ++ clpr.s2 ++subj
}
++ compl
} ;
-- various :
heavyNP : {s : NCase => Str ; a : Agr; hasClit : Bool; ss : Str} -> NounPhrase = \np -> {
s = \\c => {comp = np.s ! c ;
clit = \\cs => if_then_Str np.hasClit ((genCliticsCase np.a c).s ! cs) [] };
a = np.a ;
indForm = np.ss ;
hasClit = np.hasClit ;
isPronoun = False;
hasRef = False
} ;
genForms : Str -> Str -> Gender => Str = \bon,bonne ->
table {
Masc => bon ;
Fem => bonne
} ;
aagrForms : (x1,_,_,x4 : Str) -> (AAgr => Str) = \tout,toute,tous,toutes ->
table {
{g = g ; n = Sg} => genForms tout toute ! g ;
{g = g ; n = Pl} => genForms tous toutes ! g
} ;
appCompl : Compl -> NounPhrase -> Str = \comp,np ->
comp.s ++ (np.s ! comp.c).comp ;
convCase : NCase -> ACase =\nc ->
case nc of
{Da | Ge => AGenDat;
No | Ac => ANomAcc;
_ => AVoc} ;
convACase : ACase -> NCase = \ac ->
case ac of
{ANomAcc => No ;
AGenDat => Ge ;
_ => Vo};
getSize : Size -> Str =\s ->
case s of
{pl => "de" ;
_ => ""
};
nextClit : VClit -> ParClit -> VClit = \vc,pc ->
case vc of
{VNone => VOne pc;
_ => VMany
};
isAgrFSg : Agr -> Bool = \ag ->
case <ag.n,ag.g,ag.p> of
{<Sg,Fem,P3> => True ;
_ => False
};
clitFromNoun : NounPhrase -> NCase -> RAgr = \np,nc ->
{s = (np.s ! nc).clit; hasClit = True};
agrGender : NGender -> Number -> Gender =\ng,n ->
case <ng,n> of
{<NMasc,_> => Masc ;
<NFem,_> => Fem ;
<NNeut, Sg> => Masc ;
_ => Fem};
getNumber : Size -> Number =\n ->
case n of
{sg => Sg;
_ => Pl };
getClit : Animacy -> Bool =\a ->
case a of
{Animate => True;
_ => False};
} }

50
lib/src/romanian/SentenceRon.gf
View File

@@ -1,17 +1,17 @@
incomplete concrete SentenceRon of Sentence = concrete SentenceRon of Sentence =
CatRon ** open Prelude, ResRon in { CatRon ** open Prelude, ResRon in {
flags optimize=all_subs ; flags optimize=all_subs ;
lin lin
PredVP np vp = mkClause (np.s ! No).comp np.hasClit np.a vp ; PredVP np vp = mkClause (np.s ! No).comp np.a vp ;
PredSCVP sc vp = mkClause sc.s False (agrP3 Masc Sg) vp ; PredSCVP sc vp = mkClause sc.s (agrP3 Masc Sg) vp ;
ImpVP vpr = let agSg = {n = Sg ; g = Masc ; p = P2 } ; ImpVP vpr = let agSg = {n = Sg ; g = Masc ; p = P2 } ;
agPl = {n = Pl ; g = Masc ; p = P2 } ; agPl = {n = Pl ; g = Masc ; p = P2 } ;
clDirSg = vpr.clDat.s ! Vocative ++ (vpr.isRefl ! agSg).s ! Vocative ++ vpr.clAcc.s ! Vocative ; clDirSg = vpr.clDat.s ! Imperative ++ (vpr.isRefl ! agSg).s ! Imperative ++ vpr.clAcc.s ! Imperative ;
clDirPl = vpr.clDat.s ! Vocative ++ (vpr.isRefl ! agPl).s ! Vocative ++ vpr.clAcc.s ! Vocative ; clDirPl = vpr.clDat.s ! Imperative ++ (vpr.isRefl ! agPl).s ! Imperative ++ vpr.clAcc.s ! Imperative ;
clNegSg = flattenSimpleClitics vpr.nrClit vpr.clAcc vpr.clDat (vpr.isRefl ! agSg) ; clNegSg = flattenSimpleClitics vpr.nrClit vpr.clAcc vpr.clDat (vpr.isRefl ! agSg) ;
clNegPl = flattenSimpleClitics vpr.nrClit vpr.clAcc vpr.clDat (vpr.isRefl ! agPl) clNegPl = flattenSimpleClitics vpr.nrClit vpr.clAcc vpr.clDat (vpr.isRefl ! agPl)
in in
@@ -28,35 +28,40 @@ incomplete concrete SentenceRon of Sentence =
}; };
<Neg, ImpF n b> => case n of <Neg, ImpF n b> => case n of
{Sg => "nu" ++ clNegSg ++ vpr.s ! Inf ++ vpr.comp ! agSg ++ vpr.ext ! Pos; {Sg => "nu" ++ clNegSg ++ vpr.s ! Inf ++ vpr.comp ! agSg ++ vpr.ext ! Pos;
Pl => "nu" ++ clNegPl ++ vpr.s ! Inf ++ vpr.comp ! agPl ++ vpr.ext ! Pos Pl => "nu" ++ clNegPl ++ vpr.s ! Indi Presn Pl P2 ++ vpr.comp ! agPl ++ vpr.ext ! Pos
} }
} }
} ; } ;
SlashVP np v2 = SlashVP np v2 =
{s = \\ag => {s = \\bb,ag=>
let let
vp = v2 vp = v2 ;
in (mkClause (np.s ! No).comp np.hasClit np.a vp).s ; bcond = andB vp.needClit bb
c2 = v2.c2 in
case <bcond,v2.c2.isDir> of
{<True, Dir pc> => (mkClause (np.s ! No).comp np.a (putClit (agrP3 ag.g ag.n) pc vp)).s ;
_ => (mkClause (np.s ! No).comp np.a vp).s
};
c2 = v2.c2
} ; } ;
AdvSlash slash adv = { AdvSlash slash adv = {
s = \\ag,d,t,a,b,m => slash.s ! ag ! d ! t ! a ! b ! m ++ adv.s ; s = \\bb,ag,d,t,a,b,m => slash.s ! bb ! ag ! d ! t ! a ! b ! m ++ adv.s ;
c2 = slash.c2 c2 = slash.c2
} ; } ;
-- potentially overgenerating !! since the complements have a preposition already -- potentially overgenerating !! since the complements have a preposition already
SlashPrep cl prep = { SlashPrep cl prep = {
s = \\_ => cl.s ; s = \\bb => \\_ => cl.s ;
c2 = {s = prep.s ; c = prep.c ; isDir = NoDir; needIndef = prep.needIndef; prepDir = ""} c2 = {s = prep.s ; c = prep.c ; isDir = NoDir; needIndef = prep.needIndef; prepDir = ""}
} ; } ;
SlashVS np vs slash = SlashVS np vs slash =
{s = \\ag => {s = \\bb,ag =>
(mkClause (mkClause
(np.s ! No).comp np.hasClit np.a (np.s ! No).comp np.a
(insertExtrapos (\\b => conjThat ++ slash.s ! ag ! (vs.m ! b)) (insertExtrapos (\\b => conjThat ++ slash.s ! ag ! (vs.m ! b))
(predV vs)) (predV vs))
).s ; ).s ;
c2 = slash.c2 c2 = slash.c2
@@ -65,7 +70,8 @@ incomplete concrete SentenceRon of Sentence =
EmbedS s = {s = conjThat ++ s.s ! Indic} ; EmbedS s = {s = conjThat ++ s.s ! Indic} ;
EmbedQS qs = {s = qs.s ! QIndir} ; EmbedQS qs = {s = qs.s ! QIndir} ;
-- EmbedVP vp = {s = infVP vp (agrP3 Masc Sg)} ; --- agr ---- compl EmbedVP vp = let a = agrP3 Masc Sg in
{ s= "sã" ++ (flattenSimpleClitics vp.nrClit vp.clAcc vp.clDat (vp.isRefl ! a)) ++ conjVP vp a ++vp.comp ! a ++ vp.ext ! Pos };
UseCl t p cl = { UseCl t p cl = {
s = \\o => t.s ++ p.s ++ cl.s ! DDir ! t.t ! t.a ! p.p ! o s = \\o => t.s ++ p.s ++ cl.s ! DDir ! t.t ! t.a ! p.p ! o
@@ -81,7 +87,7 @@ incomplete concrete SentenceRon of Sentence =
} ; } ;
UseSlash t p cl = { UseSlash t p cl = {
s = \\ag,mo => s = \\ag,mo =>
t.s ++ p.s ++ cl.s ! ag ! DDir ! t.t ! t.a ! p.p ! mo ; t.s ++ p.s ++ cl.s ! False ! ag ! DDir ! t.t ! t.a ! p.p ! mo ;
c2 = cl.c2 c2 = cl.c2
} ; } ;
@@ -91,4 +97,14 @@ incomplete concrete SentenceRon of Sentence =
s = \\o => s.s ! o ++ "," ++ r.s ! Indic ! agrP3 Masc Sg s = \\o => s.s ! o ++ "," ++ r.s ! Indic ! agrP3 Masc Sg
} ; } ;
oper putClit : Agr -> ParClit -> VP -> VP = \ag, pc, vp -> let nrC = nextClit vp.nrClit pc
in
case pc of
{PAcc => {s = vp.s; isRefl = vp.isRefl; clDat = vp.clDat; clAcc = cliticsAc ag.g ag.n ag.p; isFemSg = isAgrFSg ag;
comp = vp.comp; ext = vp.ext; neg = vp.neg; nrClit = nrC ; vpre = vp.vpre ; clitPre = vp.clitPre ; pReflClit = vp.pReflClit ;lock_VP = <>};
PDat => {s = vp.s; isRefl = vp.isRefl; clDat = cliticsDa ag.g ag.n ag.p; clAcc = vp.clAcc; isFemSg = vp.isFemSg;
comp = vp.comp; ext = vp.ext; neg = vp.neg; nrClit = nrC ; vpre = vp.vpre ; pReflClit = vp.pReflClit ;clitPre = vp.clitPre ;lock_VP = <>}
};
} }

232
lib/src/romanian/VerbRon.gf
View File

@@ -1,4 +1,4 @@
incomplete concrete VerbRon of Verb = concrete VerbRon of Verb =
CatRon ** open Prelude, ResRon in { CatRon ** open Prelude, ResRon in {
flags optimize=all_subs ; flags optimize=all_subs ;
@@ -9,7 +9,7 @@ incomplete concrete VerbRon of Verb =
s = verb.s ; s = verb.s ;
isRefl = verb.isRefl; isRefl = verb.isRefl;
nrClit = verb.nrClit; nrClit = verb.nrClit;
isFemSg = False ; isFemSg = False ; pReflClit = verb.pReflClit ;
neg = table {Pos => ""; Neg => "nu"} ; neg = table {Pos => ""; Neg => "nu"} ;
clAcc = RNoAg ; nrClit = verb.nrClit; clAcc = RNoAg ; nrClit = verb.nrClit;
clDat = RNoAg ; clDat = RNoAg ;
@@ -28,14 +28,14 @@ incomplete concrete VerbRon of Verb =
insertSimpObj (\\a => ap.s ! AF a.g a.n Indef ANomAcc) (UseV v) ; insertSimpObj (\\a => ap.s ! AF a.g a.n Indef ANomAcc) (UseV v) ;
SlashV2a verb = {s = verb.s ; isRefl = verb.isRefl; nrClit = verb.nrClit; SlashV2a verb = {s = verb.s ; isRefl = verb.isRefl; nrClit = verb.nrClit;
isFemSg = False ; isFemSg = False ; pReflClit = verb.pReflClit ;
neg = table {Pos => ""; Neg => "nu"} ; neg = table {Pos => ""; Neg => "nu"} ;
clAcc = RNoAg ; clAcc = RNoAg ;
clDat = RNoAg ; clDat = RNoAg ;
comp = \\a => [] ; comp = \\a => [] ;
ext = \\p => [] ; ext = \\p => [] ;
c2 = verb.c2 ; needAgr = False ; lock_VP = <>}; c2 = verb.c2 ; needAgr = False ; needClit = True ; lock_VP = <>};
@@ -47,9 +47,9 @@ incomplete concrete VerbRon of Verb =
vcAc = if_then_else VClit np.hasRef (nextClit v.nrClit PAcc) v.nrClit vcAc = if_then_else VClit np.hasRef (nextClit v.nrClit PAcc) v.nrClit
in in
case v.c2.isDir of case v.c2.isDir of
{Dir PAcc => (insertObje (\\_ => sir) (clitFromNoun np Ac) RNoAg (isAgrFSg np.a) vcAc (UseV v)) ** {needAgr = False ; c2 = v.c3} ; {Dir PAcc => (insertObje (\\_ => sir) (clitFromNoun np Ac) RNoAg (isAgrFSg np.a) vcAc (UseV v)) ** {needAgr = False ; needClit = True ; c2 = v.c3} ;
Dir PDat => (insertObje (\\_ => sir) RNoAg (clitFromNoun np Da) False vcDa (UseV v)) ** {needAgr = False ; c2 = v.c3}; Dir PDat => (insertObje (\\_ => sir) RNoAg (clitFromNoun np Da) False vcDa (UseV v)) ** {needAgr = False ; needClit = True ; c2 = v.c3};
_ => (insertSimpObj (\\_ => ss) (UseV v)) ** {needAgr = False ; c2 = v.c3} _ => (insertSimpObjPre (\\_ => ss) (UseV v)) ** {needAgr = False ; needClit = True ; c2 = v.c3}
}; };
Slash3V3 v np = let s1 = v.c3.s ++ (np.s ! (v.c3.c)).comp ; Slash3V3 v np = let s1 = v.c3.s ++ (np.s ! (v.c3.c)).comp ;
@@ -59,20 +59,20 @@ incomplete concrete VerbRon of Verb =
vcAc = if_then_else VClit np.hasRef (nextClit v.nrClit PAcc) v.nrClit vcAc = if_then_else VClit np.hasRef (nextClit v.nrClit PAcc) v.nrClit
in in
case v.c3.isDir of case v.c3.isDir of
{Dir PAcc => (insertObje (\\_ => sir) (clitFromNoun np Ac) RNoAg (isAgrFSg np.a) vcAc (UseV v)) ** {needAgr = False ; c2 = v.c2} ; {Dir PAcc => (insertObje (\\_ => sir) (clitFromNoun np Ac) RNoAg (isAgrFSg np.a) vcAc (UseV v)) ** {needAgr = False ; needClit = True ; c2 = v.c2} ;
Dir PDat => (insertObje (\\_ => sir) RNoAg (clitFromNoun np Da) False vcDa (UseV v)) ** {needAgr = False ; c2 = v.c2} ; Dir PDat => (insertObje (\\_ => sir) RNoAg (clitFromNoun np Da) False vcDa (UseV v)) ** {needAgr = False ; needClit = True ; c2 = v.c2} ;
_ => (insertSimpObj (\\_ => ss) (UseV v)) ** {needAgr = False ; c2 = v.c2} _ => (insertSimpObjPre (\\_ => ss) (UseV v)) ** {needAgr = False ; needClit = True ;c2 = v.c2}
}; };
-- needs fixing - agreement for the added verb must be made accordingly to what we add in ComplSlash !!! -- needs fixing - agreement for the added verb must be made accordingly to what we add in ComplSlash !!!
-- fixed with extra parameter ! -- fixed with extra parameter !
SlashV2V v vp = (insertSimpObj (\\a => "sã" ++ (flattenSimpleClitics vp.nrClit vp.clAcc vp.clDat (vp.isRefl ! a)) ++ conjVP vp a ++ vp.comp ! a ++ vp.ext ! Pos) (UseV v)) ** {needAgr = True ;c2 = v.c2} ; SlashV2V v vp = (insertSimpObj (\\a => "sã" ++ (flattenSimpleClitics vp.nrClit vp.clAcc vp.clDat (vp.isRefl ! a)) ++ conjVP vp a ++ vp.comp ! a ++ vp.ext ! Pos) (UseV v)) ** {needAgr = True ; needClit = True ;c2 = v.c2} ;
SlashV2S v s = (insertExtrapos (\\b => conjThat ++ s.s ! Indic) (UseV v)) ** {needAgr = False; c2 = v.c2}; SlashV2S v s = (insertExtrapos (\\b => conjThat ++ s.s ! Indic) (UseV v)) ** {needAgr = False; needClit = True ;c2 = v.c2};
SlashV2Q v q = (insertExtrapos (\\_ => q.s ! QIndir) (UseV v)) ** {needAgr = False ; c2 = v.c2 } ; SlashV2Q v q = (insertExtrapos (\\_ => q.s ! QIndir) (UseV v)) ** {needAgr = False ; needClit = False ;c2 = v.c2 } ;
@@ -80,7 +80,7 @@ incomplete concrete VerbRon of Verb =
SlashV2A v ap = SlashV2A v ap =
(insertSimpObj (\\a => v.c3.s ++ ap.s ! (AF Masc Sg Indef (convCase v.c3.c))) (insertSimpObj (\\a => v.c3.s ++ ap.s ! (AF Masc Sg Indef (convCase v.c3.c)))
(UseV v)) ** {needAgr = False ;c2 = v.c2} ; (UseV v)) ** {needAgr = False ; needClit = True ; c2 = v.c2} ;
ComplSlash vp np = let s1 = vp.c2.s ++(np.s ! (vp.c2.c)).comp ; ComplSlash vp np = let s1 = vp.c2.s ++(np.s ! (vp.c2.c)).comp ;
ss = if_then_Str np.hasRef (vp.c2.prepDir ++ s1) s1 ; ss = if_then_Str np.hasRef (vp.c2.prepDir ++ s1) s1 ;
@@ -90,11 +90,11 @@ incomplete concrete VerbRon of Verb =
vpp = case vp.c2.isDir of vpp = case vp.c2.isDir of
{Dir PAcc => insertObje (\\_ => sir) (clitFromNoun np Ac) RNoAg (isAgrFSg np.a) vcAc vp ; {Dir PAcc => insertObje (\\_ => sir) (clitFromNoun np Ac) RNoAg (isAgrFSg np.a) vcAc vp ;
Dir PDat => insertObje (\\_ => sir) RNoAg (clitFromNoun np Da) False vcDa vp; Dir PDat => insertObje (\\_ => sir) RNoAg (clitFromNoun np Da) False vcDa vp;
_ => insertSimpObj (\\_ => ss) vp _ => insertSimpObjPre (\\_ => ss) vp
} }
in in
{isRefl = vpp.isRefl; {isRefl = vpp.isRefl;
s = vpp.s ; isFemSg = vpp.isFemSg ; s = vpp.s ; isFemSg = vpp.isFemSg ; pReflClit = vp.pReflClit ;
nrClit = vpp.nrClit; clAcc = vpp.clAcc ; nrClit = vpp.nrClit; clAcc = vpp.clAcc ;
clDat = vpp.clDat ; neg = vpp.neg ; clDat = vpp.clDat ; neg = vpp.neg ;
comp = case vp.needAgr of comp = case vp.needAgr of
@@ -112,11 +112,14 @@ incomplete concrete VerbRon of Verb =
{Da => \\a => dRefl a; {Da => \\a => dRefl a;
_ => \\a => aRefl a _ => \\a => aRefl a
}; };
s = v.s ; isFemSg = v.isFemSg ; s = v.s ; isFemSg = v.isFemSg ;
nrClit = case v.nrClit of nrClit = case v.nrClit of
{VNone => VRefl; {VNone => VRefl;
_ => VMany }; _ => VMany };
clAcc = v.clAcc ; clAcc = v.clAcc ;
pReflClit = case v.c2.c of
{Ac => Short ;
_ => Composite};
clDat = v.clDat ; clDat = v.clDat ;
neg = v.neg ; neg = v.neg ;
comp = v.comp ; comp = v.comp ;
@@ -126,8 +129,8 @@ incomplete concrete VerbRon of Verb =
SlashVV v vp = SlashVV v vp =
insertObjc (\\a => "sã" ++ (flattenSimpleClitics vp.nrClit vp.clAcc vp.clDat (vp.isRefl ! a)) ++ conjVP vp a ++ vp.comp ! a ++ vp.ext ! Pos) ((UseV v) **{c2=vp.c2; needAgr= vp.needAgr ; lock_VPSlash = <>}) ; insertObjc (\\a => "sã" ++ (flattenSimpleClitics vp.nrClit vp.clAcc vp.clDat (vp.isRefl ! a)) ++ conjVP vp a ++ vp.comp ! a ++ vp.ext ! Pos) ((UseV v) **{c2=vp.c2; needAgr= vp.needAgr ; needClit = False; lock_VPSlash = <>}) ;
{-
SlashV2VNP v np vp = let s1 = v.c2.s ++(np.s ! (v.c2.c)).comp ; SlashV2VNP v np vp = let s1 = v.c2.s ++(np.s ! (v.c2.c)).comp ;
ss = if_then_Str np.hasRef (v.c2.prepDir ++ s1) s1; ss = if_then_Str np.hasRef (v.c2.prepDir ++ s1) s1;
sir = if_then_Str np.isPronoun "" ss ; sir = if_then_Str np.isPronoun "" ss ;
@@ -136,14 +139,14 @@ incomplete concrete VerbRon of Verb =
vcomp = (getConjComp vp np.a).s vcomp = (getConjComp vp np.a).s
in in
case v.c2.isDir of case v.c2.isDir of
{Dir PAcc => (insertObje (\\a => sir ++ vcomp ! a) (clitFromNoun np Ac) RNoAg (isAgrFSg np.a) vcAc (UseV v)) ** {needAgr = vp.needAgr ; c2 = vp.c2} ; {Dir PAcc => (insertObje (\\a => sir ++ vcomp ! a) (clitFromNoun np Ac) RNoAg (isAgrFSg np.a) vcAc (UseV v)) ** {needAgr = vp.needAgr ; needClit = False ;c2 = vp.c2} ;
Dir PDat => (insertObje (\\a => sir ++ vcomp ! a) RNoAg (clitFromNoun np Da) False vcDa (UseV v)) ** {needAgr = vp.needAgr ; c2 = vp.c2}; Dir PDat => (insertObje (\\a => sir ++ vcomp ! a) RNoAg (clitFromNoun np Da) False vcDa (UseV v)) ** {needAgr = vp.needAgr ; needClit = False ; c2 = vp.c2};
_ => (insertSimpObj (\\a => ss ++ vcomp ! a) (UseV v)) ** {needAgr = vp.needAgr ; c2 = vp.c2} _ => (insertSimpObjPre (\\a => ss ++ vcomp ! a) (UseV v)) ** {needAgr = vp.needAgr ; needClit = False ; c2 = vp.c2}
}; };
-}
UseComp comp = insertSimpObj comp.s (UseV copula) ; UseComp comp = insertSimpObj comp.s (UseV copula) ;
CompAP ap = {s = \\ag => ap.s ! AF ag.g ag.n Indef ANomAcc} ; CompAP ap = {s = \\ag => ap.s ! AF ag.g ag.n Indef ANomAcc} ;
@@ -158,143 +161,19 @@ incomplete concrete VerbRon of Verb =
oper
oper conjVP : VP -> Agr -> Str = \vp,agr ->
let
inf = vp.s ! Subjo SPres agr.n agr.p ;
neg = vp.neg ! Pos ;
in
neg ++ inf ;
insertAdv : Str -> VP -> VP = \co,vp -> { insertAdv : Str -> VP -> VP = \co,vp -> {
s = vp.s ; s = vp.s ;
isRefl = vp.isRefl; isRefl = vp.isRefl;
isFemSg = vp.isFemSg ; isFemSg = vp.isFemSg ; pReflClit = vp.pReflClit ;
clAcc = vp.clAcc ; nrClit = vp.nrClit ; clAcc = vp.clAcc ; nrClit = vp.nrClit ;
clDat = vp.clDat ; clDat = vp.clDat ;
neg = vp.neg ; neg = vp.neg ;
comp = \\a => vp.comp ! a ++ co ; comp = \\a => vp.comp ! a ++ co ;
ext = vp.ext ; ext = vp.ext ;
lock_VP = <> lock_VP = <>
} ; } ;
oper copula : V =
let t = table {Inf => "fi" ;
Indi Presn Sg P1 => "sunt" ; Indi Presn Sg P2 => "eºti" ; Indi Presn Sg P3 => "este" ;
Indi Presn Pl P1 => "suntem" ; Indi Presn Pl P2 => "sunteþi" ; Indi Presn Pl P3 => "sunt" ;
Indi PSimple Sg P1 => "fusei" ; Indi PSimple Sg P2 => "fuseºi" ; Indi PSimple Sg P3 => "fuse" ;
Indi PSimple Pl P1 => "fuserãm" ; Indi PSimple Pl P2 => "fuserãþi" ; Indi PSimple Pl P3 => "fuserã" ;
Indi Imparf Sg P1 => "eram" ; Indi Imparf Sg P2 => "erai" ; Indi Imparf Sg P3 => "era" ;
Indi Imparf Pl P1 => "eram" ; Indi Imparf Pl P2 => "eraþi" ; Indi Imparf Pl P3 => "erau" ;
Indi PPerfect Sg P1 => "fusesem" ; Indi PPerfect Sg P2 => "fuseseºi" ; Indi PPerfect Sg P3 => "fusese" ;
Indi PPerfect Pl P1 => "fusesem" ; Indi PPerfect Pl P2 => "fuseseþi" ; Indi PPerfect Pl P3 => "fuseserã" ;
Subjo SPres Sg P1 => "fiu" ; Subjo SPres Sg P2 => "fii" ; Subjo SPres Sg P3 => "fie" ;
Subjo SPres Pl P1 => "fim" ; Subjo SPres Pl P2 => "fiþi" ; Subjo SPres Pl P3 => "fie" ;
Imper SgP2 => "fii" ; Imper PlP2 => "fiþi" ; Imper PlP1 => "fim" ;
Ger => "fiind";
PPasse g n a d => (mkAdjReg "fost"). s ! (AF g n a d)
} in
{s = t; isRefl = \\_ => RNoAg; nrClit = VNone ; lock_V = <>} ;
predV : V -> VP = \verb ->
{
s = verb.s ;
isRefl = verb.isRefl;
isFemSg = False ;
nrClit = verb.nrClit ;
neg = table {Pos => ""; Neg => "nu"} ;
clAcc = RNoAg ;
clDat = RNoAg ;
comp = \\a => [] ;
ext = \\p => [] ; lock_VP = <>
} ;
useVP : VP -> VPC = \vp ->
let
verb = vp.s ;
vinf : Bool -> Str = \b -> verb ! Inf ;
vger = verb ! Ger ;
vimp : Agr -> Str = \a -> case <a.n,a.p> of
{<Sg,P2> => verb ! Imper SgP2 ;
<Pl,P2> => verb ! Imper PlP2 ;
_ => verb ! Subjo SPres a.n a.p
} ;
vf : Str -> (Agr -> Str) -> {
sa : Str ;
sv : Agr => Str
} =
\fin,inf -> {
sa = fin ;
sv = \\a => inf a
} ;
in {
s = table {
VPFinite tm Simul => case tm of
{VPres Indic => vf "" (\a -> verb ! Indi Presn a.n a.p) ;
VPres Conjunct => vf "sã" (\a -> verb ! Subjo SPres a.n a.p) ;
VImperff => vf "" (\a -> verb ! Indi Imparf a.n a.p) ;
VPasse Indic => vf "" (\a -> pComp ! a.n ! a.p ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
VPasse Conjunct => vf "sã" (\a -> copula.s! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
VFut => vf "" (\a -> pFut ! a.n ! a.p ++ verb ! Inf) ;
VCondit => vf "" (\a -> pCond ! a.n ! a.p ++ verb ! Inf)
} ;
VPFinite tm Anter => case tm of
{VPres Indic => vf "" (\a -> pComp ! a.n ! a.p ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
(VPres Conjunct | VPasse Conjunct) => vf "sã" (\a -> copula.s! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
VFut => vf "" (\a -> pFut !a.n ! a.p ++ copula.s! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc) ;
VCondit => vf "" (\a -> pCond ! a.n ! a.p ++ copula.s ! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc);
_ => vf "" (\a -> verb ! Indi PPerfect a.n a.p)
};
VPInfinit Anter b=> vf "a" (\a -> copula.s ! Inf ++ verb ! PPasse Masc Sg Indef ANomAcc);
VPImperat => vf "sã" (\a -> verb ! Subjo SPres a.n a.p) ; -- fix it later !
VPGerund => vf "" (\a -> vger) ;
VPInfinit Simul b => vf "a" (\a -> verb ! Inf)
} ;
agr = vp.agr ;
neg = vp.neg ;
clitAc = vp.clAcc ;
clitDa = vp.clDat ;
clitRe = RNoAg ;
nrClit = vp.nrClit ;
comp = vp.comp ;
ext = vp.ext
} ;
mkClause : Str -> Bool -> Agr -> VP ->
{s : Direct => RTense => Anteriority => Polarity => Mood => Str} =
\subj,hasClit,agr,vpr -> {
s = \\d,t,a,b,m =>
let
tm = case t of {
RPast => VPasse m ;
RFut => VFut ;
RCond => VCondit ;
RPres => VPres m
} ;
cmp = case <t,a,m> of
{<RPast,Simul,Indic> | <RPres, Anter,Indic> => True ;
<RCond, _, _> => True;
_ => False
} ;
vp = useVP vpr ;
vps = (vp.s ! VPFinite tm a).sv ;
sa = (vp.s ! VPFinite tm a ).sa ;
verb = vps ! agr ;
neg = vp.neg ! b ;
clpr = flattenClitics vpr.nrClit vpr.clAcc vpr.clDat (vpr.isRefl ! agr) (andB vpr.isFemSg cmp) cmp;
compl = vp.comp ! agr ++ vp.ext ! b
in
case d of {
DDir =>
subj ++ sa ++ neg ++ clpr.s1 ++ verb ++ clpr.s2;
DInv =>
sa ++ neg ++ clpr.s1 ++verb ++ clpr.s2 ++subj
}
++ compl
} ;
@@ -303,62 +182,17 @@ mkClause : Str -> Bool -> Agr -> VP ->
oper auxPassive = copula ; oper auxPassive = copula ;
mkVPSlash : Compl -> VP -> VP ** {c2 : Compl} = \c,vp -> vp ** {c2 = c; needAgr = False} ; mkVPSlash : Compl -> VP -> VP ** {c2 : Compl} = \c,vp -> vp ** {c2 = c; needAgr = False; needClit = True} ;
insertObje : (Agr => Str) -> RAgr -> RAgr -> Bool -> VClit -> VP -> VP = \obj,clA, clD, agg, vc, vp -> {
s = vp.s ; isRefl = vp.isRefl;
isFemSg= orB agg vp.isFemSg ;
nrClit = vc;
neg = table {Pos => ""; Neg => "nu"} ;
clAcc = {s = \\cs => vp.clAcc.s ! cs ++ clA.s ! cs };
clDat = {s = \\cs => vp.clDat.s ! cs ++ clD.s ! cs };
comp = \\a => vp.comp ! a ++ obj ! a ;
ext = vp.ext ; lock_VP = <>
};
insertSimpObj : (Agr => Str) -> VP -> VP = \obj,vp -> {
s = vp.s ; isRefl = vp.isRefl; isFemSg = vp.isFemSg ; neg = vp.neg ;
clAcc = vp.clAcc ; clDat = vp.clDat ;
nrClit = vp.nrClit ;
comp = \\a => vp.comp ! a ++ obj ! a ;
ext = vp.ext ; lock_VP = <>
};
insertObjc : (Agr => Str) -> VPSlash -> VPSlash = \obj,vp -> insertObjc : (Agr => Str) -> VPSlash -> VPSlash = \obj,vp ->
insertSimpObj obj vp ** {c2 = vp.c2; needAgr = False ; lock_VPSlash = <>} ; insertSimpObj obj vp ** {c2 = vp.c2; needAgr = False ; needClit = True ; lock_VPSlash = <>} ;
insertExtrapos : (Polarity => Str) -> VP -> VP = \co,vp -> {
s = vp.s ;
isFemSg = vp.isFemSg ;
clAcc = vp.clAcc ; isRefl = vp.isRefl;
clDat = vp.clDat ;
neg = vp.neg ;
comp = vp.comp ; nrClit = vp.nrClit ;
ext = \\p => vp.ext ! p ++ co ! p ;
lock_VP =<>
} ;
clitFromNoun : NP -> NCase -> RAgr = \np,nc ->
{s = (np.s ! nc).clit; hasClit = True};
isAgrFSg : Agr -> Bool = \ag ->
case <ag.n,ag.g,ag.p> of
{<Sg,Fem,P3> => True ;
_ => False
};
getConjComp : VP -> Agr -> {s: Agr => Str} = \vp,ag -> getConjComp : VP -> Agr -> {s: Agr => Str} = \vp,ag ->
{s = \\a => "sã" ++ (flattenSimpleClitics vp.nrClit vp.clAcc vp.clDat (vp.isRefl ! a)) ++ conjVP vp ag ++ vp.comp ! a ++ vp.ext ! Pos}; {s = \\a => "sã" ++ (flattenSimpleClitics vp.nrClit vp.clAcc vp.clDat (vp.isRefl ! a)) ++ conjVP vp ag ++ vp.comp ! a ++ vp.ext ! Pos};
oper nextClit : VClit -> ParClit -> VClit = \vc,pc ->
case vc of
{ VNone => VOne pc;
_ => VMany
};
-- discuss example -- discuss example
-- l -table (ComplSlash (Slash3V3 sell_V3 (UsePN john_PN)) (UsePN paris_PN)) -- l -table (ComplSlash (Slash3V3 sell_V3 (UsePN john_PN)) (UsePN paris_PN))
-- in English the direct object always comes first, which could lead to incorrect longer examples -- in English the direct object always comes first, which could lead to incorrect longer examples