119 lines
4.7 KiB
Standard ML
119 lines
4.7 KiB
Standard ML
(******************************************************************************
|
|
* STANDARD ML OF NEW JERSEY COPYRIGHT NOTICE, LICENSE AND DISCLAIMER.
|
|
*
|
|
* Copyright (c) 1989-2002 by Lucent Technologies
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software and its
|
|
* documentation for any purpose and without fee is hereby granted,
|
|
* provided that the above copyright notice appear in all copies and that
|
|
* both the copyright notice and this permission notice and warranty
|
|
* disclaimer appear in supporting documentation, and that the name of
|
|
* Lucent Technologies, Bell Labs or any Lucent entity not be used in
|
|
* advertising or publicity pertaining to distribution of the software
|
|
* without specific, written prior permission.
|
|
*
|
|
* Lucent disclaims all warranties with regard to this software,
|
|
* including all implied warranties of merchantability and fitness. In no
|
|
* event shall Lucent be liable for any special, indirect or
|
|
* consequential damages or any damages whatsoever resulting from loss of
|
|
* use, data or profits, whether in an action of contract, negligence or
|
|
* other tortious action, arising out of or in connection with the use
|
|
* or performance of this software.
|
|
******************************************************************************)
|
|
(* $Id$ *)
|
|
|
|
(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)
|
|
|
|
(* functor Join creates a user parser by putting together a Lexer structure,
|
|
an LrValues structure, and a polymorphic parser structure. Note that
|
|
the Lexer and LrValues structure must share the type pos (i.e. the type
|
|
of line numbers), the type svalues for semantic values, and the type
|
|
of tokens.
|
|
*)
|
|
|
|
functor Join(structure Lex : LEXER
|
|
structure ParserData: PARSER_DATA
|
|
structure LrParser : LR_PARSER
|
|
sharing ParserData.LrTable = LrParser.LrTable
|
|
sharing ParserData.Token = LrParser.Token
|
|
sharing type Lex.UserDeclarations.svalue = ParserData.svalue
|
|
sharing type Lex.UserDeclarations.pos = ParserData.pos
|
|
sharing type Lex.UserDeclarations.token = ParserData.Token.token)
|
|
: PARSER =
|
|
struct
|
|
structure Token = ParserData.Token
|
|
structure Stream = LrParser.Stream
|
|
|
|
exception ParseError = LrParser.ParseError
|
|
|
|
type arg = ParserData.arg
|
|
type pos = ParserData.pos
|
|
type result = ParserData.result
|
|
type svalue = ParserData.svalue
|
|
val makeLexer = LrParser.Stream.streamify o Lex.makeLexer
|
|
val parse = fn (lookahead,lexer,error,arg) =>
|
|
(fn (a,b) => (ParserData.Actions.extract a,b))
|
|
(LrParser.parse {table = ParserData.table,
|
|
lexer=lexer,
|
|
lookahead=lookahead,
|
|
saction = ParserData.Actions.actions,
|
|
arg=arg,
|
|
void= ParserData.Actions.void,
|
|
ec = {is_keyword = ParserData.EC.is_keyword,
|
|
noShift = ParserData.EC.noShift,
|
|
preferred_change = ParserData.EC.preferred_change,
|
|
errtermvalue = ParserData.EC.errtermvalue,
|
|
error=error,
|
|
showTerminal = ParserData.EC.showTerminal,
|
|
terms = ParserData.EC.terms}}
|
|
)
|
|
val sameToken = Token.sameToken
|
|
end
|
|
|
|
(* functor JoinWithArg creates a variant of the parser structure produced
|
|
above. In this case, the makeLexer take an additional argument before
|
|
yielding a value of type unit -> (svalue,pos) token
|
|
*)
|
|
|
|
functor JoinWithArg(structure Lex : ARG_LEXER
|
|
structure ParserData: PARSER_DATA
|
|
structure LrParser : LR_PARSER
|
|
sharing ParserData.LrTable = LrParser.LrTable
|
|
sharing ParserData.Token = LrParser.Token
|
|
sharing type Lex.UserDeclarations.svalue = ParserData.svalue
|
|
sharing type Lex.UserDeclarations.pos = ParserData.pos
|
|
sharing type Lex.UserDeclarations.token = ParserData.Token.token)
|
|
: ARG_PARSER =
|
|
struct
|
|
structure Token = ParserData.Token
|
|
structure Stream = LrParser.Stream
|
|
|
|
exception ParseError = LrParser.ParseError
|
|
|
|
type arg = ParserData.arg
|
|
type lexarg = Lex.UserDeclarations.arg
|
|
type pos = ParserData.pos
|
|
type result = ParserData.result
|
|
type svalue = ParserData.svalue
|
|
|
|
val makeLexer = fn s => fn arg =>
|
|
LrParser.Stream.streamify (Lex.makeLexer s arg)
|
|
val parse = fn (lookahead,lexer,error,arg) =>
|
|
(fn (a,b) => (ParserData.Actions.extract a,b))
|
|
(LrParser.parse {table = ParserData.table,
|
|
lexer=lexer,
|
|
lookahead=lookahead,
|
|
saction = ParserData.Actions.actions,
|
|
arg=arg,
|
|
void= ParserData.Actions.void,
|
|
ec = {is_keyword = ParserData.EC.is_keyword,
|
|
noShift = ParserData.EC.noShift,
|
|
preferred_change = ParserData.EC.preferred_change,
|
|
errtermvalue = ParserData.EC.errtermvalue,
|
|
error=error,
|
|
showTerminal = ParserData.EC.showTerminal,
|
|
terms = ParserData.EC.terms}}
|
|
)
|
|
val sameToken = Token.sameToken
|
|
end;
|