TYPE_ast_state /* 22 */
};
-#define ast_istype(x, t) ( ((ast_node*)x)->nodetype == (TYPE_##t) )
+#define ast_istype(x, t) ( ((ast_node*)x)->node_type == (TYPE_##t) )
#define ast_ctx(node) (((ast_node*)(node))->context)
#define ast_side_effects(node) (((ast_node*)(node))->side_effects)
lex_ctx_t context;
/* I don't feel comfortable using keywords like 'delete' as names... */
ast_node_delete *destroy;
- int nodetype;
- /* keep: if a node contains this node, 'keep'
+ int node_type;
+ /* keep_node: if a node contains this node, 'keep_node'
* prevents its dtor from destroying this node as well.
*/
- bool keep;
+ bool keep_node;
bool side_effects;
};
#define ast_delete(x) (*( ((ast_node*)(x))->destroy ))((ast_node*)(x))
-#define ast_unref(x) do \
-{ \
- if (! (((ast_node*)(x))->keep) ) { \
- ast_delete(x); \
- } \
+#define ast_unref(x) do \
+{ \
+ if (! (((ast_node*)(x))->keep_node) ) { \
+ ast_delete(x); \
+ } \
} while(0)
/* Expression interface
* type `expression`, so the ast_ident's codegen would search for
* variables through the environment (or functions, constants...).
*/
-struct ast_expression {
+struct ast_expression : ast_node {
ast_expression() {}
- ast_node node;
ast_expression_codegen *codegen;
- int vtype;
+ qc_type vtype;
ast_expression *next;
/* arrays get a member-count */
size_t count;
- std::vector<ast_value*> params;
+ std::vector<ast_value*> type_params;
ast_flag_t flags;
/* void foo(string...) gets varparam set as a restriction
ast_value *vfield;
};
-struct ast_value
+struct ast_value : ast_expression
{
- ast_expression expression;
-
const char *name;
const char *desc;
* of constants when an initializer list
* was provided.
*/
- basic_value_t *initlist;
+ std::vector<basic_value_t> initlist;
/* usecount for the parser */
size_t uses;
bool intrinsic; /* true if associated with intrinsic */
};
-ast_value* ast_value_new(lex_ctx_t ctx, const char *name, int qctype);
+ast_value* ast_value_new(lex_ctx_t ctx, const char *name, qc_type qctype);
ast_value* ast_value_copy(const ast_value *self);
/* This will NOT delete an underlying ast_function */
void ast_value_delete(ast_value*);
*
* A value-returning binary expression.
*/
-struct ast_binary
+struct ast_binary : ast_expression
{
- ast_expression expression;
int op;
ast_expression *left;
ast_expression *right;
* An assignment including a binary expression with the source as left operand.
* Eg. a += b; is a binstore { INSTR_STORE, INSTR_ADD, a, b }
*/
-struct ast_binstore
+struct ast_binstore : ast_expression
{
- ast_expression expression;
int opstore;
int opbin;
ast_expression *dest;
*
* Regular unary expressions: not,neg
*/
-struct ast_unary
+struct ast_unary : ast_expression
{
- ast_expression expression;
int op;
ast_expression *operand;
};
* will refuse to create further instructions.
* This should be honored by the parser.
*/
-struct ast_return
+struct ast_return : ast_expression
{
- ast_expression expression;
ast_expression *operand;
};
ast_return* ast_return_new(lex_ctx_t ctx,
* For this we will have to extend the codegen() functions with
* a flag saying whether or not we need an L or an R-value.
*/
-struct ast_entfield
+struct ast_entfield : ast_expression
{
- ast_expression expression;
/* The entity can come from an expression of course. */
ast_expression *entity;
/* As can the field, it just must result in a value of TYPE_FIELD */
* For now used for vectors. If we get structs or unions
* we can have them handled here as well.
*/
-struct ast_member
+struct ast_member : ast_expression
{
- ast_expression expression;
ast_expression *owner;
unsigned int field;
const char *name;
* In any case, accessing an element via a compiletime-constant index will
* result in quick access to that variable.
*/
-struct ast_array_index
+struct ast_array_index : ast_expression
{
- ast_expression expression;
ast_expression *array;
ast_expression *index;
};
*
* copy all varargs starting from a specific index
*/
-struct ast_argpipe
+struct ast_argpipe : ast_expression
{
- ast_expression expression;
ast_expression *index;
};
ast_argpipe* ast_argpipe_new(lex_ctx_t ctx, ast_expression *index);
* Stores left<-right and returns left.
* Specialized binary expression node
*/
-struct ast_store
+struct ast_store : ast_expression
{
- ast_expression expression;
int op;
ast_expression *dest;
ast_expression *source;
/* If
*
- * A general 'if then else' statement, either side can be NULL and will
- * thus be omitted. It is an error for *both* cases to be NULL at once.
+ * A general 'if then else' statement, either side can be nullptr and will
+ * thus be omitted. It is an error for *both* cases to be nullptr at once.
*
* During its 'codegen' it'll be changing the ast_function's block.
*
- * An if is also an "expression". Its codegen will put NULL into the
+ * An if is also an "expression". Its codegen will put nullptr into the
* output field though. For ternary expressions an ast_ternary will be
* added.
*/
-struct ast_ifthen
+struct ast_ifthen : ast_expression
{
- ast_expression expression;
ast_expression *cond;
/* It's all just 'expressions', since an ast_block is one too. */
ast_expression *on_true;
* a PHI node.
*
* The other difference is that in an ast_ternary, NEITHER side
- * must be NULL, there's ALWAYS an else branch.
+ * must be nullptr, there's ALWAYS an else branch.
*
* This is the only ast_node beside ast_value which contains
* an ir_value. Theoretically we don't need to remember it though.
*/
-struct ast_ternary
+struct ast_ternary : ast_expression
{
- ast_expression expression;
ast_expression *cond;
/* It's all just 'expressions', since an ast_block is one too. */
ast_expression *on_true;
{inc};
}
*/
-struct ast_loop
+struct ast_loop : ast_expression
{
- ast_expression expression;
ast_expression *initexpr;
ast_expression *precond;
ast_expression *postcond;
/* Break/Continue
*/
-struct ast_breakcont
+struct ast_breakcont : ast_expression
{
- ast_expression expression;
- bool is_continue;
+ bool is_continue;
unsigned int levels;
};
ast_breakcont* ast_breakcont_new(lex_ctx_t ctx, bool iscont, unsigned int levels);
ast_expression *code;
};
-struct ast_switch
+struct ast_switch : ast_expression
{
- ast_expression expression;
ast_expression *operand;
- ast_switch_case *cases;
+ std::vector<ast_switch_case> cases;
};
ast_switch* ast_switch_new(lex_ctx_t ctx, ast_expression *op);
*
* Introduce a label which can be used together with 'goto'
*/
-struct ast_label
+struct ast_label : ast_expression
{
- ast_expression expression;
const char *name;
ir_block *irblock;
std::vector<ast_goto*> gotos;
*
* Go to a label, the label node is filled in at a later point!
*/
-struct ast_goto
+struct ast_goto : ast_expression
{
- ast_expression expression;
const char *name;
ast_label *target;
ir_block *irblock_from;
*
* For frame/think state updates: void foo() [framenum, nextthink] {}
*/
-struct ast_state
+struct ast_state : ast_expression
{
- ast_expression expression;
ast_expression *framenum;
ast_expression *nextthink;
};
* Additionally it contains a list of ast_expressions as parameters.
* Since calls can return values, an ast_call is also an ast_expression.
*/
-struct ast_call
+struct ast_call : ast_expression
{
- ast_expression expression;
ast_expression *func;
std::vector<ast_expression *> params;
ast_expression *va_count;
/* Blocks
*
*/
-struct ast_block
+struct ast_block : ast_expression
{
- ast_expression expression;
-
- std::vector<ast_value*> locals;
+ std::vector<ast_value*> locals;
std::vector<ast_expression*> exprs;
std::vector<ast_expression*> collect;
};
*/
struct ast_function
{
- ast_node node;
+ ast_node node;
- ast_value *vtype;
+ ast_value *function_type;
const char *name;
int builtin;
/* list of used-up names for statics without the count suffix */
- char **static_names;
+ std::vector<char*> static_names;
/* number of static variables, by convention this includes the
* ones without the count-suffix - remember this when dealing
* with savegames. uint instead of size_t as %zu in printf is
unsigned int static_count;
ir_function *ir_func;
- ir_block *curblock;
- ir_block **breakblocks;
- ir_block **continueblocks;
+ ir_block *curblock;
+ std::vector<ir_block*> breakblocks;
+ std::vector<ir_block*> continueblocks;
- size_t labelcount;
+ size_t labelcount;
/* in order for thread safety - for the optional
* channel abesed multithreading... keeping a buffer
* here to use in ast_function_label.
*/
- char labelbuf[64];
- ast_block* *blocks;
+ char labelbuf[64];
+ std::vector<std::unique_ptr<ast_block>> blocks;
ast_value *varargs;
ast_value *argc;
ast_value *fixedparams;
projects / xonotic / gmqcc.git / blobdiff