Dostosowanie do nowego Walentego

Wojciech Jaworski
1 parent 44e8be87
Showing 14 changed files with 223 additions and 43 deletions
LCGlexicon/ENIAMcategoriesPL.ml
LCGparser/ENIAM_LCGlatexOf.ml
semantics/ENIAMsemGraph.ml
subsyntax/ENIAMsubsyntax.ml
subsyntax/ENIAMsubsyntaxTypes.ml
subsyntax/interface.ml
walenty/ENIAMwalAnalyze.ml
walenty/ENIAMwalConnect.ml
walenty/ENIAMwalGenerate.ml
walenty/ENIAMwalStringOf.ml
walenty/ENIAMwalTEI.ml
walenty/ENIAMwalTypes.ml
walenty/README
walenty/resources/README
@@ -37,7 +37,7 @@ let selector_values = Xlist.fold [
           "day-month-interval";"month-interval";"roman";"roman-interval";"roman-ordnum";
           "match-result";"url";"email";"phone-number";"postal-code";"obj-id";"building-number";"list-item";"adj";"adjc";"adjp";"adja";
           "adv";"ger";"pact";"ppas";"fin";"bedzie";"praet";"winien";"impt";
-          "imps";"pred";"aglt";"inf";"pcon";"pant";"qub";"part";"comp";"conj";"interj";
+          "imps";"pred";"aglt";"inf";"pcon";"pant";"pacta";"qub";"part";"comp";"conj";"interj";
           "sinterj";"burk";"interp";"xxx";"unk";"html-tag";"apron";"compar"];
     Pos2, [];
     Cat, [];
@@ -413,6 +413,7 @@ let clarify_categories proper cat coerced (*snode*) = function
   | lemma,"inf",[aspects] -> [{empty_cats with lemma=lemma; pos="inf"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; aspects=aspects; negations=["aff"; "neg"]}]
   | lemma,"pcon",[aspects] -> [{empty_cats with lemma=lemma; pos="pcon"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; aspects=aspects; negations=["aff"; "neg"]}]
   | lemma,"pant",[aspects] -> [{empty_cats with lemma=lemma; pos="pant"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; aspects=aspects; negations=["aff"; "neg"]}]
+  | lemma,"pacta",[] -> [{empty_cats with lemma=lemma; pos="pacta"; pos2="verb"; cat=cat; coerced=coerced; snode=snode}]
   | lemma,"qub",[] ->
       if StringSet.mem part_set lemma then [{empty_cats with lemma=lemma; pos="part"; pos2="qub"; snode=snode}]
       else [{empty_cats with lemma=lemma; pos="qub"; pos2="qub"; cat=cat; snode=snode}]
@@ -662,6 +663,7 @@ let pos_categories = Xlist.fold [
     "inf",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Aspect;Negation;];
     "pcon",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Aspect;Negation;];
     "pant",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Aspect;Negation;];
+    "pacta",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;];
     "qub",[Lemma;Cat;Role;SNode;];
     "part",[Lemma;SNode];
     "comp",[Lemma;SNode;];(* ctype *)
@@ -213,7 +213,7 @@ let chart page text_fragments g =
   String.concat "" (List.rev (IntMap.fold layers [] (fun l layer nodes ->
       IntMap.fold nodes l (fun l node1 contents ->
           Xlist.fold contents l (fun l (node2,symbol,sem) ->
-              let s = try IntMap.find text_fragments.(node1) node2 with Not_found -> failwith (Printf.sprintf "chart: text_fragment not found %d-%d" node1 node2) in
+              let s = try Xlatex.escape_string (IntMap.find text_fragments.(node1) node2) with Not_found -> failwith (Printf.sprintf "chart: text_fragment not found %d-%d" node1 node2) in
               (Printf.sprintf "%d & %d--%d & %s & $\\begin{array}{l}%s\\end{array}$ & $%s$\\\\\n\\hline\n" layer node1 node2 s symbol sem) :: l))))) ^
   "\\end{longtable}"
  
@@ -221,7 +221,7 @@ let chart2 page text_fragments g =
   let n = match page with "a4" -> "4" | "a1" -> "10" | _ -> "6" in
   "\\begin{longtable}{|l|p{" ^ n ^ "cm}|l|}\n\\hline\n" ^
   String.concat "" (List.rev (ENIAM_LCGchart.fold g [] (fun l (symbol,node1,node2,sem,layer) ->
-      let s = try IntMap.find text_fragments.(node1) node2 with Not_found -> failwith (Printf.sprintf "chart: text_fragment not found %d-%d" node1 node2) in
+      let s = try Xlatex.escape_string (IntMap.find text_fragments.(node1) node2) with Not_found -> failwith (Printf.sprintf "chart: text_fragment not found %d-%d" node1 node2) in
       (Printf.sprintf "%d--%d & %s & $\\begin{array}{l}%s\\end{array}$\\\\\n\\hline\n" node1 node2 s (grammar_symbol 0 symbol)) :: l))) ^
   "\\end{longtable}"
  
@@ -570,7 +570,8 @@ let rec reduce_tree = function
       (match reduce_tree c with
         Context c ->
            let t,args = extract_aroles {t with arole=""} c.cx_contents in
-           make_relation t (Context {c with cx_contents=args})
+           (*make_relation t (Context {c with cx_contents=args})*) (* FIXME: to trzeba poprawić tak by działało w obu wersjach parserów *)
+           Relation(t.role,"",Context {c with cx_contents=args})
       | Variant(e,l) -> reduce_tree (Variant(e,Xlist.map l (fun (i,c) -> i,ManageCoordination(t,c))))
       | c -> ManageCoordination(t,c))
   | Tuple l -> Tuple(List.rev (Xlist.rev_map l reduce_tree))
@@ -325,7 +325,7 @@ let parse query =
   let paths,_ = ENIAM_MWE.process paths in
   (* print_endline "XXXXXXXXXXXXXXXXXXXXXXXXX a12"; *)
   (* print_endline (ENIAMsubsyntaxStringOf.token_list paths); *)
-  let paths =  List.rev (Xlist.rev_map paths find_proper_names) in
+  let paths =  if !recognize_proper_names then List.rev (Xlist.rev_map paths find_proper_names) else paths in
   (* print_endline "XXXXXXXXXXXXXXXXXXXXXXXXX a13"; *)
   (* print_endline (ENIAMsubsyntaxStringOf.token_list paths); *)
   let paths = modify_weights paths in
@@ -46,6 +46,7 @@ type text =
   | AltText of (mode * text) list
  
 let strong_disambiguate_flag = ref false
+let recognize_proper_names = ref true
  
 let data_path =
   try Sys.getenv "ENIAM_USER_DATA_PATH"
@@ -43,6 +43,8 @@ let spec_list = [
   "--no-internet-mode", Arg.Unit (fun () -> ENIAMtokenizerTypes.internet_mode:=false), "Strict attitude towards interpunction (default)";
   "--par-names", Arg.Unit (fun () -> par_names:=true), "Identifiers of paragraphs provided";
   "--no-par-names", Arg.Unit (fun () -> par_names:=false), "No identifiers of paragraphs provided (default)";
+  "--proper-names", Arg.Unit (fun () -> ENIAMsubsyntaxTypes.recognize_proper_names:=true), "Recognize proper names (default)";
+  "--no-proper-names", Arg.Unit (fun () -> ENIAMsubsyntaxTypes.recognize_proper_names:=false), "Do not recognize proper names";
   ]
  
 let usage_msg =
@@ -93,7 +93,7 @@ let walenty_filename,expands_filename =
   (* "/home/yacheu/Dokumenty/NLP resources/Walenty/walenty_20170311.xml",
     "/home/yacheu/Dokumenty/NLP resources/Walenty/phrase_types_expand_20170311.xml" *)
  
-let _ =
+(*let _ =
   let walenty,phrases = ENIAMwalTEI.load_walenty walenty_filename in
   let walenty = Xlist.rev_map walenty correct_walenty in
   let expands = ENIAMwalTEI.load_expands expands_filename in
@@ -126,7 +126,7 @@ let _ =
   File.file_out "results/controll.tab" (fun file ->
     StringMap.iter cmap (fun s l  ->
       Printf.fprintf file "%d\t%s\t%s\n" (Xlist.size l) s (String.concat " " l)));
-  ()
+  ()*)
  
 (* Test unikalności indeksów sensów *)
 (* let _ =
@@ -339,3 +339,110 @@ let has_realization = function
  
 (* let _ = print_entries entries *)
 *)
+
+let selected_phrases =
+  File.fold_tab "results/phrases_cp.tab" IntSet.empty (fun set -> function
+    [id;_] -> IntSet.add set (int_of_string id)
+  | _ -> failwith "selected_phrases")
+
+let print_phrases filename phrases =
+  File.file_out filename (fun file ->
+      IntMap.iter phrases (fun id morf ->
+        Printf.fprintf file "%d\t%s\n" id (ENIAMwalStringOf.morf morf)))
+
+let rec connected_schema schema =
+  String.concat "+" (Xlist.map schema (fun s ->
+      String.concat "," (
+        (if s.gf = ARG then [] else [ENIAMwalStringOf.gf s.gf])@
+        s.mode@(ENIAMwalStringOf.controllers s.cr)@(ENIAMwalStringOf.controllees s.ce)) ^
+      "{" ^  String.concat ";" (Xlist.map s.morfs ENIAMwalStringOf.morf) ^ "}:" ^ ENIAMwalStringOf.sem_frame s))
+
+let print_connected filename connected =
+  File.file_out filename (fun file ->
+      Entries.iter connected (fun pos lemma c(*sopinion,fopinion,meanings,(n,p,a),schema,examples*) ->
+          Printf.fprintf file "\n\t%d\t%d\t%s: %s: %s: %s: %s: %s: %s: %s:\t%s\n"
+            c.sch_id c.frm_id pos lemma
+            (ENIAMwalStringOf.opinion c.sopinion)
+            (ENIAMwalStringOf.opinion c.fopinion)
+            (String.concat "," (Xlist.map c.meanings (fun m ->
+              if m.name="" then string_of_int m.mng_id else m.name ^ "-" ^ m.variant)))
+            (ENIAMwalStringOf.negation c.negativity)
+            (ENIAMwalStringOf.pred c.predicativity)
+            (ENIAMwalStringOf.aspect c.aspect)
+            (connected_schema c.schema);
+          Xlist.iter c.examples (fun (opinion,exm) ->
+            Printf.fprintf file "#%s: %s\n" (ENIAMwalStringOf.opinion opinion) exm)))
+
+let expand_morf phrases = function
+  | MorfId id ->
+      (try IntMap.find phrases id
+      with Not_found -> Printf.printf "expand_morf: %d\n" id; MorfId id)
+  | _ -> failwith "expand_morf"
+
+let expand_sel_prefs meanings = function
+    SynsetId id ->
+      (try
+        let m = IntMap.find meanings id in
+        Predef (m.name ^ "-" ^ m.variant)
+      with Not_found -> (*Printf.printf "expand_sel_prefs: %d\n" id;*) SynsetId id)
+  | s -> s
+
+let expand_schema phrases meanings_map c =
+  let schema = Xlist.map c.schema (fun (s : position) ->
+    {s with
+      morfs = Xlist.map s.morfs (expand_morf phrases);
+      sel_prefs = Xlist.map s.sel_prefs (expand_sel_prefs meanings_map)}) in
+  (* let meanings = Xlist.map c.meanings (fun id -> try IntMap.find meanings_map id with Not_found -> {empty_meaning with name=string_of_int id}) in *)
+  {c with (*meanings2=meanings;*) schema=schema}
+
+let assign_examples examples c =
+  let p_set = Xlist.fold c.schema IntSet.empty (fun p_set p ->
+    Xlist.fold p.morfs p_set (fun p_set -> function
+        MorfId id -> IntSet.add p_set id
+      | _ -> p_set)) in
+  let m_set = Xlist.fold c.meanings IntSet.empty (fun m_set m -> IntSet.add m_set m.mng_id) in
+  let examples = Xlist.fold examples [] (fun examples (e : example) ->
+    let b = Xlist.fold e.phrases false (fun b (sch_id,_,morf_id) ->
+      if c.sch_id = sch_id && IntSet.mem p_set morf_id then true else b) in
+    if IntSet.mem m_set e.meaning && b then e :: examples else examples) in
+  let examples = Xlist.rev_map examples (fun e -> e.opinion,e.sentence) in
+  {c with examples=examples}
+
+let select_morfs morfs =
+  List.rev (Xlist.fold morfs [] (fun morfs -> function
+      MorfId id -> if IntSet.mem selected_phrases id then (MorfId id) :: morfs else morfs
+    | _ -> failwith "select_morfs"))
+
+let select_positions schema =
+  List.rev (Xlist.fold schema [] (fun schema p ->
+    let morfs = select_morfs p.morfs in
+    if morfs = [] then schema else
+    {p with morfs = morfs} :: schema))
+
+let select_entries entries =
+  Xlist.fold entries [] (fun entries c ->
+    let schema = select_positions c.schema in
+    if schema = [] then entries else c :: entries)
+
+(* Wypisanie podrzędników zdaniowych *)
+let _ =
+  let walenty,phrases = ENIAMwalTEI.load_walenty walenty_filename in
+  print_phrases "results/phrases.tab" phrases;
+  let meanings =
+    Xlist.fold walenty IntMap.empty (fun meanings entry ->
+      Xlist.fold entry.meanings meanings (fun meanings meaning ->
+        IntMap.add meanings meaning.mng_id meaning)) in
+  let connected_walenty =
+    Xlist.fold walenty Entries.empty (fun connected_walenty e ->
+        (* print_endline "1"; *)
+        let entries = ENIAMwalConnect.connect e in
+        (* print_endline "2"; *)
+        let entries = select_entries entries in
+        (* print_endline "3"; *)
+        let entries = Xlist.rev_map entries (assign_examples e.examples) in
+        (* print_endline "4"; *)
+        let entries = Xlist.rev_map entries (expand_schema phrases meanings) in
+        (* print_endline "5"; *)
+        Entries.add_inc_list connected_walenty e.form_pos e.form_orth entries) in
+  print_connected "results/connected.tab" connected_walenty;
+  ()
@@ -30,7 +30,7 @@ let process_positions positions =
       IntMap.add positions position.psn_id position)
  
 let process_schemata schemata =
-  Xlist.fold schemata IntMap.empty (fun schemata schema ->
+  Xlist.fold schemata IntMap.empty (fun schemata (schema : schema)  ->
     let atrs = schema.negativity, schema.predicativity, schema.aspect in
     let positions = process_positions schema.positions in
     IntMap.add schemata schema.sch_id (schema.reflexiveMark,schema.opinion,atrs,positions))
@@ -44,9 +44,9 @@ let process_frames frames =
       let arguments = process_arguments frame.arguments in
       IntMap.add frames frame.frm_id (frame,arguments))
  
-(* let process_meanings meanings =
+let process_meanings meanings =
   Xlist.fold meanings IntMap.empty (fun meanings meaning ->
-      IntMap.add meanings meaning.mng_id meaning(*meaning.name ^ " " ^ meaning.variant*)) *)
+      IntMap.add meanings meaning.mng_id meaning(*meaning.name ^ " " ^ meaning.variant*))
  
 let process_sel_pref arguments = function
     SynsetId s -> SynsetId s(*try ENIAMplWordnet.synset_name s with Not_found -> "unknown"*)
@@ -59,9 +59,9 @@ let process_sel_pref arguments = function
 let connect entry =
   let schemata = process_schemata entry.schemata in
   let frames = process_frames entry.frames in
-  (* let meanings = process_meanings entry.meanings in *)
+  let meanings = process_meanings entry.meanings in
   Xlist.fold entry.alternations [] (fun found alt ->
-    let refl,opinion,schema_atrs,positions = IntMap.find schemata alt.schema in
+    let refl,opinion,(n,p,a),positions = IntMap.find schemata alt.schema in
     let frame,arguments = IntMap.find frames alt.frame in
     let conn_positions = if refl then [ENIAMwalTEI.refl_position] else [] in
     let conn_positions = Xlist.fold alt.connections conn_positions (fun conn_positions conn ->
@@ -75,9 +75,10 @@ let connect entry =
               with Not_found -> if entry.form_orth <> "podobać" then Printf.printf "connect: %s\n%!" entry.form_orth;morfs) in
           {position with role=arg.role; role_attr=arg.role_attribute; sel_prefs=sel_prefs;
                          morfs=List.rev morfs} :: conn_positions)) in
-    (* let meanings = List.rev (Xlist.rev_map frame.meanings (fun id ->
-          IntMap.find meanings id)) in *)
-    (opinion,frame.opinion,frame.meanings,schema_atrs,conn_positions) :: found)
+    let meanings = List.rev (Xlist.rev_map frame.meanings (fun id ->
+          try IntMap.find meanings id with Not_found -> {empty_meaning with mng_id=id})) in
+    {sch_id=alt.schema; frm_id=alt.frame; sopinion=opinion; fopinion=frame.opinion; meanings=meanings;
+      negativity=n; predicativity=p;aspect=a; schema=conn_positions; examples=[]} :: found)
  
 let schemata entry =
   let schemata = process_schemata entry.schemata in
@@ -31,40 +31,54 @@ let correct_walenty entry =
   else entry
  
 let load_walenty walenty_filename expands_filename =
+  print_endline "load_walenty 1";
   let walenty,phrases = ENIAMwalTEI.load_walenty walenty_filename in
+  print_endline "load_walenty 2";
   let walenty = Xlist.rev_map walenty correct_walenty in
+  print_endline "load_walenty 3";
   let expands = ENIAMwalTEI.load_expands expands_filename in
+  print_endline "load_walenty 4";
   let meanings =
     Xlist.fold walenty IntMap.empty (fun meanings entry ->
       Xlist.fold entry.meanings meanings (fun meanings meaning ->
         IntMap.add meanings meaning.mng_id meaning)) in
+  print_endline "load_walenty 5";
   let connected_walenty =
     Xlist.fold walenty Entries.empty (fun connected_walenty e ->
         let entries = ENIAMwalConnect.connect e in
         Entries.add_inc_list connected_walenty e.form_pos e.form_orth entries) in
+  print_endline "load_walenty 6";
   let schemata_walenty =
     Xlist.fold walenty Entries.empty (fun schemata_walenty e ->
         let entries = ENIAMwalConnect.schemata e in
         Entries.add_inc_list schemata_walenty e.form_pos e.form_orth entries) in
+  print_endline "load_walenty 7";
   let expands,compreps,subtypes,equivs,adv_types =
     ENIAMwalRealizations.load_realizations (expands,ENIAMwalTEI.subtypes,ENIAMwalTEI.equivs) in
+  print_endline "load_walenty 8";
   let phrases =
     IntMap.map phrases (fun morf ->
         let morf = ENIAMwalRealizations.expand_schema_morf expands morf in
         let morfs = ENIAMwalRealizations.expand_subtypes_morf subtypes morf in
         let morf = List.flatten (Xlist.map morfs (ENIAMwalRealizations.expand_equivs_morf equivs)) in
         morf) in
+  print_endline "load_walenty 9";
   let compreps = Xlist.map compreps (fun (lemma,morfs) ->
       lemma, ENIAMwalLex.expand_lexicalizations_morfs morfs) in
+  print_endline "load_walenty 10";
   let entries = ENIAMwalLex.extract_lex_entries_comprepnp [] compreps in
+  print_endline "load_walenty 11";
   let phrases,entries =
     IntMap.fold phrases (IntMap.empty,entries) (fun (phrases,entries) id morfs ->
         let morfs = ENIAMwalLex.expand_lexicalizations_morfs morfs in
         let morfs,entries = Xlist.fold morfs ([],entries) ENIAMwalLex.extract_lex_entries in
         IntMap.add phrases id morfs, entries) in
+  print_endline "load_walenty 12";
   let entries = Xlist.fold entries Entries.empty (fun entries (pos,lemma,entry) ->
       Entries.add_inc entries pos lemma entry) in
+  print_endline "load_walenty 13";
   let entries = Entries.map2 entries (fun pos lemma entries -> EntrySet.to_list (EntrySet.of_list entries)) in
+  print_endline "load_walenty 14";
   let entries = Entries.flatten_map entries (fun pos lemma entry ->
       ENIAMwalLex.expand_restr [] lemma pos entry) in
     (* let entries =
@@ -72,6 +86,7 @@ let load_walenty walenty_filename expands_filename =
         StringMap.mapi entries2 (fun lemma entries3 ->
             EntrySet.fold entries3 [] (fun entries3 entry ->
                 (ENIAMwalLex.expand_restr [] lemma pos entry) @ entries3))) in *)
+  print_endline "load_walenty 15";
   connected_walenty, schemata_walenty, phrases, entries, meanings, adv_types
  
 let print_entries filename entries =
@@ -97,15 +112,15 @@ let print_schemata filename schemata =
  
 let print_connected filename connected =
   File.file_out filename (fun file ->
-      Entries.iter connected (fun pos lemma (sopinion,fopinion,meanings,(n,p,a),schema) ->
+      Entries.iter connected (fun pos lemma c(*sopinion,fopinion,meanings,(n,p,a),schema*) ->
           Printf.fprintf file "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n" pos lemma
-            (ENIAMwalStringOf.opinion sopinion)
-            (ENIAMwalStringOf.opinion fopinion)
-            (String.concat "," (Xlist.map meanings string_of_int))
-            (ENIAMwalStringOf.negation n)
-            (ENIAMwalStringOf.pred p)
-            (ENIAMwalStringOf.aspect a)
-            (ENIAMwalStringOf.connected_schema schema)))
+            (ENIAMwalStringOf.opinion c.sopinion)
+            (ENIAMwalStringOf.opinion c.fopinion)
+            (String.concat "," (Xlist.map c.meanings (fun m -> string_of_int m.mng_id)))
+            (ENIAMwalStringOf.negation c.negativity)
+            (ENIAMwalStringOf.pred c.predicativity)
+            (ENIAMwalStringOf.aspect c.aspect)
+            (ENIAMwalStringOf.connected_schema c.schema)))
  
 let split_tokens s =
   let l = List.flatten (Xlist.map (Str.full_split (Str.regexp " \\|,\\|-") s) (function
@@ -101,6 +101,7 @@ let gf = function
     SUBJ -> "subj"
   | OBJ -> "obj"
   | ARG -> "arg"(*""*)
+  | HEAD -> "head"
  
 let pos = function
     SUBST(n,c) -> "SUBST(" ^ number n ^ "," ^ case c ^ ")"
@@ -60,7 +60,8 @@ let rec tei_to_string = function
   | Fset(s,l) -> Printf.sprintf "Fset(%s,[%s])" s (String.concat ";" (Xlist.map l tei_to_string))
   | Fs(s,l) -> Printf.sprintf "Fs(%s,[%s])" s (String.concat ";" (Xlist.map l tei_to_string))
   | Id id -> Printf.sprintf "Id(%s)" (string_of_id id)
-  | SameAs(id,s) -> Printf.sprintf "F(Id,%s)" s
+  (* | SameAs(id,s) -> Printf.sprintf "F(Id,%s)" s *)
+  | SameAs(id,s) -> Printf.sprintf "SameAs(%s,%s)" (string_of_id id) s
  
 let rec parse_tei = function
     Xml.Element("f",["name",name],[Xml.Element("vColl",["org","set"],set)]) ->
@@ -82,6 +83,7 @@ let rec parse_tei = function
 let parse_gf = function
     "subj" -> SUBJ
   | "obj" -> OBJ
+  | "head" -> HEAD
   | s -> failwith ("parse_gf: " ^ s)
  
 let parse_control arg = function
@@ -128,6 +130,7 @@ let parse_number = function
  
 let parse_gender = function
     "m1" -> Gender "m1"
+  | "m2" -> Gender "m2"
   | "m3" -> Gender "m3"
   | "n" -> Gender "n"(*Genders["n1";"n2"]*)
   | "f" -> Gender "f"
@@ -136,6 +139,21 @@ let parse_gender = function
   | "agr" -> GenderAgr
   | s -> failwith ("parse_gender: " ^ s)
  
+let parse_genders = function
+    [Symbol "agr"] -> GenderAgr
+  | genders ->
+      let genders = Xlist.map genders (function
+           Symbol "m1" -> "m1"
+         | Symbol "m2" -> "m2"
+         | Symbol "m3" -> "m3"
+         | Symbol "n" -> "n"
+         | Symbol "f" -> "f"
+         | s -> failwith ("parse_genders: " ^ tei_to_string s)) in
+      (match genders with
+        [g] -> Gender g
+      | [] -> failwith "parse_genders: empty"
+      | _ -> Genders genders)
+
 let parse_grad = function
     "pos" -> Grad "pos"
   | "com" -> Grad "com"
@@ -310,7 +328,7 @@ and load_lex arg xml = match xml with
   | F("reflex",Binary true) -> {arg with lex_reflex = ReflTrue}
   | F("reflex",Binary false) -> {arg with lex_reflex = ReflFalse}
   | Fset("reflex",[]) -> {arg with lex_reflex = ReflEmpty}
-  | Fset("gender",[Symbol value]) -> {arg with lex_gender = parse_gender value}
+  | Fset("gender",genders) -> {arg with lex_gender = parse_genders genders}
   | xml ->
     Printf.printf "%s\n" (tei_to_string xml);
     failwith "load_lex:\n "
@@ -436,6 +454,8 @@ let load_phrases_set ent = function
 let load_example_info ent arg = function
   | F("meaning",SameAs({hash=true; numbers=[ent_id;id]; suffix="mng"},"lexical_unit")) ->
       if ent_id = ent then {arg with meaning = id} else failwith (Printf.sprintf "load_example_info %d %d" ent ent_id)
+  | F("meaning",SameAs({hash=true; numbers=[id]; suffix="mng"},"lexical_unit")) ->
+      {arg with meaning = id}
   | Fset("phrases",phrases_set) ->
     {arg with phrases = List.rev (Xlist.rev_map phrases_set (load_phrases_set ent))}
   | F("sentence",TEIstring sentence_string) -> {arg with sentence = sentence_string}
@@ -456,8 +476,8 @@ let load_example ent = function
 let load_self_prefs_sets name ent frm = function
   | Numeric value -> if name = "synsets" then SynsetId value else failwith "load_self_prefs_sets"
   | Symbol value -> if name = "predefs" then Predef value else failwith "load_self_prefs_sets"
-  | Fs("relation",[F("type",Symbol value);F("to",SameAs({hash=true; numbers=[ent_id;frm_id;arg_id]; suffix="arg"}, "argument"))]) ->
-    if ent_id <> ent || frm_id <> frm || name <> "relations" then failwith (Printf.sprintf "load_self_prefs_sets %d %d" ent ent_id)
+  | Fs("relation",[F("type",Symbol value);F("to",SameAs({hash=true; numbers=[(*ent_id;*)frm_id;arg_id]; suffix="arg"}, "argument"))]) ->
+    if (*ent_id <> ent ||*) frm_id <> frm || name <> "relations" then failwith (Printf.sprintf "load_self_prefs_sets %d" ent (*ent_id*))
     else RelationArgId(value,arg_id)
   | xml -> failwith ("load_self_prefs_sets: \n " ^ tei_to_string xml)
  
@@ -472,9 +492,9 @@ let load_argument_info ent frm arg = function
   | F("sel_prefs",Fs("sel_prefs_groups", self_prefs)) ->
     {arg with sel_prefs = List.flatten (List.rev (Xlist.rev_map self_prefs (load_argument_self_prefs ent frm)))}
   (* | Id id -> {arg with arg_id = id} *)
-  | Id{hash=false; numbers=[ent_id;frm_id;id]; suffix="arg"} ->
-     if ent_id = ent && frm_id = frm then {arg with arg_id = id}
-     else failwith (Printf.sprintf "load_argument_info %d %d" ent ent_id)
+  | Id{hash=false; numbers=[(*ent_id;*)frm_id;id]; suffix="arg"} ->
+     if (*ent_id = ent &&*) frm_id = frm then {arg with arg_id = id}
+     else failwith (Printf.sprintf "load_argument_info %d" ent (*ent_id*))
   | xml -> failwith ("load_argument_info :\n " ^ tei_to_string xml)
  
 let load_arguments_set ent frm = function
@@ -485,21 +505,26 @@ let load_arguments_set ent frm = function
   | xml -> failwith ("load_arguments_set :\n " ^ tei_to_string xml)
  
 let load_meanings_set ent = function
-  | SameAs({hash=true; numbers=[ent_id;id]; suffix="mng"},"lexical_unit") ->
-      if ent_id = ent then id else failwith (Printf.sprintf "load_meanings_set %d %d" ent ent_id)
+  | SameAs({hash=true; numbers=[(*ent_id;*)id]; suffix="mng"},"lexical_unit") ->
+      (*if ent_id = ent then*) id (*else failwith (Printf.sprintf "load_meanings_set %d %d" ent ent_id)*)
   | xml -> failwith ("load_meanings_set :\n " ^ tei_to_string xml)
  
 let load_frame ent = function
   | Fs("frame",[
-      Id{hash=false; numbers=[ent_id;id]; suffix="frm"};
+      Id{hash=false; numbers=[(*ent_id;*)id]; suffix="frm"};
       F("opinion",Symbol opinion);
       Fset("meanings",meanings_set);
       Fset("arguments",arguments_set)]) ->
-    if ent_id <> ent then failwith (Printf.sprintf "load_frame %d %d" ent ent_id) else
+    (*if ent_id <> ent then failwith (Printf.sprintf "load_frame %d %d" ent ent_id) else*)
+    (* Printf.printf "Frame IN %d\n" id; *)
     {frm_id = id;
      opinion = parse_opinion opinion;
      meanings = List.rev (Xlist.rev_map meanings_set (load_meanings_set ent));
      arguments = List.rev (Xlist.rev_map arguments_set (load_arguments_set ent id))}
+  | SameAs({hash=true; numbers=[id]; suffix="frm"},frame) -> (* FIXME !! *)
+      (* (try IntMap.find frames id with Not_found -> failwith ("load_frame: ^ " ^ string_of_int id)) *)
+      (* Printf.printf "Frame OUT %d\n" id; *)
+      {frm_id=(-id); opinion=Nieokreslony; meanings=[]; arguments=[]}
   | xml -> failwith ("load_frame :\n " ^ tei_to_string xml)
  
 let load_meaning_info ent arg = function
@@ -507,7 +532,8 @@ let load_meaning_info ent arg = function
   | F("variant",TEIstring variant_string) -> {arg with variant = variant_string}
   | F("plwnluid",Numeric value) -> {arg with plwnluid = value}
   | F("gloss",TEIstring gloss_string) -> {arg with gloss = gloss_string}
-  | Id{hash=false; numbers=[ent_id;id]; suffix="mng"} -> if ent_id = ent then {arg with mng_id = id} else failwith (Printf.sprintf "load_meaning_info %d %d" ent ent_id)
+  (* | Id{hash=false; numbers=[ent_id;id]; suffix="mng"} -> if ent_id = ent then {arg with mng_id = id} else failwith (Printf.sprintf "load_meaning_info %d %d" ent ent_id) *)
+  | Id{hash=false; numbers=[id]; suffix="mng"} -> {arg with mng_id = id}
   | xml -> failwith ("load_meaning_info:\n " ^ tei_to_string xml)
  
  
@@ -518,9 +544,9 @@ let load_meaning ent = function
  
 let load_alter_connection ent = function
   | Fs("connection", [
-      F("argument",SameAs({hash=true; numbers=[ent_id;frm_id;arg_id]; suffix="arg"},"argument"));
+      F("argument",SameAs({hash=true; numbers=[(*ent_id;*)frm_id;arg_id]; suffix="arg"},"argument"));
       Fset("phrases",phrases)]) ->
-   if ent_id <> ent then failwith (Printf.sprintf "load_alter_connection %d %d" ent ent_id) else
+   (* if ent_id <> ent then failwith (Printf.sprintf "load_alter_connection %d %d" ent ent_id) else *)
      let phrases,sch_set = Xlist.fold phrases (IntMap.empty,IntSet.empty) (fun (phrases,sch_set) phrase ->
        let sch_id,psn_id,phr_id = load_phrases_set ent phrase in
        IntMap.add_inc phrases psn_id [phr_id] (fun l -> phr_id :: l),
@@ -528,7 +554,7 @@ let load_alter_connection ent = function
      if IntSet.size sch_set <> 1 then failwith (Printf.sprintf "load_alter_connection: |sch_set|=%d" (IntSet.size sch_set)) else
      IntSet.min_elt sch_set, frm_id,
      {argument = arg_id; phrases = IntMap.fold phrases [] (fun l psn phrs -> (psn,phrs) :: l)}
-  | xml -> failwith ("load_alter_connections: \n " ^ tei_to_string xml)
+  | xml -> failwith ("load_alter_connection: \n " ^ tei_to_string xml)
  
 let load_alternations ent = function
   | Fs("alternation",[Fset("connections",connections_set)]) ->
@@ -561,6 +587,17 @@ let load_entry phrases = function
             | xml -> failwith ("load_entry: \n" ^ tei_to_string xml)))
    | xml -> failwith ("load_entry: \n" ^ Xml.to_string_fmt xml)
  
+let add_known_frames known_frames e =
+  Xlist.fold e.frames known_frames (fun known_frames f ->
+    if f.frm_id < 0 then known_frames else IntMap.add known_frames f.frm_id f)
+
+let expand_frames known_frames e =
+  {e with frames =
+    List.rev (Xlist.rev_map e.frames (fun f ->
+      if f.frm_id < 0 then
+        try IntMap.find known_frames (-f.frm_id) with Not_found -> failwith "expand_frames"
+      else f))}
+
 let load_walenty filename =
   begin
     match Xml.parse_file filename with
@@ -568,7 +605,9 @@ let load_walenty filename =
                   [Xml.Element("teiHeader",_,_) ;
                    Xml.Element("text",[],[Xml.Element("body",[],entries)])]) ->
         let phrases = ref IntMap.empty in
-        let walenty = List.rev (Xlist.rev_map entries (load_entry phrases)) in
+        let walenty = Xlist.rev_map entries (load_entry phrases) in
+        let known_frames = Xlist.fold walenty IntMap.empty add_known_frames in
+        let walenty = Xlist.rev_map walenty (expand_frames known_frames) in
         walenty, !phrases
     | _ -> failwith "load_walenty"
   end
@@ -33,7 +33,7 @@ type grad = Grad of string | GradUndef
 type refl = ReflEmpty | ReflTrue | ReflFalse | ReflUndef
 (* type acm = Acm of string | AcmUndef *)
  
-type gf = SUBJ | OBJ | ARG
+type gf = SUBJ | OBJ | ARG | HEAD (* FIXME *)
  
 type pos =
     SUBST of number * case
@@ -219,3 +219,14 @@ type entry = {ent_id: int;
  
 let empty_entry = {ent_id=(-1); status=""; form_orth=""; form_pos=""; schemata=[]; examples=[];
                    frames=[]; meanings=[]; alternations=[]}
+
+type connected = {sch_id: int;
+                  frm_id: int;
+                  sopinion: opinion;
+                  fopinion: opinion;
+                  meanings: meaning list;
+                  negativity: negation;
+                  predicativity: pred;
+                  aspect: aspect;
+                  schema: position list;
+                  examples: (opinion * string) list}
@@ -32,8 +32,8 @@ make clean
  
 Credits
 -------
-Copyright © 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
-Copyright © 2016-2017 Institute of Computer Science Polish Academy of Sciences
+Copyright © 2016-2018 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+Copyright © 2016-2018 Institute of Computer Science Polish Academy of Sciences
  
 Licence
 -------
@@ -3,7 +3,7 @@ Walenty: a valence dictionary of Polish (http://zil.ipipan.waw.pl/Walenty)
  
 Walenty is licensed under the following license:
  
-(C) Copyright 2012–2017 by the Institute of Computer Science, Polish Academy of Sciences (IPI PAN)
+(C) Copyright 2012–2018 by the Institute of Computer Science, Polish Academy of Sciences (IPI PAN)
 This work is distributed under a CC BY-SA license: http://creativecommons.org/licenses/by-sa/4.0/
 Walenty is a valence dictionary of Polish developed at the Institute of Computer Science, Polish Academy of Sciences (IPI PAN). It currently contains 90326 schemata and 17920 frames for 16044 lemmata.
 The original formalism of Walenty was established by Filip Skwarski, Elżbieta Hajnicz, Agnieszka Patejuk, Adam Przepiórkowski, Marcin Woliński, Marek Świdziński, and Magdalena Zawisławska. It has been further developed by Elżbieta Hajnicz, Agnieszka Patejuk, Adam Przepiórkowski, and Marcin Woliński. The semantic layer has been developed by Elżbieta Hajnicz and Anna Andrzejczuk.