qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-04-04 16:31:30 +00:00
Code Issues Projects Releases Packages Wiki Activity

[qfcc] Make expressions const-correct

Browse source 
Or at least mostly so (there are a few casts). This doesn't fix the
motor bug, but I've wanted to do this for over twenty years and at least
I know what's not causing the bug. However, disabling fold_constants in
expr_algebra.c does "fix" things, so it's still a good place to look.
This commit is contained in:
Bill Currie 2023-09-27 12:41:31 +09:00
parent 153a19937f
commit 210a925be4
50 changed files with 1653 additions and 1924 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
tools/qfcc/include/algebra.h
View file

@ -86,7 +86,7 @@ typedef struct multivector_s {
struct expr_s;
struct attribute_s;
bool is_algebra (const struct type_s *type) __attribute__((pure));
struct type_s *algebra_type (struct type_s *type, struct expr_s *params);
struct type_s *algebra_type (struct type_s *type, const struct expr_s *params);
struct type_s *algebra_subtype (struct type_s *type, struct attribute_s *attr);
struct type_s *algebra_mvec_type (algebra_t *algebra, pr_uint_t group_mask);
int algebra_count_flips (const algebra_t *alg, pr_uint_t a, pr_uint_t b) __attribute__((pure));
@ -109,14 +109,16 @@ bool is_mono_grade (const struct type_s *type) __attribute__((pure));
int algebra_get_grade (const struct type_s *type) __attribute__((pure));
int algebra_blade_grade (basis_blade_t blade) __attribute__((const));
struct expr_s *algebra_binary_expr (int op, struct expr_s *e1,
struct expr_s *e2);
struct expr_s *algebra_negate (struct expr_s *e);
struct expr_s *algebra_dual (struct expr_s *e);
struct expr_s *algebra_reverse (struct expr_s *e);
struct expr_s *algebra_cast_expr (struct type_s *dstType, struct expr_s *e);
struct expr_s *algebra_assign_expr (struct expr_s *dst, struct expr_s *src);
struct expr_s *algebra_field_expr (struct expr_s *mvec,
struct expr_s *field_name);
const struct expr_s *algebra_binary_expr (int op, const struct expr_s *e1,
const struct expr_s *e2);
const struct expr_s *algebra_negate (const struct expr_s *e);
const struct expr_s *algebra_dual (const struct expr_s *e);
const struct expr_s *algebra_reverse (const struct expr_s *e);
const struct expr_s *algebra_cast_expr (struct type_s *dstType,
const struct expr_s *e);
const struct expr_s *algebra_assign_expr (const struct expr_s *dst,
const struct expr_s *src);
const struct expr_s *algebra_field_expr (const struct expr_s *mvec,
const struct expr_s *field_name);
#endif//__algebra_h

4
tools/qfcc/include/attribute.h
View file

@ -34,10 +34,10 @@
typedef struct attribute_s {
struct attribute_s *next;
const char *name;
struct expr_s *params;
const struct expr_s *params;
} attribute_t;
struct expr_s;
attribute_t *new_attribute(const char *name, struct expr_s *params);
attribute_t *new_attribute(const char *name, const struct expr_s *params);
#endif//attribute_h

2
tools/qfcc/include/class.h
View file

@ -148,7 +148,7 @@ void class_finish_ivar_scope (class_type_t *class_type,
struct method_s *class_find_method (class_type_t *class_type,
struct method_s *method);
struct method_s *class_message_response (struct type_s *clstype, int class_msg,
struct expr_s *sel);
const struct expr_s *sel);
struct symbol_s *class_pointer_symbol (class_t *class_type);
category_t *get_category (struct symbol_s *class_name,
const char *category_name, int create);

2
tools/qfcc/include/dags.h
View file

@ -50,7 +50,7 @@ typedef struct daglabel_s {
const char *opcode; ///< not if op
struct operand_s *op; ///< not if opcode;
struct dagnode_s *dagnode; ///< node with which this label is associated
struct expr_s *expr; ///< expression associated with this label
const struct expr_s *expr; ///< expression associated with this label
} daglabel_t;
typedef struct dagnode_s {

4
tools/qfcc/include/def.h
View file

@ -86,7 +86,7 @@ typedef struct def_s {
struct def_s *alias; ///< real def which this def aliases
//@}
struct reloc_s *relocs; ///< for relocations
struct expr_s *initializer;///< initialer expression
const struct expr_s *initializer;///< initialer expression
struct daglabel_s *daglabel;///< daglabel for this def
struct flowvar_s *flowvar; ///< flowvar for this def
@ -254,7 +254,7 @@ void init_vector_components (struct symbol_s *vector_sym, int is_field,
\param symtab The symbol table into which the def will be placed.
*/
void initialize_def (struct symbol_s *sym,
struct expr_s *init, struct defspace_s *space,
const struct expr_s *init, struct defspace_s *space,
storage_class_t storage, struct symtab_s *symtab);
/** Convenience function for obtaining a def's actual offset.

16
tools/qfcc/include/diagnostic.h
View file

@ -42,8 +42,8 @@ extern diagnostic_hook error_hook;
extern diagnostic_hook warning_hook;
extern diagnostic_hook notice_hook;
struct expr_s *_error (struct expr_s *e, const char *file, int line,
const char *func, const char *fmt, ...)
struct expr_s *_error (const struct expr_s *e, const char *file,
int line, const char *func, const char *fmt, ...)
__attribute__ ((format (PRINTF, 5, 6)));
#define error(e, fmt...) _error(e, __FILE__, __LINE__, __FUNCTION__, fmt)
@ -52,22 +52,22 @@ void _internal_error (const struct expr_s *e, const char *file, int line,
__attribute__ ((format (PRINTF, 5, 6), noreturn));
#define internal_error(e, fmt...) _internal_error(e, __FILE__, __LINE__, __FUNCTION__, fmt)
struct expr_s *_warning (struct expr_s *e, const char *file, int line,
const char *func, const char *fmt, ...)
struct expr_s *_warning (const struct expr_s *e, const char *file,
int line, const char *func, const char *fmt, ...)
__attribute__ ((format (PRINTF, 5, 6)));
#define warning(e, fmt...) _warning(e, __FILE__, __LINE__, __FUNCTION__, fmt)
struct expr_s *_notice (struct expr_s *e, const char *file, int line,
const char *func, const char *fmt, ...)
struct expr_s *_notice (const struct expr_s *e, const char *file,
int line, const char *func, const char *fmt, ...)
__attribute__ ((format (PRINTF, 5, 6)));
#define notice(e, fmt...) _notice(e, __FILE__, __LINE__, __FUNCTION__, fmt)
void _debug (struct expr_s *e, const char *file, int line,
void _debug (const struct expr_s *e, const char *file, int line,
const char *func, const char *fmt, ...)
__attribute__ ((format (PRINTF, 5, 6)));
#define debug(e, fmt...) _debug(e, __FILE__, __LINE__, __FUNCTION__, fmt)
void _bug (struct expr_s *e, const char *file, int line,
void _bug (const struct expr_s *e, const char *file, int line,
const char * func, const char *fmt, ...)
__attribute__ ((format (PRINTF, 5, 6)));
#define bug(e, fmt...) _bug(e, __FILE__, __LINE__, __FUNCTION__, fmt)

4
tools/qfcc/include/dot.h
View file

@ -31,7 +31,7 @@
#ifndef dot_h
#define dot_h
void dump_dot (const char *stage, void *data,
void (*dump_func) (void *data, const char *fname));
void dump_dot (const char *stage, const void *data,
void (*dump_func) (const void *data, const char *fname));
#endif//dot_h

2
tools/qfcc/include/evaluate.h
View file

@ -40,7 +40,7 @@ struct type_s;
struct ex_value_s;
struct ex_value_s *convert_value (struct ex_value_s *value,
struct type_s *type);
struct expr_s *evaluate_constexpr (struct expr_s *e);
const struct expr_s *evaluate_constexpr (const struct expr_s *e);
void setup_value_progs (void);
///@}

384
tools/qfcc/include/expr.h
View file

@ -54,12 +54,12 @@ typedef enum {
though special codes are used for non-math expressions.
*/
typedef struct ex_expr_s {
int op; ///< op-code of this expression
bool commutative; ///< e1 and e2 can be swapped
bool anticommute; ///< e1 and e2 can be swapped with negation
struct type_s *type; ///< the type of the result of this expression
struct expr_s *e1; ///< left side of binary, sole of unary
struct expr_s *e2; ///< right side of binary, null for unary
int op; ///< op-code of this expression
bool commutative; ///< e1 and e2 can be swapped
bool anticommute; ///< e1 and e2 can be swapped with negation
const struct type_s *type; ///< the type of the result of this expression
const struct expr_s *e1; ///< left side of binary, sole of unary
const struct expr_s *e2; ///< right side of binary, null for unary
} ex_expr_t;
typedef struct ex_label_s {
@ -73,20 +73,20 @@ typedef struct ex_label_s {
} ex_label_t;
typedef struct {
ex_label_t *label;
const ex_label_t *label;
} ex_labelref_t;
typedef struct designator_s {
struct designator_s *next;
struct expr_s *field;
struct expr_s *index;
const struct expr_s *field;
const struct expr_s *index;
} designator_t;
typedef struct element_s {
struct element_s *next; ///< next in chain
int offset;
struct type_s *type;
struct expr_s *expr; ///< initializer expression
const struct expr_s *expr; ///< initializer expression
designator_t *designator; ///< for labeled initializers
} element_t;
@ -97,7 +97,7 @@ typedef struct element_chain_s {
typedef struct ex_listitem_s {
struct ex_listitem_s *next;
struct expr_s *expr;
const struct expr_s *expr;
} ex_listitem_t;
typedef struct ex_list_s {
@ -110,7 +110,7 @@ typedef union {
struct {
ex_listitem_t *head;
ex_listitem_t **tail;
struct expr_s *result; ///< the result of this block if non-void
const struct expr_s *result;///< the result of this block if non-void
int is_call; ///< this block exprssion forms a function call
void *return_addr;///< who allocated this
};
@ -123,13 +123,13 @@ typedef struct {
} ex_temp_t;
typedef struct {
struct type_s *type; ///< Type of vector (vector/quaternion)
struct expr_s *list; ///< Linked list of element expressions.
struct type_s *type; ///< Type of vector (vector/quaternion)
const struct expr_s *list; ///< Linked list of element expressions.
} ex_vector_t;
typedef struct {
struct expr_s *sel_ref; ///< Reference to selector in selector table
struct selector_s *sel; ///< selector
const struct expr_s *sel_ref; ///< Reference to selector in selector table
struct selector_s *sel; ///< selector
} ex_selector_t;
/** Pointer constant expression.
@ -156,13 +156,13 @@ typedef struct {
typedef struct {
ex_boollist_t *true_list;
ex_boollist_t *false_list;
struct expr_s *e;
const struct expr_s *e;
} ex_bool_t;
typedef struct ex_memset_s {
struct expr_s *dst;
struct expr_s *val;
struct expr_s *count;
const struct expr_s *dst;
const struct expr_s *val;
const struct expr_s *count;
} ex_memset_t;
/** State expression used for think function state-machines.
@ -200,9 +200,9 @@ typedef struct ex_memset_s {
<code>state.f framenum, nextthink, timestep</code> (QF, optional).
*/
typedef struct {
struct expr_s *frame; ///< the frame to which to change in this state
struct expr_s *think; ///< think function for the next state
struct expr_s *step; ///< time step until the next state
const struct expr_s *frame; ///< the frame to which to change in this state
const struct expr_s *think; ///< think function for the next state
const struct expr_s *step; ///< time step until the next state
} ex_state_t;
typedef struct ex_value_s {
@ -232,32 +232,32 @@ typedef struct ex_value_s {
typedef struct {
struct type_s *type; ///< type to view the expression
struct expr_s *expr; ///< the expression to alias
struct expr_s *offset; ///< offset for alias
const struct expr_s *expr; ///< the expression to alias
const struct expr_s *offset; ///< offset for alias
} ex_alias_t;
typedef struct {
struct type_s *type; ///< pointer type
struct expr_s *lvalue; ///< the lvalue being addressed
struct expr_s *offset; ///< offset from the address
const struct expr_s *lvalue; ///< the lvalue being addressed
const struct expr_s *offset; ///< offset from the address
} ex_address_t;
typedef struct {
struct expr_s *dst; ///< destination of assignment
struct expr_s *src; ///< source of assignment
const struct expr_s *dst; ///< destination of assignment
const struct expr_s *src; ///< source of assignment
} ex_assign_t;
typedef struct {
pr_branch_e type; ///< type of branch
struct expr_s *target; ///< destination of branch
struct expr_s *index; ///< index for indirect branches
struct expr_s *test; ///< test expression (null for jump/call)
struct expr_s *args; ///< only for call
const struct expr_s *target; ///< destination of branch
const struct expr_s *index; ///< index for indirect branches
const struct expr_s *test; ///< test expression (null for jump/call)
const struct expr_s *args; ///< only for call
struct type_s *ret_type; ///< void for non-call
} ex_branch_t;
typedef struct {
struct expr_s *ret_val;
const struct expr_s *ret_val;
int at_return; ///< return void_return call through void
} ex_return_t;
@ -269,12 +269,12 @@ typedef struct {
typedef struct {
short mode;
short reg; ///< base register to load
struct expr_s *with; ///< value to load
const struct expr_s *with; ///< value to load
} ex_with_t;
typedef struct {
int op; ///< operation to perform
struct expr_s *vec; ///< vector expression on which to operate
const struct expr_s *vec; ///< vector expression on which to operate
struct type_s *type; ///< result type
} ex_horizontal_t;
@ -282,7 +282,7 @@ typedef struct {
//care must be taken when working with smaller source operands (check aligmnet
//and adjust swizzle operation as needed)
typedef struct {
struct expr_s *src; ///< source expression
const struct expr_s *src; ///< source expression
unsigned source[4]; ///< src component indices
unsigned neg; ///< bitmask of dst components to negate
unsigned zero; ///< bitmask of dst components to 0
@ -290,7 +290,7 @@ typedef struct {
} ex_swizzle_t;
typedef struct {
struct expr_s *src; ///< source expression
const struct expr_s *src; ///< source expression
int extend; ///< extend mode 0: 0, 1: 1, 2: copy/0 3:-1
bool reverse; ///< reverse resultant vector
struct type_s *type; ///< result type;
@ -300,7 +300,7 @@ typedef struct {
struct type_s *type; ///< overall type of multivector
struct algebra_s *algebra; ///< owning algebra
int count; ///< number of component expressions
struct expr_s *components; ///< multivector components
const struct expr_s *components;///< multivector components
} ex_multivec_t;
#define POINTER_VAL(p) (((p).def ? (p).def->offset : 0) + (p).val)
@ -356,11 +356,11 @@ extern const char *expr_names[];
\param op The opcode of the expression.
\return \a e1 with its type set to ex_error.
*/
expr_t *type_mismatch (expr_t *e1, expr_t *e2, int op);
expr_t *type_mismatch (const expr_t *e1, const expr_t *e2, int op);
expr_t *param_mismatch (expr_t *e, int param, const char *fn,
struct type_s *t1, struct type_s *t2);
expr_t *test_error (expr_t *e, struct type_s *t);
expr_t *param_mismatch (const expr_t *e, int param, const char *fn,
struct type_s *t1, struct type_s *t2);
expr_t *test_error (const expr_t *e, struct type_s *t);
extern expr_t *local_expr;
@ -370,7 +370,7 @@ extern expr_t *local_expr;
\return Pointer to the type description, or null if the expression
type (expr_t::type) is inappropriate.
*/
struct type_s *get_type (expr_t *e);
struct type_s *get_type (const expr_t *e);
/** Get the basic type code of the expression result.
@ -378,16 +378,16 @@ struct type_s *get_type (expr_t *e);
\return Pointer to the type description, or ev_type_count if
get_type() returns null.
*/
etype_t extract_type (expr_t *e);
etype_t extract_type (const expr_t *e);
ex_listitem_t *new_listitem (expr_t *e);
int list_count (ex_list_t *list) __attribute__((pure));
void list_scatter (ex_list_t *list, expr_t **exprs);
void list_scatter_rev (ex_list_t *list, expr_t **exprs);
void list_gather (ex_list_t *dst, expr_t **exprs, int count);
expr_t *new_list_expr (expr_t *first);
expr_t *list_append_expr (expr_t *list, expr_t *expr);
expr_t *list_prepend_expr (expr_t *list, expr_t *expr);
ex_listitem_t *new_listitem (const expr_t *e);
int list_count (const ex_list_t *list) __attribute__((pure));
void list_scatter (const ex_list_t *list, const expr_t **exprs);
void list_scatter_rev (const ex_list_t *list, const expr_t **exprs);
void list_gather (ex_list_t *dst, const expr_t **exprs, int count);
expr_t *new_list_expr (const expr_t *first);
expr_t *list_append_expr (expr_t *list, const expr_t *expr);
expr_t *list_prepend_expr (expr_t *list, const expr_t *expr);
expr_t *list_append_list (expr_t *list, ex_list_t *append);
expr_t *list_prepend_list (expr_t *list, ex_list_t *prepend);
@ -400,13 +400,6 @@ expr_t *list_prepend_list (expr_t *list, ex_list_t *prepend);
*/
expr_t *new_expr (void);
/** Create a deep copy of an expression tree.
\param e The root of the expression tree to copy.
\return A new expression tree giving the same expression.
*/
expr_t *copy_expr (expr_t *e);
/** Copy source expression's file and line to the destination expression
\param dst The expression to receive the file and line
@ -444,7 +437,7 @@ expr_t *new_label_expr (void);
label scope.
\return The new label expression (::ex_label_t) node.
*/
expr_t *named_label_expr (struct symbol_s *label);
const expr_t *named_label_expr (struct symbol_s *label);
/** Create a new label reference expression node.
@ -453,7 +446,7 @@ expr_t *named_label_expr (struct symbol_s *label);
\return The new label reference expression (::ex_labelref_t) node.
*/
expr_t *new_label_ref (ex_label_t *label);
expr_t *new_label_ref (const ex_label_t *label);
/** Create a new state expression node.
@ -466,19 +459,21 @@ expr_t *new_label_ref (ex_label_t *label);
no time-step is specified (standard form).
\return The new state expression (::ex_state_t) node.
*/
expr_t *new_state_expr (expr_t *frame, expr_t *think, expr_t *step);
expr_t *new_state_expr (const expr_t *frame, const expr_t *think,
const expr_t *step);
expr_t *new_bool_expr (ex_boollist_t *true_list, ex_boollist_t *false_list,
expr_t *e);
const expr_t *e);
/** Create a new statement block expression node.
The returned block expression is empty. Use append_expr() to add
expressions to the block expression.
\param old Old block expression to copy or null if a fresh block.
\return The new block expression (::ex_block_t) node.
*/
expr_t *new_block_expr (void);
expr_t *new_block_expr (const expr_t *old);
/** Create a new statement block expression node from an expression list
@ -489,16 +484,17 @@ expr_t *new_block_expr (void);
*/
expr_t *build_block_expr (expr_t *list, bool set_result);
designator_t *new_designator (expr_t *field, expr_t *index);
element_t *new_element (expr_t *expr, designator_t *designator);
designator_t *new_designator (const expr_t *field, const expr_t *index);
element_t *new_element (const expr_t *expr, designator_t *designator);
expr_t *new_compound_init (void);
expr_t *append_element (expr_t *compound, element_t *element);
expr_t *initialized_temp_expr (const struct type_s *type, expr_t *compound);
void assign_elements (expr_t *local_expr, expr_t *ptr,
expr_t *initialized_temp_expr (const struct type_s *type,
const expr_t *compound);
void assign_elements (expr_t *local_expr, const expr_t *ptr,
element_chain_t *element_chain);
void build_element_chain (element_chain_t *element_chain,
const struct type_s *type,
expr_t *eles, int base_offset);
const expr_t *eles, int base_offset);
void free_element_chain (element_chain_t *element_chain);
/** Create a new binary expression node.
@ -513,7 +509,7 @@ void free_element_chain (element_chain_t *element_chain);
\a e1 nor \a e2 are error expressions, otherwise the
expression that is an error expression.
*/
expr_t *new_binary_expr (int op, expr_t *e1, expr_t *e2);
expr_t *new_binary_expr (int op, const expr_t *e1, const expr_t *e2);
/** Create a new unary expression node.
@ -525,7 +521,7 @@ expr_t *new_binary_expr (int op, expr_t *e1, expr_t *e2);
\return The new unary expression node (::ex_expr_t) if \a e1
is not an error expression, otherwise \a e1.
*/
expr_t *new_unary_expr (int op, expr_t *e1);
expr_t *new_unary_expr (int op, const expr_t *e1);
/** Create a new horizontal vector operantion node.
@ -538,11 +534,12 @@ expr_t *new_unary_expr (int op, expr_t *e1);
\return The new unary expression node (::ex_expr_t) if \a e1
is not an error expression, otherwise \a e1.
*/
expr_t *new_horizontal_expr (int op, expr_t *vec, struct type_s *type);
expr_t *new_horizontal_expr (int op, const expr_t *vec, struct type_s *type);
expr_t *new_swizzle_expr (expr_t *src, const char *swizzle);
expr_t *new_swizzle_expr (const expr_t *src, const char *swizzle);
expr_t *new_extend_expr (expr_t *src, struct type_s *type, int ext, bool rev);
expr_t *new_extend_expr (const expr_t *src, struct type_s *type, int ext,
bool rev);
/** Create a new def reference (non-temporary variable) expression node.
@ -587,7 +584,7 @@ expr_t *new_args_expr (void);
\param value The value to put in the expression node.
\return The new value expression.
*/
expr_t *new_value_expr (ex_value_t *value);
const expr_t *new_value_expr (ex_value_t *value);
/** Create a new typed zero value expression node.
@ -596,16 +593,16 @@ expr_t *new_value_expr (ex_value_t *value);
\param type The type to use for the zero.
\return The new value expression.
*/
expr_t *new_zero_expr (struct type_s *type);
const expr_t *new_zero_expr (struct type_s *type);
/** Create a new symbol expression node from a name.
\param name The name for the symbol.
\return The new symbol expression.
*/
expr_t *new_name_expr (const char *name);
const expr_t *new_name_expr (const char *name);
struct symbol_s *get_name (expr_t *e) __attribute__((pure));
struct symbol_s *get_name (const expr_t *e) __attribute__((pure));
/** Create a new string constant expression node.
@ -613,8 +610,8 @@ struct symbol_s *get_name (expr_t *e) __attribute__((pure));
\return The new string constant expression node
(expr_t::e::string_val).
*/
expr_t *new_string_expr (const char *string_val);
const char *expr_string (expr_t *e) __attribute__((pure));
const expr_t *new_string_expr (const char *string_val);
const char *expr_string (const expr_t *e) __attribute__((pure));
/** Create a new double constant expression node.
@ -622,8 +619,8 @@ const char *expr_string (expr_t *e) __attribute__((pure));
\return The new double constant expression node
(expr_t::e::double_val).
*/
expr_t *new_double_expr (double double_val);
double expr_double (expr_t *e) __attribute__((pure));
const expr_t *new_double_expr (double double_val, bool implicit);
double expr_double (const expr_t *e) __attribute__((pure));
/** Create a new float constant expression node.
@ -631,8 +628,8 @@ double expr_double (expr_t *e) __attribute__((pure));
\return The new float constant expression node
(expr_t::e::float_val).
*/
expr_t *new_float_expr (float float_val);
float expr_float (expr_t *e) __attribute__((pure));
const expr_t *new_float_expr (float float_val);
float expr_float (const expr_t *e) __attribute__((pure));
/** Create a new vector constant expression node.
@ -640,9 +637,9 @@ float expr_float (expr_t *e) __attribute__((pure));
\return The new vector constant expression node
(expr_t::e::vector_val).
*/
expr_t *new_vector_expr (const float *vector_val);
const float *expr_vector (expr_t *e) __attribute__((pure));
expr_t *new_vector_list (expr_t *e);
const expr_t *new_vector_expr (const float *vector_val);
const float *expr_vector (const expr_t *e) __attribute__((pure));
const expr_t *new_vector_list (const expr_t *e);
/** Create a new entity constant expression node.
@ -650,7 +647,7 @@ expr_t *new_vector_list (expr_t *e);
\return The new entity constant expression node
(expr_t::e::entity_val).
*/
expr_t *new_entity_expr (int entity_val);
const expr_t *new_entity_expr (int entity_val);
/** Create a new field constant expression node.
@ -660,9 +657,10 @@ expr_t *new_entity_expr (int entity_val);
\return The new field constant expression node
(expr_t::e::field_val).
*/
expr_t *new_field_expr (int field_val, struct type_s *type, struct def_s *def);
struct symbol_s *get_struct_field (const struct type_s *t1, expr_t *e1,
expr_t *e2);
const expr_t *new_field_expr (int field_val, struct type_s *type,
struct def_s *def);
struct symbol_s *get_struct_field (const struct type_s *t1, const expr_t *e1,
const expr_t *e2);
/** Create a new function constant expression node.
@ -671,7 +669,7 @@ struct symbol_s *get_struct_field (const struct type_s *t1, expr_t *e1,
\return The new function constant expression node
(expr_t::e::func_val).
*/
expr_t *new_func_expr (int func_val, struct type_s *type);
const expr_t *new_func_expr (int func_val, struct type_s *type);
/** Create a new pointer constant expression node.
@ -681,7 +679,8 @@ expr_t *new_func_expr (int func_val, struct type_s *type);
\return The new pointer constant expression node
(expr_t::e::pointer_val).
*/
expr_t *new_pointer_expr (int val, struct type_s *type, struct def_s *def);
const expr_t *new_pointer_expr (int val, struct type_s *type,
struct def_s *def);
/** Create a new quaternion constant expression node.
@ -689,8 +688,8 @@ expr_t *new_pointer_expr (int val, struct type_s *type, struct def_s *def);
\return The new quaternion constant expression node
(expr_t::e::quaternion_val).
*/
expr_t *new_quaternion_expr (const float *quaternion_val);
const float *expr_quaternion (expr_t *e) __attribute__((pure));
const expr_t *new_quaternion_expr (const float *quaternion_val);
const float *expr_quaternion (const expr_t *e) __attribute__((pure));
/** Create a new itn constant expression node.
@ -698,8 +697,8 @@ const float *expr_quaternion (expr_t *e) __attribute__((pure));
\return The new int constant expression node
(expr_t::e::int_val).
*/
expr_t *new_int_expr (int int_val);
int expr_int (expr_t *e) __attribute__((pure));
const expr_t *new_int_expr (int int_val);
int expr_int (const expr_t *e) __attribute__((pure));
/** Create a new int constant expression node.
@ -707,11 +706,11 @@ int expr_int (expr_t *e) __attribute__((pure));
\return The new int constant expression node
(expr_t::e::int_val).
*/
expr_t *new_uint_expr (unsigned uint_val);
unsigned expr_uint (expr_t *e) __attribute__((pure));
const expr_t *new_uint_expr (unsigned uint_val);
unsigned expr_uint (const expr_t *e) __attribute__((pure));
expr_t *new_long_expr (pr_long_t long_val);
expr_t *new_ulong_expr (pr_ulong_t ulong_val);
const expr_t *new_long_expr (pr_long_t long_val);
const expr_t *new_ulong_expr (pr_ulong_t ulong_val);
/** Create a new short constant expression node.
@ -719,18 +718,18 @@ expr_t *new_ulong_expr (pr_ulong_t ulong_val);
\return The new short constant expression node
(expr_t::e::short_val).
*/
expr_t *new_short_expr (short short_val);
short expr_short (expr_t *e) __attribute__((pure));
unsigned short expr_ushort (expr_t *e) __attribute__((pure));
const expr_t *new_short_expr (short short_val);
short expr_short (const expr_t *e) __attribute__((pure));
unsigned short expr_ushort (const expr_t *e) __attribute__((pure));
int expr_integral (expr_t *e) __attribute__((pure));
int expr_integral (const expr_t *e) __attribute__((pure));
/** Check if the expression refers to a constant value.
\param e The expression to check.
\return True if the expression is constant.
*/
int is_constant (expr_t *e) __attribute__((pure));
int is_constant (const expr_t *e) __attribute__((pure));
/** Check if the expression refers to a variable.
@ -738,14 +737,14 @@ int is_constant (expr_t *e) __attribute__((pure));
\return True if the expression refers to a variable (def
expression, var symbol expression, or temp expression).
*/
int is_variable (expr_t *e) __attribute__((pure));
int is_variable (const expr_t *e) __attribute__((pure));
/** Check if the expression refers to a selector
\param e The expression to check.
\return True if the expression is a selector.
*/
int is_selector (expr_t *e) __attribute__((pure));
int is_selector (const expr_t *e) __attribute__((pure));
/** Return a value expression representing the constant stored in \a e.
@ -755,7 +754,7 @@ int is_selector (expr_t *e) __attribute__((pure));
\param e The expression from which to extract the value.
\return A new expression holding the value of \a e or \e itself.
*/
expr_t *constant_expr (expr_t *e);
const expr_t *constant_expr (const expr_t *e);
/** Check if the op-code is a comparison.
@ -778,20 +777,20 @@ int is_math_op (int op) __attribute__((const));
*/
int is_logic (int op) __attribute__((const));
int has_function_call (expr_t *e) __attribute__((pure));
int is_function_call (expr_t *e) __attribute__((pure));
int has_function_call (const expr_t *e) __attribute__((pure));
int is_function_call (const expr_t *e) __attribute__((pure));
int is_nil (expr_t *e) __attribute__((pure));
int is_string_val (expr_t *e) __attribute__((pure));
int is_float_val (expr_t *e) __attribute__((pure));
int is_vector_val (expr_t *e) __attribute__((pure));
int is_quaternion_val (expr_t *e) __attribute__((pure));
int is_int_val (expr_t *e) __attribute__((pure));
int is_uint_val (expr_t *e) __attribute__((pure));
int is_short_val (expr_t *e) __attribute__((pure));
int is_integral_val (expr_t *e) __attribute__((pure));
int is_pointer_val (expr_t *e) __attribute__((pure));
int is_math_val (expr_t *e) __attribute__((pure));
int is_nil (const expr_t *e) __attribute__((pure));
int is_string_val (const expr_t *e) __attribute__((pure));
int is_float_val (const expr_t *e) __attribute__((pure));
int is_vector_val (const expr_t *e) __attribute__((pure));
int is_quaternion_val (const expr_t *e) __attribute__((pure));
int is_int_val (const expr_t *e) __attribute__((pure));
int is_uint_val (const expr_t *e) __attribute__((pure));
int is_short_val (const expr_t *e) __attribute__((pure));
int is_integral_val (const expr_t *e) __attribute__((pure));
int is_pointer_val (const expr_t *e) __attribute__((pure));
int is_math_val (const expr_t *e) __attribute__((pure));
/** Create a reference to the global <code>.self</code> entity variable.
@ -812,17 +811,18 @@ expr_t *new_this_expr (void);
\param type The type of the reference to the return slot.
\return A new expression referencing the return slot.
*/
expr_t *new_ret_expr (struct type_s *type);
const expr_t *new_ret_expr (struct type_s *type);
expr_t *new_alias_expr (struct type_s *type, expr_t *expr);
expr_t *new_offset_alias_expr (struct type_s *type, expr_t *expr, int offset);
const expr_t *new_alias_expr (struct type_s *type, const expr_t *expr);
const expr_t *new_offset_alias_expr (struct type_s *type, const expr_t *expr,
int offset);
expr_t *new_address_expr (struct type_s *lvtype, expr_t *lvalue,
expr_t *offset);
expr_t *new_assign_expr (expr_t *dst, expr_t *src);
expr_t *new_return_expr (expr_t *ret_val);
expr_t *new_address_expr (const struct type_s *lvtype, const expr_t *lvalue,
const expr_t *offset);
expr_t *new_assign_expr (const expr_t *dst, const expr_t *src);
expr_t *new_return_expr (const expr_t *ret_val);
expr_t *new_adjstk_expr (int mode, int offset);
expr_t *new_with_expr (int mode, int reg, expr_t *val);
expr_t *new_with_expr (int mode, int reg, const expr_t *val);
/** Create an expression of the correct type that references the specified
parameter slot.
@ -831,9 +831,10 @@ expr_t *new_with_expr (int mode, int reg, expr_t *val);
\param num The index of the parameter (0-7).
\return A new expression referencing the parameter slot.
*/
expr_t *new_param_expr (struct type_s *type, int num);
const expr_t *new_param_expr (struct type_s *type, int num);
expr_t *new_memset_expr (expr_t *dst, expr_t *val, expr_t *count);
expr_t *new_memset_expr (const expr_t *dst, const expr_t *val,
const expr_t *count);
/** Convert a name to an expression of the appropriate type.
@ -842,73 +843,84 @@ expr_t *new_memset_expr (expr_t *dst, expr_t *val, expr_t *count);
\param e The expression to convert.
*/
expr_t *convert_name (expr_t *e)__attribute__((warn_unused_result));
const expr_t *convert_name (const expr_t *e) __attribute__((warn_unused_result));
expr_t *append_expr (expr_t *block, expr_t *e);
expr_t *prepend_expr (expr_t *block, expr_t *e);
expr_t *append_expr (expr_t *block, const expr_t *e);
expr_t *prepend_expr (expr_t *block, const expr_t *e);
void print_expr (expr_t *e);
void dump_dot_expr (void *e, const char *filename);
void print_expr (const expr_t *e);
void dump_dot_expr (const void *e, const char *filename);
expr_t *convert_nil (expr_t *e, struct type_s *t);
const expr_t *convert_nil (const expr_t *e, const struct type_s *t) __attribute__((warn_unused_result));
expr_t *test_expr (expr_t *e);
void backpatch (ex_boollist_t *list, expr_t *label);
expr_t *convert_bool (expr_t *e, int block);
expr_t *convert_from_bool (expr_t *e, struct type_s *type);
expr_t *bool_expr (int op, expr_t *label, expr_t *e1, expr_t *e2);
expr_t *binary_expr (int op, expr_t *e1, expr_t *e2);
expr_t *field_expr (expr_t *e1, expr_t *e2);
expr_t *asx_expr (int op, expr_t *e1, expr_t *e2);
expr_t *unary_expr (int op, expr_t *e);
void vararg_integer (expr_t *e);
expr_t *build_function_call (expr_t *fexpr, const struct type_s *ftype,
expr_t *params);
expr_t *function_expr (expr_t *e1, expr_t *e2);
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_from_bool (const expr_t *e, struct type_s *type) __attribute__((warn_unused_result));
const expr_t *bool_expr (int op, const expr_t *label, const expr_t *e1,
const expr_t *e2);
const expr_t *binary_expr (int op, const expr_t *e1, const expr_t *e2);
const expr_t *field_expr (const expr_t *e1, const expr_t *e2);
const expr_t *asx_expr (int op, const expr_t *e1, const expr_t *e2);
const expr_t *unary_expr (int op, const expr_t *e);
void vararg_integer (const expr_t *e);
const expr_t *build_function_call (const expr_t *fexpr,
const struct type_s *ftype,
const expr_t *params);
const expr_t *function_expr (const expr_t *e1, const expr_t *e2);
struct function_s;
expr_t *branch_expr (int op, expr_t *test, expr_t *label);
expr_t *goto_expr (expr_t *label);
expr_t *jump_table_expr (expr_t *table, expr_t *index);
expr_t *call_expr (expr_t *func, expr_t *args, struct type_s *ret_type);
expr_t *return_expr (struct function_s *f, expr_t *e);
expr_t *at_return_expr (struct function_s *f, expr_t *e);
expr_t *conditional_expr (expr_t *cond, expr_t *e1, expr_t *e2);
expr_t *incop_expr (int op, expr_t *e, int postop);
expr_t *array_expr (expr_t *array, expr_t *index);
expr_t *deref_pointer_expr (expr_t *pointer);
expr_t *offset_pointer_expr (expr_t *pointer, expr_t *offset);
expr_t *address_expr (expr_t *e1, struct type_s *t);
expr_t *build_if_statement (int not, expr_t *test, expr_t *s1, expr_t *els,
expr_t *s2);
expr_t *build_while_statement (int not, expr_t *test, expr_t *statement,
expr_t *break_label, expr_t *continue_label);
expr_t *build_do_while_statement (expr_t *statement, int not, expr_t *test,
expr_t *break_label, expr_t *continue_label);
expr_t *build_for_statement (expr_t *init, expr_t *test, expr_t *next,
expr_t *statement,
expr_t *break_label, expr_t *continue_label);
expr_t *build_state_expr (expr_t *e);
expr_t *think_expr (struct symbol_s *think_sym);
const expr_t *branch_expr (int op, const expr_t *test, const expr_t *label);
const expr_t *goto_expr (const expr_t *label);
const expr_t *jump_table_expr (const expr_t *table, const expr_t *index);
const expr_t *call_expr (const expr_t *func, const expr_t *args,
struct type_s *ret_type);
const expr_t *return_expr (struct function_s *f, const expr_t *e);
const expr_t *at_return_expr (struct function_s *f, const expr_t *e);
const expr_t *conditional_expr (const expr_t *cond, const expr_t *e1,
const expr_t *e2);
const expr_t *incop_expr (int op, const expr_t *e, int postop);
const expr_t *array_expr (const expr_t *array, const expr_t *index);
const expr_t *deref_pointer_expr (const expr_t *pointer);
const expr_t *offset_pointer_expr (const expr_t *pointer, const expr_t *offset);
const expr_t *address_expr (const expr_t *e1, struct type_s *t);
const expr_t *build_if_statement (int not, const expr_t *test, const expr_t *s1,
const expr_t *els, const expr_t *s2);
const expr_t *build_while_statement (int not, const expr_t *test,
const expr_t *statement,
const expr_t *break_label,
const expr_t *continue_label);
const expr_t *build_do_while_statement (const expr_t *statement, int not,
const expr_t *test,
const expr_t *break_label,
const expr_t *continue_label);
const expr_t *build_for_statement (const expr_t *init, const expr_t *test,
const expr_t *next, const expr_t *statement,
const expr_t *break_label,
const expr_t *continue_label);
const expr_t *build_state_expr (const expr_t *e);
const expr_t *think_expr (struct symbol_s *think_sym);
int is_lvalue (const expr_t *expr) __attribute__((pure));
expr_t *assign_expr (expr_t *dst, expr_t *src);
expr_t *cast_expr (struct type_s *t, expr_t *e);
expr_t *cast_error (expr_t *e, struct type_s *t1, struct type_s *t2);
const expr_t *assign_expr (const expr_t *dst, const expr_t *src);
const expr_t *cast_expr (struct type_s *t, const expr_t *e);
const expr_t *cast_error (const expr_t *e, struct type_s *t1,
struct type_s *t2);
const char *get_op_string (int op) __attribute__((const));
struct keywordarg_s;
struct class_type_s;
expr_t *selector_expr (struct keywordarg_s *selector);
expr_t *protocol_expr (const char *protocol);
expr_t *encode_expr (struct type_s *type);
expr_t *super_expr (struct class_type_s *class_type);
expr_t *message_expr (expr_t *receiver, struct keywordarg_s *message);
expr_t *sizeof_expr (expr_t *expr, struct type_s *type);
const expr_t *selector_expr (struct keywordarg_s *selector);
const expr_t *protocol_expr (const char *protocol);
const expr_t *encode_expr (struct type_s *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 *sizeof_expr (const expr_t *expr, struct type_s *type);
expr_t *fold_constants (expr_t *e);
const expr_t *fold_constants (const expr_t *e);
void edag_flush (void);
expr_t *edag_add_expr (expr_t *e);
const expr_t *edag_add_expr (const expr_t *e);
///@}

10
tools/qfcc/include/flow.h
View file

@ -118,11 +118,11 @@ void flow_analyze_statement (struct statement_s *s, struct set_s *use,
void flow_data_flow (struct function_s *func);
void dump_dot_flow (void *g, const char *filename);
void dump_dot_flow_dags (void *g, const char *filename);
void dump_dot_flow_live (void *g, const char *filename);
void dump_dot_flow_reaching (void *g, const char *filename);
void dump_dot_flow_statements (void *g, const char *filename);
void dump_dot_flow (const void *g, const char *filename);
void dump_dot_flow_dags (const void *g, const char *filename);
void dump_dot_flow_live (const void *g, const char *filename);
void dump_dot_flow_reaching (const void *g, const char *filename);
void dump_dot_flow_statements (const void *g, const char *filename);
///@}

7
tools/qfcc/include/function.h
View file

@ -164,17 +164,18 @@ void make_function (struct symbol_s *sym, const char *nice_name,
struct defspace_s *space, enum storage_class_e storage);
struct symbol_s *function_symbol (struct symbol_s *sym,
int overload, int create);
struct expr_s *find_function (struct expr_s *fexpr, struct expr_s *params);
const struct expr_s *find_function (const struct expr_s *fexpr,
const struct expr_s *params);
function_t *new_function (const char *name, const char *nice_name);
void add_function (function_t *f);
function_t *begin_function (struct symbol_s *sym, const char *nicename,
struct symtab_s *parent, int far,
enum storage_class_e storage);
function_t *build_code_function (struct symbol_s *fsym,
struct expr_s *state_expr,
const struct expr_s *state_expr,
struct expr_s *statements);
function_t *build_builtin_function (struct symbol_s *sym,
struct expr_s *bi_val, int far,
const struct expr_s *bi_val, int far,
enum storage_class_e storage);
void emit_function (function_t *f, struct expr_s *e);
int function_parms (function_t *f, byte *parm_size);

5
tools/qfcc/include/method.h
View file

@ -105,7 +105,7 @@ method_t *methodlist_find_method (methodlist_t *methodlist,
void selector_name (struct dstring_s *sel_id, keywordarg_t *selector);
void method_types (struct dstring_s *sel_types, method_t *method);
int selector_index (const char *sel_id);
selector_t *get_selector (struct expr_s *sel);
selector_t *get_selector (const struct expr_s *sel);
struct def_s *emit_selectors(void);
struct def_s *emit_methods (methodlist_t *methods, const char *name,
@ -115,6 +115,7 @@ struct def_s *emit_method_descriptions (methodlist_t *_methods,
void clear_selectors (void);
struct expr_s *method_check_params (method_t *method, struct expr_s *args);
const struct expr_s *method_check_params (method_t *method,
const struct expr_s *args);
#endif//__method_h

31
tools/qfcc/include/statements.h
View file

@ -60,7 +60,8 @@ typedef struct pseudoop_s {
struct pseudoop_s *next;
const char *name;
struct flowvar_s *flowvar;
void (*uninitialized) (struct expr_s *expr, struct pseudoop_s *op);
void (*uninitialized) (const struct expr_s *expr,
struct pseudoop_s *op);
} pseudoop_t;
typedef struct operand_s {
@ -69,7 +70,7 @@ typedef struct operand_s {
struct type_s *type; ///< possibly override def's/nil's type
int size; ///< for structures
int width; ///< for SIMD selection
struct expr_s *expr; ///< expression generating this operand
const struct expr_s *expr; ///< expression generating this operand
void *return_addr; ///< who created this operand
union {
struct def_s *def;
@ -114,7 +115,7 @@ typedef struct statement_s {
operand_t *opa;
operand_t *opb;
operand_t *opc;
struct expr_s *expr; ///< source expression for this statement
const struct expr_s *expr; ///< source expression for this statement
operand_t *use; ///< list of auxiliary operands used
operand_t *def; ///< list of auxiliary operands defined
operand_t *kill; ///< list of auxiliary operands killed
@ -145,27 +146,27 @@ extern const char * const st_type_names[];
const char *optype_str (op_type_e type) __attribute__((const));
operand_t *nil_operand (struct type_s *type, struct expr_s *expr);
operand_t *nil_operand (struct type_s *type, const struct expr_s *expr);
operand_t *def_operand (struct def_s *def, struct type_s *type,
struct expr_s *expr);
operand_t *return_operand (struct type_s *type, struct expr_s *expr);
operand_t *value_operand (struct ex_value_s *value, struct expr_s *expr);
const struct expr_s *expr);
operand_t *return_operand (struct type_s *type, const struct expr_s *expr);
operand_t *value_operand (struct ex_value_s *value, const struct expr_s *expr);
int tempop_overlap (tempop_t *t1, tempop_t *t2) __attribute__((pure));
operand_t *temp_operand (struct type_s *type, struct expr_s *expr);
operand_t *temp_operand (const struct type_s *type, const struct expr_s *expr);
int tempop_visit_all (tempop_t *tempop, int overlap,
int (*visit) (tempop_t *, void *), void *data);
operand_t *offset_alias_operand (struct type_s *type, int offset,
operand_t *aop, struct expr_s *expr);
operand_t *aop, const struct expr_s *expr);
operand_t *alias_operand (struct type_s *type, operand_t *op,
struct expr_s *expr);
operand_t *label_operand (struct expr_s *label);
const struct expr_s *expr);
operand_t *label_operand (const struct expr_s *label);
void free_operand (operand_t *op);
sblock_t *new_sblock (void);
void free_sblock (sblock_t *sblock);
statement_t *new_statement (st_type_t type, const char *opcode,
struct expr_s *expr);
const struct expr_s *expr);
int statement_is_cond (statement_t *s) __attribute__((pure));
int statement_is_goto (statement_t *s) __attribute__((pure));
int statement_is_jumpb (statement_t *s) __attribute__((pure));
@ -174,14 +175,14 @@ int statement_is_return (statement_t *s) __attribute__((pure));
sblock_t *statement_get_target (statement_t *s) __attribute__((pure));
sblock_t **statement_get_targetlist (statement_t *s);
void sblock_add_statement (sblock_t *sblock, statement_t *statement);
sblock_t *make_statements (struct expr_s *expr);
sblock_t *make_statements (const struct expr_s *expr);
struct ex_list_s;
sblock_t *statement_slist (sblock_t *sblock, struct ex_list_s *slist);
sblock_t *statement_slist (sblock_t *sblock, const struct ex_list_s *slist);
void statements_count_temps (sblock_t *sblock);
void print_operand (operand_t *op);
void print_statement (statement_t *s);
void dump_dot_sblock (void *data, const char *fname);
void dump_dot_sblock (const void *data, const char *fname);
void dot_sblock (struct dstring_s *dstr, sblock_t *sblock, int blockno);
void print_sblock (sblock_t *sblock, const char *filename);
const char *operand_string (operand_t *op);

2
tools/qfcc/include/struct.h
View file

@ -56,7 +56,7 @@ struct symbol_s *find_enum (struct symbol_s *tag);
struct symtab_s *start_enum (struct symbol_s *enm);
struct symbol_s *finish_enum (struct symbol_s *sym);
void add_enum (struct symbol_s *enm, struct symbol_s *name,
struct expr_s *val);
const struct expr_s *val);
int enum_as_bool (struct type_s *enm, struct expr_s **zero,
struct expr_s **one);

16
tools/qfcc/include/switch.h
View file

@ -32,20 +32,20 @@
#define __switch_h
typedef struct switch_block_s {
expr_t *test;
const expr_t *test;
struct hashtab_s *labels;
} switch_block_t;
typedef struct case_label_s {
struct expr_s *label;
struct expr_s *value;
const struct expr_s *label;
const struct expr_s *value;
} case_label_t;
struct expr_s *case_label_expr (switch_block_t *switch_block,
struct expr_s *value);
const struct expr_s *case_label_expr (switch_block_t *switch_block,
const struct expr_s *value);
switch_block_t *new_switch_block (void);
struct expr_s *switch_expr (switch_block_t *switch_block,
struct expr_s *break_label,
struct expr_s *statements);
const struct expr_s *switch_expr (switch_block_t *switch_block,
const struct expr_s *break_label,
const struct expr_s *statements);
#endif//__switch_h

6
tools/qfcc/include/symtab.h
View file

@ -60,7 +60,7 @@ typedef enum {
} sy_type_e;
typedef struct symconv_s {
struct expr_s *(*conv) (struct symbol_s *symbol, void *data);
const struct expr_s *(*conv) (struct symbol_s *symbol, void *data);
void *data;
} symconv_t;
@ -77,7 +77,7 @@ typedef struct symbol_s {
int offset; ///< sy_var (in a struct/union)
struct def_s *def; ///< sy_var
struct ex_value_s *value; ///< sy_const
struct expr_s *expr; ///< sy_expr
const struct expr_s *expr; ///< sy_expr
struct function_s *func; ///< sy_func
symconv_t convert; ///< sy_convert
} s;
@ -253,7 +253,7 @@ symbol_t *make_symbol (const char *name, struct type_s *type,
struct defspace_s *space, enum storage_class_e storage);
struct specifier_s;
symbol_t *declare_symbol (struct specifier_s spec, struct expr_s *init,
symbol_t *declare_symbol (struct specifier_s spec, const struct expr_s *init,
symtab_t *symtab);
symbol_t *declare_field (struct specifier_s spec, symtab_t *symtab);

4
tools/qfcc/include/type.h
View file

@ -144,7 +144,7 @@ extern struct symtab_s *quaternion_struct;
struct dstring_s;
etype_t low_level_type (type_t *type) __attribute__((pure));
etype_t low_level_type (const type_t *type) __attribute__((pure));
type_t *new_type (void);
void free_type (type_t *type);
void chain_type (type_t *type);
@ -165,7 +165,7 @@ specifier_t default_type (specifier_t spec, struct symbol_s *sym);
type_t *find_type (type_t *new);
void new_typedef (const char *name, type_t *type);
type_t *field_type (type_t *aux);
type_t *pointer_type (type_t *aux);
type_t *pointer_type (const type_t *aux);
type_t *vector_type (const type_t *ele_type, int width) __attribute__((pure));
type_t *base_type (const type_t *vec_type) __attribute__((pure));

6
tools/qfcc/source/algebra.c
View file

@ -337,7 +337,7 @@ is_algebra (const type_t *type)
}
type_t *
algebra_type (type_t *type, expr_t *params)
algebra_type (type_t *type, const expr_t *params)
{
if (!is_float (type) && !is_double (type)) {
error (0, "algebra type must be float or double");
@ -348,7 +348,7 @@ algebra_type (type_t *type, expr_t *params)
error (params, "too many arguments in signature");
return type_default;
}
expr_t *param_exprs[3] = {};
const expr_t *param_exprs[3] = {};
if (params) {
list_scatter (&params->list, param_exprs);
}
@ -356,7 +356,7 @@ algebra_type (type_t *type, expr_t *params)
auto minus = param_exprs[1];
auto zero = param_exprs[2];
expr_t *err = 0;
const expr_t *err = 0;
if ((plus && !is_integral_val (err = plus))
|| (minus && !is_integral_val (err = minus))
|| (zero && !is_integral_val (err = zero))) {

2
tools/qfcc/source/attribute.c
View file

@ -40,7 +40,7 @@
ALLOC_STATE (attribute_t, attributes);
attribute_t *new_attribute(const char *name, expr_t *params)
attribute_t *new_attribute(const char *name, const expr_t *params)
{
if (params && params->type != ex_list) {
internal_error (params, "attribute params not a list");

16
tools/qfcc/source/class.c
View file

@ -1228,7 +1228,7 @@ cls_find_method (methodlist_t *methodlist, selector_t *selector,
}
method_t *
class_message_response (type_t *clstype, int class_msg, expr_t *sel)
class_message_response (type_t *clstype, int class_msg, const expr_t *sel)
{
selector_t *selector;
method_t *m;
@ -1583,7 +1583,6 @@ class_finish_module (void)
category_t **ca;
def_t *symtab_def;
symbol_t *module_sym;
expr_t *module_expr;
pr_module_t *module;
symbol_t *exec_class_sym;
symbol_t *init_sym;
@ -1636,10 +1635,11 @@ class_finish_module (void)
init_sym = new_symbol_type (".ctor", &type_func);
init_sym = function_symbol (init_sym, 0, 1);
const expr_t *module_expr;
module_expr = address_expr (new_symbol_expr (module_sym), 0);
module_expr = new_list_expr (module_expr);
init_expr = new_block_expr ();
init_expr = new_block_expr (0);
append_expr (init_expr,
build_function_call (new_symbol_expr (exec_class_sym),
exec_class_sym->type, module_expr));
@ -1921,13 +1921,12 @@ class_ivar_scope (class_type_t *class_type, symtab_t *parent)
return symtab_flat_copy (class->ivars, parent, stab_ivars);
}
static expr_t *
static const expr_t *
class_dereference_ivar (symbol_t *sym, void *_self)
{
expr_t *self = (expr_t *) _self;
return field_expr (copy_expr (self),
new_symbol_expr (new_symbol (sym->name)));
return field_expr (self, new_symbol_expr (new_symbol (sym->name)));
}
void
@ -1938,7 +1937,6 @@ class_finish_ivar_scope (class_type_t *class_type, symtab_t *ivar_scope,
type_t *class_ptr = pointer_type (class->type);
symbol_t *sym;
symbol_t *self;
expr_t *self_expr;
if (!ivar_scope)
return;
@ -1946,7 +1944,7 @@ class_finish_ivar_scope (class_type_t *class_type, symtab_t *ivar_scope,
if (!self) {
internal_error (0, "I've lost my self!");
}
self_expr = new_symbol_expr (self);
const expr_t *self_expr = new_symbol_expr (self);
if (self->type != class_ptr) {
debug (0, "class method scope");
//FIXME should generate a warning on access
@ -1957,7 +1955,7 @@ class_finish_ivar_scope (class_type_t *class_type, symtab_t *ivar_scope,
continue;
sym->sy_type = sy_convert;
sym->s.convert.conv = class_dereference_ivar;
sym->s.convert.data = self_expr;
sym->s.convert.data = (void *) self_expr;
}
}

556
tools/qfcc/source/constfold.c
View file

File diff suppressed because it is too large Load diff

6
tools/qfcc/source/dags.c
View file

@ -229,7 +229,7 @@ daglabel_string (daglabel_t *label)
}
static daglabel_t *
opcode_label (dag_t *dag, const char *opcode, expr_t *expr)
opcode_label (dag_t *dag, const char *opcode, const expr_t *expr)
{
daglabel_t *label;
@ -284,7 +284,7 @@ operand_label (dag_t *dag, operand_t *op)
}
static dagnode_t *
leaf_node (dag_t *dag, operand_t *op, expr_t *expr)
leaf_node (dag_t *dag, operand_t *op, const expr_t *expr)
{
daglabel_t *label;
dagnode_t *node;
@ -1053,7 +1053,7 @@ dag_create (flownode_t *flownode)
}
static statement_t *
build_statement (const char *opcode, operand_t **operands, expr_t *expr)
build_statement (const char *opcode, operand_t **operands, const expr_t *expr)
{
int i;
operand_t *op;

34
tools/qfcc/source/def.c
View file

@ -313,8 +313,8 @@ zero_memory (expr_t *local_expr, def_t *def, type_t *zero_type,
int init_size, int init_offset)
{
int zero_size = type_size (zero_type);
expr_t *zero = convert_nil (new_nil_expr (), zero_type);
expr_t *dst;
const expr_t *zero = convert_nil (new_nil_expr (), zero_type);
const expr_t *dst;
for (; init_offset < init_size + 1 - zero_size; init_offset += zero_size) {
dst = new_def_expr (def);
@ -360,9 +360,9 @@ init_elements_nil (def_t *def)
}
static void
init_elements (struct def_s *def, expr_t *eles)
init_elements (struct def_s *def, const expr_t *eles)
{
expr_t *c;
const expr_t *c;
pr_type_t *g;
element_chain_t element_chain;
element_t *element;
@ -409,10 +409,7 @@ init_elements (struct def_s *def, expr_t *eles)
get_type_string (element->type),
get_type_string (ctype));
}
expr_t *n = cast_expr (element->type, c);
n->line = c->line;
n->file = c->line;
c = n;
c = cast_expr (element->type, c);
}
if (get_type (c) != element->type) {
error (c, "type mismatch in initializer");
@ -448,7 +445,7 @@ init_vector_components (symbol_t *vector_sym, int is_field, symtab_t *symtab)
vector_expr = new_symbol_expr (vector_sym);
for (i = 0; i < 3; i++) {
expr_t *expr = 0;
const expr_t *expr = 0;
symbol_t *sym;
const char *name;
@ -493,8 +490,8 @@ init_vector_components (symbol_t *vector_sym, int is_field, symtab_t *symtab)
}
}
static void
init_field_def (def_t *def, expr_t *init, storage_class_t storage,
static const expr_t *
init_field_def (def_t *def, const expr_t *init, storage_class_t storage,
symtab_t *symtab)
{
type_t *type = (type_t *) dereference_type (def->type);//FIXME cast
@ -533,18 +530,19 @@ init_field_def (def_t *def, expr_t *init, storage_class_t storage,
symbol_t *sym = init->symbol;
symbol_t *field = symtab_lookup (pr.entity_fields, sym->name);
if (field) {
expr_t *new = new_field_expr (0, field->type, field->s.def);
auto new = new_field_expr (0, field->type, field->s.def);
if (new->type != ex_value) {
internal_error (init, "expected value expression");
}
init->type = new->type;
init->value = new->value;
//FIXME init = expr_file_line (new, init);
init = new;
}
}
return init;
}
static int
num_elements (expr_t *e)
num_elements (const expr_t *e)
{
int count = 0;
for (auto ele = e->compound.head; ele; ele = ele->next) {
@ -554,7 +552,7 @@ num_elements (expr_t *e)
}
void
initialize_def (symbol_t *sym, expr_t *init, defspace_t *space,
initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
storage_class_t storage, symtab_t *symtab)
{
symbol_t *check = symtab_lookup (symtab, sym->name);
@ -616,7 +614,7 @@ initialize_def (symbol_t *sym, expr_t *init, defspace_t *space,
init_vector_components (sym, 0, symtab);
if (sym->type->type == ev_field && storage != sc_local
&& storage != sc_param)
init_field_def (sym->s.def, init, storage, symtab);
init = init_field_def (sym->s.def, init, storage, symtab);
if (storage == sc_extern) {
if (init)
error (0, "initializing external variable");
@ -634,7 +632,7 @@ initialize_def (symbol_t *sym, expr_t *init, defspace_t *space,
} else {
type_t *init_type;
if (init->type == ex_nil) {
convert_nil (init, sym->type);
init = convert_nil (init, sym->type);
}
init_type = get_type (init);
if (!type_assignable (sym->type, init_type)) {

26
tools/qfcc/source/diagnostic.c
View file

@ -111,7 +111,7 @@ format_message (dstring_t *message, const char *msg_type, const expr_t *e,
}
static __attribute__((format(PRINTF, 5, 0))) void
__warning (expr_t *e, const char *file, int line, const char *func,
__warning (const expr_t *e, const char *file, int line, const char *func,
const char *fmt, va_list args)
{
static int promoted = 0;
@ -141,7 +141,7 @@ __warning (expr_t *e, const char *file, int line, const char *func,
}
void
_debug (expr_t *e, const char *file, int line, const char *func,
_debug (const expr_t *e, const char *file, int line, const char *func,
const char *fmt, ...)
{
va_list args;
@ -178,7 +178,7 @@ __internal_error (const expr_t *e, const char *file, int line,
}
void
_bug (expr_t *e, const char *file, int line, const char *func,
_bug (const expr_t *e, const char *file, int line, const char *func,
const char *fmt, ...)
{
va_list args;
@ -209,12 +209,13 @@ _bug (expr_t *e, const char *file, int line, const char *func,
}
expr_t *
_notice (expr_t *e, const char *file, int line, const char *func, const char *fmt, ...)
_notice (const expr_t *e, const char *file, int line, const char *func,
const char *fmt, ...)
{
va_list args;
if (options.notices.silent)
return e;
return (expr_t *) e;
va_start (args, fmt);
if (options.notices.promote) {
@ -236,11 +237,11 @@ _notice (expr_t *e, const char *file, int line, const char *func, const char *fm
dstring_delete (message);
}
va_end (args);
return e;
return (expr_t *) e;
}
expr_t *
_warning (expr_t *e, const char *file, int line, const char *func,
_warning (const expr_t *e, const char *file, int line, const char *func,
const char *fmt, ...)
{
va_list args;
@ -248,7 +249,7 @@ _warning (expr_t *e, const char *file, int line, const char *func,
va_start (args, fmt);
__warning (e, file, line, func, fmt, args);
va_end (args);
return e;
return (expr_t *) e;
}
void
@ -263,7 +264,7 @@ _internal_error (const expr_t *e, const char *file, int line,
}
expr_t *
_error (expr_t *e, const char *file, int line, const char *func,
_error (const expr_t *e, const char *file, int line, const char *func,
const char *fmt, ...)
{
va_list args;
@ -289,8 +290,7 @@ _error (expr_t *e, const char *file, int line, const char *func,
}
va_end (args);
if (!e)
e = new_expr ();
e->type = ex_error;
return e;
expr_t *err = new_expr ();
err->type = ex_error;
return (expr_t *) e;
}

4
tools/qfcc/source/dot.c
View file

@ -44,8 +44,8 @@ static function_t *last_func;
static int dot_index;
void
dump_dot (const char *stage, void *data,
void (*dump_func) (void *data, const char *fname))
dump_dot (const char *stage, const void *data,
void (*dump_func) (const void *data, const char *fname))
{
char *fname;

122
tools/qfcc/source/dot_expr.c
View file

@ -104,12 +104,12 @@ get_op_string (int op)
}
}
typedef void (*print_f) (dstring_t *dstr, expr_t *, int, int, expr_t *);
static void _print_expr (dstring_t *dstr, expr_t *e, int level, int id,
expr_t *next);
typedef void print_f (dstring_t *dstr, const expr_t *, int, int,
const expr_t *);
static print_f _print_expr;
static void
print_error (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_error (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -118,7 +118,7 @@ print_error (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_state (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_state (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -139,12 +139,12 @@ print_state (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_bool (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_bool (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
int i, count;
int tl_count = 0, fl_count = 0;
ex_bool_t *boolean = &e->boolean;
const ex_bool_t *boolean = &e->boolean;
dasprintf (dstr, "%*se_%p [shape=none,label=<\n", indent, "", e);
dasprintf (dstr, "%*s<table border=\"0\" cellborder=\"1\" "
@ -190,7 +190,7 @@ print_bool (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_label (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_label (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -204,7 +204,7 @@ print_label (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_labelref (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_labelref (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -212,17 +212,18 @@ print_labelref (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
next = e->next;
if (next)
dasprintf (dstr, "%*se_%p -> e_%p [constraint=true,style=dashed];\n",
indent, "", e, e->next);
indent, "", e, next);
dasprintf (dstr, "%*se_%p [label=\"&%s\\n%d\"];\n", indent, "", e,
e->label.name, e->line);
}
static void
print_block (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_block (dstring_t *dstr, const expr_t *e, int level, int id,
const expr_t *next)
{
int indent = level * 2 + 2;
int num_exprs = list_count (&e->block.list);
expr_t *exprs[num_exprs + 1];
const expr_t *exprs[num_exprs + 1];
list_scatter (&e->block.list, exprs);
exprs[num_exprs] = 0;
@ -268,11 +269,12 @@ print_block (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_list (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_list (dstring_t *dstr, const expr_t *e, int level, int id,
const expr_t *next)
{
int indent = level * 2 + 2;
int num_exprs = list_count (&e->list);
expr_t *exprs[num_exprs + 1];
const expr_t *exprs[num_exprs + 1];
list_scatter (&e->list, exprs);
exprs[num_exprs] = 0;
@ -309,7 +311,7 @@ print_list (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_subexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_subexpr (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -324,7 +326,7 @@ print_subexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_alias (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_alias (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -345,7 +347,7 @@ print_alias (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_address (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_address (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -366,7 +368,7 @@ print_address (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_assign (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_assign (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -382,7 +384,7 @@ print_assign (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_conditional (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_conditional (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
static const char *condition[] = {
@ -406,7 +408,7 @@ print_conditional (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_jump (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_jump (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -418,25 +420,19 @@ print_jump (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_call (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_call (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
expr_t *p;
int i, count;
expr_t **args;
for (count = 0, p = e->branch.args; p; p = p->next)
count++;
args = alloca (count * sizeof (expr_t *));
for (i = 0, p = e->branch.args; p; p = p->next, i++)
args[count - 1 - i] = p;
int count = list_count (&e->branch.args->list);
const expr_t *args[count];
list_scatter_rev (&e->branch.args->list, args);
_print_expr (dstr, e->branch.target, level, id, next);
dasprintf (dstr, "%*se_%p [label=\"<c>call", indent, "", e);
for (i = 0; i < count; i++)
for (int i = 0; i < count; i++)
dasprintf (dstr, "|<p%d>p%d", i, i);
dasprintf (dstr, "\",shape=record];\n");
for (i = 0; i < count; i++) {
for (int i = 0; i < count; i++) {
_print_expr (dstr, args[i], level + 1, id, next);
dasprintf (dstr, "%*se_%p:p%d -> e_%p;\n", indent + 2, "", e, i,
args[i]);
@ -446,7 +442,7 @@ print_call (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_branch (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_branch (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
switch (e->branch.type) {
case pr_branch_eq:
@ -467,7 +463,7 @@ print_branch (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_return (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_return (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -481,7 +477,7 @@ print_return (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_uexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_uexpr (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -492,7 +488,7 @@ print_uexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_def (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_def (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -501,7 +497,7 @@ print_def (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_symbol (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_symbol (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -510,7 +506,7 @@ print_symbol (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_temp (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_temp (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -519,11 +515,11 @@ print_temp (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_vector (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_vector (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
for (expr_t *ele = e->vector.list; ele; ele = ele->next) {
for (const expr_t *ele = e->vector.list; ele; ele = ele->next) {
_print_expr (dstr, ele, level, id, next);
dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, ele);
}
@ -532,7 +528,7 @@ print_vector (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_selector (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_selector (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -541,7 +537,7 @@ print_selector (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_nil (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_nil (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -550,7 +546,7 @@ print_nil (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_value (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_value (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
const char *label = "?!?";
@ -564,19 +560,19 @@ print_value (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_compound (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_compound (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
dasprintf (dstr, "%*se_%p [label=\"compound init\"];\n", indent, "", e);
}
static void
print_memset (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_memset (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
expr_t *dst = e->memset.dst;
expr_t *val = e->memset.val;
expr_t *count = e->memset.count;
const expr_t *dst = e->memset.dst;
const expr_t *val = e->memset.val;
const expr_t *count = e->memset.count;
_print_expr (dstr, dst, level, id, next);
_print_expr (dstr, val, level, id, next);
_print_expr (dstr, count, level, id, next);
@ -587,7 +583,7 @@ print_memset (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_adjstk (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_adjstk (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -596,10 +592,10 @@ print_adjstk (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_with (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_with (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
expr_t *with = e->with.with;
const expr_t *with = e->with.with;
_print_expr (dstr, with, level, id, next);
dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, with);
@ -608,7 +604,7 @@ print_with (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_args (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_args (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -617,7 +613,7 @@ print_args (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_horizontal (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_horizontal (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
@ -628,7 +624,7 @@ print_horizontal (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_swizzle (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_swizzle (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
static char swizzle_components[] = "xyzw";
int indent = level * 2 + 2;
@ -652,7 +648,7 @@ print_swizzle (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_extend (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_extend (dstring_t *dstr, const expr_t *e, int level, int id, const expr_t *next)
{
int indent = level * 2 + 2;
ex_extend_t extend = e->extend;
@ -672,7 +668,8 @@ print_extend (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
print_multivec (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
print_multivec (dstring_t *dstr, const expr_t *e, int level, int id,
const expr_t *next)
{
int indent = level * 2 + 2;
ex_multivec_t multivec = e->multivec;
@ -690,9 +687,10 @@ print_multivec (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
static void
_print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
_print_expr (dstring_t *dstr, const expr_t *e, int level, int id,
const expr_t *next)
{
static print_f print_funcs[ex_count] = {
static print_f *print_funcs[ex_count] = {
[ex_error] = print_error,
[ex_state] = print_state,
[ex_bool] = print_bool,
@ -732,7 +730,7 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
if (e->printid == id) // already printed this expression
return;
e->printid = id;
((expr_t *) e)->printid = id;
if ((int) e->type < 0 || e->type >= ex_count || !print_funcs[e->type]) {
const char *type = va (0, "%d", e->type);
@ -748,11 +746,11 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next)
}
void
dump_dot_expr (void *_e, const char *filename)
dump_dot_expr (const void *_e, const char *filename)
{
static int id = 0;
dstring_t *dstr = dstring_newstr ();
expr_t *e = (expr_t *) _e;
const expr_t *e = _e;
dasprintf (dstr, "digraph expr_%p {\n", e);
dasprintf (dstr, " graph [label=\"%s\"];\n", quote_string (filename));
@ -773,7 +771,7 @@ dump_dot_expr (void *_e, const char *filename)
}
void
print_expr (expr_t *e)
print_expr (const expr_t *e)
{
dump_dot_expr (e, 0);
}

10
tools/qfcc/source/dot_flow.c
View file

@ -409,31 +409,31 @@ print_flowgraph (flow_dot_t *method, flowgraph_t *graph, const char *filename)
}
void
dump_dot_flow (void *g, const char *filename)
dump_dot_flow (const void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[0], (flowgraph_t *) g, filename);
}
void
dump_dot_flow_dags (void *g, const char *filename)
dump_dot_flow_dags (const void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[1], (flowgraph_t *) g, filename);
}
void
dump_dot_flow_live (void *g, const char *filename)
dump_dot_flow_live (const void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[2], (flowgraph_t *) g, filename);
}
void
dump_dot_flow_reaching (void *g, const char *filename)
dump_dot_flow_reaching (const void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[3], (flowgraph_t *) g, filename);
}
void
dump_dot_flow_statements (void *g, const char *filename)
dump_dot_flow_statements (const void *g, const char *filename)
{
print_flowgraph (&flow_dot_methods[4], (flowgraph_t *) g, filename);
}

12
tools/qfcc/source/emit.c
View file

@ -60,10 +60,10 @@
static def_t zero_def;
static def_t *get_operand_def (expr_t *expr, operand_t *op);
static def_t *get_operand_def (const expr_t *expr, operand_t *op);
static def_t *
get_tempop_def (expr_t *expr, operand_t *tmpop, type_t *type)
get_tempop_def (const expr_t *expr, operand_t *tmpop, type_t *type)
{
tempop_t *tempop = &tmpop->tempop;
if (tempop->def) {
@ -81,7 +81,7 @@ get_tempop_def (expr_t *expr, operand_t *tmpop, type_t *type)
}
static def_t *
get_value_def (expr_t *expr, ex_value_t *value, type_t *type)
get_value_def (const expr_t *expr, ex_value_t *value, type_t *type)
{
def_t *def;
@ -101,7 +101,7 @@ get_value_def (expr_t *expr, ex_value_t *value, type_t *type)
}
static def_t *
get_operand_def (expr_t *expr, operand_t *op)
get_operand_def (const expr_t *expr, operand_t *op)
{
if (!op)
return 0;
@ -167,7 +167,7 @@ add_statement_op_ref (operand_t *op, dstatement_t *st, int field)
}
static void
use_tempop (operand_t *op, expr_t *expr)
use_tempop (operand_t *op, const expr_t *expr)
{
if (!op || op->op_type != op_temp)
return;
@ -227,7 +227,7 @@ emit_statement (statement_t *statement)
internal_error (statement->expr, "ice ice baby");
}
if (options.code.debug) {
expr_t *e = statement->expr;
const expr_t *e = statement->expr;
pr_uint_t line = (e ? e->line : pr.source_line) - lineno_base;
if (line != pr.linenos[pr.num_linenos - 1].line) {

4
tools/qfcc/source/evaluate.c
View file

@ -223,8 +223,8 @@ get_def (operand_t *op)
internal_error (0, "unexpected operand");
}
expr_t *
evaluate_constexpr (expr_t *e)
const expr_t *
evaluate_constexpr (const expr_t *e)
{
debug (e, "fold_constants");
if (e->type == ex_uexpr) {

841
tools/qfcc/source/expr.c
View file

File diff suppressed because it is too large Load diff

473
tools/qfcc/source/expr_algebra.c
View file

File diff suppressed because it is too large Load diff

56
tools/qfcc/source/expr_assign.c
View file

@ -65,17 +65,17 @@
#include "tools/qfcc/include/type.h"
#include "tools/qfcc/include/value.h"
static expr_t *
check_assign_logic_precedence (expr_t *dst, expr_t *src)
static const expr_t *
check_assign_logic_precedence (const expr_t *dst, const expr_t *src)
{
if (src->type == ex_expr && !src->paren && is_logic (src->expr.op)) {
// traditional QuakeC gives = higher precedence than && and ||
expr_t *assignment;
notice (src, "precedence of `=' and `%s' inverted for "
"traditional code", get_op_string (src->expr.op));
// change {a = (b logic c)} to {(a = b) logic c}
assignment = assign_expr (dst, src->expr.e1);
assignment->paren = 1; // protect assignment from binary_expr
auto assignment = assign_expr (dst, src->expr.e1);
// protect assignment from binary_expr
((expr_t *) assignment)->paren = 1;
return binary_expr (src->expr.op, assignment, src->expr.e2);
}
return 0;
@ -154,8 +154,8 @@ is_lvalue (const expr_t *expr)
return 0;
}
static expr_t *
check_valid_lvalue (expr_t *expr)
static const expr_t *
check_valid_lvalue (const expr_t *expr)
{
if (!is_lvalue (expr)) {
if (options.traditional) {
@ -167,8 +167,8 @@ check_valid_lvalue (expr_t *expr)
return 0;
}
static expr_t *
check_types_compatible (expr_t *dst, expr_t *src)
static const expr_t *
check_types_compatible (const expr_t *dst, const expr_t *src)
{
type_t *dst_type = get_type (dst);
type_t *src_type = get_type (src);
@ -192,7 +192,7 @@ check_types_compatible (expr_t *dst, expr_t *src)
}
}
// the types are different but cast-compatible
expr_t *new = cast_expr (dst_type, src);
auto new = cast_expr (dst_type, src);
// the cast was a no-op, so the types are compatible at the
// low level (very true for default type <-> enum)
if (new != src) {
@ -222,14 +222,14 @@ check_types_compatible (expr_t *dst, expr_t *src)
}
static void
copy_qv_elements (expr_t *block, expr_t *dst, expr_t *src)
copy_qv_elements (expr_t *block, const expr_t *dst, const expr_t *src)
{
expr_t *dx, *sx;
expr_t *dy, *sy;
expr_t *dz, *sz;
expr_t *dw, *sw;
expr_t *ds, *ss;
expr_t *dv, *sv;
const expr_t *dx, *sx;
const expr_t *dy, *sy;
const expr_t *dz, *sz;
const expr_t *dw, *sw;
const expr_t *ds, *ss;
const expr_t *dv, *sv;
if (is_vector (src->vector.type)) {
// guaranteed to have three elements
@ -271,10 +271,10 @@ copy_qv_elements (expr_t *block, expr_t *dst, expr_t *src)
}
static int
copy_elements (expr_t *block, expr_t *dst, expr_t *src, int base)
copy_elements (expr_t *block, const expr_t *dst, const expr_t *src, int base)
{
int index = 0;
for (expr_t *e = src->vector.list; e; e = e->next) {
for (const expr_t *e = src->vector.list; e; e = e->next) {
if (e->type == ex_vector) {
index += copy_elements (block, dst, e, index + base);
} else {
@ -287,11 +287,11 @@ copy_elements (expr_t *block, expr_t *dst, expr_t *src, int base)
return index;
}
static expr_t *
assign_vector_expr (expr_t *dst, expr_t *src)
static const expr_t *
assign_vector_expr (const expr_t *dst, const expr_t *src)
{
if (src->type == ex_vector && dst->type != ex_vector) {
expr_t *block = new_block_expr ();
expr_t *block = new_block_expr (0);
if (options.code.progsversion < PROG_VERSION) {
copy_qv_elements (block, dst, src);
@ -304,16 +304,16 @@ assign_vector_expr (expr_t *dst, expr_t *src)
return 0;
}
static __attribute__((pure)) int
is_memset (expr_t *e)
static int __attribute__((pure))
is_memset (const expr_t *e)
{
return e->type == ex_memset;
}
expr_t *
assign_expr (expr_t *dst, expr_t *src)
const expr_t *
assign_expr (const expr_t *dst, const expr_t *src)
{
expr_t *expr;
const expr_t *expr;
type_t *dst_type, *src_type;
dst = convert_name (dst);
@ -381,7 +381,7 @@ assign_expr (expr_t *dst, expr_t *src)
return expr;
}
} else {
convert_nil (src, dst_type);
src = convert_nil (src, dst_type);
}
expr = new_assign_expr (dst, src);

160
tools/qfcc/source/expr_binary.c
View file

@ -44,21 +44,26 @@ typedef struct {
type_t *result_type;
type_t *a_cast;
type_t *b_cast;
expr_t *(*process)(int op, expr_t *e1, expr_t *e2);
const expr_t *(*process)(int op, const expr_t *e1, const expr_t *e2);
bool (*commutative) (void);
bool (*anticommute) (void);
} expr_type_t;
static expr_t *pointer_arithmetic (int op, expr_t *e1, expr_t *e2);
static expr_t *pointer_compare (int op, expr_t *e1, expr_t *e2);
static expr_t *func_compare (int op, expr_t *e1, expr_t *e2);
static expr_t *inverse_multiply (int op, expr_t *e1, expr_t *e2);
static expr_t *double_compare (int op, expr_t *e1, expr_t *e2);
static expr_t *vector_compare (int op, expr_t *e1, expr_t *e2);
static expr_t *vector_dot (int op, expr_t *e1, expr_t *e2);
static expr_t *vector_multiply (int op, expr_t *e1, expr_t *e2);
static expr_t *vector_scale (int op, expr_t *e1, expr_t *e2);
static expr_t *entity_compare (int op, expr_t *e1, expr_t *e2);
static const expr_t *pointer_arithmetic (int op, const expr_t *e1,
const expr_t *e2);
static const expr_t *pointer_compare (int op, const expr_t *e1,
const expr_t *e2);
static const expr_t *func_compare (int op, const expr_t *e1,
const expr_t *e2);
static const expr_t *inverse_multiply (int op, const expr_t *e1,
const expr_t *e2);
static const expr_t *double_compare (int op, const expr_t *e1,
const expr_t *e2);
static const expr_t *vector_compare (int op, const expr_t *e1, const expr_t *e2);
static const expr_t *vector_dot (int op, const expr_t *e1, const expr_t *e2);
static const expr_t *vector_multiply (int op, const expr_t *e1, const expr_t *e2);
static const expr_t *vector_scale (int op, const expr_t *e1, const expr_t *e2);
static const expr_t *entity_compare (int op, const expr_t *e1, const expr_t *e2);
static bool always (void)
{
@ -721,8 +726,8 @@ static expr_type_t **binary_expr_types[ev_type_count] = {
// supported operators for scalar-vector expressions
static int scalar_vec_ops[] = { '*', '/', '%', MOD, 0 };
static expr_t *
convert_scalar (expr_t *scalar, int op, expr_t *vec)
static const expr_t *
convert_scalar (const expr_t *scalar, int op, const expr_t *vec)
{
int *s_op = scalar_vec_ops;
while (*s_op && *s_op != op) {
@ -737,7 +742,7 @@ convert_scalar (expr_t *scalar, int op, expr_t *vec)
if (is_constant (scalar)) {
int width = type_width (get_type (vec));
expr_t *elements[width];
const expr_t *elements[width];
for (int i = 0; i < width; i++) {
elements[i] = scalar;
}
@ -749,14 +754,14 @@ convert_scalar (expr_t *scalar, int op, expr_t *vec)
return new_extend_expr (scalar, vec_type, 2, false);//2 = copy
}
static expr_t *
pointer_arithmetic (int op, expr_t *e1, expr_t *e2)
static const expr_t *
pointer_arithmetic (int op, const expr_t *e1, const expr_t *e2)
{
type_t *t1 = get_type (e1);
type_t *t2 = get_type (e2);
expr_t *ptr = 0;
expr_t *offset = 0;
expr_t *psize;
const expr_t *ptr = 0;
const expr_t *offset = 0;
const expr_t *psize;
type_t *ptype = 0;
if (!is_ptr (t1) && !is_ptr (t2)) {
@ -789,8 +794,8 @@ pointer_arithmetic (int op, expr_t *e1, expr_t *e2)
return offset_pointer_expr (ptr, offset);
}
static expr_t *
pointer_compare (int op, expr_t *e1, expr_t *e2)
static const expr_t *
pointer_compare (int op, const expr_t *e1, const expr_t *e2)
{
type_t *t1 = get_type (e1);
type_t *t2 = get_type (e2);
@ -810,8 +815,8 @@ pointer_compare (int op, expr_t *e1, expr_t *e2)
return e;
}
static expr_t *
func_compare (int op, expr_t *e1, expr_t *e2)
static const expr_t *
func_compare (int op, const expr_t *e1, const expr_t *e2)
{
expr_t *e;
@ -828,17 +833,17 @@ func_compare (int op, expr_t *e1, expr_t *e2)
return e;
}
static expr_t *
inverse_multiply (int op, expr_t *e1, expr_t *e2)
static const expr_t *
inverse_multiply (int op, const expr_t *e1, const expr_t *e2)
{
// There is no vector/float or quaternion/float instruction and adding
// one would mean the engine would have to do 1/f every time
expr_t *one = new_float_expr (1);
auto one = new_float_expr (1);
return binary_expr ('*', e1, binary_expr ('/', one, e2));
}
static expr_t *
vector_compare (int op, expr_t *e1, expr_t *e2)
static const expr_t *
vector_compare (int op, const expr_t *e1, const expr_t *e2)
{
if (options.code.progsversion < PROG_VERSION) {
expr_t *e = new_binary_expr (op, e1, e2);
@ -856,16 +861,16 @@ vector_compare (int op, expr_t *e1, expr_t *e2)
return new_horizontal_expr (hop, e, &type_int);
}
static expr_t *
vector_dot (int op, expr_t *e1, expr_t *e2)
static const expr_t *
vector_dot (int op, const expr_t *e1, const expr_t *e2)
{
expr_t *e = new_binary_expr (DOT, e1, e2);
e->expr.type = &type_float;
return e;
}
static expr_t *
vector_multiply (int op, expr_t *e1, expr_t *e2)
static const expr_t *
vector_multiply (int op, const expr_t *e1, const expr_t *e2)
{
if (options.math.vector_mult == DOT) {
// vector * vector is dot product in v6 progs (ick)
@ -877,14 +882,14 @@ vector_multiply (int op, expr_t *e1, expr_t *e2)
return e;
}
static expr_t *
vector_scale (int op, expr_t *e1, expr_t *e2)
static const expr_t *
vector_scale (int op, const expr_t *e1, const expr_t *e2)
{
// Ensure the expression is always vector * scalar. The operation is
// always commutative, and the Ruamoko ISA supports only vector * scalar
// (though v6 does support scalar * vector, one less if).
if (is_scalar (get_type (e1))) {
expr_t *t = e1;
auto t = e1;
e1 = e2;
e2 = t;
}
@ -893,8 +898,8 @@ vector_scale (int op, expr_t *e1, expr_t *e2)
return e;
}
static expr_t *
double_compare (int op, expr_t *e1, expr_t *e2)
static const expr_t *
double_compare (int op, const expr_t *e1, const expr_t *e2)
{
type_t *t1 = get_type (e1);
type_t *t2 = get_type (e2);
@ -928,8 +933,8 @@ double_compare (int op, expr_t *e1, expr_t *e2)
return e;
}
static expr_t *
entity_compare (int op, expr_t *e1, expr_t *e2)
static const expr_t *
entity_compare (int op, const expr_t *e1, const expr_t *e2)
{
if (options.code.progsversion == PROG_VERSION) {
e1 = new_alias_expr (&type_int, e1);
@ -945,8 +950,8 @@ entity_compare (int op, expr_t *e1, expr_t *e2)
#define invalid_binary_expr(_op, _e1, _e2) \
_invalid_binary_expr(_op, _e1, _e2, __FILE__, __LINE__, __FUNCTION__)
static expr_t *
_invalid_binary_expr (int op, expr_t *e1, expr_t *e2,
static const expr_t *
_invalid_binary_expr (int op, const expr_t *e1, const expr_t *e2,
const char *file, int line, const char *func)
{
type_t *t1, *t2;
@ -957,8 +962,8 @@ _invalid_binary_expr (int op, expr_t *e1, expr_t *e2,
get_type_string (t2));
}
static expr_t *
reimplement_binary_expr (int op, expr_t *e1, expr_t *e2)
static const expr_t *
reimplement_binary_expr (int op, const expr_t *e1, const expr_t *e2)
{
expr_t *e;
@ -967,7 +972,7 @@ reimplement_binary_expr (int op, expr_t *e1, expr_t *e2)
case '%':
{
expr_t *tmp1, *tmp2;
e = new_block_expr ();
e = new_block_expr (0);
tmp1 = new_temp_def_expr (&type_float);
tmp2 = new_temp_def_expr (&type_float);
@ -982,15 +987,21 @@ reimplement_binary_expr (int op, expr_t *e1, expr_t *e2)
return 0;
}
static expr_t *
check_precedence (int op, expr_t *e1, expr_t *e2)
static void
set_paren (const expr_t *e)
{
((expr_t *) e)->paren = 1;
}
static const expr_t *
check_precedence (int op, const expr_t *e1, const expr_t *e2)
{
if (e1->type == ex_uexpr && e1->expr.op == '!' && !e1->paren) {
if (options.traditional) {
if (op != AND && op != OR && op != '=') {
notice (e1, "precedence of `!' and `%s' inverted for "
"traditional code", get_op_string (op));
e1->expr.e1->paren = 1;
set_paren (e1->expr.e1);
return unary_expr ('!', binary_expr (op, e1->expr.e1, e2));
}
} else if (op == '&' || op == '|') {
@ -1010,7 +1021,7 @@ check_precedence (int op, expr_t *e1, expr_t *e2)
"traditional code", get_op_string (op),
get_op_string (e2->expr.op));
e1 = binary_expr (op, e1, e2->expr.e1);
e1->paren = 1;
set_paren (e1);
return binary_expr (e2->expr.op, e1, e2->expr.e2);
}
if (((op == EQ || op == NE) && is_compare (e2->expr.op))
@ -1020,7 +1031,7 @@ check_precedence (int op, expr_t *e1, expr_t *e2)
"traditional code", get_op_string (op),
get_op_string (e2->expr.op));
e1 = binary_expr (op, e1, e2->expr.e1);
e1->paren = 1;
set_paren (e1);
return binary_expr (e2->expr.op, e1, e2->expr.e2);
}
} else if (e1->type == ex_expr && !e1->paren) {
@ -1032,7 +1043,7 @@ check_precedence (int op, expr_t *e1, expr_t *e2)
"traditional code", get_op_string (op),
get_op_string (e1->expr.op));
e2 = binary_expr (op, e1->expr.e2, e2);
e2->paren = 1;
set_paren (e1);
return binary_expr (e1->expr.op, e1->expr.e1, e2);
}
}
@ -1067,7 +1078,8 @@ check_precedence (int op, expr_t *e1, expr_t *e2)
return 0;
}
static int is_call (expr_t *e)
static int
is_call (const expr_t *e)
{
return e->type == ex_block && e->block.is_call;
}
@ -1081,12 +1093,12 @@ promote_type (type_t *dst, type_t *src)
return vector_type (base_type (dst), type_width (src));
}
expr_t *
binary_expr (int op, expr_t *e1, expr_t *e2)
const expr_t *
binary_expr (int op, const expr_t *e1, const expr_t *e2)
{
type_t *t1, *t2;
etype_t et1, et2;
expr_t *e;
const expr_t *e;
expr_type_t *expr_type;
e1 = convert_name (e1);
@ -1095,19 +1107,23 @@ binary_expr (int op, expr_t *e1, expr_t *e2)
if (e1->type == ex_alias && is_call (e1->alias.expr)) {
// move the alias expression inside the block so the following check
// can detect the call and move the temp assignment into the block
expr_t *block = e1->alias.expr;
e1->alias.expr = block->block.result;
block->block.result = e1;
auto block = (expr_t *) e1->alias.expr;
auto ne = new_expr ();
*ne = *e1;
ne->alias.expr = block->block.result;
block->block.result = ne;
e1 = block;
}
if (e1->type == ex_block && e1->block.is_call
&& has_function_call (e2) && e1->block.result) {
// the temp assignment needs to be insided the block so assignment
// the temp assignment needs to be inside the block so assignment
// code generation doesn't see it when applying right-associativity
expr_t *tmp = new_temp_def_expr (get_type (e1->block.result));
e = assign_expr (tmp, e1->block.result);
append_expr (e1, e);
e1->block.result = tmp;
auto ne = assign_expr (tmp, e1->block.result);
auto nb = new_block_expr (e1);
append_expr (nb, ne);
nb->block.result = tmp;
e1 = nb;
}
if (e1->type == ex_error)
return e1;
@ -1136,10 +1152,10 @@ binary_expr (int op, expr_t *e1, expr_t *e2)
if (op == EQ || op == NE) {
if (e1->type == ex_nil) {
t1 = t2;
convert_nil (e1, t1);
e1 = convert_nil (e1, t1);
} else if (e2->type == ex_nil) {
t2 = t1;
convert_nil (e2, t2);
e2 = convert_nil (e2, t2);
}
}
@ -1236,7 +1252,7 @@ binary_expr (int op, expr_t *e1, expr_t *e2)
et2 = low_level_type (t2);
// both widths are the same at this point
if (t1->width > 1) {
e = new_binary_expr (op, e1, e2);
auto ne = new_binary_expr (op, e1, e2);
if (is_compare (op)) {
t1 = int_type (t1);
}
@ -1246,8 +1262,8 @@ binary_expr (int op, expr_t *e1, expr_t *e2)
}
t1 = base_type (t1);
}
e->expr.type = t1;
return edag_add_expr (e);
ne->expr.type = t1;
return edag_add_expr (ne);
}
}
@ -1269,18 +1285,18 @@ binary_expr (int op, expr_t *e1, expr_t *e2)
if ((e = reimplement_binary_expr (op, e1, e2)))
return edag_add_expr (fold_constants (e));
e = new_binary_expr (op, e1, e2);
e->expr.type = expr_type->result_type;
auto ne = new_binary_expr (op, e1, e2);
ne->expr.type = expr_type->result_type;
if (expr_type->commutative) {
e->expr.commutative = expr_type->commutative ();
ne->expr.commutative = expr_type->commutative ();
}
if (expr_type->anticommute) {
e->expr.anticommute = expr_type->anticommute ();
ne->expr.anticommute = expr_type->anticommute ();
}
if (is_compare (op) || is_logic (op)) {
if (options.code.progsversion == PROG_ID_VERSION) {
e->expr.type = &type_float;
ne->expr.type = &type_float;
}
}
return edag_add_expr (fold_constants (e));
return edag_add_expr (fold_constants (ne));
}

61
tools/qfcc/source/expr_bool.c
View file

@ -66,10 +66,10 @@
#include "tools/qfcc/source/qc-parse.h"
expr_t *
test_expr (expr_t *e)
const expr_t *
test_expr (const expr_t *e)
{
expr_t *new = 0;
const expr_t *new = 0;
type_t *type;
e = convert_name (e);
@ -128,12 +128,12 @@ test_expr (expr_t *e)
}
return e;
}
new = expr_file_line (new_zero_expr (type), e);
new = expr_file_line (binary_expr (NE, e, new), e);
new = expr_file_line ((expr_t *) new_zero_expr (type), e);
new = expr_file_line ((expr_t *) binary_expr (NE, e, new), e);
return test_expr (new);
case ev_double:
new = expr_file_line (new_zero_expr (type), e);
new = expr_file_line (binary_expr (NE, e, new), e);
new = expr_file_line ((expr_t *) new_zero_expr (type), e);
new = expr_file_line ((expr_t *) binary_expr (NE, e, new), e);
return test_expr (new);
case ev_vector:
new = new_zero_expr (&type_vector);
@ -156,16 +156,14 @@ test_expr (expr_t *e)
}
return test_error (e, get_type (e));
}
new->line = e->line;
new->file = e->file;
new = expr_file_line ((expr_t *) new, e);
new = binary_expr (NE, e, new);
new->line = e->line;
new->file = e->file;
new = expr_file_line ((expr_t *) new, e);
return new;
}
void
backpatch (ex_boollist_t *list, expr_t *label)
backpatch (ex_boollist_t *list, const expr_t *label)
{
int i;
expr_t *e;
@ -182,7 +180,7 @@ backpatch (ex_boollist_t *list, expr_t *label)
} else {
internal_error (e, 0);
}
label->label.used++;
((expr_t *)label)->label.used++;
}
}
@ -205,18 +203,18 @@ merge (ex_boollist_t *l1, ex_boollist_t *l2)
}
static ex_boollist_t *
make_list (expr_t *e)
make_list (const expr_t *e)
{
ex_boollist_t *m;
m = malloc (field_offset (ex_boollist_t, e[1]));
m->size = 1;
m->e[0] = e;
m->e[0] = (expr_t *) e;
return m;
}
expr_t *
bool_expr (int op, expr_t *label, expr_t *e1, expr_t *e2)
const expr_t *
bool_expr (int op, const expr_t *label, const expr_t *e1, const expr_t *e2)
{
expr_t *block;
@ -231,7 +229,7 @@ bool_expr (int op, expr_t *label, expr_t *e1, expr_t *e2)
if (e2->type == ex_error)
return e2;
block = new_block_expr ();
block = new_block_expr (0);
append_expr (block, e1);
append_expr (block, label);
append_expr (block, e2);
@ -254,7 +252,7 @@ bool_expr (int op, expr_t *label, expr_t *e1, expr_t *e2)
}
static int __attribute__((pure))
has_block_expr (expr_t *e)
has_block_expr (const expr_t *e)
{
while (e->type == ex_alias) {
e = e->alias.expr;
@ -262,17 +260,14 @@ has_block_expr (expr_t *e)
return e->type == ex_block;
}
expr_t *
convert_bool (expr_t *e, int block)
const expr_t *
convert_bool (const expr_t *e, int block)
{
expr_t *b;
if (e->type == ex_assign) {
expr_t *tst;
if (!e->paren && options.warnings.precedence)
warning (e, "suggest parentheses around assignment "
"used as truth value");
tst = e->assign.src;
auto tst = e->assign.src;
if (has_block_expr (tst) && has_block_expr (e->assign.dst)) {
tst = new_temp_def_expr (get_type (tst));
e = new_assign_expr (e->assign.dst,
@ -280,11 +275,11 @@ convert_bool (expr_t *e, int block)
} else if (has_block_expr (tst)) {
tst = e->assign.dst;
}
b = convert_bool (tst, 1);
auto b = convert_bool (tst, 1);
if (b->type == ex_error)
return b;
// insert the assignment into the boolean's block
prepend_expr (b->boolean.e, e);
prepend_expr ((expr_t *) b->boolean.e, e); //FIXME cast
return b;
}
@ -292,17 +287,17 @@ convert_bool (expr_t *e, int block)
&& !is_string(get_type (e->expr.e1))) {
e = convert_bool (e->expr.e1, 0);
if (e->type == ex_error)
return e;
return (expr_t *) e;
e = unary_expr ('!', e);
}
if (e->type != ex_bool) {
e = test_expr (e);
if (e->type == ex_error)
return e;
return (expr_t *) e;
if (is_constant (e)) {
int val;
b = goto_expr (0);
auto b = goto_expr (0);
if (is_int_val (e)) {
val = expr_int (e);
} else {
@ -313,7 +308,7 @@ convert_bool (expr_t *e, int block)
else
e = new_bool_expr (0, make_list (b), b);
} else {
b = new_block_expr ();
auto b = new_block_expr (0);
append_expr (b, branch_expr (NE, e, 0));
append_expr (b, goto_expr (0));
e = new_bool_expr (make_list (b->block.head->expr),
@ -321,9 +316,9 @@ convert_bool (expr_t *e, int block)
}
}
if (block && e->boolean.e->type != ex_block) {
expr_t *block = new_block_expr ();
expr_t *block = new_block_expr (0);
append_expr (block, e->boolean.e);
e->boolean.e = block;
((expr_t *) e)->boolean.e = block;
}
return edag_add_expr (e);
}

33
tools/qfcc/source/expr_cast.c
View file

@ -44,8 +44,8 @@
#include "tools/qfcc/include/type.h"
#include "tools/qfcc/include/value.h"
expr_t *
cast_error (expr_t *e, type_t *t1, type_t *t2)
const expr_t *
cast_error (const expr_t *e, type_t *t1, type_t *t2)
{
e = error (e, "cannot cast from %s to %s", get_type_string (t1),
get_type_string (t2));
@ -54,7 +54,7 @@ cast_error (expr_t *e, type_t *t1, type_t *t2)
static void
do_conversion (pr_type_t *dst_value, type_t *dstType,
pr_type_t *src_value, type_t *srcType, expr_t *expr)
pr_type_t *src_value, type_t *srcType, const expr_t *expr)
{
int from = type_cast_map[base_type (srcType)->type];
int to = type_cast_map[base_type (dstType)->type];
@ -69,8 +69,8 @@ do_conversion (pr_type_t *dst_value, type_t *dstType,
}
}
static expr_t *
cast_math (type_t *dstType, type_t *srcType, expr_t *expr)
static const expr_t *
cast_math (type_t *dstType, type_t *srcType, const expr_t *expr)
{
pr_type_t src_value[type_size (srcType)];
pr_type_t dst_value[type_size (dstType)];
@ -82,10 +82,9 @@ cast_math (type_t *dstType, type_t *srcType, expr_t *expr)
return new_value_expr (new_type_value (dstType, dst_value));
}
expr_t *
cast_expr (type_t *dstType, expr_t *e)
const expr_t *
cast_expr (type_t *dstType, const expr_t *e)
{
expr_t *c;
type_t *srcType;
e = convert_name (e);
@ -93,6 +92,10 @@ cast_expr (type_t *dstType, expr_t *e)
if (e->type == ex_error)
return e;
if (is_nil (e)) {
return convert_nil (e, dstType);
}
dstType = (type_t *) unalias_type (dstType); //FIXME cast
srcType = get_type (e);
@ -104,10 +107,10 @@ cast_expr (type_t *dstType, expr_t *e)
return e;
if ((is_ptr (dstType) && is_string (srcType))
|| (is_string (dstType) && is_ptr (srcType))) {
c = new_alias_expr (dstType, e);
return c;
return new_alias_expr (dstType, e);
}
if (is_algebra (dstType) || is_algebra (srcType)) {
const expr_t *c;
if ((c = algebra_cast_expr (dstType, e))) {
return c;
}
@ -136,19 +139,21 @@ cast_expr (type_t *dstType, expr_t *e)
e = new_int_expr (expr_ushort (e));
srcType = &type_int;
}
expr_t *c = 0;
if (is_constant (e) && is_math (dstType) && is_math (srcType)) {
return cast_math (dstType, srcType, e);
} else if (is_integral (dstType) && is_integral (srcType)
&& type_size (dstType) == type_size (srcType)) {
c = new_alias_expr (dstType, e);
c = (expr_t *) new_alias_expr (dstType, e);
} else if (is_scalar (dstType) && is_scalar (srcType)) {
c = new_unary_expr ('C', e);
c->expr.type = dstType;
} else if (e->type == ex_uexpr && e->expr.op == '.') {
e->expr.type = dstType;
c = e;
c = new_expr ();
*c = *e;
c->expr.type = dstType;
} else {
c = new_alias_expr (dstType, e);
c = (expr_t *) new_alias_expr (dstType, e);
}
return c;
}

28
tools/qfcc/source/expr_compound.c
View file

@ -57,7 +57,7 @@ ALLOC_STATE (element_t, elements);
ALLOC_STATE (designator_t, designators);
designator_t *
new_designator (expr_t *field, expr_t *index)
new_designator (const expr_t *field, const expr_t *index)
{
if ((!field && !index) || (field && index)) {
internal_error (0, "exactly one of field or index is required");
@ -73,7 +73,7 @@ new_designator (expr_t *field, expr_t *index)
}
element_t *
new_element (expr_t *expr, designator_t *designator)
new_element (const expr_t *expr, designator_t *designator)
{
element_t *element;
ALLOC (256, element_t, elements, element);
@ -198,7 +198,7 @@ skip_field (symbol_t *field)
void
build_element_chain (element_chain_t *element_chain, const type_t *type,
expr_t *eles, int base_offset)
const expr_t *eles, int base_offset)
{
element_t *ele = eles->compound.head;
@ -304,7 +304,7 @@ append_element (expr_t *compound, element_t *element)
}
void
assign_elements (expr_t *local_expr, expr_t *init,
assign_elements (expr_t *local_expr, const expr_t *init,
element_chain_t *element_chain)
{
element_t *element;
@ -314,9 +314,9 @@ assign_elements (expr_t *local_expr, expr_t *init,
for (element = element_chain->head; element; element = element->next) {
int offset = element->offset;
type_t *type = element->type;
expr_t *alias = new_offset_alias_expr (type, init, offset);
const expr_t *alias = new_offset_alias_expr (type, init, offset);
expr_t *c;
const expr_t *c;
if (type_size (type) == 0)
internal_error (init, "wtw");
@ -336,9 +336,9 @@ assign_elements (expr_t *local_expr, expr_t *init,
for (set_iter_t *in = set_first (initialized); in; in = set_next (in)) {
unsigned end = in->element;
if (end > start) {
expr_t *dst = new_offset_alias_expr (&type_int, init, start);
expr_t *zero = new_int_expr (0);
expr_t *count = new_int_expr (end - start);
auto dst = new_offset_alias_expr (&type_int, init, start);
auto zero = new_int_expr (0);
auto count = new_int_expr (end - start);
append_expr (local_expr, new_memset_expr (dst, zero, count));
}
// skip over all the initialized locations
@ -348,21 +348,21 @@ assign_elements (expr_t *local_expr, expr_t *init,
}
}
if (start < (unsigned) type_size (init_type)) {
expr_t *dst = new_offset_alias_expr (&type_int, init, start);
expr_t *zero = new_int_expr (0);
expr_t *count = new_int_expr (type_size (init_type) - start);
auto dst = new_offset_alias_expr (&type_int, init, start);
auto zero = new_int_expr (0);
auto count = new_int_expr (type_size (init_type) - start);
append_expr (local_expr, new_memset_expr (dst, zero, count));
}
set_delete (initialized);
}
expr_t *
initialized_temp_expr (const type_t *type, expr_t *compound)
initialized_temp_expr (const type_t *type, const expr_t *compound)
{
type = unalias_type (type);
element_chain_t element_chain;
expr_t *temp = new_temp_def_expr (type);
expr_t *block = new_block_expr ();
expr_t *block = new_block_expr (0);
element_chain.head = 0;
element_chain.tail = &element_chain.head;

8
tools/qfcc/source/expr_dag.c
View file

@ -40,7 +40,7 @@
#include "tools/qfcc/include/symtab.h"
#include "tools/qfcc/include/type.h"
typedef struct DARRAY_TYPE (expr_t *) exprset_t;
typedef struct DARRAY_TYPE (const expr_t *) exprset_t;
static exprset_t expr_dag = DARRAY_STATIC_INIT(32);
@ -50,14 +50,14 @@ edag_flush (void)
expr_dag.size = 0;
}
expr_t *
edag_add_expr (expr_t *expr)
const expr_t *
edag_add_expr (const expr_t *expr)
{
if (!expr) {
return expr;
}
for (size_t i = 0; i < expr_dag.size; i++) {
expr_t *e = expr_dag.a[i];
auto e = expr_dag.a[i];
if (e->type != expr->type) {
continue;
}

27
tools/qfcc/source/expr_obj.c
View file

@ -86,7 +86,7 @@ new_this_expr (void)
return new_symbol_expr (sym);
}
expr_t *
const expr_t *
selector_expr (keywordarg_t *selector)
{
dstring_t *sel_id = dstring_newstr ();
@ -123,7 +123,7 @@ selector_expr (keywordarg_t *selector)
return sel;
}
expr_t *
const expr_t *
protocol_expr (const char *protocol_name)
{
protocol_t *protocol = get_protocol (protocol_name, 0);
@ -136,12 +136,11 @@ protocol_expr (const char *protocol_name)
return new_pointer_expr (0, proto_class->type, protocol_def (protocol));
}
expr_t *
const expr_t *
super_expr (class_type_t *class_type)
{
symbol_t *sym;
expr_t *super;
expr_t *e;
expr_t *super_block;
class_t *class;
@ -161,8 +160,9 @@ super_expr (class_type_t *class_type)
}
super = new_symbol_expr (sym);
super_block = new_block_expr ();
super_block = new_block_expr (0);
const expr_t *e;
e = assign_expr (field_expr (super, new_name_expr ("self")),
new_name_expr ("self"));
append_expr (super_block, e);
@ -177,22 +177,22 @@ super_expr (class_type_t *class_type)
return super_block;
}
expr_t *
message_expr (expr_t *receiver, keywordarg_t *message)
const expr_t *
message_expr (const expr_t *receiver, keywordarg_t *message)
{
expr_t *selector = selector_expr (message);
expr_t *call;
const expr_t *selector = selector_expr (message);
const expr_t *call;
keywordarg_t *m;
int super = 0, class_msg = 0;
type_t *rec_type = 0;
type_t *return_type;
type_t *method_type = &type_IMP;
method_t *method;
expr_t *send_msg;
const expr_t *send_msg;
if (receiver->type == ex_nil) {
rec_type = &type_id;
convert_nil (receiver, rec_type);
receiver = convert_nil (receiver, rec_type);
} else if (receiver->type == ex_symbol) {
if (strcmp (receiver->symbol->name, "self") == 0) {
rec_type = get_type (receiver);
@ -229,7 +229,6 @@ message_expr (expr_t *receiver, keywordarg_t *message)
for (m = message; m; m = m->next) {
if (m->expr && m->expr->list.head) {
list_append_list (args, &m->expr->list);
expr_file_line (selector, m->expr);
}
}
list_append_expr (args, selector);
@ -237,7 +236,7 @@ message_expr (expr_t *receiver, keywordarg_t *message)
send_msg = expr_file_line (send_message (super), receiver);
if (method) {
expr_t *err;
const expr_t *err;
if ((err = method_check_params (method, args)))
return err;
method_type = method->type;
@ -250,6 +249,6 @@ message_expr (expr_t *receiver, keywordarg_t *message)
if (!is_function_call (call)) {
internal_error (call, "unexpected call expression type");
}
call->block.result->branch.ret_type = return_type;
((expr_t *) call->block.result)->branch.ret_type = return_type;
return call;
}

17
tools/qfcc/source/expr_vector.c
View file

@ -36,12 +36,12 @@
#include "tools/qfcc/include/type.h"
#include "tools/qfcc/include/value.h"
expr_t *
new_vector_list (expr_t *expr_list)
const expr_t *
new_vector_list (const expr_t *expr_list)
{
type_t *ele_type = type_default;
int count = list_count (&expr_list->list);
expr_t *elements[count + 1];
const expr_t *elements[count + 1];
list_scatter (&expr_list->list, elements);
elements[count] = 0;
@ -91,8 +91,8 @@ new_vector_list (expr_t *expr_list)
// be only one, but futhre...)
for (int i = 1; i < count; i++) {
if (is_nonscalar (get_type (elements[i]))) {
expr_t *t = elements[i];
int j = i;
auto t = elements[i];
int j = i;
for (; j > 0 && is_scalar (get_type (elements[j])); j--) {
elements[j] = elements[j - 1];
}
@ -104,7 +104,7 @@ new_vector_list (expr_t *expr_list)
if (is_scalar (get_type (elements[0]))
&& is_nonscalar (get_type (elements[1]))) {
// swap s, v to be v, s (ie, vector always comes before scalar)
expr_t *t = elements[0];
auto t = elements[0];
elements[0] = elements[1];
elements[1] = t;
}
@ -127,13 +127,14 @@ new_vector_list (expr_t *expr_list)
offs += type_size (src_type);
}
expr_t *vec = new_value_expr (new_type_value (vec_type, value));
auto vec = (expr_t *) new_value_expr (new_type_value (vec_type, value));
vec->implicit = all_implicit;
return vec;
}
for (int i = 0; i < count; i++) {
elements[i]->next = elements[i + 1];
//FIXME this should use ex_list
((expr_t *) elements[i])->next = (expr_t *) elements[i + 1];
}
expr_t *vec = new_expr ();

38
tools/qfcc/source/function.c
View file

@ -346,8 +346,22 @@ func_compare (const void *a, const void *b)
return 0;
}
expr_t *
find_function (expr_t *fexpr, expr_t *params)
static const expr_t *
set_func_symbol (const expr_t *fexpr, overloaded_function_t *f)
{
auto sym = symtab_lookup (current_symtab, f->full_name);
if (!sym) {
internal_error (fexpr, "overloaded function %s not found",
f->full_name);
}
auto nf = new_expr ();
*nf = *fexpr;
nf->symbol = sym;
return nf;
}
const expr_t *
find_function (const expr_t *fexpr, const expr_t *params)
{
int i, j, func_count, parm_count, reported = 0;
overloaded_function_t *f, dummy, *best = 0;
@ -359,7 +373,7 @@ find_function (expr_t *fexpr, expr_t *params)
type.type = ev_func;
type.t.func.num_params = params ? list_count (&params->list) : 0;
expr_t *args[type.t.func.num_params];
const expr_t *args[type.t.func.num_params];
if (params) {
list_scatter_rev (&params->list, args);
}
@ -399,10 +413,7 @@ find_function (expr_t *fexpr, expr_t *params)
if (dummy_p) {
f = (overloaded_function_t *) *(void **) dummy_p;
if (f->overloaded) {
fexpr->symbol = symtab_lookup (current_symtab, f->full_name);
if (!fexpr->symbol)
internal_error (fexpr, "overloaded function %s not found",
best->full_name);
fexpr = set_func_symbol (fexpr, f);
}
free (funcs);
return fexpr;
@ -447,11 +458,7 @@ find_function (expr_t *fexpr, expr_t *params)
return fexpr;
if (best) {
if (best->overloaded) {
fexpr->symbol = symtab_lookup (current_symtab,
best->full_name);
if (!fexpr->symbol)
internal_error (fexpr, "overloaded function %s not found",
best->full_name);
fexpr = set_func_symbol (fexpr, best);
}
free (funcs);
return fexpr;
@ -743,7 +750,8 @@ merge_spaces (defspace_t *dst, defspace_t *src, int alignment)
}
function_t *
build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements)
build_code_function (symbol_t *fsym, const expr_t *state_expr,
expr_t *statements)
{
if (fsym->sy_type != sy_func) // probably in error recovery
return 0;
@ -759,7 +767,7 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements)
* optimizer gets.
*/
expr_t *e;
expr_t *entry = new_block_expr ();
expr_t *entry = new_block_expr (0);
entry->file = func->def->file;
entry->line = func->def->line;
@ -842,7 +850,7 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements)
}
function_t *
build_builtin_function (symbol_t *sym, expr_t *bi_val, int far,
build_builtin_function (symbol_t *sym, const expr_t *bi_val, int far,
storage_class_t storage)
{
int bi;

10
tools/qfcc/source/method.c
View file

@ -483,7 +483,7 @@ selector_index (const char *sel_id)
}
selector_t *
get_selector (expr_t *sel)
get_selector (const expr_t *sel)
{
selector_t _sel = {0, 0, 0};
@ -700,8 +700,8 @@ clear_selectors (void)
Hash_FlushTable (known_methods);
}
expr_t *
method_check_params (method_t *method, expr_t *args)
const expr_t *
method_check_params (method_t *method, const expr_t *args)
{
int i, param_count;
expr_t *err = 0;
@ -721,10 +721,10 @@ method_check_params (method_t *method, expr_t *args)
if (mtype->t.func.num_params >= 0 && count > mtype->t.func.num_params)
return error (args, "too many arguments");
expr_t *arg_list[count];
const expr_t *arg_list[count];
list_scatter_rev (&args->list, arg_list);
for (i = 2; i < count; i++) {
expr_t *e = arg_list[i];
const expr_t *e = arg_list[i];
type_t *arg_type = mtype->t.func.param_types[i];
type_t *t;

21
tools/qfcc/source/qc-lex.l
View file

@ -81,8 +81,8 @@ FILE *yyget_in (void) __attribute__((pure));
FILE *yyget_out (void) __attribute__((pure));
static int keyword_or_id (const char *token);
static expr_t *parse_float_vector (const char *token, int width);
static expr_t *parse_int_vector (const char *token, int width);
static const expr_t *parse_float_vector (const char *token, int width);
static const expr_t *parse_int_vector (const char *token, int width);
extern QC_YYSTYPE qc_yylval;
@ -149,7 +149,7 @@ STRING \"(\\.|[^"\\])*\"
qc_yylval.expr = new_long_expr (i);
} else {
qc_yylval.expr = new_int_expr (i);
qc_yylval.expr->implicit = 1;
((expr_t *) qc_yylval.expr)->implicit = 1;
}
}
return VALUE;
@ -160,8 +160,7 @@ STRING \"(\\.|[^"\\])*\"
// and extended code defaults to float
if (options.traditional < 1) {
double d = strtod (yytext, 0);
qc_yylval.expr = new_double_expr (d);
qc_yylval.expr->implicit = 1;
qc_yylval.expr = new_double_expr (d, true);
} else {
float f = strtof (yytext, 0);
qc_yylval.expr = new_float_expr (f);
@ -178,7 +177,7 @@ STRING \"(\\.|[^"\\])*\"
// and extended code defaults to float
if (options.traditional < 1) {
double d = strtod (yytext, 0);
qc_yylval.expr = new_double_expr (d);
qc_yylval.expr = new_double_expr (d, false);
} else {
float f = strtof (yytext, 0);
qc_yylval.expr = new_float_expr (f);
@ -586,7 +585,7 @@ keyword_or_id (const char *token)
return NAME;
}
static expr_t *
static const expr_t *
parse_int_vector (const char *token, int width)
{
char t1 = 0, t2 = 0;
@ -622,7 +621,7 @@ parse_int_vector (const char *token, int width)
t1 = 'f';
}
}
expr_t *expr = 0;
const expr_t *expr = 0;
switch (t1) {
case 'u':
if (t2 == 'l') {
@ -704,11 +703,11 @@ parse_int_vector (const char *token, int width)
expr = new_value_expr (new_type_value (type, data));
break;
}
expr->implicit = !t1;
((expr_t *) expr)->implicit = !t1;
return expr;
}
static expr_t *
static const expr_t *
parse_float_vector (const char *token, int width)
{
char t = 0;
@ -762,7 +761,7 @@ parse_float_vector (const char *token, int width)
type = &type_double;
}
type = vector_type (type, width);
expr_t *expr = new_value_expr (new_type_value (type, data));
auto expr = (expr_t *) new_value_expr (new_type_value (type, data));
expr->implicit = !t;
return expr;
}

39
tools/qfcc/source/qc-parse.y
View file

@ -99,7 +99,8 @@ int yylex (void);
specifier_t spec;
void *pointer; // for ensuring pointer values are null
struct type_s *type;
struct expr_s *expr;
const struct expr_s *expr;
struct expr_s *mut_expr;
struct element_s *element;
struct function_s *function;
struct switch_block_s *switch_block;
@ -194,20 +195,24 @@ int yylex (void);
%type <symbol> methoddef
%type <expr> var_initializer local_def
%type <expr> opt_init_semi opt_expr comma_expr expr
%type <expr> compound_init element_list
%type <mut_expr> opt_init_semi opt_expr comma_expr
%type <expr> expr
%type <expr> compound_init
%type <mut_expr> element_list expr_list
%type <designator> designator designator_spec
%type <element> element
%type <expr> method_optional_state_expr optional_state_expr
%type <expr> texpr vector_expr
%type <expr> statement statements compound_statement
%type <expr> statement
%type <mut_expr> statements compound_statement
%type <expr> else bool_label break_label continue_label
%type <expr> unary_expr ident_expr cast_expr expr_list
%type <expr> opt_arg_list arg_list arg_expr
%type <expr> unary_expr ident_expr cast_expr
%type <mut_expr> opt_arg_list arg_list
%type <expr> arg_expr
%type <switch_block> switch_block
%type <symbol> identifier label
%type <expr> identifier_list
%type <mut_expr> identifier_list
%type <symbol> protocol_name_list selector reserved_word
%type <param> optional_param_list unaryselector keyworddecl
%type <param> keywordselector
@ -227,8 +232,8 @@ int yylex (void);
%{
static switch_block_t *switch_block;
static expr_t *break_label;
static expr_t *continue_label;
static const expr_t *break_label;
static const expr_t *continue_label;
static specifier_t
make_spec (type_t *type, storage_class_t storage, int is_typedef,
@ -645,7 +650,7 @@ qc_nocode_func
{
specifier_t spec = $<spec>0;
symbol_t *sym = $1;
expr_t *expr = $4;
const expr_t *expr = $4;
sym = qc_function_symbol (spec, sym);
build_builtin_function (sym, expr, 0, spec.storage);
}
@ -1396,7 +1401,7 @@ local_expr
: /* emtpy */
{
$<spec>$ = $<spec>0;
local_expr = new_block_expr ();
local_expr = new_block_expr (0);
}
;
@ -1507,7 +1512,7 @@ compound_statement
statements
: /*empty*/
{
$$ = new_block_expr ();
$$ = new_block_expr (0);
}
| statements flush_dag statement
{
@ -1564,7 +1569,7 @@ statement
}
| GOTO NAME
{
expr_t *label = named_label_expr ($2);
const expr_t *label = named_label_expr ($2);
$$ = goto_expr (label);
}
| IF not '(' texpr ')' flush_dag statement %prec IFX
@ -1687,7 +1692,7 @@ switch_block
opt_init_semi
: comma_expr seq_semi
| decl /* contains ; */
| decl /* contains ; */ { $$ = (expr_t *) $1; }
| ';'
{
$$ = 0;
@ -1708,7 +1713,7 @@ unary_expr
| SELF { $$ = new_self_expr (); }
| THIS { $$ = new_this_expr (); }
| const { $$ = $1; }
| '(' expr ')' { $$ = $2; $$->paren = 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); }
@ -1797,7 +1802,7 @@ comma_expr
if ($1->list.head->next) {
$$ = build_block_expr ($1, true);
} else {
$$ = $1->list.head->expr;
$$ = (expr_t *) $1->list.head->expr;
}
}
;
@ -1861,7 +1866,7 @@ obj_def
identifier_list
: identifier
{
$$ = append_expr (new_block_expr (), new_symbol_expr ($1));
$$ = append_expr (new_block_expr (0), new_symbol_expr ($1));
}
| identifier_list ',' identifier
{

16
tools/qfcc/source/qp-parse.y
View file

@ -85,7 +85,8 @@ int yylex (void);
struct hashtab_s *def_list;
struct type_s *type;
struct typedef_s *typename;
struct expr_s *expr;
const struct expr_s *expr;
struct expr_s *mut_expr;
struct function_s *function;
struct switch_block_s *switch_block;
struct param_s *param;
@ -134,9 +135,11 @@ int yylex (void);
%type <symbol> program_head identifier_list subprogram_head
%type <symtab> param_scope
%type <param> arguments parameter_list
%type <expr> compound_statement else optional_statements statement_list
%type <mut_expr> compound_statement optional_statements statement_list
%type <expr> else
%type <expr> statement procedure_statement
%type <expr> expression_list expression unary_expr primary variable name
%type <mut_expr> expression_list
%type <expr> expression unary_expr primary variable name
%type <op> sign
%{
@ -158,7 +161,7 @@ build_dotmain (symbol_t *program)
current_func = begin_function (dotmain, 0, current_symtab, 0,
current_storage);
current_symtab = current_func->locals;
code = new_block_expr ();
code = new_block_expr (0);
append_expr (code, function_expr (new_symbol_expr (program), 0));
append_expr (code, return_expr (current_func, exitcode));
build_code_function (dotmain, 0, code);
@ -389,7 +392,7 @@ opt_semi
statement_list
: statement
{
$$ = new_block_expr ();
$$ = new_block_expr (0);
append_expr ($$, $1);
}
| statement_list ';' statement
@ -419,6 +422,9 @@ statement
}
| procedure_statement
| compound_statement
{
$$ = $1;
}
| IF expression THEN statement else statement
{
$$ = build_if_statement (0, $2, $4, $5, $6);

338
tools/qfcc/source/statements.c
View file

File diff suppressed because it is too large Load diff

2
tools/qfcc/source/struct.c
View file

@ -263,7 +263,7 @@ finish_enum (symbol_t *sym)
}
void
add_enum (symbol_t *enm, symbol_t *name, expr_t *val)
add_enum (symbol_t *enm, symbol_t *name, const expr_t *val)
{
type_t *enum_type = enm->type;
symtab_t *enum_tab = enum_type->t.symtab;

8
tools/qfcc/source/stub.c
View file

@ -55,8 +55,8 @@ void codespace_addcode (codespace_t *codespace, struct dstatement_s *code, int s
__attribute__((const)) int function_parms (function_t *f, byte *parm_size) {return 0;}
void def_to_ddef (def_t *def, ddef_t *ddef, int aux) {}
__attribute__((noreturn)) void _internal_error (const expr_t *e, const char *file, int line, const char *func, const char *fmt, ...) {abort();}
__attribute__((const)) expr_t *_warning (expr_t *e, const char *file, int line, const char *func, const char *fmt, ...) {return 0;}
__attribute__((const)) expr_t *_error (expr_t *e, const char *file, int line, const char *func, const char *fmt, ...) {return 0;}
__attribute__((const)) expr_t *_warning (const expr_t *e, const char *file, int line, const char *func, const char *fmt, ...) {return 0;}
__attribute__((const)) expr_t *_error (const expr_t *e, const char *file, int line, const char *func, const char *fmt, ...) {return 0;}
__attribute__((const)) symbol_t *make_structure (const char *name, int su, struct_def_t *defs, type_t *type) {return 0;}
__attribute__((const)) symbol_t *symtab_addsymbol (symtab_t *symtab, symbol_t *symbol) {return 0;}
__attribute__((const)) symbol_t *new_symbol_type (const char *name, type_t *type) {return 0;}
@ -68,8 +68,8 @@ int is_id (const type_t *type){return type->type;}
int is_SEL (const type_t *type){return 0;}
int is_Class (const type_t *type){return 0;}
int compare_protocols (protocollist_t *protos1, protocollist_t *protos2){return protos1->count - protos2->count;}
void dump_dot (const char *stage, void *data,
void (*dump_func) (void *data, const char *fname)){}
void dump_dot (const char *stage, const void *data,
void (*dump_func) (const void *data, const char *fname)){}
void dump_dot_type (void *_t, const char *filename){}
char *fubar;
const char *file_basename(const char *p, int keepdot) { return fubar;}

74
tools/qfcc/source/switch.c
View file

@ -57,15 +57,15 @@
#include "tools/qfcc/source/qc-parse.h"
typedef struct case_node_s {
expr_t *low;
expr_t *high;
expr_t **labels;
expr_t *_label;
const expr_t *low;
const expr_t *high;
const expr_t **labels;
const expr_t *_label;
struct case_node_s *left, *right;
} case_node_t;
static __attribute__((pure)) ex_value_t *
get_value (expr_t *e)
static ex_value_t * __attribute__((pure))
get_value (const expr_t *e)
{
if (e->type == ex_symbol)
return e->symbol->s.value;
@ -91,8 +91,8 @@ compare (const void *_cla, const void *_clb, void *unused)
{
case_label_t *cla = (case_label_t *) _cla;
case_label_t *clb = (case_label_t *) _clb;
expr_t *v1 = cla->value;
expr_t *v2 = clb->value;
const expr_t *v1 = cla->value;
const expr_t *v2 = clb->value;
ex_value_t *val1, *val2;
if (v1 == v2)
@ -108,8 +108,8 @@ compare (const void *_cla, const void *_clb, void *unused)
return memcmp (&val1->v, &val2->v, sizeof (val1->v)) == 0;
}
struct expr_s *
case_label_expr (switch_block_t *switch_block, expr_t *value)
const expr_t *
case_label_expr (switch_block_t *switch_block, const expr_t *value)
{
case_label_t *cl = malloc (sizeof (case_label_t));
@ -197,7 +197,7 @@ label_compare (const void *_a, const void *_b)
}
static case_node_t *
new_case_node (expr_t *low, expr_t *high)
new_case_node (const expr_t *low, const expr_t *high)
{
case_node_t *node = malloc (sizeof (case_node_t));
@ -214,7 +214,7 @@ new_case_node (expr_t *low, expr_t *high)
if (!is_int_val (low))
internal_error (low, "switch");
size = expr_int (high) - expr_int (low) + 1;
node->labels = calloc (size, sizeof (expr_t *));
node->labels = calloc (size, sizeof (const expr_t *));
}
node->left = node->right = 0;
return node;
@ -285,13 +285,13 @@ build_case_tree (case_label_t **labels, int count, int range)
}
static void
build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val,
expr_t *temp, expr_t *default_label)
build_switch (expr_t *sw, case_node_t *tree, int op, const expr_t *sw_val,
const expr_t *temp, const expr_t *default_label)
{
expr_t *test;
expr_t *branch;
expr_t *high_label = default_label;
expr_t *low_label = default_label;
const expr_t *test;
const expr_t *branch;
const expr_t *high_label = default_label;
const expr_t *low_label = default_label;
if (!tree) {
branch = goto_expr (default_label);
@ -333,16 +333,16 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val,
int low = expr_int (tree->low);
int high = expr_int (tree->high);
symbol_t *table_sym;
expr_t *table_expr;
const expr_t *table_expr;
expr_t *table_init;
const char *table_name = new_label_name ();
int i;
expr_t *range = binary_expr ('-', tree->high, tree->low);
expr_t *label;
const expr_t *range = binary_expr ('-', tree->high, tree->low);
const expr_t *label;
table_init = new_compound_init ();
for (i = 0; i <= high - low; i++) {
tree->labels[i]->label.used++;
((expr_t *) tree->labels[i])->label.used++;
label = address_expr (tree->labels[i], 0);
append_element (table_init, new_element (label, 0));
}
@ -393,27 +393,27 @@ check_enum_switch (switch_block_t *switch_block)
}
}
struct expr_s *
switch_expr (switch_block_t *switch_block, expr_t *break_label,
expr_t *statements)
const expr_t *
switch_expr (switch_block_t *switch_block, const expr_t *break_label,
const expr_t *statements)
{
if (switch_block->test->type == ex_error) {
return switch_block->test;
}
int saved_line = pr.source_line;
pr_string_t saved_file = pr.source_file;
pr.source_line = switch_block->test->line;
pr.source_file = switch_block->test->file;
case_label_t **labels, **l;
case_label_t _default_label;
case_label_t *default_label = &_default_label;
expr_t *sw = new_block_expr ();
expr_t *sw = new_block_expr (0);
type_t *type = get_type (switch_block->test);
expr_t *sw_val = new_temp_def_expr (type);
expr_t *default_expr;
const expr_t *sw_val = new_temp_def_expr (type);
const expr_t *default_expr;
int num_labels = 0;
int saved_line = pr.source_line;
pr_string_t saved_file = pr.source_file;
pr.source_line = sw_val->line = switch_block->test->line;
pr.source_file = sw_val->file = switch_block->test->file;
default_label->value = 0;
default_label = Hash_DelElement (switch_block->labels, default_label);
@ -434,16 +434,16 @@ switch_expr (switch_block_t *switch_block, expr_t *break_label,
|| (!is_string(type) && !is_float(type) && !is_integral (type))
|| num_labels < 8) {
for (l = labels; *l; l++) {
expr_t *cmp = binary_expr (EQ, sw_val, (*l)->value);
expr_t *test = branch_expr (NE, test_expr (cmp),
(*l)->label);
const expr_t *cmp = binary_expr (EQ, sw_val, (*l)->value);
const expr_t *test = branch_expr (NE, test_expr (cmp),
(*l)->label);
append_expr (sw, test);
}
default_expr = goto_expr (default_label->label);
append_expr (sw, default_expr);
} else {
expr_t *temp;
const expr_t *temp;
int op;
case_node_t *case_tree;

2
tools/qfcc/source/symtab.c
View file

@ -251,7 +251,7 @@ make_symbol (const char *name, type_t *type, defspace_t *space,
}
symbol_t *
declare_symbol (specifier_t spec, expr_t *init, symtab_t *symtab)
declare_symbol (specifier_t spec, const expr_t *init, symtab_t *symtab)
{
symbol_t *s = spec.sym;
defspace_t *space = symtab->space;

6
tools/qfcc/source/type.c
View file

@ -170,7 +170,7 @@ int type_cast_map[ev_type_count] = {
ALLOC_STATE (type_t, types);
etype_t
low_level_type (type_t *type)
low_level_type (const type_t *type)
{
if (type->type > ev_type_count)
internal_error (0, "invalid type");
@ -630,7 +630,7 @@ field_type (type_t *aux)
}
type_t *
pointer_type (type_t *aux)
pointer_type (const type_t *aux)
{
type_t _new;
type_t *new = &_new;
@ -643,7 +643,7 @@ pointer_type (type_t *aux)
new->alignment = 1;
new->width = 1;
if (aux) {
new = find_type (append_type (new, aux));
new = find_type (append_type (new, (type_t *) aux));
}
return new;
}