sclass SimpleLeftToRightParser > Meta {
  S text;
  LS tok;
  gettable TokPtr ptr;
  TokPtr mainLoopPtr;
  S currentToken;
  bool caseInsensitive;
  new L warnings;
  
  settable bool internIdentifiers;
  
  *() {}
  *(S *text) {}
  *(LS *tok) {}
  
  swappable LS tokenize(S text) { ret javaTok(text); }
  
  S t aka token() { ret currentToken; }
  S token(int i) { ret get(tok, ptr.idx()+i*2); }
  S next aka consume aka tpp() { var t = t(); next(1); ret t; }
  S lastSpace aka prevSpace() { ret get(tok, ptr.idx()-1); }
  S nextSpace() { ret get(tok, ptr.idx()+1); }
  S space(int i) { ret get(tok, ptr.idx()+i*2+1); }
  
  void unconsume() { next(-1); }
  
  bool tokEq aka eqTok(S a, S b) { ret eqOrEqic(caseInsensitive, a, b); }
  bool tokEqOneOf(S a, S... l) { ret any(l, b -> tokEq(a, b)); }
  
  bool is(int i, S t) { ret tokEq(token(i), t); }
  bool is(S t) { ret tokEq(currentToken, t); }
  bool was(S t) { ret tokEq(token(-1), t); }
  
  bool isOneOf(S... tokens) { ret tokEqOneOf(currentToken, tokens); }
  
  S[] consumeArray(int n) {
    S[] array = new[n];
    for i to n: array[i] = consume();
    ret array;
  }
  
  meta-for isInteger also as isIdentifier {
    bool isInteger() { ret isInteger(t()); }
    bool isInteger(S s) { ret main isInteger(s); }
  }
  
  S consumeIdentifier() {
    S s = assertIdentifier(consume());
    if (internIdentifiers)
      s = intern(s);
    ret s;
  }
  
  S consumeIdentifierOpt() { ret isIdentifier(t()) ? consumeIdentifier() : null; }
  
  int consumeInteger() { ret parseInt(assertInteger(consume())); }
  
  bool consumeOpt(S token) {
    if (!is(token)) false;
    consume();
    true;
  }
  
  void consume(S token) {
    if (!is(token))
      fail("Expected " + quote(token) + ", got " + describeToken(token());
    consume();
  }
  
  S describeToken(S token) {
    ret token == null ? "EOF" : quote(token);
  }
  
  S consumeOneOf(S... tokens) {
    if (!isOneOf(tokens))
      fail("Expected one of " + asList(tokens));
    ret consume();
  }
  
  void ptr(TokPtr ptr) { this.ptr = ptr; fetch(); }
  int idx aka tokIdx() { ret ptr.idx(); }
  int lTok() { ret l(tok); }
  int nRemainingTokens() { ret (lTok()-idx())/2; }

  bool atEnd aka endOfText() { ret ptr.atEnd(); }
    
  void fetch { currentToken = ptr!; }
  
  bool lineBreak() { ret containsLineBreak(get(tok, ptr.idx()-1)); }
  bool atEndOrLineBreak() { ret atEnd() || lineBreak(); }
  
  void init {
    tok if null = tokenize(text);
    if (ptr == null) ptr(ListAndIndex(tok, 1));
  }
  
  bool mainLoop() {
    init();
    if (atEnd()) false;
    if (eq(mainLoopPtr, ptr))
      fail("main loop didn't advance (current token: " + quote(token()) + ")");
    mainLoopPtr = ptr;
    true;
  }
  
  class AssureAdvance {
    TokPtr cur;
    
    { init(); }
    
    bool get() {
      if (atEnd()) false;
      if (eq(cur, ptr))
        fail("Parse loop didn't advance (current token: " + quote(token()) + ")");
      cur = ptr;
      true;
    }
  }
  
  void unknownToken {
    warn("Unknown token: " + t());
  }
  
  void warn(S msg) {
    warnings.add(print(msg));
  }
  
  // can also move backwards for negative n
  void next aka skip aka consume(int n) { 
    ptr(min(lTok(), ptr.idx()+n*2));
  }
  
  // if i points to an N token, it is incremented
  void ptr(int i) {
    ptr(ListAndIndex(tok, min(i | 1, l(tok))));
  }
  
  LineAndColumn lineAndColumn() {
    ret tokenToLineAndColumn(ptr);
  }
  
  LineAndColumn lineAndColumn(int idx) {
    ret tokenToLineAndColumn(ptr.plus(idx*2));
  }
  
  S consumeUntilSpaceOr(IF0<Bool> pred) {
    int i = idx();
    do next(); while (!atEnd() && empty(lastSpace()) && !pred!);
    ret joinSubList(tok, i, idx()-1);
  }
  
  void setText(S text) {
    this.text = text;
    tok = null;
    ptr = null;
  }
  
  int relativeIndexOf(S token) {
    int n = nRemainingTokens();
    for i to n:
      if (eqTok(token(i), token))
        ret i;
    ret -1;
  }
}

Began life as a copy of #1033717