* boot/scanner.boot (%Lexer): New record structure.

	Add a lexer parameter to all lexing functions that need one.
	Adjust their callers.

3 files changed, 343 insertions, 278 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 9adb8f94..a4787328 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,9 @@
+2012-05-24  Gabriel Dos Reis  <gdr@cs.tamu.edu>
+
+	* boot/scanner.boot (%Lexer): New record structure.
+	Add a lexer parameter to all lexing functions that need one.
+	Adjust their callers.
+
 2012-05-23  Gabriel Dos Reis  <gdr@cs.tamu.edu>
 
 	* boot/tokens.boot: "@" is now a new keyword.
diff --git a/src/boot/scanner.boot b/src/boot/scanner.boot
index 91298559..6dcbce92 100644
--- a/src/boot/scanner.boot
+++ b/src/boot/scanner.boot
@@ -60,97 +60,108 @@ dqToList s ==
   s = nil => nil
   first s
  
-shoeNextLine s==
+--%
+structure %Lexer ==
+  Record(line: %String, pos: %Short) with
+    lexerInputLine == (.line)
+    lexerCurrentPosition == (.pos)
+
+makeLexer() ==
+  mk%Lexer(nil,nil)
+
+--%  
+
+shoeNextLine(lex,s) ==
   bStreamNull s => false
   $linepos := s
   [$f,:$r] := s
-  $ln := sourceLineString $f
-  $n := firstNonblankPosition($ln,0)
-  $sz := #$ln
+  lexerInputLine(lex) := sourceLineString $f
+  $n := firstNonblankPosition(lexerInputLine lex,0)
+  $sz := #lexerInputLine lex
   $n = nil => true
-  stringChar($ln,$n) = shoeTAB =>
+  stringChar(lexerInputLine lex,$n) = shoeTAB =>
     a := makeString(7-($n rem 8),char " ")
-    stringChar($ln,$n) := char " "
-    $ln := strconc(a,$ln)
-    s1 := [makeSourceLine($ln,sourceLineNumber $f),:$r]
-    shoeNextLine s1
+    stringChar(lexerInputLine lex,$n) := char " "
+    lexerInputLine(lex) := strconc(a,lexerInputLine lex)
+    s1 := [makeSourceLine(lexerInputLine lex,sourceLineNumber $f),:$r]
+    shoeNextLine(lex,s1)
   true
  
 shoeLineToks s ==
   $f: local := nil
   $r: local := nil
-  $ln: local := nil
   $n: local := nil
   $sz: local := nil
   $floatok: local := true
   $linepos: local := s
-  not shoeNextLine s =>  [nil,:nil]
+  lex := makeLexer()
+  not shoeNextLine(lex,s) =>  [nil,:nil]
   $n = nil => shoeLineToks $r
-  stringChar($ln,0) = char ")" =>
-    command := shoeLine? $ln =>
+  stringChar(lexerInputLine lex,0) = char ")" =>
+    command := shoeLine? lexerInputLine lex =>
       dq := dqUnit makeToken($linepos,shoeLeafLine command,0)
       [[dq],:$r]
-    command := shoeLisp? $ln => shoeLispToken($r,command)
+    command := shoeLisp? lexerInputLine lex => shoeLispToken(lex,$r,command)
     shoeLineToks $r
   toks := []
   while $n < $sz repeat
-    toks := dqAppend(toks,shoeToken())
+    toks := dqAppend(toks,shoeToken lex)
   toks = nil => shoeLineToks $r
   [[toks],:$r]
  
-shoeLispToken(s,string)==
+shoeLispToken(lex,s,string)==
   if #string = 0 or stringChar(string,0) = char ";" then
     string := '""
-  ln := $ln
+  ln := lexerInputLine lex
   linepos := $linepos
-  [r,:st] := shoeAccumulateLines(s,string)
+  [r,:st] := shoeAccumulateLines(lex,s,string)
   dq := dqUnit makeToken(linepos,shoeLeafLisp st,0)
   [[dq],:r]
  
-shoeAccumulateLines(s,string)==
-  not shoeNextLine s =>  [s,:string]
-  $n = nil => shoeAccumulateLines($r,string)
-  #$ln = 0 => shoeAccumulateLines($r,string)
-  stringChar($ln,0) = char ")" =>
-    command := shoeLisp? $ln
+shoeAccumulateLines(lex,s,string)==
+  not shoeNextLine(lex,s) =>  [s,:string]
+  $n = nil => shoeAccumulateLines(lex,$r,string)
+  #lexerInputLine lex = 0 => shoeAccumulateLines(lex,$r,string)
+  stringChar(lexerInputLine lex,0) = char ")" =>
+    command := shoeLisp? lexerInputLine lex
     command and #command > 0 =>
       stringChar(command,0) = char ";" =>
-		  shoeAccumulateLines($r,string)
+		  shoeAccumulateLines(lex,$r,string)
       a := charPosition(char ";",command,0) =>
-	shoeAccumulateLines($r,
+	shoeAccumulateLines(lex,$r,
 	   strconc(string,subString(command,0,a-1)))
-      shoeAccumulateLines($r,strconc(string,command))
-    shoeAccumulateLines($r,string)
+      shoeAccumulateLines(lex,$r,strconc(string,command))
+    shoeAccumulateLines(lex,$r,string)
   [s,:string]
 
 -- returns true if token t is closing `parenthesis'.
 shoeCloser t ==
   shoeKeyWord t in '(CPAREN CBRACK)
  
-shoeToken() ==
+shoeToken lex ==
   linepos := $linepos
   n := $n
-  ch := stringChar($ln,$n)
+  ch := stringChar(lexerInputLine lex,$n)
   b :=
-    shoeStartsComment() =>
-      shoeComment()
+    shoeStartsComment lex =>
+      shoeComment lex
       []
-    shoeStartsNegComment() =>
-      shoeNegComment()
+    shoeStartsNegComment lex =>
+      shoeNegComment lex
       []
-    ch = char "!" => shoeLispEscape()
-    shoePunctuation codePoint ch => shoePunct()
-    shoeStartsId ch => shoeWord(false)
+    ch = char "!" => shoeLispEscape lex
+    shoePunctuation codePoint ch => shoePunct lex
+    shoeStartsId ch => shoeWord(lex,false)
     ch = char " " =>
-      shoeSpace()
+      shoeSpace lex
       []
-    ch = char "_"" => shoeString()
-    digit? ch => shoeNumber()
-    ch = char "__" => shoeEscape()
+    ch = char "_"" => shoeString lex
+    digit? ch => shoeNumber lex
+    ch = char "__" => shoeEscape lex
     ch = shoeTAB =>
       $n := $n + 1
       []
-    shoeError()
+    shoeError lex
   b = nil => nil
   dqUnit makeToken(linepos,b,n)
  
@@ -193,15 +204,15 @@ shoeLeafError x   ==
 shoeLeafSpaces x  == 
   ["SPACES",x]
  
-shoeLispEscape()==
+shoeLispEscape lex ==
   $n := $n + 1
   $n >= $sz =>
     SoftShoeError([$linepos,:$n],'"lisp escape error")
-    shoeLeafError stringChar($ln,$n)
-  a := shoeReadLispString($ln,$n)
+    shoeLeafError stringChar(lexerInputLine lex,$n)
+  a := shoeReadLispString(lexerInputLine lex,$n)
   a = nil =>
     SoftShoeError([$linepos,:$n],'"lisp escape error")
-    shoeLeafError stringChar($ln,$n)
+    shoeLeafError stringChar(lexerInputLine lex,$n)
   [exp,n] := a
   n = nil =>
     $n := $sz
@@ -209,110 +220,110 @@ shoeLispEscape()==
   $n := n
   shoeLeafLispExp  exp
 
-shoeEscape() ==
+shoeEscape lex ==
   $n := $n + 1
-  shoeEsc() => shoeWord true 
+  shoeEsc lex => shoeWord(lex,true)
   nil
  
-shoeEsc()==
+shoeEsc lex ==
   $n >= $sz =>
-    shoeNextLine($r) =>
-      while $n = nil repeat shoeNextLine($r)
-      shoeEsc()
+    shoeNextLine(lex,$r) =>
+      while $n = nil repeat shoeNextLine(lex,$r)
+      shoeEsc lex
       false
     false
-  n1 := firstNonblankPosition($ln,$n)
+  n1 := firstNonblankPosition(lexerInputLine lex,$n)
   n1 = nil =>
-    shoeNextLine($r)
+    shoeNextLine(lex,$r)
     while $n = nil repeat 
-      shoeNextLine($r)
-    shoeEsc()
+      shoeNextLine(lex,$r)
+    shoeEsc lex
     false
   true
  
-shoeStartsComment()==
+shoeStartsComment lex ==
   $n < $sz =>
-    stringChar($ln,$n) = char "+" => 
+    stringChar(lexerInputLine lex,$n) = char "+" => 
        www := $n + 1
        www >= $sz => false
-       stringChar($ln,www) = char "+"
+       stringChar(lexerInputLine lex,www) = char "+"
     false
   false
  
-shoeStartsNegComment()==
+shoeStartsNegComment lex ==
   $n < $sz =>
-    stringChar($ln,$n) = char "-" =>
+    stringChar(lexerInputLine lex,$n) = char "-" =>
       www := $n + 1
       www >= $sz => false
-      stringChar($ln,www) = char "-"
+      stringChar(lexerInputLine lex,www) = char "-"
     false
   false
  
-shoeNegComment()==
+shoeNegComment lex ==
   n := $n
   $n := $sz
-  shoeLeafNegComment subString($ln,n)
+  shoeLeafNegComment subString(lexerInputLine lex,n)
  
-shoeComment()==
+shoeComment lex ==
   n := $n
   $n := $sz
-  shoeLeafComment subString($ln,n)
+  shoeLeafComment subString(lexerInputLine lex,n)
  
-shoePunct()==
-  sss := shoeMatch($ln,$n)
+shoePunct lex ==
+  sss := shoeMatch(lexerInputLine lex,$n)
   $n := $n + #sss
-  shoeKeyTr sss
+  shoeKeyTr(lex,sss)
  
-shoeKeyTr w==
+shoeKeyTr(lex,w) ==
   shoeKeyWord w = "DOT" =>
-    $floatok => shoePossFloat(w)
+    $floatok => shoePossFloat(lex,w)
     shoeLeafKey w
   $floatok := not shoeCloser w
   shoeLeafKey w
  
-shoePossFloat (w)==
-  $n >= $sz or not digit? stringChar($ln,$n) => shoeLeafKey w
-  w := shoeInteger()
-  shoeExponent('"0",w)
+shoePossFloat(lex,w)==
+  $n >= $sz or not digit? stringChar(lexerInputLine lex,$n) => shoeLeafKey w
+  w := shoeInteger lex
+  shoeExponent(lex,'"0",w)
  
-shoeSpace()==
+shoeSpace lex ==
   n := $n
-  $n := firstNonblankPosition($ln,$n)
+  $n := firstNonblankPosition(lexerInputLine lex,$n)
   $floatok := true
   $n = nil =>
      shoeLeafSpaces 0
-     $n:= # $ln
+     $n:= # lexerInputLine lex
   shoeLeafSpaces ($n-n)
  
-shoeString()==
+shoeString lex ==
   $n := $n+1
   $floatok := false
-  shoeLeafString shoeS ()
+  shoeLeafString shoeS lex
  
-shoeS()==
+shoeS lex ==
   $n >= $sz =>
     SoftShoeError([$linepos,:$n],'"quote added")
     '""
   n := $n
-  strsym := charPosition(char "_"",$ln,$n) or $sz
-  escsym := charPosition(char "__",$ln,$n) or $sz
+  strsym := charPosition(char "_"",lexerInputLine lex,$n) or $sz
+  escsym := charPosition(char "__",lexerInputLine lex,$n) or $sz
   mn := MIN(strsym,escsym)
   mn=$sz =>
     $n := $sz
     SoftShoeError([$linepos,:$n],'"quote added")
-    subString($ln,n)
+    subString(lexerInputLine lex,n)
   mn = strsym =>
     $n := mn + 1
-    subString($ln,n,mn-n)
-  str := subString($ln,n,mn-n)
+    subString(lexerInputLine lex,n,mn-n)
+  str := subString(lexerInputLine lex,n,mn-n)
   $n := mn+1
-  a := shoeEsc()
+  a := shoeEsc lex
   b := 
     a =>
-      str := strconc(str,charString stringChar($ln,$n))
+      str := strconc(str,charString stringChar(lexerInputLine lex,$n))
       $n := $n + 1
-      shoeS()
-    shoeS()
+      shoeS lex
+    shoeS lex
   strconc(str,b)
  
 shoeIdEnd(line,n)==
@@ -320,24 +331,24 @@ shoeIdEnd(line,n)==
     n := n+1
   n
  
-shoeW(b) ==
+shoeW(lex,b) ==
   n1 := $n
   $n := $n+1
   l := $sz
-  endid := shoeIdEnd($ln,$n)
-  endid = l or stringChar($ln,endid) ~= char "__" => 
+  endid := shoeIdEnd(lexerInputLine lex,$n)
+  endid = l or stringChar(lexerInputLine lex,endid) ~= char "__" => 
     $n := endid
-    [b,subString($ln,n1,endid-n1)]
-  str := subString($ln,n1,endid-n1)
+    [b,subString(lexerInputLine lex,n1,endid-n1)]
+  str := subString(lexerInputLine lex,n1,endid-n1)
   $n := endid+1
-  a := shoeEsc()
+  a := shoeEsc lex
   bb := 
-    a => shoeW(true)
+    a => shoeW(lex,true)
     [b,'""]   --  escape finds space or newline
   [bb.0 or b,strconc(str,bb.1)]
  
-shoeWord(esp) ==
-   aaa:=shoeW(false)
+shoeWord(lex,esp) ==
+   aaa := shoeW(lex,false)
    w:=aaa.1
    $floatok:=false
    esp or aaa.0 =>  shoeLeafId w
@@ -346,21 +357,21 @@ shoeWord(esp) ==
      shoeLeafKey w
    shoeLeafId  w
  
-shoeInteger() ==
-  shoeInteger1(false)
+shoeInteger lex ==
+  shoeInteger1(lex,false)
  
-shoeInteger1(zro) ==
+shoeInteger1(lex,zro) ==
   n := $n
   l := $sz
-  while $n <l and digit? stringChar($ln,$n) repeat 
+  while $n <l and digit? stringChar(lexerInputLine lex,$n) repeat 
     $n := $n+1
-  $n = l or stringChar($ln,$n) ~= char "__" =>
+  $n = l or stringChar(lexerInputLine lex,$n) ~= char "__" =>
     n = $n and zro => '"0"
-    subString($ln,n,$n - n)
-  str := subString($ln,n,$n - n)
+    subString(lexerInputLine lex,n,$n - n)
+  str := subString(lexerInputLine lex,n,$n - n)
   $n := $n+1
-  a := shoeEsc()
-  bb := shoeInteger1(zro)
+  a := shoeEsc lex
+  bb := shoeInteger1(lex,zro)
   strconc(str,bb)
  
 shoeIntValue(s) ==
@@ -371,40 +382,40 @@ shoeIntValue(s) ==
     ival := 10*ival + d
   ival
  
-shoeNumber() ==
-  a := shoeInteger()
+shoeNumber lex ==
+  a := shoeInteger lex
   $n >= $sz => shoeLeafInteger a
-  $floatok and stringChar($ln,$n) = char "." => 
+  $floatok and stringChar(lexerInputLine lex,$n) = char "." => 
     n := $n
     $n := $n+1
-    $n < $sz and stringChar($ln,$n) = char "." =>
+    $n < $sz and stringChar(lexerInputLine lex,$n) = char "." =>
       $n := n
       shoeLeafInteger a
-    w := shoeInteger1(true)
-    shoeExponent(a,w)
+    w := shoeInteger1(lex,true)
+    shoeExponent(lex,a,w)
   shoeLeafInteger a
  
-shoeExponent(a,w)==
+shoeExponent(lex,a,w)==
   $n >= $sz => shoeLeafFloat(a,w,0)
   n := $n
-  c := stringChar($ln,$n)
+  c := stringChar(lexerInputLine lex,$n)
   c = char "E" or c = char "e" =>
     $n := $n+1
     $n >= $sz =>
       $n := n
       shoeLeafFloat(a,w,0)
-    digit? stringChar($ln,$n) =>
-      e := shoeInteger()
+    digit? stringChar(lexerInputLine lex,$n) =>
+      e := shoeInteger lex
       e := shoeIntValue e
       shoeLeafFloat(a,w,e)
-    c1 := stringChar($ln,$n)
+    c1 := stringChar(lexerInputLine lex,$n)
     c1 = char "+" or c1 = char "-" =>
       $n := $n+1
       $n >= $sz =>
 	$n := n
 	shoeLeafFloat(a,w,0)
-      digit? stringChar($ln,$n) =>
-	e := shoeInteger()
+      digit? stringChar(lexerInputLine lex,$n) =>
+	e := shoeInteger lex
 	e := shoeIntValue e
 	shoeLeafFloat(a,w,(c1 = char "-" => MINUS e; e))
       $n := n
@@ -412,13 +423,14 @@ shoeExponent(a,w)==
     -- FIXME: Missing alternative.
   shoeLeafFloat(a,w,0)
  
-shoeError()==
+shoeError lex ==
   n := $n
   $n := $n + 1
   SoftShoeError([$linepos,:n],
     strconc( '"The character whose number is ",
-	    toString codePoint stringChar($ln,n),'" is not a Boot character"))
-  shoeLeafError stringChar($ln,n)
+      toString codePoint stringChar(lexerInputLine lex,n),
+        '" is not a Boot character"))
+  shoeLeafError stringChar(lexerInputLine lex,n)
  
 shoeKeyWord st   == 
   tableValue(shoeKeyTable,st)
diff --git a/src/boot/strap/scanner.clisp b/src/boot/strap/scanner.clisp
index 070235e3..ba33e189 100644
--- a/src/boot/strap/scanner.clisp
+++ b/src/boot/strap/scanner.clisp
@@ -23,116 +23,135 @@
 
 (DEFUN |dqToList| (|s|) (COND ((NULL |s|) NIL) (T (CAR |s|))))
 
-(DEFUN |shoeNextLine| (|s|)
+(DEFSTRUCT (|%Lexer| (:COPIER |copy%Lexer|)) |line| |pos|)
+
+(DEFMACRO |mk%Lexer| (|line| |pos|)
+  (LIST '|MAKE-%Lexer| :|line| |line| :|pos| |pos|))
+
+(DEFMACRO |lexerInputLine| (|bfVar#1|) (LIST '|%Lexer-line| |bfVar#1|))
+
+(DEFMACRO |lexerCurrentPosition| (|bfVar#1|) (LIST '|%Lexer-pos| |bfVar#1|))
+
+(DEFUN |makeLexer| () (|mk%Lexer| NIL NIL))
+
+(DEFUN |shoeNextLine| (|lex| |s|)
   (LET* (|s1| |a|)
-    (DECLARE (SPECIAL |$sz| |$n| |$ln| |$r| |$f| |$linepos|))
+    (DECLARE (SPECIAL |$sz| |$n| |$r| |$f| |$linepos|))
     (COND ((|bStreamNull| |s|) NIL)
           (T (SETQ |$linepos| |s|) (SETQ |$f| (CAR |s|)) (SETQ |$r| (CDR |s|))
-           (SETQ |$ln| (|sourceLineString| |$f|))
-           (SETQ |$n| (|firstNonblankPosition| |$ln| 0))
-           (SETQ |$sz| (LENGTH |$ln|))
+           (SETF (|lexerInputLine| |lex|) (|sourceLineString| |$f|))
+           (SETQ |$n| (|firstNonblankPosition| (|lexerInputLine| |lex|) 0))
+           (SETQ |$sz| (LENGTH (|lexerInputLine| |lex|)))
            (COND ((NULL |$n|) T)
-                 ((CHAR= (SCHAR |$ln| |$n|) |shoeTAB|)
+                 ((CHAR= (SCHAR (|lexerInputLine| |lex|) |$n|) |shoeTAB|)
                   (SETQ |a| (|makeString| (- 7 (REM |$n| 8)) (|char| '| |)))
-                  (SETF (SCHAR |$ln| |$n|) (|char| '| |))
-                  (SETQ |$ln| (CONCAT |a| |$ln|))
+                  (SETF (SCHAR (|lexerInputLine| |lex|) |$n|) (|char| '| |))
+                  (SETF (|lexerInputLine| |lex|)
+                          (CONCAT |a| (|lexerInputLine| |lex|)))
                   (SETQ |s1|
                           (CONS
-                           (|makeSourceLine| |$ln| (|sourceLineNumber| |$f|))
+                           (|makeSourceLine| (|lexerInputLine| |lex|)
+                                             (|sourceLineNumber| |$f|))
                            |$r|))
-                  (|shoeNextLine| |s1|))
+                  (|shoeNextLine| |lex| |s1|))
                  (T T))))))
 
 (DEFUN |shoeLineToks| (|s|)
   (LET* ((|$f| NIL)
          (|$r| NIL)
-         (|$ln| NIL)
          (|$n| NIL)
          (|$sz| NIL)
          (|$floatok| T)
          (|$linepos| |s|)
          |toks|
          |dq|
-         |command|)
-    (DECLARE (SPECIAL |$f| |$r| |$ln| |$n| |$sz| |$floatok| |$linepos|))
-    (COND ((NOT (|shoeNextLine| |s|)) (CONS NIL NIL))
-          ((NULL |$n|) (|shoeLineToks| |$r|))
-          ((CHAR= (SCHAR |$ln| 0) (|char| '|)|))
-           (COND
-            ((SETQ |command| (|shoeLine?| |$ln|))
-             (SETQ |dq|
-                     (|dqUnit|
-                      (|makeToken| |$linepos| (|shoeLeafLine| |command|) 0)))
-             (CONS (LIST |dq|) |$r|))
-            ((SETQ |command| (|shoeLisp?| |$ln|))
-             (|shoeLispToken| |$r| |command|))
-            (T (|shoeLineToks| |$r|))))
-          (T (SETQ |toks| NIL)
-           (LOOP
-            (COND ((NOT (< |$n| |$sz|)) (RETURN NIL))
-                  (T (SETQ |toks| (|dqAppend| |toks| (|shoeToken|))))))
-           (COND ((NULL |toks|) (|shoeLineToks| |$r|))
-                 (T (CONS (LIST |toks|) |$r|)))))))
-
-(DEFUN |shoeLispToken| (|s| |string|)
+         |command|
+         |lex|)
+    (DECLARE (SPECIAL |$f| |$r| |$n| |$sz| |$floatok| |$linepos|))
+    (PROGN
+     (SETQ |lex| (|makeLexer|))
+     (COND ((NOT (|shoeNextLine| |lex| |s|)) (CONS NIL NIL))
+           ((NULL |$n|) (|shoeLineToks| |$r|))
+           ((CHAR= (SCHAR (|lexerInputLine| |lex|) 0) (|char| '|)|))
+            (COND
+             ((SETQ |command| (|shoeLine?| (|lexerInputLine| |lex|)))
+              (SETQ |dq|
+                      (|dqUnit|
+                       (|makeToken| |$linepos| (|shoeLeafLine| |command|) 0)))
+              (CONS (LIST |dq|) |$r|))
+             ((SETQ |command| (|shoeLisp?| (|lexerInputLine| |lex|)))
+              (|shoeLispToken| |lex| |$r| |command|))
+             (T (|shoeLineToks| |$r|))))
+           (T (SETQ |toks| NIL)
+            (LOOP
+             (COND ((NOT (< |$n| |$sz|)) (RETURN NIL))
+                   (T (SETQ |toks| (|dqAppend| |toks| (|shoeToken| |lex|))))))
+            (COND ((NULL |toks|) (|shoeLineToks| |$r|))
+                  (T (CONS (LIST |toks|) |$r|))))))))
+
+(DEFUN |shoeLispToken| (|lex| |s| |string|)
   (LET* (|dq| |st| |r| |LETTMP#1| |linepos| |ln|)
-    (DECLARE (SPECIAL |$linepos| |$ln|))
+    (DECLARE (SPECIAL |$linepos|))
     (PROGN
      (COND
       ((OR (EQL (LENGTH |string|) 0) (CHAR= (SCHAR |string| 0) (|char| '|;|)))
        (SETQ |string| "")))
-     (SETQ |ln| |$ln|)
+     (SETQ |ln| (|lexerInputLine| |lex|))
      (SETQ |linepos| |$linepos|)
-     (SETQ |LETTMP#1| (|shoeAccumulateLines| |s| |string|))
+     (SETQ |LETTMP#1| (|shoeAccumulateLines| |lex| |s| |string|))
      (SETQ |r| (CAR |LETTMP#1|))
      (SETQ |st| (CDR |LETTMP#1|))
      (SETQ |dq| (|dqUnit| (|makeToken| |linepos| (|shoeLeafLisp| |st|) 0)))
      (CONS (LIST |dq|) |r|))))
 
-(DEFUN |shoeAccumulateLines| (|s| |string|)
+(DEFUN |shoeAccumulateLines| (|lex| |s| |string|)
   (LET* (|a| |command|)
-    (DECLARE (SPECIAL |$ln| |$r| |$n|))
-    (COND ((NOT (|shoeNextLine| |s|)) (CONS |s| |string|))
-          ((NULL |$n|) (|shoeAccumulateLines| |$r| |string|))
-          ((EQL (LENGTH |$ln|) 0) (|shoeAccumulateLines| |$r| |string|))
-          ((CHAR= (SCHAR |$ln| 0) (|char| '|)|))
-           (SETQ |command| (|shoeLisp?| |$ln|))
+    (DECLARE (SPECIAL |$r| |$n|))
+    (COND ((NOT (|shoeNextLine| |lex| |s|)) (CONS |s| |string|))
+          ((NULL |$n|) (|shoeAccumulateLines| |lex| |$r| |string|))
+          ((EQL (LENGTH (|lexerInputLine| |lex|)) 0)
+           (|shoeAccumulateLines| |lex| |$r| |string|))
+          ((CHAR= (SCHAR (|lexerInputLine| |lex|) 0) (|char| '|)|))
+           (SETQ |command| (|shoeLisp?| (|lexerInputLine| |lex|)))
            (COND
             ((AND |command| (PLUSP (LENGTH |command|)))
              (COND
               ((CHAR= (SCHAR |command| 0) (|char| '|;|))
-               (|shoeAccumulateLines| |$r| |string|))
+               (|shoeAccumulateLines| |lex| |$r| |string|))
               ((SETQ |a| (|charPosition| (|char| '|;|) |command| 0))
-               (|shoeAccumulateLines| |$r|
+               (|shoeAccumulateLines| |lex| |$r|
                                       (CONCAT |string|
                                               (|subString| |command| 0
                                                            (- |a| 1)))))
-              (T (|shoeAccumulateLines| |$r| (CONCAT |string| |command|)))))
-            (T (|shoeAccumulateLines| |$r| |string|))))
+              (T
+               (|shoeAccumulateLines| |lex| |$r|
+                                      (CONCAT |string| |command|)))))
+            (T (|shoeAccumulateLines| |lex| |$r| |string|))))
           (T (CONS |s| |string|)))))
 
 (DEFUN |shoeCloser| (|t|)
   (|symbolMember?| (|shoeKeyWord| |t|) '(CPAREN CBRACK)))
 
-(DEFUN |shoeToken| ()
+(DEFUN |shoeToken| (|lex|)
   (LET* (|b| |ch| |n| |linepos|)
-    (DECLARE (SPECIAL |$ln| |$n| |$linepos|))
+    (DECLARE (SPECIAL |$n| |$linepos|))
     (PROGN
      (SETQ |linepos| |$linepos|)
      (SETQ |n| |$n|)
-     (SETQ |ch| (SCHAR |$ln| |$n|))
+     (SETQ |ch| (SCHAR (|lexerInputLine| |lex|) |$n|))
      (SETQ |b|
-             (COND ((|shoeStartsComment|) (|shoeComment|) NIL)
-                   ((|shoeStartsNegComment|) (|shoeNegComment|) NIL)
-                   ((CHAR= |ch| (|char| '!)) (|shoeLispEscape|))
-                   ((|shoePunctuation| (CHAR-CODE |ch|)) (|shoePunct|))
-                   ((|shoeStartsId| |ch|) (|shoeWord| NIL))
-                   ((CHAR= |ch| (|char| '| |)) (|shoeSpace|) NIL)
-                   ((CHAR= |ch| (|char| '|"|)) (|shoeString|))
-                   ((DIGIT-CHAR-P |ch|) (|shoeNumber|))
-                   ((CHAR= |ch| (|char| '_)) (|shoeEscape|))
+             (COND ((|shoeStartsComment| |lex|) (|shoeComment| |lex|) NIL)
+                   ((|shoeStartsNegComment| |lex|) (|shoeNegComment| |lex|)
+                    NIL)
+                   ((CHAR= |ch| (|char| '!)) (|shoeLispEscape| |lex|))
+                   ((|shoePunctuation| (CHAR-CODE |ch|)) (|shoePunct| |lex|))
+                   ((|shoeStartsId| |ch|) (|shoeWord| |lex| NIL))
+                   ((CHAR= |ch| (|char| '| |)) (|shoeSpace| |lex|) NIL)
+                   ((CHAR= |ch| (|char| '|"|)) (|shoeString| |lex|))
+                   ((DIGIT-CHAR-P |ch|) (|shoeNumber| |lex|))
+                   ((CHAR= |ch| (|char| '_)) (|shoeEscape| |lex|))
                    ((EQUAL |ch| |shoeTAB|) (SETQ |$n| (+ |$n| 1)) NIL)
-                   (T (|shoeError|))))
+                   (T (|shoeError| |lex|))))
      (COND ((NULL |b|) NIL) (T (|dqUnit| (|makeToken| |linepos| |b| |n|)))))))
 
 (DEFUN |shoeLeafId| (|x|) (LIST 'ID (INTERN |x|)))
@@ -164,147 +183,162 @@
 
 (DEFUN |shoeLeafSpaces| (|x|) (LIST 'SPACES |x|))
 
-(DEFUN |shoeLispEscape| ()
+(DEFUN |shoeLispEscape| (|lex|)
   (LET* (|n| |exp| |a|)
-    (DECLARE (SPECIAL |$ln| |$linepos| |$sz| |$n|))
+    (DECLARE (SPECIAL |$linepos| |$sz| |$n|))
     (PROGN
      (SETQ |$n| (+ |$n| 1))
      (COND
       ((NOT (< |$n| |$sz|))
        (|SoftShoeError| (CONS |$linepos| |$n|) "lisp escape error")
-       (|shoeLeafError| (SCHAR |$ln| |$n|)))
-      (T (SETQ |a| (|shoeReadLispString| |$ln| |$n|))
+       (|shoeLeafError| (SCHAR (|lexerInputLine| |lex|) |$n|)))
+      (T (SETQ |a| (|shoeReadLispString| (|lexerInputLine| |lex|) |$n|))
        (COND
         ((NULL |a|)
          (|SoftShoeError| (CONS |$linepos| |$n|) "lisp escape error")
-         (|shoeLeafError| (SCHAR |$ln| |$n|)))
+         (|shoeLeafError| (SCHAR (|lexerInputLine| |lex|) |$n|)))
         (T (SETQ |exp| (CAR |a|)) (SETQ |n| (CADR |a|))
          (COND ((NULL |n|) (SETQ |$n| |$sz|) (|shoeLeafLispExp| |exp|))
                (T (SETQ |$n| |n|) (|shoeLeafLispExp| |exp|))))))))))
 
-(DEFUN |shoeEscape| ()
+(DEFUN |shoeEscape| (|lex|)
   (DECLARE (SPECIAL |$n|))
-  (PROGN (SETQ |$n| (+ |$n| 1)) (COND ((|shoeEsc|) (|shoeWord| T)) (T NIL))))
+  (PROGN
+   (SETQ |$n| (+ |$n| 1))
+   (COND ((|shoeEsc| |lex|) (|shoeWord| |lex| T)) (T NIL))))
 
-(DEFUN |shoeEsc| ()
+(DEFUN |shoeEsc| (|lex|)
   (LET* (|n1|)
-    (DECLARE (SPECIAL |$ln| |$r| |$sz| |$n|))
+    (DECLARE (SPECIAL |$r| |$sz| |$n|))
     (COND
      ((NOT (< |$n| |$sz|))
       (COND
-       ((|shoeNextLine| |$r|)
-        (LOOP (COND (|$n| (RETURN NIL)) (T (|shoeNextLine| |$r|)))) (|shoeEsc|)
-        NIL)
+       ((|shoeNextLine| |lex| |$r|)
+        (LOOP (COND (|$n| (RETURN NIL)) (T (|shoeNextLine| |lex| |$r|))))
+        (|shoeEsc| |lex|) NIL)
        (T NIL)))
-     (T (SETQ |n1| (|firstNonblankPosition| |$ln| |$n|))
+     (T (SETQ |n1| (|firstNonblankPosition| (|lexerInputLine| |lex|) |$n|))
       (COND
-       ((NULL |n1|) (|shoeNextLine| |$r|)
-        (LOOP (COND (|$n| (RETURN NIL)) (T (|shoeNextLine| |$r|)))) (|shoeEsc|)
-        NIL)
+       ((NULL |n1|) (|shoeNextLine| |lex| |$r|)
+        (LOOP (COND (|$n| (RETURN NIL)) (T (|shoeNextLine| |lex| |$r|))))
+        (|shoeEsc| |lex|) NIL)
        (T T))))))
 
-(DEFUN |shoeStartsComment| ()
+(DEFUN |shoeStartsComment| (|lex|)
   (LET* (|www|)
-    (DECLARE (SPECIAL |$ln| |$sz| |$n|))
+    (DECLARE (SPECIAL |$sz| |$n|))
     (COND
      ((< |$n| |$sz|)
       (COND
-       ((CHAR= (SCHAR |$ln| |$n|) (|char| '+)) (SETQ |www| (+ |$n| 1))
+       ((CHAR= (SCHAR (|lexerInputLine| |lex|) |$n|) (|char| '+))
+        (SETQ |www| (+ |$n| 1))
         (COND ((NOT (< |www| |$sz|)) NIL)
-              (T (CHAR= (SCHAR |$ln| |www|) (|char| '+)))))
+              (T (CHAR= (SCHAR (|lexerInputLine| |lex|) |www|) (|char| '+)))))
        (T NIL)))
      (T NIL))))
 
-(DEFUN |shoeStartsNegComment| ()
+(DEFUN |shoeStartsNegComment| (|lex|)
   (LET* (|www|)
-    (DECLARE (SPECIAL |$ln| |$sz| |$n|))
+    (DECLARE (SPECIAL |$sz| |$n|))
     (COND
      ((< |$n| |$sz|)
       (COND
-       ((CHAR= (SCHAR |$ln| |$n|) (|char| '-)) (SETQ |www| (+ |$n| 1))
+       ((CHAR= (SCHAR (|lexerInputLine| |lex|) |$n|) (|char| '-))
+        (SETQ |www| (+ |$n| 1))
         (COND ((NOT (< |www| |$sz|)) NIL)
-              (T (CHAR= (SCHAR |$ln| |www|) (|char| '-)))))
+              (T (CHAR= (SCHAR (|lexerInputLine| |lex|) |www|) (|char| '-)))))
        (T NIL)))
      (T NIL))))
 
-(DEFUN |shoeNegComment| ()
+(DEFUN |shoeNegComment| (|lex|)
   (LET* (|n|)
-    (DECLARE (SPECIAL |$ln| |$sz| |$n|))
+    (DECLARE (SPECIAL |$sz| |$n|))
     (PROGN
      (SETQ |n| |$n|)
      (SETQ |$n| |$sz|)
-     (|shoeLeafNegComment| (|subString| |$ln| |n|)))))
+     (|shoeLeafNegComment| (|subString| (|lexerInputLine| |lex|) |n|)))))
 
-(DEFUN |shoeComment| ()
+(DEFUN |shoeComment| (|lex|)
   (LET* (|n|)
-    (DECLARE (SPECIAL |$ln| |$sz| |$n|))
+    (DECLARE (SPECIAL |$sz| |$n|))
     (PROGN
      (SETQ |n| |$n|)
      (SETQ |$n| |$sz|)
-     (|shoeLeafComment| (|subString| |$ln| |n|)))))
+     (|shoeLeafComment| (|subString| (|lexerInputLine| |lex|) |n|)))))
 
-(DEFUN |shoePunct| ()
+(DEFUN |shoePunct| (|lex|)
   (LET* (|sss|)
-    (DECLARE (SPECIAL |$n| |$ln|))
+    (DECLARE (SPECIAL |$n|))
     (PROGN
-     (SETQ |sss| (|shoeMatch| |$ln| |$n|))
+     (SETQ |sss| (|shoeMatch| (|lexerInputLine| |lex|) |$n|))
      (SETQ |$n| (+ |$n| (LENGTH |sss|)))
-     (|shoeKeyTr| |sss|))))
+     (|shoeKeyTr| |lex| |sss|))))
 
-(DEFUN |shoeKeyTr| (|w|)
+(DEFUN |shoeKeyTr| (|lex| |w|)
   (DECLARE (SPECIAL |$floatok|))
   (COND
    ((EQ (|shoeKeyWord| |w|) 'DOT)
-    (COND (|$floatok| (|shoePossFloat| |w|)) (T (|shoeLeafKey| |w|))))
+    (COND (|$floatok| (|shoePossFloat| |lex| |w|)) (T (|shoeLeafKey| |w|))))
    (T (SETQ |$floatok| (NOT (|shoeCloser| |w|))) (|shoeLeafKey| |w|))))
 
-(DEFUN |shoePossFloat| (|w|)
-  (DECLARE (SPECIAL |$ln| |$sz| |$n|))
+(DEFUN |shoePossFloat| (|lex| |w|)
+  (DECLARE (SPECIAL |$sz| |$n|))
   (COND
-   ((OR (NOT (< |$n| |$sz|)) (NOT (DIGIT-CHAR-P (SCHAR |$ln| |$n|))))
+   ((OR (NOT (< |$n| |$sz|))
+        (NOT (DIGIT-CHAR-P (SCHAR (|lexerInputLine| |lex|) |$n|))))
     (|shoeLeafKey| |w|))
-   (T (SETQ |w| (|shoeInteger|)) (|shoeExponent| "0" |w|))))
+   (T (SETQ |w| (|shoeInteger| |lex|)) (|shoeExponent| |lex| "0" |w|))))
 
-(DEFUN |shoeSpace| ()
+(DEFUN |shoeSpace| (|lex|)
   (LET* (|n|)
-    (DECLARE (SPECIAL |$floatok| |$ln| |$n|))
+    (DECLARE (SPECIAL |$floatok| |$n|))
     (PROGN
      (SETQ |n| |$n|)
-     (SETQ |$n| (|firstNonblankPosition| |$ln| |$n|))
+     (SETQ |$n| (|firstNonblankPosition| (|lexerInputLine| |lex|) |$n|))
      (SETQ |$floatok| T)
-     (COND ((NULL |$n|) (|shoeLeafSpaces| 0) (SETQ |$n| (LENGTH |$ln|)))
-           (T (|shoeLeafSpaces| (- |$n| |n|)))))))
+     (COND
+      ((NULL |$n|) (|shoeLeafSpaces| 0)
+       (SETQ |$n| (LENGTH (|lexerInputLine| |lex|))))
+      (T (|shoeLeafSpaces| (- |$n| |n|)))))))
 
-(DEFUN |shoeString| ()
+(DEFUN |shoeString| (|lex|)
   (DECLARE (SPECIAL |$floatok| |$n|))
   (PROGN
    (SETQ |$n| (+ |$n| 1))
    (SETQ |$floatok| NIL)
-   (|shoeLeafString| (|shoeS|))))
+   (|shoeLeafString| (|shoeS| |lex|))))
 
-(DEFUN |shoeS| ()
+(DEFUN |shoeS| (|lex|)
   (LET* (|b| |a| |str| |mn| |escsym| |strsym| |n|)
-    (DECLARE (SPECIAL |$ln| |$linepos| |$sz| |$n|))
+    (DECLARE (SPECIAL |$linepos| |$sz| |$n|))
     (COND
      ((NOT (< |$n| |$sz|))
       (|SoftShoeError| (CONS |$linepos| |$n|) "quote added") "")
      (T (SETQ |n| |$n|)
-      (SETQ |strsym| (OR (|charPosition| (|char| '|"|) |$ln| |$n|) |$sz|))
-      (SETQ |escsym| (OR (|charPosition| (|char| '_) |$ln| |$n|) |$sz|))
+      (SETQ |strsym|
+              (OR (|charPosition| (|char| '|"|) (|lexerInputLine| |lex|) |$n|)
+                  |$sz|))
+      (SETQ |escsym|
+              (OR (|charPosition| (|char| '_) (|lexerInputLine| |lex|) |$n|)
+                  |$sz|))
       (SETQ |mn| (MIN |strsym| |escsym|))
       (COND
        ((EQUAL |mn| |$sz|) (SETQ |$n| |$sz|)
         (|SoftShoeError| (CONS |$linepos| |$n|) "quote added")
-        (|subString| |$ln| |n|))
+        (|subString| (|lexerInputLine| |lex|) |n|))
        ((EQUAL |mn| |strsym|) (SETQ |$n| (+ |mn| 1))
-        (|subString| |$ln| |n| (- |mn| |n|)))
-       (T (SETQ |str| (|subString| |$ln| |n| (- |mn| |n|)))
-        (SETQ |$n| (+ |mn| 1)) (SETQ |a| (|shoeEsc|))
+        (|subString| (|lexerInputLine| |lex|) |n| (- |mn| |n|)))
+       (T (SETQ |str| (|subString| (|lexerInputLine| |lex|) |n| (- |mn| |n|)))
+        (SETQ |$n| (+ |mn| 1)) (SETQ |a| (|shoeEsc| |lex|))
         (SETQ |b|
                 (COND
-                 (|a| (SETQ |str| (CONCAT |str| (STRING (SCHAR |$ln| |$n|))))
-                  (SETQ |$n| (+ |$n| 1)) (|shoeS|))
-                 (T (|shoeS|))))
+                 (|a|
+                  (SETQ |str|
+                          (CONCAT |str|
+                                  (STRING
+                                   (SCHAR (|lexerInputLine| |lex|) |$n|))))
+                  (SETQ |$n| (+ |$n| 1)) (|shoeS| |lex|))
+                 (T (|shoeS| |lex|))))
         (CONCAT |str| |b|)))))))
 
 (DEFUN |shoeIdEnd| (|line| |n|)
@@ -316,54 +350,60 @@
      (T (SETQ |n| (+ |n| 1)))))
    |n|))
 
-(DEFUN |shoeW| (|b|)
+(DEFUN |shoeW| (|lex| |b|)
   (LET* (|bb| |a| |str| |endid| |l| |n1|)
-    (DECLARE (SPECIAL |$ln| |$sz| |$n|))
+    (DECLARE (SPECIAL |$sz| |$n|))
     (PROGN
      (SETQ |n1| |$n|)
      (SETQ |$n| (+ |$n| 1))
      (SETQ |l| |$sz|)
-     (SETQ |endid| (|shoeIdEnd| |$ln| |$n|))
+     (SETQ |endid| (|shoeIdEnd| (|lexerInputLine| |lex|) |$n|))
      (COND
-      ((OR (EQUAL |endid| |l|) (NOT (CHAR= (SCHAR |$ln| |endid|) (|char| '_))))
+      ((OR (EQUAL |endid| |l|)
+           (NOT (CHAR= (SCHAR (|lexerInputLine| |lex|) |endid|) (|char| '_))))
        (SETQ |$n| |endid|)
-       (LIST |b| (|subString| |$ln| |n1| (- |endid| |n1|))))
-      (T (SETQ |str| (|subString| |$ln| |n1| (- |endid| |n1|)))
-       (SETQ |$n| (+ |endid| 1)) (SETQ |a| (|shoeEsc|))
-       (SETQ |bb| (COND (|a| (|shoeW| T)) (T (LIST |b| ""))))
+       (LIST |b| (|subString| (|lexerInputLine| |lex|) |n1| (- |endid| |n1|))))
+      (T
+       (SETQ |str|
+               (|subString| (|lexerInputLine| |lex|) |n1| (- |endid| |n1|)))
+       (SETQ |$n| (+ |endid| 1)) (SETQ |a| (|shoeEsc| |lex|))
+       (SETQ |bb| (COND (|a| (|shoeW| |lex| T)) (T (LIST |b| ""))))
        (LIST (OR (ELT |bb| 0) |b|) (CONCAT |str| (ELT |bb| 1))))))))
 
-(DEFUN |shoeWord| (|esp|)
+(DEFUN |shoeWord| (|lex| |esp|)
   (LET* (|w| |aaa|)
     (DECLARE (SPECIAL |$floatok|))
     (PROGN
-     (SETQ |aaa| (|shoeW| NIL))
+     (SETQ |aaa| (|shoeW| |lex| NIL))
      (SETQ |w| (ELT |aaa| 1))
      (SETQ |$floatok| NIL)
      (COND ((OR |esp| (ELT |aaa| 0)) (|shoeLeafId| |w|))
            ((|shoeKeyWordP| |w|) (SETQ |$floatok| T) (|shoeLeafKey| |w|))
            (T (|shoeLeafId| |w|))))))
 
-(DEFUN |shoeInteger| () (|shoeInteger1| NIL))
+(DEFUN |shoeInteger| (|lex|) (|shoeInteger1| |lex| NIL))
 
-(DEFUN |shoeInteger1| (|zro|)
+(DEFUN |shoeInteger1| (|lex| |zro|)
   (LET* (|bb| |a| |str| |l| |n|)
-    (DECLARE (SPECIAL |$ln| |$sz| |$n|))
+    (DECLARE (SPECIAL |$sz| |$n|))
     (PROGN
      (SETQ |n| |$n|)
      (SETQ |l| |$sz|)
      (LOOP
       (COND
-       ((NOT (AND (< |$n| |l|) (DIGIT-CHAR-P (SCHAR |$ln| |$n|))))
+       ((NOT
+         (AND (< |$n| |l|)
+              (DIGIT-CHAR-P (SCHAR (|lexerInputLine| |lex|) |$n|))))
         (RETURN NIL))
        (T (SETQ |$n| (+ |$n| 1)))))
      (COND
-      ((OR (EQUAL |$n| |l|) (NOT (CHAR= (SCHAR |$ln| |$n|) (|char| '_))))
+      ((OR (EQUAL |$n| |l|)
+           (NOT (CHAR= (SCHAR (|lexerInputLine| |lex|) |$n|) (|char| '_))))
        (COND ((AND (EQUAL |n| |$n|) |zro|) "0")
-             (T (|subString| |$ln| |n| (- |$n| |n|)))))
-      (T (SETQ |str| (|subString| |$ln| |n| (- |$n| |n|)))
-       (SETQ |$n| (+ |$n| 1)) (SETQ |a| (|shoeEsc|))
-       (SETQ |bb| (|shoeInteger1| |zro|)) (CONCAT |str| |bb|))))))
+             (T (|subString| (|lexerInputLine| |lex|) |n| (- |$n| |n|)))))
+      (T (SETQ |str| (|subString| (|lexerInputLine| |lex|) |n| (- |$n| |n|)))
+       (SETQ |$n| (+ |$n| 1)) (SETQ |a| (|shoeEsc| |lex|))
+       (SETQ |bb| (|shoeInteger1| |lex| |zro|)) (CONCAT |str| |bb|))))))
 
 (DEFUN |shoeIntValue| (|s|)
   (LET* (|d| |ival| |ns|)
@@ -378,41 +418,46 @@
         (SETQ |i| (+ |i| 1))))
      |ival|)))
 
-(DEFUN |shoeNumber| ()
+(DEFUN |shoeNumber| (|lex|)
   (LET* (|w| |n| |a|)
-    (DECLARE (SPECIAL |$ln| |$floatok| |$sz| |$n|))
+    (DECLARE (SPECIAL |$floatok| |$sz| |$n|))
     (PROGN
-     (SETQ |a| (|shoeInteger|))
+     (SETQ |a| (|shoeInteger| |lex|))
      (COND ((NOT (< |$n| |$sz|)) (|shoeLeafInteger| |a|))
-           ((AND |$floatok| (CHAR= (SCHAR |$ln| |$n|) (|char| '|.|)))
+           ((AND |$floatok|
+                 (CHAR= (SCHAR (|lexerInputLine| |lex|) |$n|) (|char| '|.|)))
             (SETQ |n| |$n|) (SETQ |$n| (+ |$n| 1))
             (COND
-             ((AND (< |$n| |$sz|) (CHAR= (SCHAR |$ln| |$n|) (|char| '|.|)))
+             ((AND (< |$n| |$sz|)
+                   (CHAR= (SCHAR (|lexerInputLine| |lex|) |$n|) (|char| '|.|)))
               (SETQ |$n| |n|) (|shoeLeafInteger| |a|))
-             (T (SETQ |w| (|shoeInteger1| T)) (|shoeExponent| |a| |w|))))
+             (T (SETQ |w| (|shoeInteger1| |lex| T))
+              (|shoeExponent| |lex| |a| |w|))))
            (T (|shoeLeafInteger| |a|))))))
 
-(DEFUN |shoeExponent| (|a| |w|)
+(DEFUN |shoeExponent| (|lex| |a| |w|)
   (LET* (|c1| |e| |c| |n|)
-    (DECLARE (SPECIAL |$ln| |$sz| |$n|))
+    (DECLARE (SPECIAL |$sz| |$n|))
     (COND ((NOT (< |$n| |$sz|)) (|shoeLeafFloat| |a| |w| 0))
-          (T (SETQ |n| |$n|) (SETQ |c| (SCHAR |$ln| |$n|))
+          (T (SETQ |n| |$n|) (SETQ |c| (SCHAR (|lexerInputLine| |lex|) |$n|))
            (COND
             ((OR (CHAR= |c| (|char| 'E)) (CHAR= |c| (|char| '|e|)))
              (SETQ |$n| (+ |$n| 1))
              (COND
               ((NOT (< |$n| |$sz|)) (SETQ |$n| |n|)
                (|shoeLeafFloat| |a| |w| 0))
-              ((DIGIT-CHAR-P (SCHAR |$ln| |$n|)) (SETQ |e| (|shoeInteger|))
-               (SETQ |e| (|shoeIntValue| |e|)) (|shoeLeafFloat| |a| |w| |e|))
-              (T (SETQ |c1| (SCHAR |$ln| |$n|))
+              ((DIGIT-CHAR-P (SCHAR (|lexerInputLine| |lex|) |$n|))
+               (SETQ |e| (|shoeInteger| |lex|)) (SETQ |e| (|shoeIntValue| |e|))
+               (|shoeLeafFloat| |a| |w| |e|))
+              (T (SETQ |c1| (SCHAR (|lexerInputLine| |lex|) |$n|))
                (COND
                 ((OR (CHAR= |c1| (|char| '+)) (CHAR= |c1| (|char| '-)))
                  (SETQ |$n| (+ |$n| 1))
                  (COND
                   ((NOT (< |$n| |$sz|)) (SETQ |$n| |n|)
                    (|shoeLeafFloat| |a| |w| 0))
-                  ((DIGIT-CHAR-P (SCHAR |$ln| |$n|)) (SETQ |e| (|shoeInteger|))
+                  ((DIGIT-CHAR-P (SCHAR (|lexerInputLine| |lex|) |$n|))
+                   (SETQ |e| (|shoeInteger| |lex|))
                    (SETQ |e| (|shoeIntValue| |e|))
                    (|shoeLeafFloat| |a| |w|
                                     (COND ((CHAR= |c1| (|char| '-)) (- |e|))
@@ -420,17 +465,19 @@
                   (T (SETQ |$n| |n|) (|shoeLeafFloat| |a| |w| 0))))))))
             (T (|shoeLeafFloat| |a| |w| 0)))))))
 
-(DEFUN |shoeError| ()
+(DEFUN |shoeError| (|lex|)
   (LET* (|n|)
-    (DECLARE (SPECIAL |$ln| |$linepos| |$n|))
+    (DECLARE (SPECIAL |$linepos| |$n|))
     (PROGN
      (SETQ |n| |$n|)
      (SETQ |$n| (+ |$n| 1))
      (|SoftShoeError| (CONS |$linepos| |n|)
                       (CONCAT "The character whose number is "
-                              (WRITE-TO-STRING (CHAR-CODE (SCHAR |$ln| |n|)))
+                              (WRITE-TO-STRING
+                               (CHAR-CODE
+                                (SCHAR (|lexerInputLine| |lex|) |n|)))
                               " is not a Boot character"))
-     (|shoeLeafError| (SCHAR |$ln| |n|)))))
+     (|shoeLeafError| (SCHAR (|lexerInputLine| |lex|) |n|)))))
 
 (DEFUN |shoeKeyWord| (|st|) (|tableValue| |shoeKeyTable| |st|))