vkd3d/libs/vkd3d-shader/preproc.l

903 lines
30 KiB
Plaintext
Raw Permalink Normal View History

/*
* HLSL preprocessor
*
* Copyright 2020 Zebediah Figura for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
%{
#include "preproc.tab.h"
#undef ERROR /* defined in wingdi.h */
#define YYSTYPE PREPROC_YYSTYPE
#define YYLTYPE PREPROC_YYLTYPE
#define YY_DECL static int preproc_lexer_lex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param, yyscan_t yyscanner)
static struct preproc_expansion *preproc_get_top_expansion(struct preproc_ctx *ctx)
{
if (!ctx->expansion_count)
return NULL;
return &ctx->expansion_stack[ctx->expansion_count - 1];
}
static void update_location(struct preproc_ctx *ctx);
#define YY_USER_ACTION update_location(yyget_extra(yyscanner));
%}
%option 8bit
%option bison-bridge
%option bison-locations
%option extra-type="struct preproc_ctx *"
%option never-interactive
%option nodefault
%option noinput
%option nounput
%option noyy_top_state
%option noyywrap
%option prefix="preproc_yy"
%option reentrant
%option stack
/* Because these can both be terminated by EOF, we need states for them. */
%s C_COMMENT
%s CXX_COMMENT
%s ERROR
%s INCLUDE
%s LINE
NEWLINE \r?\n
WS [ \t\r]
IDENTIFIER (::)?[A-Za-z_]((::)?[A-Za-z0-9_]+)*
INT_SUFFIX [uUlL]{0,2}
%%
<INITIAL>"//" {yy_push_state(CXX_COMMENT, yyscanner);}
<INITIAL>"/*" {yy_push_state(C_COMMENT, yyscanner);}
<CXX_COMMENT>\\{NEWLINE} {}
<CXX_COMMENT>\n {
yy_pop_state(yyscanner);
BEGIN(INITIAL);
return T_NEWLINE;
}
<C_COMMENT>"*/" {yy_pop_state(yyscanner);}
<C_COMMENT,CXX_COMMENT><<EOF>> {yy_pop_state(yyscanner);}
<C_COMMENT,CXX_COMMENT>. {}
<C_COMMENT>\n {}
<ERROR>(\\{NEWLINE}|[^\n])* {return T_STRING;}
<INITIAL>defined/\( {return T_DEFINED;}
<INITIAL>defined {return T_DEFINED;}
<INITIAL>{IDENTIFIER}/\( {return T_IDENTIFIER_PAREN;}
<INITIAL>{IDENTIFIER} {return T_IDENTIFIER;}
<INITIAL>"<=" {return T_LE;}
<INITIAL>">=" {return T_GE;}
<INITIAL>"==" {return T_EQ;}
<INITIAL>"!=" {return T_NE;}
<INITIAL>"&&" {return T_AND;}
<INITIAL>"||" {return T_OR;}
/* We have no use for floats, but shouldn't parse them as integers. */
<INITIAL>[0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[hHfF]? {return T_TEXT;}
<INITIAL>[0-9]+\.([eE][+-]?[0-9]+)?[hHfF]? {return T_TEXT;}
<INITIAL>[0-9]+([eE][+-]?[0-9]+)?[hHfF] {return T_TEXT;}
<INITIAL>[0-9]+[eE][+-]?[0-9]+ {return T_TEXT;}
<INITIAL,LINE>0[xX][0-9a-fA-f]+{INT_SUFFIX} {return T_INTEGER;}
<INITIAL,LINE>0[0-7]*{INT_SUFFIX} {return T_INTEGER;}
<INITIAL,LINE>[1-9][0-9]*{INT_SUFFIX} {return T_INTEGER;}
<INITIAL>## {return T_CONCAT;}
<INITIAL>"++" {return T_TEXT;}
<INITIAL>"--" {return T_TEXT;}
<INITIAL>"<<"=? {return T_TEXT;}
<INITIAL>">>"=? {return T_TEXT;}
<INITIAL>[-+*/%&|^]= {return T_TEXT;}
/* Native doesn't preserve these tokens when running the preprocessor on its
* own, but there's no good reason to emulate that difference yet. */
<INITIAL>[pv]s\.[123]\.[0-4x] {return T_TEXT;}
<INCLUDE,LINE>\"[^"]*\" {return T_STRING;}
<INCLUDE>\<[^>]*\> {return T_STRING;}
/* C strings (including escaped quotes). */
<INITIAL>\"([^"\\]|\\.)*\" {return T_TEXT;}
<INITIAL>#{WS}*{IDENTIFIER} {
struct preproc_ctx *ctx = yyget_extra(yyscanner);
const char *p;
if (!ctx->last_was_newline)
{
struct preproc_expansion *exp;
/* Stringification is only done for function-like macro bodies.
* Anywhere else, we need to parse it as two separate tokens.
* We could use a state for this, but yyless() is easier and cheap.
*/
if ((exp = preproc_get_top_expansion(ctx)) && exp->macro && exp->macro->arg_count)
return T_HASHSTRING;
yyless(1);
return T_TEXT;
}
for (p = yytext + 1; strchr(" \t", *p); ++p)
;
if (!strcmp(p, "error"))
{
BEGIN(ERROR);
return T_ERROR;
}
if (!strcmp(p, "include"))
{
BEGIN(INCLUDE);
return T_INCLUDE;
}
if (!strcmp(p, "line"))
{
BEGIN(LINE);
return T_LINE;
}
if (!strcmp(p, "define"))
return T_DEFINE;
if (!strcmp(p, "elif"))
return T_ELIF;
if (!strcmp(p, "else"))
return T_ELSE;
if (!strcmp(p, "endif"))
return T_ENDIF;
if (!strcmp(p, "if"))
return T_IF;
if (!strcmp(p, "ifdef"))
return T_IFDEF;
if (!strcmp(p, "ifndef"))
return T_IFNDEF;
if (!strcmp(p, "pragma"))
return T_PRAGMA;
if (!strcmp(p, "undef"))
return T_UNDEF;
preproc_warning(ctx, yyget_lloc(yyscanner), VKD3D_SHADER_WARNING_PP_UNKNOWN_DIRECTIVE,
"Ignoring unknown directive \"%s\".", yytext);
return T_TEXT;
}
<INITIAL,INCLUDE,LINE>\\{NEWLINE} {}
<INITIAL,INCLUDE,ERROR,LINE>{NEWLINE} {
BEGIN(INITIAL);
return T_NEWLINE;
}
<INITIAL,INCLUDE,LINE>{WS}+ {}
<INITIAL>[-()\[\]{},+!*/<>&|^?:] {return yytext[0];}
<INITIAL,INCLUDE,LINE>. {return T_TEXT;}
%%
static void update_location(struct preproc_ctx *ctx)
{
struct preproc_buffer *buffer = &preproc_get_top_file(ctx)->buffer;
unsigned int i, leng = yyget_leng(ctx->scanner);
const char *text = yyget_text(ctx->scanner);
/* We want to do this here, rather than before calling yylex(), because
* some tokens are skipped by the lexer. */
*yyget_lloc(ctx->scanner) = buffer->location;
for (i = 0; i < leng; ++i)
{
++buffer->location.column;
if (text[i] == '\n')
{
buffer->location.column = 1;
++buffer->location.line;
}
}
}
static bool preproc_is_writing(struct preproc_ctx *ctx)
{
const struct preproc_file *file;
/* This can happen while checking for unterminated macro invocation. */
if (!ctx->file_count)
return true;
file = preproc_get_top_file(ctx);
if (!file->if_count)
return true;
return file->if_stack[file->if_count - 1].current_true;
}
/* Concatenation is not done for object-like macros, but is done for both
* function-like macro bodies and their arguments. */
static bool should_concat(struct preproc_ctx *ctx)
{
struct preproc_macro *macro;
if (!ctx->expansion_count)
return false;
macro = ctx->expansion_stack[ctx->expansion_count - 1].macro;
return !macro || macro->arg_count;
}
static void preproc_pop_buffer(struct preproc_ctx *ctx)
{
if (ctx->expansion_count)
{
struct preproc_expansion *exp = &ctx->expansion_stack[ctx->expansion_count - 1];
yy_delete_buffer(exp->buffer.lexer_buffer, ctx->scanner);
if (exp->macro)
{
for (unsigned int i = 0; i < exp->macro->arg_count; ++i)
vkd3d_string_buffer_cleanup(&exp->arg_values[i].text);
free(exp->arg_values);
}
--ctx->expansion_count;
TRACE("Expansion stack size is now %zu.\n", ctx->expansion_count);
}
else
{
struct preproc_file *file = preproc_get_top_file(ctx);
if (ctx->file_count > 1)
preproc_close_include(ctx, &file->code);
if (file->if_count)
{
const struct vkd3d_shader_location loc = {.source_name = file->filename};
preproc_warning(ctx, &loc, VKD3D_SHADER_WARNING_PP_UNTERMINATED_IF, "Unterminated #if block.");
}
vkd3d_free(file->if_stack);
vkd3d_free(file->filename);
yy_delete_buffer(file->buffer.lexer_buffer, ctx->scanner);
--ctx->file_count;
TRACE("File stack size is now %zu.\n", ctx->file_count);
}
if (ctx->expansion_count)
yy_switch_to_buffer(ctx->expansion_stack[ctx->expansion_count - 1].buffer.lexer_buffer, ctx->scanner);
else if (ctx->file_count)
yy_switch_to_buffer(ctx->file_stack[ctx->file_count - 1].buffer.lexer_buffer, ctx->scanner);
}
static int return_token(int token, YYSTYPE *lval, const char *text)
{
switch (token)
{
case T_HASHSTRING:
case T_IDENTIFIER:
case T_IDENTIFIER_PAREN:
case T_INTEGER:
case T_STRING:
case T_TEXT:
if (!(lval->string = vkd3d_strdup(text)))
return 0;
break;
}
return token;
}
static const struct preproc_text *find_arg_expansion(struct preproc_ctx *ctx, const char *s)
{
struct preproc_expansion *exp;
unsigned int i;
if ((exp = preproc_get_top_expansion(ctx)) && exp->macro)
{
for (i = 0; i < exp->macro->arg_count; ++i)
{
if (!strcmp(s, exp->macro->arg_names[i]))
return &exp->arg_values[i];
}
}
return NULL;
}
static void preproc_text_add(struct preproc_text *text, const char *string)
{
vkd3d_string_buffer_printf(&text->text, "%s", string);
}
static bool preproc_push_expansion(struct preproc_ctx *ctx,
const struct preproc_text *text, struct preproc_macro *macro, struct preproc_text *arg_values)
{
struct preproc_expansion *exp;
if (!vkd3d_array_reserve((void **)&ctx->expansion_stack, &ctx->expansion_stack_size,
ctx->expansion_count + 1, sizeof(*ctx->expansion_stack)))
return false;
exp = &ctx->expansion_stack[ctx->expansion_count++];
exp->text = text;
exp->buffer.lexer_buffer = yy_scan_bytes(text->text.buffer, text->text.content_size, ctx->scanner);
exp->buffer.location = text->location;
exp->macro = macro;
exp->arg_values = arg_values;
TRACE("Expansion stack size is now %zu.\n", ctx->expansion_count);
return true;
}
static void preproc_stringify(struct preproc_ctx *ctx, struct vkd3d_string_buffer *buffer, const char *text)
{
const struct preproc_text *expansion;
const char *p = text + 1;
unsigned int i;
while (*p == ' ' || *p == '\t')
++p;
vkd3d_string_buffer_printf(buffer, "\"");
if ((expansion = find_arg_expansion(ctx, p)))
{
size_t len = expansion->text.content_size;
size_t start = 0;
while (len && strchr(" \t\r\n", expansion->text.buffer[len - 1]))
--len;
while (start < len && strchr(" \t\r\n", expansion->text.buffer[start]))
++start;
for (i = start; i < len; ++i)
{
char c = expansion->text.buffer[i];
if (c == '\\' || c == '"')
vkd3d_string_buffer_printf(buffer, "\\");
vkd3d_string_buffer_printf(buffer, "%c", c);
}
}
else
{
vkd3d_string_buffer_printf(buffer, "%s", p);
}
vkd3d_string_buffer_printf(buffer, "\"");
}
int yylex(YYSTYPE *lval, YYLTYPE *lloc, yyscan_t scanner)
{
struct preproc_ctx *ctx = yyget_extra(scanner);
for (;;)
{
struct preproc_func_state *func_state;
const char *text;
int token;
if (ctx->lookahead_token)
{
token = ctx->lookahead_token;
text = yyget_text(scanner);
}
else
{
if (ctx->last_was_eof)
{
preproc_pop_buffer(ctx);
if (!ctx->file_count)
return 0;
}
ctx->last_was_eof = false;
VKD3D_ASSERT(ctx->file_count);
if (!(token = preproc_lexer_lex(lval, lloc, scanner)))
{
ctx->last_was_eof = true;
/* If we have reached the end of an included file, inject a newline. */
if (ctx->expansion_count)
continue;
token = T_NEWLINE;
text = "\n";
}
else
{
text = yyget_text(scanner);
}
if (ctx->last_was_newline)
{
switch (token)
{
case T_DEFINE:
case T_ELIF:
case T_ELSE:
case T_ENDIF:
case T_ERROR:
case T_IF:
case T_IFDEF:
case T_IFNDEF:
case T_INCLUDE:
case T_LINE:
case T_PRAGMA:
case T_UNDEF:
ctx->current_directive = token;
break;
default:
ctx->current_directive = 0;
}
}
ctx->last_was_newline = (token == T_NEWLINE);
}
if (ctx->current_directive && token == T_DEFINED)
ctx->last_was_defined = true;
func_state = ctx->current_directive ? &ctx->directive_func : &ctx->text_func;
TRACE("Parsing token %d%s, line %d, in directive %d, state %#x, string %s.\n",
token, ctx->lookahead_token ? " (lookahead)" : "", lloc->line,
ctx->current_directive, func_state->state, debugstr_a(text));
ctx->lookahead_token = 0;
switch (ctx->current_directive)
{
case T_ELIF:
case T_ELSE:
case T_ENDIF:
case T_IF:
case T_IFDEF:
case T_IFNDEF:
break;
default:
if (!preproc_is_writing(ctx))
continue;
}
if (ctx->current_directive == T_PRAGMA)
{
/* Print all tokens verbatim. */
if (token == T_PRAGMA)
vkd3d_string_buffer_printf(&ctx->buffer, "#pragma ");
else
vkd3d_string_buffer_printf(&ctx->buffer, "%s", text);
continue;
}
switch (func_state->state)
{
case STATE_NONE:
if (token == T_CONCAT && should_concat(ctx))
{
while (ctx->buffer.content_size
&& strchr(" \t\r\n", ctx->buffer.buffer[ctx->buffer.content_size - 1]))
--ctx->buffer.content_size;
break;
}
if (token == T_HASHSTRING)
{
struct vkd3d_string_buffer buffer;
if (ctx->current_directive)
return return_token(token, lval, text);
vkd3d_string_buffer_init(&buffer);
preproc_stringify(ctx, &buffer, text);
vkd3d_string_buffer_printf(&ctx->buffer, "%s", buffer.buffer);
vkd3d_string_buffer_cleanup(&buffer);
break;
}
if (token == T_IDENTIFIER || token == T_IDENTIFIER_PAREN)
{
const struct preproc_text *expansion;
struct preproc_macro *macro;
switch (ctx->current_directive)
{
case T_DEFINE:
case T_IFDEF:
case T_IFNDEF:
case T_UNDEF:
/* Return identifiers verbatim. */
return return_token(token, lval, text);
case T_IF:
case T_ELIF:
/* Return identifiers verbatim only if they're the
* argument to "defined". */
if (ctx->last_was_defined)
{
ctx->last_was_defined = false;
return return_token(token, lval, text);
}
break;
}
/* Otherwise, expand a macro if there is one. */
if ((expansion = find_arg_expansion(ctx, text)))
{
preproc_push_expansion(ctx, expansion, NULL, NULL);
continue;
}
if ((macro = preproc_find_macro(ctx, text)))
{
if (!macro->arg_count)
{
preproc_push_expansion(ctx, &macro->body, macro, NULL);
}
else
{
func_state->state = STATE_IDENTIFIER;
func_state->macro = macro;
}
continue;
}
if (!strcmp(text, "__FILE__"))
{
const struct preproc_file *file = preproc_get_top_file(ctx);
/* Not the current file name, but rather the file name
* before invoking any macros. */
if (ctx->current_directive)
{
char *string;
if (!(string = vkd3d_malloc(strlen(file->filename) + 3)))
return 0;
sprintf(string, "\"%s\"", file->filename);
lval->string = string;
return T_STRING;
}
if (preproc_is_writing(ctx))
vkd3d_string_buffer_printf(&ctx->buffer, "\"%s\" ", file->filename);
continue;
}
if (!strcmp(text, "__LINE__"))
{
const struct preproc_file *file = preproc_get_top_file(ctx);
/* Not the current line number, but rather the line
* number before invoking any macros. */
if (ctx->current_directive)
{
char string[13];
sprintf(string, "%d", file->buffer.location.line);
return return_token(T_INTEGER, lval, string);
}
if (preproc_is_writing(ctx))
vkd3d_string_buffer_printf(&ctx->buffer, "%d ", file->buffer.location.line);
continue;
}
}
if (ctx->current_directive)
return return_token(token, lval, text);
if (isspace(text[0]))
vkd3d_string_buffer_printf(&ctx->buffer, "%s", text);
else
vkd3d_string_buffer_printf(&ctx->buffer, "%s ", text);
break;
case STATE_IDENTIFIER:
if (token == '(')
{
struct preproc_text *arg_values;
if (!(arg_values = calloc(func_state->macro->arg_count, sizeof(*arg_values))))
return 0;
for (unsigned int i = 0; i < func_state->macro->arg_count; ++i)
vkd3d_string_buffer_init(&arg_values[i].text);
arg_values[0].location = *lloc;
func_state->arg_count = 0;
func_state->paren_depth = 1;
func_state->state = STATE_ARGS;
func_state->arg_values = arg_values;
}
else
{
const char *name = func_state->macro->name;
ctx->lookahead_token = token;
func_state->macro = NULL;
func_state->state = STATE_NONE;
if (ctx->current_directive)
return return_token(T_IDENTIFIER, lval, name);
vkd3d_string_buffer_printf(&ctx->buffer, "%s ", name);
}
break;
case STATE_ARGS:
{
struct preproc_text *current_arg = NULL;
VKD3D_ASSERT(func_state->macro->arg_count);
if (func_state->arg_count < func_state->macro->arg_count)
current_arg = &func_state->arg_values[func_state->arg_count];
switch (token)
{
/* Most text gets left alone (e.g. if it contains macros,
* the macros should be evaluated later).
* Arguments are a special case, and are replaced with
* their values immediately. */
case T_IDENTIFIER:
case T_IDENTIFIER_PAREN:
{
const struct preproc_text *expansion;
if ((expansion = find_arg_expansion(ctx, text)))
{
preproc_push_expansion(ctx, expansion, NULL, NULL);
continue;
}
if (current_arg)
preproc_text_add(current_arg, text);
break;
}
/* Stringification is another special case. Unsurprisingly,
* we need to stringify if this is an argument. More
* surprisingly, we need to stringify even if it's not. */
case T_HASHSTRING:
{
struct vkd3d_string_buffer buffer;
vkd3d_string_buffer_init(&buffer);
preproc_stringify(ctx, &buffer, text);
if (current_arg)
preproc_text_add(current_arg, buffer.buffer);
vkd3d_string_buffer_cleanup(&buffer);
break;
}
case T_NEWLINE:
if (current_arg)
preproc_text_add(current_arg, " ");
break;
case ')':
case ']':
case '}':
if (!--func_state->paren_depth)
{
if (++func_state->arg_count == func_state->macro->arg_count)
{
preproc_push_expansion(ctx, &func_state->macro->body,
func_state->macro, func_state->arg_values);
}
else
{
preproc_warning(ctx, lloc, VKD3D_SHADER_WARNING_PP_ARGUMENT_COUNT_MISMATCH,
"Wrong number of arguments to macro \"%s\": expected %zu, got %zu.",
func_state->macro->name, func_state->macro->arg_count, func_state->arg_count);
if (ctx->current_directive)
return return_token(T_IDENTIFIER, lval, func_state->macro->name);
vkd3d_string_buffer_printf(&ctx->buffer, "%s ", func_state->macro->name);
}
func_state->macro = NULL;
func_state->state = STATE_NONE;
}
else
{
if (current_arg)
preproc_text_add(current_arg, text);
}
break;
case ',':
if (func_state->paren_depth == 1)
{
++func_state->arg_count;
if (current_arg)
current_arg->location = *lloc;
}
else if (current_arg)
{
preproc_text_add(current_arg, text);
}
break;
case '(':
case '[':
case '{':
++func_state->paren_depth;
/* fall through */
default:
if (current_arg)
preproc_text_add(current_arg, text);
}
if (current_arg)
preproc_text_add(current_arg, " ");
break;
}
}
}
}
bool preproc_push_include(struct preproc_ctx *ctx, char *filename, const struct vkd3d_shader_code *code)
{
struct preproc_file *file;
if (!vkd3d_array_reserve((void **)&ctx->file_stack, &ctx->file_stack_size,
ctx->file_count + 1, sizeof(*ctx->file_stack)))
return false;
file = &ctx->file_stack[ctx->file_count++];
memset(file, 0, sizeof(*file));
file->code = *code;
file->filename = filename;
file->buffer.lexer_buffer = yy_scan_bytes(code->code, code->size, ctx->scanner);
file->buffer.location.source_name = file->filename;
file->buffer.location.line = 1;
file->buffer.location.column = 1;
TRACE("File stack size is now %zu.\n", ctx->file_count);
ctx->last_was_newline = true;
return true;
}
static int preproc_macro_compare(const void *key, const struct rb_entry *entry)
{
const struct preproc_macro *macro = RB_ENTRY_VALUE(entry, struct preproc_macro, entry);
const char *name = key;
return strcmp(name, macro->name);
}
static void preproc_macro_rb_free(struct rb_entry *entry, void *ctx)
{
preproc_free_macro(RB_ENTRY_VALUE(entry, struct preproc_macro, entry));
}
int preproc_lexer_parse(const struct vkd3d_shader_compile_info *compile_info,
struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context)
{
static const struct vkd3d_shader_preprocess_info default_preprocess_info = {0};
struct preproc_ctx ctx = {0};
char *source_name = NULL;
void *output_code;
unsigned int i;
vkd3d_string_buffer_init(&ctx.buffer);
rb_init(&ctx.macros, preproc_macro_compare);
if (!(ctx.preprocess_info = vkd3d_find_struct(compile_info->next, PREPROCESS_INFO)))
ctx.preprocess_info = &default_preprocess_info;
ctx.message_context = message_context;
if (!(source_name = vkd3d_strdup(compile_info->source_name ? compile_info->source_name : "<anonymous>")))
goto fail;
for (i = 0; i < ctx.preprocess_info->macro_count; ++i)
{
const struct vkd3d_shader_location loc = {.source_name = source_name};
struct vkd3d_string_buffer body;
char *name;
vkd3d_string_buffer_init(&body);
vkd3d_string_buffer_printf(&body, "%s", ctx.preprocess_info->macros[i].value);
if (!(name = vkd3d_strdup(ctx.preprocess_info->macros[i].name)))
{
vkd3d_string_buffer_cleanup(&body);
goto fail;
}
if (!preproc_add_macro(&ctx, &loc, name, NULL, 0, &loc, &body))
{
vkd3d_free(name);
vkd3d_string_buffer_cleanup(&body);
goto fail;
}
}
yylex_init_extra(&ctx, &ctx.scanner);
if (!preproc_push_include(&ctx, source_name, &compile_info->source))
{
yylex_destroy(ctx.scanner);
goto fail;
}
preproc_yyparse(ctx.scanner, &ctx);
switch (ctx.text_func.state)
{
case STATE_NONE:
break;
case STATE_ARGS:
{
const struct vkd3d_shader_location loc = {.source_name = source_name};
preproc_warning(&ctx, &loc, VKD3D_SHADER_WARNING_PP_UNTERMINATED_MACRO,
"Unterminated macro invocation.");
}
/* fall through */
case STATE_IDENTIFIER:
if (preproc_is_writing(&ctx))
vkd3d_string_buffer_printf(&ctx.buffer, "%s ", ctx.text_func.macro->name);
break;
}
while (ctx.file_count)
preproc_pop_buffer(&ctx);
yylex_destroy(ctx.scanner);
rb_destroy(&ctx.macros, preproc_macro_rb_free, NULL);
vkd3d_free(ctx.file_stack);
vkd3d_free(ctx.expansion_stack);
if (ctx.error)
{
WARN("Failed to preprocess.\n");
vkd3d_string_buffer_cleanup(&ctx.buffer);
return VKD3D_ERROR_INVALID_SHADER;
}
if (!(output_code = vkd3d_malloc(ctx.buffer.content_size)))
{
vkd3d_string_buffer_cleanup(&ctx.buffer);
return VKD3D_ERROR_OUT_OF_MEMORY;
}
memcpy(output_code, ctx.buffer.buffer, ctx.buffer.content_size);
out->size = ctx.buffer.content_size;
out->code = output_code;
vkd3d_string_buffer_trace(&ctx.buffer);
vkd3d_string_buffer_cleanup(&ctx.buffer);
return VKD3D_OK;
fail:
rb_destroy(&ctx.macros, preproc_macro_rb_free, NULL);
vkd3d_free(source_name);
vkd3d_string_buffer_cleanup(&ctx.buffer);
return VKD3D_ERROR_OUT_OF_MEMORY;
}