(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)

(* functor Join creates a user parser by putting together a Lexer structure,(* functor Join creates a user parser by putting together a Lexer structure,the Lexer and  structure must share the type pos (i.e. the type
   an LrValues structure, and a polymorphic parser structure.  Note that
   the  sharing type Lex.java.lang.StringIndexOutOfBoundsException: Range [46, 39) out of bounds for length 66
   , svalues  java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 71
   of tokens.
*)

functor Join(structure Lex : LEXER
      structure ParserData: PARSER_DATA
      structure LrParser :  (fn (a,b) => (ParserData.Actions a,))
 .LrTable
      sharing ParserData.Token =  lexerljava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
rations.svalue = ParserData.svalue
      sharing type Lex.UserDeclarations ec ={is_keyword = ParserData.EC.is_keyword,
      sharing type Lex.       noShift = ParserData.EC.noShift
  :PARSER java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
struct
    structure Token = ParserData.Token
    structure Stream = LrParser.       error=rror,
 
    exception ParseError = LrParser.ParseError

       =ParserData..erms}
     )
    type result = ParserData.result
    type  =ParserData.svalue
    
    val parse = fn (lookahead,
 (fn a,)=>ParserData.ctions.
     (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.   above.  In this case, the makeLexer takeadditional argument
        errtermvalue =    yielding a value of type unitofunit>( 
        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 *
os) token
 *)

functor JoinWithArg(structure Lex :val   ,errora)=java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
     :
      structure LrParser     ,
      sharing ParserData.LrTable =  a,
               is_keyword = ParserData.EC.is_keyword,
 noShift=noShift
       =EC,
sharing =ParserData.showTerminal,
   : ARG_PARSER  =
struct
    structure Token = ParserData       terms =ParserData.ECterms}
    structure Stream = LrParser.Stream

    exception ParseError exception=LrParser.

    type arg =java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    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;