projects / mesa.git / blob
? search:


5919186c5204a30e5f212f289ab96058723206eb
[mesa.git] / src / glsl / cl / sl_cl_parse.c
1 /**************************************************************************
2 *
3 * Copyright 2009 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include <assert.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include "../pp/sl_pp_public.h"
32 #include "sl_cl_parse.h"
33
34
35 /* revision number - increment after each change affecting emitted output */
36 #define REVISION 5
37
38 /* external declaration (or precision or invariant stmt) */
39 #define EXTERNAL_NULL 0
40 #define EXTERNAL_FUNCTION_DEFINITION 1
41 #define EXTERNAL_DECLARATION 2
42 #define DEFAULT_PRECISION 3
43 #define INVARIANT_STMT 4
44
45 /* precision */
46 #define PRECISION_DEFAULT 0
47 #define PRECISION_LOW 1
48 #define PRECISION_MEDIUM 2
49 #define PRECISION_HIGH 3
50
51 /* declaration */
52 #define DECLARATION_FUNCTION_PROTOTYPE 1
53 #define DECLARATION_INIT_DECLARATOR_LIST 2
54
55 /* function type */
56 #define FUNCTION_ORDINARY 0
57 #define FUNCTION_CONSTRUCTOR 1
58 #define FUNCTION_OPERATOR 2
59
60 /* function call type */
61 #define FUNCTION_CALL_NONARRAY 0
62 #define FUNCTION_CALL_ARRAY 1
63
64 /* operator type */
65 #define OPERATOR_ADDASSIGN 1
66 #define OPERATOR_SUBASSIGN 2
67 #define OPERATOR_MULASSIGN 3
68 #define OPERATOR_DIVASSIGN 4
69 /*#define OPERATOR_MODASSIGN 5*/
70 /*#define OPERATOR_LSHASSIGN 6*/
71 /*#define OPERATOR_RSHASSIGN 7*/
72 /*#define OPERATOR_ORASSIGN 8*/
73 /*#define OPERATOR_XORASSIGN 9*/
74 /*#define OPERATOR_ANDASSIGN 10*/
75 #define OPERATOR_LOGICALXOR 11
76 /*#define OPERATOR_BITOR 12*/
77 /*#define OPERATOR_BITXOR 13*/
78 /*#define OPERATOR_BITAND 14*/
79 #define OPERATOR_LESS 15
80 #define OPERATOR_GREATER 16
81 #define OPERATOR_LESSEQUAL 17
82 #define OPERATOR_GREATEREQUAL 18
83 /*#define OPERATOR_LSHIFT 19*/
84 /*#define OPERATOR_RSHIFT 20*/
85 #define OPERATOR_MULTIPLY 21
86 #define OPERATOR_DIVIDE 22
87 /*#define OPERATOR_MODULUS 23*/
88 #define OPERATOR_INCREMENT 24
89 #define OPERATOR_DECREMENT 25
90 #define OPERATOR_PLUS 26
91 #define OPERATOR_MINUS 27
92 /*#define OPERATOR_COMPLEMENT 28*/
93 #define OPERATOR_NOT 29
94
95 /* init declarator list */
96 #define DECLARATOR_NONE 0
97 #define DECLARATOR_NEXT 1
98
99 /* variable declaration */
100 #define VARIABLE_NONE 0
101 #define VARIABLE_IDENTIFIER 1
102 #define VARIABLE_INITIALIZER 2
103 #define VARIABLE_ARRAY_EXPLICIT 3
104 #define VARIABLE_ARRAY_UNKNOWN 4
105
106 /* type qualifier */
107 #define TYPE_QUALIFIER_NONE 0
108 #define TYPE_QUALIFIER_CONST 1
109 #define TYPE_QUALIFIER_ATTRIBUTE 2
110 #define TYPE_QUALIFIER_VARYING 3
111 #define TYPE_QUALIFIER_UNIFORM 4
112 #define TYPE_QUALIFIER_FIXEDOUTPUT 5
113 #define TYPE_QUALIFIER_FIXEDINPUT 6
114
115 /* invariant qualifier */
116 #define TYPE_VARIANT 90
117 #define TYPE_INVARIANT 91
118
119 /* centroid qualifier */
120 #define TYPE_CENTER 95
121 #define TYPE_CENTROID 96
122
123 /* type specifier */
124 #define TYPE_SPECIFIER_VOID 0
125 #define TYPE_SPECIFIER_BOOL 1
126 #define TYPE_SPECIFIER_BVEC2 2
127 #define TYPE_SPECIFIER_BVEC3 3
128 #define TYPE_SPECIFIER_BVEC4 4
129 #define TYPE_SPECIFIER_INT 5
130 #define TYPE_SPECIFIER_IVEC2 6
131 #define TYPE_SPECIFIER_IVEC3 7
132 #define TYPE_SPECIFIER_IVEC4 8
133 #define TYPE_SPECIFIER_FLOAT 9
134 #define TYPE_SPECIFIER_VEC2 10
135 #define TYPE_SPECIFIER_VEC3 11
136 #define TYPE_SPECIFIER_VEC4 12
137 #define TYPE_SPECIFIER_MAT2 13
138 #define TYPE_SPECIFIER_MAT3 14
139 #define TYPE_SPECIFIER_MAT4 15
140 #define TYPE_SPECIFIER_SAMPLER1D 16
141 #define TYPE_SPECIFIER_SAMPLER2D 17
142 #define TYPE_SPECIFIER_SAMPLER3D 18
143 #define TYPE_SPECIFIER_SAMPLERCUBE 19
144 #define TYPE_SPECIFIER_SAMPLER1DSHADOW 20
145 #define TYPE_SPECIFIER_SAMPLER2DSHADOW 21
146 #define TYPE_SPECIFIER_SAMPLER2DRECT 22
147 #define TYPE_SPECIFIER_SAMPLER2DRECTSHADOW 23
148 #define TYPE_SPECIFIER_STRUCT 24
149 #define TYPE_SPECIFIER_TYPENAME 25
150
151 /* OpenGL 2.1 */
152 #define TYPE_SPECIFIER_MAT23 26
153 #define TYPE_SPECIFIER_MAT32 27
154 #define TYPE_SPECIFIER_MAT24 28
155 #define TYPE_SPECIFIER_MAT42 29
156 #define TYPE_SPECIFIER_MAT34 30
157 #define TYPE_SPECIFIER_MAT43 31
158
159 /* type specifier array */
160 #define TYPE_SPECIFIER_NONARRAY 0
161 #define TYPE_SPECIFIER_ARRAY 1
162
163 /* structure field */
164 #define FIELD_NONE 0
165 #define FIELD_NEXT 1
166 #define FIELD_ARRAY 2
167
168 /* operation */
169 #define OP_END 0
170 #define OP_BLOCK_BEGIN_NO_NEW_SCOPE 1
171 #define OP_BLOCK_BEGIN_NEW_SCOPE 2
172 #define OP_DECLARE 3
173 #define OP_ASM 4
174 #define OP_BREAK 5
175 #define OP_CONTINUE 6
176 #define OP_DISCARD 7
177 #define OP_RETURN 8
178 #define OP_EXPRESSION 9
179 #define OP_IF 10
180 #define OP_WHILE 11
181 #define OP_DO 12
182 #define OP_FOR 13
183 #define OP_PUSH_VOID 14
184 #define OP_PUSH_BOOL 15
185 #define OP_PUSH_INT 16
186 #define OP_PUSH_FLOAT 17
187 #define OP_PUSH_IDENTIFIER 18
188 #define OP_SEQUENCE 19
189 #define OP_ASSIGN 20
190 #define OP_ADDASSIGN 21
191 #define OP_SUBASSIGN 22
192 #define OP_MULASSIGN 23
193 #define OP_DIVASSIGN 24
194 /*#define OP_MODASSIGN 25*/
195 /*#define OP_LSHASSIGN 26*/
196 /*#define OP_RSHASSIGN 27*/
197 /*#define OP_ORASSIGN 28*/
198 /*#define OP_XORASSIGN 29*/
199 /*#define OP_ANDASSIGN 30*/
200 #define OP_SELECT 31
201 #define OP_LOGICALOR 32
202 #define OP_LOGICALXOR 33
203 #define OP_LOGICALAND 34
204 /*#define OP_BITOR 35*/
205 /*#define OP_BITXOR 36*/
206 /*#define OP_BITAND 37*/
207 #define OP_EQUAL 38
208 #define OP_NOTEQUAL 39
209 #define OP_LESS 40
210 #define OP_GREATER 41
211 #define OP_LESSEQUAL 42
212 #define OP_GREATEREQUAL 43
213 /*#define OP_LSHIFT 44*/
214 /*#define OP_RSHIFT 45*/
215 #define OP_ADD 46
216 #define OP_SUBTRACT 47
217 #define OP_MULTIPLY 48
218 #define OP_DIVIDE 49
219 /*#define OP_MODULUS 50*/
220 #define OP_PREINCREMENT 51
221 #define OP_PREDECREMENT 52
222 #define OP_PLUS 53
223 #define OP_MINUS 54
224 /*#define OP_COMPLEMENT 55*/
225 #define OP_NOT 56
226 #define OP_SUBSCRIPT 57
227 #define OP_CALL 58
228 #define OP_FIELD 59
229 #define OP_POSTINCREMENT 60
230 #define OP_POSTDECREMENT 61
231 #define OP_PRECISION 62
232 #define OP_METHOD 63
233
234 /* parameter qualifier */
235 #define PARAM_QUALIFIER_IN 0
236 #define PARAM_QUALIFIER_OUT 1
237 #define PARAM_QUALIFIER_INOUT 2
238
239 /* function parameter */
240 #define PARAMETER_NONE 0
241 #define PARAMETER_NEXT 1
242
243 /* function parameter array presence */
244 #define PARAMETER_ARRAY_NOT_PRESENT 0
245 #define PARAMETER_ARRAY_PRESENT 1
246
247
248 struct parse_dict {
249 int _void;
250 int _float;
251 int _int;
252 int _bool;
253 int vec2;
254 int vec3;
255 int vec4;
256 int bvec2;
257 int bvec3;
258 int bvec4;
259 int ivec2;
260 int ivec3;
261 int ivec4;
262 int mat2;
263 int mat3;
264 int mat4;
265 int mat2x3;
266 int mat3x2;
267 int mat2x4;
268 int mat4x2;
269 int mat3x4;
270 int mat4x3;
271 int sampler1D;
272 int sampler2D;
273 int sampler3D;
274 int samplerCube;
275 int sampler1DShadow;
276 int sampler2DShadow;
277 int sampler2DRect;
278 int sampler2DRectShadow;
279
280 int invariant;
281
282 int centroid;
283
284 int precision;
285 int lowp;
286 int mediump;
287 int highp;
288
289 int _const;
290 int attribute;
291 int varying;
292 int uniform;
293 int __fixed_output;
294 int __fixed_input;
295
296 int in;
297 int out;
298 int inout;
299
300 int _struct;
301
302 int __constructor;
303 int __operator;
304 int ___asm;
305
306 int _if;
307 int _else;
308 int _for;
309 int _while;
310 int _do;
311
312 int _continue;
313 int _break;
314 int _return;
315 int discard;
316
317 int _false;
318 int _true;
319 };
320
321
322 struct parse_context {
323 struct sl_pp_context *context;
324 const struct sl_pp_token_info *input;
325
326 struct parse_dict dict;
327
328 unsigned char *out_buf;
329 unsigned int out_cap;
330
331 unsigned int shader_type;
332 unsigned int parsing_builtin;
333
334 char error[256];
335 };
336
337
338 struct parse_state {
339 unsigned int in;
340 unsigned int out;
341 };
342
343
344 static __inline unsigned int
345 _emit(struct parse_context *ctx,
346 unsigned int *out,
347 unsigned char b)
348 {
349 if (*out == ctx->out_cap) {
350 ctx->out_cap += 4096;
351 ctx->out_buf = (unsigned char *)realloc(ctx->out_buf, ctx->out_cap * sizeof(unsigned char));
352 }
353 ctx->out_buf[*out] = b;
354 return (*out)++;
355 }
356
357
358 static void
359 _update(struct parse_context *ctx,
360 unsigned int out,
361 unsigned char b)
362 {
363 ctx->out_buf[out] = b;
364 }
365
366
367 static void
368 _error(struct parse_context *ctx,
369 char *msg)
370 {
371 if (ctx->error[0] == '\0') {
372 strcpy(ctx->error, msg);
373 }
374 }
375
376
377 static int
378 _parse_token(struct parse_context *ctx,
379 enum sl_pp_token token,
380 struct parse_state *ps)
381 {
382 if (ctx->input[ps->in].token == token) {
383 ps->in++;
384 return 0;
385 }
386 return -1;
387 }
388
389
390 static int
391 _parse_id(struct parse_context *ctx,
392 int id,
393 struct parse_state *ps)
394 {
395 if (ctx->input[ps->in].token == SL_PP_IDENTIFIER &&
396 ctx->input[ps->in].data.identifier == id) {
397 ps->in++;
398 return 0;
399 }
400 return -1;
401 }
402
403
404 static int
405 _parse_identifier(struct parse_context *ctx,
406 struct parse_state *ps)
407 {
408 if (ctx->input[ps->in].token == SL_PP_IDENTIFIER) {
409 const char *cstr = sl_pp_context_cstr(ctx->context, ctx->input[ps->in].data.identifier);
410
411 do {
412 _emit(ctx, &ps->out, *cstr);
413 } while (*cstr++);
414 ps->in++;
415 return 0;
416 }
417 return -1;
418 }
419
420
421 static int
422 _parse_float(struct parse_context *ctx,
423 struct parse_state *ps)
424 {
425 if (ctx->input[ps->in].token == SL_PP_FLOAT) {
426 const char *cstr = sl_pp_context_cstr(ctx->context, ctx->input[ps->in].data._float);
427
428 _emit(ctx, &ps->out, 1);
429 do {
430 _emit(ctx, &ps->out, *cstr);
431 } while (*cstr++);
432 ps->in++;
433 return 0;
434 }
435 return -1;
436 }
437
438
439 static int
440 _parse_uint(struct parse_context *ctx,
441 struct parse_state *ps)
442 {
443 if (ctx->input[ps->in].token == SL_PP_UINT) {
444 const char *cstr = sl_pp_context_cstr(ctx->context, ctx->input[ps->in].data._uint);
445
446 _emit(ctx, &ps->out, 1);
447 do {
448 _emit(ctx, &ps->out, *cstr);
449 } while (*cstr++);
450 ps->in++;
451 return 0;
452 }
453 return -1;
454 }
455
456
457 /**************************************/
458
459
460 static int
461 _parse_unary_expression(struct parse_context *ctx,
462 struct parse_state *ps);
463
464 static int
465 _parse_conditional_expression(struct parse_context *ctx,
466 struct parse_state *ps);
467
468
469 static int
470 _parse_constant_expression(struct parse_context *ctx,
471 struct parse_state *ps);
472
473
474 static int
475 _parse_primary_expression(struct parse_context *ctx,
476 struct parse_state *ps);
477
478
479 static int
480 _parse_statement(struct parse_context *ctx,
481 struct parse_state *ps);
482
483
484 static int
485 _parse_type_specifier(struct parse_context *ctx,
486 struct parse_state *ps);
487
488
489 static int
490 _parse_declaration(struct parse_context *ctx,
491 struct parse_state *ps);
492
493
494 static int
495 _parse_statement_list(struct parse_context *ctx,
496 struct parse_state *ps);
497
498
499 static int
500 _parse_assignment_expression(struct parse_context *ctx,
501 struct parse_state *ps);
502
503
504 static int
505 _parse_precision(struct parse_context *ctx,
506 struct parse_state *ps);
507
508
509 static int
510 _parse_overriden_operator(struct parse_context *ctx,
511 struct parse_state *ps)
512 {
513 unsigned int op;
514
515 if (_parse_token(ctx, SL_PP_INCREMENT, ps) == 0) {
516 op = OPERATOR_INCREMENT;
517 } else if (_parse_token(ctx, SL_PP_ADDASSIGN, ps) == 0) {
518 op = OPERATOR_ADDASSIGN;
519 } else if (_parse_token(ctx, SL_PP_PLUS, ps) == 0) {
520 op = OPERATOR_PLUS;
521 } else if (_parse_token(ctx, SL_PP_DECREMENT, ps) == 0) {
522 op = OPERATOR_DECREMENT;
523 } else if (_parse_token(ctx, SL_PP_SUBASSIGN, ps) == 0) {
524 op = OPERATOR_SUBASSIGN;
525 } else if (_parse_token(ctx, SL_PP_MINUS, ps) == 0) {
526 op = OPERATOR_MINUS;
527 } else if (_parse_token(ctx, SL_PP_NOT, ps) == 0) {
528 op = OPERATOR_NOT;
529 } else if (_parse_token(ctx, SL_PP_MULASSIGN, ps) == 0) {
530 op = OPERATOR_MULASSIGN;
531 } else if (_parse_token(ctx, SL_PP_STAR, ps) == 0) {
532 op = OPERATOR_MULTIPLY;
533 } else if (_parse_token(ctx, SL_PP_DIVASSIGN, ps) == 0) {
534 op = OPERATOR_DIVASSIGN;
535 } else if (_parse_token(ctx, SL_PP_SLASH, ps) == 0) {
536 op = OPERATOR_DIVIDE;
537 } else if (_parse_token(ctx, SL_PP_LESSEQUAL, ps) == 0) {
538 op = OPERATOR_LESSEQUAL;
539 } else if (_parse_token(ctx, SL_PP_LESS, ps) == 0) {
540 op = OPERATOR_LESS;
541 } else if (_parse_token(ctx, SL_PP_GREATEREQUAL, ps) == 0) {
542 op = OPERATOR_GREATEREQUAL;
543 } else if (_parse_token(ctx, SL_PP_GREATER, ps) == 0) {
544 op = OPERATOR_GREATER;
545 } else if (_parse_token(ctx, SL_PP_XOR, ps) == 0) {
546 op = OPERATOR_LOGICALXOR;
547 } else {
548 return -1;
549 }
550
551 _emit(ctx, &ps->out, op);
552 return 0;
553 }
554
555
556 static int
557 _parse_function_decl_identifier(struct parse_context *ctx,
558 struct parse_state *ps)
559 {
560 struct parse_state p = *ps;
561 unsigned int e = _emit(ctx, &p.out, 0);
562
563 if (ctx->parsing_builtin && _parse_id(ctx, ctx->dict.__constructor, &p) == 0) {
564 _update(ctx, e, FUNCTION_CONSTRUCTOR);
565 *ps = p;
566 return 0;
567 }
568
569 if (ctx->parsing_builtin && _parse_id(ctx, ctx->dict.__operator, &p) == 0) {
570 _update(ctx, e, FUNCTION_OPERATOR);
571 if (_parse_overriden_operator(ctx, &p) == 0) {
572 *ps = p;
573 return 0;
574 }
575 return -1;
576 }
577
578 if (_parse_identifier(ctx, &p) == 0) {
579 _update(ctx, e, FUNCTION_ORDINARY);
580 *ps = p;
581 return 0;
582 }
583
584 return -1;
585 }
586
587
588 static int
589 _parse_invariant_qualifier(struct parse_context *ctx,
590 struct parse_state *ps)
591 {
592 if (_parse_id(ctx, ctx->dict.invariant, ps)) {
593 return -1;
594 }
595 _emit(ctx, &ps->out, TYPE_INVARIANT);
596 return 0;
597 }
598
599
600 static int
601 _parse_centroid_qualifier(struct parse_context *ctx,
602 struct parse_state *ps)
603 {
604 if (_parse_id(ctx, ctx->dict.centroid, ps)) {
605 return -1;
606 }
607 _emit(ctx, &ps->out, TYPE_CENTROID);
608 return 0;
609 }
610
611
612 static int
613 _parse_type_qualifier(struct parse_context *ctx,
614 struct parse_state *ps)
615 {
616 struct parse_state p = *ps;
617 unsigned int e = _emit(ctx, &p.out, 0);
618 int id;
619
620 if (ctx->input[p.in].token != SL_PP_IDENTIFIER) {
621 return -1;
622 }
623 id = ctx->input[p.in].data.identifier;
624
625 if (id == ctx->dict._const) {
626 _update(ctx, e, TYPE_QUALIFIER_CONST);
627 } else if (ctx->shader_type == 2 && id == ctx->dict.attribute) {
628 _update(ctx, e, TYPE_QUALIFIER_ATTRIBUTE);
629 } else if (id == ctx->dict.varying) {
630 _update(ctx, e, TYPE_QUALIFIER_VARYING);
631 } else if (id == ctx->dict.uniform) {
632 _update(ctx, e, TYPE_QUALIFIER_UNIFORM);
633 } else if (ctx->parsing_builtin && id == ctx->dict.__fixed_output) {
634 _update(ctx, e, TYPE_QUALIFIER_FIXEDOUTPUT);
635 } else if (ctx->parsing_builtin && id == ctx->dict.__fixed_input) {
636 _update(ctx, e, TYPE_QUALIFIER_FIXEDINPUT);
637 } else {
638 return -1;
639 }
640 _parse_token(ctx, SL_PP_IDENTIFIER, &p);
641 *ps = p;
642 return 0;
643 }
644
645
646 static int
647 _parse_struct_declarator(struct parse_context *ctx,
648 struct parse_state *ps)
649 {
650 struct parse_state p = *ps;
651 unsigned int e;
652
653 if (_parse_identifier(ctx, &p)) {
654 return -1;
655 }
656 e = _emit(ctx, &p.out, FIELD_NONE);
657 *ps = p;
658
659 if (_parse_token(ctx, SL_PP_LBRACKET, &p)) {
660 return 0;
661 }
662 if (_parse_constant_expression(ctx, &p)) {
663 _error(ctx, "expected constant integral expression");
664 return -1;
665 }
666 if (_parse_token(ctx, SL_PP_RBRACKET, &p)) {
667 _error(ctx, "expected `]'");
668 return -1;
669 }
670 _update(ctx, e, FIELD_ARRAY);
671 *ps = p;
672 return 0;
673 }
674
675
676 static int
677 _parse_struct_declarator_list(struct parse_context *ctx,
678 struct parse_state *ps)
679 {
680 struct parse_state p = *ps;
681
682 if (_parse_struct_declarator(ctx, &p)) {
683 return -1;
684 }
685
686 for (;;) {
687 *ps = p;
688 _emit(ctx, &p.out, FIELD_NEXT);
689 if (_parse_token(ctx, SL_PP_COMMA, &p)) {
690 return 0;
691 }
692 if (_parse_struct_declarator(ctx, &p)) {
693 return 0;
694 }
695 }
696 }
697
698
699 static int
700 _parse_struct_declaration(struct parse_context *ctx,
701 struct parse_state *ps)
702 {
703 struct parse_state p = *ps;
704
705 if (_parse_type_specifier(ctx, &p)) {
706 return -1;
707 }
708 if (_parse_struct_declarator_list(ctx, &p)) {
709 return -1;
710 }
711 if (_parse_token(ctx, SL_PP_SEMICOLON, &p)) {
712 return -1;
713 }
714 _emit(ctx, &p.out, FIELD_NONE);
715 *ps = p;
716 return 0;
717 }
718
719
720 static int
721 _parse_struct_declaration_list(struct parse_context *ctx,
722 struct parse_state *ps)
723 {
724 struct parse_state p = *ps;
725
726 if (_parse_struct_declaration(ctx, &p)) {
727 return -1;
728 }
729
730 for (;;) {
731 *ps = p;
732 _emit(ctx, &p.out, FIELD_NEXT);
733 if (_parse_struct_declaration(ctx, &p)) {
734 return 0;
735 }
736 }
737 }
738
739
740 static int
741 _parse_struct_specifier(struct parse_context *ctx,
742 struct parse_state *ps)
743 {
744 struct parse_state p = *ps;
745
746 if (_parse_id(ctx, ctx->dict._struct, &p)) {
747 return -1;
748 }
749 if (_parse_identifier(ctx, &p)) {
750 _emit(ctx, &p.out, '\0');
751 }
752 if (_parse_token(ctx, SL_PP_LBRACE, &p)) {
753 _error(ctx, "expected `{'");
754 return -1;
755 }
756 if (_parse_struct_declaration_list(ctx, &p)) {
757 return -1;
758 }
759 if (_parse_token(ctx, SL_PP_RBRACE, &p)) {
760 return -1;
761 }
762 _emit(ctx, &p.out, FIELD_NONE);
763 *ps = p;
764 return 0;
765 }
766
767
768 static int
769 _parse_type_specifier_nonarray(struct parse_context *ctx,
770 struct parse_state *ps)
771 {
772 struct parse_state p = *ps;
773 unsigned int e = _emit(ctx, &p.out, 0);
774 int id;
775
776 if (_parse_struct_specifier(ctx, &p) == 0) {
777 _update(ctx, e, TYPE_SPECIFIER_STRUCT);
778 *ps = p;
779 return 0;
780 }
781
782 if (ctx->input[p.in].token != SL_PP_IDENTIFIER) {
783 return -1;
784 }
785 id = ctx->input[p.in].data.identifier;
786
787 if (id == ctx->dict._void) {
788 _update(ctx, e, TYPE_SPECIFIER_VOID);
789 } else if (id == ctx->dict._float) {
790 _update(ctx, e, TYPE_SPECIFIER_FLOAT);
791 } else if (id == ctx->dict._int) {
792 _update(ctx, e, TYPE_SPECIFIER_INT);
793 } else if (id == ctx->dict._bool) {
794 _update(ctx, e, TYPE_SPECIFIER_BOOL);
795 } else if (id == ctx->dict.vec2) {
796 _update(ctx, e, TYPE_SPECIFIER_VEC2);
797 } else if (id == ctx->dict.vec3) {
798 _update(ctx, e, TYPE_SPECIFIER_VEC3);
799 } else if (id == ctx->dict.vec4) {
800 _update(ctx, e, TYPE_SPECIFIER_VEC4);
801 } else if (id == ctx->dict.bvec2) {
802 _update(ctx, e, TYPE_SPECIFIER_BVEC2);
803 } else if (id == ctx->dict.bvec3) {
804 _update(ctx, e, TYPE_SPECIFIER_BVEC3);
805 } else if (id == ctx->dict.bvec4) {
806 _update(ctx, e, TYPE_SPECIFIER_BVEC4);
807 } else if (id == ctx->dict.ivec2) {
808 _update(ctx, e, TYPE_SPECIFIER_IVEC2);
809 } else if (id == ctx->dict.ivec3) {
810 _update(ctx, e, TYPE_SPECIFIER_IVEC3);
811 } else if (id == ctx->dict.ivec4) {
812 _update(ctx, e, TYPE_SPECIFIER_IVEC4);
813 } else if (id == ctx->dict.mat2) {
814 _update(ctx, e, TYPE_SPECIFIER_MAT2);
815 } else if (id == ctx->dict.mat3) {
816 _update(ctx, e, TYPE_SPECIFIER_MAT3);
817 } else if (id == ctx->dict.mat4) {
818 _update(ctx, e, TYPE_SPECIFIER_MAT4);
819 } else if (id == ctx->dict.mat2x3) {
820 _update(ctx, e, TYPE_SPECIFIER_MAT23);
821 } else if (id == ctx->dict.mat3x2) {
822 _update(ctx, e, TYPE_SPECIFIER_MAT32);
823 } else if (id == ctx->dict.mat2x4) {
824 _update(ctx, e, TYPE_SPECIFIER_MAT24);
825 } else if (id == ctx->dict.mat4x2) {
826 _update(ctx, e, TYPE_SPECIFIER_MAT42);
827 } else if (id == ctx->dict.mat3x4) {
828 _update(ctx, e, TYPE_SPECIFIER_MAT34);
829 } else if (id == ctx->dict.mat4x3) {
830 _update(ctx, e, TYPE_SPECIFIER_MAT43);
831 } else if (id == ctx->dict.sampler1D) {
832 _update(ctx, e, TYPE_SPECIFIER_SAMPLER1D);
833 } else if (id == ctx->dict.sampler2D) {
834 _update(ctx, e, TYPE_SPECIFIER_SAMPLER2D);
835 } else if (id == ctx->dict.sampler3D) {
836 _update(ctx, e, TYPE_SPECIFIER_SAMPLER3D);
837 } else if (id == ctx->dict.samplerCube) {
838 _update(ctx, e, TYPE_SPECIFIER_SAMPLERCUBE);
839 } else if (id == ctx->dict.sampler1DShadow) {
840 _update(ctx, e, TYPE_SPECIFIER_SAMPLER1DSHADOW);
841 } else if (id == ctx->dict.sampler2DShadow) {
842 _update(ctx, e, TYPE_SPECIFIER_SAMPLER2DSHADOW);
843 } else if (id == ctx->dict.sampler2DRect) {
844 _update(ctx, e, TYPE_SPECIFIER_SAMPLER2DRECT);
845 } else if (id == ctx->dict.sampler2DRectShadow) {
846 _update(ctx, e, TYPE_SPECIFIER_SAMPLER2DRECTSHADOW);
847 } else if (_parse_identifier(ctx, &p) == 0) {
848 _update(ctx, e, TYPE_SPECIFIER_TYPENAME);
849 *ps = p;
850 return 0;
851 } else {
852 return -1;
853 }
854
855 _parse_token(ctx, SL_PP_IDENTIFIER, &p);
856 *ps = p;
857 return 0;
858 }
859
860
861 static int
862 _parse_type_specifier_array(struct parse_context *ctx,
863 struct parse_state *ps)
864 {
865 struct parse_state p = *ps;
866
867 if (_parse_token(ctx, SL_PP_LBRACKET, &p)) {
868 return -1;
869 }
870 if (_parse_constant_expression(ctx, &p)) {
871 _error(ctx, "expected constant integral expression");
872 return -1;
873 }
874 if (_parse_token(ctx, SL_PP_RBRACKET, &p)) {
875 _error(ctx, "expected `]'");
876 return -1;
877 }
878 *ps = p;
879 return 0;
880 }
881
882
883 static int
884 _parse_type_specifier(struct parse_context *ctx,
885 struct parse_state *ps)
886 {
887 struct parse_state p = *ps;
888 unsigned int e;
889
890 if (_parse_type_specifier_nonarray(ctx, &p)) {
891 return -1;
892 }
893
894 e = _emit(ctx, &p.out, TYPE_SPECIFIER_ARRAY);
895 if (_parse_type_specifier_array(ctx, &p)) {
896 _update(ctx, e, TYPE_SPECIFIER_NONARRAY);
897 }
898 *ps = p;
899 return 0;
900 }
901
902
903 static int
904 _parse_fully_specified_type(struct parse_context *ctx,
905 struct parse_state *ps)
906 {
907 struct parse_state p = *ps;
908
909 if (_parse_invariant_qualifier(ctx, &p)) {
910 _emit(ctx, &p.out, TYPE_VARIANT);
911 }
912 if (_parse_centroid_qualifier(ctx, &p)) {
913 _emit(ctx, &p.out, TYPE_CENTER);
914 }
915 if (_parse_type_qualifier(ctx, &p)) {
916 _emit(ctx, &p.out, TYPE_QUALIFIER_NONE);
917 }
918 if (_parse_precision(ctx, &p)) {
919 _emit(ctx, &p.out, PRECISION_DEFAULT);
920 }
921 if (_parse_type_specifier(ctx, &p)) {
922 return -1;
923 }
924 *ps = p;
925 return 0;
926 }
927
928
929 static int
930 _parse_function_header(struct parse_context *ctx,
931 struct parse_state *ps)
932 {
933 struct parse_state p = *ps;
934
935 if (_parse_fully_specified_type(ctx, &p)) {
936 return -1;
937 }
938 if (_parse_function_decl_identifier(ctx, &p)) {
939 return -1;
940 }
941 if (_parse_token(ctx, SL_PP_LPAREN, &p)) {
942 return -1;
943 }
944 *ps = p;
945 return 0;
946 }
947
948
949 static int
950 _parse_parameter_qualifier(struct parse_context *ctx,
951 struct parse_state *ps)
952 {
953 unsigned int e = _emit(ctx, &ps->out, PARAM_QUALIFIER_IN);
954
955 if (_parse_id(ctx, ctx->dict.out, ps) == 0) {
956 _update(ctx, e, PARAM_QUALIFIER_OUT);
957 } else if (_parse_id(ctx, ctx->dict.inout, ps) == 0) {
958 _update(ctx, e, PARAM_QUALIFIER_INOUT);
959 } else {
960 _parse_id(ctx, ctx->dict.in, ps);
961 }
962 return 0;
963 }
964
965
966 static int
967 _parse_function_identifier(struct parse_context *ctx,
968 struct parse_state *ps)
969 {
970 struct parse_state p;
971 unsigned int e;
972
973 if (_parse_identifier(ctx, ps)) {
974 return -1;
975 }
976 e = _emit(ctx, &ps->out, FUNCTION_CALL_NONARRAY);
977
978 p = *ps;
979 if (_parse_token(ctx, SL_PP_LBRACKET, &p)) {
980 return 0;
981 }
982 if (_parse_constant_expression(ctx, &p)) {
983 _error(ctx, "expected constant integral expression");
984 return -1;
985 }
986 if (_parse_token(ctx, SL_PP_RBRACKET, &p)) {
987 _error(ctx, "expected `]'");
988 return -1;
989 }
990 _update(ctx, e, FUNCTION_CALL_ARRAY);
991 *ps = p;
992 return 0;
993 }
994
995
996 static int
997 _parse_function_call_header(struct parse_context *ctx,
998 struct parse_state *ps)
999 {
1000 struct parse_state p = *ps;
1001
1002 if (_parse_function_identifier(ctx, &p)) {
1003 return -1;
1004 }
1005 if (_parse_token(ctx, SL_PP_LPAREN, &p)) {
1006 return -1;
1007 }
1008 *ps = p;
1009 return 0;
1010 }
1011
1012
1013 static int
1014 _parse_assign_expression(struct parse_context *ctx,
1015 struct parse_state *ps)
1016 {
1017 struct parse_state p = *ps;
1018 unsigned int op;
1019
1020 if (_parse_unary_expression(ctx, &p)) {
1021 return -1;
1022 }
1023
1024 if (_parse_token(ctx, SL_PP_ASSIGN, &p) == 0) {
1025 op = OP_ASSIGN;
1026 } else if (_parse_token(ctx, SL_PP_MULASSIGN, &p) == 0) {
1027 op = OP_MULASSIGN;
1028 } else if (_parse_token(ctx, SL_PP_DIVASSIGN, &p) == 0) {
1029 op = OP_DIVASSIGN;
1030 } else if (_parse_token(ctx, SL_PP_ADDASSIGN, &p) == 0) {
1031 op = OP_ADDASSIGN;
1032 } else if (_parse_token(ctx, SL_PP_SUBASSIGN, &p) == 0) {
1033 op = OP_SUBASSIGN;
1034 } else {
1035 return -1;
1036 }
1037
1038 if (_parse_assignment_expression(ctx, &p)) {
1039 return -1;
1040 }
1041 _emit(ctx, &p.out, op);
1042
1043 *ps = p;
1044 return 0;
1045 }
1046
1047
1048 static int
1049 _parse_assignment_expression(struct parse_context *ctx,
1050 struct parse_state *ps)
1051 {
1052 if (_parse_assign_expression(ctx, ps) == 0) {
1053 return 0;
1054 }
1055
1056 if (_parse_conditional_expression(ctx, ps) == 0) {
1057 return 0;
1058 }
1059
1060 return -1;
1061 }
1062
1063
1064 static int
1065 _parse_function_call_header_with_parameters(struct parse_context *ctx,
1066 struct parse_state *ps)
1067 {
1068 struct parse_state p = *ps;
1069
1070 if (_parse_function_call_header(ctx, &p)) {
1071 return -1;
1072 }
1073 if (_parse_assignment_expression(ctx, &p)) {
1074 return -1;
1075 }
1076 _emit(ctx, &p.out, OP_END);
1077 for (;;) {
1078 *ps = p;
1079 if (_parse_token(ctx, SL_PP_COMMA, &p)) {
1080 return 0;
1081 }
1082 if (_parse_assignment_expression(ctx, &p)) {
1083 return 0;
1084 }
1085 _emit(ctx, &p.out, OP_END);
1086 }
1087 }
1088
1089
1090 static int
1091 _parse_function_call_header_no_parameters(struct parse_context *ctx,
1092 struct parse_state *ps)
1093 {
1094 if (_parse_function_call_header(ctx, ps)) {
1095 return -1;
1096 }
1097 _parse_id(ctx, ctx->dict._void, ps);
1098 return 0;
1099 }
1100
1101
1102 static int
1103 _parse_function_call_generic(struct parse_context *ctx,
1104 struct parse_state *ps)
1105 {
1106 struct parse_state p = *ps;
1107
1108 if (_parse_function_call_header_with_parameters(ctx, &p) == 0) {
1109 if (_parse_token(ctx, SL_PP_RPAREN, &p) == 0) {
1110 *ps = p;
1111 return 0;
1112 }
1113 _error(ctx, "expected `)'");
1114 return -1;
1115 }
1116
1117 p = *ps;
1118 if (_parse_function_call_header_no_parameters(ctx, &p) == 0) {
1119 if (_parse_token(ctx, SL_PP_RPAREN, &p) == 0) {
1120 *ps = p;
1121 return 0;
1122 }
1123 _error(ctx, "expected `)'");
1124 return -1;
1125 }
1126
1127 return -1;
1128 }
1129
1130
1131 static int
1132 _parse_method_call(struct parse_context *ctx,
1133 struct parse_state *ps)
1134 {
1135 struct parse_state p = *ps;
1136
1137 _emit(ctx, &p.out, OP_METHOD);
1138 if (_parse_identifier(ctx, &p)) {
1139 return -1;
1140 }
1141 if (_parse_token(ctx, SL_PP_DOT, &p)) {
1142 return -1;
1143 }
1144 if (_parse_function_call_generic(ctx, &p)) {
1145 return -1;
1146 }
1147 _emit(ctx, &p.out, OP_END);
1148 *ps = p;
1149 return 0;
1150 }
1151
1152
1153 static int
1154 _parse_regular_function_call(struct parse_context *ctx,
1155 struct parse_state *ps)
1156 {
1157 struct parse_state p = *ps;
1158
1159 _emit(ctx, &p.out, OP_CALL);
1160 if (_parse_function_call_generic(ctx, &p)) {
1161 return -1;
1162 }
1163 _emit(ctx, &p.out, OP_END);
1164 *ps = p;
1165 return 0;
1166 }
1167
1168
1169 static int
1170 _parse_function_call(struct parse_context *ctx,
1171 struct parse_state *ps)
1172 {
1173 if (_parse_regular_function_call(ctx, ps) == 0) {
1174 return 0;
1175 }
1176
1177 if (_parse_method_call(ctx, ps) == 0) {
1178 return 0;
1179 }
1180
1181 return -1;
1182 }
1183
1184
1185 static int
1186 _parse_expression(struct parse_context *ctx,
1187 struct parse_state *ps)
1188 {
1189 struct parse_state p = *ps;
1190
1191 if (_parse_assignment_expression(ctx, &p)) {
1192 return -1;
1193 }
1194
1195 for (;;) {
1196 *ps = p;
1197 if (_parse_token(ctx, SL_PP_COMMA, &p)) {
1198 return 0;
1199 }
1200 if (_parse_assignment_expression(ctx, &p)) {
1201 return 0;
1202 }
1203 _emit(ctx, &p.out, OP_SEQUENCE);
1204 }
1205 }
1206
1207
1208 static int
1209 _parse_postfix_expression(struct parse_context *ctx,
1210 struct parse_state *ps)
1211 {
1212 struct parse_state p;
1213
1214 if (_parse_function_call(ctx, ps)) {
1215 if (_parse_primary_expression(ctx, ps)) {
1216 return -1;
1217 }
1218 }
1219
1220 for (p = *ps;;) {
1221 *ps = p;
1222 if (_parse_token(ctx, SL_PP_INCREMENT, &p) == 0) {
1223 _emit(ctx, &p.out, OP_POSTINCREMENT);
1224 } else if (_parse_token(ctx, SL_PP_DECREMENT, &p) == 0) {
1225 _emit(ctx, &p.out, OP_POSTDECREMENT);
1226 } else if (_parse_token(ctx, SL_PP_LBRACKET, &p) == 0) {
1227 if (_parse_expression(ctx, &p)) {
1228 _error(ctx, "expected an integral expression");
1229 return -1;
1230 }
1231 if (_parse_token(ctx, SL_PP_RBRACKET, &p)) {
1232 _error(ctx, "expected `]'");
1233 return -1;
1234 }
1235 _emit(ctx, &p.out, OP_SUBSCRIPT);
1236 } else if (_parse_token(ctx, SL_PP_DOT, &p) == 0) {
1237 _emit(ctx, &p.out, OP_FIELD);
1238 if (_parse_identifier(ctx, &p)) {
1239 return 0;
1240 }
1241 } else {
1242 return 0;
1243 }
1244 }
1245 }
1246
1247
1248 static int
1249 _parse_unary_expression(struct parse_context *ctx,
1250 struct parse_state *ps)
1251 {
1252 struct parse_state p;
1253 unsigned int op;
1254
1255 if (_parse_postfix_expression(ctx, ps) == 0) {
1256 return 0;
1257 }
1258
1259 p = *ps;
1260 if (_parse_token(ctx, SL_PP_INCREMENT, &p) == 0) {
1261 op = OP_PREINCREMENT;
1262 } else if (_parse_token(ctx, SL_PP_DECREMENT, &p) == 0) {
1263 op = OP_PREDECREMENT;
1264 } else if (_parse_token(ctx, SL_PP_PLUS, &p) == 0) {
1265 op = OP_PLUS;
1266 } else if (_parse_token(ctx, SL_PP_MINUS, &p) == 0) {
1267 op = OP_MINUS;
1268 } else if (_parse_token(ctx, SL_PP_NOT, &p) == 0) {
1269 op = OP_NOT;
1270 } else {
1271 return -1;
1272 }
1273
1274 if (_parse_unary_expression(ctx, &p)) {
1275 return -1;
1276 }
1277 _emit(ctx, &p.out, op);
1278 *ps = p;
1279 return 0;
1280 }
1281
1282
1283 static int
1284 _parse_multiplicative_expression(struct parse_context *ctx,
1285 struct parse_state *ps)
1286 {
1287 struct parse_state p = *ps;
1288
1289 if (_parse_unary_expression(ctx, &p)) {
1290 return -1;
1291 }
1292 for (;;) {
1293 unsigned int op;
1294
1295 *ps = p;
1296 if (_parse_token(ctx, SL_PP_STAR, &p) == 0) {
1297 op = OP_MULTIPLY;
1298 } else if (_parse_token(ctx, SL_PP_SLASH, &p) == 0) {
1299 op = OP_DIVIDE;
1300 } else {
1301 return 0;
1302 }
1303 if (_parse_unary_expression(ctx, &p)) {
1304 return 0;
1305 }
1306 _emit(ctx, &p.out, op);
1307 }
1308 }
1309
1310
1311 static int
1312 _parse_additive_expression(struct parse_context *ctx,
1313 struct parse_state *ps)
1314 {
1315 struct parse_state p = *ps;
1316
1317 if (_parse_multiplicative_expression(ctx, &p)) {
1318 return -1;
1319 }
1320 for (;;) {
1321 unsigned int op;
1322
1323 *ps = p;
1324 if (_parse_token(ctx, SL_PP_PLUS, &p) == 0) {
1325 op = OP_ADD;
1326 } else if (_parse_token(ctx, SL_PP_MINUS, &p) == 0) {
1327 op = OP_SUBTRACT;
1328 } else {
1329 return 0;
1330 }
1331 if (_parse_multiplicative_expression(ctx, &p)) {
1332 return 0;
1333 }
1334 _emit(ctx, &p.out, op);
1335 }
1336 }
1337
1338
1339 static int
1340 _parse_relational_expression(struct parse_context *ctx,
1341 struct parse_state *ps)
1342 {
1343 struct parse_state p = *ps;
1344
1345 if (_parse_additive_expression(ctx, &p)) {
1346 return -1;
1347 }
1348 for (;;) {
1349 unsigned int op;
1350
1351 *ps = p;
1352 if (_parse_token(ctx, SL_PP_LESS, &p) == 0) {
1353 op = OP_LESS;
1354 } else if (_parse_token(ctx, SL_PP_GREATER, &p) == 0) {
1355 op = OP_GREATER;
1356 } else if (_parse_token(ctx, SL_PP_LESSEQUAL, &p) == 0) {
1357 op = OP_LESSEQUAL;
1358 } else if (_parse_token(ctx, SL_PP_GREATEREQUAL, &p) == 0) {
1359 op = OP_GREATEREQUAL;
1360 } else {
1361 return 0;
1362 }
1363 if (_parse_additive_expression(ctx, &p)) {
1364 return 0;
1365 }
1366 _emit(ctx, &p.out, op);
1367 }
1368 }
1369
1370
1371 static int
1372 _parse_equality_expression(struct parse_context *ctx,
1373 struct parse_state *ps)
1374 {
1375 struct parse_state p = *ps;
1376
1377 if (_parse_relational_expression(ctx, &p)) {
1378 return -1;
1379 }
1380 for (;;) {
1381 unsigned int op;
1382
1383 *ps = p;
1384 if (_parse_token(ctx, SL_PP_EQUAL, &p) == 0) {
1385 op = OP_EQUAL;
1386 } else if (_parse_token(ctx, SL_PP_NOTEQUAL, &p) == 0) {
1387 op = OP_NOTEQUAL;
1388 } else {
1389 return 0;
1390 }
1391 if (_parse_relational_expression(ctx, &p)) {
1392 return -1;
1393 }
1394 _emit(ctx, &p.out, op);
1395 }
1396 }
1397
1398
1399 static int
1400 _parse_logical_and_expression(struct parse_context *ctx,
1401 struct parse_state *ps)
1402 {
1403 struct parse_state p = *ps;
1404
1405 if (_parse_equality_expression(ctx, &p)) {
1406 return -1;
1407 }
1408 for (;;) {
1409 *ps = p;
1410 if (_parse_token(ctx, SL_PP_AND, &p)) {
1411 return 0;
1412 }
1413 if (_parse_equality_expression(ctx, &p)) {
1414 return 0;
1415 }
1416 _emit(ctx, &p.out, OP_LOGICALAND);
1417 }
1418 }
1419
1420
1421 static int
1422 _parse_logical_xor_expression(struct parse_context *ctx,
1423 struct parse_state *ps)
1424 {
1425 struct parse_state p = *ps;
1426
1427 if (_parse_logical_and_expression(ctx, &p)) {
1428 return -1;
1429 }
1430 for (;;) {
1431 *ps = p;
1432 if (_parse_token(ctx, SL_PP_XOR, &p)) {
1433 return 0;
1434 }
1435 if (_parse_logical_and_expression(ctx, &p)) {
1436 return 0;
1437 }
1438 _emit(ctx, &p.out, OP_LOGICALXOR);
1439 }
1440 }
1441
1442
1443 static int
1444 _parse_logical_or_expression(struct parse_context *ctx,
1445 struct parse_state *ps)
1446 {
1447 struct parse_state p = *ps;
1448
1449 if (_parse_logical_xor_expression(ctx, &p)) {
1450 return -1;
1451 }
1452 for (;;) {
1453 *ps = p;
1454 if (_parse_token(ctx, SL_PP_OR, &p)) {
1455 return 0;
1456 }
1457 if (_parse_logical_xor_expression(ctx, &p)) {
1458 return 0;
1459 }
1460 _emit(ctx, &p.out, OP_LOGICALOR);
1461 }
1462 }
1463
1464
1465 static int
1466 _parse_conditional_expression(struct parse_context *ctx,
1467 struct parse_state *ps)
1468 {
1469 struct parse_state p = *ps;
1470
1471 if (_parse_logical_or_expression(ctx, &p)) {
1472 return -1;
1473 }
1474 for (;;) {
1475 *ps = p;
1476 if (_parse_token(ctx, SL_PP_QUESTION, &p)) {
1477 return 0;
1478 }
1479 if (_parse_expression(ctx, &p)) {
1480 return 0;
1481 }
1482 if (_parse_token(ctx, SL_PP_COLON, &p)) {
1483 return 0;
1484 }
1485 if (_parse_conditional_expression(ctx, &p)) {
1486 return 0;
1487 }
1488 _emit(ctx, &p.out, OP_SELECT);
1489 }
1490 }
1491
1492
1493 static int
1494 _parse_constant_expression(struct parse_context *ctx,
1495 struct parse_state *ps)
1496 {
1497 if (_parse_conditional_expression(ctx, ps)) {
1498 return -1;
1499 }
1500 _emit(ctx, &ps->out, OP_END);
1501 return 0;
1502 }
1503
1504
1505 static int
1506 _parse_parameter_declarator_array(struct parse_context *ctx,
1507 struct parse_state *ps)
1508 {
1509 struct parse_state p = *ps;
1510
1511 if (_parse_token(ctx, SL_PP_LBRACKET, &p)) {
1512 return -1;
1513 }
1514 if (_parse_constant_expression(ctx, &p)) {
1515 _error(ctx, "expected constant integral expression");
1516 return -1;
1517 }
1518 if (_parse_token(ctx, SL_PP_RBRACKET, &p)) {
1519 _error(ctx, "expected `]'");
1520 return -1;
1521 }
1522 *ps = p;
1523 return 0;
1524 }
1525
1526
1527 static int
1528 _parse_parameter_declarator(struct parse_context *ctx,
1529 struct parse_state *ps)
1530 {
1531 struct parse_state p = *ps;
1532 unsigned int e;
1533
1534 if (_parse_type_specifier(ctx, &p)) {
1535 return -1;
1536 }
1537 if (_parse_identifier(ctx, &p)) {
1538 return -1;
1539 }
1540 e = _emit(ctx, &p.out, PARAMETER_ARRAY_PRESENT);
1541 if (_parse_parameter_declarator_array(ctx, &p)) {
1542 _update(ctx, e, PARAMETER_ARRAY_NOT_PRESENT);
1543 }
1544 *ps = p;
1545 return 0;
1546 }
1547
1548
1549 static int
1550 _parse_parameter_type_specifier_array(struct parse_context *ctx,
1551 struct parse_state *ps)
1552 {
1553 struct parse_state p = *ps;
1554
1555 if (_parse_token(ctx, SL_PP_LBRACKET, &p)) {
1556 return -1;
1557 }
1558 if (_parse_constant_expression(ctx, &p)) {
1559 _error(ctx, "expected constant integral expression");
1560 return -1;
1561 }
1562 if (_parse_token(ctx, SL_PP_RBRACKET, &p)) {
1563 _error(ctx, "expected `]'");
1564 return -1;
1565 }
1566 *ps = p;
1567 return 0;
1568 }
1569
1570
1571 static int
1572 _parse_parameter_type_specifier(struct parse_context *ctx,
1573 struct parse_state *ps)
1574 {
1575 struct parse_state p = *ps;
1576 unsigned int e;
1577
1578 if (_parse_type_specifier(ctx, &p)) {
1579 return -1;
1580 }
1581 _emit(ctx, &p.out, '\0');
1582
1583 e = _emit(ctx, &p.out, PARAMETER_ARRAY_PRESENT);
1584 if (_parse_parameter_type_specifier_array(ctx, &p)) {
1585 _update(ctx, e, PARAMETER_ARRAY_NOT_PRESENT);
1586 }
1587 *ps = p;
1588 return 0;
1589 }
1590
1591
1592 static int
1593 _parse_parameter_declaration(struct parse_context *ctx,
1594 struct parse_state *ps)
1595 {
1596 struct parse_state p = *ps;
1597 unsigned int e = _emit(ctx, &p.out, PARAMETER_NEXT);
1598
1599 if (_parse_type_qualifier(ctx, &p)) {
1600 _emit(ctx, &p.out, TYPE_QUALIFIER_NONE);
1601 }
1602 _parse_parameter_qualifier(ctx, &p);
1603 if (_parse_precision(ctx, &p)) {
1604 _emit(ctx, &p.out, PRECISION_DEFAULT);
1605 }
1606 if (_parse_parameter_declarator(ctx, &p) == 0) {
1607 *ps = p;
1608 return 0;
1609 }
1610 if (_parse_parameter_type_specifier(ctx, &p) == 0) {
1611 *ps = p;
1612 return 0;
1613 }
1614
1615 return -1;
1616 }
1617
1618
1619 static int
1620 _parse_function_header_with_parameters(struct parse_context *ctx,
1621 struct parse_state *ps)
1622 {
1623 struct parse_state p = *ps;
1624
1625 if (_parse_function_header(ctx, &p)) {
1626 return -1;
1627 }
1628 if (_parse_parameter_declaration(ctx, &p)) {
1629 return -1;
1630 }
1631
1632 for (;;) {
1633 *ps = p;
1634 if (_parse_token(ctx, SL_PP_COMMA, &p)) {
1635 return 0;
1636 }
1637 if (_parse_parameter_declaration(ctx, &p)) {
1638 return 0;
1639 }
1640 }
1641 }
1642
1643
1644 static int
1645 _parse_function_declarator(struct parse_context *ctx,
1646 struct parse_state *ps)
1647 {
1648 if (_parse_function_header_with_parameters(ctx, ps) == 0) {
1649 return 0;
1650 }
1651
1652 if (_parse_function_header(ctx, ps) == 0) {
1653 return 0;
1654 }
1655
1656 return -1;
1657 }
1658
1659
1660 static int
1661 _parse_function_prototype(struct parse_context *ctx,
1662 struct parse_state *ps)
1663 {
1664 struct parse_state p = *ps;
1665
1666 if (_parse_function_header(ctx, &p) == 0) {
1667 if (_parse_id(ctx, ctx->dict._void, &p) == 0) {
1668 if (_parse_token(ctx, SL_PP_RPAREN, &p) == 0) {
1669 _emit(ctx, &p.out, PARAMETER_NONE);
1670 *ps = p;
1671 return 0;
1672 }
1673 _error(ctx, "expected `)'");
1674 return -1;
1675 }
1676 }
1677
1678 p = *ps;
1679 if (_parse_function_declarator(ctx, &p) == 0) {
1680 if (_parse_token(ctx, SL_PP_RPAREN, &p) == 0) {
1681 _emit(ctx, &p.out, PARAMETER_NONE);
1682 *ps = p;
1683 return 0;
1684 }
1685 _error(ctx, "expected `)'");
1686 return -1;
1687 }
1688
1689 return -1;
1690 }
1691
1692
1693 static int
1694 _parse_precision(struct parse_context *ctx,
1695 struct parse_state *ps)
1696 {
1697 int id;
1698 unsigned int precision;
1699
1700 if (ctx->input[ps->in].token != SL_PP_IDENTIFIER) {
1701 return -1;
1702 }
1703 id = ctx->input[ps->in].data.identifier;
1704
1705 if (id == ctx->dict.lowp) {
1706 precision = PRECISION_LOW;
1707 } else if (id == ctx->dict.mediump) {
1708 precision = PRECISION_MEDIUM;
1709 } else if (id == ctx->dict.highp) {
1710 precision = PRECISION_HIGH;
1711 } else {
1712 return -1;
1713 }
1714
1715 _parse_token(ctx, SL_PP_IDENTIFIER, ps);
1716 _emit(ctx, &ps->out, precision);
1717 return 0;
1718 }
1719
1720
1721 static int
1722 _parse_prectype(struct parse_context *ctx,
1723 struct parse_state *ps)
1724 {
1725 int id;
1726 unsigned int type;
1727
1728 if (ctx->input[ps->in].token != SL_PP_IDENTIFIER) {
1729 return -1;
1730 }
1731 id = ctx->input[ps->in].data.identifier;
1732
1733 if (id == ctx->dict._int) {
1734 type = TYPE_SPECIFIER_INT;
1735 } else if (id == ctx->dict._float) {
1736 type = TYPE_SPECIFIER_FLOAT;
1737 } else if (id == ctx->dict.sampler1D) {
1738 type = TYPE_SPECIFIER_SAMPLER1D;
1739 } else if (id == ctx->dict.sampler2D) {
1740 type = TYPE_SPECIFIER_SAMPLER2D;
1741 } else if (id == ctx->dict.sampler3D) {
1742 type = TYPE_SPECIFIER_SAMPLER3D;
1743 } else if (id == ctx->dict.samplerCube) {
1744 type = TYPE_SPECIFIER_SAMPLERCUBE;
1745 } else if (id == ctx->dict.sampler1DShadow) {
1746 type = TYPE_SPECIFIER_SAMPLER1DSHADOW;
1747 } else if (id == ctx->dict.sampler2DShadow) {
1748 type = TYPE_SPECIFIER_SAMPLER2DSHADOW;
1749 } else if (id == ctx->dict.sampler2DRect) {
1750 type = TYPE_SPECIFIER_SAMPLER2DRECT;
1751 } else if (id == ctx->dict.sampler2DRectShadow) {
1752 type = TYPE_SPECIFIER_SAMPLER2DRECTSHADOW;
1753 } else {
1754 return -1;
1755 }
1756
1757 _parse_token(ctx, SL_PP_IDENTIFIER, ps);
1758 _emit(ctx, &ps->out, type);
1759 return 0;
1760 }
1761
1762
1763 static int
1764 _parse_precision_stmt(struct parse_context *ctx,
1765 struct parse_state *ps)
1766 {
1767 struct parse_state p = *ps;
1768
1769 if (_parse_id(ctx, ctx->dict.precision, &p)) {
1770 return -1;
1771 }
1772 if (_parse_precision(ctx, &p)) {
1773 return -1;
1774 }
1775 if (_parse_prectype(ctx, &p)) {
1776 return -1;
1777 }
1778 if (_parse_token(ctx, SL_PP_SEMICOLON, &p)) {
1779 return -1;
1780 }
1781 *ps = p;
1782 return 0;
1783 }
1784
1785
1786 static int
1787 _parse_floatconstant(struct parse_context *ctx,
1788 struct parse_state *ps)
1789 {
1790 struct parse_state p = *ps;
1791
1792 _emit(ctx, &p.out, OP_PUSH_FLOAT);
1793 if (_parse_float(ctx, &p)) {
1794 return -1;
1795 }
1796 *ps = p;
1797 return 0;
1798 }
1799
1800
1801 static int
1802 _parse_intconstant(struct parse_context *ctx,
1803 struct parse_state *ps)
1804 {
1805 struct parse_state p = *ps;
1806
1807 _emit(ctx, &p.out, OP_PUSH_INT);
1808 if (_parse_uint(ctx, &p)) {
1809 return -1;
1810 }
1811 *ps = p;
1812 return 0;
1813 }
1814
1815
1816 static int
1817 _parse_boolconstant(struct parse_context *ctx,
1818 struct parse_state *ps)
1819 {
1820 if (_parse_id(ctx, ctx->dict._false, ps) == 0) {
1821 _emit(ctx, &ps->out, OP_PUSH_BOOL);
1822 _emit(ctx, &ps->out, '0');
1823 _emit(ctx, &ps->out, '\0');
1824 return 0;
1825 }
1826
1827 if (_parse_id(ctx, ctx->dict._true, ps) == 0) {
1828 _emit(ctx, &ps->out, OP_PUSH_BOOL);
1829 _emit(ctx, &ps->out, '1');
1830 _emit(ctx, &ps->out, '\0');
1831 return 0;
1832 }
1833
1834 return -1;
1835 }
1836
1837
1838 static int
1839 _parse_variable_identifier(struct parse_context *ctx,
1840 struct parse_state *ps)
1841 {
1842 struct parse_state p = *ps;
1843
1844 _emit(ctx, &p.out, OP_PUSH_IDENTIFIER);
1845 if (_parse_identifier(ctx, &p)) {
1846 return -1;
1847 }
1848 *ps = p;
1849 return 0;
1850 }
1851
1852
1853 static int
1854 _parse_primary_expression(struct parse_context *ctx,
1855 struct parse_state *ps)
1856 {
1857 struct parse_state p;
1858
1859 if (_parse_floatconstant(ctx, ps) == 0) {
1860 return 0;
1861 }
1862 if (_parse_boolconstant(ctx, ps) == 0) {
1863 return 0;
1864 }
1865 if (_parse_intconstant(ctx, ps) == 0) {
1866 return 0;
1867 }
1868 if (_parse_variable_identifier(ctx, ps) == 0) {
1869 return 0;
1870 }
1871
1872 p = *ps;
1873 if (_parse_token(ctx, SL_PP_LPAREN, &p)) {
1874 return -1;
1875 }
1876 if (_parse_expression(ctx, &p)) {
1877 return -1;
1878 }
1879 if (_parse_token(ctx, SL_PP_RPAREN, &p)) {
1880 return -1;
1881 }
1882
1883 *ps = p;
1884 return 0;
1885 }
1886
1887
1888 static int
1889 _parse_asm_argument(struct parse_context *ctx,
1890 struct parse_state *ps)
1891 {
1892 if (_parse_variable_identifier(ctx, ps) == 0) {
1893 struct parse_state p = *ps;
1894
1895 if (_parse_token(ctx, SL_PP_DOT, &p)) {
1896 return 0;
1897 }
1898 _emit(ctx, &p.out, OP_FIELD);
1899 if (_parse_identifier(ctx, &p)) {
1900 return 0;
1901 }
1902 *ps = p;
1903 return 0;
1904 }
1905
1906 if (_parse_floatconstant(ctx, ps) == 0) {
1907 return 0;
1908 }
1909
1910 return -1;
1911 }
1912
1913
1914 static int
1915 _parse_asm_arguments(struct parse_context *ctx,
1916 struct parse_state *ps)
1917 {
1918 struct parse_state p = *ps;
1919
1920 if (_parse_asm_argument(ctx, &p)) {
1921 return -1;
1922 }
1923 _emit(ctx, &p.out, OP_END);
1924
1925 for (;;) {
1926 *ps = p;
1927 if (_parse_token(ctx, SL_PP_COMMA, &p)) {
1928 return 0;
1929 }
1930 if (_parse_asm_argument(ctx, &p)) {
1931 return 0;
1932 }
1933 _emit(ctx, &p.out, OP_END);
1934 }
1935 }
1936
1937
1938 static int
1939 _parse_asm_statement(struct parse_context *ctx,
1940 struct parse_state *ps)
1941 {
1942 struct parse_state p = *ps;
1943
1944 if (_parse_id(ctx, ctx->dict.___asm, &p)) {
1945 return -1;
1946 }
1947 if (_parse_identifier(ctx, &p)) {
1948 return -1;
1949 }
1950 if (_parse_asm_arguments(ctx, &p)) {
1951 return -1;
1952 }
1953 if (_parse_token(ctx, SL_PP_SEMICOLON, &p)) {
1954 return -1;
1955 }
1956 _emit(ctx, &p.out, OP_END);
1957 *ps = p;
1958 return 0;
1959 }
1960
1961
1962 static int
1963 _parse_selection_statement(struct parse_context *ctx,
1964 struct parse_state *ps)
1965 {
1966 struct parse_state p = *ps;
1967
1968 _emit(ctx, &p.out, OP_IF);
1969 if (_parse_id(ctx, ctx->dict._if, &p)) {
1970 return -1;
1971 }
1972 if (_parse_token(ctx, SL_PP_LPAREN, &p)) {
1973 _error(ctx, "expected `('");
1974 return -1;
1975 }
1976 if (_parse_expression(ctx, &p)) {
1977 _error(ctx, "expected an expression");
1978 return -1;
1979 }
1980 if (_parse_token(ctx, SL_PP_RPAREN, &p)) {
1981 _error(ctx, "expected `)'");
1982 return -1;
1983 }
1984 _emit(ctx, &p.out, OP_END);
1985 if (_parse_statement(ctx, &p)) {
1986 return -1;
1987 }
1988
1989 *ps = p;
1990 if (_parse_id(ctx, ctx->dict._else, &p) == 0) {
1991 if (_parse_statement(ctx, &p) == 0) {
1992 *ps = p;
1993 return 0;
1994 }
1995 }
1996
1997 _emit(ctx, &ps->out, OP_EXPRESSION);
1998 _emit(ctx, &ps->out, OP_PUSH_VOID);
1999 _emit(ctx, &ps->out, OP_END);
2000 return 0;
2001 }
2002
2003
2004 static int
2005 _parse_expression_statement(struct parse_context *ctx,
2006 struct parse_state *ps)
2007 {
2008 struct parse_state p = *ps;
2009
2010 if (_parse_expression(ctx, &p)) {
2011 _emit(ctx, &p.out, OP_PUSH_VOID);
2012 }
2013 if (_parse_token(ctx, SL_PP_SEMICOLON, &p)) {
2014 return -1;
2015 }
2016 _emit(ctx, &p.out, OP_END);
2017 *ps = p;
2018 return 0;
2019 }
2020
2021
2022 static int
2023 _parse_for_init_statement(struct parse_context *ctx,
2024 struct parse_state *ps)
2025 {
2026 struct parse_state p = *ps;
2027 unsigned int e = _emit(ctx, &p.out, OP_EXPRESSION);
2028
2029 if (_parse_expression_statement(ctx, &p) == 0) {
2030 *ps = p;
2031 return 0;
2032 }
2033
2034 if (_parse_declaration(ctx, &p) == 0) {
2035 _update(ctx, e, OP_DECLARE);
2036 *ps = p;
2037 return 0;
2038 }
2039
2040 return -1;
2041 }
2042
2043
2044 static int
2045 _parse_initializer(struct parse_context *ctx,
2046 struct parse_state *ps)
2047 {
2048 if (_parse_assignment_expression(ctx, ps) == 0) {
2049 _emit(ctx, &ps->out, OP_END);
2050 return 0;
2051 }
2052 return -1;
2053 }
2054
2055
2056 static int
2057 _parse_condition_initializer(struct parse_context *ctx,
2058 struct parse_state *ps)
2059 {
2060 struct parse_state p = *ps;
2061
2062 _emit(ctx, &p.out, OP_DECLARE);
2063 _emit(ctx, &p.out, DECLARATION_INIT_DECLARATOR_LIST);
2064 if (_parse_fully_specified_type(ctx, &p)) {
2065 return -1;
2066 }
2067 _emit(ctx, &p.out, VARIABLE_IDENTIFIER);
2068 if (_parse_identifier(ctx, &p)) {
2069 return -1;
2070 }
2071 if (_parse_token(ctx, SL_PP_ASSIGN, &p)) {
2072 _error(ctx, "expected `='");
2073 return -1;
2074 }
2075 _emit(ctx, &p.out, VARIABLE_INITIALIZER);
2076 if (_parse_initializer(ctx, &p)) {
2077 _error(ctx, "expected an initialiser");
2078 return -1;
2079 }
2080 _emit(ctx, &p.out, DECLARATOR_NONE);
2081 *ps = p;
2082 return 0;
2083 }
2084
2085
2086 static int
2087 _parse_condition(struct parse_context *ctx,
2088 struct parse_state *ps)
2089 {
2090 struct parse_state p;
2091
2092 if (_parse_condition_initializer(ctx, ps) == 0) {
2093 return 0;
2094 }
2095
2096 p = *ps;
2097 _emit(ctx, &p.out, OP_EXPRESSION);
2098 if (_parse_expression(ctx, &p) == 0) {
2099 _emit(ctx, &p.out, OP_END);
2100 *ps = p;
2101 return 0;
2102 }
2103
2104 return -1;
2105 }
2106
2107
2108 static int
2109 _parse_for_rest_statement(struct parse_context *ctx,
2110 struct parse_state *ps)
2111 {
2112 struct parse_state p = *ps;
2113
2114 if (_parse_condition(ctx, &p)) {
2115 _emit(ctx, &p.out, OP_EXPRESSION);
2116 _emit(ctx, &p.out, OP_PUSH_BOOL);
2117 _emit(ctx, &p.out, 2);
2118 _emit(ctx, &p.out, '1');
2119 _emit(ctx, &p.out, '\0');
2120 _emit(ctx, &p.out, OP_END);
2121 }
2122 if (_parse_token(ctx, SL_PP_SEMICOLON, &p)) {
2123 return -1;
2124 }
2125 if (_parse_expression(ctx, &p)) {
2126 _emit(ctx, &p.out, OP_PUSH_VOID);
2127 }
2128 _emit(ctx, &p.out, OP_END);
2129 *ps = p;
2130 return 0;
2131 }
2132
2133
2134 static int
2135 _parse_iteration_statement(struct parse_context *ctx,
2136 struct parse_state *ps)
2137 {
2138 struct parse_state p = *ps;
2139
2140 if (_parse_id(ctx, ctx->dict._while, &p) == 0) {
2141 _emit(ctx, &p.out, OP_WHILE);
2142 if (_parse_token(ctx, SL_PP_LPAREN, &p)) {
2143 _error(ctx, "expected `('");
2144 return -1;
2145 }
2146 if (_parse_condition(ctx, &p)) {
2147 _error(ctx, "expected an expression");
2148 return -1;
2149 }
2150 if (_parse_token(ctx, SL_PP_RPAREN, &p)) {
2151 _error(ctx, "expected `)'");
2152 return -1;
2153 }
2154 if (_parse_statement(ctx, &p)) {
2155 return -1;
2156 }
2157 *ps = p;
2158 return 0;
2159 }
2160
2161 if (_parse_id(ctx, ctx->dict._do, &p) == 0) {
2162 _emit(ctx, &p.out, OP_DO);
2163 if (_parse_statement(ctx, &p)) {
2164 return -1;
2165 }
2166 if (_parse_id(ctx, ctx->dict._while, &p)) {
2167 return -1;
2168 }
2169 if (_parse_token(ctx, SL_PP_LPAREN, &p)) {
2170 _error(ctx, "expected `('");
2171 return -1;
2172 }
2173 if (_parse_expression(ctx, &p)) {
2174 _error(ctx, "expected an expression");
2175 return -1;
2176 }
2177 if (_parse_token(ctx, SL_PP_RPAREN, &p)) {
2178 _error(ctx, "expected `)'");
2179 return -1;
2180 }
2181 _emit(ctx, &p.out, OP_END);
2182 if (_parse_token(ctx, SL_PP_SEMICOLON, &p)) {
2183 _error(ctx, "expected `;'");
2184 return -1;
2185 }
2186 *ps = p;
2187 return 0;
2188 }
2189
2190 if (_parse_id(ctx, ctx->dict._for, &p) == 0) {
2191 _emit(ctx, &p.out, OP_FOR);
2192 if (_parse_token(ctx, SL_PP_LPAREN, &p)) {
2193 _error(ctx, "expected `('");
2194 return -1;
2195 }
2196 if (_parse_for_init_statement(ctx, &p)) {
2197 return -1;
2198 }
2199 if (_parse_for_rest_statement(ctx, &p)) {
2200 return -1;
2201 }
2202 if (_parse_token(ctx, SL_PP_RPAREN, &p)) {
2203 _error(ctx, "expected `)'");
2204 return -1;
2205 }
2206 if (_parse_statement(ctx, &p)) {
2207 return -1;
2208 }
2209 *ps = p;
2210 return 0;
2211 }
2212
2213 return -1;
2214 }
2215
2216
2217 static int
2218 _parse_jump_statement(struct parse_context *ctx,
2219 struct parse_state *ps)
2220 {
2221 struct parse_state p = *ps;
2222 unsigned int e = _emit(ctx, &p.out, 0);
2223
2224 if (_parse_id(ctx, ctx->dict._continue, &p) == 0) {
2225 _update(ctx, e, OP_CONTINUE);
2226 } else if (_parse_id(ctx, ctx->dict._break, &p) == 0) {
2227 _update(ctx, e, OP_BREAK);
2228 } else if (_parse_id(ctx, ctx->dict._return, &p) == 0) {
2229 _update(ctx, e, OP_RETURN);
2230 if (_parse_expression(ctx, &p)) {
2231 _emit(ctx, &p.out, OP_PUSH_VOID);
2232 }
2233 _emit(ctx, &p.out, OP_END);
2234 } else if (ctx->shader_type == 1 && _parse_id(ctx, ctx->dict.discard, &p) == 0) {
2235 _update(ctx, e, OP_DISCARD);
2236 } else {
2237 return -1;
2238 }
2239 if (_parse_token(ctx, SL_PP_SEMICOLON, &p)) {
2240 return -1;
2241 }
2242 *ps = p;
2243 return 0;
2244 }
2245
2246
2247 static int
2248 _parse_simple_statement(struct parse_context *ctx,
2249 struct parse_state *ps)
2250 {
2251 struct parse_state p;
2252 unsigned int e;
2253
2254 if (_parse_selection_statement(ctx, ps) == 0) {
2255 return 0;
2256 }
2257
2258 if (_parse_iteration_statement(ctx, ps) == 0) {
2259 return 0;
2260 }
2261
2262 if (_parse_jump_statement(ctx, ps) == 0) {
2263 return 0;
2264 }
2265
2266 p = *ps;
2267 e = _emit(ctx, &p.out, OP_EXPRESSION);
2268 if (_parse_expression_statement(ctx, &p) == 0) {
2269 *ps = p;
2270 return 0;
2271 }
2272
2273 if (_parse_precision_stmt(ctx, &p) == 0) {
2274 _update(ctx, e, OP_PRECISION);
2275 *ps = p;
2276 return 0;
2277 }
2278
2279 if (ctx->parsing_builtin && _parse_asm_statement(ctx, &p) == 0) {
2280 _update(ctx, e, OP_ASM);
2281 *ps = p;
2282 return 0;
2283 }
2284
2285 if (_parse_declaration(ctx, &p) == 0) {
2286 _update(ctx, e, OP_DECLARE);
2287 *ps = p;
2288 return 0;
2289 }
2290
2291 return -1;
2292 }
2293
2294
2295 static int
2296 _parse_compound_statement(struct parse_context *ctx,
2297 struct parse_state *ps)
2298 {
2299 struct parse_state p = *ps;
2300
2301 if (_parse_token(ctx, SL_PP_LBRACE, &p)) {
2302 return -1;
2303 }
2304 _emit(ctx, &p.out, OP_BLOCK_BEGIN_NEW_SCOPE);
2305 _parse_statement_list(ctx, &p);
2306 if (_parse_token(ctx, SL_PP_RBRACE, &p)) {
2307 return -1;
2308 }
2309 _emit(ctx, &p.out, OP_END);
2310 *ps = p;
2311 return 0;
2312 }
2313
2314
2315 static int
2316 _parse_statement(struct parse_context *ctx,
2317 struct parse_state *ps)
2318 {
2319 if (_parse_compound_statement(ctx, ps) == 0) {
2320 return 0;
2321 }
2322
2323 if (_parse_simple_statement(ctx, ps) == 0) {
2324 return 0;
2325 }
2326
2327 return -1;
2328 }
2329
2330
2331 static int
2332 _parse_statement_list(struct parse_context *ctx,
2333 struct parse_state *ps)
2334 {
2335 struct parse_state p = *ps;
2336
2337 if (_parse_statement(ctx, &p)) {
2338 return -1;
2339 }
2340
2341 for (;;) {
2342 *ps = p;
2343 if (_parse_statement(ctx, &p)) {
2344 return 0;
2345 }
2346 }
2347 }
2348
2349
2350 static int
2351 _parse_compound_statement_no_new_scope(struct parse_context *ctx,
2352 struct parse_state *ps)
2353 {
2354 struct parse_state p = *ps;
2355
2356 if (_parse_token(ctx, SL_PP_LBRACE, &p)) {
2357 return -1;
2358 }
2359 _emit(ctx, &p.out, OP_BLOCK_BEGIN_NO_NEW_SCOPE);
2360 _parse_statement_list(ctx, &p);
2361 if (_parse_token(ctx, SL_PP_RBRACE, &p)) {
2362 return -1;
2363 }
2364 _emit(ctx, &p.out, OP_END);
2365 *ps = p;
2366 return 0;
2367 }
2368
2369
2370 static int
2371 _parse_function_definition(struct parse_context *ctx,
2372 struct parse_state *ps)
2373 {
2374 struct parse_state p = *ps;
2375
2376 if (_parse_function_prototype(ctx, &p)) {
2377 return -1;
2378 }
2379 if (_parse_compound_statement_no_new_scope(ctx, &p)) {
2380 return -1;
2381 }
2382 *ps = p;
2383 return 0;
2384 }
2385
2386
2387 static int
2388 _parse_invariant_stmt(struct parse_context *ctx,
2389 struct parse_state *ps)
2390 {
2391 struct parse_state p = *ps;
2392
2393 if (_parse_id(ctx, ctx->dict.invariant, &p)) {
2394 return -1;
2395 }
2396 if (_parse_identifier(ctx, &p)) {
2397 return -1;
2398 }
2399 if (_parse_token(ctx, SL_PP_SEMICOLON, &p)) {
2400 return -1;
2401 }
2402 *ps = p;
2403 return 0;
2404 }
2405
2406
2407 static int
2408 _parse_single_declaration(struct parse_context *ctx,
2409 struct parse_state *ps)
2410 {
2411 struct parse_state p = *ps;
2412 unsigned int e;
2413
2414 if (_parse_fully_specified_type(ctx, &p)) {
2415 return -1;
2416 }
2417
2418 e = _emit(ctx, &p.out, VARIABLE_IDENTIFIER);
2419 if (_parse_identifier(ctx, &p)) {
2420 _update(ctx, e, VARIABLE_NONE);
2421 *ps = p;
2422 return 0;
2423 }
2424
2425 e = _emit(ctx, &p.out, VARIABLE_NONE);
2426 *ps = p;
2427
2428 if (_parse_token(ctx, SL_PP_ASSIGN, &p) == 0) {
2429 _update(ctx, e, VARIABLE_INITIALIZER);
2430 if (_parse_initializer(ctx, &p) == 0) {
2431 *ps = p;
2432 return 0;
2433 }
2434 _error(ctx, "expected an initialiser");
2435 return -1;
2436 }
2437 p = *ps;
2438
2439 if (_parse_token(ctx, SL_PP_LBRACKET, &p) == 0) {
2440 if (_parse_constant_expression(ctx, &p)) {
2441 _update(ctx, e, VARIABLE_ARRAY_UNKNOWN);
2442 } else {
2443 _update(ctx, e, VARIABLE_ARRAY_EXPLICIT);
2444 }
2445 if (_parse_token(ctx, SL_PP_RBRACKET, &p) == 0) {
2446 *ps = p;
2447 return 0;
2448 }
2449 _error(ctx, "expected `]'");
2450 return -1;
2451 }
2452 return 0;
2453 }
2454
2455
2456 static int
2457 _parse_init_declarator_list(struct parse_context *ctx,
2458 struct parse_state *ps)
2459 {
2460 struct parse_state p = *ps;
2461
2462 if (_parse_single_declaration(ctx, &p)) {
2463 return -1;
2464 }
2465
2466 for (;;) {
2467 unsigned int e;
2468
2469 *ps = p;
2470 if (_parse_token(ctx, SL_PP_COMMA, &p)) {
2471 break;
2472 }
2473 _emit(ctx, &p.out, DECLARATOR_NEXT);
2474 _emit(ctx, &p.out, VARIABLE_IDENTIFIER);
2475 if (_parse_identifier(ctx, &p)) {
2476 break;
2477 }
2478
2479 e = _emit(ctx, &p.out, VARIABLE_NONE);
2480 *ps = p;
2481
2482 if (_parse_token(ctx, SL_PP_ASSIGN, &p) == 0) {
2483 if (_parse_initializer(ctx, &p) == 0) {
2484 _update(ctx, e, VARIABLE_INITIALIZER);
2485 *ps = p;
2486 continue;
2487 }
2488 _error(ctx, "expected an initialiser");
2489 break;
2490 }
2491 p = *ps;
2492
2493 if (_parse_token(ctx, SL_PP_LBRACKET, &p) == 0) {
2494 unsigned int arr;
2495
2496 if (_parse_constant_expression(ctx, &p)) {
2497 arr = VARIABLE_ARRAY_UNKNOWN;
2498 } else {
2499 arr = VARIABLE_ARRAY_EXPLICIT;
2500 }
2501 if (_parse_token(ctx, SL_PP_RBRACKET, &p) == 0) {
2502 _update(ctx, e, arr);
2503 *ps = p;
2504 continue;
2505 }
2506 _error(ctx, "expected `]'");
2507 break;
2508 }
2509 p = *ps;
2510 }
2511
2512 _emit(ctx, &ps->out, DECLARATOR_NONE);
2513 return 0;
2514 }
2515
2516
2517 static int
2518 _parse_declaration(struct parse_context *ctx,
2519 struct parse_state *ps)
2520 {
2521 struct parse_state p = *ps;
2522 unsigned int e = _emit(ctx, &p.out, DECLARATION_FUNCTION_PROTOTYPE);
2523
2524 if (_parse_function_prototype(ctx, &p)) {
2525 if (_parse_init_declarator_list(ctx, &p)) {
2526 return -1;
2527 }
2528 _update(ctx, e, DECLARATION_INIT_DECLARATOR_LIST);
2529 }
2530 if (_parse_token(ctx, SL_PP_SEMICOLON, &p)) {
2531 _error(ctx, "expected `;'");
2532 return -1;
2533 }
2534 *ps = p;
2535 return 0;
2536 }
2537
2538
2539 static int
2540 _parse_external_declaration(struct parse_context *ctx,
2541 struct parse_state *ps)
2542 {
2543 struct parse_state p = *ps;
2544 unsigned int e = _emit(ctx, &p.out, 0);
2545
2546 if (_parse_precision_stmt(ctx, &p) == 0) {
2547 _update(ctx, e, DEFAULT_PRECISION);
2548 *ps = p;
2549 return 0;
2550 }
2551
2552 if (_parse_function_definition(ctx, &p) == 0) {
2553 _update(ctx, e, EXTERNAL_FUNCTION_DEFINITION);
2554 *ps = p;
2555 return 0;
2556 }
2557
2558 if (_parse_invariant_stmt(ctx, &p) == 0) {
2559 _update(ctx, e, INVARIANT_STMT);
2560 *ps = p;
2561 return 0;
2562 }
2563
2564 if (_parse_declaration(ctx, &p) == 0) {
2565 _update(ctx, e, EXTERNAL_DECLARATION);
2566 *ps = p;
2567 return 0;
2568 }
2569
2570 _error(ctx, "expected an identifier");
2571 return -1;
2572 }
2573
2574
2575 static int
2576 _parse_translation_unit(struct parse_context *ctx,
2577 struct parse_state *ps)
2578 {
2579 _emit(ctx, &ps->out, REVISION);
2580 if (_parse_external_declaration(ctx, ps)) {
2581 return -1;
2582 }
2583 while (_parse_external_declaration(ctx, ps) == 0) {
2584 }
2585 _emit(ctx, &ps->out, EXTERNAL_NULL);
2586 if (_parse_token(ctx, SL_PP_EOF, ps)) {
2587 return -1;
2588 }
2589 return 0;
2590 }
2591
2592
2593 #define ADD_NAME_STR(CTX, NAME, STR)\
2594 do {\
2595 (CTX).dict.NAME = sl_pp_context_add_unique_str((CTX).context, (STR));\
2596 if ((CTX).dict.NAME == -1) {\
2597 return -1;\
2598 }\
2599 } while (0)
2600
2601 #define ADD_NAME(CTX, NAME) ADD_NAME_STR(CTX, NAME, #NAME)
2602
2603
2604 int
2605 sl_cl_compile(struct sl_pp_context *context,
2606 const struct sl_pp_token_info *input,
2607 unsigned int shader_type,
2608 unsigned int parsing_builtin,
2609 unsigned char **output,
2610 unsigned int *cboutput,
2611 char *error,
2612 unsigned int cberror)
2613 {
2614 struct parse_context ctx;
2615 struct parse_state ps;
2616
2617 ctx.context = context;
2618 ctx.input = input;
2619
2620 ADD_NAME_STR(ctx, _void, "void");
2621 ADD_NAME_STR(ctx, _float, "float");
2622 ADD_NAME_STR(ctx, _int, "int");
2623 ADD_NAME_STR(ctx, _bool, "bool");
2624 ADD_NAME(ctx, vec2);
2625 ADD_NAME(ctx, vec3);
2626 ADD_NAME(ctx, vec4);
2627 ADD_NAME(ctx, bvec2);
2628 ADD_NAME(ctx, bvec3);
2629 ADD_NAME(ctx, bvec4);
2630 ADD_NAME(ctx, ivec2);
2631 ADD_NAME(ctx, ivec3);
2632 ADD_NAME(ctx, ivec4);
2633 ADD_NAME(ctx, mat2);
2634 ADD_NAME(ctx, mat3);
2635 ADD_NAME(ctx, mat4);
2636 ADD_NAME(ctx, mat2x3);
2637 ADD_NAME(ctx, mat3x2);
2638 ADD_NAME(ctx, mat2x4);
2639 ADD_NAME(ctx, mat4x2);
2640 ADD_NAME(ctx, mat3x4);
2641 ADD_NAME(ctx, mat4x3);
2642 ADD_NAME(ctx, sampler1D);
2643 ADD_NAME(ctx, sampler2D);
2644 ADD_NAME(ctx, sampler3D);
2645 ADD_NAME(ctx, samplerCube);
2646 ADD_NAME(ctx, sampler1DShadow);
2647 ADD_NAME(ctx, sampler2DShadow);
2648 ADD_NAME(ctx, sampler2DRect);
2649 ADD_NAME(ctx, sampler2DRectShadow);
2650
2651 ADD_NAME(ctx, invariant);
2652
2653 ADD_NAME(ctx, centroid);
2654
2655 ADD_NAME(ctx, precision);
2656 ADD_NAME(ctx, lowp);
2657 ADD_NAME(ctx, mediump);
2658 ADD_NAME(ctx, highp);
2659
2660 ADD_NAME_STR(ctx, _const, "const");
2661 ADD_NAME(ctx, attribute);
2662 ADD_NAME(ctx, varying);
2663 ADD_NAME(ctx, uniform);
2664 ADD_NAME(ctx, __fixed_output);
2665 ADD_NAME(ctx, __fixed_input);
2666
2667 ADD_NAME(ctx, in);
2668 ADD_NAME(ctx, out);
2669 ADD_NAME(ctx, inout);
2670
2671 ADD_NAME_STR(ctx, _struct, "struct");
2672
2673 ADD_NAME(ctx, __constructor);
2674 ADD_NAME(ctx, __operator);
2675 ADD_NAME_STR(ctx, ___asm, "__asm");
2676
2677 ADD_NAME_STR(ctx, _if, "if");
2678 ADD_NAME_STR(ctx, _else, "else");
2679 ADD_NAME_STR(ctx, _for, "for");
2680 ADD_NAME_STR(ctx, _while, "while");
2681 ADD_NAME_STR(ctx, _do, "do");
2682
2683 ADD_NAME_STR(ctx, _continue, "continue");
2684 ADD_NAME_STR(ctx, _break, "break");
2685 ADD_NAME_STR(ctx, _return, "return");
2686 ADD_NAME(ctx, discard);
2687
2688 ADD_NAME_STR(ctx, _false, "false");
2689 ADD_NAME_STR(ctx, _true, "true");
2690
2691 ctx.out_buf = NULL;
2692 ctx.out_cap = 0;
2693
2694 ctx.shader_type = shader_type;
2695 ctx.parsing_builtin = 1;
2696
2697 ctx.error[0] = '\0';
2698
2699 ps.in = 0;
2700 ps.out = 0;
2701
2702 if (_parse_translation_unit(&ctx, &ps)) {
2703 strncpy(error, ctx.error, cberror);
2704 return -1;
2705 }
2706
2707 *output = ctx.out_buf;
2708 *cboutput = ps.out;
2709 return 0;
2710 }