From 8a160dc7f2790bd007a940876ea72f63ca7c412c Mon Sep 17 00:00:00 2001 From: ValKmjolnir Date: Sun, 5 Nov 2023 00:10:26 +0800 Subject: [PATCH] :sparkles: use reinterpret_cast as pointer cast --- module/nasocket.cpp | 22 +++++++--- src/coroutine.cpp | 2 +- src/dylib_lib.cpp | 4 +- src/nasal_import.cpp | 6 +-- src/nasal_parse.cpp | 8 +++- src/optimizer.cpp | 102 +++++++++++++++++++++++++------------------ 6 files changed, 86 insertions(+), 58 deletions(-) diff --git a/module/nasocket.cpp b/module/nasocket.cpp index d44fc9b..7b692c6 100644 --- a/module/nasocket.cpp +++ b/module/nasocket.cpp @@ -71,7 +71,7 @@ var nas_bind(var* args, usize size, gc* ngc) { server.sin_port = htons(args[2].num()); return var::num(static_cast(bind( args[0].num(), - (sockaddr*)&server, + reinterpret_cast(&server), sizeof(server) ))); } @@ -110,9 +110,17 @@ var nas_accept(var* args, usize size, gc* ngc) { sockaddr_in client; int socklen = sizeof(sockaddr_in); #ifdef _WIN32 - int client_sd = accept(args[0].num(), (sockaddr*)&client, &socklen); + int client_sd = accept( + args[0].num(), + reinterpret_cast(&client), + &socklen + ); #else - int client_sd = accept(args[0].num(), (sockaddr*)&client, (socklen_t*)&socklen); + int client_sd = accept( + args[0].num(), + reinterpret_cast(&client), + reinterpret_cast(&socklen) + ); #endif var res = ngc->temp = ngc->alloc(vm_hash); auto& hash = res.hash().elems; @@ -159,7 +167,7 @@ var nas_sendto(var* args, usize size, gc* ngc) { args[3].str().c_str(), args[3].str().length(), args[4].num(), - (sockaddr*)&addr, + reinterpret_cast(&addr), sizeof(sockaddr_in) ))); } @@ -205,7 +213,7 @@ var nas_recvfrom(var* args, usize size, gc* ngc) { buf, args[1].num(), args[2].num(), - (sockaddr*)&addr, + reinterpret_cast(&addr), &socklen ); #else @@ -214,8 +222,8 @@ var nas_recvfrom(var* args, usize size, gc* ngc) { buf, args[1].num(), args[2].num(), - (sockaddr*)&addr, - (socklen_t*)&socklen + reinterpret_cast(&addr), + reinterpret_cast(&socklen) ); #endif hash["size"] = var::num(static_cast(recvsize)); diff --git a/src/coroutine.cpp b/src/coroutine.cpp index c0f5003..3aeed49 100644 --- a/src/coroutine.cpp +++ b/src/coroutine.cpp @@ -45,7 +45,7 @@ var builtin_cocreate(context* ctx, gc* ngc) { coroutine.ctx.top++; // store old localr on stack - coroutine.ctx.top[0] = var::addr((var*)nullptr); + coroutine.ctx.top[0] = var::addr(nullptr); coroutine.ctx.top++; // store old pc on stack diff --git a/src/dylib_lib.cpp b/src/dylib_lib.cpp index 494466d..a3402cc 100644 --- a/src/dylib_lib.cpp +++ b/src/dylib_lib.cpp @@ -53,9 +53,9 @@ var builtin_dlopen(context* ctx, gc* ngc) { // get "get" function, to get the register table #ifdef _WIN32 - void* register_table_get_function = (void*)GetProcAddress( + void* register_table_get_function = reinterpret_cast(GetProcAddress( static_cast(library_object.ghost().pointer), "get" - ); + )); #else void* register_table_get_function = dlsym( library_object.ghost().pointer, "get" diff --git a/src/nasal_import.cpp b/src/nasal_import.cpp index 874cc02..2904b82 100644 --- a/src/nasal_import.cpp +++ b/src/nasal_import.cpp @@ -113,11 +113,11 @@ bool linker::import_check(expr* node) { if (call_node->get_calls().size()!=1) { return false; } - - if (call_node->get_calls()[0]->get_type()!=expr_type::ast_callf) { + auto maybe_func_call = call_node->get_calls()[0]; + if (maybe_func_call->get_type()!=expr_type::ast_callf) { return false; } - auto func_call = (call_function*)call_node->get_calls()[0]; + auto func_call = reinterpret_cast(maybe_func_call); if (func_call->get_argument().size()!=1) { return false; } diff --git a/src/nasal_parse.cpp b/src/nasal_parse.cpp index 60d4dbc..e62ff28 100644 --- a/src/nasal_parse.cpp +++ b/src/nasal_parse.cpp @@ -132,9 +132,13 @@ bool parse::check_func_end(expr* node) { if (type==expr_type::ast_func) { return true; } else if (type==expr_type::ast_def) { - return check_func_end(((definition_expr*)node)->get_value()); + return check_func_end( + reinterpret_cast(node)->get_value() + ); } else if (type==expr_type::ast_assign) { - return check_func_end(((assignment_expr*)node)->get_right()); + return check_func_end( + reinterpret_cast(node)->get_right() + ); } return false; } diff --git a/src/optimizer.cpp b/src/optimizer.cpp index 25bd769..357f0f5 100644 --- a/src/optimizer.cpp +++ b/src/optimizer.cpp @@ -12,7 +12,8 @@ void optimizer::const_string( const auto& left = left_node->get_content(); const auto& right = right_node->get_content(); node->set_optimized_string( - new string_literal(node->get_location(), left+right)); + new string_literal(node->get_location(), left+right) + ); } void optimizer::const_number( @@ -43,7 +44,8 @@ void optimizer::const_number( return; } node->set_optimized_number( - new number_literal(node->get_location(), res)); + new number_literal(node->get_location(), res) + ); } void optimizer::const_number( @@ -62,46 +64,56 @@ void optimizer::const_number( return; } node->set_optimized_number( - new number_literal(node->get_location(), res)); + new number_literal(node->get_location(), res) + ); } bool optimizer::visit_binary_operator(binary_operator* node) { - node->get_left()->accept(this); - node->get_right()->accept(this); + auto left_node = node->get_left(); + auto right_node = node->get_right(); + left_node->accept(this); + right_node->accept(this); + number_literal* left_num_node = nullptr; number_literal* right_num_node = nullptr; string_literal* left_str_node = nullptr; string_literal* right_str_node = nullptr; - if (node->get_left()->get_type()==expr_type::ast_num) { - left_num_node = (number_literal*)node->get_left(); - } else if (node->get_left()->get_type()==expr_type::ast_binary && - ((binary_operator*)node->get_left())->get_optimized_number()) { - left_num_node = ((binary_operator*)node->get_left())->get_optimized_number(); - } else if (node->get_left()->get_type()==expr_type::ast_unary && - ((unary_operator*)node->get_left())->get_optimized_number()) { - left_num_node = ((unary_operator*)node->get_left())->get_optimized_number(); + if (left_node->get_type()==expr_type::ast_num) { + left_num_node = reinterpret_cast(left_node); + } else if (left_node->get_type()==expr_type::ast_binary && + reinterpret_cast(left_node)->get_optimized_number()) { + auto optimized = reinterpret_cast(left_node); + left_num_node = optimized->get_optimized_number(); + } else if (left_node->get_type()==expr_type::ast_unary && + reinterpret_cast(left_node)->get_optimized_number()) { + auto optimized = reinterpret_cast(left_node); + left_num_node = optimized->get_optimized_number(); } - if (node->get_right()->get_type()==expr_type::ast_num) { - right_num_node = (number_literal*)node->get_right(); - } else if (node->get_right()->get_type()==expr_type::ast_binary && - ((binary_operator*)node->get_right())->get_optimized_number()) { - right_num_node = ((binary_operator*)node->get_right())->get_optimized_number(); - } else if (node->get_right()->get_type()==expr_type::ast_unary && - ((unary_operator*)node->get_right())->get_optimized_number()) { - right_num_node = ((unary_operator*)node->get_right())->get_optimized_number(); + if (right_node->get_type()==expr_type::ast_num) { + right_num_node = reinterpret_cast(right_node); + } else if (right_node->get_type()==expr_type::ast_binary && + reinterpret_cast(right_node)->get_optimized_number()) { + auto optimized = reinterpret_cast(right_node); + right_num_node = optimized->get_optimized_number(); + } else if (right_node->get_type()==expr_type::ast_unary && + reinterpret_cast(right_node)->get_optimized_number()) { + auto optimized = reinterpret_cast(right_node); + right_num_node = optimized->get_optimized_number(); } - if (node->get_left()->get_type()==expr_type::ast_str) { - left_str_node = (string_literal*)node->get_left(); - } else if (node->get_left()->get_type()==expr_type::ast_binary && - ((binary_operator*)node->get_left())->get_optimized_string()) { - left_str_node = ((binary_operator*)node->get_left())->get_optimized_string(); + if (left_node->get_type()==expr_type::ast_str) { + left_str_node = reinterpret_cast(left_node); + } else if (left_node->get_type()==expr_type::ast_binary && + reinterpret_cast(left_node)->get_optimized_string()) { + auto optimized = reinterpret_cast(left_node); + left_str_node = optimized->get_optimized_string(); } - if (node->get_right()->get_type()==expr_type::ast_str) { - right_str_node = (string_literal*)node->get_right(); - } else if (node->get_right()->get_type()==expr_type::ast_binary && - ((binary_operator*)node->get_right())->get_optimized_string()) { - right_str_node = ((binary_operator*)node->get_right())->get_optimized_string(); + if (right_node->get_type()==expr_type::ast_str) { + right_str_node = reinterpret_cast(right_node); + } else if (right_node->get_type()==expr_type::ast_binary && + reinterpret_cast(right_node)->get_optimized_string()) { + auto optimized = reinterpret_cast(right_node); + right_str_node = optimized->get_optimized_string(); } if (left_num_node && right_num_node) { const_number(node, left_num_node, right_num_node); @@ -115,19 +127,23 @@ bool optimizer::visit_binary_operator(binary_operator* node) { } bool optimizer::visit_unary_operator(unary_operator* node) { - node->get_value()->accept(this); - number_literal* value_node = nullptr; - if (node->get_value()->get_type()==expr_type::ast_num) { - value_node = (number_literal*)node->get_value(); - } else if (node->get_value()->get_type()==expr_type::ast_binary && - ((binary_operator*)node->get_value())->get_optimized_number()) { - value_node = ((binary_operator*)node->get_value())->get_optimized_number(); - } else if (node->get_value()->get_type()==expr_type::ast_unary && - ((unary_operator*)node->get_value())->get_optimized_number()) { - value_node = ((unary_operator*)node->get_value())->get_optimized_number(); + auto value = node->get_value(); + value->accept(this); + + number_literal* num_node = nullptr; + if (value->get_type()==expr_type::ast_num) { + num_node = reinterpret_cast(value); + } else if (value->get_type()==expr_type::ast_binary && + reinterpret_cast(value)->get_optimized_number()) { + auto optimized = reinterpret_cast(value); + num_node = optimized->get_optimized_number(); + } else if (value->get_type()==expr_type::ast_unary && + reinterpret_cast(value)->get_optimized_number()) { + auto optimized = reinterpret_cast(value); + num_node = optimized->get_optimized_number(); } - if (value_node) { - const_number(node, value_node); + if (num_node) { + const_number(node, num_node); } return true; }