external/openglcts/modules/common/glcShaderLibrary.cpp

   1 /*-------------------------------------------------------------------------
   2  * OpenGL Conformance Test Suite
   3  * -----------------------------
   4  *
   5  * Copyright (c) 2016 Google Inc.
   6  * Copyright (c) 2016 The Khronos Group Inc.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */ /*!
  21  * \file
  22  * \brief Compiler test case.
  23  */ /*-------------------------------------------------------------------*/
  24
  25 #include "glcShaderLibrary.hpp"
  26 #include "glcShaderLibraryCase.hpp"
  27 #include "gluShaderUtil.hpp"
  28 #include "tcuResource.hpp"
  29
  30 #include "deInt32.h"
  31
  32 #include <fstream>
  33 #include <sstream>
  34 #include <string>
  35 #include <vector>
  36
  37 #include <stdarg.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40
  41 using std::string;
  42 using std::vector;
  43 using std::ostringstream;
  44
  45 using namespace glu;
  46
  47 #if 0
  48 #define PARSE_DBG(X) printf X
  49 #else
  50 #define PARSE_DBG(X) DE_NULL_STATEMENT
  51 #endif
  52
  53 namespace deqp
  54 {
  55 namespace sl
  56 {
  57
  58 static const glu::GLSLVersion DEFAULT_GLSL_VERSION = glu::GLSL_VERSION_100_ES;
  59
  60 DE_INLINE deBool isWhitespace(char c)
  61 {
  62         return (c == ' ') || (c == '\t') || (c == '\r') || (c == '\n');
  63 }
  64
  65 DE_INLINE deBool isEOL(char c)
  66 {
  67         return (c == '\r') || (c == '\n');
  68 }
  69
  70 DE_INLINE deBool isNumeric(char c)
  71 {
  72         return deInRange32(c, '0', '9');
  73 }
  74
  75 DE_INLINE deBool isAlpha(char c)
  76 {
  77         return deInRange32(c, 'a', 'z') || deInRange32(c, 'A', 'Z');
  78 }
  79
  80 DE_INLINE deBool isCaseNameChar(char c)
  81 {
  82         return deInRange32(c, 'a', 'z') || deInRange32(c, 'A', 'Z') || deInRange32(c, '0', '9') || (c == '_') ||
  83                    (c == '-') || (c == '.');
  84 }
  85
  86 // \todo [2011-02-11 pyry] Should not depend on Context or TestContext!
  87 class ShaderParser
  88 {
  89 public:
  90         ShaderParser(tcu::TestContext& testCtx, RenderContext& renderCtx);
  91         ~ShaderParser(void);
  92
  93         vector<tcu::TestNode*> parse(const char* input);
  94
  95 private:
  96         enum Token
  97         {
  98                 TOKEN_INVALID = 0,
  99                 TOKEN_EOF,
 100                 TOKEN_STRING,
 101                 TOKEN_SHADER_SOURCE,
 102
 103                 TOKEN_INT_LITERAL,
 104                 TOKEN_FLOAT_LITERAL,
 105
 106                 // identifiers
 107                 TOKEN_IDENTIFIER,
 108                 TOKEN_TRUE,
 109                 TOKEN_FALSE,
 110                 TOKEN_DESC,
 111                 TOKEN_EXPECT,
 112                 TOKEN_GROUP,
 113                 TOKEN_CASE,
 114                 TOKEN_END,
 115                 TOKEN_VALUES,
 116                 TOKEN_BOTH,
 117                 TOKEN_VERTEX,
 118                 TOKEN_FRAGMENT,
 119                 TOKEN_UNIFORM,
 120                 TOKEN_INPUT,
 121                 TOKEN_OUTPUT,
 122                 TOKEN_FLOAT,
 123                 TOKEN_FLOAT_VEC2,
 124                 TOKEN_FLOAT_VEC3,
 125                 TOKEN_FLOAT_VEC4,
 126                 TOKEN_FLOAT_MAT2,
 127                 TOKEN_FLOAT_MAT2X3,
 128                 TOKEN_FLOAT_MAT2X4,
 129                 TOKEN_FLOAT_MAT3X2,
 130                 TOKEN_FLOAT_MAT3,
 131                 TOKEN_FLOAT_MAT3X4,
 132                 TOKEN_FLOAT_MAT4X2,
 133                 TOKEN_FLOAT_MAT4X3,
 134                 TOKEN_FLOAT_MAT4,
 135                 TOKEN_INT,
 136                 TOKEN_INT_VEC2,
 137                 TOKEN_INT_VEC3,
 138                 TOKEN_INT_VEC4,
 139                 TOKEN_UINT,
 140                 TOKEN_UINT_VEC2,
 141                 TOKEN_UINT_VEC3,
 142                 TOKEN_UINT_VEC4,
 143                 TOKEN_BOOL,
 144                 TOKEN_BOOL_VEC2,
 145                 TOKEN_BOOL_VEC3,
 146                 TOKEN_BOOL_VEC4,
 147                 TOKEN_VERSION,
 148
 149                 // symbols
 150                 TOKEN_ASSIGN,
 151                 TOKEN_PLUS,
 152                 TOKEN_MINUS,
 153                 TOKEN_COMMA,
 154                 TOKEN_VERTICAL_BAR,
 155                 TOKEN_SEMI_COLON,
 156                 TOKEN_LEFT_PAREN,
 157                 TOKEN_RIGHT_PAREN,
 158                 TOKEN_LEFT_BRACKET,
 159                 TOKEN_RIGHT_BRACKET,
 160                 TOKEN_LEFT_BRACE,
 161                 TOKEN_RIGHT_BRACE,
 162
 163                 TOKEN_LAST
 164         };
 165
 166         void parseError(const std::string& errorStr);
 167         float parseFloatLiteral(const char* str);
 168         long long int parseIntLiteral(const char* str);
 169         string parseStringLiteral(const char* str);
 170         string parseShaderSource(const char* str);
 171         void advanceToken(void);
 172         void advanceToken(Token assumed);
 173         void assumeToken(Token token);
 174         DataType mapDataTypeToken(Token token);
 175         const char* getTokenName(Token token);
 176
 177         void parseValueElement(DataType dataType, ShaderCase::Value& result);
 178         void parseValue(ShaderCase::ValueBlock& valueBlock);
 179         void parseValueBlock(ShaderCase::ValueBlock& valueBlock);
 180         void parseShaderCase(vector<tcu::TestNode*>& shaderNodeList);
 181         void parseShaderGroup(vector<tcu::TestNode*>& shaderNodeList);
 182
 183         // Member variables.
 184         tcu::TestContext& m_testCtx;
 185         RenderContext&  m_renderCtx;
 186         std::string               m_input;
 187         const char*               m_curPtr;
 188         Token                     m_curToken;
 189         std::string               m_curTokenStr;
 190 };
 191
 192 ShaderParser::ShaderParser(tcu::TestContext& testCtx, RenderContext& renderCtx)
 193         : m_testCtx(testCtx), m_renderCtx(renderCtx), m_curPtr(DE_NULL), m_curToken(TOKEN_LAST)
 194 {
 195 }
 196
 197 ShaderParser::~ShaderParser(void)
 198 {
 199         // nada
 200 }
 201
 202 void ShaderParser::parseError(const std::string& errorStr)
 203 {
 204         string atStr = string(m_curPtr, 80);
 205         throw tcu::InternalError((string("Parser error: ") + errorStr + " near '" + atStr + " ...'").c_str(), "", __FILE__,
 206                                                          __LINE__);
 207 }
 208
 209 float ShaderParser::parseFloatLiteral(const char* str)
 210 {
 211         return (float)atof(str);
 212 }
 213
 214 long long int ShaderParser::parseIntLiteral(const char* str)
 215 {
 216         return strtoll(str, NULL, 0);
 217 }
 218
 219 string ShaderParser::parseStringLiteral(const char* str)
 220 {
 221         const char*   p           = str;
 222         char              endChar = *p++;
 223         ostringstream o;
 224
 225         while (*p != endChar && *p)
 226         {
 227                 if (*p == '\\')
 228                 {
 229                         switch (p[1])
 230                         {
 231                         case 0:
 232                                 DE_ASSERT(DE_FALSE);
 233                                 break;
 234                         case 'n':
 235                                 o << '\n';
 236                                 break;
 237                         case 't':
 238                                 o << '\t';
 239                                 break;
 240                         default:
 241                                 o << p[1];
 242                                 break;
 243                         }
 244
 245                         p += 2;
 246                 }
 247                 else
 248                         o << *p++;
 249         }
 250
 251         return o.str();
 252 }
 253
 254 static string removeExtraIndentation(const string& source)
 255 {
 256         // Detect indentation from first line.
 257         int numIndentChars = 0;
 258         for (int ndx = 0; isWhitespace(source[ndx]) && ndx < (int)source.length(); ndx++)
 259                 numIndentChars += source[ndx] == '\t' ? 4 : 1;
 260
 261         // Process all lines and remove preceding indentation.
 262         ostringstream processed;
 263         {
 264                 bool atLineStart                = true;
 265                 int  indentCharsOmitted = 0;
 266
 267                 for (int pos = 0; pos < (int)source.length(); pos++)
 268                 {
 269                         char c = source[pos];
 270
 271                         if (atLineStart && indentCharsOmitted < numIndentChars && (c == ' ' || c == '\t'))
 272                         {
 273                                 indentCharsOmitted += c == '\t' ? 4 : 1;
 274                         }
 275                         else if (isEOL(c))
 276                         {
 277                                 if (source[pos] == '\r' && source[pos + 1] == '\n')
 278                                 {
 279                                         pos += 1;
 280                                         processed << '\n';
 281                                 }
 282                                 else
 283                                         processed << c;
 284
 285                                 atLineStart                = true;
 286                                 indentCharsOmitted = 0;
 287                         }
 288                         else
 289                         {
 290                                 processed << c;
 291                                 atLineStart = false;
 292                         }
 293                 }
 294         }
 295
 296         return processed.str();
 297 }
 298
 299 string ShaderParser::parseShaderSource(const char* str)
 300 {
 301         const char*   p = str + 2;
 302         ostringstream o;
 303
 304         // Eat first empty line from beginning.
 305         while (*p == ' ')
 306                 p++;
 307         while (isEOL(*p))
 308                 p++;
 309
 310         while ((p[0] != '"') || (p[1] != '"'))
 311         {
 312                 if (*p == '\\')
 313                 {
 314                         switch (p[1])
 315                         {
 316                         case 0:
 317                                 DE_ASSERT(DE_FALSE);
 318                                 break;
 319                         case 'n':
 320                                 o << '\n';
 321                                 break;
 322                         case 't':
 323                                 o << '\t';
 324                                 break;
 325                         default:
 326                                 o << p[1];
 327                                 break;
 328                         }
 329
 330                         p += 2;
 331                 }
 332                 else
 333                         o << *p++;
 334         }
 335
 336         return removeExtraIndentation(o.str());
 337 }
 338
 339 void ShaderParser::advanceToken(void)
 340 {
 341         // Skip old token.
 342         m_curPtr += m_curTokenStr.length();
 343
 344         // Reset token (for safety).
 345         m_curToken      = TOKEN_INVALID;
 346         m_curTokenStr = "";
 347
 348         // Eat whitespace & comments while they last.
 349         for (;;)
 350         {
 351                 while (isWhitespace(*m_curPtr))
 352                         m_curPtr++;
 353
 354                 // Check for EOL comment.
 355                 if (*m_curPtr == '#')
 356                 {
 357                         while (*m_curPtr && !isEOL(*m_curPtr))
 358                                 m_curPtr++;
 359                 }
 360                 else
 361                         break;
 362         }
 363
 364         if (!*m_curPtr)
 365         {
 366                 m_curToken      = TOKEN_EOF;
 367                 m_curTokenStr = "<EOF>";
 368         }
 369         else if (isAlpha(*m_curPtr))
 370         {
 371                 struct Named
 372                 {
 373                         const char* str;
 374                         Token           token;
 375                 };
 376
 377                 static const Named s_named[] = { { "true", TOKEN_TRUE },
 378                                                                                  { "false", TOKEN_FALSE },
 379                                                                                  { "desc", TOKEN_DESC },
 380                                                                                  { "expect", TOKEN_EXPECT },
 381                                                                                  { "group", TOKEN_GROUP },
 382                                                                                  { "case", TOKEN_CASE },
 383                                                                                  { "end", TOKEN_END },
 384                                                                                  { "values", TOKEN_VALUES },
 385                                                                                  { "both", TOKEN_BOTH },
 386                                                                                  { "vertex", TOKEN_VERTEX },
 387                                                                                  { "fragment", TOKEN_FRAGMENT },
 388                                                                                  { "uniform", TOKEN_UNIFORM },
 389                                                                                  { "input", TOKEN_INPUT },
 390                                                                                  { "output", TOKEN_OUTPUT },
 391                                                                                  { "float", TOKEN_FLOAT },
 392                                                                                  { "vec2", TOKEN_FLOAT_VEC2 },
 393                                                                                  { "vec3", TOKEN_FLOAT_VEC3 },
 394                                                                                  { "vec4", TOKEN_FLOAT_VEC4 },
 395                                                                                  { "mat2", TOKEN_FLOAT_MAT2 },
 396                                                                                  { "mat2x3", TOKEN_FLOAT_MAT2X3 },
 397                                                                                  { "mat2x4", TOKEN_FLOAT_MAT2X4 },
 398                                                                                  { "mat3x2", TOKEN_FLOAT_MAT3X2 },
 399                                                                                  { "mat3", TOKEN_FLOAT_MAT3 },
 400                                                                                  { "mat3x4", TOKEN_FLOAT_MAT3X4 },
 401                                                                                  { "mat4x2", TOKEN_FLOAT_MAT4X2 },
 402                                                                                  { "mat4x3", TOKEN_FLOAT_MAT4X3 },
 403                                                                                  { "mat4", TOKEN_FLOAT_MAT4 },
 404                                                                                  { "int", TOKEN_INT },
 405                                                                                  { "ivec2", TOKEN_INT_VEC2 },
 406                                                                                  { "ivec3", TOKEN_INT_VEC3 },
 407                                                                                  { "ivec4", TOKEN_INT_VEC4 },
 408                                                                                  { "uint", TOKEN_UINT },
 409                                                                                  { "uvec2", TOKEN_UINT_VEC2 },
 410                                                                                  { "uvec3", TOKEN_UINT_VEC3 },
 411                                                                                  { "uvec4", TOKEN_UINT_VEC4 },
 412                                                                                  { "bool", TOKEN_BOOL },
 413                                                                                  { "bvec2", TOKEN_BOOL_VEC2 },
 414                                                                                  { "bvec3", TOKEN_BOOL_VEC3 },
 415                                                                                  { "bvec4", TOKEN_BOOL_VEC4 },
 416                                                                                  { "version", TOKEN_VERSION } };
 417
 418                 const char* end = m_curPtr + 1;
 419                 while (isCaseNameChar(*end))
 420                         end++;
 421                 m_curTokenStr = string(m_curPtr, end - m_curPtr);
 422
 423                 m_curToken = TOKEN_IDENTIFIER;
 424
 425                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_named); ndx++)
 426                 {
 427                         if (m_curTokenStr == s_named[ndx].str)
 428                         {
 429                                 m_curToken = s_named[ndx].token;
 430                                 break;
 431                         }
 432                 }
 433         }
 434         else if (isNumeric(*m_curPtr))
 435         {
 436                 /* \todo [2010-03-31 petri] Hex? */
 437                 const char* p = m_curPtr;
 438                 while (isNumeric(*p))
 439                         p++;
 440                 if (*p == '.')
 441                 {
 442                         p++;
 443                         while (isNumeric(*p))
 444                                 p++;
 445
 446                         if (*p == 'e' || *p == 'E')
 447                         {
 448                                 p++;
 449                                 if (*p == '+' || *p == '-')
 450                                         p++;
 451                                 DE_ASSERT(isNumeric(*p));
 452                                 while (isNumeric(*p))
 453                                         p++;
 454                         }
 455
 456                         m_curToken      = TOKEN_FLOAT_LITERAL;
 457                         m_curTokenStr = string(m_curPtr, p - m_curPtr);
 458                 }
 459                 else
 460                 {
 461                         m_curToken      = TOKEN_INT_LITERAL;
 462                         m_curTokenStr = string(m_curPtr, p - m_curPtr);
 463                 }
 464         }
 465         else if (*m_curPtr == '"' && m_curPtr[1] == '"')
 466         {
 467                 const char* p = m_curPtr + 2;
 468
 469                 while ((p[0] != '"') || (p[1] != '"'))
 470                 {
 471                         DE_ASSERT(*p);
 472                         if (*p == '\\')
 473                         {
 474                                 DE_ASSERT(p[1] != 0);
 475                                 p += 2;
 476                         }
 477                         else
 478                                 p++;
 479                 }
 480                 p += 2;
 481
 482                 m_curToken      = TOKEN_SHADER_SOURCE;
 483                 m_curTokenStr = string(m_curPtr, (int)(p - m_curPtr));
 484         }
 485         else if (*m_curPtr == '"' || *m_curPtr == '\'')
 486         {
 487                 char            endChar = *m_curPtr;
 488                 const char* p           = m_curPtr + 1;
 489
 490                 while (*p != endChar)
 491                 {
 492                         DE_ASSERT(*p);
 493                         if (*p == '\\')
 494                         {
 495                                 DE_ASSERT(p[1] != 0);
 496                                 p += 2;
 497                         }
 498                         else
 499                                 p++;
 500                 }
 501                 p++;
 502
 503                 m_curToken      = TOKEN_STRING;
 504                 m_curTokenStr = string(m_curPtr, (int)(p - m_curPtr));
 505         }
 506         else
 507         {
 508                 struct SimpleToken
 509                 {
 510                         const char* str;
 511                         Token           token;
 512                 };
 513
 514                 static const SimpleToken s_simple[] = { { "=", TOKEN_ASSIGN },           { "+", TOKEN_PLUS },
 515                                                                                                 { "-", TOKEN_MINUS },            { ",", TOKEN_COMMA },
 516                                                                                                 { "|", TOKEN_VERTICAL_BAR }, { ";", TOKEN_SEMI_COLON },
 517                                                                                                 { "(", TOKEN_LEFT_PAREN },   { ")", TOKEN_RIGHT_PAREN },
 518                                                                                                 { "[", TOKEN_LEFT_BRACKET }, { "]", TOKEN_RIGHT_BRACKET },
 519                                                                                                 { "{", TOKEN_LEFT_BRACE },   { "}", TOKEN_RIGHT_BRACE } };
 520
 521                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_simple); ndx++)
 522                 {
 523                         if (strncmp(s_simple[ndx].str, m_curPtr, strlen(s_simple[ndx].str)) == 0)
 524                         {
 525                                 m_curToken      = s_simple[ndx].token;
 526                                 m_curTokenStr = s_simple[ndx].str;
 527                                 return;
 528                         }
 529                 }
 530
 531                 // Otherwise invalid token.
 532                 m_curToken      = TOKEN_INVALID;
 533                 m_curTokenStr = *m_curPtr;
 534         }
 535 }
 536
 537 void ShaderParser::advanceToken(Token assumed)
 538 {
 539         assumeToken(assumed);
 540         advanceToken();
 541 }
 542
 543 void ShaderParser::assumeToken(Token token)
 544 {
 545         if (m_curToken != token)
 546                 parseError(
 547                         (string("unexpected token '") + m_curTokenStr + "', expecting '" + getTokenName(token) + "'").c_str());
 548         DE_TEST_ASSERT(m_curToken == token);
 549 }
 550
 551 DataType ShaderParser::mapDataTypeToken(Token token)
 552 {
 553         switch (token)
 554         {
 555         case TOKEN_FLOAT:
 556                 return TYPE_FLOAT;
 557         case TOKEN_FLOAT_VEC2:
 558                 return TYPE_FLOAT_VEC2;
 559         case TOKEN_FLOAT_VEC3:
 560                 return TYPE_FLOAT_VEC3;
 561         case TOKEN_FLOAT_VEC4:
 562                 return TYPE_FLOAT_VEC4;
 563         case TOKEN_FLOAT_MAT2:
 564                 return TYPE_FLOAT_MAT2;
 565         case TOKEN_FLOAT_MAT2X3:
 566                 return TYPE_FLOAT_MAT2X3;
 567         case TOKEN_FLOAT_MAT2X4:
 568                 return TYPE_FLOAT_MAT2X4;
 569         case TOKEN_FLOAT_MAT3X2:
 570                 return TYPE_FLOAT_MAT3X2;
 571         case TOKEN_FLOAT_MAT3:
 572                 return TYPE_FLOAT_MAT3;
 573         case TOKEN_FLOAT_MAT3X4:
 574                 return TYPE_FLOAT_MAT3X4;
 575         case TOKEN_FLOAT_MAT4X2:
 576                 return TYPE_FLOAT_MAT4X2;
 577         case TOKEN_FLOAT_MAT4X3:
 578                 return TYPE_FLOAT_MAT4X3;
 579         case TOKEN_FLOAT_MAT4:
 580                 return TYPE_FLOAT_MAT4;
 581         case TOKEN_INT:
 582                 return TYPE_INT;
 583         case TOKEN_INT_VEC2:
 584                 return TYPE_INT_VEC2;
 585         case TOKEN_INT_VEC3:
 586                 return TYPE_INT_VEC3;
 587         case TOKEN_INT_VEC4:
 588                 return TYPE_INT_VEC4;
 589         case TOKEN_UINT:
 590                 return TYPE_UINT;
 591         case TOKEN_UINT_VEC2:
 592                 return TYPE_UINT_VEC2;
 593         case TOKEN_UINT_VEC3:
 594                 return TYPE_UINT_VEC3;
 595         case TOKEN_UINT_VEC4:
 596                 return TYPE_UINT_VEC4;
 597         case TOKEN_BOOL:
 598                 return TYPE_BOOL;
 599         case TOKEN_BOOL_VEC2:
 600                 return TYPE_BOOL_VEC2;
 601         case TOKEN_BOOL_VEC3:
 602                 return TYPE_BOOL_VEC3;
 603         case TOKEN_BOOL_VEC4:
 604                 return TYPE_BOOL_VEC4;
 605         default:
 606                 return TYPE_INVALID;
 607         }
 608 }
 609
 610 const char* ShaderParser::getTokenName(Token token)
 611 {
 612         switch (token)
 613         {
 614         case TOKEN_INVALID:
 615                 return "<invalid>";
 616         case TOKEN_EOF:
 617                 return "<eof>";
 618         case TOKEN_STRING:
 619                 return "<string>";
 620         case TOKEN_SHADER_SOURCE:
 621                 return "source";
 622
 623         case TOKEN_INT_LITERAL:
 624                 return "<int>";
 625         case TOKEN_FLOAT_LITERAL:
 626                 return "<float>";
 627
 628         // identifiers
 629         case TOKEN_IDENTIFIER:
 630                 return "<identifier>";
 631         case TOKEN_TRUE:
 632                 return "true";
 633         case TOKEN_FALSE:
 634                 return "false";
 635         case TOKEN_DESC:
 636                 return "desc";
 637         case TOKEN_EXPECT:
 638                 return "expect";
 639         case TOKEN_GROUP:
 640                 return "group";
 641         case TOKEN_CASE:
 642                 return "case";
 643         case TOKEN_END:
 644                 return "end";
 645         case TOKEN_VALUES:
 646                 return "values";
 647         case TOKEN_BOTH:
 648                 return "both";
 649         case TOKEN_VERTEX:
 650                 return "vertex";
 651         case TOKEN_FRAGMENT:
 652                 return "fragment";
 653         case TOKEN_UNIFORM:
 654                 return "uniform";
 655         case TOKEN_INPUT:
 656                 return "input";
 657         case TOKEN_OUTPUT:
 658                 return "output";
 659         case TOKEN_FLOAT:
 660                 return "float";
 661         case TOKEN_FLOAT_VEC2:
 662                 return "vec2";
 663         case TOKEN_FLOAT_VEC3:
 664                 return "vec3";
 665         case TOKEN_FLOAT_VEC4:
 666                 return "vec4";
 667         case TOKEN_FLOAT_MAT2:
 668                 return "mat2";
 669         case TOKEN_FLOAT_MAT2X3:
 670                 return "mat2x3";
 671         case TOKEN_FLOAT_MAT2X4:
 672                 return "mat2x4";
 673         case TOKEN_FLOAT_MAT3X2:
 674                 return "mat3x2";
 675         case TOKEN_FLOAT_MAT3:
 676                 return "mat3";
 677         case TOKEN_FLOAT_MAT3X4:
 678                 return "mat3x4";
 679         case TOKEN_FLOAT_MAT4X2:
 680                 return "mat4x2";
 681         case TOKEN_FLOAT_MAT4X3:
 682                 return "mat4x3";
 683         case TOKEN_FLOAT_MAT4:
 684                 return "mat4";
 685         case TOKEN_INT:
 686                 return "int";
 687         case TOKEN_INT_VEC2:
 688                 return "ivec2";
 689         case TOKEN_INT_VEC3:
 690                 return "ivec3";
 691         case TOKEN_INT_VEC4:
 692                 return "ivec4";
 693         case TOKEN_UINT:
 694                 return "uint";
 695         case TOKEN_UINT_VEC2:
 696                 return "uvec2";
 697         case TOKEN_UINT_VEC3:
 698                 return "uvec3";
 699         case TOKEN_UINT_VEC4:
 700                 return "uvec4";
 701         case TOKEN_BOOL:
 702                 return "bool";
 703         case TOKEN_BOOL_VEC2:
 704                 return "bvec2";
 705         case TOKEN_BOOL_VEC3:
 706                 return "bvec3";
 707         case TOKEN_BOOL_VEC4:
 708                 return "bvec4";
 709
 710         case TOKEN_ASSIGN:
 711                 return "=";
 712         case TOKEN_PLUS:
 713                 return "+";
 714         case TOKEN_MINUS:
 715                 return "-";
 716         case TOKEN_COMMA:
 717                 return ",";
 718         case TOKEN_VERTICAL_BAR:
 719                 return "|";
 720         case TOKEN_SEMI_COLON:
 721                 return ";";
 722         case TOKEN_LEFT_PAREN:
 723                 return "(";
 724         case TOKEN_RIGHT_PAREN:
 725                 return ")";
 726         case TOKEN_LEFT_BRACKET:
 727                 return "[";
 728         case TOKEN_RIGHT_BRACKET:
 729                 return "]";
 730         case TOKEN_LEFT_BRACE:
 731                 return "{";
 732         case TOKEN_RIGHT_BRACE:
 733                 return "}";
 734
 735         default:
 736                 return "<unknown>";
 737         }
 738 }
 739
 740 void ShaderParser::parseValueElement(DataType expectedDataType, ShaderCase::Value& result)
 741 {
 742         DataType scalarType = getDataTypeScalarType(expectedDataType);
 743         int              scalarSize = getDataTypeScalarSize(expectedDataType);
 744
 745         /* \todo [2010-04-19 petri] Support arrays. */
 746         ShaderCase::Value::Element elems[16];
 747
 748         if (scalarSize > 1)
 749         {
 750                 DE_ASSERT(mapDataTypeToken(m_curToken) == expectedDataType);
 751                 advanceToken(); // data type (float, vec2, etc.)
 752                 advanceToken(TOKEN_LEFT_PAREN);
 753         }
 754
 755         for (int scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++)
 756         {
 757                 if (scalarType == TYPE_FLOAT)
 758                 {
 759                         float signMult = 1.0f;
 760                         if (m_curToken == TOKEN_MINUS)
 761                         {
 762                                 signMult = -1.0f;
 763                                 advanceToken();
 764                         }
 765
 766                         assumeToken(TOKEN_FLOAT_LITERAL);
 767                         elems[scalarNdx].float32 = signMult * parseFloatLiteral(m_curTokenStr.c_str());
 768                         advanceToken(TOKEN_FLOAT_LITERAL);
 769                 }
 770                 else if (scalarType == TYPE_INT || scalarType == TYPE_UINT)
 771                 {
 772                         int signMult = 1;
 773                         if (m_curToken == TOKEN_MINUS)
 774                         {
 775                                 signMult = -1;
 776                                 advanceToken();
 777                         }
 778
 779                         assumeToken(TOKEN_INT_LITERAL);
 780                         elems[scalarNdx].int32 = signMult * parseIntLiteral(m_curTokenStr.c_str());
 781                         advanceToken(TOKEN_INT_LITERAL);
 782                 }
 783                 else
 784                 {
 785                         DE_ASSERT(scalarType == TYPE_BOOL);
 786                         elems[scalarNdx].bool32 = (m_curToken == TOKEN_TRUE);
 787                         if (m_curToken != TOKEN_TRUE && m_curToken != TOKEN_FALSE)
 788                                 parseError(string("unexpected token, expecting bool: " + m_curTokenStr));
 789                         advanceToken(); // true/false
 790                 }
 791
 792                 if (scalarNdx != (scalarSize - 1))
 793                         advanceToken(TOKEN_COMMA);
 794         }
 795
 796         if (scalarSize > 1)
 797                 advanceToken(TOKEN_RIGHT_PAREN);
 798
 799         // Store results.
 800         for (int scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++)
 801                 result.elements.push_back(elems[scalarNdx]);
 802 }
 803
 804 void ShaderParser::parseValue(ShaderCase::ValueBlock& valueBlock)
 805 {
 806         PARSE_DBG(("      parseValue()\n"));
 807
 808         // Parsed results.
 809         ShaderCase::Value result;
 810
 811         // Parse storage.
 812         if (m_curToken == TOKEN_UNIFORM)
 813                 result.storageType = ShaderCase::Value::STORAGE_UNIFORM;
 814         else if (m_curToken == TOKEN_INPUT)
 815                 result.storageType = ShaderCase::Value::STORAGE_INPUT;
 816         else if (m_curToken == TOKEN_OUTPUT)
 817                 result.storageType = ShaderCase::Value::STORAGE_OUTPUT;
 818         else
 819                 parseError(string("unexpected token encountered when parsing value classifier"));
 820         advanceToken();
 821
 822         // Parse data type.
 823         result.dataType = mapDataTypeToken(m_curToken);
 824         if (result.dataType == TYPE_INVALID)
 825                 parseError(string("unexpected token when parsing value data type: " + m_curTokenStr));
 826         advanceToken();
 827
 828         // Parse value name.
 829         if (m_curToken == TOKEN_IDENTIFIER || m_curToken == TOKEN_STRING)
 830         {
 831                 if (m_curToken == TOKEN_IDENTIFIER)
 832                         result.valueName = m_curTokenStr;
 833                 else
 834                         result.valueName = parseStringLiteral(m_curTokenStr.c_str());
 835         }
 836         else
 837                 parseError(string("unexpected token when parsing value name: " + m_curTokenStr));
 838         advanceToken();
 839
 840         // Parse assignment operator.
 841         advanceToken(TOKEN_ASSIGN);
 842
 843         // Parse actual value.
 844         if (m_curToken == TOKEN_LEFT_BRACKET) // value list
 845         {
 846                 advanceToken(TOKEN_LEFT_BRACKET);
 847                 result.arrayLength = 0;
 848
 849                 for (;;)
 850                 {
 851                         parseValueElement(result.dataType, result);
 852                         result.arrayLength++;
 853
 854                         if (m_curToken == TOKEN_RIGHT_BRACKET)
 855                                 break;
 856                         else if (m_curToken == TOKEN_VERTICAL_BAR)
 857                         {
 858                                 advanceToken();
 859                                 continue;
 860                         }
 861                         else
 862                                 parseError(string("unexpected token in value element array: " + m_curTokenStr));
 863                 }
 864
 865                 advanceToken(TOKEN_RIGHT_BRACKET);
 866         }
 867         else // arrays, single elements
 868         {
 869                 parseValueElement(result.dataType, result);
 870                 result.arrayLength = 1;
 871         }
 872
 873         advanceToken(TOKEN_SEMI_COLON); // end of declaration
 874
 875         valueBlock.values.push_back(result);
 876 }
 877
 878 void ShaderParser::parseValueBlock(ShaderCase::ValueBlock& valueBlock)
 879 {
 880         PARSE_DBG(("    parseValueBlock()\n"));
 881         advanceToken(TOKEN_VALUES);
 882         advanceToken(TOKEN_LEFT_BRACE);
 883
 884         for (;;)
 885         {
 886                 if (m_curToken == TOKEN_UNIFORM || m_curToken == TOKEN_INPUT || m_curToken == TOKEN_OUTPUT)
 887                         parseValue(valueBlock);
 888                 else if (m_curToken == TOKEN_RIGHT_BRACE)
 889                         break;
 890                 else
 891                         parseError(string("unexpected token when parsing a value block: " + m_curTokenStr));
 892         }
 893
 894         advanceToken(TOKEN_RIGHT_BRACE);
 895
 896         // Compute combined array length of value block.
 897         int arrayLength = 1;
 898         for (int valueNdx = 0; valueNdx < (int)valueBlock.values.size(); valueNdx++)
 899         {
 900                 const ShaderCase::Value& val = valueBlock.values[valueNdx];
 901                 if (val.arrayLength > 1)
 902                 {
 903                         DE_ASSERT(arrayLength == 1 || arrayLength == val.arrayLength);
 904                         arrayLength = val.arrayLength;
 905                 }
 906         }
 907         valueBlock.arrayLength = arrayLength;
 908 }
 909
 910 void ShaderParser::parseShaderCase(vector<tcu::TestNode*>& shaderNodeList)
 911 {
 912         // Parse 'case'.
 913         PARSE_DBG(("  parseShaderCase()\n"));
 914         advanceToken(TOKEN_CASE);
 915
 916         // Parse case name.
 917         string caseName = m_curTokenStr;
 918         advanceToken(); // \note [pyry] All token types are allowed here.
 919
 920         // Setup case.
 921         vector<ShaderCase::ValueBlock> valueBlockList;
 922
 923         GLSLVersion                              version          = DEFAULT_GLSL_VERSION;
 924         ShaderCase::ExpectResult expectResult = ShaderCase::EXPECT_PASS;
 925         string                                   description;
 926         string                                   bothSource;
 927         string                                   vertexSource;
 928         string                                   fragmentSource;
 929
 930         for (;;)
 931         {
 932                 if (m_curToken == TOKEN_END)
 933                         break;
 934                 else if (m_curToken == TOKEN_DESC)
 935                 {
 936                         advanceToken();
 937                         assumeToken(TOKEN_STRING);
 938
 939                         description = parseStringLiteral(m_curTokenStr.c_str());
 940                         advanceToken();
 941                 }
 942                 else if (m_curToken == TOKEN_EXPECT)
 943                 {
 944                         advanceToken();
 945                         assumeToken(TOKEN_IDENTIFIER);
 946
 947                         if (m_curTokenStr == "pass")
 948                                 expectResult = ShaderCase::EXPECT_PASS;
 949                         else if (m_curTokenStr == "compile_fail")
 950                                 expectResult = ShaderCase::EXPECT_COMPILE_FAIL;
 951                         else if (m_curTokenStr == "link_fail")
 952                                 expectResult = ShaderCase::EXPECT_LINK_FAIL;
 953                         else
 954                                 parseError(string("invalid expected result value: " + m_curTokenStr));
 955
 956                         advanceToken();
 957                 }
 958                 else if (m_curToken == TOKEN_VALUES)
 959                 {
 960                         ShaderCase::ValueBlock block;
 961                         parseValueBlock(block);
 962                         valueBlockList.push_back(block);
 963                 }
 964                 else if (m_curToken == TOKEN_BOTH || m_curToken == TOKEN_VERTEX || m_curToken == TOKEN_FRAGMENT)
 965                 {
 966                         Token token = m_curToken;
 967                         advanceToken();
 968                         assumeToken(TOKEN_SHADER_SOURCE);
 969                         string source = parseShaderSource(m_curTokenStr.c_str());
 970                         advanceToken();
 971                         if (token == TOKEN_BOTH)
 972                                 bothSource = source;
 973                         else if (token == TOKEN_VERTEX)
 974                                 vertexSource = source;
 975                         else if (token == TOKEN_FRAGMENT)
 976                                 fragmentSource = source;
 977                         else
 978                                 DE_ASSERT(DE_FALSE);
 979                 }
 980                 else if (m_curToken == TOKEN_VERSION)
 981                 {
 982                         advanceToken();
 983
 984                         int                     versionNum = 0;
 985                         std::string postfix     = "";
 986
 987                         assumeToken(TOKEN_INT_LITERAL);
 988                         versionNum = parseIntLiteral(m_curTokenStr.c_str());
 989                         advanceToken();
 990
 991                         if (m_curToken == TOKEN_IDENTIFIER)
 992                         {
 993                                 postfix = m_curTokenStr;
 994                                 advanceToken();
 995                         }
 996
 997                         if (versionNum == 100 && postfix == "es")
 998                                 version = glu::GLSL_VERSION_100_ES;
 999                         else if (versionNum == 300 && postfix == "es")
1000                                 version = glu::GLSL_VERSION_300_ES;
1001                         else if (versionNum == 310 && postfix == "es")
1002                                 version = glu::GLSL_VERSION_310_ES;
1003                         else if (versionNum == 130)
1004                                 version = glu::GLSL_VERSION_130;
1005                         else if (versionNum == 140)
1006                                 version = glu::GLSL_VERSION_140;
1007                         else if (versionNum == 150)
1008                                 version = glu::GLSL_VERSION_150;
1009                         else if (versionNum == 330)
1010                                 version = glu::GLSL_VERSION_330;
1011                         else if (versionNum == 400)
1012                                 version = glu::GLSL_VERSION_400;
1013                         else if (versionNum == 410)
1014                                 version = glu::GLSL_VERSION_410;
1015                         else if (versionNum == 420)
1016                                 version = glu::GLSL_VERSION_420;
1017                         else if (versionNum == 430)
1018                                 version = glu::GLSL_VERSION_430;
1019                         else if (versionNum == 440)
1020                                 version = glu::GLSL_VERSION_440;
1021                         else if (versionNum == 450)
1022                                 version = glu::GLSL_VERSION_450;
1023                         else
1024                                 parseError("Unknown GLSL version");
1025                 }
1026                 else
1027                         parseError(string("unexpected token while parsing shader case: " + m_curTokenStr));
1028         }
1029
1030         advanceToken(TOKEN_END); // case end
1031
1032         if (bothSource.length() > 0)
1033         {
1034                 DE_ASSERT(vertexSource.length() == 0);
1035                 DE_ASSERT(fragmentSource.length() == 0);
1036
1037                 string vertName = caseName + "_vertex";
1038                 string fragName = caseName + "_fragment";
1039                 shaderNodeList.push_back(new ShaderCase(m_testCtx, m_renderCtx, vertName.c_str(), description.c_str(),
1040                                                                                                 expectResult, valueBlockList, version, bothSource.c_str(), DE_NULL));
1041                 shaderNodeList.push_back(new ShaderCase(m_testCtx, m_renderCtx, fragName.c_str(), description.c_str(),
1042                                                                                                 expectResult, valueBlockList, version, DE_NULL, bothSource.c_str()));
1043         }
1044         else
1045         {
1046                 shaderNodeList.push_back(new ShaderCase(m_testCtx, m_renderCtx, caseName.c_str(), description.c_str(),
1047                                                                                                 expectResult, valueBlockList, version, vertexSource.c_str(),
1048                                                                                                 fragmentSource.c_str()));
1049         }
1050 }
1051
1052 void ShaderParser::parseShaderGroup(vector<tcu::TestNode*>& shaderNodeList)
1053 {
1054         // Parse 'case'.
1055         PARSE_DBG(("  parseShaderGroup()\n"));
1056         advanceToken(TOKEN_GROUP);
1057
1058         // Parse case name.
1059         string name = m_curTokenStr;
1060         advanceToken(); // \note [pyry] We don't want to check token type here (for instance to allow "uniform") group.
1061
1062         // Parse description.
1063         assumeToken(TOKEN_STRING);
1064         string description = parseStringLiteral(m_curTokenStr.c_str());
1065         advanceToken(TOKEN_STRING);
1066
1067         std::vector<tcu::TestNode*> children;
1068
1069         // Parse group children.
1070         for (;;)
1071         {
1072                 if (m_curToken == TOKEN_END)
1073                         break;
1074                 else if (m_curToken == TOKEN_GROUP)
1075                         parseShaderGroup(children);
1076                 else if (m_curToken == TOKEN_CASE)
1077                         parseShaderCase(children);
1078                 else
1079                         parseError(string("unexpected token while parsing shader group: " + m_curTokenStr));
1080         }
1081
1082         advanceToken(TOKEN_END); // group end
1083
1084         // Create group node.
1085         tcu::TestCaseGroup* groupNode = new tcu::TestCaseGroup(m_testCtx, name.c_str(), description.c_str(), children);
1086         shaderNodeList.push_back(groupNode);
1087 }
1088
1089 vector<tcu::TestNode*> ShaderParser::parse(const char* input)
1090 {
1091         // Initialize parser.
1092         m_input           = input;
1093         m_curPtr          = m_input.c_str();
1094         m_curToken      = TOKEN_INVALID;
1095         m_curTokenStr = "";
1096         advanceToken();
1097
1098         vector<tcu::TestNode*> nodeList;
1099
1100         // Parse all cases.
1101         PARSE_DBG(("parse()\n"));
1102         for (;;)
1103         {
1104                 if (m_curToken == TOKEN_CASE)
1105                         parseShaderCase(nodeList);
1106                 else if (m_curToken == TOKEN_GROUP)
1107                         parseShaderGroup(nodeList);
1108                 else if (m_curToken == TOKEN_EOF)
1109                         break;
1110                 else
1111                         parseError(string("invalid token encountered at main level: '") + m_curTokenStr + "'");
1112         }
1113
1114         assumeToken(TOKEN_EOF);
1115         //  printf("  parsed %d test cases.\n", caseList.size());
1116         return nodeList;
1117 }
1118
1119 } // sl
1120
1121 ShaderLibrary::ShaderLibrary(tcu::TestContext& testCtx, RenderContext& renderCtx)
1122         : m_testCtx(testCtx), m_renderCtx(renderCtx)
1123 {
1124 }
1125
1126 ShaderLibrary::~ShaderLibrary(void)
1127 {
1128 }
1129
1130 vector<tcu::TestNode*> ShaderLibrary::loadShaderFile(const char* fileName)
1131 {
1132         tcu::Resource*  resource = m_testCtx.getArchive().getResource(fileName);
1133         std::vector<char> buf;
1134
1135         /*  printf("  loading '%s'\n", fileName);*/
1136
1137         try
1138         {
1139                 int size = resource->getSize();
1140                 buf.resize(size + 1);
1141                 resource->read((deUint8*)&buf[0], size);
1142                 buf[size] = '\0';
1143         }
1144         catch (const std::exception&)
1145         {
1146                 delete resource;
1147                 throw;
1148         }
1149
1150         delete resource;
1151
1152         sl::ShaderParser           parser(m_testCtx, m_renderCtx);
1153         vector<tcu::TestNode*> nodes = parser.parse(&buf[0]);
1154
1155         return nodes;
1156 }
1157
1158 // ShaderLibraryGroup
1159
1160 ShaderLibraryGroup::ShaderLibraryGroup(Context& context, const char* name, const char* description,
1161                                                                            const char* filename)
1162         : TestCaseGroup(context, name, description), m_filename(filename)
1163 {
1164 }
1165
1166 ShaderLibraryGroup::~ShaderLibraryGroup(void)
1167 {
1168 }
1169
1170 void ShaderLibraryGroup::init(void)
1171 {
1172         deqp::ShaderLibrary                     shaderLibrary(m_testCtx, m_context.getRenderContext());
1173         std::vector<tcu::TestNode*> children = shaderLibrary.loadShaderFile(m_filename.c_str());
1174
1175         for (int i = 0; i < (int)children.size(); i++)
1176                 addChild(children[i]);
1177 }
1178
1179 } // deqp