Revert of Turned on SkSL->GLSL compiler

src/sksl/SkSLCompiler.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 "SkSLCompiler.h"
 
 #include <fstream>
 #include <streambuf>
 
-#include "ast/SkSLASTPrecision.h"
 #include "SkSLIRGenerator.h"
 #include "SkSLParser.h"
 #include "SkSLSPIRVCodeGenerator.h"
 #include "ir/SkSLExpression.h"
 #include "ir/SkSLIntLiteral.h"
-#include "ir/SkSLModifiersDeclaration.h"
 #include "ir/SkSLSymbolTable.h"
 #include "ir/SkSLVarDeclaration.h"
 #include "SkMutex.h"
 
 #define STRINGIFY(x) #x
 
 // include the built-in shader symbols as static strings
 
-static const char* SKSL_INCLUDE =
+static std::string SKSL_INCLUDE = 
 #include "sksl.include"
 ;
 
-static const char* SKSL_VERT_INCLUDE =
+static std::string SKSL_VERT_INCLUDE = 
 #include "sksl_vert.include"
 ;
 
-static const char* SKSL_FRAG_INCLUDE =
+static std::string SKSL_FRAG_INCLUDE = 
 #include "sksl_frag.include"
 ;
 
 namespace SkSL {
 
 Compiler::Compiler() 
 : fErrorCount(0) {
     auto types = std::shared_ptr<SymbolTable>(new SymbolTable(*this));
     auto symbols = std::shared_ptr<SymbolTable>(new SymbolTable(types, *this));
     fIRGenerator = new IRGenerator(&fContext, symbols, *this);
@@ skipping 45 matching lines @@
     ADD_TYPE(GVec3);
     ADD_TYPE(GVec4);
     ADD_TYPE(DVec);
     ADD_TYPE(IVec);
     ADD_TYPE(UVec);
     ADD_TYPE(BVec);
 
     ADD_TYPE(Sampler1D);
     ADD_TYPE(Sampler2D);
     ADD_TYPE(Sampler3D);
-    ADD_TYPE(SamplerExternalOES);
     ADD_TYPE(SamplerCube);
     ADD_TYPE(Sampler2DRect);
     ADD_TYPE(Sampler1DArray);
     ADD_TYPE(Sampler2DArray);
     ADD_TYPE(SamplerCubeArray);
     ADD_TYPE(SamplerBuffer);
     ADD_TYPE(Sampler2DMS);
     ADD_TYPE(Sampler2DMSArray);
 
     ADD_TYPE(GSampler1D);
@@ skipping 11 matching lines @@
     ADD_TYPE(Sampler1DShadow);
     ADD_TYPE(Sampler2DShadow);
     ADD_TYPE(SamplerCubeShadow);
     ADD_TYPE(Sampler2DRectShadow);
     ADD_TYPE(Sampler1DArrayShadow);
     ADD_TYPE(Sampler2DArrayShadow);
     ADD_TYPE(SamplerCubeArrayShadow);
     ADD_TYPE(GSampler2DArrayShadow);
     ADD_TYPE(GSamplerCubeArrayShadow);
 
-    Modifiers::Flag ignored1;
-    std::vector<std::unique_ptr<ProgramElement>> ignored2;
-    this->internalConvertProgram(SKSL_INCLUDE, &ignored1, &ignored2);
+    std::vector<std::unique_ptr<ProgramElement>> ignored;
+    this->internalConvertProgram(SKSL_INCLUDE, &ignored);
     ASSERT(!fErrorCount);
 }
 
 Compiler::~Compiler() {
     delete fIRGenerator;
 }
 
 void Compiler::internalConvertProgram(std::string text,
-                                      Modifiers::Flag* defaultPrecision,
                                       std::vector<std::unique_ptr<ProgramElement>>* result) {
     Parser parser(text, *fTypes, *this);
     std::vector<std::unique_ptr<ASTDeclaration>> parsed = parser.file();
     if (fErrorCount) {
         return;
     }
-    *defaultPrecision = Modifiers::kHighp_Flag;
     for (size_t i = 0; i < parsed.size(); i++) {
         ASTDeclaration& decl = *parsed[i];
         switch (decl.fKind) {
             case ASTDeclaration::kVar_Kind: {
                 std::unique_ptr<VarDeclarations> s = fIRGenerator->convertVarDeclarations(
                                                                          (ASTVarDeclarations&) decl, 
                                                                          Variable::kGlobal_Storage);
                 if (s) {
                     result->push_back(std::move(s));
                 }
                 break;
             }
             case ASTDeclaration::kFunction_Kind: {
                 std::unique_ptr<FunctionDefinition> f = fIRGenerator->convertFunction(
                                                                                (ASTFunction&) decl);
                 if (f) {
                     result->push_back(std::move(f));
                 }
                 break;
             }
-            case ASTDeclaration::kModifiers_Kind: {
-                std::unique_ptr<ModifiersDeclaration> f = fIRGenerator->convertModifiersDeclaration(
-                                                                   (ASTModifiersDeclaration&) decl);
-                if (f) {
-                    result->push_back(std::move(f));
-                }
-                break;
-            }
             case ASTDeclaration::kInterfaceBlock_Kind: {
                 std::unique_ptr<InterfaceBlock> i = fIRGenerator->convertInterfaceBlock(
                                                                          (ASTInterfaceBlock&) decl);
                 if (i) {
                     result->push_back(std::move(i));
                 }
                 break;
             }
             case ASTDeclaration::kExtension_Kind: {
                 std::unique_ptr<Extension> e = fIRGenerator->convertExtension((ASTExtension&) decl);
                 if (e) {
                     result->push_back(std::move(e));
                 }
                 break;
             }
-            case ASTDeclaration::kPrecision_Kind: {
-                *defaultPrecision = ((ASTPrecision&) decl).fPrecision;
-                break;
-            }
             default:
                 ABORT("unsupported declaration: %s\n", decl.description().c_str());
         }
     }
 }
 
 std::unique_ptr<Program> Compiler::convertProgram(Program::Kind kind, std::string text) {
     fErrorText = "";
     fErrorCount = 0;
     fIRGenerator->pushSymbolTable();
     std::vector<std::unique_ptr<ProgramElement>> elements;
-    Modifiers::Flag ignored;
     switch (kind) {
         case Program::kVertex_Kind:
-            this->internalConvertProgram(SKSL_VERT_INCLUDE, &ignored, &elements);
+            this->internalConvertProgram(SKSL_VERT_INCLUDE, &elements);
             break;
         case Program::kFragment_Kind:
-            this->internalConvertProgram(SKSL_FRAG_INCLUDE, &ignored, &elements);
+            this->internalConvertProgram(SKSL_FRAG_INCLUDE, &elements);
             break;
     }
-    Modifiers::Flag defaultPrecision;
-    this->internalConvertProgram(text, &defaultPrecision, &elements);
-    auto result = std::unique_ptr<Program>(new Program(kind, defaultPrecision, std::move(elements), 
+    this->internalConvertProgram(text, &elements);
+    auto result = std::unique_ptr<Program>(new Program(kind, std::move(elements), 
                                                        fIRGenerator->fSymbolTable));;
     fIRGenerator->popSymbolTable();
     this->writeErrorCount();
     return result;
 }
 
 void Compiler::error(Position position, std::string msg) {
     fErrorCount++;
     fErrorText += "error: " + position.description() + ": " + msg.c_str() + "\n";
 }
@@ skipping 47 matching lines @@
                       std::string* out) {
     std::stringstream buffer;
     bool result = this->toGLSL(kind, text, caps, buffer);
     if (result) {
         *out = buffer.str();
     }
     return result;
 }
 
 } // namespace