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