Initial import of l2c

[snipe.git] / parse / parse.sml

diff --git a/parse/parse.sml b/parse/parse.sml
index 5981be1131aba92d1647216e40291925104a8609..1fc612f9727fba19963e2f91548cbb76a0cd9e0a 100644 (file)
--- a/parse/parse.sml
+++ b/parse/parse.sml
@@ -17,10 +17,10 @@ end
 structure Parse :> PARSE =
 struct 
 
 structure Parse :> PARSE =
 struct 
 

-  structure L1LrVals = L1LrValsFn (structure Token = LrParser.Token)
-  structure L1Lex = L1LexFn (structure Tokens = L1LrVals.Tokens)
-  structure L1Parse = Join (structure ParserData = L1LrVals.ParserData
-                            structure Lex = L1Lex
+  structure L2LrVals = L2LrValsFn (structure Token = LrParser.Token)
+  structure L2Lex = L2LexFn (structure Tokens = L2LrVals.Tokens)
+  structure L2Parse = Join (structure ParserData = L2LrVals.ParserData
+                            structure Lex = L2Lex

                             structure LrParser = LrParser)
 
   (* Main parsing function *)
                             structure LrParser = LrParser)
 
   (* Main parsing function *)


@@ -31,17 +31,17 @@ struct
          val _ = ParseState.setfile filename (* start at position 0 in filename *)
          fun parseerror (s, p1, p2) = ErrorMsg.error (ParseState.ext (p1,p2)) s
          val lexer = LrParser.Stream.streamify
          val _ = ParseState.setfile filename (* start at position 0 in filename *)
          fun parseerror (s, p1, p2) = ErrorMsg.error (ParseState.ext (p1,p2)) s
          val lexer = LrParser.Stream.streamify

-                         (L1Lex.makeLexer (fn _ => TextIO.input instream))
+                         (L2Lex.makeLexer (fn _ => TextIO.input instream))

          (* 0 = no error correction, 15 = reasonable lookahead for correction *)
          (* 0 = no error correction, 15 = reasonable lookahead for correction *)

-         val (absyn, _) = L1Parse.parse(0, lexer, parseerror, ())
+         val (absyn, _) = L2Parse.parse(0, lexer, parseerror, ())

           val _ = if !ErrorMsg.anyErrors
                  then raise ErrorMsg.Error
                  else ()
        in
          absyn
        end)
           val _ = if !ErrorMsg.anyErrors
                  then raise ErrorMsg.Error
                  else ()
        in
          absyn
        end)

-      handle L1Lex.LexError => ( ErrorMsg.error NONE "lexer error" ;
-                              raise ErrorMsg.Error )
+      handle Fail s => ( ErrorMsg.error NONE ("lexer error: "^s) ;
+                        raise ErrorMsg.Error )

           | LrParser.ParseError => raise ErrorMsg.Error (* always preceded by msg *)
            | e as IO.Io _ => ( ErrorMsg.error NONE (exnMessage e);
                                raise ErrorMsg.Error )
           | LrParser.ParseError => raise ErrorMsg.Error (* always preceded by msg *)
            | e as IO.Io _ => ( ErrorMsg.error NONE (exnMessage e);
                                raise ErrorMsg.Error )