static new AtomicInteger nlParse_count; // how often did we parse something?

static Lisp nlParse(S s) {
  ret nlParse(s, true);
}

static Lisp nlParse(S s, boolean unbracket) {
  ret nlParse(codeTokens(snlTok(s)), unbracket, false, null);
}

static Lisp nlParse(S s, boolean unbracket, boolean explicitBrackets) {
  ret nlParse(codeTokens(snlTok(s)), unbracket, explicitBrackets, null);
}

static Lisp nlParse(L<S> tok) {
  ret nlParse(tok, true, false, null);
}

// unbracket refers to outermost brackets
// explicitBrackets refers to inner brackets
static Lisp nlParse(L<S> tok, boolean unbracket, final boolean explicitBrackets, L<S> warnings) {
  nlParse_count.incrementAndGet();
  
  class Entry {
    int i;
    Lisp tree;
    S wrapper;
    
    *(int *i) {
      tree = lisp("[]");
    }
    
    *(int *i, S bracket) {
      tree = lisp("[]");
      wrapper = bracket;
    }
    
    Lisp wrapped() {
      Lisp t = explicitBrackets ? tree : nlUnbracket(tree);
      ret wrapper == null ? t : lisp(wrapper, t);
    }
  }

  new L<Entry> stack;
  stack.add(new Entry(0));
  
  for (int i = 0; i < l(tok); i++) {
    S t = tok.get(i);
    if (eq(t, "[") || eq(t, "(")) {
      stack.add(new Entry(i, eq(t, "(") ? "()" : null));
    } else if (eq(t, "]") || eq(t, ")")) {
      if (l(stack) == 1)
        warn("too many closing brackets", warnings);
      else {
        Entry e = popLast(stack);
        /*if (!bracketsMatch(tok.get(e.i), t))
          warn("non-matching brackets");*/
        last(stack).tree.add(e.wrapped());
      }
    } else
      last(stack).tree.add(t);
  }
  
  while (l(stack) > 1) {
    warn("too many opening brackets", warnings);
    Entry e = popLast(stack);
    last(stack).tree.add(e.wrapped());
  }
  
  Lisp result = last(stack).wrapped();
  ret unbracket ? nlUnbracket(result) : result;
}