mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-09-20 13:08:50 +02:00
e9342143a7
- Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
682 lines
17 KiB
C
682 lines
17 KiB
C
/******************************************************************************
|
|
Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
******************************************************************************/
|
|
|
|
#include "shader-parser.h"
|
|
|
|
enum shader_param_type get_shader_param_type(const char *type)
|
|
{
|
|
if (strcmp(type, "float") == 0)
|
|
return SHADER_PARAM_FLOAT;
|
|
else if (strcmp(type, "float2") == 0)
|
|
return SHADER_PARAM_VEC2;
|
|
else if (strcmp(type, "float3") == 0)
|
|
return SHADER_PARAM_VEC3;
|
|
else if (strcmp(type, "float4") == 0)
|
|
return SHADER_PARAM_VEC4;
|
|
else if (astrcmp_n(type, "texture", 7) == 0)
|
|
return SHADER_PARAM_TEXTURE;
|
|
else if (strcmp(type, "float4x4") == 0)
|
|
return SHADER_PARAM_MATRIX4X4;
|
|
else if (strcmp(type, "bool") == 0)
|
|
return SHADER_PARAM_BOOL;
|
|
else if (strcmp(type, "int") == 0)
|
|
return SHADER_PARAM_INT;
|
|
else if (strcmp(type, "string") == 0)
|
|
return SHADER_PARAM_STRING;
|
|
|
|
return SHADER_PARAM_UNKNOWN;
|
|
}
|
|
|
|
enum gs_sample_filter get_sample_filter(const char *filter)
|
|
{
|
|
if (astrcmpi(filter, "Anisotropy") == 0)
|
|
return GS_FILTER_ANISOTROPIC;
|
|
|
|
else if (astrcmpi(filter, "Point") == 0 ||
|
|
strcmp(filter, "MIN_MAG_MIP_POINT") == 0)
|
|
return GS_FILTER_POINT;
|
|
|
|
else if (astrcmpi(filter, "Linear") == 0 ||
|
|
strcmp(filter, "MIN_MAG_MIP_LINEAR") == 0)
|
|
return GS_FILTER_LINEAR;
|
|
|
|
else if (strcmp(filter, "MIN_MAG_POINT_MIP_LINEAR") == 0)
|
|
return GS_FILTER_MIN_MAG_POINT_MIP_LINEAR;
|
|
|
|
else if (strcmp(filter, "MIN_POINT_MAG_LINEAR_MIP_POINT") == 0)
|
|
return GS_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT;
|
|
|
|
else if (strcmp(filter, "MIN_POINT_MAG_MIP_LINEAR") == 0)
|
|
return GS_FILTER_MIN_POINT_MAG_MIP_LINEAR;
|
|
|
|
else if (strcmp(filter, "MIN_LINEAR_MAG_MIP_POINT") == 0)
|
|
return GS_FILTER_MIN_LINEAR_MAG_MIP_POINT;
|
|
|
|
else if (strcmp(filter, "MIN_LINEAR_MAG_POINT_MIP_LINEAR") == 0)
|
|
return GS_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
|
|
|
|
else if (strcmp(filter, "MIN_MAG_LINEAR_MIP_POINT") == 0)
|
|
return GS_FILTER_MIN_MAG_LINEAR_MIP_POINT;
|
|
|
|
return GS_FILTER_LINEAR;
|
|
}
|
|
|
|
extern enum gs_address_mode get_address_mode(const char *mode)
|
|
{
|
|
if (astrcmpi(mode, "Wrap") == 0 || astrcmpi(mode, "Repeat") == 0)
|
|
return GS_ADDRESS_WRAP;
|
|
else if (astrcmpi(mode, "Clamp") == 0 || astrcmpi(mode, "None") == 0)
|
|
return GS_ADDRESS_CLAMP;
|
|
else if (astrcmpi(mode, "Mirror") == 0)
|
|
return GS_ADDRESS_MIRROR;
|
|
else if (astrcmpi(mode, "Border") == 0)
|
|
return GS_ADDRESS_BORDER;
|
|
else if (astrcmpi(mode, "MirrorOnce") == 0)
|
|
return GS_ADDRESS_MIRRORONCE;
|
|
|
|
return GS_ADDRESS_CLAMP;
|
|
}
|
|
|
|
void shader_sampler_convert(struct shader_sampler *ss,
|
|
struct gs_sampler_info *info)
|
|
{
|
|
size_t i;
|
|
memset(info, 0, sizeof(struct gs_sampler_info));
|
|
|
|
for (i = 0; i < ss->states.num; i++) {
|
|
const char *state = ss->states.array[i];
|
|
const char *value = ss->values.array[i];
|
|
|
|
if (astrcmpi(state, "Filter") == 0)
|
|
info->filter = get_sample_filter(value);
|
|
else if (astrcmpi(state, "AddressU") == 0)
|
|
info->address_u = get_address_mode(value);
|
|
else if (astrcmpi(state, "AddressV") == 0)
|
|
info->address_v = get_address_mode(value);
|
|
else if (astrcmpi(state, "AddressW") == 0)
|
|
info->address_w = get_address_mode(value);
|
|
else if (astrcmpi(state, "MaxAnisotropy") == 0)
|
|
info->max_anisotropy = (int)strtol(value, NULL, 10);
|
|
/*else if (astrcmpi(state, "BorderColor") == 0)
|
|
// TODO */
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
static int sp_parse_sampler_state_item(struct shader_parser *sp,
|
|
struct shader_sampler *ss)
|
|
{
|
|
int ret;
|
|
char *state = NULL, *value = NULL;
|
|
|
|
ret = cf_next_name(&sp->cfp, &state, "state name", ";");
|
|
if (ret != PARSE_SUCCESS) goto fail;
|
|
|
|
ret = cf_next_token_should_be(&sp->cfp, "=", ";", NULL);
|
|
if (ret != PARSE_SUCCESS) goto fail;
|
|
|
|
ret = cf_next_name(&sp->cfp, &value, "value name", ";");
|
|
if (ret != PARSE_SUCCESS) goto fail;
|
|
|
|
ret = cf_next_token_should_be(&sp->cfp, ";", ";", NULL);
|
|
if (ret != PARSE_SUCCESS) goto fail;
|
|
|
|
da_push_back(ss->states, &state);
|
|
da_push_back(ss->values, &value);
|
|
return ret;
|
|
|
|
fail:
|
|
bfree(state);
|
|
bfree(value);
|
|
return ret;
|
|
}
|
|
|
|
static void sp_parse_sampler_state(struct shader_parser *sp)
|
|
{
|
|
struct shader_sampler ss;
|
|
struct cf_token peek;
|
|
shader_sampler_init(&ss);
|
|
|
|
if (cf_next_name(&sp->cfp, &ss.name, "name", ";") != PARSE_SUCCESS)
|
|
goto error;
|
|
if (cf_next_token_should_be(&sp->cfp, "{", ";", NULL) != PARSE_SUCCESS)
|
|
goto error;
|
|
|
|
if (!cf_peek_valid_token(&sp->cfp, &peek))
|
|
goto error;
|
|
|
|
while (strref_cmp(&peek.str, "}") != 0) {
|
|
int ret = sp_parse_sampler_state_item(sp, &ss);
|
|
if (ret == PARSE_EOF)
|
|
goto error;
|
|
|
|
if (!cf_peek_valid_token(&sp->cfp, &peek))
|
|
goto error;
|
|
}
|
|
|
|
if (cf_next_token_should_be(&sp->cfp, "}", ";", NULL) != PARSE_SUCCESS)
|
|
goto error;
|
|
if (cf_next_token_should_be(&sp->cfp, ";", NULL, NULL) != PARSE_SUCCESS)
|
|
goto error;
|
|
|
|
da_push_back(sp->samplers, &ss);
|
|
return;
|
|
|
|
error:
|
|
shader_sampler_free(&ss);
|
|
}
|
|
|
|
static inline int sp_parse_struct_var(struct shader_parser *sp,
|
|
struct shader_var *var)
|
|
{
|
|
int code;
|
|
|
|
/* -------------------------------------- */
|
|
/* variable type */
|
|
|
|
if (!cf_next_valid_token(&sp->cfp)) return PARSE_EOF;
|
|
|
|
if (cf_token_is(&sp->cfp, ";")) return PARSE_CONTINUE;
|
|
if (cf_token_is(&sp->cfp, "}")) return PARSE_BREAK;
|
|
|
|
code = cf_token_is_type(&sp->cfp, CFTOKEN_NAME, "type name", ";");
|
|
if (code != PARSE_SUCCESS)
|
|
return code;
|
|
|
|
cf_copy_token(&sp->cfp, &var->type);
|
|
|
|
/* -------------------------------------- */
|
|
/* variable name */
|
|
|
|
if (!cf_next_valid_token(&sp->cfp)) return PARSE_EOF;
|
|
|
|
if (cf_token_is(&sp->cfp, ";")) return PARSE_UNEXPECTED_CONTINUE;
|
|
if (cf_token_is(&sp->cfp, "}")) return PARSE_UNEXPECTED_BREAK;
|
|
|
|
code = cf_token_is_type(&sp->cfp, CFTOKEN_NAME, "variable name",
|
|
";");
|
|
if (code != PARSE_SUCCESS)
|
|
return code;
|
|
|
|
cf_copy_token(&sp->cfp, &var->name);
|
|
|
|
/* -------------------------------------- */
|
|
/* variable mapping if any (POSITION, TEXCOORD, etc) */
|
|
|
|
if (!cf_next_valid_token(&sp->cfp)) return PARSE_EOF;
|
|
|
|
if (cf_token_is(&sp->cfp, ":")) {
|
|
if (!cf_next_valid_token(&sp->cfp)) return PARSE_EOF;
|
|
|
|
if (cf_token_is(&sp->cfp, ";"))
|
|
return PARSE_UNEXPECTED_CONTINUE;
|
|
if (cf_token_is(&sp->cfp, "}"))
|
|
return PARSE_UNEXPECTED_BREAK;
|
|
|
|
code = cf_token_is_type(&sp->cfp, CFTOKEN_NAME,
|
|
"mapping name", ";");
|
|
if (code != PARSE_SUCCESS)
|
|
return code;
|
|
|
|
cf_copy_token(&sp->cfp, &var->mapping);
|
|
|
|
if (!cf_next_valid_token(&sp->cfp)) return PARSE_EOF;
|
|
}
|
|
|
|
/* -------------------------------------- */
|
|
|
|
if (!cf_token_is(&sp->cfp, ";")) {
|
|
if (!cf_go_to_valid_token(&sp->cfp, ";", "}"))
|
|
return PARSE_EOF;
|
|
return PARSE_CONTINUE;
|
|
}
|
|
|
|
return PARSE_SUCCESS;
|
|
}
|
|
|
|
static void sp_parse_struct(struct shader_parser *sp)
|
|
{
|
|
struct shader_struct ss;
|
|
shader_struct_init(&ss);
|
|
|
|
if (cf_next_name(&sp->cfp, &ss.name, "name", ";") != PARSE_SUCCESS)
|
|
goto error;
|
|
if (cf_next_token_should_be(&sp->cfp, "{", ";", NULL) != PARSE_SUCCESS)
|
|
goto error;
|
|
|
|
/* get structure variables */
|
|
while (true) {
|
|
bool do_break = false;
|
|
struct shader_var var;
|
|
|
|
shader_var_init(&var);
|
|
|
|
switch (sp_parse_struct_var(sp, &var)) {
|
|
|
|
case PARSE_UNEXPECTED_CONTINUE:
|
|
cf_adderror_syntax_error(&sp->cfp);
|
|
case PARSE_CONTINUE:
|
|
shader_var_free(&var);
|
|
continue;
|
|
|
|
case PARSE_UNEXPECTED_BREAK:
|
|
cf_adderror_syntax_error(&sp->cfp);
|
|
case PARSE_BREAK:
|
|
shader_var_free(&var);
|
|
do_break = true;
|
|
break;
|
|
|
|
case PARSE_EOF:
|
|
shader_var_free(&var);
|
|
goto error;
|
|
}
|
|
|
|
if (do_break)
|
|
break;
|
|
|
|
da_push_back(ss.vars, &var);
|
|
}
|
|
|
|
if (cf_next_token_should_be(&sp->cfp, ";", NULL, NULL) != PARSE_SUCCESS)
|
|
goto error;
|
|
|
|
da_push_back(sp->structs, &ss);
|
|
return;
|
|
|
|
error:
|
|
shader_struct_free(&ss);
|
|
}
|
|
|
|
static inline int sp_check_for_keyword(struct shader_parser *sp,
|
|
const char *keyword, bool *val)
|
|
{
|
|
bool new_val = cf_token_is(&sp->cfp, keyword);
|
|
if (new_val) {
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
return PARSE_EOF;
|
|
|
|
if (new_val && *val)
|
|
cf_adderror(&sp->cfp, "'$1' keyword already specified",
|
|
LEX_WARNING, keyword, NULL, NULL);
|
|
*val = new_val;
|
|
|
|
return PARSE_CONTINUE;
|
|
}
|
|
|
|
return PARSE_SUCCESS;
|
|
}
|
|
|
|
static inline int sp_parse_func_param(struct shader_parser *sp,
|
|
struct shader_var *var)
|
|
{
|
|
int code;
|
|
bool is_uniform = false;
|
|
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
return PARSE_EOF;
|
|
|
|
code = sp_check_for_keyword(sp, "uniform", &is_uniform);
|
|
if (code == PARSE_EOF)
|
|
return PARSE_EOF;
|
|
|
|
var->var_type = is_uniform ? SHADER_VAR_UNIFORM : SHADER_VAR_NONE;
|
|
|
|
code = cf_get_name(&sp->cfp, &var->type, "type", ")");
|
|
if (code != PARSE_SUCCESS)
|
|
return code;
|
|
|
|
code = cf_next_name(&sp->cfp, &var->name, "name", ")");
|
|
if (code != PARSE_SUCCESS)
|
|
return code;
|
|
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
return PARSE_EOF;
|
|
|
|
if (cf_token_is(&sp->cfp, ":")) {
|
|
code = cf_next_name(&sp->cfp, &var->mapping,
|
|
"mapping specifier", ")");
|
|
if (code != PARSE_SUCCESS)
|
|
return code;
|
|
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
return PARSE_EOF;
|
|
}
|
|
|
|
return PARSE_SUCCESS;
|
|
}
|
|
|
|
static bool sp_parse_func_params(struct shader_parser *sp,
|
|
struct shader_func *func)
|
|
{
|
|
struct cf_token peek;
|
|
int code;
|
|
|
|
cf_token_clear(&peek);
|
|
|
|
if (!cf_peek_valid_token(&sp->cfp, &peek))
|
|
return false;
|
|
|
|
if (*peek.str.array == ')') {
|
|
cf_next_token(&sp->cfp);
|
|
goto exit;
|
|
}
|
|
|
|
do {
|
|
struct shader_var var;
|
|
shader_var_init(&var);
|
|
|
|
if (!cf_token_is(&sp->cfp, "(") && !cf_token_is(&sp->cfp, ","))
|
|
cf_adderror_syntax_error(&sp->cfp);
|
|
|
|
code = sp_parse_func_param(sp, &var);
|
|
if (code != PARSE_SUCCESS) {
|
|
shader_var_free(&var);
|
|
|
|
if (code == PARSE_CONTINUE)
|
|
goto exit;
|
|
else if (code == PARSE_EOF)
|
|
return false;
|
|
}
|
|
|
|
da_push_back(func->params, &var);
|
|
} while (!cf_token_is(&sp->cfp, ")"));
|
|
|
|
exit:
|
|
return true;
|
|
}
|
|
|
|
static void sp_parse_function(struct shader_parser *sp, char *type, char *name)
|
|
{
|
|
struct shader_func func;
|
|
|
|
shader_func_init(&func, type, name);
|
|
if (!sp_parse_func_params(sp, &func))
|
|
goto error;
|
|
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
goto error;
|
|
|
|
/* if function is mapped to something, for example COLOR */
|
|
if (cf_token_is(&sp->cfp, ":")) {
|
|
char *mapping = NULL;
|
|
int errorcode = cf_next_name(&sp->cfp, &mapping, "mapping",
|
|
"{");
|
|
if (errorcode != PARSE_SUCCESS)
|
|
goto error;
|
|
|
|
func.mapping = mapping;
|
|
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
goto error;
|
|
}
|
|
|
|
if (!cf_token_is(&sp->cfp, "{")) {
|
|
cf_adderror_expecting(&sp->cfp, "{");
|
|
goto error;
|
|
}
|
|
|
|
func.start = sp->cfp.cur_token;
|
|
if (!cf_pass_pair(&sp->cfp, '{', '}'))
|
|
goto error;
|
|
|
|
/* it is established that the current token is '}' if we reach this */
|
|
cf_next_token(&sp->cfp);
|
|
|
|
func.end = sp->cfp.cur_token;
|
|
da_push_back(sp->funcs, &func);
|
|
return;
|
|
|
|
error:
|
|
shader_func_free(&func);
|
|
}
|
|
|
|
/* parses "array[count]" */
|
|
static bool sp_parse_param_array(struct shader_parser *sp,
|
|
struct shader_var *param)
|
|
{
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
return false;
|
|
|
|
if (sp->cfp.cur_token->type != CFTOKEN_NUM ||
|
|
!valid_int_str(sp->cfp.cur_token->str.array,
|
|
sp->cfp.cur_token->str.len))
|
|
return false;
|
|
|
|
param->array_count =(int)strtol(sp->cfp.cur_token->str.array, NULL, 10);
|
|
|
|
if (cf_next_token_should_be(&sp->cfp, "]", ";", NULL) == PARSE_EOF)
|
|
return false;
|
|
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline int sp_parse_param_assign_intfloat(struct shader_parser *sp,
|
|
struct shader_var *param, bool is_float)
|
|
{
|
|
int code;
|
|
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
return PARSE_EOF;
|
|
|
|
code = cf_token_is_type(&sp->cfp, CFTOKEN_NUM, "numeric value", ";");
|
|
if (code != PARSE_SUCCESS)
|
|
return code;
|
|
|
|
if (is_float) {
|
|
float f = (float)strtod(sp->cfp.cur_token->str.array, NULL);
|
|
da_push_back_array(param->default_val, &f, sizeof(float));
|
|
} else {
|
|
long l = strtol(sp->cfp.cur_token->str.array, NULL, 10);
|
|
da_push_back_array(param->default_val, &l, sizeof(long));
|
|
}
|
|
|
|
return PARSE_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* parses assignment for float1, float2, float3, float4, and any combination
|
|
* for float3x3, float4x4, etc
|
|
*/
|
|
static inline int sp_parse_param_assign_float_array(struct shader_parser *sp,
|
|
struct shader_var *param)
|
|
{
|
|
const char *float_type = param->type+5;
|
|
int float_count = 0, code, i;
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
if (float_type[0] < '1' || float_type[0] > '4')
|
|
cf_adderror(&sp->cfp, "Invalid row count", LEX_ERROR,
|
|
NULL, NULL, NULL);
|
|
|
|
float_count = float_type[0]-'0';
|
|
|
|
if (float_type[1] == 'x') {
|
|
if (float_type[2] < '1' || float_type[2] > '4')
|
|
cf_adderror(&sp->cfp, "Invalid column count",
|
|
LEX_ERROR, NULL, NULL, NULL);
|
|
|
|
float_count *= float_type[2]-'0';
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
|
|
code = cf_next_token_should_be(&sp->cfp, "{", ";", NULL);
|
|
if (code != PARSE_SUCCESS) return code;
|
|
|
|
for (i = 0; i < float_count; i++) {
|
|
char *next = ((i+1) < float_count) ? "," : "}";
|
|
|
|
code = sp_parse_param_assign_intfloat(sp, param, true);
|
|
if (code != PARSE_SUCCESS) return code;
|
|
|
|
code = cf_next_token_should_be(&sp->cfp, next, ";", NULL);
|
|
if (code != PARSE_SUCCESS) return code;
|
|
}
|
|
|
|
return PARSE_SUCCESS;
|
|
}
|
|
|
|
static int sp_parse_param_assignment_val(struct shader_parser *sp,
|
|
struct shader_var *param)
|
|
{
|
|
if (strcmp(param->type, "int") == 0)
|
|
return sp_parse_param_assign_intfloat(sp, param, false);
|
|
else if (strcmp(param->type, "float") == 0)
|
|
return sp_parse_param_assign_intfloat(sp, param, true);
|
|
else if (astrcmp_n(param->type, "float", 5) == 0)
|
|
return sp_parse_param_assign_float_array(sp, param);
|
|
|
|
cf_adderror(&sp->cfp, "Invalid type '$1' used for assignment",
|
|
LEX_ERROR, param->type, NULL, NULL);
|
|
|
|
return PARSE_CONTINUE;
|
|
}
|
|
|
|
static inline bool sp_parse_param_assign(struct shader_parser *sp,
|
|
struct shader_var *param)
|
|
{
|
|
if (sp_parse_param_assignment_val(sp, param) != PARSE_SUCCESS)
|
|
return false;
|
|
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static void sp_parse_param(struct shader_parser *sp,
|
|
char *type, char *name, bool is_const, bool is_uniform)
|
|
{
|
|
struct shader_var param;
|
|
shader_var_init_param(¶m, type, name, is_uniform, is_const);
|
|
|
|
if (cf_token_is(&sp->cfp, ";"))
|
|
goto complete;
|
|
if (cf_token_is(&sp->cfp, "[") && !sp_parse_param_array(sp, ¶m))
|
|
goto error;
|
|
if (cf_token_is(&sp->cfp, "=") && !sp_parse_param_assign(sp, ¶m))
|
|
goto error;
|
|
if (!cf_token_is(&sp->cfp, ";"))
|
|
goto error;
|
|
|
|
complete:
|
|
da_push_back(sp->params, ¶m);
|
|
return;
|
|
|
|
error:
|
|
shader_var_free(¶m);
|
|
}
|
|
|
|
static bool sp_get_var_specifiers(struct shader_parser *sp,
|
|
bool *is_const, bool *is_uniform)
|
|
{
|
|
while(true) {
|
|
int code = sp_check_for_keyword(sp, "const", is_const);
|
|
if (code == PARSE_EOF)
|
|
return false;
|
|
else if (code == PARSE_CONTINUE)
|
|
continue;
|
|
|
|
code = sp_check_for_keyword(sp, "uniform", is_uniform);
|
|
if (code == PARSE_EOF)
|
|
return false;
|
|
else if (code == PARSE_CONTINUE)
|
|
continue;
|
|
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline void report_invalid_func_keyword(struct shader_parser *sp,
|
|
const char *name, bool val)
|
|
{
|
|
if (val)
|
|
cf_adderror(&sp->cfp, "'$1' keyword cannot be used with a "
|
|
"function", LEX_ERROR,
|
|
name, NULL, NULL);
|
|
}
|
|
|
|
static void sp_parse_other(struct shader_parser *sp)
|
|
{
|
|
bool is_const = false, is_uniform = false;
|
|
char *type = NULL, *name = NULL;
|
|
|
|
if (!sp_get_var_specifiers(sp, &is_const, &is_uniform))
|
|
goto error;
|
|
|
|
if (cf_get_name(&sp->cfp, &type, "type", ";") != PARSE_SUCCESS)
|
|
goto error;
|
|
if (cf_next_name(&sp->cfp, &name, "name", ";") != PARSE_SUCCESS)
|
|
goto error;
|
|
|
|
if (!cf_next_valid_token(&sp->cfp))
|
|
goto error;
|
|
|
|
if (cf_token_is(&sp->cfp, "(")) {
|
|
report_invalid_func_keyword(sp, "const", is_const);
|
|
report_invalid_func_keyword(sp, "uniform", is_uniform);
|
|
|
|
sp_parse_function(sp, type, name);
|
|
return;
|
|
} else {
|
|
sp_parse_param(sp, type, name, is_const, is_uniform);
|
|
return;
|
|
}
|
|
|
|
error:
|
|
bfree(type);
|
|
bfree(name);
|
|
}
|
|
|
|
bool shader_parse(struct shader_parser *sp, const char *shader,
|
|
const char *file)
|
|
{
|
|
if (!cf_parser_parse(&sp->cfp, shader, file))
|
|
return false;
|
|
|
|
while (sp->cfp.cur_token && sp->cfp.cur_token->type != CFTOKEN_NONE) {
|
|
if (cf_token_is(&sp->cfp, ";") ||
|
|
is_whitespace(*sp->cfp.cur_token->str.array)) {
|
|
sp->cfp.cur_token++;
|
|
|
|
} else if (cf_token_is(&sp->cfp, "struct")) {
|
|
sp_parse_struct(sp);
|
|
|
|
} else if (cf_token_is(&sp->cfp, "sampler_state")) {
|
|
sp_parse_sampler_state(sp);
|
|
|
|
} else if (cf_token_is(&sp->cfp, "{")) {
|
|
cf_adderror(&sp->cfp, "Unexpected code segment",
|
|
LEX_ERROR, NULL, NULL, NULL);
|
|
cf_pass_pair(&sp->cfp, '{', '}');
|
|
|
|
} else {
|
|
/* parameters and functions */
|
|
sp_parse_other(sp);
|
|
}
|
|
}
|
|
|
|
return !error_data_has_errors(&sp->cfp.error_list);
|
|
}
|