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