src/glsl/glcpp/glcpp-parse.y

   1 %{
   2 /*
   3  * Copyright © 2010 Intel Corporation
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <assert.h>
  29 #include <inttypes.h>
  30
  31 #include "glcpp.h"
  32 #include "main/core.h" /* for struct gl_extensions */
  33 #include "main/mtypes.h" /* for gl_api enum */
  34
  35 static void
  36 yyerror (YYLTYPE *locp, glcpp_parser_t *parser, const char *error);
  37
  38 static void
  39 _define_object_macro (glcpp_parser_t *parser,
  40                       YYLTYPE *loc,
  41                       const char *macro,
  42                       token_list_t *replacements);
  43
  44 static void
  45 _define_function_macro (glcpp_parser_t *parser,
  46                         YYLTYPE *loc,
  47                         const char *macro,
  48                         string_list_t *parameters,
  49                         token_list_t *replacements);
  50
  51 static string_list_t *
  52 _string_list_create (void *ctx);
  53
  54 static void
  55 _string_list_append_item (string_list_t *list, const char *str);
  56
  57 static int
  58 _string_list_contains (string_list_t *list, const char *member, int *index);
  59
  60 static int
  61 _string_list_length (string_list_t *list);
  62
  63 static int
  64 _string_list_equal (string_list_t *a, string_list_t *b);
  65
  66 static argument_list_t *
  67 _argument_list_create (void *ctx);
  68
  69 static void
  70 _argument_list_append (argument_list_t *list, token_list_t *argument);
  71
  72 static int
  73 _argument_list_length (argument_list_t *list);
  74
  75 static token_list_t *
  76 _argument_list_member_at (argument_list_t *list, int index);
  77
  78 /* Note: This function ralloc_steal()s the str pointer. */
  79 static token_t *
  80 _token_create_str (void *ctx, int type, char *str);
  81
  82 static token_t *
  83 _token_create_ival (void *ctx, int type, int ival);
  84
  85 static token_list_t *
  86 _token_list_create (void *ctx);
  87
  88 /* Note: This function calls ralloc_steal on token. */
  89 static void
  90 _token_list_append (token_list_t *list, token_t *token);
  91
  92 static void
  93 _token_list_append_list (token_list_t *list, token_list_t *tail);
  94
  95 static int
  96 _token_list_equal_ignoring_space (token_list_t *a, token_list_t *b);
  97
  98 static active_list_t *
  99 _active_list_push (active_list_t *list,
 100                    const char *identifier,
 101                    token_node_t *marker);
 102
 103 static active_list_t *
 104 _active_list_pop (active_list_t *list);
 105
 106 int
 107 _active_list_contains (active_list_t *list, const char *identifier);
 108
 109 static void
 110 _glcpp_parser_expand_if (glcpp_parser_t *parser, int type, token_list_t *list);
 111
 112 static void
 113 _glcpp_parser_expand_token_list (glcpp_parser_t *parser,
 114                                  token_list_t *list);
 115
 116 static void
 117 _glcpp_parser_print_expanded_token_list (glcpp_parser_t *parser,
 118                                          token_list_t *list);
 119
 120 static void
 121 _glcpp_parser_skip_stack_push_if (glcpp_parser_t *parser, YYLTYPE *loc,
 122                                   int condition);
 123
 124 static void
 125 _glcpp_parser_skip_stack_change_if (glcpp_parser_t *parser, YYLTYPE *loc,
 126                                     const char *type, int condition);
 127
 128 static void
 129 _glcpp_parser_skip_stack_pop (glcpp_parser_t *parser, YYLTYPE *loc);
 130
 131 #define yylex glcpp_parser_lex
 132
 133 static int
 134 glcpp_parser_lex (YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser);
 135
 136 static void
 137 glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list);
 138
 139 static void
 140 add_builtin_define(glcpp_parser_t *parser, const char *name, int value);
 141
 142 %}
 143
 144 %pure-parser
 145 %error-verbose
 146
 147 %locations
 148 %initial-action {
 149         @$.first_line = 1;
 150         @$.first_column = 1;
 151         @$.last_line = 1;
 152         @$.last_column = 1;
 153         @$.source = 0;
 154 }
 155
 156 %parse-param {glcpp_parser_t *parser}
 157 %lex-param {glcpp_parser_t *parser}
 158
 159 %expect 0
 160 %token COMMA_FINAL DEFINED ELIF_EXPANDED HASH HASH_DEFINE_FUNC HASH_DEFINE_OBJ HASH_ELIF HASH_ELSE HASH_ENDIF HASH_IF HASH_IFDEF HASH_IFNDEF HASH_UNDEF HASH_VERSION IDENTIFIER IF_EXPANDED INTEGER INTEGER_STRING NEWLINE OTHER PLACEHOLDER SPACE
 161 %token PASTE
 162 %type <ival> expression INTEGER operator SPACE integer_constant
 163 %type <str> IDENTIFIER INTEGER_STRING OTHER
 164 %type <string_list> identifier_list
 165 %type <token> preprocessing_token conditional_token
 166 %type <token_list> pp_tokens replacement_list text_line conditional_tokens
 167 %left OR
 168 %left AND
 169 %left '|'
 170 %left '^'
 171 %left '&'
 172 %left EQUAL NOT_EQUAL
 173 %left '<' '>' LESS_OR_EQUAL GREATER_OR_EQUAL
 174 %left LEFT_SHIFT RIGHT_SHIFT
 175 %left '+' '-'
 176 %left '*' '/' '%'
 177 %right UNARY
 178
 179 %%
 180
 181 input:
 182         /* empty */
 183 |       input line
 184 ;
 185
 186 line:
 187         control_line {
 188                 ralloc_strcat (&parser->output, "\n");
 189         }
 190 |       text_line {
 191                 _glcpp_parser_print_expanded_token_list (parser, $1);
 192                 ralloc_strcat (&parser->output, "\n");
 193                 ralloc_free ($1);
 194         }
 195 |       expanded_line
 196 |       HASH non_directive
 197 ;
 198
 199 expanded_line:
 200         IF_EXPANDED expression NEWLINE {
 201                 _glcpp_parser_skip_stack_push_if (parser, & @1, $2);
 202         }
 203 |       ELIF_EXPANDED expression NEWLINE {
 204                 _glcpp_parser_skip_stack_change_if (parser, & @1, "elif", $2);
 205         }
 206 ;
 207
 208 control_line:
 209         HASH_DEFINE_OBJ IDENTIFIER replacement_list NEWLINE {
 210                 _define_object_macro (parser, & @2, $2, $3);
 211         }
 212 |       HASH_DEFINE_FUNC IDENTIFIER '(' ')' replacement_list NEWLINE {
 213                 _define_function_macro (parser, & @2, $2, NULL, $5);
 214         }
 215 |       HASH_DEFINE_FUNC IDENTIFIER '(' identifier_list ')' replacement_list NEWLINE {
 216                 _define_function_macro (parser, & @2, $2, $4, $6);
 217         }
 218 |       HASH_UNDEF IDENTIFIER NEWLINE {
 219                 macro_t *macro = hash_table_find (parser->defines, $2);
 220                 if (macro) {
 221                         hash_table_remove (parser->defines, $2);
 222                         ralloc_free (macro);
 223                 }
 224                 ralloc_free ($2);
 225         }
 226 |       HASH_IF conditional_tokens NEWLINE {
 227                 /* Be careful to only evaluate the 'if' expression if
 228                  * we are not skipping. When we are skipping, we
 229                  * simply push a new 0-valued 'if' onto the skip
 230                  * stack.
 231                  *
 232                  * This avoids generating diagnostics for invalid
 233                  * expressions that are being skipped. */
 234                 if (parser->skip_stack == NULL ||
 235                     parser->skip_stack->type == SKIP_NO_SKIP)
 236                 {
 237                         _glcpp_parser_expand_if (parser, IF_EXPANDED, $2);
 238                 }
 239                 else
 240                 {
 241                         _glcpp_parser_skip_stack_push_if (parser, & @1, 0);
 242                         parser->skip_stack->type = SKIP_TO_ENDIF;
 243                 }
 244         }
 245 |       HASH_IF NEWLINE {
 246                 /* #if without an expression is only an error if we
 247                  *  are not skipping */
 248                 if (parser->skip_stack == NULL ||
 249                     parser->skip_stack->type == SKIP_NO_SKIP)
 250                 {
 251                         glcpp_error(& @1, parser, "#if with no expression");
 252                 }
 253                 _glcpp_parser_skip_stack_push_if (parser, & @1, 0);
 254         }
 255 |       HASH_IFDEF IDENTIFIER junk NEWLINE {
 256                 macro_t *macro = hash_table_find (parser->defines, $2);
 257                 ralloc_free ($2);
 258                 _glcpp_parser_skip_stack_push_if (parser, & @1, macro != NULL);
 259         }
 260 |       HASH_IFNDEF IDENTIFIER junk NEWLINE {
 261                 macro_t *macro = hash_table_find (parser->defines, $2);
 262                 ralloc_free ($2);
 263                 _glcpp_parser_skip_stack_push_if (parser, & @1, macro == NULL);
 264         }
 265 |       HASH_ELIF conditional_tokens NEWLINE {
 266                 /* Be careful to only evaluate the 'elif' expression
 267                  * if we are not skipping. When we are skipping, we
 268                  * simply change to a 0-valued 'elif' on the skip
 269                  * stack.
 270                  *
 271                  * This avoids generating diagnostics for invalid
 272                  * expressions that are being skipped. */
 273                 if (parser->skip_stack &&
 274                     parser->skip_stack->type == SKIP_TO_ELSE)
 275                 {
 276                         _glcpp_parser_expand_if (parser, ELIF_EXPANDED, $2);
 277                 }
 278                 else
 279                 {
 280                         _glcpp_parser_skip_stack_change_if (parser, & @1,
 281                                                             "elif", 0);
 282                 }
 283         }
 284 |       HASH_ELIF NEWLINE {
 285                 /* #elif without an expression is an error unless we
 286                  * are skipping. */
 287                 if (parser->skip_stack &&
 288                     parser->skip_stack->type == SKIP_TO_ELSE)
 289                 {
 290                         glcpp_error(& @1, parser, "#elif with no expression");
 291                 }
 292                 else
 293                 {
 294                         _glcpp_parser_skip_stack_change_if (parser, & @1,
 295                                                             "elif", 0);
 296                         glcpp_warning(& @1, parser, "ignoring illegal #elif without expression");
 297                 }
 298         }
 299 |       HASH_ELSE NEWLINE {
 300                 _glcpp_parser_skip_stack_change_if (parser, & @1, "else", 1);
 301         }
 302 |       HASH_ENDIF NEWLINE {
 303                 _glcpp_parser_skip_stack_pop (parser, & @1);
 304         }
 305 |       HASH_VERSION integer_constant NEWLINE {
 306                 macro_t *macro = hash_table_find (parser->defines, "__VERSION__");
 307                 if (macro) {
 308                         hash_table_remove (parser->defines, "__VERSION__");
 309                         ralloc_free (macro);
 310                 }
 311                 add_builtin_define (parser, "__VERSION__", $2);
 312
 313                 if ($2 == 100)
 314                         add_builtin_define (parser, "GL_ES", 1);
 315
 316                 /* Currently, all ES2 implementations support highp in the
 317                  * fragment shader, so we always define this macro in ES2.
 318                  * If we ever get a driver that doesn't support highp, we'll
 319                  * need to add a flag to the gl_context and check that here.
 320                  */
 321                 if ($2 >= 130 || $2 == 100)
 322                         add_builtin_define (parser, "GL_FRAGMENT_PRECISION_HIGH", 1);
 323
 324                 ralloc_asprintf_append (&parser->output, "#version %" PRIiMAX, $2);
 325         }
 326 |       HASH NEWLINE
 327 ;
 328
 329 integer_constant:
 330         INTEGER_STRING {
 331                 if (strlen ($1) >= 3 && strncmp ($1, "0x", 2) == 0) {
 332                         $$ = strtoll ($1 + 2, NULL, 16);
 333                 } else if ($1[0] == '0') {
 334                         $$ = strtoll ($1, NULL, 8);
 335                 } else {
 336                         $$ = strtoll ($1, NULL, 10);
 337                 }
 338         }
 339 |       INTEGER {
 340                 $$ = $1;
 341         }
 342
 343 expression:
 344         integer_constant
 345 |       expression OR expression {
 346                 $$ = $1 || $3;
 347         }
 348 |       expression AND expression {
 349                 $$ = $1 && $3;
 350         }
 351 |       expression '|' expression {
 352                 $$ = $1 | $3;
 353         }
 354 |       expression '^' expression {
 355                 $$ = $1 ^ $3;
 356         }
 357 |       expression '&' expression {
 358                 $$ = $1 & $3;
 359         }
 360 |       expression NOT_EQUAL expression {
 361                 $$ = $1 != $3;
 362         }
 363 |       expression EQUAL expression {
 364                 $$ = $1 == $3;
 365         }
 366 |       expression GREATER_OR_EQUAL expression {
 367                 $$ = $1 >= $3;
 368         }
 369 |       expression LESS_OR_EQUAL expression {
 370                 $$ = $1 <= $3;
 371         }
 372 |       expression '>' expression {
 373                 $$ = $1 > $3;
 374         }
 375 |       expression '<' expression {
 376                 $$ = $1 < $3;
 377         }
 378 |       expression RIGHT_SHIFT expression {
 379                 $$ = $1 >> $3;
 380         }
 381 |       expression LEFT_SHIFT expression {
 382                 $$ = $1 << $3;
 383         }
 384 |       expression '-' expression {
 385                 $$ = $1 - $3;
 386         }
 387 |       expression '+' expression {
 388                 $$ = $1 + $3;
 389         }
 390 |       expression '%' expression {
 391                 if ($3 == 0) {
 392                         yyerror (& @1, parser,
 393                                  "zero modulus in preprocessor directive");
 394                 } else {
 395                         $$ = $1 % $3;
 396                 }
 397         }
 398 |       expression '/' expression {
 399                 if ($3 == 0) {
 400                         yyerror (& @1, parser,
 401                                  "division by 0 in preprocessor directive");
 402                 } else {
 403                         $$ = $1 / $3;
 404                 }
 405         }
 406 |       expression '*' expression {
 407                 $$ = $1 * $3;
 408         }
 409 |       '!' expression %prec UNARY {
 410                 $$ = ! $2;
 411         }
 412 |       '~' expression %prec UNARY {
 413                 $$ = ~ $2;
 414         }
 415 |       '-' expression %prec UNARY {
 416                 $$ = - $2;
 417         }
 418 |       '+' expression %prec UNARY {
 419                 $$ = + $2;
 420         }
 421 |       '(' expression ')' {
 422                 $$ = $2;
 423         }
 424 ;
 425
 426 identifier_list:
 427         IDENTIFIER {
 428                 $$ = _string_list_create (parser);
 429                 _string_list_append_item ($$, $1);
 430                 ralloc_steal ($$, $1);
 431         }
 432 |       identifier_list ',' IDENTIFIER {
 433                 $$ = $1;
 434                 _string_list_append_item ($$, $3);
 435                 ralloc_steal ($$, $3);
 436         }
 437 ;
 438
 439 text_line:
 440         NEWLINE { $$ = NULL; }
 441 |       pp_tokens NEWLINE
 442 ;
 443
 444 non_directive:
 445         pp_tokens NEWLINE {
 446                 yyerror (& @1, parser, "Invalid tokens after #");
 447         }
 448 ;
 449
 450 replacement_list:
 451         /* empty */ { $$ = NULL; }
 452 |       pp_tokens
 453 ;
 454
 455 junk:
 456         /* empty */
 457 |       pp_tokens {
 458                 glcpp_warning(&@1, parser, "extra tokens at end of directive");
 459         }
 460 ;
 461
 462 conditional_token:
 463         /* Handle "defined" operator */
 464         DEFINED IDENTIFIER {
 465                 int v = hash_table_find (parser->defines, $2) ? 1 : 0;
 466                 $$ = _token_create_ival (parser, INTEGER, v);
 467         }
 468 |       DEFINED '(' IDENTIFIER ')' {
 469                 int v = hash_table_find (parser->defines, $3) ? 1 : 0;
 470                 $$ = _token_create_ival (parser, INTEGER, v);
 471         }
 472 |       preprocessing_token
 473 ;
 474
 475 conditional_tokens:
 476         /* Exactly the same as pp_tokens, but using conditional_token */
 477         conditional_token {
 478                 $$ = _token_list_create (parser);
 479                 _token_list_append ($$, $1);
 480         }
 481 |       conditional_tokens conditional_token {
 482                 $$ = $1;
 483                 _token_list_append ($$, $2);
 484         }
 485 ;
 486
 487 pp_tokens:
 488         preprocessing_token {
 489                 parser->space_tokens = 1;
 490                 $$ = _token_list_create (parser);
 491                 _token_list_append ($$, $1);
 492         }
 493 |       pp_tokens preprocessing_token {
 494                 $$ = $1;
 495                 _token_list_append ($$, $2);
 496         }
 497 ;
 498
 499 preprocessing_token:
 500         IDENTIFIER {
 501                 $$ = _token_create_str (parser, IDENTIFIER, $1);
 502                 $$->location = yylloc;
 503         }
 504 |       INTEGER_STRING {
 505                 $$ = _token_create_str (parser, INTEGER_STRING, $1);
 506                 $$->location = yylloc;
 507         }
 508 |       operator {
 509                 $$ = _token_create_ival (parser, $1, $1);
 510                 $$->location = yylloc;
 511         }
 512 |       OTHER {
 513                 $$ = _token_create_str (parser, OTHER, $1);
 514                 $$->location = yylloc;
 515         }
 516 |       SPACE {
 517                 $$ = _token_create_ival (parser, SPACE, SPACE);
 518                 $$->location = yylloc;
 519         }
 520 ;
 521
 522 operator:
 523         '['                     { $$ = '['; }
 524 |       ']'                     { $$ = ']'; }
 525 |       '('                     { $$ = '('; }
 526 |       ')'                     { $$ = ')'; }
 527 |       '{'                     { $$ = '{'; }
 528 |       '}'                     { $$ = '}'; }
 529 |       '.'                     { $$ = '.'; }
 530 |       '&'                     { $$ = '&'; }
 531 |       '*'                     { $$ = '*'; }
 532 |       '+'                     { $$ = '+'; }
 533 |       '-'                     { $$ = '-'; }
 534 |       '~'                     { $$ = '~'; }
 535 |       '!'                     { $$ = '!'; }
 536 |       '/'                     { $$ = '/'; }
 537 |       '%'                     { $$ = '%'; }
 538 |       LEFT_SHIFT              { $$ = LEFT_SHIFT; }
 539 |       RIGHT_SHIFT             { $$ = RIGHT_SHIFT; }
 540 |       '<'                     { $$ = '<'; }
 541 |       '>'                     { $$ = '>'; }
 542 |       LESS_OR_EQUAL           { $$ = LESS_OR_EQUAL; }
 543 |       GREATER_OR_EQUAL        { $$ = GREATER_OR_EQUAL; }
 544 |       EQUAL                   { $$ = EQUAL; }
 545 |       NOT_EQUAL               { $$ = NOT_EQUAL; }
 546 |       '^'                     { $$ = '^'; }
 547 |       '|'                     { $$ = '|'; }
 548 |       AND                     { $$ = AND; }
 549 |       OR                      { $$ = OR; }
 550 |       ';'                     { $$ = ';'; }
 551 |       ','                     { $$ = ','; }
 552 |       '='                     { $$ = '='; }
 553 |       PASTE                   { $$ = PASTE; }
 554 ;
 555
 556 %%
 557
 558 string_list_t *
 559 _string_list_create (void *ctx)
 560 {
 561         string_list_t *list;
 562
 563         list = ralloc (ctx, string_list_t);
 564         list->head = NULL;
 565         list->tail = NULL;
 566
 567         return list;
 568 }
 569
 570 void
 571 _string_list_append_item (string_list_t *list, const char *str)
 572 {
 573         string_node_t *node;
 574
 575         node = ralloc (list, string_node_t);
 576         node->str = ralloc_strdup (node, str);
 577
 578         node->next = NULL;
 579
 580         if (list->head == NULL) {
 581                 list->head = node;
 582         } else {
 583                 list->tail->next = node;
 584         }
 585
 586         list->tail = node;
 587 }
 588
 589 int
 590 _string_list_contains (string_list_t *list, const char *member, int *index)
 591 {
 592         string_node_t *node;
 593         int i;
 594
 595         if (list == NULL)
 596                 return 0;
 597
 598         for (i = 0, node = list->head; node; i++, node = node->next) {
 599                 if (strcmp (node->str, member) == 0) {
 600                         if (index)
 601                                 *index = i;
 602                         return 1;
 603                 }
 604         }
 605
 606         return 0;
 607 }
 608
 609 int
 610 _string_list_length (string_list_t *list)
 611 {
 612         int length = 0;
 613         string_node_t *node;
 614
 615         if (list == NULL)
 616                 return 0;
 617
 618         for (node = list->head; node; node = node->next)
 619                 length++;
 620
 621         return length;
 622 }
 623
 624 int
 625 _string_list_equal (string_list_t *a, string_list_t *b)
 626 {
 627         string_node_t *node_a, *node_b;
 628
 629         if (a == NULL && b == NULL)
 630                 return 1;
 631
 632         if (a == NULL || b == NULL)
 633                 return 0;
 634
 635         for (node_a = a->head, node_b = b->head;
 636              node_a && node_b;
 637              node_a = node_a->next, node_b = node_b->next)
 638         {
 639                 if (strcmp (node_a->str, node_b->str))
 640                         return 0;
 641         }
 642
 643         /* Catch the case of lists being different lengths, (which
 644          * would cause the loop above to terminate after the shorter
 645          * list). */
 646         return node_a == node_b;
 647 }
 648
 649 argument_list_t *
 650 _argument_list_create (void *ctx)
 651 {
 652         argument_list_t *list;
 653
 654         list = ralloc (ctx, argument_list_t);
 655         list->head = NULL;
 656         list->tail = NULL;
 657
 658         return list;
 659 }
 660
 661 void
 662 _argument_list_append (argument_list_t *list, token_list_t *argument)
 663 {
 664         argument_node_t *node;
 665
 666         node = ralloc (list, argument_node_t);
 667         node->argument = argument;
 668
 669         node->next = NULL;
 670
 671         if (list->head == NULL) {
 672                 list->head = node;
 673         } else {
 674                 list->tail->next = node;
 675         }
 676
 677         list->tail = node;
 678 }
 679
 680 int
 681 _argument_list_length (argument_list_t *list)
 682 {
 683         int length = 0;
 684         argument_node_t *node;
 685
 686         if (list == NULL)
 687                 return 0;
 688
 689         for (node = list->head; node; node = node->next)
 690                 length++;
 691
 692         return length;
 693 }
 694
 695 token_list_t *
 696 _argument_list_member_at (argument_list_t *list, int index)
 697 {
 698         argument_node_t *node;
 699         int i;
 700
 701         if (list == NULL)
 702                 return NULL;
 703
 704         node = list->head;
 705         for (i = 0; i < index; i++) {
 706                 node = node->next;
 707                 if (node == NULL)
 708                         break;
 709         }
 710
 711         if (node)
 712                 return node->argument;
 713
 714         return NULL;
 715 }
 716
 717 /* Note: This function ralloc_steal()s the str pointer. */
 718 token_t *
 719 _token_create_str (void *ctx, int type, char *str)
 720 {
 721         token_t *token;
 722
 723         token = ralloc (ctx, token_t);
 724         token->type = type;
 725         token->value.str = str;
 726
 727         ralloc_steal (token, str);
 728
 729         return token;
 730 }
 731
 732 token_t *
 733 _token_create_ival (void *ctx, int type, int ival)
 734 {
 735         token_t *token;
 736
 737         token = ralloc (ctx, token_t);
 738         token->type = type;
 739         token->value.ival = ival;
 740
 741         return token;
 742 }
 743
 744 token_list_t *
 745 _token_list_create (void *ctx)
 746 {
 747         token_list_t *list;
 748
 749         list = ralloc (ctx, token_list_t);
 750         list->head = NULL;
 751         list->tail = NULL;
 752         list->non_space_tail = NULL;
 753
 754         return list;
 755 }
 756
 757 void
 758 _token_list_append (token_list_t *list, token_t *token)
 759 {
 760         token_node_t *node;
 761
 762         node = ralloc (list, token_node_t);
 763         node->token = token;
 764         node->next = NULL;
 765
 766         ralloc_steal (list, token);
 767
 768         if (list->head == NULL) {
 769                 list->head = node;
 770         } else {
 771                 list->tail->next = node;
 772         }
 773
 774         list->tail = node;
 775         if (token->type != SPACE)
 776                 list->non_space_tail = node;
 777 }
 778
 779 void
 780 _token_list_append_list (token_list_t *list, token_list_t *tail)
 781 {
 782         if (tail == NULL || tail->head == NULL)
 783                 return;
 784
 785         if (list->head == NULL) {
 786                 list->head = tail->head;
 787         } else {
 788                 list->tail->next = tail->head;
 789         }
 790
 791         list->tail = tail->tail;
 792         list->non_space_tail = tail->non_space_tail;
 793 }
 794
 795 static token_list_t *
 796 _token_list_copy (void *ctx, token_list_t *other)
 797 {
 798         token_list_t *copy;
 799         token_node_t *node;
 800
 801         if (other == NULL)
 802                 return NULL;
 803
 804         copy = _token_list_create (ctx);
 805         for (node = other->head; node; node = node->next) {
 806                 token_t *new_token = ralloc (copy, token_t);
 807                 *new_token = *node->token;
 808                 _token_list_append (copy, new_token);
 809         }
 810
 811         return copy;
 812 }
 813
 814 static void
 815 _token_list_trim_trailing_space (token_list_t *list)
 816 {
 817         token_node_t *tail, *next;
 818
 819         if (list->non_space_tail) {
 820                 tail = list->non_space_tail->next;
 821                 list->non_space_tail->next = NULL;
 822                 list->tail = list->non_space_tail;
 823
 824                 while (tail) {
 825                         next = tail->next;
 826                         ralloc_free (tail);
 827                         tail = next;
 828                 }
 829         }
 830 }
 831
 832 static int
 833 _token_list_is_empty_ignoring_space (token_list_t *l)
 834 {
 835         token_node_t *n;
 836
 837         if (l == NULL)
 838                 return 1;
 839
 840         n = l->head;
 841         while (n != NULL && n->token->type == SPACE)
 842                 n = n->next;
 843
 844         return n == NULL;
 845 }
 846
 847 int
 848 _token_list_equal_ignoring_space (token_list_t *a, token_list_t *b)
 849 {
 850         token_node_t *node_a, *node_b;
 851
 852         if (a == NULL || b == NULL) {
 853                 int a_empty = _token_list_is_empty_ignoring_space(a);
 854                 int b_empty = _token_list_is_empty_ignoring_space(b);
 855                 return a_empty == b_empty;
 856         }
 857
 858         node_a = a->head;
 859         node_b = b->head;
 860
 861         while (1)
 862         {
 863                 if (node_a == NULL && node_b == NULL)
 864                         break;
 865
 866                 if (node_a == NULL || node_b == NULL)
 867                         return 0;
 868
 869                 if (node_a->token->type == SPACE) {
 870                         node_a = node_a->next;
 871                         continue;
 872                 }
 873
 874                 if (node_b->token->type == SPACE) {
 875                         node_b = node_b->next;
 876                         continue;
 877                 }
 878
 879                 if (node_a->token->type != node_b->token->type)
 880                         return 0;
 881
 882                 switch (node_a->token->type) {
 883                 case INTEGER:
 884                         if (node_a->token->value.ival !=
 885                             node_b->token->value.ival)
 886                         {
 887                                 return 0;
 888                         }
 889                         break;
 890                 case IDENTIFIER:
 891                 case INTEGER_STRING:
 892                 case OTHER:
 893                         if (strcmp (node_a->token->value.str,
 894                                     node_b->token->value.str))
 895                         {
 896                                 return 0;
 897                         }
 898                         break;
 899                 }
 900
 901                 node_a = node_a->next;
 902                 node_b = node_b->next;
 903         }
 904
 905         return 1;
 906 }
 907
 908 static void
 909 _token_print (char **out, token_t *token)
 910 {
 911         if (token->type < 256) {
 912                 ralloc_asprintf_append (out, "%c", token->type);
 913                 return;
 914         }
 915
 916         switch (token->type) {
 917         case INTEGER:
 918                 ralloc_asprintf_append (out, "%" PRIiMAX, token->value.ival);
 919                 break;
 920         case IDENTIFIER:
 921         case INTEGER_STRING:
 922         case OTHER:
 923                 ralloc_strcat (out, token->value.str);
 924                 break;
 925         case SPACE:
 926                 ralloc_strcat (out, " ");
 927                 break;
 928         case LEFT_SHIFT:
 929                 ralloc_strcat (out, "<<");
 930                 break;
 931         case RIGHT_SHIFT:
 932                 ralloc_strcat (out, ">>");
 933                 break;
 934         case LESS_OR_EQUAL:
 935                 ralloc_strcat (out, "<=");
 936                 break;
 937         case GREATER_OR_EQUAL:
 938                 ralloc_strcat (out, ">=");
 939                 break;
 940         case EQUAL:
 941                 ralloc_strcat (out, "==");
 942                 break;
 943         case NOT_EQUAL:
 944                 ralloc_strcat (out, "!=");
 945                 break;
 946         case AND:
 947                 ralloc_strcat (out, "&&");
 948                 break;
 949         case OR:
 950                 ralloc_strcat (out, "||");
 951                 break;
 952         case PASTE:
 953                 ralloc_strcat (out, "##");
 954                 break;
 955         case COMMA_FINAL:
 956                 ralloc_strcat (out, ",");
 957                 break;
 958         case PLACEHOLDER:
 959                 /* Nothing to print. */
 960                 break;
 961         default:
 962                 assert(!"Error: Don't know how to print token.");
 963                 break;
 964         }
 965 }
 966
 967 /* Return a new token (ralloc()ed off of 'token') formed by pasting
 968  * 'token' and 'other'. Note that this function may return 'token' or
 969  * 'other' directly rather than allocating anything new.
 970  *
 971  * Caution: Only very cursory error-checking is performed to see if
 972  * the final result is a valid single token. */
 973 static token_t *
 974 _token_paste (glcpp_parser_t *parser, token_t *token, token_t *other)
 975 {
 976         token_t *combined = NULL;
 977
 978         /* Pasting a placeholder onto anything makes no change. */
 979         if (other->type == PLACEHOLDER)
 980                 return token;
 981
 982         /* When 'token' is a placeholder, just return 'other'. */
 983         if (token->type == PLACEHOLDER)
 984                 return other;
 985
 986         /* A very few single-character punctuators can be combined
 987          * with another to form a multi-character punctuator. */
 988         switch (token->type) {
 989         case '<':
 990                 if (other->type == '<')
 991                         combined = _token_create_ival (token, LEFT_SHIFT, LEFT_SHIFT);
 992                 else if (other->type == '=')
 993                         combined = _token_create_ival (token, LESS_OR_EQUAL, LESS_OR_EQUAL);
 994                 break;
 995         case '>':
 996                 if (other->type == '>')
 997                         combined = _token_create_ival (token, RIGHT_SHIFT, RIGHT_SHIFT);
 998                 else if (other->type == '=')
 999                         combined = _token_create_ival (token, GREATER_OR_EQUAL, GREATER_OR_EQUAL);
1000                 break;
1001         case '=':
1002                 if (other->type == '=')
1003                         combined = _token_create_ival (token, EQUAL, EQUAL);
1004                 break;
1005         case '!':
1006                 if (other->type == '=')
1007                         combined = _token_create_ival (token, NOT_EQUAL, NOT_EQUAL);
1008                 break;
1009         case '&':
1010                 if (other->type == '&')
1011                         combined = _token_create_ival (token, AND, AND);
1012                 break;
1013         case '|':
1014                 if (other->type == '|')
1015                         combined = _token_create_ival (token, OR, OR);
1016                 break;
1017         }
1018
1019         if (combined != NULL) {
1020                 /* Inherit the location from the first token */
1021                 combined->location = token->location;
1022                 return combined;
1023         }
1024
1025         /* Two string-valued tokens can usually just be mashed
1026          * together.
1027          *
1028          * XXX: This isn't actually legitimate. Several things here
1029          * should result in a diagnostic since the result cannot be a
1030          * valid, single pre-processing token. For example, pasting
1031          * "123" and "abc" is not legal, but we don't catch that
1032          * here. */
1033         if ((token->type == IDENTIFIER || token->type == OTHER || token->type == INTEGER_STRING) &&
1034             (other->type == IDENTIFIER || other->type == OTHER || other->type == INTEGER_STRING))
1035         {
1036                 char *str;
1037
1038                 str = ralloc_asprintf (token, "%s%s", token->value.str,
1039                                        other->value.str);
1040                 combined = _token_create_str (token, token->type, str);
1041                 combined->location = token->location;
1042                 return combined;
1043         }
1044
1045         glcpp_error (&token->location, parser, "");
1046         ralloc_strcat (&parser->info_log, "Pasting \"");
1047         _token_print (&parser->info_log, token);
1048         ralloc_strcat (&parser->info_log, "\" and \"");
1049         _token_print (&parser->info_log, other);
1050         ralloc_strcat (&parser->info_log, "\" does not give a valid preprocessing token.\n");
1051
1052         return token;
1053 }
1054
1055 static void
1056 _token_list_print (glcpp_parser_t *parser, token_list_t *list)
1057 {
1058         token_node_t *node;
1059
1060         if (list == NULL)
1061                 return;
1062
1063         for (node = list->head; node; node = node->next)
1064                 _token_print (&parser->output, node->token);
1065 }
1066
1067 void
1068 yyerror (YYLTYPE *locp, glcpp_parser_t *parser, const char *error)
1069 {
1070         glcpp_error(locp, parser, "%s", error);
1071 }
1072
1073 static void add_builtin_define(glcpp_parser_t *parser,
1074                                const char *name, int value)
1075 {
1076    token_t *tok;
1077    token_list_t *list;
1078
1079    tok = _token_create_ival (parser, INTEGER, value);
1080
1081    list = _token_list_create(parser);
1082    _token_list_append(list, tok);
1083    _define_object_macro(parser, NULL, name, list);
1084 }
1085
1086 glcpp_parser_t *
1087 glcpp_parser_create (const struct gl_extensions *extensions, int api)
1088 {
1089         glcpp_parser_t *parser;
1090         int language_version;
1091
1092         parser = ralloc (NULL, glcpp_parser_t);
1093
1094         glcpp_lex_init_extra (parser, &parser->scanner);
1095         parser->defines = hash_table_ctor (32, hash_table_string_hash,
1096                                            hash_table_string_compare);
1097         parser->active = NULL;
1098         parser->lexing_if = 0;
1099         parser->space_tokens = 1;
1100         parser->newline_as_space = 0;
1101         parser->in_control_line = 0;
1102         parser->paren_count = 0;
1103
1104         parser->skip_stack = NULL;
1105
1106         parser->lex_from_list = NULL;
1107         parser->lex_from_node = NULL;
1108
1109         parser->output = ralloc_strdup(parser, "");
1110         parser->info_log = ralloc_strdup(parser, "");
1111         parser->error = 0;
1112
1113         /* Add pre-defined macros. */
1114         add_builtin_define(parser, "GL_ARB_draw_buffers", 1);
1115         add_builtin_define(parser, "GL_ARB_texture_rectangle", 1);
1116
1117         if (api == API_OPENGLES2)
1118                 add_builtin_define(parser, "GL_ES", 1);
1119
1120         if (extensions != NULL) {
1121            if (extensions->EXT_texture_array) {
1122               add_builtin_define(parser, "GL_EXT_texture_array", 1);
1123            }
1124
1125            if (extensions->ARB_fragment_coord_conventions)
1126               add_builtin_define(parser, "GL_ARB_fragment_coord_conventions",
1127                                  1);
1128
1129            if (extensions->ARB_explicit_attrib_location)
1130               add_builtin_define(parser, "GL_ARB_explicit_attrib_location", 1);
1131            if (extensions->AMD_conservative_depth)
1132               add_builtin_define(parser, "GL_AMD_conservative_depth", 1);
1133         }
1134
1135         language_version = 110;
1136         add_builtin_define(parser, "__VERSION__", language_version);
1137
1138         return parser;
1139 }
1140
1141 int
1142 glcpp_parser_parse (glcpp_parser_t *parser)
1143 {
1144         return yyparse (parser);
1145 }
1146
1147 void
1148 glcpp_parser_destroy (glcpp_parser_t *parser)
1149 {
1150         glcpp_lex_destroy (parser->scanner);
1151         hash_table_dtor (parser->defines);
1152         ralloc_free (parser);
1153 }
1154
1155 typedef enum function_status
1156 {
1157         FUNCTION_STATUS_SUCCESS,
1158         FUNCTION_NOT_A_FUNCTION,
1159         FUNCTION_UNBALANCED_PARENTHESES
1160 } function_status_t;
1161
1162 /* Find a set of function-like macro arguments by looking for a
1163  * balanced set of parentheses.
1164  *
1165  * When called, 'node' should be the opening-parenthesis token, (or
1166  * perhaps preceeding SPACE tokens). Upon successful return *last will
1167  * be the last consumed node, (corresponding to the closing right
1168  * parenthesis).
1169  *
1170  * Return values:
1171  *
1172  *   FUNCTION_STATUS_SUCCESS:
1173  *
1174  *      Successfully parsed a set of function arguments.
1175  *
1176  *   FUNCTION_NOT_A_FUNCTION:
1177  *
1178  *      Macro name not followed by a '('. This is not an error, but
1179  *      simply that the macro name should be treated as a non-macro.
1180  *
1181  *   FUNCTION_UNBALANCED_PARENTHESES
1182  *
1183  *      Macro name is not followed by a balanced set of parentheses.
1184  */
1185 static function_status_t
1186 _arguments_parse (argument_list_t *arguments,
1187                   token_node_t *node,
1188                   token_node_t **last)
1189 {
1190         token_list_t *argument;
1191         int paren_count;
1192
1193         node = node->next;
1194
1195         /* Ignore whitespace before first parenthesis. */
1196         while (node && node->token->type == SPACE)
1197                 node = node->next;
1198
1199         if (node == NULL || node->token->type != '(')
1200                 return FUNCTION_NOT_A_FUNCTION;
1201
1202         node = node->next;
1203
1204         argument = _token_list_create (arguments);
1205         _argument_list_append (arguments, argument);
1206
1207         for (paren_count = 1; node; node = node->next) {
1208                 if (node->token->type == '(')
1209                 {
1210                         paren_count++;
1211                 }
1212                 else if (node->token->type == ')')
1213                 {
1214                         paren_count--;
1215                         if (paren_count == 0)
1216                                 break;
1217                 }
1218
1219                 if (node->token->type == ',' &&
1220                          paren_count == 1)
1221                 {
1222                         _token_list_trim_trailing_space (argument);
1223                         argument = _token_list_create (arguments);
1224                         _argument_list_append (arguments, argument);
1225                 }
1226                 else {
1227                         if (argument->head == NULL) {
1228                                 /* Don't treat initial whitespace as
1229                                  * part of the arguement. */
1230                                 if (node->token->type == SPACE)
1231                                         continue;
1232                         }
1233                         _token_list_append (argument, node->token);
1234                 }
1235         }
1236
1237         if (paren_count)
1238                 return FUNCTION_UNBALANCED_PARENTHESES;
1239
1240         *last = node;
1241
1242         return FUNCTION_STATUS_SUCCESS;
1243 }
1244
1245 static token_list_t *
1246 _token_list_create_with_one_space (void *ctx)
1247 {
1248         token_list_t *list;
1249         token_t *space;
1250
1251         list = _token_list_create (ctx);
1252         space = _token_create_ival (list, SPACE, SPACE);
1253         _token_list_append (list, space);
1254
1255         return list;
1256 }
1257
1258 static void
1259 _glcpp_parser_expand_if (glcpp_parser_t *parser, int type, token_list_t *list)
1260 {
1261         token_list_t *expanded;
1262         token_t *token;
1263
1264         expanded = _token_list_create (parser);
1265         token = _token_create_ival (parser, type, type);
1266         _token_list_append (expanded, token);
1267         _glcpp_parser_expand_token_list (parser, list);
1268         _token_list_append_list (expanded, list);
1269         glcpp_parser_lex_from (parser, expanded);
1270 }
1271
1272 /* This is a helper function that's essentially part of the
1273  * implementation of _glcpp_parser_expand_node. It shouldn't be called
1274  * except for by that function.
1275  *
1276  * Returns NULL if node is a simple token with no expansion, (that is,
1277  * although 'node' corresponds to an identifier defined as a
1278  * function-like macro, it is not followed with a parenthesized
1279  * argument list).
1280  *
1281  * Compute the complete expansion of node (which is a function-like
1282  * macro) and subsequent nodes which are arguments.
1283  *
1284  * Returns the token list that results from the expansion and sets
1285  * *last to the last node in the list that was consumed by the
1286  * expansion. Specifically, *last will be set as follows: as the
1287  * token of the closing right parenthesis.
1288  */
1289 static token_list_t *
1290 _glcpp_parser_expand_function (glcpp_parser_t *parser,
1291                                token_node_t *node,
1292                                token_node_t **last)
1293
1294 {
1295         macro_t *macro;
1296         const char *identifier;
1297         argument_list_t *arguments;
1298         function_status_t status;
1299         token_list_t *substituted;
1300         int parameter_index;
1301
1302         identifier = node->token->value.str;
1303
1304         macro = hash_table_find (parser->defines, identifier);
1305
1306         assert (macro->is_function);
1307
1308         arguments = _argument_list_create (parser);
1309         status = _arguments_parse (arguments, node, last);
1310
1311         switch (status) {
1312         case FUNCTION_STATUS_SUCCESS:
1313                 break;
1314         case FUNCTION_NOT_A_FUNCTION:
1315                 return NULL;
1316         case FUNCTION_UNBALANCED_PARENTHESES:
1317                 glcpp_error (&node->token->location, parser, "Macro %s call has unbalanced parentheses\n", identifier);
1318                 return NULL;
1319         }
1320
1321         /* Replace a macro defined as empty with a SPACE token. */
1322         if (macro->replacements == NULL) {
1323                 ralloc_free (arguments);
1324                 return _token_list_create_with_one_space (parser);
1325         }
1326
1327         if (! ((_argument_list_length (arguments) ==
1328                 _string_list_length (macro->parameters)) ||
1329                (_string_list_length (macro->parameters) == 0 &&
1330                 _argument_list_length (arguments) == 1 &&
1331                 arguments->head->argument->head == NULL)))
1332         {
1333                 glcpp_error (&node->token->location, parser,
1334                               "Error: macro %s invoked with %d arguments (expected %d)\n",
1335                               identifier,
1336                               _argument_list_length (arguments),
1337                               _string_list_length (macro->parameters));
1338                 return NULL;
1339         }
1340
1341         /* Perform argument substitution on the replacement list. */
1342         substituted = _token_list_create (arguments);
1343
1344         for (node = macro->replacements->head; node; node = node->next)
1345         {
1346                 if (node->token->type == IDENTIFIER &&
1347                     _string_list_contains (macro->parameters,
1348                                            node->token->value.str,
1349                                            &parameter_index))
1350                 {
1351                         token_list_t *argument;
1352                         argument = _argument_list_member_at (arguments,
1353                                                              parameter_index);
1354                         /* Before substituting, we expand the argument
1355                          * tokens, or append a placeholder token for
1356                          * an empty argument. */
1357                         if (argument->head) {
1358                                 token_list_t *expanded_argument;
1359                                 expanded_argument = _token_list_copy (parser,
1360                                                                       argument);
1361                                 _glcpp_parser_expand_token_list (parser,
1362                                                                  expanded_argument);
1363                                 _token_list_append_list (substituted,
1364                                                          expanded_argument);
1365                         } else {
1366                                 token_t *new_token;
1367
1368                                 new_token = _token_create_ival (substituted,
1369                                                                 PLACEHOLDER,
1370                                                                 PLACEHOLDER);
1371                                 _token_list_append (substituted, new_token);
1372                         }
1373                 } else {
1374                         _token_list_append (substituted, node->token);
1375                 }
1376         }
1377
1378         /* After argument substitution, and before further expansion
1379          * below, implement token pasting. */
1380
1381         _token_list_trim_trailing_space (substituted);
1382
1383         node = substituted->head;
1384         while (node)
1385         {
1386                 token_node_t *next_non_space;
1387
1388                 /* Look ahead for a PASTE token, skipping space. */
1389                 next_non_space = node->next;
1390                 while (next_non_space && next_non_space->token->type == SPACE)
1391                         next_non_space = next_non_space->next;
1392
1393                 if (next_non_space == NULL)
1394                         break;
1395
1396                 if (next_non_space->token->type != PASTE) {
1397                         node = next_non_space;
1398                         continue;
1399                 }
1400
1401                 /* Now find the next non-space token after the PASTE. */
1402                 next_non_space = next_non_space->next;
1403                 while (next_non_space && next_non_space->token->type == SPACE)
1404                         next_non_space = next_non_space->next;
1405
1406                 if (next_non_space == NULL) {
1407                         yyerror (&node->token->location, parser, "'##' cannot appear at either end of a macro expansion\n");
1408                         return NULL;
1409                 }
1410
1411                 node->token = _token_paste (parser, node->token, next_non_space->token);
1412                 node->next = next_non_space->next;
1413                 if (next_non_space == substituted->tail)
1414                         substituted->tail = node;
1415
1416                 node = node->next;
1417         }
1418
1419         substituted->non_space_tail = substituted->tail;
1420
1421         return substituted;
1422 }
1423
1424 /* Compute the complete expansion of node, (and subsequent nodes after
1425  * 'node' in the case that 'node' is a function-like macro and
1426  * subsequent nodes are arguments).
1427  *
1428  * Returns NULL if node is a simple token with no expansion.
1429  *
1430  * Otherwise, returns the token list that results from the expansion
1431  * and sets *last to the last node in the list that was consumed by
1432  * the expansion. Specifically, *last will be set as follows:
1433  *
1434  *      As 'node' in the case of object-like macro expansion.
1435  *
1436  *      As the token of the closing right parenthesis in the case of
1437  *      function-like macro expansion.
1438  */
1439 static token_list_t *
1440 _glcpp_parser_expand_node (glcpp_parser_t *parser,
1441                            token_node_t *node,
1442                            token_node_t **last)
1443 {
1444         token_t *token = node->token;
1445         const char *identifier;
1446         macro_t *macro;
1447
1448         /* We only expand identifiers */
1449         if (token->type != IDENTIFIER) {
1450                 /* We change any COMMA into a COMMA_FINAL to prevent
1451                  * it being mistaken for an argument separator
1452                  * later. */
1453                 if (token->type == ',') {
1454                         token->type = COMMA_FINAL;
1455                         token->value.ival = COMMA_FINAL;
1456                 }
1457
1458                 return NULL;
1459         }
1460
1461         /* Look up this identifier in the hash table. */
1462         identifier = token->value.str;
1463         macro = hash_table_find (parser->defines, identifier);
1464
1465         /* Not a macro, so no expansion needed. */
1466         if (macro == NULL)
1467                 return NULL;
1468
1469         /* Finally, don't expand this macro if we're already actively
1470          * expanding it, (to avoid infinite recursion). */
1471         if (_active_list_contains (parser->active, identifier)) {
1472                 /* We change the token type here from IDENTIFIER to
1473                  * OTHER to prevent any future expansion of this
1474                  * unexpanded token. */
1475                 char *str;
1476                 token_list_t *expansion;
1477                 token_t *final;
1478
1479                 str = ralloc_strdup (parser, token->value.str);
1480                 final = _token_create_str (parser, OTHER, str);
1481                 expansion = _token_list_create (parser);
1482                 _token_list_append (expansion, final);
1483                 *last = node;
1484                 return expansion;
1485         }
1486
1487         if (! macro->is_function)
1488         {
1489                 *last = node;
1490
1491                 /* Replace a macro defined as empty with a SPACE token. */
1492                 if (macro->replacements == NULL)
1493                         return _token_list_create_with_one_space (parser);
1494
1495                 return _token_list_copy (parser, macro->replacements);
1496         }
1497
1498         return _glcpp_parser_expand_function (parser, node, last);
1499 }
1500
1501 /* Push a new identifier onto the active list, returning the new list.
1502  *
1503  * Here, 'marker' is the token node that appears in the list after the
1504  * expansion of 'identifier'. That is, when the list iterator begins
1505  * examinging 'marker', then it is time to pop this node from the
1506  * active stack.
1507  */
1508 active_list_t *
1509 _active_list_push (active_list_t *list,
1510                    const char *identifier,
1511                    token_node_t *marker)
1512 {
1513         active_list_t *node;
1514
1515         node = ralloc (list, active_list_t);
1516         node->identifier = ralloc_strdup (node, identifier);
1517         node->marker = marker;
1518         node->next = list;
1519
1520         return node;
1521 }
1522
1523 active_list_t *
1524 _active_list_pop (active_list_t *list)
1525 {
1526         active_list_t *node = list;
1527
1528         if (node == NULL)
1529                 return NULL;
1530
1531         node = list->next;
1532         ralloc_free (list);
1533
1534         return node;
1535 }
1536
1537 int
1538 _active_list_contains (active_list_t *list, const char *identifier)
1539 {
1540         active_list_t *node;
1541
1542         if (list == NULL)
1543                 return 0;
1544
1545         for (node = list; node; node = node->next)
1546                 if (strcmp (node->identifier, identifier) == 0)
1547                         return 1;
1548
1549         return 0;
1550 }
1551
1552 /* Walk over the token list replacing nodes with their expansion.
1553  * Whenever nodes are expanded the walking will walk over the new
1554  * nodes, continuing to expand as necessary. The results are placed in
1555  * 'list' itself;
1556  */
1557 static void
1558 _glcpp_parser_expand_token_list (glcpp_parser_t *parser,
1559                                  token_list_t *list)
1560 {
1561         token_node_t *node_prev;
1562         token_node_t *node, *last = NULL;
1563         token_list_t *expansion;
1564
1565         if (list == NULL)
1566                 return;
1567
1568         _token_list_trim_trailing_space (list);
1569
1570         node_prev = NULL;
1571         node = list->head;
1572
1573         while (node) {
1574
1575                 while (parser->active && parser->active->marker == node)
1576                         parser->active = _active_list_pop (parser->active);
1577
1578                 /* Find the expansion for node, which will replace all
1579                  * nodes from node to last, inclusive. */
1580                 expansion = _glcpp_parser_expand_node (parser, node, &last);
1581                 if (expansion) {
1582                         token_node_t *n;
1583
1584                         for (n = node; n != last->next; n = n->next)
1585                                 while (parser->active &&
1586                                        parser->active->marker == n)
1587                                 {
1588                                         parser->active = _active_list_pop (parser->active);
1589                                 }
1590
1591                         parser->active = _active_list_push (parser->active,
1592                                                             node->token->value.str,
1593                                                             last->next);
1594
1595                         /* Splice expansion into list, supporting a
1596                          * simple deletion if the expansion is
1597                          * empty. */
1598                         if (expansion->head) {
1599                                 if (node_prev)
1600                                         node_prev->next = expansion->head;
1601                                 else
1602                                         list->head = expansion->head;
1603                                 expansion->tail->next = last->next;
1604                                 if (last == list->tail)
1605                                         list->tail = expansion->tail;
1606                         } else {
1607                                 if (node_prev)
1608                                         node_prev->next = last->next;
1609                                 else
1610                                         list->head = last->next;
1611                                 if (last == list->tail)
1612                                         list->tail = NULL;
1613                         }
1614                 } else {
1615                         node_prev = node;
1616                 }
1617                 node = node_prev ? node_prev->next : list->head;
1618         }
1619
1620         while (parser->active)
1621                 parser->active = _active_list_pop (parser->active);
1622
1623         list->non_space_tail = list->tail;
1624 }
1625
1626 void
1627 _glcpp_parser_print_expanded_token_list (glcpp_parser_t *parser,
1628                                          token_list_t *list)
1629 {
1630         if (list == NULL)
1631                 return;
1632
1633         _glcpp_parser_expand_token_list (parser, list);
1634
1635         _token_list_trim_trailing_space (list);
1636
1637         _token_list_print (parser, list);
1638 }
1639
1640 static void
1641 _check_for_reserved_macro_name (glcpp_parser_t *parser, YYLTYPE *loc,
1642                                 const char *identifier)
1643 {
1644         /* According to the GLSL specification, macro names starting with "__"
1645          * or "GL_" are reserved for future use.  So, don't allow them.
1646          */
1647         if (strncmp(identifier, "__", 2) == 0) {
1648                 glcpp_error (loc, parser, "Macro names starting with \"__\" are reserved.\n");
1649         }
1650         if (strncmp(identifier, "GL_", 3) == 0) {
1651                 glcpp_error (loc, parser, "Macro names starting with \"GL_\" are reserved.\n");
1652         }
1653 }
1654
1655 static int
1656 _macro_equal (macro_t *a, macro_t *b)
1657 {
1658         if (a->is_function != b->is_function)
1659                 return 0;
1660
1661         if (a->is_function) {
1662                 if (! _string_list_equal (a->parameters, b->parameters))
1663                         return 0;
1664         }
1665
1666         return _token_list_equal_ignoring_space (a->replacements,
1667                                                  b->replacements);
1668 }
1669
1670 void
1671 _define_object_macro (glcpp_parser_t *parser,
1672                       YYLTYPE *loc,
1673                       const char *identifier,
1674                       token_list_t *replacements)
1675 {
1676         macro_t *macro, *previous;
1677
1678         if (loc != NULL)
1679                 _check_for_reserved_macro_name(parser, loc, identifier);
1680
1681         macro = ralloc (parser, macro_t);
1682
1683         macro->is_function = 0;
1684         macro->parameters = NULL;
1685         macro->identifier = ralloc_strdup (macro, identifier);
1686         macro->replacements = replacements;
1687         ralloc_steal (macro, replacements);
1688
1689         previous = hash_table_find (parser->defines, identifier);
1690         if (previous) {
1691                 if (_macro_equal (macro, previous)) {
1692                         ralloc_free (macro);
1693                         return;
1694                 }
1695                 glcpp_error (loc, parser, "Redefinition of macro %s\n",
1696                              identifier);
1697         }
1698
1699         hash_table_insert (parser->defines, macro, identifier);
1700 }
1701
1702 void
1703 _define_function_macro (glcpp_parser_t *parser,
1704                         YYLTYPE *loc,
1705                         const char *identifier,
1706                         string_list_t *parameters,
1707                         token_list_t *replacements)
1708 {
1709         macro_t *macro, *previous;
1710
1711         _check_for_reserved_macro_name(parser, loc, identifier);
1712
1713         macro = ralloc (parser, macro_t);
1714         ralloc_steal (macro, parameters);
1715         ralloc_steal (macro, replacements);
1716
1717         macro->is_function = 1;
1718         macro->parameters = parameters;
1719         macro->identifier = ralloc_strdup (macro, identifier);
1720         macro->replacements = replacements;
1721         previous = hash_table_find (parser->defines, identifier);
1722         if (previous) {
1723                 if (_macro_equal (macro, previous)) {
1724                         ralloc_free (macro);
1725                         return;
1726                 }
1727                 glcpp_error (loc, parser, "Redefinition of macro %s\n",
1728                              identifier);
1729         }
1730
1731         hash_table_insert (parser->defines, macro, identifier);
1732 }
1733
1734 static int
1735 glcpp_parser_lex (YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser)
1736 {
1737         token_node_t *node;
1738         int ret;
1739
1740         if (parser->lex_from_list == NULL) {
1741                 ret = glcpp_lex (yylval, yylloc, parser->scanner);
1742
1743                 /* XXX: This ugly block of code exists for the sole
1744                  * purpose of converting a NEWLINE token into a SPACE
1745                  * token, but only in the case where we have seen a
1746                  * function-like macro name, but have not yet seen its
1747                  * closing parenthesis.
1748                  *
1749                  * There's perhaps a more compact way to do this with
1750                  * mid-rule actions in the grammar.
1751                  *
1752                  * I'm definitely not pleased with the complexity of
1753                  * this code here.
1754                  */
1755                 if (parser->newline_as_space)
1756                 {
1757                         if (ret == '(') {
1758                                 parser->paren_count++;
1759                         } else if (ret == ')') {
1760                                 parser->paren_count--;
1761                                 if (parser->paren_count == 0)
1762                                         parser->newline_as_space = 0;
1763                         } else if (ret == NEWLINE) {
1764                                 ret = SPACE;
1765                         } else if (ret != SPACE) {
1766                                 if (parser->paren_count == 0)
1767                                         parser->newline_as_space = 0;
1768                         }
1769                 }
1770                 else if (parser->in_control_line)
1771                 {
1772                         if (ret == NEWLINE)
1773                                 parser->in_control_line = 0;
1774                 }
1775                 else if (ret == HASH_DEFINE_OBJ || ret == HASH_DEFINE_FUNC ||
1776                            ret == HASH_UNDEF || ret == HASH_IF ||
1777                            ret == HASH_IFDEF || ret == HASH_IFNDEF ||
1778                            ret == HASH_ELIF || ret == HASH_ELSE ||
1779                            ret == HASH_ENDIF || ret == HASH)
1780                 {
1781                         parser->in_control_line = 1;
1782                 }
1783                 else if (ret == IDENTIFIER)
1784                 {
1785                         macro_t *macro;
1786                         macro = hash_table_find (parser->defines,
1787                                                  yylval->str);
1788                         if (macro && macro->is_function) {
1789                                 parser->newline_as_space = 1;
1790                                 parser->paren_count = 0;
1791                         }
1792                 }
1793
1794                 return ret;
1795         }
1796
1797         node = parser->lex_from_node;
1798
1799         if (node == NULL) {
1800                 ralloc_free (parser->lex_from_list);
1801                 parser->lex_from_list = NULL;
1802                 return NEWLINE;
1803         }
1804
1805         *yylval = node->token->value;
1806         ret = node->token->type;
1807
1808         parser->lex_from_node = node->next;
1809
1810         return ret;
1811 }
1812
1813 static void
1814 glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list)
1815 {
1816         token_node_t *node;
1817
1818         assert (parser->lex_from_list == NULL);
1819
1820         /* Copy list, eliminating any space tokens. */
1821         parser->lex_from_list = _token_list_create (parser);
1822
1823         for (node = list->head; node; node = node->next) {
1824                 if (node->token->type == SPACE)
1825                         continue;
1826                 _token_list_append (parser->lex_from_list, node->token);
1827         }
1828
1829         ralloc_free (list);
1830
1831         parser->lex_from_node = parser->lex_from_list->head;
1832
1833         /* It's possible the list consisted of nothing but whitespace. */
1834         if (parser->lex_from_node == NULL) {
1835                 ralloc_free (parser->lex_from_list);
1836                 parser->lex_from_list = NULL;
1837         }
1838 }
1839
1840 static void
1841 _glcpp_parser_skip_stack_push_if (glcpp_parser_t *parser, YYLTYPE *loc,
1842                                   int condition)
1843 {
1844         skip_type_t current = SKIP_NO_SKIP;
1845         skip_node_t *node;
1846
1847         if (parser->skip_stack)
1848                 current = parser->skip_stack->type;
1849
1850         node = ralloc (parser, skip_node_t);
1851         node->loc = *loc;
1852
1853         if (current == SKIP_NO_SKIP) {
1854                 if (condition)
1855                         node->type = SKIP_NO_SKIP;
1856                 else
1857                         node->type = SKIP_TO_ELSE;
1858         } else {
1859                 node->type = SKIP_TO_ENDIF;
1860         }
1861
1862         node->next = parser->skip_stack;
1863         parser->skip_stack = node;
1864 }
1865
1866 static void
1867 _glcpp_parser_skip_stack_change_if (glcpp_parser_t *parser, YYLTYPE *loc,
1868                                     const char *type, int condition)
1869 {
1870         if (parser->skip_stack == NULL) {
1871                 glcpp_error (loc, parser, "%s without #if\n", type);
1872                 return;
1873         }
1874
1875         if (parser->skip_stack->type == SKIP_TO_ELSE) {
1876                 if (condition)
1877                         parser->skip_stack->type = SKIP_NO_SKIP;
1878         } else {
1879                 parser->skip_stack->type = SKIP_TO_ENDIF;
1880         }
1881 }
1882
1883 static void
1884 _glcpp_parser_skip_stack_pop (glcpp_parser_t *parser, YYLTYPE *loc)
1885 {
1886         skip_node_t *node;
1887
1888         if (parser->skip_stack == NULL) {
1889                 glcpp_error (loc, parser, "#endif without #if\n");
1890                 return;
1891         }
1892
1893         node = parser->skip_stack;
1894         parser->skip_stack = node->next;
1895         ralloc_free (node);
1896 }