Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
  • 6 commits
  • 11 files changed
  • 0 comments
  • 1 contributor
Jan 12, 2012
Werner Almesberger ptest: put a blank line between system and user symbols, like symtab_…
…dump did

This broke the logic of test/nsyms. Strangely enough, this didn't
surface for a while.
fe39eef
Werner Almesberger compiler: change forall_<plural> to more common foreach_<singular>
Specifically,
forall_syms -> forall_syms, and
forall_patches -> foreach_patch
2db737d
Werner Almesberger src/Makefile: suppress ctype.h warnings with -Wno-char-subscripts
This is because RTEMS' libc headers lack the appropriate casts.
To do: find where all this really comes from and fix it at the
source.
efa45ee
Werner Almesberger parser.y: don't indent content of %include
The indentation made the placement of macros and functions look weird.
0bfffe9
Werner Almesberger compiler: moved handling of warnings and errors from parser.y to pars…
…er_helper.c

Two reasons:

1) since the mechanism that picks up the diagnostics is also in
   parser_helper.c, it makes sense to keep both ends together.

2) we use (v)asprintf, which isn't easily available in parser.y
   The reason for this is that we need to #define _GNU_SOURCE before
   including stdio.h, but lemon includes stdio.h right before the
   things from %include { ... }, so we can't sneak it in there.
   There would still be the possibility to -D_GNU_SOURCE when
   invoking the compiler, but that seems a little messy.
6d67f52
Werner Almesberger compiler: give parser more convenient control over the error messages
Also, improve what the diagnostics say.
bed7bf7
1  src/Makefile
@@ -34,6 +34,7 @@ endif
34 34
 
35 35
 CFLAGS = -O9 -Wall -Wstrict-prototypes -Wmissing-prototypes \
36 36
 	 -Wold-style-declaration -Wold-style-definition \
  37
+	 -Wno-char-subscripts \
37 38
 	 -mbarrel-shift-enabled -mmultiply-enabled \
38 39
 	 -mdivide-enabled -msign-extend-enabled -fsingle-precision-constant \
39 40
 	 -I$(RTEMS_MAKEFILE_PATH)/lib/include -g
332  src/compiler/parser.y
@@ -16,179 +16,173 @@
16 16
  */
17 17
 
18 18
 %include {
19  
-	#include <assert.h>
20  
-	#include <string.h>
21  
-	#include <ctype.h>
22  
-	#include <stdlib.h>
23  
-	#include <malloc.h>
24  
-	#include <math.h>
25 19
 
26  
-	#include <fpvm/ast.h>
27  
-	#include <fpvm/fpvm.h>
  20
+#include <assert.h>
  21
+#include <string.h>
  22
+#include <ctype.h>
  23
+#include <stdlib.h>
  24
+#include <malloc.h>
  25
+#include <math.h>
28 26
 
29  
-	#include "symtab.h"
30  
-	#include "parser_itf.h"
31  
-	#include "parser_helper.h"
32  
-	#include "parser.h"
  27
+#include <fpvm/ast.h>
  28
+#include <fpvm/fpvm.h>
33 29
 
  30
+#include "symtab.h"
  31
+#include "parser_itf.h"
  32
+#include "parser_helper.h"
  33
+#include "parser.h"
34 34
 
35  
-	int warn_section = 0;
36  
-	int warn_undefined = 0;
37 35
 
38  
-	struct yyParser;
39  
-	static void yy_parse_failed(struct yyParser *yypParser);
  36
+int warn_section = 0;
  37
+int warn_undefined = 0;
40 38
 
41  
-	typedef const char *(*assign_callback)(struct parser_comm *comm,
42  
-	    struct sym *sym, struct ast_node *node);
43  
-
44  
-	#define	FAIL					\
45  
-		do {					\
46  
-			syntax_error(state);		\
47  
-			yy_parse_failed(yypParser);	\
48  
-		} while (0)
49  
-
50  
-	#define	OTHER_STYLE_new_style	old_style
51  
-	#define	OTHER_STYLE_old_style	new_style
52  
-
53  
-	#define	IS_STYLE(which)						\
54  
-		do {							\
55  
-			if(state->style == OTHER_STYLE_##which) {	\
56  
-				FAIL;					\
57  
-				return;					\
58  
-			}						\
59  
-			state->style = which;				\
60  
-		} while (0)
61  
-
62  
-	static const enum ast_op tok2op[] = {
63  
-		[TOK_IDENT]	= op_ident,
64  
-		[TOK_CONSTANT]	= op_constant,
65  
-		[TOK_PLUS]	= op_plus,
66  
-		[TOK_MINUS]	= op_minus,
67  
-		[TOK_MULTIPLY]	= op_multiply,
68  
-		[TOK_DIVIDE]	= op_divide,
69  
-		[TOK_PERCENT]	= op_percent,
70  
-		[TOK_ABS]	= op_abs,
71  
-		[TOK_ISIN]	= op_isin,
72  
-		[TOK_ICOS]	= op_icos,
73  
-		[TOK_SIN]	= op_sin,
74  
-		[TOK_COS]	= op_cos,
75  
-		[TOK_ABOVE]	= op_above,
76  
-		[TOK_BELOW]	= op_below,
77  
-		[TOK_EQUAL]	= op_equal,
78  
-		[TOK_I2F]	= op_i2f,
79  
-		[TOK_F2I]	= op_f2i,
80  
-		[TOK_IF]	= op_if,
81  
-		[TOK_TSIGN]	= op_tsign,
82  
-		[TOK_QUAKE]	= op_quake,
83  
-		[TOK_SQR]	= op_sqr,
84  
-		[TOK_SQRT]	= op_sqrt,
85  
-		[TOK_INVSQRT]	= op_invsqrt,
86  
-		[TOK_MIN]	= op_min,
87  
-		[TOK_MAX]	= op_max,
88  
-		[TOK_INT]	= op_int,
89  
-	};
90  
-
91  
-	static struct ast_node *node_op(enum ast_op op,
92  
-	    struct ast_node *a, struct ast_node *b, struct ast_node *c)
93  
-	{
94  
-		struct ast_node *n;
95  
-
96  
-		n = malloc(sizeof(struct ast_node));
97  
-		n->op = op;
98  
-		n->sym = NULL;
99  
-		n->contents.branches.a = a;
100  
-		n->contents.branches.b = b;
101  
-		n->contents.branches.c = c;
102  
-		return n;
103  
-	}
104  
-
105  
-	static struct ast_node *node(int token, struct sym *sym,
106  
-	    struct ast_node *a, struct ast_node *b, struct ast_node *c)
107  
-	{
108  
-		struct ast_node *n;
109  
-
110  
-		n = node_op(tok2op[token], a, b, c);
111  
-		n->sym = &sym->fpvm_sym;
112  
-		return n;
113  
-	}
114  
-
115  
-	static struct ast_node *constant(float n)
116  
-	{
117  
-		struct ast_node *node;
  39
+struct yyParser;
  40
+static void yy_parse_failed(struct yyParser *yypParser);
118 41
 
119  
-		node = node_op(op_constant, NULL, NULL, NULL);
120  
-		node->contents.constant = n;
121  
-		return node;
122  
-	}
  42
+typedef const char *(*assign_callback)(struct parser_comm *comm,
  43
+	    struct sym *sym, struct ast_node *node);
123 44
 
124  
-	#define FOLD_UNARY(res, ast_op, arg, expr)			\
125  
-		do {							\
126  
-			if((arg)->op == op_constant) {			\
127  
-				float a = (arg)->contents.constant;	\
128  
-									\
129  
-				res = constant(expr);			\
130  
-				parse_free(arg);			\
131  
-			} else {					\
132  
-				res = node_op(ast_op, arg, NULL, NULL);	\
133  
-			}						\
134  
-		} while (0)
135  
-
136  
-	#define FOLD_BINARY(res, ast_op, arg_a, arg_b, expr)		\
137  
-		do {							\
138  
-			if((arg_a)->op == op_constant && 		\
139  
-			    (arg_b)->op == op_constant) {		\
140  
-				float a = (arg_a)->contents.constant;	\
141  
-				float b = (arg_b)->contents.constant;	\
  45
+#define	FAIL(msg)				\
  46
+	do {					\
  47
+		error(state, msg);		\
  48
+		yy_parse_failed(yypParser);	\
  49
+	} while (0)
  50
+
  51
+#define	OTHER_STYLE_new_style	old_style
  52
+#define	OTHER_STYLE_old_style	new_style
  53
+
  54
+#define	IS_STYLE(which)						\
  55
+	do {							\
  56
+		if(state->style == OTHER_STYLE_##which) {	\
  57
+			FAIL("style mismatch");			\
  58
+			return;					\
  59
+		}						\
  60
+		state->style = which;				\
  61
+	} while (0)
  62
+
  63
+static const enum ast_op tok2op[] = {
  64
+	[TOK_IDENT]	= op_ident,
  65
+	[TOK_CONSTANT]	= op_constant,
  66
+	[TOK_PLUS]	= op_plus,
  67
+	[TOK_MINUS]	= op_minus,
  68
+	[TOK_MULTIPLY]	= op_multiply,
  69
+	[TOK_DIVIDE]	= op_divide,
  70
+	[TOK_PERCENT]	= op_percent,
  71
+	[TOK_ABS]	= op_abs,
  72
+	[TOK_ISIN]	= op_isin,
  73
+	[TOK_ICOS]	= op_icos,
  74
+	[TOK_SIN]	= op_sin,
  75
+	[TOK_COS]	= op_cos,
  76
+	[TOK_ABOVE]	= op_above,
  77
+	[TOK_BELOW]	= op_below,
  78
+	[TOK_EQUAL]	= op_equal,
  79
+	[TOK_I2F]	= op_i2f,
  80
+	[TOK_F2I]	= op_f2i,
  81
+	[TOK_IF]	= op_if,
  82
+	[TOK_TSIGN]	= op_tsign,
  83
+	[TOK_QUAKE]	= op_quake,
  84
+	[TOK_SQR]	= op_sqr,
  85
+	[TOK_SQRT]	= op_sqrt,
  86
+	[TOK_INVSQRT]	= op_invsqrt,
  87
+	[TOK_MIN]	= op_min,
  88
+	[TOK_MAX]	= op_max,
  89
+	[TOK_INT]	= op_int,
  90
+};
  91
+
  92
+static struct ast_node *node_op(enum ast_op op,
  93
+    struct ast_node *a, struct ast_node *b, struct ast_node *c)
  94
+{
  95
+	struct ast_node *n;
  96
+
  97
+	n = malloc(sizeof(struct ast_node));
  98
+	n->op = op;
  99
+	n->sym = NULL;
  100
+	n->contents.branches.a = a;
  101
+	n->contents.branches.b = b;
  102
+	n->contents.branches.c = c;
  103
+	return n;
  104
+}
  105
+
  106
+static struct ast_node *node(int token, struct sym *sym,
  107
+    struct ast_node *a, struct ast_node *b, struct ast_node *c)
  108
+{
  109
+	struct ast_node *n;
  110
+
  111
+	n = node_op(tok2op[token], a, b, c);
  112
+	n->sym = &sym->fpvm_sym;
  113
+	return n;
  114
+}
  115
+
  116
+static struct ast_node *constant(float n)
  117
+{
  118
+	struct ast_node *node;
  119
+
  120
+	node = node_op(op_constant, NULL, NULL, NULL);
  121
+	node->contents.constant = n;
  122
+	return node;
  123
+}
  124
+
  125
+#define FOLD_UNARY(res, ast_op, arg, expr)			\
  126
+	do {							\
  127
+		if((arg)->op == op_constant) {			\
  128
+			float a = (arg)->contents.constant;	\
  129
+								\
  130
+			res = constant(expr);			\
  131
+			parse_free(arg);			\
  132
+		} else {					\
  133
+			res = node_op(ast_op, arg, NULL, NULL);	\
  134
+		}						\
  135
+	} while (0)
  136
+
  137
+#define FOLD_BINARY(res, ast_op, arg_a, arg_b, expr)			\
  138
+	do {								\
  139
+		if((arg_a)->op == op_constant &&			\
  140
+		    (arg_b)->op == op_constant) {			\
  141
+			float a = (arg_a)->contents.constant;		\
  142
+			float b = (arg_b)->contents.constant;		\
142 143
 									\
143  
-				res = constant(expr);			\
144  
-				parse_free(arg_a);			\
145  
-				parse_free(arg_b);			\
146  
-			} else {					\
147  
-				res = node_op(ast_op,			\
148  
-				     arg_a, arg_b, NULL); 		\
149  
-			}						\
150  
-		} while (0)
151  
-
152  
-	static struct ast_node *conditional(struct ast_node *a,
153  
-	    struct ast_node *b, struct ast_node *c)
154  
-	{
155  
-		if(a->op == op_not) {
156  
-			struct ast_node *next = a->contents.branches.a;
157  
-
158  
-			parse_free_one(a);
159  
-			return node_op(op_if, next, c, b);
160  
-		}
161  
-		if(a->op != op_constant)
162  
-			return node_op(op_if, a, b, c);
163  
-		if(a->contents.constant) {
164  
-			parse_free(a);
165  
-			parse_free(c);
166  
-			return b;
167  
-		} else {
168  
-			parse_free(a);
169  
-			parse_free(b);
170  
-			return c;
171  
-		}
  144
+			res = constant(expr);				\
  145
+			parse_free(arg_a);				\
  146
+			parse_free(arg_b);				\
  147
+		} else {						\
  148
+			res = node_op(ast_op, arg_a, arg_b, NULL);	\
  149
+		}							\
  150
+	} while (0)
  151
+
  152
+static struct ast_node *conditional(struct ast_node *a,
  153
+    struct ast_node *b, struct ast_node *c)
  154
+{
  155
+	if(a->op == op_not) {
  156
+		struct ast_node *next = a->contents.branches.a;
  157
+
  158
+		parse_free_one(a);
  159
+		return node_op(op_if, next, c, b);
172 160
 	}
173  
-
174  
-	static void syntax_error(struct parser_state *state)
175  
-	{
176  
-		if(!state->error_label) {
177  
-			state->error_label = state->id->label;
178  
-			state->error_lineno = state->id->lineno;
179  
-		}
  161
+	if(a->op != op_constant)
  162
+		return node_op(op_if, a, b, c);
  163
+	if(a->contents.constant) {
  164
+		parse_free(a);
  165
+		parse_free(c);
  166
+		return b;
  167
+	} else {
  168
+		parse_free(a);
  169
+		parse_free(b);
  170
+		return c;
180 171
 	}
  172
+}
181 173
 
182  
-	static struct id *symbolify(struct id *id)
183  
-	{
184  
-		const char *p;
  174
+static struct id *symbolify(struct id *id)
  175
+{
  176
+	const char *p;
185 177
 
186  
-		for(p = id->label; isalnum(*p); p++);
187  
-		id->sym = unique_n(id->label, p-id->label);
188  
-		return id;
189  
-	}
  178
+	for(p = id->label; isalnum(*p); p++);
  179
+	id->sym = unique_n(id->label, p-id->label);
  180
+	return id;
190 181
 }
191 182
 
  183
+} /* %include */
  184
+
  185
+
192 186
 %start_symbol start
193 187
 %extra_argument {struct parser_state *state}
194 188
 %token_type {struct id *}
@@ -219,7 +213,7 @@
219 213
 %type context {assign_callback}
220 214
 
221 215
 %syntax_error {
222  
-	FAIL;
  216
+	FAIL("parse error");
223 217
 }
224 218
 
225 219
 start ::= TOK_START_EXPR expr(N). {
@@ -231,9 +225,10 @@ start ::= TOK_START_ASSIGN sections. {
231 225
 	if(warn_undefined && state->style == old_style) {
232 226
 		const struct sym *sym;
233 227
 
234  
-		forall_syms(sym)
  228
+		foreach_sym(sym)
235 229
 			if(!(sym->flags & (SF_SYSTEM | SF_ASSIGNED)))
236  
-				printf("variable %s is only read, never set\n",
  230
+				warn(state,
  231
+				    "variable %s is only read, never set\n",
237 232
 				    sym->fpvm_sym.name);
238 233
 	}
239 234
 	state->success = 1;
@@ -277,9 +272,8 @@ assignment ::= ident(I) TOK_ASSIGN expr(N) opt_semi. {
277 272
 	    I->sym->pfv_idx == -1) {
278 273
 		free(I);
279 274
 		if(N->op != op_constant || N->contents.constant) {
280  
-			state->error = strdup("can initialize non-system "
281  
-			    "variables only to zero");
282  
-			FAIL;
  275
+			FAIL("can initialize non-system variables only "
  276
+			    "to zero");
283 277
 			return;
284 278
 		}
285 279
 		IS_STYLE(new_style);
@@ -288,7 +282,7 @@ assignment ::= ident(I) TOK_ASSIGN expr(N) opt_semi. {
288 282
 		    state->comm->assign_default(state->comm, I->sym, N);
289 283
 		free(I);
290 284
 		if(state->error) {
291  
-			FAIL;
  285
+			FAIL(NULL);
292 286
 			return;
293 287
 		}
294 288
 	}
@@ -300,7 +294,7 @@ assignment ::= TOK_IMAGEFILE(I) TOK_ASSIGN TOK_FNAME(N). {
300 294
 	    atoi(I->label+9), N->fname);
301 295
 	free(I);
302 296
 	if(state->error) {
303  
-		FAIL;
  297
+		FAIL(NULL);
304 298
 		free((void *) N->fname);
305 299
 		free(N);
306 300
 		return;
@@ -513,7 +507,7 @@ primary_expr(N) ::= TOK_CONSTANT(C). {
513 507
 primary_expr(N) ::= ident(I). {
514 508
 	if(warn_undefined && state->style == new_style &&
515 509
 	    !(I->sym->flags & (SF_SYSTEM | SF_ASSIGNED)))
516  
-		printf("accessing undefined variable %s\n",
  510
+		warn(state, "reading undefined variable %s\n",
517 511
 		    I->sym->fpvm_sym.name);
518 512
 	N = node(I->token, I->sym, NULL, NULL, NULL);
519 513
 	free(I);
@@ -540,12 +534,12 @@ ident(O) ::= TOK_IDENT(I). {
540 534
 		if(state->comm->assign_default ==
541 535
 		    state->comm->assign_per_frame &&
542 536
 		    I->sym->pfv_idx == -1 && I->sym->pvv_idx != -1)
543  
-			printf("using per-vertex variable %s in "
  537
+			warn(state, "using per-vertex variable %s in "
544 538
 			    "per-frame section\n", I->sym->fpvm_sym.name);
545 539
 		if(state->comm->assign_default ==
546 540
 		    state->comm->assign_per_vertex &&
547 541
 		    I->sym->pfv_idx != -1 && I->sym->pvv_idx == -1)
548  
-			printf("using per-frame variable %s in "
  542
+			warn(state, "using per-frame variable %s in "
549 543
 			    "per-vertex section\n", I->sym->fpvm_sym.name);
550 544
 	}
551 545
 	O = I;
44  src/compiler/parser_helper.c
@@ -21,6 +21,7 @@
21 21
 #include <stdio.h>
22 22
 #include <ctype.h>
23 23
 #include <malloc.h>
  24
+
24 25
 #include <fpvm/ast.h>
25 26
 
26 27
 #include "symtab.h"
@@ -29,6 +30,49 @@
29 30
 #include "parser_itf.h"
30 31
 #include "parser_helper.h"
31 32
 
  33
+
  34
+void verror(struct parser_state *state, const char *fmt, va_list ap)
  35
+{
  36
+	/*
  37
+	 * If "error" or "error_label" are already set, then we keep the
  38
+	 * previous value. There are two reasons for this:
  39
+	 *
  40
+	 * - "error" may have already been set before calling error()
  41
+	 *
  42
+ 	 * - we may be in the process of exiting the parser and are running
  43
+	 *   into false or unrelated problems
  44
+	 */
  45
+
  46
+	if(!state->error) {
  47
+		char *tmp;
  48
+
  49
+		vasprintf(&tmp, fmt, ap);
  50
+		state->error = tmp;
  51
+	}
  52
+	if(!state->error_label) {
  53
+		state->error_label = state->id->label;
  54
+		state->error_lineno = state->id->lineno;
  55
+	}
  56
+}
  57
+
  58
+void error(struct parser_state *state, const char *fmt, ...)
  59
+{
  60
+	va_list ap;
  61
+
  62
+	va_start(ap, fmt);
  63
+	verror(state, fmt, ap);
  64
+	va_end(ap);
  65
+}
  66
+
  67
+void warn(struct parser_state *state, const char *fmt, ...)
  68
+{
  69
+	va_list ap;
  70
+
  71
+	va_start(ap, fmt);
  72
+	vprintf(fmt, ap);
  73
+	va_end(ap);
  74
+}
  75
+
32 76
 static char printable_char(unsigned char c)
33 77
 {
34 78
 	return c < ' ' || c > '~' ? '?' : c;
7  src/compiler/parser_helper.h
@@ -18,6 +18,8 @@
18 18
 #ifndef __PARSER_HELPER_H
19 19
 #define __PARSER_HELPER_H
20 20
 
  21
+#include <stdarg.h>
  22
+
21 23
 #include <fpvm/ast.h>
22 24
 #include <fpvm/fpvm.h>
23 25
 
@@ -25,6 +27,7 @@
25 27
 
26 28
 
27 29
 struct compiler_sc;
  30
+struct parser_state;
28 31
 
29 32
 struct parser_comm {
30 33
 	union {
@@ -45,6 +48,10 @@ struct parser_comm {
45 48
 extern int warn_section;
46 49
 extern int warn_undefined;
47 50
 
  51
+void verror(struct parser_state *state, const char *fmt, va_list ap);
  52
+void error(struct parser_state *state, const char *fmt, ...);
  53
+void warn(struct parser_state *state, const char *fmt, ...);
  54
+
48 55
 const char *parse(const char *expr, int start_token, struct parser_comm *comm);
49 56
 void parse_free_one(struct ast_node *node);
50 57
 void parse_free(struct ast_node *node);
10  src/compiler/ptest/ptest.c
@@ -242,9 +242,15 @@ static void parse_only(const char *pgm)
242 242
 	error = parse(pgm, TOK_START_ASSIGN, &comm);
243 243
 	if (symbols) {
244 244
 		const struct sym *sym;
  245
+		int user = 0;
245 246
 
246  
-		forall_syms(sym)
  247
+		foreach_sym(sym) {
  248
+			if (!user && !(sym->flags & SF_SYSTEM)) {
  249
+				printf("\n");
  250
+				user = 1;
  251
+			}
247 252
 			printf("%s\n", sym->fpvm_sym.name);
  253
+		}
248 254
 	}
249 255
 	symtab_free();
250 256
 	if (!error)
@@ -267,7 +273,7 @@ static const char *lookup_name(int idx, struct sym *sym, const int *field)
267 273
 {
268 274
 	const struct sym *walk;
269 275
 
270  
-	forall_syms(walk) {
  276
+	foreach_sym(walk) {
271 277
 		*sym = *walk;
272 278
 		if (*field == idx)
273 279
 			return walk->fpvm_sym.name;
2  src/compiler/symtab.h
@@ -32,7 +32,7 @@ extern int num_user_syms;
32 32
 
33 33
 #define	FPVM2SYM(fpvm_sym)	((struct sym *) (fpvm_sym))
34 34
 
35  
-#define	forall_syms(p) \
  35
+#define	foreach_sym(p) \
36 36
 	for ((p) = well_known; (p) != user_syms+num_user_syms; \
37 37
 	    (p) = (p) == well_known+num_well_known-1 ? user_syms : (p)+1)
38 38
 
2  src/compiler/test/Patches
@@ -5,7 +5,7 @@
5 5
 # won't interfere.
6 6
 #
7 7
 
8  
-forall_patches()
  8
+foreach_patch()
9 9
 {
10 10
 for n in \
11 11
     "Aderassi - Making time.fnp" \
2  src/compiler/test/nsyms
@@ -22,7 +22,7 @@ echo -n "nsyms: count number of symbols: " 1>&2
22 22
 max=0
23 23
 ns=0
24 24
 np=0
25  
-forall_patches count_syms
  25
+foreach_patch count_syms
26 26
 echo $max,$ns/$np >_out
27 27
 
28 28
 expect <<EOF
2  src/compiler/test/patches
@@ -22,7 +22,7 @@ do_test()
22 22
 	expect </dev/null
23 23
 }
24 24
 
25  
-forall_patches do_test
  25
+foreach_patch do_test
26 26
 
27 27
 VALGRIND=$valgrind_orig
28 28
 
4  src/compiler/test/sections
@@ -130,7 +130,7 @@ per_vertex=c=d
130 130
 EOF
131 131
 expect <<EOF
132 132
 per_frame = a = b
133  
-FPVM, line 3: parse error near 'c'
  133
+FPVM, line 3: style mismatch near 'c'
134 134
 EOF
135 135
 
136 136
 #------------------------------------------------------------------------------
@@ -142,7 +142,7 @@ per_frame:
142 142
 EOF
143 143
 expect <<EOF
144 144
 per_vertex = a = b
145  
-FPVM, line 3: parse error near 'c'
  145
+FPVM, line 3: style mismatch near 'c'
146 146
 EOF
147 147
 
148 148
 #------------------------------------------------------------------------------
4  src/compiler/test/wundef
@@ -42,7 +42,7 @@ per_frame:
42 42
 	bar = foo
43 43
 EOF
44 44
 expect <<EOF
45  
-accessing undefined variable foo
  45
+reading undefined variable foo
46 46
 EOF
47 47
 
48 48
 #------------------------------------------------------------------------------
@@ -52,7 +52,7 @@ per_vertex:
52 52
 	bar = foo
53 53
 EOF
54 54
 expect <<EOF
55  
-accessing undefined variable foo
  55
+reading undefined variable foo
56 56
 EOF
57 57
 
58 58
 #------------------------------------------------------------------------------

No commit comments for this range

Something went wrong with that request. Please try again.