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