mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-10 00:03:10 +00:00
Code Issues Packages Projects Releases Wiki Activity
zig/src/eval.cpp
Andrew Kelley 36c6acfc76 enum init uses container init syntax instead of fn call 
See #5
2016-04-19 18:52:09 -07:00

1194 lines
44 KiB
C++
Raw Blame History

#include "eval.hpp"
#include "analyze.hpp"
#include "error.hpp"
static bool eval_fn_args(EvalFnRoot *efr, FnTableEntry *fn, ConstExprValue *args, ConstExprValue *out_val);
bool const_values_equal(ConstExprValue *a, ConstExprValue *b, TypeTableEntry *type_entry) {
switch (type_entry->id) {
case TypeTableEntryIdEnum:
{
ConstEnumValue *enum1 = &a->data.x_enum;
ConstEnumValue *enum2 = &b->data.x_enum;
if (enum1->tag == enum2->tag) {
TypeEnumField *enum_field = &type_entry->data.enumeration.fields[enum1->tag];
if (type_has_bits(enum_field->type_entry)) {
zig_panic("TODO const expr analyze enum special value for equality");
} else {
return true;
}
}
return false;
}
case TypeTableEntryIdMetaType:
return a->data.x_type == b->data.x_type;
case TypeTableEntryIdVoid:
return true;
case TypeTableEntryIdPureError:
return a->data.x_err.err == b->data.x_err.err;
case TypeTableEntryIdFn:
return a->data.x_fn == b->data.x_fn;
case TypeTableEntryIdBool:
return a->data.x_bool == b->data.x_bool;
case TypeTableEntryIdInt:
case TypeTableEntryIdFloat:
case TypeTableEntryIdNumLitFloat:
case TypeTableEntryIdNumLitInt:
return bignum_cmp_eq(&a->data.x_bignum, &b->data.x_bignum);
case TypeTableEntryIdPointer:
zig_panic("TODO");
case TypeTableEntryIdArray:
zig_panic("TODO");
case TypeTableEntryIdStruct:
zig_panic("TODO");
case TypeTableEntryIdUndefLit:
zig_panic("TODO");
case TypeTableEntryIdMaybe:
zig_panic("TODO");
case TypeTableEntryIdErrorUnion:
zig_panic("TODO");
case TypeTableEntryIdTypeDecl:
zig_panic("TODO");
case TypeTableEntryIdNamespace:
zig_panic("TODO");
case TypeTableEntryIdGenericFn:
case TypeTableEntryIdInvalid:
case TypeTableEntryIdUnreachable:
zig_unreachable();
}
zig_unreachable();
}
static bool eval_expr(EvalFn *ef, AstNode *node, ConstExprValue *out);
static bool eval_block(EvalFn *ef, AstNode *node, ConstExprValue *out) {
assert(node->type == NodeTypeBlock);
EvalScope *my_scope = allocate<EvalScope>(1);
my_scope->block_context = node->block_context;
ef->scope_stack.append(my_scope);
for (int i = 0; i < node->data.block.statements.length; i += 1) {
AstNode *child = node->data.block.statements.at(i);
memset(out, 0, sizeof(ConstExprValue));
if (eval_expr(ef, child, out)) return true;
}
ef->scope_stack.pop();
return false;
}
static bool eval_return(EvalFn *ef, AstNode *node, ConstExprValue *out) {
assert(node->type == NodeTypeReturnExpr);
eval_expr(ef, node->data.return_expr.expr, ef->return_expr);
return true;
}
static bool eval_bool_bin_op_bool(bool a, BinOpType bin_op, bool b) {
if (bin_op == BinOpTypeBoolOr) {
return a || b;
} else if (bin_op == BinOpTypeBoolAnd) {
return a && b;
} else {
zig_unreachable();
}
}
static int eval_const_expr_bin_op_bignum(ConstExprValue *op1_val, ConstExprValue *op2_val,
ConstExprValue *out_val, bool (*bignum_fn)(BigNum *, BigNum *, BigNum *))
{
bool overflow = bignum_fn(&out_val->data.x_bignum, &op1_val->data.x_bignum, &op2_val->data.x_bignum);
if (overflow) {
return ErrorOverflow;
}
out_val->ok = true;
out_val->depends_on_compile_var = op1_val->depends_on_compile_var || op2_val->depends_on_compile_var;
return 0;
}
int eval_const_expr_bin_op(ConstExprValue *op1_val, TypeTableEntry *op1_type,
BinOpType bin_op, ConstExprValue *op2_val, TypeTableEntry *op2_type, ConstExprValue *out_val)
{
assert(op1_val->ok);
assert(op2_val->ok);
switch (bin_op) {
case BinOpTypeAssign:
case BinOpTypeAssignTimes:
case BinOpTypeAssignDiv:
case BinOpTypeAssignMod:
case BinOpTypeAssignPlus:
case BinOpTypeAssignMinus:
case BinOpTypeAssignBitShiftLeft:
case BinOpTypeAssignBitShiftRight:
case BinOpTypeAssignBitAnd:
case BinOpTypeAssignBitXor:
case BinOpTypeAssignBitOr:
case BinOpTypeAssignBoolAnd:
case BinOpTypeAssignBoolOr:
out_val->ok = true;
return 0;
case BinOpTypeBoolOr:
case BinOpTypeBoolAnd:
assert(op1_type->id == TypeTableEntryIdBool);
assert(op2_type->id == TypeTableEntryIdBool);
out_val->data.x_bool = eval_bool_bin_op_bool(op1_val->data.x_bool, bin_op, op2_val->data.x_bool);
out_val->ok = true;
out_val->depends_on_compile_var = op1_val->depends_on_compile_var || op2_val->depends_on_compile_var;
return 0;
case BinOpTypeCmpEq:
case BinOpTypeCmpNotEq:
case BinOpTypeCmpLessThan:
case BinOpTypeCmpGreaterThan:
case BinOpTypeCmpLessOrEq:
case BinOpTypeCmpGreaterOrEq:
{
bool type_can_gt_lt_cmp = (op1_type->id == TypeTableEntryIdNumLitFloat ||
op1_type->id == TypeTableEntryIdNumLitInt ||
op1_type->id == TypeTableEntryIdFloat ||
op1_type->id == TypeTableEntryIdInt);
bool answer;
if (type_can_gt_lt_cmp) {
bool (*bignum_cmp)(BigNum *, BigNum *);
if (bin_op == BinOpTypeCmpEq) {
bignum_cmp = bignum_cmp_eq;
} else if (bin_op == BinOpTypeCmpNotEq) {
bignum_cmp = bignum_cmp_neq;
} else if (bin_op == BinOpTypeCmpLessThan) {
bignum_cmp = bignum_cmp_lt;
} else if (bin_op == BinOpTypeCmpGreaterThan) {
bignum_cmp = bignum_cmp_gt;
} else if (bin_op == BinOpTypeCmpLessOrEq) {
bignum_cmp = bignum_cmp_lte;
} else if (bin_op == BinOpTypeCmpGreaterOrEq) {
bignum_cmp = bignum_cmp_gte;
} else {
zig_unreachable();
}
answer = bignum_cmp(&op1_val->data.x_bignum, &op2_val->data.x_bignum);
} else {
bool are_equal = const_values_equal(op1_val, op2_val, op1_type);
if (bin_op == BinOpTypeCmpEq) {
answer = are_equal;
} else if (bin_op == BinOpTypeCmpNotEq) {
answer = !are_equal;
} else {
zig_unreachable();
}
}
out_val->depends_on_compile_var =
op1_val->depends_on_compile_var || op2_val->depends_on_compile_var;
out_val->data.x_bool = answer;
out_val->ok = true;
return 0;
}
case BinOpTypeAdd:
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_add);
case BinOpTypeBinOr:
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_or);
case BinOpTypeBinXor:
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_xor);
case BinOpTypeBinAnd:
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_and);
case BinOpTypeBitShiftLeft:
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_shl);
case BinOpTypeBitShiftRight:
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_shr);
case BinOpTypeSub:
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_sub);
case BinOpTypeMult:
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_mul);
case BinOpTypeDiv:
{
bool is_int = false;
bool is_float = false;
if (op1_type->id == TypeTableEntryIdInt ||
op1_type->id == TypeTableEntryIdNumLitInt)
{
is_int = true;
} else if (op1_type->id == TypeTableEntryIdFloat ||
op1_type->id == TypeTableEntryIdNumLitFloat)
{
is_float = true;
}
if ((is_int && op2_val->data.x_bignum.data.x_uint == 0) ||
(is_float && op2_val->data.x_bignum.data.x_float == 0.0))
{
return ErrorDivByZero;
} else {
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_div);
}
}
case BinOpTypeMod:
return eval_const_expr_bin_op_bignum(op1_val, op2_val, out_val, bignum_mod);
case BinOpTypeUnwrapMaybe:
zig_panic("TODO");
case BinOpTypeStrCat:
zig_panic("TODO");
case BinOpTypeInvalid:
zig_unreachable();
}
zig_unreachable();
}
static bool eval_bin_op_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeBinOpExpr);
AstNode *op1 = node->data.bin_op_expr.op1;
AstNode *op2 = node->data.bin_op_expr.op2;
TypeTableEntry *op1_type = get_resolved_expr(op1)->type_entry;
TypeTableEntry *op2_type = get_resolved_expr(op2)->type_entry;
ConstExprValue op1_val = {0};
if (eval_expr(ef, op1, &op1_val)) return true;
ConstExprValue op2_val = {0};
if (eval_expr(ef, op2, &op2_val)) return true;
BinOpType bin_op = node->data.bin_op_expr.bin_op;
int err;
if ((err = eval_const_expr_bin_op(&op1_val, op1_type, bin_op, &op2_val, op2_type, out_val))) {
ef->root->abort = true;
if (err == ErrorDivByZero) {
ErrorMsg *msg = add_node_error(ef->root->codegen, ef->root->fn->fn_def_node,
buf_sprintf("function evaluation caused division by zero"));
add_error_note(ef->root->codegen, msg, ef->root->call_node, buf_sprintf("called from here"));
add_error_note(ef->root->codegen, msg, node, buf_sprintf("division by zero here"));
} else if (err == ErrorOverflow) {
ErrorMsg *msg = add_node_error(ef->root->codegen, ef->root->fn->fn_def_node,
buf_sprintf("function evaluation caused overflow"));
add_error_note(ef->root->codegen, msg, ef->root->call_node, buf_sprintf("called from here"));
add_error_note(ef->root->codegen, msg, node, buf_sprintf("overflow occurred here"));
} else {
zig_unreachable();
}
return true;
}
assert(out_val->ok);
return false;
}
static EvalVar *find_var(EvalFn *ef, Buf *name) {
int scope_index = ef->scope_stack.length - 1;
while (scope_index >= 0) {
EvalScope *scope = ef->scope_stack.at(scope_index);
for (int var_i = 0; var_i < scope->vars.length; var_i += 1) {
EvalVar *var = &scope->vars.at(var_i);
if (buf_eql_buf(var->name, name)) {
return var;
}
}
scope_index -= 1;
}
return nullptr;
}
static bool eval_symbol_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeSymbol);
Buf *name = &node->data.symbol_expr.symbol;
EvalVar *var = find_var(ef, name);
assert(var);
*out_val = var->value;
return false;
}
static TypeTableEntry *resolve_expr_type(AstNode *node) {
Expr *expr = get_resolved_expr(node);
TypeTableEntry *type_entry = expr->type_entry;
assert(type_entry->id == TypeTableEntryIdMetaType);
ConstExprValue *const_val = &expr->const_val;
assert(const_val->ok);
return const_val->data.x_type;
}
static bool eval_container_init_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeContainerInitExpr);
AstNodeContainerInitExpr *container_init_expr = &node->data.container_init_expr;
ContainerInitKind kind = container_init_expr->kind;
if (container_init_expr->enum_type) {
zig_panic("TODO");
}
TypeTableEntry *container_type = resolve_expr_type(container_init_expr->type);
out_val->ok = true;
if (container_type->id == TypeTableEntryIdStruct &&
!container_type->data.structure.is_unknown_size_array &&
kind == ContainerInitKindStruct)
{
int expr_field_count = container_init_expr->entries.length;
int actual_field_count = container_type->data.structure.src_field_count;
assert(expr_field_count == actual_field_count);
out_val->data.x_struct.fields = allocate<ConstExprValue*>(actual_field_count);
for (int i = 0; i < expr_field_count; i += 1) {
AstNode *val_field_node = container_init_expr->entries.at(i);
assert(val_field_node->type == NodeTypeStructValueField);
TypeStructField *type_field = val_field_node->data.struct_val_field.type_struct_field;
int field_index = type_field->src_index;
ConstExprValue src_field_val = {0};
if (eval_expr(ef, val_field_node->data.struct_val_field.expr, &src_field_val)) return true;
ConstExprValue *dest_field_val = allocate<ConstExprValue>(1);
*dest_field_val = src_field_val;
out_val->data.x_struct.fields[field_index] = dest_field_val;
out_val->depends_on_compile_var = out_val->depends_on_compile_var ||
src_field_val.depends_on_compile_var;
}
} else if (container_type->id == TypeTableEntryIdVoid) {
return false;
} else if (container_type->id == TypeTableEntryIdUnreachable) {
ef->root->abort = true;
ErrorMsg *msg = add_node_error(ef->root->codegen, ef->root->fn->fn_def_node,
buf_sprintf("function evaluation reached unreachable expression"));
add_error_note(ef->root->codegen, msg, ef->root->call_node, buf_sprintf("called from here"));
add_error_note(ef->root->codegen, msg, node, buf_sprintf("unreachable expression here"));
return true;
} else if (container_type->id == TypeTableEntryIdStruct &&
container_type->data.structure.is_unknown_size_array &&
kind == ContainerInitKindArray)
{
int elem_count = container_init_expr->entries.length;
out_val->ok = true;
out_val->data.x_array.fields = allocate<ConstExprValue*>(elem_count);
for (int i = 0; i < elem_count; i += 1) {
AstNode *elem_node = container_init_expr->entries.at(i);
ConstExprValue *elem_val = allocate<ConstExprValue>(1);
if (eval_expr(ef, elem_node, elem_val)) return true;
assert(elem_val->ok);
out_val->data.x_array.fields[i] = elem_val;
out_val->depends_on_compile_var = out_val->depends_on_compile_var ||
elem_val->depends_on_compile_var;
}
} else {
zig_panic("TODO");
}
return false;
}
static bool eval_if_bool_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeIfBoolExpr);
ConstExprValue cond_val = {0};
if (eval_expr(ef, node->data.if_bool_expr.condition, &cond_val)) return true;
AstNode *exec_node = cond_val.data.x_bool ?
node->data.if_bool_expr.then_block : node->data.if_bool_expr.else_node;
if (exec_node) {
if (eval_expr(ef, exec_node, out_val)) return true;
}
out_val->ok = true;
return false;
}
void eval_const_expr_implicit_cast(CastOp cast_op,
ConstExprValue *other_val, TypeTableEntry *other_type,
ConstExprValue *const_val, TypeTableEntry *new_type)
{
const_val->depends_on_compile_var = other_val->depends_on_compile_var;
const_val->undef = other_val->undef;
assert(other_val != const_val);
switch (cast_op) {
case CastOpNoCast:
zig_unreachable();
case CastOpNoop:
case CastOpWidenOrShorten:
*const_val = *other_val;
break;
case CastOpPointerReinterpret:
if (other_type->id == TypeTableEntryIdPointer &&
new_type->id == TypeTableEntryIdPointer)
{
TypeTableEntry *other_child_type = other_type->data.pointer.child_type;
TypeTableEntry *new_child_type = new_type->data.pointer.child_type;
if ((other_child_type->id == TypeTableEntryIdInt ||
other_child_type->id == TypeTableEntryIdFloat) &&
(new_child_type->id == TypeTableEntryIdInt ||
new_child_type->id == TypeTableEntryIdFloat))
{
ConstExprValue **ptr_val = allocate<ConstExprValue*>(1);
*ptr_val = other_val->data.x_ptr.ptr[0];
const_val->data.x_ptr.ptr = ptr_val;
const_val->data.x_ptr.len = 1;
const_val->ok = true;
const_val->undef = other_val->undef;
const_val->depends_on_compile_var = other_val->depends_on_compile_var;
} else {
zig_panic("TODO");
}
} else if (other_type->id == TypeTableEntryIdMaybe &&
new_type->id == TypeTableEntryIdMaybe)
{
if (!other_val->data.x_maybe) {
*const_val = *other_val;
break;
}
TypeTableEntry *other_ptr_type = other_type->data.maybe.child_type;
TypeTableEntry *new_ptr_type = new_type->data.maybe.child_type;
if (other_ptr_type->id == TypeTableEntryIdPointer &&
new_ptr_type->id == TypeTableEntryIdPointer)
{
TypeTableEntry *other_child_type = other_ptr_type->data.pointer.child_type;
TypeTableEntry *new_child_type = new_ptr_type->data.pointer.child_type;
if ((other_child_type->id == TypeTableEntryIdInt ||
other_child_type->id == TypeTableEntryIdFloat) &&
(new_child_type->id == TypeTableEntryIdInt ||
new_child_type->id == TypeTableEntryIdFloat))
{
ConstExprValue *ptr_parent = allocate<ConstExprValue>(1);
ConstExprValue **ptr_val = allocate<ConstExprValue*>(1);
*ptr_val = other_val->data.x_maybe->data.x_ptr.ptr[0];
ptr_parent->data.x_ptr.ptr = ptr_val;
ptr_parent->data.x_ptr.len = 1;
ptr_parent->ok = true;
const_val->data.x_maybe = ptr_parent;
const_val->ok = true;
const_val->undef = other_val->undef;
const_val->depends_on_compile_var = other_val->depends_on_compile_var;
} else {
zig_panic("TODO");
}
} else {
zig_panic("TODO");
}
}
break;
case CastOpPtrToInt:
case CastOpIntToPtr:
// can't do it
break;
case CastOpToUnknownSizeArray:
{
assert(other_type->id == TypeTableEntryIdArray);
ConstExprValue *all_fields = allocate<ConstExprValue>(2);
ConstExprValue *ptr_field = &all_fields[0];
ConstExprValue *len_field = &all_fields[1];
const_val->data.x_struct.fields = allocate<ConstExprValue*>(2);
const_val->data.x_struct.fields[0] = ptr_field;
const_val->data.x_struct.fields[1] = len_field;
ptr_field->ok = true;
ptr_field->data.x_ptr.ptr = other_val->data.x_array.fields;
ptr_field->data.x_ptr.len = other_type->data.array.len;
len_field->ok = true;
bignum_init_unsigned(&len_field->data.x_bignum, other_type->data.array.len);
const_val->ok = true;
break;
}
case CastOpMaybeWrap:
const_val->data.x_maybe = other_val;
const_val->ok = true;
break;
case CastOpErrorWrap:
const_val->data.x_err.err = nullptr;
const_val->data.x_err.payload = other_val;
const_val->ok = true;
break;
case CastOpPureErrorWrap:
const_val->data.x_err.err = other_val->data.x_err.err;
const_val->ok = true;
break;
case CastOpErrToInt:
{
uint64_t value = other_val->data.x_err.err ? other_val->data.x_err.err->value : 0;
bignum_init_unsigned(&const_val->data.x_bignum, value);
const_val->ok = true;
break;
}
case CastOpIntToFloat:
bignum_cast_to_float(&const_val->data.x_bignum, &other_val->data.x_bignum);
const_val->ok = true;
break;
case CastOpFloatToInt:
bignum_cast_to_int(&const_val->data.x_bignum, &other_val->data.x_bignum);
const_val->ok = true;
break;
case CastOpBoolToInt:
bignum_init_unsigned(&const_val->data.x_bignum, other_val->data.x_bool ? 1 : 0);
const_val->ok = true;
break;
}
}
static bool int_type_depends_on_compile_var(CodeGen *g, TypeTableEntry *int_type) {
assert(int_type->id == TypeTableEntryIdInt);
for (int i = 0; i < CIntTypeCount; i += 1) {
if (int_type == g->builtin_types.entry_c_int[i]) {
return true;
}
}
return false;
}
void eval_min_max_value(CodeGen *g, TypeTableEntry *type_entry, ConstExprValue *const_val, bool is_max) {
if (type_entry->id == TypeTableEntryIdInt) {
const_val->ok = true;
const_val->depends_on_compile_var = int_type_depends_on_compile_var(g, type_entry);
if (is_max) {
if (type_entry->data.integral.is_signed) {
int64_t val;
if (type_entry->data.integral.bit_count == 64) {
val = INT64_MAX;
} else if (type_entry->data.integral.bit_count == 32) {
val = INT32_MAX;
} else if (type_entry->data.integral.bit_count == 16) {
val = INT16_MAX;
} else if (type_entry->data.integral.bit_count == 8) {
val = INT8_MAX;
} else {
zig_unreachable();
}
bignum_init_signed(&const_val->data.x_bignum, val);
} else {
uint64_t val;
if (type_entry->data.integral.bit_count == 64) {
val = UINT64_MAX;
} else if (type_entry->data.integral.bit_count == 32) {
val = UINT32_MAX;
} else if (type_entry->data.integral.bit_count == 16) {
val = UINT16_MAX;
} else if (type_entry->data.integral.bit_count == 8) {
val = UINT8_MAX;
} else {
zig_unreachable();
}
bignum_init_unsigned(&const_val->data.x_bignum, val);
}
} else {
if (type_entry->data.integral.is_signed) {
int64_t val;
if (type_entry->data.integral.bit_count == 64) {
val = INT64_MIN;
} else if (type_entry->data.integral.bit_count == 32) {
val = INT32_MIN;
} else if (type_entry->data.integral.bit_count == 16) {
val = INT16_MIN;
} else if (type_entry->data.integral.bit_count == 8) {
val = INT8_MIN;
} else {
zig_unreachable();
}
bignum_init_signed(&const_val->data.x_bignum, val);
} else {
bignum_init_unsigned(&const_val->data.x_bignum, 0);
}
}
} else if (type_entry->id == TypeTableEntryIdFloat) {
zig_panic("TODO analyze_min_max_value float");
} else if (type_entry->id == TypeTableEntryIdBool) {
const_val->ok = true;
const_val->data.x_bool = is_max;
} else {
zig_unreachable();
}
}
static bool eval_min_max(EvalFn *ef, AstNode *node, ConstExprValue *out_val, bool is_max) {
assert(node->type == NodeTypeFnCallExpr);
AstNode *type_node = node->data.fn_call_expr.params.at(0);
TypeTableEntry *type_entry = resolve_expr_type(type_node);
eval_min_max_value(ef->root->codegen, type_entry, out_val, is_max);
return false;
}
static bool eval_fn_with_overflow(EvalFn *ef, AstNode *node, ConstExprValue *out_val,
bool (*bignum_fn)(BigNum *dest, BigNum *op1, BigNum *op2))
{
assert(node->type == NodeTypeFnCallExpr);
AstNode *type_node = node->data.fn_call_expr.params.at(0);
TypeTableEntry *int_type = resolve_expr_type(type_node);
assert(int_type->id == TypeTableEntryIdInt);
AstNode *op1_node = node->data.fn_call_expr.params.at(1);
AstNode *op2_node = node->data.fn_call_expr.params.at(2);
AstNode *result_node = node->data.fn_call_expr.params.at(3);
ConstExprValue op1_val = {0};
if (eval_expr(ef, op1_node, &op1_val)) return true;
ConstExprValue op2_val = {0};
if (eval_expr(ef, op2_node, &op2_val)) return true;
ConstExprValue result_ptr_val = {0};
if (eval_expr(ef, result_node, &result_ptr_val)) return true;
ConstExprValue *result_val = result_ptr_val.data.x_ptr.ptr[0];
out_val->ok = true;
bool overflow = bignum_fn(&result_val->data.x_bignum, &op1_val.data.x_bignum, &op2_val.data.x_bignum);
overflow = overflow || !bignum_fits_in_bits(&result_val->data.x_bignum,
int_type->data.integral.bit_count, int_type->data.integral.is_signed);
out_val->data.x_bool = overflow;
if (overflow) {
bignum_truncate(&result_val->data.x_bignum, int_type->data.integral.bit_count);
}
return false;
}
static bool eval_fn_call_builtin(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeFnCallExpr);
BuiltinFnEntry *builtin_fn = node->data.fn_call_expr.builtin_fn;
switch (builtin_fn->id) {
case BuiltinFnIdMaxValue:
return eval_min_max(ef, node, out_val, true);
case BuiltinFnIdMinValue:
return eval_min_max(ef, node, out_val, false);
case BuiltinFnIdMulWithOverflow:
return eval_fn_with_overflow(ef, node, out_val, bignum_mul);
case BuiltinFnIdAddWithOverflow:
return eval_fn_with_overflow(ef, node, out_val, bignum_add);
case BuiltinFnIdSubWithOverflow:
return eval_fn_with_overflow(ef, node, out_val, bignum_sub);
case BuiltinFnIdMemcpy:
case BuiltinFnIdMemset:
case BuiltinFnIdSizeof:
case BuiltinFnIdAlignof:
case BuiltinFnIdMemberCount:
case BuiltinFnIdTypeof:
case BuiltinFnIdCInclude:
case BuiltinFnIdCDefine:
case BuiltinFnIdCUndef:
case BuiltinFnIdCompileVar:
case BuiltinFnIdConstEval:
case BuiltinFnIdCtz:
case BuiltinFnIdClz:
case BuiltinFnIdImport:
case BuiltinFnIdCImport:
case BuiltinFnIdErrName:
case BuiltinFnIdEmbedFile:
zig_panic("TODO");
case BuiltinFnIdBreakpoint:
case BuiltinFnIdInvalid:
zig_unreachable();
}
return false;
}
static bool eval_fn_call_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeFnCallExpr);
AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
CastOp cast_op = node->data.fn_call_expr.cast_op;
if (node->data.fn_call_expr.is_builtin) {
return eval_fn_call_builtin(ef, node, out_val);
} else if (cast_op != CastOpNoCast) {
TypeTableEntry *new_type = resolve_expr_type(fn_ref_expr);
AstNode *param_node = node->data.fn_call_expr.params.at(0);
TypeTableEntry *old_type = get_resolved_expr(param_node)->type_entry;
ConstExprValue param_val = {0};
if (eval_expr(ef, param_node, &param_val)) return true;
eval_const_expr_implicit_cast(cast_op, &param_val, old_type, out_val, new_type);
return false;
}
FnTableEntry *fn_table_entry = node->data.fn_call_expr.fn_entry;
if (fn_ref_expr->type == NodeTypeFieldAccessExpr &&
fn_ref_expr->data.field_access_expr.is_member_fn)
{
zig_panic("TODO");
}
if (!fn_table_entry) {
ConstExprValue fn_val = {0};
if (eval_expr(ef, fn_ref_expr, &fn_val)) return true;
fn_table_entry = fn_val.data.x_fn;
}
int param_count = node->data.fn_call_expr.params.length;
ConstExprValue *args = allocate<ConstExprValue>(param_count);
for (int i = 0; i < param_count; i += 1) {
AstNode *param_expr_node = node->data.fn_call_expr.params.at(i);
ConstExprValue *param_val = &args[i];
if (eval_expr(ef, param_expr_node, param_val)) return true;
}
ef->root->branches_used += 1;
eval_fn_args(ef->root, fn_table_entry, args, out_val);
return false;
}
static bool eval_field_access_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeFieldAccessExpr);
AstNode *struct_expr = node->data.field_access_expr.struct_expr;
TypeTableEntry *struct_type = get_resolved_expr(struct_expr)->type_entry;
if (struct_type->id == TypeTableEntryIdArray) {
Buf *name = &node->data.field_access_expr.field_name;
assert(buf_eql_str(name, "len"));
zig_panic("TODO");
} else if (struct_type->id == TypeTableEntryIdStruct || (struct_type->id == TypeTableEntryIdPointer &&
struct_type->data.pointer.child_type->id == TypeTableEntryIdStruct))
{
TypeStructField *tsf = node->data.field_access_expr.type_struct_field;
assert(tsf);
if (struct_type->id == TypeTableEntryIdStruct) {
ConstExprValue struct_val = {0};
if (eval_expr(ef, struct_expr, &struct_val)) return true;
ConstExprValue *field_value = struct_val.data.x_struct.fields[tsf->src_index];
*out_val = *field_value;
assert(out_val->ok);
} else {
zig_panic("TODO");
}
} else if (struct_type->id == TypeTableEntryIdMetaType) {
TypeTableEntry *child_type = resolve_expr_type(struct_expr);
if (child_type->id == TypeTableEntryIdPureError) {
*out_val = get_resolved_expr(node)->const_val;
} else {
zig_panic("TODO");
}
} else if (struct_type->id == TypeTableEntryIdNamespace) {
zig_panic("TODO");
} else {
zig_unreachable();
}
return false;
}
static bool eval_for_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeForExpr);
AstNode *array_node = node->data.for_expr.array_expr;
AstNode *elem_node = node->data.for_expr.elem_node;
AstNode *index_node = node->data.for_expr.index_node;
AstNode *body_node = node->data.for_expr.body;
TypeTableEntry *array_type = get_resolved_expr(array_node)->type_entry;
ConstExprValue array_val = {0};
if (eval_expr(ef, array_node, &array_val)) return true;
assert(elem_node->type == NodeTypeSymbol);
Buf *elem_var_name = &elem_node->data.symbol_expr.symbol;
Buf *index_var_name = nullptr;
if (index_node) {
assert(index_node->type == NodeTypeSymbol);
index_var_name = &index_node->data.symbol_expr.symbol;
}
uint64_t it_index = 0;
uint64_t array_len;
ConstExprValue **array_ptr_val;
if (array_type->id == TypeTableEntryIdArray) {
array_len = array_type->data.array.len;
array_ptr_val = array_val.data.x_array.fields;
} else if (array_type->id == TypeTableEntryIdStruct) {
ConstExprValue *len_field_val = array_val.data.x_struct.fields[1];
array_len = len_field_val->data.x_bignum.data.x_uint;
array_ptr_val = array_val.data.x_struct.fields[0]->data.x_ptr.ptr;
} else {
zig_unreachable();
}
EvalScope *my_scope = allocate<EvalScope>(1);
my_scope->block_context = body_node->block_context;
ef->scope_stack.append(my_scope);
for (; it_index < array_len; it_index += 1) {
my_scope->vars.resize(0);
if (index_var_name) {
my_scope->vars.add_one();
EvalVar *index_var = &my_scope->vars.last();
index_var->name = index_var_name;
memset(&index_var->value, 0, sizeof(ConstExprValue));
index_var->value.ok = true;
bignum_init_unsigned(&index_var->value.data.x_bignum, it_index);
}
{
my_scope->vars.add_one();
EvalVar *elem_var = &my_scope->vars.last();
elem_var->name = elem_var_name;
elem_var->value = *array_ptr_val[it_index];
}
ConstExprValue body_val = {0};
if (eval_expr(ef, body_node, &body_val)) return true;
ef->root->branches_used += 1;
}
ef->scope_stack.pop();
return false;
}
static bool eval_array_access_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeArrayAccessExpr);
AstNode *array_ref_node = node->data.array_access_expr.array_ref_expr;
AstNode *index_node = node->data.array_access_expr.subscript;
TypeTableEntry *array_type = get_resolved_expr(array_ref_node)->type_entry;
ConstExprValue array_val = {0};
if (eval_expr(ef, array_ref_node, &array_val)) return true;
ConstExprValue index_val = {0};
if (eval_expr(ef, index_node, &index_val)) return true;
uint64_t index_int = index_val.data.x_bignum.data.x_uint;
if (array_type->id == TypeTableEntryIdPointer) {
if (index_int >= array_val.data.x_ptr.len) {
zig_panic("TODO");
}
*out_val = *array_val.data.x_ptr.ptr[index_int];
} else if (array_type->id == TypeTableEntryIdStruct) {
assert(array_type->data.structure.is_unknown_size_array);
ConstExprValue *len_value = array_val.data.x_struct.fields[1];
uint64_t len_int = len_value->data.x_bignum.data.x_uint;
if (index_int >= len_int) {
zig_panic("TODO");
}
ConstExprValue *ptr_value = array_val.data.x_struct.fields[0];
*out_val = *ptr_value->data.x_ptr.ptr[index_int];
} else if (array_type->id == TypeTableEntryIdArray) {
uint64_t array_len = array_type->data.array.len;
if (index_int >= array_len) {
zig_panic("TODO");
}
*out_val = *array_val.data.x_array.fields[index_int];
} else {
zig_unreachable();
}
return false;
}
static bool eval_bool_literal_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeBoolLiteral);
out_val->ok = true;
out_val->data.x_bool = node->data.bool_literal.value;
return false;
}
static bool eval_prefix_op_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypePrefixOpExpr);
PrefixOp prefix_op = node->data.prefix_op_expr.prefix_op;
AstNode *expr_node = node->data.prefix_op_expr.primary_expr;
ConstExprValue expr_val = {0};
if (eval_expr(ef, expr_node, &expr_val)) return true;
TypeTableEntry *expr_type = get_resolved_expr(expr_node)->type_entry;
switch (prefix_op) {
case PrefixOpBoolNot:
*out_val = expr_val;
out_val->data.x_bool = !out_val->data.x_bool;
break;
case PrefixOpDereference:
assert(expr_type->id == TypeTableEntryIdPointer);
*out_val = *expr_val.data.x_ptr.ptr[0];
break;
case PrefixOpAddressOf:
case PrefixOpConstAddressOf:
{
ConstExprValue *child_val = allocate<ConstExprValue>(1);
*child_val = expr_val;
ConstExprValue **ptr_val = allocate<ConstExprValue*>(1);
*ptr_val = child_val;
out_val->data.x_ptr.ptr = ptr_val;
out_val->data.x_ptr.len = 1;
out_val->ok = true;
break;
}
case PrefixOpBinNot:
case PrefixOpNegation:
case PrefixOpMaybe:
case PrefixOpError:
case PrefixOpUnwrapError:
case PrefixOpUnwrapMaybe:
zig_panic("TODO");
case PrefixOpInvalid:
zig_unreachable();
}
return false;
}
static bool eval_var_decl_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeVariableDeclaration);
assert(node->data.variable_declaration.expr);
EvalScope *my_scope = ef->scope_stack.at(ef->scope_stack.length - 1);
my_scope->vars.add_one();
EvalVar *var = &my_scope->vars.last();
var->name = &node->data.variable_declaration.symbol;
if (eval_expr(ef, node->data.variable_declaration.expr, &var->value)) return true;
out_val->ok = true;
return false;
}
static bool eval_number_literal_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeNumberLiteral);
assert(!node->data.number_literal.overflow);
out_val->ok = true;
if (node->data.number_literal.kind == NumLitUInt) {
bignum_init_unsigned(&out_val->data.x_bignum, node->data.number_literal.data.x_uint);
} else if (node->data.number_literal.kind == NumLitFloat) {
bignum_init_float(&out_val->data.x_bignum, node->data.number_literal.data.x_float);
} else {
zig_unreachable();
}
return false;
}
static bool eval_char_literal_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeCharLiteral);
out_val->ok = true;
bignum_init_unsigned(&out_val->data.x_bignum, node->data.char_literal.value);
return false;
}
static bool eval_while_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val) {
assert(node->type == NodeTypeWhileExpr);
AstNode *cond_node = node->data.while_expr.condition;
AstNode *body_node = node->data.while_expr.body;
EvalScope *my_scope = allocate<EvalScope>(1);
my_scope->block_context = body_node->block_context;
ef->scope_stack.append(my_scope);
for (;;) {
my_scope->vars.resize(0);
ConstExprValue cond_val = {0};
if (eval_expr(ef, cond_node, &cond_val)) return true;
if (!cond_val.data.x_bool) break;
ConstExprValue body_val = {0};
if (eval_expr(ef, body_node, &body_val)) return true;
ef->root->branches_used += 1;
}
ef->scope_stack.pop();
return false;
}
static bool eval_expr(EvalFn *ef, AstNode *node, ConstExprValue *out) {
if (ef->root->branches_used > ef->root->branch_quota) {
ef->root->exceeded_quota_node = node;
return true;
}
ConstExprValue *const_val = &get_resolved_expr(node)->const_val;
if (const_val->ok) {
*out = *const_val;
return false;
}
switch (node->type) {
case NodeTypeBlock:
return eval_block(ef, node, out);
case NodeTypeReturnExpr:
return eval_return(ef, node, out);
case NodeTypeBinOpExpr:
return eval_bin_op_expr(ef, node, out);
case NodeTypeSymbol:
return eval_symbol_expr(ef, node, out);
case NodeTypeContainerInitExpr:
return eval_container_init_expr(ef, node, out);
case NodeTypeIfBoolExpr:
return eval_if_bool_expr(ef, node, out);
case NodeTypeFnCallExpr:
return eval_fn_call_expr(ef, node, out);
case NodeTypeFieldAccessExpr:
return eval_field_access_expr(ef, node, out);
case NodeTypeForExpr:
return eval_for_expr(ef, node, out);
case NodeTypeArrayAccessExpr:
return eval_array_access_expr(ef, node, out);
case NodeTypeBoolLiteral:
return eval_bool_literal_expr(ef, node, out);
case NodeTypePrefixOpExpr:
return eval_prefix_op_expr(ef, node, out);
case NodeTypeVariableDeclaration:
return eval_var_decl_expr(ef, node, out);
case NodeTypeNumberLiteral:
return eval_number_literal_expr(ef, node, out);
case NodeTypeCharLiteral:
return eval_char_literal_expr(ef, node, out);
case NodeTypeWhileExpr:
return eval_while_expr(ef, node, out);
case NodeTypeDefer:
case NodeTypeErrorValueDecl:
case NodeTypeUnwrapErrorExpr:
case NodeTypeStringLiteral:
case NodeTypeSliceExpr:
case NodeTypeNullLiteral:
case NodeTypeUndefinedLiteral:
case NodeTypeIfVarExpr:
case NodeTypeSwitchExpr:
case NodeTypeSwitchProng:
case NodeTypeSwitchRange:
case NodeTypeLabel:
case NodeTypeGoto:
case NodeTypeBreak:
case NodeTypeContinue:
case NodeTypeStructDecl:
case NodeTypeStructField:
case NodeTypeStructValueField:
case NodeTypeArrayType:
case NodeTypeErrorType:
case NodeTypeTypeLiteral:
zig_panic("TODO");
case NodeTypeRoot:
case NodeTypeFnProto:
case NodeTypeFnDef:
case NodeTypeFnDecl:
case NodeTypeUse:
case NodeTypeAsmExpr:
case NodeTypeParamDecl:
case NodeTypeDirective:
case NodeTypeTypeDecl:
zig_unreachable();
}
}
static bool eval_fn_args(EvalFnRoot *efr, FnTableEntry *fn, ConstExprValue *args, ConstExprValue *out_val) {
EvalFn ef = {0};
ef.root = efr;
ef.fn = fn;
ef.return_expr = out_val;
EvalScope *root_scope = allocate<EvalScope>(1);
root_scope->block_context = fn->fn_def_node->data.fn_def.body->block_context;
ef.scope_stack.append(root_scope);
int param_count = fn->type_entry->data.fn.fn_type_id.param_count;
for (int i = 0; i < param_count; i += 1) {
AstNode *decl_param_node = fn->proto_node->data.fn_proto.params.at(i);
assert(decl_param_node->type == NodeTypeParamDecl);
ConstExprValue *src_const_val = &args[i];
assert(src_const_val->ok);
root_scope->vars.add_one();
EvalVar *eval_var = &root_scope->vars.last();
eval_var->name = &decl_param_node->data.param_decl.name;
eval_var->value = *src_const_val;
}
return eval_expr(&ef, fn->fn_def_node->data.fn_def.body, out_val);
}
bool eval_fn(CodeGen *g, AstNode *node, FnTableEntry *fn, ConstExprValue *out_val,
int branch_quota, AstNode *struct_node)
{
assert(node->type == NodeTypeFnCallExpr);
EvalFnRoot efr = {0};
efr.codegen = g;
efr.fn = fn;
efr.call_node = node;
efr.branch_quota = branch_quota;
int call_param_count = node->data.fn_call_expr.params.length;
int type_param_count = fn->type_entry->data.fn.fn_type_id.param_count;
ConstExprValue *args = allocate<ConstExprValue>(type_param_count);
int next_arg_index = 0;
if (struct_node) {
ConstExprValue *struct_val = &get_resolved_expr(struct_node)->const_val;
assert(struct_val->ok);
args[next_arg_index] = *struct_val;
next_arg_index += 1;
}
for (int call_index = 0; call_index < call_param_count; call_index += 1) {
AstNode *call_param_node = node->data.fn_call_expr.params.at(call_index);
ConstExprValue *src_const_val = &get_resolved_expr(call_param_node)->const_val;
assert(src_const_val->ok);
args[next_arg_index] = *src_const_val;
next_arg_index += 1;
}
eval_fn_args(&efr, fn, args, out_val);
if (efr.exceeded_quota_node) {
ErrorMsg *msg = add_node_error(g, fn->fn_def_node,
buf_sprintf("function evaluation exceeded %d branches", efr.branch_quota));
add_error_note(g, msg, efr.call_node, buf_sprintf("called from here"));
add_error_note(g, msg, efr.exceeded_quota_node, buf_sprintf("quota exceeded here"));
return true;
}
if (efr.abort) {
return true;
}
assert(out_val->ok);
return false;
}
Reference in New Issue View Git Blame Copy Permalink