| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES Utilities |
| * ------------------------------------------------ |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| 'use strict'; |
| goog.provide('modules.shared.glsShaderLibrary'); |
| goog.require('framework.common.tcuTestCase'); |
| goog.require('framework.opengl.gluShaderUtil'); |
| goog.require('modules.shared.glsShaderLibraryCase'); |
| |
| goog.scope(function() { |
| |
| var glsShaderLibrary = modules.shared.glsShaderLibrary; |
| var tcuTestCase = framework.common.tcuTestCase; |
| var glsShaderLibraryCase = modules.shared.glsShaderLibraryCase; |
| var gluShaderUtil = framework.opengl.gluShaderUtil; |
| |
| glsShaderLibrary.generateTestCases = function() { |
| /** @type {glsShaderLibrary.Parser} */ var parser = new glsShaderLibrary.Parser(); |
| try { |
| /** @type {Object} */ var state = tcuTestCase.runner; |
| var tree = parser.parse(state.testFile); |
| var rootTest = tcuTestCase.newTest(state.testName, 'Top level'); |
| rootTest.setChildren(tree); |
| state.setRoot(rootTest); |
| } |
| catch (err) { |
| bufferedLogToConsole(err); |
| testFailed('Failed to parse shader test case file'); |
| return false; |
| } |
| return true; |
| }; |
| |
| glsShaderLibrary.processTestFile = function() { |
| if (glsShaderLibrary.generateTestCases()) { |
| tcuTestCase.runner.runCallback(glsShaderLibraryCase.runTestCases); |
| } else { |
| tcuTestCase.runner.terminate(); |
| } |
| }; |
| |
| glsShaderLibrary.isWhitespace = function(value) { |
| return /^[ \t\r\n]+$/.test(value); |
| }; |
| glsShaderLibrary.isEOL = function(value) { |
| return /^[\r\n]+$/.test(value); |
| }; |
| glsShaderLibrary.isAlpha = function(value) { |
| return /^[a-zA-Z]$/.test(value); |
| }; |
| glsShaderLibrary.isNumeric = function(value) { |
| return /^[0-9]$/.test(value); |
| }; |
| glsShaderLibrary.isCaseNameChar = function(value) { |
| return /^[a-zA-Z0-9_\-\.]$/.test(value); |
| }; |
| |
| /** |
| * Removes however many indents there are on the first line from all lines. |
| * @param {string} str |
| * @return {string} output |
| */ |
| glsShaderLibrary.removeExtraIndentation = function(str) { |
| return glsShaderLibrary.removeExtraIndentationArray( |
| str.split(/\r\n|\r|\n/) |
| ).join('\n'); |
| }; |
| |
| /** |
| * Returns an array of strings without indentation. |
| * @param {Array<string>} arr |
| * @return {Array<string>} output |
| */ |
| glsShaderLibrary.removeExtraIndentationArray = function(arr) { |
| /** @type {Array<string>} */ var output = []; |
| |
| if (arr.length) { |
| |
| /** @type {number} */ var numIndentChars = 0; |
| for (var i = 0; i < arr[0].length && glsShaderLibrary.isWhitespace(arr[0].charAt(i)); ++i) { |
| numIndentChars += arr[0].charAt(i) === '\t' ? 4 : 1; |
| } |
| |
| for (var i = 0; i < arr.length; ++i) { |
| /** @type {number} */ var removed = 0; |
| /** @type {number} */ var j; |
| // Some tests are indented inconsistently, so we have to check for non-whitespace characters here. |
| for (j = 0; removed < numIndentChars && j < arr[i].length && glsShaderLibrary.isWhitespace(arr[i].charAt(j)); ++j) { |
| removed += (arr[i].charAt(j) === '\t' ? 4 : 1); |
| } |
| |
| output.push(arr[i].substr(j, arr[i].length - j)); |
| } |
| |
| } |
| |
| return output; |
| }; |
| |
| glsShaderLibrary.de_assert = function(condition) { |
| if (!condition) { |
| throw Error(); |
| } |
| }; |
| |
| /** |
| * @param {string} str |
| * @param {string} endstr end of string character |
| * @param {boolean=} trimFront trim leading whitespace |
| * @return {string} str |
| * @private |
| */ |
| glsShaderLibrary.parseStringLiteralHelper = function(str, endstr, trimFront) { |
| trimFront = trimFront || false; |
| |
| /** @type {number} */ var index_end = 0; |
| // isolate the string |
| do { |
| index_end = str.indexOf(endstr, index_end + 1); |
| } while (index_end >= 0 && str.charAt(index_end - 1) === '\\'); |
| |
| if (index_end <= 0) { |
| index_end = str.length; |
| } |
| |
| // strip quotes, replace \n and \t with nl and tabs respectively |
| str = str.substr(endstr.length, index_end - endstr.length); |
| if (trimFront) |
| str = str.replace(/^\s*\n/, ''); |
| var result = ''; |
| var i = 0; |
| while (str[i] != undefined) { |
| if (str[i] == '\\') { |
| switch (str[i + 1]) { |
| case undefined: |
| break; |
| case 'n': |
| result += '\n'; |
| break; |
| case 't': |
| result += '\t'; |
| break; |
| default: |
| result += str[i + 1]; |
| break; |
| } |
| i += 2; |
| } else { |
| result += str[i]; |
| i++; |
| } |
| } |
| return result; |
| |
| }; |
| |
| /** |
| * glsShaderLibrary.Parser class |
| * @constructor |
| */ |
| glsShaderLibrary.Parser = function() { |
| |
| /* data members */ |
| |
| /** |
| * The Token constants |
| * @enum {number} |
| */ |
| var Token = { |
| TOKEN_INVALID: 0, |
| TOKEN_EOF: 1, |
| TOKEN_STRING: 2, |
| TOKEN_SHADER_SOURCE: 3, |
| |
| TOKEN_INT_LITERAL: 4, |
| TOKEN_FLOAT_LITERAL: 5, |
| |
| // identifiers |
| TOKEN_IDENTIFIER: 6, |
| TOKEN_TRUE: 7, |
| TOKEN_FALSE: 8, |
| TOKEN_DESC: 9, |
| TOKEN_EXPECT: 10, |
| TOKEN_GROUP: 11, |
| TOKEN_CASE: 12, |
| TOKEN_END: 13, |
| TOKEN_VALUES: 14, |
| TOKEN_BOTH: 15, |
| TOKEN_VERTEX: 26, |
| TOKEN_FRAGMENT: 17, |
| TOKEN_UNIFORM: 18, |
| TOKEN_INPUT: 19, |
| TOKEN_OUTPUT: 20, |
| TOKEN_FLOAT: 21, |
| TOKEN_FLOAT_VEC2: 22, |
| TOKEN_FLOAT_VEC3: 23, |
| TOKEN_FLOAT_VEC4: 24, |
| TOKEN_FLOAT_MAT2: 25, |
| TOKEN_FLOAT_MAT2X3: 26, |
| TOKEN_FLOAT_MAT2X4: 27, |
| TOKEN_FLOAT_MAT3X2: 28, |
| TOKEN_FLOAT_MAT3: 29, |
| TOKEN_FLOAT_MAT3X4: 30, |
| TOKEN_FLOAT_MAT4X2: 31, |
| TOKEN_FLOAT_MAT4X3: 32, |
| TOKEN_FLOAT_MAT4: 33, |
| TOKEN_INT: 34, |
| TOKEN_INT_VEC2: 35, |
| TOKEN_INT_VEC3: 36, |
| TOKEN_INT_VEC4: 37, |
| TOKEN_UINT: 38, |
| TOKEN_UINT_VEC2: 39, |
| TOKEN_UINT_VEC3: 40, |
| TOKEN_UINT_VEC4: 41, |
| TOKEN_BOOL: 42, |
| TOKEN_BOOL_VEC2: 43, |
| TOKEN_BOOL_VEC3: 44, |
| TOKEN_BOOL_VEC4: 45, |
| TOKEN_VERSION: 46, |
| |
| // symbols |
| TOKEN_ASSIGN: 47, |
| TOKEN_PLUS: 48, |
| TOKEN_MINUS: 49, |
| TOKEN_COMMA: 50, |
| TOKEN_VERTICAL_BAR: 51, |
| TOKEN_SEMI_COLON: 52, |
| TOKEN_LEFT_PAREN: 53, |
| TOKEN_RIGHT_PAREN: 54, |
| TOKEN_LEFT_BRACKET: 55, |
| TOKEN_RIGHT_BRACKET: 56, |
| TOKEN_LEFT_BRACE: 57, |
| TOKEN_RIGHT_BRACE: 58, |
| |
| TOKEN_LAST: 59 |
| }; |
| |
| /** @type {string} */ var m_input = ''; |
| /** @type {number} */ var m_curPtr = 0; |
| /** @type {number} */ var m_curToken;// = Token.TOKEN_INVALID; |
| /** @type {string} */ var m_curTokenStr = ''; |
| |
| /* function members */ |
| this.parse = function(input) { |
| |
| // initialise parser |
| m_input = input; |
| m_curPtr = 0; |
| m_curToken = Token.TOKEN_INVALID; |
| m_curTokenStr = ''; |
| advanceToken(); |
| |
| /** @type {Array<tcuTestCase.DeqpTest>} */ var nodeList = []; |
| |
| for (;;) { |
| |
| if (m_curToken === Token.TOKEN_CASE) { |
| parseShaderCase(nodeList); |
| } else if (m_curToken === Token.TOKEN_GROUP) { |
| parseShaderGroup(nodeList); |
| } else if (m_curToken === Token.TOKEN_EOF) { |
| break; |
| } else { |
| // throw Error("invalid token encountered at main level: '" + m_curTokenStr + "'"); |
| testFailed("invalid token encountered at main level: '" + m_curTokenStr + "'"); |
| tcuTestCase.runner.terminate(); |
| } |
| |
| } |
| |
| return nodeList; |
| |
| }; |
| |
| /** |
| * ensures that the token exists |
| * otherwise it returns the corresponding token's name depending on enum number value |
| * @param {number} id |
| * @return {string} name |
| */ |
| var resolveTokenName = function(id) { |
| for (var name in Token) { |
| if (Token[name] === id) return name; |
| } |
| return 'TOKEN_UNKNOWN'; |
| }; |
| |
| /** |
| * Throws an error which contains the passed string |
| * @param {string} errorStr that contains an error to notify |
| * @return {string} error |
| */ |
| var parseError = function(errorStr) { |
| // abort |
| throw 'glsShaderLibrary.Parser error: ' + errorStr + ' near ' + m_input.substr(m_curPtr, m_curPtr + 80); |
| }; |
| |
| /** |
| * Converts string into float |
| * @param {string} str |
| * @return {number} |
| */ |
| var parseFloatLiteral = function(str) { |
| return parseFloat(str); |
| }; |
| |
| /** |
| * Converts string into integer |
| * @param {string} str |
| * @return {number} |
| */ |
| var parseIntLiteral = function(str) { |
| return parseInt(str, 10); |
| }; |
| var parseStringLiteral = function(str) { |
| /** |
| * @type {string} |
| * find delimitor |
| */ var endchar = str.substr(0, 1); |
| return glsShaderLibrary.parseStringLiteralHelper(str, endchar); |
| }; |
| var parseShaderSource = function(str) { |
| // similar to parse literal, delimitors are two double quotes ("") |
| return glsShaderLibrary.removeExtraIndentation( |
| glsShaderLibrary.parseStringLiteralHelper(str, '""', true) |
| ); |
| }; |
| |
| var advanceTokenWorker = function() { |
| |
| // Skip old token |
| m_curPtr += m_curTokenStr.length; |
| |
| // Reset token (for safety). |
| m_curToken = Token.TOKEN_INVALID; |
| m_curTokenStr = ''; |
| |
| // Eat whitespace & comments while they last. |
| for (;;) { |
| |
| while (glsShaderLibrary.isWhitespace(m_input.charAt(m_curPtr))) ++m_curPtr; |
| |
| // check for EOL comment |
| if (m_input.charAt(m_curPtr) === '#') { |
| // if m_input is to be an array of lines then this probably wont work very well |
| while ( |
| m_curPtr < m_input.length && |
| !glsShaderLibrary.isEOL(m_input.charAt(m_curPtr)) |
| ) ++m_curPtr; |
| } else { |
| break; |
| } |
| |
| } |
| |
| if (m_curPtr >= m_input.length) { |
| |
| m_curToken = Token.TOKEN_EOF; |
| m_curTokenStr = '<EOF>'; |
| |
| } else if (glsShaderLibrary.isAlpha(m_input.charAt(m_curPtr))) { |
| |
| /** @type {number} */ var end = m_curPtr + 1; |
| while (glsShaderLibrary.isCaseNameChar(m_input.charAt(end))) ++end; |
| |
| m_curTokenStr = m_input.substr(m_curPtr, end - m_curPtr); |
| |
| m_curToken = (function() { |
| // consider reimplementing with a binary search |
| switch (m_curTokenStr) { |
| case 'true': return Token.TOKEN_TRUE; |
| case 'false': return Token.TOKEN_FALSE; |
| case 'desc': return Token.TOKEN_DESC; |
| case 'expect': return Token.TOKEN_EXPECT; |
| case 'group': return Token.TOKEN_GROUP; |
| case 'case': return Token.TOKEN_CASE; |
| case 'end': return Token.TOKEN_END; |
| case 'values': return Token.TOKEN_VALUES; |
| case 'both': return Token.TOKEN_BOTH; |
| case 'vertex': return Token.TOKEN_VERTEX; |
| case 'fragment': return Token.TOKEN_FRAGMENT; |
| case 'uniform': return Token.TOKEN_UNIFORM; |
| case 'input': return Token.TOKEN_INPUT; |
| case 'output': return Token.TOKEN_OUTPUT; |
| case 'float': return Token.TOKEN_FLOAT; |
| case 'vec2': return Token.TOKEN_FLOAT_VEC2; |
| case 'vec3': return Token.TOKEN_FLOAT_VEC3; |
| case 'vec4': return Token.TOKEN_FLOAT_VEC4; |
| case 'mat2': return Token.TOKEN_FLOAT_MAT2; |
| case 'mat2x3': return Token.TOKEN_FLOAT_MAT2X3; |
| case 'mat2x4': return Token.TOKEN_FLOAT_MAT2X4; |
| case 'mat3x2': return Token.TOKEN_FLOAT_MAT3X2; |
| case 'mat3': return Token.TOKEN_FLOAT_MAT3; |
| case 'mat3x4': return Token.TOKEN_FLOAT_MAT3X4; |
| case 'mat4x2': return Token.TOKEN_FLOAT_MAT4X2; |
| case 'mat4x3': return Token.TOKEN_FLOAT_MAT4X3; |
| case 'mat4': return Token.TOKEN_FLOAT_MAT4; |
| case 'int': return Token.TOKEN_INT; |
| case 'ivec2': return Token.TOKEN_INT_VEC2; |
| case 'ivec3': return Token.TOKEN_INT_VEC3; |
| case 'ivec4': return Token.TOKEN_INT_VEC4; |
| case 'uint': return Token.TOKEN_UINT; |
| case 'uvec2': return Token.TOKEN_UINT_VEC2; |
| case 'uvec3': return Token.TOKEN_UINT_VEC3; |
| case 'uvec4': return Token.TOKEN_UINT_VEC4; |
| case 'bool': return Token.TOKEN_BOOL; |
| case 'bvec2': return Token.TOKEN_BOOL_VEC2; |
| case 'bvec3': return Token.TOKEN_BOOL_VEC3; |
| case 'bvec4': return Token.TOKEN_BOOL_VEC4; |
| case 'version': return Token.TOKEN_VERSION; |
| default: return Token.TOKEN_IDENTIFIER; |
| } |
| }()); |
| |
| } else if (glsShaderLibrary.isNumeric(m_input.charAt(m_curPtr))) { |
| |
| /** @type {number} */ var p = m_curPtr; |
| while (glsShaderLibrary.isNumeric(m_input.charAt(p))) ++p; |
| |
| if (m_input.charAt(p) === '.') { // float |
| |
| ++p; |
| while (glsShaderLibrary.isNumeric(m_input.charAt(p))) ++p; |
| |
| if (m_input.charAt(p) === 'e' || m_input.charAt(p) === 'E') { |
| |
| ++p; |
| if (m_input.charAt(p) === '+' || m_input.charAt(p) === '-') ++p; |
| |
| glsShaderLibrary.de_assert(p < m_input.length && glsShaderLibrary.isNumeric(m_input.charAt(p))); |
| while (glsShaderLibrary.isNumeric(m_input.charAt(p))) ++p; |
| |
| } |
| |
| m_curToken = Token.TOKEN_FLOAT_LITERAL; |
| m_curTokenStr = m_input.substr(m_curPtr, p - m_curPtr); |
| |
| } else { |
| |
| m_curToken = Token.TOKEN_INT_LITERAL; |
| m_curTokenStr = m_input.substr(m_curPtr, p - m_curPtr); |
| |
| } |
| |
| } else if (m_input.charAt(m_curPtr) === '"' && m_input.charAt(m_curPtr + 1) === '"') { // shader source |
| |
| var p = m_curPtr + 2; |
| |
| while (m_input.charAt(p) != '"' || m_input.charAt(p + 1) != '"') { |
| glsShaderLibrary.de_assert(p < m_input.length); |
| if (m_input.charAt(p) === '\\') { |
| glsShaderLibrary.de_assert(p + 1 < m_input.length); |
| p += 2; |
| } else { |
| ++p; |
| } |
| } |
| p += 2; |
| |
| m_curToken = Token.TOKEN_SHADER_SOURCE; |
| m_curTokenStr = m_input.substr(m_curPtr, p - m_curPtr); |
| |
| } else if (m_input.charAt(m_curPtr) === '"' || m_input.charAt(m_curPtr) === "'") { |
| |
| /** @type {string} */ var delimitor = m_input.charAt(m_curPtr); |
| var p = m_curPtr + 1; |
| |
| while (m_input.charAt(p) != delimitor) { |
| |
| glsShaderLibrary.de_assert(p < m_input.length); |
| if (m_input.charAt(p) === '\\') { |
| glsShaderLibrary.de_assert(p + 1 < m_input.length); |
| p += 2; |
| } else { |
| ++p; |
| } |
| |
| } |
| ++p; |
| |
| m_curToken = Token.TOKEN_STRING; |
| m_curTokenStr = m_input.substr(m_curPtr, p - m_curPtr); |
| |
| } else { |
| |
| m_curTokenStr = m_input.charAt(m_curPtr); |
| m_curToken = (function() { |
| // consider reimplementing with a binary search |
| switch (m_curTokenStr) { |
| case '=': return Token.TOKEN_ASSIGN; |
| case '+': return Token.TOKEN_PLUS; |
| case '-': return Token.TOKEN_MINUS; |
| case ',': return Token.TOKEN_COMMA; |
| case '|': return Token.TOKEN_VERTICAL_BAR; |
| case ';': return Token.TOKEN_SEMI_COLON; |
| case '(': return Token.TOKEN_LEFT_PAREN; |
| case ')': return Token.TOKEN_RIGHT_PAREN; |
| case '[': return Token.TOKEN_LEFT_BRACKET; |
| case ']': return Token.TOKEN_RIGHT_BRACKET; |
| case '{': return Token.TOKEN_LEFT_BRACE; |
| case '}': return Token.TOKEN_RIGHT_BRACE; |
| |
| default: return Token.TOKEN_INVALID; |
| } |
| }()); |
| |
| } |
| |
| }; |
| |
| /** |
| * @return {Object.<number, string, string>} |
| */ |
| var advanceTokenTester = function(input, current_index) { |
| m_input = input; |
| m_curPtr = current_index; |
| m_curTokenStr = ''; |
| advanceTokenWorker(); |
| return { |
| /** @type {number} */ idType: m_curToken, |
| /** @type {string} */ name: resolveTokenName(m_curToken), |
| /** @type {string} */ value: m_curTokenStr |
| }; |
| }; |
| |
| /** |
| * @param {Token=} tokenAssumed |
| */ |
| var advanceToken = function(tokenAssumed) { |
| if (typeof(tokenAssumed) !== 'undefined') { |
| assumeToken(tokenAssumed); |
| } |
| advanceTokenWorker(); |
| }; |
| var assumeToken = function(token) { |
| |
| if (m_curToken != token) { |
| // parse error |
| /** @type {string} */ var msg = "unexpected token '" + m_curTokenStr + "', expecting '" + getTokenName(token) + "'"; |
| throw Error('Parse Error. ' + msg + ' near ' + m_curPtr + ' ...'); |
| } |
| }; |
| var mapDataTypeToken = function(token) { |
| switch (token) { |
| case Token.TOKEN_FLOAT: return gluShaderUtil.DataType.FLOAT; |
| case Token.TOKEN_FLOAT_VEC2: return gluShaderUtil.DataType.FLOAT_VEC2; |
| case Token.TOKEN_FLOAT_VEC3: return gluShaderUtil.DataType.FLOAT_VEC3; |
| case Token.TOKEN_FLOAT_VEC4: return gluShaderUtil.DataType.FLOAT_VEC4; |
| case Token.TOKEN_FLOAT_MAT2: return gluShaderUtil.DataType.FLOAT_MAT2; |
| case Token.TOKEN_FLOAT_MAT2X3: return gluShaderUtil.DataType.FLOAT_MAT2X3; |
| case Token.TOKEN_FLOAT_MAT2X4: return gluShaderUtil.DataType.FLOAT_MAT2X4; |
| case Token.TOKEN_FLOAT_MAT3X2: return gluShaderUtil.DataType.FLOAT_MAT3X2; |
| case Token.TOKEN_FLOAT_MAT3: return gluShaderUtil.DataType.FLOAT_MAT3; |
| case Token.TOKEN_FLOAT_MAT3X4: return gluShaderUtil.DataType.FLOAT_MAT3X4; |
| case Token.TOKEN_FLOAT_MAT4X2: return gluShaderUtil.DataType.FLOAT_MAT4X2; |
| case Token.TOKEN_FLOAT_MAT4X3: return gluShaderUtil.DataType.FLOAT_MAT4X3; |
| case Token.TOKEN_FLOAT_MAT4: return gluShaderUtil.DataType.FLOAT_MAT4; |
| case Token.TOKEN_INT: return gluShaderUtil.DataType.INT; |
| case Token.TOKEN_INT_VEC2: return gluShaderUtil.DataType.INT_VEC2; |
| case Token.TOKEN_INT_VEC3: return gluShaderUtil.DataType.INT_VEC3; |
| case Token.TOKEN_INT_VEC4: return gluShaderUtil.DataType.INT_VEC4; |
| case Token.TOKEN_UINT: return gluShaderUtil.DataType.UINT; |
| case Token.TOKEN_UINT_VEC2: return gluShaderUtil.DataType.UINT_VEC2; |
| case Token.TOKEN_UINT_VEC3: return gluShaderUtil.DataType.UINT_VEC3; |
| case Token.TOKEN_UINT_VEC4: return gluShaderUtil.DataType.UINT_VEC4; |
| case Token.TOKEN_BOOL: return gluShaderUtil.DataType.BOOL; |
| case Token.TOKEN_BOOL_VEC2: return gluShaderUtil.DataType.BOOL_VEC2; |
| case Token.TOKEN_BOOL_VEC3: return gluShaderUtil.DataType.BOOL_VEC3; |
| case Token.TOKEN_BOOL_VEC4: return gluShaderUtil.DataType.BOOL_VEC4; |
| default: return gluShaderUtil.DataType.INVALID; |
| } |
| }; |
| |
| /** |
| * Returns the corresponding token's name depending on enum number value |
| * @param {number} token |
| * @return {string} |
| */ |
| var getTokenName = function(token) { |
| switch (token) { |
| case Token.TOKEN_INVALID: return '<invalid>'; |
| case Token.TOKEN_EOF: return '<eof>'; |
| case Token.TOKEN_STRING: return '<string>'; |
| case Token.TOKEN_SHADER_SOURCE: return 'source'; |
| |
| case Token.TOKEN_INT_LITERAL: return '<int>'; |
| case Token.TOKEN_FLOAT_LITERAL: return '<float>'; |
| |
| // identifiers |
| case Token.TOKEN_IDENTIFIER: return '<identifier>'; |
| case Token.TOKEN_TRUE: return 'true'; |
| case Token.TOKEN_FALSE: return 'false'; |
| case Token.TOKEN_DESC: return 'desc'; |
| case Token.TOKEN_EXPECT: return 'expect'; |
| case Token.TOKEN_GROUP: return 'group'; |
| case Token.TOKEN_CASE: return 'case'; |
| case Token.TOKEN_END: return 'end'; |
| case Token.TOKEN_VALUES: return 'values'; |
| case Token.TOKEN_BOTH: return 'both'; |
| case Token.TOKEN_VERTEX: return 'vertex'; |
| case Token.TOKEN_FRAGMENT: return 'fragment'; |
| case Token.TOKEN_UNIFORM: return 'uniform'; |
| case Token.TOKEN_INPUT: return 'input'; |
| case Token.TOKEN_OUTPUT: return 'output'; |
| case Token.TOKEN_FLOAT: return 'float'; |
| case Token.TOKEN_FLOAT_VEC2: return 'vec2'; |
| case Token.TOKEN_FLOAT_VEC3: return 'vec3'; |
| case Token.TOKEN_FLOAT_VEC4: return 'vec4'; |
| case Token.TOKEN_FLOAT_MAT2: return 'mat2'; |
| case Token.TOKEN_FLOAT_MAT2X3: return 'mat2x3'; |
| case Token.TOKEN_FLOAT_MAT2X4: return 'mat2x4'; |
| case Token.TOKEN_FLOAT_MAT3X2: return 'mat3x2'; |
| case Token.TOKEN_FLOAT_MAT3: return 'mat3'; |
| case Token.TOKEN_FLOAT_MAT3X4: return 'mat3x4'; |
| case Token.TOKEN_FLOAT_MAT4X2: return 'mat4x2'; |
| case Token.TOKEN_FLOAT_MAT4X3: return 'mat4x3'; |
| case Token.TOKEN_FLOAT_MAT4: return 'mat4'; |
| case Token.TOKEN_INT: return 'int'; |
| case Token.TOKEN_INT_VEC2: return 'ivec2'; |
| case Token.TOKEN_INT_VEC3: return 'ivec3'; |
| case Token.TOKEN_INT_VEC4: return 'ivec4'; |
| case Token.TOKEN_UINT: return 'uint'; |
| case Token.TOKEN_UINT_VEC2: return 'uvec2'; |
| case Token.TOKEN_UINT_VEC3: return 'uvec3'; |
| case Token.TOKEN_UINT_VEC4: return 'uvec4'; |
| case Token.TOKEN_BOOL: return 'bool'; |
| case Token.TOKEN_BOOL_VEC2: return 'bvec2'; |
| case Token.TOKEN_BOOL_VEC3: return 'bvec3'; |
| case Token.TOKEN_BOOL_VEC4: return 'bvec4'; |
| |
| case Token.TOKEN_ASSIGN: return '='; |
| case Token.TOKEN_PLUS: return '+'; |
| case Token.TOKEN_MINUS: return '-'; |
| case Token.TOKEN_COMMA: return ','; |
| case Token.TOKEN_VERTICAL_BAR: return '|'; |
| case Token.TOKEN_SEMI_COLON: return ';'; |
| case Token.TOKEN_LEFT_PAREN: return '('; |
| case Token.TOKEN_RIGHT_PAREN: return ')'; |
| case Token.TOKEN_LEFT_BRACKET: return '['; |
| case Token.TOKEN_RIGHT_BRACKET: return ']'; |
| case Token.TOKEN_LEFT_BRACE: return ' {'; |
| case Token.TOKEN_RIGHT_BRACE: return '}'; |
| |
| default: return '<unknown>'; |
| } |
| }; |
| |
| /** |
| * @param {?gluShaderUtil.DataType} expectedDataType |
| * @param {Object} result |
| */ |
| var parseValueElement = function(expectedDataType, result) { |
| /** @type {?string} */ var scalarType = null; |
| /** @type {number} */ var scalarSize = 0; |
| if (expectedDataType) { |
| scalarType = gluShaderUtil.getDataTypeScalarType(expectedDataType); |
| scalarSize = gluShaderUtil.getDataTypeScalarSize(expectedDataType); |
| } |
| |
| /** @type {Array<number>} */ var elems = []; |
| |
| if (scalarSize > 1) { |
| glsShaderLibrary.de_assert(mapDataTypeToken(m_curToken) === expectedDataType); |
| advanceToken(); // data type(float, vec2, etc.) |
| advanceToken(Token.TOKEN_LEFT_PAREN); |
| } |
| |
| for (var i = 0; i < scalarSize; ++i) { |
| if (scalarType === 'float') { |
| |
| /** @type {number} */ var signMult = 1.0; |
| if (m_curToken === Token.TOKEN_MINUS) { |
| signMult = -1.0; |
| advanceToken(); |
| } |
| |
| assumeToken(Token.TOKEN_FLOAT_LITERAL); |
| elems.push(signMult * parseFloatLiteral(m_curTokenStr)); |
| advanceToken(Token.TOKEN_FLOAT_LITERAL); |
| |
| } else if (scalarType === 'int' || scalarType === 'uint') { |
| |
| var signMult = 1; |
| if (m_curToken === Token.TOKEN_MINUS) { |
| signMult = -1; |
| advanceToken(); |
| } |
| |
| assumeToken(Token.TOKEN_INT_LITERAL); |
| elems.push(signMult * parseIntLiteral(m_curTokenStr)); |
| advanceToken(Token.TOKEN_INT_LITERAL); |
| |
| } else { |
| |
| glsShaderLibrary.de_assert(scalarType === 'bool'); |
| elems.push(m_curToken === Token.TOKEN_TRUE); |
| if (m_curToken != Token.TOKEN_TRUE && m_curToken != Token.TOKEN_FALSE) { |
| throw Error('unexpected token, expecting bool: ' + m_curTokenStr); |
| } |
| advanceToken(); // true/false |
| |
| } |
| |
| if (i != (scalarSize - 1)) { |
| advanceToken(Token.TOKEN_COMMA); |
| } |
| } |
| |
| if (scalarSize > 1) { |
| advanceToken(Token.TOKEN_RIGHT_PAREN); |
| } |
| |
| for (var i = 0; i < elems.length; i++) |
| result.elements.push(elems[i]); |
| |
| }; |
| |
| /** |
| * @param {Object.<Array, number>} valueBlock |
| */ |
| var parseValue = function(valueBlock) { |
| |
| /** |
| * @type {Object} |
| */ |
| var result = { |
| /** @type {?gluShaderUtil.DataType} */ dataType: null, |
| /** @type {?glsShaderLibraryCase.shaderCase} */ storageType: null, |
| /** @type {?string} */ valueName: null, |
| /** @type {Array} */ elements: [] |
| }; |
| |
| // parse storage |
| switch (m_curToken) { |
| case Token.TOKEN_UNIFORM: |
| result.storageType = glsShaderLibraryCase.shaderCase.STORAGE_UNIFORM; |
| break; |
| case Token.TOKEN_INPUT: |
| result.storageType = glsShaderLibraryCase.shaderCase.STORAGE_INPUT; |
| break; |
| case Token.TOKEN_OUTPUT: |
| result.storageType = glsShaderLibraryCase.shaderCase.STORAGE_OUTPUT; |
| break; |
| default: |
| throw Error('unexpected token encountered when parsing value classifier'); |
| break; |
| } |
| advanceToken(); |
| |
| // parse data type |
| result.dataType = mapDataTypeToken(m_curToken); |
| if (result.dataType === gluShaderUtil.DataType.INVALID) { |
| throw Error('unexpected token when parsing value data type: ' + m_curTokenStr); |
| } |
| advanceToken(); |
| |
| // parse value name |
| if (m_curToken === Token.TOKEN_IDENTIFIER) { |
| result.valueName = m_curTokenStr; |
| } else if (m_curToken === Token.TOKEN_STRING) { |
| result.valueName = parseStringLiteral(m_curTokenStr); |
| } else { |
| throw Error('unexpected token when parsing value name: ' + m_curTokenStr); |
| } |
| advanceToken(); |
| |
| // parse assignment operator. |
| advanceToken(Token.TOKEN_ASSIGN); |
| |
| // parse actual value |
| if (m_curToken === Token.TOKEN_LEFT_BRACKET) { // value list |
| advanceToken(Token.TOKEN_LEFT_BRACKET); |
| result.arrayLength = 0; |
| |
| for (;;) { |
| parseValueElement(result.dataType, result); |
| result.arrayLength += 1; |
| |
| if (m_curToken === Token.TOKEN_RIGHT_BRACKET) { |
| break; |
| } else if (m_curToken === Token.TOKEN_VERTICAL_BAR) { // pipe? |
| advanceToken(); |
| continue; |
| } else { |
| throw Error('unexpected token in value element array: ' + m_curTokenStr); |
| } |
| } |
| |
| advanceToken(Token.TOKEN_RIGHT_BRACKET); |
| |
| } else { // arrays, single elements |
| parseValueElement(result.dataType, result); |
| result.arrayLength = 1; |
| } |
| |
| advanceToken(Token.TOKEN_SEMI_COLON); |
| |
| valueBlock.values.push(result); |
| |
| }; |
| |
| /** |
| * @param {Object.<Array, number>} valueBlock |
| */ |
| var parseValueBlock = function(valueBlock) { |
| |
| advanceToken(Token.TOKEN_VALUES); |
| advanceToken(Token.TOKEN_LEFT_BRACE); |
| |
| for (;;) { |
| if ( |
| m_curToken === Token.TOKEN_UNIFORM || |
| m_curToken === Token.TOKEN_INPUT || |
| m_curToken === Token.TOKEN_OUTPUT |
| ) { |
| parseValue(valueBlock); |
| } else if (m_curToken === Token.TOKEN_RIGHT_BRACE) { |
| break; |
| } else { |
| throw Error('unexpected( token when parsing a value block: ' + m_curTokenStr); |
| } |
| } |
| |
| advanceToken(Token.TOKEN_RIGHT_BRACE); |
| |
| /** @type {number} */ var arrayLength = 1; |
| // compute combined array length of value block. |
| for (var i = 0; i < valueBlock.values.length; ++i) { |
| if (valueBlock.values[i].arrayLength > 1) { |
| glsShaderLibrary.de_assert(arrayLength === 1 || arrayLength === valueBlock.values[i].arrayLength); |
| arrayLength = valueBlock.values[i].arrayLength; |
| } |
| } |
| |
| valueBlock.arrayLength = arrayLength; |
| |
| }; |
| |
| /** |
| * @param {Array<tcuTestCase.DeqpTest>} shaderNodeList |
| */ |
| var parseShaderCase = function(shaderNodeList) { |
| |
| // parse case |
| advanceToken(Token.TOKEN_CASE); |
| |
| /** |
| * @type {string} |
| * parse case name |
| */ |
| var caseName = m_curTokenStr; |
| advanceToken(); // \note [pyry] All token types are allowed here. |
| |
| /** |
| * @type {Array<Object>} |
| * setup case |
| */ |
| var valueBlockList = []; |
| |
| /** TODO: Should the default version be defined elsewhere? */ |
| /** @type {string} */ var version = '100'; |
| /** @type {number} */ var expectResult = glsShaderLibraryCase.expectResult.EXPECT_PASS; |
| /** @type {string} */ var description; |
| /** @type {string} */ var bothSource = ''; |
| /** @type {string} */ var vertexSource = ''; |
| /** @type {string} */ var fragmentSource = ''; |
| |
| for (;;) { |
| |
| if (m_curToken === Token.TOKEN_END) { |
| |
| break; |
| |
| } else if (m_curToken === Token.TOKEN_DESC) { |
| |
| advanceToken(); |
| assumeToken(Token.TOKEN_STRING); |
| |
| description = parseStringLiteral(m_curTokenStr); |
| advanceToken(); |
| |
| } else if (m_curToken === Token.TOKEN_EXPECT) { |
| |
| advanceToken(); |
| assumeToken(Token.TOKEN_IDENTIFIER); |
| |
| expectResult = (function(token) { |
| switch (token) { |
| case 'pass': return glsShaderLibraryCase.expectResult.EXPECT_PASS; |
| case 'compile_fail': return glsShaderLibraryCase.expectResult.EXPECT_COMPILE_FAIL; |
| case 'link_fail': return glsShaderLibraryCase.expectResult.EXPECT_LINK_FAIL; |
| case 'compile_or_link_fail': return glsShaderLibraryCase.expectResult.EXPECT_COMPILE_LINK_FAIL; |
| case 'build_successful': return glsShaderLibraryCase.expectResult.EXPECT_BUILD_SUCCESSFUL; |
| default: |
| throw Error('invalid expected result value: ' + m_curTokenStr); |
| } |
| }(m_curTokenStr)); |
| |
| advanceToken(); |
| |
| } else if (m_curToken === Token.TOKEN_VALUES) { |
| |
| /** @type {Object.<Array, number>} */ var block = glsShaderLibraryCase.genValueBlock(); |
| parseValueBlock(block); |
| valueBlockList.push(block); |
| |
| } else if ( |
| m_curToken === Token.TOKEN_BOTH || |
| m_curToken === Token.TOKEN_VERTEX || |
| m_curToken === Token.TOKEN_FRAGMENT |
| ) { |
| |
| /** @type {number} */ var token = m_curToken; |
| advanceToken(); |
| assumeToken(Token.TOKEN_SHADER_SOURCE); |
| /** @type {string} */ var source = parseShaderSource(m_curTokenStr); |
| |
| advanceToken(); |
| switch (token) { |
| case Token.TOKEN_BOTH: bothSource = source; break; |
| case Token.TOKEN_VERTEX: vertexSource = source; break; |
| case Token.TOKEN_FRAGMENT: fragmentSource = source; break; |
| default: glsShaderLibrary.de_assert(false); break; |
| } |
| |
| } else if (m_curToken === Token.TOKEN_VERSION) { |
| |
| advanceToken(); |
| |
| /** @type {number} */ var versionNum = 0; |
| /** @type {string} */ var postfix = ''; |
| |
| assumeToken(Token.TOKEN_INT_LITERAL); |
| versionNum = parseIntLiteral(m_curTokenStr); |
| advanceToken(); |
| |
| if (m_curToken === Token.TOKEN_IDENTIFIER) { |
| postfix = m_curTokenStr; |
| advanceToken(); |
| } |
| |
| // TODO: need to fix these constants, we dont have glu |
| if (versionNum === 100 && postfix === 'es') version = '100'; |
| else if (versionNum === 300 && postfix === 'es') version = '300 es'; |
| else if (versionNum === 310 && postfix === 'es') version = '310 es'; |
| else if (versionNum === 130) version = '130'; |
| else if (versionNum === 140) version = '140'; |
| else if (versionNum === 150) version = '150'; |
| else if (versionNum === 330) version = '330'; |
| else if (versionNum === 400) version = '400'; |
| else if (versionNum === 410) version = '410'; |
| else if (versionNum === 420) version = '420'; |
| else if (versionNum === 430) version = '430'; |
| else if (versionNum === 440) version = '440'; |
| else if (versionNum === 450) version = '450'; |
| else { |
| throw Error('Unknown GLSL version'); |
| } |
| |
| } else { |
| throw Error('unexpected token while parsing shader case: ' + m_curTokenStr); |
| } |
| |
| } |
| |
| advanceToken(Token.TOKEN_END); // case end |
| |
| /** |
| * no ShaderCase yet? |
| * @param {?string} vert |
| * @param {?string} frag |
| * @param {glsShaderLibraryCase.caseType} type |
| * @return {Object} |
| */ |
| var getShaderSpec = function(vert, frag, type) { |
| return { |
| /** @type {glsShaderLibraryCase.expectResult} */ expectResult: expectResult, |
| /** @type {glsShaderLibraryCase.caseType} */ caseType: type, |
| /** @type {Array<Object>} */ valueBlockList: valueBlockList, |
| /** @type {string} */ targetVersion: version, |
| /** @type {?string} */ vertexSource: vert, |
| /** @type {?string} */ fragmentSource: frag |
| }; |
| }; |
| getShaderSpec.bind(this); |
| |
| if (bothSource.length) { |
| |
| glsShaderLibrary.de_assert(!vertexSource); |
| glsShaderLibrary.de_assert(!fragmentSource); |
| |
| shaderNodeList.push(tcuTestCase.newTest(caseName + '_vertex', description, getShaderSpec(bothSource, null, |
| glsShaderLibraryCase.caseType.CASETYPE_VERTEX_ONLY))); |
| shaderNodeList.push(tcuTestCase.newTest(caseName + '_fragment', description, getShaderSpec(null, bothSource, |
| glsShaderLibraryCase.caseType.CASETYPE_FRAGMENT_ONLY))); |
| |
| } else { |
| glsShaderLibrary.de_assert(vertexSource); |
| glsShaderLibrary.de_assert(fragmentSource); |
| |
| shaderNodeList.push(tcuTestCase.newTest(caseName, description, getShaderSpec(vertexSource, fragmentSource, |
| glsShaderLibraryCase.caseType.CASETYPE_COMPLETE))); |
| } |
| }; |
| |
| /** |
| * @param {Array<tcuTestCase.DeqpTest>} shaderNodeList |
| */ |
| var parseShaderGroup = function(shaderNodeList) { |
| |
| // parse 'case' |
| advanceToken(Token.TOKEN_GROUP); |
| |
| /** @type {string} |
| * parse case name |
| */ var name = m_curTokenStr; |
| advanceToken(); // \note [pyry] We don't want to check token type here (for instance to allow "uniform") group. |
| |
| // Parse description. |
| assumeToken(Token.TOKEN_STRING); |
| /** @type {string} */ var description = parseStringLiteral(m_curTokenStr); |
| advanceToken(Token.TOKEN_STRING); |
| |
| /** @type {Array<tcuTestCase.DeqpTest>} */ var children = []; |
| |
| for (;;) { |
| |
| if (m_curToken === Token.TOKEN_END) { |
| break; |
| } else if (m_curToken === Token.TOKEN_GROUP) { |
| parseShaderGroup(children); |
| } else if (m_curToken === Token.TOKEN_CASE) { |
| parseShaderCase(children); |
| } else { |
| testFailed('unexpected token while parsing shader group: ' + m_curTokenStr); |
| tcuTestCase.runner.terminate(); |
| } |
| |
| } |
| |
| advanceToken(Token.TOKEN_END); // group end |
| |
| /** @type {tcuTestCase.DeqpTest} */ var groupNode = tcuTestCase.newTest(name, description, null); |
| groupNode.setChildren(children); |
| |
| shaderNodeList.push(groupNode); |
| |
| }; |
| |
| // uncomment to expose private functions |
| (function(obj) { |
| obj.priv = { |
| m_curPtr: m_curPtr, |
| |
| parseError: parseError, |
| parseFloatLiteral: parseFloatLiteral, |
| parseIntLiteral: parseIntLiteral, |
| parseStringLiteral: parseStringLiteral, |
| parseShaderSource: parseShaderSource, |
| advanceTokenTester: advanceTokenTester, |
| assumeToken: assumeToken, |
| mapDataTypeToken: mapDataTypeToken, |
| getTokenName: getTokenName, |
| |
| Token: Token, |
| |
| parseValueElement: parseValueElement, |
| parseValue: parseValue, |
| parseValueBlock: parseValueBlock, |
| parseShaderCase: parseShaderCase, |
| parseShaderGroup: parseShaderGroup, |
| |
| none: false |
| }; |
| }(this)); |
| //*/ |
| }; |
| |
| /** |
| * Parse the test file and execute the test cases |
| * @param {string} testName Name of the test file (without extension) |
| * @param {string} filter Optional filter. Common substring of the names of the tests that should be glsShaderLibrary.run. |
| */ |
| glsShaderLibrary.run = function(testName, filter) { |
| WebGLTestUtils.loadTextFileAsync(testName + '.test', function(success, content) { |
| if (success) { |
| tcuTestCase.runner.testFile = content; |
| tcuTestCase.runner.testName = testName; |
| tcuTestCase.runner.runCallback(glsShaderLibrary.processTestFile); |
| } else { |
| testFailed('Failed to load test file: ' + testName); |
| tcuTestCase.runner.terminate(); |
| } |
| }); |
| }; |
| |
| }); |
