mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2025-02-25 21:21:14 +00:00
6840a208b9
They're buggy in that the defspaces for parameters and locals are incorrect (they need to point to the calling scope's space). Also, parameters are not yet hooked up correctly. However, errors (because I need to allow casts from scalars to vectors) do get handled.
320 lines
7.8 KiB
C
320 lines
7.8 KiB
C
/*
|
|
expr_assign.c
|
|
|
|
assignment expression construction and manipulations
|
|
|
|
Copyright (C) 2001 Bill Currie <bill@taniwha.org>
|
|
|
|
Author: Bill Currie <bill@taniwha.org>
|
|
Date: 2001/06/15
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_STRING_H
|
|
# include <string.h>
|
|
#endif
|
|
#ifdef HAVE_STRINGS_H
|
|
# include <strings.h>
|
|
#endif
|
|
#include <stdlib.h>
|
|
|
|
#include "QF/alloc.h"
|
|
#include "QF/dstring.h"
|
|
#include "QF/mathlib.h"
|
|
#include "QF/sys.h"
|
|
#include "QF/va.h"
|
|
|
|
#include "tools/qfcc/include/qfcc.h"
|
|
#include "tools/qfcc/include/algebra.h"
|
|
#include "tools/qfcc/include/class.h"
|
|
#include "tools/qfcc/include/def.h"
|
|
#include "tools/qfcc/include/defspace.h"
|
|
#include "tools/qfcc/include/diagnostic.h"
|
|
#include "tools/qfcc/include/emit.h"
|
|
#include "tools/qfcc/include/expr.h"
|
|
#include "tools/qfcc/include/function.h"
|
|
#include "tools/qfcc/include/idstuff.h"
|
|
#include "tools/qfcc/include/method.h"
|
|
#include "tools/qfcc/include/options.h"
|
|
#include "tools/qfcc/include/reloc.h"
|
|
#include "tools/qfcc/include/shared.h"
|
|
#include "tools/qfcc/include/strpool.h"
|
|
#include "tools/qfcc/include/struct.h"
|
|
#include "tools/qfcc/include/symtab.h"
|
|
#include "tools/qfcc/include/target.h"
|
|
#include "tools/qfcc/include/type.h"
|
|
#include "tools/qfcc/include/value.h"
|
|
|
|
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 ||
|
|
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}
|
|
auto assignment = assign_expr (dst, src->expr.e1);
|
|
// protect assignment from binary_expr
|
|
assignment = paren_expr (assignment);
|
|
return binary_expr (src->expr.op, assignment, src->expr.e2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
is_lvalue (const expr_t *expr)
|
|
{
|
|
switch (expr->type) {
|
|
case ex_def:
|
|
return !expr->def->constant;
|
|
case ex_symbol:
|
|
return expr->symbol->lvalue;
|
|
case ex_temp:
|
|
return true;
|
|
case ex_expr:
|
|
if (expr->expr.op == '.') {
|
|
return true;
|
|
}
|
|
break;
|
|
case ex_alias:
|
|
return is_lvalue (expr->alias.expr);
|
|
case ex_address:
|
|
return false;
|
|
case ex_assign:
|
|
return false;
|
|
case ex_uexpr:
|
|
if (expr->expr.op == '.') {
|
|
return true;
|
|
}
|
|
break;
|
|
case ex_branch:
|
|
case ex_inout:
|
|
case ex_memset:
|
|
case ex_compound:
|
|
case ex_state:
|
|
case ex_bool:
|
|
case ex_label:
|
|
case ex_labelref:
|
|
case ex_block:
|
|
case ex_vector:
|
|
case ex_nil:
|
|
case ex_value:
|
|
case ex_error:
|
|
case ex_selector:
|
|
case ex_message:
|
|
case ex_return:
|
|
case ex_adjstk:
|
|
case ex_with:
|
|
case ex_args:
|
|
case ex_horizontal:
|
|
case ex_swizzle:
|
|
case ex_extend:
|
|
case ex_multivec:
|
|
case ex_list:
|
|
case ex_type:
|
|
case ex_incop:
|
|
case ex_decl:
|
|
case ex_loop:
|
|
case ex_select:
|
|
case ex_intrinsic:
|
|
case ex_switch:
|
|
case ex_caselabel:
|
|
case ex_process:
|
|
break;
|
|
case ex_cond:
|
|
return (is_lvalue (expr->cond.true_expr)
|
|
&& is_lvalue (expr->cond.false_expr));
|
|
case ex_field:
|
|
return true;
|
|
case ex_array:
|
|
return true;
|
|
case ex_xvalue:
|
|
bug (expr, "should xvalue happen here?");
|
|
if (expr->xvalue.lvalue) {
|
|
return is_lvalue (expr->xvalue.expr);
|
|
}
|
|
return false;
|
|
case ex_count:
|
|
internal_error (expr, "invalid expression");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static const expr_t *
|
|
check_valid_lvalue (const expr_t *expr)
|
|
{
|
|
if (!is_lvalue (expr)) {
|
|
if (options.traditional) {
|
|
warning (expr, "invalid lvalue in assignment");
|
|
return 0;
|
|
}
|
|
return error (expr, "invalid lvalue in assignment");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static const expr_t *
|
|
check_types_compatible (const expr_t *dst, const expr_t *src)
|
|
{
|
|
auto dst_type = get_type (dst);
|
|
auto src_type = get_type (src);
|
|
|
|
if (dst_type == src_type) {
|
|
if (is_algebra (dst_type) || is_algebra (src_type)) {
|
|
return algebra_assign_expr (dst, src);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
if (type_assignable (dst_type, src_type)) {
|
|
if (is_algebra (dst_type) || is_algebra (src_type)) {
|
|
return algebra_assign_expr (dst, src);
|
|
}
|
|
debug (dst, "casting %s to %s", src_type->name, dst_type->name);
|
|
if (!src->implicit && !type_promotes (dst_type, src_type)) {
|
|
if (is_double (src_type)) {
|
|
warning (dst, "assignment of %s to %s (use a cast)\n",
|
|
src_type->name, dst_type->name);
|
|
}
|
|
}
|
|
// the types are different but cast-compatible
|
|
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) {
|
|
return assign_expr (dst, new);
|
|
}
|
|
return 0;
|
|
}
|
|
// traditional qcc is a little sloppy
|
|
if (!options.traditional) {
|
|
return type_mismatch (dst, src, '=');
|
|
}
|
|
if (is_func (dst_type) && is_func (src_type)) {
|
|
warning (dst, "assignment between disparate function types");
|
|
return 0;
|
|
}
|
|
if (is_float (dst_type) && is_vector (src_type)) {
|
|
warning (dst, "assignment of vector to float");
|
|
src = field_expr (src, new_name_expr ("x"));
|
|
return assign_expr (dst, src);
|
|
}
|
|
if (is_vector (dst_type) && is_float (src_type)) {
|
|
warning (dst, "assignment of float to vector");
|
|
dst = field_expr (dst, new_name_expr ("x"));
|
|
return assign_expr (dst, src);
|
|
}
|
|
return type_mismatch (dst, src, '=');
|
|
}
|
|
|
|
static int __attribute__((pure))
|
|
is_memset (const expr_t *e)
|
|
{
|
|
return e->type == ex_memset;
|
|
}
|
|
|
|
const expr_t *
|
|
assign_expr (const expr_t *dst, const expr_t *src)
|
|
{
|
|
const expr_t *expr;
|
|
const type_t *dst_type, *src_type;
|
|
|
|
if (is_error (dst)) {
|
|
return dst;
|
|
}
|
|
|
|
const expr_t *err;
|
|
if ((err = check_valid_lvalue (dst))) {
|
|
return err;
|
|
}
|
|
|
|
if (is_reference (get_type (dst))) {
|
|
dst = pointer_deref (dst);
|
|
}
|
|
dst_type = get_type (dst);
|
|
if (!dst_type) {
|
|
internal_error (dst, "dst_type broke in assign_expr");
|
|
}
|
|
|
|
if (src && !is_memset (src)) {
|
|
if (is_error (src)) {
|
|
return src;
|
|
}
|
|
|
|
if (options.traditional
|
|
&& (expr = check_assign_logic_precedence (dst, src))) {
|
|
return expr;
|
|
}
|
|
} else {
|
|
if (!src && is_scalar (dst_type)) {
|
|
return error (dst, "empty scalar initializer");
|
|
}
|
|
src = new_nil_expr ();
|
|
}
|
|
if (src->type == ex_compound) {
|
|
src = current_target.initialized_temp (dst_type, src);
|
|
if (is_error (src)) {
|
|
return src;
|
|
}
|
|
}
|
|
if (is_reference (get_type (src))) {
|
|
src = pointer_deref (src);
|
|
}
|
|
src_type = get_type (src);
|
|
if (!src_type) {
|
|
internal_error (src, "src_type broke in assign_expr");
|
|
}
|
|
|
|
if (is_pointer (dst_type) && is_array (src_type)) {
|
|
// assigning an array to a pointer is the same as taking the address of
|
|
// the array but using the type of the array elements
|
|
src = address_expr (src, src_type->fldptr.type);
|
|
src_type = get_type (src);
|
|
}
|
|
if (src->type == ex_bool) {
|
|
// boolean expressions are chains of tests, so extract the result
|
|
// of the tests
|
|
src = convert_from_bool (src, dst_type);
|
|
if (is_error (src)) {
|
|
return src;
|
|
}
|
|
src_type = get_type (src);
|
|
}
|
|
|
|
if (!is_nil (src)) {
|
|
if ((expr = check_types_compatible (dst, src))) {
|
|
// expr might be a valid expression, but if so,
|
|
// check_types_compatible will take care of everything
|
|
return expr;
|
|
}
|
|
if (src->type == ex_vector) {
|
|
return current_target.assign_vector (dst, src);
|
|
}
|
|
} else {
|
|
src = convert_nil (src, dst_type);
|
|
}
|
|
|
|
expr = new_assign_expr (dst, src);
|
|
return expr;
|
|
}
|