glsl/glcpp: Drop the HASH_ prefix from token names like HASH_IF

Previously, we had a single token for "#if" but now that we have two separate
tokens, it looks much better to see:

	HASH_TOKEN IF

than:

	HASH_TOKEN HASH_IF

(Note, that for the same reason we use HASH_TOKEN instead of HASH, we also use
DEFINE_TOKEN instead of DEFINE to avoid a conflict with the <DEFINE> start
condition in the lexer.)

There should be no behavioral change from this commit.

Reviewed-by: Jordan Justen <jordan.l.justen@intel.com>

diff --git a/src/glsl/glcpp/glcpp-lex.l b/src/glsl/glcpp/glcpp-lex.l
index 60bc0800b2d3add43060da323b75bfb556a3f9c2..466f4386053454d8095c8f4bb64b4ee2b96f779b 100644 (file)
--- a/src/glsl/glcpp/glcpp-lex.l
+++ b/src/glsl/glcpp/glcpp-lex.l
@@ -280,7 +280,7 @@ HEXADECIMAL_INTEGER 0[xX][0-9a-fA-F]+[uU]?
 <HASH>version{HSPACE}+ {
        BEGIN INITIAL;
        yyextra->space_tokens = 0;
-       RETURN_STRING_TOKEN (HASH_VERSION);
+       RETURN_STRING_TOKEN (VERSION_TOKEN);
 }
 
        /* glcpp doesn't handle #extension, #version, or #pragma directives.
@@ -289,12 +289,12 @@ HEXADECIMAL_INTEGER       0[xX][0-9a-fA-F]+[uU]?
        BEGIN INITIAL;
        yylineno++;
        yycolumn = 0;
-       RETURN_STRING_TOKEN (HASH_PRAGMA);
+       RETURN_STRING_TOKEN (PRAGMA);
 }
 
 <HASH>line{HSPACE}+ {
        BEGIN INITIAL;
-       RETURN_TOKEN (HASH_LINE);
+       RETURN_TOKEN (LINE);
 }
 
 <HASH>\n {
@@ -308,45 +308,45 @@ HEXADECIMAL_INTEGER       0[xX][0-9a-fA-F]+[uU]?
        BEGIN INITIAL;
        yyextra->lexing_directive = 1;
        yyextra->space_tokens = 0;
-       RETURN_TOKEN_NEVER_SKIP (HASH_IFDEF);
+       RETURN_TOKEN_NEVER_SKIP (IFDEF);
 }
 
 <HASH>ifndef {
        BEGIN INITIAL;
        yyextra->lexing_directive = 1;
        yyextra->space_tokens = 0;
-       RETURN_TOKEN_NEVER_SKIP (HASH_IFNDEF);
+       RETURN_TOKEN_NEVER_SKIP (IFNDEF);
 }
 
 <HASH>if/[^_a-zA-Z0-9] {
        BEGIN INITIAL;
        yyextra->lexing_directive = 1;
        yyextra->space_tokens = 0;
-       RETURN_TOKEN_NEVER_SKIP (HASH_IF);
+       RETURN_TOKEN_NEVER_SKIP (IF);
 }
 
 <HASH>elif/[^_a-zA-Z0-9] {
        BEGIN INITIAL;
        yyextra->lexing_directive = 1;
        yyextra->space_tokens = 0;
-       RETURN_TOKEN_NEVER_SKIP (HASH_ELIF);
+       RETURN_TOKEN_NEVER_SKIP (ELIF);
 }
 
 <HASH>else {
        BEGIN INITIAL;
        yyextra->space_tokens = 0;
-       RETURN_TOKEN_NEVER_SKIP (HASH_ELSE);
+       RETURN_TOKEN_NEVER_SKIP (ELSE);
 }
 
 <HASH>endif {
        BEGIN INITIAL;
        yyextra->space_tokens = 0;
-       RETURN_TOKEN_NEVER_SKIP (HASH_ENDIF);
+       RETURN_TOKEN_NEVER_SKIP (ENDIF);
 }
 
 <HASH>error.* {
        BEGIN INITIAL;
-       RETURN_STRING_TOKEN (HASH_ERROR);
+       RETURN_STRING_TOKEN (ERROR);
 }
 
        /* After we see a "#define" we enter the <DEFINE> start state
@@ -371,14 +371,14 @@ HEXADECIMAL_INTEGER       0[xX][0-9a-fA-F]+[uU]?
        if (! parser->skipping) {
                BEGIN DEFINE;
                yyextra->space_tokens = 0;
-               RETURN_TOKEN (HASH_DEFINE);
+               RETURN_TOKEN (DEFINE_TOKEN);
        }
 }
 
 <HASH>undef {
        BEGIN INITIAL;
        yyextra->space_tokens = 0;
-       RETURN_TOKEN (HASH_UNDEF);
+       RETURN_TOKEN (UNDEF);
 }
 
 <HASH>{HSPACE}+ {
@@ -390,7 +390,7 @@ HEXADECIMAL_INTEGER 0[xX][0-9a-fA-F]+[uU]?
        /* This will catch any non-directive garbage after a HASH */
 <HASH>{NONSPACE} {
        BEGIN INITIAL;
-       RETURN_TOKEN (HASH_GARBAGE);
+       RETURN_TOKEN (GARBAGE);
 }
 
        /* An identifier immediately followed by '(' */

diff --git a/src/glsl/glcpp/glcpp-parse.y b/src/glsl/glcpp/glcpp-parse.y
index 2952bf84d8dfa56c89274d48378d004b2f845cfc..9b753ddecd4e06f211b937f1c85f1130a814965e 100644 (file)
--- a/src/glsl/glcpp/glcpp-parse.y
+++ b/src/glsl/glcpp/glcpp-parse.y
@@ -165,13 +165,14 @@ add_builtin_define(glcpp_parser_t *parser, const char *name, int value);
 
 %expect 0
 
-       /* We use HASH_TOKEN, not HASH to avoid a conflict with the <HASH>
-         * start condition in the lexer. */
-%token COMMA_FINAL DEFINED ELIF_EXPANDED HASH_TOKEN HASH_DEFINE FUNC_IDENTIFIER OBJ_IDENTIFIER HASH_ELIF HASH_ELSE HASH_ENDIF HASH_ERROR HASH_IF HASH_IFDEF HASH_IFNDEF HASH_LINE HASH_PRAGMA HASH_UNDEF HASH_VERSION HASH_GARBAGE IDENTIFIER IF_EXPANDED INTEGER INTEGER_STRING LINE_EXPANDED NEWLINE OTHER PLACEHOLDER SPACE
+       /* We use HASH_TOKEN, DEFINE_TOKEN and VERSION_TOKEN (as opposed to
+         * HASH, DEFINE, and VERSION) to avoid conflicts with other symbols,
+         * (such as the <HASH> and <DEFINE> start conditions in the lexer). */
+%token COMMA_FINAL DEFINED ELIF_EXPANDED HASH_TOKEN DEFINE_TOKEN FUNC_IDENTIFIER OBJ_IDENTIFIER ELIF ELSE ENDIF ERROR IF IFDEF IFNDEF LINE PRAGMA UNDEF VERSION_TOKEN GARBAGE IDENTIFIER IF_EXPANDED INTEGER INTEGER_STRING LINE_EXPANDED NEWLINE OTHER PLACEHOLDER SPACE
 %token PASTE
 %type <ival> INTEGER operator SPACE integer_constant
 %type <expression_value> expression
-%type <str> IDENTIFIER FUNC_IDENTIFIER OBJ_IDENTIFIER INTEGER_STRING OTHER HASH_ERROR HASH_PRAGMA
+%type <str> IDENTIFIER FUNC_IDENTIFIER OBJ_IDENTIFIER INTEGER_STRING OTHER ERROR PRAGMA
 %type <string_list> identifier_list
 %type <token> preprocessing_token conditional_token
 %type <token_list> pp_tokens replacement_list text_line conditional_tokens
@@ -255,7 +256,7 @@ control_line:
                ralloc_asprintf_rewrite_tail (&parser->output, &parser->output_length, "\n");
        }
 |      control_line_error
-|      HASH_TOKEN HASH_LINE {
+|      HASH_TOKEN LINE {
                glcpp_parser_resolve_implicit_version(parser);
        } pp_tokens NEWLINE {
 
@@ -269,10 +270,10 @@ control_line:
 ;
 
 control_line_success:
-       HASH_TOKEN HASH_DEFINE {
+       HASH_TOKEN DEFINE_TOKEN {
                glcpp_parser_resolve_implicit_version(parser);
        } define
-|      HASH_TOKEN HASH_UNDEF {
+|      HASH_TOKEN UNDEF {
                glcpp_parser_resolve_implicit_version(parser);
        } IDENTIFIER NEWLINE {
                macro_t *macro;
@@ -289,7 +290,7 @@ control_line_success:
                }
                ralloc_free ($4);
        }
-|      HASH_TOKEN HASH_IF {
+|      HASH_TOKEN IF {
                glcpp_parser_resolve_implicit_version(parser);
        } conditional_tokens NEWLINE {
                /* Be careful to only evaluate the 'if' expression if
@@ -311,7 +312,7 @@ control_line_success:
                        parser->skip_stack->type = SKIP_TO_ENDIF;
                }
        }
-|      HASH_TOKEN HASH_IF NEWLINE {
+|      HASH_TOKEN IF NEWLINE {
                /* #if without an expression is only an error if we
                 *  are not skipping */
                if (parser->skip_stack == NULL ||
@@ -321,21 +322,21 @@ control_line_success:
                }       
                _glcpp_parser_skip_stack_push_if (parser, & @1, 0);
        }
-|      HASH_TOKEN HASH_IFDEF {
+|      HASH_TOKEN IFDEF {
                glcpp_parser_resolve_implicit_version(parser);
        } IDENTIFIER junk NEWLINE {
                macro_t *macro = hash_table_find (parser->defines, $4);
                ralloc_free ($4);
                _glcpp_parser_skip_stack_push_if (parser, & @1, macro != NULL);
        }
-|      HASH_TOKEN HASH_IFNDEF {
+|      HASH_TOKEN IFNDEF {
                glcpp_parser_resolve_implicit_version(parser);
        } IDENTIFIER junk NEWLINE {
                macro_t *macro = hash_table_find (parser->defines, $4);
                ralloc_free ($4);
                _glcpp_parser_skip_stack_push_if (parser, & @3, macro == NULL);
        }
-|      HASH_TOKEN HASH_ELIF conditional_tokens NEWLINE {
+|      HASH_TOKEN ELIF conditional_tokens NEWLINE {
                /* Be careful to only evaluate the 'elif' expression
                 * if we are not skipping. When we are skipping, we
                 * simply change to a 0-valued 'elif' on the skip
@@ -360,7 +361,7 @@ control_line_success:
                                                            "elif", 0);
                }
        }
-|      HASH_TOKEN HASH_ELIF NEWLINE {
+|      HASH_TOKEN ELIF NEWLINE {
                /* #elif without an expression is an error unless we
                 * are skipping. */
                if (parser->skip_stack &&
@@ -380,7 +381,7 @@ control_line_success:
                        glcpp_warning(& @1, parser, "ignoring illegal #elif without expression");
                }
        }
-|      HASH_TOKEN HASH_ELSE { parser->lexing_directive = 1; } NEWLINE {
+|      HASH_TOKEN ELSE { parser->lexing_directive = 1; } NEWLINE {
                if (parser->skip_stack &&
                    parser->skip_stack->has_else)
                {
@@ -393,16 +394,16 @@ control_line_success:
                                parser->skip_stack->has_else = true;
                }
        }
-|      HASH_TOKEN HASH_ENDIF {
+|      HASH_TOKEN ENDIF {
                _glcpp_parser_skip_stack_pop (parser, & @1);
        } NEWLINE
-|      HASH_TOKEN HASH_VERSION integer_constant NEWLINE {
+|      HASH_TOKEN VERSION_TOKEN integer_constant NEWLINE {
                if (parser->version_resolved) {
                        glcpp_error(& @1, parser, "#version must appear on the first line");
                }
                _glcpp_parser_handle_version_declaration(parser, $3, NULL, true);
        }
-|      HASH_TOKEN HASH_VERSION integer_constant IDENTIFIER NEWLINE {
+|      HASH_TOKEN VERSION_TOKEN integer_constant IDENTIFIER NEWLINE {
                if (parser->version_resolved) {
                        glcpp_error(& @1, parser, "#version must appear on the first line");
                }
@@ -411,16 +412,16 @@ control_line_success:
 |      HASH_TOKEN NEWLINE {
                glcpp_parser_resolve_implicit_version(parser);
        }
-|      HASH_TOKEN HASH_PRAGMA NEWLINE {
+|      HASH_TOKEN PRAGMA NEWLINE {
                ralloc_asprintf_rewrite_tail (&parser->output, &parser->output_length, "#%s", $2);
        }
 ;
 
 control_line_error:
-       HASH_TOKEN HASH_ERROR NEWLINE {
+       HASH_TOKEN ERROR NEWLINE {
                glcpp_error(& @1, parser, "#%s", $2);
        }
-|      HASH_TOKEN HASH_GARBAGE pp_tokens NEWLINE  {
+|      HASH_TOKEN GARBAGE pp_tokens NEWLINE  {
                glcpp_error (& @1, parser, "Illegal non-directive after #");
        }
 ;
@@ -2040,11 +2041,11 @@ glcpp_parser_lex (YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser)
                        if (ret == NEWLINE)
                                parser->in_control_line = 0;
                }
-               else if (ret == HASH_DEFINE ||
-                          ret == HASH_UNDEF || ret == HASH_IF ||
-                          ret == HASH_IFDEF || ret == HASH_IFNDEF ||
-                          ret == HASH_ELIF || ret == HASH_ELSE ||
-                          ret == HASH_ENDIF || ret == HASH_TOKEN)
+               else if (ret == DEFINE_TOKEN ||
+                        ret == UNDEF || ret == IF ||
+                        ret == IFDEF || ret == IFNDEF ||
+                        ret == ELIF || ret == ELSE ||
+                        ret == ENDIF || ret == HASH_TOKEN)
                {
                        parser->in_control_line = 1;
                }