* boot/scanner.boot: Eliminate fluid variable $n.

	(lexerRefresh?): New.
	(lexerSetLine!): Likewise.
	(lexerSkipBlank!): Likewise.
	(lexerSkipToEnd!): Likewise.
	(lexerAdvancePosition!): Likewise.
	(lexerCharCountToCompleteTab): Likewise.
	(lexerCurrentChar): Likewise.
	(lexerCharPosition): Likewise.
	(lexerCharacterAt): Likewise.
	(lexerEol?): Likewise.

3 files changed, 379 insertions, 262 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 786d22e7..debe24eb 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,19 @@
 2012-05-24  Gabriel Dos Reis  <gdr@cs.tamu.edu>
 
+	* boot/scanner.boot: Eliminate fluid variable $n.
+	(lexerRefresh?): New.
+	(lexerSetLine!): Likewise.
+	(lexerSkipBlank!): Likewise.
+	(lexerSkipToEnd!): Likewise.
+	(lexerAdvancePosition!): Likewise.
+	(lexerCharCountToCompleteTab): Likewise.
+	(lexerCurrentChar): Likewise.
+	(lexerCharPosition): Likewise.
+	(lexerCharacterAt): Likewise.
+	(lexerEol?): Likewise.
+
+2012-05-24  Gabriel Dos Reis  <gdr@cs.tamu.edu>
+
 	* boot/scanner.boot (lexerLineLength): New.
 	(shoeNextLine): Use it in replacement of $sz.
 	(shoeLineToks): Likewise.
diff --git a/src/boot/scanner.boot b/src/boot/scanner.boot
index a87f5e48..b9272757 100644
--- a/src/boot/scanner.boot
+++ b/src/boot/scanner.boot
@@ -62,28 +62,80 @@ dqToList s ==
  
 --%
 structure %Lexer ==
-  Record(line: %String, pos: %Short) with
+  Record(line: %String, pos: %Maybe %Short) with
     lexerLineString == (.line)
     lexerCurrentPosition == (.pos)
 
 makeLexer() ==
   mk%Lexer(nil,nil)
 
+++ Return true if the lexer wants a fresh input line.
+macro lexerRefresh? lex ==
+  lexerCurrentPosition lex = nil
+
 macro lexerLineLength lex ==
   #lexerLineString lex
 
+++ Make the lexer ready to process a new input line.
+lexerSetLine!(lex,line) ==
+  lexerLineString(lex) := line
+  lexerCurrentPosition(lex) := 0
+
+++ Adjust the current position to the next non-blank character.
+lexerSkipBlank! lex ==
+  lexerCurrentPosition(lex) :=
+    firstNonblankPosition(lexerLineString lex,lexerCurrentPosition lex)
+
+++ Move the current position by a given amount   
+lexerAdvancePosition!(lex,n == 1) ==
+  lexerCurrentPosition(lex) := lexerCurrentPosition lex + n
+
+++ Move the current position to end of line.
+lexerSkipToEnd! lex ==
+  lexerCurrentPosition(lex) := lexerLineLength lex
+
+++ Set the current position at a given index.
+lexerPosition!(lex,k) ==
+  lexerCurrentPosition(lex) := k
+
+++ Return the amount of space characters need to complete a tab
+++ to its next logical stop.
+lexerCharCountToCompleteTab lex ==
+  7 - (lexerCurrentPosition lex rem 8)
+
+
+++ Access the character the current position.
+macro lexerCurrentChar lex ==
+  stringChar(lexerLineString lex,lexerCurrentPosition lex)
+
+++ Access the character at a given position.
+macro lexerCharacterAt(lex,k) ==
+  stringChar(lexerLineString lex,k)
+
+++ Return the position of next character `c', or end of line.
+lexerCharPosition(lex,c) ==
+  charPosition(c,lexerLineString lex,lexerCurrentPosition lex)
+    or lexerLineLength lex
+
+++ Return true if the current position is at end of line.
+lexerEol? lex ==
+  lexerCurrentPosition lex >= lexerLineLength lex
+
 --%  
 
+lexerReadLisp lex ==
+  shoeReadLispString(lexerLineString lex,lexerCurrentPosition lex)
+
 shoeNextLine(lex,s) ==
   bStreamNull s => false
   $linepos := s
   [$f,:$r] := s
-  lexerLineString(lex) := sourceLineString $f
-  $n := firstNonblankPosition(lexerLineString lex,0)
-  $n = nil => true
-  stringChar(lexerLineString lex,$n) = shoeTAB =>
-    a := makeString(7-($n rem 8),char " ")
-    stringChar(lexerLineString lex,$n) := char " "
+  lexerSetLine!(lex,sourceLineString $f)
+  lexerSkipBlank! lex
+  lexerRefresh? lex => true
+  lexerCurrentChar lex = shoeTAB =>
+    a := makeString(lexerCharCountToCompleteTab lex,char " ")
+    lexerCurrentChar(lex) := char " "
     lexerLineString(lex) := strconc(a,lexerLineString lex)
     s1 := [makeSourceLine(lexerLineString lex,sourceLineNumber $f),:$r]
     shoeNextLine(lex,s1)
@@ -92,20 +144,19 @@ shoeNextLine(lex,s) ==
 shoeLineToks s ==
   $f: local := nil
   $r: local := nil
-  $n: local := nil
   $floatok: local := true
   $linepos: local := s
   lex := makeLexer()
   not shoeNextLine(lex,s) =>  [nil,:nil]
-  $n = nil => shoeLineToks $r
-  stringChar(lexerLineString lex,0) = char ")" =>
+  lexerRefresh? lex => shoeLineToks $r
+  lexerCharacterAt(lex,0) = char ")" =>
     command := shoeLine? lexerLineString lex =>
       dq := dqUnit makeToken($linepos,shoeLeafLine command,0)
       [[dq],:$r]
     command := shoeLisp? lexerLineString lex => shoeLispToken(lex,$r,command)
     shoeLineToks $r
   toks := []
-  while $n < lexerLineLength lex repeat
+  while not lexerEol? lex repeat
     toks := dqAppend(toks,shoeToken lex)
   toks = nil => shoeLineToks $r
   [[toks],:$r]
@@ -121,9 +172,9 @@ shoeLispToken(lex,s,string)==
  
 shoeAccumulateLines(lex,s,string)==
   not shoeNextLine(lex,s) =>  [s,:string]
-  $n = nil => shoeAccumulateLines(lex,$r,string)
+  lexerRefresh? lex => shoeAccumulateLines(lex,$r,string)
   lexerLineLength lex = 0 => shoeAccumulateLines(lex,$r,string)
-  stringChar(lexerLineString lex,0) = char ")" =>
+  lexerCharacterAt(lex,0) = char ")" =>
     command := shoeLisp? lexerLineString lex
     command and #command > 0 =>
       stringChar(command,0) = char ";" =>
@@ -141,8 +192,8 @@ shoeCloser t ==
  
 shoeToken lex ==
   linepos := $linepos
-  n := $n
-  ch := stringChar(lexerLineString lex,$n)
+  n := lexerCurrentPosition lex
+  ch := lexerCurrentChar lex
   b :=
     shoeStartsComment lex =>
       shoeComment lex
@@ -160,7 +211,7 @@ shoeToken lex ==
     digit? ch => shoeNumber lex
     ch = char "__" => shoeEscape lex
     ch = shoeTAB =>
-      $n := $n + 1
+      lexerAdvancePosition! lex
       []
     shoeError lex
   b = nil => nil
@@ -206,73 +257,74 @@ shoeLeafSpaces x  ==
   ["SPACES",x]
  
 shoeLispEscape lex ==
-  $n := $n + 1
-  $n >= lexerLineLength lex =>
-    SoftShoeError([$linepos,:$n],'"lisp escape error")
-    shoeLeafError stringChar(lexerLineString lex,$n)
-  a := shoeReadLispString(lexerLineString lex,$n)
+  lexerAdvancePosition! lex
+  lexerEol? lex =>
+    SoftShoeError([$linepos,:lexerCurrentPosition lex],'"lisp escape error")
+    shoeLeafError lexerCurrentChar lex
+  a := lexerReadLisp lex
   a = nil =>
-    SoftShoeError([$linepos,:$n],'"lisp escape error")
-    shoeLeafError stringChar(lexerLineString lex,$n)
+    SoftShoeError([$linepos,:lexerCurrentPosition lex],'"lisp escape error")
+    shoeLeafError lexerCurrentChar lex
   [exp,n] := a
   n = nil =>
-    $n := lexerLineLength lex
+    lexerSkipToEnd! lex
     shoeLeafLispExp exp
-  $n := n
+  lexerPosition!(lex,n)
   shoeLeafLispExp  exp
 
 shoeEscape lex ==
-  $n := $n + 1
+  lexerAdvancePosition! lex
   shoeEsc lex => shoeWord(lex,true)
   nil
  
 shoeEsc lex ==
-  $n >= lexerLineLength lex =>
+  lexerEol? lex =>
     shoeNextLine(lex,$r) =>
-      while $n = nil repeat shoeNextLine(lex,$r)
+      while lexerRefresh? lex repeat
+        shoeNextLine(lex,$r)
       shoeEsc lex
       false
     false
-  n1 := firstNonblankPosition(lexerLineString lex,$n)
+  n1 := firstNonblankPosition(lexerLineString lex,lexerCurrentPosition lex)
   n1 = nil =>
     shoeNextLine(lex,$r)
-    while $n = nil repeat 
+    while lexerRefresh? lex repeat 
       shoeNextLine(lex,$r)
     shoeEsc lex
     false
   true
  
 shoeStartsComment lex ==
-  $n < lexerLineLength lex =>
-    stringChar(lexerLineString lex,$n) = char "+" => 
-       www := $n + 1
+  not lexerEol? lex =>
+    lexerCurrentChar lex = char "+" => 
+       www := lexerCurrentPosition lex + 1
        www >= lexerLineLength lex => false
-       stringChar(lexerLineString lex,www) = char "+"
+       lexerCharacterAt(lex,www) = char "+"
     false
   false
  
 shoeStartsNegComment lex ==
-  $n < lexerLineLength lex =>
-    stringChar(lexerLineString lex,$n) = char "-" =>
-      www := $n + 1
+  not lexerEol? lex =>
+    lexerCurrentChar lex = char "-" =>
+      www := lexerCurrentPosition lex + 1
       www >= lexerLineLength lex => false
-      stringChar(lexerLineString lex,www) = char "-"
+      lexerCharacterAt(lex,www) = char "-"
     false
   false
  
 shoeNegComment lex ==
-  n := $n
-  $n := lexerLineLength lex
+  n := lexerCurrentPosition lex
+  lexerSkipToEnd! lex
   shoeLeafNegComment subString(lexerLineString lex,n)
  
 shoeComment lex ==
-  n := $n
-  $n := lexerLineLength lex
+  n := lexerCurrentPosition lex
+  lexerSkipToEnd! lex
   shoeLeafComment subString(lexerLineString lex,n)
  
 shoePunct lex ==
-  sss := shoeMatch(lexerLineString lex,$n)
-  $n := $n + #sss
+  sss := shoeMatch lex
+  lexerAdvancePosition!(lex,#sss)
   shoeKeyTr(lex,sss)
  
 shoeKeyTr(lex,w) ==
@@ -283,65 +335,66 @@ shoeKeyTr(lex,w) ==
   shoeLeafKey w
  
 shoePossFloat(lex,w)==
-  $n >= lexerLineLength lex or not digit? stringChar(lexerLineString lex,$n) => shoeLeafKey w
+  lexerEol? lex or not digit? lexerCurrentChar lex => shoeLeafKey w
   w := shoeInteger lex
   shoeExponent(lex,'"0",w)
  
 shoeSpace lex ==
-  n := $n
-  $n := firstNonblankPosition(lexerLineString lex,$n)
+  n := lexerCurrentPosition lex
+  lexerSkipBlank! lex
   $floatok := true
-  $n = nil =>
+  lexerRefresh? lex =>
      shoeLeafSpaces 0
-     $n:= lexerLineLength lex
-  shoeLeafSpaces ($n-n)
+     lexerSkipToEnd! lex
+  shoeLeafSpaces(lexerCurrentPosition lex - n)
  
 shoeString lex ==
-  $n := $n+1
+  lexerAdvancePosition! lex
   $floatok := false
   shoeLeafString shoeS lex
  
 shoeS lex ==
-  $n >= lexerLineLength lex =>
-    SoftShoeError([$linepos,:$n],'"quote added")
+  lexerEol? lex =>
+    SoftShoeError([$linepos,:lexerCurrentPosition lex],'"quote added")
     '""
-  n := $n
-  strsym := charPosition(char "_"",lexerLineString lex,$n) or lexerLineLength lex
-  escsym := charPosition(char "__",lexerLineString lex,$n) or lexerLineLength lex
+  n := lexerCurrentPosition lex
+  strsym := lexerCharPosition(lex,char "_"")
+  escsym := lexerCharPosition(lex,char "__")
   mn := MIN(strsym,escsym)
   mn = lexerLineLength lex =>
-    $n := lexerLineLength lex
-    SoftShoeError([$linepos,:$n],'"quote added")
+    lexerSkipToEnd! lex
+    SoftShoeError([$linepos,:lexerCurrentPosition lex],'"quote added")
     subString(lexerLineString lex,n)
   mn = strsym =>
-    $n := mn + 1
+    lexerPosition!(lex,mn + 1)
     subString(lexerLineString lex,n,mn-n)
   str := subString(lexerLineString lex,n,mn-n)
-  $n := mn+1
+  lexerPosition!(lex,mn + 1)
   a := shoeEsc lex
   b := 
     a =>
-      str := strconc(str,charString stringChar(lexerLineString lex,$n))
-      $n := $n + 1
+      str := strconc(str,charString lexerCurrentChar lex)
+      lexerAdvancePosition! lex
       shoeS lex
     shoeS lex
   strconc(str,b)
  
-shoeIdEnd(line,n)==
-  while n<#line and shoeIdChar stringChar(line,n) repeat 
-    n := n+1
+shoeIdEnd lex ==
+  n := lexerCurrentPosition lex
+  while n < lexerLineLength lex and shoeIdChar lexerCharacterAt(lex,n) repeat 
+    n := n + 1
   n
  
 shoeW(lex,b) ==
-  n1 := $n
-  $n := $n+1
+  n1 := lexerCurrentPosition lex
+  lexerAdvancePosition! lex
   l := lexerLineLength lex
-  endid := shoeIdEnd(lexerLineString lex,$n)
-  endid = l or stringChar(lexerLineString lex,endid) ~= char "__" => 
-    $n := endid
+  endid := shoeIdEnd lex
+  endid = l or lexerCharacterAt(lex,endid) ~= char "__" => 
+    lexerPosition!(lex,endid)
     [b,subString(lexerLineString lex,n1,endid-n1)]
   str := subString(lexerLineString lex,n1,endid-n1)
-  $n := endid+1
+  lexerPosition!(lex,endid + 1)
   a := shoeEsc lex
   bb := 
     a => shoeW(lex,true)
@@ -362,15 +415,14 @@ shoeInteger lex ==
   shoeInteger1(lex,false)
  
 shoeInteger1(lex,zro) ==
-  n := $n
-  l := lexerLineLength lex
-  while $n <l and digit? stringChar(lexerLineString lex,$n) repeat 
-    $n := $n+1
-  $n = l or stringChar(lexerLineString lex,$n) ~= char "__" =>
-    n = $n and zro => '"0"
-    subString(lexerLineString lex,n,$n - n)
-  str := subString(lexerLineString lex,n,$n - n)
-  $n := $n+1
+  n := lexerCurrentPosition lex
+  while not lexerEol? lex and digit? lexerCurrentChar lex repeat 
+    lexerAdvancePosition! lex
+  lexerEol? lex or lexerCurrentChar lex ~= char "__" =>
+    n = lexerCurrentPosition lex and zro => '"0"
+    subString(lexerLineString lex,n,lexerCurrentPosition lex - n)
+  str := subString(lexerLineString lex,n,lexerCurrentPosition lex - n)
+  lexerAdvancePosition! lex
   a := shoeEsc lex
   bb := shoeInteger1(lex,zro)
   strconc(str,bb)
@@ -385,53 +437,53 @@ shoeIntValue(s) ==
  
 shoeNumber lex ==
   a := shoeInteger lex
-  $n >= lexerLineLength lex => shoeLeafInteger a
-  $floatok and stringChar(lexerLineString lex,$n) = char "." => 
-    n := $n
-    $n := $n+1
-    $n < lexerLineLength lex and stringChar(lexerLineString lex,$n) = char "." =>
-      $n := n
+  lexerEol? lex => shoeLeafInteger a
+  $floatok and lexerCurrentChar lex = char "." => 
+    n := lexerCurrentPosition lex
+    lexerAdvancePosition! lex
+    not lexerEol? lex and lexerCurrentChar lex = char "." =>
+      lexerPosition!(lex,n)
       shoeLeafInteger a
     w := shoeInteger1(lex,true)
     shoeExponent(lex,a,w)
   shoeLeafInteger a
  
 shoeExponent(lex,a,w)==
-  $n >= lexerLineLength lex => shoeLeafFloat(a,w,0)
-  n := $n
-  c := stringChar(lexerLineString lex,$n)
+  lexerEol? lex => shoeLeafFloat(a,w,0)
+  n := lexerCurrentPosition lex
+  c := lexerCurrentChar lex
   c = char "E" or c = char "e" =>
-    $n := $n+1
-    $n >= lexerLineLength lex =>
-      $n := n
+    lexerAdvancePosition! lex
+    lexerEol? lex =>
+      lexerPosition!(lex,n)
       shoeLeafFloat(a,w,0)
-    digit? stringChar(lexerLineString lex,$n) =>
+    digit? lexerCurrentChar lex =>
       e := shoeInteger lex
       e := shoeIntValue e
       shoeLeafFloat(a,w,e)
-    c1 := stringChar(lexerLineString lex,$n)
+    c1 := lexerCurrentChar lex
     c1 = char "+" or c1 = char "-" =>
-      $n := $n+1
-      $n >= lexerLineLength lex =>
-	$n := n
+      lexerAdvancePosition! lex
+      lexerEol? lex =>
+	lexerPosition!(lex,n)
 	shoeLeafFloat(a,w,0)
-      digit? stringChar(lexerLineString lex,$n) =>
+      digit? lexerCurrentChar lex =>
 	e := shoeInteger lex
 	e := shoeIntValue e
 	shoeLeafFloat(a,w,(c1 = char "-" => MINUS e; e))
-      $n := n
+      lexerPosition!(lex,n)
       shoeLeafFloat(a,w,0)
     -- FIXME: Missing alternative.
   shoeLeafFloat(a,w,0)
  
 shoeError lex ==
-  n := $n
-  $n := $n + 1
+  n := lexerCurrentPosition lex
+  lexerAdvancePosition! lex
   SoftShoeError([$linepos,:n],
     strconc( '"The character whose number is ",
-      toString codePoint stringChar(lexerLineString lex,n),
+      toString codePoint lexerCharacterAt(lex,n),
         '" is not a Boot character"))
-  shoeLeafError stringChar(lexerLineString lex,n)
+  shoeLeafError lexerCharacterAt(lex,n)
  
 shoeKeyWord st   == 
   tableValue(shoeKeyTable,st)
@@ -439,8 +491,8 @@ shoeKeyWord st   ==
 shoeKeyWordP st  ==  
   tableValue(shoeKeyTable,st) ~= nil
  
-shoeMatch(l,i) == 
-  shoeSubStringMatch(l,shoeDict,i)
+shoeMatch lex == 
+  shoeSubStringMatch(lexerLineString lex,shoeDict,lexerCurrentPosition lex)
  
 shoeSubStringMatch(l,d,i) ==
   h := codePoint stringChar(l, i)
diff --git a/src/boot/strap/scanner.clisp b/src/boot/strap/scanner.clisp
index e428c877..48582bbf 100644
--- a/src/boot/strap/scanner.clisp
+++ b/src/boot/strap/scanner.clisp
@@ -34,21 +34,70 @@
 
 (DEFUN |makeLexer| () (|mk%Lexer| NIL NIL))
 
+(DEFMACRO |lexerRefresh?| (|bfVar#1|)
+  (|applySubst| (LIST (CONS '|bfVar#1| |bfVar#1|))
+                '(NULL (|lexerCurrentPosition| |bfVar#1|))))
+
 (DEFMACRO |lexerLineLength| (|bfVar#1|)
   (|applySubst| (LIST (CONS '|bfVar#1| |bfVar#1|))
                 '(LENGTH (|lexerLineString| |bfVar#1|))))
 
+(DEFUN |lexerSetLine!| (|lex| |line|)
+  (PROGN
+   (SETF (|lexerLineString| |lex|) |line|)
+   (SETF (|lexerCurrentPosition| |lex|) 0)))
+
+(DEFUN |lexerSkipBlank!| (|lex|)
+  (SETF (|lexerCurrentPosition| |lex|)
+          (|firstNonblankPosition| (|lexerLineString| |lex|)
+                                   (|lexerCurrentPosition| |lex|))))
+
+(DEFUN |lexerAdvancePosition!| (|lex| &OPTIONAL (|n| 1))
+  (SETF (|lexerCurrentPosition| |lex|) (+ (|lexerCurrentPosition| |lex|) |n|)))
+
+(DEFUN |lexerSkipToEnd!| (|lex|)
+  (SETF (|lexerCurrentPosition| |lex|) (|lexerLineLength| |lex|)))
+
+(DEFUN |lexerPosition!| (|lex| |k|) (SETF (|lexerCurrentPosition| |lex|) |k|))
+
+(DEFUN |lexerCharCountToCompleteTab| (|lex|)
+  (- 7 (REM (|lexerCurrentPosition| |lex|) 8)))
+
+(DEFMACRO |lexerCurrentChar| (|bfVar#1|)
+  (|applySubst| (LIST (CONS '|bfVar#1| |bfVar#1|))
+                '(SCHAR (|lexerLineString| |bfVar#1|)
+                        (|lexerCurrentPosition| |bfVar#1|))))
+
+(DEFMACRO |lexerCharacterAt| (|bfVar#2| |bfVar#1|)
+  (|applySubst| (LIST (CONS '|bfVar#2| |bfVar#2|) (CONS '|bfVar#1| |bfVar#1|))
+                '(SCHAR (|lexerLineString| |bfVar#2|) |bfVar#1|)))
+
+(DEFUN |lexerCharPosition| (|lex| |c|)
+  (OR
+   (|charPosition| |c| (|lexerLineString| |lex|)
+                   (|lexerCurrentPosition| |lex|))
+   (|lexerLineLength| |lex|)))
+
+(DEFUN |lexerEol?| (|lex|)
+  (NOT (< (|lexerCurrentPosition| |lex|) (|lexerLineLength| |lex|))))
+
+(DEFUN |lexerReadLisp| (|lex|)
+  (|shoeReadLispString| (|lexerLineString| |lex|)
+                        (|lexerCurrentPosition| |lex|)))
+
 (DEFUN |shoeNextLine| (|lex| |s|)
   (LET* (|s1| |a|)
-    (DECLARE (SPECIAL |$n| |$r| |$f| |$linepos|))
+    (DECLARE (SPECIAL |$r| |$f| |$linepos|))
     (COND ((|bStreamNull| |s|) NIL)
           (T (SETQ |$linepos| |s|) (SETQ |$f| (CAR |s|)) (SETQ |$r| (CDR |s|))
-           (SETF (|lexerLineString| |lex|) (|sourceLineString| |$f|))
-           (SETQ |$n| (|firstNonblankPosition| (|lexerLineString| |lex|) 0))
-           (COND ((NULL |$n|) T)
-                 ((CHAR= (SCHAR (|lexerLineString| |lex|) |$n|) |shoeTAB|)
-                  (SETQ |a| (|makeString| (- 7 (REM |$n| 8)) (|char| '| |)))
-                  (SETF (SCHAR (|lexerLineString| |lex|) |$n|) (|char| '| |))
+           (|lexerSetLine!| |lex| (|sourceLineString| |$f|))
+           (|lexerSkipBlank!| |lex|)
+           (COND ((|lexerRefresh?| |lex|) T)
+                 ((EQUAL (|lexerCurrentChar| |lex|) |shoeTAB|)
+                  (SETQ |a|
+                          (|makeString| (|lexerCharCountToCompleteTab| |lex|)
+                                        (|char| '| |)))
+                  (SETF (|lexerCurrentChar| |lex|) (|char| '| |))
                   (SETF (|lexerLineString| |lex|)
                           (CONCAT |a| (|lexerLineString| |lex|)))
                   (SETQ |s1|
@@ -62,19 +111,18 @@
 (DEFUN |shoeLineToks| (|s|)
   (LET* ((|$f| NIL)
          (|$r| NIL)
-         (|$n| NIL)
          (|$floatok| T)
          (|$linepos| |s|)
          |toks|
          |dq|
          |command|
          |lex|)
-    (DECLARE (SPECIAL |$f| |$r| |$n| |$floatok| |$linepos|))
+    (DECLARE (SPECIAL |$f| |$r| |$floatok| |$linepos|))
     (PROGN
      (SETQ |lex| (|makeLexer|))
      (COND ((NOT (|shoeNextLine| |lex| |s|)) (CONS NIL NIL))
-           ((NULL |$n|) (|shoeLineToks| |$r|))
-           ((CHAR= (SCHAR (|lexerLineString| |lex|) 0) (|char| '|)|))
+           ((|lexerRefresh?| |lex|) (|shoeLineToks| |$r|))
+           ((CHAR= (|lexerCharacterAt| |lex| 0) (|char| '|)|))
             (COND
              ((SETQ |command| (|shoeLine?| (|lexerLineString| |lex|)))
               (SETQ |dq|
@@ -86,7 +134,7 @@
              (T (|shoeLineToks| |$r|))))
            (T (SETQ |toks| NIL)
             (LOOP
-             (COND ((NOT (< |$n| (|lexerLineLength| |lex|))) (RETURN NIL))
+             (COND ((|lexerEol?| |lex|) (RETURN NIL))
                    (T (SETQ |toks| (|dqAppend| |toks| (|shoeToken| |lex|))))))
             (COND ((NULL |toks|) (|shoeLineToks| |$r|))
                   (T (CONS (LIST |toks|) |$r|))))))))
@@ -108,12 +156,12 @@
 
 (DEFUN |shoeAccumulateLines| (|lex| |s| |string|)
   (LET* (|a| |command|)
-    (DECLARE (SPECIAL |$r| |$n|))
+    (DECLARE (SPECIAL |$r|))
     (COND ((NOT (|shoeNextLine| |lex| |s|)) (CONS |s| |string|))
-          ((NULL |$n|) (|shoeAccumulateLines| |lex| |$r| |string|))
+          ((|lexerRefresh?| |lex|) (|shoeAccumulateLines| |lex| |$r| |string|))
           ((EQL (|lexerLineLength| |lex|) 0)
            (|shoeAccumulateLines| |lex| |$r| |string|))
-          ((CHAR= (SCHAR (|lexerLineString| |lex|) 0) (|char| '|)|))
+          ((CHAR= (|lexerCharacterAt| |lex| 0) (|char| '|)|))
            (SETQ |command| (|shoeLisp?| (|lexerLineString| |lex|)))
            (COND
             ((AND |command| (PLUSP (LENGTH |command|)))
@@ -136,11 +184,11 @@
 
 (DEFUN |shoeToken| (|lex|)
   (LET* (|b| |ch| |n| |linepos|)
-    (DECLARE (SPECIAL |$n| |$linepos|))
+    (DECLARE (SPECIAL |$linepos|))
     (PROGN
      (SETQ |linepos| |$linepos|)
-     (SETQ |n| |$n|)
-     (SETQ |ch| (SCHAR (|lexerLineString| |lex|) |$n|))
+     (SETQ |n| (|lexerCurrentPosition| |lex|))
+     (SETQ |ch| (|lexerCurrentChar| |lex|))
      (SETQ |b|
              (COND ((|shoeStartsComment| |lex|) (|shoeComment| |lex|) NIL)
                    ((|shoeStartsNegComment| |lex|) (|shoeNegComment| |lex|)
@@ -152,7 +200,7 @@
                    ((CHAR= |ch| (|char| '|"|)) (|shoeString| |lex|))
                    ((DIGIT-CHAR-P |ch|) (|shoeNumber| |lex|))
                    ((CHAR= |ch| (|char| '_)) (|shoeEscape| |lex|))
-                   ((EQUAL |ch| |shoeTAB|) (SETQ |$n| (+ |$n| 1)) NIL)
+                   ((EQUAL |ch| |shoeTAB|) (|lexerAdvancePosition!| |lex|) NIL)
                    (T (|shoeError| |lex|))))
      (COND ((NULL |b|) NIL) (T (|dqUnit| (|makeToken| |linepos| |b| |n|)))))))
 
@@ -187,95 +235,97 @@
 
 (DEFUN |shoeLispEscape| (|lex|)
   (LET* (|n| |exp| |a|)
-    (DECLARE (SPECIAL |$linepos| |$n|))
+    (DECLARE (SPECIAL |$linepos|))
     (PROGN
-     (SETQ |$n| (+ |$n| 1))
+     (|lexerAdvancePosition!| |lex|)
      (COND
-      ((NOT (< |$n| (|lexerLineLength| |lex|)))
-       (|SoftShoeError| (CONS |$linepos| |$n|) "lisp escape error")
-       (|shoeLeafError| (SCHAR (|lexerLineString| |lex|) |$n|)))
-      (T (SETQ |a| (|shoeReadLispString| (|lexerLineString| |lex|) |$n|))
+      ((|lexerEol?| |lex|)
+       (|SoftShoeError| (CONS |$linepos| (|lexerCurrentPosition| |lex|))
+                        "lisp escape error")
+       (|shoeLeafError| (|lexerCurrentChar| |lex|)))
+      (T (SETQ |a| (|lexerReadLisp| |lex|))
        (COND
         ((NULL |a|)
-         (|SoftShoeError| (CONS |$linepos| |$n|) "lisp escape error")
-         (|shoeLeafError| (SCHAR (|lexerLineString| |lex|) |$n|)))
+         (|SoftShoeError| (CONS |$linepos| (|lexerCurrentPosition| |lex|))
+                          "lisp escape error")
+         (|shoeLeafError| (|lexerCurrentChar| |lex|)))
         (T (SETQ |exp| (CAR |a|)) (SETQ |n| (CADR |a|))
-         (COND
-          ((NULL |n|) (SETQ |$n| (|lexerLineLength| |lex|))
-           (|shoeLeafLispExp| |exp|))
-          (T (SETQ |$n| |n|) (|shoeLeafLispExp| |exp|))))))))))
+         (COND ((NULL |n|) (|lexerSkipToEnd!| |lex|) (|shoeLeafLispExp| |exp|))
+               (T (|lexerPosition!| |lex| |n|)
+                (|shoeLeafLispExp| |exp|))))))))))
 
 (DEFUN |shoeEscape| (|lex|)
-  (DECLARE (SPECIAL |$n|))
   (PROGN
-   (SETQ |$n| (+ |$n| 1))
+   (|lexerAdvancePosition!| |lex|)
    (COND ((|shoeEsc| |lex|) (|shoeWord| |lex| T)) (T NIL))))
 
 (DEFUN |shoeEsc| (|lex|)
   (LET* (|n1|)
-    (DECLARE (SPECIAL |$r| |$n|))
+    (DECLARE (SPECIAL |$r|))
     (COND
-     ((NOT (< |$n| (|lexerLineLength| |lex|)))
+     ((|lexerEol?| |lex|)
       (COND
        ((|shoeNextLine| |lex| |$r|)
-        (LOOP (COND (|$n| (RETURN NIL)) (T (|shoeNextLine| |lex| |$r|))))
+        (LOOP
+         (COND ((NOT (|lexerRefresh?| |lex|)) (RETURN NIL))
+               (T (|shoeNextLine| |lex| |$r|))))
         (|shoeEsc| |lex|) NIL)
        (T NIL)))
-     (T (SETQ |n1| (|firstNonblankPosition| (|lexerLineString| |lex|) |$n|))
+     (T
+      (SETQ |n1|
+              (|firstNonblankPosition| (|lexerLineString| |lex|)
+                                       (|lexerCurrentPosition| |lex|)))
       (COND
        ((NULL |n1|) (|shoeNextLine| |lex| |$r|)
-        (LOOP (COND (|$n| (RETURN NIL)) (T (|shoeNextLine| |lex| |$r|))))
+        (LOOP
+         (COND ((NOT (|lexerRefresh?| |lex|)) (RETURN NIL))
+               (T (|shoeNextLine| |lex| |$r|))))
         (|shoeEsc| |lex|) NIL)
        (T T))))))
 
 (DEFUN |shoeStartsComment| (|lex|)
   (LET* (|www|)
-    (DECLARE (SPECIAL |$n|))
     (COND
-     ((< |$n| (|lexerLineLength| |lex|))
+     ((NOT (|lexerEol?| |lex|))
       (COND
-       ((CHAR= (SCHAR (|lexerLineString| |lex|) |$n|) (|char| '+))
-        (SETQ |www| (+ |$n| 1))
+       ((CHAR= (|lexerCurrentChar| |lex|) (|char| '+))
+        (SETQ |www| (+ (|lexerCurrentPosition| |lex|) 1))
         (COND ((NOT (< |www| (|lexerLineLength| |lex|))) NIL)
-              (T (CHAR= (SCHAR (|lexerLineString| |lex|) |www|) (|char| '+)))))
+              (T (CHAR= (|lexerCharacterAt| |lex| |www|) (|char| '+)))))
        (T NIL)))
      (T NIL))))
 
 (DEFUN |shoeStartsNegComment| (|lex|)
   (LET* (|www|)
-    (DECLARE (SPECIAL |$n|))
     (COND
-     ((< |$n| (|lexerLineLength| |lex|))
+     ((NOT (|lexerEol?| |lex|))
       (COND
-       ((CHAR= (SCHAR (|lexerLineString| |lex|) |$n|) (|char| '-))
-        (SETQ |www| (+ |$n| 1))
+       ((CHAR= (|lexerCurrentChar| |lex|) (|char| '-))
+        (SETQ |www| (+ (|lexerCurrentPosition| |lex|) 1))
         (COND ((NOT (< |www| (|lexerLineLength| |lex|))) NIL)
-              (T (CHAR= (SCHAR (|lexerLineString| |lex|) |www|) (|char| '-)))))
+              (T (CHAR= (|lexerCharacterAt| |lex| |www|) (|char| '-)))))
        (T NIL)))
      (T NIL))))
 
 (DEFUN |shoeNegComment| (|lex|)
   (LET* (|n|)
-    (DECLARE (SPECIAL |$n|))
     (PROGN
-     (SETQ |n| |$n|)
-     (SETQ |$n| (|lexerLineLength| |lex|))
+     (SETQ |n| (|lexerCurrentPosition| |lex|))
+     (|lexerSkipToEnd!| |lex|)
      (|shoeLeafNegComment| (|subString| (|lexerLineString| |lex|) |n|)))))
 
 (DEFUN |shoeComment| (|lex|)
   (LET* (|n|)
-    (DECLARE (SPECIAL |$n|))
     (PROGN
-     (SETQ |n| |$n|)
-     (SETQ |$n| (|lexerLineLength| |lex|))
+     (SETQ |n| (|lexerCurrentPosition| |lex|))
+     (|lexerSkipToEnd!| |lex|)
      (|shoeLeafComment| (|subString| (|lexerLineString| |lex|) |n|)))))
 
 (DEFUN |shoePunct| (|lex|)
   (LET* (|sss|)
-    (DECLARE (SPECIAL |$n|))
     (PROGN
-     (SETQ |sss| (|shoeMatch| (|lexerLineString| |lex|) |$n|))
-     (SETQ |$n| (+ |$n| (LENGTH |sss|)))
+     (SETQ |sss| (|shoeMatch| |lex|))
+     (|lexerAdvancePosition!| |lex| (LENGTH |sss|))
      (|shoeKeyTr| |lex| |sss|))))
 
 (DEFUN |shoeKeyTr| (|lex| |w|)
@@ -286,92 +336,89 @@
    (T (SETQ |$floatok| (NOT (|shoeCloser| |w|))) (|shoeLeafKey| |w|))))
 
 (DEFUN |shoePossFloat| (|lex| |w|)
-  (DECLARE (SPECIAL |$n|))
   (COND
-   ((OR (NOT (< |$n| (|lexerLineLength| |lex|)))
-        (NOT (DIGIT-CHAR-P (SCHAR (|lexerLineString| |lex|) |$n|))))
+   ((OR (|lexerEol?| |lex|) (NOT (DIGIT-CHAR-P (|lexerCurrentChar| |lex|))))
     (|shoeLeafKey| |w|))
    (T (SETQ |w| (|shoeInteger| |lex|)) (|shoeExponent| |lex| "0" |w|))))
 
 (DEFUN |shoeSpace| (|lex|)
   (LET* (|n|)
-    (DECLARE (SPECIAL |$floatok| |$n|))
+    (DECLARE (SPECIAL |$floatok|))
     (PROGN
-     (SETQ |n| |$n|)
-     (SETQ |$n| (|firstNonblankPosition| (|lexerLineString| |lex|) |$n|))
+     (SETQ |n| (|lexerCurrentPosition| |lex|))
+     (|lexerSkipBlank!| |lex|)
      (SETQ |$floatok| T)
      (COND
-      ((NULL |$n|) (|shoeLeafSpaces| 0) (SETQ |$n| (|lexerLineLength| |lex|)))
-      (T (|shoeLeafSpaces| (- |$n| |n|)))))))
+      ((|lexerRefresh?| |lex|) (|shoeLeafSpaces| 0) (|lexerSkipToEnd!| |lex|))
+      (T (|shoeLeafSpaces| (- (|lexerCurrentPosition| |lex|) |n|)))))))
 
 (DEFUN |shoeString| (|lex|)
-  (DECLARE (SPECIAL |$floatok| |$n|))
+  (DECLARE (SPECIAL |$floatok|))
   (PROGN
-   (SETQ |$n| (+ |$n| 1))
+   (|lexerAdvancePosition!| |lex|)
    (SETQ |$floatok| NIL)
    (|shoeLeafString| (|shoeS| |lex|))))
 
 (DEFUN |shoeS| (|lex|)
   (LET* (|b| |a| |str| |mn| |escsym| |strsym| |n|)
-    (DECLARE (SPECIAL |$linepos| |$n|))
+    (DECLARE (SPECIAL |$linepos|))
     (COND
-     ((NOT (< |$n| (|lexerLineLength| |lex|)))
-      (|SoftShoeError| (CONS |$linepos| |$n|) "quote added") "")
-     (T (SETQ |n| |$n|)
-      (SETQ |strsym|
-              (OR (|charPosition| (|char| '|"|) (|lexerLineString| |lex|) |$n|)
-                  (|lexerLineLength| |lex|)))
-      (SETQ |escsym|
-              (OR (|charPosition| (|char| '_) (|lexerLineString| |lex|) |$n|)
-                  (|lexerLineLength| |lex|)))
+     ((|lexerEol?| |lex|)
+      (|SoftShoeError| (CONS |$linepos| (|lexerCurrentPosition| |lex|))
+                       "quote added")
+      "")
+     (T (SETQ |n| (|lexerCurrentPosition| |lex|))
+      (SETQ |strsym| (|lexerCharPosition| |lex| (|char| '|"|)))
+      (SETQ |escsym| (|lexerCharPosition| |lex| (|char| '_)))
       (SETQ |mn| (MIN |strsym| |escsym|))
       (COND
-       ((EQUAL |mn| (|lexerLineLength| |lex|))
-        (SETQ |$n| (|lexerLineLength| |lex|))
-        (|SoftShoeError| (CONS |$linepos| |$n|) "quote added")
+       ((EQUAL |mn| (|lexerLineLength| |lex|)) (|lexerSkipToEnd!| |lex|)
+        (|SoftShoeError| (CONS |$linepos| (|lexerCurrentPosition| |lex|))
+                         "quote added")
         (|subString| (|lexerLineString| |lex|) |n|))
-       ((EQUAL |mn| |strsym|) (SETQ |$n| (+ |mn| 1))
+       ((EQUAL |mn| |strsym|) (|lexerPosition!| |lex| (+ |mn| 1))
         (|subString| (|lexerLineString| |lex|) |n| (- |mn| |n|)))
        (T (SETQ |str| (|subString| (|lexerLineString| |lex|) |n| (- |mn| |n|)))
-        (SETQ |$n| (+ |mn| 1)) (SETQ |a| (|shoeEsc| |lex|))
+        (|lexerPosition!| |lex| (+ |mn| 1)) (SETQ |a| (|shoeEsc| |lex|))
         (SETQ |b|
                 (COND
                  (|a|
                   (SETQ |str|
-                          (CONCAT |str|
-                                  (STRING
-                                   (SCHAR (|lexerLineString| |lex|) |$n|))))
-                  (SETQ |$n| (+ |$n| 1)) (|shoeS| |lex|))
+                          (CONCAT |str| (STRING (|lexerCurrentChar| |lex|))))
+                  (|lexerAdvancePosition!| |lex|) (|shoeS| |lex|))
                  (T (|shoeS| |lex|))))
         (CONCAT |str| |b|)))))))
 
-(DEFUN |shoeIdEnd| (|line| |n|)
-  (PROGN
-   (LOOP
-    (COND
-     ((NOT (AND (< |n| (LENGTH |line|)) (|shoeIdChar| (SCHAR |line| |n|))))
-      (RETURN NIL))
-     (T (SETQ |n| (+ |n| 1)))))
-   |n|))
+(DEFUN |shoeIdEnd| (|lex|)
+  (LET* (|n|)
+    (PROGN
+     (SETQ |n| (|lexerCurrentPosition| |lex|))
+     (LOOP
+      (COND
+       ((NOT
+         (AND (< |n| (|lexerLineLength| |lex|))
+              (|shoeIdChar| (|lexerCharacterAt| |lex| |n|))))
+        (RETURN NIL))
+       (T (SETQ |n| (+ |n| 1)))))
+     |n|)))
 
 (DEFUN |shoeW| (|lex| |b|)
   (LET* (|bb| |a| |str| |endid| |l| |n1|)
-    (DECLARE (SPECIAL |$n|))
     (PROGN
-     (SETQ |n1| |$n|)
-     (SETQ |$n| (+ |$n| 1))
+     (SETQ |n1| (|lexerCurrentPosition| |lex|))
+     (|lexerAdvancePosition!| |lex|)
      (SETQ |l| (|lexerLineLength| |lex|))
-     (SETQ |endid| (|shoeIdEnd| (|lexerLineString| |lex|) |$n|))
+     (SETQ |endid| (|shoeIdEnd| |lex|))
      (COND
       ((OR (EQUAL |endid| |l|)
-           (NOT (CHAR= (SCHAR (|lexerLineString| |lex|) |endid|) (|char| '_))))
-       (SETQ |$n| |endid|)
+           (NOT (CHAR= (|lexerCharacterAt| |lex| |endid|) (|char| '_))))
+       (|lexerPosition!| |lex| |endid|)
        (LIST |b|
              (|subString| (|lexerLineString| |lex|) |n1| (- |endid| |n1|))))
       (T
        (SETQ |str|
                (|subString| (|lexerLineString| |lex|) |n1| (- |endid| |n1|)))
-       (SETQ |$n| (+ |endid| 1)) (SETQ |a| (|shoeEsc| |lex|))
+       (|lexerPosition!| |lex| (+ |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))))))))
 
@@ -389,25 +436,28 @@
 (DEFUN |shoeInteger| (|lex|) (|shoeInteger1| |lex| NIL))
 
 (DEFUN |shoeInteger1| (|lex| |zro|)
-  (LET* (|bb| |a| |str| |l| |n|)
-    (DECLARE (SPECIAL |$n|))
+  (LET* (|bb| |a| |str| |n|)
     (PROGN
-     (SETQ |n| |$n|)
-     (SETQ |l| (|lexerLineLength| |lex|))
+     (SETQ |n| (|lexerCurrentPosition| |lex|))
      (LOOP
       (COND
        ((NOT
-         (AND (< |$n| |l|)
-              (DIGIT-CHAR-P (SCHAR (|lexerLineString| |lex|) |$n|))))
+         (AND (NOT (|lexerEol?| |lex|))
+              (DIGIT-CHAR-P (|lexerCurrentChar| |lex|))))
         (RETURN NIL))
-       (T (SETQ |$n| (+ |$n| 1)))))
+       (T (|lexerAdvancePosition!| |lex|))))
      (COND
-      ((OR (EQUAL |$n| |l|)
-           (NOT (CHAR= (SCHAR (|lexerLineString| |lex|) |$n|) (|char| '_))))
-       (COND ((AND (EQUAL |n| |$n|) |zro|) "0")
-             (T (|subString| (|lexerLineString| |lex|) |n| (- |$n| |n|)))))
-      (T (SETQ |str| (|subString| (|lexerLineString| |lex|) |n| (- |$n| |n|)))
-       (SETQ |$n| (+ |$n| 1)) (SETQ |a| (|shoeEsc| |lex|))
+      ((OR (|lexerEol?| |lex|)
+           (NOT (CHAR= (|lexerCurrentChar| |lex|) (|char| '_))))
+       (COND ((AND (EQUAL |n| (|lexerCurrentPosition| |lex|)) |zro|) "0")
+             (T
+              (|subString| (|lexerLineString| |lex|) |n|
+                           (- (|lexerCurrentPosition| |lex|) |n|)))))
+      (T
+       (SETQ |str|
+               (|subString| (|lexerLineString| |lex|) |n|
+                            (- (|lexerCurrentPosition| |lex|) |n|)))
+       (|lexerAdvancePosition!| |lex|) (SETQ |a| (|shoeEsc| |lex|))
        (SETQ |bb| (|shoeInteger1| |lex| |zro|)) (CONCAT |str| |bb|))))))
 
 (DEFUN |shoeIntValue| (|s|)
@@ -425,71 +475,72 @@
 
 (DEFUN |shoeNumber| (|lex|)
   (LET* (|w| |n| |a|)
-    (DECLARE (SPECIAL |$floatok| |$n|))
+    (DECLARE (SPECIAL |$floatok|))
     (PROGN
      (SETQ |a| (|shoeInteger| |lex|))
-     (COND ((NOT (< |$n| (|lexerLineLength| |lex|))) (|shoeLeafInteger| |a|))
-           ((AND |$floatok|
-                 (CHAR= (SCHAR (|lexerLineString| |lex|) |$n|) (|char| '|.|)))
-            (SETQ |n| |$n|) (SETQ |$n| (+ |$n| 1))
+     (COND ((|lexerEol?| |lex|) (|shoeLeafInteger| |a|))
+           ((AND |$floatok| (CHAR= (|lexerCurrentChar| |lex|) (|char| '|.|)))
+            (SETQ |n| (|lexerCurrentPosition| |lex|))
+            (|lexerAdvancePosition!| |lex|)
             (COND
-             ((AND (< |$n| (|lexerLineLength| |lex|))
-                   (CHAR= (SCHAR (|lexerLineString| |lex|) |$n|)
-                          (|char| '|.|)))
-              (SETQ |$n| |n|) (|shoeLeafInteger| |a|))
+             ((AND (NOT (|lexerEol?| |lex|))
+                   (CHAR= (|lexerCurrentChar| |lex|) (|char| '|.|)))
+              (|lexerPosition!| |lex| |n|) (|shoeLeafInteger| |a|))
              (T (SETQ |w| (|shoeInteger1| |lex| T))
               (|shoeExponent| |lex| |a| |w|))))
            (T (|shoeLeafInteger| |a|))))))
 
 (DEFUN |shoeExponent| (|lex| |a| |w|)
   (LET* (|c1| |e| |c| |n|)
-    (DECLARE (SPECIAL |$n|))
-    (COND
-     ((NOT (< |$n| (|lexerLineLength| |lex|))) (|shoeLeafFloat| |a| |w| 0))
-     (T (SETQ |n| |$n|) (SETQ |c| (SCHAR (|lexerLineString| |lex|) |$n|))
-      (COND
-       ((OR (CHAR= |c| (|char| 'E)) (CHAR= |c| (|char| '|e|)))
-        (SETQ |$n| (+ |$n| 1))
-        (COND
-         ((NOT (< |$n| (|lexerLineLength| |lex|))) (SETQ |$n| |n|)
-          (|shoeLeafFloat| |a| |w| 0))
-         ((DIGIT-CHAR-P (SCHAR (|lexerLineString| |lex|) |$n|))
-          (SETQ |e| (|shoeInteger| |lex|)) (SETQ |e| (|shoeIntValue| |e|))
-          (|shoeLeafFloat| |a| |w| |e|))
-         (T (SETQ |c1| (SCHAR (|lexerLineString| |lex|) |$n|))
-          (COND
-           ((OR (CHAR= |c1| (|char| '+)) (CHAR= |c1| (|char| '-)))
-            (SETQ |$n| (+ |$n| 1))
-            (COND
-             ((NOT (< |$n| (|lexerLineLength| |lex|))) (SETQ |$n| |n|)
-              (|shoeLeafFloat| |a| |w| 0))
-             ((DIGIT-CHAR-P (SCHAR (|lexerLineString| |lex|) |$n|))
-              (SETQ |e| (|shoeInteger| |lex|)) (SETQ |e| (|shoeIntValue| |e|))
-              (|shoeLeafFloat| |a| |w|
-                               (COND ((CHAR= |c1| (|char| '-)) (- |e|))
-                                     (T |e|))))
-             (T (SETQ |$n| |n|) (|shoeLeafFloat| |a| |w| 0))))))))
-       (T (|shoeLeafFloat| |a| |w| 0)))))))
+    (COND ((|lexerEol?| |lex|) (|shoeLeafFloat| |a| |w| 0))
+          (T (SETQ |n| (|lexerCurrentPosition| |lex|))
+           (SETQ |c| (|lexerCurrentChar| |lex|))
+           (COND
+            ((OR (CHAR= |c| (|char| 'E)) (CHAR= |c| (|char| '|e|)))
+             (|lexerAdvancePosition!| |lex|)
+             (COND
+              ((|lexerEol?| |lex|) (|lexerPosition!| |lex| |n|)
+               (|shoeLeafFloat| |a| |w| 0))
+              ((DIGIT-CHAR-P (|lexerCurrentChar| |lex|))
+               (SETQ |e| (|shoeInteger| |lex|)) (SETQ |e| (|shoeIntValue| |e|))
+               (|shoeLeafFloat| |a| |w| |e|))
+              (T (SETQ |c1| (|lexerCurrentChar| |lex|))
+               (COND
+                ((OR (CHAR= |c1| (|char| '+)) (CHAR= |c1| (|char| '-)))
+                 (|lexerAdvancePosition!| |lex|)
+                 (COND
+                  ((|lexerEol?| |lex|) (|lexerPosition!| |lex| |n|)
+                   (|shoeLeafFloat| |a| |w| 0))
+                  ((DIGIT-CHAR-P (|lexerCurrentChar| |lex|))
+                   (SETQ |e| (|shoeInteger| |lex|))
+                   (SETQ |e| (|shoeIntValue| |e|))
+                   (|shoeLeafFloat| |a| |w|
+                                    (COND ((CHAR= |c1| (|char| '-)) (- |e|))
+                                          (T |e|))))
+                  (T (|lexerPosition!| |lex| |n|)
+                   (|shoeLeafFloat| |a| |w| 0))))))))
+            (T (|shoeLeafFloat| |a| |w| 0)))))))
 
 (DEFUN |shoeError| (|lex|)
   (LET* (|n|)
-    (DECLARE (SPECIAL |$linepos| |$n|))
+    (DECLARE (SPECIAL |$linepos|))
     (PROGN
-     (SETQ |n| |$n|)
-     (SETQ |$n| (+ |$n| 1))
+     (SETQ |n| (|lexerCurrentPosition| |lex|))
+     (|lexerAdvancePosition!| |lex|)
      (|SoftShoeError| (CONS |$linepos| |n|)
                       (CONCAT "The character whose number is "
                               (WRITE-TO-STRING
-                               (CHAR-CODE
-                                (SCHAR (|lexerLineString| |lex|) |n|)))
+                               (CHAR-CODE (|lexerCharacterAt| |lex| |n|)))
                               " is not a Boot character"))
-     (|shoeLeafError| (SCHAR (|lexerLineString| |lex|) |n|)))))
+     (|shoeLeafError| (|lexerCharacterAt| |lex| |n|)))))
 
 (DEFUN |shoeKeyWord| (|st|) (|tableValue| |shoeKeyTable| |st|))
 
 (DEFUN |shoeKeyWordP| (|st|) (|tableValue| |shoeKeyTable| |st|))
 
-(DEFUN |shoeMatch| (|l| |i|) (|shoeSubStringMatch| |l| |shoeDict| |i|))
+(DEFUN |shoeMatch| (|lex|)
+  (|shoeSubStringMatch| (|lexerLineString| |lex|) |shoeDict|
+                        (|lexerCurrentPosition| |lex|)))
 
 (DEFUN |shoeSubStringMatch| (|l| |d| |i|)
   (LET* (|eql| |ls| |s| |s1| |done| |ll| |u| |h|)