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