qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-27 06:34:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/include/QF/cexpr.h

167 lines
4.9 KiB
C
Raw Normal View History

[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
/*
cexpr.h
Config expression parser. Or concurrent.
Copyright (C) 2020 Bill Currie <bill@taniwha.org>
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, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
[headers] Fix some inconsistent include guards
2021-03-03 07:34:44 +00:00
#ifndef __QF_expr_h
#define __QF_expr_h
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
#include <stdlib.h>
struct exprval_s;
struct exprctx_s;
[cexpr] Add a get_string function to exprtype_t This allows for easy (and safe) printing of cexpr values where the type supports it. Types that don't support printing would be due to being too complex or possibly write-only (eg, password strings, when strings are supported directly).
2022-04-24 06:04:08 +00:00
struct va_ctx_s;
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
typedef struct binop_s {
int op;
struct exprtype_s *other;
struct exprtype_s *result;
void (*func) (const struct exprval_s *val1,
const struct exprval_s *val2,
struct exprval_s *result,
struct exprctx_s *context);
} binop_t;
typedef struct unop_s {
int op;
struct exprtype_s *result;
void (*func) (const struct exprval_s *val, struct exprval_s *result,
struct exprctx_s *context);
} unop_t;
typedef struct exprtype_s {
const char *name;
size_t size;
[cexpr] Add a get_string function to exprtype_t This allows for easy (and safe) printing of cexpr values where the type supports it. Types that don't support printing would be due to being too complex or possibly write-only (eg, password strings, when strings are supported directly).
2022-04-24 06:04:08 +00:00
const char *(*get_string) (const struct exprval_s *val, struct va_ctx_s *va_ctx);
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
binop_t *binops;
unop_t *unops;
void *data;
Abandon support for clang The inconsistencies in clang's handling of casts was bad enough, and its silliness with certain extensions, but discovering that it doesn't support raw strings was just too much. Yes, it gives a 3s boost to qfvis on gmsp3v2.bsp, but it's not worth the hassle.
2022-10-16 09:02:25 +00:00
} __attribute__((designated_init)) exprtype_t;
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
typedef struct exprval_s {
exprtype_t *type;
void *value;
} exprval_t;
[util] Implement more of cexpr This adds unary, vector and function expressions.
2021-01-03 15:11:52 +00:00
typedef struct exprlist_s {
struct exprlist_s *next;
exprval_t *value;
} exprlist_t;
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
typedef struct exprsym_s {
const char *name;
exprtype_t *type;
void *value;
struct exprsym_s *next;
} exprsym_t;
[util] Implement more of cexpr This adds unary, vector and function expressions.
2021-01-03 15:11:52 +00:00
typedef struct exprfunc_s {
exprtype_t *result;
int num_params;
exprtype_t **param_types;
void (*func) (const exprval_t **params, exprval_t *result,
struct exprctx_s *context);
} exprfunc_t;
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
typedef struct exprtab_s {
exprsym_t *symbols;
struct hashtab_s *tab;
} exprtab_t;
[cexpr] Support array indexing The index is currently limited to ints, and is bounds checked (the array type has a size field indicating the number of elements).
2021-12-04 01:04:58 +00:00
typedef struct exprarray_s {
exprtype_t *type;
unsigned size;
} exprarray_t;
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
typedef struct exprctx_s {
[cexpr] Support chained contexts for scoping cexpr's symbol tables currently aren't readily extended, and dynamic scoping is usually a good thing anyway. The chain of contexts is walked when a symbol is not found in the current context's symtab, but minor efforts are made to avoid checking the same symtab twice (usually cased by cloning a context but not updating the symtab).
2021-12-04 03:28:46 +00:00
struct exprctx_s *parent; // for nested symol scopes
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
exprval_t *result;
exprtab_t *symtab; // directly accessible symbols
exprtab_t *external_variables; // accessible via $id
[cexpr] Add optional error message prefix string The prefix gives more context to the error messages, making the system a lot easier to use (it was especially helpful when getting my cvar revamp into shape).
2022-04-24 06:16:15 +00:00
const char *msg_prefix; // optional prefix for error messages
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
struct memsuper_s *memsuper;
const struct plitem_s *item;
struct plitem_s *messages;
[hash] Rename the publicly visible hashlink_t to hashctx_t I think my biggest problem with the hashlink freelist parameter was how much implementation it exposed in just the name.
2022-05-12 08:54:23 +00:00
struct hashctx_s **hashctx;
[util] Propagate cexpr errors back to the caller Not much point in error detection when it's ignored.
2020-12-21 11:15:43 +00:00
int errors;
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
} exprctx_t;
typedef struct exprenum_s {
exprtype_t *type;
exprtab_t *symtab;
} exprenum_t;
[cexpr] Expose cexpr assignment This makes it much easier for other systems (in particular, cvar) to copy values safely.
2022-04-24 06:18:09 +00:00
exprval_t *cexpr_assign_value (exprval_t *dst, const exprval_t *src,
exprctx_t *context);
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
int cexpr_parse_enum (exprenum_t *enm, const char *str,
const exprctx_t *context, void *data);
binop_t *cexpr_find_cast (exprtype_t *dst_type, exprtype_t *src_type) __attribute__((pure));
exprval_t *cexpr_value (exprtype_t *type, exprctx_t *ctx);
exprval_t *cexpr_value_reference (exprtype_t *type, void *data, exprctx_t *ctx);
[cexpr] Add a get_string function to exprtype_t This allows for easy (and safe) printing of cexpr values where the type supports it. Types that don't support printing would be due to being too complex or possibly write-only (eg, password strings, when strings are supported directly).
2022-04-24 06:04:08 +00:00
const char *cexpr_enum_get_string (const exprval_t *val, struct va_ctx_s *va_ctx) __attribute__((pure));
[cexpr] Add a flags type Based on the flags type used in vkparse (difference is the lack of support for plists). Having this will make supporting named flags in cvars much easier (though setting up the enum type is a bit of a chore).
2022-04-24 06:12:56 +00:00
const char *cexpr_flags_get_string (const exprval_t *val, struct va_ctx_s *va_ctx) __attribute__((pure));
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
int cexpr_eval_string (const char *str, exprctx_t *context);
[build] Autoconfiscate printf format attribute I don't know if gnu_printf is appropriate for all cases, but it is needed for mingw32.
2021-03-27 10:52:59 +00:00
void cexpr_error(exprctx_t *ctx, const char *fmt, ...) __attribute__((format(PRINTF,2,3)));
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
[cexpr] Support array indexing The index is currently limited to ints, and is bounds checked (the array type has a size field indicating the number of elements).
2021-12-04 01:04:58 +00:00
void cexpr_array_getelement (const exprval_t *a, const exprval_t *b,
exprval_t *c, exprctx_t *ctx);
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
void cexpr_struct_getfield (const exprval_t *a, const exprval_t *b,
exprval_t *c, exprctx_t *ctx);
[util] Support struct pointer accesses in cexpr
2021-01-09 16:35:39 +00:00
void cexpr_struct_pointer_getfield (const exprval_t *a, const exprval_t *b,
exprval_t *c, exprctx_t *ctx);
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
exprval_t *cexpr_cvar (const char *name, exprctx_t *ctx);
exprval_t *cexpr_cvar_struct (exprctx_t *ctx);
[util] Auto-cast plist string items The casting uses a recursive call to the expression parser, so the expressions are type-checked automatically.
2021-02-04 13:37:20 +00:00
void cexpr_cast_plitem (const exprval_t *val1, const exprval_t *src,
exprval_t *result, exprctx_t *ctx);
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
void cexpr_init_symtab (exprtab_t *symtab, exprctx_t *ctx);
char *cexpr_yyget_text (void *scanner);
extern exprtype_t cexpr_int;
extern exprtype_t cexpr_uint;
[util] Add size_t support to cexpr
2020-12-23 05:06:20 +00:00
extern exprtype_t cexpr_size_t;
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
extern exprtype_t cexpr_float;
extern exprtype_t cexpr_double;
[util] Add vector and quaternion types to cexpr Although there's no distinction between the two at the C level, I think it's probably best to separate them in a scripting language.
2020-12-28 05:56:59 +00:00
extern exprtype_t cexpr_vector;
extern exprtype_t cexpr_quaternion;
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
extern exprtype_t cexpr_exprval;
extern exprtype_t cexpr_field;
[util] Implement more of cexpr This adds unary, vector and function expressions.
2021-01-03 15:11:52 +00:00
extern exprtype_t cexpr_function;
[util] Add plist support to cexpr This allows plist objects to be accessed directly from cexpr expressions using struct.field syntax for dictionary objects and array[index] syntax for array objects.
2021-02-04 07:58:13 +00:00
extern exprtype_t cexpr_plitem;
[cexpr] Add string and voidptr types The string type is useful for passing around strings (the only thing that they can do, currently), particularly as arguments to functions. The voidptr type is (currently) never generated by the core cexpr system, but is useful for storing pointers via cexpr (probably a bit of a hack, but it seems to work well in my current use).
2023-06-18 08:20:38 +00:00
extern exprtype_t cexpr_string;
// generic pointer holder, never generated directly by cexpr
extern exprtype_t cexpr_voidptr;
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
[cexpr] Support array indexing The index is currently limited to ints, and is bounds checked (the array type has a size field indicating the number of elements).
2021-12-04 01:04:58 +00:00
extern binop_t cexpr_array_binops[];
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
extern binop_t cexpr_struct_binops[];
[util] Support struct pointer accesses in cexpr
2021-01-09 16:35:39 +00:00
extern binop_t cexpr_struct_pointer_binops[];
[cexpr] Add a flags type Based on the flags type used in vkparse (difference is the lack of support for plists). Having this will make supporting named flags in cvars much easier (though setting up the enum type is a bit of a chore).
2022-04-24 06:12:56 +00:00
extern binop_t cexpr_flag_binops[];
extern unop_t cexpr_flag_unops[];
[util] Add a mini expression parser It is capable of parsing single expressions with fairly simple operations. It current supports ints, enums, cvars and (external) data structs. It is also thread-safe (in theory, needs proper testing) and the memory it uses can be mass-freed.
2020-12-21 05:06:21 +00:00
[cexpr] Add a small library with some useful functions For now, just dot product, trig, and min/max/bound, but it works well as a proof of concept. The main goal was actually min. Only the list of symbols is provided, it is the user's responsibility to set up the symbol table and context.
2021-12-04 05:04:45 +00:00
extern exprsym_t cexpr_lib_symbols[];
[headers] Fix some inconsistent include guards
2021-03-03 07:34:44 +00:00
#endif//__QF_expr_h
Reference in a new issue Copy permalink