Ekdohibs
/
zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

analyze if maybe var expressions

master
Andrew Kelley 2015-12-26 15:43:40 -07:00
parent 1f8e3871ee
commit 7ba99e9715
3 changed files with 61 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
example/guess_number/main.zig
View File

@ -12,7 +12,7 @@ fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
const answer = rand_int(&rand_state, 0, 100) + 1;
while true {
line = readline("\nGuess a number between 1 and 100: ");
const line = readline("\nGuess a number between 1 and 100: ");
if const guess ?= parse_number(line) {
if (guess > answer) {

76
src/analyze.cpp
View File

@ -661,6 +661,8 @@ static bool num_lit_fits_in_other_type(CodeGen *g, TypeTableEntry *literal_type,
} else {
return false;
}
case TypeTableEntryIdMaybe:
return num_lit_fits_in_other_type(g, literal_type, other_type->data.maybe.child_type);
}
zig_unreachable();
}
@ -1220,11 +1222,11 @@ static TypeTableEntry *analyze_bin_op_expr(CodeGen *g, ImportTableEntry *import,
zig_unreachable();
}
static VariableTableEntry *analyze_variable_declaration(CodeGen *g, ImportTableEntry *import,
BlockContext *context, TypeTableEntry *expected_type, AstNode *node)
static VariableTableEntry *analyze_variable_declaration_raw(CodeGen *g, ImportTableEntry *import,
BlockContext *context, AstNode *source_node,
AstNodeVariableDeclaration *variable_declaration,
bool expr_is_maybe)
{
AstNodeVariableDeclaration *variable_declaration = &node->data.variable_declaration;
TypeTableEntry *explicit_type = nullptr;
if (variable_declaration->type != nullptr) {
explicit_type = resolve_type(g, variable_declaration->type);
@ -1238,19 +1240,28 @@ static VariableTableEntry *analyze_variable_declaration(CodeGen *g, ImportTableE
TypeTableEntry *implicit_type = nullptr;
if (variable_declaration->expr != nullptr) {
implicit_type = analyze_expression(g, import, context, explicit_type, variable_declaration->expr);
if (implicit_type->id == TypeTableEntryIdUnreachable) {
add_node_error(g, node,
if (implicit_type->id == TypeTableEntryIdInvalid) {
// ignore the poison value
} else if (expr_is_maybe) {
if (implicit_type->id == TypeTableEntryIdMaybe) {
implicit_type = implicit_type->data.maybe.child_type;
} else {
add_node_error(g, source_node, buf_sprintf("expected maybe type"));
implicit_type = g->builtin_types.entry_invalid;
}
} else if (implicit_type->id == TypeTableEntryIdUnreachable) {
add_node_error(g, source_node,
buf_sprintf("variable initialization is unreachable"));
implicit_type = g->builtin_types.entry_invalid;
} else if (implicit_type->id == TypeTableEntryIdNumberLiteral) {
add_node_error(g, node,
add_node_error(g, source_node,
buf_sprintf("unable to infer variable type"));
implicit_type = g->builtin_types.entry_invalid;
}
}
if (implicit_type == nullptr && variable_declaration->is_const) {
add_node_error(g, node, buf_sprintf("variables must have initial values or be declared 'mut'."));
add_node_error(g, source_node, buf_sprintf("variables must have initial values or be declared 'mut'."));
implicit_type = g->builtin_types.entry_invalid;
}
@ -1259,7 +1270,7 @@ static VariableTableEntry *analyze_variable_declaration(CodeGen *g, ImportTableE
VariableTableEntry *existing_variable = find_local_variable(context, &variable_declaration->symbol);
if (existing_variable) {
add_node_error(g, node,
add_node_error(g, source_node,
buf_sprintf("redeclaration of variable '%s'", buf_ptr(&variable_declaration->symbol)));
} else {
VariableTableEntry *variable_entry = allocate<VariableTableEntry>(1);
@ -1267,13 +1278,20 @@ static VariableTableEntry *analyze_variable_declaration(CodeGen *g, ImportTableE
variable_entry->type = type;
variable_entry->is_const = variable_declaration->is_const;
variable_entry->is_ptr = true;
variable_entry->decl_node = node;
variable_entry->decl_node = source_node;
context->variable_table.put(&variable_entry->name, variable_entry);
return variable_entry;
}
return nullptr;
}
static VariableTableEntry *analyze_variable_declaration(CodeGen *g, ImportTableEntry *import,
BlockContext *context, TypeTableEntry *expected_type, AstNode *node)
{
AstNodeVariableDeclaration *variable_declaration = &node->data.variable_declaration;
return analyze_variable_declaration_raw(g, import, context, node, variable_declaration, false);
}
static TypeTableEntry *analyze_number_literal_expr(CodeGen *g, ImportTableEntry *import,
BlockContext *block_context, TypeTableEntry *expected_type, AstNode *node)
{
@ -1397,37 +1415,51 @@ static TypeTableEntry *analyze_continue_expr(CodeGen *g, ImportTableEntry *impor
return g->builtin_types.entry_unreachable;
}
static TypeTableEntry *analyze_if_bool_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
TypeTableEntry *expected_type, AstNode *node)
static TypeTableEntry *analyze_if_then_else(CodeGen *g, ImportTableEntry *import, BlockContext *context,
TypeTableEntry *expected_type, AstNode *then_block, AstNode *else_node, AstNode *parent_node)
{
analyze_expression(g, import, context, g->builtin_types.entry_bool, node->data.if_bool_expr.condition);
TypeTableEntry *then_type = analyze_expression(g, import, context, expected_type,
node->data.if_bool_expr.then_block);
TypeTableEntry *then_type = analyze_expression(g, import, context, expected_type, then_block);
TypeTableEntry *else_type;
if (node->data.if_bool_expr.else_node) {
else_type = analyze_expression(g, import, context, expected_type, node->data.if_bool_expr.else_node);
if (else_node) {
else_type = analyze_expression(g, import, context, expected_type, else_node);
} else {
else_type = g->builtin_types.entry_void;
else_type = resolve_type_compatibility(g, context, node, expected_type, else_type);
else_type = resolve_type_compatibility(g, context, parent_node, expected_type, else_type);
}
if (expected_type) {
return (then_type->id == TypeTableEntryIdUnreachable) ? else_type : then_type;
} else {
return resolve_peer_type_compatibility(g, context, node,
node->data.if_bool_expr.then_block, node->data.if_bool_expr.else_node,
return resolve_peer_type_compatibility(g, context, parent_node,
then_block, else_node,
then_type, else_type);
}
}
static TypeTableEntry *analyze_if_bool_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
TypeTableEntry *expected_type, AstNode *node)
{
analyze_expression(g, import, context, g->builtin_types.entry_bool, node->data.if_bool_expr.condition);
return analyze_if_then_else(g, import, context, expected_type,
node->data.if_bool_expr.then_block,
node->data.if_bool_expr.else_node,
node);
}
static TypeTableEntry *analyze_if_var_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
TypeTableEntry *expected_type, AstNode *node)
{
assert(node->type == NodeTypeIfVarExpr);
zig_panic("TODO analyze_if_var_expr");
BlockContext *child_context = new_block_context(node, context);
analyze_variable_declaration_raw(g, import, child_context, node, &node->data.if_var_expr.var_decl, true);
return analyze_if_then_else(g, import, child_context, expected_type,
node->data.if_var_expr.then_block, node->data.if_var_expr.else_node, node);
}
static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import, BlockContext *context,

6
src/analyze.hpp
View File

@ -55,6 +55,10 @@ struct TypeTableEntryNumLit {
NumLit kind;
};
struct TypeTableEntryMaybe {
TypeTableEntry *child_type;
};
enum TypeTableEntryId {
TypeTableEntryIdInvalid,
TypeTableEntryIdVoid,
@ -66,6 +70,7 @@ enum TypeTableEntryId {
TypeTableEntryIdArray,
TypeTableEntryIdStruct,
TypeTableEntryIdNumberLiteral,
TypeTableEntryIdMaybe,
};
struct TypeTableEntry {
@ -84,6 +89,7 @@ struct TypeTableEntry {
TypeTableEntryArray array;
TypeTableEntryStruct structure;
TypeTableEntryNumLit num_lit;
TypeTableEntryMaybe maybe;
} data;
// use these fields to make sure we don't duplicate type table entries for the same type