mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2025-04-05 17:01:11 +00:00
[qfcc] Defer Ruamoko semantics processing
The main goal was to make it possible to give generic functions definitions (since the code would be very dependent on the actual parameter types), but will also allow for inline functions. It also helped move a lot of the back-end dependent code out of semantics processing and almost completely (if not completely) out of the parser. Possibly more importantly, it gets the dags flushing out of the parser, which means such is now shared by all front-ends. There's probably a lot of dead code in expr.c now, but that can be taken care of another time.
This commit is contained in:
Bill Currie
parent
d08816cb6b
commit
c5d77141eb
22 changed files with 996 additions and 235 deletions
|
|
@ -143,6 +143,11 @@ typedef struct {
|
|||
struct selector_s *sel; ///< selector
|
||||
} ex_selector_t;
|
||||
|
||||
typedef struct {
|
||||
const expr_t *receiver;
|
||||
struct keywordarg_s *message;
|
||||
} ex_message_t;
|
||||
|
||||
/** Pointer constant expression.
|
||||
|
||||
Represent a pointer to an absolute address in data space.
|
||||
|
|
@ -279,7 +284,7 @@ typedef struct {
|
|||
|
||||
typedef struct {
|
||||
const expr_t *ret_val;
|
||||
int at_return; ///< return void_return call through void
|
||||
bool at_return; ///< return void_return call through void
|
||||
} ex_return_t;
|
||||
|
||||
typedef struct {
|
||||
|
|
@ -360,18 +365,19 @@ typedef struct {
|
|||
typedef struct {
|
||||
const expr_t *test;
|
||||
const expr_t *body;
|
||||
const expr_t *break_label;
|
||||
const expr_t *continue_label;
|
||||
const expr_t *continue_body;
|
||||
const expr_t *break_label;
|
||||
bool do_while;
|
||||
bool not;
|
||||
} ex_loop_t;
|
||||
|
||||
typedef struct {
|
||||
bool not;
|
||||
const expr_t *test;
|
||||
const expr_t *true_body;
|
||||
const expr_t *els;
|
||||
const expr_t *false_body;
|
||||
rua_loc_t els;
|
||||
bool not;
|
||||
} ex_select_t;
|
||||
|
||||
typedef struct {
|
||||
|
|
@ -380,6 +386,17 @@ typedef struct {
|
|||
ex_list_t operands;
|
||||
} ex_intrinsic_t;
|
||||
|
||||
typedef struct {
|
||||
const expr_t *test;
|
||||
const expr_t *body;
|
||||
const expr_t *break_label;
|
||||
} ex_switch_t;
|
||||
|
||||
typedef struct {
|
||||
const expr_t *value; ///< null if default
|
||||
const expr_t *end_value; ///< for case value ranges (otherwise null)
|
||||
} ex_caselabel_t;
|
||||
|
||||
typedef struct expr_s {
|
||||
expr_t *next;
|
||||
rua_loc_t loc; ///< source location of expression
|
||||
|
|
@ -404,6 +421,7 @@ typedef struct expr_s {
|
|||
ex_temp_t temp; ///< temporary variable expression
|
||||
ex_vector_t vector; ///< vector expression list
|
||||
ex_selector_t selector; ///< selector ref and name
|
||||
ex_message_t message; ///< message receiver and message
|
||||
ex_value_t *value; ///< constant value
|
||||
element_chain_t compound; ///< compound initializer
|
||||
ex_memset_t memset; ///< memset expr params
|
||||
|
|
@ -429,6 +447,8 @@ typedef struct expr_s {
|
|||
ex_loop_t loop; ///< loop construct expression
|
||||
ex_select_t select; ///< selection construct expression
|
||||
ex_intrinsic_t intrinsic; ///< intrinsic intruction expression
|
||||
ex_switch_t switchblock; ///< switch block expression
|
||||
ex_caselabel_t caselabel; ///< case label expression
|
||||
};
|
||||
} expr_t;
|
||||
|
||||
|
|
@ -747,6 +767,7 @@ const float *expr_vector (const expr_t *e) __attribute__((pure));
|
|||
const expr_t *new_vector_list (const expr_t *e);
|
||||
const expr_t *new_vector_list_gather (const type_t *type,
|
||||
const expr_t **elements, int count);
|
||||
const expr_t *new_vector_list_expr (const expr_t *e);
|
||||
const expr_t *new_vector_value (const type_t *ele_type, int width,
|
||||
int count, const expr_t **elements,
|
||||
bool implicit);
|
||||
|
|
@ -976,18 +997,24 @@ expr_t *new_cond_expr (const expr_t *test, const expr_t *true_expr,
|
|||
expr_t *new_field_expr (const expr_t *object, const expr_t *member);
|
||||
expr_t *new_array_expr (const expr_t *base, const expr_t *index);
|
||||
expr_t *new_decl_expr (specifier_t spec, symtab_t *symtab);
|
||||
expr_t *new_decl (symbol_t *sym, const expr_t *init);
|
||||
expr_t *append_decl (expr_t *decl, symbol_t *sym, const expr_t *init);
|
||||
expr_t *append_decl_list (expr_t *decl, const expr_t *list);
|
||||
|
||||
expr_t *new_loop_expr (bool not, bool do_while,
|
||||
const expr_t *test, const expr_t *body,
|
||||
const expr_t *break_label, const expr_t *continue_label);
|
||||
const expr_t *continue_label,
|
||||
const expr_t *continue_body,
|
||||
const expr_t *break_label);
|
||||
|
||||
expr_t *new_select_expr (bool not, const expr_t *test,
|
||||
const expr_t *true_body,
|
||||
const expr_t *els, const expr_t *false_body);
|
||||
|
||||
expr_t *new_intrinsic_expr (const expr_t *expr_list);
|
||||
expr_t *new_switch_expr (const expr_t *test, const expr_t *body,
|
||||
const expr_t *break_label);
|
||||
expr_t *new_caselabel_expr (const expr_t *value, const expr_t *end_value);
|
||||
|
||||
/** Create an expression of the correct type that references the specified
|
||||
parameter slot.
|
||||
|
|
@ -1027,7 +1054,7 @@ const expr_t *convert_nil (const expr_t *e, const type_t *t) __attribute__((warn
|
|||
|
||||
const expr_t *test_expr (const expr_t *e);
|
||||
void backpatch (ex_boollist_t *list, const expr_t *label);
|
||||
const expr_t *convert_bool (const expr_t *e, int block) __attribute__((warn_unused_result));
|
||||
const expr_t *convert_bool (const expr_t *e, bool block) __attribute__((warn_unused_result));
|
||||
const expr_t *convert_from_bool (const expr_t *e, const type_t *type) __attribute__((warn_unused_result));
|
||||
const expr_t *bool_expr (int op, const expr_t *label, const expr_t *e1,
|
||||
const expr_t *e2);
|
||||
|
|
@ -1085,6 +1112,8 @@ const expr_t *encode_expr (const type_t *type);
|
|||
const expr_t *super_expr (struct class_type_s *class_type);
|
||||
const expr_t *message_expr (const expr_t *receiver,
|
||||
struct keywordarg_s *message);
|
||||
const expr_t *new_message_expr (const expr_t *receiver,
|
||||
struct keywordarg_s *message);
|
||||
const expr_t *sizeof_expr (const expr_t *expr, const type_t *type);
|
||||
|
||||
const expr_t *fold_constants (const expr_t *e);
|
||||
|
|
|
|||
|
|
@ -50,6 +50,7 @@ EX_EXPR(symbol) ///< non-temporary variable (::symbol_t)
|
|||
EX_EXPR(temp) ///< temporary variable (::ex_temp_t)
|
||||
EX_EXPR(vector) ///< "vector" expression (::ex_vector_t)
|
||||
EX_EXPR(selector) ///< selector expression (::ex_selector_t)
|
||||
EX_EXPR(message) ///< message expression (::ex_message_t)
|
||||
EX_EXPR(nil) ///< umm, nil, null. nuff said (0 of any type)
|
||||
EX_EXPR(value) ///< constant value (::ex_value_t)
|
||||
EX_EXPR(compound) ///< compound initializer
|
||||
|
|
@ -77,6 +78,8 @@ EX_EXPR(decl) ///< delcaration expression (::ex_array_t)
|
|||
EX_EXPR(loop) ///< loop construct expression (::ex_loop_t)
|
||||
EX_EXPR(select) ///< select construct expression (::ex_select_t)
|
||||
EX_EXPR(intrinsic) ///< intrinsic instruction expression (::ex_intrinsic_t)
|
||||
EX_EXPR(switch) ///< switch expression (::ex_switch_t)
|
||||
EX_EXPR(caselabel) ///< case expression (::ex_caselabel_t)
|
||||
|
||||
#undef EX_EXPR
|
||||
|
||||
|
|
|
|||
|
|
@ -217,4 +217,8 @@ extern language_t lang_pascal;
|
|||
|
||||
int qc_parse_string (const char *str);
|
||||
|
||||
void rua_parse_declaration (specifier_t spec, symbol_t *sym,
|
||||
const expr_t *init, symtab_t *symtab,
|
||||
expr_t *block);
|
||||
|
||||
#endif//__rua_lang_h
|
||||
|
|
|
|||
|
|
@ -36,7 +36,6 @@ extern struct class_type_s *current_class;
|
|||
extern enum vis_e current_visibility;
|
||||
extern enum storage_class_e current_storage;
|
||||
extern struct symtab_s *current_symtab;
|
||||
extern bool no_flush_dag;
|
||||
|
||||
struct symbol_s *check_redefined (struct symbol_s *sym);
|
||||
extern struct symbol_s *check_undefined (struct symbol_s *sym);
|
||||
|
|
|
|||
|
|
@ -45,6 +45,9 @@ typedef struct {
|
|||
|
||||
const expr_t *(*initialized_temp) (const type_t *type, const expr_t *src);
|
||||
const expr_t *(*assign_vector) (const expr_t *dst, const expr_t *src);
|
||||
const expr_t *(*proc_switch) (const expr_t *expr);
|
||||
const expr_t *(*proc_caselabel) (const expr_t *expr);
|
||||
const expr_t *(*proc_address) (const expr_t *expr);
|
||||
|
||||
unsigned label_id;
|
||||
} target_t;
|
||||
|
|
@ -57,4 +60,9 @@ extern target_t spirv_target;
|
|||
|
||||
bool target_set_backend (const char *tgt);
|
||||
|
||||
const expr_t *ruamoko_proc_switch (const expr_t *expr);
|
||||
const expr_t *ruamoko_proc_caselabel (const expr_t *expr);
|
||||
const expr_t *ruamoko_field_array (const expr_t *e);
|
||||
const expr_t *ruamoko_proc_address (const expr_t *expr);
|
||||
|
||||
#endif//__target_h
|
||||
|
|
|
|||
|
|
@ -73,6 +73,7 @@ qfcc_SOURCES = \
|
|||
tools/qfcc/source/qp-lex.l \
|
||||
tools/qfcc/source/qp-parse.y \
|
||||
tools/qfcc/source/reloc.c \
|
||||
tools/qfcc/source/rua-declaration.c \
|
||||
tools/qfcc/source/shared.c \
|
||||
tools/qfcc/source/statements.c \
|
||||
tools/qfcc/source/strpool.c \
|
||||
|
|
|
|||
|
|
@ -349,6 +349,22 @@ print_type_expr (dstring_t *dstr, const expr_t *e, int level, int id,
|
|||
str, e->loc.line);
|
||||
}
|
||||
|
||||
static void
|
||||
print_incop (dstring_t *dstr, const expr_t *e, int level, int id,
|
||||
const expr_t *next)
|
||||
{
|
||||
int indent = level * 2 + 2;
|
||||
|
||||
dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"m\"];\n", indent, "", e,
|
||||
e->incop.expr);
|
||||
_print_expr (dstr, e->incop.expr, level, id, next);
|
||||
const char *b = e->incop.postop ? "Q" : "";
|
||||
const char *a = e->incop.postop ? "" : "Q";
|
||||
int op = e->incop.op;
|
||||
dasprintf (dstr, "%*se_%p [label=\"%s%c%c%s\\n%d\"];\n", indent, "", e,
|
||||
b, op, op, a, e->loc.line);
|
||||
}
|
||||
|
||||
static void
|
||||
print_cond (dstring_t *dstr, const expr_t *e, int level, int id,
|
||||
const expr_t *next)
|
||||
|
|
@ -400,6 +416,23 @@ print_array (dstring_t *dstr, const expr_t *e, int level, int id,
|
|||
"[]", e->loc.line);
|
||||
}
|
||||
|
||||
static void
|
||||
print_decl (dstring_t *dstr, const expr_t *e, int level, int id,
|
||||
const expr_t *next)
|
||||
{
|
||||
int indent = level * 2 + 2;
|
||||
|
||||
for (auto l = e->decl.list.head; l; l = l->next) {
|
||||
_print_expr (dstr, l->expr, level, id, next);
|
||||
}
|
||||
for (auto l = e->decl.list.head; l; l = l->next) {
|
||||
dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"b\"];\n", indent, "", e,
|
||||
l->expr);
|
||||
}
|
||||
dasprintf (dstr, "%*se_%p [label=\"decl:%s\\n%d\"];\n", indent, "", e,
|
||||
get_type_string (e->decl.spec.type), e->loc.line);
|
||||
}
|
||||
|
||||
static void
|
||||
print_select (dstring_t *dstr, const expr_t *e, int level, int id,
|
||||
const expr_t *next)
|
||||
|
|
@ -450,8 +483,10 @@ print_subexpr (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t
|
|||
e->expr.e1);
|
||||
dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"r\"];\n", indent, "", e,
|
||||
e->expr.e2);
|
||||
dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e,
|
||||
get_op_string (e->expr.op), e->loc.line);
|
||||
const char *o = e->paren ? "(" : "";
|
||||
const char *c = e->paren ? ")" : "";
|
||||
dasprintf (dstr, "%*se_%p [label=\"%s%s%s\\n%d\"];\n", indent, "", e,
|
||||
o, get_op_string (e->expr.op), c, e->loc.line);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -889,11 +924,11 @@ _print_expr (dstring_t *dstr, const expr_t *e, int level, int id,
|
|||
[ex_multivec] = print_multivec,
|
||||
[ex_list] = print_list,
|
||||
[ex_type] = print_type_expr,
|
||||
[ex_incop] = nullptr,
|
||||
[ex_incop] = print_incop,
|
||||
[ex_cond] = print_cond,
|
||||
[ex_field] = print_field,
|
||||
[ex_array] = print_array,
|
||||
[ex_decl] = nullptr,
|
||||
[ex_decl] = print_decl,
|
||||
[ex_loop] = nullptr,
|
||||
[ex_select] = print_select,
|
||||
[ex_intrinsic] = print_intrinsic,
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ get_type (const expr_t *e)
|
|||
case ex_labelref:
|
||||
case ex_adjstk:
|
||||
case ex_with:
|
||||
return &type_void;
|
||||
type = &type_void;
|
||||
case ex_memset:
|
||||
return nullptr;
|
||||
case ex_error:
|
||||
|
|
@ -148,25 +148,33 @@ get_type (const expr_t *e)
|
|||
case ex_decl:
|
||||
case ex_loop:
|
||||
case ex_select:
|
||||
internal_error (e, "unexpected expression type");
|
||||
case ex_message:
|
||||
internal_error (e, "unexpected expression type: %s",
|
||||
expr_names[e->type]);
|
||||
case ex_label:
|
||||
case ex_switch:
|
||||
case ex_caselabel:
|
||||
return nullptr;
|
||||
case ex_compound:
|
||||
return e->compound.type;
|
||||
type = e->compound.type;
|
||||
break;
|
||||
case ex_bool:
|
||||
if (options.code.progsversion == PROG_ID_VERSION)
|
||||
return &type_float;
|
||||
return &type_int;
|
||||
case ex_nil:
|
||||
if (e->nil) {
|
||||
return e->nil;
|
||||
type = e->nil;
|
||||
break;
|
||||
}
|
||||
// fall through
|
||||
case ex_state:
|
||||
return &type_void;
|
||||
break;
|
||||
case ex_block:
|
||||
if (e->block.result)
|
||||
if (e->block.result) {
|
||||
return get_type (e->block.result);
|
||||
}
|
||||
return &type_void;
|
||||
case ex_expr:
|
||||
case ex_uexpr:
|
||||
|
|
@ -185,7 +193,8 @@ get_type (const expr_t *e)
|
|||
type = e->value->type;
|
||||
break;
|
||||
case ex_vector:
|
||||
return e->vector.type;
|
||||
type = e->vector.type;
|
||||
break;
|
||||
case ex_selector:
|
||||
return &type_SEL;
|
||||
case ex_alias:
|
||||
|
|
@ -199,13 +208,17 @@ get_type (const expr_t *e)
|
|||
case ex_args:
|
||||
return &type_va_list;
|
||||
case ex_horizontal:
|
||||
return e->hop.type;
|
||||
type = e->hop.type;
|
||||
break;
|
||||
case ex_swizzle:
|
||||
return e->swizzle.type;
|
||||
type = e->swizzle.type;
|
||||
break;
|
||||
case ex_extend:
|
||||
return e->extend.type;
|
||||
type = e->extend.type;
|
||||
break;
|
||||
case ex_multivec:
|
||||
return e->multivec.type;
|
||||
type = e->multivec.type;
|
||||
break;
|
||||
case ex_list:
|
||||
if (e->list.head) {
|
||||
auto last = (ex_listitem_t *) e->list.tail;
|
||||
|
|
@ -221,16 +234,18 @@ get_type (const expr_t *e)
|
|||
//unless one is nil
|
||||
return get_type (e->cond.true_expr);
|
||||
case ex_field:
|
||||
return e->field.type;
|
||||
type = e->field.type;
|
||||
break;
|
||||
case ex_array:
|
||||
return e->array.type;
|
||||
type = e->array.type;
|
||||
break;
|
||||
case ex_intrinsic:
|
||||
type = e->intrinsic.res_type;
|
||||
break;
|
||||
case ex_count:
|
||||
internal_error (e, "invalid expression");
|
||||
}
|
||||
return unalias_type (type);
|
||||
return type ? unalias_type (type) : nullptr;
|
||||
}
|
||||
|
||||
etype_t
|
||||
|
|
@ -1987,6 +2002,8 @@ has_function_call (const expr_t *e)
|
|||
return has_function_call (e->swizzle.src);
|
||||
case ex_extend:
|
||||
return has_function_call (e->extend.src);
|
||||
case ex_message:
|
||||
return true;
|
||||
case ex_error:
|
||||
case ex_state:
|
||||
case ex_label:
|
||||
|
|
@ -2008,6 +2025,7 @@ has_function_call (const expr_t *e)
|
|||
case ex_loop:
|
||||
case ex_select:
|
||||
case ex_intrinsic:
|
||||
case ex_caselabel:
|
||||
return false;
|
||||
case ex_multivec:
|
||||
for (auto c = e->multivec.components.head; c; c = c->next) {
|
||||
|
|
@ -2027,6 +2045,8 @@ has_function_call (const expr_t *e)
|
|||
case ex_array:
|
||||
return (has_function_call (e->array.base)
|
||||
|| has_function_call (e->array.index));
|
||||
case ex_switch:
|
||||
return has_function_call (e->switchblock.test);
|
||||
case ex_count:
|
||||
break;
|
||||
}
|
||||
|
|
@ -2125,6 +2145,16 @@ new_call_expr (const expr_t *func, const expr_t *args, const type_t *ret_type)
|
|||
return branch;
|
||||
}
|
||||
|
||||
const expr_t *
|
||||
new_message_expr (const expr_t *receiver, struct keywordarg_s *message)
|
||||
{
|
||||
auto msg = new_expr ();
|
||||
msg->type = ex_message;
|
||||
msg->message.receiver = receiver;
|
||||
msg->message.message = message;
|
||||
return msg;
|
||||
}
|
||||
|
||||
const expr_t *
|
||||
conditional_expr (const expr_t *cond, const expr_t *e1, const expr_t *e2)
|
||||
{
|
||||
|
|
@ -2135,7 +2165,7 @@ conditional_expr (const expr_t *cond, const expr_t *e1, const expr_t *e2)
|
|||
if (e2->type == ex_error)
|
||||
return e2;
|
||||
|
||||
expr_t *c = (expr_t *) convert_bool (cond, 1);
|
||||
expr_t *c = (expr_t *) convert_bool (cond, true);
|
||||
if (c->type == ex_error)
|
||||
return c;
|
||||
|
||||
|
|
@ -2247,15 +2277,17 @@ new_decl_expr (specifier_t spec, symtab_t *symtab)
|
|||
expr_t *
|
||||
new_loop_expr (bool not, bool do_while,
|
||||
const expr_t *test, const expr_t *body,
|
||||
const expr_t *break_label, const expr_t *continue_label)
|
||||
const expr_t *continue_label, const expr_t *continue_body,
|
||||
const expr_t *break_label)
|
||||
{
|
||||
auto loop = new_expr ();
|
||||
loop->type = ex_loop;
|
||||
loop->loop = (ex_loop_t) {
|
||||
.test = test,
|
||||
.body = body,
|
||||
.break_label = break_label,
|
||||
.continue_label = continue_label,
|
||||
.continue_body = continue_body,
|
||||
.break_label = break_label,
|
||||
.do_while = do_while,
|
||||
.not = not,
|
||||
};
|
||||
|
|
@ -2271,14 +2303,12 @@ new_select_expr (bool not, const expr_t *test,
|
|||
auto select = new_expr ();
|
||||
select->type = ex_select;
|
||||
select->select = (ex_select_t) {
|
||||
.not = not,
|
||||
.test = test,
|
||||
.true_body = true_body,
|
||||
.els = els,
|
||||
.false_body = false_body,
|
||||
.not = not,
|
||||
};
|
||||
if (els) {
|
||||
select->select.els = els->loc;
|
||||
}
|
||||
return select;
|
||||
}
|
||||
|
||||
|
|
@ -2302,12 +2332,48 @@ new_intrinsic_expr (const expr_t *expr_list)
|
|||
}
|
||||
|
||||
expr_t *
|
||||
append_decl (expr_t *decl, symbol_t *sym, const expr_t *init)
|
||||
new_switch_expr (const expr_t *test, const expr_t *body,
|
||||
const expr_t *break_label)
|
||||
{
|
||||
auto swtch = new_expr ();
|
||||
swtch->type = ex_switch;
|
||||
swtch->switchblock = (ex_switch_t) {
|
||||
.test = test,
|
||||
.body = body,
|
||||
.break_label = break_label,
|
||||
};
|
||||
return swtch;
|
||||
}
|
||||
|
||||
expr_t *
|
||||
new_caselabel_expr (const expr_t *value, const expr_t *end_value)
|
||||
{
|
||||
if (end_value && !value) {
|
||||
internal_error (end_value, "case label with end value but no value");
|
||||
}
|
||||
auto cl = new_expr ();
|
||||
cl->type = ex_caselabel;
|
||||
cl->caselabel = (ex_caselabel_t) {
|
||||
.value = value,
|
||||
.end_value = end_value,
|
||||
};
|
||||
return cl;
|
||||
}
|
||||
|
||||
expr_t *
|
||||
new_decl (symbol_t *sym, const expr_t *init)
|
||||
{
|
||||
auto expr = new_symbol_expr (sym);
|
||||
if (init) {
|
||||
expr = new_assign_expr (expr, init);
|
||||
}
|
||||
return expr;
|
||||
}
|
||||
|
||||
expr_t *
|
||||
append_decl (expr_t *decl, symbol_t *sym, const expr_t *init)
|
||||
{
|
||||
auto expr = new_decl (sym, init);
|
||||
list_append (&decl->decl.list, expr);
|
||||
return decl;
|
||||
}
|
||||
|
|
@ -2406,7 +2472,7 @@ array_expr (const expr_t *array, const expr_t *index)
|
|||
} else {
|
||||
ele_type = base_type (array_type);
|
||||
if (is_matrix (array_type)) {
|
||||
ele_type = vector_type (ele_type, array_type->width);
|
||||
ele_type = column_type (array_type);
|
||||
}
|
||||
if (array->type == ex_uexpr && array->expr.op == '.') {
|
||||
auto vec = offset_pointer_expr (array->expr.e1, index);
|
||||
|
|
@ -2592,7 +2658,7 @@ build_if_statement (bool not, const expr_t *test, const expr_t *s1,
|
|||
|
||||
if_expr = new_block_expr (0);
|
||||
|
||||
test = convert_bool (test, 1);
|
||||
test = convert_bool (test, true);
|
||||
if (test->type != ex_error) {
|
||||
if (not) {
|
||||
backpatch (test->boolean.true_list, fl);
|
||||
|
|
@ -2644,7 +2710,7 @@ build_while_statement (bool not, const expr_t *test, const expr_t *statement,
|
|||
append_expr (while_expr, statement);
|
||||
append_expr (while_expr, continue_label);
|
||||
|
||||
test = convert_bool (test, 1);
|
||||
test = convert_bool (test, true);
|
||||
if (test->type != ex_error) {
|
||||
if (not) {
|
||||
backpatch (test->boolean.true_list, l2);
|
||||
|
|
@ -2684,7 +2750,7 @@ build_do_while_statement (const expr_t *statement, bool not, const expr_t *test,
|
|||
append_expr (do_while_expr, statement);
|
||||
append_expr (do_while_expr, continue_label);
|
||||
|
||||
test = convert_bool (test, 1);
|
||||
test = convert_bool (test, true);
|
||||
if (test->type != ex_error) {
|
||||
if (not) {
|
||||
backpatch (test->boolean.true_list, break_label);
|
||||
|
|
@ -2737,7 +2803,7 @@ build_for_statement (const expr_t *init, const expr_t *test, const expr_t *next,
|
|||
append_expr (for_expr, next);
|
||||
if (test) {
|
||||
append_expr (for_expr, l1);
|
||||
test = convert_bool (test, 1);
|
||||
test = convert_bool (test, true);
|
||||
if (test->type != ex_error) {
|
||||
backpatch (test->boolean.true_list, tl);
|
||||
backpatch (test->boolean.false_list, fl);
|
||||
|
|
|
|||
|
|
@ -122,6 +122,7 @@ is_lvalue (const expr_t *expr)
|
|||
case ex_value:
|
||||
case ex_error:
|
||||
case ex_selector:
|
||||
case ex_message:
|
||||
case ex_return:
|
||||
case ex_adjstk:
|
||||
case ex_with:
|
||||
|
|
@ -137,6 +138,8 @@ is_lvalue (const expr_t *expr)
|
|||
case ex_loop:
|
||||
case ex_select:
|
||||
case ex_intrinsic:
|
||||
case ex_switch:
|
||||
case ex_caselabel:
|
||||
break;
|
||||
case ex_cond:
|
||||
return (is_lvalue (expr->cond.true_expr)
|
||||
|
|
|
|||
|
|
@ -788,7 +788,7 @@ binary_expr (int op, const expr_t *e1, const expr_t *e2)
|
|||
}
|
||||
|
||||
if ((unsigned) op > countof (expr_types) || !expr_types[op]) {
|
||||
internal_error (e1, "invalid operator: %d", op);
|
||||
internal_error (e1, "invalid operator: %s", get_op_string (op));
|
||||
}
|
||||
expr_type_t *expr_type = expr_types[op];
|
||||
for (; expr_type->match_a; expr_type++) {
|
||||
|
|
|
|||
|
|
@ -218,11 +218,11 @@ bool_expr (int op, const expr_t *label, const expr_t *e1, const expr_t *e2)
|
|||
if (!options.code.short_circuit)
|
||||
return binary_expr (op, e1, e2);
|
||||
|
||||
e1 = convert_bool (e1, 0);
|
||||
e1 = convert_bool (e1, false);
|
||||
if (e1->type == ex_error)
|
||||
return e1;
|
||||
|
||||
e2 = convert_bool (e2, 0);
|
||||
e2 = convert_bool (e2, false);
|
||||
if (e2->type == ex_error)
|
||||
return e2;
|
||||
|
||||
|
|
@ -258,7 +258,7 @@ has_block_expr (const expr_t *e)
|
|||
}
|
||||
|
||||
const expr_t *
|
||||
convert_bool (const expr_t *e, int block)
|
||||
convert_bool (const expr_t *e, bool block)
|
||||
{
|
||||
if (e->type == ex_assign) {
|
||||
if (!e->paren && options.warnings.precedence)
|
||||
|
|
@ -272,7 +272,7 @@ convert_bool (const expr_t *e, int block)
|
|||
} else if (has_block_expr (tst)) {
|
||||
tst = e->assign.dst;
|
||||
}
|
||||
auto b = convert_bool (tst, 1);
|
||||
auto b = convert_bool (tst, true);
|
||||
if (b->type == ex_error)
|
||||
return b;
|
||||
// insert the assignment into the boolean's block
|
||||
|
|
@ -282,7 +282,7 @@ convert_bool (const expr_t *e, int block)
|
|||
|
||||
if (e->type == ex_uexpr && e->expr.op == '!'
|
||||
&& !is_string(get_type (e->expr.e1))) {
|
||||
e = convert_bool (e->expr.e1, 0);
|
||||
e = convert_bool (e->expr.e1, false);
|
||||
if (e->type == ex_error)
|
||||
return (expr_t *) e;
|
||||
e = unary_expr ('!', e);
|
||||
|
|
|
|||
|
|
@ -488,6 +488,6 @@ at_return_expr (function_t *f, const expr_t *e)
|
|||
return error (e, "@return function not void_return");
|
||||
}
|
||||
expr_t *ret_expr = new_return_expr (e);
|
||||
ret_expr->retrn.at_return = 1;
|
||||
ret_expr->retrn.at_return = true;
|
||||
return ret_expr;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -98,7 +98,6 @@ cast_expr (const type_t *dstType, const expr_t *e)
|
|||
return convert_nil (e, dstType);
|
||||
}
|
||||
|
||||
dstType = unalias_type (dstType);
|
||||
srcType = get_type (e);
|
||||
|
||||
if (is_reference (srcType)) {
|
||||
|
|
@ -106,8 +105,9 @@ cast_expr (const type_t *dstType, const expr_t *e)
|
|||
e = pointer_deref (e);
|
||||
}
|
||||
|
||||
if (dstType == srcType)
|
||||
if (type_same (dstType, srcType)) {
|
||||
return e;
|
||||
}
|
||||
|
||||
if ((dstType == type_default && is_enum (srcType))
|
||||
|| (is_enum (dstType) && srcType == type_default))
|
||||
|
|
@ -155,7 +155,8 @@ cast_expr (const type_t *dstType, const expr_t *e)
|
|||
return cast_error (e, srcType, dstType);
|
||||
}
|
||||
if (is_array (srcType)) {
|
||||
return address_expr (e, dstType->fldptr.type);
|
||||
dstType = dereference_type (dstType);
|
||||
return address_expr (e, dstType);
|
||||
}
|
||||
if (is_short (srcType)) {
|
||||
e = new_int_expr (expr_short (e), false);
|
||||
|
|
|
|||
|
|
@ -72,6 +72,7 @@ edag_add_expr (const expr_t *expr)
|
|||
case ex_compound:
|
||||
case ex_memset:
|
||||
case ex_branch:
|
||||
case ex_message:
|
||||
case ex_inout:
|
||||
case ex_return:
|
||||
case ex_adjstk:
|
||||
|
|
@ -83,6 +84,8 @@ edag_add_expr (const expr_t *expr)
|
|||
case ex_loop:
|
||||
case ex_select:
|
||||
case ex_intrinsic:
|
||||
case ex_switch:
|
||||
case ex_caselabel:
|
||||
// these are never put in the dag
|
||||
return expr;
|
||||
case ex_list:
|
||||
|
|
|
|||
|
|
@ -37,10 +37,12 @@
|
|||
#include "tools/qfcc/include/class.h"
|
||||
#include "tools/qfcc/include/diagnostic.h"
|
||||
#include "tools/qfcc/include/expr.h"
|
||||
#include "tools/qfcc/include/method.h"
|
||||
#include "tools/qfcc/include/qfcc.h"
|
||||
#include "tools/qfcc/include/rua-lang.h"
|
||||
#include "tools/qfcc/include/shared.h"
|
||||
#include "tools/qfcc/include/symtab.h"
|
||||
#include "tools/qfcc/include/target.h"
|
||||
#include "tools/qfcc/include/type.h"
|
||||
#include "tools/qfcc/include/value.h"
|
||||
|
||||
|
|
@ -49,6 +51,12 @@ typedef const expr_t *(*process_f) (const expr_t *expr);
|
|||
static const expr_t *
|
||||
proc_expr (const expr_t *expr)
|
||||
{
|
||||
scoped_src_loc (expr);
|
||||
if (expr->expr.op == 'C') {
|
||||
auto type = resolve_type (expr->expr.e1);
|
||||
expr = expr_process (expr->expr.e2);
|
||||
return cast_expr (type, expr);
|
||||
}
|
||||
auto e1 = expr_process (expr->expr.e1);
|
||||
auto e2 = expr_process (expr->expr.e2);
|
||||
if (is_error (e1)) {
|
||||
|
|
@ -58,19 +66,39 @@ proc_expr (const expr_t *expr)
|
|||
return e2;
|
||||
}
|
||||
|
||||
scoped_src_loc (expr);
|
||||
return binary_expr (expr->expr.op, e1, e2);
|
||||
if (expr->expr.op == QC_AND || expr->expr.op == QC_OR) {
|
||||
auto label = new_label_expr ();
|
||||
return bool_expr (expr->expr.op, label, e1, e2);
|
||||
}
|
||||
|
||||
auto e = binary_expr (expr->expr.op, e1, e2);
|
||||
if (expr->paren) {
|
||||
e = paren_expr (e);
|
||||
}
|
||||
return e;
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_uexpr (const expr_t *expr)
|
||||
{
|
||||
scoped_src_loc (expr);
|
||||
if (expr->expr.op == '&') {
|
||||
return current_target.proc_address (expr);
|
||||
}
|
||||
auto e1 = expr_process (expr->expr.e1);
|
||||
if (is_error (e1)) {
|
||||
return e1;
|
||||
}
|
||||
if (expr->expr.op == 'S') {
|
||||
const type_t *type;
|
||||
if (e1->type == ex_type) {
|
||||
type = e1->typ.type;
|
||||
} else {
|
||||
type = get_type (e1);
|
||||
}
|
||||
return sizeof_expr (nullptr, type);
|
||||
}
|
||||
|
||||
scoped_src_loc (expr);
|
||||
return unary_expr (expr->expr.op, e1);
|
||||
}
|
||||
|
||||
|
|
@ -122,9 +150,26 @@ proc_field (const expr_t *expr)
|
|||
return algebra_field_expr (object, member);
|
||||
}
|
||||
if (is_entity (obj_type)) {
|
||||
obj_type = &type_entity;
|
||||
}
|
||||
if (is_nonscalar (obj_type)) {
|
||||
symbol_t *field = nullptr;
|
||||
if (member->type == ex_symbol) {
|
||||
field = get_struct_field (&type_entity, object, member);
|
||||
}
|
||||
if (field) {
|
||||
member = new_deffield_expr (0, field->type, field->def);
|
||||
return typed_binary_expr (field->type, '.', object, member);
|
||||
} else {
|
||||
member = expr_process (member);
|
||||
if (is_error (member)) {
|
||||
return member;
|
||||
}
|
||||
auto mem_type = get_type (member);
|
||||
if (is_field (mem_type)) {
|
||||
mem_type = dereference_type (mem_type);
|
||||
return typed_binary_expr (mem_type, '.', object, member);
|
||||
}
|
||||
}
|
||||
return type_mismatch (object, member, '.');
|
||||
} else if (is_nonscalar (obj_type)) {
|
||||
auto field = get_struct_field (obj_type, object, member);
|
||||
if (!field) {
|
||||
if (member->type != ex_symbol) {
|
||||
|
|
@ -204,6 +249,7 @@ proc_block (const expr_t *expr)
|
|||
const expr_t *out[count + 1];
|
||||
list_scatter (&expr->block.list, in);
|
||||
for (int i = 0; i < count; i++) {
|
||||
edag_flush ();
|
||||
auto e = expr_process (in[i]);
|
||||
if (e && !is_error (e)) {
|
||||
out[num_out++] = e;
|
||||
|
|
@ -212,6 +258,7 @@ proc_block (const expr_t *expr)
|
|||
}
|
||||
}
|
||||
}
|
||||
edag_flush ();
|
||||
|
||||
scoped_src_loc (expr);
|
||||
auto block = new_block_expr (nullptr);
|
||||
|
|
@ -245,13 +292,17 @@ proc_do_list (ex_list_t *out, const ex_list_t *in)
|
|||
const expr_t *exprs[count + 1] = {};
|
||||
list_scatter (in, exprs);
|
||||
bool ok = true;
|
||||
int new_count = 0;
|
||||
for (int i = 0; i < count; i++) {
|
||||
exprs[i] = expr_process (exprs[i]);
|
||||
exprs[new_count] = expr_process (exprs[i]);
|
||||
// keep null expressions out of the list (non-local declarations
|
||||
// or local declarations without initializers return null)
|
||||
new_count += !!exprs[new_count];
|
||||
if (is_error (exprs[i])) {
|
||||
ok = false;
|
||||
}
|
||||
}
|
||||
list_gather (out, exprs, count);
|
||||
list_gather (out, exprs, new_count);
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
|
@ -259,13 +310,38 @@ static const expr_t *
|
|||
proc_vector (const expr_t *expr)
|
||||
{
|
||||
scoped_src_loc (expr);
|
||||
auto vec = new_expr ();
|
||||
vec->type = ex_vector;
|
||||
vec->vector.type = expr->vector.type;
|
||||
if (!proc_do_list (&vec->vector.list, &expr->vector.list)) {
|
||||
auto list = new_expr ();
|
||||
list->type = ex_list;
|
||||
if (!proc_do_list (&list->list, &expr->vector.list)) {
|
||||
return new_error_expr ();
|
||||
}
|
||||
return vec;
|
||||
return new_vector_list (list);
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_selector (const expr_t *expr)
|
||||
{
|
||||
return expr;
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_message (const expr_t *expr)
|
||||
{
|
||||
auto receiver = expr_process (expr->message.receiver);
|
||||
auto message = expr->message.message;
|
||||
scoped_src_loc (receiver);
|
||||
for (auto k = message; k; k = k->next) {
|
||||
if (k->expr) {
|
||||
k->expr = (expr_t *) expr_process (k->expr);
|
||||
}
|
||||
}
|
||||
return message_expr (receiver, message);
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_nil (const expr_t *expr)
|
||||
{
|
||||
return expr;
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
|
|
@ -298,7 +374,11 @@ proc_assign (const expr_t *expr)
|
|||
return src;
|
||||
}
|
||||
scoped_src_loc (expr);
|
||||
return assign_expr (dst, src);
|
||||
auto assign = assign_expr (dst, src);
|
||||
if (expr->paren) {
|
||||
assign = paren_expr (assign);
|
||||
}
|
||||
return assign;
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
|
|
@ -306,9 +386,13 @@ proc_branch (const expr_t *expr)
|
|||
{
|
||||
scoped_src_loc (expr);
|
||||
if (expr->branch.type == pr_branch_call) {
|
||||
auto args = new_list_expr (nullptr);
|
||||
proc_do_list (&args->list, &expr->branch.args->list);
|
||||
return function_expr (expr->branch.target, args);
|
||||
auto target = expr_process (expr->branch.target);
|
||||
auto args = (expr_t *) expr->branch.args;
|
||||
if (expr->branch.args) {
|
||||
args = new_list_expr (nullptr);
|
||||
proc_do_list (&args->list, &expr->branch.args->list);
|
||||
}
|
||||
return function_expr (target, args);
|
||||
} else {
|
||||
auto branch = new_expr ();
|
||||
branch->type = ex_branch;
|
||||
|
|
@ -344,6 +428,40 @@ proc_return (const expr_t *expr)
|
|||
}
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_list (const expr_t *expr)
|
||||
{
|
||||
scoped_src_loc (expr);
|
||||
auto list = new_list_expr (nullptr);
|
||||
if (!proc_do_list (&list->list, &expr->list)) {
|
||||
return new_error_expr ();
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_type (const expr_t *expr)
|
||||
{
|
||||
scoped_src_loc (expr);
|
||||
auto type = resolve_type (expr);
|
||||
return new_type_expr (type);
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_incop (const expr_t *expr)
|
||||
{
|
||||
scoped_src_loc (expr);
|
||||
auto e = expr_process (expr->incop.expr);
|
||||
if (is_error (e)) {
|
||||
return e;
|
||||
}
|
||||
if (!is_lvalue (e)) {
|
||||
return error (expr, "invalid lvalue for %c%c",
|
||||
expr->incop.op, expr->incop.op);
|
||||
}
|
||||
return new_incop_expr (expr->incop.op, e, expr->incop.postop);
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_cond (const expr_t *expr)
|
||||
{
|
||||
|
|
@ -405,6 +523,7 @@ proc_decl (const expr_t *expr)
|
|||
auto symtab = expr->decl.symtab;
|
||||
current_language.parse_declaration (spec, sym, init, symtab, block);
|
||||
}
|
||||
edag_flush ();
|
||||
return block;
|
||||
}
|
||||
|
||||
|
|
@ -413,13 +532,14 @@ proc_loop (const expr_t *expr)
|
|||
{
|
||||
auto test = expr_process (expr->loop.test);
|
||||
auto body = expr_process (expr->loop.body);
|
||||
auto break_label = expr->loop.break_label;
|
||||
auto continue_label = expr->loop.continue_label;
|
||||
auto continue_body = expr_process (expr->loop.continue_body);
|
||||
auto break_label = expr->loop.break_label;
|
||||
bool do_while = expr->loop.do_while;
|
||||
bool not = expr->loop.not;
|
||||
scoped_src_loc (expr);
|
||||
return new_loop_expr (not, do_while, test, body,
|
||||
break_label, continue_label);
|
||||
continue_label, continue_body, break_label);
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
|
|
@ -456,6 +576,18 @@ proc_intrinsic (const expr_t *expr)
|
|||
return e;
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_switch (const expr_t *expr)
|
||||
{
|
||||
return current_target.proc_switch (expr);
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
proc_caselabel (const expr_t *expr)
|
||||
{
|
||||
return current_target.proc_caselabel (expr);
|
||||
}
|
||||
|
||||
const expr_t *
|
||||
expr_process (const expr_t *expr)
|
||||
{
|
||||
|
|
@ -469,11 +601,17 @@ expr_process (const expr_t *expr)
|
|||
[ex_uexpr] = proc_uexpr,
|
||||
[ex_symbol] = proc_symbol,
|
||||
[ex_vector] = proc_vector,
|
||||
[ex_selector] = proc_selector,
|
||||
[ex_message] = proc_message,
|
||||
[ex_nil] = proc_nil,
|
||||
[ex_value] = proc_value,
|
||||
[ex_compound] = proc_compound,
|
||||
[ex_assign] = proc_assign,
|
||||
[ex_branch] = proc_branch,
|
||||
[ex_return] = proc_return,
|
||||
[ex_list] = proc_list,
|
||||
[ex_type] = proc_type,
|
||||
[ex_incop] = proc_incop,
|
||||
[ex_cond] = proc_cond,
|
||||
[ex_field] = proc_field,
|
||||
[ex_array] = proc_array,
|
||||
|
|
@ -481,6 +619,8 @@ expr_process (const expr_t *expr)
|
|||
[ex_loop] = proc_loop,
|
||||
[ex_select] = proc_select,
|
||||
[ex_intrinsic] = proc_intrinsic,
|
||||
[ex_switch] = proc_switch,
|
||||
[ex_caselabel] = proc_caselabel,
|
||||
};
|
||||
|
||||
if (expr->type >= ex_count) {
|
||||
|
|
|
|||
|
|
@ -78,6 +78,18 @@ new_vector_list_gather (const type_t *type, const expr_t **elements, int count)
|
|||
return vec;
|
||||
}
|
||||
|
||||
const expr_t *
|
||||
new_vector_list_expr (const expr_t *e)
|
||||
{
|
||||
if (e->type != ex_list) {
|
||||
internal_error (e, "not a list");
|
||||
}
|
||||
int count = list_count (&e->list);
|
||||
const expr_t *elements[count + 1] = {};
|
||||
list_scatter (&e->list, elements);
|
||||
return new_vector_list_gather (nullptr, elements, count);
|
||||
}
|
||||
|
||||
const expr_t *
|
||||
new_vector_list (const expr_t *expr_list)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -186,6 +186,8 @@ int yylex (YYSTYPE *yylval, YYLTYPE *yylloc);
|
|||
%type <spec> type_ref_spec
|
||||
%type <expr> generic_type
|
||||
%type <mut_expr> type_list type_param_list
|
||||
%type <expr> initdecl notype_initdecl
|
||||
%type <mut_expr> initdecls notype_initdecls
|
||||
|
||||
%type <attribute> attribute_list attribute
|
||||
|
||||
|
|
@ -208,7 +210,7 @@ int yylex (YYSTYPE *yylval, YYLTYPE *yylloc);
|
|||
%type <symbol> methoddef
|
||||
%type <expr> var_initializer local_def
|
||||
|
||||
%type <mut_expr> opt_init_semi opt_expr comma_expr
|
||||
%type <expr> opt_init_semi opt_expr comma_expr
|
||||
%type <expr> expr
|
||||
%type <expr> compound_init
|
||||
%type <spec> opt_cast
|
||||
|
|
@ -216,15 +218,15 @@ int yylex (YYSTYPE *yylval, YYLTYPE *yylloc);
|
|||
%type <designator> designator designator_spec
|
||||
%type <element> element
|
||||
%type <expr> method_optional_state_expr optional_state_expr
|
||||
%type <expr> texpr vector_expr
|
||||
%type <expr> vector_expr
|
||||
%type <expr> intrinsic
|
||||
%type <expr> statement
|
||||
%type <mut_expr> statements compound_statement compound_statement_ns
|
||||
%type <expr> else bool_label break_label continue_label
|
||||
%type <mut_expr> statement_list compound_statement compound_statement_ns
|
||||
%type <mut_expr> new_block new_scope
|
||||
%type <expr> else line break_label continue_label
|
||||
%type <expr> unary_expr ident_expr cast_expr
|
||||
%type <mut_expr> arg_list
|
||||
%type <expr> opt_arg_list arg_expr
|
||||
%type <switch_block> switch_block
|
||||
%type <symbol> identifier label
|
||||
|
||||
%type <mut_expr> identifier_list
|
||||
|
|
@ -246,7 +248,6 @@ int yylex (YYSTYPE *yylval, YYLTYPE *yylloc);
|
|||
|
||||
%{
|
||||
|
||||
static switch_block_t *switch_block;
|
||||
static const expr_t *break_label;
|
||||
static const expr_t *continue_label;
|
||||
static bool generic_scope, generic_block;
|
||||
|
|
@ -652,6 +653,15 @@ check_specifiers (specifier_t spec)
|
|||
}
|
||||
}
|
||||
|
||||
static const expr_t *
|
||||
decl_expr (specifier_t spec, const expr_t *init)
|
||||
{
|
||||
auto sym = spec.sym;
|
||||
spec.sym = nullptr;
|
||||
auto decl = new_decl_expr (spec, current_symtab);
|
||||
return append_decl (decl, sym, init);
|
||||
}
|
||||
|
||||
%}
|
||||
|
||||
%expect 2
|
||||
|
|
@ -706,8 +716,17 @@ fndef
|
|||
|
||||
datadef
|
||||
: defspecs notype_initdecls ';'
|
||||
{
|
||||
expr_process ($2);
|
||||
}
|
||||
| declspecs_nots notype_initdecls ';'
|
||||
{
|
||||
expr_process ($2);
|
||||
}
|
||||
| declspecs_ts initdecls ';'
|
||||
{
|
||||
expr_process ($2);
|
||||
}
|
||||
| declspecs_ts qc_func_params
|
||||
{
|
||||
$<spec>$ = qc_function_spec ($1, $2);
|
||||
|
|
@ -810,7 +829,7 @@ qc_nocode_func
|
|||
: identifier '=' '#' expr
|
||||
{
|
||||
specifier_t spec = qc_set_symbol ($<spec>0, $1);
|
||||
const expr_t *bi_val = $4;
|
||||
const expr_t *bi_val = expr_process ($4);
|
||||
|
||||
symbol_t *sym = function_symbol (spec);
|
||||
build_builtin_function (sym, bi_val, 0, spec.storage);
|
||||
|
|
@ -852,7 +871,8 @@ qc_code_func
|
|||
}
|
||||
compound_statement_ns
|
||||
{
|
||||
build_code_function ($1, $3, $6);
|
||||
auto statements = (expr_t *) expr_process ($6);
|
||||
build_code_function ($1, $3, statements);
|
||||
current_symtab = $<funcstate>5.symtab;
|
||||
current_func = $<funcstate>5.function;
|
||||
restore_storage ($4);
|
||||
|
|
@ -864,6 +884,7 @@ declarator
|
|||
| notype_declarator
|
||||
;
|
||||
|
||||
// reuses typedef or class name
|
||||
after_type_declarator
|
||||
: '(' copy_spec after_type_declarator ')' { $$ = $3; }
|
||||
| after_type_declarator function_params
|
||||
|
|
@ -901,6 +922,7 @@ ptr_spec
|
|||
: copy_spec // for when no qualifiers are present
|
||||
;
|
||||
|
||||
// does not reuse a typedef or class name
|
||||
notype_declarator
|
||||
: '(' copy_spec notype_declarator ')' { $$ = $3; }
|
||||
| notype_declarator function_params
|
||||
|
|
@ -928,27 +950,29 @@ notype_declarator
|
|||
;
|
||||
|
||||
initdecls
|
||||
: initdecl
|
||||
: initdecl { $$ = new_list_expr ($1); }
|
||||
| initdecls ',' { $<spec>$ = $<spec>0; } initdecl
|
||||
{
|
||||
$$ = expr_append_expr ($1, $4);
|
||||
}
|
||||
;
|
||||
|
||||
initdecl
|
||||
: declarator '=' var_initializer
|
||||
{ declare_symbol ($1, $3, current_symtab, local_expr); }
|
||||
| declarator
|
||||
{ declare_symbol ($1, 0, current_symtab, local_expr); }
|
||||
: declarator '=' var_initializer { $$ = decl_expr ($1, $3); }
|
||||
| declarator { $$ = decl_expr ($1, nullptr); }
|
||||
;
|
||||
|
||||
notype_initdecls
|
||||
: notype_initdecl
|
||||
: notype_initdecl { $$ = new_list_expr ($1); }
|
||||
| notype_initdecls ',' { $<spec>$ = $<spec>0; } notype_initdecl
|
||||
{
|
||||
$$ = expr_append_expr ($1, $4);
|
||||
}
|
||||
;
|
||||
|
||||
notype_initdecl
|
||||
: notype_declarator '=' var_initializer
|
||||
{ declare_symbol ($1, $3, current_symtab, local_expr); }
|
||||
| notype_declarator
|
||||
{ declare_symbol ($1, 0, current_symtab, local_expr); }
|
||||
: notype_declarator '=' var_initializer { $$ = decl_expr ($1, $3); }
|
||||
| notype_declarator { $$ = decl_expr ($1, nullptr); }
|
||||
;
|
||||
|
||||
/* various lists of type specifiers, storage class etc */
|
||||
|
|
@ -1164,7 +1188,8 @@ function_body
|
|||
}
|
||||
compound_statement_ns
|
||||
{
|
||||
build_code_function ($<symbol>2, $1, $5);
|
||||
auto statements = (expr_t *) expr_process ($5);
|
||||
build_code_function ($<symbol>2, $1, statements);
|
||||
current_symtab = $<funcstate>4.symtab;
|
||||
current_func = $<funcstate>4.function;
|
||||
restore_storage ($3);
|
||||
|
|
@ -1172,7 +1197,7 @@ function_body
|
|||
| '=' '#' expr ';'
|
||||
{
|
||||
specifier_t spec = $<spec>0;
|
||||
const expr_t *bi_val = $3;
|
||||
const expr_t *bi_val = expr_process ($3);
|
||||
|
||||
symbol_t *sym = function_symbol (spec);
|
||||
build_builtin_function (sym, bi_val, 0, spec.storage);
|
||||
|
|
@ -1377,8 +1402,15 @@ enumerator_list
|
|||
;
|
||||
|
||||
enumerator
|
||||
: identifier { add_enum ($<symbol>0, $1, 0); }
|
||||
| identifier '=' expr { add_enum ($<symbol>0, $1, $3); }
|
||||
: identifier
|
||||
{
|
||||
add_enum ($<symbol>0, $identifier, nullptr);
|
||||
}
|
||||
| identifier '=' expr
|
||||
{
|
||||
$expr = expr_process ($expr);
|
||||
add_enum ($<symbol>0, $identifier, $expr);
|
||||
}
|
||||
;
|
||||
|
||||
struct_specifier
|
||||
|
|
@ -1666,13 +1698,11 @@ array_decl
|
|||
decl
|
||||
: declspecs_ts local_expr initdecls seq_semi
|
||||
{
|
||||
$$ = local_expr;
|
||||
local_expr = 0;
|
||||
$$ = $3;
|
||||
}
|
||||
| declspecs_nots local_expr notype_initdecls seq_semi
|
||||
{
|
||||
$$ = local_expr;
|
||||
local_expr = 0;
|
||||
$$ = $3;
|
||||
}
|
||||
| declspecs_ts local_expr qc_func_params
|
||||
{
|
||||
|
|
@ -1783,53 +1813,61 @@ optional_comma
|
|||
| ','
|
||||
;
|
||||
|
||||
push_scope
|
||||
new_block
|
||||
: /* empty */
|
||||
{
|
||||
auto block = new_block_expr (nullptr);
|
||||
block->block.scope = current_symtab;
|
||||
$$ = block;
|
||||
}
|
||||
|
||||
new_scope
|
||||
: /* empty */
|
||||
{
|
||||
auto block = new_block_expr (nullptr);
|
||||
block->block.scope = current_symtab;
|
||||
if (!options.traditional) {
|
||||
block->block.scope = new_symtab (current_symtab, stab_local);
|
||||
block->block.scope->space = current_symtab->space;
|
||||
current_symtab = block->block.scope;
|
||||
}
|
||||
$$ = block;
|
||||
}
|
||||
;
|
||||
|
||||
end_scope
|
||||
: /* empty */
|
||||
{
|
||||
if (!options.traditional) {
|
||||
current_symtab = new_symtab (current_symtab, stab_local);
|
||||
current_symtab->space = current_symtab->parent->space;
|
||||
}
|
||||
}
|
||||
;
|
||||
|
||||
pop_scope
|
||||
: /* empty */
|
||||
{
|
||||
if (!options.traditional)
|
||||
current_symtab = current_symtab->parent;
|
||||
}
|
||||
;
|
||||
|
||||
flush_dag
|
||||
: /* empty */
|
||||
{
|
||||
if (!no_flush_dag) {
|
||||
edag_flush ();
|
||||
}
|
||||
}
|
||||
;
|
||||
|
||||
seq_semi
|
||||
: ';' flush_dag
|
||||
: ';'
|
||||
;
|
||||
|
||||
compound_statement
|
||||
: '{' push_scope flush_dag statements '}' pop_scope flush_dag { $$ = $4; }
|
||||
: '{' '}' { $$ = new_block_expr (0); }
|
||||
| '{' new_scope statement_list '}' end_scope { $$ = $3; }
|
||||
;
|
||||
|
||||
compound_statement_ns
|
||||
: '{' flush_dag statements '}' flush_dag { $$ = $3; }
|
||||
: '{' '}' { $$ = new_block_expr (0); }
|
||||
| '{' new_block statement_list '}' { $$ = $3; }
|
||||
;
|
||||
|
||||
statements
|
||||
: /*empty*/
|
||||
statement_list
|
||||
: statement
|
||||
{
|
||||
$$ = new_block_expr (0);
|
||||
auto list = $<mut_expr>0;
|
||||
$$ = append_expr (list, $1);
|
||||
}
|
||||
| statements flush_dag statement
|
||||
| statement_list statement
|
||||
{
|
||||
$$ = append_expr ($1, $3);
|
||||
auto list = $1;
|
||||
$$ = append_expr (list, $2);
|
||||
}
|
||||
;
|
||||
|
||||
|
|
@ -1843,9 +1881,14 @@ statement
|
|||
| error ';' { $$ = 0; yyerrok; }
|
||||
| compound_statement { $$ = $1; }
|
||||
| local_def { $$ = $1; }
|
||||
| RETURN opt_expr ';' { $$ = return_expr (current_func, $2); }
|
||||
| RETURN compound_init ';' { $$ = return_expr (current_func, $2); }
|
||||
| AT_RETURN expr ';' { $$ = at_return_expr (current_func, $2); }
|
||||
| RETURN opt_expr ';' { $$ = new_return_expr ($2); }
|
||||
| RETURN compound_init ';' { $$ = new_return_expr ($2); }
|
||||
| AT_RETURN expr ';'
|
||||
{
|
||||
auto at = new_return_expr ($2);
|
||||
at->retrn.at_return = true;
|
||||
$$ = at;
|
||||
}
|
||||
| BREAK ';'
|
||||
{
|
||||
$$ = 0;
|
||||
|
|
@ -1868,55 +1911,65 @@ statement
|
|||
}
|
||||
| CASE expr ':'
|
||||
{
|
||||
$$ = case_label_expr (switch_block, $2);
|
||||
$$ = new_caselabel_expr ($2, nullptr);
|
||||
}
|
||||
| DEFAULT ':'
|
||||
{
|
||||
$$ = case_label_expr (switch_block, 0);
|
||||
$$ = new_caselabel_expr (nullptr, nullptr);
|
||||
}
|
||||
| SWITCH break_label '(' comma_expr switch_block ')' compound_statement
|
||||
| SWITCH break_label line '(' comma_expr[test] ')' compound_statement[body]
|
||||
{
|
||||
$$ = switch_expr (switch_block, break_label, $7);
|
||||
switch_block = $5;
|
||||
break_label = $2;
|
||||
scoped_src_loc ($line);
|
||||
$$ = new_switch_expr ($test, $body, break_label);
|
||||
break_label = $break_label;
|
||||
}
|
||||
| GOTO NAME
|
||||
{
|
||||
const expr_t *label = named_label_expr ($2);
|
||||
$$ = goto_expr (label);
|
||||
}
|
||||
| IF not '(' texpr ')' flush_dag statement %prec IFX
|
||||
| IF not line '(' expr[test] ')' statement[true] %prec IFX
|
||||
{
|
||||
$$ = build_if_statement ($2, $4, $7, 0, 0);
|
||||
scoped_src_loc ($line);
|
||||
$$ = new_select_expr ($not, $test, $true, nullptr, nullptr);
|
||||
}
|
||||
| IF not '(' texpr ')' flush_dag statement else statement
|
||||
| IF not line '(' expr[test]')' statement[true]
|
||||
else statement[false]
|
||||
{
|
||||
$$ = build_if_statement ($2, $4, $7, $8, $9);
|
||||
scoped_src_loc ($line);
|
||||
$$ = new_select_expr ($not, $test, $true, $else, $false);
|
||||
}
|
||||
| FOR push_scope break_label continue_label
|
||||
'(' opt_init_semi opt_expr seq_semi opt_expr ')' flush_dag statement pop_scope
|
||||
| FOR new_scope break_label continue_label
|
||||
'(' opt_init_semi[init] opt_expr[test] ';' opt_expr[cont] ')'
|
||||
statement[body] end_scope
|
||||
{
|
||||
if ($6) {
|
||||
$6 = build_block_expr ($6, false);
|
||||
auto test = $test;
|
||||
if (!test) {
|
||||
test = new_bool_expr (true);
|
||||
}
|
||||
$$ = build_for_statement ($6, $7, $9, $12,
|
||||
break_label, continue_label);
|
||||
break_label = $3;
|
||||
continue_label = $4;
|
||||
auto loop = new_loop_expr (false, false, test, $body,
|
||||
continue_label, $cont, break_label);
|
||||
auto block = $new_scope;
|
||||
append_expr (block, $init);
|
||||
$$ = append_expr (block, loop);
|
||||
break_label = $break_label;
|
||||
continue_label = $continue_label;
|
||||
}
|
||||
| WHILE break_label continue_label not '(' texpr ')' flush_dag statement
|
||||
| WHILE break_label continue_label not '(' expr[test] ')'
|
||||
statement[body]
|
||||
{
|
||||
$$ = build_while_statement ($4, $6, $9, break_label,
|
||||
continue_label);
|
||||
break_label = $2;
|
||||
continue_label = $3;
|
||||
$$ = new_loop_expr ($not, false, $test, $body,
|
||||
continue_label, nullptr, break_label);
|
||||
break_label = $break_label;
|
||||
continue_label = $continue_label;
|
||||
}
|
||||
| DO break_label continue_label statement WHILE not '(' texpr ')' ';'
|
||||
| DO break_label continue_label statement[body]
|
||||
WHILE not '(' expr[test] ')' ';'
|
||||
{
|
||||
$$ = build_do_while_statement ($4, $6, $8,
|
||||
break_label, continue_label);
|
||||
break_label = $2;
|
||||
continue_label = $3;
|
||||
$$ = new_loop_expr ($not, true, $test, $body,
|
||||
continue_label, nullptr, break_label);
|
||||
break_label = $break_label;
|
||||
continue_label = $continue_label;
|
||||
}
|
||||
| ALGEBRA '(' TYPE_SPEC '(' expr_list ')' ')'
|
||||
{
|
||||
|
|
@ -1959,25 +2012,21 @@ not
|
|||
| /* empty */ { $$ = 0; }
|
||||
;
|
||||
|
||||
else
|
||||
: ELSE flush_dag
|
||||
line
|
||||
: /* empty */
|
||||
{
|
||||
// this is only to get the the file and line number info
|
||||
$$ = new_nil_expr ();
|
||||
}
|
||||
|
||||
else
|
||||
: ELSE line { $$ = $line; }
|
||||
;
|
||||
|
||||
label
|
||||
: NAME ':'
|
||||
;
|
||||
|
||||
bool_label
|
||||
: /* empty */
|
||||
{
|
||||
$$ = new_label_expr ();
|
||||
}
|
||||
;
|
||||
|
||||
break_label
|
||||
: /* empty */
|
||||
{
|
||||
|
|
@ -1994,17 +2043,8 @@ continue_label
|
|||
}
|
||||
;
|
||||
|
||||
switch_block
|
||||
: /* empty */
|
||||
{
|
||||
$$ = switch_block;
|
||||
switch_block = new_switch_block ();
|
||||
switch_block->test = $<expr>0;
|
||||
}
|
||||
;
|
||||
|
||||
opt_init_semi
|
||||
: comma_expr seq_semi
|
||||
: comma_expr ';'
|
||||
| decl /* contains ; */ { $$ = (expr_t *) $1; }
|
||||
| ';'
|
||||
{
|
||||
|
|
@ -2027,29 +2067,34 @@ unary_expr
|
|||
| THIS { $$ = new_this_expr (); }
|
||||
| const { $$ = $1; }
|
||||
| '(' expr ')' { $$ = $2; ((expr_t *) $$)->paren = 1; }
|
||||
| unary_expr '(' opt_arg_list ')' { $$ = function_expr ($1, $3); }
|
||||
| unary_expr '[' expr ']' { $$ = array_expr ($1, $3); }
|
||||
| unary_expr '.' ident_expr { $$ = field_expr ($1, $3); }
|
||||
| unary_expr '.' unary_expr { $$ = field_expr ($1, $3); }
|
||||
| INCOP unary_expr { $$ = incop_expr ($1, $2, 0); }
|
||||
| unary_expr INCOP { $$ = incop_expr ($2, $1, 1); }
|
||||
| unary_expr REVERSE { $$ = unary_expr (QC_REVERSE, $1); }
|
||||
| DUAL cast_expr %prec UNARY { $$ = unary_expr (QC_DUAL, $2); }
|
||||
| UNDUAL cast_expr %prec UNARY { $$ = unary_expr (QC_UNDUAL, $2); }
|
||||
| unary_expr '(' opt_arg_list ')' { $$ = new_call_expr ($1, $3, nullptr); }
|
||||
| unary_expr '[' expr ']' { $$ = new_array_expr ($1, $3); }
|
||||
| unary_expr '.' ident_expr { $$ = new_field_expr ($1, $3); }
|
||||
| unary_expr '.' unary_expr { $$ = new_field_expr ($1, $3); }
|
||||
| INCOP unary_expr { $$ = new_incop_expr ($1, $2, false); }
|
||||
| unary_expr INCOP { $$ = new_incop_expr ($2, $1, true); }
|
||||
| unary_expr REVERSE { $$ = new_unary_expr (QC_REVERSE, $1); }
|
||||
| DUAL cast_expr %prec UNARY { $$ = new_unary_expr (QC_DUAL, $2); }
|
||||
| UNDUAL cast_expr %prec UNARY { $$ = new_unary_expr (QC_UNDUAL, $2); }
|
||||
| '+' cast_expr %prec UNARY { $$ = $2; }
|
||||
| '-' cast_expr %prec UNARY { $$ = unary_expr ('-', $2); }
|
||||
| '!' cast_expr %prec UNARY { $$ = unary_expr ('!', $2); }
|
||||
| '~' cast_expr %prec UNARY { $$ = unary_expr ('~', $2); }
|
||||
| '&' cast_expr %prec UNARY { $$ = address_expr ($2, 0); }
|
||||
| '*' cast_expr %prec UNARY { $$ = deref_pointer_expr ($2); }
|
||||
| SIZEOF unary_expr %prec UNARY { $$ = sizeof_expr ($2, 0); }
|
||||
| '-' cast_expr %prec UNARY { $$ = new_unary_expr ('-', $2); }
|
||||
| '!' cast_expr %prec UNARY { $$ = new_unary_expr ('!', $2); }
|
||||
| '~' cast_expr %prec UNARY { $$ = new_unary_expr ('~', $2); }
|
||||
| '&' cast_expr %prec UNARY { $$ = new_unary_expr ('&', $2); }
|
||||
| '*' cast_expr %prec UNARY { $$ = new_unary_expr ('.', $2); }
|
||||
| SIZEOF unary_expr %prec UNARY { $$ = new_unary_expr ('S', $2); }
|
||||
| SIZEOF '(' typename ')' %prec HYPERUNARY
|
||||
{
|
||||
auto type = resolve_type_spec ($3);
|
||||
$$ = sizeof_expr (0, type);
|
||||
auto spec = $3;
|
||||
auto type_expr = spec.type_expr;
|
||||
if (!type_expr) {
|
||||
spec = default_type (spec, nullptr);
|
||||
type_expr = new_type_expr (spec.type);
|
||||
}
|
||||
$$ = new_unary_expr ('S', type_expr);
|
||||
}
|
||||
| type_op '(' type_param_list ')' { $$ = type_function ($1, $3); }
|
||||
| vector_expr { $$ = new_vector_list ($1); }
|
||||
| vector_expr { $$ = new_vector_list_expr ($1); }
|
||||
| obj_expr { $$ = $1; }
|
||||
;
|
||||
|
||||
|
|
@ -2060,65 +2105,74 @@ ident_expr
|
|||
;
|
||||
|
||||
vector_expr
|
||||
: '[' expr ',' { no_flush_dag = true; } expr_list ']'
|
||||
: '[' expr ',' expr_list ']'
|
||||
{
|
||||
$$ = expr_prepend_expr ($5, $2);
|
||||
no_flush_dag = false;
|
||||
$$ = expr_prepend_expr ($4, $2);
|
||||
}
|
||||
;
|
||||
|
||||
cast_expr
|
||||
: '(' typename ')' cast_expr
|
||||
{
|
||||
auto type = resolve_type_spec ($2);
|
||||
$$ = cast_expr (type, $4);
|
||||
auto spec = $2;
|
||||
auto type_expr = spec.type_expr;
|
||||
if (!type_expr) {
|
||||
spec = default_type (spec, nullptr);
|
||||
type_expr = new_type_expr (spec.type);
|
||||
}
|
||||
$$ = new_binary_expr ('C', type_expr, $4);
|
||||
}
|
||||
| unary_expr %prec LOW
|
||||
;
|
||||
|
||||
expr
|
||||
: cast_expr
|
||||
| expr '=' expr { $$ = assign_expr ($1, $3); }
|
||||
| expr '=' compound_init { $$ = assign_expr ($1, $3); }
|
||||
| expr ASX expr { $$ = asx_expr ($2, $1, $3); }
|
||||
| expr '?' flush_dag expr ':' expr { $$ = conditional_expr ($1, $4, $6); }
|
||||
| expr AND flush_dag bool_label expr{ $$ = bool_expr (QC_AND, $4, $1, $5); }
|
||||
| expr OR flush_dag bool_label expr { $$ = bool_expr (QC_OR, $4, $1, $5); }
|
||||
| expr EQ expr { $$ = binary_expr (QC_EQ, $1, $3); }
|
||||
| expr NE expr { $$ = binary_expr (QC_NE, $1, $3); }
|
||||
| expr LE expr { $$ = binary_expr (QC_LE, $1, $3); }
|
||||
| expr GE expr { $$ = binary_expr (QC_GE, $1, $3); }
|
||||
| expr LT expr { $$ = binary_expr (QC_LT, $1, $3); }
|
||||
| expr GT expr { $$ = binary_expr (QC_GT, $1, $3); }
|
||||
| expr SHL expr { $$ = binary_expr (QC_SHL, $1, $3); }
|
||||
| expr SHR expr { $$ = binary_expr (QC_SHR, $1, $3); }
|
||||
| expr '+' expr { $$ = binary_expr ('+', $1, $3); }
|
||||
| expr '-' expr { $$ = binary_expr ('-', $1, $3); }
|
||||
| expr '*' expr { $$ = binary_expr ('*', $1, $3); }
|
||||
| expr '/' expr { $$ = binary_expr ('/', $1, $3); }
|
||||
| expr '&' expr { $$ = binary_expr ('&', $1, $3); }
|
||||
| expr '|' expr { $$ = binary_expr ('|', $1, $3); }
|
||||
| expr '^' expr { $$ = binary_expr ('^', $1, $3); }
|
||||
| expr '%' expr { $$ = binary_expr ('%', $1, $3); }
|
||||
| expr MOD expr { $$ = binary_expr (QC_MOD, $1, $3); }
|
||||
| expr GEOMETRIC expr { $$ = binary_expr (QC_GEOMETRIC, $1, $3); }
|
||||
| expr HADAMARD expr { $$ = binary_expr (QC_HADAMARD, $1, $3); }
|
||||
| expr CROSS expr { $$ = binary_expr (QC_CROSS, $1, $3); }
|
||||
| expr DOT expr { $$ = binary_expr (QC_DOT, $1, $3); }
|
||||
| expr OUTER expr { $$ = binary_expr (QC_OUTER, $1, $3); }
|
||||
| expr WEDGE expr { $$ = binary_expr (QC_WEDGE, $1, $3); }
|
||||
| expr REGRESSIVE expr { $$ = binary_expr (QC_REGRESSIVE, $1, $3); }
|
||||
;
|
||||
|
||||
texpr
|
||||
: expr { $$ = convert_bool ($1, 1); }
|
||||
| expr '=' expr { $$ = new_assign_expr ($1, $3); }
|
||||
| expr '=' compound_init { $$ = new_assign_expr ($1, $3); }
|
||||
| expr ASX expr
|
||||
{
|
||||
scoped_src_loc ($1);
|
||||
auto expr = $3;
|
||||
expr = paren_expr (expr);
|
||||
expr = new_binary_expr ($2, $1, expr);
|
||||
$$ = new_assign_expr ($1, expr);
|
||||
}
|
||||
| expr '?' expr ':' expr { $$ = new_cond_expr ($1, $3, $5); }
|
||||
| expr AND expr { $$ = new_binary_expr (QC_AND, $1, $3); }
|
||||
| expr OR expr { $$ = new_binary_expr (QC_OR, $1, $3); }
|
||||
| expr EQ expr { $$ = new_binary_expr (QC_EQ, $1, $3); }
|
||||
| expr NE expr { $$ = new_binary_expr (QC_NE, $1, $3); }
|
||||
| expr LE expr { $$ = new_binary_expr (QC_LE, $1, $3); }
|
||||
| expr GE expr { $$ = new_binary_expr (QC_GE, $1, $3); }
|
||||
| expr LT expr { $$ = new_binary_expr (QC_LT, $1, $3); }
|
||||
| expr GT expr { $$ = new_binary_expr (QC_GT, $1, $3); }
|
||||
| expr SHL expr { $$ = new_binary_expr (QC_SHL, $1, $3); }
|
||||
| expr SHR expr { $$ = new_binary_expr (QC_SHR, $1, $3); }
|
||||
| expr '+' expr { $$ = new_binary_expr ('+', $1, $3); }
|
||||
| expr '-' expr { $$ = new_binary_expr ('-', $1, $3); }
|
||||
| expr '*' expr { $$ = new_binary_expr ('*', $1, $3); }
|
||||
| expr '/' expr { $$ = new_binary_expr ('/', $1, $3); }
|
||||
| expr '&' expr { $$ = new_binary_expr ('&', $1, $3); }
|
||||
| expr '|' expr { $$ = new_binary_expr ('|', $1, $3); }
|
||||
| expr '^' expr { $$ = new_binary_expr ('^', $1, $3); }
|
||||
| expr '%' expr { $$ = new_binary_expr ('%', $1, $3); }
|
||||
| expr MOD expr { $$ = new_binary_expr (QC_MOD, $1, $3); }
|
||||
| expr GEOMETRIC expr { $$ = new_binary_expr (QC_GEOMETRIC, $1, $3); }
|
||||
| expr HADAMARD expr { $$ = new_binary_expr (QC_HADAMARD, $1, $3); }
|
||||
| expr CROSS expr { $$ = new_binary_expr (QC_CROSS, $1, $3); }
|
||||
| expr DOT expr { $$ = new_binary_expr (QC_DOT, $1, $3); }
|
||||
| expr OUTER expr { $$ = new_binary_expr (QC_OUTER, $1, $3); }
|
||||
| expr WEDGE expr { $$ = new_binary_expr (QC_WEDGE, $1, $3); }
|
||||
| expr REGRESSIVE expr { $$ = new_binary_expr (QC_REGRESSIVE, $1, $3); }
|
||||
;
|
||||
|
||||
comma_expr
|
||||
: expr_list
|
||||
{
|
||||
if ($1->list.head->next) {
|
||||
$$ = build_block_expr ($1, true);
|
||||
auto b = build_block_expr ($1, true);
|
||||
b->block.scope = current_symtab;
|
||||
$$ = b;
|
||||
} else {
|
||||
$$ = (expr_t *) $1->list.head->expr;
|
||||
}
|
||||
|
|
@ -2126,8 +2180,8 @@ comma_expr
|
|||
;
|
||||
|
||||
expr_list
|
||||
: expr { $$ = new_list_expr ($1); }
|
||||
| expr_list ',' flush_dag expr { $$ = expr_append_expr ($1, $4); }
|
||||
: expr { $$ = new_list_expr ($1); }
|
||||
| expr_list ',' expr { $$ = expr_append_expr ($1, $3); }
|
||||
;
|
||||
|
||||
opt_arg_list
|
||||
|
|
@ -2576,7 +2630,8 @@ methoddef
|
|||
}
|
||||
compound_statement_ns
|
||||
{
|
||||
build_code_function ($<symbol>4, $3, $7);
|
||||
auto statements = (expr_t *) expr_process ($7);
|
||||
build_code_function ($<symbol>4, $3, statements);
|
||||
current_symtab = $<funcstate>6.symtab;
|
||||
current_func = $<funcstate>6.function;
|
||||
restore_storage ($5);
|
||||
|
|
@ -2585,7 +2640,7 @@ methoddef
|
|||
{
|
||||
symbol_t *sym;
|
||||
method_t *method = $2;
|
||||
const expr_t *bi_val = $5;
|
||||
const expr_t *bi_val = expr_process ($5);
|
||||
|
||||
method->instance = $1;
|
||||
method = class_find_method (current_class, method);
|
||||
|
|
@ -2722,7 +2777,11 @@ obj_expr
|
|||
;
|
||||
|
||||
obj_messageexpr
|
||||
: '[' receiver messageargs ']' { $$ = message_expr ($2, $3); }
|
||||
: '[' receiver messageargs ']'
|
||||
{
|
||||
scoped_src_loc ($receiver);
|
||||
$$ = new_message_expr ($receiver, $messageargs);
|
||||
}
|
||||
;
|
||||
|
||||
receiver
|
||||
|
|
@ -3154,4 +3213,5 @@ language_t lang_ruamoko = {
|
|||
.init = rua_init,
|
||||
.parse = qc_yyparse,
|
||||
.finish = qc_finish,
|
||||
.parse_declaration = rua_parse_declaration,
|
||||
};
|
||||
|
|
|
|||
102
tools/qfcc/source/rua-declaration.c
Normal file
102
tools/qfcc/source/rua-declaration.c
Normal file
|
|
@ -0,0 +1,102 @@
|
|||
/*
|
||||
rua-declaration.c
|
||||
|
||||
Ruamoko declaration handling
|
||||
|
||||
Copyright (C) 2024 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
|
||||
|
||||
*/
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#include "QF/alloc.h"
|
||||
#include "QF/hash.h"
|
||||
#include "QF/va.h"
|
||||
|
||||
#include "tools/qfcc/include/attribute.h"
|
||||
#include "tools/qfcc/include/def.h"
|
||||
#include "tools/qfcc/include/diagnostic.h"
|
||||
#include "tools/qfcc/include/rua-lang.h"
|
||||
#include "tools/qfcc/include/shared.h"
|
||||
#include "tools/qfcc/include/strpool.h"
|
||||
#include "tools/qfcc/include/symtab.h"
|
||||
#include "tools/qfcc/include/type.h"
|
||||
|
||||
void
|
||||
rua_parse_declaration (specifier_t spec, symbol_t *sym, const expr_t *init,
|
||||
symtab_t *symtab, expr_t *block)
|
||||
{
|
||||
if (sym && sym->type) {
|
||||
internal_error (0, "unexected typed symbol");
|
||||
}
|
||||
if (sym && sym->sy_type == sy_expr) {
|
||||
auto id_list = sym->expr;
|
||||
if (id_list->type != ex_list) {
|
||||
internal_error (id_list, "not a list");
|
||||
}
|
||||
for (auto id = id_list->list.head; id; id = id->next) {
|
||||
if (id->expr->type != ex_symbol) {
|
||||
internal_error (id_list, "not a symbol");
|
||||
}
|
||||
spec.sym = id->expr->symbol;
|
||||
spec.sym = declare_symbol (spec, init, symtab, block);
|
||||
}
|
||||
} else {
|
||||
spec.sym = sym;
|
||||
if (spec.sym) {
|
||||
if (spec.is_const && !init) {
|
||||
error (0, "uninitialized const %s", sym->name);
|
||||
init = new_zero_expr (spec.type);
|
||||
}
|
||||
if (spec.is_const && init->type != ex_compound) {
|
||||
auto type = get_type (init);
|
||||
if (type != spec.type && type_assignable (spec.type, type)) {
|
||||
if (!init->implicit && !type_promotes (spec.type, type)) {
|
||||
warning (init, "initialization of %s with %s"
|
||||
" (use a cast)\n)",
|
||||
get_type_string (spec.type),
|
||||
get_type_string (type));
|
||||
}
|
||||
init = cast_expr (spec.type, init);
|
||||
}
|
||||
if (get_type (init) != spec.type) {
|
||||
error (init, "type mismatch in initializer");
|
||||
init = new_zero_expr (spec.type);
|
||||
}
|
||||
if (!is_constexpr (init)) {
|
||||
error (init, "non-constant initializer");
|
||||
init = new_zero_expr (spec.type);
|
||||
}
|
||||
sym->type = spec.type;
|
||||
sym->sy_type = sy_expr;
|
||||
sym->expr = init;
|
||||
auto s = symtab_lookup (symtab, sym->name);
|
||||
if (s && s->table == symtab) {
|
||||
error (0, "%s redeclared", sym->name);
|
||||
}
|
||||
symtab_addsymbol (symtab, sym);
|
||||
} else {
|
||||
spec.sym = declare_symbol (spec, init, symtab, block);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -61,6 +61,7 @@
|
|||
#include "tools/qfcc/include/statements.h"
|
||||
#include "tools/qfcc/include/strpool.h"
|
||||
#include "tools/qfcc/include/symtab.h"
|
||||
#include "tools/qfcc/include/target.h"
|
||||
#include "tools/qfcc/include/type.h"
|
||||
#include "tools/qfcc/include/value.h"
|
||||
|
||||
|
|
@ -864,6 +865,13 @@ expr_assign_copy (sblock_t *sblock, const expr_t *e, operand_t **op, operand_t *
|
|||
|
||||
scoped_src_loc (e);
|
||||
|
||||
if (dst_expr->type == ex_field || dst_expr->type == ex_array) {
|
||||
dst_expr = ruamoko_field_array (dst_expr);
|
||||
}
|
||||
if (src_expr->type == ex_field || src_expr->type == ex_array) {
|
||||
src_expr = ruamoko_field_array (src_expr);
|
||||
}
|
||||
|
||||
if ((src && src->op_type == op_nil) || src_expr->type == ex_nil) {
|
||||
// switch to memset because nil is type agnostic 0 and structures
|
||||
// can be any size
|
||||
|
|
@ -977,6 +985,13 @@ expr_assign (sblock_t *sblock, const expr_t *e, operand_t **op)
|
|||
const char *opcode = "assign";
|
||||
st_type_t type = st_assign;
|
||||
|
||||
if (dst_expr->type == ex_field || dst_expr->type == ex_array) {
|
||||
dst_expr = ruamoko_field_array (dst_expr);
|
||||
}
|
||||
if (src_expr->type == ex_field || src_expr->type == ex_array) {
|
||||
src_expr = ruamoko_field_array (src_expr);
|
||||
}
|
||||
|
||||
if (src_expr->type == ex_assign) {
|
||||
sblock = statement_subexpr (sblock, src_expr, &src);
|
||||
if (is_structural (dst_type) || is_matrix (dst_type)
|
||||
|
|
@ -1595,6 +1610,9 @@ statement_return (sblock_t *sblock, const expr_t *e)
|
|||
} else {
|
||||
if (!e->retrn.at_return && e->retrn.ret_val) {
|
||||
const expr_t *ret_val = e->retrn.ret_val;
|
||||
if (ret_val->type == ex_field || ret_val->type == ex_array) {
|
||||
ret_val = ruamoko_field_array (ret_val);
|
||||
}
|
||||
auto ret_type = get_type (ret_val);
|
||||
operand_t *target = 0;
|
||||
pr_ushort_t ret_ctrl = type_size (ret_type) - 1;
|
||||
|
|
@ -1657,6 +1675,95 @@ statement_with (sblock_t *sblock, const expr_t *e)
|
|||
return sblock;
|
||||
}
|
||||
|
||||
static sblock_t *
|
||||
statement_list (sblock_t *sblock, const expr_t *e)
|
||||
{
|
||||
return statement_slist (sblock, &e->list);
|
||||
}
|
||||
|
||||
static sblock_t *
|
||||
statement_incop (sblock_t *sblock, const expr_t *e)
|
||||
{
|
||||
scoped_src_loc (e);
|
||||
// postop is irrelevant because the value is discarded
|
||||
auto one = new_int_expr (1, false);
|
||||
auto type = get_type (e->incop.expr);
|
||||
if (is_scalar (type)) {
|
||||
one = cast_expr (type, one);
|
||||
}
|
||||
auto incop = binary_expr (e->incop.op, e->incop.expr, one);
|
||||
incop = assign_expr (e->incop.expr, incop);
|
||||
return statement_single (sblock, incop);
|
||||
}
|
||||
|
||||
static sblock_t *
|
||||
statement_loop (sblock_t *sblock, const expr_t *e)
|
||||
{
|
||||
scoped_src_loc (e);
|
||||
auto test = e->loop.test;
|
||||
auto body_label = new_label_expr ();
|
||||
auto body = e->loop.body;
|
||||
auto continue_label = e->loop.continue_label;
|
||||
auto continue_body = e->loop.continue_body;
|
||||
auto break_label = e->loop.break_label;
|
||||
bool do_while = e->loop.do_while;
|
||||
bool not = e->loop.not;
|
||||
|
||||
auto loop = new_block_expr (nullptr);
|
||||
if (do_while) {
|
||||
append_expr (loop, body_label);
|
||||
append_expr (loop, body);
|
||||
append_expr (loop, continue_label);
|
||||
append_expr (loop, continue_body);
|
||||
test = convert_bool (test, true);
|
||||
if (!is_error (test)) {
|
||||
if (not) {
|
||||
backpatch (test->boolean.true_list, break_label);
|
||||
backpatch (test->boolean.false_list, body_label);
|
||||
} else {
|
||||
backpatch (test->boolean.true_list, body_label);
|
||||
backpatch (test->boolean.false_list, break_label);
|
||||
}
|
||||
append_expr (loop, test);
|
||||
}
|
||||
append_expr (loop, break_label);
|
||||
} else {
|
||||
scoped_src_loc (test);
|
||||
auto test_label = new_label_expr ();
|
||||
append_expr (loop, test_label);
|
||||
test = convert_bool (test, true);
|
||||
if (!is_error (test)) {
|
||||
if (not) {
|
||||
backpatch (test->boolean.true_list, break_label);
|
||||
backpatch (test->boolean.false_list, body_label);
|
||||
} else {
|
||||
backpatch (test->boolean.true_list, body_label);
|
||||
backpatch (test->boolean.false_list, break_label);
|
||||
}
|
||||
append_expr (loop, test);
|
||||
}
|
||||
append_expr (loop, body_label);
|
||||
append_expr (loop, body);
|
||||
append_expr (loop, continue_label);
|
||||
append_expr (loop, continue_body);
|
||||
append_expr (loop, goto_expr (test_label));
|
||||
append_expr (loop, break_label);
|
||||
}
|
||||
return statement_slist (sblock, &loop->block.list);
|
||||
}
|
||||
|
||||
static sblock_t *
|
||||
statement_select (sblock_t *sblock, const expr_t *e)
|
||||
{
|
||||
bool not = e->select.not;
|
||||
auto test = e->select.test;
|
||||
auto true_body = e->select.true_body;
|
||||
auto els = e->select.els;
|
||||
auto false_body = e->select.false_body;
|
||||
auto sel = build_if_statement (not, test, true_body, els, false_body);
|
||||
return statement_slist (sblock, &sel->block.list);
|
||||
}
|
||||
|
||||
static statement_t *
|
||||
lea_statement (operand_t *pointer, operand_t *offset, const expr_t *e)
|
||||
{
|
||||
|
|
@ -2072,6 +2179,49 @@ expr_extend (sblock_t *sblock, const expr_t *e, operand_t **op)
|
|||
return sblock;
|
||||
}
|
||||
|
||||
static sblock_t *
|
||||
expr_incop (sblock_t *sblock, const expr_t *e, operand_t **op)
|
||||
{
|
||||
scoped_src_loc (e);
|
||||
|
||||
if (e->incop.postop) {
|
||||
auto tmp = new_temp_def_expr (get_type (e->incop.expr));
|
||||
auto assign = assign_expr (tmp, e->incop.expr);
|
||||
sblock = statement_single (sblock, assign);
|
||||
sblock = statement_subexpr (sblock, tmp, op);
|
||||
}
|
||||
auto one = new_int_expr (1, false);
|
||||
auto type = get_type (e->incop.expr);
|
||||
if (is_scalar (type)) {
|
||||
one = cast_expr (type, one);
|
||||
}
|
||||
auto incop = binary_expr (e->incop.op, e->incop.expr, one);
|
||||
incop = assign_expr (e->incop.expr, incop);
|
||||
if (e->incop.postop) {
|
||||
return statement_single (sblock, incop);
|
||||
} else {
|
||||
return statement_subexpr (sblock, incop, op);
|
||||
}
|
||||
}
|
||||
|
||||
static sblock_t *
|
||||
expr_cond (sblock_t *sblock, const expr_t *e, operand_t **op)
|
||||
{
|
||||
scoped_src_loc (e);
|
||||
auto test = e->cond.test;
|
||||
auto true_expr = e->cond.true_expr;
|
||||
auto false_expr = e->cond.false_expr;
|
||||
e = conditional_expr (test, true_expr, false_expr);
|
||||
return statement_subexpr (sblock, e, op);
|
||||
}
|
||||
|
||||
static sblock_t *
|
||||
expr_field_array (sblock_t *sblock, const expr_t *e, operand_t **op)
|
||||
{
|
||||
e = ruamoko_field_array (e);
|
||||
return statement_subexpr (sblock, e, op);
|
||||
}
|
||||
|
||||
static sblock_t *
|
||||
expr_def (sblock_t *sblock, const expr_t *e, operand_t **op)
|
||||
{
|
||||
|
|
@ -2206,20 +2356,24 @@ statement_subexpr (sblock_t *sblock, const expr_t *e, operand_t **op)
|
|||
[ex_block] = expr_block,
|
||||
[ex_expr] = expr_expr,
|
||||
[ex_uexpr] = expr_uexpr,
|
||||
[ex_horizontal] = expr_horizontal,
|
||||
[ex_swizzle] = expr_swizzle,
|
||||
[ex_def] = expr_def,
|
||||
[ex_symbol] = expr_symbol,
|
||||
[ex_temp] = expr_temp,
|
||||
[ex_vector] = expr_vector_e,
|
||||
[ex_selector] = expr_selector,
|
||||
[ex_nil] = expr_nil,
|
||||
[ex_value] = expr_value,
|
||||
[ex_selector] = expr_selector,
|
||||
[ex_alias] = expr_alias,
|
||||
[ex_address] = expr_address,
|
||||
[ex_assign] = expr_assign,
|
||||
[ex_branch] = expr_branch,
|
||||
[ex_horizontal] = expr_horizontal,
|
||||
[ex_swizzle] = expr_swizzle,
|
||||
[ex_extend] = expr_extend,
|
||||
[ex_incop] = expr_incop,
|
||||
[ex_cond] = expr_cond,
|
||||
[ex_field] = expr_field_array,
|
||||
[ex_array] = expr_field_array,
|
||||
};
|
||||
if (!e) {
|
||||
*op = 0;
|
||||
|
|
@ -2498,6 +2652,10 @@ statement_single (sblock_t *sblock, const expr_t *e)
|
|||
[ex_return] = statement_return,
|
||||
[ex_adjstk] = statement_adjstk,
|
||||
[ex_with] = statement_with,
|
||||
[ex_list] = statement_list,
|
||||
[ex_incop] = statement_incop,
|
||||
[ex_loop] = statement_loop,
|
||||
[ex_select] = statement_select,
|
||||
};
|
||||
|
||||
if (e->type >= ex_count || !sfuncs[e->type]) {
|
||||
|
|
|
|||
|
|
@ -42,6 +42,7 @@
|
|||
#include "tools/qfcc/include/qfcc.h"
|
||||
#include "tools/qfcc/include/statements.h"
|
||||
#include "tools/qfcc/include/strpool.h"
|
||||
#include "tools/qfcc/include/switch.h"
|
||||
#include "tools/qfcc/include/symtab.h"
|
||||
#include "tools/qfcc/include/target.h"
|
||||
#include "tools/qfcc/include/type.h"
|
||||
|
|
@ -233,6 +234,127 @@ ruamoko_assign_vector (const expr_t *dst, const expr_t *src)
|
|||
return block;
|
||||
}
|
||||
|
||||
static switch_block_t *switch_block;
|
||||
const expr_t *
|
||||
ruamoko_proc_switch (const expr_t *expr)
|
||||
{
|
||||
scoped_src_loc (expr);
|
||||
auto test = expr_process (expr->switchblock.test);
|
||||
|
||||
auto sb = switch_block;
|
||||
switch_block = new_switch_block ();
|
||||
switch_block->test = test;
|
||||
auto body = expr_process (expr->switchblock.body);
|
||||
|
||||
auto break_label = expr->switchblock.break_label;
|
||||
auto swtch = switch_expr (switch_block, break_label, body);
|
||||
switch_block = sb;
|
||||
return swtch;
|
||||
}
|
||||
|
||||
const expr_t *
|
||||
ruamoko_proc_caselabel (const expr_t *expr)
|
||||
{
|
||||
scoped_src_loc (expr);
|
||||
if (expr->caselabel.end_value) {
|
||||
internal_error (expr, "case ranges not implemented");
|
||||
}
|
||||
auto value = expr_process (expr->caselabel.value);
|
||||
if (is_error (value)) {
|
||||
return value;
|
||||
}
|
||||
return case_label_expr (switch_block, value);
|
||||
}
|
||||
|
||||
const expr_t *
|
||||
ruamoko_field_array (const expr_t *e)
|
||||
{
|
||||
ex_list_t list = {};
|
||||
// convert the left-branching field/array expression chain to a list
|
||||
while (e->type == ex_field || e->type == ex_array) {
|
||||
for (; e->type == ex_field; e = e->field.object) {
|
||||
list_prepend (&list, e);
|
||||
}
|
||||
for (; e->type == ex_array; e = e->array.base) {
|
||||
list_prepend (&list, e);
|
||||
}
|
||||
}
|
||||
// e is now the base object of the field/array expression chain
|
||||
|
||||
int num_obj = list_count (&list);
|
||||
const expr_t *objects[num_obj];
|
||||
list_scatter (&list, objects);
|
||||
for (int i = 0; i < num_obj; i++) {
|
||||
auto obj = objects[i];
|
||||
auto base_type = get_type (e);
|
||||
if (obj->type == ex_field) {
|
||||
if (obj->field.member->type != ex_symbol) {
|
||||
internal_error (obj->field.member, "not a symbol");
|
||||
}
|
||||
auto sym = obj->field.member->symbol;
|
||||
if (is_pointer (base_type)) {
|
||||
auto offset = new_short_expr (sym->offset);
|
||||
e = offset_pointer_expr (e, offset);
|
||||
e = cast_expr (pointer_type (obj->field.type), e);
|
||||
e = unary_expr ('.', e);
|
||||
} else if (e->type == ex_uexpr && e->expr.op == '.') {
|
||||
auto offset = new_short_expr (sym->offset);
|
||||
e = offset_pointer_expr (e->expr.e1, offset);
|
||||
e = cast_expr (pointer_type (obj->field.type), e);
|
||||
e = unary_expr ('.', e);
|
||||
} else {
|
||||
e = new_offset_alias_expr (obj->field.type, e, sym->offset);
|
||||
}
|
||||
} else if (obj->type == ex_array) {
|
||||
scoped_src_loc (obj->array.index);
|
||||
int base_ind = 0;
|
||||
if (is_array (base_type)) {
|
||||
base_ind = base_type->array.base;
|
||||
}
|
||||
auto ele_type = obj->array.type;
|
||||
auto base = new_int_expr (base_ind, false);
|
||||
auto scale = new_int_expr (type_size (ele_type), false);
|
||||
auto offset = binary_expr ('*', base, scale);
|
||||
auto index = binary_expr ('*', obj->array.index, scale);
|
||||
offset = binary_expr ('-', index, offset);
|
||||
const expr_t *ptr;
|
||||
if (is_array (base_type)) {
|
||||
if (e->type == ex_uexpr && e->expr.op == '.') {
|
||||
ptr = e->expr.e1;
|
||||
} else {
|
||||
auto alias = new_offset_alias_expr (ele_type, e, 0);
|
||||
ptr = new_address_expr (ele_type, alias, 0);
|
||||
}
|
||||
} else if (is_nonscalar (base_type) || is_matrix (base_type)) {
|
||||
auto alias = new_offset_alias_expr (ele_type, e, 0);
|
||||
ptr = new_address_expr (ele_type, alias, 0);
|
||||
} else {
|
||||
ptr = e;
|
||||
}
|
||||
ptr = offset_pointer_expr (ptr, offset);
|
||||
ptr = cast_expr (pointer_type (obj->field.type), ptr);
|
||||
e = unary_expr ('.', ptr);
|
||||
} else {
|
||||
internal_error (obj, "what the what?!?");
|
||||
}
|
||||
}
|
||||
return e;
|
||||
}
|
||||
|
||||
const expr_t *
|
||||
ruamoko_proc_address (const expr_t *expr)
|
||||
{
|
||||
scoped_src_loc (expr);
|
||||
auto e = expr_process (expr->expr.e1);
|
||||
if (is_error (e)) {
|
||||
return e;
|
||||
}
|
||||
if (e->type == ex_field || e->type == ex_array) {
|
||||
e = ruamoko_field_array (e);
|
||||
}
|
||||
return address_expr (e, nullptr);
|
||||
}
|
||||
|
||||
target_t ruamoko_target = {
|
||||
.value_too_large = ruamoko_value_too_large,
|
||||
.build_scope = ruamoko_build_scope,
|
||||
|
|
@ -240,4 +362,7 @@ target_t ruamoko_target = {
|
|||
.declare_sym = declare_def,
|
||||
.initialized_temp = initialized_temp_expr,
|
||||
.assign_vector = ruamoko_assign_vector,
|
||||
.proc_switch = ruamoko_proc_switch,
|
||||
.proc_caselabel = ruamoko_proc_caselabel,
|
||||
.proc_address = ruamoko_proc_address,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1635,6 +1635,9 @@ spirv_loop (const expr_t *e, spirvctx_t *ctx)
|
|||
spirv_SplitBlock (ctx);
|
||||
spirv_emit_expr (e->loop.body, ctx);
|
||||
spirv_SplitBlockId (cont, ctx);
|
||||
if (e->loop.continue_body) {
|
||||
spirv_emit_expr (e->loop.continue_body, ctx);
|
||||
}
|
||||
unsigned test = spirv_emit_expr (e->loop.test, ctx);
|
||||
spirv_BranchConditional (e->loop.not, test, merge, loop, ctx);
|
||||
spirv_LabelId (merge, ctx);
|
||||
|
|
@ -1648,6 +1651,9 @@ spirv_loop (const expr_t *e, spirvctx_t *ctx)
|
|||
spirv_LabelId (body, ctx);
|
||||
spirv_emit_expr (e->loop.body, ctx);
|
||||
spirv_SplitBlockId (cont, ctx);
|
||||
if (e->loop.continue_body) {
|
||||
spirv_emit_expr (e->loop.continue_body, ctx);
|
||||
}
|
||||
spirv_Branch (loop, ctx);
|
||||
spirv_LabelId (merge, ctx);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -201,6 +201,9 @@ target_t v6_target = {
|
|||
.vararg_int = vararg_int,
|
||||
.initialized_temp = initialized_temp_expr,
|
||||
.assign_vector = v6p_assign_vector,
|
||||
.proc_switch = ruamoko_proc_switch,
|
||||
.proc_caselabel = ruamoko_proc_caselabel,
|
||||
.proc_address = ruamoko_proc_address,
|
||||
};
|
||||
|
||||
target_t v6p_target = {
|
||||
|
|
@ -211,4 +214,7 @@ target_t v6p_target = {
|
|||
.vararg_int = vararg_int,
|
||||
.initialized_temp = initialized_temp_expr,
|
||||
.assign_vector = v6p_assign_vector,
|
||||
.proc_switch = ruamoko_proc_switch,
|
||||
.proc_caselabel = ruamoko_proc_caselabel,
|
||||
.proc_address = ruamoko_proc_address,
|
||||
};
|
||||
|
|
|
|||
Loading…
Reference in a new issue