--- /dev/null
--- /dev/null
++%{
++/*
++ * Copyright © 2010 Intel Corporation
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <assert.h>
++#include <inttypes.h>
++
++#include "glcpp.h"
++
++static void
++yyerror (void *scanner, const char *error);
++
++static void
++_define_object_macro (glcpp_parser_t *parser,
++ const char *macro,
++ token_list_t *replacements);
++
++static void
++_define_function_macro (glcpp_parser_t *parser,
++ const char *macro,
++ string_list_t *parameters,
++ token_list_t *replacements);
++
++static string_list_t *
++_string_list_create (void *ctx);
++
++static void
++_string_list_append_item (string_list_t *list, const char *str);
++
++static void
++_string_list_append_list (string_list_t *list, string_list_t *tail);
++
++static int
++_string_list_contains (string_list_t *list, const char *member, int *index);
++
++static int
++_string_list_length (string_list_t *list);
++
++static argument_list_t *
++_argument_list_create (void *ctx);
++
++static void
++_argument_list_append (argument_list_t *list, token_list_t *argument);
++
++static int
++_argument_list_length (argument_list_t *list);
++
++static token_list_t *
++_argument_list_member_at (argument_list_t *list, int index);
++
++/* Note: This function talloc_steal()s the str pointer. */
++static token_t *
++_token_create_str (void *ctx, int type, char *str);
++
++static token_t *
++_token_create_ival (void *ctx, int type, int ival);
++
++static token_list_t *
++_token_list_create (void *ctx);
++
++/* Note: This function adds a talloc_reference() to token.
++ *
++ * You may want to talloc_unlink any current reference if you no
++ * longer need it. */
++static void
++_token_list_append (token_list_t *list, token_t *token);
++
++static void
++_token_list_append_list (token_list_t *list, token_list_t *tail);
++
++static int
++_token_list_length (token_list_t *list);
++
++static active_list_t *
++_active_list_push (active_list_t *list,
++ const char *identifier,
++ token_node_t *marker);
++
++static active_list_t *
++_active_list_pop (active_list_t *list);
++
++int
++_active_list_contains (active_list_t *list, const char *identifier);
++
++static void
++_glcpp_parser_evaluate_defined (glcpp_parser_t *parser,
++ token_list_t *list);
++
++static void
++_glcpp_parser_expand_token_list (glcpp_parser_t *parser,
++ token_list_t *list);
++
++static void
++_glcpp_parser_print_expanded_token_list (glcpp_parser_t *parser,
++ token_list_t *list);
++
++static void
++_glcpp_parser_skip_stack_push_if (glcpp_parser_t *parser, int condition);
++
++static void
++_glcpp_parser_skip_stack_change_if (glcpp_parser_t *parser, const char *type,
++ int condition);
++
++static void
++_glcpp_parser_skip_stack_pop (glcpp_parser_t *parser);
++
++#define yylex glcpp_parser_lex
++
++static int
++glcpp_parser_lex (glcpp_parser_t *parser);
++
++static void
++glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list);
++
++%}
++
++%parse-param {glcpp_parser_t *parser}
++%lex-param {glcpp_parser_t *parser}
++
++%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 IDENTIFIER IF_EXPANDED INTEGER INTEGER_STRING NEWLINE OTHER PLACEHOLDER SPACE
++%token PASTE
++%type <ival> expression INTEGER operator SPACE
++%type <str> IDENTIFIER INTEGER_STRING OTHER
++%type <string_list> identifier_list
++%type <token> preprocessing_token
++%type <token_list> pp_tokens replacement_list text_line
++%left OR
++%left AND
++%left '|'
++%left '^'
++%left '&'
++%left EQUAL NOT_EQUAL
++%left '<' '>' LESS_OR_EQUAL GREATER_OR_EQUAL
++%left LEFT_SHIFT RIGHT_SHIFT
++%left '+' '-'
++%left '*' '/' '%'
++%right UNARY
++
++%%
++
++input:
++ /* empty */
++| input line
++;
++
++line:
++ control_line {
++ printf ("\n");
++ }
++| text_line {
++ _glcpp_parser_print_expanded_token_list (parser, $1);
++ printf ("\n");
++ talloc_free ($1);
++ }
++| expanded_line
++| HASH non_directive
++;
++
++expanded_line:
++ IF_EXPANDED expression NEWLINE {
++ _glcpp_parser_skip_stack_push_if (parser, $2);
++ }
++| ELIF_EXPANDED expression NEWLINE {
++ _glcpp_parser_skip_stack_change_if (parser, "elif", $2);
++ }
++;
++
++control_line:
++ HASH_DEFINE_OBJ IDENTIFIER replacement_list NEWLINE {
++ _define_object_macro (parser, $2, $3);
++ }
++| HASH_DEFINE_FUNC IDENTIFIER '(' ')' replacement_list NEWLINE {
++ _define_function_macro (parser, $2, NULL, $5);
++ }
++| HASH_DEFINE_FUNC IDENTIFIER '(' identifier_list ')' replacement_list NEWLINE {
++ _define_function_macro (parser, $2, $4, $6);
++ }
++| HASH_UNDEF IDENTIFIER NEWLINE {
++ macro_t *macro = hash_table_find (parser->defines, $2);
++ if (macro) {
++ /* XXX: Need hash table to support a real way
++ * to remove an element rather than prefixing
++ * a new node with data of NULL like this. */
++ hash_table_insert (parser->defines, NULL, $2);
++ talloc_free (macro);
++ }
++ talloc_free ($2);
++ }
++| HASH_IF pp_tokens NEWLINE {
++ token_list_t *expanded;
++ token_t *token;
++
++ expanded = _token_list_create (parser);
++ token = _token_create_ival (parser, IF_EXPANDED, IF_EXPANDED);
++ _token_list_append (expanded, token);
++ talloc_unlink (parser, token);
++ _glcpp_parser_evaluate_defined (parser, $2);
++ _glcpp_parser_expand_token_list (parser, $2);
++ _token_list_append_list (expanded, $2);
++ glcpp_parser_lex_from (parser, expanded);
++ }
++| HASH_IFDEF IDENTIFIER NEWLINE {
++ macro_t *macro = hash_table_find (parser->defines, $2);
++ talloc_free ($2);
++ _glcpp_parser_skip_stack_push_if (parser, macro != NULL);
++ }
++| HASH_IFNDEF IDENTIFIER NEWLINE {
++ macro_t *macro = hash_table_find (parser->defines, $2);
++ talloc_free ($2);
++ _glcpp_parser_skip_stack_push_if (parser, macro == NULL);
++ }
++| HASH_ELIF pp_tokens NEWLINE {
++ token_list_t *expanded;
++ token_t *token;
++
++ expanded = _token_list_create (parser);
++ token = _token_create_ival (parser, ELIF_EXPANDED, ELIF_EXPANDED);
++ _token_list_append (expanded, token);
++ talloc_unlink (parser, token);
++ _glcpp_parser_evaluate_defined (parser, $2);
++ _glcpp_parser_expand_token_list (parser, $2);
++ _token_list_append_list (expanded, $2);
++ glcpp_parser_lex_from (parser, expanded);
++ }
++| HASH_ELSE NEWLINE {
++ _glcpp_parser_skip_stack_change_if (parser, "else", 1);
++ }
++| HASH_ENDIF NEWLINE {
++ _glcpp_parser_skip_stack_pop (parser);
++ }
++| HASH NEWLINE
++;
++
++expression:
++ INTEGER_STRING {
++ if (strlen ($1) >= 3 && strncmp ($1, "0x", 2) == 0) {
++ $$ = strtoll ($1 + 2, NULL, 16);
++ } else if ($1[0] == '0') {
++ $$ = strtoll ($1, NULL, 8);
++ } else {
++ $$ = strtoll ($1, NULL, 10);
++ }
++ }
++| INTEGER {
++ $$ = $1;
++ }
++| expression OR expression {
++ $$ = $1 || $3;
++ }
++| expression AND expression {
++ $$ = $1 && $3;
++ }
++| expression '|' expression {
++ $$ = $1 | $3;
++ }
++| expression '^' expression {
++ $$ = $1 ^ $3;
++ }
++| expression '&' expression {
++ $$ = $1 & $3;
++ }
++| expression NOT_EQUAL expression {
++ $$ = $1 != $3;
++ }
++| expression EQUAL expression {
++ $$ = $1 == $3;
++ }
++| expression GREATER_OR_EQUAL expression {
++ $$ = $1 >= $3;
++ }
++| expression LESS_OR_EQUAL expression {
++ $$ = $1 <= $3;
++ }
++| expression '>' expression {
++ $$ = $1 > $3;
++ }
++| expression '<' expression {
++ $$ = $1 < $3;
++ }
++| expression RIGHT_SHIFT expression {
++ $$ = $1 >> $3;
++ }
++| expression LEFT_SHIFT expression {
++ $$ = $1 << $3;
++ }
++| expression '-' expression {
++ $$ = $1 - $3;
++ }
++| expression '+' expression {
++ $$ = $1 + $3;
++ }
++| expression '%' expression {
++ $$ = $1 % $3;
++ }
++| expression '/' expression {
++ $$ = $1 / $3;
++ }
++| expression '*' expression {
++ $$ = $1 * $3;
++ }
++| '!' expression %prec UNARY {
++ $$ = ! $2;
++ }
++| '~' expression %prec UNARY {
++ $$ = ~ $2;
++ }
++| '-' expression %prec UNARY {
++ $$ = - $2;
++ }
++| '+' expression %prec UNARY {
++ $$ = + $2;
++ }
++| '(' expression ')' {
++ $$ = $2;
++ }
++;
++
++identifier_list:
++ IDENTIFIER {
++ $$ = _string_list_create (parser);
++ _string_list_append_item ($$, $1);
++ talloc_steal ($$, $1);
++ }
++| identifier_list ',' IDENTIFIER {
++ $$ = $1;
++ _string_list_append_item ($$, $3);
++ talloc_steal ($$, $3);
++ }
++;
++
++text_line:
++ NEWLINE { $$ = NULL; }
++| pp_tokens NEWLINE
++;
++
++non_directive:
++ pp_tokens NEWLINE
++;
++
++replacement_list:
++ /* empty */ { $$ = NULL; }
++| pp_tokens
++;
++
++pp_tokens:
++ preprocessing_token {
++ parser->space_tokens = 1;
++ $$ = _token_list_create (parser);
++ _token_list_append ($$, $1);
++ talloc_unlink (parser, $1);
++ }
++| pp_tokens preprocessing_token {
++ $$ = $1;
++ _token_list_append ($$, $2);
++ talloc_unlink (parser, $2);
++ }
++;
++
++preprocessing_token:
++ IDENTIFIER {
++ $$ = _token_create_str (parser, IDENTIFIER, $1);
++ }
++| INTEGER_STRING {
++ $$ = _token_create_str (parser, INTEGER_STRING, $1);
++ }
++| operator {
++ $$ = _token_create_ival (parser, $1, $1);
++ }
++| OTHER {
++ $$ = _token_create_str (parser, OTHER, $1);
++ }
++| SPACE {
++ $$ = _token_create_ival (parser, SPACE, SPACE);
++ }
++;
++
++operator:
++ '[' { $$ = '['; }
++| ']' { $$ = ']'; }
++| '(' { $$ = '('; }
++| ')' { $$ = ')'; }
++| '{' { $$ = '{'; }
++| '}' { $$ = '}'; }
++| '.' { $$ = '.'; }
++| '&' { $$ = '&'; }
++| '*' { $$ = '*'; }
++| '+' { $$ = '+'; }
++| '-' { $$ = '-'; }
++| '~' { $$ = '~'; }
++| '!' { $$ = '!'; }
++| '/' { $$ = '/'; }
++| '%' { $$ = '%'; }
++| LEFT_SHIFT { $$ = LEFT_SHIFT; }
++| RIGHT_SHIFT { $$ = RIGHT_SHIFT; }
++| '<' { $$ = '<'; }
++| '>' { $$ = '>'; }
++| LESS_OR_EQUAL { $$ = LESS_OR_EQUAL; }
++| GREATER_OR_EQUAL { $$ = GREATER_OR_EQUAL; }
++| EQUAL { $$ = EQUAL; }
++| NOT_EQUAL { $$ = NOT_EQUAL; }
++| '^' { $$ = '^'; }
++| '|' { $$ = '|'; }
++| AND { $$ = AND; }
++| OR { $$ = OR; }
++| ';' { $$ = ';'; }
++| ',' { $$ = ','; }
++| '=' { $$ = '='; }
++| PASTE { $$ = PASTE; }
++| DEFINED { $$ = DEFINED; }
++;
++
++%%
++
++string_list_t *
++_string_list_create (void *ctx)
++{
++ string_list_t *list;
++
++ list = xtalloc (ctx, string_list_t);
++ list->head = NULL;
++ list->tail = NULL;
++
++ return list;
++}
++
++void
++_string_list_append_list (string_list_t *list, string_list_t *tail)
++{
++ if (list->head == NULL) {
++ list->head = tail->head;
++ } else {
++ list->tail->next = tail->head;
++ }
++
++ list->tail = tail->tail;
++}
++
++void
++_string_list_append_item (string_list_t *list, const char *str)
++{
++ string_node_t *node;
++
++ node = xtalloc (list, string_node_t);
++ node->str = xtalloc_strdup (node, str);
++
++ node->next = NULL;
++
++ if (list->head == NULL) {
++ list->head = node;
++ } else {
++ list->tail->next = node;
++ }
++
++ list->tail = node;
++}
++
++int
++_string_list_contains (string_list_t *list, const char *member, int *index)
++{
++ string_node_t *node;
++ int i;
++
++ if (list == NULL)
++ return 0;
++
++ for (i = 0, node = list->head; node; i++, node = node->next) {
++ if (strcmp (node->str, member) == 0) {
++ if (index)
++ *index = i;
++ return 1;
++ }
++ }
++
++ return 0;
++}
++
++int
++_string_list_length (string_list_t *list)
++{
++ int length = 0;
++ string_node_t *node;
++
++ if (list == NULL)
++ return 0;
++
++ for (node = list->head; node; node = node->next)
++ length++;
++
++ return length;
++}
++
++argument_list_t *
++_argument_list_create (void *ctx)
++{
++ argument_list_t *list;
++
++ list = xtalloc (ctx, argument_list_t);
++ list->head = NULL;
++ list->tail = NULL;
++
++ return list;
++}
++
++void
++_argument_list_append (argument_list_t *list, token_list_t *argument)
++{
++ argument_node_t *node;
++
++ node = xtalloc (list, argument_node_t);
++ node->argument = argument;
++
++ node->next = NULL;
++
++ if (list->head == NULL) {
++ list->head = node;
++ } else {
++ list->tail->next = node;
++ }
++
++ list->tail = node;
++}
++
++int
++_argument_list_length (argument_list_t *list)
++{
++ int length = 0;
++ argument_node_t *node;
++
++ if (list == NULL)
++ return 0;
++
++ for (node = list->head; node; node = node->next)
++ length++;
++
++ return length;
++}
++
++token_list_t *
++_argument_list_member_at (argument_list_t *list, int index)
++{
++ argument_node_t *node;
++ int i;
++
++ if (list == NULL)
++ return NULL;
++
++ node = list->head;
++ for (i = 0; i < index; i++) {
++ node = node->next;
++ if (node == NULL)
++ break;
++ }
++
++ if (node)
++ return node->argument;
++
++ return NULL;
++}
++
++/* Note: This function talloc_steal()s the str pointer. */
++token_t *
++_token_create_str (void *ctx, int type, char *str)
++{
++ token_t *token;
++
++ token = xtalloc (ctx, token_t);
++ token->type = type;
++ token->value.str = talloc_steal (token, str);
++
++ return token;
++}
++
++token_t *
++_token_create_ival (void *ctx, int type, int ival)
++{
++ token_t *token;
++
++ token = xtalloc (ctx, token_t);
++ token->type = type;
++ token->value.ival = ival;
++
++ return token;
++}
++
++token_list_t *
++_token_list_create (void *ctx)
++{
++ token_list_t *list;
++
++ list = xtalloc (ctx, token_list_t);
++ list->head = NULL;
++ list->tail = NULL;
++ list->non_space_tail = NULL;
++
++ return list;
++}
++
++void
++_token_list_append (token_list_t *list, token_t *token)
++{
++ token_node_t *node;
++
++ node = xtalloc (list, token_node_t);
++ node->token = xtalloc_reference (list, token);
++
++ node->next = NULL;
++
++ if (list->head == NULL) {
++ list->head = node;
++ } else {
++ list->tail->next = node;
++ }
++
++ list->tail = node;
++ if (token->type != SPACE)
++ list->non_space_tail = node;
++}
++
++void
++_token_list_append_list (token_list_t *list, token_list_t *tail)
++{
++ if (tail == NULL || tail->head == NULL)
++ return;
++
++ if (list->head == NULL) {
++ list->head = tail->head;
++ } else {
++ list->tail->next = tail->head;
++ }
++
++ list->tail = tail->tail;
++ list->non_space_tail = tail->non_space_tail;
++}
++
++token_list_t *
++_token_list_copy (void *ctx, token_list_t *other)
++{
++ token_list_t *copy;
++ token_node_t *node;
++
++ if (other == NULL)
++ return NULL;
++
++ copy = _token_list_create (ctx);
++ for (node = other->head; node; node = node->next)
++ _token_list_append (copy, node->token);
++
++ return copy;
++}
++
++void
++_token_list_trim_trailing_space (token_list_t *list)
++{
++ token_node_t *tail, *next;
++
++ if (list->non_space_tail) {
++ tail = list->non_space_tail->next;
++ list->non_space_tail->next = NULL;
++ list->tail = list->non_space_tail;
++
++ while (tail) {
++ next = tail->next;
++ talloc_free (tail);
++ tail = next;
++ }
++ }
++}
++
++static int
++_token_list_length (token_list_t *list)
++{
++ int length = 0;
++ token_node_t *node;
++
++ if (list == NULL)
++ return 0;
++
++ for (node = list->head; node; node = node->next)
++ length++;
++
++ return length;
++}
++
++static void
++_token_print (token_t *token)
++{
++ if (token->type < 256) {
++ printf ("%c", token->type);
++ return;
++ }
++
++ switch (token->type) {
++ case INTEGER:
++ printf ("%" PRIxMAX, token->value.ival);
++ break;
++ case IDENTIFIER:
++ case INTEGER_STRING:
++ case OTHER:
++ printf ("%s", token->value.str);
++ break;
++ case SPACE:
++ printf (" ");
++ break;
++ case LEFT_SHIFT:
++ printf ("<<");
++ break;
++ case RIGHT_SHIFT:
++ printf (">>");
++ break;
++ case LESS_OR_EQUAL:
++ printf ("<=");
++ break;
++ case GREATER_OR_EQUAL:
++ printf (">=");
++ break;
++ case EQUAL:
++ printf ("==");
++ break;
++ case NOT_EQUAL:
++ printf ("!=");
++ break;
++ case AND:
++ printf ("&&");
++ break;
++ case OR:
++ printf ("||");
++ break;
++ case PASTE:
++ printf ("##");
++ break;
++ case COMMA_FINAL:
++ printf (",");
++ break;
++ case PLACEHOLDER:
++ /* Nothing to print. */
++ break;
++ default:
++ fprintf (stderr, "Error: Don't know how to print token type %d\n", token->type);
++ break;
++ }
++}
++
++/* Return a new token (talloc()ed off of 'token') formed by pasting
++ * 'token' and 'other'. Note that this function may return 'token' or
++ * 'other' directly rather than allocating anything new.
++ *
++ * Caution: Only very cursory error-checking is performed to see if
++ * the final result is a valid single token. */
++static token_t *
++_token_paste (token_t *token, token_t *other)
++{
++ /* Pasting a placeholder onto anything makes no change. */
++ if (other->type == PLACEHOLDER)
++ return token;
++
++ /* When 'token' is a placeholder, just return 'other'. */
++ if (token->type == PLACEHOLDER)
++ return other;
++
++ /* A very few single-character punctuators can be combined
++ * with another to form a multi-character punctuator. */
++ switch (token->type) {
++ case '<':
++ if (other->type == '<')
++ return _token_create_ival (token, LEFT_SHIFT, LEFT_SHIFT);
++ else if (other->type == '=')
++ return _token_create_ival (token, LESS_OR_EQUAL, LESS_OR_EQUAL);
++ break;
++ case '>':
++ if (other->type == '>')
++ return _token_create_ival (token, RIGHT_SHIFT, RIGHT_SHIFT);
++ else if (other->type == '=')
++ return _token_create_ival (token, GREATER_OR_EQUAL, GREATER_OR_EQUAL);
++ break;
++ case '=':
++ if (other->type == '=')
++ return _token_create_ival (token, EQUAL, EQUAL);
++ break;
++ case '!':
++ if (other->type == '=')
++ return _token_create_ival (token, NOT_EQUAL, NOT_EQUAL);
++ break;
++ case '&':
++ if (other->type == '&')
++ return _token_create_ival (token, AND, AND);
++ break;
++ case '|':
++ if (other->type == '|')
++ return _token_create_ival (token, OR, OR);
++ break;
++ }
++
++ /* Two string-valued tokens can usually just be mashed
++ * together.
++ *
++ * XXX: This isn't actually legitimate. Several things here
++ * should result in a diagnostic since the result cannot be a
++ * valid, single pre-processing token. For example, pasting
++ * "123" and "abc" is not legal, but we don't catch that
++ * here. */
++ if ((token->type == IDENTIFIER || token->type == OTHER || token->type == INTEGER_STRING) &&
++ (other->type == IDENTIFIER || other->type == OTHER || other->type == INTEGER_STRING))
++ {
++ char *str;
++
++ str = xtalloc_asprintf (token, "%s%s",
++ token->value.str, other->value.str);
++ return _token_create_str (token, token->type, str);
++ }
++
++ printf ("Error: Pasting \"");
++ _token_print (token);
++ printf ("\" and \"");
++ _token_print (other);
++ printf ("\" does not give a valid preprocessing token.\n");
++
++ return token;
++}
++
++static void
++_token_list_print (token_list_t *list)
++{
++ token_node_t *node;
++
++ if (list == NULL)
++ return;
++
++ for (node = list->head; node; node = node->next)
++ _token_print (node->token);
++}
++
++void
++yyerror (void *scanner, const char *error)
++{
++ fprintf (stderr, "Parse error: %s\n", error);
++}
++
++glcpp_parser_t *
++glcpp_parser_create (void)
++{
++ glcpp_parser_t *parser;
++
++ parser = xtalloc (NULL, glcpp_parser_t);
++
++ glcpp_lex_init_extra (parser, &parser->scanner);
++ parser->defines = hash_table_ctor (32, hash_table_string_hash,
++ hash_table_string_compare);
++ parser->active = NULL;
++ parser->lexing_if = 0;
++ parser->space_tokens = 1;
++ parser->newline_as_space = 0;
++ parser->in_control_line = 0;
++ parser->paren_count = 0;
++
++ parser->skip_stack = NULL;
++
++ parser->lex_from_list = NULL;
++ parser->lex_from_node = NULL;
++
++ return parser;
++}
++
++int
++glcpp_parser_parse (glcpp_parser_t *parser)
++{
++ return yyparse (parser);
++}
++
++void
++glcpp_parser_destroy (glcpp_parser_t *parser)
++{
++ if (parser->skip_stack)
++ fprintf (stderr, "Error: Unterminated #if\n");
++ glcpp_lex_destroy (parser->scanner);
++ hash_table_dtor (parser->defines);
++ talloc_free (parser);
++}
++
++/* Replace any occurences of DEFINED tokens in 'list' with either a
++ * '0' or '1' INTEGER token depending on whether the next token in the
++ * list is defined or not. */
++static void
++_glcpp_parser_evaluate_defined (glcpp_parser_t *parser,
++ token_list_t *list)
++{
++ token_node_t *node, *next;
++ macro_t *macro;
++
++ if (list == NULL)
++ return;
++
++ for (node = list->head; node; node = node->next) {
++ if (node->token->type != DEFINED)
++ continue;
++ next = node->next;
++ while (next && next->token->type == SPACE)
++ next = next->next;
++ if (next == NULL || next->token->type != IDENTIFIER) {
++ fprintf (stderr, "Error: operator \"defined\" requires an identifier\n");
++ exit (1);
++ }
++ macro = hash_table_find (parser->defines,
++ next->token->value.str);
++
++ node->token->type = INTEGER;
++ node->token->value.ival = (macro != NULL);
++ node->next = next->next;
++ }
++}
++
++typedef enum function_status
++{
++ FUNCTION_STATUS_SUCCESS,
++ FUNCTION_NOT_A_FUNCTION,
++ FUNCTION_UNBALANCED_PARENTHESES
++} function_status_t;
++
++/* Find a set of function-like macro arguments by looking for a
++ * balanced set of parentheses.
++ *
++ * When called, 'node' should be the opening-parenthesis token, (or
++ * perhaps preceeding SPACE tokens). Upon successful return *last will
++ * be the last consumed node, (corresponding to the closing right
++ * parenthesis).
++ *
++ * Return values:
++ *
++ * FUNCTION_STATUS_SUCCESS:
++ *
++ * Successfully parsed a set of function arguments.
++ *
++ * FUNCTION_NOT_A_FUNCTION:
++ *
++ * Macro name not followed by a '('. This is not an error, but
++ * simply that the macro name should be treated as a non-macro.
++ *
++ * FUNCTION_UNBALANCED_PARENTHESES
++ *
++ * Macro name is not followed by a balanced set of parentheses.
++ */
++static function_status_t
++_arguments_parse (argument_list_t *arguments,
++ token_node_t *node,
++ token_node_t **last)
++{
++ token_list_t *argument;
++ int paren_count;
++
++ node = node->next;
++
++ /* Ignore whitespace before first parenthesis. */
++ while (node && node->token->type == SPACE)
++ node = node->next;
++
++ if (node == NULL || node->token->type != '(')
++ return FUNCTION_NOT_A_FUNCTION;
++
++ node = node->next;
++
++ argument = _token_list_create (arguments);
++ _argument_list_append (arguments, argument);
++
++ for (paren_count = 1; node; node = node->next) {
++ if (node->token->type == '(')
++ {
++ paren_count++;
++ }
++ else if (node->token->type == ')')
++ {
++ paren_count--;
++ if (paren_count == 0)
++ break;
++ }
++
++ if (node->token->type == ',' &&
++ paren_count == 1)
++ {
++ _token_list_trim_trailing_space (argument);
++ argument = _token_list_create (arguments);
++ _argument_list_append (arguments, argument);
++ }
++ else {
++ if (argument->head == NULL) {
++ /* Don't treat initial whitespace as
++ * part of the arguement. */
++ if (node->token->type == SPACE)
++ continue;
++ }
++ _token_list_append (argument, node->token);
++ }
++ }
++
++ if (paren_count)
++ return FUNCTION_UNBALANCED_PARENTHESES;
++
++ *last = node;
++
++ return FUNCTION_STATUS_SUCCESS;
++}
++
++/* This is a helper function that's essentially part of the
++ * implementation of _glcpp_parser_expand_node. It shouldn't be called
++ * except for by that function.
++ *
++ * Returns NULL if node is a simple token with no expansion, (that is,
++ * although 'node' corresponds to an identifier defined as a
++ * function-like macro, it is not followed with a parenthesized
++ * argument list).
++ *
++ * Compute the complete expansion of node (which is a function-like
++ * macro) and subsequent nodes which are arguments.
++ *
++ * Returns the token list that results from the expansion and sets
++ * *last to the last node in the list that was consumed by the
++ * expansion. Specificallty, *last will be set as follows: as the
++ * token of the closing right parenthesis.
++ */
++static token_list_t *
++_glcpp_parser_expand_function (glcpp_parser_t *parser,
++ token_node_t *node,
++ token_node_t **last)
++
++{
++ macro_t *macro;
++ const char *identifier;
++ argument_list_t *arguments;
++ function_status_t status;
++ token_list_t *substituted;
++ int parameter_index;
++
++ identifier = node->token->value.str;
++
++ macro = hash_table_find (parser->defines, identifier);
++
++ assert (macro->is_function);
++
++ arguments = _argument_list_create (parser);
++ status = _arguments_parse (arguments, node, last);
++
++ switch (status) {
++ case FUNCTION_STATUS_SUCCESS:
++ break;
++ case FUNCTION_NOT_A_FUNCTION:
++ return NULL;
++ case FUNCTION_UNBALANCED_PARENTHESES:
++ fprintf (stderr, "Error: Macro %s call has unbalanced parentheses\n",
++ identifier);
++ exit (1);
++ return NULL;
++ }
++
++ if (macro->replacements == NULL) {
++ talloc_free (arguments);
++ return _token_list_create (parser);
++ }
++
++ if (! ((_argument_list_length (arguments) ==
++ _string_list_length (macro->parameters)) ||
++ (_string_list_length (macro->parameters) == 0 &&
++ _argument_list_length (arguments) == 1 &&
++ arguments->head->argument->head == NULL)))
++ {
++ fprintf (stderr,
++ "Error: macro %s invoked with %d arguments (expected %d)\n",
++ identifier,
++ _argument_list_length (arguments),
++ _string_list_length (macro->parameters));
++ return NULL;
++ }
++
++ /* Perform argument substitution on the replacement list. */
++ substituted = _token_list_create (arguments);
++
++ for (node = macro->replacements->head; node; node = node->next)
++ {
++ if (node->token->type == IDENTIFIER &&
++ _string_list_contains (macro->parameters,
++ node->token->value.str,
++ ¶meter_index))
++ {
++ token_list_t *argument;
++ argument = _argument_list_member_at (arguments,
++ parameter_index);
++ /* Before substituting, we expand the argument
++ * tokens, or append a placeholder token for
++ * an empty argument. */
++ if (argument->head) {
++ _glcpp_parser_expand_token_list (parser,
++ argument);
++ _token_list_append_list (substituted, argument);
++ } else {
++ token_t *new_token;
++
++ new_token = _token_create_ival (substituted,
++ PLACEHOLDER,
++ PLACEHOLDER);
++ _token_list_append (substituted, new_token);
++ }
++ } else {
++ _token_list_append (substituted, node->token);
++ }
++ }
++
++ /* After argument substitution, and before further expansion
++ * below, implement token pasting. */
++
++ _token_list_trim_trailing_space (substituted);
++
++ node = substituted->head;
++ while (node)
++ {
++ token_node_t *next_non_space;
++
++ /* Look ahead for a PASTE token, skipping space. */
++ next_non_space = node->next;
++ while (next_non_space && next_non_space->token->type == SPACE)
++ next_non_space = next_non_space->next;
++
++ if (next_non_space == NULL)
++ break;
++
++ if (next_non_space->token->type != PASTE) {
++ node = next_non_space;
++ continue;
++ }
++
++ /* Now find the next non-space token after the PASTE. */
++ next_non_space = next_non_space->next;
++ while (next_non_space && next_non_space->token->type == SPACE)
++ next_non_space = next_non_space->next;
++
++ if (next_non_space == NULL) {
++ fprintf (stderr, "Error: '##' cannot appear at either end of a macro expansion\n");
++ return NULL;
++ }
++
++ node->token = _token_paste (node->token, next_non_space->token);
++ node->next = next_non_space->next;
++ if (next_non_space == substituted->tail)
++ substituted->tail = node;
++
++ node = node->next;
++ }
++
++ substituted->non_space_tail = substituted->tail;
++
++ return substituted;
++}
++
++/* Compute the complete expansion of node, (and subsequent nodes after
++ * 'node' in the case that 'node' is a function-like macro and
++ * subsequent nodes are arguments).
++ *
++ * Returns NULL if node is a simple token with no expansion.
++ *
++ * Otherwise, returns the token list that results from the expansion
++ * and sets *last to the last node in the list that was consumed by
++ * the expansion. Specificallty, *last will be set as follows:
++ *
++ * As 'node' in the case of object-like macro expansion.
++ *
++ * As the token of the closing right parenthesis in the case of
++ * function-like macro expansion.
++ */
++static token_list_t *
++_glcpp_parser_expand_node (glcpp_parser_t *parser,
++ token_node_t *node,
++ token_node_t **last)
++{
++ token_t *token = node->token;
++ const char *identifier;
++ macro_t *macro;
++
++ /* We only expand identifiers */
++ if (token->type != IDENTIFIER) {
++ /* We change any COMMA into a COMMA_FINAL to prevent
++ * it being mistaken for an argument separator
++ * later. */
++ if (token->type == ',') {
++ token->type = COMMA_FINAL;
++ token->value.ival = COMMA_FINAL;
++ }
++
++ return NULL;
++ }
++
++ /* Look up this identifier in the hash table. */
++ identifier = token->value.str;
++ macro = hash_table_find (parser->defines, identifier);
++
++ /* Not a macro, so no expansion needed. */
++ if (macro == NULL)
++ return NULL;
++
++ /* Finally, don't expand this macro if we're already actively
++ * expanding it, (to avoid infinite recursion). */
++ if (_active_list_contains (parser->active, identifier)) {
++ /* We change the token type here from IDENTIFIER to
++ * OTHER to prevent any future expansion of this
++ * unexpanded token. */
++ char *str;
++ token_list_t *expansion;
++ token_t *final;
++
++ str = xtalloc_strdup (parser, token->value.str);
++ final = _token_create_str (parser, OTHER, str);
++ expansion = _token_list_create (parser);
++ _token_list_append (expansion, final);
++ *last = node;
++ return expansion;
++ }
++
++ if (! macro->is_function)
++ {
++ *last = node;
++
++ if (macro->replacements == NULL)
++ return _token_list_create (parser);
++
++ return _token_list_copy (parser, macro->replacements);
++ }
++
++ return _glcpp_parser_expand_function (parser, node, last);
++}
++
++/* Push a new identifier onto the active list, returning the new list.
++ *
++ * Here, 'marker' is the token node that appears in the list after the
++ * expansion of 'identifier'. That is, when the list iterator begins
++ * examinging 'marker', then it is time to pop this node from the
++ * active stack.
++ */
++active_list_t *
++_active_list_push (active_list_t *list,
++ const char *identifier,
++ token_node_t *marker)
++{
++ active_list_t *node;
++
++ node = xtalloc (list, active_list_t);
++ node->identifier = xtalloc_strdup (node, identifier);
++ node->marker = marker;
++ node->next = list;
++
++ return node;
++}
++
++active_list_t *
++_active_list_pop (active_list_t *list)
++{
++ active_list_t *node = list;
++
++ if (node == NULL)
++ return NULL;
++
++ node = list->next;
++ talloc_free (list);
++
++ return node;
++}
++
++int
++_active_list_contains (active_list_t *list, const char *identifier)
++{
++ active_list_t *node;
++
++ if (list == NULL)
++ return 0;
++
++ for (node = list; node; node = node->next)
++ if (strcmp (node->identifier, identifier) == 0)
++ return 1;
++
++ return 0;
++}
++
++/* Walk over the token list replacing nodes with their expansion.
++ * Whenever nodes are expanded the walking will walk over the new
++ * nodes, continuing to expand as necessary. The results are placed in
++ * 'list' itself;
++ */
++static void
++_glcpp_parser_expand_token_list (glcpp_parser_t *parser,
++ token_list_t *list)
++{
++ token_node_t *node_prev;
++ token_node_t *node, *last;
++ token_list_t *expansion;
++
++ if (list == NULL)
++ return;
++
++ _token_list_trim_trailing_space (list);
++
++ node_prev = NULL;
++ node = list->head;
++
++ while (node) {
++
++ while (parser->active && parser->active->marker == node)
++ parser->active = _active_list_pop (parser->active);
++
++ /* Find the expansion for node, which will replace all
++ * nodes from node to last, inclusive. */
++ expansion = _glcpp_parser_expand_node (parser, node, &last);
++ if (expansion) {
++ token_node_t *n;
++
++ for (n = node; n != last->next; n = n->next)
++ while (parser->active &&
++ parser->active->marker == n)
++ {
++ parser->active = _active_list_pop (parser->active);
++ }
++
++ parser->active = _active_list_push (parser->active,
++ node->token->value.str,
++ last->next);
++
++ /* Splice expansion into list, supporting a
++ * simple deletion if the expansion is
++ * empty. */
++ if (expansion->head) {
++ if (node_prev)
++ node_prev->next = expansion->head;
++ else
++ list->head = expansion->head;
++ expansion->tail->next = last->next;
++ if (last == list->tail)
++ list->tail = expansion->tail;
++ } else {
++ if (node_prev)
++ node_prev->next = last->next;
++ else
++ list->head = last->next;
++ if (last == list->tail)
++ list->tail == NULL;
++ }
++ } else {
++ node_prev = node;
++ }
++ node = node_prev ? node_prev->next : list->head;
++ }
++
++ while (parser->active)
++ parser->active = _active_list_pop (parser->active);
++
++ list->non_space_tail = list->tail;
++}
++
++void
++_glcpp_parser_print_expanded_token_list (glcpp_parser_t *parser,
++ token_list_t *list)
++{
++ if (list == NULL)
++ return;
++
++ _glcpp_parser_expand_token_list (parser, list);
++
++ _token_list_trim_trailing_space (list);
++
++ _token_list_print (list);
++}
++
++void
++_check_for_reserved_macro_name (const char *identifier)
++{
++ /* According to the GLSL specification, macro names starting with "__"
++ * or "GL_" are reserved for future use. So, don't allow them.
++ */
++ if (strncmp(identifier, "__", 2) == 0) {
++ fprintf (stderr, "Error: Macro names starting with \"__\" are reserved.\n");
++ exit(1);
++ }
++ if (strncmp(identifier, "GL_", 3) == 0) {
++ fprintf (stderr, "Error: Macro names starting with \"GL_\" are reserved.\n");
++ exit(1);
++ }
++}
++
++void
++_define_object_macro (glcpp_parser_t *parser,
++ const char *identifier,
++ token_list_t *replacements)
++{
++ macro_t *macro;
++
++ _check_for_reserved_macro_name(identifier);
++
++ macro = xtalloc (parser, macro_t);
++
++ macro->is_function = 0;
++ macro->parameters = NULL;
++ macro->identifier = talloc_strdup (macro, identifier);
++ macro->replacements = talloc_steal (macro, replacements);
++
++ hash_table_insert (parser->defines, macro, identifier);
++}
++
++void
++_define_function_macro (glcpp_parser_t *parser,
++ const char *identifier,
++ string_list_t *parameters,
++ token_list_t *replacements)
++{
++ macro_t *macro;
++
++ _check_for_reserved_macro_name(identifier);
++
++ macro = xtalloc (parser, macro_t);
++
++ macro->is_function = 1;
++ macro->parameters = talloc_steal (macro, parameters);
++ macro->identifier = talloc_strdup (macro, identifier);
++ macro->replacements = talloc_steal (macro, replacements);
++
++ hash_table_insert (parser->defines, macro, identifier);
++}
++
++static int
++glcpp_parser_lex (glcpp_parser_t *parser)
++{
++ token_node_t *node;
++ int ret;
++
++ if (parser->lex_from_list == NULL) {
++ ret = glcpp_lex (parser->scanner);
++
++ /* XXX: This ugly block of code exists for the sole
++ * purpose of converting a NEWLINE token into a SPACE
++ * token, but only in the case where we have seen a
++ * function-like macro name, but have not yet seen its
++ * closing parenthesis.
++ *
++ * There's perhaps a more compact way to do this with
++ * mid-rule actions in the grammar.
++ *
++ * I'm definitely not pleased with the complexity of
++ * this code here.
++ */
++ if (parser->newline_as_space)
++ {
++ if (ret == '(') {
++ parser->paren_count++;
++ } else if (ret == ')') {
++ parser->paren_count--;
++ if (parser->paren_count == 0)
++ parser->newline_as_space = 0;
++ } else if (ret == NEWLINE) {
++ ret = SPACE;
++ } else if (ret != SPACE) {
++ if (parser->paren_count == 0)
++ parser->newline_as_space = 0;
++ }
++ }
++ else if (parser->in_control_line)
++ {
++ if (ret == NEWLINE)
++ parser->in_control_line = 0;
++ }
++ else if (ret == HASH_DEFINE_OBJ || ret == HASH_DEFINE_FUNC ||
++ ret == HASH_UNDEF || ret == HASH_IF ||
++ ret == HASH_IFDEF || ret == HASH_IFNDEF ||
++ ret == HASH_ELIF || ret == HASH_ELSE ||
++ ret == HASH_ENDIF || ret == HASH)
++ {
++ parser->in_control_line = 1;
++ }
++ else if (ret == IDENTIFIER)
++ {
++ macro_t *macro;
++ macro = hash_table_find (parser->defines,
++ yylval.str);
++ if (macro && macro->is_function) {
++ parser->newline_as_space = 1;
++ parser->paren_count = 0;
++ }
++ }
++
++ return ret;
++ }
++
++ node = parser->lex_from_node;
++
++ if (node == NULL) {
++ talloc_free (parser->lex_from_list);
++ parser->lex_from_list = NULL;
++ return NEWLINE;
++ }
++
++ yylval = node->token->value;
++ ret = node->token->type;
++
++ parser->lex_from_node = node->next;
++
++ return ret;
++}
++
++static void
++glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list)
++{
++ token_node_t *node;
++
++ assert (parser->lex_from_list == NULL);
++
++ /* Copy list, eliminating any space tokens. */
++ parser->lex_from_list = _token_list_create (parser);
++
++ for (node = list->head; node; node = node->next) {
++ if (node->token->type == SPACE)
++ continue;
++ _token_list_append (parser->lex_from_list, node->token);
++ }
++
++ talloc_free (list);
++
++ parser->lex_from_node = parser->lex_from_list->head;
++
++ /* It's possible the list consisted of nothing but whitespace. */
++ if (parser->lex_from_node == NULL) {
++ talloc_free (parser->lex_from_list);
++ parser->lex_from_list = NULL;
++ }
++}
++
++static void
++_glcpp_parser_skip_stack_push_if (glcpp_parser_t *parser, int condition)
++{
++ skip_type_t current = SKIP_NO_SKIP;
++ skip_node_t *node;
++
++ if (parser->skip_stack)
++ current = parser->skip_stack->type;
++
++ node = xtalloc (parser, skip_node_t);
++
++ if (current == SKIP_NO_SKIP) {
++ if (condition)
++ node->type = SKIP_NO_SKIP;
++ else
++ node->type = SKIP_TO_ELSE;
++ } else {
++ node->type = SKIP_TO_ENDIF;
++ }
++
++ node->next = parser->skip_stack;
++ parser->skip_stack = node;
++}
++
++static void
++_glcpp_parser_skip_stack_change_if (glcpp_parser_t *parser, const char *type,
++ int condition)
++{
++ if (parser->skip_stack == NULL) {
++ fprintf (stderr, "Error: %s without #if\n", type);
++ exit (1);
++ }
++
++ if (parser->skip_stack->type == SKIP_TO_ELSE) {
++ if (condition)
++ parser->skip_stack->type = SKIP_NO_SKIP;
++ } else {
++ parser->skip_stack->type = SKIP_TO_ENDIF;
++ }
++}
++
++static void
++_glcpp_parser_skip_stack_pop (glcpp_parser_t *parser)
++{
++ skip_node_t *node;
++
++ if (parser->skip_stack == NULL) {
++ fprintf (stderr, "Error: #endif without #if\n");
++ exit (1);
++ }
++
++ node = parser->skip_stack;
++ parser->skip_stack = node->next;
++ talloc_free (node);
++}
projects / mesa.git / commitdiff