1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
(* camlp5r *)
(* grammar.mli,v *)
(* Copyright (c) INRIA 2007-2017 *)
(** Extensible grammars.
This module implements the Camlp5 extensible grammars system.
Grammars entries can be extended using the [EXTEND] statement,
added by loading the Camlp5 [pa_extend.cmo] file. *)
(** {6 Functorial interface} *)
(** Alternative for grammars use. Grammars are no more Ocaml values:
there is no type for them. Modules generated preserve the
rule "an entry cannot call an entry of another grammar" by
normal OCaml typing. *)
module type GLexerType = Plexing.Lexer
(** The input signature for the functor [Grammar.GMake]: [te] is the
type of the tokens. *)
type norec
type mayrec
module type S = sig
type te
type 'c pattern
module Parsable : sig
type t
val make : ?loc:Loc.t -> char Stream.t -> t
end
val tokens : string -> (string option * int) list
module Entry : sig
type 'a t
val make : string -> 'a t
val parse : 'a t -> Parsable.t -> 'a
val name : 'a t -> string
val of_parser : string -> (Plexing.location_function -> te Stream.t -> 'a) -> 'a t
val parse_token_stream : 'a t -> te Stream.t -> 'a
val print : Format.formatter -> 'a t -> unit
end
module rec Symbol : sig
type ('self, 'trec, 'a) t
val nterm : 'a Entry.t -> ('self, norec, 'a) t
val nterml : 'a Entry.t -> string -> ('self, norec, 'a) t
val list0 : ('self, 'trec, 'a) t -> ('self, 'trec, 'a list) t
val list0sep :
('self, 'trec, 'a) t -> ('self, norec, 'b) t -> bool ->
('self, 'trec, 'a list) t
val list1 : ('self, 'trec, 'a) t -> ('self, 'trec, 'a list) t
val list1sep :
('self, 'trec, 'a) t -> ('self, norec, 'b) t -> bool ->
('self, 'trec, 'a list) t
val opt : ('self, 'trec, 'a) t -> ('self, 'trec, 'a option) t
val self : ('self, mayrec, 'self) t
val next : ('self, mayrec, 'self) t
val token : 'c pattern -> ('self, norec, 'c) t
val rules : warning:(string -> unit) option -> 'a Rules.t list -> ('self, norec, 'a) t
end and Rule : sig
type ('self, 'trec, 'f, 'r) t
val stop : ('self, norec, 'r, 'r) t
val next :
('self, _, 'a, 'r) t -> ('self, _, 'b) Symbol.t ->
('self, mayrec, 'b -> 'a, 'r) t
val next_norec :
('self, norec, 'a, 'r) Rule.t -> ('self, norec, 'b) Symbol.t ->
('self, norec, 'b -> 'a, 'r) t
end and Rules : sig
type 'a t
val make : (_, norec, 'f, Loc.t -> 'a) Rule.t -> 'f -> 'a t
end
module Production : sig
type 'a t
val make : ('a, _, 'f, Loc.t -> 'a) Rule.t -> 'f -> 'a t
end
module Unsafe :
sig
val clear_entry : 'a Entry.t -> unit
end
val safe_extend : warning:(string -> unit) option ->
'a Entry.t -> Gramext.position option ->
(string option * Gramext.g_assoc option * 'a Production.t list)
list ->
unit
val safe_delete_rule : 'a Entry.t -> ('a, _, 'f, 'r) Rule.t -> unit
end
(** Signature type of the functor [Grammar.GMake]. The types and
functions are almost the same than in generic interface, but:
- Grammars are not values. Functions holding a grammar as parameter
do not have this parameter yet.
- The type [parsable] is used in function [parse] instead of
the char stream, avoiding the possible loss of tokens.
- The type of tokens (expressions and patterns) can be any
type (instead of (string * string)); the module parameter
must specify a way to show them as (string * string) *)
module GMake (L : GLexerType) :
S with type te = L.te and type 'c pattern = 'c L.pattern
|
