Revert of Turned on SkSL->GLSL compiler

src/sksl/SkSLGLSLCodeGenerator.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 "SkSLGLSLCodeGenerator.h"
 
 #include "string.h"
 
 #include "GLSL.std.450.h"
 
 #include "ir/SkSLExpressionStatement.h"
 #include "ir/SkSLExtension.h"
 #include "ir/SkSLIndexExpression.h"
-#include "ir/SkSLModifiersDeclaration.h"
 #include "ir/SkSLVariableReference.h"
 
-#define SK_FRAGCOLOR_BUILTIN 10001
-
 namespace SkSL {
 
 void GLSLCodeGenerator::write(const char* s) {
     if (s[0] == 0) {
         return;
     }
     if (fAtLineStart) {
         for (int i = 0; i < fIndentation; i++) {
             *fOut << "    ";
         }
@@ skipping 30 matching lines @@
             if (*search == type) {
                 // already written
                 this->write(type.name());
                 return;
             }
         }
         fWrittenStructs.push_back(&type);
         this->writeLine("struct " + type.name() + " {");
         fIndentation++;
         for (const auto& f : type.fields()) {
-            this->writeModifiers(f.fModifiers, false);
+            this->writeModifiers(f.fModifiers);
             // sizes (which must be static in structs) are part of the type name here
             this->writeType(*f.fType);
             this->writeLine(" " + f.fName + ";");
         }
         fIndentation--;
         this->writeLine("}");
     } else {
         this->write(type.name());
     }
 }
@@ skipping 37 matching lines @@
             this->writeTernaryExpression((TernaryExpression&) expr, parentPrecedence);
             break;
         case Expression::kIndex_Kind:
             this->writeIndexExpression((IndexExpression&) expr);
             break;
         default:
             ABORT("unsupported expression: %s", expr.description().c_str());
     }
 }
 
-static bool is_abs(Expression& expr) {
-    if (expr.fKind != Expression::kFunctionCall_Kind) {
-        return false;
-    }
-    return ((FunctionCall&) expr).fFunction.fName == "abs";
-}
-
-// turns min(abs(x), y) into (abs(x) > (tmpVar = y) ? tmpVar : abs(x)) to avoid a Tegra3 compiler 
-// bug.
-void GLSLCodeGenerator::writeMinAbsHack(Expression& absExpr, Expression& otherExpr) {
-    ASSERT(!fCaps.fCanUseMinAndAbsTogether);
-    std::string varName = "minAbsHackVar" + to_string(fVarCount++);
-    this->fFunctionHeader += "    " + otherExpr.fType.name() + " " + varName + ";\n";
-    this->write("(");
-    this->writeExpression(absExpr, kTopLevel_Precedence);
-    this->write(" > (" + varName + " = ");
-    this->writeExpression(otherExpr, kRelational_Precedence);
-    this->write(") ? " + varName + " : ");
-    this->writeExpression(absExpr, kTernary_Precedence);
-    this->write(")");
-}
-
 void GLSLCodeGenerator::writeFunctionCall(const FunctionCall& c) {
-    if (!fCaps.fCanUseMinAndAbsTogether && c.fFunction.fName == "min") {
-        ASSERT(c.fArguments.size() == 2);
-        if (is_abs(*c.fArguments[0])) {
-            this->writeMinAbsHack(*c.fArguments[0], *c.fArguments[1]);
-            return;
-        }
-        if (is_abs(*c.fArguments[1])) {
-            this->writeMinAbsHack(*c.fArguments[1], *c.fArguments[0]);
-            return;
-        }
-    }
     this->write(c.fFunction.fName + "(");
     const char* separator = "";
     for (const auto& arg : c.fArguments) {
         this->write(separator);
         separator = ", ";
         this->writeExpression(*arg, kSequence_Precedence);
     }
     this->write(")");
 }
 
 void GLSLCodeGenerator::writeConstructor(const Constructor& c) {
     this->write(c.fType.name() + "(");
     const char* separator = "";
     for (const auto& arg : c.fArguments) {
         this->write(separator);
         separator = ", ";
         this->writeExpression(*arg, kSequence_Precedence);
     }
     this->write(")");
 }
 
 void GLSLCodeGenerator::writeVariableReference(const VariableReference& ref) {
-    if (ref.fVariable.fModifiers.fLayout.fBuiltin == SK_FRAGCOLOR_BUILTIN) {
-        if (fCaps.fMustDeclareFragmentShaderOutput) {
-            this->write("sk_FragColor");
-        } else {
-            this->write("gl_FragColor");
-        }
-    } else {
-        this->write(ref.fVariable.fName);
-    }
+    this->write(ref.fVariable.fName);
 }
 
 void GLSLCodeGenerator::writeIndexExpression(const IndexExpression& expr) {
     this->writeExpression(*expr.fBase, kPostfix_Precedence);
     this->write("[");
     this->writeExpression(*expr.fIndex, kTopLevel_Precedence);
     this->write("]");
 }
 
 void GLSLCodeGenerator::writeFieldAccess(const FieldAccess& f) {
@@ skipping 102 matching lines @@
     if (kPostfix_Precedence >= parentPrecedence) {
         this->write(")");
     }
 }
 
 void GLSLCodeGenerator::writeBoolLiteral(const BoolLiteral& b) {
     this->write(b.fValue ? "true" : "false");
 }
 
 void GLSLCodeGenerator::writeIntLiteral(const IntLiteral& i) {
-    if (i.fType == *fContext.fUInt_Type) {
-        this->write(to_string(i.fValue & 0xffffffff) + "u");
-    } else {
-        this->write(to_string(i.fValue));
-    }
+    this->write(to_string(i.fValue));
 }
 
 void GLSLCodeGenerator::writeFloatLiteral(const FloatLiteral& f) {
     this->write(to_string(f.fValue));
 }
 
 void GLSLCodeGenerator::writeFunction(const FunctionDefinition& f) {
     this->writeType(f.fDeclaration.fReturnType);
     this->write(" " + f.fDeclaration.fName + "(");
     const char* separator = "";
     for (const auto& param : f.fDeclaration.fParameters) {
         this->write(separator);
         separator = ", ";
-        this->writeModifiers(param->fModifiers, false);
-        std::vector<int> sizes;
-        const Type* type = &param->fType;
-        while (type->kind() == Type::kArray_Kind) {
-            sizes.push_back(type->columns());
-            type = &type->componentType();
-        }
-        this->writeType(*type);
+        this->writeModifiers(param->fModifiers);
+        this->writeType(param->fType);
         this->write(" " + param->fName);
-        for (int s : sizes) {
-            if (s <= 0) {
-                this->write("[]");
-            } else {
-                this->write("[" + to_string(s) + "]");
-            }
-        }
     }
-    this->writeLine(") {");
-
-    fFunctionHeader = "";
-    std::ostream* oldOut = fOut;
-    std::stringstream buffer;
-    fOut = &buffer;
-    fIndentation++;
-    for (const auto& s : f.fBody->fStatements) {
-        this->writeStatement(*s);
-        this->writeLine();
-    }
-    fIndentation--;
-    this->writeLine("}");
-
-    fOut = oldOut;
-    this->write(fFunctionHeader);
-    this->write(buffer.str());
+    this->write(") ");
+    this->writeBlock(*f.fBody);
+    this->writeLine();
 }
 
-void GLSLCodeGenerator::writeModifiers(const Modifiers& modifiers, 
-                                       bool globalContext) {
-    if (modifiers.fFlags & Modifiers::kNoPerspective_Flag) {
-        this->write("noperspective ");
-    }
-    if (modifiers.fFlags & Modifiers::kFlat_Flag) {
-        this->write("flat ");
-    }
-    std::string layout = modifiers.fLayout.description();
-    if (layout.length()) {
-        this->write(layout + " ");
-    }
-    if ((modifiers.fFlags & Modifiers::kIn_Flag) && 
-        (modifiers.fFlags & Modifiers::kOut_Flag)) {
-        this->write("inout ");
-    } else if (modifiers.fFlags & Modifiers::kIn_Flag) {
-        if (globalContext && fCaps.fVersion < 130) {
-            this->write(fProgramKind == Program::kVertex_Kind ? "attribute "
-                                                              : "varying ");
-        } else {
-            this->write("in ");
-        }
-    } else if (modifiers.fFlags & Modifiers::kOut_Flag) {
-        if (globalContext && fCaps.fVersion < 130) {
-            this->write("varying ");
-        } else {
-            this->write("out ");
-        }
-    }
-    if (modifiers.fFlags & Modifiers::kUniform_Flag) {
-        this->write("uniform ");
-    }
-    if (modifiers.fFlags & Modifiers::kConst_Flag) {
-        this->write("const ");
-    }
-    if (fCaps.fUsesPrecisionModifiers) {
-        if (modifiers.fFlags & Modifiers::kLowp_Flag) {
-            this->write("lowp ");
-        }
-        if (modifiers.fFlags & Modifiers::kMediump_Flag) {
-            this->write("mediump ");
-        }
-        if (modifiers.fFlags & Modifiers::kHighp_Flag) {
-            this->write("highp ");
-        }
-    }
+void GLSLCodeGenerator::writeModifiers(const Modifiers& modifiers) {
+    this->write(modifiers.description());
 }
 
 void GLSLCodeGenerator::writeInterfaceBlock(const InterfaceBlock& intf) {
     if (intf.fVariable.fName == "gl_PerVertex") {
         return;
     }
-    this->writeModifiers(intf.fVariable.fModifiers, true);
+    this->writeModifiers(intf.fVariable.fModifiers);
     this->writeLine(intf.fVariable.fType.name() + " {");
     fIndentation++;
     for (const auto& f : intf.fVariable.fType.fields()) {
-        this->writeModifiers(f.fModifiers, false);
+        this->writeModifiers(f.fModifiers);
         this->writeType(*f.fType);
         this->writeLine(" " + f.fName + ";");
     }
     fIndentation--;
     this->writeLine("};");
 }
 
-void GLSLCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, bool global) {
+void GLSLCodeGenerator::writeVarDeclarations(const VarDeclarations& decl) {
     ASSERT(decl.fVars.size() > 0);
-    this->writeModifiers(decl.fVars[0].fVar->fModifiers, global);
+    this->writeModifiers(decl.fVars[0].fVar->fModifiers);
     this->writeType(decl.fBaseType);
     std::string separator = " ";
     for (const auto& var : decl.fVars) {
         ASSERT(var.fVar->fModifiers == decl.fVars[0].fVar->fModifiers);
         this->write(separator);
         separator = ", ";
         this->write(var.fVar->fName);
         for (const auto& size : var.fSizes) {
             this->write("[");
-            if (size) {
-                this->writeExpression(*size, kTopLevel_Precedence);
-            }
+            this->writeExpression(*size, kTopLevel_Precedence);
             this->write("]");
         }
         if (var.fValue) {
             this->write(" = ");
             this->writeExpression(*var.fValue, kTopLevel_Precedence);
         }
     }
     this->write(";");
 }
 
 void GLSLCodeGenerator::writeStatement(const Statement& s) {
     switch (s.fKind) {
         case Statement::kBlock_Kind:
             this->writeBlock((Block&) s);
             break;
         case Statement::kExpression_Kind:
             this->writeExpression(*((ExpressionStatement&) s).fExpression, kTopLevel_Precedence);
             this->write(";");
             break;
         case Statement::kReturn_Kind: 
             this->writeReturnStatement((ReturnStatement&) s);
             break;
         case Statement::kVarDeclarations_Kind:
-            this->writeVarDeclarations(*((VarDeclarationsStatement&) s).fDeclaration, false);
+            this->writeVarDeclarations(*((VarDeclarationsStatement&) s).fDeclaration);
             break;
         case Statement::kIf_Kind:
             this->writeIfStatement((IfStatement&) s);
             break;
         case Statement::kFor_Kind:
             this->writeForStatement((ForStatement&) s);
             break;
         case Statement::kWhile_Kind:
             this->writeWhileStatement((WhileStatement&) s);
             break;
@@ skipping 74 matching lines @@
     if (r.fExpression) {
         this->write(" ");
         this->writeExpression(*r.fExpression, kTopLevel_Precedence);
     }
     this->write(";");
 }
 
 void GLSLCodeGenerator::generateCode(const Program& program, std::ostream& out) {
     ASSERT(fOut == nullptr);
     fOut = &out;
-    fProgramKind = program.fKind;
     this->write("#version " + to_string(fCaps.fVersion));
-    if (fCaps.fStandard == GLCaps::kGLES_Standard && fCaps.fVersion >= 300) {
+    if (fCaps.fStandard == GLCaps::kGLES_Standard) {
         this->write(" es");
-    } else if (fCaps.fIsCoreProfile) {
-        this->write(" core");
     }
     this->writeLine();
     for (const auto& e : program.fElements) {
-        if (e->fKind == ProgramElement::kExtension_Kind) {
-            this->writeExtension((Extension&) *e);
-        }
-    }
-    if (fCaps.fStandard == GLCaps::kGLES_Standard) {
-        this->write("precision ");
-        switch (program.fDefaultPrecision) {
-            case Modifiers::kLowp_Flag:
-                this->write("lowp");
-                break;
-            case Modifiers::kMediump_Flag:
-                this->write("mediump");
-                break;
-            case Modifiers::kHighp_Flag:
-                this->write("highp");
-                break;
-            default:
-                ASSERT(false);
-                this->write("<error>");
-        }
-        this->writeLine(" float;");
-    }
-    for (const auto& e : program.fElements) {
         switch (e->fKind) {
             case ProgramElement::kExtension_Kind:
+                this->writeExtension((Extension&) *e);
                 break;
             case ProgramElement::kVar_Kind: {
                 VarDeclarations& decl = (VarDeclarations&) *e;
-                if (decl.fVars.size() > 0) {
-                    int builtin = decl.fVars[0].fVar->fModifiers.fLayout.fBuiltin;
-                    if (builtin == -1) {
-                        // normal var
-                        this->writeVarDeclarations(decl, true);
-                        this->writeLine();
-                    } else if (builtin == SK_FRAGCOLOR_BUILTIN &&
-                               fCaps.fMustDeclareFragmentShaderOutput) {
-                        this->write("out ");
-                        if (fCaps.fUsesPrecisionModifiers) {
-                            this->write("mediump ");
-                        }
-                        this->writeLine("vec4 sk_FragColor;");
-                    }
+                if (decl.fVars.size() > 0 && 
+                    decl.fVars[0].fVar->fModifiers.fLayout.fBuiltin == -1) {
+                    this->writeVarDeclarations(decl);
+                    this->writeLine();
                 }
                 break;
             }
             case ProgramElement::kInterfaceBlock_Kind:
                 this->writeInterfaceBlock((InterfaceBlock&) *e);
                 break;
             case ProgramElement::kFunction_Kind:
                 this->writeFunction((FunctionDefinition&) *e);
                 break;
-            case ProgramElement::kModifiers_Kind:
-                this->writeModifiers(((ModifiersDeclaration&) *e).fModifiers, true);
-                this->writeLine(";");
-                break;
             default:
                 printf("%s\n", e->description().c_str());
                 ABORT("unsupported program element");
         }
     }
     fOut = nullptr;
 }
 
 }