From 7134b09e502ca2ff17b165e72b04e88f7973fbab Mon Sep 17 00:00:00 2001
From: David Majda <david@majda.cz>
Date: Sun, 15 Jul 2012 17:17:25 +0200
Subject: [PATCH] Merge |allocateRegisters| and |computeParams| passes

The purpose of this change is to avoid the need to index register
variables storing match results of sequences whose elements are labeled.
The indexing happened when match results of labeled elements were passed
to action/predicate functions.

In order to avoid indexing, the register allocator needs to ensure that
registers storing match results of any labeled sequence elements are
still "alive" after finishing parsing of the sequence. They should not
be used to store anything else at least until code of all actions and
predicates that can see the labels is executed. This requires that the
|allocateRegisters| pass has the knowledge of scoping. Because that
knowledge was already implicitly embedded in the |coputeParams| pass,
the logical step to prevent duplication was to merge it with the
|allocateRegisters| pass. This is what this commit does.

As a part of the merge the tests of both passes were largely refactored.
This is both to accomodate the merge and to make the tests in sync with
the code again (the tests became a bit out-of-sync during the last few
commits -- they tested more than was needed).

The speed/size impact is slightly positive:

Speed impact
------------
Before:     849.86 kB/s
After:      858.16 kB/s
Difference: 0.97%

Size impact
-----------
Before:     876618 b
After:      875602 b
Difference: -0.12%

(Measured by /tools/impact with Node.js v0.6.18 on x86_64 GNU/Linux.)
---
 .../passes/allocate-registers.spec.js         | 419 +++++++++++-------
 spec/compiler/passes/compute-params.spec.js   | 207 ---------
 spec/index.html                               |   1 -
 src/compiler.js                               |   1 -
 src/compiler/passes.js                        |   1 -
 src/compiler/passes/allocate-registers.js     | 246 +++++++---
 src/compiler/passes/compute-params.js         | 109 -----
 src/compiler/passes/generate-code.js          |  11 +-
 src/parser.js                                 |  62 +--
 9 files changed, 468 insertions(+), 589 deletions(-)
 delete mode 100644 spec/compiler/passes/compute-params.spec.js
 delete mode 100644 src/compiler/passes/compute-params.js

diff --git a/spec/compiler/passes/allocate-registers.spec.js b/spec/compiler/passes/allocate-registers.spec.js
index ab35df0..645ca42 100644
--- a/spec/compiler/passes/allocate-registers.spec.js
+++ b/spec/compiler/passes/allocate-registers.spec.js
@@ -1,203 +1,288 @@
 describe("compiler pass |allocateRegisters|", function() {
   var pass = PEG.compiler.passes.allocateRegisters;
 
-  var leafDetails     = { resultIndex: 0 },
-      choiceDetails   = {
-        resultIndex:  0,
-        alternatives: [
-          { resultIndex: 0, posIndex: 1 },
-          { resultIndex: 0, posIndex: 1 },
-          { resultIndex: 0, posIndex: 1 }
+  function ruleDetails(details) { return { rules: [details] }; }
+
+  function expressionDetails(details) {
+    return ruleDetails({ expression: details });
+  }
+
+  function innerExpressionDetails(details) {
+    return expressionDetails({ expression: details });
+  }
+
+  var reuseResultDetails = innerExpressionDetails({ resultIndex: 0 }),
+      allocResultDetails = innerExpressionDetails({ resultIndex: 1 }),
+      savePosDetails     = expressionDetails({ posIndex: 1 }),
+      scopedDetails      = expressionDetails({ params: {} }),
+      blockedDetails     = expressionDetails({
+        elements: [
+          {},
+          {
+            resultIndex: 3,
+            posIndex:    5,
+            elements:    [{ resultIndex: 6 }, { resultIndex: 7 }]
+          }
         ]
-      },
-      sequenceDetails = {
-        resultIndex: 0,
-        posIndex:    1,
-        elements:    [
-          { resultIndex: 2, posIndex: 3 },
-          { resultIndex: 3, posIndex: 4 },
-          { resultIndex: 4, posIndex: 5 }
+      }),
+      unblockedDetails   = expressionDetails({
+        elements: [
+          {},
+          {
+            resultIndex: 3,
+            posIndex:    4,
+            elements:    [{ resultIndex: 5 }, { resultIndex: 6 }]
+          }
         ]
-      };
+      });
 
-  function ruleDetails(details) { return { rules: [details] }; }
+  describe("for rule", function() {
+    it("allocates a new result register for the expression", function() {
+      expect(pass).toChangeAST('start = "a"', expressionDetails({
+        resultIndex: 0
+      }));
+    });
 
-  it("allocates registers for a named", function() {
-    expect(pass).toChangeAST('start "start" = &"a"', ruleDetails({
-      registerCount: 2,
-      expression:    {
-        resultIndex: 0,
-        expression:  { resultIndex: 0, posIndex: 1 }
-      }
-    }));
-  });
+    it("counts used registers", function() {
+      expect(pass).toChangeAST('start = "a"', ruleDetails({
+        registerCount: 1
+      }));
+      expect(pass).toChangeAST('start = "a"*', ruleDetails({
+        registerCount: 2
+      }));
+      expect(pass).toChangeAST('start = ("a"*)*', ruleDetails({
+        registerCount: 3
+      }));
+    });
 
-  it("allocates registers for a choice", function() {
-    expect(pass).toChangeAST('start = &"a" / &"b" / &"c"', ruleDetails({
-      registerCount: 2,
-      expression:    choiceDetails
-    }));
-    expect(pass).toChangeAST('start = &"a" / &"b"* / &"c"', ruleDetails({
-      registerCount: 3,
-      expression:    choiceDetails
-    }));
-    expect(pass).toChangeAST('start = &"a" / &(&"b") / &"c"', ruleDetails({
-      registerCount: 3,
-      expression:    choiceDetails
-    }));
+    it("resets used registers counter", function() {
+      expect(pass).toChangeAST('a = "a"*; b = "b"', {
+        rules: [ { registerCount: 2 }, { registerCount: 1 }]
+      });
+    });
   });
 
-  it("allocates registers for an action", function() {
-    expect(pass).toChangeAST('start = &"a" { code }', ruleDetails({
-      registerCount: 3,
-      expression:    {
-        resultIndex: 0,
-        posIndex:    1,
-        expression:  { resultIndex: 0, posIndex: 2 }
-      }
-    }));
+  describe("for named", function() {
+    it("reuses its own result register for the expression", function() {
+      expect(pass).toChangeAST('start "start" = "a"', reuseResultDetails);
+    });
   });
 
-  it("allocates registers for a sequence", function() {
-    expect(pass).toChangeAST('start = ', ruleDetails({
-      registerCount: 2,
-      expression:    { resultIndex: 0, posIndex: 1 }
-    }));
-    expect(pass).toChangeAST('start = &"a" &"b" &"c"', ruleDetails({
-      registerCount: 6,
-      expression:    sequenceDetails
-    }));
-    expect(pass).toChangeAST('start = &"a" &"b" &"c"*', ruleDetails({
-      registerCount: 7,
-      expression:    sequenceDetails
-    }));
-    expect(pass).toChangeAST('start = &"a" &"b"* &"c"', ruleDetails({
-      registerCount: 6,
-      expression:    sequenceDetails
-    }));
-    expect(pass).toChangeAST('start = &"a" &("b"*)* &"c"', ruleDetails({
-      registerCount: 7,
-      expression:    sequenceDetails
-    }));
-    expect(pass).toChangeAST('start = &"a"* &"b" &"c"', ruleDetails({
-      registerCount: 6,
-      expression:    sequenceDetails
-    }));
-    expect(pass).toChangeAST('start = &("a"*)* &"b" &"c"', ruleDetails({
-      registerCount: 6,
-      expression:    sequenceDetails
-    }));
-    expect(pass).toChangeAST('start = &(("a"*)*)* &"b" &"c"', ruleDetails({
-      registerCount: 7,
-      expression:    sequenceDetails
-    }));
-    expect(pass).toChangeAST('start = &"a" &(&"b") &"c"', ruleDetails({
-      registerCount: 6,
-      expression:    sequenceDetails
-    }));
-  });
+  describe("for choice", function() {
+    it("reuses its own result register for the alternatives", function() {
+      expect(pass).toChangeAST('start = "a" / "b" / "c"', expressionDetails({
+        alternatives: [
+          { resultIndex: 0 },
+          { resultIndex: 0 },
+          { resultIndex: 0 }
+        ]
+      }));
+    });
 
-  it("allocates registers for a labeled", function() {
-    expect(pass).toChangeAST('start = label:&"a"', ruleDetails({
-      registerCount: 2,
-      expression:    {
-        resultIndex: 0,
-        expression:  { resultIndex: 0, posIndex: 1 }
-      }
-    }));
-  });
+    it("creates a new scope", function() {
+      expect(pass).toChangeAST('start = (a:"a" / "b" / "c") { }', scopedDetails);
+    });
 
-  it("allocates registers for a simple and", function() {
-    expect(pass).toChangeAST('start = &(&"a")', ruleDetails({
-      registerCount: 3,
-      expression:    {
-        resultIndex: 0,
-        posIndex:    1,
-        expression:  { resultIndex: 0, posIndex: 2 }
-      }
-    }));
+    it("unblocks registers blocked by its children", function() {
+      expect(pass).toChangeAST(
+        'start = ((a:"a" / "b" / "c") "d") ("e" "f")',
+        unblockedDetails
+      );
+    });
   });
 
-  it("allocates registers for a simple not", function() {
-    expect(pass).toChangeAST('start = !(&"a")', ruleDetails({
-      registerCount: 3,
-      expression:    {
-        resultIndex: 0,
-        posIndex:    1,
-        expression:  { resultIndex: 0, posIndex: 2 }
-      }
-    }));
+  describe("for action", function() {
+    it("allocates a position register", function() {
+      expect(pass).toChangeAST('start = "a" { }', savePosDetails);
+    });
+
+    it("reuses its own result register for the expression", function() {
+      expect(pass).toChangeAST('start = "a" { }', reuseResultDetails);
+    });
+
+    it("creates a new scope", function() {
+      expect(pass).toChangeAST('start = (a:"a" { }) { }', scopedDetails);
+    });
+
+    it("unblocks registers blocked by its children", function() {
+      expect(pass).toChangeAST(
+        'start = ((a:"a" { }) "b") ("c" "d")',
+        unblockedDetails
+      );
+    });
+
+    it("computes params", function() {
+      expect(pass).toChangeAST('start = a:"a" b:"b" c:"c" { }', expressionDetails({
+        params: { a: 3, b: 4, c: 5 }
+      }));
+    });
   });
 
-  it("allocates registers for a semantic and", function() {
-    expect(pass).toChangeAST('start = &{ code }', ruleDetails({
-      registerCount: 1,
-      expression:    leafDetails
-    }));
+  describe("for sequence", function() {
+    it("allocates a position register", function() {
+      expect(pass).toChangeAST('start = ',            savePosDetails);
+      expect(pass).toChangeAST('start = "a" "b" "c"', savePosDetails);
+    });
+
+    it("allocates new result registers for the elements", function() {
+      expect(pass).toChangeAST('start = "a" "b" "c"', expressionDetails({
+        elements: [{ resultIndex: 2 }, { resultIndex: 3 }, { resultIndex: 4 }]
+      }));
+    });
+
+    it("does not create a new scope", function() {
+      expect(pass).toChangeAST(
+        'start = a:"a" b:"b" c:"c" { }',
+        expressionDetails({ params: { a: 3, b: 4, c: 5 } })
+      );
+    });
+
+    it("does not unblock blocked result registers from children", function() {
+      expect(pass).toChangeAST(
+        'start = (a:"a" "b") ("c" "d")',
+        blockedDetails
+      );
+    });
   });
 
-  it("allocates registers for a semantic not", function() {
-    expect(pass).toChangeAST('start = !{ code }', ruleDetails({
-      registerCount: 1,
-      expression:    leafDetails
-    }));
+  describe("for labeled", function() {
+    it("reuses its own result register for the expression", function() {
+      expect(pass).toChangeAST('start = a:"a"', reuseResultDetails);
+    });
+
+    it("creates a new scope", function() {
+      expect(pass).toChangeAST('start = a:(b:"b") { }', expressionDetails({
+        params: { a: 0 }
+      }));
+    });
+
+    it("unblocks registers blocked by its children", function() {
+      expect(pass).toChangeAST(
+        'start = (a:(b:"b") "c") ("d" "e")',
+        blockedDetails
+      );
+    });
+
+    it("adds label to the environment", function() {
+      expect(pass).toChangeAST('start = a:"a" { }', expressionDetails({
+        params: { a: 0 }
+      }));
+    });
+
+    it("blocks its own result register", function() {
+      expect(pass).toChangeAST(
+        'start = (a:"a" "b") ("c" "d")',
+        blockedDetails
+      );
+    });
   });
 
-  it("allocates registers for an optional", function() {
-    expect(pass).toChangeAST('start = (&"a")?', ruleDetails({
-      registerCount: 2,
-      expression:    {
-        resultIndex: 0,
-        expression:  { resultIndex: 0, posIndex: 1 }
-      }
-    }));
+  describe("for simple and", function() {
+    it("allocates a position register", function() {
+      expect(pass).toChangeAST('start = &"a"', savePosDetails);
+    });
+
+    it("reuses its own result register for the expression", function() {
+      expect(pass).toChangeAST('start = &"a"', reuseResultDetails);
+    });
+
+    it("creates a new scope", function() {
+      expect(pass).toChangeAST('start = &(a:"a") { }', scopedDetails);
+    });
+
+    it("unblocks registers blocked by its children", function() {
+      expect(pass).toChangeAST(
+        'start = (&(a:"a") "b") ("c" "d")',
+        unblockedDetails
+      );
+    });
   });
 
-  it("allocates registers for a zero or more", function() {
-    expect(pass).toChangeAST('start = (&"a")*', ruleDetails({
-      registerCount: 3,
-      expression:    {
-        resultIndex: 0,
-        expression:  { resultIndex: 1, posIndex: 2 }
-      }
-    }));
+  describe("for simple not", function() {
+    it("allocates a position register", function() {
+      expect(pass).toChangeAST('start = !"a"', savePosDetails);
+    });
+
+    it("reuses its own result register for the expression", function() {
+      expect(pass).toChangeAST('start = !"a"', reuseResultDetails);
+    });
+
+    it("creates a new scope", function() {
+      expect(pass).toChangeAST('start = !(a:"a") { }', scopedDetails);
+    });
+
+    it("unblocks registers blocked by its children", function() {
+      expect(pass).toChangeAST(
+        'start = (!(a:"a") "b") ("c" "d")',
+        unblockedDetails
+      );
+    });
   });
 
-  it("allocates registers for a one or more", function() {
-    expect(pass).toChangeAST('start = (&"a")+', ruleDetails({
-      registerCount: 3,
-      expression:    {
-        resultIndex: 0,
-        expression:  { resultIndex: 1, posIndex: 2 }
-      }
-    }));
+  describe("for semantic and", function() {
+    it("computes params", function() {
+      expect(pass).toChangeAST('start = a:"a" b:"b" c:"c" &{ }', expressionDetails({
+        elements: [{}, {}, {}, { params: { a: 2, b: 3, c: 4 } }]
+      }));
+    });
   });
 
-  it("allocates registers for a rule reference", function() {
-    expect(pass).toChangeAST('start = a', ruleDetails({
-      registerCount: 1,
-      expression:    leafDetails
-    }));
+  describe("for semantic not", function() {
+    it("computes params", function() {
+      expect(pass).toChangeAST('start = a:"a" b:"b" c:"c" !{ }', expressionDetails({
+        elements: [{}, {}, {}, { params: { a: 2, b: 3, c: 4 } }]
+      }));
+    });
   });
 
-  it("allocates registers for a literal", function() {
-    expect(pass).toChangeAST('start = "a"', ruleDetails({
-      registerCount: 1,
-      expression:    leafDetails
-    }));
+  describe("for optional", function() {
+    it("reuses its own result register for the expression", function() {
+      expect(pass).toChangeAST('start = "a"?', reuseResultDetails);
+    });
+
+    it("creates a new scope", function() {
+      expect(pass).toChangeAST('start = (a:"a")? { }', scopedDetails);
+    });
+
+    it("unblocks registers blocked by its children", function() {
+      expect(pass).toChangeAST(
+        'start = ((a:"a")? "b") ("c" "d")',
+        unblockedDetails
+      );
+    });
   });
 
-  it("allocates registers for a class", function() {
-    expect(pass).toChangeAST('start = [a-z]', ruleDetails({
-      registerCount: 1,
-      expression:    leafDetails
-    }));
+  describe("for zero or more", function() {
+    it("allocates a new result register for the expression", function() {
+      expect(pass).toChangeAST('start = "a"*', allocResultDetails);
+    });
+
+    it("creates a new scope", function() {
+      expect(pass).toChangeAST('start = (a:"a")* { }', scopedDetails);
+    });
+
+    it("unblocks registers blocked by its children", function() {
+      expect(pass).toChangeAST(
+        'start = ((a:"a")* "b") ("c" "d")',
+        unblockedDetails
+      );
+    });
   });
 
-  it("allocates registers for an any", function() {
-    expect(pass).toChangeAST('start = .', ruleDetails({
-      registerCount: 1,
-      expression:    leafDetails
-    }));
+  describe("for one or more", function() {
+    it("allocates a new result register for the expression", function() {
+      expect(pass).toChangeAST('start = "a"+', allocResultDetails);
+    });
+
+    it("creates a new scope", function() {
+      expect(pass).toChangeAST('start = (a:"a")+ { }', scopedDetails);
+    });
+
+    it("unblocks registers blocked by its children", function() {
+      expect(pass).toChangeAST(
+        'start = ((a:"a")+ "b") ("c" "d")',
+        unblockedDetails
+      );
+    });
   });
 });
diff --git a/spec/compiler/passes/compute-params.spec.js b/spec/compiler/passes/compute-params.spec.js
deleted file mode 100644
index a5be9da..0000000
--- a/spec/compiler/passes/compute-params.spec.js
+++ /dev/null
@@ -1,207 +0,0 @@
-describe("compiler pass |computeParams|", function() {
-  function pass(ast) {
-    PEG.compiler.passes.allocateRegisters(ast);
-    PEG.compiler.passes.computeParams(ast);
-  }
-
-  var result0     = { resultIndex: 0, subindices: []     },
-      result0_0   = { resultIndex: 0, subindices: [0]    },
-      result0_1   = { resultIndex: 0, subindices: [1]    },
-      result0_1_0 = { resultIndex: 0, subindices: [1, 0] },
-      result0_1_1 = { resultIndex: 0, subindices: [1, 1] },
-      result0_1_2 = { resultIndex: 0, subindices: [1, 2] },
-      result0_2   = { resultIndex: 0, subindices: [2]    },
-      result1_9   = { resultIndex: 1, subindices: [9]    },
-      result1     = { resultIndex: 1, subindices: []     };
-      result2     = { resultIndex: 2, subindices: []     },
-      result4     = { resultIndex: 4, subindices: []     };
-
-  function ruleDetails(details) { return { rules: [details] }; }
-
-  function expressionDetails(details) {
-    return ruleDetails({ expression: details });
-  }
-
-  function innerExpressionDetails(details) {
-    return expressionDetails({ expression: details });
-  }
-
-  describe("basic cases", function() {
-    it("computes params for an action", function() {
-      expect(pass).toChangeAST('start = a:"a" { }', expressionDetails({
-        params: { a: result0 }
-      }));
-    });
-
-    it("computes params for a semantic and", function() {
-      expect(pass).toChangeAST('start = a:"a" &{ }', expressionDetails({
-        elements: [
-          {},
-          { params: { a: result2 } }
-        ]
-      }));
-    });
-
-    it("computes params for a semantic not", function() {
-      expect(pass).toChangeAST('start = a:"a" !{ }', expressionDetails({
-        elements: [
-          {},
-          { params: { a: result2 } }
-        ]
-      }));
-    });
-  });
-
-  describe("recursive walk", function() {
-    it("computes params for a named", function() {
-      expect(pass).toChangeAST(
-        'start "start" = a:"a" { }',
-        innerExpressionDetails({ params: { a: result0 } })
-      );
-    });
-
-    it("computes params for a choice", function() {
-      expect(pass).toChangeAST(
-        'start = a:"a" { } / "b" / "c"',
-        expressionDetails({
-          alternatives: [{ params: { a: result0 } }, {}, {}]
-        })
-      );
-      expect(pass).toChangeAST(
-        'start = "a" / "b" / c:"c" { }',
-        expressionDetails({
-          alternatives: [{}, {}, { params: { c: result0 } }]
-        })
-      );
-    });
-
-    it("computes params for an action", function() {
-      expect(pass).toChangeAST('start = (a:"a" { }) { }', innerExpressionDetails({
-        params: { a: result0 }
-      }));
-    });
-
-    it("computes params for a sequence", function() {
-      expect(pass).toChangeAST(
-        'start = (a:"a" { }) "b" "c"',
-        expressionDetails({
-          elements: [{ params: { a: result2 } }, {}, {}]
-        })
-      );
-      expect(pass).toChangeAST(
-        'start = "a" "b" (c:"c" { })',
-        expressionDetails({
-          elements: [{}, {}, { params: { c: result4 } }]
-        })
-      );
-    });
-
-    it("computes params for a labeled", function() {
-      expect(pass).toChangeAST('start = a:(b:"b" { })', innerExpressionDetails({
-        params: { b: result0 }
-      }));
-    });
-
-    it("computes params for a simple and", function() {
-      expect(pass).toChangeAST('start = &(a:"a" { })', innerExpressionDetails({
-        params: { a: result0 }
-      }));
-    });
-
-    it("computes params for a simple not", function() {
-      expect(pass).toChangeAST('start = &(a:"a" { })', innerExpressionDetails({
-        params: { a: result0 }
-      }));
-    });
-
-    it("computes params for an optional", function() {
-      expect(pass).toChangeAST('start = (a:"a" { })?', innerExpressionDetails({
-        params: { a: result0 }
-      }));
-    });
-
-    it("computes params for a zero or more", function() {
-      expect(pass).toChangeAST('start = (a:"a" { })*', innerExpressionDetails({
-        params: { a: result1 }
-      }));
-    });
-
-    it("computes params for a one or more", function() {
-      expect(pass).toChangeAST('start = (a:"a" { })+', innerExpressionDetails({
-        params: { a: result1 }
-      }));
-    });
-  });
-
-  describe("scoping", function() {
-    it("creates a new scope for a choice", function() {
-      expect(pass).toChangeAST(
-        'start = (a:"a" / b:"b" / c:"c") { }',
-        expressionDetails({ params: {} })
-      );
-    });
-
-    it("creates a new scope for an action", function() {
-      expect(pass).toChangeAST('start = (a:"a" { }) { }', expressionDetails({
-        params: {}
-      }));
-    });
-
-    it("does not create a new scope for a sequence", function() {
-      expect(pass).toChangeAST(
-        'start = a:"a" b:"b" c:"c" { }',
-        expressionDetails({
-          params: { a: result0_0, b: result0_1, c: result0_2 }
-        })
-      );
-      expect(pass).toChangeAST(
-        'start = a:"a" (b:"b" c:"c" d:"d") e:"e"{ }',
-        expressionDetails({
-          params: {
-            a: result0_0,
-            b: result0_1_0,
-            c: result0_1_1,
-            d: result0_1_2,
-            e: result0_2
-          }
-        })
-      );
-    });
-
-    it("creates a new scope for a labeled", function() {
-      expect(pass).toChangeAST('start = a:(b:"b") { }', expressionDetails({
-        params: { a: result0 }
-      }));
-    });
-
-    it("creates a new scope for a simple and", function() {
-      expect(pass).toChangeAST('start = &(a:"a") { }', expressionDetails({
-        params: {}
-      }));
-    });
-
-    it("creates a new scope for a simple not", function() {
-      expect(pass).toChangeAST('start = !(a:"a") { }', expressionDetails({
-        params: {}
-      }));
-    });
-
-    it("creates a new scope for an optional", function() {
-      expect(pass).toChangeAST('start = (a:"a")? { }', expressionDetails({
-        params: {}
-      }));
-    });
-
-    it("creates a new scope for a zero or more", function() {
-      expect(pass).toChangeAST('start = (a:"a")* { }', expressionDetails({
-        params: {}
-      }));
-    });
-
-    it("creates a new scope for a one or more", function() {
-      expect(pass).toChangeAST('start = (a:"a")+ { }', expressionDetails({
-        params: {}
-      }));
-    });
-  });
-});
diff --git a/spec/index.html b/spec/index.html
index a328230..4a5db67 100644
--- a/spec/index.html
+++ b/spec/index.html
@@ -13,7 +13,6 @@
     <script src="compiler/passes/report-left-recursion.spec.js"></script>
     <script src="compiler/passes/remove-proxy-rules.spec.js"></script>
     <script src="compiler/passes/allocate-registers.spec.js"></script>
-    <script src="compiler/passes/compute-params.spec.js"></script>
     <script>
       (function() {
         var env      = jasmine.getEnv(),
diff --git a/src/compiler.js b/src/compiler.js
index ccff697..3ba1a01 100644
--- a/src/compiler.js
+++ b/src/compiler.js
@@ -8,7 +8,6 @@ PEG.compiler = {
     "reportLeftRecursion",
     "removeProxyRules",
     "allocateRegisters",
-    "computeParams",
     "generateCode"
   ],
 
diff --git a/src/compiler/passes.js b/src/compiler/passes.js
index 5997220..2e4db35 100644
--- a/src/compiler/passes.js
+++ b/src/compiler/passes.js
@@ -11,5 +11,4 @@ PEG.compiler.passes = {};
 // @include "passes/report-left-recursion.js"
 // @include "passes/remove-proxy-rules.js"
 // @include "passes/allocate-registers.js"
-// @include "passes/compute-params.js"
 // @include "passes/generate-code.js"
diff --git a/src/compiler/passes/allocate-registers.js b/src/compiler/passes/allocate-registers.js
index c6e1d8d..2e3255c 100644
--- a/src/compiler/passes/allocate-registers.js
+++ b/src/compiler/passes/allocate-registers.js
@@ -1,7 +1,11 @@
 /*
  * Allocates registers that the generated code for each node will use to store
- * match results and parse positions. The following will hold after running this
- * pass:
+ * match results and parse positions. For "action", "semantic_and" and
+ * "semantic_or" nodes it also computes visibility of labels at the point of
+ * action/predicate code execution and a mapping from label names to registers
+ * that will contain the labeled values.
+ *
+ * The following will hold after running this pass:
  *
  *   * All nodes except "grammar" and "rule" nodes will have a |resultIndex|
  *     property. It will contain an index of a register that will store a match
@@ -13,97 +17,211 @@
  *   * All "rule" nodes will contain a |registerCount| property. It will contain
  *     the number of registers that will be used by code generated for the
  *     rule's expression.
+ *
+ *   * All "action", "semantic_and" and "semantic_or" nodes will have a |params|
+ *     property. It will contain a mapping from names of labels visible at the
+ *     point of action/predicate code execution to registers that will contain
+ *     the labeled values.
  */
 PEG.compiler.passes.allocateRegisters = function(ast) {
-  function computeLeaf(node, index) { return 0; }
+  /*
+   * Register allocator that allocates registers from an unlimited
+   * integer-indexed pool. It allows allocating and releaseing registers in any
+   * order. It also supports reference counting (this simplifies tracking active
+   * registers when they store values passed to action/predicate code).
+   * Allocating a register allways uses the first free register (the one with
+   * the lowest index).
+   */
+  var registers = (function() {
+    var refCounts = []; // reference count for each register that was
+                        // allocated at least once
+
+    return {
+      alloc: function() {
+        var i;
+
+        for (i = 0; i < refCounts.length; i++) {
+          if (refCounts[i] === 0) {
+            refCounts[i] = 1;
+            return i;
+          }
+        }
+
+        refCounts.push(1);
+        return refCounts.length - 1;
+      },
 
-  function computeFromExpression(delta) {
-    return function(node, index) {
-      var depth;
+      use: function(index) {
+        refCounts[index]++;
+      },
 
-      node.expression.resultIndex = delta.result > 0
-        ? index + delta.result + delta.pos
-        : node.resultIndex;
+      release: function(index) {
+        refCounts[index]--;
+      },
 
-      depth = compute(
-        node.expression,
-        index + delta.result + delta.pos
-      );
+      maxIndex: function() {
+        return refCounts.length - 1;
+      },
 
-      if (delta.pos !== 0) {
-        node.posIndex = index + delta.pos;
+      reset: function() {
+        refCounts = [];
       }
+    };
+  })();
+
+  /*
+   * Manages mapping of label names to indices of registers that will store the
+   * labeled values as long as they are in scope.
+   */
+  var vars = (function(registers) {
+    var envs = []; // stack of nested environments
+
+    return {
+      beginScope: function() {
+        envs.push({});
+      },
+
+      endScope: function() {
+        var env = envs.pop(), name;
 
-      return depth + delta.result + delta.pos;
+        for (name in env) {
+          registers.release(env[name]);
+        }
+      },
+
+      add: function(name, index) {
+        envs[envs.length - 1][name] = index;
+        registers.use(index);
+      },
+
+      buildParams: function() {
+        var env = envs[envs.length - 1], params = {}, name;
+
+        for (name in env) {
+          params[name] = env[name];
+        }
+
+        return params;
+      }
     };
+  })(registers);
+
+  function savePos(node, f) {
+    node.posIndex = registers.alloc();
+    f();
+    registers.release(node.posIndex);
+  }
+
+  function reuseResult(node, subnode) {
+    subnode.resultIndex = node.resultIndex;
+  }
+
+  function allocResult(node, f) {
+    node.resultIndex = registers.alloc();
+    f();
+    registers.release(node.resultIndex);
+  }
+
+  function scoped(f) {
+    vars.beginScope();
+    f();
+    vars.endScope();
+  }
+
+  function nop() {}
+
+  function computeExpressionScoped(node) {
+    scoped(function() { compute(node.expression); })
+  }
+
+  function computeExpressionScopedReuseResult(node) {
+    reuseResult(node, node.expression);
+    computeExpressionScoped(node);
+  }
+
+  function computeExpressionScopedAllocResult(node) {
+    allocResult(node.expression, function() { computeExpressionScoped(node); });
+  }
+
+  function computeExpressionScopedReuseResultSavePos(node) {
+    savePos(node, function() { computeExpressionScopedReuseResult(node); });
+  }
+
+  function computeParams(node) {
+    node.params = vars.buildParams();
   }
 
   var compute = buildNodeVisitor({
     grammar:
-      function(node, index) {
-        each(node.rules, function(node) {
-          compute(node, index);
-        });
+      function(node) {
+        each(node.rules, compute);
       },
 
     rule:
-      function(node, index) {
-        var depth;
-
-        node.expression.resultIndex = index;
-
-        depth = compute(node.expression, index);
-
-        node.registerCount = depth + 1;
+      function(node) {
+        registers.reset();
+        computeExpressionScopedAllocResult(node);
+        node.registerCount = registers.maxIndex() + 1;
       },
 
-    named:        computeFromExpression({ result: 0, pos: 0 }),
+    named:
+      function(node) {
+        reuseResult(node, node.expression);
+        compute(node.expression);
+      },
 
     choice:
-      function(node, index) {
-        var depths = map(node.alternatives, function(alternative) {
-          alternative.resultIndex = node.resultIndex;
-
-          return compute(alternative, index);
+      function(node) {
+        each(node.alternatives, function(alternative) {
+          reuseResult(node, alternative);
+          scoped(function() {
+            compute(alternative);
+          });
         });
-
-        return Math.max.apply(null, depths);
       },
 
-    action:       computeFromExpression({ result: 0, pos: 1 }),
+    action:
+      function(node) {
+        savePos(node, function() {
+          reuseResult(node, node.expression);
+          scoped(function() {
+            compute(node.expression);
+            computeParams(node);
+          });
+        });
+      },
 
     sequence:
-      function(node, index) {
-        var depths = map(node.elements, function(element, i) {
-          element.resultIndex = index + i + 2;
-
-          return compute(element, index + i + 2);
+      function(node) {
+        savePos(node, function() {
+          each(node.elements, function(element) {
+            element.resultIndex = registers.alloc();
+            compute(element);
+          });
+          each(node.elements, function(element) {
+            registers.release(element.resultIndex);
+          });
         });
+      },
 
-        node.posIndex = index + 1;
-
-        return node.elements.length > 0
-          ? Math.max.apply(
-              null,
-              map(depths, function(d, i) { return i + d; })
-            )
-            + 2
-          : 1;
+    labeled:
+      function(node) {
+        vars.add(node.label, node.resultIndex);
+        computeExpressionScopedReuseResult(node);
       },
 
-    labeled:      computeFromExpression({ result: 0, pos: 0 }),
-    simple_and:   computeFromExpression({ result: 0, pos: 1 }),
-    simple_not:   computeFromExpression({ result: 0, pos: 1 }),
-    semantic_and: computeLeaf,
-    semantic_not: computeLeaf,
-    optional:     computeFromExpression({ result: 0, pos: 0 }),
-    zero_or_more: computeFromExpression({ result: 1, pos: 0 }),
-    one_or_more:  computeFromExpression({ result: 1, pos: 0 }),
-    rule_ref:     computeLeaf,
-    literal:      computeLeaf,
-    "class":      computeLeaf,
-    any:          computeLeaf
+    simple_and:   computeExpressionScopedReuseResultSavePos,
+    simple_not:   computeExpressionScopedReuseResultSavePos,
+    semantic_and: computeParams,
+    semantic_not: computeParams,
+    optional:     computeExpressionScopedReuseResult,
+    zero_or_more: computeExpressionScopedAllocResult,
+    one_or_more:  computeExpressionScopedAllocResult,
+    rule_ref:     nop,
+    literal:      nop,
+    "class":      nop,
+    any:          nop
   });
 
-  compute(ast, 0);
+  compute(ast);
 };
diff --git a/src/compiler/passes/compute-params.js b/src/compiler/passes/compute-params.js
deleted file mode 100644
index e1d2621..0000000
--- a/src/compiler/passes/compute-params.js
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * This pass walks through the AST and tracks what labels are visible at each
- * point. For "action", "semantic_and" and "semantic_or" nodes it computes
- * parameter names and values for the function used in generated code. (In the
- * emitter, user's code is wrapped into a function that is immediately executed.
- * Its parameter names correspond to visible labels and its parameter values to
- * their captured values). Implicitly, this pass defines scoping rules for
- * labels.
- *
- * After running this pass, all "action", "semantic_and" and "semantic_or" nodes
- * will have a |params| property containing an object mapping parameter names to
- * the expressions that will be used as their values.
- */
-PEG.compiler.passes.computeParams = function(ast) {
-  var envs = [];
-
-  function scoped(f) {
-    envs.push({});
-    f();
-    envs.pop();
-  }
-
-  function nop() {}
-
-  function computeForScopedExpression(node) {
-    scoped(function() { compute(node.expression); });
-  }
-
-  function computeParams(node) {
-    var env = envs[envs.length - 1], params = {}, name;
-
-    for (name in env) {
-      params[name] = env[name];
-    }
-    node.params = params;
-  }
-
-  var compute = buildNodeVisitor({
-    grammar:
-      function(node) {
-        each(node.rules, compute);
-      },
-
-    rule:         computeForScopedExpression,
-    named:
-      function(node) {
-        compute(node.expression);
-      },
-
-    choice:
-      function(node) {
-        scoped(function() { each(node.alternatives, compute); });
-      },
-
-    action:
-      function(node) {
-        scoped(function() {
-          compute(node.expression);
-          computeParams(node);
-        });
-      },
-
-    sequence:
-      function(node) {
-        var env = envs[envs.length - 1], name;
-
-        function fixup(name) {
-          each(pluck(node.elements, "resultIndex"), function(resultIndex, i) {
-            if (env[name].resultIndex === resultIndex) {
-              env[name] = {
-                resultIndex: node.resultIndex,
-                subindices:  [i].concat(env[name].subindices)
-              };
-            }
-          });
-        }
-
-        each(node.elements, compute);
-
-        for (name in env) {
-          fixup(name);
-        }
-      },
-
-    labeled:
-      function(node) {
-        envs[envs.length - 1][node.label] = {
-          resultIndex: node.resultIndex,
-          subindices:  []
-        };
-
-        scoped(function() { compute(node.expression); });
-      },
-
-    simple_and:   computeForScopedExpression,
-    simple_not:   computeForScopedExpression,
-    semantic_and: computeParams,
-    semantic_not: computeParams,
-    optional:     computeForScopedExpression,
-    zero_or_more: computeForScopedExpression,
-    one_or_more:  computeForScopedExpression,
-    rule_ref:     nop,
-    literal:      nop,
-    "class":      nop,
-    any:          nop
-  });
-
-  compute(ast);
-};
diff --git a/src/compiler/passes/generate-code.js b/src/compiler/passes/generate-code.js
index 93c6a67..da506d1 100644
--- a/src/compiler/passes/generate-code.js
+++ b/src/compiler/passes/generate-code.js
@@ -594,7 +594,7 @@ PEG.compiler.passes.generateCode = function(ast, options) {
             '#{posSave(node)};',
             '#block emit(node.expression)',
             'if (#{r(node.resultIndex)} !== null) {',
-            '  #{r(node.resultIndex)} = (function(#{(options.trackLineAndColumn ? ["offset", "line", "column"] : ["offset"]).concat(keys(node.params)).join(", ")}) {#{node.code}})(#{(options.trackLineAndColumn ? [r(node.posIndex) + ".offset", r(node.posIndex) + ".line", r(node.posIndex) + ".column"] : [r(node.posIndex)]).concat(map(values(node.params), param)).join(", ")});',
+            '  #{r(node.resultIndex)} = (function(#{(options.trackLineAndColumn ? ["offset", "line", "column"] : ["offset"]).concat(keys(node.params)).join(", ")}) {#{node.code}})(#{(options.trackLineAndColumn ? [r(node.posIndex) + ".offset", r(node.posIndex) + ".line", r(node.posIndex) + ".column"] : [r(node.posIndex)]).concat(map(values(node.params), r)).join(", ")});',
             '}',
             'if (#{r(node.resultIndex)} === null) {',
             '  #{posRestore(node)};',
@@ -641,10 +641,10 @@ PEG.compiler.passes.generateCode = function(ast, options) {
             '}'
           ],
           semantic_and: [
-            '#{r(node.resultIndex)} = (function(#{(options.trackLineAndColumn ? ["offset", "line", "column"] : ["offset"]).concat(keys(node.params)).join(", ")}) {#{node.code}})(#{(options.trackLineAndColumn ? ["pos.offset", "pos.line", "pos.column"] : ["pos"]).concat(map(values(node.params), param)).join(", ")}) ? "" : null;'
+            '#{r(node.resultIndex)} = (function(#{(options.trackLineAndColumn ? ["offset", "line", "column"] : ["offset"]).concat(keys(node.params)).join(", ")}) {#{node.code}})(#{(options.trackLineAndColumn ? ["pos.offset", "pos.line", "pos.column"] : ["pos"]).concat(map(values(node.params), r)).join(", ")}) ? "" : null;'
           ],
           semantic_not: [
-            '#{r(node.resultIndex)} = (function(#{(options.trackLineAndColumn ? ["offset", "line", "column"] : ["offset"]).concat(keys(node.params)).join(", ")}) {#{node.code}})(#{(options.trackLineAndColumn ? ["pos.offset", "pos.line", "pos.column"] : ["pos"]).concat(map(values(node.params), param)).join(", ")}) ? null : "";'
+            '#{r(node.resultIndex)} = (function(#{(options.trackLineAndColumn ? ["offset", "line", "column"] : ["offset"]).concat(keys(node.params)).join(", ")}) {#{node.code}})(#{(options.trackLineAndColumn ? ["pos.offset", "pos.line", "pos.column"] : ["pos"]).concat(map(values(node.params), r)).join(", ")}) ? null : "";'
           ],
           optional: [
             '#block emit(node.expression)',
@@ -751,11 +751,6 @@ PEG.compiler.passes.generateCode = function(ast, options) {
 
     vars.r = function(index) { return "r" + index; };
 
-    vars.param = function(param) {
-      return vars.r(param.resultIndex)
-           + map(param.subindices, function(i) { return "[" + i + "]"; });
-    };
-
     /* Position-handling macros */
     if (options.trackLineAndColumn) {
       vars.posInit    = function(name) {
diff --git a/src/parser.js b/src/parser.js
index 24f676d..52b15dd 100644
--- a/src/parser.js
+++ b/src/parser.js
@@ -190,7 +190,7 @@ PEG.parser = (function(){
                 rules:       rules,
                 startRule:   rules[0].name
               };
-            })(r1, r0[1], r0[2]);
+            })(r1, r4, r5);
         }
         if (r0 === null) {
           pos = r1;
@@ -223,7 +223,7 @@ PEG.parser = (function(){
                 type: "initializer",
                 code: code
               };
-            })(r1, r0[0]);
+            })(r1, r3);
         }
         if (r0 === null) {
           pos = r1;
@@ -282,7 +282,7 @@ PEG.parser = (function(){
                     }
                   : expression
               };
-            })(r1, r0[0], r0[1], r0[3]);
+            })(r1, r3, r4, r6);
         }
         if (r0 === null) {
           pos = r1;
@@ -353,7 +353,7 @@ PEG.parser = (function(){
               } else {
                 return head;
               }
-            })(r1, r0[0], r0[1]);
+            })(r1, r3, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -397,7 +397,7 @@ PEG.parser = (function(){
                 expression: expression,
                 code:       code
               };
-            })(r1, r0[0], r0[1]);
+            })(r1, r3, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -458,7 +458,7 @@ PEG.parser = (function(){
                 label:      label,
                 expression: expression
               };
-            })(r1, r0[0], r0[2]);
+            })(r1, r3, r5);
         }
         if (r0 === null) {
           pos = r1;
@@ -493,7 +493,7 @@ PEG.parser = (function(){
                 type: "semantic_and",
                 code: code
               };
-            })(r1, r0[1]);
+            })(r1, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -520,7 +520,7 @@ PEG.parser = (function(){
                   type:       "simple_and",
                   expression: expression
                 };
-              })(r1, r0[1]);
+              })(r1, r4);
           }
           if (r0 === null) {
             pos = r1;
@@ -547,7 +547,7 @@ PEG.parser = (function(){
                     type: "semantic_not",
                     code: code
                   };
-                })(r1, r0[1]);
+                })(r1, r4);
             }
             if (r0 === null) {
               pos = r1;
@@ -574,7 +574,7 @@ PEG.parser = (function(){
                       type:       "simple_not",
                       expression: expression
                     };
-                  })(r1, r0[1]);
+                  })(r1, r4);
               }
               if (r0 === null) {
                 pos = r1;
@@ -612,7 +612,7 @@ PEG.parser = (function(){
                 type:       "optional",
                 expression: expression
               };
-            })(r1, r0[0]);
+            })(r1, r3);
         }
         if (r0 === null) {
           pos = r1;
@@ -639,7 +639,7 @@ PEG.parser = (function(){
                   type:       "zero_or_more",
                   expression: expression
                 };
-              })(r1, r0[0]);
+              })(r1, r3);
           }
           if (r0 === null) {
             pos = r1;
@@ -666,7 +666,7 @@ PEG.parser = (function(){
                     type:       "one_or_more",
                     expression: expression
                   };
-                })(r1, r0[0]);
+                })(r1, r3);
             }
             if (r0 === null) {
               pos = r1;
@@ -726,7 +726,7 @@ PEG.parser = (function(){
                 type: "rule_ref",
                 name: name
               };
-            })(r1, r0[0]);
+            })(r1, r3);
         }
         if (r0 === null) {
           pos = r1;
@@ -767,7 +767,7 @@ PEG.parser = (function(){
                   pos = r2;
                 }
                 if (r0 !== null) {
-                  r0 = (function(offset, expression) { return expression; })(r1, r0[1]);
+                  r0 = (function(offset, expression) { return expression; })(r1, r4);
                 }
                 if (r0 === null) {
                   pos = r1;
@@ -799,7 +799,7 @@ PEG.parser = (function(){
           pos = r2;
         }
         if (r0 !== null) {
-          r0 = (function(offset, braced) { return braced.substr(1, braced.length - 2); })(r1, r0[0]);
+          r0 = (function(offset, braced) { return braced.substr(1, braced.length - 2); })(r1, r3);
         }
         if (r0 === null) {
           pos = r1;
@@ -865,7 +865,7 @@ PEG.parser = (function(){
         if (r0 !== null) {
           r0 = (function(offset, parts) {
               return "{" + parts.join("") + "}";
-            })(r1, r0[1]);
+            })(r1, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -1436,7 +1436,7 @@ PEG.parser = (function(){
         if (r0 !== null) {
           r0 = (function(offset, head, tail) {
               return head + tail.join("");
-            })(r1, r0[0], r0[1]);
+            })(r1, r3, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -1492,7 +1492,7 @@ PEG.parser = (function(){
                 value:      value,
                 ignoreCase: flags === "i"
               };
-            })(r1, r0[0], r0[1]);
+            })(r1, r3, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -1527,7 +1527,7 @@ PEG.parser = (function(){
           pos = r2;
         }
         if (r0 !== null) {
-          r0 = (function(offset, string) { return string; })(r1, r0[0]);
+          r0 = (function(offset, string) { return string; })(r1, r3);
         }
         if (r0 === null) {
           pos = r1;
@@ -1585,7 +1585,7 @@ PEG.parser = (function(){
           pos = r2;
         }
         if (r0 !== null) {
-          r0 = (function(offset, chars) { return chars.join(""); })(r1, r0[1]);
+          r0 = (function(offset, chars) { return chars.join(""); })(r1, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -1673,7 +1673,7 @@ PEG.parser = (function(){
           pos = r2;
         }
         if (r0 !== null) {
-          r0 = (function(offset, char_) { return char_; })(r1, r0[1]);
+          r0 = (function(offset, char_) { return char_; })(r1, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -1727,7 +1727,7 @@ PEG.parser = (function(){
           pos = r2;
         }
         if (r0 !== null) {
-          r0 = (function(offset, chars) { return chars.join(""); })(r1, r0[1]);
+          r0 = (function(offset, chars) { return chars.join(""); })(r1, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -1815,7 +1815,7 @@ PEG.parser = (function(){
           pos = r2;
         }
         if (r0 !== null) {
-          r0 = (function(offset, char_) { return char_; })(r1, r0[1]);
+          r0 = (function(offset, char_) { return char_; })(r1, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -1928,7 +1928,7 @@ PEG.parser = (function(){
                 inverted:   inverted === "^",
                 ignoreCase: flags === "i"
               };
-            })(r1, r0[1], r0[2], r0[4]);
+            })(r1, r4, r5, r7);
         }
         if (r0 === null) {
           pos = r1;
@@ -1985,7 +1985,7 @@ PEG.parser = (function(){
                 // FIXME: Get the raw text from the input directly.
                 rawText: begin.rawText + "-" + end.rawText
               };
-            })(r1, r0[0], r0[2]);
+            })(r1, r3, r5);
         }
         if (r0 === null) {
           pos = r1;
@@ -2093,7 +2093,7 @@ PEG.parser = (function(){
           pos = r2;
         }
         if (r0 !== null) {
-          r0 = (function(offset, char_) { return char_; })(r1, r0[1]);
+          r0 = (function(offset, char_) { return char_; })(r1, r4);
         }
         if (r0 === null) {
           pos = r1;
@@ -2184,7 +2184,7 @@ PEG.parser = (function(){
                 .replace("r", "\r")
                 .replace("t", "\t")
                 .replace("v", "\x0B"); // IE does not recognize "\v".
-            })(r1, r0[2]);
+            })(r1, r5);
         }
         if (r0 === null) {
           pos = r1;
@@ -2271,7 +2271,7 @@ PEG.parser = (function(){
         if (r0 !== null) {
           r0 = (function(offset, h1, h2) {
               return String.fromCharCode(parseInt(h1 + h2, 16));
-            })(r1, r0[1], r0[2]);
+            })(r1, r4, r5);
         }
         if (r0 === null) {
           pos = r1;
@@ -2326,7 +2326,7 @@ PEG.parser = (function(){
         if (r0 !== null) {
           r0 = (function(offset, h1, h2, h3, h4) {
               return String.fromCharCode(parseInt(h1 + h2 + h3 + h4, 16));
-            })(r1, r0[1], r0[2], r0[3], r0[4]);
+            })(r1, r4, r5, r6, r7);
         }
         if (r0 === null) {
           pos = r1;
@@ -2361,7 +2361,7 @@ PEG.parser = (function(){
           pos = r2;
         }
         if (r0 !== null) {
-          r0 = (function(offset, eol) { return eol; })(r1, r0[1]);
+          r0 = (function(offset, eol) { return eol; })(r1, r4);
         }
         if (r0 === null) {
           pos = r1;