Revert "Switch to the new SkSL lexer."

This reverts commit c576e93d174f3106e072a2f506bca3990b541265.

Reason for revert: ASAN failures

Original change's description:
> Switch to the new SkSL lexer.
> 
> This completely replaces flex with a new in-house lexical analyzer generator,
> which we have done for performance and memory usage reasons. Flex requires us
> to copy strings every time we need the text of a token, whereas this new lexer
> allows us to handle strings as a (non-null-terminated) pointer and length
> everywhere, eliminating most string copies.
> 
> Bug: skia:
> Change-Id: I2add26efc9e20cb699520e82abcf713af3968aca
> Reviewed-on: https://skia-review.googlesource.com/39780
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Commit-Queue: Ethan Nicholas <ethannicholas@google.com>

TBR=bsalomon@google.com,ethannicholas@google.com

Change-Id: If27b750a5f696d06a6bcffed12fe9f0598e084a6
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/44881
Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
Commit-Queue: Ethan Nicholas <ethannicholas@google.com>

1 files changed, 12 insertions, 11 deletions

diff --git a/src/sksl/ir/SkSLVariableReference.h b/src/sksl/ir/SkSLVariableReference.h
index 54917b0431..ba17437e24 100644
--- a/src/sksl/ir/SkSLVariableReference.h
+++ b/src/sksl/ir/SkSLVariableReference.h
@@ -32,8 +32,8 @@ struct VariableReference : public Expression {
         kReadWrite_RefKind
     };
 
-    VariableReference(int offset, const Variable& variable, RefKind refKind = kRead_RefKind)
-    : INHERITED(offset, kVariableReference_Kind, variable.fType)
+    VariableReference(Position position, const Variable& variable, RefKind refKind = kRead_RefKind)
+    : INHERITED(position, kVariableReference_Kind, variable.fType)
     , fVariable(variable)
     , fRefKind(refKind) {
         if (refKind != kRead_RefKind) {
@@ -83,17 +83,18 @@ struct VariableReference : public Expression {
         ASSERT(expr->isConstant());
         switch (expr->fKind) {
             case Expression::kIntLiteral_Kind:
-                return std::unique_ptr<Expression>(new IntLiteral(irGenerator.fContext,
-                                                                  -1,
-                                                                  ((IntLiteral*) expr)->fValue));
+                return std::unique_ptr<Expression>(new IntLiteral(
+                                                                 irGenerator.fContext,
+                                                                 Position(),
+                                                                 ((IntLiteral*) expr)->fValue));
             case Expression::kFloatLiteral_Kind:
                 return std::unique_ptr<Expression>(new FloatLiteral(
-                                                                   irGenerator.fContext,
-                                                                   -1,
-                                                                   ((FloatLiteral*) expr)->fValue));
+                                                               irGenerator.fContext,
+                                                               Position(),
+                                                               ((FloatLiteral*) expr)->fValue));
             case Expression::kBoolLiteral_Kind:
                 return std::unique_ptr<Expression>(new BoolLiteral(irGenerator.fContext,
-                                                                   -1,
+                                                                   Position(),
                                                                    ((BoolLiteral*) expr)->fValue));
             case Expression::kConstructor_Kind: {
                 const Constructor* c = (const Constructor*) expr;
@@ -101,12 +102,12 @@ struct VariableReference : public Expression {
                 for (const auto& arg : c->fArguments) {
                     args.push_back(copy_constant(irGenerator, arg.get()));
                 }
-                return std::unique_ptr<Expression>(new Constructor(-1, c->fType,
+                return std::unique_ptr<Expression>(new Constructor(Position(), c->fType,
                                                                    std::move(args)));
             }
             case Expression::kSetting_Kind: {
                 const Setting* s = (const Setting*) expr;
-                return std::unique_ptr<Expression>(new Setting(-1, s->fName,
+                return std::unique_ptr<Expression>(new Setting(Position(), s->fName,
                                                                copy_constant(irGenerator,
                                                                              s->fValue.get())));
             }