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

restored a parsing grammar api/Browse

Browse Source
This commit is contained in:
aarne
2009-11-20 15:14:41 +00:00
parent 16c7420410
commit 29406fa916
6 changed files with 691 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
lib/doc/synopsis.html
View File

@@ -2779,10 +2779,19 @@ Lexical category, constructors given in
</P>
<A NAME="V2"></A>
<H2>V2 - two-place verb</H2>
<P>
Lexical category, constructors given in
<A HREF="#RParadigms">lexical paradigms</A>.
</P>
<TABLE CELLPADDING="4" BORDER="1">
<TR>
<TH>Function</TH>
<TH>Type</TH>
<TH COLSPAN="2">Example</TH>
</TR>
<TR>
<TD><CODE>have_V2</CODE></TD>
<TD><A HREF="#V2" TITLE="V2 - two-place verb">V2</A></TD>
<TD><I>have</I></TD>
</TR>
</TABLE>
<A NAME="V2A"></A>
<H2>V2A - verb with NP and AP complement</H2>
<P>
@@ -4561,7 +4570,7 @@ source <A HREF="../src/english/ParadigmsEng.gf"><CODE>http://www.cs.chalmers.se/
</TR>
<TR>
<TD><CODE>mkSubj</CODE></TD>
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <A HREF="#Subj" TITLE="Subj - subjunction">Subj</A> <CODE>=</CODE> <CODE>\s</CODE> <CODE>-&gt;</CODE> <CODE>{s</CODE> <CODE>=</CODE> <CODE>s</CODE> <CODE>lock_Subj</CODE> <CODE>=</CODE> <CODE>&lt;&gt;}</CODE></TD>
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <A HREF="#Subj" TITLE="Subj - subjunction">Subj</A> <CODE>=</CODE> <CODE>\s</CODE> <CODE>-&gt;</CODE> <CODE>lin</CODE> <A HREF="#Subj" TITLE="Subj - subjunction">Subj</A> <CODE>{s</CODE> <CODE>=</CODE> <CODE>s}</CODE></TD>
</TR>
</TABLE>
@@ -5923,7 +5932,11 @@ source <A HREF="../src/romanian/ParadigmsRon.gf"><CODE>http://www.cs.chalmers.se
</TR>
<TR>
<TD><CODE>mkPrep</CODE></TD>
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <A HREF="#NCase">NCase</A> <CODE>-&gt;</CODE> <A HREF="#Prep" TITLE="Prep - preposition, or just case">Prep</A></TD>
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <CODE>NCase-&gt;</CODE> <A HREF="#Bool">Bool</A> <CODE>-&gt;</CODE> <A HREF="#Prep" TITLE="Prep - preposition, or just case">Prep</A></TD>
</TR>
<TR>
<TD><CODE>mkPrep</CODE></TD>
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <A HREF="#NCase">NCase</A> <CODE>-&gt;</CODE> <CODE>Prep;</CODE></TD>
</TR>
<TR>
<TD><CODE>noPrep</CODE></TD>
@@ -5943,6 +5956,10 @@ source <A HREF="../src/romanian/ParadigmsRon.gf"><CODE>http://www.cs.chalmers.se
</TR>
<TR>
<TD><CODE>mkPN</CODE></TD>
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <CODE>Str</CODE> <CODE>-&gt;</CODE> <A HREF="#Gender">Gender</A> <CODE>-&gt;</CODE> <A HREF="#Number">Number</A> <CODE>-&gt;</CODE> <A HREF="#PN" TITLE="PN - proper name">PN</A> <CODE>=</CODE> <CODE>mkPropNI</CODE></TD>
</TR>
<TR>
<TD><CODE>mkPN</CODE></TD>
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <A HREF="#Gender">Gender</A> <CODE>-&gt;</CODE> <A HREF="#PN" TITLE="PN - proper name">PN</A> <CODE>=</CODE> <CODE>mkPropNoun</CODE></TD>
</TR>
<TR>
@@ -5950,6 +5967,14 @@ source <A HREF="../src/romanian/ParadigmsRon.gf"><CODE>http://www.cs.chalmers.se
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <A HREF="#Gender">Gender</A> <CODE>-&gt;</CODE> <A HREF="#Number">Number</A> <CODE>-&gt;</CODE> <A HREF="#PN" TITLE="PN - proper name">PN</A> <CODE>=</CODE> <CODE>mkProperNoun;</CODE></TD>
</TR>
<TR>
<TD><CODE>mkInAn</CODE></TD>
<TD><A HREF="#PN" TITLE="PN - proper name">PN</A> <CODE>-&gt;</CODE> <A HREF="#PN" TITLE="PN - proper name">PN</A> <CODE>=</CODE> <CODE>\romania</CODE> <CODE>-&gt;</CODE></TD>
</TR>
<TR>
<TD><CODE>mkPropNI</CODE></TD>
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <CODE>Str</CODE> <CODE>-&gt;</CODE> <A HREF="#Gender">Gender</A> <CODE>-&gt;</CODE> <A HREF="#Number">Number</A> <CODE>-&gt;</CODE> <A HREF="#PN" TITLE="PN - proper name">PN</A> <CODE>=</CODE></TD>
</TR>
<TR>
<TD><CODE>mkPropN</CODE></TD>
<TD><CODE>Str</CODE> <CODE>-&gt;</CODE> <A HREF="#PN" TITLE="PN - proper name">PN</A> <CODE>=</CODE> <CODE>\Ion</CODE> <CODE>-&gt;</CODE></TD>
</TR>

12
lib/doc/synopsis.txt
View File

@@ -623,8 +623,8 @@ Lexical category, constructors given in
Lexical category, constructors given in
[lexical paradigms #RParadigms].
==V2 - two-place verb==[V2]
Lexical category, constructors given in
[lexical paradigms #RParadigms].
|| Function | Type | Example ||
| ``have_V2`` | [V2 #V2] | //have// |
==V2A - verb with NP and AP complement==[V2A]
Lexical category, constructors given in
[lexical paradigms #RParadigms].
@@ -1106,7 +1106,7 @@ source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/english/Paradigms
| ``mkAV`` | [A #A] ``->`` [AV #AV] |
| ``mkA2V`` | [A #A] ``->`` [Prep #Prep] ``->`` [A2V #A2V] |
| ``V0`` | [Type #Type] |
| ``mkSubj`` | ``Str`` ``->`` [Subj #Subj] ``=`` ``\s`` ``->`` ``{s`` ``=`` ``s`` ``lock_Subj`` ``=`` ``<>}`` |
| ``mkSubj`` | ``Str`` ``->`` [Subj #Subj] ``=`` ``\s`` ``->`` ``lin`` [Subj #Subj] ``{s`` ``=`` ``s}`` |
==Paradigms for Finnish==
@@ -1496,13 +1496,17 @@ source [``http://www.cs.chalmers.se/~aarne/GF/lib/resource/src/romanian/Paradigm
| ``Acc`` | [NCase #NCase] |
| ``Dat`` | [NCase #NCase] |
| ``Gen`` | [NCase #NCase] |
| ``mkPrep`` | ``Str`` ``->`` [NCase #NCase] ``->`` [Prep #Prep] |
| ``mkPrep`` | ``Str`` ``->`` ``NCase->`` [Bool #Bool] ``->`` [Prep #Prep] |
| ``mkPrep`` | ``Str`` ``->`` [NCase #NCase] ``->`` ``Prep;`` |
| ``noPrep`` | [NCase #NCase] ``->`` [Prep #Prep] |
| ``mkN2`` | [N #N] ``->`` [Prep #Prep] ``->`` [N2 #N2] |
| ``mkN3`` | [N #N] ``->`` [Prep #Prep] ``->`` [Prep #Prep] ``->`` [N3 #N3] |
| ``mkPN`` | ``Str`` ``->`` [PN #PN] ``=`` ``mkPropN`` |
| ``mkPN`` | ``Str`` ``->`` ``Str`` ``->`` [Gender #Gender] ``->`` [Number #Number] ``->`` [PN #PN] ``=`` ``mkPropNI`` |
| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [PN #PN] ``=`` ``mkPropNoun`` |
| ``mkPN`` | ``Str`` ``->`` [Gender #Gender] ``->`` [Number #Number] ``->`` [PN #PN] ``=`` ``mkProperNoun;`` |
| ``mkInAn`` | [PN #PN] ``->`` [PN #PN] ``=`` ``\romania`` ``->`` |
| ``mkPropNI`` | ``Str`` ``->`` ``Str`` ``->`` [Gender #Gender] ``->`` [Number #Number] ``->`` [PN #PN] ``=`` |
| ``mkPropN`` | ``Str`` ``->`` [PN #PN] ``=`` ``\Ion`` ``->`` |
| ``mkPropNoun`` | ``Str`` ``->`` [Gender #Gender] ``->`` [PN #PN] ``=`` ``\Ion,`` ``gen`` ``->`` |
| ``mkProperNoun`` | ``Str`` ``->`` [Gender #Gender] ``->`` [Number #Number] ``->`` [PN #PN] ``=`` ``\Ion,`` ``gen,`` ``num`` ``->`` |

290
lib/src/api/Browse.gf Normal file
View File

@@ -0,0 +1,290 @@
abstract Browse = Cat, Conjunction, Numeral, Structural, Lexicon ** {
fun mkAP_1 : A -> AP ;
fun mkAP_2 : A -> NP -> AP ;
fun mkAP_3 : A2 -> NP -> AP ;
fun mkAP_4 : A2 -> AP ;
fun mkAP_5 : AP -> S -> AP ;
fun mkAP_6 : AP -> QS -> AP ;
fun mkAP_7 : AP -> VP -> AP ;
fun mkAP_8 : AdA -> A -> AP ;
fun mkAP_9 : AdA -> AP -> AP ;
fun mkAP_10 : Conj -> AP -> AP -> AP ;
fun mkAP_11 : Conj -> ListAP -> AP ;
fun mkAP_12 : Ord -> AP ;
fun mkAP_13 : CAdv -> AP -> NP -> AP ;
fun mkAdv_16 : A -> Adv ;
fun mkAdv_17 : Prep -> NP -> Adv ;
fun mkAdv_18 : CAdv -> A -> NP -> Adv ;
fun mkAdv_19 : CAdv -> A -> S -> Adv ;
fun mkAdv_20 : AdA -> Adv -> Adv ;
fun mkAdv_21 : Subj -> S -> Adv ;
fun mkAdv_22 : Conj -> Adv -> Adv -> Adv ;
fun mkAdv_23 : Conj -> ListAdv -> Adv ;
fun mkCl_24 : NP -> VP -> Cl ;
fun mkCl_25 : NP -> V -> Cl ;
fun mkCl_26 : NP -> V2 -> NP -> Cl ;
fun mkCl_27 : NP -> V3 -> NP -> NP -> Cl ;
fun mkCl_28 : NP -> VV -> VP -> Cl ;
fun mkCl_29 : NP -> VS -> S -> Cl ;
fun mkCl_30 : NP -> VQ -> QS -> Cl ;
fun mkCl_31 : NP -> VA -> AP -> Cl ;
fun mkCl_32 : NP -> V2A -> NP -> AP -> Cl ;
fun mkCl_33 : NP -> V2S -> NP -> S -> Cl ;
fun mkCl_34 : NP -> V2Q -> NP -> QS -> Cl ;
fun mkCl_35 : NP -> V2V -> NP -> VP -> Cl ;
fun mkCl_36 : VP -> Cl ;
fun mkCl_37 : NP -> RS -> Cl ;
fun mkCl_38 : Adv -> S -> Cl ;
fun mkCl_39 : N -> Cl ;
fun mkCl_40 : CN -> Cl ;
fun mkCl_41 : NP -> Cl ;
fun mkCl_42 : NP -> AP -> Cl ;
fun mkCl_43 : NP -> A -> Cl ;
fun mkCl_44 : NP -> A -> NP -> Cl ;
fun mkCl_45 : NP -> A2 -> NP -> Cl ;
fun mkCl_46 : NP -> NP -> Cl ;
fun mkCl_47 : NP -> CN -> Cl ;
fun mkCl_48 : NP -> N -> Cl ;
fun mkCl_49 : NP -> Adv -> Cl ;
fun mkCl_50 : V -> Cl ;
fun genericCl_51 : VP -> Cl ;
fun mkNP_58 : CN -> NP ;
fun mkNP_59 : N -> NP ;
fun mkNP_60 : Det -> CN -> NP ;
fun mkNP_61 : Det -> N -> NP ;
fun mkNP_62 : Quant -> NP ;
fun mkNP_63 : Quant -> Num -> NP ;
fun mkNP_64 : Det -> NP ;
fun mkNP_65 : Card -> CN -> NP ;
fun mkNP_66 : Card -> N -> NP ;
fun mkNP_67 : Quant -> CN -> NP ;
fun mkNP_68 : Quant -> N -> NP ;
fun mkNP_69 : Quant -> Num -> CN -> NP ;
fun mkNP_70 : Quant -> Num -> N -> NP ;
fun mkNP_71 : Pron -> CN -> NP ;
fun mkNP_72 : Pron -> N -> NP ;
fun mkNP_73 : Numeral -> CN -> NP ;
fun mkNP_74 : Numeral -> N -> NP ;
fun mkNP_75 : Digits -> CN -> NP ;
fun mkNP_76 : Digits -> N -> NP ;
fun mkNP_77 : Digit -> CN -> NP ;
fun mkNP_78 : Digit -> N -> NP ;
fun mkNP_79 : PN -> NP ;
fun mkNP_80 : Pron -> NP ;
fun mkNP_81 : Predet -> NP -> NP ;
fun mkNP_82 : NP -> V2 -> NP ;
fun mkNP_83 : NP -> Adv -> NP ;
fun mkNP_84 : NP -> RS -> NP ;
fun mkNP_85 : Conj -> NP -> NP -> NP ;
fun mkNP_86 : Conj -> ListNP -> NP ;
fun mkDet_90 : Quant -> Ord -> Det ;
fun mkDet_91 : Quant -> Det ;
fun mkDet_92 : Quant -> Num -> Ord -> Det ;
fun mkDet_93 : Quant -> Num -> Det ;
fun mkDet_94 : Card -> Det ;
fun mkDet_95 : Digits -> Det ;
fun mkDet_96 : Numeral -> Det ;
fun mkDet_97 : Pron -> Det ;
fun mkDet_98 : Pron -> Num -> Det ;
fun sgNum_101 : Num ;
fun plNum_102 : Num ;
fun mkCard_103 : Numeral -> Card ;
fun mkCard_104 : Digits -> Card ;
fun mkCard_105 : AdN -> Card -> Card ;
fun mkNum_106 : Numeral -> Num ;
fun mkNum_107 : Digits -> Num ;
fun mkNum_108 : Digit -> Num ;
fun mkNum_109 : Card -> Num ;
fun mkNum_110 : AdN -> Card -> Num ;
fun mkOrd_111 : Numeral -> Ord ;
fun mkOrd_112 : Digits -> Ord ;
fun mkOrd_113 : Digit -> Ord ;
fun mkOrd_114 : A -> Ord ;
fun mkAdN_141 : CAdv -> AdN ;
fun mkDigits_142 : Dig -> Digits ;
fun mkDigits_143 : Dig -> Digits -> Digits ;
fun mkCN_154 : N -> CN ;
fun mkCN_155 : N2 -> NP -> CN ;
fun mkCN_156 : N3 -> NP -> NP -> CN ;
fun mkCN_157 : N2 -> CN ;
fun mkCN_158 : N3 -> CN ;
fun mkCN_159 : AP -> CN -> CN ;
fun mkCN_160 : AP -> N -> CN ;
fun mkCN_161 : CN -> AP -> CN ;
fun mkCN_162 : N -> AP -> CN ;
fun mkCN_163 : A -> CN -> CN ;
fun mkCN_164 : A -> N -> CN ;
fun mkCN_165 : CN -> RS -> CN ;
fun mkCN_166 : N -> RS -> CN ;
fun mkCN_167 : CN -> Adv -> CN ;
fun mkCN_168 : N -> Adv -> CN ;
fun mkCN_169 : CN -> S -> CN ;
fun mkCN_170 : CN -> QS -> CN ;
fun mkCN_171 : CN -> VP -> CN ;
fun mkCN_172 : CN -> NP -> CN ;
fun mkCN_173 : N -> NP -> CN ;
fun mkPhr_174 : PConj -> Utt -> Voc -> Phr ;
fun mkPhr_175 : Utt -> Voc -> Phr ;
fun mkPhr_176 : PConj -> Utt -> Phr ;
fun mkPhr_177 : Utt -> Phr ;
fun mkPhr_178 : S -> Phr ;
fun mkPhr_179 : Cl -> Phr ;
fun mkPhr_180 : QS -> Phr ;
fun mkPhr_181 : Imp -> Phr ;
fun mkPConj_182 : Conj -> PConj ;
fun noPConj_183 : PConj ;
fun mkVoc_184 : NP -> Voc ;
fun noVoc_185 : Voc ;
fun positivePol_186 : Pol ;
fun negativePol_187 : Pol ;
fun simultaneousAnt_188 : Ant ;
fun anteriorAnt_189 : Ant ;
fun presentTense_190 : Tense ;
fun pastTense_191 : Tense ;
fun futureTense_192 : Tense ;
fun conditionalTense_193 : Tense ;
--fun singularImpForm_194 : ImpForm ;
--fun pluralImpForm_195 : ImpForm ;
--fun politeImpForm_196 : ImpForm ;
fun mkUtt_197 : S -> Utt ;
fun mkUtt_198 : Cl -> Utt ;
fun mkUtt_199 : QS -> Utt ;
fun mkUtt_200 : QCl -> Utt ;
--fun mkUtt_201 : ImpForm -> Pol -> Imp -> Utt ;
--fun mkUtt_202 : ImpForm -> Imp -> Utt ;
fun mkUtt_203 : Pol -> Imp -> Utt ;
fun mkUtt_204 : Imp -> Utt ;
fun mkUtt_205 : IP -> Utt ;
fun mkUtt_206 : IAdv -> Utt ;
fun mkUtt_207 : NP -> Utt ;
fun mkUtt_208 : Adv -> Utt ;
fun mkUtt_209 : VP -> Utt ;
fun lets_Utt_210 : VP -> Utt ;
fun mkQCl_211 : Cl -> QCl ;
fun mkQCl_212 : IP -> VP -> QCl ;
fun mkQCl_213 : IP -> ClSlash -> QCl ;
fun mkQCl_214 : IP -> NP -> V2 -> QCl ;
fun mkQCl_215 : IAdv -> Cl -> QCl ;
fun mkQCl_216 : Prep -> IP -> Cl -> QCl ;
fun mkQCl_217 : IAdv -> NP -> QCl ;
fun mkQCl_218 : IP -> NP -> QCl ;
fun mkQCl_219 : IP -> QCl ;
fun mkIP_220 : IDet -> CN -> IP ;
fun mkIP_221 : IDet -> N -> IP ;
fun mkIP_222 : IQuant -> CN -> IP ;
fun mkIP_223 : IQuant -> Num -> CN -> IP ;
fun mkIP_224 : IQuant -> N -> IP ;
fun mkIP_225 : IP -> Adv -> IP ;
fun mkIDet_226 : IQuant -> Num -> IDet ;
fun mkIDet_227 : IQuant -> IDet ;
fun whichSg_IDet_228 : IDet ;
fun whichPl_IDet_229 : IDet ;
fun what_IP_230 : IP ;
fun who_IP_231 : IP ;
fun which_IDet_232 : IDet ;
fun mkIAdv_233 : Prep -> IP -> IAdv ;
fun mkRCl_234 : Cl -> RCl ;
fun mkRCl_235 : RP -> VP -> RCl ;
fun mkRCl_236 : RP -> ClSlash -> RCl ;
fun mkRCl_237 : RP -> NP -> V2 -> RCl ;
fun which_RP_238 : RP ;
fun mkRP_239 : Prep -> NP -> RP -> RP ;
fun mkClSlash_240 : NP -> V2 -> ClSlash ;
fun mkClSlash_241 : NP -> VV -> V2 -> ClSlash ;
fun mkClSlash_242 : ClSlash -> Adv -> ClSlash ;
fun mkClSlash_243 : Cl -> Prep -> ClSlash ;
fun mkImp_244 : VP -> Imp ;
fun mkImp_245 : V -> Imp ;
fun mkImp_246 : V2 -> NP -> Imp ;
fun mkS_400 : Cl -> S ;
fun mkS_247 : Tense -> Cl -> S ;
fun mkS_248 : Ant -> Cl -> S ;
fun mkS_249 : Pol -> Cl -> S ;
fun mkS_250 : Tense -> Ant -> Cl -> S ;
fun mkS_251 : Tense -> Pol -> Cl -> S ;
fun mkS_252 : Ant -> Pol -> Cl -> S ;
fun mkS_253 : Tense -> Ant -> Pol -> Cl -> S ;
fun mkS_254 : Conj -> S -> S -> S ;
fun mkS_255 : Conj -> ListS -> S ;
fun mkS_256 : Adv -> S -> S ;
fun mkQS_257 : QCl -> QS ;
fun mkQS_258 : Tense -> QCl -> QS ;
fun mkQS_259 : Ant -> QCl -> QS ;
fun mkQS_260 : Pol -> QCl -> QS ;
fun mkQS_261 : Tense -> Ant -> QCl -> QS ;
fun mkQS_262 : Tense -> Pol -> QCl -> QS ;
fun mkQS_263 : Ant -> Pol -> QCl -> QS ;
fun mkQS_264 : Tense -> Ant -> Pol -> QCl -> QS ;
fun mkQS_265 : Cl -> QS ;
fun mkRS_266 : RCl -> RS ;
fun mkRS_267 : Tense -> RCl -> RS ;
fun mkRS_268 : Ant -> RCl -> RS ;
fun mkRS_269 : Pol -> RCl -> RS ;
fun mkRS_270 : Tense -> Ant -> RCl -> RS ;
fun mkRS_271 : Tense -> Pol -> RCl -> RS ;
fun mkRS_272 : Ant -> Pol -> RCl -> RS ;
fun mkRS_273 : Tense -> Ant -> Pol -> RCl -> RS ;
fun mkRS_274 : Conj -> RS -> RS -> RS ;
fun mkRS_275 : Conj -> ListRS -> RS ;
fun emptyText_276 : Text ;
fun mkText_280 : Phr -> Text ;
fun mkText_281 : Utt -> Text ;
fun mkText_282 : S -> Text ;
fun mkText_283 : Cl -> Text ;
fun mkText_284 : QS -> Text ;
fun mkText_285 : Imp -> Text ;
fun mkText_286 : Pol -> Imp -> Text ;
fun mkText_287 : Phr -> Text -> Text ;
fun mkVP_288 : V -> VP ;
fun mkVP_289 : V2 -> NP -> VP ;
fun mkVP_290 : V3 -> NP -> NP -> VP ;
fun mkVP_291 : VV -> VP -> VP ;
fun mkVP_292 : VS -> S -> VP ;
fun mkVP_293 : VQ -> QS -> VP ;
fun mkVP_294 : VA -> AP -> VP ;
fun mkVP_295 : V2A -> NP -> AP -> VP ;
fun mkVP_296 : V2S -> NP -> S -> VP ;
fun mkVP_297 : V2Q -> NP -> QS -> VP ;
fun mkVP_298 : V2V -> NP -> VP -> VP ;
fun mkVP_299 : A -> VP ;
fun mkVP_300 : A -> NP -> VP ;
fun mkVP_301 : A2 -> NP -> VP ;
fun mkVP_302 : AP -> VP ;
fun mkVP_303 : NP -> VP ;
fun mkVP_304 : CN -> VP ;
fun mkVP_305 : N -> VP ;
fun mkVP_306 : Adv -> VP ;
fun mkVP_307 : VP -> Adv -> VP ;
fun mkVP_308 : AdV -> VP -> VP ;
fun mkVP_309 : VPSlash -> NP -> VP ;
fun mkVP_310 : VPSlash -> VP ;
fun reflexiveVP_311 : V2 -> VP ;
fun mkVPSlash_312 : V2 -> VPSlash ;
fun mkVPSlash_313 : V3 -> NP -> VPSlash ;
fun mkVPSlash_314 : V2A -> AP -> VPSlash ;
fun mkVPSlash_315 : V2Q -> QS -> VPSlash ;
fun mkVPSlash_316 : V2S -> S -> VPSlash ;
fun mkVPSlash_317 : V2V -> VP -> VPSlash ;
fun passiveVP_318 : V2 -> VP ;
fun passiveVP_319 : V2 -> NP -> VP ;
fun progressiveVP_320 : VP -> VP ;
fun mkListS_321 : S -> S -> ListS ;
fun mkListS_322 : S -> ListS -> ListS ;
fun mkListAP_323 : AP -> AP -> ListAP ;
fun mkListAP_324 : AP -> ListAP -> ListAP ;
fun mkListAdv_325 : Adv -> Adv -> ListAdv ;
fun mkListAdv_326 : Adv -> ListAdv -> ListAdv ;
fun mkListNP_327 : NP -> NP -> ListNP ;
fun mkListNP_328 : NP -> ListNP -> ListNP ;
fun mkListRS_329 : RS -> RS -> ListRS ;
fun mkListRS_330 : RS -> ListRS -> ListRS ;
fun that_NP_331 : NP ;
fun this_NP_332 : NP ;
fun those_NP_333 : NP ;
fun these_NP_334 : NP ;
fun that_Det_335 : Det ;
fun this_Det_336 : Det ;
fun those_Det_337 : Det ;
fun these_Det_338 : Det ;
}

331
lib/src/api/BrowseEng.gf Normal file
View File

@@ -0,0 +1,331 @@
--# -path=.:alltenses
concrete BrowseEng of Browse = CatEng, ConjunctionEng, NumeralEng, LexiconEng, StructuralEng ** open LangEng in {
lin mkAP_1 = PositA ;
lin mkAP_2 = ComparA ;
lin mkAP_3 = ComplA2 ;
lin mkAP_4 = UseA2 ;
lin mkAP_5 = \ap,s -> SentAP ap (EmbedS s) ;
lin mkAP_6 = \ap,s -> SentAP ap (EmbedQS s) ;
lin mkAP_7 = \ap,s -> SentAP ap (EmbedVP s) ;
lin mkAP_8 = \x,y -> AdAP x (PositA y) ;
lin mkAP_9 = AdAP ;
lin mkAP_10 = \c,x,y -> ConjAP c (BaseAP x y) ;
lin mkAP_11 = \c,xy -> ConjAP c xy ;
lin mkAP_12 = AdjOrd ;
lin mkAP_13 = CAdvAP ;
lin mkAdv_16 = PositAdvAdj ;
lin mkAdv_17 = PrepNP ;
lin mkAdv_18 = ComparAdvAdj ;
lin mkAdv_19 = ComparAdvAdjS ;
lin mkAdv_20 = AdAdv ;
lin mkAdv_21 = SubjS ;
lin mkAdv_22 = \c,x,y -> ConjAdv c (BaseAdv x y) ;
lin mkAdv_23 = \c,xy -> ConjAdv c xy ;
lin mkCl_24 = PredVP ;
lin mkCl_25 = \s,v -> PredVP s (UseV v) ;
lin mkCl_26 = \s,v,o -> PredVP s (ComplV2 v o) ;
lin mkCl_27 = \s,v,o,i -> PredVP s (ComplV3 v o i) ;
lin mkCl_28 = \s,v,vp -> PredVP s (ComplVV v vp) ;
lin mkCl_29 = \s,v,p -> PredVP s (ComplVS v p) ;
lin mkCl_30 = \s,v,q -> PredVP s (ComplVQ v q) ;
lin mkCl_31 = \s,v,q -> PredVP s (ComplVA v q) ;
lin mkCl_32 = \s,v,n,q -> PredVP s (ComplV2A v n q) ;
lin mkCl_33 = \s,v,n,q -> PredVP s (ComplSlash (SlashV2S v q) n) ;
lin mkCl_34 = \s,v,n,q -> PredVP s (ComplSlash (SlashV2Q v q) n) ;
lin mkCl_35 = \s,v,n,q -> PredVP s (ComplSlash (SlashV2V v q) n) ;
lin mkCl_36 = ImpersCl ;
lin mkCl_37 = CleftNP ;
lin mkCl_38 = CleftAdv ;
lin mkCl_39 = \y -> ExistNP (DetArtSg IndefArt (UseN y)) ;
lin mkCl_40 = \y -> ExistNP (DetArtSg IndefArt y) ;
lin mkCl_41 = ExistNP ;
lin mkCl_42 = \x,y -> PredVP x (UseComp (CompAP y)) ;
lin mkCl_43 = \x,y -> PredVP x (UseComp (CompAP (PositA y))) ;
lin mkCl_44 = \x,y,z -> PredVP x (UseComp (CompAP (ComparA y z))) ;
lin mkCl_45 = \x,y,z -> PredVP x (UseComp (CompAP (ComplA2 y z))) ;
lin mkCl_46 = \x,y -> PredVP x (UseComp (CompNP y)) ;
lin mkCl_47 = \x,y -> PredVP x (UseComp (CompNP (DetArtSg IndefArt y))) ;
lin mkCl_48 = \x,y -> PredVP x (UseComp (CompNP (DetArtSg IndefArt (UseN y)))) ;
lin mkCl_49 = \x,y -> PredVP x (UseComp (CompAdv y)) ;
lin mkCl_50 = \v -> ImpersCl (UseV v) ;
lin genericCl_51 = GenericCl ;
lin mkNP_58 = MassNP ;
lin mkNP_59 = \n -> MassNP (UseN n) ;
lin mkNP_60 = DetCN ;
lin mkNP_61 = \d,n -> DetCN d (UseN n) ;
lin mkNP_62 = \q -> DetNP (DetQuant q NumSg) ;
lin mkNP_63 = \q,n -> DetNP (DetQuant q n) ;
lin mkNP_64 = DetNP ;
lin mkNP_65 = \d,n -> DetCN (DetArtCard IndefArt d) n ;
lin mkNP_66 = \d,n -> DetCN (DetArtCard IndefArt d) (UseN n) ;
lin mkNP_67 = \q,n -> DetCN (DetQuant q NumSg) n ;
lin mkNP_68 = \q,n -> DetCN (DetQuant q NumSg) (UseN n) ;
lin mkNP_69 = \q,nu,n -> DetCN (DetQuant q nu) n ;
lin mkNP_70 = \q,nu,n -> DetCN (DetQuant q nu) (UseN n) ;
lin mkNP_71 = \p,n -> DetCN (DetQuant (PossPron p) NumSg) n ;
lin mkNP_72 = \p,n -> DetCN (DetQuant (PossPron p) NumSg) (UseN n) ;
lin mkNP_73 = \d,n -> DetCN (DetArtCard IndefArt (NumNumeral d)) n ;
lin mkNP_74 = \d,n -> DetCN (DetArtCard IndefArt (NumNumeral d)) (UseN n) ;
lin mkNP_75 = \d,n -> DetCN (DetArtCard IndefArt (NumDigits d)) n ;
lin mkNP_76 = \d,n -> DetCN (DetArtCard IndefArt (NumDigits d)) (UseN n) ;
lin mkNP_77 = \d,n -> DetCN (DetArtCard IndefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))))) n ;
lin mkNP_78 = \d,n -> DetCN (DetArtCard IndefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))))) (UseN n) ;
lin mkNP_79 = UsePN ;
lin mkNP_80 = UsePron ;
lin mkNP_81 = PredetNP ;
lin mkNP_82 = PPartNP ;
lin mkNP_83 = AdvNP ;
lin mkNP_84 = RelNP ;
--lin mkNP_85 = \c,x,y -> ConjNP c (BaseNP x y) ;
lin mkNP_86 = \c,xy -> ConjNP c xy ;
lin mkNP_87 = \q,n -> DetCN (DetQuant q NumSg) n ;
lin mkNP_88 = \q,n -> DetCN (DetQuant q NumPl) n ;
lin mkDet_89 = \d,nu -> (DetArtCard d nu) ;
lin mkDet_90 = \q,o -> DetQuantOrd q NumSg o ;
lin mkDet_91 = \q -> DetQuant q NumSg ;
lin mkDet_92 = DetQuantOrd ;
lin mkDet_93 = DetQuant ;
lin mkDet_94 = DetArtCard IndefArt ;
lin mkDet_95 = \d -> DetArtCard IndefArt (NumDigits d) ;
lin mkDet_96 = \d -> DetArtCard IndefArt (NumNumeral d) ;
lin mkDet_97 = \p -> DetQuant (PossPron p) NumSg ;
lin mkDet_98 = \p -> DetQuant (PossPron p) ;
lin the_Art_99 = DefArt ;
lin a_Art_100 = IndefArt ;
lin sgNum_101 = NumSg ;
lin plNum_102 = NumPl ;
lin mkCard_103 = NumNumeral ;
lin mkCard_104 = NumDigits ;
lin mkCard_105 = AdNum ;
lin mkNum_106 = \d -> NumCard (NumNumeral d) ;
lin mkNum_107 = \d -> NumCard (NumDigits d) ;
lin mkNum_108 = \d -> NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d)))))) ;
lin mkNum_109 = NumCard ;
lin mkNum_110 = \a,c -> NumCard (AdNum a c) ;
lin mkOrd_111 = OrdNumeral ;
lin mkOrd_112 = OrdDigits ;
lin mkOrd_113 = \d -> OrdNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))) ;
lin mkOrd_114 = OrdSuperl ;
lin mkAdN_141 = AdnCAdv ;
lin mkDigits_142 = IDig ;
lin mkDigits_143 = IIDig ;
lin mkCN_154 = UseN ;
lin mkCN_155 = ComplN2 ;
lin mkCN_156 = \f,x -> ComplN2 (ComplN3 f x) ;
lin mkCN_157 = UseN2 ;
lin mkCN_158 = \n -> UseN2 (Use2N3 n) ;
lin mkCN_159 = AdjCN ;
lin mkCN_160 = \x,y -> AdjCN x (UseN y) ;
lin mkCN_161 = \x,y -> AdjCN y x ;
lin mkCN_162 = \x,y -> AdjCN y (UseN x) ;
lin mkCN_163 = \x,y -> AdjCN (PositA x) y ;
lin mkCN_164 = \x,y -> AdjCN (PositA x) (UseN y) ;
lin mkCN_165 = RelCN ;
lin mkCN_166 = \x,y -> RelCN (UseN x) y ;
lin mkCN_167 = AdvCN ;
lin mkCN_168 = \x,y -> AdvCN (UseN x) y ;
lin mkCN_169 = \cn,s -> SentCN cn (EmbedS s) ;
lin mkCN_170 = \cn,s -> SentCN cn (EmbedQS s) ;
lin mkCN_171 = \cn,s -> SentCN cn (EmbedVP s) ;
lin mkCN_172 = ApposCN ;
lin mkCN_173 = \x,y -> ApposCN (UseN x) y ;
lin mkPhr_174 = PhrUtt ;
lin mkPhr_175 = \u,v -> PhrUtt NoPConj u v ;
lin mkPhr_176 = \u,v -> PhrUtt u v NoVoc ;
lin mkPhr_177 = \u -> PhrUtt NoPConj u NoVoc ;
lin mkPhr_178 = \s -> PhrUtt NoPConj (UttS s) NoVoc ;
lin mkPhr_179 = \s -> PhrUtt NoPConj (UttS (TUseCl TPres ASimul PPos s)) NoVoc ;
lin mkPhr_180 = \s -> PhrUtt NoPConj (UttQS s) NoVoc ;
lin mkPhr_181 = \s -> PhrUtt NoPConj (UttImpSg PPos s) NoVoc ;
lin mkPConj_182 = PConjConj ;
lin noPConj_183 = NoPConj ;
lin mkVoc_184 = VocNP ;
lin noVoc_185 = NoVoc ;
lin positivePol_186 = PPos ;
lin negativePol_187 = PNeg ;
lin simultaneousAnt_188 = ASimul ;
lin anteriorAnt_189 = AAnter ;
lin presentTense_190 = TPres ;
lin pastTense_191 = TPast ;
lin futureTense_192 = TFut ;
lin conditionalTense_193 = TCond ;
lin singularImpForm_194 = IFSg ;
lin pluralImpForm_195 = IFPl ;
lin politeImpForm_196 = IFPol ;
lin mkUtt_197 = UttS ;
lin mkUtt_198 = \c -> UttS (TUseCl TPres ASimul PPos c) ;
lin mkUtt_199 = UttQS ;
lin mkUtt_200 = \c -> UttQS (TUseQCl TPres ASimul PPos c) ;
lin mkUtt_201 = mkUttImp ;
lin mkUtt_202 = \f -> mkUttImp f PPos ;
lin mkUtt_203 = UttImpSg ;
lin mkUtt_204 = UttImpSg PPos ;
lin mkUtt_205 = UttIP ;
lin mkUtt_206 = UttIAdv ;
lin mkUtt_207 = UttNP ;
lin mkUtt_208 = UttAdv ;
lin mkUtt_209 = UttVP ;
lin lets_Utt_210 = ImpPl1 ;
lin mkQCl_211 = QuestCl ;
lin mkQCl_212 = QuestVP ;
lin mkQCl_213 = QuestSlash ;
lin mkQCl_214 = \ip,np,v -> QuestSlash ip (SlashVP np (SlashV2a v)) ;
lin mkQCl_215 = QuestIAdv ;
lin mkQCl_216 = \p,ip -> QuestIAdv (PrepIP p ip) ;
lin mkQCl_217 = \a -> QuestIComp (CompIAdv a) ;
lin mkQCl_218 = \a -> QuestIComp (CompIP a) ;
lin mkQCl_219 = ExistIP ;
lin mkIP_220 = IdetCN ;
lin mkIP_221 = \i,n -> IdetCN i (UseN n) ;
lin mkIP_222 = \i,n -> IdetCN (IdetQuant i NumSg) n ;
lin mkIP_223 = \i,nu,n -> IdetCN (IdetQuant i nu) n ;
lin mkIP_224 = \i,n -> IdetCN (IdetQuant i NumSg) (UseN n) ;
lin mkIP_225 = AdvIP ;
lin mkIDet_226 = \i,nu -> IdetQuant i nu ;
lin mkIDet_227 = \i -> IdetQuant i NumSg ;
lin whichSg_IDet_228 = IdetQuant which_IQuant NumSg ;
lin whichPl_IDet_229 = IdetQuant which_IQuant NumPl ;
lin what_IP_230 = whatSg_IP ;
lin who_IP_231 = whoSg_IP ;
lin which_IDet_232 = whichSg_IDet ;
lin mkIAdv_233 = PrepIP ;
lin mkRCl_234 = RelCl ;
lin mkRCl_235 = RelVP ;
lin mkRCl_236 = RelSlash ;
lin mkRCl_237 = \rp,np,v2 -> RelSlash rp (SlashVP np (SlashV2a v2)) ;
lin which_RP_238 = IdRP ;
lin mkRP_239 = FunRP ;
lin mkClSlash_240 = \np,v2 -> SlashVP np (SlashV2a v2) ;
lin mkClSlash_241 = \np,vv,v2 -> SlashVP np (SlashVV vv (SlashV2a v2)) ;
lin mkClSlash_242 = AdvSlash ;
lin mkClSlash_243 = SlashPrep ;
lin mkImp_244 = ImpVP ;
lin mkImp_245 = \v -> ImpVP (UseV v) ;
lin mkImp_246 = \v,np -> ImpVP (ComplV2 v np) ;
lin mkS_400 = TUseCl TPres ASimul PPos ;
lin mkS_247 = \t -> TUseCl t ASimul PPos ;
lin mkS_248 = \a -> TUseCl TPres a PPos ;
lin mkS_249 = \p -> TUseCl TPres ASimul p ;
lin mkS_250 = \t,a -> TUseCl t a PPos ;
lin mkS_251 = \t,p -> TUseCl t ASimul p ;
lin mkS_252 = \a,p -> TUseCl TPres a p ;
lin mkS_253 = \t,a -> TUseCl t a ;
lin mkS_254 = \c,x,y -> ConjS c (BaseS x y) ;
lin mkS_255 = \c,xy -> ConjS c xy ;
lin mkS_256 = AdvS ;
lin mkQS_257 = TUseQCl TPres ASimul PPos ;
lin mkQS_258 = \t -> TUseQCl t ASimul PPos ;
lin mkQS_259 = \a -> TUseQCl TPres a PPos ;
lin mkQS_260 = \p -> TUseQCl TPres ASimul p ;
lin mkQS_261 = \t,a -> TUseQCl t a PPos ;
lin mkQS_262 = \t,p -> TUseQCl t ASimul p ;
lin mkQS_263 = \a,p -> TUseQCl TPres a p ;
lin mkQS_264 = TUseQCl ;
lin mkQS_265 = \x -> TUseQCl TPres ASimul PPos (QuestCl x) ;
lin mkRS_266 = TUseRCl TPres ASimul PPos ;
lin mkRS_267 = \t -> TUseRCl t ASimul PPos ;
lin mkRS_268 = \a -> TUseRCl TPres a PPos ;
lin mkRS_269 = \p -> TUseRCl TPres ASimul p ;
lin mkRS_270 = \t,a -> TUseRCl t a PPos ;
lin mkRS_271 = \t,p -> TUseRCl t ASimul p ;
lin mkRS_272 = \a,p -> TUseRCl TPres a p ;
lin mkRS_273 = TUseRCl ;
lin mkRS_274 = \c,x,y -> ConjRS c (BaseRS x y) ;
lin mkRS_275 = \c,xy -> ConjRS c xy ;
lin emptyText_276 = TEmpty ;
--lin fullStopPunct_277 = PFullStop ;
--lin questMarkPunct_278 = PQuestMark ;
--lin exclMarkPunct_279 = PExclMark ;
lin mkText_280 = \x -> TFullStop x TEmpty ;
lin mkText_281 = \u -> TFullStop (PhrUtt NoPConj u NoVoc) TEmpty ;
lin mkText_282 = \s -> TFullStop (PhrUtt NoPConj (UttS s) NoVoc) TEmpty ;
lin mkText_283 = \c -> TFullStop (PhrUtt NoPConj (UttS (TUseCl TPres ASimul PPos c)) NoVoc) TEmpty ;
lin mkText_284 = \q -> TQuestMark (PhrUtt NoPConj (UttQS q) NoVoc) TEmpty ;
lin mkText_285 = \i -> TExclMark (PhrUtt NoPConj (UttImpSg PPos i) NoVoc) TEmpty ;
lin mkText_286 = \p,i -> TExclMark (PhrUtt NoPConj (UttImpSg p i) NoVoc) TEmpty ;
lin mkText_287 = TFullStop ;
lin mkVP_288 = UseV ;
lin mkVP_289 = ComplV2 ;
lin mkVP_290 = ComplV3 ;
lin mkVP_291 = ComplVV ;
lin mkVP_292 = ComplVS ;
lin mkVP_293 = ComplVQ ;
lin mkVP_294 = ComplVA ;
lin mkVP_295 = ComplV2A ;
lin mkVP_296 = \v,n,q -> (ComplSlash (SlashV2S v q) n) ;
lin mkVP_297 = \v,n,q -> (ComplSlash (SlashV2Q v q) n) ;
lin mkVP_298 = \v,n,q -> (ComplSlash (SlashV2V v q) n) ;
lin mkVP_299 = \a -> UseComp (CompAP (PositA a)) ;
lin mkVP_300 = \y,z -> (UseComp (CompAP (ComparA y z))) ;
lin mkVP_301 = \y,z -> (UseComp (CompAP (ComplA2 y z))) ;
lin mkVP_302 = \a -> UseComp (CompAP a) ;
lin mkVP_303 = \a -> UseComp (CompNP a) ;
lin mkVP_304 = \y -> (UseComp (CompNP (DetArtSg IndefArt y))) ;
lin mkVP_305 = \y -> (UseComp (CompNP (DetArtSg IndefArt (UseN y)))) ;
lin mkVP_306 = \a -> UseComp (CompAdv a) ;
lin mkVP_307 = AdvVP ;
lin mkVP_308 = AdVVP ;
lin mkVP_309 = ComplSlash ;
lin mkVP_310 = ReflVP ;
lin reflexiveVP_311 = \v -> ReflVP (SlashV2a v) ;
lin mkVPSlash_312 = SlashV2a ;
lin mkVPSlash_313 = Slash2V3 ;
lin mkVPSlash_314 = SlashV2A ;
lin mkVPSlash_315 = SlashV2Q ;
lin mkVPSlash_316 = SlashV2S ;
lin mkVPSlash_317 = SlashV2V ;
lin passiveVP_318 = PassV2 ;
lin passiveVP_319 = \v,np -> (AdvVP (PassV2 v) (PrepNP by8agent_Prep np)) ;
lin progressiveVP_320 = ProgrVP ;
lin mkListS_321 = BaseS ;
lin mkListS_322 = ConsS ;
lin mkListAP_323 = BaseAP ;
lin mkListAP_324 = ConsAP ;
lin mkListAdv_325 = BaseAdv ;
lin mkListAdv_326 = ConsAdv ;
lin mkListNP_327 = BaseNP ;
lin mkListNP_328 = ConsNP ;
lin mkListRS_329 = BaseRS ;
lin mkListRS_330 = ConsRS ;
lin that_NP_331 = DetNP (DetQuant that_Quant NumSg) ;
lin this_NP_332 = DetNP (DetQuant this_Quant NumSg) ;
lin those_NP_333 = DetNP (DetQuant that_Quant NumPl) ;
lin these_NP_334 = DetNP (DetQuant this_Quant NumPl) ;
lin that_Det_335 = (DetQuant that_Quant NumSg) ;
lin this_Det_336 = (DetQuant this_Quant NumSg) ;
lin those_Det_337 = (DetQuant that_Quant NumPl) ;
lin these_Det_338 = (DetQuant this_Quant NumPl) ;
oper
ComplV2 : V2 -> NP -> VP = \v,np -> ComplSlash (SlashV2a v) np ;
ComplV2A : V2A -> NP -> AP -> VP = \v,np,ap -> ComplSlash (SlashV2A v ap) np ; --# notminimal
ComplV3 : V3 -> NP -> NP -> VP = \v,o,d -> ComplSlash (Slash3V3 v o) d ;
DetArtSg : Quant -> CN -> NP = \a -> DetCN (DetQuant a NumSg) ;
DetArtPl : Quant -> CN -> NP = \a -> DetCN (DetQuant a NumPl) ;
DetArtOrd : Quant -> Num -> Ord -> Det = DetQuantOrd ; --# notminimal
DetArtCard : Quant -> Card -> Det = \a,c -> DetQuant a (NumCard c) ;
TUseCl : Tense -> Ant -> Pol -> Cl -> S = \t,a -> UseCl (TTAnt t a) ;
TUseQCl : Tense -> Ant -> Pol -> QCl -> QS = \t,a -> UseQCl (TTAnt t a) ;
TUseRCl : Tense -> Ant -> Pol -> RCl -> RS = \t,a -> UseRCl (TTAnt t a) ; --# notminimal
param ImpForm = IFSg | IFPl | IFPol ; --# notminimal
oper --# notminimal
singularImpForm : ImpForm = IFSg ; --# notminimal
pluralImpForm : ImpForm = IFPl ; --# notminimal
politeImpForm : ImpForm = IFPol ; --# notminimal
mkUttImp : ImpForm -> Pol -> Imp -> Utt = \f,p,i -> case f of { --# notminimal
IFSg => UttImpSg p i ; --# notminimal
IFPl => UttImpPl p i ; --# notminimal
IFPol => UttImpPol p i --# notminimal
} ; --# notminimal
whichSg_IDet : IDet = IdetQuant which_IQuant NumSg ; --# notminimal
whichPl_IDet : IDet = IdetQuant which_IQuant NumPl ; --# notminimal
}

26
lib/src/api/MkBrowse.hs Normal file
View File

@@ -0,0 +1,26 @@
main = interact mkBrowse
mkBrowse = unlines . map mkJment . zip [1..] . jments
jments = chop ';'
mkJment (i,j) = case words j of
f:":":ws -> toJment f i (break (=="=") ws)
_ -> []
toJment f0 i (ty,de) = let f = f0 ++ "_" ++ show i in unlines $ map unwords [
["fun",f,":",unwords ty,";"],
["lin",f,"=",unwords de,";"]
]
chop c s = case break (==c) s of
(j,_:cs) -> j : chop c cs
(j,_) -> [j]
uncomm = unlines . map unc . lines
unc l = case l of
'-':'-':_ -> []
c : cs -> c : unc cs
_ -> l

8
src/GF/Command/Commands.hs
View File

@@ -480,9 +480,10 @@ allCommands cod env@(pgf, mos) = Map.fromList [
examples = [
"pt -compute (plus one two) -- compute value"
],
exec = \opts -> returnFromExprs . treeOps opts,
exec = \opts ->
returnFromExprs . takeOptNum opts . treeOps opts,
options = treeOpOptions pgf,
flags = treeOpFlags pgf
flags = [("number","take at most this many trees")] ++ treeOpFlags pgf
}),
("q", emptyCommandInfo {
longname = "quit",
@@ -821,7 +822,8 @@ allCommands cod env@(pgf, mos) = Map.fromList [
optViewGraph opts = valStrOpts "view" "open" opts
optNum opts = valIntOpts "number" 1 opts
optNumInf opts = valIntOpts "number" 1000000000 opts ---- 10^9
takeOptNum opts = take (optNumInf opts)
fromExprs es = (es,unlines (map (showExpr []) es))
fromStrings ss = (map (ELit . LStr) ss, unlines ss)
fromString s = ([ELit (LStr s)], s)