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