1 (* Title: Pure/Syntax/syntax.ML
3 Author: Tobias Nipkow and Markus Wenzel, TU Muenchen
5 Root of Isabelle's syntax module.
8 signature BASIC_SYNTAX =
25 val extend_trtab: string -> (string * ('a * stamp)) list ->
26 ('a * stamp) Symtab.table -> ('a * stamp) Symtab.table
27 val merge_trtabs: string -> ('a * stamp) Symtab.table -> ('a * stamp) Symtab.table ->
28 ('a * stamp) Symtab.table
29 val merge_tr'tabs: ('a * stamp) list Symtab.table -> ('a * stamp) list Symtab.table
30 -> ('a * stamp) list Symtab.table
31 val extend_tr'tab: (string * ('a * stamp)) list ->
32 ('a * stamp) list Symtab.table -> ('a * stamp) list Symtab.table
34 ParseRule of 'a * 'a |
35 PrintRule of 'a * 'a |
36 ParsePrintRule of 'a * 'a
38 val eq_syntax: syntax * syntax -> bool
39 val is_keyword: syntax -> string -> bool
40 val default_mode: string * bool
41 val extend_type_gram: (string * int * mixfix) list -> syntax -> syntax
42 val extend_const_gram: (string -> bool) ->
43 string * bool -> (string * typ * mixfix) list -> syntax -> syntax
44 val extend_consts: string list -> syntax -> syntax
46 (string * ((ast list -> ast) * stamp)) list *
47 (string * ((term list -> term) * stamp)) list *
48 (string * ((bool -> typ -> term list -> term) * stamp)) list *
49 (string * ((ast list -> ast) * stamp)) list -> syntax -> syntax
50 val extend_advanced_trfuns:
51 (string * ((Context.generic -> ast list -> ast) * stamp)) list *
52 (string * ((Context.generic -> term list -> term) * stamp)) list *
53 (string * ((Context.generic -> bool -> typ -> term list -> term) * stamp)) list *
54 (string * ((Context.generic -> ast list -> ast) * stamp)) list -> syntax -> syntax
55 val extend_tokentrfuns: (string * string * (string -> string * real)) list -> syntax -> syntax
56 val remove_const_gram: (string -> bool) ->
57 string * bool -> (string * typ * mixfix) list -> syntax -> syntax
58 val extend_trrules: Context.generic -> (string -> bool) -> syntax ->
59 (string * string) trrule list -> syntax -> syntax
60 val remove_trrules: Context.generic -> (string -> bool) -> syntax ->
61 (string * string) trrule list -> syntax -> syntax
62 val extend_trrules_i: ast trrule list -> syntax -> syntax
63 val remove_trrules_i: ast trrule list -> syntax -> syntax
64 val map_trrule: ('a -> 'b) -> 'a trrule -> 'b trrule
65 val merge_syntaxes: syntax -> syntax -> syntax
67 val basic_nonterms: string list
68 val appl_syntax: (string * string * mixfix) list
69 val applC_syntax: (string * string * mixfix) list
70 val print_gram: syntax -> unit
71 val print_trans: syntax -> unit
72 val print_syntax: syntax -> unit
73 val read: Context.generic -> (string -> bool) -> syntax -> typ -> string -> term list
74 val read_typ: Context.generic -> syntax -> ((indexname * sort) list -> indexname -> sort) ->
75 (sort -> sort) -> string -> typ
76 val read_sort: Context.generic -> syntax -> string -> sort
77 val pretty_term: (string -> xstring) -> Context.generic -> syntax -> bool -> term -> Pretty.T
78 val pretty_typ: Context.generic -> syntax -> typ -> Pretty.T
79 val pretty_sort: Context.generic -> syntax -> sort -> Pretty.T
80 val ambiguity_level: int ref
81 val ambiguity_is_error: bool ref
84 structure Syntax: SYNTAX =
87 (** tables of translation functions **)
89 (* parse (ast) translations *)
91 fun lookup_tr tab c = Option.map fst (Symtab.lookup tab c);
93 fun err_dup_trfuns name cs =
94 error ("More than one " ^ name ^ " for " ^ commas_quote cs);
96 fun extend_trtab name trfuns tab = Symtab.extend (tab, trfuns)
97 handle Symtab.DUPS cs => err_dup_trfuns name cs;
99 fun remove_trtab trfuns = fold (Symtab.remove SynExt.eq_trfun) trfuns;
101 fun merge_trtabs name tab1 tab2 = Symtab.merge SynExt.eq_trfun (tab1, tab2)
102 handle Symtab.DUPS cs => err_dup_trfuns name cs;
105 (* print (ast) translations *)
107 fun lookup_tr' tab c = map fst (Symtab.lookup_list tab c);
108 fun extend_tr'tab trfuns = fold_rev Symtab.update_list trfuns;
109 fun remove_tr'tab trfuns = fold (Symtab.remove_list SynExt.eq_trfun) trfuns;
110 fun merge_tr'tabs tab1 tab2 = Symtab.merge_list SynExt.eq_trfun (tab1, tab2);
114 (** tables of token translation functions **)
116 fun lookup_tokentr tabs modes =
117 let val trs = distinct (eq_fst (op =)) (maps (these o AList.lookup (op =) tabs) (modes @ [""]))
118 in fn c => Option.map fst (AList.lookup (op =) trs c) end;
120 fun merge_tokentrtabs tabs1 tabs2 =
122 fun eq_tr ((c1, (_, s1)), (c2, (_, s2))) = c1 = c2 andalso s1 = s2;
124 fun name (s, _) = implode (tl (Symbol.explode s));
128 val trs1 = these (AList.lookup (op =) tabs1 mode);
129 val trs2 = these (AList.lookup (op =) tabs2 mode);
130 val trs = distinct eq_tr (trs1 @ trs2);
132 (case duplicates (eq_fst (op =)) trs of
134 | dups => error ("More than one token translation function in mode " ^
135 quote mode ^ " for " ^ commas_quote (map name dups)))
137 in map merge (distinct (op =) (map fst (tabs1 @ tabs2))) end;
139 fun extend_tokentrtab tokentrs tabs =
141 fun ins_tokentr (m, c, f) =
142 AList.default (op =) (m, [])
143 #> AList.map_entry (op =) m (cons ("_" ^ c, (f, stamp ())));
144 in merge_tokentrtabs tabs (fold ins_tokentr tokentrs []) end;
148 (** tables of translation rules **)
150 type ruletab = (Ast.ast * Ast.ast) list Symtab.table;
152 fun dest_ruletab tab = maps snd (Symtab.dest tab);
155 (* empty, extend, merge ruletabs *)
157 val extend_ruletab = fold_rev (fn r => Symtab.update_list (Ast.head_of_rule r, r));
158 val remove_ruletab = fold (fn r => Symtab.remove_list (op =) (Ast.head_of_rule r, r));
159 fun merge_ruletabs tab1 tab2 = Symtab.merge_list (op =) (tab1, tab2);
163 (** datatype syntax **)
167 input: SynExt.xprod list,
168 lexicon: Scan.lexicon,
171 prmodes: string list,
172 parse_ast_trtab: ((Context.generic -> Ast.ast list -> Ast.ast) * stamp) Symtab.table,
173 parse_ruletab: ruletab,
174 parse_trtab: ((Context.generic -> term list -> term) * stamp) Symtab.table,
175 print_trtab: ((Context.generic -> bool -> typ -> term list -> term) * stamp) list Symtab.table,
176 print_ruletab: ruletab,
177 print_ast_trtab: ((Context.generic -> Ast.ast list -> Ast.ast) * stamp) list Symtab.table,
178 tokentrtab: (string * (string * ((string -> string * real) * stamp)) list) list,
179 prtabs: Printer.prtabs} * stamp;
181 fun eq_syntax (Syntax (_, s1), Syntax (_, s2)) = s1 = s2;
183 fun is_keyword (Syntax ({lexicon, ...}, _)) = Scan.is_literal lexicon o Symbol.explode;
185 val default_mode = ("", true);
190 val empty_syntax = Syntax
192 lexicon = Scan.empty_lexicon,
193 gram = Parser.empty_gram,
196 parse_ast_trtab = Symtab.empty,
197 parse_ruletab = Symtab.empty,
198 parse_trtab = Symtab.empty,
199 print_trtab = Symtab.empty,
200 print_ruletab = Symtab.empty,
201 print_ast_trtab = Symtab.empty,
203 prtabs = Printer.empty_prtabs}, stamp ());
208 fun extend_syntax (mode, inout) syn_ext (Syntax (tabs, _)) =
210 val {input, lexicon, gram, consts = consts1, prmodes = prmodes1,
211 parse_ast_trtab, parse_ruletab, parse_trtab, print_trtab, print_ruletab,
212 print_ast_trtab, tokentrtab, prtabs} = tabs;
213 val SynExt.SynExt {xprods, consts = consts2, prmodes = prmodes2,
214 parse_ast_translation, parse_rules, parse_translation, print_translation, print_rules,
215 print_ast_translation, token_translation} = syn_ext;
218 ({input = if inout then xprods @ input else input,
219 lexicon = if inout then Scan.extend_lexicon lexicon (SynExt.delims_of xprods) else lexicon,
220 gram = if inout then Parser.extend_gram gram xprods else gram,
221 consts = Library.merge (op =) (consts1, consts2),
222 prmodes = insert (op =) mode (Library.merge (op =) (prmodes1, prmodes2)),
224 extend_trtab "parse ast translation" parse_ast_translation parse_ast_trtab,
225 parse_ruletab = extend_ruletab parse_rules parse_ruletab,
226 parse_trtab = extend_trtab "parse translation" parse_translation parse_trtab,
227 print_trtab = extend_tr'tab print_translation print_trtab,
228 print_ruletab = extend_ruletab print_rules print_ruletab,
229 print_ast_trtab = extend_tr'tab print_ast_translation print_ast_trtab,
230 tokentrtab = extend_tokentrtab token_translation tokentrtab,
231 prtabs = Printer.extend_prtabs mode xprods prtabs}, stamp ())
237 fun remove_syntax (mode, inout) syn_ext (Syntax (tabs, _)) =
239 val SynExt.SynExt {xprods, consts = _, prmodes = _,
240 parse_ast_translation, parse_rules, parse_translation, print_translation, print_rules,
241 print_ast_translation, token_translation = _} = syn_ext;
242 val {input, lexicon, gram, consts, prmodes,
243 parse_ast_trtab, parse_ruletab, parse_trtab, print_trtab, print_ruletab,
244 print_ast_trtab, tokentrtab, prtabs} = tabs;
245 val input' = if inout then subtract (op =) xprods input else input;
249 lexicon = if inout then Scan.make_lexicon (SynExt.delims_of input') else lexicon,
250 gram = if inout then Parser.make_gram input' else gram,
253 parse_ast_trtab = remove_trtab parse_ast_translation parse_ast_trtab,
254 parse_ruletab = remove_ruletab parse_rules parse_ruletab,
255 parse_trtab = remove_trtab parse_translation parse_trtab,
256 print_trtab = remove_tr'tab print_translation print_trtab,
257 print_ruletab = remove_ruletab print_rules print_ruletab,
258 print_ast_trtab = remove_tr'tab print_ast_translation print_ast_trtab,
259 tokentrtab = tokentrtab,
260 prtabs = Printer.remove_prtabs mode xprods prtabs}, stamp ())
266 fun merge_syntaxes (Syntax (tabs1, _)) (Syntax (tabs2, _)) =
268 val {input = input1, lexicon = lexicon1, gram = gram1, consts = consts1,
269 prmodes = prmodes1, parse_ast_trtab = parse_ast_trtab1,
270 parse_ruletab = parse_ruletab1, parse_trtab = parse_trtab1,
271 print_trtab = print_trtab1, print_ruletab = print_ruletab1,
272 print_ast_trtab = print_ast_trtab1, tokentrtab = tokentrtab1, prtabs = prtabs1} = tabs1;
274 val {input = input2, lexicon = lexicon2, gram = gram2, consts = consts2,
275 prmodes = prmodes2, parse_ast_trtab = parse_ast_trtab2,
276 parse_ruletab = parse_ruletab2, parse_trtab = parse_trtab2,
277 print_trtab = print_trtab2, print_ruletab = print_ruletab2,
278 print_ast_trtab = print_ast_trtab2, tokentrtab = tokentrtab2, prtabs = prtabs2} = tabs2;
281 ({input = Library.merge (op =) (input1, input2),
282 lexicon = Scan.merge_lexicons lexicon1 lexicon2,
283 gram = Parser.merge_grams gram1 gram2,
284 consts = sort_distinct string_ord (consts1 @ consts2),
285 prmodes = Library.merge (op =) (prmodes1, prmodes2),
287 merge_trtabs "parse ast translation" parse_ast_trtab1 parse_ast_trtab2,
288 parse_ruletab = merge_ruletabs parse_ruletab1 parse_ruletab2,
289 parse_trtab = merge_trtabs "parse translation" parse_trtab1 parse_trtab2,
290 print_trtab = merge_tr'tabs print_trtab1 print_trtab2,
291 print_ruletab = merge_ruletabs print_ruletab1 print_ruletab2,
292 print_ast_trtab = merge_tr'tabs print_ast_trtab1 print_ast_trtab2,
293 tokentrtab = merge_tokentrtabs tokentrtab1 tokentrtab2,
294 prtabs = Printer.merge_prtabs prtabs1 prtabs2}, stamp ())
302 |> extend_syntax default_mode TypeExt.type_ext
303 |> extend_syntax default_mode SynExt.pure_ext;
306 (Lexicon.terminals @ [SynExt.logic, "type", "types", "sort", "classes",
307 SynExt.args, SynExt.cargs, "pttrn", "pttrns", "idt", "idts", "aprop",
308 "asms", SynExt.any, SynExt.sprop, "num_const", "index", "struct"]);
311 [("_appl", "[('b => 'a), args] => logic", Mixfix.Mixfix ("(1_/(1'(_')))", [1000, 0], 1000)),
312 ("_appl", "[('b => 'a), args] => aprop", Mixfix.Mixfix ("(1_/(1'(_')))", [1000, 0], 1000))];
315 [("", "'a => cargs", Mixfix.Delimfix "_"),
316 ("_cargs", "['a, cargs] => cargs", Mixfix.Mixfix ("_/ _", [1000, 1000], 1000)),
317 ("_applC", "[('b => 'a), cargs] => logic", Mixfix.Mixfix ("(1_/ _)", [1000, 1000], 999)),
318 ("_applC", "[('b => 'a), cargs] => aprop", Mixfix.Mixfix ("(1_/ _)", [1000, 1000], 999))];
326 fun pretty_strs_qs name strs =
327 Pretty.strs (name :: map Library.quote (sort_strings strs));
329 fun pretty_gram (Syntax (tabs, _)) =
331 val {lexicon, prmodes, gram, prtabs, ...} = tabs;
332 val prmodes' = sort_strings (filter_out (equal "") prmodes);
334 [pretty_strs_qs "lexicon:" (Scan.dest_lexicon lexicon),
335 Pretty.big_list "prods:" (Parser.pretty_gram gram),
336 pretty_strs_qs "print modes:" prmodes']
339 fun pretty_trans (Syntax (tabs, _)) =
341 fun pretty_trtab name tab =
342 pretty_strs_qs name (Symtab.keys tab);
344 fun pretty_ruletab name tab =
345 Pretty.big_list name (map Ast.pretty_rule (dest_ruletab tab));
347 fun pretty_tokentr (mode, trs) = Pretty.strs (Library.quote mode ^ ":" :: map fst trs);
349 val {consts, parse_ast_trtab, parse_ruletab, parse_trtab, print_trtab,
350 print_ruletab, print_ast_trtab, tokentrtab, ...} = tabs;
352 [pretty_strs_qs "consts:" consts,
353 pretty_trtab "parse_ast_translation:" parse_ast_trtab,
354 pretty_ruletab "parse_rules:" parse_ruletab,
355 pretty_trtab "parse_translation:" parse_trtab,
356 pretty_trtab "print_translation:" print_trtab,
357 pretty_ruletab "print_rules:" print_ruletab,
358 pretty_trtab "print_ast_translation:" print_ast_trtab,
359 Pretty.big_list "token_translation:" (map pretty_tokentr tokentrtab)]
364 fun print_gram syn = Pretty.writeln (Pretty.chunks (pretty_gram syn));
365 fun print_trans syn = Pretty.writeln (Pretty.chunks (pretty_trans syn));
366 fun print_syntax syn = Pretty.writeln (Pretty.chunks (pretty_gram syn @ pretty_trans syn));
376 val ambiguity_level = ref 1;
377 val ambiguity_is_error = ref false
379 fun read_asts context is_logtype (Syntax (tabs, _)) xids root str =
381 val {lexicon, gram, parse_ast_trtab, ...} = tabs;
382 val root' = if root <> "prop" andalso is_logtype root then SynExt.logic else root;
383 val chars = Symbol.explode str;
384 val pts = Parser.parse gram root' (Lexicon.tokenize lexicon xids chars);
387 Pretty.string_of (Ast.pretty_ast (hd (SynTrans.pts_to_asts context (K NONE) [pt])));
389 conditional (length pts > ! ambiguity_level) (fn () =>
390 if ! ambiguity_is_error then error ("Ambiguous input " ^ quote str)
391 else (warning ("Ambiguous input " ^ quote str ^ "\n" ^
392 "produces " ^ string_of_int (length pts) ^ " parse trees.");
393 List.app (warning o show_pt) pts));
394 SynTrans.pts_to_asts context (lookup_tr parse_ast_trtab) pts
400 fun read context is_logtype (syn as Syntax (tabs, _)) ty str =
402 val {parse_ruletab, parse_trtab, ...} = tabs;
403 val asts = read_asts context is_logtype syn false (SynExt.typ_to_nonterm ty) str;
405 SynTrans.asts_to_terms context (lookup_tr parse_trtab)
406 (map (Ast.normalize_ast (Symtab.lookup_list parse_ruletab)) asts)
412 fun read_typ context syn get_sort map_sort str =
413 (case read context (K false) syn SynExt.typeT str of
414 [t] => TypeExt.typ_of_term (get_sort (TypeExt.raw_term_sorts t)) map_sort t
415 | _ => error "read_typ: ambiguous syntax");
420 fun read_sort context syn str =
421 (case read context (K false) syn TypeExt.sortT str of
422 [t] => TypeExt.sort_of_term t
423 | _ => error "read_sort: ambiguous syntax");
427 (** prepare translation rules **)
430 ParseRule of 'a * 'a |
431 PrintRule of 'a * 'a |
432 ParsePrintRule of 'a * 'a;
434 fun map_trrule f (ParseRule (x, y)) = ParseRule (f x, f y)
435 | map_trrule f (PrintRule (x, y)) = PrintRule (f x, f y)
436 | map_trrule f (ParsePrintRule (x, y)) = ParsePrintRule (f x, f y);
438 fun parse_rule (ParseRule pats) = SOME pats
439 | parse_rule (PrintRule _) = NONE
440 | parse_rule (ParsePrintRule pats) = SOME pats;
442 fun print_rule (ParseRule _) = NONE
443 | print_rule (PrintRule pats) = SOME (swap pats)
444 | print_rule (ParsePrintRule pats) = SOME (swap pats);
449 fun check_rule (rule as (lhs, rhs)) =
450 (case Ast.rule_error rule of
452 error ("Error in syntax translation rule: " ^ msg ^ "\n" ^
453 Ast.str_of_ast lhs ^ " -> " ^ Ast.str_of_ast rhs)
457 fun read_pattern context is_logtype syn (root, str) =
459 val Syntax ({consts, ...}, _) = syn;
461 fun constify (ast as Ast.Constant _) = ast
462 | constify (ast as Ast.Variable x) =
463 if x mem consts orelse NameSpace.is_qualified x then Ast.Constant x
465 | constify (Ast.Appl asts) = Ast.Appl (map constify asts);
467 (case read_asts context is_logtype syn true root str of
468 [ast] => constify ast
469 | _ => error ("Syntactically ambiguous input: " ^ quote str))
470 end handle ERROR msg =>
471 cat_error msg ("The error(s) above occurred in translation pattern " ^
474 fun prep_rules rd_pat raw_rules =
475 let val rules = map (map_trrule rd_pat) raw_rules in
476 (map check_rule (map_filter parse_rule rules),
477 map check_rule (map_filter print_rule rules))
482 val cert_rules = prep_rules I;
484 fun read_rules context is_logtype syn =
485 prep_rules (read_pattern context is_logtype syn);
491 (** pretty terms, typs, sorts **)
493 fun pretty_t t_to_ast prt_t context (syn as Syntax (tabs, _)) curried t =
495 val {print_trtab, print_ruletab, print_ast_trtab, tokentrtab, prtabs, ...} = tabs;
496 val ast = t_to_ast context (lookup_tr' print_trtab) t;
498 prt_t context curried prtabs (lookup_tr' print_ast_trtab)
499 (lookup_tokentr tokentrtab (! print_mode))
500 (Ast.normalize_ast (Symtab.lookup_list print_ruletab) ast)
503 val pretty_term = pretty_t Printer.term_to_ast o Printer.pretty_term_ast;
504 fun pretty_typ context syn = pretty_t Printer.typ_to_ast Printer.pretty_typ_ast context syn false;
505 fun pretty_sort context syn = pretty_t Printer.sort_to_ast Printer.pretty_typ_ast context syn false;
509 (** modify syntax **)
511 fun ext_syntax' f is_logtype prmode decls = extend_syntax prmode (f is_logtype decls);
512 fun ext_syntax f = ext_syntax' (K f) (K false) default_mode;
514 val extend_type_gram = ext_syntax Mixfix.syn_ext_types;
515 val extend_const_gram = ext_syntax' Mixfix.syn_ext_consts;
516 val extend_consts = ext_syntax SynExt.syn_ext_const_names;
517 val extend_trfuns = ext_syntax SynExt.syn_ext_trfuns;
518 val extend_advanced_trfuns = ext_syntax SynExt.syn_ext_advanced_trfuns;
519 val extend_tokentrfuns = ext_syntax SynExt.syn_ext_tokentrfuns;
521 fun remove_const_gram is_logtype prmode decls =
522 remove_syntax prmode (Mixfix.syn_ext_consts is_logtype decls);
524 fun extend_trrules context is_logtype syn =
525 ext_syntax SynExt.syn_ext_rules o read_rules context is_logtype syn;
527 fun remove_trrules context is_logtype syn =
528 remove_syntax default_mode o SynExt.syn_ext_rules o read_rules context is_logtype syn;
530 val extend_trrules_i = ext_syntax SynExt.syn_ext_rules o cert_rules;
531 val remove_trrules_i = remove_syntax default_mode o SynExt.syn_ext_rules o cert_rules;
534 (*export parts of internal Syntax structures*)
535 open Lexicon SynExt Ast Parser TypeExt SynTrans Mixfix Printer;
539 structure BasicSyntax: BASIC_SYNTAX = Syntax;