xxq250
/
Nasal-Interpreter
mirror of https://github.com/ValKmjolnir/Nasal-Interpreter.git
1
0
Fork 0
Code Issues Actions 1 Packages Projects Releases Wiki Activity

✨ use reinterpret_cast and static_cast

This commit is contained in:
ValKmjolnir 2023-11-05 21:25:20 +08:00
parent 336139dcae
commit e8c8a6446b
4 changed files with 193 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/nasal_builtin.cpp
View File

@ -309,8 +309,8 @@ var builtin_substr(context* ctx, gc* ngc) {
if (len.type!=vm_num || len.num()<0) {
return nas_err("substr", "\"length\" should be number >= 0");
}
usize begin = (usize)beg.num();
usize length = (usize)len.num();
auto begin = static_cast<usize>(beg.num());
auto length = static_cast<usize>(len.num());
if (begin>=str.str().length()) {
return nas_err("susbtr", "begin index out of range: "+std::to_string(begin));
}
@ -397,7 +397,7 @@ var builtin_chr(context* ctx, gc* ngc) {
};
auto num = static_cast<i32>(ctx->localr[1].num());
if (0<=num && num<128) {
return ngc->newstr((char)num);
return ngc->newstr(static_cast<char>(num));
} else if (128<=num && num<256) {
return ngc->newstr(extend[num-128]);
}

212
src/nasal_codegen.cpp
View File

@ -58,7 +58,7 @@ void codegen::check_id_exist(identifier* node) {
);
}
void codegen::regist_num(const f64 num) {
void codegen::regist_number(const f64 num) {
if (const_number_map.count(num)) {
return;
}
@ -67,7 +67,7 @@ void codegen::regist_num(const f64 num) {
const_number_table.push_back(num);
}
void codegen::regist_str(const std::string& str) {
void codegen::regist_string(const std::string& str) {
if (const_string_map.count(str)) {
return;
}
@ -94,11 +94,11 @@ void codegen::find_symbol(code_block* node) {
scope.insert(i.name);
}
// add symbol for codegen symbol check
add_symbol(i.name);
regist_symbol(i.name);
}
}
void codegen::add_symbol(const std::string& name) {
void codegen::regist_symbol(const std::string& name) {
if (local.empty()) {
if (global.count(name)) {
return;
@ -150,25 +150,25 @@ void codegen::emit(u8 operation_code, u32 immediate_num, const span& location) {
});
}
void codegen::num_gen(number_literal* node) {
void codegen::number_gen(number_literal* node) {
f64 num = node->get_number();
regist_num(num);
regist_number(num);
emit(op_pnum, const_number_map.at(num), node->get_location());
}
void codegen::str_gen(string_literal* node) {
void codegen::string_gen(string_literal* node) {
const auto& str = node->get_content();
regist_str(str);
regist_string(str);
emit(op_pstr, const_string_map.at(str), node->get_location());
}
void codegen::bool_gen(bool_literal* node) {
f64 num = node->get_flag()? 1:0;
regist_num(num);
regist_number(num);
emit(op_pnum, const_number_map.at(num), node->get_location());
}
void codegen::vec_gen(vector_expr* node) {
void codegen::vector_gen(vector_expr* node) {
for(auto child : node->get_elements()) {
calc_gen(child);
}
@ -180,7 +180,7 @@ void codegen::hash_gen(hash_expr* node) {
for(auto child : node->get_members()) {
calc_gen(child->get_value());
const auto& field_name = child->get_name();
regist_str(field_name);
regist_string(field_name);
emit(op_happ, const_string_map.at(field_name), child->get_location());
}
}
@ -243,7 +243,7 @@ void codegen::func_gen(function* node) {
tmp->get_location()
);
}
regist_str(name);
regist_string(name);
switch(tmp->get_parameter_type()) {
case parameter::param_type::normal_parameter:
emit(op_para, const_string_map.at(name), tmp->get_location());
@ -256,7 +256,7 @@ void codegen::func_gen(function* node) {
emit(op_dyn, const_string_map.at(name), tmp->get_location());
break;
}
add_symbol(name);
regist_symbol(name);
}
code[newf].num = code.size()+1; // entry
@ -282,7 +282,7 @@ void codegen::func_gen(function* node) {
while(local_symbol_find(arg)>=0) {
arg = "0" + arg;
}
add_symbol(arg);
regist_symbol(arg);
// generate code block
in_foreach_loop_level.push_back(0);
@ -323,7 +323,7 @@ void codegen::call_gen(call_expr* node) {
}
}
void codegen::call_id(identifier* node) {
void codegen::call_identifier(identifier* node) {
const auto& name = node->get_name();
if (native_function_mapper.count(name)) {
emit(op_callb,
@ -357,7 +357,7 @@ void codegen::call_id(identifier* node) {
}
void codegen::call_hash_gen(call_hash* node) {
regist_str(node->get_field());
regist_string(node->get_field());
emit(op_callh, const_string_map.at(node->get_field()), node->get_location());
}
@ -391,7 +391,7 @@ void codegen::call_func_gen(call_function* node) {
auto pair_node = reinterpret_cast<hash_pair*>(child);
calc_gen(pair_node->get_value());
const auto& field_name = pair_node->get_name();
regist_str(field_name);
regist_string(field_name);
emit(op_happ, const_string_map.at(field_name), child->get_location());
}
emit(op_callfh, 0, node->get_location());
@ -419,7 +419,7 @@ void codegen::mcall(expr* node) {
}
// generate symbol call if node is just ast_id and return
if (node->get_type()==expr_type::ast_id) {
mcall_id(reinterpret_cast<identifier*>(node));
mcall_identifier(reinterpret_cast<identifier*>(node));
return;
}
// generate call expression until the last sub-node
@ -428,17 +428,22 @@ void codegen::mcall(expr* node) {
for(usize i = 0; i<call_node->get_calls().size()-1; ++i) {
auto tmp = call_node->get_calls()[i];
switch(tmp->get_type()) {
case expr_type::ast_callh: call_hash_gen((call_hash*)tmp); break;
case expr_type::ast_callv: call_vector_gen((call_vector*)tmp); break;
case expr_type::ast_callf: call_func_gen((call_function*)tmp); break;
case expr_type::ast_callh:
call_hash_gen(reinterpret_cast<call_hash*>(tmp)); break;
case expr_type::ast_callv:
call_vector_gen(reinterpret_cast<call_vector*>(tmp)); break;
case expr_type::ast_callf:
call_func_gen(reinterpret_cast<call_function*>(tmp)); break;
default: break;
}
}
// the last sub-node will be used to generate memory call expression
auto tmp = call_node->get_calls().back();
switch(tmp->get_type()) {
case expr_type::ast_callh: mcall_hash((call_hash*)tmp); break;
case expr_type::ast_callv: mcall_vec((call_vector*)tmp); break;
case expr_type::ast_callh:
mcall_hash(reinterpret_cast<call_hash*>(tmp)); break;
case expr_type::ast_callv:
mcall_vec(reinterpret_cast<call_vector*>(tmp)); break;
case expr_type::ast_callf:
die("bad left-value: function call", tmp->get_location()); break;
default:
@ -446,7 +451,7 @@ void codegen::mcall(expr* node) {
}
}
void codegen::mcall_id(identifier* node) {
void codegen::mcall_identifier(identifier* node) {
const auto& name = node->get_name();
if (native_function_mapper.count(name)) {
die("cannot modify native function", node->get_location());
@ -484,7 +489,7 @@ void codegen::mcall_vec(call_vector* node) {
}
void codegen::mcall_hash(call_hash* node) {
regist_str(node->get_field());
regist_string(node->get_field());
emit(op_mcallh, const_string_map.at(node->get_field()), node->get_location());
}
@ -509,12 +514,16 @@ void codegen::multi_def(definition_expr* node) {
if (node->get_tuple()) {
auto& vals = node->get_tuple()->get_elements();
if (identifiers.size()>vals.size()) {
die("lack values in multi-definition",
die("lack values in multi-definition, expect " +
std::to_string(identifiers.size()) + " but get " +
std::to_string(vals.size()),
node->get_tuple()->get_location()
);
return;
} else if (identifiers.size()<vals.size()) {
die("too many values in multi-definition",
die("too many values in multi-definition, expect " +
std::to_string(identifiers.size()) + " but get " +
std::to_string(vals.size()),
node->get_tuple()->get_location()
);
return;
@ -540,7 +549,7 @@ void codegen::multi_def(definition_expr* node) {
emit(op_pop, 0, node->get_location());
}
void codegen::def_gen(definition_expr* node) {
void codegen::definition_gen(definition_expr* node) {
if (node->get_variable_name() && node->get_tuple()) {
die("cannot accept too many values", node->get_value()->get_location());
}
@ -562,8 +571,9 @@ void codegen::assignment_expression(assignment_expr* node) {
if (node->get_right()->get_type()!=expr_type::ast_num) {
emit(op_addeq, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_addeqc, const_number_map[num], node->get_location());
}
break;
@ -575,8 +585,9 @@ void codegen::assignment_expression(assignment_expr* node) {
if (node->get_right()->get_type()!=expr_type::ast_num) {
emit(op_subeq, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_subeqc, const_number_map[num], node->get_location());
}
break;
@ -588,8 +599,9 @@ void codegen::assignment_expression(assignment_expr* node) {
if (node->get_right()->get_type()!=expr_type::ast_num) {
emit(op_muleq, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_muleqc, const_number_map[num], node->get_location());
}
break;
@ -601,8 +613,9 @@ void codegen::assignment_expression(assignment_expr* node) {
if (node->get_right()->get_type()!=expr_type::ast_num) {
emit(op_diveq, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_diveqc, const_number_map[num], node->get_location());
}
break;
@ -614,8 +627,9 @@ void codegen::assignment_expression(assignment_expr* node) {
if (node->get_right()->get_type()!=expr_type::ast_str) {
emit(op_lnkeq, 0, node->get_location());
} else {
const auto& str = ((string_literal*)node->get_right())->get_content();
regist_str(str);
const auto& str = reinterpret_cast<string_literal*>(
node->get_right())->get_content();
regist_string(str);
emit(op_lnkeqc, const_string_map[str], node->get_location());
}
break;
@ -655,7 +669,7 @@ void codegen::gen_assignment_equal_statement(assignment_expr* node) {
// generate symbol load
calc_gen(node->get_right());
// get memory space of left identifier
mcall_id(reinterpret_cast<identifier*>(node->get_left()));
mcall_identifier(reinterpret_cast<identifier*>(node->get_left()));
// check memory get operand type and replace it with load operand
switch(code.back().op) {
case op_mcallg: code.back().op = op_loadg; break;
@ -802,9 +816,12 @@ void codegen::loop_gen(expr* node) {
break_ptr.push_front({});
switch(node->get_type()) {
case expr_type::ast_while: while_gen((while_expr*)node); break;
case expr_type::ast_for: for_gen((for_expr*)node); break;
case expr_type::ast_forei: forei_gen((forei_expr*)node); break;
case expr_type::ast_while:
while_gen(reinterpret_cast<while_expr*>(node)); break;
case expr_type::ast_for:
for_gen(reinterpret_cast<for_expr*>(node)); break;
case expr_type::ast_forei:
forei_gen(reinterpret_cast<forei_expr*>(node)); break;
default: break;
}
}
@ -836,7 +853,7 @@ void codegen::for_gen(for_expr* node) {
statement_generation(node->get_initial());
usize jmp_place = code.size();
if (node->get_condition()->get_type()==expr_type::ast_null) {
regist_num(1);
regist_number(1);
emit(op_pnum, const_number_map.at(1), node->get_condition()->get_location());
} else {
calc_gen(node->get_condition());
@ -900,11 +917,11 @@ void codegen::statement_generation(expr* node) {
switch(node->get_type()) {
case expr_type::ast_null: break;
case expr_type::ast_def:
def_gen((definition_expr*)node); break;
definition_gen(reinterpret_cast<definition_expr*>(node)); break;
case expr_type::ast_multi_assign:
multi_assign_gen((multi_assign*)node); break;
multi_assign_gen(reinterpret_cast<multi_assign*>(node)); break;
case expr_type::ast_assign:
assignment_statement((assignment_expr*)node); break;
assignment_statement(reinterpret_cast<assignment_expr*>(node)); break;
case expr_type::ast_nil:
case expr_type::ast_num:
case expr_type::ast_str:
@ -963,7 +980,7 @@ void codegen::and_gen(binary_operator* node) {
void codegen::unary_gen(unary_operator* node) {
// generate optimized result
if (node->get_optimized_number()) {
num_gen(node->get_optimized_number());
number_gen(node->get_optimized_number());
return;
}
@ -981,11 +998,11 @@ void codegen::unary_gen(unary_operator* node) {
void codegen::binary_gen(binary_operator* node) {
// generate optimized result
if (node->get_optimized_number()) {
num_gen(node->get_optimized_number());
number_gen(node->get_optimized_number());
return;
}
if (node->get_optimized_string()) {
str_gen(node->get_optimized_string());
string_gen(node->get_optimized_string());
return;
}
@ -1029,8 +1046,9 @@ void codegen::binary_gen(binary_operator* node) {
calc_gen(node->get_right());
emit(op_add, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_addc, const_number_map.at(num), node->get_location());
}
return;
@ -1040,8 +1058,9 @@ void codegen::binary_gen(binary_operator* node) {
calc_gen(node->get_right());
emit(op_sub, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_subc, const_number_map.at(num), node->get_location());
}
return;
@ -1051,8 +1070,9 @@ void codegen::binary_gen(binary_operator* node) {
calc_gen(node->get_right());
emit(op_mul, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_mulc, const_number_map.at(num), node->get_location());
}
return;
@ -1062,8 +1082,9 @@ void codegen::binary_gen(binary_operator* node) {
calc_gen(node->get_right());
emit(op_div, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_divc, const_number_map.at(num), node->get_location());
}
return;
@ -1073,8 +1094,9 @@ void codegen::binary_gen(binary_operator* node) {
calc_gen(node->get_right());
emit(op_lnk, 0, node->get_location());
} else {
const auto& str = ((string_literal*)node->get_right())->get_content();
regist_str(str);
const auto& str = reinterpret_cast<string_literal*>(
node->get_right())->get_content();
regist_string(str);
emit(op_lnkc, const_string_map.at(str), node->get_location());
}
break;
@ -1084,8 +1106,9 @@ void codegen::binary_gen(binary_operator* node) {
calc_gen(node->get_right());
emit(op_less, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_lessc, const_number_map.at(num), node->get_location());
}
return;
@ -1095,8 +1118,9 @@ void codegen::binary_gen(binary_operator* node) {
calc_gen(node->get_right());
emit(op_leq, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_leqc, const_number_map.at(num), node->get_location());
}
return;
@ -1106,8 +1130,9 @@ void codegen::binary_gen(binary_operator* node) {
calc_gen(node->get_right());
emit(op_grt, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_grtc, const_number_map.at(num), node->get_location());
}
return;
@ -1117,8 +1142,9 @@ void codegen::binary_gen(binary_operator* node) {
calc_gen(node->get_right());
emit(op_geq, 0, node->get_location());
} else {
auto num = ((number_literal*)node->get_right())->get_number();
regist_num(num);
auto num = reinterpret_cast<number_literal*>(node->get_right())
->get_number();
regist_number(num);
emit(op_geqc, const_number_map.at(num), node->get_location());
}
return;
@ -1143,33 +1169,38 @@ void codegen::calc_gen(expr* node) {
case expr_type::ast_nil:
emit(op_pnil, 0, node->get_location()); break;
case expr_type::ast_num:
num_gen((number_literal*)node); break;
number_gen(reinterpret_cast<number_literal*>(node)); break;
case expr_type::ast_str:
str_gen((string_literal*)node); break;
string_gen(reinterpret_cast<string_literal*>(node)); break;
case expr_type::ast_id:
call_id((identifier*)node); break;
call_identifier(reinterpret_cast<identifier*>(node)); break;
case expr_type::ast_bool:
bool_gen((bool_literal*)node); break;
bool_gen(reinterpret_cast<bool_literal*>(node)); break;
case expr_type::ast_vec:
vec_gen((vector_expr*)node); break;
vector_gen(reinterpret_cast<vector_expr*>(node)); break;
case expr_type::ast_hash:
hash_gen((hash_expr*)node); break;
hash_gen(reinterpret_cast<hash_expr*>(node)); break;
case expr_type::ast_func:
func_gen((function*)node); break;
func_gen(reinterpret_cast<function*>(node)); break;
case expr_type::ast_call:
call_gen((call_expr*)node); break;
call_gen(reinterpret_cast<call_expr*>(node)); break;
case expr_type::ast_assign:
assignment_expression((assignment_expr*)node); break;
assignment_expression(
reinterpret_cast<assignment_expr*>(node)
);
break;
case expr_type::ast_ternary:
trino_gen((ternary_operator*)node); break;
trino_gen(reinterpret_cast<ternary_operator*>(node)); break;
case expr_type::ast_unary:
unary_gen((unary_operator*)node); break;
unary_gen(reinterpret_cast<unary_operator*>(node)); break;
case expr_type::ast_binary:
binary_gen((binary_operator*)node); break;
binary_gen(reinterpret_cast<binary_operator*>(node)); break;
case expr_type::ast_def:
// definition in calculation only should be single def
single_def((definition_expr*)node);
call_id(((definition_expr*)node)->get_variable_name());
single_def(reinterpret_cast<definition_expr*>(node));
call_identifier(
(reinterpret_cast<definition_expr*>(node))->get_variable_name()
);
break;
default: break;
}
@ -1177,11 +1208,16 @@ void codegen::calc_gen(expr* node) {
void codegen::repl_mode_info_output_gen(expr* node) {
switch(node->get_type()) {
case expr_type::ast_id: call_id((identifier*)node); break;
case expr_type::ast_nil: emit(op_pnil, 0, node->get_location()); break;
case expr_type::ast_num: num_gen((number_literal*)node); break;
case expr_type::ast_str: str_gen((string_literal*)node); break;
case expr_type::ast_bool: bool_gen((bool_literal*)node); break;
case expr_type::ast_id:
call_identifier(reinterpret_cast<identifier*>(node)); break;
case expr_type::ast_nil:
emit(op_pnil, 0, node->get_location()); break;
case expr_type::ast_num:
number_gen(reinterpret_cast<number_literal*>(node)); break;
case expr_type::ast_str:
string_gen(reinterpret_cast<string_literal*>(node)); break;
case expr_type::ast_bool:
bool_gen(reinterpret_cast<bool_literal*>(node)); break;
default: return;
}
// generate repl output operand
@ -1273,9 +1309,9 @@ const error& codegen::compile(parse& parse, linker& import, bool repl_flag) {
in_foreach_loop_level.push_back(0);
// add special symbol globals, which is a hash stores all global variables
add_symbol("globals");
regist_symbol("globals");
// add special symbol arg here, which is used to store command line args
add_symbol("arg");
regist_symbol("arg");
// search global symbols first
find_symbol(parse.tree());

18
src/nasal_codegen.h
View File

@ -78,34 +78,34 @@ private:
err.err("code", loc, info);
}
void regist_num(const f64);
void regist_str(const std::string&);
void regist_number(const f64);
void regist_string(const std::string&);
void find_symbol(code_block*);
void add_symbol(const std::string&);
void regist_symbol(const std::string&);
i32 local_symbol_find(const std::string&);
i32 global_symbol_find(const std::string&);
i32 upvalue_symbol_find(const std::string&);
void emit(u8, u32, const span&);
void num_gen(number_literal*);
void str_gen(string_literal*);
void number_gen(number_literal*);
void string_gen(string_literal*);
void bool_gen(bool_literal*);
void vec_gen(vector_expr*);
void vector_gen(vector_expr*);
void hash_gen(hash_expr*);
void func_gen(function*);
void call_gen(call_expr*);
void call_id(identifier*);
void call_identifier(identifier*);
void call_hash_gen(call_hash*);
void call_vector_gen(call_vector*);
void call_func_gen(call_function*);
void mcall(expr*);
void mcall_id(identifier*);
void mcall_identifier(identifier*);
void mcall_vec(call_vector*);
void mcall_hash(call_hash*);
void multi_def(definition_expr*);
void single_def(definition_expr*);
void def_gen(definition_expr*);
void definition_gen(definition_expr*);
void assignment_expression(assignment_expr*);
void gen_assignment_equal_statement(assignment_expr*);
void replace_left_assignment_with_load(const span&);

107
test/md5compare.nas
View File

@ -4,95 +4,102 @@ use std.file;
srand();
var compare=func() {
var ch=[
var compare = func() {
var ch = [
"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","+",
"_","*","/","\'","\"",".",",",";",":","<",">","!","@","#","$","%",
"^","&","*","(",")","-","=","\\","|","[","]","{","}","`"," ","\t","?"
];
return func(begin,end) {
var byte=0;
var total=end-begin;
var timestamp=maketimestamp();
return func(begin, end) {
var byte = 0;
var total = end-begin;
var timestamp = maketimestamp();
timestamp.stamp();
var bar=process_bar.high_resolution_bar(40);
for(var i=begin;i<end;i+=1) {
var s="";
for(var j=0;j<i;j+=1) {
s~=ch[rand()*size(ch)];
var bar = process_bar.high_resolution_bar(40);
for(var i = begin; i<end; i += 1) {
var s = "";
for(var j = 0; j<i; j += 1) {
s ~= ch[rand()*size(ch)];
}
byte+=size(s);
var res=md5(s);
byte += size(s);
var res = md5(s);
if(cmp(res, md5_self.md5(s))) {
die("error: "~str(i));
}
if (i-begin-int((i-begin)/4)*4==0) {
print(
"\e[1000D ",bar.bar((i-begin+1)/total),
" (",i-begin+1,"/",total,")\t",
res," byte: ",int(byte/1024),"k"
"\e[1000D ", bar.bar((i-begin+1)/total),
" (", i-begin+1, "/", total, ")\t",
res, " byte: ", int(byte/1024), "k"
);
}
}
print(
"\e[1000D ",bar.bar((i-begin)/total),
" (",i-begin,"/",total,")\t",
res," byte: ",int(byte/1024),"k",
" time: ",timestamp.elapsedMSec()
"\e[1000D ", bar.bar((i-begin)/total),
" (", i-begin, "/", total, ")\t",
res, " byte: ", int(byte/1024), "k",
" time: ", timestamp.elapsedMSec()
);
print("\n");
};
}();
var filechecksum=func(){
var files=[];
foreach(var p;file.find_all_files_with_extension("./test","nas")) {
append(files,"./test/"~p);
var filechecksum = func() {
var files = [];
foreach(var p; file.find_all_files_with_extension("./test","nas")) {
append(files, "./test/"~p);
}
foreach(var p;file.find_all_files_with_extension("./std","nas")) {
append(files,"./std/"~p);
foreach(var p; file.find_all_files_with_extension("./std","nas")) {
append(files, "./std/"~p);
}
foreach(var p;file.find_all_files_with_extension("./module","nas","cpp")) {
append(files,"./module/"~p);
foreach(var p; file.find_all_files_with_extension("./module","nas","cpp")) {
append(files, "./module/"~p);
}
foreach(var p;file.find_all_files_with_extension(".","md")) {
append(files,"./"~p);
foreach(var p; file.find_all_files_with_extension(".","md")) {
append(files, "./"~p);
}
foreach(var p;file.find_all_files_with_extension("./src","cpp","h")) {
append(files,"./src/"~p);
foreach(var p; file.find_all_files_with_extension("./src","cpp","h")) {
append(files, "./src/"~p);
}
foreach(var p;file.find_all_files_with_extension("./doc","md")) {
append(files,"./doc/"~p);
foreach(var p; file.find_all_files_with_extension("./doc","md")) {
append(files, "./doc/"~p);
}
var byte=0;
var total=size(files);
var timestamp=maketimestamp();
var source = [];
foreach(var f; files) {
append(source, io.readfile(f));
}
var byte = 0;
var total = size(files);
var timestamp = maketimestamp();
timestamp.stamp();
var bar=process_bar.high_resolution_bar(40);
forindex(var i;files){
var f=io.readfile(files[i]);
var res=md5(f);
byte+=size(f);
var bar = process_bar.high_resolution_bar(40);
forindex(var i; files) {
var f = source[i];
var res = md5(f);
byte += size(f);
if(cmp(res, md5_self.md5(f))){
die("error: "~files[i]);
}
print(
"\e[1000D ",bar.bar((i+1)/total),
" (",i+1,"/",total,")\t",res,
" byte: ",int(byte/1024),"k",
" time: ",timestamp.elapsedMSec()
"\e[1000D ", bar.bar((i+1)/total),
" (", i+1, "/", total, ")\t", res,
" byte: ", int(byte/1024), "k",
" time: ", timestamp.elapsedMSec()
);
}
print("\n");
}
var randomchecksum=func(){
for(var i=0;i<2048;i+=256)
compare(i,i+256);
var randomchecksum = func() {
for(var i = 0; i<2048; i += 256) {
compare(i, i+256);
}
}
if(os.platform()=="windows")
if(os.platform()=="windows") {
system("chcp 65001");
}
filechecksum();
randomchecksum();