src/glsl/cl/sl_cl_parse.c

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