From e5c81a13f6d4bd867a92c7e9d7f7c02fa09e72a0 Mon Sep 17 00:00:00 2001
From: Wojciech Jaworski <wjaworski@mimuw.edu.pl>
Date: Sun, 5 Mar 2017 22:07:01 +0100
Subject: [PATCH] oznaczanie kierunku implikacji
---
LCGlexicon/ENIAM_LCGlexicon.ml | 69 +++++++++++++++------------------------------------------------------
LCGlexicon/resources/lexicon-pl.dic | 58 +++++++++++++++++++++++++++++++++-------------------------
LCGlexicon/test.ml | 27 +++++++++++++++++++++++++--
LCGparser/ENIAM_LCGgraphOf.ml | 2 +-
LCGparser/ENIAM_LCGlatexOf.ml | 2 +-
LCGparser/ENIAM_LCGreductions.ml | 1 +
LCGparser/ENIAM_LCGrenderer.ml | 22 +++++++++++++++-------
LCGparser/ENIAM_LCGstringOf.ml | 2 +-
LCGparser/ENIAM_LCGtypes.ml | 1 +
9 files changed, 93 insertions(+), 91 deletions(-)
diff --git a/LCGlexicon/ENIAM_LCGlexicon.ml b/LCGlexicon/ENIAM_LCGlexicon.ml
index 65b566a..9681ca4 100644
--- a/LCGlexicon/ENIAM_LCGlexicon.ml
+++ b/LCGlexicon/ENIAM_LCGlexicon.ml
@@ -152,55 +152,6 @@ let make_quantification e rules =
let syntax = if bracket then ENIAM_LCGtypes.Bracket(true,true,syntax) else ENIAM_LCGtypes.Bracket(false,false,syntax) in
cats,syntax,semantics)
-(***
-type rule2 =
- Basic of string
- | Quant of (selector * string) list * string
- | Raised of (selector * string) list * string * selector list
- | Quot of (selector * string) list * string
- | Inclusion of string
- | Conj of (selector * string) list * string
- | Bracket of string
-
-
-
-let parse_quants_range quant =
- Xlist.map quant (fun (cats,v) -> cats, parse_quant_range (cats,v))
-(**
- let parse_rule categories = function
- Basic syntax ->
- let quant = parse_quants_range categories in
- false, quant, parse_syntax syntax, BasicSem(Xlist.map quant fst)
- | Quant(quant,syntax) ->
- let quant = parse_quants_range (merge_quant categories quant) in
- false, quant, parse_syntax syntax, BasicSem(Xlist.map quant fst)
- | Raised(quant,syntax,semantics) ->
- let quant = parse_quants_range (merge_quant categories quant) in
- false, quant, parse_syntax syntax, RaisedSem(Xlist.map quant fst,semantics)
- | Quot(quant,syntax) ->
- let quant = parse_quants_range (merge_quant categories quant) in
- false, quant, parse_syntax syntax, QuotSem(Xlist.map quant fst)
- | Inclusion syntax ->
- let quant = parse_quants_range categories in
- false, quant, parse_syntax syntax, InclusionSem(Xlist.map quant fst)
- | Conj(quant,syntax) ->
- let quant = parse_quants_range (merge_quant categories quant) in
- false, quant, parse_syntax syntax, ConjSem(Xlist.map quant fst)
- | Bracket syntax ->
- let quant = parse_quants_range categories in
- true, quant, parse_syntax syntax, BasicSem(Xlist.map quant fst)
-
- let parse_grammar grammar =
- List.rev (Xlist.fold grammar [] (fun grammar (selectors,rule,weight) ->
- let selectors = parse_selectors selectors in
- let pos = find_selector Pos selectors in
- let categories =
- try StringMap.find pos_categories pos
- with Not_found -> failwith ("parse_grammar: " ^ pos) in
- let rule = try parse_rule categories rule with Not_found -> failwith ("parse_grammar: " ) in
- (selectors,rule,weight) :: grammar))
- **)
-
(* let translate_negation = function
(Negation:negation) -> ["neg"]
| Aff -> ["aff"]
@@ -231,8 +182,8 @@ let parse_quants_range quant =
| GerAtrs(m,le,neg,a) -> [Negation,Eq,translate_negation neg;Aspect,Eq,translate_aspect a]
| NonPersAtrs(m,le,role,role_attr,neg,a) -> [Negation,Eq,translate_negation neg;Aspect,Eq,translate_aspect a]
| ComprepAtrs _ -> failwith "apply_valence_selectors" *)
- ***)
-(* FIXME: argumenty X i raised i inne *)
+
+(* FIXME: argumenty X *)
(* let render_schema schema =
Xlist.map schema (function
@@ -253,11 +204,12 @@ let parse_quants_range quant =
| _ -> l)
else (cats,(bracket,quant,syntax,semantics),weight) :: l) *)
-(* FIXME: ustawienie wartości symbol *)
(* FIXME: problem z atrybutami przy zamianie kolejności rzędników *)
let make_node id orth lemma pos syntax weight cat_list is_raised =
- let attrs = Xlist.fold cat_list(*Xlist.rev_map quant fst*) [] (fun attrs -> function
+ let attrs = Xlist.fold cat_list [] (fun attrs -> function
| Lemma -> attrs
+ | Pos -> attrs
+ | Pos2 -> attrs
| Cat -> ("CAT",SubstVar "cat") :: attrs
| Number -> ("NUM",SubstVar "number") :: attrs
| Case -> ("CASE",SubstVar "case") :: attrs
@@ -273,7 +225,16 @@ let make_node id orth lemma pos syntax weight cat_list is_raised =
| Nsyn -> ("NSYN", SubstVar "nsyn") :: attrs
| Nsem -> ("NSEM", SubstVar "nsem") :: attrs
| Ctype -> ("CTYPE", SubstVar "ctype") :: attrs
- | s -> (string_of_selector s, Dot) :: attrs) in
+ | Inumber -> attrs
+ | Igender -> attrs
+ | Iperson -> attrs
+ | Nperson -> attrs
+ | Plemma -> attrs
+ | Unumber -> attrs
+ | Ucase -> attrs
+ | Ugender -> attrs
+ | Uperson -> attrs) in
+ (* | s -> (string_of_selector s, Dot) :: attrs) in *)
(* | "lex" -> ("LEX",Val "+") :: attrs *)
(* | s -> failwith ("make_node: " ^ (string_of_selector s))) in *)
let symbol = if is_raised then
diff --git a/LCGlexicon/resources/lexicon-pl.dic b/LCGlexicon/resources/lexicon-pl.dic
index 09d2f10..a2b40a8 100644
--- a/LCGlexicon/resources/lexicon-pl.dic
+++ b/LCGlexicon/resources/lexicon-pl.dic
@@ -137,13 +137,13 @@ pos=adv: advp{schema}{\(1+qub),/(1+inclusion)}{\(1+adja)};
# FIXME: dwa znaczenia jak: pytanie o cechę lub spójnik
lemma=jak|skąd|dokąd|gdzie|którędy|kiedy,pos=adv:
QUANT[inumber=0,igender=0,iperson=0,ctype=int&rel] RAISED[ctype]
- cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)}; #["CTYPE",SubstVar "ctype"]
+ cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)};
lemma=odkąd|dlaczego|czemu,pos=adv:
QUANT[inumber=0,igender=0,iperson=0,ctype=int] RAISED[ctype]
- cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)}; #["CTYPE",SubstVar "ctype"]
+ cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)};
lemma=gdy,pos=adv:
QUANT[inumber=0,igender=0,iperson=0,ctype=sub] RAISED[ctype]
- cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)}; #["CTYPE",SubstVar "ctype"]
+ cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)};
# czasowniki
pos=ger: np*number*case*gender*person{schema}{\(1+qub),/(1+inclusion)};
@@ -195,42 +195,50 @@ pos=pant,negation=neg: padvp{schema}{\(1+qub),/(1+inclusion)}{\nie};
pos=comp: QUANT[ctype=sub] cp*ctype*lemma/ip*T*T*T;
pos=conj: QUANT[ctype=coord] cp*ctype*lemma/ip*T*T*T;
-#lemma=i|lub|czy|bądź,pos=conj: Conj([number=all_numbers,gender=all_genders,person=all_persons],"(ip*number*gender*person/ip*T*T*T)\ip*T*T*T"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([],"(advp/prepnp*T*T)\prepnp*T*T"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([],"(advp/advp)\prepnp*T*T"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([],"(advp/prepnp*T*T)\advp"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([],"(advp/advp)\advp"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([plemma=0,case=all_cases],"(prepnp*plemma*case/prepnp*plemma*case)\prepnp*plemma*case"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([number=all_numbers,case=all_cases,gender=all_genders,person=all_persons],"(np*number*case*gender*person/np*T*case*T*T)\np*T*case*T*T"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([number=all_numbers,case=all_cases,gender=all_genders],"(adjp*number*case*gender/adjp*number*case*gender)\adjp*number*case*gender"),0.;
+lemma=i|lub|czy|bądź,pos=conj:
+ QUANT[number=all_numbers,gender=all_genders,person=all_persons]
+ (ip*number*gender*person/ip*T*T*T)\ip*T*T*T;
+lemma=,|i|lub|czy|bądź,pos=conj: (advp/prepnp*T*T)\prepnp*T*T;
+lemma=,|i|lub|czy|bądź,pos=conj: (advp/advp)\prepnp*T*T;
+lemma=,|i|lub|czy|bądź,pos=conj: (advp/prepnp*T*T)\advp;
+lemma=,|i|lub|czy|bądź,pos=conj: (advp/advp)\advp;
+lemma=,|i|lub|czy|bądź,pos=conj:
+ QUANT[plemma=0,case=all_cases]
+ (prepnp*plemma*case/prepnp*plemma*case)\prepnp*plemma*case;
+lemma=,|i|lub|czy|bądź,pos=conj:
+ QUANT[number=all_numbers,case=all_cases,gender=all_genders,person=all_persons]
+ (np*number*case*gender*person/np*T*case*T*T)\np*T*case*T*T;
+lemma=,|i|lub|czy|bądź,pos=conj:
+ QUANT[number=all_numbers,case=all_cases,gender=all_genders]
+ (adjp*number*case*gender/adjp*number*case*gender)\adjp*number*case*gender;
lemma=co|kto,pos=subst:
QUANT[inumber=0,igender=0,iperson=0,ctype=int&rel,number=T,case=T,gender=T,person=ter] RAISED[ctype]
- cp*ctype*lemma/(ip*inumber*igender*iperson/np*number*case*gender*person); #["CTYPE",SubstVar "ctype"]
+ cp*ctype*lemma/(ip*inumber*igender*iperson/np*number*case*gender*person);
lemma=co|kto,pos=subst:
QUANT[inumber=0,igender=0,iperson=0,plemma=0,ctype=int&rel,number=T,case=T,gender=T,person=ter] RAISED[ctype]
- cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case),/(prepnp*plemma*case/np*number*case*gender*person)}; #["CTYPE",SubstVar "ctype"]
+ cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case),/(prepnp*plemma*case/np*number*case*gender*person)};
lemma=to,pos=subst:
QUANT[ctype=0,plemma=0,number=T,case=T,gender=T,person=ter]
ncp*number*case*gender*person*ctype*plemma{\(1+qub),/(1+inclusion)}{/cp*ctype*plemma};
pos=ppron3,praep=praep:
QUANT[plemma=0,number=T,case=T,gender=T,person=T] RAISED[]
- prepnp*plemma*case\(prepnp*plemma*case/np*number*case*gender*person); #inclusion #[Number;Case;Gender;Person];
+ prepnp*plemma*case\(prepnp*plemma*case/np*number*case*gender*person); #inclusion #[Number;Case;Gender;Person]; #FIXME: semantyka
lemma=ile,pos=num: # FIXME: iloma ma bezpośredni podrzędnik rzeczownikowy, a ile nie # FIXME: mwe "o ile, na ile"
QUANT[inumber=0,igender=0,iperson=0,ctype=int&rel,number=T,case=T,gender=T,person=ter]
- cp*ctype*lemma/ip*inumber*igender*iperson; # FIXME: zaślepka, bo podrzędnik ile nie musi z nim sąciadować #["CTYPE",SubstVar "ctype"] # FIXME: trzeba dodać przypadki, bezpośredniego podrzędnika rzeczownikowego i przyimka nad "ile"
+ cp*ctype*lemma/ip*inumber*igender*iperson; # FIXME: zaślepka, bo podrzędnik ile nie musi z nim sąciadować # FIXME: trzeba dodać przypadki, bezpośredniego podrzędnika rzeczownikowego i przyimka nad "ile"
lemma=czyj|jaki|który,pos=apron:
QUANT[inumber=0,igender=0,iperson=0,nperson=0,ctype=int,number=T,case=T,gender=T] RAISED[ctype]
- cp*ctype*lemma{/(ip*inumber*igender*iperson/np*number*case*gender*nperson)}{/(np*number*case*gender*nperson\adjp*number*case*gender)}; #["CTYPE",SubstVar "ctype"]
+ cp*ctype*lemma{/(ip*inumber*igender*iperson/np*number*case*gender*nperson)}{/(np*number*case*gender*nperson\adjp*number*case*gender)};
lemma=czyj|jaki|który,pos=apron:
QUANT[inumber=0,igender=0,iperson=0,nperson=0,plemma=0,ctype=int,number=T,case=T,gender=T] RAISED[ctype]
- cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case)}{/(prepnp*plemma*case/np*number*case*gender*nperson)}{/(np*number*case*gender*nperson\adjp*number*case*gender)}; #["CTYPE",SubstVar "ctype"]
+ cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case)}{/(prepnp*plemma*case/np*number*case*gender*nperson)}{/(np*number*case*gender*nperson\adjp*number*case*gender)};
lemma=czyj|jaki,pos=apron:
QUANT[inumber=0,igender=0,iperson=0,ctype=rel,number=T,case=T,gender=T,person=ter] RAISED[ctype]
- cp*ctype*lemma/(ip*inumber*igender*iperson/np*number*case*gender*person); #["CTYPE",SubstVar "ctype"]
+ cp*ctype*lemma/(ip*inumber*igender*iperson/np*number*case*gender*person);
lemma=jaki|który,pos=apron:
QUANT[inumber=0,igender=0,iperson=0,plemma=0,ctype=rel,number=T,case=T,gender=T,person=ter] RAISED[ctype]
- cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case)}{/(prepnp*plemma*case/np*number*case*gender*person)}; #["CTYPE",SubstVar "ctype"]
+ cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case)}{/(prepnp*plemma*case/np*number*case*gender*person)};
lemma=się,pos=qub: się; # FIXME: dodać make_np
lemma=nie,pos=qub: nie;
@@ -245,14 +253,14 @@ pos=qub: qub;
pos=interj: interj;
lemma=-,pos=interp: hyphen;
lemma=?,pos=interp: int;
-#lemma=„,pos=interp: Quot([number=0,case=0,gender=0,person=0],"(np*number*case*gender*person/rquot)/np*number*case*gender*person"),0.;
-#lemma=«,pos=interp: Quot([number=0,case=0,gender=0,person=0],"(np*number*case*gender*person/rquot2)/np*number*case*gender*person"),0.;
-#lemma=»,pos=interp: Quot([number=0,case=0,gender=0,person=0],"(np*number*case*gender*person/rquot3)/np*number*case*gender*person"),0.;
+lemma=„,pos=interp: QUANT[number=0,case=0,gender=0,person=0] (np*number*case*gender*person/rquot)/np*number*case*gender*person; #SetAttr("QUOT",Val "+",Var "x"
+lemma=«,pos=interp: QUANT[number=0,case=0,gender=0,person=0] (np*number*case*gender*person/rquot2)/np*number*case*gender*person; #SetAttr("QUOT",Val "+",Var "x"
+lemma=»,pos=interp: QUANT[number=0,case=0,gender=0,person=0] (np*number*case*gender*person/rquot3)/np*number*case*gender*person; #SetAttr("QUOT",Val "+",Var "x"
lemma=”,pos=interp: rquot;
lemma=»,pos=interp: rquot2;
lemma=«,pos=interp: rquot3;
-#lemma=(,pos=interp: Inclusion "(inclusion/rparen)/(np*T*T*T*T+ip*T*T*T+adjp*T*T*T+prepnp*T*T);
-#lemma=[,pos=interp: Inclusion "(inclusion/rparen2)/(np*T*T*T*T+ip*T*T*T+adjp*T*T*T+prepnp*T*T);
+lemma=(,pos=interp: (inclusion/rparen)/(np*T*T*T*T+ip*T*T*T+adjp*T*T*T+prepnp*T*T); #SetAttr("INCLUSION",Val "+",
+lemma=[,pos=interp: (inclusion/rparen2)/(np*T*T*T*T+ip*T*T*T+adjp*T*T*T+prepnp*T*T); #SetAttr("INCLUSION",Val "+",
lemma=),pos=interp: rparen;
lemma=],pos=interp: rparen2;
pos=unk: np*number*case*gender*person;
@@ -273,7 +281,7 @@ lemma=:,pos=interp: BRACKET or;
lemma=:s,pos=interp: BRACKET <colon>\<speaker>;
lemma=:s,pos=interp: BRACKET (<colon>\<speaker>)/<squery>;
lemma=<or-sentence>,pos=interp: BRACKET <root>/s;
-lemma=<or-sentence>,pos=interp: BRACKET ((<root>/<speaker-end>)/(ip*T*T*T/or))/or2;
+lemma=<or-sentence>,pos=interp: BRACKET ((<root>/<speaker-end>)/(ip*T*T*T/or))/or2; #FIXME: semantyka
lemma=</or-sentence>,pos=interp: BRACKET or2\?(ip*T*T*T+cp*int*T+np*sg*voc*T*T+interj);
lemma=<sentence>,pos=interp: BRACKET (<speaker>/<speaker-end>)/np*T*nom*T*T;
lemma=</sentence>,pos=interp: BRACKET <speaker-end>;
diff --git a/LCGlexicon/test.ml b/LCGlexicon/test.ml
index f9d7745..1666012 100644
--- a/LCGlexicon/test.ml
+++ b/LCGlexicon/test.ml
@@ -43,7 +43,7 @@ let examples = [
8, 5, 6, "","</clause>","interp", [],false;
9, 6, 7, ".","</sentence>","interp", [],false;
],7;*)
- "jaki",[
+ (* "jaki",[
1, 0, 1, "","<sentence>","interp", [],false;
2, 1, 2, "","<clause>","interp", [],false;
3, 2, 3, "Jakiego","jaki","adj", [["sg"];["gen";"acc"];["m1";"m2"];["pos"]],false;
@@ -53,7 +53,29 @@ let examples = [
7, 6, 7, "?","?","interp", [],false;
8, 7, 8, "","</clause>","interp", [],false;
9, 8, 9, ".","</sentence>","interp", [],false;
- ],9;
+ ],9; *)
+ (*"kot_i_pies",[
+ 1, 0, 1, "","<sentence>","interp", [],false;
+ 2, 1, 2, "","<clause>","interp", [],false;
+ 3, 2, 3, "Ala","Ala","subst", [["sg"];["nom"];["f"]],true;
+ 4, 3, 4, "ma","mieć","fin", [["sg"];["ter"];["imperf"]],false;
+ 5, 4, 5, "kota","kot","subst", [["sg"];["gen";"acc"];["m1";"m2"]],false;
+ 6, 5, 6, "i","i","conj", [],false;
+ 7, 6, 7, "psa","pies","subst", [["sg"];["gen";"acc"];["m2"]],false;
+ 8, 7, 8, "","</clause>","interp", [],false;
+ 9, 8, 9, ".","</sentence>","interp", [],false;
+ ],9;*)
+"kotx",[
+ 1, 0, 1, "","<sentence>","interp", [],false;
+ 2, 1, 2, "","<clause>","interp", [],false;
+ 3, 2, 3, "Ala","Ala","subst", [["sg"];["nom"];["f"]],true;
+ 4, 3, 4, "ma","mieć","fin", [["sg"];["ter"];["imperf"]],false;
+ 5, 4, 5, "„","„","interp", [],false;
+ 6, 5, 6, "kota","kot","subst", [["sg"];["gen";"acc"];["m1";"m2"]],false;
+ 7, 6, 7, "”","”","interp", [],false;
+ 8, 7, 8, "","</clause>","interp", [],false;
+ 9, 8, 9, ".","</sentence>","interp", [],false;
+],9;
]
let valence = [
@@ -64,6 +86,7 @@ let valence = [
Both,Plus[One;Tensor[Atom "np";Top;Atom "gen";Top;Top]]];
[Lemma,Eq,["kot"];Pos,Eq,["subst"]],[Both,Plus[One;Tensor[Atom "adjp";AVar "number";AVar "case";AVar "gender"]]];
[Lemma,Eq,["kota"];Pos,Eq,["subst"]],[];
+ [Lemma,Eq,["pies"];Pos,Eq,["subst"]],[];
]
let create_chart valence tokens last =
diff --git a/LCGparser/ENIAM_LCGgraphOf.ml b/LCGparser/ENIAM_LCGgraphOf.ml
index deea1e8..6cd0424 100644
--- a/LCGparser/ENIAM_LCGgraphOf.ml
+++ b/LCGparser/ENIAM_LCGgraphOf.ml
@@ -30,7 +30,7 @@ let escape_string s =
let string_of_node t =
let l = [
"ORTH",Val t.orth;"LEMMA",Val t.lemma;"POS",Val t.pos;"ID",Val (string_of_int t.id);"WEIGHT",Val (string_of_float t.weight);
- "SYMBOL",t.symbol;"ARG_SYMBOL",t.arg_symbol] @ t.attrs in
+ "SYMBOL",t.symbol;"ARG_SYMBOL",t.arg_symbol;"ARG_DIR",Val t.arg_dir] @ t.attrs in
"{ " ^ String.concat " | " (Xlist.map l (fun (e,t) -> "{ " ^ e ^ " | " ^ escape_string (ENIAM_LCGstringOf.linear_term 0 t) ^ " }")) ^ " }"
diff --git a/LCGparser/ENIAM_LCGlatexOf.ml b/LCGparser/ENIAM_LCGlatexOf.ml
index e820aa5..121b1a6 100644
--- a/LCGparser/ENIAM_LCGlatexOf.ml
+++ b/LCGparser/ENIAM_LCGlatexOf.ml
@@ -73,7 +73,7 @@ let rec linear_term c = function
"{\\left[\\begin{array}{ll}" ^
(String.concat "\\\\ " (Xlist.map (["ORTH",Val t.orth;"LEMMA",Val t.lemma;"POS",Val t.pos;"ID",Val (string_of_int t.id);
"WEIGHT",Val (string_of_float t.weight);"SYMBOL",t.symbol;
- "ARG_SYMBOL",t.arg_symbol;"ARGS",t.args] @ t.attrs) (fun (e,t) ->
+ "ARG_SYMBOL",t.arg_symbol;"ARG_DIR",Val t.arg_dir;"ARGS",t.args] @ t.attrs) (fun (e,t) ->
"\\text{" ^ (Xlatex.escape_string e) ^ "} & " ^ (linear_term 0 t)))) ^ "\\end{array}\\right]}"
(* | Morf m -> "\\text{" ^ Xlatex.escape_string (ENIAMwalStringOf.morf m) ^ "}"
| Gf s -> "\\text{" ^ Xlatex.escape_string (ENIAMwalStringOf.gf s) ^ "}" *)
diff --git a/LCGparser/ENIAM_LCGreductions.ml b/LCGparser/ENIAM_LCGreductions.ml
index 83d02db..789b3e9 100644
--- a/LCGparser/ENIAM_LCGreductions.ml
+++ b/LCGparser/ENIAM_LCGreductions.ml
@@ -226,6 +226,7 @@ let linear_term_beta_reduction4 references =
| "MORF",Morf morf -> Node{t with amorf=morf}
| "AROLE",Val arole -> Node{t with arole=arole} *)
| "ARG_SYMBOL",symbol -> Node{t with arg_symbol=symbol}
+ | "ARG_DIR",Val dir -> Node{t with arg_dir=dir}
| _ -> Node{t with attrs=(e,linear_term_beta_reduction subst s) :: t.attrs})
| Variant(e2,l) -> Variant(e2,Xlist.map l (fun (i,t) -> i,linear_term_beta_reduction subst (SetAttr(e,s,t))))
| t -> SetAttr(e,s,t))
diff --git a/LCGparser/ENIAM_LCGrenderer.ml b/LCGparser/ENIAM_LCGrenderer.ml
index b0cbc2f..5f792c2 100644
--- a/LCGparser/ENIAM_LCGrenderer.ml
+++ b/LCGparser/ENIAM_LCGrenderer.ml
@@ -95,7 +95,7 @@ let rec substitute_substvar v g = function
let empty_node = {
- orth=""; lemma=""; pos=""; weight=0.; id=0; symbol=Dot; arg_symbol=Dot; attrs=[]; args=Dot;}
+ orth=""; lemma=""; pos=""; weight=0.; id=0; symbol=Dot; arg_symbol=Dot; arg_dir=""; attrs=[]; args=Dot;}
let variable_num_ref = ref 0
@@ -126,13 +126,21 @@ let make_arg_symbol l =
| Top -> Val "T"
| _ -> failwith "make_arg_symbol"))
-let rec make_term_arg = function
- Tensor l -> let v = get_variable_name () in v, Cut(SetAttr("ARG_SYMBOL",make_arg_symbol l,Var v))
- | Plus l -> let v = get_variable_name () in v, Case(Var v,Xlist.map l make_term_arg)
+let string_of_direction = function
+ Forward -> "forward"
+ | Backward -> "backward"
+ | Both -> "both"
+
+let rec make_term_arg dir = function
+ Tensor l ->
+ let v = get_variable_name () in
+ v, Cut(SetAttr("ARG_DIR",Val (string_of_direction dir),
+ SetAttr("ARG_SYMBOL",make_arg_symbol l,Var v)))
+ | Plus l -> let v = get_variable_name () in v, Case(Var v,Xlist.map l (make_term_arg dir))
(* | Imp(s,d,t2) -> *)
| One -> get_variable_name (), Dot
| Maybe s ->
- let v,arg = make_term_arg s in
+ let v,arg = make_term_arg dir s in
let w = get_variable_name () in
w, Fix(Var w,Lambda(v,arg))
| _ -> failwith "make_term_arg"
@@ -165,11 +173,11 @@ let is_raised = function
let rec make_term_imp node outer_node = function
| Imp(s,d,t2) ->
if is_raised [d,t2] then make_raised_term_imp (Node node) outer_node Dot (Imp(s,d,t2)) else
- let v,arg = make_term_arg t2 in
+ let v,arg = make_term_arg d t2 in
Lambda(v,make_term_imp (add_args node [arg]) outer_node s)
| ImpSet(s,l) ->
if is_raised l then make_raised_term_imp (Node node) outer_node Dot (ImpSet(s,l)) else
- let vars,args = List.split (Xlist.map l (fun (_,t) -> make_term_arg t)) in
+ let vars,args = List.split (Xlist.map l (fun (d,t) -> make_term_arg d t)) in
LambdaSet(vars,make_term_imp (add_args node args) outer_node s)
| Tensor l -> Node node
| _ -> failwith "make_term_imp"
diff --git a/LCGparser/ENIAM_LCGstringOf.ml b/LCGparser/ENIAM_LCGstringOf.ml
index 572eb29..3f5d082 100644
--- a/LCGparser/ENIAM_LCGstringOf.ml
+++ b/LCGparser/ENIAM_LCGstringOf.ml
@@ -56,7 +56,7 @@ let rec linear_term c = function
"[" ^
(String.concat "; " (Xlist.map (["ORTH",Val t.orth;"LEMMA",Val t.lemma;"POS",Val t.pos;"ID",Val (string_of_int t.id);
"WEIGHT",Val (string_of_float t.weight);"SYMBOL",t.symbol;
- "ARG_SYMBOL",t.arg_symbol;"ARGS",t.args] @ t.attrs) (fun (e,t) ->
+ "ARG_SYMBOL",t.arg_symbol;"ARG_DIR",Val t.arg_dir;"ARGS",t.args] @ t.attrs) (fun (e,t) ->
e ^ ": " ^ (linear_term 0 t)))) ^ "]"
(* | Morf m -> ENIAMwalStringOf.morf m
| Gf s -> ENIAMwalStringOf.gf s*)
diff --git a/LCGparser/ENIAM_LCGtypes.ml b/LCGparser/ENIAM_LCGtypes.ml
index 2f87a6b..5170ed7 100644
--- a/LCGparser/ENIAM_LCGtypes.ml
+++ b/LCGparser/ENIAM_LCGtypes.ml
@@ -31,6 +31,7 @@ type node = {
id: int;
symbol: linear_term;
arg_symbol: linear_term;
+ arg_dir: string;
(*agf: ENIAMwalTypes.gf;
amorf: ENIAMwalTypes.morf;
arole: string;
--
libgit2 0.22.2