Turned on SkSL->GLSL compiler

src/sksl/SkSLParser.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #include "stdio.h"
 #include "SkSLParser.h"
 #include "SkSLToken.h"
@@ skipping 38 matching lines @@
 #include "ast/SkSLASTExtension.h"
 #include "ast/SkSLASTFieldSuffix.h"
 #include "ast/SkSLASTFloatLiteral.h"
 #include "ast/SkSLASTForStatement.h"
 #include "ast/SkSLASTFunction.h"
 #include "ast/SkSLASTIdentifier.h"
 #include "ast/SkSLASTIfStatement.h"
 #include "ast/SkSLASTIndexSuffix.h"
 #include "ast/SkSLASTInterfaceBlock.h"
 #include "ast/SkSLASTIntLiteral.h"
+#include "ast/SkSLASTModifiersDeclaration.h"
 #include "ast/SkSLASTParameter.h"
+#include "ast/SkSLASTPrecision.h"
 #include "ast/SkSLASTPrefixExpression.h"
 #include "ast/SkSLASTReturnStatement.h"
 #include "ast/SkSLASTStatement.h"
 #include "ast/SkSLASTSuffixExpression.h"
 #include "ast/SkSLASTTernaryExpression.h"
 #include "ast/SkSLASTType.h"
 #include "ast/SkSLASTVarDeclaration.h"
 #include "ast/SkSLASTVarDeclarationStatement.h"
 #include "ast/SkSLASTWhileStatement.h"
 #include "ir/SkSLSymbolTable.h"
@@ skipping 20 matching lines @@
     sksllex_destroy(fScanner);
 }
 
 /* (precision | directive | declaration)* END_OF_FILE */
 std::vector<std::unique_ptr<ASTDeclaration>> Parser::file() {
     std::vector<std::unique_ptr<ASTDeclaration>> result;
     for (;;) {
         switch (this->peek().fKind) {
             case Token::END_OF_FILE:
                 return result;
-            case Token::PRECISION:
-                this->precision();
+            case Token::PRECISION: {
+                std::unique_ptr<ASTDeclaration> precision = this->precision();
+                if (precision) {
+                    result.push_back(std::move(precision));
+                }
                 break;
+            }
             case Token::DIRECTIVE: {
                 std::unique_ptr<ASTDeclaration> decl = this->directive();
                 if (decl) {
                     result.push_back(std::move(decl));
                 }
                 break;
             }
             default: {
                 std::unique_ptr<ASTDeclaration> decl = this->declaration();
                 if (!decl) {
@@ skipping 43 matching lines @@
 
 void Parser::error(Position p, std::string msg) {
     fErrors.error(p, msg);
 }
 
 bool Parser::isType(std::string name) {
     return nullptr != fTypes[name];
 }
 
 /* PRECISION (LOWP | MEDIUMP | HIGHP) type SEMICOLON */
-void Parser::precision() {
+std::unique_ptr<ASTDeclaration> Parser::precision() {
     if (!this->expect(Token::PRECISION, "'precision'")) {
-        return;
+        return nullptr;
     }
+    Modifiers::Flag result;
     Token p = this->nextToken();
     switch (p.fKind) {
-        case Token::LOWP: // fall through
-        case Token::MEDIUMP: // fall through
+        case Token::LOWP:
+            result = Modifiers::kLowp_Flag;
+            break;
+        case Token::MEDIUMP:
+            result = Modifiers::kMediump_Flag;
+            break;
         case Token::HIGHP:
-            // ignored for now
+            result = Modifiers::kHighp_Flag;
             break;
         default:
             this->error(p.fPosition, "expected 'lowp', 'mediump', or 'highp', but found '" + 
                                      p.fText + "'");
-            return;
+            return nullptr;
     }
+    // FIXME handle the type
     if (!this->type()) {
-        return;
+        return nullptr;
     }
     this->expect(Token::SEMICOLON, "';'");
+    return std::unique_ptr<ASTDeclaration>(new ASTPrecision(p.fPosition, result));
 }
 
-/* DIRECTIVE(#version) INT_LITERAL | DIRECTIVE(#extension) IDENTIFIER COLON IDENTIFIER */
+/* DIRECTIVE(#version) INT_LITERAL ("es" | "compatibility")? | 
+   DIRECTIVE(#extension) IDENTIFIER COLON IDENTIFIER */
 std::unique_ptr<ASTDeclaration> Parser::directive() {
     Token start;
     if (!this->expect(Token::DIRECTIVE, "a directive", &start)) {
         return nullptr;
     }
     if (start.fText == "#version") {
         this->expect(Token::INT_LITERAL, "a version number");
-        // ignored for now
+        Token next = this->peek();
+        if (next.fText == "es" || next.fText == "compatibility") {
+            this->nextToken();
+        }
+        // version is ignored for now; it will eventually become an error when we stop pretending
+        // to be GLSL
         return nullptr;
     } else if (start.fText == "#extension") {
         Token name;
         if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
             return nullptr;
         }
         if (!this->expect(Token::COLON, "':'")) {
             return nullptr;
         }
         // FIXME: need to start paying attention to this token
@@ skipping 13 matching lines @@
 std::unique_ptr<ASTDeclaration> Parser::declaration() {
     ASTModifiers modifiers = this->modifiers();
     Token lookahead = this->peek();
     if (lookahead.fKind == Token::IDENTIFIER && !this->isType(lookahead.fText)) {
         // we have an identifier that's not a type, could be the start of an interface block
         return this->interfaceBlock(modifiers);
     }
     if (lookahead.fKind == Token::STRUCT) {
         return this->structVarDeclaration(modifiers);
     }
+    if (lookahead.fKind == Token::SEMICOLON) {
+        this->nextToken();
+        return std::unique_ptr<ASTDeclaration>(new ASTModifiersDeclaration(modifiers));
+    }
     std::unique_ptr<ASTType> type(this->type());
     if (!type) {
         return nullptr;
     }
     if (type->fKind == ASTType::kStruct_Kind && peek().fKind == Token::SEMICOLON) {
         this->nextToken();
         return nullptr;
     }
     Token name;
     if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
@@ skipping 230 matching lines @@
 
 /* LAYOUT LPAREN IDENTIFIER EQ INT_LITERAL (COMMA IDENTIFIER EQ INT_LITERAL)* 
    RPAREN */
 ASTLayout Parser::layout() {
     int location = -1;
     int binding = -1;
     int index = -1;
     int set = -1;
     int builtin = -1;
     bool originUpperLeft = false;
+    bool overrideCoverage = false;
+    bool blendSupportAllEquations = false;
     if (this->peek().fKind == Token::LAYOUT) {
         this->nextToken();
         if (!this->expect(Token::LPAREN, "'('")) {
-            return ASTLayout(location, binding, index, set, builtin, originUpperLeft);
+            return ASTLayout(location, binding, index, set, builtin, originUpperLeft,
+                             overrideCoverage, blendSupportAllEquations);
         }
         for (;;) {
             Token t = this->nextToken();
             if (t.fText == "location") {
                 location = this->layoutInt();
             } else if (t.fText == "binding") {
                 binding = this->layoutInt();
             } else if (t.fText == "index") {
                 index = this->layoutInt();
             } else if (t.fText == "set") {
                 set = this->layoutInt();
             } else if (t.fText == "builtin") {
                 builtin = this->layoutInt();
             } else if (t.fText == "origin_upper_left") {
                 originUpperLeft = true;
+            } else if (t.fText == "override_coverage") {
+                overrideCoverage = true;
+            } else if (t.fText == "blend_support_all_equations") {
+                blendSupportAllEquations = true;
             } else {
                 this->error(t.fPosition, ("'" + t.fText + 
                                           "' is not a valid layout qualifier").c_str());
             }
             if (this->peek().fKind == Token::RPAREN) {
                 this->nextToken();
                 break;
             }
             if (!this->expect(Token::COMMA, "','")) {
                 break;
             }
         }
     }
-    return ASTLayout(location, binding, index, set, builtin, originUpperLeft);
+    return ASTLayout(location, binding, index, set, builtin, originUpperLeft, overrideCoverage,
+                     blendSupportAllEquations);
 }
 
 /* layout? (UNIFORM | CONST | IN | OUT | INOUT | LOWP | MEDIUMP | HIGHP | FLAT | NOPERSPECTIVE)* */
 ASTModifiers Parser::modifiers() {
     ASTLayout layout = this->layout();
     int flags = 0;
     for (;;) {
         // TODO: handle duplicate / incompatible flags
         switch (peek().fKind) {
             case Token::UNIFORM:
@@ skipping 681 matching lines @@
             }
             default:
                 return result;
         }
     }
 }
 
 /* postfixExpression | (PLUS | MINUS | NOT | PLUSPLUS | MINUSMINUS) unaryExpression */
 std::unique_ptr<ASTExpression> Parser::unaryExpression() {
     switch (this->peek().fKind) {
-        case Token::PLUS:     // fall through
-        case Token::MINUS:    // fall through
-        case Token::NOT:      // fall through
-        case Token::PLUSPLUS: // fall through
+        case Token::PLUS:       // fall through
+        case Token::MINUS:      // fall through
+        case Token::LOGICALNOT: // fall through
+        case Token::BITWISENOT: // fall through
+        case Token::PLUSPLUS:   // fall through
         case Token::MINUSMINUS: {
             Token t = this->nextToken();
             std::unique_ptr<ASTExpression> expr = this->unaryExpression();
             if (!expr) {
                 return nullptr;
             }
             return std::unique_ptr<ASTExpression>(new ASTPrefixExpression(t, std::move(expr)));
         }
         default:
             return this->postfixExpression();
@@ skipping 19 matching lines @@
                 }
                 result.reset(new ASTSuffixExpression(std::move(result), std::move(s)));
                 break;
             }
             default:
                 return result;
         }
     }
 }
 
-/* LBRACKET expression RBRACKET | DOT IDENTIFIER | LPAREN parameters RPAREN | 
+/* LBRACKET expression? RBRACKET | DOT IDENTIFIER | LPAREN parameters RPAREN | 
    PLUSPLUS | MINUSMINUS */
 std::unique_ptr<ASTSuffix> Parser::suffix() {
     Token next = this->nextToken();
     switch (next.fKind) {
         case Token::LBRACKET: {
+            if (this->peek().fKind == Token::RBRACKET) {
+                this->nextToken();
+                return std::unique_ptr<ASTSuffix>(new ASTIndexSuffix(next.fPosition));
+            }
             std::unique_ptr<ASTExpression> e = this->expression();
             if (!e) {
                 return nullptr;
             }
             this->expect(Token::RBRACKET, "']' to complete array access expression");
             return std::unique_ptr<ASTSuffix>(new ASTIndexSuffix(std::move(e)));
         }
         case Token::DOT: {
             Position pos = this->peek().fPosition;
             std::string text;
@@ skipping 125 matching lines @@
 bool Parser::identifier(std::string* dest) {
     Token t;
     if (this->expect(Token::IDENTIFIER, "identifier", &t)) {
         *dest = t.fText; 
         return true;
     }
     return false;
 }
 
 } // namespace