scripts: Adopted Parser class in prettyasserts.py

This ended up being a pretty in-depth rework of prettyasserts.py to
adopt the shared Parser class. But now prettyasserts.py should be both
more robust and faster.

The tricky parts:

- The Parser class eagerly munches whitespace by default. This is
  usually a good thing, but for prettyasserts.py we need to keep track
  of the whitespace somehow in order to write it to the output file.

  The solution here is a little bit hacky. Instead of complicating the
  Parser class, we implicitly add a regex group for whitespace when
  compiling our lexer.

  Unfortunately this does make last-minute patching of the lexer a bit
  messy (for things like -p/--prefix, etc), thanks to Python's
  re.Pattern class not being extendable. To work around this, the Lexer
  class keeps track of the original patterns to allow recompilation.

- Since we no longer tokenize in a separate pass, we can't use the
  None token to match any unmatched tokens.

  Fortunately this can be worked around with sufficiently ugly regex.
  See the 'STUFF' rule.

  It's a good thing Python has negative lookaheads.

  On the flip side, this means we no longer need to explicitly specify
  all possible tokens when multiple tokens overlap.

- Unlike stack.py/csv.py, prettyasserts.py needs multi-token lookahead.

  Fortunately this has a pretty straightforward solution with the
  addition of an optional stack to the Parser class.

  We can even have a bit of fun with Python's with statements (though I
  do wish with statements could have else clauses, so we wouldn't need
  double nesting to catch parser exceptions).

---

In addition to adopting the new Parser class, I also made sure to
eliminate intermediate string allocation through heavy use of Python's
io.StringIO class.

This, plus Parser's cheap shallow chomp/slice operations, gives
prettyasserts.py a much needed speed boost.

(Honestly, the original prettyasserts.py was pretty naive, with the
assumption that it wouldn't be the bottleneck during compilation. This
turned out to be wrong.)

These changes cut total compile time in ~half:

                                          real      user      sys
  before (time make test-runner -j): 0m56.202s 2m31.853s 0m2.827s
  after  (time make test-runner -j): 0m26.836s 1m51.213s 0m2.338s

Keep in mind this includes both prettyasserts.py and gcc -Os (and other
Makefile stuff).

scripts/stack.py

@@ -171,7 +171,7 @@ def openio(path, mode='r', buffering=-1):
 # basically just because memoryview doesn't support strs
 class Parser:
     def __init__(self, data, ws='\s*', ws_flags=0):
-        self.data = data.lstrip()
+        self.data = data
         self.i = 0
         self.m = None
         # also consume whitespace
@@ -179,9 +179,10 @@ class Parser:
         self.i = self.ws.match(self.data, self.i).end()
 
     def __repr__(self):
-        return '%s(%r...)' % (
-                self.__class__.__name__,
-                self.data[self.i:self.i+32])
+        if len(self.data) - self.i <= 32:
+            return repr(self.data[self.i:])
+        else:
+            return "%s..." % repr(self.data[self.i:self.i+32])[:32]
 
     def __str__(self):
         return self.data[self.i:]
@@ -212,15 +213,36 @@ class Parser:
 
     def chompmatch(self, pattern, flags=0, *groups):
         if not self.match(pattern, flags):
-            raise Parser.Error(
-                    "expected %r, found %r..." % (
-                        pattern, self.data[self.i:self.i+32]))
+            raise Parser.Error("expected %r, found %r" % (pattern, self))
         return self.chomp(*groups)
 
     def unexpected(self):
-        raise Parser.Error(
-                "unexpected %r..." % (
-                    self.data[self.i:self.i+32]))
+        raise Parser.Error("unexpected %r" % self)
+
+    def lookahead(self):
+        # push state on the stack
+        if not hasattr(self, 'stack'):
+            self.stack = []
+        self.stack.append((self.i, self.m))
+        return self
+
+    def consume(self):
+        # pop and use new state
+        self.stack.pop()
+
+    def discard(self):
+        # pop and discard new state
+        self.i, self.m = self.stack.pop()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, et, ev, tb):
+        # keep new state if no exception occured
+        if et is None:
+            self.consume()
+        else:
+            self.discard()
 
 class CGNode(co.namedtuple('CGNode', [
         'name', 'file', 'size', 'qualifiers', 'calls'])):