Turned on SkSL->GLSL compiler

src/sksl/SkSLIRGenerator.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_IRGENERATOR
 #define SKSL_IRGENERATOR
 
 #include "SkSLErrorReporter.h"
 #include "ast/SkSLASTBinaryExpression.h"
 #include "ast/SkSLASTBlock.h"
 #include "ast/SkSLASTBreakStatement.h"
 #include "ast/SkSLASTCallSuffix.h"
 #include "ast/SkSLASTContinueStatement.h"
 #include "ast/SkSLASTDiscardStatement.h"
 #include "ast/SkSLASTDoStatement.h"
 #include "ast/SkSLASTExpression.h"
 #include "ast/SkSLASTExpressionStatement.h"
 #include "ast/SkSLASTExtension.h"
 #include "ast/SkSLASTForStatement.h"
 #include "ast/SkSLASTFunction.h"
 #include "ast/SkSLASTIdentifier.h"
 #include "ast/SkSLASTIfStatement.h"
 #include "ast/SkSLASTInterfaceBlock.h"
 #include "ast/SkSLASTModifiers.h"
+#include "ast/SkSLASTModifiersDeclaration.h"
 #include "ast/SkSLASTPrefixExpression.h"
 #include "ast/SkSLASTReturnStatement.h"
 #include "ast/SkSLASTStatement.h"
 #include "ast/SkSLASTSuffixExpression.h"
 #include "ast/SkSLASTTernaryExpression.h"
 #include "ast/SkSLASTVarDeclaration.h"
 #include "ast/SkSLASTVarDeclarationStatement.h"
 #include "ast/SkSLASTWhileStatement.h"
 #include "ir/SkSLBlock.h"
 #include "ir/SkSLExpression.h"
 #include "ir/SkSLExtension.h"
 #include "ir/SkSLFunctionDefinition.h"
 #include "ir/SkSLInterfaceBlock.h"
 #include "ir/SkSLModifiers.h"
+#include "ir/SkSLModifiersDeclaration.h"
 #include "ir/SkSLSymbolTable.h"
 #include "ir/SkSLStatement.h"
 #include "ir/SkSLType.h"
 #include "ir/SkSLTypeReference.h"
 #include "ir/SkSLVarDeclaration.h"
 
 namespace SkSL {
 
 /**
  * Performs semantic analysis on an abstract syntax tree (AST) and produces the corresponding 
  * (unoptimized) intermediate representation (IR).
  */
 class IRGenerator {
 public:
     IRGenerator(const Context* context, std::shared_ptr<SymbolTable> root, 
                 ErrorReporter& errorReporter);
 
     std::unique_ptr<VarDeclarations> convertVarDeclarations(const ASTVarDeclarations& decl, 
                                                             Variable::Storage storage);
     std::unique_ptr<FunctionDefinition> convertFunction(const ASTFunction& f);
     std::unique_ptr<Statement> convertStatement(const ASTStatement& statement);
     std::unique_ptr<Expression> convertExpression(const ASTExpression& expression);
+    std::unique_ptr<ModifiersDeclaration> convertModifiersDeclaration(
+                                                                  const ASTModifiersDeclaration& m);
 
 private:
     void pushSymbolTable();
     void popSymbolTable();
 
     const Type* convertType(const ASTType& type);
     std::unique_ptr<Expression> call(Position position, 
                                      const FunctionDeclaration& function, 
                                      std::vector<std::unique_ptr<Expression>> arguments);
     bool determineCallCost(const FunctionDeclaration& function, 
@@ skipping 40 matching lines @@
     std::shared_ptr<SymbolTable> fSymbolTable;
     ErrorReporter& fErrors;
 
     friend class AutoSymbolTable;
     friend class Compiler;
 };
 
 }
 
 #endif