Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/branches/SMLNJ/src/ml-yacc/lib/base.sig
ViewVC logotype

Annotation of /sml/branches/SMLNJ/src/ml-yacc/lib/base.sig

Parent Directory Parent Directory | Revision Log Revision Log


Revision 167 - (view) (download) (as text)

1 : monnier 2 (* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi
2 :     *
3 :     * $Log$
4 : monnier 167 * Revision 1.1.1.6 1998/11/07 20:11:14 monnier
5 :     * version $version
6 : monnier 2 *
7 : monnier 8 * Revision 1.1.1.1 1997/01/14 01:38:04 george
8 :     * Version 109.24
9 :     *
10 : monnier 2 * Revision 1.1.1.1 1996/01/31 16:01:42 george
11 :     * Version 109
12 :     *
13 :     *)
14 :    
15 :     (* base.sig: Base signature file for SML-Yacc. This file contains signatures
16 :     that must be loaded before any of the files produced by ML-Yacc are loaded
17 :     *)
18 :    
19 :     (* STREAM: signature for a lazy stream.*)
20 :    
21 :     signature STREAM =
22 :     sig type 'xa stream
23 :     val streamify : (unit -> '_a) -> '_a stream
24 :     val cons : '_a * '_a stream -> '_a stream
25 :     val get : '_a stream -> '_a * '_a stream
26 :     end
27 :    
28 :     (* LR_TABLE: signature for an LR Table.
29 :    
30 :     The list of actions and gotos passed to mkLrTable must be ordered by state
31 :     number. The values for state 0 are the first in the list, the values for
32 :     state 1 are next, etc.
33 :     *)
34 :    
35 :     signature LR_TABLE =
36 :     sig
37 :     datatype ('a,'b) pairlist = EMPTY | PAIR of 'a * 'b * ('a,'b) pairlist
38 :     datatype state = STATE of int
39 :     datatype term = T of int
40 :     datatype nonterm = NT of int
41 :     datatype action = SHIFT of state
42 :     | REDUCE of int
43 :     | ACCEPT
44 :     | ERROR
45 :     type table
46 :    
47 :     val numStates : table -> int
48 :     val numRules : table -> int
49 :     val describeActions : table -> state ->
50 :     (term,action) pairlist * action
51 :     val describeGoto : table -> state -> (nonterm,state) pairlist
52 :     val action : table -> state * term -> action
53 :     val goto : table -> state * nonterm -> state
54 :     val initialState : table -> state
55 :     exception Goto of state * nonterm
56 :    
57 :     val mkLrTable : {actions : ((term,action) pairlist * action) array,
58 :     gotos : (nonterm,state) pairlist array,
59 :     numStates : int, numRules : int,
60 :     initialState : state} -> table
61 :     end
62 :    
63 :     (* TOKEN: signature revealing the internal structure of a token. This signature
64 :     TOKEN distinct from the signature {parser name}_TOKENS produced by ML-Yacc.
65 :     The {parser name}_TOKENS structures contain some types and functions to
66 :     construct tokens from values and positions.
67 :    
68 :     The representation of token was very carefully chosen here to allow the
69 :     polymorphic parser to work without knowing the types of semantic values
70 :     or line numbers.
71 :    
72 :     This has had an impact on the TOKENS structure produced by SML-Yacc, which
73 :     is a structure parameter to lexer functors. We would like to have some
74 :     type 'a token which functions to construct tokens would create. A
75 :     constructor function for a integer token might be
76 :    
77 :     INT: int * 'a * 'a -> 'a token.
78 :    
79 :     This is not possible because we need to have tokens with the representation
80 :     given below for the polymorphic parser.
81 :    
82 :     Thus our constructur functions for tokens have the form:
83 :    
84 :     INT: int * 'a * 'a -> (svalue,'a) token
85 :    
86 :     This in turn has had an impact on the signature that lexers for SML-Yacc
87 :     must match and the types that a user must declare in the user declarations
88 :     section of lexers.
89 :     *)
90 :    
91 :     signature TOKEN =
92 :     sig
93 :     structure LrTable : LR_TABLE
94 :     datatype ('a,'b) token = TOKEN of LrTable.term * ('a * 'b * 'b)
95 :     val sameToken : ('a,'b) token * ('a,'b) token -> bool
96 :     end
97 :    
98 :     (* LR_PARSER: signature for a polymorphic LR parser *)
99 :    
100 :     signature LR_PARSER =
101 :     sig
102 :     structure Stream: STREAM
103 :     structure LrTable : LR_TABLE
104 :     structure Token : TOKEN
105 :    
106 :     sharing LrTable = Token.LrTable
107 :    
108 :     exception ParseError
109 :    
110 :     val parse : {table : LrTable.table,
111 :     lexer : ('_b,'_c) Token.token Stream.stream,
112 :     arg: 'arg,
113 :     saction : int *
114 :     '_c *
115 :     (LrTable.state * ('_b * '_c * '_c)) list *
116 :     'arg ->
117 :     LrTable.nonterm *
118 :     ('_b * '_c * '_c) *
119 :     ((LrTable.state *('_b * '_c * '_c)) list),
120 :     void : '_b,
121 :     ec : { is_keyword : LrTable.term -> bool,
122 :     noShift : LrTable.term -> bool,
123 :     preferred_change : (LrTable.term list * LrTable.term list) list,
124 :     errtermvalue : LrTable.term -> '_b,
125 :     showTerminal : LrTable.term -> string,
126 :     terms: LrTable.term list,
127 :     error : string * '_c * '_c -> unit
128 :     },
129 :     lookahead : int (* max amount of lookahead used in *)
130 :     (* error correction *)
131 :     } -> '_b *
132 :     (('_b,'_c) Token.token Stream.stream)
133 :     end
134 :    
135 :     (* LEXER: a signature that most lexers produced for use with SML-Yacc's
136 :     output will match. The user is responsible for declaring type token,
137 :     type pos, and type svalue in the UserDeclarations section of a lexer.
138 :    
139 :     Note that type token is abstract in the lexer. This allows SML-Yacc to
140 :     create a TOKENS signature for use with lexers produced by ML-Lex that
141 :     treats the type token abstractly. Lexers that are functors parametrized by
142 :     a Tokens structure matching a TOKENS signature cannot examine the structure
143 :     of tokens.
144 :     *)
145 :    
146 :     signature LEXER =
147 :     sig
148 :     structure UserDeclarations :
149 :     sig
150 :     type ('a,'b) token
151 :     type pos
152 :     type svalue
153 :     end
154 :     val makeLexer : (int -> string) -> unit ->
155 :     (UserDeclarations.svalue,UserDeclarations.pos) UserDeclarations.token
156 :     end
157 :    
158 :     (* ARG_LEXER: the %arg option of ML-Lex allows users to produce lexers which
159 :     also take an argument before yielding a function from unit to a token
160 :     *)
161 :    
162 :     signature ARG_LEXER =
163 :     sig
164 :     structure UserDeclarations :
165 :     sig
166 :     type ('a,'b) token
167 :     type pos
168 :     type svalue
169 :     type arg
170 :     end
171 :     val makeLexer : (int -> string) -> UserDeclarations.arg -> unit ->
172 :     (UserDeclarations.svalue,UserDeclarations.pos) UserDeclarations.token
173 :     end
174 :    
175 :     (* PARSER_DATA: the signature of ParserData structures in {parser name}LrValsFun
176 :     produced by SML-Yacc. All such structures match this signature.
177 :    
178 :     The {parser name}LrValsFun produces a structure which contains all the values
179 :     except for the lexer needed to call the polymorphic parser mentioned
180 :     before.
181 :    
182 :     *)
183 :    
184 :     signature PARSER_DATA =
185 :     sig
186 :     (* the type of line numbers *)
187 :    
188 :     type pos
189 :    
190 :     (* the type of semantic values *)
191 :    
192 :     type svalue
193 :    
194 :     (* the type of the user-supplied argument to the parser *)
195 :     type arg
196 :    
197 :     (* the intended type of the result of the parser. This value is
198 :     produced by applying extract from the structure Actions to the
199 :     final semantic value resultiing from a parse.
200 :     *)
201 :    
202 :     type result
203 :    
204 :     structure LrTable : LR_TABLE
205 :     structure Token : TOKEN
206 :     sharing Token.LrTable = LrTable
207 :    
208 :     (* structure Actions contains the functions which mantain the
209 :     semantic values stack in the parser. Void is used to provide
210 :     a default value for the semantic stack.
211 :     *)
212 :    
213 :     structure Actions :
214 :     sig
215 :     val actions : int * pos *
216 :     (LrTable.state * (svalue * pos * pos)) list * arg->
217 :     LrTable.nonterm * (svalue * pos * pos) *
218 :     ((LrTable.state *(svalue * pos * pos)) list)
219 :     val void : svalue
220 :     val extract : svalue -> result
221 :     end
222 :    
223 :     (* structure EC contains information used to improve error
224 :     recovery in an error-correcting parser *)
225 :    
226 :     structure EC :
227 :     sig
228 :     val is_keyword : LrTable.term -> bool
229 :     val noShift : LrTable.term -> bool
230 :     val preferred_change : (LrTable.term list * LrTable.term list) list
231 :     val errtermvalue : LrTable.term -> svalue
232 :     val showTerminal : LrTable.term -> string
233 :     val terms: LrTable.term list
234 :     end
235 :    
236 :     (* table is the LR table for the parser *)
237 :    
238 :     val table : LrTable.table
239 :     end
240 :    
241 :     (* signature PARSER is the signature that most user parsers created by
242 :     SML-Yacc will match.
243 :     *)
244 :    
245 :     signature PARSER =
246 :     sig
247 :     structure Token : TOKEN
248 :     structure Stream : STREAM
249 :     exception ParseError
250 :    
251 :     (* type pos is the type of line numbers *)
252 :    
253 :     type pos
254 :    
255 :     (* type result is the type of the result from the parser *)
256 :    
257 :     type result
258 :    
259 :     (* the type of the user-supplied argument to the parser *)
260 :     type arg
261 :    
262 :     (* type svalue is the type of semantic values for the semantic value
263 :     stack
264 :     *)
265 :    
266 :     type svalue
267 :    
268 :     (* val makeLexer is used to create a stream of tokens for the parser *)
269 :    
270 :     val makeLexer : (int -> string) ->
271 :     (svalue,pos) Token.token Stream.stream
272 :    
273 :     (* val parse takes a stream of tokens and a function to print
274 :     errors and returns a value of type result and a stream containing
275 :     the unused tokens
276 :     *)
277 :    
278 :     val parse : int * ((svalue,pos) Token.token Stream.stream) *
279 :     (string * pos * pos -> unit) * arg ->
280 :     result * (svalue,pos) Token.token Stream.stream
281 :    
282 :     val sameToken : (svalue,pos) Token.token * (svalue,pos) Token.token ->
283 :     bool
284 :     end
285 :    
286 :     (* signature ARG_PARSER is the signature that will be matched by parsers whose
287 :     lexer takes an additional argument.
288 :     *)
289 :    
290 :     signature ARG_PARSER =
291 :     sig
292 :     structure Token : TOKEN
293 :     structure Stream : STREAM
294 :     exception ParseError
295 :    
296 :     type arg
297 :     type lexarg
298 :     type pos
299 :     type result
300 :     type svalue
301 :    
302 :     val makeLexer : (int -> string) -> lexarg ->
303 :     (svalue,pos) Token.token Stream.stream
304 :     val parse : int * ((svalue,pos) Token.token Stream.stream) *
305 :     (string * pos * pos -> unit) * arg ->
306 :     result * (svalue,pos) Token.token Stream.stream
307 :    
308 :     val sameToken : (svalue,pos) Token.token * (svalue,pos) Token.token ->
309 :     bool
310 :     end
311 :    

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0