Turned on SkSL->GLSL compiler

src/sksl/SkSLGLSLCodeGenerator.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #ifndef SKSL_GLSLCODEGENERATOR
 #define SKSL_GLSLCODEGENERATOR
 
@@ skipping 32 matching lines @@
 namespace SkSL {
 
 #define kLast_Capability SpvCapabilityMultiViewport
 
 struct GLCaps {
     int fVersion;
     enum {
         kGL_Standard,
         kGLES_Standard
     } fStandard;
+    bool fIsCoreProfile;
+    bool fUsesPrecisionModifiers;
+    bool fMustDeclareFragmentShaderOutput;
+    // The Tegra3 compiler will sometimes never return if we have min(abs(x), y)
+    bool fCanUseMinAndAbsTogether;
 };
 
 /**
  * Converts a Program into GLSL code.
  */
 class GLSLCodeGenerator : public CodeGenerator {
 public:
     enum Precedence {
         kParentheses_Precedence    =  1,
         kPostfix_Precedence        =  2,
@@ skipping 11 matching lines @@
         kLogicalOr_Precedence      = 14,
         kTernary_Precedence        = 15,
         kAssignment_Precedence     = 16,
         kSequence_Precedence       = 17,
         kTopLevel_Precedence       = 18
     };
 
     GLSLCodeGenerator(const Context* context, GLCaps caps)
     : fContext(*context)
     , fCaps(caps)
+    , fOut(nullptr)
+    , fVarCount(0)
     , fIndentation(0)
     , fAtLineStart(true) {}
 
     void generateCode(const Program& program, std::ostream& out) override;
 
 private:
     void write(const char* s);
 
     void writeLine();
 
@@ skipping 10 matching lines @@
     void writeInterfaceBlock(const InterfaceBlock& intf);
 
     void writeFunctionStart(const FunctionDeclaration& f);
     
     void writeFunctionDeclaration(const FunctionDeclaration& f);
 
     void writeFunction(const FunctionDefinition& f);
 
     void writeLayout(const Layout& layout);
 
-    void writeModifiers(const Modifiers& modifiers);
+    void writeModifiers(const Modifiers& modifiers, bool globalContext);
     
     void writeGlobalVars(const VarDeclaration& vs);
 
-    void writeVarDeclarations(const VarDeclarations& decl);
+    void writeVarDeclarations(const VarDeclarations& decl, bool global);
 
     void writeVariableReference(const VariableReference& ref);
 
     void writeExpression(const Expression& expr, Precedence parentPrecedence);
     
     void writeIntrinsicCall(const FunctionCall& c);
 
+    void writeMinAbsHack(Expression& absExpr, Expression& otherExpr);
+
     void writeFunctionCall(const FunctionCall& c);
 
     void writeConstructor(const Constructor& c);
 
     void writeFieldAccess(const FieldAccess& f);
 
     void writeSwizzle(const Swizzle& swizzle);
 
     void writeBinaryExpression(const BinaryExpression& b, Precedence parentPrecedence);
 
@@ skipping 21 matching lines @@
 
     void writeWhileStatement(const WhileStatement& w);
 
     void writeDoStatement(const DoStatement& d);
 
     void writeReturnStatement(const ReturnStatement& r);
 
     const Context& fContext;
     const GLCaps fCaps;
     std::ostream* fOut;
+    std::string fFunctionHeader;
+    Program::Kind fProgramKind;
+    int fVarCount;
     int fIndentation;
     bool fAtLineStart;
     // Keeps track of which struct types we have written. Given that we are unlikely to ever write 
     // more than one or two structs per shader, a simple linear search will be faster than anything 
     // fancier.
     std::vector<const Type*> fWrittenStructs;
 };
 
 }
 
 #endif