framework/opengl/gluShaderLibrary.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES Utilities
   3  * ------------------------------------------------
   4  *
   5  * Copyright 2015 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Shader .test file utilities.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "gluShaderLibrary.hpp"
  25
  26 #include "tcuStringTemplate.hpp"
  27 #include "tcuResource.hpp"
  28 #include "tcuTestLog.hpp"
  29
  30 #include "deStringUtil.hpp"
  31 #include "deUniquePtr.hpp"
  32 #include "deFilePath.hpp"
  33
  34 #include "glwEnums.hpp"
  35
  36 #include <sstream>
  37 #include <map>
  38 #include <cstdlib>
  39
  40 #if 0
  41 #       define PARSE_DBG(X) printf X
  42 #else
  43 #       define PARSE_DBG(X) DE_NULL_STATEMENT
  44 #endif
  45
  46 namespace glu
  47 {
  48 namespace sl
  49 {
  50
  51 using namespace tcu;
  52
  53 using std::vector;
  54 using std::string;
  55 using std::map;
  56 using std::ostringstream;
  57 using std::pair;
  58 using de::UniquePtr;
  59
  60 // Specification
  61
  62 bool isValid (const ValueBlock& block)
  63 {
  64         for (size_t storageNdx = 0; storageNdx < 3; ++storageNdx)
  65         {
  66                 const vector<Value>&    values          = storageNdx == 0 ? block.inputs        :
  67                                                                                           storageNdx == 1 ? block.outputs       :
  68                                                                                                                                 block.uniforms;
  69                 const size_t                    refArrayLen     = values.empty() ? 0 : (values[0].elements.size() / (size_t)values[0].type.getScalarSize());
  70
  71                 for (size_t valNdx = 0; valNdx < values.size(); ++valNdx)
  72                 {
  73                         const Value&    value   = values[valNdx];
  74
  75                         if (!value.type.isBasicType())
  76                         {
  77                                 print("ERROR: Value '%s' is of unsupported type!\n", value.name.c_str());
  78                                 return false;
  79                         }
  80
  81                         if (value.elements.size() != refArrayLen*(size_t)value.type.getScalarSize())
  82                         {
  83                                 print("ERROR: Value '%s' has invalid number of scalars!\n", value.name.c_str());
  84                                 return false;
  85                         }
  86                 }
  87         }
  88
  89         return true;
  90 }
  91
  92 bool isValid (const ShaderCaseSpecification& spec)
  93 {
  94         const deUint32  vtxFragMask                     = (1u << SHADERTYPE_VERTEX)
  95                                                                                 | (1u << SHADERTYPE_FRAGMENT);
  96         const deUint32  tessCtrlEvalMask        = (1u << SHADERTYPE_TESSELLATION_CONTROL)
  97                                                                                 | (1u << SHADERTYPE_TESSELLATION_EVALUATION);
  98         const deUint32  supportedStageMask      = vtxFragMask | tessCtrlEvalMask
  99                                                                                 | (1u << SHADERTYPE_GEOMETRY);
 100         const bool              isSeparable                     = !spec.programs.empty() && spec.programs[0].sources.separable;
 101
 102         if (spec.programs.empty())
 103         {
 104                 print("ERROR: No programs specified!\n");
 105                 return false;
 106         }
 107
 108         if (isCapabilityRequired(CAPABILITY_FULL_GLSL_ES_100_SUPPORT, spec))
 109         {
 110                 if (spec.targetVersion != GLSL_VERSION_100_ES)
 111                 {
 112                         print("ERROR: Full GLSL ES 1.00 support requested for other GLSL version!\n");
 113                         return false;
 114                 }
 115
 116                 if (spec.expectResult != EXPECT_PASS                    &&
 117                         spec.expectResult != EXPECT_VALIDATION_FAIL     &&
 118                         spec.expectResult != EXPECT_BUILD_SUCCESSFUL)
 119                 {
 120                         print("ERROR: Full GLSL ES 1.00 support doesn't make sense when expecting compile/link failure!\n");
 121                         return false;
 122                 }
 123         }
 124
 125         if (!de::inBounds(spec.caseType, (CaseType)0, CASETYPE_LAST))
 126         {
 127                 print("ERROR: Invalid case type!\n");
 128                 return false;
 129         }
 130
 131         if (!de::inBounds(spec.expectResult, (ExpectResult)0, EXPECT_LAST))
 132         {
 133                 print("ERROR: Invalid expected result!\n");
 134                 return false;
 135         }
 136
 137         if (!isValid(spec.values))
 138                 return false;
 139
 140         if (!spec.values.inputs.empty() && !spec.values.outputs.empty() &&
 141                 spec.values.inputs[0].elements.size() / spec.values.inputs[0].type.getScalarSize() != spec.values.outputs[0].elements.size() / spec.values.outputs[0].type.getScalarSize())
 142         {
 143                 print("ERROR: Number of input and output elements don't match!\n");
 144                 return false;
 145         }
 146
 147         if (isSeparable)
 148         {
 149                 deUint32        usedStageMask   = 0u;
 150
 151                 if (spec.caseType != CASETYPE_COMPLETE)
 152                 {
 153                         print("ERROR: Separable shaders supported only for complete cases!\n");
 154                         return false;
 155                 }
 156
 157                 for (size_t progNdx = 0; progNdx < spec.programs.size(); ++progNdx)
 158                 {
 159                         for (int shaderStageNdx = 0; shaderStageNdx < SHADERTYPE_LAST; ++shaderStageNdx)
 160                         {
 161                                 const deUint32  curStageMask    = (1u << shaderStageNdx);
 162
 163                                 if (supportedStageMask & curStageMask)
 164                                 {
 165                                         const bool              hasShader       = !spec.programs[progNdx].sources.sources[shaderStageNdx].empty();
 166                                         const bool              isEnabled       = (spec.programs[progNdx].activeStages & curStageMask) != 0;
 167
 168                                         if (hasShader != isEnabled)
 169                                         {
 170                                                 print("ERROR: Inconsistent source/enable for shader stage %s!\n", getShaderTypeName((ShaderType)shaderStageNdx));
 171                                                 return false;
 172                                         }
 173
 174                                         if (hasShader && (usedStageMask & curStageMask) != 0)
 175                                         {
 176                                                 print("ERROR: Stage %s enabled on multiple programs!\n", getShaderTypeName((ShaderType)shaderStageNdx));
 177                                                 return false;
 178                                         }
 179
 180                                         if (isEnabled)
 181                                                 usedStageMask |= curStageMask;
 182                                 }
 183                                 else if (!spec.programs[progNdx].sources.sources[shaderStageNdx].empty())
 184                                 {
 185                                         print("ERROR: Source specified for unsupported shader stage %s!\n", getShaderTypeName((ShaderType)shaderStageNdx));
 186                                         return false;
 187                                 }
 188                         }
 189                 }
 190
 191                 if ((usedStageMask & vtxFragMask) != vtxFragMask)
 192                 {
 193                         print("ERROR: Vertex and fragment shaders are mandatory!\n");
 194                         return false;
 195                 }
 196
 197                 if ((usedStageMask & tessCtrlEvalMask) != 0 && (usedStageMask & tessCtrlEvalMask) != tessCtrlEvalMask)
 198                 {
 199                         print("ERROR: Both tessellation control and eval shaders must be either enabled or disabled!\n");
 200                         return false;
 201                 }
 202         }
 203         else
 204         {
 205                 const bool      hasVertex               = !spec.programs[0].sources.sources[SHADERTYPE_VERTEX].empty();
 206                 const bool      hasFragment             = !spec.programs[0].sources.sources[SHADERTYPE_FRAGMENT].empty();
 207
 208                 if (spec.programs.size() != 1)
 209                 {
 210                         print("ERROR: Only cases using separable programs can have multiple programs!\n");
 211                         return false;
 212                 }
 213
 214                 if (spec.caseType == CASETYPE_VERTEX_ONLY && (!hasVertex || hasFragment))
 215                 {
 216                         print("ERROR: Vertex-only case must have only vertex shader!\n");
 217                         return false;
 218                 }
 219
 220                 if (spec.caseType == CASETYPE_FRAGMENT_ONLY && (hasVertex || !hasFragment))
 221                 {
 222                         print("ERROR: Fragment-only case must have only fragment shader!\n");
 223                         return false;
 224                 }
 225
 226                 if (spec.caseType == CASETYPE_COMPLETE && (!hasVertex || !hasFragment))
 227                 {
 228                         print("ERROR: Complete case must have at least vertex and fragment shaders\n");
 229                         return false;
 230                 }
 231         }
 232
 233         return true;
 234 }
 235
 236 bool isCapabilityRequired(CapabilityFlag capabilityFlag, const ShaderCaseSpecification& spec)
 237 {
 238         std::vector<RequiredCapability>::const_iterator currRequirement = spec.requiredCaps.begin();
 239         while (currRequirement != spec.requiredCaps.end())
 240         {
 241                 if ((currRequirement->type == CAPABILITY_FLAG) && (currRequirement->flagName == capabilityFlag))
 242                         return true;
 243                 ++currRequirement;
 244         }
 245
 246         return false;
 247 }
 248
 249 // Parser
 250
 251 static const glu::GLSLVersion DEFAULT_GLSL_VERSION = glu::GLSL_VERSION_100_ES;
 252
 253 DE_INLINE deBool isWhitespace (char c)
 254 {
 255         return (c == ' ') || (c == '\t') || (c == '\r') || (c == '\n');
 256 }
 257
 258 DE_INLINE deBool isEOL (char c)
 259 {
 260         return (c == '\r') || (c == '\n');
 261 }
 262
 263 DE_INLINE deBool isNumeric (char c)
 264 {
 265         return deInRange32(c, '0', '9');
 266 }
 267
 268 DE_INLINE deBool isAlpha (char c)
 269 {
 270         return deInRange32(c, 'a', 'z') || deInRange32(c, 'A', 'Z');
 271 }
 272
 273 DE_INLINE deBool isCaseNameChar (char c)
 274 {
 275         return deInRange32(c, 'a', 'z') || deInRange32(c, 'A', 'Z') || deInRange32(c, '0', '9') || (c == '_') || (c == '-') || (c == '.');
 276 }
 277
 278 class ShaderParser
 279 {
 280 public:
 281                                                         ShaderParser                    (const tcu::Archive& archive, const std::string& filename, ShaderCaseFactory* caseFactory);
 282                                                         ~ShaderParser                   (void);
 283
 284         vector<tcu::TestNode*>  parse                                   (void);
 285
 286 private:
 287         enum Token
 288         {
 289                 TOKEN_INVALID = 0,
 290                 TOKEN_EOF,
 291                 TOKEN_STRING,
 292                 TOKEN_SHADER_SOURCE,
 293
 294                 TOKEN_INT_LITERAL,
 295                 TOKEN_FLOAT_LITERAL,
 296
 297                 // identifiers
 298                 TOKEN_IDENTIFIER,
 299                 TOKEN_TRUE,
 300                 TOKEN_FALSE,
 301                 TOKEN_DESC,
 302                 TOKEN_EXPECT,
 303                 TOKEN_GROUP,
 304                 TOKEN_CASE,
 305                 TOKEN_END,
 306                 TOKEN_OUTPUT_COLOR,
 307                 TOKEN_FORMAT,
 308                 TOKEN_VALUES,
 309                 TOKEN_BOTH,
 310                 TOKEN_VERTEX,
 311                 TOKEN_FRAGMENT,
 312                 TOKEN_UNIFORM,
 313                 TOKEN_INPUT,
 314                 TOKEN_OUTPUT,
 315                 TOKEN_FLOAT,
 316                 TOKEN_FLOAT_VEC2,
 317                 TOKEN_FLOAT_VEC3,
 318                 TOKEN_FLOAT_VEC4,
 319                 TOKEN_FLOAT_MAT2,
 320                 TOKEN_FLOAT_MAT2X3,
 321                 TOKEN_FLOAT_MAT2X4,
 322                 TOKEN_FLOAT_MAT3X2,
 323                 TOKEN_FLOAT_MAT3,
 324                 TOKEN_FLOAT_MAT3X4,
 325                 TOKEN_FLOAT_MAT4X2,
 326                 TOKEN_FLOAT_MAT4X3,
 327                 TOKEN_FLOAT_MAT4,
 328                 TOKEN_INT,
 329                 TOKEN_INT_VEC2,
 330                 TOKEN_INT_VEC3,
 331                 TOKEN_INT_VEC4,
 332                 TOKEN_UINT,
 333                 TOKEN_UINT_VEC2,
 334                 TOKEN_UINT_VEC3,
 335                 TOKEN_UINT_VEC4,
 336                 TOKEN_BOOL,
 337                 TOKEN_BOOL_VEC2,
 338                 TOKEN_BOOL_VEC3,
 339                 TOKEN_BOOL_VEC4,
 340                 TOKEN_VERSION,
 341                 TOKEN_TESSELLATION_CONTROL,
 342                 TOKEN_TESSELLATION_EVALUATION,
 343                 TOKEN_GEOMETRY,
 344                 TOKEN_REQUIRE,
 345                 TOKEN_IN,
 346                 TOKEN_IMPORT,
 347                 TOKEN_PIPELINE_PROGRAM,
 348                 TOKEN_ACTIVE_STAGES,
 349
 350                 // symbols
 351                 TOKEN_ASSIGN,
 352                 TOKEN_PLUS,
 353                 TOKEN_MINUS,
 354                 TOKEN_COMMA,
 355                 TOKEN_VERTICAL_BAR,
 356                 TOKEN_SEMI_COLON,
 357                 TOKEN_LEFT_PAREN,
 358                 TOKEN_RIGHT_PAREN,
 359                 TOKEN_LEFT_BRACKET,
 360                 TOKEN_RIGHT_BRACKET,
 361                 TOKEN_LEFT_BRACE,
 362                 TOKEN_RIGHT_BRACE,
 363                 TOKEN_GREATER,
 364
 365                 TOKEN_LAST
 366         };
 367
 368         void                                            parseError                                      (const std::string& errorStr);
 369         float                                           parseFloatLiteral                       (const char* str);
 370         int                                                     parseIntLiteral                         (const char* str);
 371         string                                          parseStringLiteral                      (const char* str);
 372         string                                          parseShaderSource                       (const char* str);
 373         void                                            advanceToken                            (void);
 374         void                                            advanceToken                            (Token assumed);
 375         void                                            assumeToken                                     (Token token);
 376         DataType                                        mapDataTypeToken                        (Token token);
 377         const char*                                     getTokenName                            (Token token);
 378         deUint32                                        getShaderStageLiteralFlag       (void);
 379         deUint32                                        getGLEnumFromName                       (const std::string& enumName);
 380
 381         void                                            parseValueElement                       (DataType dataType, Value& result);
 382         void                                            parseValue                                      (ValueBlock& valueBlock);
 383         void                                            parseValueBlock                         (ValueBlock& valueBlock);
 384         deUint32                                        parseShaderStageList            (void);
 385         void                                            parseRequirement                        (vector<RequiredCapability> &requiredCaps, vector<RequiredExtension> &requiredExts);
 386         void                                            parseExpectResult                       (ExpectResult& expectResult);
 387         void                                            parseFormat                                     (DataType& format);
 388         void                                            parseGLSLVersion                        (glu::GLSLVersion& version);
 389         void                                            parsePipelineProgram            (ProgramSpecification& program);
 390         void                                            parseShaderCase                         (vector<tcu::TestNode*>& shaderNodeList);
 391         void                                            parseShaderGroup                        (vector<tcu::TestNode*>& shaderNodeList);
 392         void                                            parseImport                                     (vector<tcu::TestNode*>& shaderNodeList);
 393
 394         const tcu::Archive&                     m_archive;
 395         const string                            m_filename;
 396         ShaderCaseFactory* const        m_caseFactory;
 397
 398         UniquePtr<tcu::Resource>        m_resource;
 399         vector<char>                            m_input;
 400
 401         const char*                                     m_curPtr;
 402         Token                                           m_curToken;
 403         std::string                                     m_curTokenStr;
 404 };
 405
 406 ShaderParser::ShaderParser (const tcu::Archive& archive, const string& filename, ShaderCaseFactory* caseFactroy)
 407         : m_archive                     (archive)
 408         , m_filename            (filename)
 409         , m_caseFactory         (caseFactroy)
 410         , m_resource            (archive.getResource(m_filename.c_str()))
 411         , m_curPtr                      (DE_NULL)
 412         , m_curToken            (TOKEN_LAST)
 413 {
 414 }
 415
 416 ShaderParser::~ShaderParser (void)
 417 {
 418 }
 419
 420 void ShaderParser::parseError (const std::string& errorStr)
 421 {
 422         string atStr = string(m_curPtr, 80);
 423         throw tcu::InternalError((string("Parser error: ") + errorStr + " near '" + atStr + " ...'").c_str(), DE_NULL, __FILE__, __LINE__);
 424 }
 425
 426 float ShaderParser::parseFloatLiteral (const char* str)
 427 {
 428         return (float)atof(str);
 429 }
 430
 431 int ShaderParser::parseIntLiteral (const char* str)
 432 {
 433         return atoi(str);
 434 }
 435
 436 string ShaderParser::parseStringLiteral (const char* str)
 437 {
 438         const char*             p               = str;
 439         char                    endChar = *p++;
 440         ostringstream   o;
 441
 442         while (*p != endChar && *p)
 443         {
 444                 if (*p == '\\')
 445                 {
 446                         switch (p[1])
 447                         {
 448                                 case 0:         DE_ASSERT(DE_FALSE);    break;
 449                                 case 'n':       o << '\n';                              break;
 450                                 case 't':       o << '\t';                              break;
 451                                 default:        o << p[1];                              break;
 452                         }
 453
 454                         p += 2;
 455                 }
 456                 else
 457                         o << *p++;
 458         }
 459
 460         return o.str();
 461 }
 462
 463 static string removeExtraIndentation (const string& source)
 464 {
 465         // Detect indentation from first line.
 466         int numIndentChars = 0;
 467         for (int ndx = 0; ndx < (int)source.length() && isWhitespace(source[ndx]); ndx++)
 468                 numIndentChars += source[ndx] == '\t' ? 4 : 1;
 469
 470         // Process all lines and remove preceding indentation.
 471         ostringstream processed;
 472         {
 473                 bool    atLineStart                     = true;
 474                 int             indentCharsOmitted      = 0;
 475
 476                 for (int pos = 0; pos < (int)source.length(); pos++)
 477                 {
 478                         char c = source[pos];
 479
 480                         if (atLineStart && indentCharsOmitted < numIndentChars && (c == ' ' || c == '\t'))
 481                         {
 482                                 indentCharsOmitted += c == '\t' ? 4 : 1;
 483                         }
 484                         else if (isEOL(c))
 485                         {
 486                                 if (source[pos] == '\r' && source[pos+1] == '\n')
 487                                 {
 488                                         pos += 1;
 489                                         processed << '\n';
 490                                 }
 491                                 else
 492                                         processed << c;
 493
 494                                 atLineStart                     = true;
 495                                 indentCharsOmitted      = 0;
 496                         }
 497                         else
 498                         {
 499                                 processed << c;
 500                                 atLineStart = false;
 501                         }
 502                 }
 503         }
 504
 505         return processed.str();
 506 }
 507
 508 string ShaderParser::parseShaderSource (const char* str)
 509 {
 510         const char*             p = str+2;
 511         ostringstream   o;
 512
 513         // Eat first empty line from beginning.
 514         while (*p == ' ') p++;
 515         if (*p == '\r') p++;
 516         if (*p == '\n') p++;
 517
 518         while ((p[0] != '"') || (p[1] != '"'))
 519         {
 520                 if (*p == '\\')
 521                 {
 522                         switch (p[1])
 523                         {
 524                                 case 0:         DE_ASSERT(DE_FALSE);    break;
 525                                 case 'n':       o << '\n';                              break;
 526                                 case 't':       o << '\t';                              break;
 527                                 default:        o << p[1];                              break;
 528                         }
 529
 530                         p += 2;
 531                 }
 532                 else
 533                         o << *p++;
 534         }
 535
 536         return removeExtraIndentation(o.str());
 537 }
 538
 539 void ShaderParser::advanceToken (void)
 540 {
 541         // Skip old token.
 542         m_curPtr += m_curTokenStr.length();
 543
 544         // Reset token (for safety).
 545         m_curToken              = TOKEN_INVALID;
 546         m_curTokenStr   = "";
 547
 548         // Eat whitespace & comments while they last.
 549         for (;;)
 550         {
 551                 while (isWhitespace(*m_curPtr))
 552                         m_curPtr++;
 553
 554                 // Check for EOL comment.
 555                 if (*m_curPtr == '#')
 556                 {
 557                         while (*m_curPtr && !isEOL(*m_curPtr))
 558                                 m_curPtr++;
 559                 }
 560                 else
 561                         break;
 562         }
 563
 564         if (!*m_curPtr)
 565         {
 566                 m_curToken = TOKEN_EOF;
 567                 m_curTokenStr = "<EOF>";
 568         }
 569         else if (isAlpha(*m_curPtr))
 570         {
 571                 struct Named
 572                 {
 573                         const char*             str;
 574                         Token                   token;
 575                 };
 576
 577                 static const Named s_named[] =
 578                 {
 579                         { "true",                                               TOKEN_TRUE                                              },
 580                         { "false",                                              TOKEN_FALSE                                             },
 581                         { "desc",                                               TOKEN_DESC                                              },
 582                         { "expect",                                             TOKEN_EXPECT                                    },
 583                         { "group",                                              TOKEN_GROUP                                             },
 584                         { "case",                                               TOKEN_CASE                                              },
 585                         { "end",                                                TOKEN_END                                               },
 586                         { "output_color",                               TOKEN_OUTPUT_COLOR                              },
 587                         { "format",                                             TOKEN_FORMAT                                    },
 588                         { "values",                                             TOKEN_VALUES                                    },
 589                         { "both",                                               TOKEN_BOTH                                              },
 590                         { "vertex",                                             TOKEN_VERTEX                                    },
 591                         { "fragment",                                   TOKEN_FRAGMENT                                  },
 592                         { "uniform",                                    TOKEN_UNIFORM                                   },
 593                         { "input",                                              TOKEN_INPUT                                             },
 594                         { "output",                                             TOKEN_OUTPUT                                    },
 595                         { "float",                                              TOKEN_FLOAT                                             },
 596                         { "vec2",                                               TOKEN_FLOAT_VEC2                                },
 597                         { "vec3",                                               TOKEN_FLOAT_VEC3                                },
 598                         { "vec4",                                               TOKEN_FLOAT_VEC4                                },
 599                         { "mat2",                                               TOKEN_FLOAT_MAT2                                },
 600                         { "mat2x3",                                             TOKEN_FLOAT_MAT2X3                              },
 601                         { "mat2x4",                                             TOKEN_FLOAT_MAT2X4                              },
 602                         { "mat3x2",                                             TOKEN_FLOAT_MAT3X2                              },
 603                         { "mat3",                                               TOKEN_FLOAT_MAT3                                },
 604                         { "mat3x4",                                             TOKEN_FLOAT_MAT3X4                              },
 605                         { "mat4x2",                                             TOKEN_FLOAT_MAT4X2                              },
 606                         { "mat4x3",                                             TOKEN_FLOAT_MAT4X3                              },
 607                         { "mat4",                                               TOKEN_FLOAT_MAT4                                },
 608                         { "int",                                                TOKEN_INT                                               },
 609                         { "ivec2",                                              TOKEN_INT_VEC2                                  },
 610                         { "ivec3",                                              TOKEN_INT_VEC3                                  },
 611                         { "ivec4",                                              TOKEN_INT_VEC4                                  },
 612                         { "uint",                                               TOKEN_UINT                                              },
 613                         { "uvec2",                                              TOKEN_UINT_VEC2                                 },
 614                         { "uvec3",                                              TOKEN_UINT_VEC3                                 },
 615                         { "uvec4",                                              TOKEN_UINT_VEC4                                 },
 616                         { "bool",                                               TOKEN_BOOL                                              },
 617                         { "bvec2",                                              TOKEN_BOOL_VEC2                                 },
 618                         { "bvec3",                                              TOKEN_BOOL_VEC3                                 },
 619                         { "bvec4",                                              TOKEN_BOOL_VEC4                                 },
 620                         { "version",                                    TOKEN_VERSION                                   },
 621                         { "tessellation_control",               TOKEN_TESSELLATION_CONTROL              },
 622                         { "tessellation_evaluation",    TOKEN_TESSELLATION_EVALUATION   },
 623                         { "geometry",                                   TOKEN_GEOMETRY                                  },
 624                         { "require",                                    TOKEN_REQUIRE                                   },
 625                         { "in",                                                 TOKEN_IN                                                },
 626                         { "import",                                             TOKEN_IMPORT                                    },
 627                         { "pipeline_program",                   TOKEN_PIPELINE_PROGRAM                  },
 628                         { "active_stages",                              TOKEN_ACTIVE_STAGES                             },
 629                 };
 630
 631                 const char* end = m_curPtr + 1;
 632                 while (isCaseNameChar(*end))
 633                         end++;
 634                 m_curTokenStr = string(m_curPtr, end - m_curPtr);
 635
 636                 m_curToken = TOKEN_IDENTIFIER;
 637
 638                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_named); ndx++)
 639                 {
 640                         if (m_curTokenStr == s_named[ndx].str)
 641                         {
 642                                 m_curToken = s_named[ndx].token;
 643                                 break;
 644                         }
 645                 }
 646         }
 647         else if (isNumeric(*m_curPtr))
 648         {
 649                 /* \todo [2010-03-31 petri] Hex? */
 650                 const char* p = m_curPtr;
 651                 while (isNumeric(*p))
 652                         p++;
 653                 if (*p == '.')
 654                 {
 655                         p++;
 656                         while (isNumeric(*p))
 657                                 p++;
 658
 659                         if (*p == 'e' || *p == 'E')
 660                         {
 661                                 p++;
 662                                 if (*p == '+' || *p == '-')
 663                                         p++;
 664                                 DE_ASSERT(isNumeric(*p));
 665                                 while (isNumeric(*p))
 666                                         p++;
 667                         }
 668
 669                         m_curToken = TOKEN_FLOAT_LITERAL;
 670                         m_curTokenStr = string(m_curPtr, p - m_curPtr);
 671                 }
 672                 else
 673                 {
 674                         m_curToken = TOKEN_INT_LITERAL;
 675                         m_curTokenStr = string(m_curPtr, p - m_curPtr);
 676                 }
 677         }
 678         else if (*m_curPtr == '"' && m_curPtr[1] == '"')
 679         {
 680                 const char*     p = m_curPtr + 2;
 681
 682                 while ((p[0] != '"') || (p[1] != '"'))
 683                 {
 684                         DE_ASSERT(*p);
 685                         if (*p == '\\')
 686                         {
 687                                 DE_ASSERT(p[1] != 0);
 688                                 p += 2;
 689                         }
 690                         else
 691                                 p++;
 692                 }
 693                 p += 2;
 694
 695                 m_curToken              = TOKEN_SHADER_SOURCE;
 696                 m_curTokenStr   = string(m_curPtr, (int)(p - m_curPtr));
 697         }
 698         else if (*m_curPtr == '"' || *m_curPtr == '\'')
 699         {
 700                 char            endChar = *m_curPtr;
 701                 const char*     p               = m_curPtr + 1;
 702
 703                 while (*p != endChar)
 704                 {
 705                         DE_ASSERT(*p);
 706                         if (*p == '\\')
 707                         {
 708                                 DE_ASSERT(p[1] != 0);
 709                                 p += 2;
 710                         }
 711                         else
 712                                 p++;
 713                 }
 714                 p++;
 715
 716                 m_curToken              = TOKEN_STRING;
 717                 m_curTokenStr   = string(m_curPtr, (int)(p - m_curPtr));
 718         }
 719         else
 720         {
 721                 struct SimpleToken
 722                 {
 723                         const char*             str;
 724                         Token                   token;
 725                 };
 726
 727                 static const SimpleToken s_simple[] =
 728                 {
 729                         { "=",                  TOKEN_ASSIGN            },
 730                         { "+",                  TOKEN_PLUS                      },
 731                         { "-",                  TOKEN_MINUS                     },
 732                         { ",",                  TOKEN_COMMA                     },
 733                         { "|",                  TOKEN_VERTICAL_BAR      },
 734                         { ";",                  TOKEN_SEMI_COLON        },
 735                         { "(",                  TOKEN_LEFT_PAREN        },
 736                         { ")",                  TOKEN_RIGHT_PAREN       },
 737                         { "[",                  TOKEN_LEFT_BRACKET      },
 738                         { "]",                  TOKEN_RIGHT_BRACKET },
 739                         { "{",                  TOKEN_LEFT_BRACE        },
 740                         { "}",                  TOKEN_RIGHT_BRACE       },
 741                         { ">",                  TOKEN_GREATER           },
 742                 };
 743
 744                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_simple); ndx++)
 745                 {
 746                         if (strncmp(s_simple[ndx].str, m_curPtr, strlen(s_simple[ndx].str)) == 0)
 747                         {
 748                                 m_curToken              = s_simple[ndx].token;
 749                                 m_curTokenStr   = s_simple[ndx].str;
 750                                 return;
 751                         }
 752                 }
 753
 754                 // Otherwise invalid token.
 755                 m_curToken = TOKEN_INVALID;
 756                 m_curTokenStr = *m_curPtr;
 757         }
 758 }
 759
 760 void ShaderParser::advanceToken (Token assumed)
 761 {
 762         assumeToken(assumed);
 763         advanceToken();
 764 }
 765
 766 void ShaderParser::assumeToken (Token token)
 767 {
 768         if (m_curToken != token)
 769                 parseError((string("unexpected token '") + m_curTokenStr + "', expecting '" + getTokenName(token) + "'").c_str());
 770         DE_TEST_ASSERT(m_curToken == token);
 771 }
 772
 773 DataType ShaderParser::mapDataTypeToken (Token token)
 774 {
 775         switch (token)
 776         {
 777                 case TOKEN_FLOAT:                       return TYPE_FLOAT;
 778                 case TOKEN_FLOAT_VEC2:          return TYPE_FLOAT_VEC2;
 779                 case TOKEN_FLOAT_VEC3:          return TYPE_FLOAT_VEC3;
 780                 case TOKEN_FLOAT_VEC4:          return TYPE_FLOAT_VEC4;
 781                 case TOKEN_FLOAT_MAT2:          return TYPE_FLOAT_MAT2;
 782                 case TOKEN_FLOAT_MAT2X3:        return TYPE_FLOAT_MAT2X3;
 783                 case TOKEN_FLOAT_MAT2X4:        return TYPE_FLOAT_MAT2X4;
 784                 case TOKEN_FLOAT_MAT3X2:        return TYPE_FLOAT_MAT3X2;
 785                 case TOKEN_FLOAT_MAT3:          return TYPE_FLOAT_MAT3;
 786                 case TOKEN_FLOAT_MAT3X4:        return TYPE_FLOAT_MAT3X4;
 787                 case TOKEN_FLOAT_MAT4X2:        return TYPE_FLOAT_MAT4X2;
 788                 case TOKEN_FLOAT_MAT4X3:        return TYPE_FLOAT_MAT4X3;
 789                 case TOKEN_FLOAT_MAT4:          return TYPE_FLOAT_MAT4;
 790                 case TOKEN_INT:                         return TYPE_INT;
 791                 case TOKEN_INT_VEC2:            return TYPE_INT_VEC2;
 792                 case TOKEN_INT_VEC3:            return TYPE_INT_VEC3;
 793                 case TOKEN_INT_VEC4:            return TYPE_INT_VEC4;
 794                 case TOKEN_UINT:                        return TYPE_UINT;
 795                 case TOKEN_UINT_VEC2:           return TYPE_UINT_VEC2;
 796                 case TOKEN_UINT_VEC3:           return TYPE_UINT_VEC3;
 797                 case TOKEN_UINT_VEC4:           return TYPE_UINT_VEC4;
 798                 case TOKEN_BOOL:                        return TYPE_BOOL;
 799                 case TOKEN_BOOL_VEC2:           return TYPE_BOOL_VEC2;
 800                 case TOKEN_BOOL_VEC3:           return TYPE_BOOL_VEC3;
 801                 case TOKEN_BOOL_VEC4:           return TYPE_BOOL_VEC4;
 802                 default:                                        return TYPE_INVALID;
 803         }
 804 }
 805
 806 const char* ShaderParser::getTokenName (Token token)
 807 {
 808         switch (token)
 809         {
 810                 case TOKEN_INVALID:                                     return "<invalid>";
 811                 case TOKEN_EOF:                                         return "<eof>";
 812                 case TOKEN_STRING:                                      return "<string>";
 813                 case TOKEN_SHADER_SOURCE:                       return "source";
 814
 815                 case TOKEN_INT_LITERAL:                         return "<int>";
 816                 case TOKEN_FLOAT_LITERAL:                       return "<float>";
 817
 818                 // identifiers
 819                 case TOKEN_IDENTIFIER:                          return "<identifier>";
 820                 case TOKEN_TRUE:                                        return "true";
 821                 case TOKEN_FALSE:                                       return "false";
 822                 case TOKEN_DESC:                                        return "desc";
 823                 case TOKEN_EXPECT:                                      return "expect";
 824                 case TOKEN_GROUP:                                       return "group";
 825                 case TOKEN_CASE:                                        return "case";
 826                 case TOKEN_END:                                         return "end";
 827                 case TOKEN_VALUES:                                      return "values";
 828                 case TOKEN_BOTH:                                        return "both";
 829                 case TOKEN_VERTEX:                                      return "vertex";
 830                 case TOKEN_FRAGMENT:                            return "fragment";
 831                 case TOKEN_TESSELLATION_CONTROL:        return "tessellation_control";
 832                 case TOKEN_TESSELLATION_EVALUATION:     return "tessellation_evaluation";
 833                 case TOKEN_GEOMETRY:                            return "geometry";
 834                 case TOKEN_REQUIRE:                                     return "require";
 835                 case TOKEN_UNIFORM:                                     return "uniform";
 836                 case TOKEN_INPUT:                                       return "input";
 837                 case TOKEN_OUTPUT:                                      return "output";
 838                 case TOKEN_FLOAT:                                       return "float";
 839                 case TOKEN_FLOAT_VEC2:                          return "vec2";
 840                 case TOKEN_FLOAT_VEC3:                          return "vec3";
 841                 case TOKEN_FLOAT_VEC4:                          return "vec4";
 842                 case TOKEN_FLOAT_MAT2:                          return "mat2";
 843                 case TOKEN_FLOAT_MAT2X3:                        return "mat2x3";
 844                 case TOKEN_FLOAT_MAT2X4:                        return "mat2x4";
 845                 case TOKEN_FLOAT_MAT3X2:                        return "mat3x2";
 846                 case TOKEN_FLOAT_MAT3:                          return "mat3";
 847                 case TOKEN_FLOAT_MAT3X4:                        return "mat3x4";
 848                 case TOKEN_FLOAT_MAT4X2:                        return "mat4x2";
 849                 case TOKEN_FLOAT_MAT4X3:                        return "mat4x3";
 850                 case TOKEN_FLOAT_MAT4:                          return "mat4";
 851                 case TOKEN_INT:                                         return "int";
 852                 case TOKEN_INT_VEC2:                            return "ivec2";
 853                 case TOKEN_INT_VEC3:                            return "ivec3";
 854                 case TOKEN_INT_VEC4:                            return "ivec4";
 855                 case TOKEN_UINT:                                        return "uint";
 856                 case TOKEN_UINT_VEC2:                           return "uvec2";
 857                 case TOKEN_UINT_VEC3:                           return "uvec3";
 858                 case TOKEN_UINT_VEC4:                           return "uvec4";
 859                 case TOKEN_BOOL:                                        return "bool";
 860                 case TOKEN_BOOL_VEC2:                           return "bvec2";
 861                 case TOKEN_BOOL_VEC3:                           return "bvec3";
 862                 case TOKEN_BOOL_VEC4:                           return "bvec4";
 863                 case TOKEN_IN:                                          return "in";
 864                 case TOKEN_IMPORT:                                      return "import";
 865                 case TOKEN_PIPELINE_PROGRAM:            return "pipeline_program";
 866                 case TOKEN_ACTIVE_STAGES:                       return "active_stages";
 867
 868                 case TOKEN_ASSIGN:                                      return "=";
 869                 case TOKEN_PLUS:                                        return "+";
 870                 case TOKEN_MINUS:                                       return "-";
 871                 case TOKEN_COMMA:                                       return ",";
 872                 case TOKEN_VERTICAL_BAR:                        return "|";
 873                 case TOKEN_SEMI_COLON:                          return ";";
 874                 case TOKEN_LEFT_PAREN:                          return "(";
 875                 case TOKEN_RIGHT_PAREN:                         return ")";
 876                 case TOKEN_LEFT_BRACKET:                        return "[";
 877                 case TOKEN_RIGHT_BRACKET:                       return "]";
 878                 case TOKEN_LEFT_BRACE:                          return "{";
 879                 case TOKEN_RIGHT_BRACE:                         return "}";
 880                 case TOKEN_GREATER:                                     return ">";
 881
 882                 default:                                                        return "<unknown>";
 883         }
 884 }
 885
 886 deUint32 ShaderParser::getShaderStageLiteralFlag (void)
 887 {
 888         switch (m_curToken)
 889         {
 890                 case TOKEN_VERTEX:                                      return (1 << glu::SHADERTYPE_VERTEX);
 891                 case TOKEN_FRAGMENT:                            return (1 << glu::SHADERTYPE_FRAGMENT);
 892                 case TOKEN_GEOMETRY:                            return (1 << glu::SHADERTYPE_GEOMETRY);
 893                 case TOKEN_TESSELLATION_CONTROL:        return (1 << glu::SHADERTYPE_TESSELLATION_CONTROL);
 894                 case TOKEN_TESSELLATION_EVALUATION:     return (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION);
 895
 896                 default:
 897                         parseError(std::string() + "invalid shader stage name, got " + m_curTokenStr);
 898                         return 0;
 899         }
 900 }
 901
 902 deUint32 ShaderParser::getGLEnumFromName (const std::string& enumName)
 903 {
 904         static const struct
 905         {
 906                 const char*     name;
 907                 deUint32        value;
 908         } names[] =
 909         {
 910                 { "GL_MAX_VERTEX_IMAGE_UNIFORMS",                       GL_MAX_VERTEX_IMAGE_UNIFORMS                    },
 911                 { "GL_MAX_VERTEX_ATOMIC_COUNTERS",                      GL_MAX_VERTEX_ATOMIC_COUNTERS                   },
 912                 { "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS",        GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS             },
 913                 { "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS",      GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS   },
 914         };
 915
 916         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(names); ++ndx)
 917                 if (names[ndx].name == enumName)
 918                         return names[ndx].value;
 919
 920         parseError(std::string() + "unknown enum name, got " + enumName);
 921         return 0;
 922 }
 923
 924 void ShaderParser::parseValueElement (DataType expectedDataType, Value& result)
 925 {
 926         DataType        scalarType      = getDataTypeScalarType(expectedDataType);
 927         int                     scalarSize      = getDataTypeScalarSize(expectedDataType);
 928
 929         /* \todo [2010-04-19 petri] Support arrays. */
 930         Value::Element elems[16];
 931
 932         if (scalarSize > 1)
 933         {
 934                 DE_ASSERT(mapDataTypeToken(m_curToken) == expectedDataType);
 935                 advanceToken(); // data type (float, vec2, etc.)
 936                 advanceToken(TOKEN_LEFT_PAREN);
 937         }
 938
 939         for (int scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++)
 940         {
 941                 if (scalarType == TYPE_FLOAT)
 942                 {
 943                         float signMult = 1.0f;
 944                         if (m_curToken == TOKEN_MINUS)
 945                         {
 946                                 signMult = -1.0f;
 947                                 advanceToken();
 948                         }
 949
 950                         assumeToken(TOKEN_FLOAT_LITERAL);
 951                         elems[scalarNdx].float32 = signMult * parseFloatLiteral(m_curTokenStr.c_str());
 952                         advanceToken(TOKEN_FLOAT_LITERAL);
 953                 }
 954                 else if (scalarType == TYPE_INT || scalarType == TYPE_UINT)
 955                 {
 956                         int signMult = 1;
 957                         if (m_curToken == TOKEN_MINUS)
 958                         {
 959                                 signMult = -1;
 960                                 advanceToken();
 961                         }
 962
 963                         assumeToken(TOKEN_INT_LITERAL);
 964                         elems[scalarNdx].int32 = signMult * parseIntLiteral(m_curTokenStr.c_str());
 965                         advanceToken(TOKEN_INT_LITERAL);
 966                 }
 967                 else
 968                 {
 969                         DE_ASSERT(scalarType == TYPE_BOOL);
 970                         elems[scalarNdx].bool32 = (m_curToken == TOKEN_TRUE);
 971                         if (m_curToken != TOKEN_TRUE && m_curToken != TOKEN_FALSE)
 972                                 parseError(string("unexpected token, expecting bool: " + m_curTokenStr));
 973                         advanceToken(); // true/false
 974                 }
 975
 976                 if (scalarNdx != (scalarSize - 1))
 977                         advanceToken(TOKEN_COMMA);
 978         }
 979
 980         if (scalarSize > 1)
 981                 advanceToken(TOKEN_RIGHT_PAREN);
 982
 983         // Store results.
 984         for (int scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++)
 985                 result.elements.push_back(elems[scalarNdx]);
 986 }
 987
 988 void ShaderParser::parseValue (ValueBlock& valueBlock)
 989 {
 990         PARSE_DBG(("      parseValue()\n"));
 991
 992         // Parsed results.
 993         vector<Value>*  dstBlock        = DE_NULL;
 994         DataType                basicType       = TYPE_LAST;
 995         std::string             valueName;
 996
 997         // Parse storage.
 998         if (m_curToken == TOKEN_UNIFORM)
 999                 dstBlock = &valueBlock.uniforms;
1000         else if (m_curToken == TOKEN_INPUT)
1001                 dstBlock = &valueBlock.inputs;
1002         else if (m_curToken == TOKEN_OUTPUT)
1003                 dstBlock = &valueBlock.outputs;
1004         else
1005                 parseError(string("unexpected token encountered when parsing value classifier"));
1006         advanceToken();
1007
1008         // Parse data type.
1009         basicType = mapDataTypeToken(m_curToken);
1010         if (basicType == TYPE_INVALID)
1011                 parseError(string("unexpected token when parsing value data type: " + m_curTokenStr));
1012         advanceToken();
1013
1014         // Parse value name.
1015         if (m_curToken == TOKEN_IDENTIFIER || m_curToken == TOKEN_STRING)
1016         {
1017                 if (m_curToken == TOKEN_IDENTIFIER)
1018                         valueName = m_curTokenStr;
1019                 else
1020                         valueName = parseStringLiteral(m_curTokenStr.c_str());
1021         }
1022         else
1023                 parseError(string("unexpected token when parsing value name: " + m_curTokenStr));
1024         advanceToken();
1025
1026         // Parse assignment operator.
1027         advanceToken(TOKEN_ASSIGN);
1028
1029         {
1030                 Value value;
1031                 value.name      = valueName;
1032                 value.type      = VarType(basicType, PRECISION_LAST);
1033                 dstBlock->push_back(value);
1034         }
1035
1036         // Parse actual value.
1037         if (m_curToken == TOKEN_LEFT_BRACKET) // value list
1038         {
1039                 int     arrayLength     = 0; // \todo [2015-08-03 pyry] Currently unused
1040
1041                 advanceToken(TOKEN_LEFT_BRACKET);
1042
1043                 for (;;)
1044                 {
1045                         parseValueElement(basicType, dstBlock->back());
1046                         arrayLength++;
1047
1048                         if (m_curToken == TOKEN_RIGHT_BRACKET)
1049                                 break;
1050                         else if (m_curToken == TOKEN_VERTICAL_BAR)
1051                         {
1052                                 advanceToken();
1053                                 continue;
1054                         }
1055                         else
1056                                 parseError(string("unexpected token in value element array: " + m_curTokenStr));
1057                 }
1058
1059                 advanceToken(TOKEN_RIGHT_BRACKET);
1060         }
1061         else //  single elements
1062         {
1063                 parseValueElement(basicType, dstBlock->back());
1064         }
1065
1066         advanceToken(TOKEN_SEMI_COLON); // end of declaration
1067 }
1068
1069 void ShaderParser::parseValueBlock (ValueBlock& valueBlock)
1070 {
1071         PARSE_DBG(("    parseValueBlock()\n"));
1072         advanceToken(TOKEN_VALUES);
1073         advanceToken(TOKEN_LEFT_BRACE);
1074
1075         for (;;)
1076         {
1077                 if (m_curToken == TOKEN_UNIFORM || m_curToken == TOKEN_INPUT || m_curToken == TOKEN_OUTPUT)
1078                         parseValue(valueBlock);
1079                 else if (m_curToken == TOKEN_RIGHT_BRACE)
1080                         break;
1081                 else
1082                         parseError(string("unexpected token when parsing a value block: " + m_curTokenStr));
1083         }
1084
1085         advanceToken(TOKEN_RIGHT_BRACE);
1086 }
1087
1088 deUint32 ShaderParser::parseShaderStageList (void)
1089 {
1090         deUint32 mask = 0;
1091
1092         assumeToken(TOKEN_LEFT_BRACE);
1093
1094         // don't allow 0-sized lists
1095         advanceToken();
1096         mask |= getShaderStageLiteralFlag();
1097         advanceToken();
1098
1099         for (;;)
1100         {
1101                 if (m_curToken == TOKEN_RIGHT_BRACE)
1102                         break;
1103                 else if (m_curToken == TOKEN_COMMA)
1104                 {
1105                         deUint32 stageFlag;
1106                         advanceToken();
1107
1108                         stageFlag = getShaderStageLiteralFlag();
1109                         if (stageFlag & mask)
1110                                 parseError(string("stage already set in the shader stage set: " + m_curTokenStr));
1111
1112                         mask |= stageFlag;
1113                         advanceToken();
1114                 }
1115                 else
1116                         parseError(string("invalid shader stage set token: " + m_curTokenStr));
1117         }
1118         advanceToken(TOKEN_RIGHT_BRACE);
1119
1120         return mask;
1121 }
1122
1123 void ShaderParser::parseRequirement (vector<RequiredCapability>& requiredCaps, vector<RequiredExtension>& requiredExts)
1124 {
1125         PARSE_DBG(("    parseRequirement()\n"));
1126
1127         advanceToken();
1128         assumeToken(TOKEN_IDENTIFIER);
1129
1130         if (m_curTokenStr == "extension")
1131         {
1132                 std::vector<std::string>        anyExtensionStringList;
1133                 deUint32                                        affectedCasesFlags              = -1; // by default all stages
1134
1135                 advanceToken();
1136                 assumeToken(TOKEN_LEFT_BRACE);
1137
1138                 advanceToken();
1139                 assumeToken(TOKEN_STRING);
1140
1141                 anyExtensionStringList.push_back(parseStringLiteral(m_curTokenStr.c_str()));
1142                 advanceToken();
1143
1144                 for (;;)
1145                 {
1146                         if (m_curToken == TOKEN_RIGHT_BRACE)
1147                                 break;
1148                         else if (m_curToken == TOKEN_VERTICAL_BAR)
1149                         {
1150                                 advanceToken();
1151                                 assumeToken(TOKEN_STRING);
1152
1153                                 anyExtensionStringList.push_back(parseStringLiteral(m_curTokenStr.c_str()));
1154                                 advanceToken();
1155                         }
1156                         else
1157                                 parseError(string("invalid extension list token: " + m_curTokenStr));
1158                 }
1159                 advanceToken(TOKEN_RIGHT_BRACE);
1160
1161                 if (m_curToken == TOKEN_IN)
1162                 {
1163                         advanceToken();
1164                         affectedCasesFlags = parseShaderStageList();
1165                 }
1166
1167                 requiredExts.push_back(RequiredExtension(anyExtensionStringList, affectedCasesFlags));
1168         }
1169         else if (m_curTokenStr == "limit")
1170         {
1171                 deUint32        limitEnum;
1172                 int                     limitValue;
1173
1174                 advanceToken();
1175
1176                 assumeToken(TOKEN_STRING);
1177                 limitEnum = getGLEnumFromName(parseStringLiteral(m_curTokenStr.c_str()));
1178                 advanceToken();
1179
1180                 assumeToken(TOKEN_GREATER);
1181                 advanceToken();
1182
1183                 assumeToken(TOKEN_INT_LITERAL);
1184                 limitValue = parseIntLiteral(m_curTokenStr.c_str());
1185                 advanceToken();
1186
1187                 requiredCaps.push_back(RequiredCapability(limitEnum, limitValue));
1188         }
1189         else if (m_curTokenStr == "full_glsl_es_100_support")
1190         {
1191                 advanceToken();
1192
1193                 requiredCaps.push_back(RequiredCapability(CAPABILITY_FULL_GLSL_ES_100_SUPPORT));
1194         }
1195         else if (m_curTokenStr == "only_glsl_es_100_support")
1196         {
1197                 advanceToken();
1198
1199                 requiredCaps.push_back(RequiredCapability(CAPABILITY_ONLY_GLSL_ES_100_SUPPORT));
1200         }
1201         else if (m_curTokenStr == "exactly_one_draw_buffer")
1202         {
1203                 advanceToken();
1204
1205                 requiredCaps.push_back(RequiredCapability(CAPABILITY_EXACTLY_ONE_DRAW_BUFFER));
1206         }
1207         else
1208                 parseError(string("invalid requirement value: " + m_curTokenStr));
1209 }
1210
1211 void ShaderParser::parseExpectResult (ExpectResult& expectResult)
1212 {
1213         assumeToken(TOKEN_IDENTIFIER);
1214
1215         if (m_curTokenStr == "pass")
1216                 expectResult = EXPECT_PASS;
1217         else if (m_curTokenStr == "compile_fail")
1218                 expectResult = EXPECT_COMPILE_FAIL;
1219         else if (m_curTokenStr == "link_fail")
1220                 expectResult = EXPECT_LINK_FAIL;
1221         else if (m_curTokenStr == "compile_or_link_fail")
1222                 expectResult = EXPECT_COMPILE_LINK_FAIL;
1223         else if (m_curTokenStr == "validation_fail")
1224                 expectResult = EXPECT_VALIDATION_FAIL;
1225         else if (m_curTokenStr == "build_successful")
1226                 expectResult = EXPECT_BUILD_SUCCESSFUL;
1227         else
1228                 parseError(string("invalid expected result value: " + m_curTokenStr));
1229
1230         advanceToken();
1231 }
1232
1233 void ShaderParser::parseFormat (DataType& format)
1234 {
1235         format = mapDataTypeToken(m_curToken);
1236         advanceToken();
1237 }
1238
1239 void ShaderParser::parseGLSLVersion (glu::GLSLVersion& version)
1240 {
1241         int                     versionNum              = 0;
1242         std::string     postfix                 = "";
1243
1244         assumeToken(TOKEN_INT_LITERAL);
1245         versionNum = parseIntLiteral(m_curTokenStr.c_str());
1246         advanceToken();
1247
1248         if (m_curToken == TOKEN_IDENTIFIER)
1249         {
1250                 postfix = m_curTokenStr;
1251                 advanceToken();
1252         }
1253
1254         DE_STATIC_ASSERT(glu::GLSL_VERSION_LAST == 15);
1255
1256         if              (versionNum == 100 && postfix == "es")  version = glu::GLSL_VERSION_100_ES;
1257         else if (versionNum == 300 && postfix == "es")  version = glu::GLSL_VERSION_300_ES;
1258         else if (versionNum == 310 && postfix == "es")  version = glu::GLSL_VERSION_310_ES;
1259         else if (versionNum == 320 && postfix == "es")  version = glu::GLSL_VERSION_320_ES;
1260         else if (versionNum == 130)                                             version = glu::GLSL_VERSION_130;
1261         else if (versionNum == 140)                                             version = glu::GLSL_VERSION_140;
1262         else if (versionNum == 150)                                             version = glu::GLSL_VERSION_150;
1263         else if (versionNum == 330)                                             version = glu::GLSL_VERSION_330;
1264         else if (versionNum == 400)                                             version = glu::GLSL_VERSION_400;
1265         else if (versionNum == 410)                                             version = glu::GLSL_VERSION_410;
1266         else if (versionNum == 420)                                             version = glu::GLSL_VERSION_420;
1267         else if (versionNum == 430)                                             version = glu::GLSL_VERSION_430;
1268         else if (versionNum == 440)                                             version = glu::GLSL_VERSION_440;
1269         else if (versionNum == 450)                                             version = glu::GLSL_VERSION_450;
1270         else if (versionNum == 460)                                             version = glu::GLSL_VERSION_460;
1271         else
1272                 parseError("Unknown GLSL version");
1273 }
1274
1275 void ShaderParser::parsePipelineProgram (ProgramSpecification& program)
1276 {
1277         advanceToken(TOKEN_PIPELINE_PROGRAM);
1278
1279         for (;;)
1280         {
1281                 if (m_curToken == TOKEN_END)
1282                         break;
1283                 else if (m_curToken == TOKEN_ACTIVE_STAGES)
1284                 {
1285                         advanceToken();
1286                         program.activeStages = parseShaderStageList();
1287                 }
1288                 else if (m_curToken == TOKEN_REQUIRE)
1289                 {
1290                         vector<RequiredCapability> unusedCaps;
1291                         size_t size = program.requiredExtensions.size();
1292                         parseRequirement(unusedCaps, program.requiredExtensions);
1293
1294                         if (size == program.requiredExtensions.size())
1295                                 parseError("only extension requirements are allowed inside pipeline program");
1296                 }
1297                 else if (m_curToken == TOKEN_VERTEX                                             ||
1298                                  m_curToken == TOKEN_FRAGMENT                                   ||
1299                                  m_curToken == TOKEN_TESSELLATION_CONTROL               ||
1300                                  m_curToken == TOKEN_TESSELLATION_EVALUATION    ||
1301                                  m_curToken == TOKEN_GEOMETRY)
1302                 {
1303                         const Token     token = m_curToken;
1304                         string          source;
1305
1306                         advanceToken();
1307                         assumeToken(TOKEN_SHADER_SOURCE);
1308                         source = parseShaderSource(m_curTokenStr.c_str());
1309                         advanceToken();
1310
1311                         switch (token)
1312                         {
1313                                 case TOKEN_VERTEX:                                      program.sources.sources[SHADERTYPE_VERTEX].push_back(source);                                   break;
1314                                 case TOKEN_FRAGMENT:                            program.sources.sources[SHADERTYPE_FRAGMENT].push_back(source);                                 break;
1315                                 case TOKEN_TESSELLATION_CONTROL:        program.sources.sources[SHADERTYPE_TESSELLATION_CONTROL].push_back(source);             break;
1316                                 case TOKEN_TESSELLATION_EVALUATION:     program.sources.sources[SHADERTYPE_TESSELLATION_EVALUATION].push_back(source);  break;
1317                                 case TOKEN_GEOMETRY:                            program.sources.sources[SHADERTYPE_GEOMETRY].push_back(source);                                 break;
1318                                 default:
1319                                         parseError(DE_FALSE);
1320                         }
1321                 }
1322                 else
1323                         parseError(string("invalid pipeline program value: " + m_curTokenStr));
1324         }
1325         advanceToken(TOKEN_END);
1326
1327         if (program.activeStages == 0)
1328                 parseError("program pipeline object must have active stages");
1329 }
1330
1331 void ShaderParser::parseShaderCase (vector<tcu::TestNode*>& shaderNodeList)
1332 {
1333         // Parse 'case'.
1334         PARSE_DBG(("  parseShaderCase()\n"));
1335         advanceToken(TOKEN_CASE);
1336
1337         // Parse case name.
1338         string caseName = m_curTokenStr;
1339         advanceToken(); // \note [pyry] All token types are allowed here.
1340
1341         // \todo [pyry] Optimize by parsing most stuff directly to ShaderCaseSpecification
1342
1343         // Setup case.
1344         GLSLVersion                                             version                 = DEFAULT_GLSL_VERSION;
1345         ExpectResult                                    expectResult    = EXPECT_PASS;
1346         OutputType                                              outputType              = OUTPUT_RESULT;
1347         DataType                                                format                  = TYPE_LAST;
1348         string                                                  description;
1349         string                                                  bothSource;
1350         vector<string>                                  vertexSources;
1351         vector<string>                                  fragmentSources;
1352         vector<string>                                  tessellationCtrlSources;
1353         vector<string>                                  tessellationEvalSources;
1354         vector<string>                                  geometrySources;
1355         ValueBlock                                              valueBlock;
1356         bool                                                    valueBlockSeen  = false;
1357         vector<RequiredCapability>              requiredCaps;
1358         vector<RequiredExtension>               requiredExts;
1359         vector<ProgramSpecification>    pipelinePrograms;
1360
1361         for (;;)
1362         {
1363                 if (m_curToken == TOKEN_END)
1364                         break;
1365                 else if (m_curToken == TOKEN_DESC)
1366                 {
1367                         advanceToken();
1368                         assumeToken(TOKEN_STRING);
1369                         description = parseStringLiteral(m_curTokenStr.c_str());
1370                         advanceToken();
1371                 }
1372                 else if (m_curToken == TOKEN_EXPECT)
1373                 {
1374                         advanceToken();
1375                         parseExpectResult(expectResult);
1376                 }
1377                 else if (m_curToken == TOKEN_OUTPUT_COLOR)
1378                 {
1379                         outputType = OUTPUT_COLOR;
1380                         advanceToken();
1381                         parseFormat(format);
1382                 }
1383                 else if (m_curToken == TOKEN_VALUES)
1384                 {
1385                         if (valueBlockSeen)
1386                                 parseError("multiple value blocks");
1387                         parseValueBlock(valueBlock);
1388                         valueBlockSeen = true;
1389                 }
1390                 else if (m_curToken == TOKEN_BOTH                                               ||
1391                                  m_curToken == TOKEN_VERTEX                                             ||
1392                                  m_curToken == TOKEN_FRAGMENT                                   ||
1393                                  m_curToken == TOKEN_TESSELLATION_CONTROL               ||
1394                                  m_curToken == TOKEN_TESSELLATION_EVALUATION    ||
1395                                  m_curToken == TOKEN_GEOMETRY)
1396                 {
1397                         const Token     token = m_curToken;
1398                         string          source;
1399
1400                         advanceToken();
1401                         assumeToken(TOKEN_SHADER_SOURCE);
1402                         source = parseShaderSource(m_curTokenStr.c_str());
1403                         advanceToken();
1404
1405                         switch (token)
1406                         {
1407                                 case TOKEN_VERTEX:                                      vertexSources.push_back(source);                        break;
1408                                 case TOKEN_FRAGMENT:                            fragmentSources.push_back(source);                      break;
1409                                 case TOKEN_TESSELLATION_CONTROL:        tessellationCtrlSources.push_back(source);      break;
1410                                 case TOKEN_TESSELLATION_EVALUATION:     tessellationEvalSources.push_back(source);      break;
1411                                 case TOKEN_GEOMETRY:                            geometrySources.push_back(source);                      break;
1412                                 case TOKEN_BOTH:
1413                                 {
1414                                         if (!bothSource.empty())
1415                                                 parseError("multiple 'both' blocks");
1416                                         bothSource = source;
1417                                         break;
1418                                 }
1419
1420                                 default:
1421                                         parseError(DE_FALSE);
1422                         }
1423                 }
1424                 else if (m_curToken == TOKEN_VERSION)
1425                 {
1426                         advanceToken();
1427                         parseGLSLVersion(version);
1428                 }
1429                 else if (m_curToken == TOKEN_REQUIRE)
1430                 {
1431                         parseRequirement(requiredCaps, requiredExts);
1432                 }
1433                 else if (m_curToken == TOKEN_PIPELINE_PROGRAM)
1434                 {
1435                         ProgramSpecification pipelineProgram;
1436                         parsePipelineProgram(pipelineProgram);
1437                         pipelineProgram.sources.separable = true;
1438                         pipelinePrograms.push_back(pipelineProgram);
1439                 }
1440                 else
1441                         parseError(string("unexpected token while parsing shader case: " + m_curTokenStr));
1442         }
1443
1444         advanceToken(TOKEN_END); // case end
1445
1446         if (!bothSource.empty())
1447         {
1448                 if (!vertexSources.empty()                              ||
1449                         !fragmentSources.empty()                        ||
1450                         !tessellationCtrlSources.empty()        ||
1451                         !tessellationEvalSources.empty()        ||
1452                         !geometrySources.empty()                        ||
1453                         !pipelinePrograms.empty())
1454                 {
1455                         parseError("'both' cannot be mixed with other shader stages");
1456                 }
1457
1458                 // vertex
1459                 {
1460                         ShaderCaseSpecification spec;
1461                         spec.caseType                           = CASETYPE_VERTEX_ONLY;
1462                         spec.expectResult                       = expectResult;
1463                         spec.targetVersion                      = version;
1464                         spec.requiredCaps                       = requiredCaps;
1465                         spec.values                                     = valueBlock;
1466
1467                         spec.programs.resize(1);
1468                         spec.programs[0].sources << VertexSource(bothSource);
1469                         spec.programs[0].requiredExtensions     = requiredExts;
1470
1471                         shaderNodeList.push_back(m_caseFactory->createCase(caseName + "_vertex", description, ShaderCaseSpecification(spec)));
1472                 }
1473
1474                 // fragment
1475                 {
1476                         ShaderCaseSpecification spec;
1477                         spec.caseType                           = CASETYPE_FRAGMENT_ONLY;
1478                         spec.expectResult                       = expectResult;
1479                         spec.targetVersion                      = version;
1480                         spec.requiredCaps                       = requiredCaps;
1481                         spec.values                                     = valueBlock;
1482
1483                         spec.programs.resize(1);
1484                         spec.programs[0].sources << FragmentSource(bothSource);
1485                         spec.programs[0].requiredExtensions     = requiredExts;
1486
1487                         shaderNodeList.push_back(m_caseFactory->createCase(caseName + "_fragment", description, ShaderCaseSpecification(spec)));
1488                 }
1489         }
1490         else if (pipelinePrograms.empty())
1491         {
1492                 ShaderCaseSpecification spec;
1493                 spec.caseType                           = CASETYPE_COMPLETE;
1494                 spec.expectResult                       = expectResult;
1495                 spec.outputType                         = outputType;
1496                 spec.outputFormat                       = format;
1497                 spec.targetVersion                      = version;
1498                 spec.requiredCaps                       = requiredCaps;
1499                 spec.values                                     = valueBlock;
1500
1501                 spec.programs.resize(1);
1502                 spec.programs[0].sources.sources[SHADERTYPE_VERTEX].swap(vertexSources);
1503                 spec.programs[0].sources.sources[SHADERTYPE_FRAGMENT].swap(fragmentSources);
1504                 spec.programs[0].sources.sources[SHADERTYPE_TESSELLATION_CONTROL].swap(tessellationCtrlSources);
1505                 spec.programs[0].sources.sources[SHADERTYPE_TESSELLATION_EVALUATION].swap(tessellationEvalSources);
1506                 spec.programs[0].sources.sources[SHADERTYPE_GEOMETRY].swap(geometrySources);
1507                 spec.programs[0].requiredExtensions.swap(requiredExts);
1508
1509                 shaderNodeList.push_back(m_caseFactory->createCase(caseName, description, ShaderCaseSpecification(spec)));
1510         }
1511         else
1512         {
1513                 if (!vertexSources.empty()                              ||
1514                         !fragmentSources.empty()                        ||
1515                         !tessellationCtrlSources.empty()        ||
1516                         !tessellationEvalSources.empty()        ||
1517                         !geometrySources.empty())
1518                 {
1519                         parseError("pipeline programs cannot be mixed with complete programs");
1520                 }
1521
1522                 if (!requiredExts.empty())
1523                         parseError("global extension requirements cannot be mixed with pipeline programs");
1524
1525                 // Pipeline case, multiple programs
1526                 {
1527                         ShaderCaseSpecification spec;
1528                         spec.caseType                           = CASETYPE_COMPLETE;
1529                         spec.expectResult                       = expectResult;
1530                         spec.targetVersion                      = version;
1531                         spec.requiredCaps                       = requiredCaps;
1532                         spec.values                                     = valueBlock;
1533
1534                         spec.programs.swap(pipelinePrograms);
1535
1536                         shaderNodeList.push_back(m_caseFactory->createCase(caseName, description, ShaderCaseSpecification(spec)));
1537                 }
1538         }
1539 }
1540
1541 void ShaderParser::parseShaderGroup (vector<tcu::TestNode*>& shaderNodeList)
1542 {
1543         // Parse 'case'.
1544         PARSE_DBG(("  parseShaderGroup()\n"));
1545         advanceToken(TOKEN_GROUP);
1546
1547         // Parse case name.
1548         string name = m_curTokenStr;
1549         advanceToken(); // \note [pyry] We don't want to check token type here (for instance to allow "uniform") group.
1550
1551         // Parse description.
1552         assumeToken(TOKEN_STRING);
1553         string description = parseStringLiteral(m_curTokenStr.c_str());
1554         advanceToken(TOKEN_STRING);
1555
1556         std::vector<tcu::TestNode*> children;
1557
1558         // Parse group children.
1559         for (;;)
1560         {
1561                 if (m_curToken == TOKEN_END)
1562                         break;
1563                 else if (m_curToken == TOKEN_GROUP)
1564                         parseShaderGroup(children);
1565                 else if (m_curToken == TOKEN_CASE)
1566                         parseShaderCase(children);
1567                 else if (m_curToken == TOKEN_IMPORT)
1568                         parseImport(children);
1569                 else
1570                         parseError(string("unexpected token while parsing shader group: " + m_curTokenStr));
1571         }
1572
1573         advanceToken(TOKEN_END); // group end
1574
1575         // Create group node.
1576         tcu::TestCaseGroup* groupNode = m_caseFactory->createGroup(name, description, children);
1577         shaderNodeList.push_back(groupNode);
1578 }
1579
1580 void ShaderParser::parseImport (vector<tcu::TestNode*>& shaderNodeList)
1581 {
1582         std::string     importFileName;
1583
1584         advanceToken(TOKEN_IMPORT);
1585
1586         assumeToken(TOKEN_STRING);
1587         importFileName = parseStringLiteral(m_curTokenStr.c_str());
1588         advanceToken(TOKEN_STRING);
1589
1590         {
1591                 ShaderParser                                    subParser               (m_archive, de::FilePath::join(de::FilePath(m_filename).getDirName(), importFileName).getPath(), m_caseFactory);
1592                 const vector<tcu::TestNode*>    importedCases = subParser.parse();
1593
1594                 // \todo [2015-08-03 pyry] Not exception safe
1595                 shaderNodeList.insert(shaderNodeList.end(), importedCases.begin(), importedCases.end());
1596         }
1597 }
1598
1599 vector<tcu::TestNode*> ShaderParser::parse (void)
1600 {
1601         const int       dataLen         = m_resource->getSize();
1602
1603         m_input.resize(dataLen+1);
1604         m_resource->setPosition(0);
1605         m_resource->read((deUint8*)&m_input[0], dataLen);
1606         m_input[dataLen] = '\0';
1607
1608         // Initialize parser.
1609         m_curPtr                = &m_input[0];
1610         m_curToken              = TOKEN_INVALID;
1611         m_curTokenStr   = "";
1612         advanceToken();
1613
1614         vector<tcu::TestNode*> nodeList;
1615
1616         // Parse all cases.
1617         PARSE_DBG(("parse()\n"));
1618         for (;;)
1619         {
1620                 if (m_curToken == TOKEN_CASE)
1621                         parseShaderCase(nodeList);
1622                 else if (m_curToken == TOKEN_GROUP)
1623                         parseShaderGroup(nodeList);
1624                 else if (m_curToken == TOKEN_IMPORT)
1625                         parseImport(nodeList);
1626                 else if (m_curToken == TOKEN_EOF)
1627                         break;
1628                 else
1629                         parseError(string("invalid token encountered at main level: '") + m_curTokenStr + "'");
1630         }
1631
1632         assumeToken(TOKEN_EOF);
1633 //      printf("  parsed %d test cases.\n", caseList.size());
1634         return nodeList;
1635 }
1636
1637 std::vector<tcu::TestNode*> parseFile (const tcu::Archive& archive, const std::string& filename, ShaderCaseFactory* caseFactory)
1638 {
1639         sl::ShaderParser        parser  (archive, filename, caseFactory);
1640
1641         return parser.parse();
1642 }
1643
1644 // Execution utilities
1645
1646 static void dumpValue (tcu::TestLog& log, const Value& val, const char* storageName, int arrayNdx)
1647 {
1648         const char* const       valueName               = val.name.c_str();
1649         const DataType          dataType                = val.type.getBasicType();
1650         int                                     scalarSize              = getDataTypeScalarSize(dataType);
1651         ostringstream           result;
1652
1653         result << "    " << storageName << " ";
1654
1655         result << getDataTypeName(dataType) << " " << valueName << ":";
1656
1657         if (isDataTypeScalar(dataType))
1658                 result << " ";
1659         if (isDataTypeVector(dataType))
1660                 result << " [ ";
1661         else if (isDataTypeMatrix(dataType))
1662                 result << "\n";
1663
1664         if (isDataTypeScalarOrVector(dataType))
1665         {
1666                 for (int scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++)
1667                 {
1668                         int                                             elemNdx = arrayNdx;
1669                         const Value::Element&   e               = val.elements[elemNdx*scalarSize + scalarNdx];
1670                         result << ((scalarNdx != 0) ? ", " : "");
1671
1672                         if (isDataTypeFloatOrVec(dataType))
1673                                 result << e.float32;
1674                         else if (isDataTypeIntOrIVec(dataType))
1675                                 result << e.int32;
1676                         else if (isDataTypeUintOrUVec(dataType))
1677                                 result << (deUint32)e.int32;
1678                         else if (isDataTypeBoolOrBVec(dataType))
1679                                 result << (e.bool32 ? "true" : "false");
1680                 }
1681         }
1682         else if (isDataTypeMatrix(dataType))
1683         {
1684                 int numRows = getDataTypeMatrixNumRows(dataType);
1685                 int numCols = getDataTypeMatrixNumColumns(dataType);
1686                 for (int rowNdx = 0; rowNdx < numRows; rowNdx++)
1687                 {
1688                         result << "       [ ";
1689                         for (int colNdx = 0; colNdx < numCols; colNdx++)
1690                         {
1691                                 int             elemNdx = arrayNdx;
1692                                 float   v               = val.elements[elemNdx*scalarSize + rowNdx*numCols + colNdx].float32;
1693                                 result << ((colNdx==0) ? "" : ", ") << v;
1694                         }
1695                         result << " ]\n";
1696                 }
1697         }
1698
1699         if (isDataTypeScalar(dataType))
1700                 result << "\n";
1701         else if (isDataTypeVector(dataType))
1702                 result << " ]\n";
1703
1704         log << TestLog::Message << result.str() << TestLog::EndMessage;
1705 }
1706
1707 static void dumpValues (tcu::TestLog& log, const vector<Value>& values, const char* storageName, int arrayNdx)
1708 {
1709         for (size_t valNdx = 0; valNdx < values.size(); valNdx++)
1710                 dumpValue(log, values[valNdx], storageName, arrayNdx);
1711 }
1712
1713 void dumpValues (tcu::TestLog& log, const ValueBlock& values, int arrayNdx)
1714 {
1715         dumpValues(log, values.inputs,          "input",        arrayNdx);
1716         dumpValues(log, values.outputs,         "expected",     arrayNdx);
1717         dumpValues(log, values.uniforms,        "uniform",      arrayNdx);
1718 }
1719
1720 static void generateExtensionStatements (std::ostringstream& buf, const std::vector<RequiredExtension>& extensions, glu::ShaderType type)
1721 {
1722         for (size_t ndx = 0; ndx < extensions.size(); ++ndx)
1723         {
1724                 DE_ASSERT(extensions[ndx].effectiveStages != 0u &&
1725                                   extensions[ndx].alternatives.size() == 1);
1726
1727                 if ((extensions[ndx].effectiveStages & (1u << (deUint32)type)) != 0)
1728                         buf << "#extension " << extensions[ndx].alternatives[0] << " : require\n";
1729         }
1730 }
1731
1732 // Injects #extension XXX : require lines after the last preprocessor directive in the shader code. Does not support line continuations
1733 std::string injectExtensionRequirements (const std::string& baseCode, const std::vector<RequiredExtension>& extensions, glu::ShaderType shaderType)
1734 {
1735         std::istringstream      baseCodeBuf                                     (baseCode);
1736         std::ostringstream      resultBuf;
1737         std::string                     line;
1738         bool                            firstNonPreprocessorLine        = true;
1739         std::ostringstream      extStr;
1740
1741         generateExtensionStatements(extStr, extensions, shaderType);
1742
1743         // skip if no requirements
1744         if (extStr.str().empty())
1745                 return baseCode;
1746
1747         while (std::getline(baseCodeBuf, line))
1748         {
1749                 // begins with '#'?
1750                 const std::string::size_type    firstNonWhitespace              = line.find_first_not_of("\t ");
1751                 const bool                                              isPreprocessorDirective = (firstNonWhitespace != std::string::npos && line.at(firstNonWhitespace) == '#');
1752
1753                 // Inject #extensions
1754                 if (!isPreprocessorDirective && firstNonPreprocessorLine)
1755                 {
1756                         firstNonPreprocessorLine = false;
1757                         resultBuf << extStr.str();
1758                 }
1759
1760                 resultBuf << line << "\n";
1761         }
1762
1763         return resultBuf.str();
1764 }
1765
1766 void genCompareFunctions (ostringstream& stream, const ValueBlock& valueBlock, bool useFloatTypes)
1767 {
1768         bool cmpTypeFound[TYPE_LAST];
1769         for (int i = 0; i < TYPE_LAST; i++)
1770                 cmpTypeFound[i] = false;
1771
1772         for (size_t valueNdx = 0; valueNdx < valueBlock.outputs.size(); valueNdx++)
1773         {
1774                 const Value& val = valueBlock.outputs[valueNdx];
1775                 cmpTypeFound[(size_t)val.type.getBasicType()] = true;
1776         }
1777
1778         if (useFloatTypes)
1779         {
1780                 if (cmpTypeFound[TYPE_BOOL])            stream << "bool isOk (float a, bool b) { return ((a > 0.5) == b); }\n";
1781                 if (cmpTypeFound[TYPE_BOOL_VEC2])       stream << "bool isOk (vec2 a, bvec2 b) { return (greaterThan(a, vec2(0.5)) == b); }\n";
1782                 if (cmpTypeFound[TYPE_BOOL_VEC3])       stream << "bool isOk (vec3 a, bvec3 b) { return (greaterThan(a, vec3(0.5)) == b); }\n";
1783                 if (cmpTypeFound[TYPE_BOOL_VEC4])       stream << "bool isOk (vec4 a, bvec4 b) { return (greaterThan(a, vec4(0.5)) == b); }\n";
1784                 if (cmpTypeFound[TYPE_INT])                     stream << "bool isOk (float a, int b)  { float atemp = a+0.5; return (float(b) <= atemp && atemp <= float(b+1)); }\n";
1785                 if (cmpTypeFound[TYPE_INT_VEC2])        stream << "bool isOk (vec2 a, ivec2 b) { return (ivec2(floor(a + 0.5)) == b); }\n";
1786                 if (cmpTypeFound[TYPE_INT_VEC3])        stream << "bool isOk (vec3 a, ivec3 b) { return (ivec3(floor(a + 0.5)) == b); }\n";
1787                 if (cmpTypeFound[TYPE_INT_VEC4])        stream << "bool isOk (vec4 a, ivec4 b) { return (ivec4(floor(a + 0.5)) == b); }\n";
1788                 if (cmpTypeFound[TYPE_UINT])            stream << "bool isOk (float a, uint b) { float atemp = a+0.5; return (float(b) <= atemp && atemp <= float(b+1u)); }\n";
1789                 if (cmpTypeFound[TYPE_UINT_VEC2])       stream << "bool isOk (vec2 a, uvec2 b) { return (uvec2(floor(a + 0.5)) == b); }\n";
1790                 if (cmpTypeFound[TYPE_UINT_VEC3])       stream << "bool isOk (vec3 a, uvec3 b) { return (uvec3(floor(a + 0.5)) == b); }\n";
1791                 if (cmpTypeFound[TYPE_UINT_VEC4])       stream << "bool isOk (vec4 a, uvec4 b) { return (uvec4(floor(a + 0.5)) == b); }\n";
1792         }
1793         else
1794         {
1795                 if (cmpTypeFound[TYPE_BOOL])            stream << "bool isOk (bool a, bool b)   { return (a == b); }\n";
1796                 if (cmpTypeFound[TYPE_BOOL_VEC2])       stream << "bool isOk (bvec2 a, bvec2 b) { return (a == b); }\n";
1797                 if (cmpTypeFound[TYPE_BOOL_VEC3])       stream << "bool isOk (bvec3 a, bvec3 b) { return (a == b); }\n";
1798                 if (cmpTypeFound[TYPE_BOOL_VEC4])       stream << "bool isOk (bvec4 a, bvec4 b) { return (a == b); }\n";
1799                 if (cmpTypeFound[TYPE_INT])                     stream << "bool isOk (int a, int b)     { return (a == b); }\n";
1800                 if (cmpTypeFound[TYPE_INT_VEC2])        stream << "bool isOk (ivec2 a, ivec2 b) { return (a == b); }\n";
1801                 if (cmpTypeFound[TYPE_INT_VEC3])        stream << "bool isOk (ivec3 a, ivec3 b) { return (a == b); }\n";
1802                 if (cmpTypeFound[TYPE_INT_VEC4])        stream << "bool isOk (ivec4 a, ivec4 b) { return (a == b); }\n";
1803                 if (cmpTypeFound[TYPE_UINT])            stream << "bool isOk (uint a, uint b)   { return (a == b); }\n";
1804                 if (cmpTypeFound[TYPE_UINT_VEC2])       stream << "bool isOk (uvec2 a, uvec2 b) { return (a == b); }\n";
1805                 if (cmpTypeFound[TYPE_UINT_VEC3])       stream << "bool isOk (uvec3 a, uvec3 b) { return (a == b); }\n";
1806                 if (cmpTypeFound[TYPE_UINT_VEC4])       stream << "bool isOk (uvec4 a, uvec4 b) { return (a == b); }\n";
1807         }
1808
1809         if (cmpTypeFound[TYPE_FLOAT])           stream << "bool isOk (float a, float b, float eps) { return (abs(a-b) <= (eps*abs(b) + eps)); }\n";
1810         if (cmpTypeFound[TYPE_FLOAT_VEC2])      stream << "bool isOk (vec2 a, vec2 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n";
1811         if (cmpTypeFound[TYPE_FLOAT_VEC3])      stream << "bool isOk (vec3 a, vec3 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n";
1812         if (cmpTypeFound[TYPE_FLOAT_VEC4])      stream << "bool isOk (vec4 a, vec4 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n";
1813
1814         if (cmpTypeFound[TYPE_FLOAT_MAT2])              stream << "bool isOk (mat2 a, mat2 b, float eps) { vec2 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return all(lessThanEqual(diff, vec2(eps))); }\n";
1815         if (cmpTypeFound[TYPE_FLOAT_MAT2X3])    stream << "bool isOk (mat2x3 a, mat2x3 b, float eps) { vec3 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return all(lessThanEqual(diff, vec3(eps))); }\n";
1816         if (cmpTypeFound[TYPE_FLOAT_MAT2X4])    stream << "bool isOk (mat2x4 a, mat2x4 b, float eps) { vec4 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return all(lessThanEqual(diff, vec4(eps))); }\n";
1817         if (cmpTypeFound[TYPE_FLOAT_MAT3X2])    stream << "bool isOk (mat3x2 a, mat3x2 b, float eps) { vec2 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), abs(a[2]-b[2])); return all(lessThanEqual(diff, vec2(eps))); }\n";
1818         if (cmpTypeFound[TYPE_FLOAT_MAT3])              stream << "bool isOk (mat3 a, mat3 b, float eps) { vec3 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), abs(a[2]-b[2])); return all(lessThanEqual(diff, vec3(eps))); }\n";
1819         if (cmpTypeFound[TYPE_FLOAT_MAT3X4])    stream << "bool isOk (mat3x4 a, mat3x4 b, float eps) { vec4 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), abs(a[2]-b[2])); return all(lessThanEqual(diff, vec4(eps))); }\n";
1820         if (cmpTypeFound[TYPE_FLOAT_MAT4X2])    stream << "bool isOk (mat4x2 a, mat4x2 b, float eps) { vec2 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec2(eps))); }\n";
1821         if (cmpTypeFound[TYPE_FLOAT_MAT4X3])    stream << "bool isOk (mat4x3 a, mat4x3 b, float eps) { vec3 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec3(eps))); }\n";
1822         if (cmpTypeFound[TYPE_FLOAT_MAT4])              stream << "bool isOk (mat4 a, mat4 b, float eps) { vec4 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec4(eps))); }\n";
1823 }
1824
1825 } // sl
1826 } // glu