src/glsl/cl/sl_cl_parse.c

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