mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-13 12:59:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/parser'

Browse Source
This commit is contained in:
Andrew Kelley 2017-04-13 03:09:09 -04:00
commit f2140efc52
6 changed files with 97 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/all_types.hpp
View File

@ -401,10 +401,8 @@ struct AstNodeParamDecl {
};
struct AstNodeBlock {
// the final statement is the returned expression.
// if there are no statements, the returned expression is void.
// the final statement is never a label.
ZigList<AstNode *> statements;
bool last_statement_is_result_expression;
};
enum ReturnKind {

17
src/analyze.cpp
View File

@ -2950,23 +2950,6 @@ void semantic_analyze(CodeGen *g) {
}
}
bool is_node_void_expr(AstNode *node) {
if (node->type == NodeTypeContainerInitExpr &&
node->data.container_init_expr.kind == ContainerInitKindArray)
{
AstNode *type_node = node->data.container_init_expr.type;
if (type_node->type == NodeTypeSymbol &&
buf_eql_str(type_node->data.symbol_expr.symbol, "void"))
{
return true;
}
} else if (node->type == NodeTypeBlock && node->data.block.statements.length == 0) {
return true;
}
return false;
}
TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, uint32_t size_in_bits) {
size_t index;
if (size_in_bits == 8) {

1
src/analyze.hpp
View File

@ -17,7 +17,6 @@ TypeTableEntry *new_type_table_entry(TypeTableEntryId id);
TypeTableEntry *get_pointer_to_type(CodeGen *g, TypeTableEntry *child_type, bool is_const);
TypeTableEntry *get_pointer_to_type_extra(CodeGen *g, TypeTableEntry *child_type, bool is_const,
bool is_volatile, uint32_t bit_offset, uint32_t unaligned_bit_count);
bool is_node_void_expr(AstNode *node);
uint64_t type_size(CodeGen *g, TypeTableEntry *type_entry);
uint64_t type_size_bits(CodeGen *g, TypeTableEntry *type_entry);
TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, uint32_t size_in_bits);

4
src/ast_render.cpp
View File

@ -459,8 +459,10 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
}
print_indent(ar);
render_node_grouped(ar, statement);
if (i != node->data.block.statements.length - 1)
if (!(i == node->data.block.statements.length - 1 &&
node->data.block.last_statement_is_result_expression)) {
fprintf(ar->f, ";");
}
fprintf(ar->f, "\n");
}
ar->indent -= ar->indent_size;

53
src/ir.cpp
View File

@ -3344,6 +3344,7 @@ static IrInstruction *ir_gen_block(IrBuilder *irb, Scope *parent_scope, AstNode
return ir_mark_gen(ir_build_const_void(irb, child_scope, block_node));
}
bool is_continuation_unreachable = false;
IrInstruction *return_value = nullptr;
for (size_t i = 0; i < block_node->data.block.statements.length; i += 1) {
AstNode *statement_node = block_node->data.block.statements.at(i);
@ -3367,7 +3368,7 @@ static IrInstruction *ir_gen_block(IrBuilder *irb, Scope *parent_scope, AstNode
scope_block->label_table.put(label_name, label);
}
if (!(return_value && instr_is_unreachable(return_value))) {
if (!is_continuation_unreachable) {
// fall through into new labeled basic block
IrInstruction *is_comptime = ir_mark_gen(ir_build_const_bool(irb, child_scope, statement_node,
ir_should_inline(irb->exec, child_scope)));
@ -3375,34 +3376,66 @@ static IrInstruction *ir_gen_block(IrBuilder *irb, Scope *parent_scope, AstNode
}
ir_set_cursor_at_end(irb, label_block);
// a label is an entry point
is_continuation_unreachable = false;
return_value = nullptr;
continue;
}
if (return_value && instr_is_unreachable(return_value)) {
if (is_node_void_expr(statement_node))
if (is_continuation_unreachable) {
// if you put a semicolon after a return statement,
// then we get a void statement in the unreachable area.
// this is fine. ignore any void blocks we get from this happening.
if (statement_node->type == NodeTypeBlock && statement_node->data.block.statements.length == 0)
continue;
add_node_error(irb->codegen, statement_node, buf_sprintf("unreachable code"));
}
return_value = ir_gen_node(irb, statement_node, child_scope);
if (statement_node->type == NodeTypeDefer && return_value != irb->codegen->invalid_instruction) {
IrInstruction *statement_value = ir_gen_node(irb, statement_node, child_scope);
is_continuation_unreachable = instr_is_unreachable(statement_value);
if (is_continuation_unreachable)
return_value = statement_value;
else
return_value = nullptr;
if (statement_node->type == NodeTypeDefer && statement_value != irb->codegen->invalid_instruction) {
// defer starts a new scope
child_scope = statement_node->data.defer.child_scope;
assert(child_scope);
} else if (return_value->id == IrInstructionIdDeclVar) {
} else if (statement_value->id == IrInstructionIdDeclVar) {
// variable declarations start a new scope
IrInstructionDeclVar *decl_var_instruction = (IrInstructionDeclVar *)return_value;
IrInstructionDeclVar *decl_var_instruction = (IrInstructionDeclVar *)statement_value;
child_scope = decl_var_instruction->var->child_scope;
} else {
// label, defer, variable declaration will never be the last statement
if (block_node->data.block.last_statement_is_result_expression &&
i == block_node->data.block.statements.length - 1) {
// this is the result value statement
return_value = statement_value;
} else {
// there are more statements ahead of this one. this statement's value must be void
TypeTableEntry *instruction_type = statement_value->value.type;
if (instruction_type &&
instruction_type->id != TypeTableEntryIdInvalid &&
instruction_type->id != TypeTableEntryIdVoid &&
instruction_type->id != TypeTableEntryIdUnreachable) {
add_node_error(irb->codegen, statement_node, buf_sprintf("expression valued ignored"));
}
}
}
}
// labels are never the last statement
assert(return_value != nullptr);
if (!is_continuation_unreachable) {
// control flow falls out of block
if (!block_node->data.block.last_statement_is_result_expression) {
assert(return_value == nullptr);
return_value = ir_mark_gen(ir_build_const_void(irb, child_scope, block_node));
}
if (!instr_is_unreachable(return_value))
ir_gen_defers_for_block(irb, child_scope, outer_block_scope, false, false);
}
assert(return_value != nullptr);
return return_value;
}

124
src/parser.cpp
View File

@ -1878,36 +1878,6 @@ static AstNode *ast_parse_switch_expr(ParseContext *pc, size_t *token_index, boo
}
}
static bool statement_has_block_body(AstNode *node) {
switch (node->type) {
case NodeTypeIfBoolExpr:
if (node->data.if_bool_expr.else_node)
return statement_has_block_body(node->data.if_bool_expr.else_node);
return node->data.if_bool_expr.then_block->type == NodeTypeBlock;
case NodeTypeIfVarExpr:
if (node->data.if_var_expr.else_node)
return statement_has_block_body(node->data.if_var_expr.else_node);
return node->data.if_var_expr.then_block->type == NodeTypeBlock;
case NodeTypeTryExpr:
if (node->data.try_expr.else_node)
return statement_has_block_body(node->data.try_expr.else_node);
return node->data.try_expr.then_node->type == NodeTypeBlock;
case NodeTypeWhileExpr:
return node->data.while_expr.body->type == NodeTypeBlock;
case NodeTypeForExpr:
return node->data.for_expr.body->type == NodeTypeBlock;
case NodeTypeSwitchExpr:
case NodeTypeBlock:
return true;
case NodeTypeCompTime:
return node->data.comptime_expr.expr->type == NodeTypeBlock;
case NodeTypeDefer:
return node->data.defer.expr->type == NodeTypeBlock;
default:
return false;
}
}
/*
BlockExpression(body) = Block | IfExpression(body) | TryExpression(body) | WhileExpression(body) | ForExpression(body) | SwitchExpression | CompTimeExpression(body)
*/
@ -2120,9 +2090,35 @@ static AstNode *ast_parse_label(ParseContext *pc, size_t *token_index, bool mand
return node;
}
static AstNode *ast_create_void_expr(ParseContext *pc, Token *token) {
AstNode *node = ast_create_node(pc, NodeTypeBlock, token);
return node;
static bool statement_terminates_without_semicolon(AstNode *node) {
switch (node->type) {
case NodeTypeIfBoolExpr:
if (node->data.if_bool_expr.else_node)
return statement_terminates_without_semicolon(node->data.if_bool_expr.else_node);
return node->data.if_bool_expr.then_block->type == NodeTypeBlock;
case NodeTypeIfVarExpr:
if (node->data.if_var_expr.else_node)
return statement_terminates_without_semicolon(node->data.if_var_expr.else_node);
return node->data.if_var_expr.then_block->type == NodeTypeBlock;
case NodeTypeTryExpr:
if (node->data.try_expr.else_node)
return statement_terminates_without_semicolon(node->data.try_expr.else_node);
return node->data.try_expr.then_node->type == NodeTypeBlock;
case NodeTypeWhileExpr:
return node->data.while_expr.body->type == NodeTypeBlock;
case NodeTypeForExpr:
return node->data.for_expr.body->type == NodeTypeBlock;
case NodeTypeCompTime:
return node->data.comptime_expr.expr->type == NodeTypeBlock;
case NodeTypeDefer:
return node->data.defer.expr->type == NodeTypeBlock;
case NodeTypeSwitchExpr:
case NodeTypeBlock:
case NodeTypeLabel:
return true;
default:
return false;
}
}
/*
@ -2145,56 +2141,36 @@ static AstNode *ast_parse_block(ParseContext *pc, size_t *token_index, bool mand
for (;;) {
AstNode *statement_node = ast_parse_label(pc, token_index, false);
bool need_implicit_final_void_statement = false;
if (!statement_node)
statement_node = ast_parse_variable_declaration_expr(pc, token_index, false, VisibModPrivate);
if (!statement_node)
statement_node = ast_parse_defer_expr(pc, token_index);
if (!statement_node)
statement_node = ast_parse_block_expr(pc, token_index, false);
if (!statement_node)
statement_node = ast_parse_expression(pc, token_index, false);
bool semicolon_expected = true;
if (statement_node) {
// label
semicolon_expected = false;
// if a label is the last thing in a block, add a void statement.
need_implicit_final_void_statement = true;
} else {
statement_node = ast_parse_variable_declaration_expr(pc, token_index, false, VisibModPrivate);
if (!statement_node) {
statement_node = ast_parse_defer_expr(pc, token_index);
if (statement_node) {
// defer
if (statement_has_block_body(statement_node)) {
// don't let defer be the last statement in a block
need_implicit_final_void_statement = true;
semicolon_expected = false;
} else {
// defer without a block body requires a semicolon
Token *token = &pc->tokens->at(*token_index);
ast_expect_token(pc, token, TokenIdSemicolon);
}
} else {
statement_node = ast_parse_block_expr(pc, token_index, false);
if (statement_node) {
// block expr
if (statement_has_block_body(statement_node))
semicolon_expected = false;
} else {
statement_node = ast_parse_expression(pc, token_index, false);
if (!statement_node) {
// no statement.
// final semicolon means add a void statement.
need_implicit_final_void_statement = true;
}
}
node->data.block.statements.append(statement_node);
if (statement_terminates_without_semicolon(statement_node)) {
semicolon_expected = false;
} else {
if (statement_node->type == NodeTypeDefer) {
// defer without a block body requires a semicolon
Token *token = &pc->tokens->at(*token_index);
ast_expect_token(pc, token, TokenIdSemicolon);
}
}
}
if (statement_node)
node->data.block.statements.append(statement_node);
node->data.block.last_statement_is_result_expression = statement_node && !(
statement_node->type == NodeTypeLabel ||
statement_node->type == NodeTypeDefer);
last_token = &pc->tokens->at(*token_index);
if (last_token->id == TokenIdRBrace) {
*token_index += 1;
if (node->data.block.statements.length > 0 && need_implicit_final_void_statement) {
node->data.block.statements.append(ast_create_void_expr(pc, last_token));
}
return node;
} else if (!semicolon_expected) {
continue;