From 360b302941fd9df51132998e3e90cddd147e364b Mon Sep 17 00:00:00 2001 From: Brendan Hansen Date: Thu, 17 Jun 2021 14:27:28 -0500 Subject: [PATCH] renamed AstArrayAccess to AstSubscript --- bin/onyx | Bin 405672 -> 405672 bytes bin/test | 2 +- include/onyxastnodes.h | 8 ++-- src/onyxchecker.c | 84 ++++++++++++++++++++--------------------- src/onyxclone.c | 10 ++--- src/onyxparser.c | 14 +++---- src/onyxsymres.c | 6 +-- src/onyxwasm.c | 56 +++++++++++++-------------- 8 files changed, 89 insertions(+), 91 deletions(-) diff --git a/bin/onyx b/bin/onyx index 828b2c92d0befbc248fae0610d44eeb9480db2ef..3d3597925d285b05d50929b590419e2b92345e8e 100755 GIT binary patch delta 6470 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/dev/null; then printf "Using $(wasmer --version)\n" else - printf "Using $(node --verison)\n" + printf "Using node $(node -v)\n" fi failed=0 diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h index 85777886..eb9a399f 100644 --- a/include/onyxastnodes.h +++ b/include/onyxastnodes.h @@ -18,7 +18,7 @@ NODE(Argument) \ NODE(AddressOf) \ NODE(Dereference) \ - NODE(ArrayAccess) \ + NODE(Subscript) \ NODE(FieldAccess) \ NODE(UnaryFieldAccess) \ NODE(SizeOf) \ @@ -153,7 +153,7 @@ typedef enum AstKind { Ast_Kind_Return, Ast_Kind_Address_Of, Ast_Kind_Dereference, - Ast_Kind_Array_Access, + Ast_Kind_Subscript, Ast_Kind_Slice, Ast_Kind_Field_Access, Ast_Kind_Unary_Field_Access, @@ -516,7 +516,7 @@ struct AstAddressOf { AstTyped_base; AstTyped *expr; }; struct AstDereference { AstTyped_base; AstTyped *expr; }; struct AstSizeOf { AstTyped_base; AstType *so_ast_type; Type *so_type; u64 size; }; struct AstAlignOf { AstTyped_base; AstType *ao_ast_type; Type *ao_type; u64 alignment; }; -struct AstArrayAccess { +struct AstSubscript { AstTyped_base; BinaryOp __unused_operation; // This will be set to Binary_Op_Subscript AstTyped *addr; @@ -1273,7 +1273,7 @@ static inline b32 is_lval(AstNode* node) { || (node->kind == Ast_Kind_Param) || (node->kind == Ast_Kind_Global) || (node->kind == Ast_Kind_Dereference) - || (node->kind == Ast_Kind_Array_Access) + || (node->kind == Ast_Kind_Subscript) || (node->kind == Ast_Kind_Field_Access) || (node->kind == Ast_Kind_Memres)) return 1; diff --git a/src/onyxchecker.c b/src/onyxchecker.c index 9829b1d0..59b43914 100644 --- a/src/onyxchecker.c +++ b/src/onyxchecker.c @@ -38,7 +38,7 @@ CheckStatus check_compound(AstCompound* compound); CheckStatus check_expression(AstTyped** expr); CheckStatus check_address_of(AstAddressOf* aof); CheckStatus check_dereference(AstDereference* deref); -CheckStatus check_array_access(AstArrayAccess** paa); +CheckStatus check_subscript(AstSubscript** paa); CheckStatus check_field_access(AstFieldAccess** pfield); CheckStatus check_method_call(AstBinaryOp** mcall); CheckStatus check_size_of(AstSizeOf* so); @@ -1253,7 +1253,7 @@ CheckStatus check_compound(AstCompound* compound) { CheckStatus check_address_of(AstAddressOf* aof) { CHECK(expression, &aof->expr); - if ((aof->expr->kind != Ast_Kind_Array_Access + if ((aof->expr->kind != Ast_Kind_Subscript && aof->expr->kind != Ast_Kind_Dereference && aof->expr->kind != Ast_Kind_Field_Access && aof->expr->kind != Ast_Kind_Memres @@ -1288,88 +1288,88 @@ CheckStatus check_dereference(AstDereference* deref) { return Check_Success; } -CheckStatus check_array_access(AstArrayAccess** paa) { - AstArrayAccess* aa = *paa; - CHECK(expression, &aa->addr); - CHECK(expression, &aa->expr); +CheckStatus check_subscript(AstSubscript** psub) { + AstSubscript* sub = *psub; + CHECK(expression, &sub->addr); + CHECK(expression, &sub->expr); // NOTE: Try operator overloading before checking everything else. - if ((aa->addr->type != NULL && aa->expr->type != NULL) && - (aa->addr->type->kind != Type_Kind_Basic || aa->expr->type->kind != Type_Kind_Basic)) { - // AstArrayAccess is the same as AstBinaryOp for the first sizeof(AstBinaryOp) bytes - AstBinaryOp* binop = (AstBinaryOp *) aa; + if ((sub->addr->type != NULL && sub->expr->type != NULL) && + (sub->addr->type->kind != Type_Kind_Basic || sub->expr->type->kind != Type_Kind_Basic)) { + // AstSubscript is the same as AstBinaryOp for the first sizeof(AstBinaryOp) bytes + AstBinaryOp* binop = (AstBinaryOp *) sub; AstCall *implicit_call = binaryop_try_operator_overload(binop); if (implicit_call != NULL) { CHECK(call, implicit_call); // NOTE: Not an array access - *paa = (AstArrayAccess *) implicit_call; + *psub = (AstSubscript *) implicit_call; return Check_Success; } } - if (!type_is_array_accessible(aa->addr->type)) { - onyx_report_error(aa->token->pos, + if (!type_is_array_accessible(sub->addr->type)) { + onyx_report_error(sub->token->pos, "Expected pointer or array type for left of array access, got '%s'.", - node_get_type_name(aa->addr)); + node_get_type_name(sub->addr)); return Check_Error; } - if (types_are_compatible(aa->expr->type, builtin_range_type_type)) { + if (types_are_compatible(sub->expr->type, builtin_range_type_type)) { Type *of = NULL; - if (aa->addr->type->kind == Type_Kind_Pointer) - of = aa->addr->type->Pointer.elem; - else if (aa->addr->type->kind == Type_Kind_Array) - of = aa->addr->type->Array.elem; + if (sub->addr->type->kind == Type_Kind_Pointer) + of = sub->addr->type->Pointer.elem; + else if (sub->addr->type->kind == Type_Kind_Array) + of = sub->addr->type->Array.elem; else { // FIXME: Slice creation should be allowed for slice types and dynamic array types, like it // is below, but this code doesn't look at that. - onyx_report_error(aa->token->pos, "Invalid type for left of slice creation."); + onyx_report_error(sub->token->pos, "Invalid type for left of slice creation."); return Check_Error; } - aa->kind = Ast_Kind_Slice; - aa->type = type_make_slice(context.ast_alloc, of); - aa->elem_size = type_size_of(of); + sub->kind = Ast_Kind_Slice; + sub->type = type_make_slice(context.ast_alloc, of); + sub->elem_size = type_size_of(of); return Check_Success; } - resolve_expression_type(aa->expr); - if (aa->expr->type->kind != Type_Kind_Basic - || (aa->expr->type->Basic.kind != Basic_Kind_I32 && aa->expr->type->Basic.kind != Basic_Kind_U32)) { - onyx_report_error(aa->token->pos, + resolve_expression_type(sub->expr); + if (sub->expr->type->kind != Type_Kind_Basic + || (sub->expr->type->Basic.kind != Basic_Kind_I32 && sub->expr->type->Basic.kind != Basic_Kind_U32)) { + onyx_report_error(sub->token->pos, "Expected type u32 or i32 for index, got '%s'.", - node_get_type_name(aa->expr)); + node_get_type_name(sub->expr)); return Check_Error; } - if (aa->addr->type->kind == Type_Kind_Pointer) - aa->type = aa->addr->type->Pointer.elem; - else if (aa->addr->type->kind == Type_Kind_Array) - aa->type = aa->addr->type->Array.elem; - else if (aa->addr->type->kind == Type_Kind_Slice - || aa->addr->type->kind == Type_Kind_DynArray - || aa->addr->type->kind == Type_Kind_VarArgs) { + if (sub->addr->type->kind == Type_Kind_Pointer) + sub->type = sub->addr->type->Pointer.elem; + else if (sub->addr->type->kind == Type_Kind_Array) + sub->type = sub->addr->type->Array.elem; + else if (sub->addr->type->kind == Type_Kind_Slice + || sub->addr->type->kind == Type_Kind_DynArray + || sub->addr->type->kind == Type_Kind_VarArgs) { // If we are accessing on a slice or a dynamic array, implicitly add a field access for the data member StructMember smem; - type_lookup_member(aa->addr->type, "data", &smem); + type_lookup_member(sub->addr->type, "data", &smem); - AstFieldAccess* fa = make_field_access(context.ast_alloc, aa->addr, "data"); + AstFieldAccess* fa = make_field_access(context.ast_alloc, sub->addr, "data"); fa->type = smem.type; fa->offset = smem.offset; fa->idx = smem.idx; - aa->addr = (AstTyped *) fa; - aa->type = aa->addr->type->Pointer.elem; + sub->addr = (AstTyped *) fa; + sub->type = sub->addr->type->Pointer.elem; } else { - onyx_report_error(aa->token->pos, "Invalid type for left of array access."); + onyx_report_error(sub->token->pos, "Invalid type for left of array access."); return Check_Error; } - aa->elem_size = type_size_of(aa->type); + sub->elem_size = type_size_of(sub->type); return Check_Success; } @@ -1534,7 +1534,7 @@ CheckStatus check_expression(AstTyped** pexpr) { case Ast_Kind_Address_Of: retval = check_address_of((AstAddressOf *) expr); break; case Ast_Kind_Dereference: retval = check_dereference((AstDereference *) expr); break; case Ast_Kind_Slice: - case Ast_Kind_Array_Access: retval = check_array_access((AstArrayAccess **) pexpr); break; + case Ast_Kind_Subscript: retval = check_subscript((AstSubscript **) pexpr); break; case Ast_Kind_Field_Access: retval = check_field_access((AstFieldAccess **) pexpr); break; case Ast_Kind_Method_Call: retval = check_method_call((AstBinaryOp **) pexpr); break; case Ast_Kind_Size_Of: retval = check_size_of((AstSizeOf *) expr); break; diff --git a/src/onyxclone.c b/src/onyxclone.c index 4e5e3a9b..ca0e8133 100644 --- a/src/onyxclone.c +++ b/src/onyxclone.c @@ -68,8 +68,8 @@ static inline i32 ast_kind_to_size(AstNode* node) { case Ast_Kind_Return: return sizeof(AstReturn); case Ast_Kind_Address_Of: return sizeof(AstAddressOf); case Ast_Kind_Dereference: return sizeof(AstDereference); - case Ast_Kind_Array_Access: return sizeof(AstArrayAccess); - case Ast_Kind_Slice: return sizeof(AstArrayAccess); + case Ast_Kind_Subscript: return sizeof(AstSubscript); + case Ast_Kind_Slice: return sizeof(AstSubscript); case Ast_Kind_Field_Access: return sizeof(AstFieldAccess); case Ast_Kind_Pipe: return sizeof(AstBinaryOp); case Ast_Kind_Range_Literal: return sizeof(AstRangeLiteral); @@ -163,9 +163,9 @@ AstNode* ast_clone(bh_allocator a, void* n) { break; case Ast_Kind_Slice: - case Ast_Kind_Array_Access: - ((AstArrayAccess *) nn)->addr = (AstTyped *) ast_clone(a, ((AstArrayAccess *) node)->addr); - ((AstArrayAccess *) nn)->expr = (AstTyped *) ast_clone(a, ((AstArrayAccess *) node)->expr); + case Ast_Kind_Subscript: + ((AstSubscript *) nn)->addr = (AstTyped *) ast_clone(a, ((AstSubscript *) node)->addr); + ((AstSubscript *) nn)->expr = (AstTyped *) ast_clone(a, ((AstSubscript *) node)->expr); break; case Ast_Kind_Field_Access: diff --git a/src/onyxparser.c b/src/onyxparser.c index fd805896..08a5256f 100644 --- a/src/onyxparser.c +++ b/src/onyxparser.c @@ -610,15 +610,13 @@ static AstTyped* parse_factor(OnyxParser* parser) { OnyxToken *open_bracket = expect_token(parser, '['); AstTyped *expr = parse_compound_expression(parser, 0); - AstKind kind = Ast_Kind_Array_Access; + AstSubscript *sub_node = make_node(AstSubscript, Ast_Kind_Subscript); + sub_node->token = open_bracket; + sub_node->addr = retval; + sub_node->expr = expr; + sub_node->__unused_operation = Binary_Op_Subscript; - AstArrayAccess *aa_node = make_node(AstArrayAccess, kind); - aa_node->token = open_bracket; - aa_node->addr = retval; - aa_node->expr = expr; - aa_node->__unused_operation = Binary_Op_Subscript; - - retval = (AstTyped *) aa_node; + retval = (AstTyped *) sub_node; expect_token(parser, ']'); break; } diff --git a/src/onyxsymres.c b/src/onyxsymres.c index 9dbb838b..deb1bbfe 100644 --- a/src/onyxsymres.c +++ b/src/onyxsymres.c @@ -432,9 +432,9 @@ static SymresStatus symres_expression(AstTyped** expr) { break; case Ast_Kind_Slice: - case Ast_Kind_Array_Access: - SYMRES(expression, &((AstArrayAccess *)(*expr))->addr); - SYMRES(expression, &((AstArrayAccess *)(*expr))->expr); + case Ast_Kind_Subscript: + SYMRES(expression, &((AstSubscript *)(*expr))->addr); + SYMRES(expression, &((AstSubscript *)(*expr))->expr); break; case Ast_Kind_Struct_Literal: diff --git a/src/onyxwasm.c b/src/onyxwasm.c index 732f9f24..52640dff 100644 --- a/src/onyxwasm.c +++ b/src/onyxwasm.c @@ -240,7 +240,7 @@ EMIT_FUNC(binop, AstBinaryOp* binop); EMIT_FUNC(unaryop, AstUnaryOp* unop); EMIT_FUNC(call, AstCall* call); EMIT_FUNC(intrinsic_call, AstCall* call); -EMIT_FUNC(array_access_location, AstArrayAccess* aa, u64* offset_return); +EMIT_FUNC(subscript_location, AstSubscript* sub, u64* offset_return); EMIT_FUNC(field_access_location, AstFieldAccess* field, u64* offset_return); EMIT_FUNC(local_location, AstLocal* local, u64* offset_return); EMIT_FUNC(memory_reservation_location, AstMemRes* memres); @@ -1868,31 +1868,31 @@ EMIT_FUNC(intrinsic_call, AstCall* call) { *pcode = code; } -EMIT_FUNC(array_access_location, AstArrayAccess* aa, u64* offset_return) { +EMIT_FUNC(subscript_location, AstSubscript* sub, u64* offset_return) { bh_arr(WasmInstruction) code = *pcode; - emit_expression(mod, &code, aa->expr); - if (aa->elem_size != 1) { - WID(WI_PTR_CONST, aa->elem_size); + emit_expression(mod, &code, sub->expr); + if (sub->elem_size != 1) { + WID(WI_PTR_CONST, sub->elem_size); WI(WI_PTR_MUL); } // CLEANUP: This is one dense clusterf**k of code... u64 offset = 0; - if (aa->addr->kind == Ast_Kind_Array_Access - && aa->addr->type->kind == Type_Kind_Array) { - emit_array_access_location(mod, &code, (AstArrayAccess *) aa->addr, &offset); - } else if (aa->addr->kind == Ast_Kind_Field_Access - && aa->addr->type->kind == Type_Kind_Array) { - emit_field_access_location(mod, &code, (AstFieldAccess *) aa->addr, &offset); - } else if ((aa->addr->kind == Ast_Kind_Local || aa->addr->kind == Ast_Kind_Param) - && aa->addr->type->kind == Type_Kind_Array) { - emit_local_location(mod, &code, (AstLocal *) aa->addr, &offset); - } else if (aa->addr->kind == Ast_Kind_Memres - && aa->addr->type->kind != Type_Kind_Array) { - emit_memory_reservation_location(mod, &code, (AstMemRes *) aa->addr); + if (sub->addr->kind == Ast_Kind_Subscript + && sub->addr->type->kind == Type_Kind_Array) { + emit_subscript_location(mod, &code, (AstSubscript *) sub->addr, &offset); + } else if (sub->addr->kind == Ast_Kind_Field_Access + && sub->addr->type->kind == Type_Kind_Array) { + emit_field_access_location(mod, &code, (AstFieldAccess *) sub->addr, &offset); + } else if ((sub->addr->kind == Ast_Kind_Local || sub->addr->kind == Ast_Kind_Param) + && sub->addr->type->kind == Type_Kind_Array) { + emit_local_location(mod, &code, (AstLocal *) sub->addr, &offset); + } else if (sub->addr->kind == Ast_Kind_Memres + && sub->addr->type->kind != Type_Kind_Array) { + emit_memory_reservation_location(mod, &code, (AstMemRes *) sub->addr); } else { - emit_expression(mod, &code, aa->addr); + emit_expression(mod, &code, sub->addr); } WI(WI_PTR_ADD); @@ -1913,10 +1913,10 @@ EMIT_FUNC(field_access_location, AstFieldAccess* field, u64* offset_return) { source_expr = (AstTyped *) ((AstFieldAccess *) source_expr)->expr; } - if (source_expr->kind == Ast_Kind_Array_Access + if (source_expr->kind == Ast_Kind_Subscript && source_expr->type->kind != Type_Kind_Pointer) { u64 o2 = 0; - emit_array_access_location(mod, &code, (AstArrayAccess *) source_expr, &o2); + emit_subscript_location(mod, &code, (AstSubscript *) source_expr, &o2); offset += o2; } else if ((source_expr->kind == Ast_Kind_Local || source_expr->kind == Ast_Kind_Param) @@ -2140,9 +2140,9 @@ EMIT_FUNC(location_return_offset, AstTyped* expr, u64* offset_return) { break; } - case Ast_Kind_Array_Access: { - AstArrayAccess* aa = (AstArrayAccess *) expr; - emit_array_access_location(mod, &code, aa, offset_return); + case Ast_Kind_Subscript: { + AstSubscript* sub = (AstSubscript *) expr; + emit_subscript_location(mod, &code, sub, offset_return); break; } @@ -2317,11 +2317,11 @@ EMIT_FUNC(expression, AstTyped* expr) { break; } - case Ast_Kind_Array_Access: { - AstArrayAccess* aa = (AstArrayAccess *) expr; + case Ast_Kind_Subscript: { + AstSubscript* sub = (AstSubscript *) expr; u64 offset = 0; - emit_array_access_location(mod, &code, aa, &offset); - emit_load_instruction(mod, &code, aa->type, offset); + emit_subscript_location(mod, &code, sub, &offset); + emit_load_instruction(mod, &code, sub->type, offset); break; } @@ -2380,7 +2380,7 @@ EMIT_FUNC(expression, AstTyped* expr) { } case Ast_Kind_Slice: { - AstArrayAccess* sl = (AstArrayAccess *) expr; + AstSubscript* sl = (AstSubscript *) expr; emit_expression(mod, &code, sl->expr); -- 2.25.1