Wojciech Jaworski / ENIAM

(*
 *  ENIAM: Categorial Syntactic-Semantic Parser for Polish
 *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
 *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *)

open ENIAMtokenizerTypes
open ENIAMwalTypes
open ENIAMlexSemanticsTypes
open LCGtypes
open Xstd

let all_genders = ["m1";"m2";"m3";"f";"n1";"n2";"p1";"p2";"p3"]
let all_cases = ["nom";"gen";"dat";"acc";"inst";"loc";"voc"]
let all_persons = ["pri";"sec";"ter"]
let all_numbers = ["sg";"pl"]
(* FIXME: zamiast wszystkich możliwych wartości można używać Zero gdy nie ma uzgodnienia *)

let expand_numbers numbers =
  if Xlist.mem numbers "_" then ["sg";"pl"] else numbers

let expand_genders genders  =
  if Xlist.mem genders "_" then all_genders else genders

let expand_cases cases  =
  if Xlist.mem cases "_" || Xlist.mem cases "$C" then all_cases else cases

let expand_akcs akcs  =
  if Xlist.mem akcs "_" then ["akc";"nakc"] else akcs

let split_voc cases =
  let cases,voc = Xlist.fold cases ([],[]) (fun (cases,voc) -> function
    "voc" -> cases, "voc" :: voc
  | s -> s :: cases, voc) in
  match cases,voc with
    [],["voc"] -> [["voc"]]
  | _,["voc"] -> [List.rev cases; ["voc"]]
  | _,[] -> [List.rev cases]
  | _ -> failwith "split_voc"

let check_frame_case cases = function
    CaseAgr -> cases
  | AllAgr -> cases
  | CaseUndef -> cases
  | Case case -> if not (Xlist.mem cases case) then raise Not_found else [case]
  | Str -> cases
  | case -> failwith ("check_frame_case: " ^ ENIAMwalStringOf.case case)

let check_frame_number numbers = function
    Number num -> if not (Xlist.mem numbers num) then raise Not_found else [num]
  | NumberUndef -> numbers
  | NumberAgr -> numbers

let check_frame_number2 numbers = function
    Common "mass" -> if not (Xlist.mem numbers "sg") then raise Not_found else ["sg"]
  | _ -> numbers

let check_frame_gender genders = function
    Gender gender -> if not (Xlist.mem genders gender) then raise Not_found else [gender]
  | GenderUndef -> genders
  | GenderAgr -> genders
  | Genders genders2 ->
       let set = StringSet.intersection (StringSet.of_list genders) (StringSet.of_list genders2) in
       if StringSet.is_empty set then raise Not_found
       else StringSet.to_list set

let check_frame_grad grads = function
    Grad grad -> if not (Xlist.mem grads grad) then raise Not_found else [grad]
  | GradUndef -> grads

let check_frame_acm acms = function
    Acm acm -> if not (Xlist.mem acms acm) then raise Not_found else acm
  | AcmUndef -> failwith "check_acm"

let check_frame_aspect aspects = function
    Aspect aspect -> if not (Xlist.mem aspects aspect) then raise Not_found else [aspect]
  | AspectUndef -> aspects
  | AspectNA -> failwith "check_frame_aspect"

let check_frame_negation = function
    ["aff"] -> (function Negation -> raise Not_found | Aff -> "aff" | NegationUndef -> "aff" | NegationNA -> failwith "check_frame_negation")
  | ["neg"] -> (function Negation -> "negation" | Aff -> raise Not_found | NegationUndef -> "negation" | NegationNA -> failwith "check_frame_negation")
  | _ -> failwith "check_frame_negation"

let adjunct_schema_field role dir morfs =
  {gf=ADJUNCT; role=role; role_attr=""; sel_prefs=[]; cr=[]; ce=[]; dir=dir; morfs=morfs}

let comp_arg_schema_field morfs =
  {gf=CORE; role=""; role_attr=""; sel_prefs=[]; cr=[]; ce=[]; dir=Forward; morfs=morfs} (* FIXME: uporządkować sensy *)

let prep_arg_schema_field morfs =
  {gf=CORE; role="Ref"; role_attr=""; sel_prefs=[]; cr=[]; ce=[]; dir=Forward; morfs=morfs} (* FIXME: uporządkować sensy *)

let prep_arg_schema_field2 morfs =
  {gf=CORE; role="Ref"; role_attr=""; sel_prefs=[]; cr=[]; ce=[]; dir=Forward; morfs=morfs} (* FIXME: uporządkować sensy *)

let schema_field gf role dir morfs =
  {gf=gf; role=role; role_attr=""; sel_prefs=[]; cr=[]; ce=[]; dir=dir; morfs=morfs}

let arg_schema_field dir morfs =
  {gf=ARG; role=""; role_attr=""; sel_prefs=[]; cr=[]; ce=[]; dir=dir; morfs=morfs}

let nosem_schema_field dir morfs =
  {gf=NOSEM; role=""; role_attr=""; sel_prefs=[]; cr=[]; ce=[]; dir=dir; morfs=morfs}

let nosem_refl_schema_field =
  {gf=NOSEM; role=""; role_attr=""; sel_prefs=[]; cr=[]; ce=[]; dir=Both; morfs=[Phrase(Lex "się")]}

let num_arg_schema_field morfs =
  {gf=CORE; role="QUANT-ARG"; role_attr=""; sel_prefs=["sense"]; cr=[]; ce=[]; dir=Forward; morfs=morfs}

let inclusion = nosem_schema_field(*adjunct_schema_field "Inclusion"*) Forward [Phrase Null;Phrase Inclusion]

let qub_inclusion = [adjunct_schema_field "Manner" Backward [Phrase Null;Phrase Qub];
                     inclusion]

let nosem_prep = [nosem_schema_field Backward [Phrase(Prep("",CaseAgr))]]
let nosem_uprep = [nosem_schema_field Backward [Phrase(Prep("",CaseUAgr))]]

let num_congr = [adjunct_schema_field "Quantifier" Backward [Phrase Null;Phrase(Num(AllAgr,Acm "congr"))]]
let num_rec = [adjunct_schema_field "Quantifier" Backward [Phrase(Num(AllAgr,Acm "rec"))]]
let noun_measure = [adjunct_schema_field "Quantifier" Backward [Phrase(Measure(AllUAgr))]]

(* Przykłady:  ironia losu, ścieżki anomalia, akcja w obronie słonia, na słoniu *)

let uni_weight = ref 0.
let uni_weight_step = 0.000001

let add_uni_weight weight =
  uni_weight := !uni_weight (*+. uni_weight_step*);
  weight +. !uni_weight

let rec list_assoc2 x = function
    (s,a,b) :: l -> if x = s then a,b else list_assoc2 x l
  | [] -> raise Not_found

let lex_weight = 2.
let symbol_weight = 1.

(* FIXME: mowę niezależną należałoby ograniczyć do zewnętrznych argumentów. *)

let ge = LCGreductions.get_variant_label

let measure_weight = 0.5

let months = StringSet.of_list ["styczeń";"luty";"marzec";"kwiecień";"maj";"czerwiec";"lipiec";"sierpień";"wrzesień";"październik";"litopad";"grudzień"]
let objids = StringSet.of_list ["rysunek"]

let int_arg = [arg_schema_field Forward [Phrase(Null);Phrase(Lex "int")]]


let create_entries tokens lex_sems id (c:ENIAMtokenizerTypes.token_record) (d:ENIAMlexSemanticsTypes.lex_sem) x_flag =

let make_node lemma cat weight fnum l =
  let attrs,args = Xlist.fold  l ([],[]) (fun (attrs,args) -> function
    | "number" -> ("NUM",SubstVar "number") :: attrs, args
    | "case" -> ("CASE",SubstVar "case") :: attrs, args
    | "gen" -> ("CASE",Val "gen") :: attrs, args
    | "gender" -> ("GEND",SubstVar "gender") :: attrs, args
    | "person" -> ("PERS",SubstVar "person") :: attrs, args
    | "aspect" -> ("ASPECT", SubstVar "aspect") :: attrs, args
    | "ctype" -> ("TYPE", SubstVar "ctype") :: attrs, args
    | "lex" -> ("LEX",Val "+") :: attrs, args
    | "pres" -> ("TENSE", Val "pres") :: attrs, args
    | "fut" -> ("TENSE", Val "fut") :: attrs, args
    | "past" -> ("TENSE", Val "past") :: attrs, args
    | "indicative" -> ("MOOD", Val "indicative") :: attrs, args
    | "conditional" -> ("MOOD", Val "conditional") :: attrs, args
    | "imperative" -> ("MOOD", Val "imperative") :: attrs, args
    | "pronoun" -> ("SYN", Val "pronoun") :: attrs, args
    | "proper" -> ("SYN", Val "proper") :: attrs, args
    | "common" -> ("SYN", Val "common") :: attrs, args
    | "count" -> ("NSEM", Val "count") :: attrs, args
    | "mass" -> ("NSEM", Val "mass") :: attrs, args
    | "measure" -> ("NSEM", Val "measure") :: attrs, args
    | "time" -> ("NSEM", Val "time") :: attrs, args
    | "int" -> ("TYPE", Val "int") :: attrs, args
    | "rel" -> ("TYPE", Val "rel") :: attrs, args
    | "sub" -> ("TYPE", Val "sub") :: attrs, args
    | "coord" -> ("TYPE", Val "coord") :: attrs, args
    | "comp" -> ("TYPE", Val "comp") :: attrs, args
    | "indexical" -> attrs, args
    | "deictic" -> attrs, args
    | "coreferential" -> attrs, args
    | "order" -> attrs, args
    | "comparative" -> attrs, args
    | "pos" -> ("GRAD", Val "pos") :: attrs, args
    | "com" -> ("GRAD", Val "com") :: attrs,
          let id = ExtArray.add tokens {empty_token with token=Lemma("bardziej","adv",[])} in
          let _ = ExtArray.add lex_sems empty_lex_sem in
          (Cut(Node{LCGrenderer.empty_node with pred="bardziej"; id=id; cat="adv"; agf=ADJUNCT; arole="Manner"; attrs=[(*"MEANING", Val "bardziej";*)"GRAD", Val "com"(*;"GF",Val "adjunct"*)]})) :: args (* FIXME: MEANING powinno być dodawane później *)
    | "sup" -> ("GRAD", Val "sup") :: attrs,
          let id = ExtArray.add tokens {empty_token with token=Lemma("najbardziej","adv",[])} in
          let _ = ExtArray.add lex_sems empty_lex_sem in
          (Cut(Node{LCGrenderer.empty_node with pred="najbardziej"; id=id; cat="adv"; agf=ADJUNCT; arole="Manner"; attrs=[(*"MEANING", Val "najbardziej";*)"GRAD", Val "sup"(*;"GF",Val "adjunct"*)]})) :: args (* FIXME: MEANING powinno być dodawane później *)
    | "aff" -> attrs, args
    | "negation" -> ("NEG",Val "+") :: attrs, args
    | "rec" -> ("ACM",Val "rec") :: attrs, args
    | "congr" -> ("ACM",Val "congr") :: attrs, args
    | "nosem" -> ("NOSEM",Val "+") :: attrs, args
    | "" -> attrs, args
    | s -> failwith ("make_node: " ^ s)) in
  let attrs = if fnum = 0 then attrs else ("FNUM",Val(string_of_int fnum)) :: attrs in
  {LCGrenderer.empty_node with pred=lemma; cat=cat; weight=weight; id=id; attrs=List.rev attrs;
     args=if args = [] then Dot else Tuple(List.rev args)} in

(* FIXME: "Można było" - brakuje uzgodnienia rodzaju przymiotnika w przypadku predykatywnym, i ogólnie kontroli składniowej *)
let make_np numbers cases genders persons (c:ENIAMtokenizerTypes.token_record) d lemma cat = (* FIXME: koreferencja siebie i się *)
  if d.simple_valence = [] then print_endline "empty simple_valence";
  let numbers = expand_numbers numbers in
  let cases = expand_cases cases in
  let genders = expand_genders genders in (* FIXME: trzeba dodać konstrukcję w marcu 2000 i leksykalizowane nazwy własne przy miesiącach *)
  (if StringSet.mem objids lemma then
    Xlist.fold numbers [] (fun l -> function
      "sg" ->
              let quant = ["number",d.e.number,["sg"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Aposition" Forward [Phrase(Lex "obj-id")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | "pl" -> l
    | _ -> failwith "make_np")
  else []) @
  (if lemma = "rok" then
    Xlist.fold numbers [] (fun l -> function
      "sg" ->
              let quant = ["number",d.e.number,["sg"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Aposition" Both [Phrase(Lex "year")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | "pl" ->
              let quant = ["number",d.e.number,["pl"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Aposition" Forward [Phrase(Lex "year-interval")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | _ -> failwith "make_np")
  else []) @
  (if lemma = "wiek" then (* FIXME: "Aranżuje w XIX w." się nie parsuje, niewłaściwa reprezentacja sem dla XIX *)
    Xlist.fold numbers [] (fun l -> function
      "sg" ->
              let quant = ["number",d.e.number,["sg"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Aposition" Both [Phrase(Lex "roman")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | "pl" ->
              let quant = ["number",d.e.number,["pl"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Aposition" Forward [Phrase(Lex "roman-interval")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | _ -> failwith "make_np")
  else []) @
  (if StringSet.mem months lemma then
    Xlist.fold numbers [] (fun l -> function
      "sg" ->
              let l = Xlist.fold cases l (fun l -> function
                  "gen" ->
                      let quant = ["number",d.e.number,["sg"];"case",d.e.case,["gen"];"gender",d.e.gender,genders; "person", d.e.person,persons] in
                      let t = ["month-lex"] in
                      let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
                      let schema_list = [[schema_field CORE "Possesive" Forward [Phrase Null; Phrase(Lex "year"); Phrase(NP(Case "gen"))]]] in
                      [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
                | _ -> l) in
              let quant = ["number",d.e.number,["sg"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Possesive" Forward [Phrase(Lex "year")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | "pl" -> l
    | _ -> failwith "make_np")
  else []) @
  (if lemma = "dzień" then
    Xlist.fold numbers [] (fun l -> function
      "sg" ->
              let l = Xlist.fold cases l (fun l -> function
                  "gen" ->
                      let quant = ["number",d.e.number,["sg"];"case",d.e.case,["gen"];"gender",d.e.gender,genders; "person", d.e.person,persons] in
                      let t = ["day-lex"] in
                      let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
                      let schema_list = [[schema_field CORE "Aposition" Forward [Phrase(Lex "date");Phrase(Lex "day");Phrase(Lex "day-month")]]] in
                      [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
                | _ -> l) in
              let quant = ["number",d.e.number,["sg"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Aposition" Forward [Phrase(Lex "date");Phrase(Lex "day");Phrase(Lex "day-month")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | "pl" ->
(*              let l = Xlist.fold cases l (fun l -> function
                  "gen" ->
                      let quant = ["number",d.e.number,["sg"];"case",d.e.case,["gen"];"gender",d.e.gender,genders; "person", d.e.person,persons] in
                      let t = ["day-lex"] in
                      let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
                      let schema_list = [[schema_field CORE "Aposition" Forward [Phrase(Lex "date-interval");Phrase(Lex "day-interval");Phrase(Lex "day-month-interval")]]] in
                      [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
                | _ -> l) in*)
              let quant = ["number",d.e.number,["pl"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Aposition" Forward [Phrase(Lex "date-interval");Phrase(Lex "day-interval");Phrase(Lex "day-month-interval")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | _ -> failwith "make_np")
  else []) @
  (if lemma = "godzina" then
    Xlist.fold numbers [] (fun l -> function
      "sg" ->
              let quant = ["number",d.e.number,["sg"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Aposition" Forward [Phrase(Lex "hour");Phrase(Lex "hour-minute")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | "pl" ->
              let quant = ["number",d.e.number,["pl"];"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) 0 ["number"; "case"; "gender"; "person"] in
              let schema_list = [[schema_field CORE "Aposition" Forward [Phrase(Lex "hour-interval");Phrase(Lex "hour-minute-interval")]]] in
              [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] @ l
    | _ -> failwith "make_np")
  else []) @
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,Frame(NounAtrs(_,nsyn,nsem),schema) ->
        (try
          let numbers = check_frame_number2 numbers nsem in
          Xlist.fold (split_voc cases) l (fun l cases ->
            if nsem = Common "measure" then
              let persons = if cases = ["voc"] then ["sec"] else persons in
              let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let quant3 = ["number",d.e.number,numbers;"case",d.e.case,all_cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["measure"; "number"; "case"; "gender"; "person"] in
              let t3 = ["measure"; "sg"; "case"; "n2"; "person"] in (* UWAGA: number "sg" i gender "n2", żeby uzgadniać z podmiotem czasownika *)
              let batrs = make_node lemma cat (c.weight +. measure_weight) fnum (nsyn :: (ENIAMwalStringOf.nsem nsem) :: ["number"; "case"; "gender"; "person"]) in
              let batrs3 = make_node lemma cat (c.weight +. measure_weight) fnum (nsyn :: (ENIAMwalStringOf.nsem nsem) :: ["number"; "gen"; "gender"; "person"]) in
              let schema_list = [qub_inclusion;schema;num_congr] in
              let schema_list3 = [qub_inclusion;schema;num_rec] in
              (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) ::
              (if Xlist.mem cases "gen" then [LCGrenderer.make_frame x_flag tokens lex_sems quant3 schema_list3 t3 d batrs3] else []) @ l
            else
              let persons = if cases = ["voc"] then ["sec"] else persons in
              let quant = ["lemma",ge (),[];"number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let quant3 = ["lemma",ge (),[];"number",d.e.number,numbers;"case",d.e.case,all_cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let quant5 = ["lemma",ge (),[];"unumber",ge (),all_numbers;"ucase",ge (),all_cases;"ugender",ge (),all_genders; "uperson",ge (),all_persons;
                            "number",d.e.number,numbers;"case",d.e.case,all_cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
              let t = ["np"; "number"; "case"; "gender"; "person"] in
              let t2 = ["prepnp"; "lemma"; "case"] in
              let t3 = ["np"; "sg"; "case"; "n2"; "person"] in (* UWAGA: number "sg" i gender "n2", żeby uzgadniać z podmiotem czasownika *)
              let t5 = ["np"; "unumber"; "ucase"; "ugender"; "uperson"] in
              let t6 = ["prepnp"; "lemma"; "ucase"] in
              let batrs = make_node lemma cat c.weight fnum (nsyn :: (ENIAMwalStringOf.nsem nsem) :: ["number"; "case"; "gender"; "person"]) in
              let batrs2 = make_node lemma cat c.weight fnum ("nosem" :: nsyn :: (ENIAMwalStringOf.nsem nsem) :: ["number"; "case"; "gender"; "person"]) in
              let batrs3 = make_node lemma cat c.weight fnum (nsyn :: (ENIAMwalStringOf.nsem nsem) :: ["number"; "gen"; "gender"; "person"]) in
              let batrs4 = make_node lemma cat c.weight fnum ("nosem" :: nsyn :: (ENIAMwalStringOf.nsem nsem) :: ["number"; "gen"; "gender"; "person"]) in
              let schema_list = [qub_inclusion;schema;num_congr] in
              let schema_list2 = [qub_inclusion;schema;num_congr;nosem_prep] in
              let schema_list3 = [qub_inclusion;schema;num_rec] in
              let schema_list4 = [qub_inclusion;schema;num_rec;nosem_prep] in
              let schema_list5 = [qub_inclusion;schema;noun_measure] in
              let schema_list6 = [qub_inclusion;schema;noun_measure;nosem_uprep] in
              (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) ::
              (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list2 t2 d batrs2) ::
              (if Xlist.mem cases "gen" then [LCGrenderer.make_frame x_flag tokens lex_sems quant3 schema_list3 t3 d batrs3] else []) @
              (if Xlist.mem cases "gen" then [LCGrenderer.make_frame x_flag tokens lex_sems quant3 schema_list4 t2 d batrs4] else []) @
              (if Xlist.mem cases "gen" then [LCGrenderer.make_frame x_flag tokens lex_sems quant5 schema_list5 t5 d batrs3] else []) @
              (if Xlist.mem cases "gen" then [LCGrenderer.make_frame x_flag tokens lex_sems quant5 schema_list6 t6 d batrs4] else []) @ l)
        with Not_found -> l)
    | fnum,Frame(AdjAtrs(_,case,_),schema) ->
        (try
          let cases = check_frame_case cases case in
          let quant = ["lemma",ge (),[];"number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
          let quant3 = ["lemma",ge (),[];"number",d.e.number,numbers;"case",d.e.case,all_cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
          let t = ["np"; "number"; "case"; "gender"; "person"] in
          let t2 = ["prepnp"; "lemma"; "case"] in
          let t3 = ["np"; "sg"; "case"; "n2"; "person"] in (* UWAGA: number "sg" i gender "n2", żeby uzgadniać z podmiotem czasownika *)
          let batrs = make_node lemma cat c.weight fnum ["number"; "case"; "gender"; "person"] in
          let batrs2 = make_node lemma cat c.weight fnum ["nosem"; "number"; "case"; "gender"; "person"] in
          let batrs3 = make_node lemma cat c.weight fnum ["number"; "gen"; "gender"; "person"] in
          let batrs4 = make_node lemma cat c.weight fnum ["nosem"; "number"; "gen"; "gender"; "person"] in
          let schema_list = [qub_inclusion;schema;num_congr] in
          let schema_list2 = [qub_inclusion;schema;num_congr;nosem_prep] in
          let schema_list3 = [qub_inclusion;schema;num_rec] in
          let schema_list4 = [qub_inclusion;schema;num_rec;nosem_prep] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) ::
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list2 t2 d batrs2) ::
          (if Xlist.mem cases "gen" then [LCGrenderer.make_frame x_flag tokens lex_sems quant3 schema_list3 t3 d batrs3] else []) @
          (if Xlist.mem cases "gen" then [LCGrenderer.make_frame x_flag tokens lex_sems quant3 schema_list4 t2 d batrs4] else []) @  l
        with Not_found -> l)
    | fnum,LexFrame(lid,SUBST(number,case),NoRestr,schema) ->
        (try
          let cases = check_frame_case cases case in
          let numbers = check_frame_number numbers number in
          let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
          let t =  ["lex";lid;lemma;"subst"; "number"; "case"; "gender"; "person"] in
          let batrs = make_node lemma cat (lex_weight +. c.weight) fnum ["lex";"number"; "case"; "gender"; "person"] in
          let schema_list = [[inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,LexFrame(_,ADJ _,_,_) -> l
    | fnum,frame -> failwith ("make_np: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_np_symbol (c:ENIAMtokenizerTypes.token_record) d lemma cat =
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,Frame(NounAtrs(_,nsyn,nsem),schema) ->
              let t = [cat] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) fnum (nsyn :: (ENIAMwalStringOf.nsem nsem) :: []) in
              let schema_list = [schema] in
              (LCGrenderer.make_frame x_flag tokens lex_sems [] schema_list t d batrs) :: l
    | fnum,frame -> failwith ("make_np_symbol: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_day (c:ENIAMtokenizerTypes.token_record) d lemma cat =
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,Frame(NounAtrs(_,nsyn,nsem),[]) ->
              let t = [cat] in
              let batrs = make_node lemma cat (symbol_weight +. c.weight) fnum (nsyn :: (ENIAMwalStringOf.nsem nsem) :: []) in
              let schema_list = [[schema_field CORE "Possesive" Forward [Phrase(Lex "month-lex")]]] in
              (LCGrenderer.make_frame x_flag tokens lex_sems [] schema_list t d batrs) :: l
    | fnum,frame -> failwith ("make_day: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_nump numbers cases genders persons acm (c:ENIAMtokenizerTypes.token_record) d lemma cat = (* FIXME: liczba po rzeczowniku *) (* FIXME: zbadać jak liczebniki współdziałąją z jako COMPAR *)
  let numbers = expand_numbers numbers in
  let cases = expand_cases cases in
  let genders = expand_genders genders in
  let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders;"person",d.e.person,persons] in
  Xlist.map acm (function
      "rec" ->
         let t = ["num"; "number"; "case"; "gender"; "person"; "rec"] in
         let batrs = make_node lemma cat c.weight 0 ["rec"; "number"; "case"; "gender"; "person"] in
         let schema_list = [qub_inclusion] in (* FIXME: jak usunięcie Phrase ProNG wpływa na pokrycie? *)
         LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs
    | "congr" ->
         let t = ["num"; "number"; "case"; "gender"; "person"; "congr"] in
         let batrs = make_node lemma cat c.weight 0 ["congr"; "number"; "case"; "gender"; "person"] in
         let schema_list = [qub_inclusion] in (* FIXME: jak usunięcie Phrase ProNG wpływa na pokrycie? *)
         LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs
    | _ -> failwith "make_nump: num acm") @
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,LexFrame(lid,NUM(case,gender,acm2),NoRestr,schema) ->
        (try
          let cases = check_frame_case cases case in
          let genders = check_frame_gender genders gender in
          let acm = check_frame_acm acm acm2 in
          let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons] in
          match acm with
            "rec" ->
               let t = ["lex";lid;lemma;"num"; "number"; "case"; "gender"; "person"] in (* UWAGA: Number "sg" i Gender "n2", żeby uzgadniać z podmiotem czasownika *)
               let batrs = make_node lemma cat (lex_weight +. c.weight) fnum ["rec";"lex"; "number"; "case"; "gender"; "person"] in
               let schema_list = [[inclusion];schema] in
               (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
          | "congr" ->
               let t = ["lex";lid;lemma;"num"; "number"; "case"; "gender"; "person"] in
               let batrs = make_node lemma cat (lex_weight +. c.weight) fnum ["congr";"lex"; "number"; "case"; "gender"; "person"] in
               let schema_list = [[inclusion];schema] in
               (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
          | _ -> failwith "make_nump: num acm"
        with Not_found -> l)
    | fnum,frame -> failwith ("make_num: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_compar (c:ENIAMtokenizerTypes.token_record) d lemma =
  let quant = ["case",d.e.case,["nom";"gen";"dat";"acc";"inst"]] in
  let t = ["comparnp"; lemma; "case"] in
  let t2 = ["comparpp"; lemma] in
  let batrs = make_node lemma "prep" c.weight 0 ["case"] in
  let batrs2 = make_node lemma "prep" c.weight 0 [] in
  let schema_list = [qub_inclusion;[adjunct_schema_field "Manner" Backward [Phrase Null;Phrase AdvP];prep_arg_schema_field [Phrase (NP(CaseAgr))]]] in
  let schema_list2 = [qub_inclusion;[adjunct_schema_field "Manner" Backward [Phrase Null;Phrase AdvP];prep_arg_schema_field [Phrase (PrepNP(Sem,"",CaseUndef));Phrase (PrepNumP(Sem,"",CaseUndef));Phrase (PrepAdjP(Sem,"",CaseUndef));Phrase (ComprepNP(Sem,""))]]] in
  [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs;
   LCGrenderer.make_frame x_flag tokens lex_sems [] schema_list2 t2 d batrs2] in

let make_arg_prepp cases (c:ENIAMtokenizerTypes.token_record) d lemma pcat phrase =
  let quant = ["case",d.e.case,expand_cases cases] in
  let t = [pcat; lemma; "case"] in
  let batrs = make_node lemma "prep" c.weight 0 ["case"] in
  let schema_list = [qub_inclusion;[adjunct_schema_field "Manner" Backward [Phrase Null;Phrase AdvP];prep_arg_schema_field [Phrase phrase]]] in
  LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs in

let make_prepnp cases (c:ENIAMtokenizerTypes.token_record) d lemma = make_arg_prepp cases c d lemma "prepnp" (NP(CaseAgr)) in
let make_prepnump cases (c:ENIAMtokenizerTypes.token_record) d lemma = make_arg_prepp cases c d lemma "prepnp" (NumP(CaseAgr)) in
let make_prepadjp cases (c:ENIAMtokenizerTypes.token_record) d lemma =
  let cases = if lemma = "po" then "postp" :: cases else cases in
  make_arg_prepp cases c d lemma "prepadjp" (AdjP(CaseAgr)) in

(*let make_prepp cases c d lemma =
  let quant = ["case",d.e.case,expand_cases cases] in
  let t = ["prepp"; "case"] in
  let batrs = make_node lemma "prep" c.weight 0 ["case"] in
  let schema_list = [qub_inclusion;[adjunct_schema_field "Manner" Backward [Phrase Null;Phrase AdvP];prep_arg_schema_field2 [Phrase (NP(CaseAgr));Phrase (NumP(CaseAgr));Phrase (AdjP(CaseAgr))]]] in
  LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs in*)

let make_prep cases (c:ENIAMtokenizerTypes.token_record) d lemma =
  let quant = ["case",d.e.case,expand_cases cases] in
  let t = ["prep"; lemma; "case"] in
  let batrs = make_node lemma "prep" c.weight 0 ["case"] in
  let schema_list = [qub_inclusion] in
  LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs in

let make_time_prep2 case (c:ENIAMtokenizerTypes.token_record) d lemma l =
  let quant = ["case",d.e.case,[case]] in
  let t = ["prepnp"; lemma; "case"] in
  let batrs = make_node lemma "prep" c.weight 0 ["case"] in
  let schema_list = [qub_inclusion;[prep_arg_schema_field (Xlist.map l (fun s -> Phrase(Lex s)))]] in
  LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs in

let make_time_prep cases (c:ENIAMtokenizerTypes.token_record) d lemma =
  Xlist.fold cases [] (fun l case ->
    match lemma,case with
      "z","gen" -> [make_time_prep2 case c d lemma ["day-month";"day";"year";"date";"hour";"hour-minute"]] @ l
   |  "do","gen" -> [make_time_prep2 case c d lemma ["day-month";"day";"year";"date";"hour";"hour-minute"]] @ l
   |  "na","acc" -> [make_time_prep2 case c d lemma ["day-month";"day";"hour";"hour-minute"]] @ l
   |  "o","loc" -> [make_time_prep2 case c d lemma ["hour";"hour-minute"]] @ l
   |  "od","gen" -> [make_time_prep2 case c d lemma ["day-month";"day";"year";"date";"hour";"hour-minute"]] @ l
   |  "około","gen" -> [make_time_prep2 case c d lemma ["day-month";"day";"year";"hour";"hour-minute"]] @ l
   |  "po","loc" -> [make_time_prep2 case c d lemma ["day-month";"day";"year";"date";"hour";"hour-minute"]] @ l
   |  "przed","inst" -> [make_time_prep2 case c d lemma ["day-month";"day";"year";"date";"hour";"hour-minute"]] @ l
   |  "w","loc" -> [make_time_prep2 case c d lemma ["year"]] @ l
   | _ -> l) in

let make_lex_prep cases (c:ENIAMtokenizerTypes.token_record) d lemma =
  let cases = expand_cases cases in
  Xlist.fold d.simple_valence [] (fun l -> function
    | fnum,LexFrame(lid,PREP case,NoRestr,schema) ->
        (try
          let cases = check_frame_case cases case in
          let quant = ["case",d.e.case,cases] in
          let t =  ["lex";lid;lemma;"prep"; "case"] in
          let batrs = make_node lemma "prep" (lex_weight +. c.weight) fnum ["lex";"case"] in
          let schema_list = [[inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,ComprepFrame(new_lemma,PREP case,NoRestr,schema) ->
        (try
          let cases = check_frame_case cases case in
          let quant = ["case",d.e.case,cases] in
          let t = ["comprepnp"; new_lemma] in
          let batrs = make_node new_lemma "prep" (lex_weight +. c.weight) fnum [] in
          let schema_list = [[inclusion];schema] in
          let l = (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l in
          let t = ["prepp"; "case"] in
          let batrs = make_node new_lemma "prep" (lex_weight +. c.weight) fnum ["case"] in
          let schema_list = [[inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,frame -> failwith ("make_lex_prep: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_adjp numbers cases genders grads (c:ENIAMtokenizerTypes.token_record) d lemma cat = (* FIXME: usunąć niektóre opcje dla roman i ordnum *)
  let numbers = expand_numbers numbers in
  let cases = expand_cases cases in
  let cases = if Xlist.mem cases "nom" then "pred" :: cases else cases in
  let genders = expand_genders genders in
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,Frame(AdjAtrs(_,case,adjsyn),schema) ->
        (try
          let cases = check_frame_case cases case in
          let grad = match grads with [grad] -> grad | _ -> failwith "make_adjp: grad" in
          let quant = ["lemma",ge (),[];"number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders] in
          let t = ["adjp"; "number"; "case"; "gender"] in
          let t2 = ["prepadjp"; "lemma"; "case"] in
          let batrs = make_node lemma cat c.weight fnum (adjsyn :: grad :: ["number"; "case"; "gender"]) in
          let batrs2 = make_node lemma cat c.weight fnum ("nosem" :: adjsyn :: grad :: ["number"; "case"; "gender"]) in
          let schema_list = [if adjsyn = "pronoun" then [] else [adjunct_schema_field "Aposition" Backward [Phrase Null;Phrase Adja]];qub_inclusion;schema] in
          let schema_list2 = [if adjsyn = "pronoun" then [] else [adjunct_schema_field "Aposition" Backward [Phrase Null;Phrase Adja]];qub_inclusion;schema;nosem_prep] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) ::
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list2 t2 d batrs2) :: l
        with Not_found -> l)
    | fnum,Frame(NounAtrs(_,nsyn,nsem),schema) ->
        (try
          let grad = match grads with [grad] -> grad | _ -> failwith "make_adjp: grad" in
          let quant = ["lemma",ge (),[];"number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders] in
          let t = ["adjp"; "number"; "case"; "gender"] in
          let batrs = make_node lemma cat c.weight fnum (nsyn :: (ENIAMwalStringOf.nsem nsem) :: grad :: ["number"; "case"; "gender"]) in
          let schema_list = [if nsyn = "pronoun" then [] else [adjunct_schema_field "Aposition" Backward [Phrase Null;Phrase Adja]];qub_inclusion;schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,LexFrame(lid,ADJ(number,case,gender,grad),NoRestr,schema) ->
        (try
          let cases = check_frame_case cases case in
          let numbers = check_frame_number numbers number in
          let genders = check_frame_gender genders gender in
          let grads = check_frame_grad grads grad in
          let grad = match grads with [grad] -> grad | _ -> failwith "make_adjp: grad" in
          let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders] in
          let t =  ["lex";lid;lemma;"adj"; "number"; "case"; "gender"] in
          let batrs = make_node lemma cat (lex_weight +. c.weight) fnum [grad;"lex"; "number"; "case"; "gender"] in
          let schema_list = [[inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,frame -> failwith ("make_adjp: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let adv_relators = Xlist.fold [ (* przy zmianie kluczy, trzeba też zmienić analogicznie zawartość *)
  "jak","Attr",[Int;Rel];       (* listy adv_relators w procedurze move_comp w pliku ../diagnostics/treeChange.ml *)
  "skąd","abl",[Int;Rel];
  "dokąd","adl",[Int;Rel];
  "gdzie","locat",[Int;Rel];
  "którędy","perl",[Int;Rel];
  "kiedy","temp",[Int;Rel];
  "odkąd","temp",[Int];
  "dlaczego","caus",[Int];
  "czemu","caus",[Int];
  "gdy","con",[Sub];
  ] StringMap.empty (fun map (k,v,l) -> StringMap.add map k (v,l)) in

let make_advp grads (c:ENIAMtokenizerTypes.token_record) d lemma =
  (if StringMap.mem adv_relators lemma then
        let role,ctypes = StringMap.find adv_relators lemma in
        List.flatten (Xlist.map ctypes (fun ctype ->
          let ctype = ENIAMwalStringOf.comp_type ctype in
          let quant = ["inumber",ge (),[];"igender",ge (),[];"iperson",ge (),[];"ctype",ge (),[ctype]] in
          let t = ["cp"; "ctype"; lemma] in
          let sem_mods = ["CTYPE",SubstVar "ctype"] in
          let batrs = make_node lemma "adv" c.weight 0 [ctype] in
          let raised_arg1 = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["advp"])] in
	let schema_list = [if lemma = "jak" then [num_arg_schema_field [Phrase Null;(*Phrase ProNG;*) Phrase AdvP]] else [];[schema_field RAISED "" Forward raised_arg1]] in (* FIXME: dwa znaczenia jak: pytanie o cechę lub spójnik *)
          let frame_advp = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          [frame_advp])) else []) @
  Xlist.fold d.simple_valence [] (fun l -> function (* FIXME: sprawdzic czy adv_relators maja leksykalizacje i schematy *)
      fnum,Frame(EmptyAtrs _,schema) ->
        (try
          let grad = match grads with [grad] -> grad | _ -> failwith "make_advp: grad" in
          let quant = [] in
          let t = ["advp"] in
          let batrs = make_node lemma "adv" c.weight fnum [grad] in
          let schema_list = [[adjunct_schema_field "Aposition" Backward [Phrase Null;Phrase Adja]];qub_inclusion;schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,LexFrame(lid,ADV grad,NoRestr,schema) ->
        (try
          let grads = check_frame_grad grads grad in
          let grad = match grads with [grad] -> grad | _ -> failwith "make_adjp: grad" in
          let quant = [] in
          let t =  ["lex";lid;lemma;"adv"] in
          let batrs = make_node lemma "adv" (lex_weight +. c.weight) fnum [grad;"lex"] in
          let schema_list = [[inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,ComprepFrame(new_lemma,ADV grad,NoRestr,schema) ->
        (try
          let _ = check_frame_grad grads grad in
          let quant = [] in
          let t = ["comprepnp"; new_lemma] in
          let batrs = make_node new_lemma "adv" (lex_weight +. c.weight) fnum [] in
          let schema_list = [[inclusion];schema] in
          let l = (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l in (* FIXME: nieprzetestowane *)
          let t = ["prepp"; "gen"] in (* FIXME: przypadek nie jest znany *)
          let batrs = make_node new_lemma "adv" (lex_weight +. c.weight) fnum [] in
          let schema_list = [[inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,frame -> failwith ("make_advp: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_ger numbers cases genders persons aspects negations (c:ENIAMtokenizerTypes.token_record) d lemma cat =
  let numbers = expand_numbers numbers in
  let cases = expand_cases cases in
  let genders = expand_genders genders in
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,Frame(GerAtrs(_,new_lemma,negation,aspect),schema) ->
        (try
          let aspects = check_frame_aspect aspects aspect in
          let negation = check_frame_negation negations negation in
          let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons; "aspect",d.e.aspect,aspects] in
          let t = ["np"; "number"; "case"; "gender"; "person"] in
          let batrs = make_node new_lemma cat c.weight fnum [negation;"aspect";"number"; "case"; "gender"; "person"] in
          let schema_list = [qub_inclusion;schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,LexFrame(lid,GER(number,case,gender,aspect,negation,ReflEmpty),NoRestr,schema) ->
        (try
          let cases = check_frame_case cases case in
          let genders = check_frame_gender genders gender in
          let numbers = check_frame_number numbers number in
          let aspects = check_frame_aspect aspects aspect in
          let negation = check_frame_negation negations negation in
          let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "person", d.e.person,persons; "aspect",d.e.aspect,aspects] in
          let t =  ["lex";lid;lemma;"ger"; "number"; "case"; "gender"; "person"] in
          let batrs = make_node lemma cat (lex_weight +. c.weight) fnum [negation;"aspect";"lex"; "number"; "case"; "gender"; "person"] in
          let schema_list = [[inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,frame -> failwith ("make_ger: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_padj numbers cases genders aspects negations (c:ENIAMtokenizerTypes.token_record) d lemma cat =
  let numbers = expand_numbers numbers in
  let cases = expand_cases cases in
  let cases = if Xlist.mem cases "nom" || cat = "ppas" then "pred" :: cases else cases in
  let genders = expand_genders genders in
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,Frame(NonPersAtrs(_,new_lemma,role,role_attr,negation,aspect),schema) ->
        (try
          let aspects = check_frame_aspect aspects aspect in
          let negation = check_frame_negation negations negation in
          let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "aspect",d.e.aspect,aspects] in
          let t = ["adjp"; "number"; "case"; "gender"] in
          let batrs = make_node new_lemma cat c.weight fnum [negation;"aspect";"number"; "case"; "gender"] in
          let schema_list = [qub_inclusion;schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,LexFrame(lid,PACT(number,case,gender,aspect,negation,ReflEmpty),NoRestr,schema) ->
        (try
          let aspects = check_frame_aspect aspects aspect in
          let negation = check_frame_negation negations negation in
          let cases = check_frame_case cases case in
          let numbers = check_frame_number numbers number in
          let genders = check_frame_gender genders gender in
          let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "aspect",d.e.aspect,aspects] in
          let t =  ["lex";lid;lemma;"pact"; "number"; "case"; "gender"] in
          let batrs = make_node lemma cat (lex_weight +. c.weight) fnum [negation;"lex";"aspect"; "number"; "case"; "gender"] in
          let schema_list = [[inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,LexFrame(lid,PPAS(number,case,gender,aspect,negation),NoRestr,schema) ->
        (try
          let aspects = check_frame_aspect aspects aspect in
          let negation = check_frame_negation negations negation in
          let cases = check_frame_case cases case in
          let numbers = check_frame_number numbers number in
          let genders = check_frame_gender genders gender in
          let quant = ["number",d.e.number,numbers;"case",d.e.case,cases;"gender",d.e.gender,genders; "aspect",d.e.aspect,aspects] in
          let t =  ["lex";lid;lemma;"ppas"; "number"; "case"; "gender"] in
          let batrs = make_node lemma cat (lex_weight +. c.weight) fnum [negation;"lex";"aspect"; "number"; "case"; "gender"] in
          let schema_list = [[inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,frame -> failwith ("make_padj: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_ip numbers genders persons aspects aglt aux2 (c:ENIAMtokenizerTypes.token_record) d lemma cat =
  let numbers = expand_numbers numbers in
  let genders = expand_genders genders in
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,Frame(PersAtrs(_,new_lemma,negation,mood,tense,aux,aspect),schema) ->
        (try
          if aux2 = true && aux = NoAux then raise Not_found else
          if aux2 = false && aux <> NoAux then raise Not_found else
          let aspects = check_frame_aspect aspects aspect in
          let quant = ["number",d.e.number,numbers;"gender",d.e.gender,genders; "person", d.e.person,persons; "aspect",d.e.aspect,aspects] in
          let t = ["ip"; "number"; "gender"; "person"] in
          let batrs = make_node new_lemma cat c.weight fnum ([mood;tense;"aspect"; "number"; "gender"; "person"] @ if negation = Aff then [] else ["negation"]) in
          let cond_arg = match mood with "conditional" -> [nosem_schema_field Both [Phrase(Lex "by")]] | "" -> failwith "make_ip" | _ -> [] in
          let aglt_arg = if aglt then [nosem_schema_field Both [Phrase Aglt]] else [] in
          let aux_arg = match aux with PastAux -> [nosem_schema_field Both [Phrase AuxPast]] | FutAux -> [nosem_schema_field Both [Phrase AuxFut]] | ImpAux -> [nosem_schema_field Both [Phrase AuxImp]] | NoAux -> [] in
          let schema_list = [if negation = Aff then [] else [nosem_schema_field Backward [Phrase(Lex "nie")]];
                             qub_inclusion;
                             aglt_arg @ aux_arg @ cond_arg @ schema @ int_arg] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,frame -> failwith ("make_ip 1: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in


let make_infp aspects (c:ENIAMtokenizerTypes.token_record) d lemma =
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,Frame(NonPersAtrs(_,new_lemma,role,role_attr,negation,aspect),schema) ->
        (try
          let aspects = check_frame_aspect aspects aspect in
          let quant = ["aspect",d.e.aspect,aspects] in
          let t = ["infp"; "aspect"] in
          let batrs = make_node new_lemma "inf" c.weight fnum (["aspect"] @ if negation = Aff then [] else ["negation"]) in
          let schema_list = [if negation = Aff then [] else [nosem_schema_field Backward [Phrase(Lex "nie")]];
                             qub_inclusion;schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,LexFrame(lid,INF(aspect,negation,refl),NoRestr,schema) ->
        (try
          let aspects = check_frame_aspect aspects aspect in
          let quant = ["aspect",d.e.aspect,aspects] in
          let t =  ["lex";lid;lemma;"inf"; "aspect"] in
          let new_lemma,schema = if refl = ReflEmpty then lemma, schema else lemma ^ " się", nosem_refl_schema_field :: schema in
          let batrs = make_node new_lemma "inf" (lex_weight +. c.weight) fnum (["lex";"aspect"] @ if negation = Aff then [] else ["negation"]) in
          let schema_list = [if negation = Aff then [] else [nosem_schema_field Backward [Phrase(Lex "nie")]];
                             [inclusion];schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,frame -> failwith ("make_infp: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_padvp aspects (c:ENIAMtokenizerTypes.token_record) d lemma cat =
  Xlist.fold d.simple_valence [] (fun l -> function
      fnum,Frame(NonPersAtrs(_,new_lemma,role,role_attr,negation,aspect),schema) ->
        (try
          let aspects = check_frame_aspect aspects aspect in
          let quant = ["aspect",d.e.aspect,aspects] in
          let t = ["padvp"] in
          let batrs = make_node new_lemma cat c.weight fnum (["aspect"] @ if negation = Aff then [] else ["negation"]) in
          let schema_list = [if negation = Aff then [] else [nosem_schema_field Backward [Phrase(Lex "nie")]];
                             qub_inclusion;schema] in
          (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
        with Not_found -> l)
    | fnum,frame -> failwith ("make_padvp: " ^ lemma ^ ": " ^ ENIAMwalStringOf.frame lemma frame)) in

let make_conjunct (c:ENIAMtokenizerTypes.token_record) d lemma cat =   (* FIXME: poprawić semantykę *)
          let ctype = if cat = "comp" then "sub" else if cat = "conj" then "coord" else failwith "make_conjunct" in
          let quant = [] in
          let t = ["cp"; ctype; lemma] in
          let batrs = make_node lemma cat c.weight 0 [ctype] in
          let schema_list = [[comp_arg_schema_field [Phrase IP]]] in
          [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs] in

(* FIXME: uzgadniania HIPERO i SELPREFS *)
let make_conj f (c:ENIAMtokenizerTypes.token_record) d lemma =
  (if f then
   [LCGrenderer.make_conj_frame
     ["number",d.e.number,all_numbers;"gender",d.e.gender,all_genders;"person",d.e.person,all_persons]
     (Tensor[Atom "ip"; Top; Top; Top]) (Tensor[Atom "ip"; Top; Top; Top])
     ["ip";"number";"gender";"person"] d
     (make_node lemma "conj" c.weight 0 ["number";"gender";"person"])] else []) @
  [LCGrenderer.make_conj_frame []
     (Tensor[Atom "prepnp"; Top; Top]) (Tensor[Atom "prepnp"; Top; Top]) ["advp"] d
     (make_node lemma "conj" c.weight 0 []);
   LCGrenderer.make_conj_frame []
     (Tensor[Atom "advp"]) (Tensor[Atom "prepnp"; Top; Top]) ["advp"] d
     (make_node lemma "conj" c.weight 0 []);
   LCGrenderer.make_conj_frame []
     (Tensor[Atom "prepnp"; Top; Top]) (Tensor[Atom "advp"]) ["advp"] d
     (make_node lemma "conj" c.weight 0 []);
   LCGrenderer.make_conj_frame []
     (Tensor[Atom "advp"]) (Tensor[Atom "advp"]) ["advp"] d
     (make_node lemma "conj" c.weight 0 []);
   LCGrenderer.make_conj_frame ["lemma",ge (),[];"case",d.e.case,all_cases]
     (Tensor[Atom "prepnp";AVar "lemma"; AVar "case"]) (Tensor[Atom "prepnp"; AVar "lemma"; AVar "case"])
     ["prepnp";"lemma";"case"] d
     (make_node lemma "conj" c.weight 0 ["case"]);
   LCGrenderer.make_conj_frame
     ["number",d.e.number,all_numbers;"case",d.e.case,all_cases;"gender",d.e.gender,all_genders;"person",d.e.person,all_persons]
     (Tensor[Atom "np"; Top; AVar "case"; Top; Top]) (Tensor[Atom "np"; Top; AVar "case"; Top; Top])
     ["np"; "number"; "case"; "gender"; "person"] d
     (make_node lemma "conj" c.weight 0 ["number";"case";"gender";"person"]);
   LCGrenderer.make_conj_frame
     ["number",d.e.number,all_numbers;"case",d.e.case,all_cases;"gender",d.e.gender,all_genders]
     (Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]) (Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"])
     ["adjp";"number";"case";"gender"] d
     (make_node lemma "conj" c.weight 0 ["number";"case";"gender"]);
   ] in

(* FIXME: aktualnie NP nie obejmują przymiotników, trzeba albo dodać podrzędniki przymiotnikowe, albo kategorię np dla przymiotników *)
(* FIXME: nadmiarowe interpretacje dla num np. dodana jest opcja z pro i apozycją *)
(* FIXME: zrobić kontolę w znaczeniu dziedziczenia podmiotu *)
(* FIXME: poprawić walencję z negacją, problem z zanegowanymi ramami dla ger i ppas *)
(* FIXME: sprawdzić czy są ramy z NegationUndef i NegationNA *)
(* FIXME: obniżyć wagi przyimków i kublików pisanych z wielkiej litery podobnie przy skrótach *)

let rec process_interp (c:ENIAMtokenizerTypes.token_record) (d:ENIAMlexSemanticsTypes.lex_sem) = function (* FIXME: rozpoznawanie lematów nie działa, gdy mają wielką literę *)
    lemma,"subst",[numbers;cases;genders] ->
      (if lemma = "co" || lemma  = "kto" then (* FIXME: dodać podrzędniki np. co nowego *)
        List.flatten (Xlist.map ["int";"rel"] (fun ctype ->
          let quant = ["inumber",ge (),[];"igender",ge (),[];"iperson",ge (),[];"plemma",ge (),[];"ctype",ge (),[ctype];"number",d.e.number,expand_numbers numbers;"case",d.e.case,expand_cases cases;"gender",d.e.gender,expand_genders genders; "person",d.e.person,["ter"]] in
          let t = ["cp"; "ctype"; lemma] in
          let sem_mods = ["CTYPE",SubstVar "ctype"] in (* atrybuty ip *)
          let batrs = make_node lemma "subst" c.weight 0 [ctype;"case"] in (* atrybuty liścia *)
          let raised_arg = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["np";"number";"case";"gender";"person"])] in
          let raised_arg1 = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["prepnp";"plemma";"case"])] in
          let raised_arg2 = [Raised(["prepnp";"plemma";"case"],Forward,["np";"number";"case";"gender";"person"])] in
          let raised_arg3 = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["comprepnp";"plemma"])] in
          let raised_arg4 = [Raised(["comprepnp";"plemma"],Forward,["np";"number";"case";"gender";"person"])] in
          let schema_list = [[schema_field RAISED "" Forward raised_arg]] in
          let frame_np = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          let schema_list = [[schema_field RAISED "" Backward raised_arg2];[schema_field RAISED "" Forward raised_arg1]] in
          let frame_prepnp = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          let schema_list = [[schema_field RAISED "" Backward raised_arg4];[schema_field RAISED "" Forward raised_arg3]] in
          let frame_comprepnp = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          [frame_np;frame_prepnp;frame_comprepnp])) else []) @
      (if lemma = "to" then (* FIXME: przetestować *)
          let quant = ["ctype",ge (),[];"lemma",ge (),[];"number",d.e.number,expand_numbers numbers;"case",d.e.case,expand_cases cases;"gender",d.e.gender,expand_genders genders; "person",d.e.person,["ter"]] in
          let t = ["ncp"; "number"; "case"; "gender"; "person"; "ctype"; "lemma"] in
          let batrs = make_node "to" "subst" c.weight 0 ["coreferential"; "number"; "case"; "gender"; "person"; "ctype"] in
          let schema_list = [qub_inclusion;[prep_arg_schema_field [Phrase(CP(CompTypeAgr,Comp "lemma"))]]] in
          [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs]
      else []) @
      make_np numbers cases genders ["ter"] c d lemma "subst"
  | lemma,"depr",[numbers;cases;genders] -> (* FIXME: sprawdzić uzgodnienie rodzaju dla depr w podmiocie *)
      make_np numbers cases genders ["ter"] c d lemma "depr"
  | lemma,"ppron12",[numbers;cases;genders;persons] ->
      make_np numbers cases genders persons c d lemma "ppron12"
  | lemma,"ppron12",[numbers;cases;genders;persons;akcs] ->
      make_np numbers cases genders persons c d lemma "ppron12"
  | lemma,"ppron3",[numbers;cases;genders;persons] ->
      make_np numbers cases genders persons c d lemma "ppron3"
  | lemma,"ppron3",[numbers;cases;genders;persons;akcs] ->
      make_np numbers cases genders persons c d lemma "ppron3"
  | lemma,"ppron3",[numbers;cases;genders;persons;akcs;praep] ->
      List.flatten (Xlist.map praep (function
        "npraep" -> make_np numbers cases genders persons c d lemma "ppron3"
     | "_" -> make_np numbers cases genders persons c d lemma "ppron3"
     | "praep" ->
          let quant = ["lemma",ge (),[]; "number",d.e.number,expand_numbers numbers;"case",d.e.case,expand_cases cases;"gender",d.e.gender,expand_genders genders; "person",d.e.person,persons] in
          let t = ["prepnp"; "lemma"; "case"] in
          Xlist.fold d.simple_valence [] (fun l -> function
              fnum,Frame(NounAtrs(_,nsyn,nsem),schema) ->
                let batrs = make_node lemma "ppron3" c.weight fnum (nsyn ::(ENIAMwalStringOf.nsem nsem) :: ["number";"case";"gender";"person"]) in
                let raised_arg = [Raised(["prepnp";"lemma";"case"],Forward,["np";"number";"case";"gender";"person"])] in
                let schema_list = [[schema_field RAISED "" Backward raised_arg];[inclusion]] in
                (LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs) :: l
            | _ -> failwith "process_interp: ppron3 praep")
     | _ -> failwith "process_interp: ppron3 praep"))
  | lemma,"siebie",[cases] -> (* FIXME: rozwiązać koreferencję *)
      make_np ["_"] cases ["_"] ["ter"] c d lemma "siebie"
  | lemma,"prep",[cases;woks] ->  (* FIXME: pomijam niesemantyczny compar *)
      if lemma = "jak" || lemma = "jako" || lemma = "niż" || lemma = "niczym" || lemma = "niby" || lemma = "co" then [make_prep all_cases c d lemma] @ make_compar c d lemma else
      [make_prepnp cases c d lemma;
       make_prepnump cases c d lemma;
       make_prepadjp cases c d lemma;
       make_prep cases c d lemma] @
      make_lex_prep cases c d lemma @
      make_time_prep cases c d lemma
  | lemma,"prep",[cases] ->
      if lemma = "jak" || lemma = "jako" || lemma = "niż" || lemma = "niczym" || lemma = "niby" || lemma = "co" then [make_prep all_cases c d lemma] @ make_compar c d lemma else
      [make_prepnp cases c d lemma;
       make_prepnump cases c d lemma;
       make_prepadjp cases c d lemma;
       make_prep cases c d lemma] @
      make_lex_prep cases c d lemma @
      make_time_prep cases c d lemma
(*  | lemma,"NUM",[["comp"]] -> failwith "num:comp"*)
  | lemma,"num",[numbers;cases;genders;acm] -> (* FIXME: liczebniki złożone *)
      (if lemma = "ile" then (* FIXME: walencja ile *)
        List.flatten (Xlist.map ["int";"rel"] (fun ctype ->
        List.flatten (Xlist.map acm (fun acm ->
          let phrase,num,gend = match acm with "congr" -> NP AllAgr,"number","gender" | "rec" -> NP GenAgr,"sg","n2" | _ -> failwith "process_interp: num acm" in
          let quant = ["inumber",ge (),[];"igender",ge (),[];"iperson",ge (),[];"plemma",ge (),[];"ctype",ge (),[ctype];"number",d.e.number,expand_numbers numbers;"case",d.e.case,expand_cases cases;"gender",d.e.gender,expand_genders genders;"person",d.e.person,["ter"]] in
          let t = ["cp"; "ctype"; lemma] in
          let sem_mods = ["CTYPE",SubstVar "ctype"] in
          let batrs = make_node lemma "num" c.weight 0 [ctype;acm;"number";"case";"gender";"person"] in
          let raised_arg1 = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["nump";num;"case";gend;"person"])] in
          let raised_arg2a = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["prepnp";"plemma";"case"])] in
          let raised_arg2b = [Raised(["prepnp";"plemma";"case"],Forward,["nump";num;"case";gend;"person"])] in
          let raised_arg3a = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["comprepnp";"plemma"])] in
          let raised_arg3b = [Raised(["comprepnp";"plemma"],Forward,["nump";num;"case";gend;"person"])] in
          let schema_list = [[num_arg_schema_field [Phrase ProNG; Phrase phrase]];[schema_field RAISED "" Forward raised_arg1]] in
          let frame_nump = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          let schema_list = [[num_arg_schema_field [Phrase ProNG; Phrase phrase]];[schema_field RAISED "" Backward raised_arg2b];[schema_field RAISED "" Forward raised_arg2a]] in
          let frame_prepnp = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          let schema_list = [[num_arg_schema_field [Phrase ProNG; Phrase phrase]];[schema_field RAISED "" Backward raised_arg3b];[schema_field RAISED "" Forward raised_arg3a]] in
          let frame_comprepnp = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          [frame_nump;frame_prepnp;frame_comprepnp])))) else []) @
      make_nump numbers cases genders ["ter"] acm c d lemma "num"
  | _,"numc",[] -> []
  | lemma,"intnum",[] ->
      let batrs = make_node lemma "intnum" c.weight 0 [] in
      let numbers,acms =
        if lemma = "1" || lemma = "-1" then ["sg"],["congr"] else
        let s = String.get lemma (String.length lemma - 1) in
        ["pl"],if s = '2' || s = '3' || s = '4' then ["rec";"congr"] else ["rec"] in
      [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field NOSEM "" Forward [Phrase(Lex "hyphen")]]] ["adja"] d batrs] @
      make_nump numbers ["_"] ["_"] ["ter"] acms c d lemma "intnum" (* FIXME: specjalne traktowanie 1 i poza tym liczba mnoga *)
  | lemma,"realnum",[] ->
      let batrs = make_node lemma "realnum" c.weight 0 [] in
      [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field NOSEM "" Forward [Phrase(Lex "hyphen")]]] ["adja"] d batrs] @
      make_nump ["sg"] ["_"] ["_"] ["ter"] ["rec"] c d lemma "realnum"
  | lemma,"intnum-interval",[] ->
      let batrs = make_node lemma "intnum-interval" c.weight 0 [] in
      [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field NOSEM "" Forward [Phrase(Lex "hyphen")]]] ["adja"] d batrs] @
      make_nump ["pl"] ["_"] ["_"] ["ter"] ["rec";"congr"] c d lemma "intnum-interval"
  | lemma,"realnum-interval",[] ->
      let batrs = make_node lemma "realnum-interval" c.weight 0 [] in
      [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field NOSEM "" Forward [Phrase(Lex "hyphen")]]] ["adja"] d batrs] @
      make_nump ["sg"] ["_"] ["_"] ["ter"] ["rec"] c d lemma "realnum-interval"
  | lemma,"symbol",[] ->
      make_np ["sg"] ["_"] ["_"] ["ter"] c d lemma "symbol"
  | lemma,"ordnum",[] ->
      make_adjp ["_"] ["_"] ["_"] ["pos"] c d lemma "ordnum"
  | lemma,"date",[] -> make_np_symbol c d lemma "date"
  | lemma,"date-interval",[] -> make_np_symbol c d lemma "date-interval"
  | lemma,"hour-minute",[] -> make_np_symbol c d lemma "hour-minute"
  | lemma,"hour",[] -> make_np_symbol c d lemma "hour"
  | lemma,"hour-minute-interval",[] -> make_np_symbol c d lemma "hour-minute-interval"
  | lemma,"hour-interval",[] -> make_np_symbol c d lemma "hour-interval"
  | lemma,"year",[] -> make_np_symbol c d lemma "year"
  | lemma,"year-interval",[] -> make_np_symbol c d lemma "year-interval"
  | lemma,"day",[] -> make_day c d lemma "day"
  | lemma,"day-interval",[] -> make_day c d lemma "day-interval"
  | lemma,"day-month",[] -> make_np_symbol c d lemma "day-month"
  | lemma,"day-month-interval",[] -> make_np_symbol c d lemma "day-month-interval"
  | lemma,"month-interval",[] -> make_np_symbol c d lemma "month-interval"
  | lemma,"roman",[] -> (* "Aranżuje XIX struś." *)
      let batrs = make_node lemma "roman" c.weight 0 [] in
      [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field NOSEM "" Forward [Phrase(Lex "hyphen")]]] ["adja"] d batrs] @
      (make_np_symbol c d lemma "roman") @
      (make_adjp ["_"] ["_"] ["_"] ["pos"] c d lemma "roman-adj")
  | lemma,"roman-interval",[] ->
      let batrs = make_node lemma "roman-interval" c.weight 0 [] in
      [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field NOSEM "" Forward [Phrase(Lex "hyphen")]]] ["adja"] d batrs] @
      (make_np_symbol c d lemma "roman-interval")
  | lemma,"match-result",[] -> make_np_symbol c d lemma "match-result"
  | lemma,"url",[] -> make_np_symbol c d lemma "url"
  | lemma,"email",[] -> make_np_symbol c d lemma "email"
  | lemma,"obj-id",[] -> make_np_symbol c d lemma "obj-id"
  | lemma,"adj",[numbers;cases;genders;grads] ->
      (if lemma = "czyj" || lemma = "jaki" || lemma = "który" then
        List.flatten (Xlist.map ["int"] (fun ctype ->
          let _ = match grads with ["pos"] -> () | _ -> failwith "process_interp adj: grad" in
          let quant = ["inumber",ge (),[];"igender",ge (),[];"iperson",ge (),[];"nperson",ge (),[];"plemma",ge (),[];"ctype",ge (),[ctype];"number",d.e.number,expand_numbers numbers;"case",d.e.case,expand_cases cases;"gender",d.e.gender,expand_genders genders] in
          let t = ["cp"; "ctype"; lemma] in
          let sem_mods = ["CTYPE",SubstVar "ctype"] in
          let batrs = make_node lemma "adj" c.weight 0 [ctype;"number";"case";"gender"] in
          let raised_arg0 = [Raised(["np";"number";"case";"gender";"nperson"],Backward,["adjp";"number";"case";"gender"])] in
          let raised_arg1 = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["np";"number";"case";"gender";"nperson"])] in
          let raised_arg2a = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["prepnp";"plemma";"case"])] in
          let raised_arg2b = [Raised(["prepnp";"plemma";"case"],Forward,["np";"number";"case";"gender";"nperson"])] in
          let raised_arg3a = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["comprepnp";"plemma"])] in
          let raised_arg3b = [Raised(["comprepnp";"plemma"],Forward,["np";"number";"case";"gender";"nperson"])] in
          let schema_list = [[schema_field RAISED "" Forward raised_arg0];[schema_field RAISED "" Forward raised_arg1]] in
          let frame_np = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          let schema_list = [[schema_field RAISED "" Forward raised_arg0];[schema_field RAISED "" Backward raised_arg2b];[schema_field RAISED "" Forward raised_arg2a]] in
          let frame_prepnp = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          let schema_list = [[schema_field RAISED "" Forward raised_arg0];[schema_field RAISED "" Backward raised_arg3b];[schema_field RAISED "" Forward raised_arg3a]] in
          let frame_comprepnp = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          [frame_np;frame_prepnp;frame_comprepnp])) else []) @
      (if lemma = "jaki" || lemma = "który" then
        List.flatten (Xlist.map ["rel"] (fun ctype ->
          let _ = match grads with ["pos"] -> () | _ -> failwith "process_interp adj: grad" in
          let quant = ["inumber",ge (),[];"igender",ge (),[];"iperson",ge (),[];"plemma",ge (),[];"ctype",ge (),[ctype];"number",d.e.number,expand_numbers numbers;"case",d.e.case,expand_cases cases;"gender",d.e.gender,expand_genders genders; "person",d.e.person,["ter"]] in
          let t = ["cp"; "ctype"; lemma] in
          let sem_mods = ["CTYPE",SubstVar "ctype"] in
          let batrs = make_node lemma "adj" c.weight 0 [ctype;"number";"case";"gender";"person"] in
          let raised_arg = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["np";"number";"case";"gender";"person"])] in
          let raised_arg1 = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["prepnp";"plemma";"case"])] in
          let raised_arg2 = [Raised(["prepnp";"plemma";"case"],Forward,["np";"number";"case";"gender";"person"])] in
          let raised_arg3 = [Raised(["ip";"inumber";"igender";"iperson"],Forward,["comprepnp";"plemma"])] in
          let raised_arg4 = [Raised(["comprepnp";"plemma"],Forward,["np";"number";"case";"gender";"person"])] in
          let schema_list = [[schema_field RAISED "" Forward raised_arg]] in
          let frame_np = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          let schema_list = [[schema_field RAISED "" Backward raised_arg2];[schema_field RAISED "" Forward raised_arg1]] in
          let frame_prepnp = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          let schema_list = [[schema_field RAISED "" Backward raised_arg4];[schema_field RAISED "" Forward raised_arg3]] in
          let frame_comprepnp = LCGrenderer.make_frame_raised tokens lex_sems quant schema_list t d batrs sem_mods in
          [frame_np;frame_prepnp;frame_comprepnp])) else []) @
      if lemma = "czyj" || lemma = "jaki" || lemma = "który" then [] else
      (if lemma = "jakiś" || lemma = "ten" || lemma = "taki" then
        make_np numbers cases genders ["ter"] c d lemma "adj" else []) @
      make_adjp numbers cases genders grads c d lemma "adj"
  | lemma,"adjc",[] -> make_adjp ["sg"] ["pred"] ["m1";"m2";"m3"] ["pos"] c d lemma "adjc" (* np: gotów *) (* FIXME: czy to na pewno ma zwykłą walencję przymiotnika? *)
  | lemma,"adjp",[] -> make_adjp all_numbers ["postp"] all_genders ["pos"] c d lemma "adjp"
  | lemma,"adja",[] ->
      let batrs = make_node lemma "adja" c.weight 0 [] in
      [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field NOSEM "" Forward [Phrase(Lex "hyphen")]]] (["adja"]) d batrs]
  | lemma,"adv",[grads] ->
      make_advp grads c d lemma
  | lemma,"adv",[] ->
      make_advp ["pos"] c d lemma
  | lemma,"ger",[numbers;cases;genders;aspects;negations] ->
      make_ger numbers cases genders ["ter"] aspects negations c d lemma "ger"
  | lemma,"pact",[numbers;cases;genders;aspects;negations] ->
      make_padj numbers cases genders aspects negations c d lemma "pact"
  | lemma,"ppas",[numbers;cases;genders;aspects;negations] ->
      make_padj numbers cases genders aspects negations c d lemma "ppas"
  | lemma,"fin",[numbers;persons;aspects] ->  (* FIXME: genders bez przymnogich *)
      let persons2 = Xlist.fold persons [] (fun l -> function "sec" -> l | s -> s :: l) in
      (make_ip numbers ["_"] persons aspects false false c d lemma "fin") @
      (if persons2 = [] then [] else
       make_ip numbers ["_"] persons2 aspects false true c d lemma "fin")
  | lemma,"bedzie",[numbers;persons;aspects] ->
      (if lemma = "być" then
        let quant = ["number",d.e.number,expand_numbers numbers;"gender",d.e.gender,all_genders; "person", d.e.person,persons] in
        let t = ["aux-fut"; "number"; "gender"; "person"] in
        [LCGrenderer.make_frame_simple quant t c ( (make_node "być" "bedzie" c.weight 0 [])(*[Dot;Dot;Dot;Dot]*))] else []) @
      (make_ip numbers ["_"] persons aspects false false c d lemma "bedzie")
  | lemma,"praet",[numbers;genders;aspects;nagl] ->
      (if lemma = "być" (*|| lemma = "zostać"*) then
        let quant = ["number",d.e.number,expand_numbers numbers;"gender",d.e.gender,expand_genders genders; "person",d.e.person, all_persons] in
        let t = ["aux-past"; "number"; "gender"; "person"] in
        [LCGrenderer.make_frame_simple quant t c ( (make_node "być" "praet" c.weight 0 [])(*[Dot;Dot;Dot;Dot]*))] else []) @
      (make_ip numbers genders ["ter"] aspects false false c d lemma "praet") @
      (make_ip numbers genders ["pri";"sec"] aspects true false c d lemma "praet") @
      (make_ip numbers genders ["pri";"sec";"ter"] aspects false true c d lemma "praet")
  | lemma,"praet",[numbers;genders;aspects] ->
      (if lemma = "być" (*|| lemma = "zostać"*) then
        let quant = ["number",d.e.number,expand_numbers numbers;"gender",d.e.gender,expand_genders genders; "person",d.e.person, all_persons] in
        let t = ["aux-past"; "number"; "gender"; "person"] in
        [LCGrenderer.make_frame_simple quant t c ( (make_node "być" "praet" c.weight 0 [])(*[Dot;Dot;Dot;Dot]*))] else []) @
      (make_ip numbers genders ["ter"] aspects false false c d lemma "praet") @
      (make_ip numbers genders ["pri";"sec"] aspects true false c d lemma "praet") @
      (make_ip numbers genders ["pri";"sec";"ter"] aspects false true c d lemma "praet")
  | lemma,"winien",[numbers;genders;aspects] ->
      (make_ip numbers genders ["ter"] aspects false false c d lemma "winien") @
      (make_ip numbers genders ["ter"] aspects false true c d lemma "winien") @
      (make_ip numbers genders ["pri";"sec"] aspects true false c d lemma "winien") @
      (make_ip numbers genders ["pri";"sec"] aspects true true c d lemma "winien")
  | lemma,"impt",[numbers;persons;aspects] -> (* FIXME: genders bez przymnogich *)
      make_ip numbers ["_"] persons aspects false false c d lemma "impt"
  | lemma,"imps",[aspects] ->
      make_ip ["_"] ["_"] all_persons aspects false false c d lemma "imps"
  | lemma,"pred",[] -> (* FIXME: czy predykatyw zawsze jest niedokonany? *)
      (make_ip ["sg"] ["n2"] ["ter"] ["imperf"] false false c d lemma "pred") @
      (make_ip ["sg"] ["n2"] ["ter"] ["imperf"] false true c d lemma "pred")
  | "być","aglt",[numbers;persons;aspects;wok] ->
      let numbers = expand_numbers numbers in
      let quant = ["number",d.e.number,numbers; "person", d.e.person,persons] in
      let t = ["aglt"; "number"; "person"] in
      [LCGrenderer.make_frame_simple quant t c ( (make_node "być" "aglt" c.weight 0 [])(*[Dot;Dot;Dot]*))]
  | lemma,"inf",[aspects] ->  (* FIXME: wielopoziomowe InfP *)
      make_infp aspects c d lemma
  | lemma,"pcon",[aspects] ->
      make_padvp aspects c d lemma "pcon"
  | lemma,"pant",[aspects] ->
      make_padvp aspects c d lemma "pant"
  | "się","qub",[] -> [LCGrenderer.make_frame_simple [] ["się"] {c with orth=""} ( (make_node "się" "qub" c.weight 0 [])) (* FIXME: dodać make_np *)]
  | "nie","qub",[] -> [LCGrenderer.make_frame_simple [] ["nie"] {c with orth=""} (make_node "nie" "qub" c.weight 0 [])]
  | "by","qub",[] -> [LCGrenderer.make_frame_simple [] ["by"] {c with orth=""} (make_node "by" "qub" c.weight 0 [])]
  | "niech","qub",[] -> [LCGrenderer.make_frame_simple [] ["aux-imp"] c (make_node "niech" "qub" c.weight 0 [])]
  | "niechaj","qub",[] -> [LCGrenderer.make_frame_simple [] ["aux-imp"] c (make_node "niechaj" "qub" c.weight 0 [])]
  | "niechże","qub",[] -> [LCGrenderer.make_frame_simple [] ["aux-imp"] c (make_node "niechże" "qub" c.weight 0 [])]
  | "niechajże","qub",[] -> [LCGrenderer.make_frame_simple [] ["aux-imp"] c (make_node "niechajże" "qub" c.weight 0 [])]
  | "czy","qub",[] -> (* FIXME: poprawić semantykę *)
          let quant = [] in
          let t = ["cp"; "int"; "czy"] in
          let batrs = make_node "czy" "qub" c.weight 0 ["int"] in
          let schema_list = [[comp_arg_schema_field [Phrase IP]]] in
          [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs]
  | "gdyby","qub",[] -> (* FIXME: poprawić semantykę *) (* FIXME: poprawić tryb przypuszczający *) (* FIXME: problem z interpretacją jako 'gdy' *)
          let quant = [] in
          let t = ["cp"; "rel"; "gdyby"] in
          let batrs = make_node "gdyby" "qub" c.weight 0 ["rel"] in
          let schema_list = [[comp_arg_schema_field [Phrase IP]]] in
          [LCGrenderer.make_frame x_flag tokens lex_sems quant schema_list t d batrs]
  | lemma,"qub",[] -> [LCGrenderer.make_frame_simple [] ["qub"] c ( (make_node lemma "qub" c.weight 0 []))] (* FIXME: semantyka i rodzaje kublików *)
  | lemma,"comp",[] -> make_conjunct c d lemma "comp"
  | "i","conj",[] -> make_conj true c d "i" @ (make_conjunct c d "i" "conj")
  | "lub","conj",[] -> make_conj true c d "lub" @ (make_conjunct c d "lub" "conj")
  | "czy","conj",[] -> make_conj true c d "czy" @ (make_conjunct c d "czy" "conj")
  | "bądź","conj",[] -> make_conj true c d "bądź" @ (make_conjunct c d "bądź" "conj")
  | lemma,"conj",[] -> make_conjunct c d lemma "conj"
(*  | "interp",[] -> []
  | "brev",[pun] -> []*)
  | lemma,"interj",[] -> [LCGrenderer.make_frame_simple [] ["interj"] c (make_node lemma "interj" c.weight 0 [])]
  | lemma,"burk",[] -> [] (* FIXME *)
(*  | "dig",[] -> []
  | "romandig",[] -> []
  | "ign",[] -> []
  | "xxx",[] -> [] (* to występuje w słowniku skrótów *)*)
(*  | ".","interp",[] -> []
  | "%","interp",[] -> []*)
  | "-","interp",[] -> [LCGrenderer.make_frame_simple [] ["hyphen"] c (make_node "-" "interp" c.weight 0 [])]
(*  | ":","interp",[] -> [LCGrenderer.make_frame_simple [] ["colon"] ":" beg len [Dot] [Dot]]*)
  | "?","interp",[] -> [LCGrenderer.make_frame_simple [] ["int"] c (make_node "?" "interp" c.weight 0 [])] (*FIXME: zdanie nadrzędne powinno mieć atrybut pytajności(Attr("INT",Val "+"))] *)
  | ",","interp",[] -> make_conj false c d "," (*@ [LCGrenderer.make_frame_simple [] ["comma"] "," beg len [Dot] [Dot]]*)
  | ";","interp",[] -> [](*[LCGrenderer.make_frame_simple [] ["comma"] ";" beg len [Dot] [Dot]]*)
  | "„","interp",[] -> [(* FIXME: zaznaczyć niesemantyczność quotów *)
          LCGrenderer.make_quot_frame
            ["number",d.e.number,[];"case",d.e.case,[];"gender",d.e.gender,[];"person",d.e.person,[]]
            (Tensor[Atom "np"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]) (Tensor[Atom "rquot"])
            ["np";"number";"case";"gender";"person"] d
            (make_node "„" "interp" c.weight 0 [])]
  | "”","interp",[] -> [LCGrenderer.make_frame_simple [] ["rquot"] c (make_node "”" "interp" c.weight 0 [])]
  | "«","interp",[] -> [LCGrenderer.make_frame_simple [] ["rquot3"] c (make_node "«" "interp" c.weight 0 []);
          LCGrenderer.make_quot_frame
            ["number",d.e.number,[];"case",d.e.case,[];"gender",d.e.gender,[];"person",d.e.person,[]]
            (Tensor[Atom "np"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]) (Tensor[Atom "rquot2"])
            ["np";"number";"case";"gender";"person"] d
            (make_node "«" "interp" c.weight 0 [])]
  | "»","interp",[] -> [LCGrenderer.make_frame_simple [] ["rquot2"] c (make_node "»" "interp" c.weight 0 []);
          LCGrenderer.make_quot_frame
            ["number",d.e.number,[];"case",d.e.case,[];"gender",d.e.gender,[];"person",d.e.person,[]]
            (Tensor[Atom "np"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]) (Tensor[Atom "rquot3"])
            ["np";"number";"case";"gender";"person"] d
            (make_node "»" "interp" c.weight 0 [])]
  | "(","interp",[] -> [LCGrenderer.make_inclusion_frame (Tensor[Atom "rparen"]) d (make_node "(" "interp" c.weight 0 [])]
  | ")","interp",[] -> [LCGrenderer.make_frame_simple [] ["rparen"] c (make_node ")" "interp" c.weight 0 [])]
  | "[","interp",[] -> [LCGrenderer.make_inclusion_frame (Tensor[Atom "rparen"]) d (make_node "[" "interp" c.weight 0 [])]
  | "]","interp",[] -> [LCGrenderer.make_frame_simple [] ["rparen"] c (make_node "]" "interp" c.weight 0 [])]
  | lemma,"unk",[] ->
     let quant = ["number",d.e.number,all_numbers;"case",d.e.case,all_cases; "gender",d.e.gender,all_genders; "person",d.e.person, ["ter"]] in
     let t = ["np"; "number"; "case"; "gender"; "person"] in
     let batrs = make_node lemma "unk" c.weight 0 ["number"; "case"; "gender"; "person"] in
     [LCGrenderer.make_frame_simple quant t c ( batrs)]
  | _,"xxx",[] -> [] (* FIXME *)
  | ".","interp",[] -> [LCGrenderer.make_frame_simple [] ["dot"] d (make_node "." "interp" c.weight 0 [])] (* FIXME: to jest potrzebne przy CONLL *)
  | "…","interp",[] -> [LCGrenderer.make_frame_simple [] ["multidot"] d (make_node "…" "interp" c.weight 0 [])] (* FIXME: to jest potrzebne przy CONLL *)
  | lemma,"brev",_ -> [LCGrenderer.make_frame_simple [] ["brev"] d (make_node lemma "brev" c.weight 0 [])] (* FIXME: to jest potrzebne przy CONLL *)
  | "<conll_root>","interp",[] ->
     let batrs = (make_node "<conll_root>" "interp" c.weight 0 []) in
     (* let schema_list = [[schema_field CLAUSE "Clause" Forward [Phrase IP;Phrase (CP(Int,CompUndef));Phrase (NP(Case "voc"));Phrase (Lex "interj")]]] in *)
     let schema_list = [[schema_field CLAUSE "Clause" Forward [Multi[IP;CP(Int,CompUndef);CP(Coord,CompUndef);NP(Case "voc");Lex "interj";Lex "<root>"]]]] in
     (* let schema_list = [[schema_field CLAUSE "Clause" Forward [Phrase IP;Phrase (CP(Int,CompUndef));Phrase (CP(Coord,CompUndef));Phrase (NP(Case "voc"));Phrase (Lex "interj");Phrase (Lex "<root>")]]] in *)
     [LCGrenderer.make_frame false tokens lex_sems [] schema_list ["<conll_root>"] d batrs]
  | lemma,c,l -> failwith ("process_interp: " ^ lemma ^ ":" ^ c ^ ":" ^ (String.concat ":" (Xlist.map l (String.concat ".")))) in

let process_bracket_lemma (c:ENIAMtokenizerTypes.token_record) (d:ENIAMlexSemanticsTypes.lex_sem) = function
    (* "<query>" ->
       [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field NOSEM "" Forward [Phrase Null;Phrase (Lex "<dummy>")]];[arg_schema_field Forward [Phrase (Lex "</query>")]]] (["<query>"]) {d with orth=""} (make_node "<query1>" "interp" c.weight 0 []);
        LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field SENTENCE "" Forward [Phrase (Lex "<ors>")]]] (["<query>"]) {d with orth=""} (make_node "<query2>" "interp" c.weight 0 []);
        LCGrenderer.make_frame x_flag tokens lex_sems [] [[(*nosem*)arg_schema_field Forward [Phrase (Lex "<speaker>")]];[nosem_schema_field Forward [Phrase (Lex "<colon>")]];[(*nosem*)arg_schema_field Forward [Phrase (Lex "<ors>")]];[(*nosem*)arg_schema_field Forward [Phrase (Lex "</query>")]]] (["<query>"]) {d with orth=""} (make_node "<query3>" "interp" c.weight 0 []);
        LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field SENTENCE "" Forward [Phrase (Lex "<colon>")]]] (["<query>"]) {d with orth=""} (make_node "<query4>" "interp" c.weight 0 []);
        LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field SENTENCE "" Forward [Phrase (Lex "<colon>")]];[schema_field SENTENCE "" Forward [Phrase (Lex "<ors>")]]] (["<query>"]) {d with orth=""} (make_node "<query5>" "interp" c.weight 0 []); (* FIXME: zdania w odwróconej kolejności *)
        LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field SENTENCE "Sentence" Forward [Phrase (Lex "<sentence>")]];[schema_field SENTENCE "" Forward [Phrase (Lex "<ors>")]]] (["<query>"]) {d with orth=""}  (make_node "<query6>" "interp" c.weight 0 [])] (* FIXME: zdania w odwróconej kolejności *)
  | "</query>" ->
       let t = (["</query>"]) in
       let batrs = (make_node "</query>" "interp" c.weight 0 []) in
       let schema_list = [[schema_field NOSEM "" Backward [Phrase Null;Phrase (Lex "<dummy>")]];[schema_field SENTENCE "Sentence" Backward [Multi[Lex "<sentence>"](*Phrase(Lex "s")*)]]] in
       [LCGrenderer.make_frame x_flag tokens lex_sems [] schema_list t d batrs]*)
  | "„s" -> []
       (*let batrs = make_node "pro-komunikować" "pro" c.weight 0 [] in
       [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field OBJ "Theme" Forward [Phrase (Lex "</or1>")]]] (["<sentence>"(*"or"*)]) {d with orth=""} batrs;
        LCGrenderer.make_frame_simple [] ["<dummy>"] d ( (make_node "„s" "interp" c.weight 0 []))]*)
  | "”s" -> []
       (*let t = (["</or1>"]) in
       let batrs = (make_node "”s" "interp" c.weight 0 []) in
       let schema_list = [[schema_field SENTENCE "Sentence" Backward [Multi[Lex "<sentence>"](*Phrase(Lex "s")*)]]] in
       [LCGrenderer.make_frame x_flag tokens lex_sems [] schema_list t d batrs;
        LCGrenderer.make_frame_simple [] ["<dummy>"] d ( (make_node "”s" "interp" c.weight 0 []))]*)
  | "«s" -> [] (* FIXME *)
  | "»s" -> [] (* FIXME *)
  | ":" ->
       [LCGrenderer.make_frame_simple [] ["or"] c (LCGrenderer.make_pro_komunikat tokens lex_sems)]
  | ":s" ->
       let batrs = make_node "pro-komunikować" "pro" c.weight 0 [] in
       [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field SUBJ "Initiator" Backward [Phrase (Lex "<speaker>")]]] (["<colon>"]) {c with orth=""} batrs;
        LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field SUBJ "Initiator" Backward [Phrase (Lex "<speaker>")]];[schema_field OBJ "Theme" Forward [Phrase (Lex "</query>")]]] (["<colon>"]) {c with orth=""} batrs]
  (*| "<or>" -> [LCGrenderer.make_frame x_flag tokens lex_sems [] [[nosem_schema_field Forward [Phrase (Lex "</or>")]]] (["or"]) {d with orth=""} (make_node "<or>" "interp" c.weight 0 [])]*)
  | "<or>" -> []
  | "<or-sentence>" -> (* FIXME: dodać mówcę jako pro *)
       let batrs = make_node "pro-komunikować" "pro" c.weight 0 [] in
       [LCGrenderer.make_frame x_flag tokens lex_sems [] [[schema_field ARG ""(*"Theme"*) Forward [Phrase (Lex "s")]]] ["<root>"] {c with orth=""} batrs;
        LCGrenderer.or_frame (make_node "<sentence>" "interp" c.weight 0 [])]
  (* | "<or-sentence-conll>" ->
       let batrs = make_node "pro-komunikować" "pro" d.weight 0 [] in
       [LCGrenderer.make_frame x_flag tokens [] [[schema_field ARG ""(*"Theme"*) Forward [Phrase (Lex "s")]]] ["<root>"] {d with orth=""} batrs;
        LCGrenderer.or_frame (make_node "<sentence>" "interp" d.weight 0 [])] *)
  | "</or-sentence>" ->
         let t = ["or2"] in
         let batrs = (make_node "</or-sentence>" "interp" c.weight 0 []) in
         let schema_list = [[schema_field CLAUSE "Clause" Backward [Multi[IP;CP(Int,CompUndef);NP(Case "voc");Lex "interj"](*Phrase IP;Phrase(CP(Int,CompUndef));Phrase(NP(Case "voc"))*)]](*;[WalFrames.schema_field NOSEM "" Backward [Phrase(Lex "<sentence>")]]*)] in
         [LCGrenderer.make_frame x_flag tokens lex_sems [] schema_list t d batrs]
  | "</or>" -> []
       (*let t = (["</or>"]) in
       let batrs = (make_node "</or>" "interp" c.weight 0 []) in
       let schema_list = [[schema_field SENTENCE "Sentence" Backward [Multi[Lex "<sentence>"](*Phrase(Lex "s")*)]]] in
       [LCGrenderer.make_frame x_flag tokens lex_sems [] schema_list t d batrs]  (* FIXME: semantyka *)*)
  | "<sentence>" ->
       [LCGrenderer.make_frame x_flag tokens lex_sems [] [[arg_schema_field Forward [Phrase (Lex "s")]]] ["<root>"] {c with orth=""} (make_node "<sentence>" "interp" c.weight 0 []);
        LCGrenderer.make_frame x_flag tokens lex_sems [] [[arg_schema_field Forward [Phrase (NP(Case "nom"))]];[nosem_schema_field Forward [Phrase (Lex "</speaker>")]]] (["<speaker>"]) {c with orth=""} (make_node "<speaker>" "interp" c.weight 0 [])]
  | "</sentence>" ->
         let t = ["s"] in
         let batrs = (make_node "</sentence>" "interp" c.weight 0 []) in
         let schema_list = [[schema_field CLAUSE "Clause" Backward [Multi[IP;CP(Int,CompUndef);NP(Case "voc");Lex "interj"](*Phrase IP;Phrase(CP(Int,CompUndef));Phrase(NP(Case "voc"))*)]](*;[WalFrames.schema_field NOSEM "" Backward [Phrase(Lex "<sentence>")]]*)] in
         [LCGrenderer.make_frame_simple [] ["</speaker>"] c ( (make_node "</speaker>" "interp" c.weight 0 []));
          LCGrenderer.make_frame x_flag tokens lex_sems [] schema_list t d batrs]
  | lemma -> raise Not_found in

let get_labels () = {
  number=ge ();
  case=ge ();
  gender=ge ();
  person=ge ();
  aspect=ge ();
  } in

(* create_entries *)
  match c with
    {token = Interp "<clause>"} -> [BracketSet(Forward),Dot]
  | {token = Interp "</clause>"} -> [BracketSet(Backward),Dot]
  | {token = Interp lemma} ->
    (try
      Xlist.fold (process_bracket_lemma c d lemma) [] (fun l (symbol,sem) -> (Bracket(true,true,symbol),sem) :: l)
    with Not_found ->
          (* print_endline ("x"^lemma^"x"); *)
          let entries = process_interp c d (lemma,"interp",[]) in
          Xlist.map entries (fun (symbol,sem) -> Bracket(false,false,symbol),sem))
  | {token = Lemma(lemma,"sinterj",[[]])} ->
          let t = ["interj"] in
          let batrs = make_node lemma "sinterj" c.weight 0 [] in
          let symbol,sem = LCGrenderer.make_frame_simple [] t c ( batrs) in
          [Bracket(true,true,symbol),sem]
  | {token = Lemma(lemma,pos,interp)} ->
        (* print_endline (lemma ^ " " ^ pos); *)
        Xlist.fold interp [] (fun l tags ->
          let d = {d with e=get_labels (); valence=LCGrenderer.make_controll d.valence} in
          let entries = process_interp c d (lemma,pos,tags) in
          Xlist.map entries (fun (symbol,sem) -> Bracket(false,false,symbol),sem) @ l)
  | _ -> []

module OrderedIntInt = struct

  type t = int * int

  let compare = compare

end

module IntIntSet = Xset.Make(OrderedIntInt)


let create (paths,last) tokens lex_sems =
  uni_weight := 0.;
  let chart = LCGchart.make last in
  let chart = Xlist.fold paths chart (fun chart (id,lnode,rnode) ->
    let c = ExtArray.get tokens id in
    let d = ExtArray.get lex_sems id in
(*     if t.weight < -0.9 || Xlist.mem t.attrs "notvalidated proper" || Xlist.mem t.attrs "lemmatized as lowercase" then chart else *)
    let chart = LCGchart.add_inc chart lnode rnode (Tensor[Atom ("[" ^ c.orth ^ "]")], Dot) 0 in
    LCGchart.add_inc_list chart lnode rnode (create_entries tokens lex_sems id (c:ENIAMtokenizerTypes.token_record) d false) 0) in
  let set = Xlist.fold paths IntIntSet.empty (fun set (_,lnode,rnode) -> IntIntSet.add set (lnode,rnode)) in
  let chart = IntIntSet.fold set chart (fun chart (i,j) -> LCGchart.make_unique chart i j) in
  chart

let rec split_sons left id right = function
    [] -> List.rev (List.sort compare left), List.sort compare right
  | x :: l -> if x < id then split_sons (x :: left) id right l else split_sons left id (x :: right) l

let rec dep_create_rec nodes sons conll_id =
  let node = IntMap.find nodes conll_id in
  let l = try IntMap.find sons conll_id with Not_found -> [] in
  let left,right = split_sons [] conll_id [] l in
  (* Printf.printf "dep_create_rec [%s] %d [%s]\n" (String.concat ";" (Xlist.map left string_of_int)) conll_id (String.concat ";" (Xlist.map right string_of_int)); *)
  DepNode(conll_id, Xlist.map left (dep_create_rec nodes sons), node, Xlist.map right (dep_create_rec nodes sons))

let dep_create paths tokens lex_sems =
  uni_weight := 0.;
  let sons = Int.fold 1 (Array.length paths - 1) IntMap.empty (fun sons i ->
    let _,super,_ = paths.(i) in
    IntMap.add_inc sons super [i] (fun l -> i :: l)) in
  let nodes = Int.fold 0 (Array.length paths - 1) IntMap.empty (fun nodes i ->
    let id,_,_ = paths.(i) in
    let c = ExtArray.get tokens id in
    let d = ExtArray.get lex_sems id in
    IntMap.add nodes i (create_entries tokens lex_sems id c d true)) in
  dep_create_rec nodes sons 0