added initial GLSL support to skslc

src/sksl/SkSLIRGenerator.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 "SkSLIRGenerator.h"
 
 #include "limits.h"
@@ skipping 164 matching lines @@
                 }
                 type = new Type(name, Type::kArray_Kind, *type, (int) count);
                 fSymbolTable->takeOwnership((Type*) type);
                 currentVarSizes.push_back(std::move(size));
             } else {
                 type = new Type(type->fName + "[]", Type::kArray_Kind, *type, -1);
                 fSymbolTable->takeOwnership((Type*) type);
                 currentVarSizes.push_back(nullptr);
             }
         }
-        sizes.push_back(std::move(currentVarSizes));
         auto var = std::unique_ptr<Variable>(new Variable(decl.fPosition, modifiers, decl.fNames[i], 
                                                           *type, storage));
         std::unique_ptr<Expression> value;
         if (decl.fValues[i]) {
             value = this->convertExpression(*decl.fValues[i]);
             if (!value) {
                 return nullptr;
             }
             value = this->coerce(std::move(value), *type);
         }
-        variables.push_back(var.get());
-        fSymbolTable->add(decl.fNames[i], std::move(var));
-        values.push_back(std::move(value));
+        if ("gl_FragCoord" == decl.fNames[i] && (*fSymbolTable)[decl.fNames[i]]) {
+            // already defined, just update the modifiers
+            Variable* old = (Variable*) (*fSymbolTable)[decl.fNames[i]];
+            old->fModifiers = var->fModifiers;
+        } else {
+            variables.push_back(var.get());
+            fSymbolTable->add(decl.fNames[i], std::move(var));
+            values.push_back(std::move(value));
+            sizes.push_back(std::move(currentVarSizes));
+        }
     }
-    return std::unique_ptr<VarDeclaration>(new VarDeclaration(decl.fPosition, std::move(variables), 
-                                                              std::move(sizes), std::move(values)));
+    return std::unique_ptr<VarDeclaration>(new VarDeclaration(decl.fPosition, 
+                                                              baseType,
+                                                              std::move(variables), 
+                                                              std::move(sizes), 
+                                                              std::move(values)));
 }
 
 std::unique_ptr<Statement> IRGenerator::convertIf(const ASTIfStatement& s) {
     std::unique_ptr<Expression> test = this->coerce(this->convertExpression(*s.fTest), 
                                                     *fContext.fBool_Type);
     if (!test) {
         return nullptr;
     }
     std::unique_ptr<Statement> ifTrue = this->convertStatement(*s.fIfTrue);
     if (!ifTrue) {
@@ skipping 354 matching lines @@
         }
         case Symbol::kVariable_Kind: {
             const Variable* var = (const Variable*) result;
             this->markReadFrom(*var);
             return std::unique_ptr<VariableReference>(new VariableReference(identifier.fPosition,
                                                                             *var));
         }
         case Symbol::kField_Kind: {
             const Field* field = (const Field*) result;
             VariableReference* base = new VariableReference(identifier.fPosition, field->fOwner);
-            return std::unique_ptr<Expression>(new FieldAccess(std::unique_ptr<Expression>(base),
-                                                               field->fFieldIndex));
+            return std::unique_ptr<Expression>(new FieldAccess(
+                                                  std::unique_ptr<Expression>(base),
+                                                  field->fFieldIndex,
+                                                  FieldAccess::kAnonymousInterfaceBlock_OwnerKind));
         }
         case Symbol::kType_Kind: {
             const Type* t = (const Type*) result;
             return std::unique_ptr<TypeReference>(new TypeReference(fContext, identifier.fPosition, 
                                                                     *t));
         }
         default:
             ABORT("unsupported symbol type %d\n", result->fKind);
     }
 
@@ skipping 21 matching lines @@
         args.push_back(std::move(expr));
         ASTIdentifier id(Position(), type.description());
         std::unique_ptr<Expression> ctor = this->convertIdentifier(id);
         ASSERT(ctor);
         return this->call(Position(), std::move(ctor), std::move(args));
     }
     ABORT("cannot coerce %s to %s", expr->fType.description().c_str(), 
           type.description().c_str());
 }
 
+static bool is_matrix_multiply(const Type& left, const Type& right) {
+    if (left.kind() == Type::kMatrix_Kind) {
+        return right.kind() == Type::kMatrix_Kind || right.kind() == Type::kVector_Kind;
+    }
+    return left.kind() == Type::kVector_Kind && right.kind() == Type::kMatrix_Kind;
+}
 /**
  * Determines the operand and result types of a binary expression. Returns true if the expression is
  * legal, false otherwise. If false, the values of the out parameters are undefined.
  */
 static bool determine_binary_type(const Context& context, 
                                   Token::Kind op, 
                                   const Type& left, 
                                   const Type& right, 
                                   const Type** outLeftType,
                                   const Type** outRightType,
@@ skipping 15 matching lines @@
         case Token::LOGICALOREQ: // fall through
         case Token::LOGICALANDEQ: // fall through
         case Token::LOGICALXOREQ:
             *outLeftType = context.fBool_Type.get();
             *outRightType = context.fBool_Type.get();
             *outResultType = context.fBool_Type.get();
             return left.canCoerceTo(*context.fBool_Type) && 
                    right.canCoerceTo(*context.fBool_Type);
         case Token::STAR: // fall through
         case Token::STAREQ: 
-            // FIXME need to handle non-square matrices
-            if (left.kind() == Type::kMatrix_Kind && right.kind() == Type::kVector_Kind) {
-                *outLeftType = &left;
-                *outRightType = &right;
-                *outResultType = &right;
-                return left.rows() == right.columns();
-            }  
-            if (left.kind() == Type::kVector_Kind && right.kind() == Type::kMatrix_Kind) {
-                *outLeftType = &left;
-                *outRightType = &right;
-                *outResultType = &left;
-                return left.columns() == right.columns();
+            if (is_matrix_multiply(left, right)) {
+                // determine final component type
+                if (determine_binary_type(context, Token::STAR, left.componentType(),
+                                          right.componentType(), outLeftType, outRightType,
+                                          outResultType, false)) {
+                    *outLeftType = &(*outResultType)->toCompound(context, left.columns(), 
+                                                                 left.rows());;
+                    *outRightType = &(*outResultType)->toCompound(context, right.columns(), 
+                                                                  right.rows());;
+                    int leftColumns = left.columns();
+                    int leftRows = left.rows();
+                    int rightColumns;
+                    int rightRows;
+                    if (right.kind() == Type::kVector_Kind) {
+                        rightColumns = right.rows();

[dogben, 2016/08/02 18:08:15]

nit: Maybe add comment: "Vector on right is implicitly transposed to
single-column."

[ethannicholas, 2016/08/02 20:43:06]

Done.

+                        rightRows = right.columns();
+                        ASSERT(rightColumns == 1);
+                    } else {
+                        rightColumns = right.columns();
+                        rightRows = right.rows();
+                    }
+                    if (rightColumns > 1) {

[dogben, 2016/08/02 18:08:15]

nit: Maybe add comment: "Single-column result is implicitly transposed to
vector."

[ethannicholas, 2016/08/02 20:43:06]

Done.

+                        *outResultType = &(*outResultType)->toCompound(context, rightColumns,
+                                                                       leftRows);
+                    } else {
+                        *outResultType = &(*outResultType)->toCompound(context, leftRows,
+                                                                       rightColumns);
+                    }
+                    return leftColumns == rightRows;
+                } else {
+                    return false;
+                }
             }
             // fall through
         default:
             isLogical = false;
     }
     // FIXME: need to disallow illegal operations like vec3 > vec3. Also do not currently have
     // full support for numbers other than float.
     if (left == right) {
         *outLeftType = &left;
         *outRightType = &left;
@@ skipping 542 matching lines @@
         case Expression::kIndex_Kind:
             this->markWrittenTo(*((IndexExpression&) expr).fBase);
             break;
         default:
             fErrors.error(expr.fPosition, "cannot assign to '" + expr.description() + "'");
             break;
     }
 }
 
 }