This is just an initial pass changing shader_runner to use the most basic parser primitives defined in a previous commit. Additional primitives for parsing numeric constants, comparison operators and various enumerations will be introduced later on. --- tests/shaders/shader_runner.c | 446 +++++++++++++++++++----------------------- 1 file changed, 203 insertions(+), 243 deletions(-)
diff --git a/tests/shaders/shader_runner.c b/tests/shaders/shader_runner.c index b0bde2c..92fab38 100644 --- a/tests/shaders/shader_runner.c +++ b/tests/shaders/shader_runner.c @@ -695,17 +695,9 @@ parse_version_comparison(const char *line, enum comparison *cmp, unsigned major; unsigned minor; unsigned full_num; - bool es = false; - bool core = false; + const bool core = parse_str(line, "CORE", &line); + const bool es = parse_str(line, "ES", &line); - if (string_match(" CORE", line)) { - core = true; - line += 5; - } - if (string_match(" ES", line)) { - es = true; - line += 3; - } line = eat_whitespace(line); line = process_comparison(line, cmp); @@ -713,7 +705,7 @@ parse_version_comparison(const char *line, enum comparison *cmp, sscanf(line, "%u.%u", &major, &minor); line = eat_text(line); - line = eat_whitespace(line); + parse_whitespace(line, &line); if (*line != '\n') { printf("Unexpected characters following version comparison\n"); piglit_report_result(PIGLIT_FAIL); @@ -777,30 +769,28 @@ process_requirement(const char *line) * shader_runner to read the specified integer value and * processes the given requirement. */ - if (string_match("INT ", line)) { + if (parse_str(line, "INT ", &line)) { enum comparison cmp; - const char *enum_name = eat_whitespace(line+3); - const char *int_string; int comparison_value, gl_int_value; - GLenum int_enum; + unsigned int_enum; - strcpy_to_space(buffer, enum_name); + REQUIRE(parse_enum_gl(line, &int_enum, &line), + "Invalid comparison enum at: %s\n", line); - int_enum = piglit_get_gl_enum_from_name(buffer); - - int_string = process_comparison(eat_whitespace(enum_name + strlen(buffer)), &cmp); - comparison_value = atoi(int_string); + line = process_comparison(eat_whitespace(line), &cmp); + comparison_value = atoi(line); glGetIntegerv(int_enum, &gl_int_value); if (!piglit_check_gl_error(GL_NO_ERROR)) { - fprintf(stderr, "Error reading %s\n", buffer); + fprintf(stderr, "Error reading %s\n", + piglit_get_gl_enum_name(int_enum)); return PIGLIT_FAIL; } if (!compare(comparison_value, gl_int_value, cmp)) { printf("Test requires %s %s %i. " "The driver supports %i.\n", - buffer, + piglit_get_gl_enum_name(int_enum), comparison_string(cmp), comparison_value, gl_int_value); @@ -828,11 +818,10 @@ process_requirement(const char *line) enum comparison cmp; int maxcomp; - if (!string_match(getint_limits[i].name, line)) + if (!parse_str(line, getint_limits[i].name, &line)) continue; - line = eat_whitespace(line + strlen(getint_limits[i].name)); - + line = eat_whitespace(line); line = process_comparison(line, &cmp); maxcomp = atoi(line); @@ -848,23 +837,19 @@ process_requirement(const char *line) return PIGLIT_PASS; } - /* Consume any leading whitespace before requirements. This is - * important for generated test files that may have odd whitespace - */ - line = eat_whitespace(line); - - if (string_match("GL_", line)) { - strcpy_to_space(buffer, line); + if (parse_str(line, "GL_", NULL) && + parse_word_copy(line, buffer, sizeof(buffer), &line)) { if (!piglit_is_extension_supported(buffer)) return PIGLIT_SKIP; - } else if (string_match("!GL_", line)) { - strcpy_to_space(buffer, line + 1); + } else if (parse_str(line, "!", &line) && + parse_str(line, "GL_", NULL) && + parse_word_copy(line, buffer, sizeof(buffer), &line)) { if (piglit_is_extension_supported(buffer)) return PIGLIT_SKIP; - } else if (string_match("GLSL", line)) { + } else if (parse_str(line, "GLSL", &line)) { enum comparison cmp; - parse_version_comparison(line + 4, &cmp, &glsl_req_version, + parse_version_comparison(line, &cmp, &glsl_req_version, VERSION_GLSL); /* We only allow >= because we potentially use the @@ -882,11 +867,11 @@ process_requirement(const char *line) version_string(&glsl_version)); return PIGLIT_SKIP; } - } else if (string_match("GL", line)) { + } else if (parse_str(line, "GL", &line)) { enum comparison cmp; struct component_version gl_req_version; - parse_version_comparison(line + 2, &cmp, &gl_req_version, + parse_version_comparison(line, &cmp, &gl_req_version, VERSION_GL); if (!version_compare(&gl_req_version, &gl_version, cmp)) { @@ -897,12 +882,11 @@ process_requirement(const char *line) version_string(&gl_version)); return PIGLIT_SKIP; } - } else if (string_match("rlimit", line)) { - unsigned long lim; + } else if (parse_str(line, "rlimit", &line)) { + unsigned lim; char *ptr; - line = eat_whitespace(line + 6); - + line = eat_whitespace(line); lim = strtoul(line, &ptr, 0); if (ptr == line) { printf("rlimit requires numeric argument\n"); @@ -910,21 +894,19 @@ process_requirement(const char *line) } piglit_set_rlimit(lim); - } else if (string_match("SSO", line)) { + } else if (parse_str(line, "SSO", &line) && + parse_str(line, "ENABLED", NULL)) { const char *const ext_name = gl_version.es ? "GL_EXT_separate_shader_objects" : "GL_ARB_separate_shader_objects"; const unsigned min_version = gl_version.es ? 31 : 41; - line = eat_whitespace(line + 3); - if (string_match("ENABLED", line)) { - if (gl_version.num < min_version) - piglit_require_extension(ext_name); + if (gl_version.num < min_version) + piglit_require_extension(ext_name); - sso_in_use = true; - glGenProgramPipelines(1, &pipeline); - } + sso_in_use = true; + glGenProgramPipelines(1, &pipeline); } return PIGLIT_PASS; } @@ -939,7 +921,7 @@ process_geometry_layout(const char *line) char s[32]; int x; - line = eat_whitespace(line); + parse_whitespace(line, &line); if (line[0] == '\0' || line[0] == '\n') { return; @@ -1195,44 +1177,44 @@ process_test_script(const char *script_name) if (result != PIGLIT_PASS) return result; - if (string_match("[require]", line)) { + if (parse_str(line, "[require]", NULL)) { state = requirements; - } else if (string_match("[vertex shader]", line)) { + } else if (parse_str(line, "[vertex shader]", NULL)) { state = vertex_shader; shader_string = NULL; - } else if (string_match("[vertex program]", line)) { + } else if (parse_str(line, "[vertex program]", NULL)) { state = vertex_program; shader_string = NULL; - } else if (string_match("[vertex shader passthrough]", line)) { + } else if (parse_str(line, "[vertex shader passthrough]", NULL)) { state = vertex_shader_passthrough; shader_string = (char *) passthrough_vertex_shader_source; shader_string_size = strlen(shader_string); - } else if (string_match("[tessellation control shader]", line)) { + } else if (parse_str(line, "[tessellation control shader]", NULL)) { state = tess_ctrl_shader; shader_string = NULL; - } else if (string_match("[tessellation evaluation shader]", line)) { + } else if (parse_str(line, "[tessellation evaluation shader]", NULL)) { state = tess_eval_shader; shader_string = NULL; - } else if (string_match("[geometry shader]", line)) { + } else if (parse_str(line, "[geometry shader]", NULL)) { state = geometry_shader; shader_string = NULL; - } else if (string_match("[geometry layout]", line)) { + } else if (parse_str(line, "[geometry layout]", NULL)) { state = geometry_layout; shader_string = NULL; - } else if (string_match("[fragment shader]", line)) { + } else if (parse_str(line, "[fragment shader]", NULL)) { state = fragment_shader; shader_string = NULL; - } else if (string_match("[fragment program]", line)) { + } else if (parse_str(line, "[fragment program]", NULL)) { state = fragment_program; shader_string = NULL; - } else if (string_match("[compute shader]", line)) { + } else if (parse_str(line, "[compute shader]", NULL)) { state = compute_shader; shader_string = NULL; - } else if (string_match("[vertex data]", line)) { + } else if (parse_str(line, "[vertex data]", NULL)) { state = vertex_data; vertex_data_start = NULL; - } else if (string_match("[test]", line)) { + } else if (parse_str(line, "[test]", NULL)) { test_start = strchrnul(line, '\n'); test_start_line_num = line_num + 1; if (test_start[0] != '\0') @@ -1330,28 +1312,28 @@ parse_required_config(struct requirement_parse_results *results, } if (!in_requirement_section) { - if (string_match("[require]", line)) { + if (parse_str(line, "[require]", NULL)) { in_requirement_section = true; } } else { - if (string_match("GL_", line) - || string_match("!GL_", line)) { + if (parse_str(line, "GL_", NULL) + || parse_str(line, "!GL_", NULL)) { /* empty */ - } else if (string_match("GLSL", line)) { + } else if (parse_str(line, "GLSL", &line)) { enum comparison cmp; struct component_version version; - parse_version_comparison(line + 4, &cmp, + parse_version_comparison(line, &cmp, &version, VERSION_GLSL); if (cmp == greater_equal) { results->found_glsl = true; version_copy(&results->glsl_version, &version); } - } else if (string_match("GL", line)) { + } else if (parse_str(line, "GL", &line)) { enum comparison cmp; struct component_version version; - parse_version_comparison(line + 2, &cmp, + parse_version_comparison(line, &cmp, &version, VERSION_GL); if (cmp == greater_equal || cmp == greater @@ -1359,10 +1341,10 @@ parse_required_config(struct requirement_parse_results *results, results->found_gl = true; version_copy(&results->gl_version, &version); } - } else if (string_match("SIZE", line)) { + } else if (parse_str(line, "SIZE", &line)) { results->found_size = true; - get_uints(line+4, results->size, 2); - } else if (string_match("depthbuffer", line)) { + get_uints(line, results->size, 2); + } else if (parse_str(line, "depthbuffer", NULL)) { results->found_depthbuffer = true; } } @@ -1635,49 +1617,49 @@ set_ubo_uniform(char *name, const char *type, const char *line, int ubo_array_in data = glMapBuffer(GL_UNIFORM_BUFFER, GL_WRITE_ONLY); data += offset; - if (string_match("float", type)) { + if (parse_str(type, "float", NULL)) { get_floats(line, f, 1); memcpy(data, f, sizeof(float)); - } else if (string_match("int64_t", type)) { + } else if (parse_str(type, "int64_t", NULL)) { get_int64s(line, int64s, 1); memcpy(data, int64s, sizeof(int64_t)); - } else if (string_match("uint64_t", type)) { + } else if (parse_str(type, "uint64_t", NULL)) { get_uint64s(line, uint64s, 1); memcpy(data, uint64s, sizeof(uint64_t)); - } else if (string_match("int", type)) { + } else if (parse_str(type, "int", NULL)) { get_ints(line, ints, 1); memcpy(data, ints, sizeof(int)); - } else if (string_match("uint", type)) { + } else if (parse_str(type, "uint", NULL)) { get_uints(line, uints, 1); memcpy(data, uints, sizeof(int)); - } else if (string_match("double", type)) { + } else if (parse_str(type, "double", NULL)) { get_doubles(line, d, 1); memcpy(data, d, sizeof(double)); - } else if (string_match("vec", type)) { + } else if (parse_str(type, "vec", NULL)) { int elements = type[3] - '0'; get_floats(line, f, elements); memcpy(data, f, elements * sizeof(float)); - } else if (string_match("ivec", type)) { + } else if (parse_str(type, "ivec", NULL)) { int elements = type[4] - '0'; get_ints(line, ints, elements); memcpy(data, ints, elements * sizeof(int)); - } else if (string_match("uvec", type)) { + } else if (parse_str(type, "uvec", NULL)) { int elements = type[4] - '0'; get_uints(line, uints, elements); memcpy(data, uints, elements * sizeof(unsigned)); - } else if (string_match("i64vec", type)) { + } else if (parse_str(type, "i64vec", NULL)) { int elements = type[6] - '0'; get_int64s(line, int64s, elements); memcpy(data, int64s, elements * sizeof(int64_t)); - } else if (string_match("u64vec", type)) { + } else if (parse_str(type, "u64vec", NULL)) { int elements = type[6] - '0'; get_uint64s(line, uint64s, elements); memcpy(data, uint64s, elements * sizeof(uint64_t)); - } else if (string_match("dvec", type)) { + } else if (parse_str(type, "dvec", NULL)) { int elements = type[4] - '0'; get_doubles(line, d, elements); memcpy(data, d, elements * sizeof(double)); - } else if (string_match("mat", type)) { + } else if (parse_str(type, "mat", NULL)) { GLint matrix_stride, row_major; int cols = type[3] - '0'; int rows = type[4] == 'x' ? type[5] - '0' : cols; @@ -1711,7 +1693,7 @@ set_ubo_uniform(char *name, const char *type, const char *line, int ubo_array_in } } } - } else if (string_match("dmat", type)) { + } else if (parse_str(type, "dmat", NULL)) { GLint matrix_stride, row_major; int cols = type[4] - '0'; int rows = type[5] == 'x' ? type[6] - '0' : cols; @@ -1758,7 +1740,7 @@ set_ubo_uniform(char *name, const char *type, const char *line, int ubo_array_in static void set_uniform(const char *line, int ubo_array_index) { - char name[512]; + char name[512], type[512]; float f[16]; double d[16]; int ints[16]; @@ -1766,12 +1748,10 @@ set_uniform(const char *line, int ubo_array_index) int64_t int64s[16]; uint64_t uint64s[16]; GLint loc; - const char *type; - - type = eat_whitespace(line); - line = eat_text(type); - line = strcpy_to_space(name, eat_whitespace(line)); + REQUIRE(parse_word_copy(line, type, sizeof(type), &line) && + parse_word_copy(line, name, sizeof(name), &line), + "Invalid set uniform command at: %s\n", line); if (isdigit(name[0])) { loc = strtol(name, NULL, 0); @@ -1790,35 +1770,35 @@ set_uniform(const char *line, int ubo_array_index) } } - if (string_match("float", type)) { + if (parse_str(type, "float", NULL)) { get_floats(line, f, 1); glUniform1fv(loc, 1, f); return; - } else if (string_match("int64_t", type)) { + } else if (parse_str(type, "int64_t", NULL)) { check_int64_support(); get_int64s(line, int64s, 1); glUniform1i64vARB(loc, 1, int64s); return; - } else if (string_match("uint64_t", type)) { + } else if (parse_str(type, "uint64_t", NULL)) { check_int64_support(); get_uint64s(line, uint64s, 1); glUniform1ui64vARB(loc, 1, uint64s); return; - } else if (string_match("int", type)) { + } else if (parse_str(type, "int", NULL)) { get_ints(line, ints, 1); glUniform1iv(loc, 1, ints); return; - } else if (string_match("uint", type)) { + } else if (parse_str(type, "uint", NULL)) { check_unsigned_support(); get_uints(line, uints, 1); glUniform1uiv(loc, 1, uints); return; - } else if (string_match("double", type)) { + } else if (parse_str(type, "double", NULL)) { check_double_support(); get_doubles(line, d, 1); glUniform1dv(loc, 1, d); return; - } else if (string_match("vec", type)) { + } else if (parse_str(type, "vec", NULL)) { switch (type[3]) { case '2': get_floats(line, f, 2); @@ -1833,7 +1813,7 @@ set_uniform(const char *line, int ubo_array_index) glUniform4fv(loc, 1, f); return; } - } else if (string_match("ivec", type)) { + } else if (parse_str(type, "ivec", NULL)) { switch (type[4]) { case '2': get_ints(line, ints, 2); @@ -1848,7 +1828,7 @@ set_uniform(const char *line, int ubo_array_index) glUniform4iv(loc, 1, ints); return; } - } else if (string_match("uvec", type)) { + } else if (parse_str(type, "uvec", NULL)) { check_unsigned_support(); switch (type[4]) { case '2': @@ -1864,7 +1844,7 @@ set_uniform(const char *line, int ubo_array_index) glUniform4uiv(loc, 1, uints); return; } - } else if (string_match("dvec", type)) { + } else if (parse_str(type, "dvec", NULL)) { check_double_support(); switch (type[4]) { case '2': @@ -1880,7 +1860,7 @@ set_uniform(const char *line, int ubo_array_index) glUniform4dv(loc, 1, d); return; } - } else if (string_match("i64vec", type)) { + } else if (parse_str(type, "i64vec", NULL)) { check_int64_support(); switch (type[6]) { case '2': @@ -1896,7 +1876,7 @@ set_uniform(const char *line, int ubo_array_index) glUniform4i64vARB(loc, 1, int64s); return; } - } else if (string_match("u64vec", type)) { + } else if (parse_str(type, "u64vec", NULL)) { check_int64_support(); switch (type[6]) { case '2': @@ -1912,7 +1892,7 @@ set_uniform(const char *line, int ubo_array_index) glUniform4ui64vARB(loc, 1, uint64s); return; } - } else if (string_match("mat", type) && type[3] != '\0') { + } else if (parse_str(type, "mat", NULL) && type[3] != '\0') { char cols = type[3]; char rows = type[4] == 'x' ? type[5] : cols; switch (cols) { @@ -1962,7 +1942,7 @@ set_uniform(const char *line, int ubo_array_index) return; } } - } else if (string_match("dmat", type) && type[4] != '\0') { + } else if (parse_str(type, "dmat", NULL) && type[4] != '\0') { char cols = type[4]; char rows = type[5] == 'x' ? type[6] : cols; switch (cols) { @@ -2014,8 +1994,7 @@ set_uniform(const char *line, int ubo_array_index) } } - strcpy_to_space(name, type); - printf("unknown uniform type \"%s\"\n", name); + printf("unknown uniform type \"%s\"\n", type); piglit_report_result(PIGLIT_FAIL); return; @@ -2043,27 +2022,27 @@ static GLenum lookup_shader_type(GLuint idx) static GLenum get_shader_from_string(const char *name, int *idx) { - if (string_match("GL_VERTEX_SHADER", name)) { + if (parse_str(name, "GL_VERTEX_SHADER", NULL)) { *idx = 0; return GL_VERTEX_SHADER; } - if (string_match("GL_FRAGMENT_SHADER", name)) { + if (parse_str(name, "GL_FRAGMENT_SHADER", NULL)) { *idx = 1; return GL_FRAGMENT_SHADER; } - if (string_match("GL_GEOMETRY_SHADER", name)) { + if (parse_str(name, "GL_GEOMETRY_SHADER", NULL)) { *idx = 2; return GL_GEOMETRY_SHADER; } - if (string_match("GL_TESS_CONTROL_SHADER", name)) { + if (parse_str(name, "GL_TESS_CONTROL_SHADER", NULL)) { *idx = 3; return GL_TESS_CONTROL_SHADER; } - if (string_match("GL_TESS_EVALUATION_SHADER", name)) { + if (parse_str(name, "GL_TESS_EVALUATION_SHADER", NULL)) { *idx = 4; return GL_TESS_EVALUATION_SHADER; } - if (string_match("GL_COMPUTE_SHADER", name)) { + if (parse_str(name, "GL_COMPUTE_SHADER", NULL)) { *idx = 5; return GL_COMPUTE_SHADER; } @@ -2103,19 +2082,18 @@ static void set_subroutine_uniform(const char *line) { GLuint prog; + char type[512]; char name[512]; char subname[512]; - const char *type; GLint loc; GLuint idx; GLenum ptype = 0; int sidx = 0; - type = eat_whitespace(line); - line = eat_text(type); - - line = strcpy_to_space(name, eat_whitespace(line)); - line = strcpy_to_space(subname, eat_whitespace(line)); + REQUIRE(parse_word_copy(line, type, sizeof(type), &line) && + parse_word_copy(line, name, sizeof(name), &line) && + parse_word_copy(line, subname, sizeof(subname), &line), + "Invalid set subroutine uniform command at: %s\n", line); ptype = get_shader_from_string(type, &sidx); if (ptype == 0) { @@ -2188,11 +2166,12 @@ active_uniform(const char *line) char name_buf[512]; char pname_string[512]; GLenum pname; - GLint expected; + int expected; int i; int num_active_uniforms; - line = strcpy_to_space(name, eat_whitespace(line)); + REQUIRE(parse_word_copy(line, name, sizeof(name), &line), + "Bad uniform name at: %s\n", line); strcpy_to_space(pname_string, eat_whitespace(line)); pname = lookup_enum_string(all_pnames, &line, "glGetUniformsiv pname"); @@ -2253,7 +2232,7 @@ active_uniform(const char *line) fprintf(stderr, "glGetActiveUniform(%s, %s): " "expected %d (0x%04x), got %d (0x%04x)\n", - name, pname_string, + name, piglit_get_gl_enum_name(pname), expected, expected, got, got); pass = false; } @@ -2275,7 +2254,7 @@ active_uniform(const char *line) fprintf(stderr, "glGetActiveUniformsiv(%s, %s): " "expected %d, got %d\n", - name, pname_string, + name, piglit_get_gl_enum_name(pname), expected, got); pass = false; } @@ -2286,7 +2265,6 @@ active_uniform(const char *line) return; } - fprintf(stderr, "No active uniform named \"%s\"\n", name); piglit_report_result(PIGLIT_FAIL); return; @@ -2362,10 +2340,8 @@ active_program_interface(const char *line) char name[512]; char name_buf[512]; - char prop_string[512]; - char interface_type_string[512]; - GLenum prop, interface_type; - GLint expected; + unsigned prop, interface_type; + int expected; int i; int num_active_buffers; @@ -2377,13 +2353,12 @@ active_program_interface(const char *line) return; } - strcpy_to_space(interface_type_string, eat_whitespace(line)); interface_type = lookup_enum_string(all_program_interface, &line, "glGetProgramResourceiv " "programInterface"); - line = strcpy_to_space(name, eat_whitespace(line)); + REQUIRE(parse_word_copy(line, name, sizeof(name), &line), + "Bad program resource name at: %s\n", line); - strcpy_to_space(prop_string, eat_whitespace(line)); prop = lookup_enum_string(all_props, &line, "glGetProgramResourceiv pname"); @@ -2417,7 +2392,7 @@ active_program_interface(const char *line) fprintf(stderr, "glGetProgramResourceName(%s, %s): " "expected %d (0x%04x), got %d (0x%04x)\n", - name, prop_string, + name, piglit_get_gl_enum_name(prop), expected, expected, name_len, name_len); pass = false; } @@ -2441,7 +2416,7 @@ active_program_interface(const char *line) fprintf(stderr, "glGetProgramResourceiv(%s, %s): " "expected %d, got %d\n", - name, prop_string, + name, piglit_get_gl_enum_name(prop), expected, got); pass = false; } @@ -2471,13 +2446,13 @@ set_parameter(const char *line) piglit_report_result(PIGLIT_FAIL); } - if (string_match("env_vp", type)) { + if (parse_str(type, "env_vp", NULL)) { glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index, f); - } else if (string_match("local_vp", type)) { + } else if (parse_str(type, "local_vp", NULL)) { glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index, f); - } else if (string_match("env_fp", type)) { + } else if (parse_str(type, "env_fp", NULL)) { glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, f); - } else if (string_match("local_fp", type)) { + } else if (parse_str(type, "local_fp", NULL)) { glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, f); } else { fprintf(stderr, "Unknown parameter type `%s'\n", type); @@ -2496,24 +2471,21 @@ set_patch_parameter(const char *line) if (gl_version.num < 40) piglit_require_extension("GL_ARB_tessellation_shader"); - if (string_match("vertices ", line)) { - line += strlen("vertices "); + if (parse_str(line, "vertices ", &line)) { count = sscanf(line, "%d", &i); if (count != 1) { fprintf(stderr, "Couldn't parse patch parameter command:\n%s\n", line0); piglit_report_result(PIGLIT_FAIL); } glPatchParameteri(GL_PATCH_VERTICES, i); - } else if (string_match("default level outer ", line)) { - line += strlen("default level outer "); + } else if (parse_str(line, "default level outer ", &line)) { count = sscanf(line, "%f %f %f %f", &f[0], &f[1], &f[2], &f[3]); if (count != 4) { fprintf(stderr, "Couldn't parse patch parameter command:\n%s\n", line0); piglit_report_result(PIGLIT_FAIL); } glPatchParameterfv(GL_PATCH_DEFAULT_OUTER_LEVEL, f); - } else if (string_match("default level inner ", line)) { - line += strlen("default level inner "); + } else if (parse_str(line, "default level inner ", &line)) { count = sscanf(line, "%f %f", &f[0], &f[1]); if (count != 2) { fprintf(stderr, "Couldn't parse patch parameter command:\n%s\n", line0); @@ -2533,9 +2505,9 @@ set_patch_parameter(const char *line) static void set_provoking_vertex(const char *line) { - if (string_match("first", line)) { + if (parse_str(line, "first", NULL)) { glProvokingVertexEXT(GL_FIRST_VERTEX_CONVENTION_EXT); - } else if (string_match("last", line)) { + } else if (parse_str(line, "last", NULL)) { glProvokingVertexEXT(GL_LAST_VERTEX_CONVENTION_EXT); } else { fprintf(stderr, "Unknown provoking vertex parameter `%s'\n", line); @@ -2563,6 +2535,7 @@ do_enable_disable(const char *line, bool enable_flag) { GLenum value = lookup_enum_string(enable_table, &line, "enable/disable enum"); + if (enable_flag) glEnable(value); else @@ -2704,52 +2677,44 @@ handle_texparameter(const char *line) { "alpha", GL_ALPHA }, { NULL, 0 } }; - GLenum target = 0; + unsigned target = 0; GLenum parameter = GL_NONE; const char *parameter_name = NULL; const struct string_to_enum *strings = NULL; - GLenum value; + unsigned value; target = lookup_enum_string(texture_target, &line, "texture target"); - if (string_match("compare_func ", line)) { + if (parse_str(line, "compare_func ", &line)) { parameter = GL_TEXTURE_COMPARE_FUNC; parameter_name = "compare_func"; - line += strlen("compare_func "); strings = compare_funcs; - } else if (string_match("depth_mode ", line)) { + } else if (parse_str(line, "depth_mode ", &line)) { parameter = GL_DEPTH_TEXTURE_MODE; parameter_name = "depth_mode"; - line += strlen("depth_mode "); strings = depth_modes; - } else if (string_match("min ", line)) { + } else if (parse_str(line, "min ", &line)) { parameter = GL_TEXTURE_MIN_FILTER; parameter_name = "min"; - line += strlen("min "); strings = min_filter_modes; - } else if (string_match("mag ", line)) { + } else if (parse_str(line, "mag ", &line)) { parameter = GL_TEXTURE_MAG_FILTER; parameter_name = "mag"; - line += strlen("mag "); strings = mag_filter_modes; - } else if (string_match("wrap_s ", line)) { + } else if (parse_str(line, "wrap_s ", &line)) { parameter = GL_TEXTURE_WRAP_S; parameter_name = "wrap_s"; - line += strlen("wrap_s "); strings = wrap_modes; - } else if (string_match("wrap_t ", line)) { + } else if (parse_str(line, "wrap_t ", &line)) { parameter = GL_TEXTURE_WRAP_T; parameter_name = "wrap_t"; - line += strlen("wrap_t "); strings = wrap_modes; - } else if (string_match("wrap_r ", line)) { + } else if (parse_str(line, "wrap_r ", &line)) { parameter = GL_TEXTURE_WRAP_R; parameter_name = "wrap_r"; - line += strlen("wrap_r "); strings = wrap_modes; - } else if (string_match("lod_bias ", line)) { + } else if (parse_str(line, "lod_bias ", &line)) { #ifdef PIGLIT_USE_OPENGL - line += strlen("lod_bias "); glTexParameterf(target, GL_TEXTURE_LOD_BIAS, strtod(line, NULL)); return; @@ -2757,26 +2722,22 @@ handle_texparameter(const char *line) printf("lod_bias feature is only available in desktop GL\n"); piglit_report_result(PIGLIT_SKIP); #endif - } else if (string_match("max_level ", line)) { - line += strlen("max_level "); + } else if (parse_str(line, "max_level ", &line)) { glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, strtol(line, NULL, 10)); return; - } else if (string_match("base_level ", line)) { - line += strlen("base_level "); + } else if (parse_str(line, "base_level ", &line)) { glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, strtol(line, NULL, 10)); return; - } else if (string_match("border_color ", line)) { + } else if (parse_str(line, "border_color ", &line)) { float bc[4]; - line += strlen("border_color "); sscanf(line, "%f %f %f %f", &bc[0], &bc[1], &bc[2], &bc[3]); glTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, bc); return; - } else if (string_match("swizzle_r ", line)) { + } else if (parse_str(line, "swizzle_r ", &line)) { parameter = GL_TEXTURE_SWIZZLE_R; parameter_name = "swizzle_r"; - line += strlen("swizzle_r "); strings = swizzle_modes; } else { fprintf(stderr, "unknown texture parameter in `%s'\n", line); @@ -2784,6 +2745,7 @@ handle_texparameter(const char *line) } value = lookup_enum_string(strings, &line, parameter_name); + glTexParameteri(target, parameter, value); } @@ -2939,7 +2901,7 @@ probe_ssbo_uint(GLint ssbo_index, GLint ssbo_offset, const char *op, uint32_t va enum piglit_result piglit_display(void) { - const char *line, *next_line; + const char *line, *next_line, *rest; unsigned line_num; enum piglit_result full_result = PIGLIT_PASS; GLbitfield clear_bits = 0; @@ -2959,7 +2921,7 @@ piglit_display(void) char s[32]; enum piglit_result result = PIGLIT_PASS; - line = eat_whitespace(next_line); + parse_whitespace(next_line, &line); next_line = strchrnul(next_line, '\n'); @@ -3012,15 +2974,15 @@ piglit_display(void) glNamedBufferSubData(atomics_bos[x], sizeof(GLuint) * y, sizeof(GLuint), &z); - } else if (string_match("clear color", line)) { - get_floats(line + 11, c, 4); + } else if (parse_str(line, "clear color ", &rest)) { + get_floats(rest, c, 4); glClearColor(c[0], c[1], c[2], c[3]); clear_bits |= GL_COLOR_BUFFER_BIT; - } else if (string_match("clear depth", line)) { - get_floats(line + 11, c, 1); + } else if (parse_str(line, "clear depth ", &rest)) { + get_floats(rest, c, 1); glClearDepth(c[0]); clear_bits |= GL_DEPTH_BUFFER_BIT; - } else if (string_match("clear", line)) { + } else if (parse_str(line, "clear", NULL)) { glClear(clear_bits); } else if (sscanf(line, "clip plane %d %lf %lf %lf %lf", @@ -3044,44 +3006,44 @@ piglit_display(void) glMemoryBarrier(GL_ALL_BARRIER_BITS); glDispatchComputeGroupSizeARB(x, y, z, w, h, l); glMemoryBarrier(GL_ALL_BARRIER_BITS); - } else if (string_match("draw rect tex", line)) { + } else if (parse_str(line, "draw rect tex ", &rest)) { program_must_be_in_use(); program_subroutine_uniforms(); - get_floats(line + 13, c, 8); + get_floats(rest, c, 8); piglit_draw_rect_tex(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]); - } else if (string_match("draw rect ortho patch", line)) { + } else if (parse_str(line, "draw rect ortho patch ", &rest)) { program_must_be_in_use(); program_subroutine_uniforms(); - get_floats(line + 21, c, 4); + get_floats(rest, c, 4); piglit_draw_rect_custom(-1.0 + 2.0 * (c[0] / piglit_width), -1.0 + 2.0 * (c[1] / piglit_height), 2.0 * (c[2] / piglit_width), 2.0 * (c[3] / piglit_height), true); - } else if (string_match("draw rect ortho", line)) { + } else if (parse_str(line, "draw rect ortho ", &rest)) { program_must_be_in_use(); program_subroutine_uniforms(); - get_floats(line + 15, c, 4); + get_floats(rest, c, 4); piglit_draw_rect(-1.0 + 2.0 * (c[0] / piglit_width), -1.0 + 2.0 * (c[1] / piglit_height), 2.0 * (c[2] / piglit_width), 2.0 * (c[3] / piglit_height)); - } else if (string_match("draw rect patch", line)) { + } else if (parse_str(line, "draw rect patch ", &rest)) { program_must_be_in_use(); - get_floats(line + 15, c, 4); + get_floats(rest, c, 4); piglit_draw_rect_custom(c[0], c[1], c[2], c[3], true); - } else if (string_match("draw rect", line)) { + } else if (parse_str(line, "draw rect ", &rest)) { program_must_be_in_use(); program_subroutine_uniforms(); - get_floats(line + 9, c, 4); + get_floats(rest, c, 4); piglit_draw_rect(c[0], c[1], c[2], c[3]); - } else if (string_match("draw instanced rect", line)) { + } else if (parse_str(line, "draw instanced rect ", &rest)) { int primcount; program_must_be_in_use(); - sscanf(line + 19, "%d %f %f %f %f", + sscanf(rest, "%d %f %f %f %f", &primcount, c + 0, c + 1, c + 2, c + 3); draw_instanced_rect(primcount, c[0], c[1], c[2], c[3]); @@ -3110,10 +3072,10 @@ piglit_display(void) } bind_vao_if_supported(); glDrawArrays(mode, first, count); - } else if (string_match("disable", line)) { - do_enable_disable(line + 7, false); - } else if (string_match("enable", line)) { - do_enable_disable(line + 6, true); + } else if (parse_str(line, "disable ", &rest)) { + do_enable_disable(rest, false); + } else if (parse_str(line, "enable ", &rest)) { + do_enable_disable(rest, true); } else if (sscanf(line, "depthfunc %31s", s) == 1) { glDepthFunc(piglit_get_gl_enum_from_name(s)); } else if (sscanf(line, "fb tex 2d %d", &tex) == 1) { @@ -3170,14 +3132,12 @@ piglit_display(void) piglit_report_result(PIGLIT_FAIL); } - glGetTexLevelParameteriv(GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_WIDTH, &render_width); - glGetTexLevelParameteriv(GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_HEIGHT, &render_height); - } else if (string_match("frustum", line)) { - get_floats(line + 7, c, 6); + } else if (parse_str(line, "frustum", &rest)) { + get_floats(rest, c, 6); piglit_frustum_projection(false, c[0], c[1], c[2], c[3], c[4], c[5]); - } else if (string_match("hint", line)) { - do_hint(line + 4); + } else if (parse_str(line, "hint", &rest)) { + do_hint(rest); } else if (sscanf(line, "image texture %d %31s", &tex, s) == 2) { @@ -3194,17 +3154,17 @@ piglit_display(void) c + 0, c + 1, c + 2, c + 3) == 4) { piglit_gen_ortho_projection(c[0], c[1], c[2], c[3], -1, 1, GL_FALSE); - } else if (string_match("ortho", line)) { + } else if (parse_str(line, "ortho", NULL)) { piglit_ortho_projection(render_width, render_height, GL_FALSE); - } else if (string_match("probe rgba", line)) { - get_floats(line + 10, c, 6); + } else if (parse_str(line, "probe rgba ", &rest)) { + get_floats(rest, c, 6); if (!piglit_probe_pixel_rgba((int) c[0], (int) c[1], & c[2])) { result = PIGLIT_FAIL; } - } else if (string_match("probe depth", line)) { - get_floats(line + 11, c, 3); + } else if (parse_str(line, "probe depth ", &rest)) { + get_floats(rest, c, 3); if (!piglit_probe_pixel_depth((int) c[0], (int) c[1], c[2])) { result = PIGLIT_FAIL; @@ -3238,8 +3198,8 @@ piglit_display(void) if (!piglit_probe_pixel_rgba(x, y, &c[2])) { result = PIGLIT_FAIL; } - } else if (string_match("probe rgb", line)) { - get_floats(line + 9, c, 5); + } else if (parse_str(line, "probe rgb ", &rest)) { + get_floats(rest, c, 5); if (!piglit_probe_pixel_rgb((int) c[0], (int) c[1], & c[2])) { result = PIGLIT_FAIL; @@ -3280,29 +3240,29 @@ piglit_display(void) if (!piglit_probe_rect_rgb(x, y, w, h, &c[4])) { result = PIGLIT_FAIL; } - } else if (string_match("probe all rgba", line)) { - get_floats(line + 14, c, 4); + } else if (parse_str(line, "probe all rgba ", &rest)) { + get_floats(rest, c, 4); if (result != PIGLIT_FAIL && !piglit_probe_rect_rgba(0, 0, render_width, render_height, c)) result = PIGLIT_FAIL; - } else if (string_match("probe warn all rgba", line)) { - get_floats(line + 19, c, 4); + } else if (parse_str(line, "probe warn all rgba ", &rest)) { + get_floats(rest, c, 4); if (result == PIGLIT_PASS && !piglit_probe_rect_rgba(0, 0, render_width, render_height, c)) result = PIGLIT_WARN; - } else if (string_match("probe all rgb", line)) { - get_floats(line + 13, c, 3); + } else if (parse_str(line, "probe all rgb", &rest)) { + get_floats(rest, c, 3); if (result != PIGLIT_FAIL && !piglit_probe_rect_rgb(0, 0, render_width, render_height, c)) result = PIGLIT_FAIL; - } else if (string_match("tolerance", line)) { - get_floats(line + strlen("tolerance"), piglit_tolerance, 4); - } else if (string_match("shade model smooth", line)) { + } else if (parse_str(line, "tolerance", &rest)) { + get_floats(rest, piglit_tolerance, 4); + } else if (parse_str(line, "shade model smooth", NULL)) { glShadeModel(GL_SMOOTH); - } else if (string_match("shade model flat", line)) { + } else if (parse_str(line, "shade model flat", NULL)) { glShadeModel(GL_FLAT); } else if (sscanf(line, "ssbo %d %d", &x, &y) == 2) { GLuint *ssbo_init = calloc(y, 1); @@ -3338,12 +3298,12 @@ piglit_display(void) num_textures++; if (!piglit_is_core_profile) glEnable(GL_TEXTURE_2D); - } else if (sscanf(line, "texture integer %d ( %d", &tex, &w) == 2) { + + } else if (parse_str(line, "texture integer ", &rest)) { GLenum int_fmt; int b, a; int num_scanned = - sscanf(line, - "texture integer %d ( %d , %d ) ( %d, %d ) %31s", + sscanf(rest, "%d ( %d , %d ) ( %d, %d ) %31s", &tex, &w, &h, &b, &a, s); if (num_scanned < 6) { fprintf(stderr, @@ -3480,22 +3440,22 @@ piglit_display(void) } else if (sscanf(line, "texcoord %d ( %f , %f , %f , %f )", &x, c + 0, c + 1, c + 2, c + 3) == 5) { glMultiTexCoord4fv(GL_TEXTURE0 + x, c); - } else if (string_match("texparameter ", line)) { - handle_texparameter(line + strlen("texparameter ")); - } else if (string_match("uniform", line)) { + } else if (parse_str(line, "texparameter ", &rest)) { + handle_texparameter(rest); + } else if (parse_str(line, "uniform ", &rest)) { program_must_be_in_use(); - set_uniform(line + 7, ubo_array_index); - } else if (string_match("subuniform", line)) { + set_uniform(rest, ubo_array_index); + } else if (parse_str(line, "subuniform ", &rest)) { program_must_be_in_use(); check_shader_subroutine_support(); - set_subroutine_uniform(line + 10); - } else if (string_match("parameter ", line)) { - set_parameter(line + strlen("parameter ")); - } else if (string_match("patch parameter ", line)) { - set_patch_parameter(line + strlen("patch parameter ")); - } else if (string_match("provoking vertex ", line)) { - set_provoking_vertex(line + strlen("provoking vertex ")); - } else if (string_match("link error", line)) { + set_subroutine_uniform(rest); + } else if (parse_str(line, "parameter ", &rest)) { + set_parameter(rest); + } else if (parse_str(line, "patch parameter ", &rest)) { + set_patch_parameter(rest); + } else if (parse_str(line, "provoking vertex ", &rest)) { + set_provoking_vertex(rest); + } else if (parse_str(line, "link error", &rest)) { link_error_expected = true; if (link_ok) { printf("shader link error expected, but it was successful!\n"); @@ -3503,14 +3463,14 @@ piglit_display(void) } else { fprintf(stderr, "Failed to link:\n%s\n", prog_err_info); } - } else if (string_match("link success", line)) { + } else if (parse_str(line, "link success", &rest)) { program_must_be_in_use(); - } else if (string_match("ubo array index ", line)) { - get_ints(line + strlen("ubo array index "), &ubo_array_index, 1); - } else if (string_match("active uniform ", line)) { - active_uniform(line + strlen("active uniform ")); - } else if (string_match("verify program_interface_query ", line)) { - active_program_interface(line + strlen("verify program_interface_query ")); + } else if (parse_str(line, "ubo array index ", &rest)) { + get_ints(rest, &ubo_array_index, 1); + } else if (parse_str(line, "active uniform ", &rest)) { + active_uniform(rest); + } else if (parse_str(line, "verify program_interface_query ", &rest)) { + active_program_interface(rest); } else if ((line[0] != '\n') && (line[0] != '\0') && (line[0] != '#')) { printf("unknown command \"%s\"\n", line); -- 2.9.0 _______________________________________________ Piglit mailing list Piglit@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/piglit