wenzelm@18: (* Title: Pure/Syntax/syntax.ML clasohm@0: ID: $Id$ clasohm@0: Author: Tobias Nipkow and Markus Wenzel, TU Muenchen wenzelm@18: wenzelm@18: Root of Isabelle's syntax module. clasohm@0: *) clasohm@0: wenzelm@260: signature BASIC_SYNTAX = wenzelm@2383: sig wenzelm@260: include AST0 wenzelm@556: include SYN_TRANS0 wenzelm@556: include MIXFIX0 wenzelm@260: include PRINTER0 wenzelm@2383: end; wenzelm@260: clasohm@0: signature SYNTAX = wenzelm@2383: sig wenzelm@260: include AST1 clasohm@0: include LEXICON0 wenzelm@237: include SYN_EXT0 clasohm@0: include TYPE_EXT0 wenzelm@556: include SYN_TRANS1 wenzelm@556: include MIXFIX1 clasohm@0: include PRINTER0 wenzelm@15755: val extend_trtab: string -> (string * ('a * stamp)) list -> wenzelm@15755: ('a * stamp) Symtab.table -> ('a * stamp) Symtab.table wenzelm@15755: val merge_trtabs: string -> ('a * stamp) Symtab.table -> ('a * stamp) Symtab.table -> wenzelm@15755: ('a * stamp) Symtab.table wenzelm@14648: val merge_tr'tabs: ('a * stamp) list Symtab.table -> ('a * stamp) list Symtab.table wenzelm@14648: -> ('a * stamp) list Symtab.table wenzelm@15755: val extend_tr'tab: (string * ('a * stamp)) list -> wenzelm@15755: ('a * stamp) list Symtab.table -> ('a * stamp) list Symtab.table wenzelm@1158: datatype 'a trrule = wenzelm@3526: ParseRule of 'a * 'a | wenzelm@3526: PrintRule of 'a * 'a | wenzelm@3526: ParsePrintRule of 'a * 'a wenzelm@556: type syntax wenzelm@17079: val eq_syntax: syntax * syntax -> bool wenzelm@14687: val is_keyword: syntax -> string -> bool wenzelm@20784: type mode wenzelm@20784: val default_mode: mode wenzelm@21702: val input_mode: mode wenzelm@12073: val extend_type_gram: (string * int * mixfix) list -> syntax -> syntax wenzelm@14904: val extend_const_gram: (string -> bool) -> wenzelm@20784: mode -> (string * typ * mixfix) list -> syntax -> syntax wenzelm@12073: val extend_consts: string list -> syntax -> syntax wenzelm@12073: val extend_trfuns: wenzelm@15755: (string * ((ast list -> ast) * stamp)) list * wenzelm@15755: (string * ((term list -> term) * stamp)) list * wenzelm@15755: (string * ((bool -> typ -> term list -> term) * stamp)) list * wenzelm@15755: (string * ((ast list -> ast) * stamp)) list -> syntax -> syntax wenzelm@16613: val extend_advanced_trfuns: wenzelm@18857: (string * ((Context.generic -> ast list -> ast) * stamp)) list * wenzelm@18857: (string * ((Context.generic -> term list -> term) * stamp)) list * wenzelm@18857: (string * ((Context.generic -> bool -> typ -> term list -> term) * stamp)) list * wenzelm@18857: (string * ((Context.generic -> ast list -> ast) * stamp)) list -> syntax -> syntax wenzelm@15755: val extend_tokentrfuns: (string * string * (string -> string * real)) list -> syntax -> syntax wenzelm@19262: val remove_const_gram: (string -> bool) -> wenzelm@20784: mode -> (string * typ * mixfix) list -> syntax -> syntax wenzelm@18857: val extend_trrules: Context.generic -> (string -> bool) -> syntax -> wenzelm@14904: (string * string) trrule list -> syntax -> syntax wenzelm@19262: val remove_trrules: Context.generic -> (string -> bool) -> syntax -> wenzelm@19262: (string * string) trrule list -> syntax -> syntax wenzelm@19262: val extend_trrules_i: ast trrule list -> syntax -> syntax wenzelm@19262: val remove_trrules_i: ast trrule list -> syntax -> syntax wenzelm@4618: val map_trrule: ('a -> 'b) -> 'a trrule -> 'b trrule wenzelm@556: val merge_syntaxes: syntax -> syntax -> syntax wenzelm@18720: val basic_syn: syntax wenzelm@18720: val basic_nonterms: string list wenzelm@18720: val appl_syntax: (string * string * mixfix) list wenzelm@18720: val applC_syntax: (string * string * mixfix) list wenzelm@556: val print_gram: syntax -> unit wenzelm@556: val print_trans: syntax -> unit wenzelm@556: val print_syntax: syntax -> unit wenzelm@18857: val read: Context.generic -> (string -> bool) -> syntax -> typ -> string -> term list wenzelm@18857: val read_typ: Context.generic -> syntax -> ((indexname * sort) list -> indexname -> sort) -> wenzelm@16613: (sort -> sort) -> string -> typ wenzelm@18857: val read_sort: Context.generic -> syntax -> string -> sort wenzelm@19375: val pretty_term: (string -> xstring) -> Context.generic -> syntax -> bool -> term -> Pretty.T wenzelm@18857: val pretty_typ: Context.generic -> syntax -> typ -> Pretty.T wenzelm@18857: val pretty_sort: Context.generic -> syntax -> sort -> Pretty.T clasohm@882: val ambiguity_level: int ref skalberg@14177: val ambiguity_is_error: bool ref wenzelm@2383: end; clasohm@0: wenzelm@12094: structure Syntax: SYNTAX = clasohm@0: struct clasohm@0: wenzelm@237: (** tables of translation functions **) wenzelm@237: wenzelm@5692: (* parse (ast) translations *) wenzelm@5692: wenzelm@17412: fun lookup_tr tab c = Option.map fst (Symtab.lookup tab c); wenzelm@237: wenzelm@383: fun err_dup_trfuns name cs = wenzelm@383: error ("More than one " ^ name ^ " for " ^ commas_quote cs); wenzelm@237: wenzelm@21536: fun remove_trtab trfuns = fold (Symtab.remove SynExt.eq_trfun) trfuns; wenzelm@21536: wenzelm@21536: fun extend_trtab name trfuns tab = Symtab.extend (remove_trtab trfuns tab, trfuns) wenzelm@15755: handle Symtab.DUPS cs => err_dup_trfuns name cs; wenzelm@237: wenzelm@15755: fun merge_trtabs name tab1 tab2 = Symtab.merge SynExt.eq_trfun (tab1, tab2) wenzelm@15755: handle Symtab.DUPS cs => err_dup_trfuns name cs; wenzelm@237: wenzelm@237: wenzelm@5692: (* print (ast) translations *) wenzelm@5692: wenzelm@18931: fun lookup_tr' tab c = map fst (Symtab.lookup_list tab c); wenzelm@18931: fun extend_tr'tab trfuns = fold_rev Symtab.update_list trfuns; wenzelm@18931: fun remove_tr'tab trfuns = fold (Symtab.remove_list SynExt.eq_trfun) trfuns; wenzelm@18931: fun merge_tr'tabs tab1 tab2 = Symtab.merge_list SynExt.eq_trfun (tab1, tab2); wenzelm@5692: wenzelm@5692: wenzelm@237: wenzelm@2700: (** tables of token translation functions **) wenzelm@2700: wenzelm@2700: fun lookup_tokentr tabs modes = wenzelm@19482: let val trs = distinct (eq_fst (op =)) (maps (these o AList.lookup (op =) tabs) (modes @ [""])) haftmann@17314: in fn c => Option.map fst (AList.lookup (op =) trs c) end; wenzelm@2700: wenzelm@2700: fun merge_tokentrtabs tabs1 tabs2 = wenzelm@2700: let wenzelm@2700: fun eq_tr ((c1, (_, s1)), (c2, (_, s2))) = c1 = c2 andalso s1 = s2; wenzelm@2700: wenzelm@4703: fun name (s, _) = implode (tl (Symbol.explode s)); wenzelm@2706: wenzelm@2700: fun merge mode = wenzelm@2700: let wenzelm@17213: val trs1 = these (AList.lookup (op =) tabs1 mode); wenzelm@17213: val trs2 = these (AList.lookup (op =) tabs2 mode); wenzelm@19046: val trs = distinct eq_tr (trs1 @ trs2); wenzelm@2700: in wenzelm@18964: (case duplicates (eq_fst (op =)) trs of wenzelm@2700: [] => (mode, trs) wenzelm@2700: | dups => error ("More than one token translation function in mode " ^ wenzelm@2706: quote mode ^ " for " ^ commas_quote (map name dups))) wenzelm@2700: end; wenzelm@19046: in map merge (distinct (op =) (map fst (tabs1 @ tabs2))) end; wenzelm@2700: wenzelm@15755: fun extend_tokentrtab tokentrs tabs = wenzelm@2700: let wenzelm@17213: fun ins_tokentr (m, c, f) = wenzelm@17213: AList.default (op =) (m, []) wenzelm@17213: #> AList.map_entry (op =) m (cons ("_" ^ c, (f, stamp ()))); wenzelm@15759: in merge_tokentrtabs tabs (fold ins_tokentr tokentrs []) end; wenzelm@2700: wenzelm@2700: wenzelm@2700: wenzelm@237: (** tables of translation rules **) wenzelm@237: wenzelm@5692: type ruletab = (Ast.ast * Ast.ast) list Symtab.table; wenzelm@237: wenzelm@19482: fun dest_ruletab tab = maps snd (Symtab.dest tab); wenzelm@237: wenzelm@237: wenzelm@237: (* empty, extend, merge ruletabs *) wenzelm@237: wenzelm@18931: val extend_ruletab = fold_rev (fn r => Symtab.update_list (Ast.head_of_rule r, r)); wenzelm@18931: val remove_ruletab = fold (fn r => Symtab.remove_list (op =) (Ast.head_of_rule r, r)); wenzelm@18931: fun merge_ruletabs tab1 tab2 = Symtab.merge_list (op =) (tab1, tab2); clasohm@0: clasohm@0: clasohm@0: clasohm@0: (** datatype syntax **) clasohm@0: wenzelm@237: datatype syntax = wenzelm@237: Syntax of { wenzelm@15755: input: SynExt.xprod list, wenzelm@4703: lexicon: Scan.lexicon, wenzelm@5692: gram: Parser.gram, wenzelm@18: consts: string list, wenzelm@2913: prmodes: string list, wenzelm@18857: parse_ast_trtab: ((Context.generic -> Ast.ast list -> Ast.ast) * stamp) Symtab.table, wenzelm@237: parse_ruletab: ruletab, wenzelm@18857: parse_trtab: ((Context.generic -> term list -> term) * stamp) Symtab.table, wenzelm@18857: print_trtab: ((Context.generic -> bool -> typ -> term list -> term) * stamp) list Symtab.table, wenzelm@237: print_ruletab: ruletab, wenzelm@18857: print_ast_trtab: ((Context.generic -> Ast.ast list -> Ast.ast) * stamp) list Symtab.table, wenzelm@6322: tokentrtab: (string * (string * ((string -> string * real) * stamp)) list) list, wenzelm@17079: prtabs: Printer.prtabs} * stamp; clasohm@0: wenzelm@17079: fun eq_syntax (Syntax (_, s1), Syntax (_, s2)) = s1 = s2; wenzelm@17079: wenzelm@17079: fun is_keyword (Syntax ({lexicon, ...}, _)) = Scan.is_literal lexicon o Symbol.explode; wenzelm@14687: wenzelm@20784: type mode = string * bool; wenzelm@15755: val default_mode = ("", true); wenzelm@21702: val input_mode = ("input", true); wenzelm@15755: wenzelm@18: wenzelm@237: (* empty_syntax *) wenzelm@18: wenzelm@17079: val empty_syntax = Syntax wenzelm@17079: ({input = [], wenzelm@4703: lexicon = Scan.empty_lexicon, wenzelm@5692: gram = Parser.empty_gram, wenzelm@167: consts = [], wenzelm@2913: prmodes = [], wenzelm@5692: parse_ast_trtab = Symtab.empty, wenzelm@5692: parse_ruletab = Symtab.empty, wenzelm@5692: parse_trtab = Symtab.empty, wenzelm@5692: print_trtab = Symtab.empty, wenzelm@5692: print_ruletab = Symtab.empty, wenzelm@5692: print_ast_trtab = Symtab.empty, wenzelm@2700: tokentrtab = [], wenzelm@17079: prtabs = Printer.empty_prtabs}, stamp ()); wenzelm@167: wenzelm@167: wenzelm@237: (* extend_syntax *) wenzelm@167: wenzelm@17079: fun extend_syntax (mode, inout) syn_ext (Syntax (tabs, _)) = wenzelm@167: let wenzelm@15755: val {input, lexicon, gram, consts = consts1, prmodes = prmodes1, wenzelm@2366: parse_ast_trtab, parse_ruletab, parse_trtab, print_trtab, print_ruletab, wenzelm@2700: print_ast_trtab, tokentrtab, prtabs} = tabs; wenzelm@14904: val SynExt.SynExt {xprods, consts = consts2, prmodes = prmodes2, wenzelm@2913: parse_ast_translation, parse_rules, parse_translation, print_translation, print_rules, wenzelm@2700: print_ast_translation, token_translation} = syn_ext; wenzelm@19546: fun if_inout xs = if inout then xs else []; wenzelm@167: in wenzelm@17079: Syntax wenzelm@19546: ({input = if_inout xprods @ input, wenzelm@19546: lexicon = Scan.extend_lexicon lexicon (if_inout (SynExt.delims_of xprods)), wenzelm@19546: gram = Parser.extend_gram gram (if_inout xprods), wenzelm@19546: consts = Library.merge (op =) (consts1, filter_out NameSpace.is_qualified consts2), wenzelm@18921: prmodes = insert (op =) mode (Library.merge (op =) (prmodes1, prmodes2)), wenzelm@167: parse_ast_trtab = wenzelm@19546: extend_trtab "parse ast translation" (if_inout parse_ast_translation) parse_ast_trtab, wenzelm@19546: parse_ruletab = extend_ruletab (if_inout parse_rules) parse_ruletab, wenzelm@19546: parse_trtab = extend_trtab "parse translation" (if_inout parse_translation) parse_trtab, wenzelm@15755: print_trtab = extend_tr'tab print_translation print_trtab, wenzelm@15755: print_ruletab = extend_ruletab print_rules print_ruletab, wenzelm@15755: print_ast_trtab = extend_tr'tab print_ast_translation print_ast_trtab, wenzelm@15755: tokentrtab = extend_tokentrtab token_translation tokentrtab, wenzelm@17079: prtabs = Printer.extend_prtabs mode xprods prtabs}, stamp ()) wenzelm@18: end; wenzelm@18: wenzelm@15755: wenzelm@15755: (* remove_syntax *) wenzelm@15755: wenzelm@17079: fun remove_syntax (mode, inout) syn_ext (Syntax (tabs, _)) = wenzelm@15755: let wenzelm@15755: val SynExt.SynExt {xprods, consts = _, prmodes = _, wenzelm@15755: parse_ast_translation, parse_rules, parse_translation, print_translation, print_rules, wenzelm@15755: print_ast_translation, token_translation = _} = syn_ext; wenzelm@15755: val {input, lexicon, gram, consts, prmodes, wenzelm@15755: parse_ast_trtab, parse_ruletab, parse_trtab, print_trtab, print_ruletab, wenzelm@15755: print_ast_trtab, tokentrtab, prtabs} = tabs; wenzelm@19300: val input' = if inout then subtract (op =) xprods input else input; wenzelm@19546: fun if_inout xs = if inout then xs else []; wenzelm@15755: in wenzelm@17079: Syntax wenzelm@17079: ({input = input', wenzelm@15755: lexicon = if inout then Scan.make_lexicon (SynExt.delims_of input') else lexicon, wenzelm@15755: gram = if inout then Parser.make_gram input' else gram, wenzelm@15755: consts = consts, wenzelm@15755: prmodes = prmodes, wenzelm@19546: parse_ast_trtab = remove_trtab (if_inout parse_ast_translation) parse_ast_trtab, wenzelm@19546: parse_ruletab = remove_ruletab (if_inout parse_rules) parse_ruletab, wenzelm@19546: parse_trtab = remove_trtab (if_inout parse_translation) parse_trtab, wenzelm@15755: print_trtab = remove_tr'tab print_translation print_trtab, wenzelm@15755: print_ruletab = remove_ruletab print_rules print_ruletab, wenzelm@15755: print_ast_trtab = remove_tr'tab print_ast_translation print_ast_trtab, wenzelm@15755: tokentrtab = tokentrtab, wenzelm@17079: prtabs = Printer.remove_prtabs mode xprods prtabs}, stamp ()) wenzelm@15755: end; wenzelm@14904: wenzelm@18: wenzelm@237: (* merge_syntaxes *) clasohm@0: wenzelm@17079: fun merge_syntaxes (Syntax (tabs1, _)) (Syntax (tabs2, _)) = clasohm@0: let wenzelm@15755: val {input = input1, lexicon = lexicon1, gram = gram1, consts = consts1, wenzelm@15755: prmodes = prmodes1, parse_ast_trtab = parse_ast_trtab1, wenzelm@15755: parse_ruletab = parse_ruletab1, parse_trtab = parse_trtab1, wenzelm@15755: print_trtab = print_trtab1, print_ruletab = print_ruletab1, wenzelm@15755: print_ast_trtab = print_ast_trtab1, tokentrtab = tokentrtab1, prtabs = prtabs1} = tabs1; wenzelm@237: wenzelm@15755: val {input = input2, lexicon = lexicon2, gram = gram2, consts = consts2, wenzelm@15755: prmodes = prmodes2, parse_ast_trtab = parse_ast_trtab2, wenzelm@15755: parse_ruletab = parse_ruletab2, parse_trtab = parse_trtab2, wenzelm@15755: print_trtab = print_trtab2, print_ruletab = print_ruletab2, wenzelm@15755: print_ast_trtab = print_ast_trtab2, tokentrtab = tokentrtab2, prtabs = prtabs2} = tabs2; clasohm@0: in wenzelm@17079: Syntax wenzelm@18921: ({input = Library.merge (op =) (input1, input2), wenzelm@4703: lexicon = Scan.merge_lexicons lexicon1 lexicon2, wenzelm@5692: gram = Parser.merge_grams gram1 gram2, wenzelm@18428: consts = sort_distinct string_ord (consts1 @ consts2), wenzelm@18921: prmodes = Library.merge (op =) (prmodes1, prmodes2), wenzelm@237: parse_ast_trtab = wenzelm@15755: merge_trtabs "parse ast translation" parse_ast_trtab1 parse_ast_trtab2, wenzelm@237: parse_ruletab = merge_ruletabs parse_ruletab1 parse_ruletab2, wenzelm@15755: parse_trtab = merge_trtabs "parse translation" parse_trtab1 parse_trtab2, wenzelm@5692: print_trtab = merge_tr'tabs print_trtab1 print_trtab2, wenzelm@237: print_ruletab = merge_ruletabs print_ruletab1 print_ruletab2, wenzelm@5692: print_ast_trtab = merge_tr'tabs print_ast_trtab1 print_ast_trtab2, wenzelm@2700: tokentrtab = merge_tokentrtabs tokentrtab1 tokentrtab2, wenzelm@17079: prtabs = Printer.merge_prtabs prtabs1 prtabs2}, stamp ()) clasohm@0: end; clasohm@0: clasohm@0: wenzelm@18720: (* basic syntax *) wenzelm@260: wenzelm@18720: val basic_syn = wenzelm@17168: empty_syntax wenzelm@17168: |> extend_syntax default_mode TypeExt.type_ext wenzelm@17168: |> extend_syntax default_mode SynExt.pure_ext; wenzelm@260: wenzelm@18720: val basic_nonterms = wenzelm@18720: (Lexicon.terminals @ [SynExt.logic, "type", "types", "sort", "classes", wenzelm@18720: SynExt.args, SynExt.cargs, "pttrn", "pttrns", "idt", "idts", "aprop", wenzelm@18720: "asms", SynExt.any, SynExt.sprop, "num_const", "index", "struct"]); wenzelm@18720: wenzelm@18720: val appl_syntax = wenzelm@18720: [("_appl", "[('b => 'a), args] => logic", Mixfix.Mixfix ("(1_/(1'(_')))", [1000, 0], 1000)), wenzelm@18720: ("_appl", "[('b => 'a), args] => aprop", Mixfix.Mixfix ("(1_/(1'(_')))", [1000, 0], 1000))]; wenzelm@18720: wenzelm@18720: val applC_syntax = wenzelm@18720: [("", "'a => cargs", Mixfix.Delimfix "_"), wenzelm@18720: ("_cargs", "['a, cargs] => cargs", Mixfix.Mixfix ("_/ _", [1000, 1000], 1000)), wenzelm@18720: ("_applC", "[('b => 'a), cargs] => logic", Mixfix.Mixfix ("(1_/ _)", [1000, 1000], 999)), wenzelm@18720: ("_applC", "[('b => 'a), cargs] => aprop", Mixfix.Mixfix ("(1_/ _)", [1000, 1000], 999))]; wenzelm@18720: clasohm@0: wenzelm@4887: wenzelm@15759: (** print syntax **) wenzelm@15759: wenzelm@15759: local clasohm@0: wenzelm@260: fun pretty_strs_qs name strs = berghofe@14598: Pretty.strs (name :: map Library.quote (sort_strings strs)); clasohm@0: wenzelm@17079: fun pretty_gram (Syntax (tabs, _)) = clasohm@0: let wenzelm@14904: val {lexicon, prmodes, gram, prtabs, ...} = tabs; wenzelm@2913: val prmodes' = sort_strings (filter_out (equal "") prmodes); clasohm@0: in wenzelm@8720: [pretty_strs_qs "lexicon:" (Scan.dest_lexicon lexicon), wenzelm@8720: Pretty.big_list "prods:" (Parser.pretty_gram gram), wenzelm@8720: pretty_strs_qs "print modes:" prmodes'] clasohm@0: end; clasohm@0: wenzelm@17079: fun pretty_trans (Syntax (tabs, _)) = clasohm@0: let wenzelm@260: fun pretty_trtab name tab = wenzelm@5692: pretty_strs_qs name (Symtab.keys tab); clasohm@0: wenzelm@260: fun pretty_ruletab name tab = wenzelm@5692: Pretty.big_list name (map Ast.pretty_rule (dest_ruletab tab)); clasohm@0: berghofe@14598: fun pretty_tokentr (mode, trs) = Pretty.strs (Library.quote mode ^ ":" :: map fst trs); wenzelm@4703: wenzelm@237: val {consts, parse_ast_trtab, parse_ruletab, parse_trtab, print_trtab, wenzelm@4703: print_ruletab, print_ast_trtab, tokentrtab, ...} = tabs; clasohm@0: in wenzelm@8720: [pretty_strs_qs "consts:" consts, wenzelm@8720: pretty_trtab "parse_ast_translation:" parse_ast_trtab, wenzelm@8720: pretty_ruletab "parse_rules:" parse_ruletab, wenzelm@8720: pretty_trtab "parse_translation:" parse_trtab, wenzelm@8720: pretty_trtab "print_translation:" print_trtab, wenzelm@8720: pretty_ruletab "print_rules:" print_ruletab, wenzelm@8720: pretty_trtab "print_ast_translation:" print_ast_trtab, wenzelm@8720: Pretty.big_list "token_translation:" (map pretty_tokentr tokentrtab)] clasohm@0: end; clasohm@0: wenzelm@15759: in clasohm@0: wenzelm@15759: fun print_gram syn = Pretty.writeln (Pretty.chunks (pretty_gram syn)); wenzelm@15759: fun print_trans syn = Pretty.writeln (Pretty.chunks (pretty_trans syn)); wenzelm@15759: fun print_syntax syn = Pretty.writeln (Pretty.chunks (pretty_gram syn @ pretty_trans syn)); clasohm@0: wenzelm@15759: end; clasohm@0: clasohm@0: clasohm@0: wenzelm@237: (** read **) wenzelm@18: wenzelm@260: (* read_ast *) wenzelm@260: clasohm@882: val ambiguity_level = ref 1; wenzelm@15755: val ambiguity_is_error = ref false clasohm@882: wenzelm@18857: fun read_asts context is_logtype (Syntax (tabs, _)) xids root str = wenzelm@260: let wenzelm@14904: val {lexicon, gram, parse_ast_trtab, ...} = tabs; wenzelm@14904: val root' = if root <> "prop" andalso is_logtype root then SynExt.logic else root; wenzelm@4703: val chars = Symbol.explode str; wenzelm@5692: val pts = Parser.parse gram root' (Lexicon.tokenize lexicon xids chars); clasohm@330: wenzelm@12292: fun show_pt pt = wenzelm@18857: Pretty.string_of (Ast.pretty_ast (hd (SynTrans.pts_to_asts context (K NONE) [pt]))); wenzelm@260: in wenzelm@16613: conditional (length pts > ! ambiguity_level) (fn () => wenzelm@16613: if ! ambiguity_is_error then error ("Ambiguous input " ^ quote str) wenzelm@16661: else (warning ("Ambiguous input " ^ quote str ^ "\n" ^ wenzelm@16716: "produces " ^ string_of_int (length pts) ^ " parse trees."); wenzelm@16669: List.app (warning o show_pt) pts)); wenzelm@18857: SynTrans.pts_to_asts context (lookup_tr parse_ast_trtab) pts wenzelm@260: end; wenzelm@260: wenzelm@260: wenzelm@237: (* read *) clasohm@0: wenzelm@18857: fun read context is_logtype (syn as Syntax (tabs, _)) ty str = clasohm@0: let wenzelm@237: val {parse_ruletab, parse_trtab, ...} = tabs; wenzelm@18857: val asts = read_asts context is_logtype syn false (SynExt.typ_to_nonterm ty) str; clasohm@0: in wenzelm@18857: SynTrans.asts_to_terms context (lookup_tr parse_trtab) wenzelm@18931: (map (Ast.normalize_ast (Symtab.lookup_list parse_ruletab)) asts) clasohm@0: end; clasohm@0: clasohm@0: wenzelm@237: (* read types *) clasohm@0: wenzelm@18857: fun read_typ context syn get_sort map_sort str = wenzelm@18857: (case read context (K false) syn SynExt.typeT str of wenzelm@12316: [t] => TypeExt.typ_of_term (get_sort (TypeExt.raw_term_sorts t)) map_sort t wenzelm@8894: | _ => error "read_typ: ambiguous syntax"); wenzelm@144: wenzelm@144: wenzelm@8894: (* read sorts *) wenzelm@8894: wenzelm@18857: fun read_sort context syn str = wenzelm@18857: (case read context (K false) syn TypeExt.sortT str of wenzelm@8894: [t] => TypeExt.sort_of_term t wenzelm@8894: | _ => error "read_sort: ambiguous syntax"); wenzelm@8894: wenzelm@8894: wenzelm@18: wenzelm@1158: (** prepare translation rules **) wenzelm@1158: wenzelm@1158: datatype 'a trrule = wenzelm@3526: ParseRule of 'a * 'a | wenzelm@3526: PrintRule of 'a * 'a | wenzelm@3526: ParsePrintRule of 'a * 'a; wenzelm@888: wenzelm@4618: fun map_trrule f (ParseRule (x, y)) = ParseRule (f x, f y) wenzelm@4618: | map_trrule f (PrintRule (x, y)) = PrintRule (f x, f y) wenzelm@4618: | map_trrule f (ParsePrintRule (x, y)) = ParsePrintRule (f x, f y); wenzelm@1158: skalberg@15531: fun parse_rule (ParseRule pats) = SOME pats skalberg@15531: | parse_rule (PrintRule _) = NONE skalberg@15531: | parse_rule (ParsePrintRule pats) = SOME pats; wenzelm@1158: skalberg@15531: fun print_rule (ParseRule _) = NONE skalberg@15531: | print_rule (PrintRule pats) = SOME (swap pats) skalberg@15531: | print_rule (ParsePrintRule pats) = SOME (swap pats); wenzelm@1158: wenzelm@1158: wenzelm@19262: local wenzelm@19262: wenzelm@1158: fun check_rule (rule as (lhs, rhs)) = wenzelm@5692: (case Ast.rule_error rule of skalberg@15531: SOME msg => wenzelm@1158: error ("Error in syntax translation rule: " ^ msg ^ "\n" ^ wenzelm@5692: Ast.str_of_ast lhs ^ " -> " ^ Ast.str_of_ast rhs) skalberg@15531: | NONE => rule); wenzelm@888: wenzelm@888: wenzelm@18857: fun read_pattern context is_logtype syn (root, str) = wenzelm@18: let wenzelm@17079: val Syntax ({consts, ...}, _) = syn; wenzelm@18: wenzelm@5692: fun constify (ast as Ast.Constant _) = ast wenzelm@5692: | constify (ast as Ast.Variable x) = wenzelm@20664: if member (op =) consts x orelse NameSpace.is_qualified x then Ast.Constant x wenzelm@3830: else ast wenzelm@5692: | constify (Ast.Appl asts) = Ast.Appl (map constify asts); wenzelm@18: in wenzelm@18857: (case read_asts context is_logtype syn true root str of wenzelm@888: [ast] => constify ast wenzelm@888: | _ => error ("Syntactically ambiguous input: " ^ quote str)) wenzelm@18678: end handle ERROR msg => wenzelm@18678: cat_error msg ("The error(s) above occurred in translation pattern " ^ wenzelm@888: quote str); clasohm@0: wenzelm@1158: fun prep_rules rd_pat raw_rules = wenzelm@4618: let val rules = map (map_trrule rd_pat) raw_rules in wenzelm@19482: (map check_rule (map_filter parse_rule rules), wenzelm@19482: map check_rule (map_filter print_rule rules)) wenzelm@1158: end wenzelm@18: wenzelm@19262: in wenzelm@19262: wenzelm@19262: val cert_rules = prep_rules I; wenzelm@19262: wenzelm@19262: fun read_rules context is_logtype syn = wenzelm@19262: prep_rules (read_pattern context is_logtype syn); wenzelm@19262: wenzelm@19262: end; wenzelm@19262: wenzelm@18: wenzelm@18: wenzelm@3779: (** pretty terms, typs, sorts **) wenzelm@18: wenzelm@18857: fun pretty_t t_to_ast prt_t context (syn as Syntax (tabs, _)) curried t = clasohm@0: let wenzelm@2700: val {print_trtab, print_ruletab, print_ast_trtab, tokentrtab, prtabs, ...} = tabs; wenzelm@18857: val ast = t_to_ast context (lookup_tr' print_trtab) t; clasohm@0: in wenzelm@18857: prt_t context curried prtabs (lookup_tr' print_ast_trtab) oheimb@6167: (lookup_tokentr tokentrtab (! print_mode)) wenzelm@18931: (Ast.normalize_ast (Symtab.lookup_list print_ruletab) ast) clasohm@0: end; clasohm@0: wenzelm@19375: val pretty_term = pretty_t Printer.term_to_ast o Printer.pretty_term_ast; wenzelm@18857: fun pretty_typ context syn = pretty_t Printer.typ_to_ast Printer.pretty_typ_ast context syn false; wenzelm@18857: fun pretty_sort context syn = pretty_t Printer.sort_to_ast Printer.pretty_typ_ast context syn false; clasohm@0: clasohm@0: clasohm@0: wenzelm@19262: (** modify syntax **) wenzelm@383: wenzelm@14904: fun ext_syntax' f is_logtype prmode decls = extend_syntax prmode (f is_logtype decls); wenzelm@14904: fun ext_syntax f = ext_syntax' (K f) (K false) default_mode; wenzelm@383: wenzelm@16613: val extend_type_gram = ext_syntax Mixfix.syn_ext_types; wenzelm@16613: val extend_const_gram = ext_syntax' Mixfix.syn_ext_consts; wenzelm@16613: val extend_consts = ext_syntax SynExt.syn_ext_const_names; wenzelm@16613: val extend_trfuns = ext_syntax SynExt.syn_ext_trfuns; wenzelm@16613: val extend_advanced_trfuns = ext_syntax SynExt.syn_ext_advanced_trfuns; wenzelm@16613: val extend_tokentrfuns = ext_syntax SynExt.syn_ext_tokentrfuns; wenzelm@5692: wenzelm@15755: fun remove_const_gram is_logtype prmode decls = wenzelm@15755: remove_syntax prmode (Mixfix.syn_ext_consts is_logtype decls); wenzelm@15755: wenzelm@19262: fun extend_trrules context is_logtype syn = wenzelm@19262: ext_syntax SynExt.syn_ext_rules o read_rules context is_logtype syn; wenzelm@19262: wenzelm@19262: fun remove_trrules context is_logtype syn = wenzelm@19262: remove_syntax default_mode o SynExt.syn_ext_rules o read_rules context is_logtype syn; wenzelm@19262: wenzelm@19262: val extend_trrules_i = ext_syntax SynExt.syn_ext_rules o cert_rules; wenzelm@19262: val remove_trrules_i = remove_syntax default_mode o SynExt.syn_ext_rules o cert_rules; wenzelm@5692: wenzelm@5692: wenzelm@15833: (*export parts of internal Syntax structures*) wenzelm@15833: open Lexicon SynExt Ast Parser TypeExt SynTrans Mixfix Printer; wenzelm@2366: clasohm@0: end; wenzelm@5692: wenzelm@5692: structure BasicSyntax: BASIC_SYNTAX = Syntax; wenzelm@5692: open BasicSyntax;