projects / mesa.git / blob
? search:


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