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@15755: val default_mode: string * bool wenzelm@12073: val extend_type_gram: (string * int * mixfix) list -> syntax -> syntax wenzelm@14904: val extend_const_gram: (string -> bool) -> wenzelm@14904: string * bool -> (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@16613: (string * ((theory -> ast list -> ast) * stamp)) list * wenzelm@16613: (string * ((theory -> term list -> term) * stamp)) list * wenzelm@16613: (string * ((theory -> bool -> typ -> term list -> term) * stamp)) list * wenzelm@16613: (string * ((theory -> ast list -> ast) * stamp)) list -> syntax -> syntax wenzelm@15755: val extend_tokentrfuns: (string * string * (string -> string * real)) list -> syntax -> syntax wenzelm@12073: val extend_trrules_i: ast trrule list -> syntax -> syntax wenzelm@16613: val extend_trrules: theory -> (string -> bool) -> syntax -> wenzelm@14904: (string * string) trrule list -> syntax -> syntax wenzelm@15755: val remove_const_gram: (string -> bool) -> wenzelm@15755: string * bool -> (string * typ * mixfix) list -> syntax -> syntax wenzelm@4618: val map_trrule: ('a -> 'b) -> 'a trrule -> 'b trrule wenzelm@556: val merge_syntaxes: syntax -> syntax -> syntax clasohm@764: val pure_syn: syntax wenzelm@556: val print_gram: syntax -> unit wenzelm@556: val print_trans: syntax -> unit wenzelm@556: val print_syntax: syntax -> unit wenzelm@16613: val read: theory -> (string -> bool) -> syntax -> typ -> string -> term list wenzelm@16613: val read_typ: theory -> syntax -> ((indexname * sort) list -> indexname -> sort) -> wenzelm@16613: (sort -> sort) -> string -> typ wenzelm@16613: val read_sort: theory -> syntax -> string -> sort wenzelm@16613: val pretty_term: theory -> syntax -> bool -> term -> Pretty.T wenzelm@16613: val pretty_typ: theory -> syntax -> typ -> Pretty.T wenzelm@16613: val pretty_sort: theory -> 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@15755: fun extend_trtab name trfuns tab = Symtab.extend (tab, trfuns) wenzelm@15755: handle Symtab.DUPS cs => err_dup_trfuns name cs; wenzelm@237: wenzelm@15759: fun remove_trtab trfuns = fold (Symtab.remove SynExt.eq_trfun) trfuns; wenzelm@15755: 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@17412: fun lookup_tr' tab c = map fst (Symtab.lookup_multi tab c); wenzelm@17412: fun extend_tr'tab trfuns = fold_rev Symtab.update_multi trfuns; wenzelm@15759: fun remove_tr'tab trfuns = fold (Symtab.remove_multi SynExt.eq_trfun) trfuns; wenzelm@15755: fun merge_tr'tabs tab1 tab2 = Symtab.merge_multi' 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 = haftmann@17496: let val trs = gen_distinct (eq_fst (op =)) haftmann@17192: (List.concat (map (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@2700: val trs = gen_distinct eq_tr (trs1 @ trs2); wenzelm@2700: in haftmann@17496: (case gen_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@2700: in wenzelm@2700: map merge (distinct (map fst (tabs1 @ tabs2))) wenzelm@2700: 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: skalberg@15570: fun dest_ruletab tab = List.concat (map snd (Symtab.dest tab)); wenzelm@237: wenzelm@237: wenzelm@237: (* empty, extend, merge ruletabs *) wenzelm@237: wenzelm@17412: val extend_ruletab = fold_rev (fn r => Symtab.update_multi (Ast.head_of_rule r, r)); wenzelm@15759: val remove_ruletab = fold (fn r => Symtab.remove_multi (op =) (Ast.head_of_rule r, r)); wenzelm@12292: fun merge_ruletabs tab1 tab2 = Symtab.merge_multi' (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@16613: parse_ast_trtab: ((theory -> Ast.ast list -> Ast.ast) * stamp) Symtab.table, wenzelm@237: parse_ruletab: ruletab, wenzelm@16613: parse_trtab: ((theory -> term list -> term) * stamp) Symtab.table, wenzelm@16613: print_trtab: ((theory -> bool -> typ -> term list -> term) * stamp) list Symtab.table, wenzelm@237: print_ruletab: ruletab, wenzelm@16613: print_ast_trtab: ((theory -> 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@15755: val default_mode = ("", 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@167: in wenzelm@17079: Syntax wenzelm@17079: ({input = if inout then xprods @ input else input, wenzelm@5692: lexicon = if inout then Scan.extend_lexicon lexicon (SynExt.delims_of xprods) else lexicon, wenzelm@5692: gram = if inout then Parser.extend_gram gram xprods else gram, wenzelm@15755: consts = merge_lists' consts1 consts2, wenzelm@15755: prmodes = mode ins_string (merge_lists' prmodes1 prmodes2), wenzelm@167: parse_ast_trtab = wenzelm@15755: extend_trtab "parse ast translation" parse_ast_translation parse_ast_trtab, wenzelm@15755: parse_ruletab = extend_ruletab parse_rules parse_ruletab, wenzelm@15755: parse_trtab = extend_trtab "parse translation" 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@15759: val input' = if inout then fold (remove (op =)) xprods input else input; 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@15755: parse_ast_trtab = remove_trtab parse_ast_translation parse_ast_trtab, wenzelm@15755: parse_ruletab = remove_ruletab parse_rules parse_ruletab, wenzelm@15755: parse_trtab = remove_trtab 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@17079: ({input = merge_lists' 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@2913: prmodes = merge_lists 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@17168: (* pure_syn *) wenzelm@260: wenzelm@17168: val pure_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: 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@17079: fun read_asts thy 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@16613: Pretty.string_of (Ast.pretty_ast (hd (SynTrans.pts_to_asts thy (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@16613: SynTrans.pts_to_asts thy (lookup_tr parse_ast_trtab) pts wenzelm@260: end; wenzelm@260: wenzelm@260: wenzelm@237: (* read *) clasohm@0: wenzelm@17079: fun read thy is_logtype (syn as Syntax (tabs, _)) ty str = clasohm@0: let wenzelm@237: val {parse_ruletab, parse_trtab, ...} = tabs; wenzelm@16613: val asts = read_asts thy is_logtype syn false (SynExt.typ_to_nonterm ty) str; clasohm@0: in wenzelm@16613: SynTrans.asts_to_terms thy (lookup_tr parse_trtab) wenzelm@17412: (map (Ast.normalize_ast (Symtab.lookup_multi parse_ruletab)) asts) clasohm@0: end; clasohm@0: clasohm@0: wenzelm@237: (* read types *) clasohm@0: wenzelm@16613: fun read_typ thy syn get_sort map_sort str = wenzelm@16613: (case read thy (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@16613: fun read_sort thy syn str = wenzelm@16613: (case read thy (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@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@16613: fun read_pattern thy 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@8720: if x mem consts 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@16613: (case read_asts thy 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@556: wenzelm@1158: fun prep_rules rd_pat raw_rules = wenzelm@4618: let val rules = map (map_trrule rd_pat) raw_rules in skalberg@15570: (map check_rule (List.mapPartial parse_rule rules), skalberg@15570: map check_rule (List.mapPartial print_rule rules)) wenzelm@1158: end wenzelm@18: wenzelm@18: wenzelm@18: wenzelm@3779: (** pretty terms, typs, sorts **) wenzelm@18: wenzelm@17079: fun pretty_t t_to_ast prt_t thy (syn as Syntax (tabs, _)) curried t = clasohm@0: let wenzelm@2700: val {print_trtab, print_ruletab, print_ast_trtab, tokentrtab, prtabs, ...} = tabs; wenzelm@16613: val ast = t_to_ast thy (lookup_tr' print_trtab) t; clasohm@0: in wenzelm@16613: prt_t thy curried prtabs (lookup_tr' print_ast_trtab) oheimb@6167: (lookup_tokentr tokentrtab (! print_mode)) wenzelm@17412: (Ast.normalize_ast (Symtab.lookup_multi print_ruletab) ast) clasohm@0: end; clasohm@0: wenzelm@5692: val pretty_term = pretty_t Printer.term_to_ast Printer.pretty_term_ast; wenzelm@16613: fun pretty_typ thy syn = pretty_t Printer.typ_to_ast Printer.pretty_typ_ast thy syn false; wenzelm@16613: fun pretty_sort thy syn = pretty_t Printer.sort_to_ast Printer.pretty_typ_ast thy syn false; clasohm@0: clasohm@0: clasohm@0: wenzelm@14904: (** extend 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@16613: val extend_trrules_i = ext_syntax SynExt.syn_ext_rules o prep_rules I; wenzelm@383: wenzelm@16613: fun extend_trrules thy is_logtype syn rules = wenzelm@14904: ext_syntax' (K SynExt.syn_ext_rules) (K false) default_mode wenzelm@16613: (prep_rules (read_pattern thy is_logtype syn) rules); 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@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;