added initial GLSL support to skslc

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"
 
 #define register
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunneeded-internal-declaration"
 #pragma clang diagnostic ignored "-Wnull-conversion"
+#pragma clang diagnostic ignored "-Wsign-compare"
+#endif
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-compare"
 #endif
 #include "lex.sksl.c"
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 #undef register
 
 #include "ast/SkSLASTBinaryExpression.h"
 #include "ast/SkSLASTBlock.h"
 #include "ast/SkSLASTBoolLiteral.h"
 #include "ast/SkSLASTBreakStatement.h"
 #include "ast/SkSLASTCallSuffix.h"
 #include "ast/SkSLASTContinueStatement.h"
 #include "ast/SkSLASTDiscardStatement.h"
 #include "ast/SkSLASTDoStatement.h"
@@ skipping 432 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;
     if (this->peek().fKind == Token::LAYOUT) {
         this->nextToken();
         if (!this->expect(Token::LPAREN, "'('")) {
-            return ASTLayout(location, binding, index, set, builtin);
+            return ASTLayout(location, binding, index, set, builtin, originUpperLeft);
         }
         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 {
                 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);
+    return ASTLayout(location, binding, index, set, builtin, originUpperLeft);
 }
 
-/* layout? (UNIFORM | CONST | IN | OUT | INOUT | LOWP | 
-   MEDIUMP | HIGHP)* */
+/* 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:
                 this->nextToken();
                 flags |= ASTModifiers::kUniform_Flag;
                 break;
@@ skipping 19 matching lines @@
                 flags |= ASTModifiers::kLowp_Flag;
                 break;
             case Token::MEDIUMP:
                 this->nextToken();
                 flags |= ASTModifiers::kMediump_Flag;
                 break;
             case Token::HIGHP:
                 this->nextToken();
                 flags |= ASTModifiers::kHighp_Flag;
                 break;
+            case Token::FLAT:
+                this->nextToken();
+                flags |= ASTModifiers::kFlat_Flag;
+                break;
+            case Token::NOPERSPECTIVE:
+                this->nextToken();
+                flags |= ASTModifiers::kNoPerspective_Flag;
+                break;
             default:
                 return ASTModifiers(layout, flags);
         }
     }
 }
 
 ASTModifiers Parser::modifiersWithDefaults(int defaultFlags) {
     ASTModifiers result = this->modifiers();
     if (!result.fFlags) {
         return ASTModifiers(result.fLayout, defaultFlags);
@@ skipping 824 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