OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ir_reader: Relax requirement that function arguments be s_lists.

Browse Source 
All of these functions used to take s_list pointers so they wouldn't all
need SX_AS_LIST conversions and error checking.  However, the new
pattern matcher conveniently does this for us in one centralized place.

So there's no need to insist on s_list.  Switching to s_expression saves
a bit of code and is somewhat cleaner.
This commit is contained in:
Kenneth Graunke
2010-12-31 02:03:21 -08:00
parent d798815272
commit e486fca2d3
1 changed files with 78 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

163
src/glsl/ir_reader.cpp
View File

@@ -38,7 +38,7 @@ static const glsl_type *read_type(_mesa_glsl_parse_state *, s_expression *);
static void scan_for_prototypes(_mesa_glsl_parse_state *, exec_list *, static void scan_for_prototypes(_mesa_glsl_parse_state *, exec_list *,
s_expression *); s_expression *);
static ir_function *read_function(_mesa_glsl_parse_state *, s_list *, static ir_function *read_function(_mesa_glsl_parse_state *, s_expression *,
bool skip_body); bool skip_body);
static void read_function_sig(_mesa_glsl_parse_state *, ir_function *, static void read_function_sig(_mesa_glsl_parse_state *, ir_function *,
s_expression *, bool skip_body); s_expression *, bool skip_body);
@@ -47,27 +47,27 @@ static void read_instructions(_mesa_glsl_parse_state *, exec_list *,
s_expression *, ir_loop *); s_expression *, ir_loop *);
static ir_instruction *read_instruction(_mesa_glsl_parse_state *, static ir_instruction *read_instruction(_mesa_glsl_parse_state *,
s_expression *, ir_loop *); s_expression *, ir_loop *);
static ir_variable *read_declaration(_mesa_glsl_parse_state *, s_list *); static ir_variable *read_declaration(_mesa_glsl_parse_state *, s_expression *);
static ir_if *read_if(_mesa_glsl_parse_state *, s_list *, ir_loop *); static ir_if *read_if(_mesa_glsl_parse_state *, s_expression *, ir_loop *);
static ir_loop *read_loop(_mesa_glsl_parse_state *st, s_list *list); static ir_loop *read_loop(_mesa_glsl_parse_state *st, s_expression *);
static ir_return *read_return(_mesa_glsl_parse_state *, s_list *); static ir_return *read_return(_mesa_glsl_parse_state *, s_expression *);
static ir_rvalue *read_rvalue(_mesa_glsl_parse_state *, s_expression *); static ir_rvalue *read_rvalue(_mesa_glsl_parse_state *, s_expression *);
static ir_assignment *read_assignment(_mesa_glsl_parse_state *, s_list *); static ir_assignment *read_assignment(_mesa_glsl_parse_state *, s_expression *);
static ir_expression *read_expression(_mesa_glsl_parse_state *, s_list *); static ir_expression *read_expression(_mesa_glsl_parse_state *, s_expression *);
static ir_call *read_call(_mesa_glsl_parse_state *, s_list *); static ir_call *read_call(_mesa_glsl_parse_state *, s_expression *);
static ir_swizzle *read_swizzle(_mesa_glsl_parse_state *, s_list *); static ir_swizzle *read_swizzle(_mesa_glsl_parse_state *, s_expression *);
static ir_constant *read_constant(_mesa_glsl_parse_state *, s_list *); static ir_constant *read_constant(_mesa_glsl_parse_state *, s_expression *);
static ir_texture *read_texture(_mesa_glsl_parse_state *, s_list *); static ir_texture *read_texture(_mesa_glsl_parse_state *, s_expression *);
static ir_dereference *read_dereference(_mesa_glsl_parse_state *, static ir_dereference *read_dereference(_mesa_glsl_parse_state *,
s_expression *); s_expression *);
static ir_dereference_variable * static ir_dereference_variable *
read_var_ref(_mesa_glsl_parse_state *, s_list *); read_var_ref(_mesa_glsl_parse_state *, s_expression *);
static ir_dereference_array * static ir_dereference_array *
read_array_ref(_mesa_glsl_parse_state *, s_list *); read_array_ref(_mesa_glsl_parse_state *, s_expression *);
static ir_dereference_record * static ir_dereference_record *
read_record_ref(_mesa_glsl_parse_state *, s_list *); read_record_ref(_mesa_glsl_parse_state *, s_expression *);
void void
_mesa_glsl_read_ir(_mesa_glsl_parse_state *state, exec_list *instructions, _mesa_glsl_read_ir(_mesa_glsl_parse_state *state, exec_list *instructions,
@@ -177,15 +177,15 @@ scan_for_prototypes(_mesa_glsl_parse_state *st, exec_list *instructions,
} }
static ir_function * static ir_function *
read_function(_mesa_glsl_parse_state *st, s_list *list, bool skip_body) read_function(_mesa_glsl_parse_state *st, s_expression *expr, bool skip_body)
{ {
void *ctx = st; void *ctx = st;
bool added = false; bool added = false;
s_symbol *name; s_symbol *name;
s_pattern pat[] = { "function", name }; s_pattern pat[] = { "function", name };
if (!PARTIAL_MATCH(list, pat)) { if (!PARTIAL_MATCH(expr, pat)) {
ir_read_error(st, list, "Expected (function <name> (signature ...) ...)"); ir_read_error(st, expr, "Expected (function <name> (signature ...) ...)");
return NULL; return NULL;
} }
@@ -196,7 +196,7 @@ read_function(_mesa_glsl_parse_state *st, s_list *list, bool skip_body)
assert(added); assert(added);
} }
exec_list_iterator it = list->subexpressions.iterator(); exec_list_iterator it = ((s_list *) expr)->subexpressions.iterator();
it.next(); // skip "function" tag it.next(); // skip "function" tag
it.next(); // skip function name it.next(); // skip function name
for (/* nothing */; it.has_next(); it.next()) { for (/* nothing */; it.has_next(); it.next()) {
@@ -238,8 +238,7 @@ read_function_sig(_mesa_glsl_parse_state *st, ir_function *f,
exec_list_iterator it = paramlist->subexpressions.iterator(); exec_list_iterator it = paramlist->subexpressions.iterator();
for (it.next() /* skip "parameters" */; it.has_next(); it.next()) { for (it.next() /* skip "parameters" */; it.has_next(); it.next()) {
s_list *decl = SX_AS_LIST(it.get()); ir_variable *var = read_declaration(st, (s_expression *) it.get());
ir_variable *var = read_declaration(st, decl);
if (var == NULL) if (var == NULL)
return; return;
@@ -364,15 +363,15 @@ read_instruction(_mesa_glsl_parse_state *st, s_expression *expr,
} }
static ir_variable * static ir_variable *
read_declaration(_mesa_glsl_parse_state *st, s_list *list) read_declaration(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
s_list *s_quals; s_list *s_quals;
s_expression *s_type; s_expression *s_type;
s_symbol *s_name; s_symbol *s_name;
s_pattern pat[] = { "declare", s_quals, s_type, s_name }; s_pattern pat[] = { "declare", s_quals, s_type, s_name };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (declare (<qualifiers>) <type> " ir_read_error(st, expr, "expected (declare (<qualifiers>) <type> "
"<name>)"); "<name>)");
return NULL; return NULL;
} }
@@ -386,7 +385,7 @@ read_declaration(_mesa_glsl_parse_state *st, s_list *list)
foreach_iter(exec_list_iterator, it, s_quals->subexpressions) { foreach_iter(exec_list_iterator, it, s_quals->subexpressions) {
s_symbol *qualifier = SX_AS_SYMBOL(it.get()); s_symbol *qualifier = SX_AS_SYMBOL(it.get());
if (qualifier == NULL) { if (qualifier == NULL) {
ir_read_error(st, list, "qualifier list must contain only symbols"); ir_read_error(st, expr, "qualifier list must contain only symbols");
return NULL; return NULL;
} }
@@ -412,7 +411,7 @@ read_declaration(_mesa_glsl_parse_state *st, s_list *list)
} else if (strcmp(qualifier->value(), "noperspective") == 0) { } else if (strcmp(qualifier->value(), "noperspective") == 0) {
var->interpolation = ir_var_noperspective; var->interpolation = ir_var_noperspective;
} else { } else {
ir_read_error(st, list, "unknown qualifier: %s", qualifier->value()); ir_read_error(st, expr, "unknown qualifier: %s", qualifier->value());
return NULL; return NULL;
} }
} }
@@ -425,15 +424,15 @@ read_declaration(_mesa_glsl_parse_state *st, s_list *list)
static ir_if * static ir_if *
read_if(_mesa_glsl_parse_state *st, s_list *list, ir_loop *loop_ctx) read_if(_mesa_glsl_parse_state *st, s_expression *expr, ir_loop *loop_ctx)
{ {
s_expression *s_cond; s_expression *s_cond;
s_expression *s_then; s_expression *s_then;
s_expression *s_else; s_expression *s_else;
s_pattern pat[] = { "if", s_cond, s_then, s_else }; s_pattern pat[] = { "if", s_cond, s_then, s_else };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (if <condition> (<then> ...) " ir_read_error(st, expr, "expected (if <condition> (<then> ...) "
"(<else> ...))"); "(<else> ...))");
return NULL; return NULL;
} }
@@ -457,13 +456,13 @@ read_if(_mesa_glsl_parse_state *st, s_list *list, ir_loop *loop_ctx)
static ir_loop * static ir_loop *
read_loop(_mesa_glsl_parse_state *st, s_list *list) read_loop(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
s_expression *s_counter, *s_from, *s_to, *s_inc, *s_body; s_expression *s_counter, *s_from, *s_to, *s_inc, *s_body;
s_pattern pat[] = { "loop", s_counter, s_from, s_to, s_inc, s_body }; s_pattern pat[] = { "loop", s_counter, s_from, s_to, s_inc, s_body };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (loop <counter> <from> <to> " ir_read_error(st, expr, "expected (loop <counter> <from> <to> "
"<increment> <body>)"); "<increment> <body>)");
return NULL; return NULL;
} }
@@ -481,17 +480,17 @@ read_loop(_mesa_glsl_parse_state *st, s_list *list)
static ir_return * static ir_return *
read_return(_mesa_glsl_parse_state *st, s_list *list) read_return(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
s_expression *expr; s_expression *s_retval;
s_pattern pat[] = { "return", expr }; s_pattern pat[] = { "return", s_retval};
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (return <rvalue>)"); ir_read_error(st, expr, "expected (return <rvalue>)");
return NULL; return NULL;
} }
ir_rvalue *retval = read_rvalue(st, expr); ir_rvalue *retval = read_rvalue(st, s_retval);
if (retval == NULL) { if (retval == NULL) {
ir_read_error(st, NULL, "when reading return value"); ir_read_error(st, NULL, "when reading return value");
return NULL; return NULL;
@@ -535,14 +534,14 @@ read_rvalue(_mesa_glsl_parse_state *st, s_expression *expr)
} }
static ir_assignment * static ir_assignment *
read_assignment(_mesa_glsl_parse_state *st, s_list *list) read_assignment(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
s_expression *cond_expr, *lhs_expr, *rhs_expr; s_expression *cond_expr, *lhs_expr, *rhs_expr;
s_list *mask_list; s_list *mask_list;
s_pattern pat[] = { "assign", cond_expr, mask_list, lhs_expr, rhs_expr }; s_pattern pat[] = { "assign", cond_expr, mask_list, lhs_expr, rhs_expr };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (assign <condition> (<write mask>) " ir_read_error(st, expr, "expected (assign <condition> (<write mask>) "
"<lhs> <rhs>)"); "<lhs> <rhs>)");
return NULL; return NULL;
} }
@@ -561,7 +560,7 @@ read_assignment(_mesa_glsl_parse_state *st, s_list *list)
const char *mask_str = mask_symbol->value(); const char *mask_str = mask_symbol->value();
unsigned mask_length = strlen(mask_str); unsigned mask_length = strlen(mask_str);
if (mask_length > 4) { if (mask_length > 4) {
ir_read_error(st, list, "invalid write mask: %s", mask_str); ir_read_error(st, expr, "invalid write mask: %s", mask_str);
return NULL; return NULL;
} }
@@ -569,7 +568,7 @@ read_assignment(_mesa_glsl_parse_state *st, s_list *list)
for (unsigned i = 0; i < mask_length; i++) { for (unsigned i = 0; i < mask_length; i++) {
if (mask_str[i] < 'w' || mask_str[i] > 'z') { if (mask_str[i] < 'w' || mask_str[i] > 'z') {
ir_read_error(st, list, "write mask contains invalid character: %c", ir_read_error(st, expr, "write mask contains invalid character: %c",
mask_str[i]); mask_str[i]);
return NULL; return NULL;
} }
@@ -593,7 +592,7 @@ read_assignment(_mesa_glsl_parse_state *st, s_list *list)
} }
if (mask == 0 && (lhs->type->is_vector() || lhs->type->is_scalar())) { if (mask == 0 && (lhs->type->is_vector() || lhs->type->is_scalar())) {
ir_read_error(st, list, "non-zero write mask required."); ir_read_error(st, expr, "non-zero write mask required.");
return NULL; return NULL;
} }
@@ -601,15 +600,15 @@ read_assignment(_mesa_glsl_parse_state *st, s_list *list)
} }
static ir_call * static ir_call *
read_call(_mesa_glsl_parse_state *st, s_list *list) read_call(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
void *ctx = st; void *ctx = st;
s_symbol *name; s_symbol *name;
s_list *params; s_list *params;
s_pattern pat[] = { "call", name, params }; s_pattern pat[] = { "call", name, params };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (call <name> (<param> ...))"); ir_read_error(st, expr, "expected (call <name> (<param> ...))");
return NULL; return NULL;
} }
@@ -619,7 +618,7 @@ read_call(_mesa_glsl_parse_state *st, s_list *list)
s_expression *expr = (s_expression*) it.get(); s_expression *expr = (s_expression*) it.get();
ir_rvalue *param = read_rvalue(st, expr); ir_rvalue *param = read_rvalue(st, expr);
if (param == NULL) { if (param == NULL) {
ir_read_error(st, list, "when reading parameter to function call"); ir_read_error(st, expr, "when reading parameter to function call");
return NULL; return NULL;
} }
parameters.push_tail(param); parameters.push_tail(param);
@@ -627,14 +626,14 @@ read_call(_mesa_glsl_parse_state *st, s_list *list)
ir_function *f = st->symbols->get_function(name->value()); ir_function *f = st->symbols->get_function(name->value());
if (f == NULL) { if (f == NULL) {
ir_read_error(st, list, "found call to undefined function %s", ir_read_error(st, expr, "found call to undefined function %s",
name->value()); name->value());
return NULL; return NULL;
} }
ir_function_signature *callee = f->matching_signature(&parameters); ir_function_signature *callee = f->matching_signature(&parameters);
if (callee == NULL) { if (callee == NULL) {
ir_read_error(st, list, "couldn't find matching signature for function " ir_read_error(st, expr, "couldn't find matching signature for function "
"%s", name->value()); "%s", name->value());
return NULL; return NULL;
} }
@@ -643,7 +642,7 @@ read_call(_mesa_glsl_parse_state *st, s_list *list)
} }
static ir_expression * static ir_expression *
read_expression(_mesa_glsl_parse_state *st, s_list *list) read_expression(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
void *ctx = st; void *ctx = st;
s_expression *s_type; s_expression *s_type;
@@ -651,8 +650,8 @@ read_expression(_mesa_glsl_parse_state *st, s_list *list)
s_expression *s_arg1; s_expression *s_arg1;
s_pattern pat[] = { "expression", s_type, s_op, s_arg1 }; s_pattern pat[] = { "expression", s_type, s_op, s_arg1 };
if (!PARTIAL_MATCH(list, pat)) { if (!PARTIAL_MATCH(expr, pat)) {
ir_read_error(st, list, "expected (expression <type> <operator> " ir_read_error(st, expr, "expected (expression <type> <operator> "
"<operand> [<operand>])"); "<operand> [<operand>])");
return NULL; return NULL;
} }
@@ -665,13 +664,13 @@ read_expression(_mesa_glsl_parse_state *st, s_list *list)
/* Read the operator */ /* Read the operator */
ir_expression_operation op = ir_expression::get_operator(s_op->value()); ir_expression_operation op = ir_expression::get_operator(s_op->value());
if (op == (ir_expression_operation) -1) { if (op == (ir_expression_operation) -1) {
ir_read_error(st, list, "invalid operator: %s", s_op->value()); ir_read_error(st, expr, "invalid operator: %s", s_op->value());
return NULL; return NULL;
} }
unsigned num_operands = ir_expression::get_num_operands(op); unsigned num_operands = ir_expression::get_num_operands(op);
if (num_operands == 1 && !s_arg1->next->is_tail_sentinel()) { if (num_operands == 1 && !s_arg1->next->is_tail_sentinel()) {
ir_read_error(st, list, "expected (expression <type> %s <operand>)", ir_read_error(st, expr, "expected (expression <type> %s <operand>)",
s_op->value()); s_op->value());
return NULL; return NULL;
} }
@@ -686,7 +685,7 @@ read_expression(_mesa_glsl_parse_state *st, s_list *list)
if (num_operands == 2) { if (num_operands == 2) {
if (s_arg2->is_tail_sentinel() || !s_arg2->next->is_tail_sentinel()) { if (s_arg2->is_tail_sentinel() || !s_arg2->next->is_tail_sentinel()) {
ir_read_error(st, list, "expected (expression <type> %s <operand> " ir_read_error(st, expr, "expected (expression <type> %s <operand> "
"<operand>)", s_op->value()); "<operand>)", s_op->value());
return NULL; return NULL;
} }
@@ -702,19 +701,19 @@ read_expression(_mesa_glsl_parse_state *st, s_list *list)
} }
static ir_swizzle * static ir_swizzle *
read_swizzle(_mesa_glsl_parse_state *st, s_list *list) read_swizzle(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
s_symbol *swiz; s_symbol *swiz;
s_expression *sub; s_expression *sub;
s_pattern pat[] = { "swiz", swiz, sub }; s_pattern pat[] = { "swiz", swiz, sub };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (swiz <swizzle> <rvalue>)"); ir_read_error(st, expr, "expected (swiz <swizzle> <rvalue>)");
return NULL; return NULL;
} }
if (strlen(swiz->value()) > 4) { if (strlen(swiz->value()) > 4) {
ir_read_error(st, list, "expected a valid swizzle; found %s", ir_read_error(st, expr, "expected a valid swizzle; found %s",
swiz->value()); swiz->value());
return NULL; return NULL;
} }
@@ -726,21 +725,21 @@ read_swizzle(_mesa_glsl_parse_state *st, s_list *list)
ir_swizzle *ir = ir_swizzle::create(rvalue, swiz->value(), ir_swizzle *ir = ir_swizzle::create(rvalue, swiz->value(),
rvalue->type->vector_elements); rvalue->type->vector_elements);
if (ir == NULL) if (ir == NULL)
ir_read_error(st, list, "invalid swizzle"); ir_read_error(st, expr, "invalid swizzle");
return ir; return ir;
} }
static ir_constant * static ir_constant *
read_constant(_mesa_glsl_parse_state *st, s_list *list) read_constant(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
void *ctx = st; void *ctx = st;
s_expression *type_expr; s_expression *type_expr;
s_list *values; s_list *values;
s_pattern pat[] = { "constant", type_expr, values }; s_pattern pat[] = { "constant", type_expr, values };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (constant <type> (...))"); ir_read_error(st, expr, "expected (constant <type> (...))");
return NULL; return NULL;
} }
@@ -749,7 +748,7 @@ read_constant(_mesa_glsl_parse_state *st, s_list *list)
return NULL; return NULL;
if (values == NULL) { if (values == NULL) {
ir_read_error(st, list, "expected (constant <type> (...))"); ir_read_error(st, expr, "expected (constant <type> (...))");
return NULL; return NULL;
} }
@@ -757,13 +756,7 @@ read_constant(_mesa_glsl_parse_state *st, s_list *list)
unsigned elements_supplied = 0; unsigned elements_supplied = 0;
exec_list elements; exec_list elements;
foreach_iter(exec_list_iterator, it, values->subexpressions) { foreach_iter(exec_list_iterator, it, values->subexpressions) {
s_expression *expr = (s_expression *) it.get(); s_expression *elt = (s_expression *) it.get();
s_list *elt = SX_AS_LIST(expr);
if (elt == NULL) {
ir_read_error(st, expr, "expected (constant ...) array element");
return NULL;
}
ir_constant *ir_elt = read_constant(st, elt); ir_constant *ir_elt = read_constant(st, elt);
if (ir_elt == NULL) if (ir_elt == NULL)
return NULL; return NULL;
@@ -851,20 +844,20 @@ read_dereference(_mesa_glsl_parse_state *st, s_expression *expr)
} }
static ir_dereference_variable * static ir_dereference_variable *
read_var_ref(_mesa_glsl_parse_state *st, s_list *list) read_var_ref(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
void *ctx = st; void *ctx = st;
s_symbol *var_name; s_symbol *var_name;
s_pattern pat[] = { "var_ref", var_name }; s_pattern pat[] = { "var_ref", var_name };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (var_ref <variable name>)"); ir_read_error(st, expr, "expected (var_ref <variable name>)");
return NULL; return NULL;
} }
ir_variable *var = st->symbols->get_variable(var_name->value()); ir_variable *var = st->symbols->get_variable(var_name->value());
if (var == NULL) { if (var == NULL) {
ir_read_error(st, list, "undeclared variable: %s", var_name->value()); ir_read_error(st, expr, "undeclared variable: %s", var_name->value());
return NULL; return NULL;
} }
@@ -872,15 +865,15 @@ read_var_ref(_mesa_glsl_parse_state *st, s_list *list)
} }
static ir_dereference_array * static ir_dereference_array *
read_array_ref(_mesa_glsl_parse_state *st, s_list *list) read_array_ref(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
void *ctx = st; void *ctx = st;
s_expression *subj_expr; s_expression *subj_expr;
s_expression *idx_expr; s_expression *idx_expr;
s_pattern pat[] = { "array_ref", subj_expr, idx_expr }; s_pattern pat[] = { "array_ref", subj_expr, idx_expr };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (array_ref <rvalue> <index>)"); ir_read_error(st, expr, "expected (array_ref <rvalue> <index>)");
return NULL; return NULL;
} }
@@ -895,15 +888,15 @@ read_array_ref(_mesa_glsl_parse_state *st, s_list *list)
} }
static ir_dereference_record * static ir_dereference_record *
read_record_ref(_mesa_glsl_parse_state *st, s_list *list) read_record_ref(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
void *ctx = st; void *ctx = st;
s_expression *subj_expr; s_expression *subj_expr;
s_symbol *field; s_symbol *field;
s_pattern pat[] = { "record_ref", subj_expr, field }; s_pattern pat[] = { "record_ref", subj_expr, field };
if (!MATCH(list, pat)) { if (!MATCH(expr, pat)) {
ir_read_error(st, list, "expected (record_ref <rvalue> <field>)"); ir_read_error(st, expr, "expected (record_ref <rvalue> <field>)");
return NULL; return NULL;
} }
@@ -916,7 +909,7 @@ read_record_ref(_mesa_glsl_parse_state *st, s_list *list)
} }
static ir_texture * static ir_texture *
read_texture(_mesa_glsl_parse_state *st, s_list *list) read_texture(_mesa_glsl_parse_state *st, s_expression *expr)
{ {
s_symbol *tag = NULL; s_symbol *tag = NULL;
s_expression *s_sampler = NULL; s_expression *s_sampler = NULL;
@@ -935,11 +928,11 @@ read_texture(_mesa_glsl_parse_state *st, s_list *list)
s_pattern other_pattern[] = s_pattern other_pattern[] =
{ tag, s_sampler, s_coord, s_offset, s_proj, s_shadow, s_lod }; { tag, s_sampler, s_coord, s_offset, s_proj, s_shadow, s_lod };
if (MATCH(list, tex_pattern)) { if (MATCH(expr, tex_pattern)) {
op = ir_tex; op = ir_tex;
} else if (MATCH(list, txf_pattern)) { } else if (MATCH(expr, txf_pattern)) {
op = ir_txf; op = ir_txf;
} else if (MATCH(list, other_pattern)) { } else if (MATCH(expr, other_pattern)) {
op = ir_texture::get_opcode(tag->value()); op = ir_texture::get_opcode(tag->value());
if (op == -1) if (op == -1)
return NULL; return NULL;