Dezambiguacja preferencji selekcyjnych

Wojciech Jaworski
1 parent 394fa219
Showing 10 changed files with 371 additions and 84 deletions
exec/ENIAMdisambiguation.ml
exec/ENIAMexec.ml
exec/ENIAMexecTypes.ml
exec/ENIAMsemGraph.ml
exec/ENIAMsemValence.ml
exec/ENIAMvisualization.ml
exec/resources/lexicon-pl.dic
lexSemantics/ENIAMlexSemantics.ml
lexSemantics/ENIAMlexSemanticsTypes.ml
lexSemantics/ENIAMwalRenderer.ml
@@ -50,8 +50,8 @@ let rec select_random_rec selection = function
   | t -> failwith ("select_random_rec: " ^ ENIAM_LCGstringOf.linear_term 0 t)
 let select_random tree =
-  Int.fold 0 (Array.length tree - 1) StringMap.empty (fun selection i ->
-    select_random_rec selection tree.(i))
+  Int.fold 0 (ExtArray.size tree - 1) StringMap.empty (fun selection i ->
+    select_random_rec selection (ExtArray.get tree i))
 let rec apply_selection_rec selection = function
     Ref i -> Ref i
@@ -119,5 +119,76 @@ let rearrange_tree tree =
 let random_tree tokens lex_sems tree =
   (* print_endline "random_tree"; *)
   let selection = select_random tree in
-  let tree = apply_selection selection tree in
+  let tree = apply_selection selection (ExtArray.to_array tree) in
   rearrange_tree tree
+
+let rec selprefs_rec cost = function
+    Ref i -> cost.(i), Ref i
+  | Node t -> -1, Node{t with args = snd(selprefs_rec cost t.args)}
+  | Variant(e,l) ->
+      let c,l = Xlist.fold  l (max_int,[]) (fun (min_c,l) (i,t) ->
+        let c,t = selprefs_rec cost t in
+        if c < min_c then c,[i,t] else
+        if c > min_c then min_c,l else
+        min_c, (i,t) :: l) in
+      (match l with
+        [_,t] -> c,t
+      | _ -> c,Variant(e,List.rev l))
+  | Tuple l ->
+      let c,l = Xlist.fold l (0,[]) (fun (c,l) t ->
+        let c2,t = selprefs_rec cost t in
+        c+c2, t :: l) in
+      c,Tuple(List.rev l)
+  | Dot -> 0, Dot
+  | t -> failwith ("selprefs_rec: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let rec get_attr pat = function
+    [] -> raise Not_found
+  | (s,v) :: l ->
+      if s = pat then v
+      else get_attr pat l
+
+let rec list_of_selprefs = function
+    Val s -> [s]
+  | Dot -> []
+  | t -> failwith ("list_of_selprefs: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let map_of_hipero = function
+    Variant(_,l) -> Xlist.fold l StringMap.empty (fun map -> function
+        _,Tuple[Val hipero; Val cost] -> StringMap.add_inc map hipero (int_of_string cost) (fun _ -> failwith "map_of_hipero 1")
+      | _ -> failwith "map_of_hipero 2")
+  | Tuple[Val hipero; Val cost] -> StringMap.add StringMap.empty hipero (int_of_string cost)
+  | t -> failwith ("map_of_hipero: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let rec count_selprefs_cost tree cost = function
+    Ref i ->
+      if cost.(i) = -1 then
+        let c = count_selprefs_cost tree cost (ExtArray.get tree i) in
+        cost.(i) <- c;
+        c
+      else cost.(i)
+  | Node t ->
+      (count_selprefs_cost tree cost t.args) +
+      (match try get_attr "gf" t.attrs with Not_found -> Val "" with
+        Val "adjunct" -> 100
+      | Val "subj" | Val "obj" | Val "arg" | Val "core" ->
+          let selprefs = try list_of_selprefs (get_attr "selprefs" t.attrs) with Not_found -> failwith "count_selprefs_cost: no selprefs" in
+          let hipero = try map_of_hipero (get_attr "hipero" t.attrs) with Not_found -> failwith "count_selprefs_cost: no hipero" in
+          Xlist.fold selprefs 1000 (fun cost selpref ->
+            try min cost (StringMap.find hipero selpref) with Not_found -> cost)
+      | Val "" -> 200
+      | Val s -> failwith ("count_selprefs_cost: unknown gf=" ^ s ^ " for " ^ t.lemma)
+      | _ -> failwith "count_selprefs_cost")
+  | Variant(e,l) ->
+      Xlist.fold l max_int (fun min_c (_,t) ->
+        min min_c (count_selprefs_cost tree cost t))
+  | Tuple l -> Xlist.fold l 0 (fun c t -> c + count_selprefs_cost tree cost t)
+  | Dot -> 0
+  | t -> failwith ("count_selprefs_cost: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let selprefs tree =
+  let cost = Array.make (ExtArray.size tree) (-1) in
+  cost.(0) <- count_selprefs_cost tree cost (ExtArray.get tree 0);
+  Int.iter 0 (ExtArray.size tree - 1) (fun i ->
+    ExtArray.set tree i (snd (selprefs_rec cost (ExtArray.get tree i))));
+  ()
@@ -392,11 +392,19 @@ let eniam_semantic_processing verbosity tokens lex_sems result =
       let tree = ENIAMsemValence.reduce_tree tokens lex_sems tree in
       let result = if verbosity < 2 then result else {result with dependency_tree8=tree} in
       tree,result
-    with e -> [| |],{result with status=SemError2; msg=Printexc.to_string e} in
+    with e -> ExtArray.make 0 Dot,{result with status=SemError2; msg=Printexc.to_string e} in
+  if result.status = SemError2 then result else
+  let result =
+    try
+      ENIAMsemValence.transfer_attributes tree; (* niejawna zmiana imperatywna w tree *)
+      result
+    with e -> {result with status=SemError2; msg=Printexc.to_string e} in
   if result.status = SemError2 then result else
   let tree,result =
     try
-      let tree = ENIAMdisambiguation.random_tree tokens lex_sems tree in
+      ENIAMdisambiguation.selprefs tree; (* niejawna zmiana imperatywna w tree *)
+      (* let tree = ENIAMdisambiguation.random_tree tokens lex_sems tree in *)
+      let tree = ExtArray.to_array tree in
       let result = if verbosity = 0 then result else {result with dependency_tree9=tree} in
       tree,result
     with e -> [| |],{result with status=SemError2; msg=Printexc.to_string e} in
@@ -406,6 +414,9 @@ let eniam_semantic_processing verbosity tokens lex_sems result =
       let graph = ENIAMsemGraph.translate tokens lex_sems tree in
       let result = if verbosity = 0 then result else {result with semantic_graph10=graph} in
       let graph = ENIAMsemGraph.make_tree graph in
+      let graph = ENIAMsemGraph.simplify_tree graph in
+(*    let graph = ENIAMsemGraph.manage_quantification graph in  *)
+      (* let graph = ENIAMsemGraph.simplify_gender graph in *)
       let result = if verbosity = 0 then result else {result with semantic_graph11=graph} in
       graph,result
     with e -> ENIAMsemTypes.Dot,{result with status=SemError2; msg=Printexc.to_string e} in
@@ -43,7 +43,7 @@ type eniam_parse_result = {
   dependency_tree5: linear_term array;
   dependency_tree6: linear_term array;
   dependency_tree7: linear_term array;
-  dependency_tree8: linear_term array;
+  dependency_tree8: linear_term ExtArray.t;
   dependency_tree9: linear_term array;
   semantic_graph10: ENIAMsemTypes.linear_term array;
   semantic_graph11: ENIAMsemTypes.linear_term;
@@ -183,7 +183,7 @@ let empty_eniam_parse_result = {
   dependency_tree5=[| |];
   dependency_tree6=[| |];
   dependency_tree7=[| |];
-  dependency_tree8=[| |];
+  dependency_tree8=ExtArray.make 0 Dot;
   dependency_tree9=[| |];
   semantic_graph10=[| |];
   semantic_graph11=ENIAMsemTypes.Dot;
@@ -69,20 +69,12 @@ let make_relation t c =
       Relation(t.role,t.role_attr,c)
   | s -> failwith ("make_relation: " (*^ s*))
-let create_normal_concept (*roles role_attrs*) tokens lex_sems t sem_args =
-(*  let sem_args = if t.pos = "pro" then
-    match get_person t.attrs with
-      "pri" -> ["indexical"]
-    | "sec" -> ["indexical"]
-    | "ter" -> ["coreferential";"deictic"]
-    | "" -> ["indexical";"coreferential";"deictic"]
-    | _ -> failwith "create_normal_concept: pro"
-    else sem_args in (* FIXME: przesunąć to do rozszerzania path_array *)
-  if t.agf = ENIAMwalTypes.NOSEM then t.args else*)
+let create_normal_concept (*roles role_attrs*) tokens lex_sems t =
+  (*if t.agf = ENIAMwalTypes.NOSEM then t.args else*)
   let c = {empty_concept with
     c_sense = if t.lemma = "<root>" then Dot else Val t.meaning;
     c_relations=t.args;
-    c_quant=(*make_sem_args sem_args*)Dot;(* FIXME *)
+    c_quant=(*make_sem_args*) t.sem_args;
     c_variable=string_of_int t.id,"";
     c_pos=(*if t.id >= Array.length tokens then -1 else*) (ExtArray.get tokens t.id).ENIAMtokenizerTypes.beg;
     c_local_quant=true} in
@@ -145,7 +137,8 @@ let create_normal_concept (*roles role_attrs*) tokens lex_sems t sem_args =
     let c = Xlist.fold t.attrs c (fun c -> function
       | "ASPECT",_ -> c
       | "TENSE",Val t -> {c with c_relations=Tuple[c.c_relations;SingleRelation t]}
-      | "NEG",Val "+" -> {c with c_quant=Tuple[c.c_quant;Val "nie"]}
+      | "NEGATION",Val "aff" -> c
+      | "NEGATION",Val "neg" -> {c with c_quant=Tuple[c.c_quant;Val "nie"]}
       | e,t -> failwith ("create_normal_concept verb: " ^ e)) in
     let id = ExtArray.add tokens ENIAMtokenizerTypes.empty_token_env in
     let _ = ExtArray.add lex_sems  in
@@ -181,7 +174,8 @@ let create_normal_concept (*roles role_attrs*) tokens lex_sems t sem_args =
       | "ASPECT",_ -> c
 (*       | "TYPE",Val "int" -> {c with c_quant=Tuple[c.c_quant;Val "interrogative"]} *)
       | "TYPE",_ -> c
-      | "NEG",Val "+" -> {c with c_quant=Tuple[c.c_quant;Val "nie"]}
+      | "NEGATION",Val "aff" -> c
+      | "NEGATION",Val "neg" -> {c with c_quant=Tuple[c.c_quant;Val "nie"]}
       | e,t -> failwith ("create_normal_concept adv: " ^ e)) in
     Relation(t.role,t.role_attr,Concept c) else
   if t.pos = "pro" || t.pos = "ppron12" || t.pos = "ppron3" || t.pos = "siebie" then (* FIXME: indexicalność *)
@@ -193,6 +187,8 @@ let create_normal_concept (*roles role_attrs*) tokens lex_sems t sem_args =
       | "CASE",_ -> c
       | "SYN",_ -> c
       | "NSEM",_ -> c
+      | "controller",_ -> c
+      | "coref",_ -> c
       | e,t -> failwith ("create_normal_concept pron: " ^ e)) in
     Relation(t.role,t.role_attr,Concept c) else
   if t.pos = "prep" then
@@ -239,11 +235,12 @@ let create_normal_concept (*roles role_attrs*) tokens lex_sems t sem_args =
     let c = Xlist.fold t.attrs c (fun c -> function
       | e,t -> failwith ("create_normal_concept sinterj: " ^ e)) in
     Concept c else
+  if t.lemma = "<root>" then t.args else
   if t.pos = "interp" && t.lemma = "</sentence>" then
     let l = List.rev (make_args_list t.args) in
-    Xlist.fold (List.tl l) (List.hd l) (fun t s -> AddRelation(RemoveRelation t,"Next","Clause",RemoveRelation s)) else
+    Xlist.fold (List.tl l) (RemoveRelation(List.hd l)) (fun t s -> AddRelation(t,"Next","Clause",RemoveRelation s)) else
   if t.pos = "interp" && t.lemma = "<sentence>" then t.args else
-  if t.pos = "interp" && t.lemma = "”s" then
+(*  if t.pos = "interp" && t.lemma = "”s" then
     let l = List.rev (make_args_list t.args) in
     let x = Xlist.fold (List.tl l) (List.hd l) (fun t s -> AddRelation(RemoveRelation t,"Next","Sentence",RemoveRelation s)) in
     Relation(t.arole,t.arole_attr,x) else (* FIXME: czy na pewno tu i w następnych arole a nie position.role? *)
@@ -267,9 +264,9 @@ let create_normal_concept (*roles role_attrs*) tokens lex_sems t sem_args =
   if t.pos = "interp" && t.lemma = "?" then SingleRelation("int") else
   if t.pos = "interp" && t.lemma = "„" then
     Relation(t.role,t.role_attr,RemoveRelation t.args) else
-  if t.pos = "interp" || t.lemma = "</or-sentence>" then Relation(t.role,t.role_attr,t.args) else (
+  if t.pos = "interp" || t.lemma = "</or-sentence>" then Relation(t.role,t.role_attr,t.args) else*) (
   if t.pos = "interp" then Node t else
-  if t.pos = "" then Relation(t.role,t.role_attr,t.args) else
+  (*if t.pos = "" then Relation(t.role,t.role_attr,t.args) else*)
   (* print_endline t.lemma; *)
   Node t)
@@ -293,6 +290,7 @@ let rec translate_node tokens lex_sems t =
     | "arole-attr",Val s -> {t with arole_attr=s},attrs
     | "arev",Val "-" -> {t with arev=false},attrs
     | "arev",Val "+" -> {t with arev=true},attrs
+    | "agf",Val s -> t,attrs
     | "sem-args",s -> {t with sem_args=s},attrs
     | "fopinion",_ -> t,attrs
     | "sopinion",_ -> t,attrs
@@ -309,6 +307,8 @@ let rec translate_node tokens lex_sems t =
     | "MOOD",s -> t,("MOOD",s) :: attrs
     | "TENSE",s -> t,("TENSE",s) :: attrs
     | "controller",s -> t,("controller",s) :: attrs
+    | "controllee",s -> t,("controllee",s) :: attrs
+    | "coref",s -> t,("coref",s) :: attrs
     | "CAT",_ -> t,attrs
     | "NUM",s -> t,("NUM",s) :: attrs
     | "CASE",s -> t,("CASE",s) :: attrs
@@ -329,7 +329,7 @@ let rec translate_node tokens lex_sems t =
 and create_concepts tokens lex_sems = function
     ENIAM_LCGtypes.Node t ->
       let t = translate_node tokens lex_sems t in
-      create_normal_concept tokens lex_sems t []
+      create_normal_concept tokens lex_sems t
   | ENIAM_LCGtypes.Tuple l -> Tuple(Xlist.map l (create_concepts tokens lex_sems))
   | ENIAM_LCGtypes.Variant(e,l) -> Variant(e,Xlist.map l (fun (i,t) -> i, create_concepts tokens lex_sems t))
   | ENIAM_LCGtypes.Dot -> Dot
@@ -365,11 +365,11 @@ let rec make_tree_rec references = function
   (* | t -> failwith ("make_tree_rec: " ^ LCGstringOf.linear_term 0 t) *)
 let make_tree references =
-  RemoveRelation(make_tree_rec references references.(0))
-(*
+  (*RemoveRelation*)(make_tree_rec references references.(0))
+
 let rec simplify_tree_add_relation r a s = function
-    Concept c -> Concept{c with c_relations=Tuple[Relation(Val r,Val a,s);c.c_relations]}
-  | Context c -> Context{c with cx_relations=Tuple[Relation(Val r,Val a,s);c.cx_relations]}
+    Concept c -> Concept{c with c_relations=Tuple[Relation(r,a,s);c.c_relations]}
+  | Context c -> Context{c with cx_relations=Tuple[Relation(r,a,s);c.cx_relations]}
   | Variant(e,l) -> Variant(e,Xlist.map l (fun (i,t) -> i, simplify_tree_add_relation r a s t))
   | t -> AddRelation(t,r,a,s)
@@ -465,13 +465,13 @@ let rec simplify_tree = function
 (*   Variant(e,Xlist.map l (fun (i,t) -> i, simplify_tree t)) *)
   | Dot -> Dot
   | Val s -> Val s
-  | t -> failwith ("simplify_tree: " ^ LCGstringOf.linear_term 0 t)
+  | t -> failwith ("simplify_tree: " ^ ENIAMsemStringOf.linear_term 0 t)
 let rec manage_quantification2 (quants,quant) = function
     Tuple l -> Xlist.fold l (quants,quant) manage_quantification2
   | Dot -> quants,quant
   | Val s -> quants,Tuple[Val s;quant]
-  | t -> (Relation(Val "Quantifier",Val "",t)) :: quants,quant
+  | t -> (Relation("Quantifier","",t)) :: quants,quant
 let rec manage_quantification = function
     Node t -> Node{t with args=manage_quantification t.args}
@@ -488,9 +488,9 @@ let rec manage_quantification = function
   | Variant(e,l) -> Variant(e,Xlist.map l (fun (i,t) -> i, manage_quantification t))
   | Dot -> Dot
   | Val s -> Val s
-  | t -> failwith ("manage_quantification: " ^ LCGstringOf.linear_term 0 t)
+  | t -> failwith ("manage_quantification: " ^ ENIAMsemStringOf.linear_term 0 t)
-let simplify_gender2 = function
+(*let simplify_gender2 = function
     Variant(e,l) ->
       (try
         let l2 = List.sort compare (Xlist.rev_map l (function (_,Val s) -> s | _ -> raise Not_found)) in
@@ -523,30 +523,30 @@ let rec simplify_gender = function
   | Variant(e,l) -> Variant(e,Xlist.map l (fun (i,t) -> i, simplify_gender t))
   | Dot -> Dot
   | Val s -> Val s
-  | t -> failwith ("simplify_gender: " ^ LCGstringOf.linear_term 0 t)
+  | t -> failwith ("simplify_gender: " ^ ENIAMsemStringOf.linear_term 0 t)*)
 (***************************************************************************************)
-
+(*
 let rec validate_semantics_quant = function
     Val _ -> true
   | Variant(e,l) -> Xlist.fold l true (fun b (_,t) -> b && validate_semantics_quant t)
   | Tuple l -> Xlist.fold l true (fun b t -> b && validate_semantics_quant t)
   | Dot -> true
-  | t -> (*print_endline ("validate_semantics_quant: " ^ LCGstringOf.linear_term 0 t);*) false
+  | t -> (*print_endline ("validate_semantics_quant: " ^ ENIAMsemStringOf.linear_term 0 t);*) false
 let rec validate_semantics_sense = function
     Val _ -> true
   | Dot -> true
-  | t -> (*print_endline ("validate_semantics_sense: " ^ LCGstringOf.linear_term 0 t);*) false
+  | t -> (*print_endline ("validate_semantics_sense: " ^ ENIAMsemStringOf.linear_term 0 t);*) false
 let rec validate_semantics_rel_name = function
     Val _ -> true
-  | t -> (*print_endline ("validate_semantics_rel_name: " ^ LCGstringOf.linear_term 0 t);*) false
+  | t -> (*print_endline ("validate_semantics_rel_name: " ^ ENIAMsemStringOf.linear_term 0 t);*) false
 let rec validate_semantics = function
     Context c -> validate_semantics_sense c.cx_sense && validate_semantics_contents c.cx_contents && validate_semantics_relations c.cx_relations
   | Variant(e,l) -> Xlist.fold l true (fun b (_,t) -> b && validate_semantics t)
-  | t -> (*print_endline ("validate_semantics: " ^ LCGstringOf.linear_term 0 t);*) false
+  | t -> (*print_endline ("validate_semantics: " ^ ENIAMsemStringOf.linear_term 0 t);*) false
 and validate_semantics_relations = function
     SingleRelation r -> validate_semantics_rel_name r
@@ -555,20 +555,20 @@ and validate_semantics_relations = function
   | Variant(e,l) -> Xlist.fold l true (fun b (_,t) -> b && validate_semantics_relations t)
   | Tuple l -> Xlist.fold l true (fun b t -> b && validate_semantics_relations t)
   | Dot -> true
-  | t -> (*print_endline ("validate_semantics_relations: " ^ LCGstringOf.linear_term 0 t);*) false
+  | t -> (*print_endline ("validate_semantics_relations: " ^ ENIAMsemStringOf.linear_term 0 t);*) false
 and validate_semantics_concept = function
     Concept c -> validate_semantics_sense c.c_sense && validate_semantics_sense c.c_name && validate_semantics_quant c.c_quant && validate_semantics_relations c.c_relations
   | Context c -> validate_semantics_sense c.cx_sense && validate_semantics_contents c.cx_contents && validate_semantics_relations c.cx_relations
   | Variant(e,l) -> Xlist.fold l true (fun b (_,t) -> b && validate_semantics_concept t)
-  | t -> (*print_endline ("validate_semantics_concept: " ^ LCGstringOf.linear_term 0 t);*) false
+  | t -> (*print_endline ("validate_semantics_concept: " ^ ENIAMsemStringOf.linear_term 0 t);*) false
 and validate_semantics_contents = function
     Concept c -> validate_semantics_concept (Concept c)
   | Context c -> validate_semantics_concept (Context c)
   | Variant(e,l) -> Xlist.fold l true (fun b (_,t) -> b && validate_semantics_contents t)
   | Tuple l -> Xlist.fold l true (fun b t -> b && validate_semantics_contents t)
-  | t -> (*print_endline ("validate_semantics_contents: " ^ LCGstringOf.linear_term 0 t);*) false
+  | t -> (*print_endline ("validate_semantics_contents: " ^ ENIAMsemStringOf.linear_term 0 t);*) false
 (***************************************************************************************)
@@ -596,7 +596,7 @@ let rec find_multiple_variants v m = function
       Xlist.fold vl v StringSet.union, m
   | Dot -> v,m
   | Val s -> v,m
-  | t -> failwith ("find_multiple_variants: " ^ LCGstringOf.linear_term 0 t)
+  | t -> failwith ("find_multiple_variants: " ^ ENIAMsemStringOf.linear_term 0 t)
 type variant_structure =
     C of variant_structure * variant_structure
@@ -636,7 +636,7 @@ let rec create_variant_structure = function
       n,V(e,n,List.rev l)
   | Dot -> 1,E
   | Val s -> 1,E
-  | t -> failwith ("create_variant_structure: " ^ LCGstringOf.linear_term 0 t)
+  | t -> failwith ("create_variant_structure: " ^ ENIAMsemStringOf.linear_term 0 t)
 let rec get_all_variants = function
     Concept c ->
@@ -667,7 +667,7 @@ let rec get_all_variants = function
       List.rev (Xlist.fold l [] (fun l (_,t) -> get_all_variants t @ l))
   | Dot -> [Dot]
   | Val s -> [Val s]
-  | t -> failwith ("get_all_variants: " ^ LCGstringOf.linear_term 0 t)
+  | t -> failwith ("get_all_variants: " ^ ENIAMsemStringOf.linear_term 0 t)
 let _ = Random.self_init ()
@@ -693,7 +693,7 @@ let rec draw_variant = function
       draw_variant (s,t)
   | E,Dot -> Dot
   | E,Val s -> Val s
-  | s,t -> (*print_endline ("draw_variant: " ^ LCGstringOf.linear_term 0 t);*) failwith ("draw_variant: " ^ string_of_variant_structure s)
+  | s,t -> (*print_endline ("draw_variant: " ^ ENIAMsemStringOf.linear_term 0 t);*) failwith ("draw_variant: " ^ string_of_variant_structure s)
 let rec get_some_variants chosen = function
     Concept c -> (* FIXME: czy pozostałe atrybuty można pominąć? *)
@@ -715,7 +715,7 @@ let rec get_some_variants chosen = function
       else Variant(e,Xlist.map l (fun (i,t) -> i,get_some_variants chosen t))
   | Dot -> Dot
   | Val s -> Val s
-  | t -> failwith ("get_some_variants: " ^ LCGstringOf.linear_term 0 t)
+  | t -> failwith ("get_some_variants: " ^ ENIAMsemStringOf.linear_term 0 t)
 let get_all_multiple_variants t mv =
   let ll = StringMap.fold mv [] (fun ll e l ->
@@ -769,7 +769,7 @@ let draw_trees max_n t =
     let n,s = create_variant_structure t in
     n,s,t) in
   let sum_n = Xlist.fold multiple_variants 0 (fun sum_n (n,_,_) -> sum_n + n) in
-(*  print_endline (LCGstringOf.linear_term 0 t);
+(*  print_endline (ENIAMsemStringOf.linear_term 0 t);
   print_endline (string_of_variant_structure s);*)
   if sum_n <= max_n then
     List.flatten (Xlist.rev_map multiple_variants (fun (n,s,t) ->
@@ -27,6 +27,48 @@ type pos = {role: linear_term; role_attr: linear_term; selprefs: linear_term; gf
   cr: string list; ce: string list;
   is_necessary: bool; is_pro: bool; is_prong: bool; is_multi: bool; dir: string; morfs: StringSet.t}
+let get_pro_lemma attrs =
+  let pers,num,gend = Xlist.fold attrs ("","",[]) (fun (pers,num,gend) -> function
+      "PERS",Val s -> s,num,gend
+    | "NUM",Val s -> pers,s,gend
+    | "GEND",Val s -> pers,num,[s]
+    | "GEND",Variant(_,l) -> pers,num,Xlist.map l (function (_,Val s) -> s | _ -> failwith "get_pro_lemma")
+    | _ -> failwith "get_pro_lemma") in
+  match pers,num with
+    "",_ -> "pro"
+  | "pri","" -> "pro1"
+  | "pri","sg" -> "ja"
+  | "pri","pl" -> "my"
+  | "sec","" -> "pro2"
+  | "sec","sg" -> "ty"
+  | "sec","pl" -> "wy"
+  | "ter","" -> "pro3"
+  | "ter","sg" ->
+       (match Xlist.fold gend (false,false,false) (fun (m,n,f) -> function
+           "m1" -> true,n,f
+         | "m2" -> true,n,f
+         | "m3" -> true,n,f
+         | "n1" -> m,true,f
+         | "n2" -> m,true,f
+         | "f" -> m,n,true
+         | _ -> m,n,f) with
+         true,false,false -> "on"
+       | false,true,true -> "ono"
+       | false,false,true -> "ona"
+       | _ -> "pro3sg")
+  | "ter","pl" ->
+       (match Xlist.fold gend (false,false) (fun (mo,nmo) -> function
+           "m1" -> true,nmo
+         | "p1" -> true,nmo
+         | _ -> mo,true) with
+         true,false -> "oni"
+       | false,true -> "one"
+       | _ -> "pro3pl")
+  | _ -> failwith "get_pro_lemma"
+
+let make_sem_args sem_args =
+  if sem_args = [] then Dot else ENIAM_LCGrules.make_variant (Xlist.map sem_args (fun s -> Val s))
+
 let match_value v2 = function
     Val v -> if v = v2 then Val v else raise Not_found
   | _ -> failwith "match_value"
@@ -102,23 +144,24 @@ let rec match_arg_positions arg rev = function
       (match l with
         [] -> (*print_endline "match_arg_positions: not matched";*) match_arg_positions arg (p :: rev) positions
       | [t] ->
+          let t = SetAttr("gf",Val (ENIAMwalStringOf.gf p.gf),t) in
           let t = if p.gf = ENIAMwalTypes.SUBJ || p.gf = ENIAMwalTypes.OBJ || p.gf = ENIAMwalTypes.ARG then
             SetAttr("role",p.role,SetAttr("role-attr",p.role_attr,SetAttr("selprefs",p.selprefs,t)))
-          else if p.gf = ENIAMwalTypes.ADJUNCT then t else failwith "match_arg_positions: ni 2" in
-          let t = SetAttr("gf",Val (ENIAMwalStringOf.gf p.gf),t) in
+          else if p.gf = ENIAMwalTypes.ADJUNCT || p.gf = ENIAMwalTypes.NOSEM || p.gf = ENIAMwalTypes.CORE then t else failwith "match_arg_positions: ni 2" in
           let t = Xlist.fold p.cr t (fun t cr -> SetAttr("controller",Val cr,t)) in
           let t = Xlist.fold p.ce t (fun t ce -> SetAttr("controllee",Val ce,t)) in
+          let t = if p.gf = ENIAMwalTypes.NOSEM then Dot else t in
           if p.is_multi then (t, rev @ (p :: positions)) :: (match_arg_positions arg (p :: rev) positions)
           else (t, rev @ positions) :: (match_arg_positions arg (p :: rev) positions)
       | _ -> failwith "match_arg_positions: ni")
   | [] -> (*Printf.printf "match_arg_positions: arg=%s rev=[%s] positions=[]\n%!" (string_of_arg arg) (String.concat "; " (Xlist.map rev string_of_position));*) []
 (* Jeśli ta funkcja zwróci pustą listę, oznacza to, że argumentów nie dało się dopasować do pozycji *)
-let rec match_args_positions_rec positions = function
+let rec match_args_positions_rec prong_attrs positions = function
     arg :: args ->
       (* Printf.printf "match_args_positions_rec: args=%s :: [%s] positions=[%s]\n%!" (string_of_arg arg) (String.concat "; " (Xlist.map args string_of_arg)) (String.concat "; " (Xlist.map positions string_of_position)); *)
       Xlist.fold (match_arg_positions arg [] positions) [] (fun found (arg_pos,positions) ->
-        Xlist.fold (match_args_positions_rec positions args) found (fun found l -> (arg_pos :: l) :: found))
+        Xlist.fold (match_args_positions_rec prong_attrs positions args) found (fun found l -> (arg_pos :: l) :: found))
   | [] ->
       (* Printf.printf "match_args_positions_rec: args=[] positions=[%s]\n%!" (String.concat "; " (Xlist.map positions string_of_position)); *)
       let b = Xlist.fold positions false (fun b p -> p.is_necessary || b) in
@@ -126,8 +169,10 @@ let rec match_args_positions_rec positions = function
       if b then [] else
         [Xlist.fold positions [] (fun found p ->
           if not p.is_pro then found else
-          let attrs = ["role",p.role; "role-attr",p.role_attr; "selprefs",p.selprefs; "gf",Val (ENIAMwalStringOf.gf p.gf)] in
-          let attrs = if p.is_prong then attrs else attrs in (* FIXME: dodać number, gender *)
+          let attrs = if p.is_prong then prong_attrs else [] in (* FIXME: dodać number, gender *)
+          let lemma = get_pro_lemma attrs in
+          let sem_args = try StringMap.find ENIAMlexSemanticsData.pron_sem_args lemma with Not_found -> failwith "match_args_positions_rec" in
+          let attrs = ["meaning",Val lemma;"role",p.role; "role-attr",p.role_attr; "selprefs",p.selprefs; "gf",Val (ENIAMwalStringOf.gf p.gf); "agf",Val ""; "sem-args",make_sem_args sem_args] @ attrs in
           let attrs = Xlist.fold p.cr attrs (fun attrs cr -> ("controller",Val cr) :: attrs) in
           let attrs = Xlist.fold p.ce attrs (fun attrs ce -> ("controllee",Val ce) :: attrs) in
           Node{ENIAM_LCGrenderer.empty_node with lemma="pro"; pos="pro"; attrs=attrs} :: found)]
@@ -135,9 +180,9 @@ let rec match_args_positions_rec positions = function
 (* FIXME: opcjonalność podrzędników argumentów zleksykalizowanych *)
 (* Jeśli ta funkcja zwróci pustą listę, oznacza to, że argumentów nie dało się dopasować do pozycji *)
-let match_args_positions args positions =
+let match_args_positions prong_attrs args positions =
   (* Printf.printf "match_args_positions: args=[%s] positions=[%s]\n%!" (String.concat "; " (Xlist.map args string_of_arg)) (String.concat "; " (Xlist.map positions string_of_position)); *)
-  Xlist.rev_map (match_args_positions_rec positions args) (function
+  Xlist.rev_map (match_args_positions_rec prong_attrs positions args) (function
       [] -> Dot
     | [t] -> t
     | l -> Tuple l)
@@ -186,8 +231,8 @@ let translate_position id p =
    is_prong = p.ENIAMwalTypes.is_necessary = ENIAMwalTypes.ProNG;
    is_multi = p.ENIAMwalTypes.is_necessary = ENIAMwalTypes.Multi;
    dir= translate_dir p.ENIAMwalTypes.dir;
-   morfs = Xlist.fold p.ENIAMwalTypes.morfs StringSet.empty (fun morfs morf ->
-        if morf = ENIAMwalTypes.LCG One then (Printf.printf "translate_position: One%!"; morfs) else
+   morfs = if p.ENIAMwalTypes.morfs=[ENIAMwalTypes.LCG One] then StringSet.empty else Xlist.fold p.ENIAMwalTypes.morfs StringSet.empty (fun morfs morf ->
+        if morf = ENIAMwalTypes.LCG One then (Printf.printf "translate_position: One%!\n"; morfs) else
         StringSet.add morfs (string_of_morf morf))}
 let get_phrase_symbol = function
@@ -201,6 +246,13 @@ let get_phrase_symbol = function
 exception NoFrame of string * string
+let get_prong_attrs attrs =
+  Xlist.fold attrs [] (fun attrs -> function
+      "NUM",t -> ("NUM",t) :: attrs
+    | "GEND",t -> ("GEND",t) :: attrs
+    | "PERS",t -> ("PERS",t) :: attrs
+    | _ -> attrs)
+
 let rec assign_frames_rec tokens lex_sems tree arg_symbols visited = function
     Ref i ->
       if IntSet.mem visited i then Ref i,visited else
@@ -210,12 +262,14 @@ let rec assign_frames_rec tokens lex_sems tree arg_symbols visited = function
   | Node t ->
       let args,visited = assign_frames_rec tokens lex_sems tree arg_symbols visited t.args in
       let t = {t with args=args} in
+      (* print_endline ("assign_frames_rec: " ^ t.lemma); *)
       if t.symbol = Dot then Node t,visited else
       let args = get_arg_symbols_tuple arg_symbols [] args in
       let s = ExtArray.get lex_sems t.id in
       let symbol = get_phrase_symbol t.symbol in
       let frames = Xlist.fold s.ENIAMlexSemanticsTypes.frames [] (fun frames frame ->
         (* print_endline ("selectors: " ^ ENIAMcategoriesPL.string_of_selectors frame.selectors); *)
+        (* Printf.printf "assign_frames_rec: lemma=%s positions=[%s]\n%!" t.lemma (ENIAMwalStringOf.schema frame.positions); *)
         try
           let attrs = apply_selectors t.attrs frame.selectors in
           let frame = ENIAMsemLexicon.extend_frame symbol frame in
@@ -223,11 +277,12 @@ let rec assign_frames_rec tokens lex_sems tree arg_symbols visited = function
           (attrs,frame,Xlist.rev_map frame.positions (translate_position (string_of_int t.id))) :: frames
         with Not_found -> (*print_endline "rejected";*) frames) in
       if frames = [] then failwith "assign_frames_rec: no frame" else
+      let prong_attrs = get_prong_attrs t.attrs in
       let e = ENIAM_LCGreductions.get_variant_label () in
       let l,_ = Xlist.fold frames ([],1) (fun (l,n) (attrs,frame,positions) ->
         (* Printf.printf "assign_frames_rec: lemma=%s args=[%s] positions=[%s]\n%!" t.lemma (String.concat "; " (Xlist.map args string_of_arg)) (String.concat "; " (Xlist.map positions string_of_position)); *)
         if frame.meanings = [] then failwith ("assign_frames_rec: no meanings '" ^ t.lemma ^ "'") else
-        Xlist.fold (match_args_positions args positions) (l,n) (fun (l,n) args ->
+        Xlist.fold (match_args_positions prong_attrs args positions) (l,n) (fun (l,n) args ->
           Xlist.fold frame.meanings (l,n) (fun (l,n) (meaning,hipero,weight) ->
             (string_of_int n, Node{t with attrs=
               ("meaning",Val meaning) ::
@@ -235,7 +290,8 @@ let rec assign_frames_rec tokens lex_sems tree arg_symbols visited = function
               ("arole",Val frame.arole) ::
               ("arole-attr",Val frame.arole_attr) ::
               ("arev",Val (if frame.arev then "+" else "-")) ::
-              ("sem-args",if frame.sem_args = [] then Dot else ENIAM_LCGrules.make_variant (Xlist.map frame.sem_args (fun s -> Val s))) ::
+              ("agf",Val frame.agf) ::
+              ("sem-args",make_sem_args frame.sem_args) ::
               ("fopinion",Val (ENIAMwalStringOf.opinion frame.fopinion)) ::
               ("sopinion",Val (ENIAMwalStringOf.opinion frame.sopinion)) :: t.attrs; args=args}) ::
               l,n+1))) in
@@ -284,6 +340,18 @@ let assign_frames tokens lex_sems tree =
   let _ = assign_frames_rec tokens lex_sems tree arg_symbols IntSet.empty (Ref 0) in
   tree
+let rec extract_attr pat rev = function
+    [] -> raise Not_found
+  | (s,v) :: l ->
+      if s = pat then (List.rev rev) @ l, v
+      else extract_attr pat ((s,v) :: rev) l
+
+let rec get_attr pat = function
+    [] -> raise Not_found
+  | (s,v) :: l ->
+      if s = pat then v
+      else get_attr pat l
+
 let rec cut_nodes result_tree = function
   | Node t ->
       let i = ExtArray.add result_tree (Node t) in
@@ -297,6 +365,22 @@ let rec cut_nodes result_tree = function
   | Dot -> Dot
   | t -> failwith ("cut_nodes: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+exception AGF
+
+let rec manage_agf = function
+  | Node t ->
+      let attrs,agf = try extract_attr "agf" [] t.attrs with Not_found -> failwith "manage_agf" in
+      let gf = try get_attr "gf" t.attrs with Not_found -> Dot in (* FIXME: to by się chyba przydało poprawić, żeby gf było zawsze ustalone *)
+      if agf = Val "" || agf=gf then Node{t with attrs=attrs} else raise AGF
+  | Variant(e,l) ->
+      let l = Xlist.fold l [] (fun l (i,t) -> try (i, manage_agf t) :: l with AGF -> l) in
+      if l = [] then raise AGF else Variant(e,List.rev l)
+  | Tuple l ->
+      let l = Xlist.rev_map l manage_agf in
+      Tuple(List.rev l)
+  | Dot -> Dot
+  | t -> failwith ("cut_nodes: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
 let rec reduce_set_attr attr v = function
     Node t -> Node{t with attrs=(attr,v) :: t.attrs}
   | Variant(e,l) ->
@@ -313,6 +397,7 @@ let rec reduce_tree_rec tokens lex_sems result_tree mid_tree orig_tree = functio
   | Node t ->
       let args = reduce_tree_rec tokens lex_sems result_tree mid_tree orig_tree t.args in
       (* print_endline ("reduce_tree_rec 1: " ^ ENIAM_LCGstringOf.linear_term 0 args); *)
+      let args = try manage_agf args with AGF -> failwith "reduce_tree_rec: AGF" in
       let args = cut_nodes result_tree args in
       (* print_endline ("reduce_tree_rec 2: " ^ ENIAM_LCGstringOf.linear_term 0 args); *)
       let id =
@@ -341,4 +426,96 @@ let reduce_tree tokens lex_sems orig_tree =
   let _ = ExtArray.add result_tree Dot in
   let t = reduce_tree_rec tokens lex_sems result_tree mid_tree orig_tree orig_tree.(0) in
   ExtArray.set result_tree 0 t;
-  ExtArray.to_array result_tree
+  result_tree
+
+let is_subj = function
+  | Node t ->
+          let gf = try get_attr "gf" t.attrs with Not_found -> failwith "is_subj" in
+          gf = Val "subj"
+  | t -> failwith ("is_subj: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let is_core = function
+  | Node t ->
+          let gf = try get_attr "gf" t.attrs with Not_found -> failwith "is_core" in
+          gf = Val "core"
+  | t -> failwith ("is_core: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let set_subj_coref ce = function
+  | Node t ->
+          let gf = try get_attr "gf" t.attrs with Not_found -> failwith "set_subj_coref" in
+          if gf = Val "subj" then Node{t with attrs=("coref",ce) :: t.attrs} else Node t
+  | t -> failwith ("set_subj_coref: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let set_core_selprefs selprefs = function (* FIXME: trzeba usunąć dotychczasowe selprefs. *)
+  | Node t ->
+          let gf = try get_attr "gf" t.attrs with Not_found -> failwith "set_core_selprefs" in
+          if gf = Val "core" then Node{t with attrs=("selprefs",selprefs) :: t.attrs} else Node t
+  | t -> failwith ("set_core_selprefs: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let rec set_subj_coref_args tree ce = function
+    Ref i ->
+      if is_subj (ExtArray.get tree i) then
+        let id = ExtArray.add tree (set_subj_coref ce (ExtArray.get tree i)) in
+        Ref id
+      else Ref i
+  | Variant(e,l) ->
+      let l = Xlist.rev_map l (fun (i,t) -> i, set_subj_coref_args tree ce t) in
+      Variant(e,List.rev l)
+  | Tuple l ->
+      let l = Xlist.rev_map l (set_subj_coref_args tree ce) in
+      Tuple(List.rev l)
+  | Dot -> Dot
+  | t -> failwith ("set_subj_coref_args: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let rec set_selprefs_core tree selprefs = function
+    Ref i ->
+      if is_core (ExtArray.get tree i) then
+        let id = ExtArray.add tree (set_core_selprefs selprefs (ExtArray.get tree i)) in
+        Ref id
+      else Ref i
+  | Variant(e,l) ->
+      let l = Xlist.rev_map l (fun (i,t) -> i, set_selprefs_core tree selprefs t) in
+      Variant(e,List.rev l)
+  | Tuple l ->
+      let l = Xlist.rev_map l (set_selprefs_core tree selprefs) in
+      Tuple(List.rev l)
+  | Dot -> Dot
+  | t -> failwith ("set_subj_coref_args: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let rec transfer_attributes_rec tree visited = function
+    Ref i ->
+      if visited.(i) then Ref i else (
+      visited.(i) <- true;
+      ExtArray.set tree i (transfer_attributes_rec tree visited (ExtArray.get tree i));
+      Ref i)
+  | Node t ->
+      let t = {t with args = transfer_attributes_rec tree visited t.args} in
+      (* print_endline ("transfer_attributes_rec 1: " ^ ENIAM_LCGstringOf.linear_term 0 args); *)
+      let t =
+        if t.pos = "inf" || t.pos = "pcon" || t.pos = "pant" then
+          try
+            let attrs,ce = extract_attr "controllee" [] t.attrs in
+            let args = set_subj_coref_args tree ce t.args in
+            {t with attrs=attrs; args=args}
+          with Not_found -> t else
+        if t.pos = "prep" && get_attr "gf" t.attrs = Val "arg" then
+          let attrs,selprefs = extract_attr "selprefs" [] t.attrs in
+          let args = set_selprefs_core tree selprefs t.args in
+          {t with attrs=("selprefs", Val "ALL") :: attrs; args=args}
+        else t in
+      Node t
+  | Variant(e,l) ->
+      let l = Xlist.rev_map l (fun (i,t) -> i, transfer_attributes_rec tree visited t) in
+      Variant(e,List.rev l)
+  | Tuple l ->
+      let l = Xlist.rev_map l (transfer_attributes_rec tree visited) in
+      Tuple(List.rev l)
+  | Dot -> Dot
+  | t -> failwith ("transfer_attributes_rec: " ^ ENIAM_LCGstringOf.linear_term 0 t)
+
+let transfer_attributes tree =
+  let visited = Array.make (ExtArray.size tree) false in
+  visited.(0) <- true;
+  let t = transfer_attributes_rec tree visited (ExtArray.get tree 0) in
+  ExtArray.set tree 0 t;
+  ()
@@ -928,10 +928,12 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
       ""
   | SemParsed ->
       if verbosity < 2 then () else (
-        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_6_dependency_tree") "a4" result.dependency_tree6;
-        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_7_dependency_tree") "a4" result.dependency_tree7;
-        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_8_dependency_tree") "a4" result.dependency_tree8;
-        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") "a4" result.dependency_tree9);
+        ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_6_dependency_tree") result.dependency_tree6;
+        ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") result.dependency_tree9;
+        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_6_dependency_tree") "a3" result.dependency_tree6;
+        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_7_dependency_tree") "a3" result.dependency_tree7;
+        ENIAM_LCGlatexOf.print_references path (file_prefix ^ "_8_dependency_tree") "a3" result.dependency_tree8;
+        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") "a3" result.dependency_tree9);
       if verbosity = 0 then () else (
         ENIAMsemLatexOf.print_semantic_graph path (file_prefix ^ "_10_semantic_graph") "a3" result.semantic_graph10;
         ENIAMsemGraphOf.print_semantic_graph2 path (file_prefix ^ "_11_semantic_graph") "" result.semantic_graph11);
@@ -940,24 +942,26 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
         sprintf "<BR><A HREF=\"%s_6_dependency_tree.pdf\">Dependency Tree References 6</A>\n" file_prefix  ^
         sprintf "<BR><A HREF=\"%s_7_dependency_tree.pdf\">Dependency Tree References 7</A>\n" file_prefix  ^
         sprintf "<BR><A HREF=\"%s_8_dependency_tree.pdf\">Dependency Tree References 8</A>\n" file_prefix  ^
-        sprintf "<BR><A HREF=\"%s_9_dependency_tree.pdf\">Dependency Tree References 9</A>\n" file_prefix)  ^
+        sprintf "<BR><A HREF=\"%s_9_dependency_tree.pdf\">Dependency Tree References 9</A>\n" file_prefix  ^
+        sprintf "<BR><IMG SRC=\"%s_6_dependency_tree.png\">\n" file_prefix ^
+        sprintf "<BR><IMG SRC=\"%s_9_dependency_tree.png\">\n" file_prefix) ^
       (if verbosity = 0 then "" else
         sprintf "<BR><A HREF=\"%s_10_semantic_graph.pdf\">Semantic Graph References 10</A>\n" file_prefix  ^
-        sprintf "<BR><IMG SRC=\"%s_11_semantic_graph.png\">\n" file_prefix) ^
+        sprintf "<BR><IMG SRC=\"%s_11_semantic_graph.png\">\n" file_prefix)  ^
       ""
   | SemError2 ->
       if verbosity = 0 then () else (
-        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_6_dependency_tree") "a4" result.dependency_tree6;
+        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_6_dependency_tree") "a3" result.dependency_tree6;
         ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_6_dependency_tree") result.dependency_tree6;
-        if result.dependency_tree7 <> [| |] then ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_7_dependency_tree") "a4" result.dependency_tree7;
-        if result.dependency_tree8 <> [| |] then ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_8_dependency_tree") "a4" result.dependency_tree8;
-        if result.dependency_tree9 <> [| |] then ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") "a4" result.dependency_tree9;
+        if result.dependency_tree7 <> [| |] then ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_7_dependency_tree") "a3" result.dependency_tree7;
+        if ExtArray.size result.dependency_tree8 <> 0 then ENIAM_LCGlatexOf.print_references path (file_prefix ^ "_8_dependency_tree") "a3" result.dependency_tree8;
+        if result.dependency_tree9 <> [| |] then ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") "a3" result.dependency_tree9;
         if result.dependency_tree9 <> [| |] then ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") result.dependency_tree9);
       sprintf "error_sem2: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" result.msg result.paths_size result.chart_size result.dependency_tree_size ^
       (if verbosity = 0 then "" else
         sprintf "<BR><A HREF=\"%s_6_dependency_tree.pdf\">Dependency Tree References 6</A>\n" file_prefix ^
         (if result.dependency_tree7 <> [| |] then sprintf "<BR><A HREF=\"%s_7_dependency_tree.pdf\">Dependency Tree References 7</A>\n" file_prefix else "")  ^
-        (if result.dependency_tree8 <> [| |] then sprintf "<BR><A HREF=\"%s_8_dependency_tree.pdf\">Dependency Tree References 8</A>\n" file_prefix else "")  ^
+        (if ExtArray.size result.dependency_tree8 <> 0 then sprintf "<BR><A HREF=\"%s_8_dependency_tree.pdf\">Dependency Tree References 8</A>\n" file_prefix else "")  ^
         (if result.dependency_tree9 <> [| |] then sprintf "<BR><A HREF=\"%s_9_dependency_tree.pdf\">Dependency Tree References 9</A>\n" file_prefix else "")  ^
         (if result.dependency_tree9 <> [| |] then sprintf "<BR><IMG SRC=\"%s_9_dependency_tree.png\">\n" file_prefix else "")  ^
         sprintf "<BR><IMG SRC=\"%s_6_dependency_tree.png\">\n" file_prefix)  ^
@@ -34,9 +34,12 @@ num: \(1+qub):adjunct /(1+inclusion):adjunct;
 measure:
   \(1+num*number*case*gender*person*congr+num*number*case*gender*person*rec):Count \(1+qub):adjunct /(1+inclusion):adjunct;
-prepnp: \(1+advp*T):adjunct /(np*T*case*T*T+day-month+day+year+date+hour+hour-minute):unk \(1+qub):adjunct /(1+inclusion):adjunct;
-prepadjp: \(1+advp*T):adjunct /(adjp*T*case*T+adjp*sg*dat*m1+adjp*T*postp*T+adjp*sg*nom*f+advp*T):unk \(1+qub):adjunct /(1+inclusion):adjunct;
-compar: \(1+advp*T):adjunct /(np*T*case*T*T+prepnp*T*T+prepadjp*T*T):unk \(1+qub):adjunct /(1+inclusion):adjunct;
+#prepnp: \(1+advp*T):adjunct /(np*T*case*T*T+day-month+day+year+date+hour+hour-minute):unk \(1+qub):adjunct /(1+inclusion):adjunct;
+#prepadjp: \(1+advp*T):adjunct /(adjp*T*case*T+adjp*sg*dat*m1+adjp*T*postp*T+adjp*sg*nom*f+advp*T):unk \(1+qub):adjunct /(1+inclusion):adjunct;
+#compar: \(1+advp*T):adjunct /(np*T*case*T*T+prepnp*T*T+prepadjp*T*T):unk \(1+qub):adjunct /(1+inclusion):adjunct;
+prepnp: \(1+advp*T):adjunct \(1+qub):adjunct /(1+inclusion):adjunct;
+prepadjp: \(1+advp*T):adjunct \(1+qub):adjunct /(1+inclusion):adjunct;
+compar: \(1+advp*T):adjunct \(1+qub):adjunct /(1+inclusion):adjunct;
 adjp: \(1+qub):adjunct /(1+inclusion):adjunct \(1+adja):unk;
@@ -190,17 +190,23 @@ let add_sem_args lemma pos frame =
 let assign_prep_semantics lemma =
   let roles = try StringMap.find ENIAMlexSemanticsData.prep_roles lemma with Not_found -> [] in
-  Printf.printf "assign_prep_semantics: |roles|=%d\n%!" (Xlist.size roles);
+  (* Printf.printf "assign_prep_semantics: |roles|=%d\n%!" (Xlist.size roles); *)
+  {empty_frame with
+    meanings = [find_prep_meaning lemma [Predef "ALL"]];
+    positions= [{empty_position with
+      dir=if lemma="temu" then Backward_ else Forward_; gf=CORE;
+      morfs=ENIAMwalRenderer.prep_morfs; is_necessary=Req}];
+    agf="arg"} ::
   Xlist.map roles (function (case,arole,arole_attr,hipero,sel_prefs) ->
-    Printf.printf "assign_prep_semantics: case=%s arole=%s arole_attr=%s\n%!" case arole arole_attr;
+    (* Printf.printf "assign_prep_semantics: case=%s arole=%s arole_attr=%s\n%!" case arole arole_attr; *)
     let meaning = find_prep_meaning lemma hipero in (* FIXME: zaślepka dla meaning i weight *)
-    print_endline "assign_prep_semantics 1";
+    (* print_endline "assign_prep_semantics 1"; *)
     let positions = [{empty_position with
       sel_prefs=sel_prefs; dir=if lemma="temu" then Backward_ else Forward_;
-      morfs=ENIAMwalRenderer.assing_pref_morfs (lemma,case); is_necessary=Req}] in
-    print_endline "assign_prep_semantics 2";
+      morfs=ENIAMwalRenderer.prep_morfs(*ENIAMwalRenderer.assing_prep_morfs (lemma,case)*); is_necessary=Req}] in
+    (* print_endline "assign_prep_semantics 2"; *)
     {empty_frame with selectors=[ENIAM_LCGlexiconTypes.Case,ENIAM_LCGlexiconTypes.Eq,[case]]; meanings=[meaning]; positions=find_selprefs positions;
-     arole=arole; arole_attr=arole_attr; arev=false})
+     arole=arole; arole_attr=arole_attr; arev=false; agf="adjunct"})
 let assign_num_semantics lemma =
   let sems = try StringMap.find !num_sem lemma with Not_found -> [] in
@@ -267,7 +273,7 @@ let assign_valence tokens lex_sems group =
           List.flatten (Xlist.rev_map (ENIAMvalence.transform_entry pos lemma neg pred aspect schema1) (fun (selectors,schema) ->
               Xlist.rev_map (ENIAMvalence.get_aroles schema1 lemma pos) (fun (sel,arole,arole_attr,arev) ->
                   {selectors=sel @ selectors; meanings=Xlist.map meanings find_meaning; positions=schema;
-                   arole=arole; arole_attr=arole_attr; arev=arev; sem_args=[]; sopinion=sopinion; fopinion=fopinion}))))) in
+                   arole=arole; arole_attr=arole_attr; arev=arev; agf=""; sem_args=[]; sopinion=sopinion; fopinion=fopinion}))))) in
       (* Printf.printf "E %s |connected|=%d\n" lemma (Xlist.size connected); *)
       let connected = if connected = [] then List.flatten (Xlist.rev_map (make_unique schemata1) (semantize lemma pos)) else connected in
       (* Printf.printf "F %s |connected|=%d\n" lemma (Xlist.size connected); *)
@@ -27,13 +27,14 @@ type frame = {
   arole: string;
   arole_attr: string;
   arev: bool;
+  agf: string;
   sem_args: string list;
   (* has_context: bool; *)
   sopinion: ENIAMwalTypes.opinion;
   fopinion: ENIAMwalTypes.opinion;
   }
-let empty_frame = {selectors=[]; meanings=[]; positions=[]; arole=""; arole_attr=""; arev=false; sem_args=[]; (*has_context=false;*)
+let empty_frame = {selectors=[]; meanings=[]; positions=[]; arole=""; arole_attr=""; arev=false; agf=""; sem_args=[]; (*has_context=false;*)
   sopinion=ENIAMwalTypes.Nieokreslony; fopinion=ENIAMwalTypes.Nieokreslony}
 type lex_sem = {
@@ -340,7 +340,7 @@ let adv_connected_adjuncts_simp = [
    adjunct [Tensor[Atom "advp"; Top]];
  ]
-let assing_pref_morfs = function
+let assing_prep_morfs = function
     "po","postp" -> [
         LCG(Tensor[Atom "adjp"; Atom "sg"; Atom "dat"; Atom "m1"]);
         LCG(Tensor[Atom "adjp"; Top; Atom "postp"; Top])]
@@ -349,3 +349,17 @@ let assing_pref_morfs = function
   | _,case -> [
         LCG(Tensor[Atom "np"; Top; Atom case; Top; Top]);
         LCG(Tensor[Atom "adjp"; Top; Atom case; Top])]
+
+let prep_morfs = [
+  LCG(Tensor[Atom "np"; Top; Atom "case"; Top; Top]);
+  LCG(Tensor[Atom "adjp"; Top; Atom "case"; Top]);
+  LCG(Tensor[Atom "adjp"; Atom "sg"; Atom "dat"; Atom "m1"]);
+  LCG(Tensor[Atom "adjp"; Atom "sg"; Atom "nom"; Atom "f"]);
+  LCG(Tensor[Atom "advp"; Top]);
+  LCG(Tensor[Atom "year"]);
+  LCG(Tensor[Atom "hour-minute"]);
+  LCG(Tensor[Atom "day-month"]);
+  LCG(Tensor[Atom "hour"]);
+  LCG(Tensor[Atom "day"]);
+  LCG(Tensor[Atom "date"]);
+  ]