Lines Matching refs:parser
1 /* A Bison parser, made by GNU Bison 3.2.4. */
21 part or all of the Bison parser skeleton and distribute that work
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
109 yyerror(YYLTYPE *locp, glcpp_parser_t *parser, const char *error);
112 _define_object_macro(glcpp_parser_t *parser,
118 _define_function_macro(glcpp_parser_t *parser,
125 _string_list_create(glcpp_parser_t *parser);
128 _string_list_append_item(glcpp_parser_t *parser, string_list_t *list,
144 _argument_list_create(glcpp_parser_t *parser);
147 _argument_list_append(glcpp_parser_t *parser, argument_list_t *list,
157 _token_create_str(glcpp_parser_t *parser, int type, char *str);
160 _token_create_ival(glcpp_parser_t *parser, int type, int ival);
163 _token_list_create(glcpp_parser_t *parser);
166 _token_list_append(glcpp_parser_t *parser, token_list_t *list, token_t *token);
175 _parser_active_list_push(glcpp_parser_t *parser, const char *identifier,
179 _parser_active_list_pop(glcpp_parser_t *parser);
182 _parser_active_list_contains(glcpp_parser_t *parser, const char *identifier);
193 _glcpp_parser_expand_and_lex_from(glcpp_parser_t *parser, int head_token_type,
198 _glcpp_parser_expand_token_list(glcpp_parser_t *parser, token_list_t *list,
202 _glcpp_parser_print_expanded_token_list(glcpp_parser_t *parser,
206 _glcpp_parser_skip_stack_push_if(glcpp_parser_t *parser, YYLTYPE *loc,
210 _glcpp_parser_skip_stack_change_if(glcpp_parser_t *parser, YYLTYPE *loc,
214 _glcpp_parser_skip_stack_pop(glcpp_parser_t *parser, YYLTYPE *loc);
217 _glcpp_parser_handle_version_declaration(glcpp_parser_t *parser, intmax_t version,
221 glcpp_parser_lex(YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser);
224 glcpp_parser_lex_from(glcpp_parser_t *parser, token_list_t *list);
227 add_builtin_define(glcpp_parser_t *parser, const char *name, int value);
328 int glcpp_parser_parse (glcpp_parser_t *parser);
436 /* The parser invokes alloca or malloc; define the necessary symbols. */
987 yyerror (&yylloc, parser, YY_("syntax error: cannot back up")); \
1089 Type, Value, Location, parser); \
1100 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, glcpp_parser_t *parser)
1105 YYUSE (parser);
1121 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, glcpp_parser_t *parser)
1128 yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, parser);
1161 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, glcpp_parser_t *parser)
1175 , &(yylsp[(yyi + 1) - (yynrhs)]) , parser);
1183 yy_reduce_print (yyssp, yyvsp, yylsp, Rule, parser); \
1197 /* YYINITDEPTH -- initial size of the parser's stacks. */
1338 correct lookahead information, and it depends on the parser not
1442 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, glcpp_parser_t *parser)
1446 YYUSE (parser);
1464 yyparse (glcpp_parser_t *parser)
1669 yychar = yylex (&yylval, &yylloc, parser);
1739 unconditionally makes the parser a bit smaller, and it avoids a
1752 _glcpp_parser_print_expanded_token_list (parser, (yyvsp[0].token_list));
1753 _mesa_string_buffer_append_char(parser->output, '\n');
1761 if (parser->is_gles && (yyvsp[-1].expression_value).undefined_macro)
1762 glcpp_error(& (yylsp[-2]), parser, "undefined macro %s in expression (illegal in GLES)", (yyvsp[-1].expression_value).undefined_macro);
1763 parser, & (yylsp[-2]), (yyvsp[-1].expression_value).value);
1771 if (parser->is_gles && (yyvsp[-1].expression_value).undefined_macro)
1772 glcpp_error(& (yylsp[-2]), parser, "undefined macro %s in expression (illegal in GLES)", (yyvsp[-1].expression_value).undefined_macro);
1773 _glcpp_parser_skip_stack_change_if (parser, & (yylsp[-2]), "elif", (yyvsp[-1].expression_value).value);
1781 parser->has_new_line_number = 1;
1782 parser->new_line_number = (yyvsp[-1].ival);
1783 _mesa_string_buffer_printf(parser->output, "#line %" PRIiMAX "\n", (yyvsp[-1].ival));
1791 parser->has_new_line_number = 1;
1792 parser->new_line_number = (yyvsp[-2].ival);
1793 parser->has_new_source_number = 1;
1794 parser->new_source_number = (yyvsp[-1].ival);
1795 _mesa_string_buffer_printf(parser->output,
1805 _define_object_macro (parser, & (yylsp[-2]), (yyvsp[-2].str), (yyvsp[-1].token_list));
1813 _define_function_macro (parser, & (yylsp[-4]), (yyvsp[-4].str), NULL, (yyvsp[-1].token_list));
1821 _define_function_macro (parser, & (yylsp[-5]), (yyvsp[-5].str), (yyvsp[-3].string_list), (yyvsp[-1].token_list));
1829 _mesa_string_buffer_append_char(parser->output, '\n');
1838 if (parser->skip_stack == NULL ||
1839 parser->skip_stack->type == SKIP_NO_SKIP)
1841 _glcpp_parser_expand_and_lex_from (parser,
1877 glcpp_error(& (yylsp[-3]), parser, "Built-in (pre-defined)"
1880 if (parser->is_gles
1881 && parser->version >= 300
1885 glcpp_error(& (yylsp[-3]), parser, "Built-in (pre-defined)"
1887 } else if (parser->is_gles && parser->version <= 300) {
1888 glcpp_error(& (yylsp[-3]), parser,
1892 glcpp_warning(& (yylsp[-3]), parser,
1898 entry = _mesa_hash_table_search (parser->defines, (yyvsp[-1].str));
1900 _mesa_hash_table_remove (parser->defines, entry);
1916 if (parser->skip_stack == NULL ||
1917 parser->skip_stack->type == SKIP_NO_SKIP)
1919 _glcpp_parser_expand_and_lex_from (parser,
1925 _glcpp_parser_skip_stack_push_if (parser, & (yylsp[-3]), 0);
1926 parser->skip_stack->type = SKIP_TO_ENDIF;
1937 if (parser->skip_stack == NULL ||
1938 parser->skip_stack->type == SKIP_NO_SKIP)
1940 glcpp_error(& (yylsp[-2]), parser, "#if with no expression");
1942 _glcpp_parser_skip_stack_push_if (parser, & (yylsp[-2]), 0);
1951 _mesa_hash_table_search(parser->defines, (yyvsp[-2].str));
1953 _glcpp_parser_skip_stack_push_if (parser, & (yylsp[-4]), macro != NULL);
1962 _mesa_hash_table_search(parser->defines, (yyvsp[-2].str));
1964 _glcpp_parser_skip_stack_push_if (parser, & (yylsp[-2]), macro == NULL);
1979 if (parser->skip_stack &&
1980 parser->skip_stack->type == SKIP_TO_ELSE)
1982 _glcpp_parser_expand_and_lex_from (parser,
1986 else if (parser->skip_stack &&
1987 parser->skip_stack->has_else)
1989 glcpp_error(& (yylsp[-3]), parser, "#elif after #else");
1993 _glcpp_parser_skip_stack_change_if (parser, & (yylsp[-3]),
2005 if (parser->skip_stack &&
2006 parser->skip_stack->type == SKIP_TO_ELSE)
2008 glcpp_error(& (yylsp[-2]), parser, "#elif with no expression");
2010 else if (parser->skip_stack &&
2011 parser->skip_stack->has_else)
2013 glcpp_error(& (yylsp[-2]), parser, "#elif after #else");
2017 _glcpp_parser_skip_stack_change_if (parser, & (yylsp[-2]),
2019 glcpp_warning(& (yylsp[-2]), parser, "ignoring illegal #elif without expression");
2027 { parser->lexing_directive = 1; }
2034 if (parser->skip_stack &&
2035 parser->skip_stack->has_else)
2037 glcpp_error(& (yylsp[-3]), parser, "multiple #else");
2041 _glcpp_parser_skip_stack_change_if (parser, & (yylsp[-3]), "else", 1);
2042 if (parser->skip_stack)
2043 parser->skip_stack->has_else = true;
2052 _glcpp_parser_skip_stack_pop (parser, & (yylsp[-1]));
2060 if (parser->version_set) {
2061 glcpp_error(& (yylsp[-3]), parser, "#version must appear on the first line");
2063 _glcpp_parser_handle_version_declaration(parser, (yyvsp[-1].ival), NULL, true);
2071 if (parser->version_set) {
2072 glcpp_error(& (yylsp[-4]), parser, "#version must appear on the first line");
2074 _glcpp_parser_handle_version_declaration(parser, (yyvsp[-2].ival), (yyvsp[-1].str), true);
2082 glcpp_parser_resolve_implicit_version(parser);
2090 _mesa_string_buffer_printf(parser->output, "#%s", (yyvsp[-1].str));
2098 glcpp_error(& (yylsp[-2]), parser, "#%s", (yyvsp[-1].str));
2106 glcpp_error (& (yylsp[-2]), parser, "#define without macro name");
2114 glcpp_error (& (yylsp[-3]), parser, "Illegal non-directive after #");
2141 glcpp_error(&(yylsp[0]), parser, "invalid #version \"%s\" (not a decimal constant)", (yyvsp[0].str));
2163 if (parser->is_gles)
2164 (yyval.expression_value).undefined_macro = linear_strdup(parser->linalloc, (yyvsp[0].str));
2363 yyerror (& (yylsp[-2]), parser,
2380 yyerror (& (yylsp[-2]), parser,
2452 (yyval.string_list) = _string_list_create (parser);
2453 _string_list_append_item (parser, (yyval.string_list), (yyvsp[0].str));
2462 _string_list_append_item (parser, (yyval.string_list), (yyvsp[0].str));
2482 glcpp_error(&(yylsp[0]), parser, "extra tokens at end of directive");
2490 parser->space_tokens = 1;
2491 (yyval.token_list) = _token_list_create (parser);
2492 _token_list_append (parser, (yyval.token_list), (yyvsp[0].token));
2501 _token_list_append (parser, (yyval.token_list), (yyvsp[0].token));
2509 (yyval.token) = _token_create_str (parser, IDENTIFIER, (yyvsp[0].str));
2518 (yyval.token) = _token_create_str (parser, INTEGER_STRING, (yyvsp[0].str));
2527 (yyval.token) = _token_create_ival (parser, (yyvsp[0].ival), (yyvsp[0].ival));
2536 (yyval.token) = _token_create_ival (parser, DEFINED, DEFINED);
2545 (yyval.token) = _token_create_str (parser, OTHER, (yyvsp[0].str));
2554 (yyval.token) = _token_create_ival (parser, SPACE, SPACE);
2770 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2809 yyerror (&yylloc, parser, YY_("syntax error"));
2836 yyerror (&yylloc, parser, yymsgp);
2860 yytoken, &yylval, &yylloc, parser);
2916 yystos[yystate], yyvsp, yylsp, parser);
2958 yyerror (&yylloc, parser, YY_("memory exhausted"));
2970 yytoken, &yylval, &yylloc, parser);
2979 yystos[*yyssp], yyvsp, yylsp, parser);
2996 _string_list_create(glcpp_parser_t *parser)
3000 list = linear_alloc_child(parser->linalloc, sizeof(string_list_t));
3008 _string_list_append_item(glcpp_parser_t *parser, string_list_t *list,
3013 node = linear_alloc_child(parser->linalloc, sizeof(string_node_t));
3014 node->str = linear_strdup(parser->linalloc, str);
3107 _argument_list_create(glcpp_parser_t *parser)
3111 list = linear_alloc_child(parser->linalloc, sizeof(argument_list_t));
3119 _argument_list_append(glcpp_parser_t *parser,
3124 node = linear_alloc_child(parser->linalloc, sizeof(argument_node_t));
3176 _token_create_str(glcpp_parser_t *parser, int type, char *str)
3180 token = linear_alloc_child(parser->linalloc, sizeof(token_t));
3188 _token_create_ival(glcpp_parser_t *parser, int type, int ival)
3192 token = linear_alloc_child(parser->linalloc, sizeof(token_t));
3200 _token_list_create(glcpp_parser_t *parser)
3204 list = linear_alloc_child(parser->linalloc, sizeof(token_list_t));
3213 _token_list_append(glcpp_parser_t *parser, token_list_t *list, token_t *token)
3217 node = linear_alloc_child(parser->linalloc, sizeof(token_node_t));
3249 _token_list_copy(glcpp_parser_t *parser, token_list_t *other)
3257 copy = _token_list_create (parser);
3259 token_t *new_token = linear_alloc_child(parser->linalloc, sizeof(token_t));
3261 _token_list_append (parser, copy, new_token);
3436 _token_paste(glcpp_parser_t *parser, token_t *token, token_t *other)
3453 combined = _token_create_ival (parser, LEFT_SHIFT, LEFT_SHIFT);
3455 combined = _token_create_ival (parser, LESS_OR_EQUAL, LESS_OR_EQUAL);
3459 combined = _token_create_ival (parser, RIGHT_SHIFT, RIGHT_SHIFT);
3461 combined = _token_create_ival (parser, GREATER_OR_EQUAL, GREATER_OR_EQUAL);
3465 combined = _token_create_ival (parser, EQUAL, EQUAL);
3469 combined = _token_create_ival (parser, NOT_EQUAL, NOT_EQUAL);
3473 combined = _token_create_ival (parser, AND, AND);
3477 combined = _token_create_ival (parser, OR, OR);
3521 str = linear_asprintf(parser->linalloc, "%" PRIiMAX, token->value.ival);
3523 str = linear_strdup(parser->linalloc, token->value.str);
3526 linear_asprintf_append(parser->linalloc, &str, "%" PRIiMAX, other->value.ival);
3528 linear_strcat(parser->linalloc, &str, other->value.str);
3537 combined = _token_create_str (parser, combined_type, str);
3543 glcpp_error (&token->location, parser, "");
3544 _mesa_string_buffer_append(parser->info_log, "Pasting \"");
3545 _token_print(parser->info_log, token);
3546 _mesa_string_buffer_append(parser->info_log, "\" and \"");
3547 _token_print(parser->info_log, other);
3548 _mesa_string_buffer_append(parser->info_log, "\" does not give a valid preprocessing token.\n");
3554 _token_list_print(glcpp_parser_t *parser, token_list_t *list)
3562 _token_print(parser->output, node->token);
3566 yyerror(YYLTYPE *locp, glcpp_parser_t *parser, const char *error)
3568 glcpp_error(locp, parser, "%s", error);
3572 add_builtin_define(glcpp_parser_t *parser, const char *name, int value)
3577 tok = _token_create_ival (parser, INTEGER, value);
3579 list = _token_list_create(parser);
3580 _token_list_append(parser, list, tok);
3581 _define_object_macro(parser, NULL, name, list);
3593 glcpp_parser_t *parser;
3595 parser = ralloc (NULL, glcpp_parser_t);
3597 glcpp_lex_init_extra (parser, &parser->scanner);
3598 parser->defines = _mesa_hash_table_create(NULL, _mesa_key_hash_string,
3600 parser->linalloc = linear_alloc_parent(parser, 0);
3601 parser->active = NULL;
3602 parser->lexing_directive = 0;
3603 parser->lexing_version_directive = 0;
3604 parser->space_tokens = 1;
3605 parser->last_token_was_newline = 0;
3606 parser->last_token_was_space = 0;
3607 parser->first_non_space_token_this_line = 1;
3608 parser->newline_as_space = 0;
3609 parser->in_control_line = 0;
3610 parser->paren_count = 0;
3611 parser->commented_newlines = 0;
3613 parser->skip_stack = NULL;
3614 parser->skipping = 0;
3616 parser->lex_from_list = NULL;
3617 parser->lex_from_node = NULL;
3619 parser->output = _mesa_string_buffer_create(parser,
3621 parser->info_log = _mesa_string_buffer_create(parser,
3623 parser->error = 0;
3625 parser->extensions = extensions;
3626 parser->extension_list = extension_list;
3627 parser->state = state;
3628 parser->api = api;
3629 parser->version = 0;
3630 parser->version_set = false;
3632 parser->has_new_line_number = 0;
3633 parser->new_line_number = 1;
3634 parser->has_new_source_number = 0;
3635 parser->new_source_number = 0;
3637 parser->is_gles = false;
3639 return parser;
3643 glcpp_parser_destroy(glcpp_parser_t *parser)
3645 glcpp_lex_destroy (parser->scanner);
3646 _mesa_hash_table_destroy(parser->defines, NULL);
3647 ralloc_free (parser);
3681 _arguments_parse(glcpp_parser_t *parser,
3699 argument = _token_list_create (parser);
3700 _argument_list_append (parser, arguments, argument);
3713 argument = _token_list_create (parser);
3714 _argument_list_append (parser, arguments, argument);
3721 _token_list_append(parser, argument, node->token);
3734 _token_list_create_with_one_ival(glcpp_parser_t *parser, int type, int ival)
3739 list = _token_list_create(parser);
3740 node = _token_create_ival(parser, type, ival);
3741 _token_list_append(parser, list, node);
3747 _token_list_create_with_one_space(glcpp_parser_t *parser)
3749 return _token_list_create_with_one_ival(parser, SPACE, SPACE);
3753 _token_list_create_with_one_integer(glcpp_parser_t *parser, int ival)
3755 return _token_list_create_with_one_ival(parser, INTEGER, ival);
3780 _glcpp_parser_evaluate_defined(glcpp_parser_t *parser, token_node_t *node,
3826 return _mesa_hash_table_search(parser->defines,
3830 glcpp_error (&defined->token->location, parser,
3838 _glcpp_parser_evaluate_defined_in_list(glcpp_parser_t *parser,
3855 value = _glcpp_parser_evaluate_defined (parser, node, &last);
3859 replacement = linear_alloc_child(parser->linalloc, sizeof(token_node_t));
3860 replacement->token = _token_create_ival (parser, INTEGER, value);
3889 _glcpp_parser_expand_and_lex_from(glcpp_parser_t *parser, int head_token_type,
3895 expanded = _token_list_create (parser);
3896 token = _token_create_ival (parser, head_token_type, head_token_type);
3897 _token_list_append (parser, expanded, token);
3898 _glcpp_parser_expand_token_list (parser, list, mode);
3900 glcpp_parser_lex_from (parser, expanded);
3904 _glcpp_parser_apply_pastes(glcpp_parser_t *parser, token_list_t *list)
3931 yyerror(&node->token->location, parser, "'##' cannot appear at either end of a macro expansion\n");
3935 node->token = _token_paste(parser, node->token, next_non_space->token);
3965 _glcpp_parser_expand_function(glcpp_parser_t *parser, token_node_t *node,
3978 entry = _mesa_hash_table_search(parser->defines, identifier);
3983 arguments = _argument_list_create(parser);
3984 status = _arguments_parse(parser, arguments, node, last);
3992 glcpp_error(&node->token->location, parser, "Macro %s call has unbalanced parentheses\n", identifier);
3998 return _token_list_create_with_one_space(parser);
4006 glcpp_error(&node->token->location, parser,
4014 substituted = _token_list_create(parser);
4026 expanded_argument = _token_list_copy(parser, argument);
4027 _glcpp_parser_expand_token_list(parser, expanded_argument, mode);
4032 new_token = _token_create_ival(parser, PLACEHOLDER,
4034 _token_list_append(parser, substituted, new_token);
4037 _token_list_append(parser, substituted, node->token);
4046 _glcpp_parser_apply_pastes(parser, substituted);
4070 _glcpp_parser_expand_node(glcpp_parser_t *parser, token_node_t *node,
4090 return _token_list_create_with_one_integer(parser,
4094 return _token_list_create_with_one_integer(parser,
4099 entry = _mesa_hash_table_search(parser->defines, identifier);
4108 if (_parser_active_list_contains (parser, identifier)) {
4115 str = linear_strdup(parser->linalloc, token->value.str);
4116 final = _token_create_str(parser, OTHER, str);
4117 expansion = _token_list_create(parser);
4118 _token_list_append(parser, expansion, final);
4127 return _token_list_create_with_one_space(parser);
4129 replacement = _token_list_copy(parser, macro->replacements);
4130 _glcpp_parser_apply_pastes(parser, replacement);
4134 return _glcpp_parser_expand_function(parser, node, last, mode);
4137 /* Push a new identifier onto the parser's active list.
4145 _parser_active_list_push(glcpp_parser_t *parser, const char *identifier,
4150 node = linear_alloc_child(parser->linalloc, sizeof(active_list_t));
4151 node->identifier = linear_strdup(parser->linalloc, identifier);
4153 node->next = parser->active;
4155 parser->active = node;
4159 _parser_active_list_pop(glcpp_parser_t *parser)
4161 active_list_t *node = parser->active;
4164 parser->active = NULL;
4168 node = parser->active->next;
4169 parser->active = node;
4173 _parser_active_list_contains(glcpp_parser_t *parser, const char *identifier)
4177 if (parser->active == NULL)
4180 for (node = parser->active; node; node = node->next)
4209 _glcpp_parser_expand_token_list(glcpp_parser_t *parser, token_list_t *list,
4215 active_list_t *active_initial = parser->active;
4226 _glcpp_parser_evaluate_defined_in_list (parser, list);
4230 while (parser->active && parser->active->marker == node)
4231 _parser_active_list_pop (parser);
4233 expansion = _glcpp_parser_expand_node (parser, node, &last, mode);
4238 _glcpp_parser_evaluate_defined_in_list (parser, expansion);
4242 while (parser->active && parser->active->marker == n) {
4243 _parser_active_list_pop (parser);
4246 _parser_active_list_push(parser, node->token->value.str, last->next);
4276 while (parser->active && parser->active != active_initial)
4277 _parser_active_list_pop (parser);
4283 _glcpp_parser_print_expanded_token_list(glcpp_parser_t *parser,
4289 _glcpp_parser_expand_token_list (parser, list, EXPANSION_MODE_IGNORE_DEFINED);
4293 _token_list_print (parser, list);
4297 _check_for_reserved_macro_name(glcpp_parser_t *parser, YYLTYPE *loc,
4318 glcpp_warning(loc, parser, "Macro names containing \"__\" are reserved "
4322 glcpp_error (loc, parser, "Macro names starting with \"GL_\" are reserved.\n");
4325 glcpp_error (loc, parser, "\"defined\" cannot be used as a macro name");
4344 _define_object_macro(glcpp_parser_t *parser, YYLTYPE *loc,
4354 _check_for_reserved_macro_name(parser, loc, identifier);
4356 macro = linear_alloc_child(parser->linalloc, sizeof(macro_t));
4360 macro->identifier = linear_strdup(parser->linalloc, identifier);
4363 entry = _mesa_hash_table_search(parser->defines, identifier);
4369 glcpp_error (loc, parser, "Redefinition of macro %s\n", identifier);
4372 _mesa_hash_table_insert (parser->defines, identifier, macro);
4376 _define_function_macro(glcpp_parser_t *parser, YYLTYPE *loc,
4384 _check_for_reserved_macro_name(parser, loc, identifier);
4388 glcpp_error (loc, parser, "Duplicate macro parameter \"%s\"", dup);
4391 macro = linear_alloc_child(parser->linalloc, sizeof(macro_t));
4395 macro->identifier = linear_strdup(parser->linalloc, identifier);
4398 entry = _mesa_hash_table_search(parser->defines, identifier);
4404 glcpp_error (loc, parser, "Redefinition of macro %s\n", identifier);
4407 _mesa_hash_table_insert(parser->defines, identifier, macro);
4411 glcpp_parser_lex(YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser)
4416 if (parser->lex_from_list == NULL) {
4417 ret = glcpp_lex(yylval, yylloc, parser->scanner);
4431 if (parser->newline_as_space) {
4433 parser->paren_count++;
4435 parser->paren_count--;
4436 if (parser->paren_count == 0)
4437 parser->newline_as_space = 0;
4441 if (parser->paren_count == 0)
4442 parser->newline_as_space = 0;
4444 } else if (parser->in_control_line) {
4446 parser->in_control_line = 0;
4451 parser->in_control_line = 1;
4453 struct hash_entry *entry = _mesa_hash_table_search(parser->defines,
4457 parser->newline_as_space = 1;
4458 parser->paren_count = 0;
4465 node = parser->lex_from_node;
4468 parser->lex_from_list = NULL;
4475 parser->lex_from_node = node->next;
4481 glcpp_parser_lex_from(glcpp_parser_t *parser, token_list_t *list)
4485 assert (parser->lex_from_list == NULL);
4488 parser->lex_from_list = _token_list_create (parser);
4493 _token_list_append (parser, parser->lex_from_list, node->token);
4496 parser->lex_from_node = parser->lex_from_list->head;
4499 if (parser->lex_from_node == NULL) {
4500 parser->lex_from_list = NULL;
4505 _glcpp_parser_skip_stack_push_if(glcpp_parser_t *parser, YYLTYPE *loc,
4511 if (parser->skip_stack)
4512 current = parser->skip_stack->type;
4514 node = linear_alloc_child(parser->linalloc, sizeof(skip_node_t));
4527 node->next = parser->skip_stack;
4528 parser->skip_stack = node;
4532 _glcpp_parser_skip_stack_change_if(glcpp_parser_t *parser, YYLTYPE *loc,
4535 if (parser->skip_stack == NULL) {
4536 glcpp_error (loc, parser, "#%s without #if\n", type);
4540 if (parser->skip_stack->type == SKIP_TO_ELSE) {
4542 parser->skip_stack->type = SKIP_NO_SKIP;
4544 parser->skip_stack->type = SKIP_TO_ENDIF;
4549 _glcpp_parser_skip_stack_pop(glcpp_parser_t *parser, YYLTYPE *loc)
4553 if (parser->skip_stack == NULL) {
4554 glcpp_error (loc, parser, "#endif without #if\n");
4558 node = parser->skip_stack;
4559 parser->skip_stack = node->next;
4563 _glcpp_parser_handle_version_declaration(glcpp_parser_t *parser, intmax_t version,
4567 if (parser->version_set)
4570 parser->version = version;
4571 parser->version_set = true;
4573 add_builtin_define (parser, "__VERSION__", version);
4575 parser->is_gles = (version == 100) ||
4581 if (parser->is_gles)
4582 add_builtin_define(parser, "GL_ES", 1);
4584 add_builtin_define(parser, "GL_compatibility_profile", 1);
4586 add_builtin_define(parser, "GL_core_profile", 1);
4593 if (version >= 130 || parser->is_gles)
4594 add_builtin_define (parser, "GL_FRAGMENT_PRECISION_HIGH", 1);
4597 if (parser->extensions)
4598 parser->extensions(parser->state, add_builtin_define, parser,
4599 version, parser->is_gles);
4601 if (parser->extension_list) {
4606 if (parser->extension_list->MESA_shader_integer_functions) {
4607 add_builtin_define(parser, "__have_builtin_builtin_sign64", 1);
4608 add_builtin_define(parser, "__have_builtin_builtin_umul64", 1);
4609 add_builtin_define(parser, "__have_builtin_builtin_udiv64", 1);
4610 add_builtin_define(parser, "__have_builtin_builtin_umod64", 1);
4611 add_builtin_define(parser, "__have_builtin_builtin_idiv64", 1);
4612 add_builtin_define(parser, "__have_builtin_builtin_imod64", 1);
4617 _mesa_string_buffer_printf(parser->output,
4631 glcpp_parser_resolve_implicit_version(glcpp_parser_t *parser)
4633 int language_version = parser->api == API_OPENGLES2 ?
4636 _glcpp_parser_handle_version_declaration(parser, language_version,
Indexes created Sun Apr 12 00:22:20 UTC 2026