Rework the get_* parser helpers used in shader_runner.c to follow the
same principle as the recently introduced parser helpers. This gives
callers the possibility to handle failure and compose numeric parsers
with other parser primitives.
---
tests/shaders/parser_utils.c | 108 +++++++++++++++++++
tests/shaders/parser_utils.h | 80 ++++++++++++++
tests/shaders/shader_runner.c | 246 ++++++++++++++++--------------------------
3 files changed, 279 insertions(+), 155 deletions(-)
diff --git a/tests/shaders/parser_utils.c b/tests/shaders/parser_utils.c
index 470144e..2eb7da1 100644
--- a/tests/shaders/parser_utils.c
+++ b/tests/shaders/parser_utils.c
@@ -49,6 +49,114 @@ parse_str(const char *s, const char *lit, const char **rest)
return ret;
}
+unsigned
+parse_ints(const char *s, int *i, unsigned n, const char **rest)
+{
+ const char *end = s;
+ unsigned j;
+
+ for (j = 0; j < n; j++) {
+ i[j] = strtoll(s = end, (char **)&end, 0);
+ if (s == end)
+ break;
+ }
+
+ if (rest)
+ *rest = end;
+
+ return j;
+}
+
+unsigned
+parse_uints(const char *s, unsigned *u, unsigned n, const char **rest)
+{
+ const char *end = s;
+ unsigned j;
+
+ for (j = 0; j < n; j++) {
+ u[j] = strtoul(s = end, (char **)&end, 0);
+ if (s == end)
+ break;
+ }
+
+ if (rest)
+ *rest = end;
+
+ return j;
+}
+
+unsigned
+parse_int64s(const char *s, int64_t *i, unsigned n, const char **rest)
+{
+ const char *end = s;
+ unsigned j;
+
+ for (j = 0; j < n; j++) {
+ i[j] = strtoll(s = end, (char **)&end, 0);
+ if (s == end)
+ break;
+ }
+
+ if (rest)
+ *rest = end;
+
+ return j;
+}
+
+unsigned
+parse_uint64s(const char *s, uint64_t *u, unsigned n, const char **rest)
+{
+ const char *end = s;
+ unsigned j;
+
+ for (j = 0; j < n; j++) {
+ u[j] = strtoull(s = end, (char **)&end, 0);
+ if (s == end)
+ break;
+ }
+
+ if (rest)
+ *rest = end;
+
+ return j;
+}
+
+unsigned
+parse_floats(const char *s, float *f, unsigned n, const char **rest)
+{
+ const char *end = s;
+ unsigned j;
+
+ for (j = 0; j < n; j++) {
+ f[j] = strtof_hex(s = end, (char **)&end);
+ if (s == end)
+ break;
+ }
+
+ if (rest)
+ *rest = end;
+
+ return j;
+}
+
+unsigned
+parse_doubles(const char *s, double *d, unsigned n, const char **rest)
+{
+ const char *end = s;
+ unsigned j;
+
+ for (j = 0; j < n; j++) {
+ d[j] = strtod_hex(s = end, (char **)&end);
+ if (s == end)
+ break;
+ }
+
+ if (rest)
+ *rest = end;
+
+ return j;
+}
+
bool
parse_word(const char *s, const char **t, const char **rest)
{
diff --git a/tests/shaders/parser_utils.h b/tests/shaders/parser_utils.h
index 8b766bc..3579bee 100644
--- a/tests/shaders/parser_utils.h
+++ b/tests/shaders/parser_utils.h
@@ -65,6 +65,86 @@ bool
parse_str(const char *s, const char *lit, const char **rest);
/**
+ * Parse up to \p n whitespace-separated signed integer values. The
+ * number of values actually parsed is returned as result.
+ */
+unsigned
+parse_ints(const char *s, int *i, unsigned n, const char **rest);
+
+static inline bool
+parse_int(const char *s, int *i, const char **rest)
+{
+ return parse_ints(s, i, 1, rest);
+}
+
+/**
+ * Parse up to \p n whitespace-separated unsigned integer values. The
+ * number of values actually parsed is returned as result.
+ */
+unsigned
+parse_uints(const char *s, unsigned *u, unsigned n, const char **rest);
+
+static inline bool
+parse_uint(const char *s, unsigned *u, const char **rest)
+{
+ return parse_uints(s, u, 1, rest);
+}
+
+/**
+ * Parse up to \p n whitespace-separated signed 64-bit integer values.
+ * The number of values actually parsed is returned as result.
+ */
+unsigned
+parse_int64s(const char *s, int64_t *i, unsigned n, const char **rest);
+
+static inline bool
+parse_int64(const char *s, int64_t *i, const char **rest)
+{
+ return parse_int64s(s, i, 1, rest);
+}
+
+/**
+ * Parse up to \p n whitespace-separated unsigned 64-bit integer
+ * values. The number of values actually parsed is returned as
+ * result.
+ */
+unsigned
+parse_uint64s(const char *s, uint64_t *u, unsigned n, const char **rest);
+
+static inline bool
+parse_uint64(const char *s, uint64_t *u, const char **rest)
+{
+ return parse_uint64s(s, u, 1, rest);
+}
+
+/**
+ * Parse up to \p n whitespace-separated floating point values. The
+ * number of values actually parsed is returned as result.
+ */
+unsigned
+parse_floats(const char *s, float *f, unsigned n, const char **rest);
+
+static inline bool
+parse_float(const char *s, float *f, const char **rest)
+{
+ return parse_floats(s, f, 1, rest);
+}
+
+/**
+ * Parse up to \p n whitespace-separated double-precision floating
+ * point values. The number of values actually parsed is returned as
+ * result.
+ */
+unsigned
+parse_doubles(const char *s, double *d, unsigned n, const char **rest);
+
+static inline bool
+parse_double(const char *s, double *d, const char **rest)
+{
+ return parse_doubles(s, d, 1, rest);
+}
+
+/**
* Parse a single non-empty whitespace-separated token. On success \p
* t and \p rest will respectively point at the first and one past the
* last character of the result.
diff --git a/tests/shaders/shader_runner.c b/tests/shaders/shader_runner.c
index 92fab38..79ffdad 100644
--- a/tests/shaders/shader_runner.c
+++ b/tests/shaders/shader_runner.c
@@ -44,9 +44,6 @@ get_required_config(const char *script_name,
static GLenum
decode_drawing_mode(const char *mode_str);
-static void
-get_uints(const char *line, unsigned *uints, unsigned count);
-
PIGLIT_GL_TEST_CONFIG_BEGIN
config.window_width = DEFAULT_WINDOW_WIDTH;
@@ -701,9 +698,10 @@ parse_version_comparison(const char *line, enum comparison
*cmp,
line = eat_whitespace(line);
line = process_comparison(line, cmp);
- line = eat_whitespace(line);
- sscanf(line, "%u.%u", &major, &minor);
- line = eat_text(line);
+ REQUIRE(parse_uint(line, &major, &line) &&
+ parse_str(line, ".", &line) &&
+ parse_uint(line, &minor, &line),
+ "Invalid version string: %s\n", line);
parse_whitespace(line, &line);
if (*line != '\n') {
@@ -778,7 +776,9 @@ process_requirement(const char *line)
"Invalid comparison enum at: %s\n", line);
line = process_comparison(eat_whitespace(line), &cmp);
- comparison_value = atoi(line);
+
+ REQUIRE(parse_int(line, &comparison_value, &line),
+ "Invalid comparison value at: %s\n", line);
glGetIntegerv(int_enum, &gl_int_value);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
@@ -884,14 +884,9 @@ process_requirement(const char *line)
}
} else if (parse_str(line, "rlimit", &line)) {
unsigned lim;
- char *ptr;
- line = eat_whitespace(line);
- lim = strtoul(line, &ptr, 0);
- if (ptr == line) {
- printf("rlimit requires numeric argument\n");
- return PIGLIT_FAIL;
- }
+ REQUIRE(parse_uint(line, &lim, &line),
+ "Invalid rlimit argument at: %s\n", line);
piglit_set_rlimit(lim);
} else if (parse_str(line, "SSO", &line) &&
@@ -1343,7 +1338,7 @@ parse_required_config(struct requirement_parse_results
*results,
}
} else if (parse_str(line, "SIZE", &line)) {
results->found_size = true;
- get_uints(line, results->size, 2);
+ parse_uints(line, results->size, 2, NULL);
} else if (parse_str(line, "depthbuffer", NULL)) {
results->found_depthbuffer = true;
}
@@ -1435,62 +1430,6 @@ get_required_config(const char *script_name,
}
}
-static void
-get_floats(const char *line, float *f, unsigned count)
-{
- unsigned i;
-
- for (i = 0; i < count; i++)
- f[i] = strtof_hex(line, (char **) &line);
-}
-
-static void
-get_doubles(const char *line, double *d, unsigned count)
-{
- unsigned i;
-
- for (i = 0; i < count; i++)
- d[i] = strtod_hex(line, (char **) &line);
-}
-
-
-static void
-get_ints(const char *line, int *ints, unsigned count)
-{
- unsigned i;
-
- for (i = 0; i < count; i++)
- ints[i] = strtol_hex(line, (char **) &line);
-}
-
-
-static void
-get_uints(const char *line, unsigned *uints, unsigned count)
-{
- unsigned i;
-
- for (i = 0; i < count; i++)
- uints[i] = strtoul(line, (char **) &line, 0);
-}
-
-static void
-get_int64s(const char *line, int64_t *ints, unsigned count)
-{
- int i;
-
- for (i = 0; i < count; i++)
- ints[i] = strtoll(line, (char **) &line, 0);
-}
-
-static void
-get_uint64s(const char *line, uint64_t *ints, unsigned count)
-{
- int i;
-
- for (i = 0; i < count; i++)
- ints[i] = strtoull(line, (char **) &line, 0);
-}
-
/**
* Check that the GL implementation supports unsigned uniforms
* (e.g. through glUniform1ui). If not, terminate the test with a
@@ -1618,46 +1557,46 @@ set_ubo_uniform(char *name, const char *type, const
char *line, int ubo_array_in
data += offset;
if (parse_str(type, "float", NULL)) {
- get_floats(line, f, 1);
+ parse_floats(line, f, 1, NULL);
memcpy(data, f, sizeof(float));
} else if (parse_str(type, "int64_t", NULL)) {
- get_int64s(line, int64s, 1);
+ parse_int64s(line, int64s, 1, NULL);
memcpy(data, int64s, sizeof(int64_t));
} else if (parse_str(type, "uint64_t", NULL)) {
- get_uint64s(line, uint64s, 1);
+ parse_uint64s(line, uint64s, 1, NULL);
memcpy(data, uint64s, sizeof(uint64_t));
} else if (parse_str(type, "int", NULL)) {
- get_ints(line, ints, 1);
+ parse_ints(line, ints, 1, NULL);
memcpy(data, ints, sizeof(int));
} else if (parse_str(type, "uint", NULL)) {
- get_uints(line, uints, 1);
+ parse_uints(line, uints, 1, NULL);
memcpy(data, uints, sizeof(int));
} else if (parse_str(type, "double", NULL)) {
- get_doubles(line, d, 1);
+ parse_doubles(line, d, 1, NULL);
memcpy(data, d, sizeof(double));
} else if (parse_str(type, "vec", NULL)) {
int elements = type[3] - '0';
- get_floats(line, f, elements);
+ parse_floats(line, f, elements, NULL);
memcpy(data, f, elements * sizeof(float));
} else if (parse_str(type, "ivec", NULL)) {
int elements = type[4] - '0';
- get_ints(line, ints, elements);
+ parse_ints(line, ints, elements, NULL);
memcpy(data, ints, elements * sizeof(int));
} else if (parse_str(type, "uvec", NULL)) {
int elements = type[4] - '0';
- get_uints(line, uints, elements);
+ parse_uints(line, uints, elements, NULL);
memcpy(data, uints, elements * sizeof(unsigned));
} else if (parse_str(type, "i64vec", NULL)) {
int elements = type[6] - '0';
- get_int64s(line, int64s, elements);
+ parse_int64s(line, int64s, elements, NULL);
memcpy(data, int64s, elements * sizeof(int64_t));
} else if (parse_str(type, "u64vec", NULL)) {
int elements = type[6] - '0';
- get_uint64s(line, uint64s, elements);
+ parse_uint64s(line, uint64s, elements, NULL);
memcpy(data, uint64s, elements * sizeof(uint64_t));
} else if (parse_str(type, "dvec", NULL)) {
int elements = type[4] - '0';
- get_doubles(line, d, elements);
+ parse_doubles(line, d, elements, NULL);
memcpy(data, d, elements * sizeof(double));
} else if (parse_str(type, "mat", NULL)) {
GLint matrix_stride, row_major;
@@ -1669,7 +1608,7 @@ set_ubo_uniform(char *name, const char *type, const char
*line, int ubo_array_in
assert(cols >= 2 && cols <= 4);
assert(rows >= 2 && rows <= 4);
- get_floats(line, f, rows * cols);
+ parse_floats(line, f, rows * cols, NULL);
glGetActiveUniformsiv(prog, 1, &uniform_index,
GL_UNIFORM_MATRIX_STRIDE, &matrix_stride);
@@ -1703,7 +1642,7 @@ set_ubo_uniform(char *name, const char *type, const char
*line, int ubo_array_in
assert(cols >= 2 && cols <= 4);
assert(rows >= 2 && rows <= 4);
- get_doubles(line, d, rows * cols);
+ parse_doubles(line, d, rows * cols, NULL);
glGetActiveUniformsiv(prog, 1, &uniform_index,
GL_UNIFORM_MATRIX_STRIDE, &matrix_stride);
@@ -1771,60 +1710,60 @@ set_uniform(const char *line, int ubo_array_index)
}
if (parse_str(type, "float", NULL)) {
- get_floats(line, f, 1);
+ parse_floats(line, f, 1, NULL);
glUniform1fv(loc, 1, f);
return;
} else if (parse_str(type, "int64_t", NULL)) {
check_int64_support();
- get_int64s(line, int64s, 1);
+ parse_int64s(line, int64s, 1, NULL);
glUniform1i64vARB(loc, 1, int64s);
return;
} else if (parse_str(type, "uint64_t", NULL)) {
check_int64_support();
- get_uint64s(line, uint64s, 1);
+ parse_uint64s(line, uint64s, 1, NULL);
glUniform1ui64vARB(loc, 1, uint64s);
return;
} else if (parse_str(type, "int", NULL)) {
- get_ints(line, ints, 1);
+ parse_ints(line, ints, 1, NULL);
glUniform1iv(loc, 1, ints);
return;
} else if (parse_str(type, "uint", NULL)) {
check_unsigned_support();
- get_uints(line, uints, 1);
+ parse_uints(line, uints, 1, NULL);
glUniform1uiv(loc, 1, uints);
return;
} else if (parse_str(type, "double", NULL)) {
check_double_support();
- get_doubles(line, d, 1);
+ parse_doubles(line, d, 1, NULL);
glUniform1dv(loc, 1, d);
return;
} else if (parse_str(type, "vec", NULL)) {
switch (type[3]) {
case '2':
- get_floats(line, f, 2);
+ parse_floats(line, f, 2, NULL);
glUniform2fv(loc, 1, f);
return;
case '3':
- get_floats(line, f, 3);
+ parse_floats(line, f, 3, NULL);
glUniform3fv(loc, 1, f);
return;
case '4':
- get_floats(line, f, 4);
+ parse_floats(line, f, 4, NULL);
glUniform4fv(loc, 1, f);
return;
}
} else if (parse_str(type, "ivec", NULL)) {
switch (type[4]) {
case '2':
- get_ints(line, ints, 2);
+ parse_ints(line, ints, 2, NULL);
glUniform2iv(loc, 1, ints);
return;
case '3':
- get_ints(line, ints, 3);
+ parse_ints(line, ints, 3, NULL);
glUniform3iv(loc, 1, ints);
return;
case '4':
- get_ints(line, ints, 4);
+ parse_ints(line, ints, 4, NULL);
glUniform4iv(loc, 1, ints);
return;
}
@@ -1832,15 +1771,15 @@ set_uniform(const char *line, int ubo_array_index)
check_unsigned_support();
switch (type[4]) {
case '2':
- get_uints(line, uints, 2);
+ parse_uints(line, uints, 2, NULL);
glUniform2uiv(loc, 1, uints);
return;
case '3':
- get_uints(line, uints, 3);
+ parse_uints(line, uints, 3, NULL);
glUniform3uiv(loc, 1, uints);
return;
case '4':
- get_uints(line, uints, 4);
+ parse_uints(line, uints, 4, NULL);
glUniform4uiv(loc, 1, uints);
return;
}
@@ -1848,15 +1787,15 @@ set_uniform(const char *line, int ubo_array_index)
check_double_support();
switch (type[4]) {
case '2':
- get_doubles(line, d, 2);
+ parse_doubles(line, d, 2, NULL);
glUniform2dv(loc, 1, d);
return;
case '3':
- get_doubles(line, d, 3);
+ parse_doubles(line, d, 3, NULL);
glUniform3dv(loc, 1, d);
return;
case '4':
- get_doubles(line, d, 4);
+ parse_doubles(line, d, 4, NULL);
glUniform4dv(loc, 1, d);
return;
}
@@ -1864,15 +1803,15 @@ set_uniform(const char *line, int ubo_array_index)
check_int64_support();
switch (type[6]) {
case '2':
- get_int64s(line, int64s, 2);
+ parse_int64s(line, int64s, 2, NULL);
glUniform2i64vARB(loc, 1, int64s);
return;
case '3':
- get_int64s(line, int64s, 3);
+ parse_int64s(line, int64s, 3, NULL);
glUniform3i64vARB(loc, 1, int64s);
return;
case '4':
- get_int64s(line, int64s, 4);
+ parse_int64s(line, int64s, 4, NULL);
glUniform4i64vARB(loc, 1, int64s);
return;
}
@@ -1880,15 +1819,15 @@ set_uniform(const char *line, int ubo_array_index)
check_int64_support();
switch (type[6]) {
case '2':
- get_uint64s(line, uint64s, 2);
+ parse_uint64s(line, uint64s, 2, NULL);
glUniform2ui64vARB(loc, 1, uint64s);
return;
case '3':
- get_uint64s(line, uint64s, 3);
+ parse_uint64s(line, uint64s, 3, NULL);
glUniform3ui64vARB(loc, 1, uint64s);
return;
case '4':
- get_uint64s(line, uint64s, 4);
+ parse_uint64s(line, uint64s, 4, NULL);
glUniform4ui64vARB(loc, 1, uint64s);
return;
}
@@ -1899,45 +1838,45 @@ set_uniform(const char *line, int ubo_array_index)
case '2':
switch (rows) {
case '2':
- get_floats(line, f, 4);
+ parse_floats(line, f, 4, NULL);
glUniformMatrix2fv(loc, 1, GL_FALSE, f);
return;
case '3':
- get_floats(line, f, 6);
+ parse_floats(line, f, 6, NULL);
glUniformMatrix2x3fv(loc, 1, GL_FALSE, f);
return;
case '4':
- get_floats(line, f, 8);
+ parse_floats(line, f, 8, NULL);
glUniformMatrix2x4fv(loc, 1, GL_FALSE, f);
return;
}
case '3':
switch (rows) {
case '2':
- get_floats(line, f, 6);
+ parse_floats(line, f, 6, NULL);
glUniformMatrix3x2fv(loc, 1, GL_FALSE, f);
return;
case '3':
- get_floats(line, f, 9);
+ parse_floats(line, f, 9, NULL);
glUniformMatrix3fv(loc, 1, GL_FALSE, f);
return;
case '4':
- get_floats(line, f, 12);
+ parse_floats(line, f, 12, NULL);
glUniformMatrix3x4fv(loc, 1, GL_FALSE, f);
return;
}
case '4':
switch (rows) {
case '2':
- get_floats(line, f, 8);
+ parse_floats(line, f, 8, NULL);
glUniformMatrix4x2fv(loc, 1, GL_FALSE, f);
return;
case '3':
- get_floats(line, f, 12);
+ parse_floats(line, f, 12, NULL);
glUniformMatrix4x3fv(loc, 1, GL_FALSE, f);
return;
case '4':
- get_floats(line, f, 16);
+ parse_floats(line, f, 16, NULL);
glUniformMatrix4fv(loc, 1, GL_FALSE, f);
return;
}
@@ -1949,45 +1888,45 @@ set_uniform(const char *line, int ubo_array_index)
case '2':
switch (rows) {
case '2':
- get_doubles(line, d, 4);
+ parse_doubles(line, d, 4, NULL);
glUniformMatrix2dv(loc, 1, GL_FALSE, d);
return;
case '3':
- get_doubles(line, d, 6);
+ parse_doubles(line, d, 6, NULL);
glUniformMatrix2x3dv(loc, 1, GL_FALSE, d);
return;
case '4':
- get_doubles(line, d, 8);
+ parse_doubles(line, d, 8, NULL);
glUniformMatrix2x4dv(loc, 1, GL_FALSE, d);
return;
}
case '3':
switch (rows) {
case '2':
- get_doubles(line, d, 6);
+ parse_doubles(line, d, 6, NULL);
glUniformMatrix3x2dv(loc, 1, GL_FALSE, d);
return;
case '3':
- get_doubles(line, d, 9);
+ parse_doubles(line, d, 9, NULL);
glUniformMatrix3dv(loc, 1, GL_FALSE, d);
return;
case '4':
- get_doubles(line, d, 12);
+ parse_doubles(line, d, 12, NULL);
glUniformMatrix3x4dv(loc, 1, GL_FALSE, d);
return;
}
case '4':
switch (rows) {
case '2':
- get_doubles(line, d, 8);
+ parse_doubles(line, d, 8, NULL);
glUniformMatrix4x2dv(loc, 1, GL_FALSE, d);
return;
case '3':
- get_doubles(line, d, 12);
+ parse_doubles(line, d, 12, NULL);
glUniformMatrix4x3dv(loc, 1, GL_FALSE, d);
return;
case '4':
- get_doubles(line, d, 16);
+ parse_doubles(line, d, 16, NULL);
glUniformMatrix4dv(loc, 1, GL_FALSE, d);
return;
}
@@ -2162,6 +2101,7 @@ active_uniform(const char *line)
{ NULL, 0 }
};
+ const char *rest = line;
char name[512];
char name_buf[512];
char pname_string[512];
@@ -2170,17 +2110,15 @@ active_uniform(const char *line)
int i;
int num_active_uniforms;
- REQUIRE(parse_word_copy(line, name, sizeof(name), &line),
+ REQUIRE(parse_word_copy(rest, name, sizeof(name), &rest),
"Bad uniform name at: %s\n", line);
- strcpy_to_space(pname_string, eat_whitespace(line));
- pname = lookup_enum_string(all_pnames, &line, "glGetUniformsiv pname");
+ strcpy_to_space(pname_string, eat_whitespace(rest));
+ pname = lookup_enum_string(all_pnames, &rest, "glGetUniformsiv pname");
- line = eat_whitespace(line);
- if (isdigit(line[0])) {
- expected = strtol(line, NULL, 0);
- } else {
- expected = lookup_enum_string(all_types, &line, "type enum");
+ if (!parse_int(rest, &expected, &rest)) {
+ rest = eat_whitespace(rest);
+ expected = lookup_enum_string(all_types, &rest, "type enum");
}
glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &num_active_uniforms);
@@ -2362,10 +2300,8 @@ active_program_interface(const char *line)
prop = lookup_enum_string(all_props, &line,
"glGetProgramResourceiv pname");
- line = eat_whitespace(line);
- if (isdigit(line[0])) {
- expected = strtol(line, NULL, 0);
- } else {
+ if (!parse_int(line, &expected, &line)) {
+ line = eat_whitespace(line);
expected = lookup_enum_string(all_types, &line, "type enum");
}
@@ -2975,11 +2911,11 @@ piglit_display(void)
sizeof(GLuint) * y, sizeof(GLuint),
&z);
} else if (parse_str(line, "clear color ", &rest)) {
- get_floats(rest, c, 4);
+ parse_floats(rest, c, 4, NULL);
glClearColor(c[0], c[1], c[2], c[3]);
clear_bits |= GL_COLOR_BUFFER_BIT;
} else if (parse_str(line, "clear depth ", &rest)) {
- get_floats(rest, c, 1);
+ parse_floats(rest, c, 1, NULL);
glClearDepth(c[0]);
clear_bits |= GL_DEPTH_BUFFER_BIT;
} else if (parse_str(line, "clear", NULL)) {
@@ -3009,13 +2945,13 @@ piglit_display(void)
} else if (parse_str(line, "draw rect tex ", &rest)) {
program_must_be_in_use();
program_subroutine_uniforms();
- get_floats(rest, c, 8);
+ parse_floats(rest, c, 8, NULL);
piglit_draw_rect_tex(c[0], c[1], c[2], c[3],
c[4], c[5], c[6], c[7]);
} else if (parse_str(line, "draw rect ortho patch ", &rest)) {
program_must_be_in_use();
program_subroutine_uniforms();
- get_floats(rest, c, 4);
+ parse_floats(rest, c, 4, NULL);
piglit_draw_rect_custom(-1.0 + 2.0 * (c[0] /
piglit_width),
-1.0 + 2.0 * (c[1] /
piglit_height),
@@ -3024,7 +2960,7 @@ piglit_display(void)
} else if (parse_str(line, "draw rect ortho ", &rest)) {
program_must_be_in_use();
program_subroutine_uniforms();
- get_floats(rest, c, 4);
+ parse_floats(rest, c, 4, NULL);
piglit_draw_rect(-1.0 + 2.0 * (c[0] / piglit_width),
-1.0 + 2.0 * (c[1] / piglit_height),
@@ -3032,12 +2968,12 @@ piglit_display(void)
2.0 * (c[3] / piglit_height));
} else if (parse_str(line, "draw rect patch ", &rest)) {
program_must_be_in_use();
- get_floats(rest, c, 4);
+ parse_floats(rest, c, 4, NULL);
piglit_draw_rect_custom(c[0], c[1], c[2], c[3], true);
} else if (parse_str(line, "draw rect ", &rest)) {
program_must_be_in_use();
program_subroutine_uniforms();
- get_floats(rest, c, 4);
+ parse_floats(rest, c, 4, NULL);
piglit_draw_rect(c[0], c[1], c[2], c[3]);
} else if (parse_str(line, "draw instanced rect ", &rest)) {
int primcount;
@@ -3133,7 +3069,7 @@ piglit_display(void)
}
} else if (parse_str(line, "frustum", &rest)) {
- get_floats(rest, c, 6);
+ parse_floats(rest, c, 6, NULL);
piglit_frustum_projection(false, c[0], c[1], c[2],
c[3], c[4], c[5]);
} else if (parse_str(line, "hint", &rest)) {
@@ -3158,13 +3094,13 @@ piglit_display(void)
piglit_ortho_projection(render_width, render_height,
GL_FALSE);
} else if (parse_str(line, "probe rgba ", &rest)) {
- get_floats(rest, c, 6);
+ parse_floats(rest, c, 6, NULL);
if (!piglit_probe_pixel_rgba((int) c[0], (int) c[1],
& c[2])) {
result = PIGLIT_FAIL;
}
} else if (parse_str(line, "probe depth ", &rest)) {
- get_floats(rest, c, 3);
+ parse_floats(rest, c, 3, NULL);
if (!piglit_probe_pixel_depth((int) c[0], (int) c[1],
c[2])) {
result = PIGLIT_FAIL;
@@ -3199,7 +3135,7 @@ piglit_display(void)
result = PIGLIT_FAIL;
}
} else if (parse_str(line, "probe rgb ", &rest)) {
- get_floats(rest, c, 5);
+ parse_floats(rest, c, 5, NULL);
if (!piglit_probe_pixel_rgb((int) c[0], (int) c[1],
& c[2])) {
result = PIGLIT_FAIL;
@@ -3241,25 +3177,25 @@ piglit_display(void)
result = PIGLIT_FAIL;
}
} else if (parse_str(line, "probe all rgba ", &rest)) {
- get_floats(rest, c, 4);
+ parse_floats(rest, c, 4, NULL);
if (result != PIGLIT_FAIL &&
!piglit_probe_rect_rgba(0, 0, render_width,
render_height, c))
result = PIGLIT_FAIL;
} else if (parse_str(line, "probe warn all rgba ", &rest)) {
- get_floats(rest, c, 4);
+ parse_floats(rest, c, 4, NULL);
if (result == PIGLIT_PASS &&
!piglit_probe_rect_rgba(0, 0, render_width,
render_height, c))
result = PIGLIT_WARN;
} else if (parse_str(line, "probe all rgb", &rest)) {
- get_floats(rest, c, 3);
+ parse_floats(rest, c, 3, NULL);
if (result != PIGLIT_FAIL &&
!piglit_probe_rect_rgb(0, 0, render_width,
render_height, c))
result = PIGLIT_FAIL;
} else if (parse_str(line, "tolerance", &rest)) {
- get_floats(rest, piglit_tolerance, 4);
+ parse_floats(rest, piglit_tolerance, 4, NULL);
} else if (parse_str(line, "shade model smooth", NULL)) {
glShadeModel(GL_SMOOTH);
} else if (parse_str(line, "shade model flat", NULL)) {
@@ -3466,7 +3402,7 @@ piglit_display(void)
} else if (parse_str(line, "link success", &rest)) {
program_must_be_in_use();
} else if (parse_str(line, "ubo array index ", &rest)) {
- get_ints(rest, &ubo_array_index, 1);
+ parse_ints(rest, &ubo_array_index, 1, NULL);
} else if (parse_str(line, "active uniform ", &rest)) {
active_uniform(rest);
} else if (parse_str(line, "verify program_interface_query ",
&rest)) {
--
2.9.0
_______________________________________________
Piglit mailing list
Piglit@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/piglit
