forked from xxq250/Nasal-Interpreter
🎨 format
This commit is contained in:
@@ -36,6 +36,7 @@ __Contact us if having great ideas to share!__
|
||||
|
||||

|
||||

|
||||
[](https://deepwiki.com/ValKmjolnir/Nasal-Interpreter)
|
||||

|
||||

|
||||
|
||||
@@ -344,7 +345,7 @@ source code:
|
||||
if (x<2) return x;
|
||||
return fib(x-1)+fib(x-2);
|
||||
}
|
||||
for(var i=0;i<31;i+=1)
|
||||
for (var i=0;i<31;i+=1)
|
||||
print(fib(i),'\n');
|
||||
|
||||
|
||||
@@ -377,7 +378,7 @@ source code:
|
||||
--> if (x<2) return x;
|
||||
return fib(x-1)+fib(x-2);
|
||||
}
|
||||
for(var i=0;i<31;i+=1)
|
||||
for (var i=0;i<31;i+=1)
|
||||
print(fib(i),'\n');
|
||||
|
||||
|
||||
|
||||
@@ -329,7 +329,7 @@ source code:
|
||||
if (x<2) return x;
|
||||
return fib(x-1)+fib(x-2);
|
||||
}
|
||||
for(var i=0;i<31;i+=1)
|
||||
for (var i=0;i<31;i+=1)
|
||||
print(fib(i),'\n');
|
||||
|
||||
|
||||
@@ -362,7 +362,7 @@ source code:
|
||||
--> if (x<2) return x;
|
||||
return fib(x-1)+fib(x-2);
|
||||
}
|
||||
for(var i=0;i<31;i+=1)
|
||||
for (var i=0;i<31;i+=1)
|
||||
print(fib(i),'\n');
|
||||
|
||||
|
||||
|
||||
@@ -124,7 +124,7 @@ Hope you could help me! :)
|
||||
There's an example of byte code below:
|
||||
|
||||
```javascript
|
||||
for(var i=0;i<4000000;i+=1);
|
||||
for (var i=0;i<4000000;i+=1);
|
||||
```
|
||||
|
||||
```x86asm
|
||||
@@ -175,7 +175,7 @@ In this update i changed global and local scope from `unordered_map` to `vector`
|
||||
So the bytecode generator changed a lot.
|
||||
|
||||
```javascript
|
||||
for(var i=0;i<4000000;i+=1);
|
||||
for (var i=0;i<4000000;i+=1);
|
||||
```
|
||||
|
||||
```x86asm
|
||||
|
||||
@@ -112,7 +112,7 @@ __该项目于2019/7/25正式开始__。
|
||||
下面是生成的字节码的样例:
|
||||
|
||||
```javascript
|
||||
for(var i=0;i<4000000;i+=1);
|
||||
for (var i=0;i<4000000;i+=1);
|
||||
```
|
||||
|
||||
```x86asm
|
||||
@@ -161,7 +161,7 @@ for(var i=0;i<4000000;i+=1);
|
||||
在这次的更新中,我把全局变量和局部变量的存储结构从`unordered_map`变为了`vector`,从而提升执行效率。所以现在生成的字节码大变样了。
|
||||
|
||||
```javascript
|
||||
for(var i=0;i<4000000;i+=1);
|
||||
for (var i=0;i<4000000;i+=1);
|
||||
```
|
||||
|
||||
```x86asm
|
||||
|
||||
@@ -258,7 +258,7 @@ While loop and for loop is simalar to C/C++.
|
||||
while(condition) {
|
||||
continue;
|
||||
}
|
||||
for(var i = 0; i<10; i += 1) {
|
||||
for (var i = 0; i<10; i += 1) {
|
||||
break;
|
||||
}
|
||||
```
|
||||
@@ -469,7 +469,7 @@ Then complete this function using C++:
|
||||
var builtin_print(context* ctx, gc* ngc) {
|
||||
// find value with index begin from 1
|
||||
// because local[0] is reserved for value 'me'
|
||||
for(auto& i : ctx->localr[1].vec().elems) {
|
||||
for (auto& i : ctx->localr[1].vec().elems) {
|
||||
std::cout << i;
|
||||
}
|
||||
std::cout << std::flush;
|
||||
@@ -495,11 +495,11 @@ var builtin_keys(context* ctx, gc* ngc) {
|
||||
auto res = ngc->temp = ngc->alloc(vm_vec);
|
||||
auto& vec = res.vec().elems;
|
||||
if (hash.type==vm_hash) {
|
||||
for(const auto& iter : hash.hash().elems) {
|
||||
for (const auto& iter : hash.hash().elems) {
|
||||
vec.push_back(ngc->newstr(iter.first));
|
||||
}
|
||||
} else {
|
||||
for(const auto& iter : hash.map().mapper) {
|
||||
for (const auto& iter : hash.map().mapper) {
|
||||
vec.push_back(ngc->newstr(iter.first));
|
||||
}
|
||||
}
|
||||
@@ -645,7 +645,7 @@ Then we write a test nasal file to run this fib function:
|
||||
use std.dylib;
|
||||
var dlhandle = dylib.dlopen("libfib");
|
||||
var fib = dlhandle.fib;
|
||||
for(var i = 1; i<30; i += 1)
|
||||
for (var i = 1; i<30; i += 1)
|
||||
println(dylib.dlcall(fib, i));
|
||||
dylib.dlclose(dlhandle.lib);
|
||||
```
|
||||
@@ -663,7 +663,7 @@ use std.dylib;
|
||||
var dlhandle = dylib.dlopen("libfib");
|
||||
var fib = dlhandle.fib;
|
||||
var invoke = dylib.limitcall(1); # this means the called function has only one parameter
|
||||
for(var i = 1; i<30; i += 1)
|
||||
for (var i = 1; i<30; i += 1)
|
||||
println(invoke(fib, i));
|
||||
dylib.dlclose(dlhandle.lib);
|
||||
```
|
||||
|
||||
@@ -250,7 +250,7 @@ while循环和for循环大体上与C/C++是一致的。
|
||||
while(condition) {
|
||||
continue;
|
||||
}
|
||||
for(var i = 0; i<10; i += 1) {
|
||||
for (var i = 0; i<10; i += 1) {
|
||||
break;
|
||||
}
|
||||
```
|
||||
@@ -457,7 +457,7 @@ var builtin_print(context*, gc*);
|
||||
var builtin_print(context* ctx, gc* ngc) {
|
||||
// 局部变量的下标其实是从 1 开始的
|
||||
// 因为 local[0] 是保留给 'me' 的空间
|
||||
for(auto& i : ctx->localr[1].vec().elems) {
|
||||
for (auto& i : ctx->localr[1].vec().elems) {
|
||||
std::cout << i;
|
||||
}
|
||||
std::cout << std::flush;
|
||||
@@ -483,11 +483,11 @@ var builtin_keys(context* ctx, gc* ngc) {
|
||||
auto res = ngc->temp = ngc->alloc(vm_vec);
|
||||
auto& vec = res.vec().elems;
|
||||
if (hash.type==vm_hash) {
|
||||
for(const auto& iter : hash.hash().elems) {
|
||||
for (const auto& iter : hash.hash().elems) {
|
||||
vec.push_back(ngc->newstr(iter.first));
|
||||
}
|
||||
} else {
|
||||
for(const auto& iter : hash.map().mapper) {
|
||||
for (const auto& iter : hash.map().mapper) {
|
||||
vec.push_back(ngc->newstr(iter.first));
|
||||
}
|
||||
}
|
||||
@@ -624,7 +624,7 @@ Windows(`.dll`):
|
||||
use std.dylib;
|
||||
var dlhandle = dylib.dlopen("libfib");
|
||||
var fib = dlhandle.fib;
|
||||
for(var i = 1; i<30; i += 1)
|
||||
for (var i = 1; i<30; i += 1)
|
||||
println(dylib.dlcall(fib, i));
|
||||
dylib.dlclose(dlhandle.lib);
|
||||
```
|
||||
@@ -642,7 +642,7 @@ use std.dylib;
|
||||
var dlhandle = dylib.dlopen("libfib");
|
||||
var fib = dlhandle.fib;
|
||||
var invoke = dylib.limitcall(1); # this means the called function has only one parameter
|
||||
for(var i = 1; i<30; i += 1)
|
||||
for (var i = 1; i<30; i += 1)
|
||||
println(invoke(fib, i));
|
||||
dylib.dlclose(dlhandle.lib);
|
||||
```
|
||||
|
||||
@@ -32,7 +32,7 @@ var quick_fib(var* args, usize size, gc* ngc) {
|
||||
return var::num(num);
|
||||
}
|
||||
double a = 1, b = 1, res = 0;
|
||||
for(double i = 1; i<num; ++i) {
|
||||
for (double i = 1; i<num; ++i) {
|
||||
res = a+b;
|
||||
a = b;
|
||||
b = res;
|
||||
|
||||
@@ -49,7 +49,7 @@ var test_ghost = func() {
|
||||
print("\n");
|
||||
set_ghost(ghost, 114); # success
|
||||
print("\n");
|
||||
for(var i = 0; i<256; i+=1) {
|
||||
for (var i = 0; i<256; i+=1) {
|
||||
var temp = []; # try to trigger gc
|
||||
}
|
||||
print("\n");
|
||||
|
||||
@@ -503,7 +503,7 @@ println("Division: ", a / b);`,
|
||||
|
||||
loops: `# Loop example
|
||||
var sum = 0;
|
||||
for(var i = 1; i <= 5; i += 1) {
|
||||
for (var i = 1; i <= 5; i += 1) {
|
||||
sum += i;
|
||||
println("Current sum: ", sum);
|
||||
}
|
||||
@@ -515,7 +515,7 @@ var factorial = func(n) {
|
||||
return n * factorial(n - 1);
|
||||
}
|
||||
|
||||
for(var i = 0; i <= 5; i += 1) {
|
||||
for (var i = 0; i <= 5; i += 1) {
|
||||
println("Factorial of ", i, " is ", factorial(i));
|
||||
}`
|
||||
};
|
||||
|
||||
@@ -200,7 +200,7 @@ const examples = {
|
||||
println("x = ", x);`,
|
||||
|
||||
loops: `var sum = 0;
|
||||
for(var i = 1; i <= 5; i += 1) {
|
||||
for (var i = 1; i <= 5; i += 1) {
|
||||
sum += i;
|
||||
}
|
||||
println("Sum:", sum);`,
|
||||
|
||||
@@ -9,7 +9,7 @@ bool ast_dumper::visit_use_stmt(use_stmt* node) {
|
||||
dump_indent();
|
||||
std::cout << "use" << format_location(node);
|
||||
push_indent();
|
||||
for(auto i : node->get_path()) {
|
||||
for (auto i : node->get_path()) {
|
||||
if (i==node->get_path().back()) {
|
||||
set_last();
|
||||
}
|
||||
@@ -64,7 +64,7 @@ bool ast_dumper::visit_vector_expr(vector_expr* node) {
|
||||
std::cout << "vector";
|
||||
std::cout << format_location(node);
|
||||
push_indent();
|
||||
for(auto i : node->get_elements()) {
|
||||
for (auto i : node->get_elements()) {
|
||||
if (i==node->get_elements().back()) {
|
||||
set_last();
|
||||
}
|
||||
@@ -79,7 +79,7 @@ bool ast_dumper::visit_hash_expr(hash_expr* node) {
|
||||
std::cout << "hash";
|
||||
std::cout << format_location(node);
|
||||
push_indent();
|
||||
for(auto i : node->get_members()) {
|
||||
for (auto i : node->get_members()) {
|
||||
if (i==node->get_members().back()) {
|
||||
set_last();
|
||||
}
|
||||
@@ -107,7 +107,7 @@ bool ast_dumper::visit_function(function* node) {
|
||||
std::cout << "function";
|
||||
std::cout << format_location(node);
|
||||
push_indent();
|
||||
for(auto i : node->get_parameter_list()) {
|
||||
for (auto i : node->get_parameter_list()) {
|
||||
i->accept(this);
|
||||
}
|
||||
set_last();
|
||||
@@ -121,7 +121,7 @@ bool ast_dumper::visit_code_block(code_block* node) {
|
||||
std::cout << "block";
|
||||
std::cout << format_location(node);
|
||||
push_indent();
|
||||
for(auto i : node->get_expressions()) {
|
||||
for (auto i : node->get_expressions()) {
|
||||
if (i==node->get_expressions().back()) {
|
||||
set_last();
|
||||
}
|
||||
@@ -231,7 +231,7 @@ bool ast_dumper::visit_call_expr(call_expr* node) {
|
||||
set_last();
|
||||
}
|
||||
node->get_first()->accept(this);
|
||||
for(auto i : node->get_calls()) {
|
||||
for (auto i : node->get_calls()) {
|
||||
if (i==node->get_calls().back()) {
|
||||
set_last();
|
||||
}
|
||||
@@ -260,7 +260,7 @@ bool ast_dumper::visit_call_vector(call_vector* node) {
|
||||
std::cout << "call_vector";
|
||||
std::cout << format_location(node);
|
||||
push_indent();
|
||||
for(auto i : node->get_slices()) {
|
||||
for (auto i : node->get_slices()) {
|
||||
if (i==node->get_slices().back()) {
|
||||
set_last();
|
||||
}
|
||||
@@ -275,7 +275,7 @@ bool ast_dumper::visit_call_function(call_function* node) {
|
||||
std::cout << "call_function";
|
||||
std::cout << format_location(node);
|
||||
push_indent();
|
||||
for(auto i : node->get_argument()) {
|
||||
for (auto i : node->get_argument()) {
|
||||
if (i==node->get_argument().back()) {
|
||||
set_last();
|
||||
}
|
||||
@@ -350,7 +350,7 @@ bool ast_dumper::visit_multi_identifier(multi_identifier* node) {
|
||||
std::cout << "multiple_identifier";
|
||||
std::cout << format_location(node);
|
||||
push_indent();
|
||||
for(auto i : node->get_variables()) {
|
||||
for (auto i : node->get_variables()) {
|
||||
if (i==node->get_variables().back()) {
|
||||
set_last();
|
||||
}
|
||||
@@ -365,7 +365,7 @@ bool ast_dumper::visit_tuple_expr(tuple_expr* node) {
|
||||
std::cout << "tuple";
|
||||
std::cout << format_location(node);
|
||||
push_indent();
|
||||
for(auto i : node->get_elements()) {
|
||||
for (auto i : node->get_elements()) {
|
||||
if (i==node->get_elements().back()) {
|
||||
set_last();
|
||||
}
|
||||
@@ -459,7 +459,7 @@ bool ast_dumper::visit_condition_expr(condition_expr* node) {
|
||||
set_last();
|
||||
}
|
||||
node->get_if_statement()->accept(this);
|
||||
for(auto i : node->get_elsif_stataments()) {
|
||||
for (auto i : node->get_elsif_stataments()) {
|
||||
if (i==node->get_elsif_stataments().back() &&
|
||||
!node->get_else_statement()) {
|
||||
set_last();
|
||||
|
||||
@@ -8,7 +8,7 @@ namespace nasal {
|
||||
bool ast_format::visit_use_stmt(use_stmt* node) {
|
||||
dump_formating_node_info(node, "use statement");
|
||||
out << "use ";
|
||||
for(auto i : node->get_path()) {
|
||||
for (auto i : node->get_path()) {
|
||||
i->accept(this);
|
||||
if (i != node->get_path().back()) {
|
||||
out << ".";
|
||||
@@ -55,7 +55,7 @@ bool ast_format::visit_bool_literal(bool_literal* node) {
|
||||
bool ast_format::visit_vector_expr(vector_expr* node) {
|
||||
dump_formating_node_info(node, "vector expression");
|
||||
out << "[";
|
||||
for(auto i : node->get_elements()) {
|
||||
for (auto i : node->get_elements()) {
|
||||
i->accept(this);
|
||||
if (i != node->get_elements().back()) {
|
||||
out << ", ";
|
||||
@@ -68,7 +68,7 @@ bool ast_format::visit_vector_expr(vector_expr* node) {
|
||||
bool ast_format::visit_hash_expr(hash_expr* node) {
|
||||
dump_formating_node_info(node, "hash expression");
|
||||
out << "{";
|
||||
for(auto i : node->get_members()) {
|
||||
for (auto i : node->get_members()) {
|
||||
i->accept(this);
|
||||
if (i != node->get_members().back()) {
|
||||
out << ", ";
|
||||
@@ -101,7 +101,7 @@ bool ast_format::visit_hash_pair(hash_pair* node) {
|
||||
bool ast_format::visit_function(function* node) {
|
||||
dump_formating_node_info(node, "function");
|
||||
out << "func(";
|
||||
for(auto i : node->get_parameter_list()) {
|
||||
for (auto i : node->get_parameter_list()) {
|
||||
i->accept(this);
|
||||
if (i != node->get_parameter_list().back()) {
|
||||
out << ", ";
|
||||
@@ -120,7 +120,7 @@ bool ast_format::visit_code_block(code_block* node) {
|
||||
dump_formating_node_info(node, "code block");
|
||||
out << "{\n";
|
||||
push_indent();
|
||||
for(auto i : node->get_expressions()) {
|
||||
for (auto i : node->get_expressions()) {
|
||||
dump_indent();
|
||||
i->accept(this);
|
||||
if (need_dump_semi(i)) {
|
||||
@@ -203,7 +203,7 @@ bool ast_format::visit_unary_operator(unary_operator* node) {
|
||||
bool ast_format::visit_call_expr(call_expr* node) {
|
||||
dump_formating_node_info(node, "call expression");
|
||||
node->get_first()->accept(this);
|
||||
for(auto i : node->get_calls()) {
|
||||
for (auto i : node->get_calls()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
@@ -224,7 +224,7 @@ bool ast_format::visit_null_access(null_access* node) {
|
||||
bool ast_format::visit_call_vector(call_vector* node) {
|
||||
dump_formating_node_info(node, "call vector");
|
||||
out << "[";
|
||||
for(auto i : node->get_slices()) {
|
||||
for (auto i : node->get_slices()) {
|
||||
i->accept(this);
|
||||
if (i != node->get_slices().back()) {
|
||||
out << ", ";
|
||||
@@ -237,7 +237,7 @@ bool ast_format::visit_call_vector(call_vector* node) {
|
||||
bool ast_format::visit_call_function(call_function* node) {
|
||||
dump_formating_node_info(node, "call function");
|
||||
out << "(";
|
||||
for(auto i : node->get_argument()) {
|
||||
for (auto i : node->get_argument()) {
|
||||
i->accept(this);
|
||||
if (i != node->get_argument().back()) {
|
||||
out << ", ";
|
||||
@@ -295,7 +295,7 @@ bool ast_format::visit_assignment_expr(assignment_expr* node) {
|
||||
bool ast_format::visit_multi_identifier(multi_identifier* node) {
|
||||
dump_formating_node_info(node, "multi identifier");
|
||||
out << "(";
|
||||
for(auto i : node->get_variables()) {
|
||||
for (auto i : node->get_variables()) {
|
||||
i->accept(this);
|
||||
if (i != node->get_variables().back()) {
|
||||
out << ", ";
|
||||
@@ -308,7 +308,7 @@ bool ast_format::visit_multi_identifier(multi_identifier* node) {
|
||||
bool ast_format::visit_tuple_expr(tuple_expr* node) {
|
||||
dump_formating_node_info(node, "tuple expression");
|
||||
out << "(";
|
||||
for(auto i : node->get_elements()) {
|
||||
for (auto i : node->get_elements()) {
|
||||
i->accept(this);
|
||||
if (i != node->get_elements().back()) {
|
||||
out << ", ";
|
||||
|
||||
@@ -8,7 +8,7 @@ bool ast_visitor::visit_expr(expr* node) {
|
||||
}
|
||||
|
||||
bool ast_visitor::visit_use_stmt(use_stmt* node) {
|
||||
for(auto i : node->get_path()) {
|
||||
for (auto i : node->get_path()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
@@ -44,14 +44,14 @@ bool ast_visitor::visit_bool_literal(bool_literal* node) {
|
||||
}
|
||||
|
||||
bool ast_visitor::visit_vector_expr(vector_expr* node) {
|
||||
for(auto i : node->get_elements()) {
|
||||
for (auto i : node->get_elements()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ast_visitor::visit_hash_expr(hash_expr* node) {
|
||||
for(auto i : node->get_members()) {
|
||||
for (auto i : node->get_members()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
@@ -65,7 +65,7 @@ bool ast_visitor::visit_hash_pair(hash_pair* node) {
|
||||
}
|
||||
|
||||
bool ast_visitor::visit_function(function* node) {
|
||||
for(auto i : node->get_parameter_list()) {
|
||||
for (auto i : node->get_parameter_list()) {
|
||||
i->accept(this);
|
||||
}
|
||||
node->get_code_block()->accept(this);
|
||||
@@ -73,7 +73,7 @@ bool ast_visitor::visit_function(function* node) {
|
||||
}
|
||||
|
||||
bool ast_visitor::visit_code_block(code_block* node) {
|
||||
for(auto i : node->get_expressions()) {
|
||||
for (auto i : node->get_expressions()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
@@ -106,7 +106,7 @@ bool ast_visitor::visit_unary_operator(unary_operator* node) {
|
||||
|
||||
bool ast_visitor::visit_call_expr(call_expr* node) {
|
||||
node->get_first()->accept(this);
|
||||
for(auto i : node->get_calls()) {
|
||||
for (auto i : node->get_calls()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
@@ -121,14 +121,14 @@ bool ast_visitor::visit_null_access(null_access* node) {
|
||||
}
|
||||
|
||||
bool ast_visitor::visit_call_vector(call_vector* node) {
|
||||
for(auto i : node->get_slices()) {
|
||||
for (auto i : node->get_slices()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ast_visitor::visit_call_function(call_function* node) {
|
||||
for(auto i : node->get_argument()) {
|
||||
for (auto i : node->get_argument()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
@@ -163,14 +163,14 @@ bool ast_visitor::visit_assignment_expr(assignment_expr* node) {
|
||||
}
|
||||
|
||||
bool ast_visitor::visit_multi_identifier(multi_identifier* node) {
|
||||
for(auto i : node->get_variables()) {
|
||||
for (auto i : node->get_variables()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ast_visitor::visit_tuple_expr(tuple_expr* node) {
|
||||
for(auto i : node->get_elements()) {
|
||||
for (auto i : node->get_elements()) {
|
||||
i->accept(this);
|
||||
}
|
||||
return true;
|
||||
@@ -214,7 +214,7 @@ bool ast_visitor::visit_forei_expr(forei_expr* node) {
|
||||
|
||||
bool ast_visitor::visit_condition_expr(condition_expr* node) {
|
||||
node->get_if_statement()->accept(this);
|
||||
for(auto i : node->get_elsif_stataments()) {
|
||||
for (auto i : node->get_elsif_stataments()) {
|
||||
i->accept(this);
|
||||
}
|
||||
if (node->get_else_statement()) {
|
||||
|
||||
@@ -13,7 +13,7 @@ namespace nasal::cli {
|
||||
cli_config parse(const std::vector<std::string>& args) {
|
||||
cli_config result;
|
||||
|
||||
for(const auto& arg : args) {
|
||||
for (const auto& arg : args) {
|
||||
if (cli_options.count(arg)) {
|
||||
result.options.insert(cli_options.at(arg));
|
||||
} else if (!result.input_file_path.length()) {
|
||||
@@ -113,7 +113,7 @@ std::ostream& version(std::ostream& out) {
|
||||
std::srand(static_cast<u32>(std::time(nullptr)));
|
||||
|
||||
f64 num = 0;
|
||||
for(u32 i = 0; i<5; ++i) {
|
||||
for (u32 i = 0; i<5; ++i) {
|
||||
num = (num+rand())*(1.0/(RAND_MAX+1.0));
|
||||
}
|
||||
// give you 5% to see this easter egg
|
||||
|
||||
@@ -51,7 +51,7 @@ void execute(const nasal::cli::cli_config& config) {
|
||||
if (ld.get_file_list().size()) {
|
||||
std::cout << "referenced file(s):\n";
|
||||
}
|
||||
for(const auto& file: ld.get_file_list()) {
|
||||
for (const auto& file: ld.get_file_list()) {
|
||||
std::cout << " " << file << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,7 +8,7 @@ void expr::accept(ast_visitor* visitor) {
|
||||
}
|
||||
|
||||
use_stmt::~use_stmt() {
|
||||
for(auto i : path) {
|
||||
for (auto i : path) {
|
||||
delete i;
|
||||
}
|
||||
}
|
||||
@@ -46,7 +46,7 @@ void bool_literal::accept(ast_visitor* visitor) {
|
||||
}
|
||||
|
||||
vector_expr::~vector_expr() {
|
||||
for(auto i : elements) {
|
||||
for (auto i : elements) {
|
||||
delete i;
|
||||
}
|
||||
}
|
||||
@@ -56,7 +56,7 @@ void vector_expr::accept(ast_visitor* visitor) {
|
||||
}
|
||||
|
||||
hash_expr::~hash_expr() {
|
||||
for(auto i : members) {
|
||||
for (auto i : members) {
|
||||
delete i;
|
||||
}
|
||||
}
|
||||
@@ -76,7 +76,7 @@ void hash_pair::accept(ast_visitor* visitor) {
|
||||
}
|
||||
|
||||
function::~function() {
|
||||
for(auto i : parameter_list) {
|
||||
for (auto i : parameter_list) {
|
||||
delete i;
|
||||
}
|
||||
if (block) {
|
||||
@@ -89,7 +89,7 @@ void function::accept(ast_visitor* visitor) {
|
||||
}
|
||||
|
||||
code_block::~code_block() {
|
||||
for(auto i : expressions) {
|
||||
for (auto i : expressions) {
|
||||
delete i;
|
||||
}
|
||||
}
|
||||
@@ -160,7 +160,7 @@ call_expr::~call_expr() {
|
||||
if(first) {
|
||||
delete first;
|
||||
}
|
||||
for(auto i : calls) {
|
||||
for (auto i : calls) {
|
||||
delete i;
|
||||
}
|
||||
}
|
||||
@@ -178,7 +178,7 @@ void null_access::accept(ast_visitor* visitor) {
|
||||
}
|
||||
|
||||
call_vector::~call_vector() {
|
||||
for(auto i : calls) {
|
||||
for (auto i : calls) {
|
||||
delete i;
|
||||
}
|
||||
}
|
||||
@@ -188,7 +188,7 @@ void call_vector::accept(ast_visitor* visitor) {
|
||||
}
|
||||
|
||||
call_function::~call_function() {
|
||||
for(auto i : args) {
|
||||
for (auto i : args) {
|
||||
delete i;
|
||||
}
|
||||
}
|
||||
@@ -243,7 +243,7 @@ void assignment_expr::accept(ast_visitor* visitor) {
|
||||
}
|
||||
|
||||
multi_identifier::~multi_identifier() {
|
||||
for(auto i : variables) {
|
||||
for (auto i : variables) {
|
||||
delete i;
|
||||
}
|
||||
}
|
||||
@@ -253,7 +253,7 @@ void multi_identifier::accept(ast_visitor* visitor) {
|
||||
}
|
||||
|
||||
tuple_expr::~tuple_expr() {
|
||||
for(auto i : elements) {
|
||||
for (auto i : elements) {
|
||||
delete i;
|
||||
}
|
||||
}
|
||||
@@ -340,7 +340,7 @@ condition_expr::~condition_expr() {
|
||||
if (if_stmt) {
|
||||
delete if_stmt;
|
||||
}
|
||||
for(auto i : elsif_stmt) {
|
||||
for (auto i : elsif_stmt) {
|
||||
delete i;
|
||||
}
|
||||
if (else_stmt) {
|
||||
|
||||
@@ -5,13 +5,13 @@ namespace nasal {
|
||||
|
||||
void codegen::init_file_map(const std::vector<std::string>& file_list) {
|
||||
file_map = {};
|
||||
for(usize i = 0; i<file_list.size(); ++i) {
|
||||
for (usize i = 0; i<file_list.size(); ++i) {
|
||||
file_map.insert({file_list[i], i});
|
||||
}
|
||||
}
|
||||
|
||||
void codegen::load_native_function_table(nasal_builtin_table* table) {
|
||||
for(usize i = 0; table[i].func; ++i) {
|
||||
for (usize i = 0; table[i].func; ++i) {
|
||||
// check confliction
|
||||
if (native_function_mapper.count(table[i].name)) {
|
||||
err.err("code", "\"" + std::string(table[i].name) + "\" conflicts.");
|
||||
@@ -91,7 +91,7 @@ void codegen::regist_string(const std::string& str) {
|
||||
|
||||
void codegen::find_symbol(code_block* node) {
|
||||
auto finder = std::make_unique<symbol_finder>();
|
||||
for(const auto& i : finder->do_find(node)) {
|
||||
for (const auto& i : finder->do_find(node)) {
|
||||
const auto& file = i.pos_node->get_location().file;
|
||||
// check if symbol conflicts with native function name
|
||||
if (native_function_mapper.count(i.name)) {
|
||||
@@ -153,7 +153,7 @@ i64 codegen::upvalue_symbol_find(const std::string& name) {
|
||||
}
|
||||
|
||||
auto iter = local.begin();
|
||||
for(u64 i = 0; i<size-1; ++i, ++iter) {
|
||||
for (u64 i = 0; i<size-1; ++i, ++iter) {
|
||||
if (iter->count(name)) {
|
||||
index = ((i<<16)|(*iter).at(name));
|
||||
}
|
||||
@@ -189,7 +189,7 @@ void codegen::bool_gen(bool_literal* node) {
|
||||
}
|
||||
|
||||
void codegen::vector_gen(vector_expr* node) {
|
||||
for(auto child : node->get_elements()) {
|
||||
for (auto child : node->get_elements()) {
|
||||
calc_gen(child);
|
||||
}
|
||||
emit(op_newv, node->get_elements().size(), node->get_location());
|
||||
@@ -197,7 +197,7 @@ void codegen::vector_gen(vector_expr* node) {
|
||||
|
||||
void codegen::hash_gen(hash_expr* node) {
|
||||
emit(op_newh, 0, node->get_location());
|
||||
for(auto child : node->get_members()) {
|
||||
for (auto child : node->get_members()) {
|
||||
calc_gen(child->get_value());
|
||||
const auto& field_name = child->get_name();
|
||||
regist_string(field_name);
|
||||
@@ -210,7 +210,7 @@ void codegen::func_gen(function* node) {
|
||||
bool checked_default = false;
|
||||
bool checked_dynamic = false;
|
||||
std::unordered_map<std::string, bool> argname;
|
||||
for(auto tmp : node->get_parameter_list()) {
|
||||
for (auto tmp : node->get_parameter_list()) {
|
||||
if (tmp->get_parameter_type()==
|
||||
parameter::kind::default_parameter) {
|
||||
checked_default = true;
|
||||
@@ -250,7 +250,7 @@ void codegen::func_gen(function* node) {
|
||||
local.push_back({{"me", 0}});
|
||||
|
||||
// generate parameter list
|
||||
for(auto tmp : node->get_parameter_list()) {
|
||||
for (auto tmp : node->get_parameter_list()) {
|
||||
const auto& name = tmp->get_parameter_name();
|
||||
if (name=="me") {
|
||||
die("\"me\" should not be parameter", tmp);
|
||||
@@ -326,7 +326,7 @@ void codegen::call_gen(call_expr* node) {
|
||||
if (code.size() && code.back().op==op_callb) {
|
||||
return;
|
||||
}
|
||||
for(auto i : node->get_calls()) {
|
||||
for (auto i : node->get_calls()) {
|
||||
switch(i->get_type()) {
|
||||
case expr_type::ast_callh:
|
||||
call_hash_gen(reinterpret_cast<call_hash*>(i)); break;
|
||||
@@ -404,7 +404,7 @@ void codegen::call_vector_gen(call_vector* node) {
|
||||
return;
|
||||
}
|
||||
emit(op_slcbeg, 0, node->get_location());
|
||||
for(auto tmp : node->get_slices()) {
|
||||
for (auto tmp : node->get_slices()) {
|
||||
if (!tmp->get_end()) {
|
||||
calc_gen(tmp->get_begin());
|
||||
emit(op_slc, 0, tmp->get_location());
|
||||
@@ -421,7 +421,7 @@ void codegen::call_func_gen(call_function* node) {
|
||||
if (node->get_argument().size() &&
|
||||
node->get_argument()[0]->get_type()==expr_type::ast_pair) {
|
||||
emit(op_newh, 0, node->get_location());
|
||||
for(auto child : node->get_argument()) {
|
||||
for (auto child : node->get_argument()) {
|
||||
auto pair_node = reinterpret_cast<hash_pair*>(child);
|
||||
calc_gen(pair_node->get_value());
|
||||
const auto& field_name = pair_node->get_name();
|
||||
@@ -430,7 +430,7 @@ void codegen::call_func_gen(call_function* node) {
|
||||
}
|
||||
emit(op_callfh, 0, node->get_location());
|
||||
} else {
|
||||
for(auto child : node->get_argument()) {
|
||||
for (auto child : node->get_argument()) {
|
||||
calc_gen(child);
|
||||
}
|
||||
emit(op_callfv, node->get_argument().size(), node->get_location());
|
||||
@@ -459,7 +459,7 @@ void codegen::mcall(expr* node) {
|
||||
// generate call expression until the last sub-node
|
||||
auto call_node = static_cast<call_expr*>(node);
|
||||
calc_gen(call_node->get_first());
|
||||
for(usize i = 0; i<call_node->get_calls().size()-1; ++i) {
|
||||
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:
|
||||
@@ -566,7 +566,7 @@ void codegen::multi_def(definition_expr* node) {
|
||||
);
|
||||
return;
|
||||
}
|
||||
for(usize i = 0; i<size; ++i) {
|
||||
for (usize i = 0; i<size; ++i) {
|
||||
calc_gen(vals[i]);
|
||||
const auto& name = identifiers[i]->get_name();
|
||||
local.empty()?
|
||||
@@ -577,7 +577,7 @@ void codegen::multi_def(definition_expr* node) {
|
||||
}
|
||||
// (var a, b, c) = [0, 1, 2];
|
||||
calc_gen(node->get_value());
|
||||
for(usize i = 0; i<size; ++i) {
|
||||
for (usize i = 0; i<size; ++i) {
|
||||
emit(op_callvi, i, node->get_value()->get_location());
|
||||
const auto& name = identifiers[i]->get_name();
|
||||
local.empty()?
|
||||
@@ -787,11 +787,11 @@ void codegen::multi_assign_gen(multi_assign* node) {
|
||||
if (value_node->get_type()==expr_type::ast_tuple) {
|
||||
const auto& value_tuple = reinterpret_cast<tuple_expr*>(value_node)
|
||||
->get_elements();
|
||||
for(i64 i = size-1; i>=0; --i) {
|
||||
for (i64 i = size-1; i>=0; --i) {
|
||||
calc_gen(value_tuple[i]);
|
||||
}
|
||||
auto& tuple = tuple_node->get_elements();
|
||||
for(i64 i = 0; i<size; ++i) {
|
||||
for (i64 i = 0; i<size; ++i) {
|
||||
mcall(tuple[i]);
|
||||
// use load operands to avoid meq's pop operand
|
||||
// and this operation changes local and global value directly
|
||||
@@ -803,7 +803,7 @@ void codegen::multi_assign_gen(multi_assign* node) {
|
||||
// generate multiple assignment: (a, b, c) = [1, 2, 3];
|
||||
calc_gen(value_node);
|
||||
auto& tuple = tuple_node->get_elements();
|
||||
for(i64 i = 0; i<size; ++i) {
|
||||
for (i64 i = 0; i<size; ++i) {
|
||||
emit(op_callvi, i, value_node->get_location());
|
||||
mcall(tuple[i]);
|
||||
// use load operands to avoid meq's pop operand
|
||||
@@ -828,7 +828,7 @@ void codegen::cond_gen(condition_expr* node) {
|
||||
}
|
||||
code[ptr].num = code.size();
|
||||
|
||||
for(auto tmp : node->get_elsif_stataments()) {
|
||||
for (auto tmp : node->get_elsif_stataments()) {
|
||||
calc_gen(tmp->get_condition());
|
||||
ptr = code.size();
|
||||
emit(op_jf, 0, tmp->get_location());
|
||||
@@ -845,7 +845,7 @@ void codegen::cond_gen(condition_expr* node) {
|
||||
if (node->get_else_statement()) {
|
||||
block_gen(node->get_else_statement()->get_code_block());
|
||||
}
|
||||
for(auto i:jmp_label) {
|
||||
for (auto i:jmp_label) {
|
||||
code[i].num = code.size();
|
||||
}
|
||||
}
|
||||
@@ -866,10 +866,10 @@ void codegen::loop_gen(expr* node) {
|
||||
}
|
||||
|
||||
void codegen::load_continue_break(u64 continue_place, u64 break_place) {
|
||||
for(auto i : continue_ptr.front()) {
|
||||
for (auto i : continue_ptr.front()) {
|
||||
code[i].num = continue_place;
|
||||
}
|
||||
for(auto i : break_ptr.front()) {
|
||||
for (auto i : break_ptr.front()) {
|
||||
code[i].num = break_place;
|
||||
}
|
||||
continue_ptr.pop_front();
|
||||
@@ -1287,7 +1287,7 @@ void codegen::repl_mode_info_output_gen(expr* node) {
|
||||
|
||||
void codegen::block_gen(code_block* node) {
|
||||
bool is_use_statement = true;
|
||||
for(auto tmp : node->get_expressions()) {
|
||||
for (auto tmp : node->get_expressions()) {
|
||||
if (tmp->get_type()!=expr_type::ast_use) {
|
||||
is_use_statement = false;
|
||||
}
|
||||
@@ -1348,7 +1348,7 @@ void codegen::block_gen(code_block* node) {
|
||||
}
|
||||
|
||||
void codegen::ret_gen(return_expr* node) {
|
||||
for(u32 i = 0; i<in_foreach_loop_level.back(); ++i) {
|
||||
for (u32 i = 0; i<in_foreach_loop_level.back(); ++i) {
|
||||
emit(op_pop, 0, node->get_location());
|
||||
emit(op_pop, 0, node->get_location());
|
||||
}
|
||||
@@ -1418,12 +1418,12 @@ void codegen::print(std::ostream& out) {
|
||||
std::stack<u64> func_end_stack;
|
||||
|
||||
// print const numbers
|
||||
for(auto num : const_number_table) {
|
||||
for (auto num : const_number_table) {
|
||||
out << " .number " << num << "\n";
|
||||
}
|
||||
|
||||
// print const strings
|
||||
for(const auto& str : const_string_table) {
|
||||
for (const auto& str : const_string_table) {
|
||||
out << " .symbol \"" << util::rawstr(str) << "\"\n";
|
||||
}
|
||||
|
||||
@@ -1440,7 +1440,7 @@ void codegen::print(std::ostream& out) {
|
||||
native_function.data()
|
||||
);
|
||||
|
||||
for(u64 i = 0; i<code.size(); ++i) {
|
||||
for (u64 i = 0; i<code.size(); ++i) {
|
||||
// print opcode index, opcode name, opcode immediate number
|
||||
const auto& c = code[i];
|
||||
if (!func_end_stack.empty() && i==func_end_stack.top()) {
|
||||
@@ -1456,7 +1456,7 @@ void codegen::print(std::ostream& out) {
|
||||
// get function begin index and end index
|
||||
if (c.op==op_newf) {
|
||||
out << std::hex << "\nfunc <0x" << i << std::dec << ">:\n";
|
||||
for(u64 j = i; j<code.size(); ++j) {
|
||||
for (u64 j = i; j<code.size(); ++j) {
|
||||
if (code[j].op==op_jmp) {
|
||||
func_begin_stack.push(i);
|
||||
func_end_stack.push(code[j].num);
|
||||
@@ -1471,9 +1471,9 @@ void codegen::print(std::ostream& out) {
|
||||
}
|
||||
|
||||
void codegen::symbol_dump(std::ostream& out) const {
|
||||
for(const auto& domain : nasal_namespace) {
|
||||
for (const auto& domain : nasal_namespace) {
|
||||
out << "<" << domain.first << ">\n";
|
||||
for(const auto& i : domain.second) {
|
||||
for (const auto& i : domain.second) {
|
||||
out << " 0x" << std::setw(4) << std::setfill('0');
|
||||
out << std::hex << global.at(i) << std::dec << " ";
|
||||
out << i << std::endl;
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
namespace nasal {
|
||||
|
||||
void operand_line_counter::init_counter() {
|
||||
for(usize i = 0; i<operand_line_counter::operand_size; ++i) {
|
||||
for (usize i = 0; i<operand_line_counter::operand_size; ++i) {
|
||||
operand_counter[i] = 0;
|
||||
}
|
||||
}
|
||||
@@ -14,7 +14,7 @@ void operand_line_counter::load_file_line_counter(
|
||||
file_line_counter = {};
|
||||
file_contents = {};
|
||||
filestream fs;
|
||||
for(usize i =0; i<file_list.size(); ++i) {
|
||||
for (usize i =0; i<file_list.size(); ++i) {
|
||||
fs.load(file_list[i]);
|
||||
file_contents.push_back(fs.file_content());
|
||||
file_line_counter.push_back({});
|
||||
@@ -31,7 +31,7 @@ void operand_line_counter::dump_operand_count() const {
|
||||
typedef std::pair<u32, u64> op_count;
|
||||
std::vector<op_count> opcall;
|
||||
u64 total = 0;
|
||||
for(usize i = 0; i<operand_line_counter::operand_size; ++i) {
|
||||
for (usize i = 0; i<operand_line_counter::operand_size; ++i) {
|
||||
total += operand_counter[i];
|
||||
opcall.push_back({i, operand_counter[i]});
|
||||
}
|
||||
@@ -41,7 +41,7 @@ void operand_line_counter::dump_operand_count() const {
|
||||
}
|
||||
);
|
||||
std::clog << "\noperands call info (<1% ignored)\n";
|
||||
for(const auto& i : opcall) {
|
||||
for (const auto& i : opcall) {
|
||||
u64 rate = i.second*100/total;
|
||||
if (!rate) {
|
||||
break;
|
||||
@@ -55,17 +55,17 @@ void operand_line_counter::dump_operand_count() const {
|
||||
|
||||
void operand_line_counter::dump_all_code_line_counter(std::ostream& os) const {
|
||||
u64 max_call_time = 0;
|
||||
for(const auto& context : file_line_counter) {
|
||||
for(const auto& count : context) {
|
||||
for (const auto& context : file_line_counter) {
|
||||
for (const auto& count : context) {
|
||||
max_call_time = count>max_call_time? count:max_call_time;
|
||||
}
|
||||
}
|
||||
auto pad_length = std::to_string(max_call_time).length();
|
||||
for(usize i = 0; i<file_name_list.size(); ++i) {
|
||||
for (usize i = 0; i<file_name_list.size(); ++i) {
|
||||
os << "\ncode profiling data of " << file_name_list[i] << ":\n";
|
||||
const auto& context = file_contents[i];
|
||||
const auto& counter = file_line_counter[i];
|
||||
for(usize j = 0; j<context.size(); ++j) {
|
||||
for (usize j = 0; j<context.size(); ++j) {
|
||||
os << " " << std::right << std::setw(pad_length);
|
||||
os << std::setfill(' ');
|
||||
os << (counter[j]==0? "":std::to_string(counter[j]));
|
||||
@@ -76,7 +76,7 @@ void operand_line_counter::dump_all_code_line_counter(std::ostream& os) const {
|
||||
|
||||
void operand_line_counter::dump_this_file_line_counter(std::ostream& os) const {
|
||||
u64 max_call_time = 0;
|
||||
for(const auto& count : file_line_counter[0]) {
|
||||
for (const auto& count : file_line_counter[0]) {
|
||||
max_call_time = count>max_call_time? count:max_call_time;
|
||||
}
|
||||
auto pad_length = std::to_string(max_call_time).length();
|
||||
@@ -84,7 +84,7 @@ void operand_line_counter::dump_this_file_line_counter(std::ostream& os) const {
|
||||
os << "\ncode profiling data of " << file_name_list[0] << ":\n";
|
||||
const auto& context = file_contents[0];
|
||||
const auto& counter = file_line_counter[0];
|
||||
for(usize i = 0; i<context.size(); ++i) {
|
||||
for (usize i = 0; i<context.size(); ++i) {
|
||||
os << " " << std::right << std::setw(pad_length);
|
||||
os << std::setfill(' ');
|
||||
os << (counter[i]==0? "":std::to_string(counter[i]));
|
||||
@@ -109,7 +109,7 @@ std::vector<std::string> dbg::parse(const std::string& cmd) {
|
||||
}
|
||||
|
||||
u16 dbg::file_index(const std::string& filename) const {
|
||||
for(u16 i = 0; i<file_list_size; ++i) {
|
||||
for (u16 i = 0; i<file_list_size; ++i) {
|
||||
if (filename==files[i]) {
|
||||
return i;
|
||||
}
|
||||
@@ -142,7 +142,7 @@ void dbg::help() const {
|
||||
}
|
||||
|
||||
void dbg::list_file() const {
|
||||
for(usize i = 0; i<file_list_size; ++i) {
|
||||
for (usize i = 0; i<file_list_size; ++i) {
|
||||
std::clog << "[" << i << "] " << files[i] << "\n";
|
||||
}
|
||||
}
|
||||
@@ -156,7 +156,7 @@ void dbg::step_info() {
|
||||
|
||||
std::clog << clear_screen << set_cursor;
|
||||
std::clog << "\nsource code:\n";
|
||||
for(u64 i = begin; i<end && i<src.size(); ++i) {
|
||||
for (u64 i = begin; i<end && i<src.size(); ++i) {
|
||||
std::clog << (i==line? back_white:reset);
|
||||
std::clog << (i==line? "--> ":" ") << src[i] << reset << "\n";
|
||||
}
|
||||
@@ -172,7 +172,7 @@ void dbg::step_info() {
|
||||
);
|
||||
|
||||
std::clog << "\nnext bytecode:\n";
|
||||
for(u64 i = begin; i<end && bytecode[i].op!=op_exit; ++i) {
|
||||
for (u64 i = begin; i<end && bytecode[i].op!=op_exit; ++i) {
|
||||
std::clog
|
||||
<< (i==ctx.pc? back_white:reset)
|
||||
<< (i==ctx.pc? "--> ":" ")
|
||||
@@ -273,7 +273,7 @@ void dbg::run(const codegen& gen,
|
||||
std::vector<u8> code;
|
||||
std::vector<u16> code_file_index;
|
||||
std::vector<u64> code_line;
|
||||
for(const auto& i : gen.codes()) {
|
||||
for (const auto& i : gen.codes()) {
|
||||
code.push_back(i.op);
|
||||
code_file_index.push_back(i.fidx);
|
||||
code_line.push_back(i.line);
|
||||
|
||||
@@ -182,7 +182,7 @@ void error::err(const std::string& stage,
|
||||
const usize maxlen = std::to_string(loc.end_line).length();
|
||||
const std::string iden = identation(maxlen);
|
||||
|
||||
for(u64 line = loc.begin_line; line<=loc.end_line; ++line) {
|
||||
for (u64 line = loc.begin_line; line<=loc.end_line; ++line) {
|
||||
// skip line 0
|
||||
if (!line) {
|
||||
continue;
|
||||
@@ -211,25 +211,25 @@ void error::err(const std::string& stage,
|
||||
// output underline
|
||||
std::cerr << cyan << iden << " | " << reset;
|
||||
if (loc.begin_line==loc.end_line) {
|
||||
for(u64 i = 0; i<loc.begin_column; ++i) {
|
||||
for (u64 i = 0; i<loc.begin_column; ++i) {
|
||||
std::cerr << char(" \t"[code[i]=='\t']);
|
||||
}
|
||||
for(u64 i = loc.begin_column; i<loc.end_column; ++i) {
|
||||
for (u64 i = loc.begin_column; i<loc.end_column; ++i) {
|
||||
std::cerr << red << (code[i]=='\t'? "^^^^":"^") << reset;
|
||||
}
|
||||
} else if (line==loc.begin_line) {
|
||||
for(u64 i = 0; i<loc.begin_column; ++i) {
|
||||
for (u64 i = 0; i<loc.begin_column; ++i) {
|
||||
std::cerr << char(" \t"[code[i]=='\t']);
|
||||
}
|
||||
for(u64 i = loc.begin_column; i<code.size(); ++i) {
|
||||
for (u64 i = loc.begin_column; i<code.size(); ++i) {
|
||||
std::cerr << red << (code[i]=='\t'? "^^^^":"^") << reset;
|
||||
}
|
||||
} else if (loc.begin_line<line && line<loc.end_line) {
|
||||
for(u64 i = 0; i<code.size(); ++i) {
|
||||
for (u64 i = 0; i<code.size(); ++i) {
|
||||
std::cerr << red << (code[i]=='\t'? "^^^^":"^");
|
||||
}
|
||||
} else {
|
||||
for(u64 i = 0; i<loc.end_column; ++i) {
|
||||
for (u64 i = 0; i<loc.end_column; ++i) {
|
||||
std::cerr << red << (code[i]=='\t'? "^^^^":"^");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -58,7 +58,7 @@ void gc::mark() {
|
||||
|
||||
void gc::concurrent_mark(std::vector<var>& vec, usize begin, usize end) {
|
||||
std::vector<var> bfs;
|
||||
for(auto i = begin; i<end; ++i) {
|
||||
for (auto i = begin; i<end; ++i) {
|
||||
var value = vec[i];
|
||||
if (value.type<=vm_type::vm_num ||
|
||||
value.val.gcobj->mark!=nas_val::gc_status::uncollected) {
|
||||
@@ -79,14 +79,14 @@ void gc::concurrent_mark(std::vector<var>& vec, usize begin, usize end) {
|
||||
|
||||
void gc::mark_context_root(std::vector<var>& bfs_queue) {
|
||||
// scan global
|
||||
for(usize i = 0; i < main_context_global_size; ++i) {
|
||||
for (usize i = 0; i < main_context_global_size; ++i) {
|
||||
auto& val = main_context_global[i];
|
||||
if (val.type > vm_type::vm_num) {
|
||||
bfs_queue.push_back(val);
|
||||
}
|
||||
}
|
||||
// scan now running context, this context maybe related to coroutine or main
|
||||
for(var* i = running_context->stack; i <= running_context->top; ++i) {
|
||||
for (var* i = running_context->stack; i <= running_context->top; ++i) {
|
||||
if (i->type > vm_type::vm_num) {
|
||||
bfs_queue.push_back(*i);
|
||||
}
|
||||
@@ -100,7 +100,7 @@ void gc::mark_context_root(std::vector<var>& bfs_queue) {
|
||||
}
|
||||
|
||||
// coroutine is running, so scan main process stack from mctx
|
||||
for(var* i = main_context.stack; i <= main_context.top; ++i) {
|
||||
for (var* i = main_context.stack; i <= main_context.top; ++i) {
|
||||
if (i->type > vm_type::vm_num) {
|
||||
bfs_queue.push_back(*i);
|
||||
}
|
||||
@@ -124,7 +124,7 @@ void gc::mark_var(std::vector<var>& bfs_queue, var& value) {
|
||||
}
|
||||
|
||||
void gc::mark_vec(std::vector<var>& bfs_queue, nas_vec& vec) {
|
||||
for(auto& i : vec.elems) {
|
||||
for (auto& i : vec.elems) {
|
||||
if (i.type > vm_type::vm_num) {
|
||||
bfs_queue.push_back(i);
|
||||
}
|
||||
@@ -132,7 +132,7 @@ void gc::mark_vec(std::vector<var>& bfs_queue, nas_vec& vec) {
|
||||
}
|
||||
|
||||
void gc::mark_hash(std::vector<var>& bfs_queue, nas_hash& hash) {
|
||||
for(auto& i : hash.elems) {
|
||||
for (auto& i : hash.elems) {
|
||||
if (i.second.type > vm_type::vm_num) {
|
||||
bfs_queue.push_back(i.second);
|
||||
}
|
||||
@@ -140,18 +140,18 @@ void gc::mark_hash(std::vector<var>& bfs_queue, nas_hash& hash) {
|
||||
}
|
||||
|
||||
void gc::mark_func(std::vector<var>& bfs_queue, nas_func& function) {
|
||||
for(auto& i : function.local) {
|
||||
for (auto& i : function.local) {
|
||||
if (i.type > vm_type::vm_num) {
|
||||
bfs_queue.push_back(i);
|
||||
}
|
||||
}
|
||||
for(auto& i : function.upval) {
|
||||
for (auto& i : function.upval) {
|
||||
bfs_queue.push_back(i);
|
||||
}
|
||||
}
|
||||
|
||||
void gc::mark_upval(std::vector<var>& bfs_queue, nas_upval& upval) {
|
||||
for(auto& i : upval.elems) {
|
||||
for (auto& i : upval.elems) {
|
||||
if (i.type > vm_type::vm_num) {
|
||||
bfs_queue.push_back(i);
|
||||
}
|
||||
@@ -168,7 +168,7 @@ void gc::mark_ghost(std::vector<var>& bfs_queue, nas_ghost& ghost) {
|
||||
void gc::mark_co(std::vector<var>& bfs_queue, nas_co& co) {
|
||||
bfs_queue.push_back(co.ctx.funcr);
|
||||
bfs_queue.push_back(co.ctx.upvalr);
|
||||
for(var* i = co.ctx.stack; i<=co.ctx.top; ++i) {
|
||||
for (var* i = co.ctx.stack; i<=co.ctx.top; ++i) {
|
||||
if (i->type > vm_type::vm_num) {
|
||||
bfs_queue.push_back(*i);
|
||||
}
|
||||
@@ -176,7 +176,7 @@ void gc::mark_co(std::vector<var>& bfs_queue, nas_co& co) {
|
||||
}
|
||||
|
||||
void gc::mark_map(std::vector<var>& bfs_queue, nas_map& mp) {
|
||||
for(const auto& i : mp.mapper) {
|
||||
for (const auto& i : mp.mapper) {
|
||||
if (i.second->type > vm_type::vm_num) {
|
||||
bfs_queue.push_back(*i.second);
|
||||
}
|
||||
@@ -211,7 +211,7 @@ void gc::extend(const vm_type type) {
|
||||
const u32 index = static_cast<u32>(type)-static_cast<u32>(vm_type::vm_str);
|
||||
status.object_size[index] += incr[index];
|
||||
|
||||
for(u64 i = 0; i<incr[index]; ++i) {
|
||||
for (u64 i = 0; i<incr[index]; ++i) {
|
||||
// no need to check, will be killed if memory is not enough
|
||||
nas_val* tmp = new nas_val(type);
|
||||
|
||||
@@ -281,14 +281,14 @@ void gc::init(const std::vector<std::string>& constant_strings,
|
||||
}
|
||||
|
||||
void gc::clear() {
|
||||
for(auto i : memory) {
|
||||
for (auto i : memory) {
|
||||
delete i;
|
||||
}
|
||||
memory.clear();
|
||||
for(u32 i = 0; i<GC_TYPE_SIZE; ++i) {
|
||||
for (u32 i = 0; i<GC_TYPE_SIZE; ++i) {
|
||||
unused[i].clear();
|
||||
}
|
||||
for(auto& i : strs) {
|
||||
for (auto& i : strs) {
|
||||
delete i.val.gcobj;
|
||||
}
|
||||
strs.clear();
|
||||
|
||||
@@ -36,7 +36,7 @@ std::string linker::get_path(expr* node) {
|
||||
if (node->get_type()==expr_type::ast_use) {
|
||||
auto file_relative_path = std::string("");
|
||||
const auto& path = reinterpret_cast<use_stmt*>(node)->get_path();
|
||||
for(auto i : path) {
|
||||
for (auto i : path) {
|
||||
file_relative_path += i->get_name();
|
||||
if (i!=path.back()) {
|
||||
file_relative_path += (util::is_windows()? "\\":"/");
|
||||
@@ -56,12 +56,12 @@ std::string linker::find_real_file_path(const std::string& filename,
|
||||
std::vector<fs::path> path_list = {filename};
|
||||
|
||||
// generate search path from environ path
|
||||
for(const auto& p : envpath) {
|
||||
for (const auto& p : envpath) {
|
||||
path_list.push_back(fs::path(p)/filename);
|
||||
}
|
||||
|
||||
// search file
|
||||
for(const auto& path : path_list) {
|
||||
for (const auto& path : path_list) {
|
||||
if (fs::exists(path)) {
|
||||
return path.str();
|
||||
}
|
||||
@@ -82,7 +82,7 @@ std::string linker::find_real_file_path(const std::string& filename,
|
||||
return "";
|
||||
}
|
||||
auto path_list_info = std::string("");
|
||||
for(const auto& path : path_list) {
|
||||
for (const auto& path : path_list) {
|
||||
path_list_info += " -> " + path.str() + "\n";
|
||||
}
|
||||
err.err("link",
|
||||
@@ -138,7 +138,7 @@ bool linker::import_check(expr* node) {
|
||||
|
||||
bool linker::check_exist_or_record_file(const std::string& file) {
|
||||
// avoid importing the same file
|
||||
for(const auto& name : imported_files) {
|
||||
for (const auto& name : imported_files) {
|
||||
if (file==name) {
|
||||
return true;
|
||||
}
|
||||
@@ -148,7 +148,7 @@ bool linker::check_exist_or_record_file(const std::string& file) {
|
||||
}
|
||||
|
||||
bool linker::check_self_import(const std::string& file) {
|
||||
for(const auto& name : module_load_stack) {
|
||||
for (const auto& name : module_load_stack) {
|
||||
if (file==name) {
|
||||
return true;
|
||||
}
|
||||
@@ -158,7 +158,7 @@ bool linker::check_self_import(const std::string& file) {
|
||||
|
||||
std::string linker::generate_self_import_path(const std::string& filename) {
|
||||
std::string res = "";
|
||||
for(const auto& i : module_load_stack) {
|
||||
for (const auto& i : module_load_stack) {
|
||||
res += "[" + i + "] -> ";
|
||||
}
|
||||
return res + "[" + filename + "]";
|
||||
@@ -166,7 +166,7 @@ std::string linker::generate_self_import_path(const std::string& filename) {
|
||||
|
||||
void linker::merge_tree(code_block* new_tree_root, code_block* old_tree_root) {
|
||||
// add children of add_root to the back of root
|
||||
for(auto& i : old_tree_root->get_expressions()) {
|
||||
for (auto& i : old_tree_root->get_expressions()) {
|
||||
new_tree_root->add_expression(i);
|
||||
}
|
||||
// clean old root
|
||||
@@ -329,7 +329,7 @@ return_expr* linker::generate_module_return(code_block* block) {
|
||||
auto result = new return_expr(block->get_location());
|
||||
auto value = new hash_expr(block->get_location());
|
||||
result->set_value(value);
|
||||
for(const auto& i : finder->do_find(block)) {
|
||||
for (const auto& i : finder->do_find(block)) {
|
||||
auto pair = new hash_pair(block->get_location());
|
||||
// do not export symbol begins with '_'
|
||||
if (i.name.length() && i.name[0]=='_') {
|
||||
@@ -369,7 +369,7 @@ definition_expr* linker::generate_module_definition(code_block* block) {
|
||||
void linker::load(code_block* program_root, const std::string& filename) {
|
||||
// load imported modules
|
||||
std::unordered_set<std::string> used_modules = {};
|
||||
for(auto& import_node : program_root->get_expressions()) {
|
||||
for (auto& import_node : program_root->get_expressions()) {
|
||||
if (!import_check(import_node)) {
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -124,7 +124,7 @@ std::string lexer::utf8_gen() {
|
||||
}
|
||||
|
||||
tmp += res[ptr++];
|
||||
for(u32 i = 0; i<nbytes; ++i, ++ptr) {
|
||||
for (u32 i = 0; i<nbytes; ++i, ++ptr) {
|
||||
if (ptr<res.size() && (res[ptr]&0xc0)==0x80) {
|
||||
tmp += res[ptr];
|
||||
}
|
||||
@@ -134,7 +134,7 @@ std::string lexer::utf8_gen() {
|
||||
if (tmp.length()!=1+nbytes) {
|
||||
++column;
|
||||
std::string utf_info = "0x" + util::char_to_hex(tmp[0]);
|
||||
for(u32 i = 1; i<tmp.size(); ++i) {
|
||||
for (u32 i = 1; i<tmp.size(); ++i) {
|
||||
utf_info += " 0x" + util::char_to_hex(tmp[i]);
|
||||
}
|
||||
err.err("lexer",
|
||||
|
||||
@@ -14,7 +14,7 @@ void codestream::set(const f64* number_list,
|
||||
files = file_list;
|
||||
|
||||
global_variable.resize(globals.size());
|
||||
for(auto& [name, index]: globals) {
|
||||
for (auto& [name, index]: globals) {
|
||||
global_variable[index] = name;
|
||||
}
|
||||
}
|
||||
@@ -47,7 +47,7 @@ void codestream::dump(std::ostream& out) const {
|
||||
<< setw(2) << setfill('0') << static_cast<u32>(op) << ":" << dec;
|
||||
|
||||
// dump immediate number(hex format)
|
||||
for(i32 i = 64-8; i>=0; i -= 8) {
|
||||
for (i32 i = 64-8; i>=0; i -= 8) {
|
||||
auto this_byte = ((num>>i)&0xff);
|
||||
out << hex << setw(2) << setfill('0') << this_byte << dec << " ";
|
||||
}
|
||||
|
||||
@@ -103,7 +103,7 @@ bool parse::is_call(tok type) {
|
||||
}
|
||||
|
||||
bool parse::check_comma(const tok* panic_set) {
|
||||
for(u32 i = 0; panic_set[i]!=tok::tk_null; ++i) {
|
||||
for (u32 i = 0; panic_set[i]!=tok::tk_null; ++i) {
|
||||
if (lookahead(panic_set[i])) {
|
||||
die(prevspan, "expected \",\" between scalars");
|
||||
return true;
|
||||
@@ -987,7 +987,7 @@ for_expr* parse::for_loop() {
|
||||
} else {
|
||||
node->set_initial(calc());
|
||||
}
|
||||
match(tok::tk_semi, "expected \";\" in for(;;)");
|
||||
match(tok::tk_semi, "expected \";\" in for (;;)");
|
||||
|
||||
// conditional expression
|
||||
if (lookahead(tok::tk_eof)) {
|
||||
@@ -998,7 +998,7 @@ for_expr* parse::for_loop() {
|
||||
} else {
|
||||
node->set_condition(calc());
|
||||
}
|
||||
match(tok::tk_semi, "expected \";\" in for(;;)");
|
||||
match(tok::tk_semi, "expected \";\" in for (;;)");
|
||||
|
||||
//after loop expression
|
||||
if (lookahead(tok::tk_eof)) {
|
||||
|
||||
@@ -14,7 +14,7 @@ std::ostream& operator<<(std::ostream& out, nas_vec& vec) {
|
||||
vec.printed = true;
|
||||
usize iter = 0, size = vec.elems.size();
|
||||
out << "[";
|
||||
for(auto& i:vec.elems) {
|
||||
for (auto& i:vec.elems) {
|
||||
out << i << ",]"[(++iter)==size];
|
||||
}
|
||||
vec.printed = false;
|
||||
@@ -34,7 +34,7 @@ var nas_hash::get_value(const std::string& key) {
|
||||
if (!val.is_vec()) {
|
||||
return ret;
|
||||
}
|
||||
for(auto& i : val.vec().elems) {
|
||||
for (auto& i : val.vec().elems) {
|
||||
if (i.is_hash()) {
|
||||
ret = i.hash().get_value(key);
|
||||
}
|
||||
@@ -58,7 +58,7 @@ var* nas_hash::get_memory(const std::string& key) {
|
||||
if (!val.is_vec()) {
|
||||
return addr;
|
||||
}
|
||||
for(auto& i : val.vec().elems) {
|
||||
for (auto& i : val.vec().elems) {
|
||||
// recursively search key in `parents`
|
||||
if (i.is_hash()) {
|
||||
addr = i.hash().get_memory(key);
|
||||
@@ -82,7 +82,7 @@ std::ostream& operator<<(std::ostream& out, nas_hash& hash) {
|
||||
static const char* sep[] = {", ", "}"};
|
||||
usize iter = 0, size = hash.elems.size();
|
||||
out << "{";
|
||||
for(auto& i : hash.elems) {
|
||||
for (auto& i : hash.elems) {
|
||||
out << i.first << ": " << i.second << sep[(++iter)==size];
|
||||
}
|
||||
|
||||
@@ -96,11 +96,11 @@ std::ostream& operator<<(std::ostream& out, nas_func& func) {
|
||||
|
||||
std::vector<std::string> argument_list = {};
|
||||
argument_list.resize(func.keys.size());
|
||||
for(const auto& key : func.keys) {
|
||||
for (const auto& key : func.keys) {
|
||||
argument_list[key.second-1] = key.first;
|
||||
}
|
||||
|
||||
for(const auto& key : argument_list) {
|
||||
for (const auto& key : argument_list) {
|
||||
out << key;
|
||||
if (key != argument_list.back()) {
|
||||
out << ", ";
|
||||
@@ -163,7 +163,7 @@ void nas_co::clear() {
|
||||
if (!ctx.stack) {
|
||||
return;
|
||||
}
|
||||
for(u32 i = 0; i<VM_STACK_DEPTH; ++i) {
|
||||
for (u32 i = 0; i<VM_STACK_DEPTH; ++i) {
|
||||
ctx.stack[i] = var::nil();
|
||||
}
|
||||
|
||||
@@ -210,7 +210,7 @@ std::ostream& operator<<(std::ostream& out, nas_map& mp) {
|
||||
static const char* sep[] = {", ", "}"};
|
||||
usize iter = 0, size = mp.mapper.size();
|
||||
out << "{";
|
||||
for(auto& i : mp.mapper) {
|
||||
for (auto& i : mp.mapper) {
|
||||
out << i.first << ": " << *i.second << sep[(++iter)==size];
|
||||
}
|
||||
|
||||
|
||||
@@ -33,7 +33,7 @@ void vm::vm_init_enrty(const std::vector<std::string>& strs,
|
||||
auto map_instance = ngc.alloc(vm_type::vm_map);
|
||||
global_symbol_name.resize(global_symbol.size());
|
||||
global[global_symbol.at("globals")] = map_instance;
|
||||
for(const auto& i : global_symbol) {
|
||||
for (const auto& i : global_symbol) {
|
||||
map_instance.map().mapper[i.first] = global + i.second;
|
||||
global_symbol_name[i.second] = i.first;
|
||||
}
|
||||
@@ -59,7 +59,7 @@ void vm::context_and_global_init() {
|
||||
ctx.top = ctx.stack - 1;
|
||||
|
||||
/* clear main stack and global */
|
||||
for(u32 i = 0; i<VM_STACK_DEPTH; ++i) {
|
||||
for (u32 i = 0; i<VM_STACK_DEPTH; ++i) {
|
||||
ctx.stack[i] = nil;
|
||||
global[i] = nil;
|
||||
}
|
||||
@@ -95,7 +95,7 @@ void vm::vector_value_info(var& val) {
|
||||
void vm::hash_value_info(var& val, const usize max_show_elems) {
|
||||
std::clog << "{";
|
||||
usize count = 0;
|
||||
for(const auto& i : val.hash().elems) {
|
||||
for (const auto& i : val.hash().elems) {
|
||||
++count;
|
||||
if (count>max_show_elems) {
|
||||
break;
|
||||
@@ -126,7 +126,7 @@ void vm::coroutine_value_info(var& val) {
|
||||
void vm::namespace_value_info(var& val, const usize max_show_elems) {
|
||||
std::clog << "{";
|
||||
usize count = 0;
|
||||
for(const auto& i : val.map().mapper) {
|
||||
for (const auto& i : val.map().mapper) {
|
||||
++count;
|
||||
if (count>max_show_elems) {
|
||||
break;
|
||||
@@ -194,12 +194,12 @@ void vm::function_detail_info(const nas_func& func) {
|
||||
|
||||
std::vector<std::string> argument_list = {};
|
||||
argument_list.resize(func.keys.size());
|
||||
for(const auto& key : func.keys) {
|
||||
for (const auto& key : func.keys) {
|
||||
argument_list[key.second-1] = key.first;
|
||||
}
|
||||
|
||||
std::clog << "(";
|
||||
for(const auto& key : argument_list) {
|
||||
for (const auto& key : argument_list) {
|
||||
std::clog << key;
|
||||
if (key != argument_list.back()) {
|
||||
std::clog << ", ";
|
||||
@@ -226,7 +226,7 @@ void vm::function_call_trace() {
|
||||
std::stack<u64> callsite;
|
||||
|
||||
// load call trace, from bottom to top
|
||||
for(var* i = bottom; i <= top; ++i) {
|
||||
for (var* i = bottom; i <= top; ++i) {
|
||||
// i-1 is the callsite program counter of this function
|
||||
// +-------+----------------+
|
||||
// | func | func() {..} | <-- i + 2
|
||||
@@ -250,7 +250,7 @@ void vm::function_call_trace() {
|
||||
|
||||
// another condition may exist
|
||||
// have ret pc on stack, but no function at the top of the ret pc
|
||||
for(var * i = top; i >= bottom; --i) {
|
||||
for (var * i = top; i >= bottom; --i) {
|
||||
// +-------+----------------+
|
||||
// | xxxx | xxxx | <-- i + 2 (not function or not exist)
|
||||
// +-------+----------------+
|
||||
@@ -282,7 +282,7 @@ void vm::function_call_trace() {
|
||||
const nas_func* last = nullptr;
|
||||
u64 last_callsite = SIZE_MAX;
|
||||
u64 same_count = 0;
|
||||
for(; !functions.empty() && !callsite.empty(); functions.pop(), callsite.pop()) {
|
||||
for (; !functions.empty() && !callsite.empty(); functions.pop(), callsite.pop()) {
|
||||
auto func = functions.top();
|
||||
auto place = callsite.top();
|
||||
|
||||
@@ -316,7 +316,7 @@ void vm::function_call_trace() {
|
||||
void vm::trace_back() {
|
||||
// generate trace back
|
||||
std::stack<u64> ret;
|
||||
for(var* i = ctx.stack; i<=ctx.top; ++i) {
|
||||
for (var* i = ctx.stack; i<=ctx.top; ++i) {
|
||||
if (i->is_ret() && i->ret()!=0) {
|
||||
ret.push(i->ret());
|
||||
}
|
||||
@@ -335,7 +335,7 @@ void vm::trace_back() {
|
||||
files
|
||||
);
|
||||
|
||||
for(u64 p = 0, same = 0, prev = 0xffffffff; !ret.empty(); prev = p, ret.pop()) {
|
||||
for (u64 p = 0, same = 0, prev = 0xffffffff; !ret.empty(); prev = p, ret.pop()) {
|
||||
if ((p = ret.top())==prev) {
|
||||
++same;
|
||||
continue;
|
||||
@@ -360,7 +360,7 @@ void vm::stack_info(const u64 limit) {
|
||||
std::clog << ", limit " << limit << ", total ";
|
||||
std::clog << (top<bottom? 0:static_cast<i64>(top-bottom+1)) << ")\n";
|
||||
|
||||
for(u32 i = 0; i<limit && top>=bottom; ++i, --top) {
|
||||
for (u32 i = 0; i<limit && top>=bottom; ++i, --top) {
|
||||
std::clog << " 0x" << std::hex
|
||||
<< std::setw(8) << std::setfill('0')
|
||||
<< static_cast<u64>(top-bottom) << std::dec
|
||||
@@ -394,7 +394,7 @@ void vm::global_state() {
|
||||
}
|
||||
std::clog << "\nglobal (0x" << std::hex
|
||||
<< reinterpret_cast<u64>(global) << ")\n" << std::dec;
|
||||
for(usize i = 0; i<global_size; ++i) {
|
||||
for (usize i = 0; i<global_size; ++i) {
|
||||
std::clog << " 0x" << std::hex << std::setw(8)
|
||||
<< std::setfill('0') << static_cast<u64>(i) << std::dec
|
||||
<< " ";
|
||||
@@ -419,7 +419,7 @@ void vm::local_state() {
|
||||
std::clog << "\nlocal (0x" << std::hex << reinterpret_cast<u64>(ctx.localr)
|
||||
<< " <+" << static_cast<u64>(ctx.localr-ctx.stack)
|
||||
<< ">)\n" << std::dec;
|
||||
for(u32 i = 0; i<lsize; ++i) {
|
||||
for (u32 i = 0; i<lsize; ++i) {
|
||||
std::clog << " 0x" << std::hex << std::setw(8)
|
||||
<< std::setfill('0') << i << std::dec
|
||||
<< " ";
|
||||
@@ -433,10 +433,10 @@ void vm::upvalue_state() {
|
||||
}
|
||||
std::clog << "\nupvalue\n";
|
||||
auto& upval = ctx.funcr.func().upval;
|
||||
for(u32 i = 0; i<upval.size(); ++i) {
|
||||
for (u32 i = 0; i<upval.size(); ++i) {
|
||||
std::clog << " -> upval[" << i << "]:\n";
|
||||
auto& uv = upval[i].upval();
|
||||
for(u32 j = 0; j<uv.size; ++j) {
|
||||
for (u32 j = 0; j<uv.size; ++j) {
|
||||
std::clog << " 0x" << std::hex << std::setw(8)
|
||||
<< std::setfill('0') << j << std::dec
|
||||
<< " ";
|
||||
@@ -456,10 +456,10 @@ std::string vm::report_lack_arguments(u32 argc, const nas_func& func) const {
|
||||
auto result = std::string("lack argument(s) when calling function:\n func(");
|
||||
std::vector<std::string> argument_list = {};
|
||||
argument_list.resize(func.keys.size());
|
||||
for(const auto& i : func.keys) {
|
||||
for (const auto& i : func.keys) {
|
||||
argument_list[i.second-1] = i.first;
|
||||
}
|
||||
for(u32 i = 0; i<argument_list.size(); ++i) {
|
||||
for (u32 i = 0; i<argument_list.size(); ++i) {
|
||||
result += argument_list[i];
|
||||
if (i<argc) {
|
||||
result += "[get]";
|
||||
@@ -485,10 +485,10 @@ std::string vm::report_special_call_lack_arguments(var* local,
|
||||
auto result = std::string("lack argument(s) when calling function:\n func(");
|
||||
std::vector<std::string> argument_list = {};
|
||||
argument_list.resize(func.keys.size());
|
||||
for(const auto& i : func.keys) {
|
||||
for (const auto& i : func.keys) {
|
||||
argument_list[i.second-1] = i.first;
|
||||
}
|
||||
for(const auto& key : argument_list) {
|
||||
for (const auto& key : argument_list) {
|
||||
if (local[func.keys.at(key)].is_none()) {
|
||||
result += key + ", ";
|
||||
} else {
|
||||
@@ -507,7 +507,7 @@ std::string vm::report_special_call_lack_arguments(var* local,
|
||||
std::string vm::report_key_not_found(const std::string& not_found,
|
||||
const nas_hash& hash) const {
|
||||
auto result = "member \"" + not_found + "\" doesn't exist in hash {";
|
||||
for(const auto& i : hash.elems) {
|
||||
for (const auto& i : hash.elems) {
|
||||
result += i.first + ", ";
|
||||
}
|
||||
if (hash.elems.size()) {
|
||||
@@ -696,7 +696,7 @@ void vm::run(const codegen& gen,
|
||||
&&ret
|
||||
};
|
||||
std::vector<const void*> code;
|
||||
for(const auto& i : gen.codes()) {
|
||||
for (const auto& i : gen.codes()) {
|
||||
code.push_back(oprs[i.op]);
|
||||
imm.push_back(i.num);
|
||||
}
|
||||
@@ -705,7 +705,7 @@ void vm::run(const codegen& gen,
|
||||
goto *code[ctx.pc];
|
||||
#else
|
||||
std::vector<nasal_vm_func> code;
|
||||
for(const auto& i : gen.codes()) {
|
||||
for (const auto& i : gen.codes()) {
|
||||
code.push_back(operand_function[i.op]);
|
||||
imm.push_back(i.num);
|
||||
}
|
||||
|
||||
@@ -413,7 +413,7 @@ inline void vm::o_newv() {
|
||||
// use top-=imm[pc]-1 here will cause error if imm[pc] is 0
|
||||
ctx.top = ctx.top - imm[ctx.pc] + 1;
|
||||
|
||||
for(u64 i = 0; i<imm[ctx.pc]; ++i) {
|
||||
for (u64 i = 0; i<imm[ctx.pc]; ++i) {
|
||||
vec[i] = ctx.top[i];
|
||||
}
|
||||
ctx.top[0] = newv;
|
||||
@@ -537,10 +537,10 @@ inline void vm::o_lnk() {
|
||||
// concat two vectors into one
|
||||
if (ctx.top[-1].is_vec() && ctx.top[0].is_vec()) {
|
||||
ngc.temp = ngc.alloc(vm_type::vm_vec);
|
||||
for(auto& i : ctx.top[-1].vec().elems) {
|
||||
for (auto& i : ctx.top[-1].vec().elems) {
|
||||
ngc.temp.vec().elems.push_back(i);
|
||||
}
|
||||
for(auto& i : ctx.top[0].vec().elems) {
|
||||
for (auto& i : ctx.top[0].vec().elems) {
|
||||
ngc.temp.vec().elems.push_back(i);
|
||||
}
|
||||
ctx.top[-1] = ngc.temp;
|
||||
@@ -584,10 +584,10 @@ inline void vm::o_lnkeq() {
|
||||
// concat two vectors into one
|
||||
if (ctx.top[-1].is_vec() && ctx.memr[0].is_vec()) {
|
||||
ngc.temp = ngc.alloc(vm_type::vm_vec);
|
||||
for(auto i : ctx.memr[0].vec().elems) {
|
||||
for (auto i : ctx.memr[0].vec().elems) {
|
||||
ngc.temp.vec().elems.push_back(i);
|
||||
}
|
||||
for(auto i : ctx.top[-1].vec().elems) {
|
||||
for (auto i : ctx.top[-1].vec().elems) {
|
||||
ngc.temp.vec().elems.push_back(i);
|
||||
}
|
||||
ctx.top[-1] = ctx.memr[0] = ngc.temp;
|
||||
@@ -919,13 +919,13 @@ inline void vm::o_callfv() {
|
||||
if (func.dynamic_parameter_index>=0) {
|
||||
// load dynamic argument
|
||||
dynamic = ngc.alloc(vm_type::vm_vec);
|
||||
for(u64 i = parameter_size; i<argc; ++i) {
|
||||
for (u64 i = parameter_size; i<argc; ++i) {
|
||||
dynamic.vec().elems.push_back(local[i]);
|
||||
}
|
||||
} else if (parameter_size<argc) {
|
||||
// load arguments to default dynamic argument "arg", located at stack+1
|
||||
dynamic = ngc.alloc(vm_type::vm_vec);
|
||||
for(u64 i = parameter_size; i<argc; ++i) {
|
||||
for (u64 i = parameter_size; i<argc; ++i) {
|
||||
dynamic.vec().elems.push_back(local[i]);
|
||||
}
|
||||
}
|
||||
@@ -942,13 +942,13 @@ inline void vm::o_callfv() {
|
||||
const u64 min_size = (std::min)(parameter_size, argc);
|
||||
|
||||
// load arguments
|
||||
for(u64 i = min_size; i>=1; --i) {
|
||||
for (u64 i = min_size; i>=1; --i) {
|
||||
local[i] = local[i-1];
|
||||
}
|
||||
local[0] = func.local[0]; // load "me"
|
||||
|
||||
// load local scope & default arguments
|
||||
for(u64 i = min_size + 1; i<func.local_size; ++i) {
|
||||
for (u64 i = min_size + 1; i<func.local_size; ++i) {
|
||||
local[i] = func.local[i];
|
||||
}
|
||||
|
||||
@@ -986,12 +986,12 @@ inline void vm::o_callfh() {
|
||||
|
||||
var* local = ctx.top;
|
||||
ctx.top += func.local_size;
|
||||
for(u32 i = 0; i<func.local_size; ++i) {
|
||||
for (u32 i = 0; i<func.local_size; ++i) {
|
||||
local[i] = func.local[i];
|
||||
}
|
||||
|
||||
bool lack_arguments_flag = false;
|
||||
for(const auto& i : func.keys) {
|
||||
for (const auto& i : func.keys) {
|
||||
const auto& key = i.first;
|
||||
if (hash.count(key)) {
|
||||
local[i.second] = hash.at(key);
|
||||
@@ -1083,7 +1083,7 @@ inline void vm::o_slc2() {
|
||||
);
|
||||
return;
|
||||
} else if (num1<=num2) {
|
||||
for(i32 i = num1; i<=num2; ++i) {
|
||||
for (i32 i = num1; i<=num2; ++i) {
|
||||
aim.push_back(i>=0? ref[i]:ref[i+size]);
|
||||
}
|
||||
}
|
||||
@@ -1215,7 +1215,7 @@ inline void vm::o_ret() {
|
||||
auto size = func.func().local_size;
|
||||
upval.on_stack = false;
|
||||
upval.elems.resize(size);
|
||||
for(u64 i = 0; i < size; ++i) {
|
||||
for (u64 i = 0; i < size; ++i) {
|
||||
upval.elems[i] = local[i];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -61,7 +61,7 @@ var builtin_fld(context* ctx, gc* ngc) {
|
||||
}
|
||||
u32 res = 0;
|
||||
auto& s = str.str();
|
||||
for(u32 i = bit; i<bit+len; ++i) {
|
||||
for (u32 i = bit; i<bit+len; ++i) {
|
||||
if (s[i>>3]&(1<<(7-(i&7)))) {
|
||||
res |= 1<<(bit+len-i-1);
|
||||
}
|
||||
@@ -91,7 +91,7 @@ var builtin_sfld(context* ctx, gc* ngc) {
|
||||
}
|
||||
u32 res = 0;
|
||||
auto& s = str.str();
|
||||
for(u32 i = bit; i<bit+len; ++i) {
|
||||
for (u32 i = bit; i<bit+len; ++i) {
|
||||
if (s[i>>3]&(1<<(7-(i&7)))) {
|
||||
res |= 1<<(bit+len-i-1);
|
||||
}
|
||||
@@ -127,7 +127,7 @@ var builtin_setfld(context* ctx, gc* ngc) {
|
||||
return nas_err("bits::setfld", "bitfield out of bounds");
|
||||
}
|
||||
auto& s = str.str();
|
||||
for(u32 i = bit; i<bit+len; ++i) {
|
||||
for (u32 i = bit; i<bit+len; ++i) {
|
||||
if (val&(1<<(i-bit))) {
|
||||
s[i>>3] |= (1<<(7-(i&7)));
|
||||
} else {
|
||||
|
||||
@@ -20,7 +20,7 @@ var builtin_unsafe(context* ctx, gc* ngc) {
|
||||
}
|
||||
|
||||
var builtin_print(context* ctx, gc* ngc) {
|
||||
for(auto& i : ctx->localr[1].vec().elems) {
|
||||
for (auto& i : ctx->localr[1].vec().elems) {
|
||||
std::cout << i;
|
||||
}
|
||||
std::cout << std::flush;
|
||||
@@ -28,7 +28,7 @@ var builtin_print(context* ctx, gc* ngc) {
|
||||
}
|
||||
|
||||
var builtin_println(context* ctx, gc* ngc) {
|
||||
for(auto& i : ctx->localr[1].vec().elems) {
|
||||
for (auto& i : ctx->localr[1].vec().elems) {
|
||||
std::cout << i;
|
||||
}
|
||||
std::cout << std::endl;
|
||||
@@ -53,7 +53,7 @@ var builtin_append(context* ctx, gc* ngc) {
|
||||
return nas_err("native::append", "\"vec\" must be vector");
|
||||
}
|
||||
auto& v = vec.vec().elems;
|
||||
for(auto& i : elem.vec().elems) {
|
||||
for (auto& i : elem.vec().elems) {
|
||||
v.push_back(i);
|
||||
}
|
||||
return nil;
|
||||
@@ -112,7 +112,7 @@ var builtin_split(context* ctx, gc* ngc) {
|
||||
|
||||
// empty separator means split every char
|
||||
if (!sep.length()) {
|
||||
for(auto i : s) {
|
||||
for (auto i : s) {
|
||||
vec.push_back(ngc->newstr(i));
|
||||
}
|
||||
ngc->temp = nil;
|
||||
@@ -160,7 +160,7 @@ var builtin_split_with_empty_substr(context* ctx, gc* ngc) {
|
||||
|
||||
// empty separator means split every char
|
||||
if (!sep.length()) {
|
||||
for(auto i : s) {
|
||||
for (auto i : s) {
|
||||
vec.push_back(ngc->newstr(i));
|
||||
}
|
||||
ngc->temp = nil;
|
||||
@@ -193,7 +193,7 @@ var builtin_rand(context* ctx, gc* ngc) {
|
||||
return nil;
|
||||
}
|
||||
f64 num = 0;
|
||||
for(u32 i = 0; i<5; ++i) {
|
||||
for (u32 i = 0; i<5; ++i) {
|
||||
num = (num+rand())*(1.0/(RAND_MAX+1.0));
|
||||
}
|
||||
return var::num(num);
|
||||
@@ -320,11 +320,11 @@ var builtin_keys(context* ctx, gc* ngc) {
|
||||
auto res = ngc->temp = ngc->alloc(vm_type::vm_vec);
|
||||
auto& vec = res.vec().elems;
|
||||
if (hash.is_hash()) {
|
||||
for(const auto& iter : hash.hash().elems) {
|
||||
for (const auto& iter : hash.hash().elems) {
|
||||
vec.push_back(ngc->newstr(iter.first));
|
||||
}
|
||||
} else {
|
||||
for(const auto& iter : hash.map().mapper) {
|
||||
for (const auto& iter : hash.map().mapper) {
|
||||
vec.push_back(ngc->newstr(iter.first));
|
||||
}
|
||||
}
|
||||
@@ -492,11 +492,11 @@ var builtin_values(context* ctx, gc* ngc) {
|
||||
auto vec = ngc->alloc(vm_type::vm_vec);
|
||||
auto& v = vec.vec().elems;
|
||||
if (hash.is_hash()) {
|
||||
for(auto& i : hash.hash().elems) {
|
||||
for (auto& i : hash.hash().elems) {
|
||||
v.push_back(i.second);
|
||||
}
|
||||
} else {
|
||||
for(auto& i : hash.map().mapper) {
|
||||
for (auto& i : hash.map().mapper) {
|
||||
v.push_back(*i.second);
|
||||
}
|
||||
}
|
||||
@@ -513,7 +513,7 @@ var builtin_sleep(context* ctx, gc* ngc) {
|
||||
// also msvc will use this
|
||||
Sleep(static_cast<i64>(val.num()*1e3));
|
||||
#else
|
||||
std::this_thread::sleep_for(
|
||||
std::this_thread::sleep_for (
|
||||
std::chrono::microseconds(static_cast<i64>(val.num()*1e6))
|
||||
);
|
||||
#endif
|
||||
@@ -536,9 +536,9 @@ var builtin_arch(context* ctx, gc* ngc) {
|
||||
std::string tohex(u32 num) {
|
||||
const char str16[] = "0123456789abcdef";
|
||||
std::string str = "";
|
||||
for(u32 i = 0; i<4; i++, num >>= 8) {
|
||||
for (u32 i = 0; i<4; i++, num >>= 8) {
|
||||
std::string tmp = "";
|
||||
for(u32 j = 0, b = num&0xff; j<2; j++, b >>= 4) {
|
||||
for (u32 j = 0, b = num&0xff; j<2; j++, b >>= 4) {
|
||||
tmp.insert(0, 1, str16[b&0xf]);
|
||||
}
|
||||
str += tmp;
|
||||
@@ -551,7 +551,7 @@ std::string md5(const std::string& src) {
|
||||
usize num = ((src.length()+8)>>6)+1;
|
||||
usize buffsize = num<<4;
|
||||
buff.resize(buffsize, 0);
|
||||
for(usize i = 0; i<src.length(); i++) {
|
||||
for (usize i = 0; i<src.length(); i++) {
|
||||
buff[i>>2] |= (static_cast<u8>(src[i]))<<((i&0x3)<<3);
|
||||
}
|
||||
buff[src.length()>>2] |= 0x80<<(((src.length()%4))<<3);
|
||||
@@ -602,9 +602,9 @@ std::string md5(const std::string& src) {
|
||||
|
||||
u32 atmp = 0x67452301, btmp = 0xefcdab89;
|
||||
u32 ctmp = 0x98badcfe, dtmp = 0x10325476;
|
||||
for(u32 i = 0; i<buffsize; i += 16) {
|
||||
for (u32 i = 0; i<buffsize; i += 16) {
|
||||
u32 f, a = atmp, b = btmp, c = ctmp, d = dtmp;
|
||||
for(u32 j = 0; j<64; j++) {
|
||||
for (u32 j = 0; j<64; j++) {
|
||||
if (j<16) f = md5f(b, c, d);
|
||||
else if (j<32) f = md5g(b, c, d);
|
||||
else if (j<48) f = md5h(b, c, d);
|
||||
|
||||
@@ -61,7 +61,7 @@ std::string search_dynamic_library_path(const std::string& dlname) {
|
||||
|
||||
// search library in PATH
|
||||
const auto possible_path = possible_dylib_path();
|
||||
for(const auto& p : possible_path) {
|
||||
for (const auto& p : possible_path) {
|
||||
const auto env_p = p + lib_path;
|
||||
if (fs::exists(env_p)) {
|
||||
return env_p;
|
||||
@@ -71,7 +71,7 @@ std::string search_dynamic_library_path(const std::string& dlname) {
|
||||
// macos may use .dylib as extension
|
||||
if (util::is_macos()) {
|
||||
const auto dylib_path = "./" + dlname + ".dylib";
|
||||
for(const auto& p : possible_path) {
|
||||
for (const auto& p : possible_path) {
|
||||
const auto env_p = p + dylib_path;
|
||||
if (fs::exists(env_p)) {
|
||||
return env_p;
|
||||
@@ -146,7 +146,7 @@ var builtin_dlopen(context* ctx, gc* ngc) {
|
||||
if (!table) {
|
||||
return nas_err("dylib::dlopen", "failed to get module functions");
|
||||
}
|
||||
for(u32 i = 0; table[i].name; ++i) {
|
||||
for (u32 i = 0; table[i].name; ++i) {
|
||||
auto function_pointer = reinterpret_cast<void*>(table[i].fd);
|
||||
auto function_object = ngc->alloc(vm_type::vm_ghost);
|
||||
function_object.ghost().set(
|
||||
|
||||
@@ -26,7 +26,7 @@ var builtin_logprint(context* ctx, gc* ngc) {
|
||||
"incorrect log level " + std::to_string(level.num())
|
||||
);
|
||||
}
|
||||
for(auto& value : elems.vec().elems) {
|
||||
for (auto& value : elems.vec().elems) {
|
||||
out << value << " ";
|
||||
}
|
||||
out << "\n";
|
||||
|
||||
@@ -123,7 +123,7 @@ std::string json::vector_generate(nas_vec& vect) {
|
||||
}
|
||||
vect.printed = true;
|
||||
std::string out = "[";
|
||||
for(auto& i : vect.elems) {
|
||||
for (auto& i : vect.elems) {
|
||||
out += var_generate(i) + ",";
|
||||
}
|
||||
if (out.back()==',') {
|
||||
@@ -142,7 +142,7 @@ std::string json::hash_generate(nas_hash& hash) {
|
||||
}
|
||||
hash.printed = true;
|
||||
std::string out = "{";
|
||||
for(auto& i : hash.elems) {
|
||||
for (auto& i : hash.elems) {
|
||||
out += "\"" + i.first + "\":";
|
||||
out += var_generate(i.second) + ",";
|
||||
}
|
||||
|
||||
@@ -53,7 +53,7 @@ var builtin_subprocess_create(context* ctx, gc* ngc) {
|
||||
);
|
||||
}
|
||||
|
||||
for(const auto& v : cmd.vec().elems) {
|
||||
for (const auto& v : cmd.vec().elems) {
|
||||
if (!v.is_str()) {
|
||||
return nas_err("subprocess::create",
|
||||
"non-string argument found"
|
||||
@@ -83,7 +83,7 @@ var builtin_subprocess_create(context* ctx, gc* ngc) {
|
||||
ZeroMemory(pi, sizeof(PROCESS_INFORMATION));
|
||||
|
||||
auto command = cmd.vec().elems[0].str();
|
||||
for(usize i = 1; i<cmd.vec().elems.size(); ++i) {
|
||||
for (usize i = 1; i<cmd.vec().elems.size(); ++i) {
|
||||
command += " " + cmd.vec().elems[i].str();
|
||||
}
|
||||
|
||||
@@ -119,7 +119,7 @@ var builtin_subprocess_create(context* ctx, gc* ngc) {
|
||||
#else
|
||||
// create argv
|
||||
char** argv = new char*[cmd.vec().elems.size()+1];
|
||||
for(usize i = 0; i<cmd.vec().elems.size(); ++i) {
|
||||
for (usize i = 0; i<cmd.vec().elems.size(); ++i) {
|
||||
argv[i] = strdup(cmd.vec().elems[i].str().c_str());
|
||||
}
|
||||
argv[cmd.vec().elems.size()] = nullptr;
|
||||
@@ -138,7 +138,7 @@ var builtin_subprocess_create(context* ctx, gc* ngc) {
|
||||
|
||||
// parent process
|
||||
obj.ghost().get<subprocess>()->pid = pid;
|
||||
for(usize i = 0; argv[i]; ++i) {
|
||||
for (usize i = 0; argv[i]; ++i) {
|
||||
delete argv[i];
|
||||
}
|
||||
delete[] argv;
|
||||
|
||||
@@ -72,7 +72,7 @@ var builtin_chdir(context* ctx, gc* ngc) {
|
||||
var builtin_environ(context* ctx, gc* ngc) {
|
||||
var res = ngc->temp = ngc->alloc(vm_type::vm_vec);
|
||||
auto& vec = res.vec().elems;
|
||||
for(char** env = environ; *env; ++env) {
|
||||
for (char** env = environ; *env; ++env) {
|
||||
vec.push_back(ngc->newstr(*env));
|
||||
}
|
||||
ngc->temp = nil;
|
||||
|
||||
@@ -28,7 +28,7 @@ std::string repl::readline(const std::string& prompt = ">>> ") {
|
||||
|
||||
void repl::update_temp_file() {
|
||||
auto content = std::string("");
|
||||
for(const auto& i : source) {
|
||||
for (const auto& i : source) {
|
||||
content += i + "\n";
|
||||
}
|
||||
info::instance()->repl_file_source = content + " ";
|
||||
@@ -36,7 +36,7 @@ void repl::update_temp_file() {
|
||||
|
||||
void repl::update_temp_file(const std::vector<std::string>& src) {
|
||||
auto content = std::string("");
|
||||
for(const auto& i : src) {
|
||||
for (const auto& i : src) {
|
||||
content += i + "\n";
|
||||
}
|
||||
info::instance()->repl_file_source = content + " ";
|
||||
@@ -53,7 +53,7 @@ bool repl::check_need_more_input() {
|
||||
i64 in_curve = 0;
|
||||
i64 in_bracket = 0;
|
||||
i64 in_brace = 0;
|
||||
for(const auto& t : nasal_lexer->result()) {
|
||||
for (const auto& t : nasal_lexer->result()) {
|
||||
switch(t.type) {
|
||||
case tok::tk_lcurve: ++in_curve; break;
|
||||
case tok::tk_rcurve: --in_curve; break;
|
||||
@@ -85,7 +85,7 @@ int repl::check_need_more_input(std::vector<std::string>& src) {
|
||||
i64 in_curve = 0;
|
||||
i64 in_bracket = 0;
|
||||
i64 in_brace = 0;
|
||||
for(const auto& t : nasal_lexer->result()) {
|
||||
for (const auto& t : nasal_lexer->result()) {
|
||||
switch(t.type) {
|
||||
case tok::tk_lcurve: ++in_curve; break;
|
||||
case tok::tk_rcurve: --in_curve; break;
|
||||
|
||||
@@ -13,7 +13,7 @@ bool symbol_finder::visit_definition_expr(definition_expr* node) {
|
||||
} else {
|
||||
// multiple variable definition
|
||||
// example: var (a, b, c) = (0, 1, 2);
|
||||
for(auto i : node->get_variables()->get_variables()) {
|
||||
for (auto i : node->get_variables()->get_variables()) {
|
||||
symbols.push_back({i->get_name(), i});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -99,7 +99,7 @@ void gc_stat::dump_info() const {
|
||||
auto len = strlen(n);
|
||||
indent = indent<len? len:indent;
|
||||
}
|
||||
for(u32 i = 0; i < GC_TYPE_SIZE; ++i) {
|
||||
for (u32 i = 0; i < GC_TYPE_SIZE; ++i) {
|
||||
auto len = std::to_string(gc_cycle_trigger_count[i]).length();
|
||||
indent = indent<len? len:indent;
|
||||
len = std::to_string(alloc_count[i]).length();
|
||||
@@ -109,7 +109,7 @@ void gc_stat::dump_info() const {
|
||||
}
|
||||
|
||||
auto indent_string = std::string("──");
|
||||
for(usize i = 0; i < indent; ++i) {
|
||||
for (usize i = 0; i < indent; ++i) {
|
||||
indent_string += "─";
|
||||
}
|
||||
|
||||
|
||||
@@ -142,7 +142,7 @@ std::string char_to_hex(const char c) {
|
||||
|
||||
std::string rawstr(const std::string& str, const usize maxlen) {
|
||||
std::string ret("");
|
||||
for(auto i : str) {
|
||||
for (auto i : str) {
|
||||
// windows doesn't output unicode normally, so we output the hex
|
||||
if (util::is_windows() && i<=0) {
|
||||
ret += "\\x" + char_to_hex(i);
|
||||
@@ -172,7 +172,7 @@ std::string rawstr(const std::string& str, const usize maxlen) {
|
||||
|
||||
f64 hex_to_f64(const char* str) {
|
||||
f64 ret = 0;
|
||||
for(; *str; ++str) {
|
||||
for (; *str; ++str) {
|
||||
if ('0'<=*str && *str<='9') {
|
||||
ret = ret*16+(*str-'0');
|
||||
} else if ('a'<=*str && *str<='f') {
|
||||
|
||||
@@ -104,7 +104,7 @@ var _parse = func(parser, args, result_hash) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
for(var i = 0; i<size(args); i += 1) {
|
||||
for (var i = 0; i<size(args); i += 1) {
|
||||
var this_arg = args[i];
|
||||
var find_command_flag = false;
|
||||
foreach(var cmd; parser.command_list) {
|
||||
|
||||
@@ -64,7 +64,7 @@ var bit = func() {
|
||||
var append = func(vec, arg...) {
|
||||
return __append;
|
||||
}
|
||||
for(var i = 1; i<32; i += 1) {
|
||||
for (var i = 1; i<32; i += 1) {
|
||||
append(res, __ += __);
|
||||
}
|
||||
return res;
|
||||
|
||||
@@ -225,7 +225,7 @@ var props={
|
||||
path=split('/',path);
|
||||
var tmp=me.globals;
|
||||
var path_size=size(path);
|
||||
for(var i=0;i<path_size-1;i+=1)
|
||||
for (var i=0;i<path_size-1;i+=1)
|
||||
tmp=tmp.val[path[i]];
|
||||
if (path_size>0) {
|
||||
if (contains(tmp.val,path[i]~'['~index~']'))
|
||||
@@ -260,7 +260,7 @@ props.Node={
|
||||
return 0;
|
||||
},
|
||||
addChildren:func(name,cnt=0) {
|
||||
for(var i=0;i<cnt;i+=1) {
|
||||
for (var i=0;i<cnt;i+=1) {
|
||||
var label=name~'['~i~']';
|
||||
me.val[label]=props.Node.new();
|
||||
me.val[label].parent=me;
|
||||
@@ -344,7 +344,7 @@ foreach(var i;c)
|
||||
props.getNode('/ai',1).addChildren('ai',4);
|
||||
props.getNode('/aircraft',1).setValue('/','IDG MD-11');
|
||||
props.getNode('/models',1).addChildren('building',4);
|
||||
for(var i=0;i<4;i+=1)
|
||||
for (var i=0;i<4;i+=1)
|
||||
props.getNode('/models/building['~i~']',1).setIntValue(i);
|
||||
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /consumables");
|
||||
@@ -354,7 +354,7 @@ props.getNode("/consumables/fuel",1).addChild("total-gal_us");
|
||||
props.getNode("/consumables/fuel/total-fuel-lbs",1).setValue('/',0);
|
||||
props.getNode("/consumables/fuel/total-gal_us",1).setValue('/',0);
|
||||
props.getNode("/consumables/fuel",1).addChildren("tank",4);
|
||||
for(var i=0;i<4;i+=1) {
|
||||
for (var i=0;i<4;i+=1) {
|
||||
props.getNode("/consumables/fuel/tank["~i~"]",1).addChild("level-lb");
|
||||
props.getNode("/consumables/fuel/tank["~i~"]",1).addChild("level-lbs");
|
||||
props.getNode("/consumables/fuel/tank["~i~"]",1).addChild("level-gal_us");
|
||||
@@ -376,7 +376,7 @@ println("[\e[32m props \e[0m] [",os.time(),"] init /controls/anti-ice");
|
||||
foreach(var i;['wing-heat','pitot-heat','wiper','window-heat'])
|
||||
props.getNode("/controls/anti-ice",1).addChild(i);
|
||||
props.getNode("/controls/anti-ice",1).addChildren("engine",2);
|
||||
for(var i=0;i<2;i+=1) {
|
||||
for (var i=0;i<2;i+=1) {
|
||||
props.getNode("/controls/anti-ice/engine["~i~"]",1).addChild("carb-heat");
|
||||
props.getNode("/controls/anti-ice/engine["~i~"]",1).addChild("inlet-heat");
|
||||
}
|
||||
@@ -390,7 +390,7 @@ props.getNode("/controls/armament",1).addChild("master-arm");
|
||||
props.getNode("/controls/armament",1).addChild("station-select");
|
||||
props.getNode("/controls/armament",1).addChild("release-all");
|
||||
props.getNode("/controls/armament",1).addChildren("station",4);
|
||||
for(var i=0;i<4;i+=1) {
|
||||
for (var i=0;i<4;i+=1) {
|
||||
props.getNode("/controls/armament/station["~i~"]",1).addChild("stick-size");
|
||||
props.getNode("/controls/armament/station["~i~"]",1).addChild("release-stick");
|
||||
props.getNode("/controls/armament/station["~i~"]",1).addChild("release-all");
|
||||
@@ -401,14 +401,14 @@ println("[\e[32m props \e[0m] [",os.time(),"] init /controls/autoflight");
|
||||
foreach(var i;['autothrottle-arm','autothrottle-engage','heading-select','altitude-select','bank-angle-select','vertical-speed-select','speed-select','mach-select','vertical-mode','lateral-mode'])
|
||||
props.getNode("/controls/autoflight",1).addChild(i);
|
||||
props.getNode("/controls/autoflight",1).addChildren("autopilot",2);
|
||||
for(var i=0;i<2;i+=1)
|
||||
for (var i=0;i<2;i+=1)
|
||||
props.getNode("/controls/autoflight/autopilot["~i~"]",1).addChild("engage");
|
||||
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /controls/electric");
|
||||
foreach(var i;['battery-switch','external-power','APU-generator'])
|
||||
props.getNode("/controls/electric",1).addChild(i);
|
||||
props.getNode("/controls/electric",1).addChildren("engine",2);
|
||||
for(var i=0;i<2;i+=1) {
|
||||
for (var i=0;i<2;i+=1) {
|
||||
props.getNode("/controls/electric/engine["~i~"]",1).addChild("generator");
|
||||
props.getNode("/controls/electric/engine["~i~"]",1).addChild("bus-tie");
|
||||
}
|
||||
@@ -416,7 +416,7 @@ for(var i=0;i<2;i+=1) {
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /controls/engines");
|
||||
props.getNode("/controls/engines",1).addChild("throttle-idle");
|
||||
props.getNode("/controls/engines",1).addChildren("engine",2);
|
||||
for(var i=0;i<2;i+=1)
|
||||
for (var i=0;i<2;i+=1)
|
||||
foreach(var j;['throttle','starter','fuel-pump','fire-switch','fire-bottle-discharge','cutoff','mixture','propeller-pitch','magnetos','boost','WEP','cowl-flaps-norm','feather','ignition','augmentation','afterburner','reverser','water-injection','condition'])
|
||||
props.getNode("/controls/engines/engine["~i~"]",1).addChild(j);
|
||||
|
||||
@@ -427,7 +427,7 @@ foreach(var i;['aileron','aileron-trim','elevator','elevator-trim','rudder','rud
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /controls/fuel");
|
||||
props.getNode("/controls/fuel",1).addChild("dump-value");
|
||||
props.getNode("/controls/fuel",1).addChildren("tank",4);
|
||||
for(var i=0;i<4;i+=1) {
|
||||
for (var i=0;i<4;i+=1) {
|
||||
foreach(var j;['fuel-selector','to_engine','to_tank'])
|
||||
props.getNode("/controls/fuel/tank["~i~"]",1).addChild(j);
|
||||
props.getNode("/controls/fuel/tank["~i~"]",1).addChildren("boost-pump",4);
|
||||
@@ -437,12 +437,12 @@ println("[\e[32m props \e[0m] [",os.time(),"] init /controls/gear");
|
||||
foreach(var i;['brake-left','brake-right','brake-parking','steering','gear-down','antiskid','tailhook','tailwheel-lock'])
|
||||
props.getNode("/controls/gear",1).addChild(i);
|
||||
props.getNode("/controls/gear",1).addChildren("wheel",4);
|
||||
for(var i=0;i<4;i+=1)
|
||||
for (var i=0;i<4;i+=1)
|
||||
props.getNode("/controls/gear/wheel["~i~"]",1).addChild("alternate-extension");
|
||||
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /controls/hydraulic");
|
||||
props.getNode("/controls/hydraulic",1).addChildren("system",2);
|
||||
for(var i=0;i<2;i+=1) {
|
||||
for (var i=0;i<2;i+=1) {
|
||||
props.getNode("/controls/hydraulic/system["~i~"]",1).addChild("engine-pump");
|
||||
props.getNode("/controls/hydraulic/system["~i~"]",1).addChild("electric-pump");
|
||||
}
|
||||
@@ -454,28 +454,28 @@ foreach(var i;['landing-lights','turn-off-lights','formation-lights','taxi-light
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /controls/pneumatic");
|
||||
props.getNode("/controls/pneumatic",1).addChild("APU-bleed");
|
||||
props.getNode("/controls/pneumatic",1).addChildren("engine",2);
|
||||
for(var i=0;i<2;i+=1)
|
||||
for (var i=0;i<2;i+=1)
|
||||
props.getNode("/controls/pneumatic/engine["~i~"]",1).addChild("bleed");
|
||||
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /controls/pressurization");
|
||||
foreach(var i;['mode','dump','outflow-valve'])
|
||||
props.getNode("/controls/pressurization",1).addChild(i);
|
||||
props.getNode("/controls/pressurization",1).addChildren("pack",4);
|
||||
for(var i=0;i<4;i+=1)
|
||||
for (var i=0;i<4;i+=1)
|
||||
props.getNode("/controls/pressurization/pack["~i~"]",1).addChild("pack-on");
|
||||
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /controls/seat");
|
||||
foreach(var i;['vertical-adjust','fore-aft-adjust','cmd_selector_valve'])
|
||||
props.getNode("/controls/seat",1).addChild(i);
|
||||
props.getNode("/controls/seat",1).addChildren("eject",3);
|
||||
for(var i=0;i<3;i+=1) {
|
||||
for (var i=0;i<3;i+=1) {
|
||||
props.getNode("/controls/seat/eject["~i~"]",1).addChild("initiate");
|
||||
props.getNode("/controls/seat/eject["~i~"]",1).addChild("status");
|
||||
}
|
||||
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /engines");
|
||||
props.getNode("/engines",1).addChildren("engine",2);
|
||||
for(var i=0;i<2;i+=1)
|
||||
for (var i=0;i<2;i+=1)
|
||||
foreach(var j;
|
||||
['fuel-flow-gph','fuel-flow-pph','thrust_lb','running','starter','cranking',
|
||||
'n1','n2','epr','augmentation','water-injection','ignition','nozzle-pos-norm',
|
||||
@@ -506,7 +506,7 @@ foreach(var i;['x-accel-fps_sec','y-accel-fps_sec','z-accel-fps_sec'])
|
||||
println("[\e[32m props \e[0m] [",os.time(),"] init /gear");
|
||||
props.getNode("/gear",1).addChild("serviceable");
|
||||
props.getNode("/gear",1).addChildren("gear",4);
|
||||
for(var i=0;i<4;i+=1)
|
||||
for (var i=0;i<4;i+=1)
|
||||
foreach(var j;['cast-angle-deg','compression-m','compression-norm','ground-friction-factor','ground-is-solid','has-brake','rollspeed-ms','wow','xoffset-in','yoffset-in','zoffset-in'])
|
||||
props.getNode("/gear/gear["~i~"]",1).addChild(j);
|
||||
|
||||
@@ -522,7 +522,7 @@ foreach(var i;['torque-sound-filtered','total-torque'])
|
||||
foreach(var i;['balance','bladesvisible','cone-deg','cone2-deg','roll-deg','rpm','stall','stall-filtered','tilt','torque','yaw-deg'])
|
||||
props.getNode("/rotors/{name}",1).addChild(i);
|
||||
props.getNode("/rotors/{name}",1).addChildren("blade",8);
|
||||
for(var i=0;i<8;i+=1)
|
||||
for (var i=0;i<8;i+=1)
|
||||
foreach(var j;['flap-deg','incidence-deg','position-deg'])
|
||||
props.getNode("/rotors/{name}/blade["~i~"]",1).addChild(j);
|
||||
|
||||
|
||||
26
std/mat.nas
26
std/mat.nas
@@ -22,8 +22,8 @@ var rand_init = func(a) {
|
||||
|
||||
var mat_print = func(a) {
|
||||
var (width,height,ref)=(a.width,a.height,a.mat);
|
||||
for(var i=0;i<height;i+=1) {
|
||||
for(var j=0;j<width;j+=1) {
|
||||
for (var i=0;i<height;i+=1) {
|
||||
for (var j=0;j<width;j+=1) {
|
||||
print(ref[i*width+j]," ");
|
||||
}
|
||||
println();
|
||||
@@ -42,8 +42,8 @@ var add = func(a,b) {
|
||||
var (width,height,ref)=(res.width,res.height,res.mat);
|
||||
var (aref,bref)=(a.mat,b.mat);
|
||||
|
||||
for(var i=0;i<height;i+=1) {
|
||||
for(var j=0;j<width;j+=1) {
|
||||
for (var i=0;i<height;i+=1) {
|
||||
for (var j=0;j<width;j+=1) {
|
||||
ref[i*width+j]=aref[i*width+j]+bref[i*width+j];
|
||||
}
|
||||
}
|
||||
@@ -62,8 +62,8 @@ var sub = func(a,b) {
|
||||
var (width,height,ref)=(res.width,res.height,res.mat);
|
||||
var (aref,bref)=(a.mat,b.mat);
|
||||
|
||||
for(var i=0;i<height;i+=1) {
|
||||
for(var j=0;j<width;j+=1) {
|
||||
for (var i=0;i<height;i+=1) {
|
||||
for (var j=0;j<width;j+=1) {
|
||||
ref[i*width+j]=aref[i*width+j]-bref[i*width+j];
|
||||
}
|
||||
}
|
||||
@@ -82,8 +82,8 @@ var hardamard = func(a,b) {
|
||||
var (width,height,ref)=(res.width,res.height,res.mat);
|
||||
var (aref,bref)=(a.mat,b.mat);
|
||||
|
||||
for(var i=0;i<height;i+=1) {
|
||||
for(var j=0;j<width;j+=1) {
|
||||
for (var i=0;i<height;i+=1) {
|
||||
for (var j=0;j<width;j+=1) {
|
||||
ref[i*width+j]=aref[i*width+j]*bref[i*width+j];
|
||||
}
|
||||
}
|
||||
@@ -122,8 +122,8 @@ var trans = func(a) {
|
||||
var res=mat(a.height,a.width);
|
||||
var ref=res.mat;
|
||||
var (a_width,a_height,aref)=(a.width,a.height,a.mat);
|
||||
for(var i=0;i<a_width;i+=1) {
|
||||
for(var j=0;j<a_height;j+=1) {
|
||||
for (var i=0;i<a_width;i+=1) {
|
||||
for (var j=0;j<a_height;j+=1) {
|
||||
ref[i*a_height+j]=aref[j*a_width+i];
|
||||
}
|
||||
}
|
||||
@@ -152,9 +152,9 @@ var mult = func(a,b) {
|
||||
var (a_width,aref)=(a.width,a.mat);
|
||||
var (b_width,bref)=(b.width,b.mat);
|
||||
|
||||
for(var i=0;i<res_width;i+=1) {
|
||||
for(var j=0;j<res_height;j+=1) {
|
||||
for(var k=0;k<a_width;k+=1) {
|
||||
for (var i=0;i<res_width;i+=1) {
|
||||
for (var j=0;j<res_height;j+=1) {
|
||||
for (var k=0;k<a_width;k+=1) {
|
||||
ref[j*res_width+i]+=aref[j*a_width+k]*bref[k*b_width+i];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,7 +6,7 @@ var leftpad = func(input_string, length, char=" ") {
|
||||
input_string = str(input_string);
|
||||
}
|
||||
var strlen = size(input_string);
|
||||
for(var i = strlen; i<length; i += 1) {
|
||||
for (var i = strlen; i<length; i += 1) {
|
||||
input_string = char~input_string;
|
||||
}
|
||||
return input_string;
|
||||
@@ -17,7 +17,7 @@ var rightpad = func(input_string, length, char=" ") {
|
||||
input_string = str(input_string);
|
||||
}
|
||||
var strlen = size(input_string);
|
||||
for(var i = strlen; i<length; i += 1) {
|
||||
for (var i = strlen; i<length; i += 1) {
|
||||
input_string ~= char;
|
||||
}
|
||||
return input_string;
|
||||
|
||||
@@ -51,9 +51,9 @@ var bar = func() {
|
||||
var finish_length=int(number*length);
|
||||
var other=length-finish_length;
|
||||
var s="";
|
||||
for(var i=0;i<finish_length;i+=1)
|
||||
for (var i=0;i<finish_length;i+=1)
|
||||
s~=front;
|
||||
for(var i=0;i<other;i+=1)
|
||||
for (var i=0;i<other;i+=1)
|
||||
s~=back;
|
||||
return sep[0]~s~sep[1];
|
||||
}
|
||||
@@ -64,7 +64,7 @@ var bar = func() {
|
||||
# return a high resolution progress bar
|
||||
# example:
|
||||
# var bar=process_bar.high_resolution_bar(40);
|
||||
# for(var i=0;i<=1;i+=0.001) {
|
||||
# for (var i=0;i<=1;i+=0.001) {
|
||||
# print(bar.bar(i,40),'\r');
|
||||
# unix.sleep(0.001);
|
||||
# }
|
||||
@@ -83,13 +83,13 @@ var high_resolution_bar = func() {
|
||||
var decimal=block_len-complete_block;
|
||||
var progress=complete_block+(decimal!=0);
|
||||
var s="|";
|
||||
for(var i=0;i<complete_block;i+=1) {
|
||||
for (var i=0;i<complete_block;i+=1) {
|
||||
s~="█";
|
||||
}
|
||||
if (decimal!=0) {
|
||||
s~=block[int(decimal*10)/10*size(block)];
|
||||
}
|
||||
for(var i=0;i<length-progress;i+=1) {
|
||||
for (var i=0;i<length-progress;i+=1) {
|
||||
s~=" ";
|
||||
}
|
||||
s~="|";
|
||||
@@ -109,7 +109,7 @@ var spinner = func() {
|
||||
var res=[];
|
||||
var len=size(vec);
|
||||
var tmp="";
|
||||
for(var i=0;i<len;i+=1) {
|
||||
for (var i=0;i<len;i+=1) {
|
||||
tmp=pop(vec)~tmp;
|
||||
append(res,tmp);
|
||||
while(size(res[-1])!=16)
|
||||
@@ -227,7 +227,7 @@ var spinner = func() {
|
||||
return {
|
||||
next: func() {
|
||||
var s="";
|
||||
for(var i=0;i<repeat;i+=1)
|
||||
for (var i=0;i<repeat;i+=1)
|
||||
s~=type[counter];
|
||||
counter+=1;
|
||||
if (counter>=size(type))
|
||||
@@ -335,7 +335,7 @@ var show = func() {
|
||||
};
|
||||
var bar_key=keys(bars);
|
||||
var spin_key=keys(spinners);
|
||||
for(var i=0; i<40; i+=1) {
|
||||
for (var i=0; i<40; i+=1) {
|
||||
forindex(var j; bar_key) {
|
||||
var k=bar_key[j];
|
||||
print("\e["~(j+1)~";1H["~k~"] "~bars[k].bar((i+1)/40));
|
||||
|
||||
@@ -433,7 +433,7 @@ var wrap = func(node) {
|
||||
} elsif (isvec(node)) {
|
||||
var v = node;
|
||||
var n = size(v);
|
||||
for(var i=0; i<n; i+=1) { v[i] = wrapNode(v[i]); }
|
||||
for (var i=0; i<n; i+=1) { v[i] = wrapNode(v[i]); }
|
||||
return v;
|
||||
}
|
||||
return node;
|
||||
|
||||
@@ -20,7 +20,7 @@ var gc = {
|
||||
times = 16;
|
||||
}
|
||||
|
||||
for(var i = 0; i<times; i+=1) {
|
||||
for (var i = 0; i<times; i+=1) {
|
||||
_gc_extend(type);
|
||||
}
|
||||
return nil;
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
var join = func(sep, vec) {
|
||||
var len = size(vec);
|
||||
var res = "";
|
||||
for(var i = 0; i<len; i += 1) {
|
||||
for (var i = 0; i<len; i += 1) {
|
||||
res ~= vec[i];
|
||||
res ~= (i==len-1? "":sep);
|
||||
}
|
||||
@@ -26,7 +26,7 @@ var __temp_contains = func(hash, key) {
|
||||
var __num_to_char = [];
|
||||
var __char_to_num = {};
|
||||
func() {
|
||||
for(var i = 0; i<256; i += 1) {
|
||||
for (var i = 0; i<256; i += 1) {
|
||||
__temp_append(__num_to_char, __temp_char(i));
|
||||
__char_to_num[__temp_char(i)] = i;
|
||||
}
|
||||
|
||||
@@ -5,21 +5,21 @@ var COUNT = 16384;
|
||||
|
||||
print("Initializing...\n");
|
||||
var v = [];
|
||||
for(var i=0; i<COUNT; i=i+1) { append(v, {}); }
|
||||
for (var i=0; i<COUNT; i=i+1) { append(v, {}); }
|
||||
|
||||
|
||||
print("Starting test\n");
|
||||
func {
|
||||
for(var rep=0; rep<REPS; rep+=1) {
|
||||
for (var rep=0; rep<REPS; rep+=1) {
|
||||
print(rep, "...\n");
|
||||
for(var i=0; i<COUNT; i=i+1) {
|
||||
for (var i=0; i<COUNT; i=i+1) {
|
||||
var obj = v[i];
|
||||
obj.fielda = i;
|
||||
obj.fieldb = i;
|
||||
obj.fieldc = i;
|
||||
obj.fieldd = i;
|
||||
}
|
||||
for(var i=0; i<COUNT; i=i+1) {
|
||||
for (var i=0; i<COUNT; i=i+1) {
|
||||
var obj = v[i];
|
||||
if (obj.fielda != i) { print("Ack!\n"); return; }
|
||||
if (obj.fieldb != i) { print("Ack!\n"); return; }
|
||||
@@ -70,7 +70,7 @@ print("cos(32) = ", math.cos(angle), "\n");
|
||||
print("s^2 + c^s = ",
|
||||
math.sin(angle)*math.sin(angle)+math.cos(angle)*math.cos(angle), "\n");
|
||||
|
||||
func {for(var j=0; j<10; j=j+1) {
|
||||
func {for (var j=0; j<10; j=j+1) {
|
||||
print(j, "/10\n");
|
||||
|
||||
# Make some tables to store stuff. This will clobber the contents
|
||||
@@ -79,7 +79,7 @@ func {for(var j=0; j<10; j=j+1) {
|
||||
var v = []; var h1 = {}; var h2 = {};
|
||||
|
||||
# Fill them
|
||||
for(var i=0; i<65536; i=i+1) {
|
||||
for (var i=0; i<65536; i=i+1) {
|
||||
var str = "i" ~ i;
|
||||
append(v, str);
|
||||
h1[str] = i;
|
||||
@@ -87,7 +87,7 @@ func {for(var j=0; j<10; j=j+1) {
|
||||
}
|
||||
|
||||
# Check that we get back what we put in
|
||||
for(i=0; i<65536; i=i+1) {
|
||||
for (i=0; i<65536; i=i+1) {
|
||||
if (v[i] != h2[h1[v[i]~""]~""][0]) {
|
||||
print("Ack!\n");
|
||||
return;
|
||||
|
||||
@@ -52,16 +52,16 @@ var char_ttf=[
|
||||
|
||||
var trans_ttf = func(string) {
|
||||
var str=["","","","","",""];
|
||||
for(var i=0;i<size(string);i+=1) {
|
||||
for (var i=0;i<size(string);i+=1) {
|
||||
var number=string[i];
|
||||
if (97<=number and number<=122)
|
||||
for(var j=0;j<6;j+=1)
|
||||
for (var j=0;j<6;j+=1)
|
||||
str[j]~=char_ttf[number-96][j];
|
||||
elsif (65<=number and number<=90)
|
||||
for(var j=0;j<6;j+=1)
|
||||
for (var j=0;j<6;j+=1)
|
||||
str[j]~=char_ttf[number-64][j];
|
||||
else
|
||||
for(var j=0;j<6;j+=1)
|
||||
for (var j=0;j<6;j+=1)
|
||||
str[j]~=char_ttf[0][j];
|
||||
}
|
||||
foreach(var i;str)
|
||||
@@ -73,8 +73,8 @@ var curve1 = func(line=4) {
|
||||
var table=["╚","═","╝","╔","║","╗"];
|
||||
rand(100);
|
||||
var s="";
|
||||
for(var i=0;i<line;i+=1) {
|
||||
for(var j=0;j<90;j+=1)
|
||||
for (var i=0;i<line;i+=1) {
|
||||
for (var j=0;j<90;j+=1)
|
||||
s~=table[int(6*rand())];
|
||||
s~='\n';
|
||||
}
|
||||
@@ -85,8 +85,8 @@ var curve2 = func(line=2) {
|
||||
var shadow=["░","▒","▓","█","▀","▄","▐","▌"];
|
||||
rand(100);
|
||||
var s="";
|
||||
for(var i=0;i<line;i+=1) {
|
||||
for(var j=0;j<90;j+=1)
|
||||
for (var i=0;i<line;i+=1) {
|
||||
for (var j=0;j<90;j+=1)
|
||||
s~=shadow[int(8*rand())];
|
||||
s~='\n';
|
||||
}
|
||||
@@ -106,15 +106,15 @@ var curve3 = func(line=2) {
|
||||
0,1,2,3,4,5,6,7,8,
|
||||
0,1,2,3,4,5,6,7,8
|
||||
];
|
||||
for(var loop=0;loop<line;loop+=1) {
|
||||
for(var i=size(arr)-1;i>=0;i-=1) {
|
||||
for (var loop=0;loop<line;loop+=1) {
|
||||
for (var i=size(arr)-1;i>=0;i-=1) {
|
||||
var rand_index=int(i*rand());
|
||||
(arr[i],arr[rand_index])=(arr[rand_index],arr[i]);
|
||||
}
|
||||
# 0 1 2 3 4 5 6 7 8
|
||||
var shadow=[" ","░","▒","▓","█","▀","▄","▐","▌"];
|
||||
var s="";
|
||||
for(var i=0;i<size(arr);i+=1)
|
||||
for (var i=0;i<size(arr);i+=1)
|
||||
s~=shadow[arr[i]];
|
||||
println(s);
|
||||
}
|
||||
@@ -132,8 +132,8 @@ var curve4 = func(line=4) {
|
||||
"100","101","102","103","104","105","106","107"
|
||||
];
|
||||
rand(time(0));
|
||||
for(var i=0;i<line;i+=1) {
|
||||
for(var j=0;j<90;j+=1)
|
||||
for (var i=0;i<line;i+=1) {
|
||||
for (var j=0;j<90;j+=1)
|
||||
print("\e["~front[16*rand()]~";"~back[16*rand()]~shadow[8*rand()]);
|
||||
print('\n');
|
||||
}
|
||||
@@ -141,8 +141,8 @@ var curve4 = func(line=4) {
|
||||
|
||||
var curve5 = func(line=4) {
|
||||
var vec=["▀▄─","▄▀─","▀─▄","▄─▀"];
|
||||
for(var (y,p)=(0,0);y!=line;y+=1) {
|
||||
for(var x=0;x!=30;x+=1)
|
||||
for (var (y,p)=(0,0);y!=line;y+=1) {
|
||||
for (var x=0;x!=30;x+=1)
|
||||
print(vec[p]);
|
||||
print("\n");
|
||||
p+=1;
|
||||
@@ -152,42 +152,42 @@ var curve5 = func(line=4) {
|
||||
|
||||
var ansi_escape_sequence = func() {
|
||||
# decoration
|
||||
for(var i=0;i<10;i+=1)
|
||||
for (var i=0;i<10;i+=1)
|
||||
print("\e["~i~"m",padding.rightpad(i,4),"\e[0m");
|
||||
print("\n");
|
||||
|
||||
# 8/16 color
|
||||
for(var i=30;i<38;i+=1)
|
||||
for (var i=30;i<38;i+=1)
|
||||
print("\e["~i~"m ",padding.rightpad(i,4),"\e[0m");
|
||||
for(var i=30;i<38;i+=1)
|
||||
for (var i=30;i<38;i+=1)
|
||||
print("\e["~i~";1m ",padding.rightpad(i,4),"\e[0m");
|
||||
print("\n");
|
||||
for(var i=40;i<48;i+=1)
|
||||
for (var i=40;i<48;i+=1)
|
||||
print("\e["~i~"m ",padding.rightpad(i,4),"\e[0m");
|
||||
for(var i=40;i<48;i+=1)
|
||||
for (var i=40;i<48;i+=1)
|
||||
print("\e["~i~";1m ",padding.rightpad(i,4),"\e[0m");
|
||||
print("\n");
|
||||
for(var i=90;i<98;i+=1)
|
||||
for (var i=90;i<98;i+=1)
|
||||
print("\e["~i~"m ",padding.rightpad(i,4),"\e[0m");
|
||||
for(var i=90;i<98;i+=1)
|
||||
for (var i=90;i<98;i+=1)
|
||||
print("\e["~i~";1m ",padding.rightpad(i,4),"\e[0m");
|
||||
print("\n");
|
||||
for(var i=100;i<108;i+=1)
|
||||
for (var i=100;i<108;i+=1)
|
||||
print("\e["~i~"m ",padding.rightpad(i,4),"\e[0m");
|
||||
for(var i=100;i<108;i+=1)
|
||||
for (var i=100;i<108;i+=1)
|
||||
print("\e["~i~";1m ",padding.rightpad(i,4),"\e[0m");
|
||||
print("\n");
|
||||
|
||||
# 256 color
|
||||
for(var i=0;i<16;i+=1) {
|
||||
for(var j=0;j<16;j+=1) {
|
||||
for (var i=0;i<16;i+=1) {
|
||||
for (var j=0;j<16;j+=1) {
|
||||
var code=str(i*16+j);
|
||||
print("\e[38;5;"~code~"m ",padding.rightpad(code,4),"\e[0m");
|
||||
}
|
||||
print("\n");
|
||||
}
|
||||
for(var i=0;i<16;i+=1) {
|
||||
for(var j=0;j<16;j+=1) {
|
||||
for (var i=0;i<16;i+=1) {
|
||||
for (var j=0;j<16;j+=1) {
|
||||
var code=str(i*16+j);
|
||||
print("\e[48;5;"~code~"m ",padding.rightpad(code,4),"\e[0m");
|
||||
}
|
||||
@@ -201,7 +201,7 @@ var ansi_escape_sequence = func() {
|
||||
foreach(var i;progress) {
|
||||
print("\e[1000D",bar.bar(i)," ",padding.rightpad(str(int(i*100)),3)," % \n");
|
||||
}
|
||||
for(var i=0;i<1/0.03;i+=1) {
|
||||
for (var i=0;i<1/0.03;i+=1) {
|
||||
print("\e[1000D","\e["~str(size(progress))~"A");
|
||||
forindex(var j;progress) {
|
||||
progress[j]+=increase[j];
|
||||
|
||||
@@ -34,7 +34,7 @@ var road_check_func = func() {
|
||||
var left_range = 0;
|
||||
var right_range = 0;
|
||||
|
||||
for(var i=0;i>-0.00005;i-=0.000001) {
|
||||
for (var i=0;i>-0.00005;i-=0.000001) {
|
||||
car_heading = props.getNode("/orientation/heading-deg",1).getValue();
|
||||
lat_change = math.sin(D2R*car_heading);
|
||||
lon_change = -math.cos(D2R*car_heading);
|
||||
@@ -47,7 +47,7 @@ var road_check_func = func() {
|
||||
else
|
||||
break;
|
||||
}
|
||||
for(var i=0;i<0.00005;i+=0.000001) {
|
||||
for (var i=0;i<0.00005;i+=0.000001) {
|
||||
car_heading = props.getNode("/orientation/heading-deg",1).getValue();
|
||||
lat_change = math.sin(D2R*car_heading);
|
||||
lon_change = -math.cos(D2R*car_heading);
|
||||
|
||||
@@ -170,12 +170,12 @@ var (add,mov,jt,jf,in,out)=(
|
||||
var codegen = func(program) {
|
||||
var (code,stack)=([],[]);
|
||||
var len=size(program);
|
||||
for(var i=0;i<len;i+=1) {
|
||||
for (var i=0;i<len;i+=1) {
|
||||
var c=chr(program[i]);
|
||||
if (c=='+' or c=='-') {
|
||||
append(code,add);
|
||||
append(inum,0);
|
||||
for(;i<len;i+=1) {
|
||||
for (;i<len;i+=1) {
|
||||
if (chr(program[i])=='+') {
|
||||
inum[-1]+=1;
|
||||
} elsif (chr(program[i])=='-') {
|
||||
@@ -188,7 +188,7 @@ var codegen = func(program) {
|
||||
} elsif (c=='<' or c=='>') {
|
||||
append(code,mov);
|
||||
append(inum,0);
|
||||
for(;i<len;i+=1) {
|
||||
for (;i<len;i+=1) {
|
||||
if (chr(program[i])=='>') {
|
||||
inum[-1]+=1;
|
||||
} elsif (chr(program[i])=='<') {
|
||||
@@ -239,7 +239,7 @@ var bf = func(program) {
|
||||
# execute
|
||||
setsize(paper,131072);
|
||||
var len=size(code);
|
||||
for(pc=0;pc<len;pc+=1) {
|
||||
for (pc=0;pc<len;pc+=1) {
|
||||
code[pc]();
|
||||
}
|
||||
return;
|
||||
|
||||
@@ -149,7 +149,7 @@ var mandelbrot=
|
||||
|
||||
var padding = func(len) {
|
||||
var res="";
|
||||
for(var i=0;i<len;i+=1) {
|
||||
for (var i=0;i<len;i+=1) {
|
||||
res~=" ";
|
||||
}
|
||||
return res;
|
||||
@@ -159,11 +159,11 @@ var bf = func(program) {
|
||||
var stack=[];
|
||||
var len=size(program);
|
||||
var f="#automatically generated by bfconvertor.nas\nvar ptr=0;\nvar paper=[];\nsetsize(paper,131072);\n";
|
||||
for(var i=0;i<len;i+=1) {
|
||||
for (var i=0;i<len;i+=1) {
|
||||
var c=chr(program[i]);
|
||||
if (c=='+' or c=='-') {
|
||||
var cnt=0;
|
||||
for(;i<len;i+=1) {
|
||||
for (;i<len;i+=1) {
|
||||
if (chr(program[i])=='+') {
|
||||
cnt+=1;
|
||||
} elsif (chr(program[i])=='-') {
|
||||
@@ -183,7 +183,7 @@ var bf = func(program) {
|
||||
}
|
||||
} elsif (c=='<' or c=='>') {
|
||||
var cnt=0;
|
||||
for(;i<len;i+=1) {
|
||||
for (;i<len;i+=1) {
|
||||
if (chr(program[i])=='>') {
|
||||
cnt+=1;
|
||||
} elsif (chr(program[i])=='<') {
|
||||
|
||||
@@ -5,17 +5,17 @@ use std.unix;
|
||||
rand(time(0));
|
||||
var pixel=[' ','#','.','*'];
|
||||
var map=[];
|
||||
for(var i=0;i<10;i+=1) {
|
||||
for (var i=0;i<10;i+=1) {
|
||||
append(map,[]);
|
||||
for(var j=0;j<20;j+=1)
|
||||
for (var j=0;j<20;j+=1)
|
||||
append(map[i],(rand()>0.7));
|
||||
}
|
||||
|
||||
var prt = func() {
|
||||
var s="\e[0;0H+--------------------+\n";
|
||||
for(var i=0;i<10;i+=1) {
|
||||
for (var i=0;i<10;i+=1) {
|
||||
s~="|";
|
||||
for(var j=0;j<20;j+=1)
|
||||
for (var j=0;j<20;j+=1)
|
||||
s~=pixel[map[i][j]];
|
||||
s~='|\n';
|
||||
}
|
||||
|
||||
@@ -1 +1 @@
|
||||
for(var i=0;i<4e6;i+=1);
|
||||
for (var i=0;i<4e6;i+=1);
|
||||
|
||||
38
test/bp.nas
38
test/bp.nas
@@ -34,32 +34,32 @@ var training_set=[[0,0],[0,1],[1,0],[1,1]];
|
||||
var expect=[0,1,1,0];
|
||||
|
||||
var hidden=[];
|
||||
for(var i=0;i<hnum;i+=1) {
|
||||
for (var i=0;i<hnum;i+=1) {
|
||||
append(hidden,new_neuron());
|
||||
for(var j=0;j<inum;j+=1)
|
||||
for (var j=0;j<inum;j+=1)
|
||||
append(hidden[i].w,rand()>0.5?-2*rand():2*rand());
|
||||
hidden[i].bia=rand()>0.5?-5*rand():5*rand();
|
||||
}
|
||||
|
||||
var output=[];
|
||||
for(var i=0;i<onum;i+=1) {
|
||||
for (var i=0;i<onum;i+=1) {
|
||||
append(output,new_neuron());
|
||||
for(var j=0;j<hnum;j+=1)
|
||||
for (var j=0;j<hnum;j+=1)
|
||||
append(output[i].w,rand()>0.5?-2*rand():2*rand());
|
||||
output[i].bia=rand()>0.5?-5*rand():5*rand();
|
||||
}
|
||||
|
||||
var forward = func(x) {
|
||||
var input=training_set[x];
|
||||
for(var i=0;i<hnum;i+=1) {
|
||||
for (var i=0;i<hnum;i+=1) {
|
||||
hidden[i].in=hidden[i].bia;
|
||||
for(var j=0;j<inum;j+=1)
|
||||
for (var j=0;j<inum;j+=1)
|
||||
hidden[i].in+=hidden[i].w[j]*input[j];
|
||||
hidden[i].out=tanh(hidden[i].in);
|
||||
}
|
||||
for(var i=0;i<onum;i+=1) {
|
||||
for (var i=0;i<onum;i+=1) {
|
||||
output[i].in=output[i].bia;
|
||||
for(var j=0;j<hnum;j+=1)
|
||||
for (var j=0;j<hnum;j+=1)
|
||||
output[i].in+=output[i].w[j]*hidden[j].out;
|
||||
output[i].out=sigmoid(output[i].in);
|
||||
}
|
||||
@@ -67,15 +67,15 @@ var forward = func(x) {
|
||||
}
|
||||
var run = func(vec) {
|
||||
var input=vec;
|
||||
for(var i=0;i<hnum;i+=1) {
|
||||
for (var i=0;i<hnum;i+=1) {
|
||||
hidden[i].in=hidden[i].bia;
|
||||
for(var j=0;j<inum;j+=1)
|
||||
for (var j=0;j<inum;j+=1)
|
||||
hidden[i].in+=hidden[i].w[j]*input[j];
|
||||
hidden[i].out=tanh(hidden[i].in);
|
||||
}
|
||||
for(var i=0;i<onum;i+=1) {
|
||||
for (var i=0;i<onum;i+=1) {
|
||||
output[i].in=output[i].bia;
|
||||
for(var j=0;j<hnum;j+=1)
|
||||
for (var j=0;j<hnum;j+=1)
|
||||
output[i].in+=output[i].w[j]*hidden[j].out;
|
||||
output[i].out=sigmoid(output[i].in);
|
||||
}
|
||||
@@ -87,20 +87,20 @@ var get_error = func(x) {
|
||||
var backward = func(x) {
|
||||
var input=training_set[x];
|
||||
output[0].diff=(expect[x]-output[0].out)*diffsigmoid(output[0].in);
|
||||
for(var i=0;i<hnum;i+=1) {
|
||||
for (var i=0;i<hnum;i+=1) {
|
||||
hidden[i].diff=0;
|
||||
for(var j=0;j<onum;j+=1)
|
||||
for (var j=0;j<onum;j+=1)
|
||||
hidden[i].diff+=output[j].w[i]*output[j].diff;
|
||||
hidden[i].diff*=difftanh(hidden[i].in);
|
||||
}
|
||||
for(var i=0;i<hnum;i+=1) {
|
||||
for (var i=0;i<hnum;i+=1) {
|
||||
hidden[i].bia+=hidden[i].diff;
|
||||
for(var j=0;j<inum;j+=1)
|
||||
for (var j=0;j<inum;j+=1)
|
||||
hidden[i].w[j]+=hidden[i].diff*input[j];
|
||||
}
|
||||
for(var i=0;i<onum;i+=1) {
|
||||
for (var i=0;i<onum;i+=1) {
|
||||
output[i].bia+=output[i].diff;
|
||||
for(var j=0;j<hnum;j+=1)
|
||||
for (var j=0;j<hnum;j+=1)
|
||||
output[i].w[j]+=output[i].diff*hidden[j].out;
|
||||
}
|
||||
return;
|
||||
@@ -109,7 +109,7 @@ var backward = func(x) {
|
||||
var (cnt,error)=(0,100);
|
||||
while(error>0.0005) {
|
||||
error=0;
|
||||
for(var i=0;i<4;i+=1) {
|
||||
for (var i=0;i<4;i+=1) {
|
||||
forward(i);
|
||||
error+=get_error(i);
|
||||
backward(i);
|
||||
|
||||
@@ -8,8 +8,8 @@ var ppm = func(filename, width, height, RGB) {
|
||||
# P6 use binary character
|
||||
var fd = io.open(filename, "wb");
|
||||
io.write(fd, "P6\n"~width~" "~height~"\n255\n");
|
||||
for(var i = 0; i<height; i += 1) {
|
||||
for(var j = 0; j<width; j += 1) {
|
||||
for (var i = 0; i<height; i += 1) {
|
||||
for (var j = 0; j<width; j += 1) {
|
||||
io.write(fd, RGB(i, j));
|
||||
}
|
||||
}
|
||||
@@ -27,7 +27,7 @@ var f = func(i, j) {
|
||||
var (yDel, xDel) = (yMax-yMin, xMax-xMin);
|
||||
var (y, x) = ((i/height)*yDel+yMin, (j/width)*xDel+xMin);
|
||||
var (x0, y0) = (x, y);
|
||||
for(var iter = 0; iter<64; iter += 1) {
|
||||
for (var iter = 0; iter<64; iter += 1) {
|
||||
(x0, y0) = (math.abs(x0), math.abs(y0));
|
||||
var (x1, y1) = ((x0*x0)-(y0*y0)+x, 2*x0*y0+y);
|
||||
(x0, y0) = (x1, y1);
|
||||
|
||||
@@ -28,7 +28,7 @@ var blank = func(s) {
|
||||
return 1;
|
||||
}
|
||||
var space = [" "[0],"\n"[0],"\t"[0],"\r"[0]];
|
||||
for(var i = 0; i<size(s); i+=1) {
|
||||
for (var i = 0; i<size(s); i+=1) {
|
||||
var flag = 0;
|
||||
foreach(var j; space) {
|
||||
if (s[i]==j) {
|
||||
|
||||
@@ -202,10 +202,10 @@ var main = func(frame) {
|
||||
|
||||
print("\e[2J");
|
||||
var stamp = maketimestamp();
|
||||
for(var t = 0; t < frame; t += 1) {
|
||||
for (var t = 0; t < frame; t += 1) {
|
||||
stamp.stamp();
|
||||
for(var i = 0; i < width; i += 1) {
|
||||
for(var j = 0; j < height; j += 1) {
|
||||
for (var i = 0; i < width; i += 1) {
|
||||
for (var j = 0; j < height; j += 1) {
|
||||
var uv=vec2sub(vec2mul(vec2div([i,j],[width,height]),vec2_2_2),vec2_1_1);
|
||||
uv[0]*=aspect*pixelAspect;
|
||||
var ro=[-6,0,0];
|
||||
|
||||
@@ -22,7 +22,7 @@ var fib = func() {
|
||||
return;
|
||||
}
|
||||
var co = [coroutine.create(fib), coroutine.create(fib)];
|
||||
for(var i = 0; i < 45; i += 1) {
|
||||
for (var i = 0; i < 45; i += 1) {
|
||||
var res = [coroutine.resume(co[0]), coroutine.resume(co[1])];
|
||||
if (res[0] == nil or res[1] == nil or res[0][0] != res[1][0])
|
||||
die("different coroutines don't share the same local scope");
|
||||
@@ -32,12 +32,12 @@ for(var i = 0; i < 45; i += 1) {
|
||||
func() {
|
||||
var x = 1;
|
||||
var co = coroutine.create(func() {
|
||||
for(var j = 0; j < 128; j += 1) {
|
||||
for (var j = 0; j < 128; j += 1) {
|
||||
coroutine.yield(x, i, j);
|
||||
x += 1;
|
||||
}
|
||||
});
|
||||
for(var i = 0; i < 16; i += 1) {
|
||||
for (var i = 0; i < 16; i += 1) {
|
||||
var res = coroutine.resume(co);
|
||||
if (res == nil or res[0] != x or res[1] != i)
|
||||
die("coroutine should have the ability to get upvalues");
|
||||
@@ -54,7 +54,7 @@ func {
|
||||
return "end";
|
||||
});
|
||||
|
||||
for(var i = 0; i < 5; i += 1)
|
||||
for (var i = 0; i < 5; i += 1)
|
||||
println("[0] coroutine.resume get ", coroutine.resume(co, i, i + 1));
|
||||
print("\n");
|
||||
}();
|
||||
@@ -93,7 +93,7 @@ println("[2] coroutine state:\e[91m ", coroutine.status(co), "\e[0m");
|
||||
println("[2] ok\n");
|
||||
|
||||
# pressure test
|
||||
for(var t = 0; t < 10; t += 1) {
|
||||
for (var t = 0; t < 10; t += 1) {
|
||||
var productor = func() {
|
||||
while(1) {
|
||||
coroutine.yield(i);
|
||||
@@ -107,7 +107,7 @@ for(var t = 0; t < 10; t += 1) {
|
||||
var bar = process_bar.high_resolution_bar(40);
|
||||
var consumer = func() {
|
||||
counter += 1;
|
||||
for(var i = 0; i < t + 1; i += 1)
|
||||
for (var i = 0; i < t + 1; i += 1)
|
||||
coroutine.resume(co);
|
||||
if (counter - int(counter / 1000) * 1000 == 0) {
|
||||
var rate = counter / 2e5;
|
||||
@@ -120,7 +120,7 @@ for(var t = 0; t < 10; t += 1) {
|
||||
}
|
||||
|
||||
tm.stamp();
|
||||
for(var i = 0; i < 1e5; i += 1)
|
||||
for (var i = 0; i < 1e5; i += 1)
|
||||
consumer();
|
||||
println(" ", bar.bar(1), " 100% | ",
|
||||
str(int(1e3 * counter / tm.elapsedMSec())),
|
||||
|
||||
@@ -4,7 +4,7 @@ use std.process_bar;
|
||||
var mess = func(vec) {
|
||||
srand();
|
||||
var s=size(vec);
|
||||
for(var i=s-1;i>=0;i-=1) {
|
||||
for (var i=s-1;i>=0;i-=1) {
|
||||
var r=int(rand()*i);
|
||||
(vec[r],vec[i])=(vec[i],vec[r]);
|
||||
}
|
||||
@@ -21,7 +21,7 @@ var project = func(n) {
|
||||
|
||||
var last_step=0;
|
||||
ts.stamp();
|
||||
for(var i=0;i<n;i+=1) {
|
||||
for (var i=0;i<n;i+=1) {
|
||||
color[i]=[i,"color "~i,i+n*10];
|
||||
# generate process bar, every 0.2%
|
||||
if ((i-last_step)/n>1/500) {
|
||||
@@ -58,7 +58,7 @@ var select = func(n) {
|
||||
|
||||
var last_step=0;
|
||||
ts.stamp();
|
||||
for(var i=0;i<n;i+=1) {
|
||||
for (var i=0;i<n;i+=1) {
|
||||
color[i]=[i,"color "~i,i+n*10];
|
||||
message[i]=[i+n*10,"message "~i];
|
||||
# generate process bar, every 0.2%
|
||||
@@ -113,7 +113,7 @@ var cartesian = func(n) {
|
||||
|
||||
var last_step=0;
|
||||
ts.stamp();
|
||||
for(var i=0;i<n;i+=1) {
|
||||
for (var i=0;i<n;i+=1) {
|
||||
color[i]=[i,"color "~i,i+n*10];
|
||||
message[i]=[i+n*10,"message "~i];
|
||||
# generate process bar, every 0.2%
|
||||
@@ -149,15 +149,15 @@ var cartesian = func(n) {
|
||||
}
|
||||
|
||||
println("project");
|
||||
for(var i=10;i<1e6;i*=10) {
|
||||
for (var i=10;i<1e6;i*=10) {
|
||||
project(i);
|
||||
}
|
||||
println("select");
|
||||
for(var i=10;i<1e6;i*=10) {
|
||||
for (var i=10;i<1e6;i*=10) {
|
||||
select(i);
|
||||
}
|
||||
println("cartesian");
|
||||
for(var i=100;i<600;i+=100) {
|
||||
for (var i=100;i<600;i+=100) {
|
||||
cartesian(i);
|
||||
}
|
||||
|
||||
|
||||
@@ -52,23 +52,23 @@ var myers = func(src,dst,show_table=0) {
|
||||
# find solution
|
||||
if (x==src_len-1 and y==dst_len-1) {
|
||||
append(path,vec[i]);
|
||||
for(var (prev,iter)=(elem[2],size(total)-1);iter>0;iter-=1) {
|
||||
for (var (prev,iter)=(elem[2],size(total)-1);iter>0;iter-=1) {
|
||||
var t=total[iter-1][prev];
|
||||
append(path,t);
|
||||
prev=t[2];
|
||||
}
|
||||
|
||||
if (show_table) {
|
||||
for(var t=size(path)-1;t>=0;t-=1)
|
||||
for (var t=size(path)-1;t>=0;t-=1)
|
||||
print("("~path[t][1]~","~path[t][0]~")",t==0?"":"->");
|
||||
println();
|
||||
}
|
||||
|
||||
# reverse path
|
||||
for(var t=0;t<size(path)/2;t+=1)
|
||||
for (var t=0;t<size(path)/2;t+=1)
|
||||
(path[t],path[-1-t])=(path[-1-t],path[t]);
|
||||
# print diff
|
||||
for(var t=1;t<size(path);t+=1) {
|
||||
for (var t=1;t<size(path);t+=1) {
|
||||
var (prev_x,prev_y)=(path[t-1][1],path[t-1][0]);
|
||||
var (x,y)=(path[t][1],path[t][0]);
|
||||
var (sub_x,sub_y)=(x-prev_x,y-prev_y);
|
||||
|
||||
@@ -15,14 +15,14 @@ var main = func(run_time) {
|
||||
setsize(b,1760);
|
||||
|
||||
print("\e[2J");
|
||||
for(var run=0;run<run_time;run+=1) {
|
||||
for (var run=0;run<run_time;run+=1) {
|
||||
ts.stamp();
|
||||
forindex(var i;b) {
|
||||
b[i]=" ";
|
||||
z[i]=0;
|
||||
}
|
||||
for(var j=0;j<6.28;j+=0.07) {
|
||||
for(var i=0;i<6.28;i+=0.02) {
|
||||
for (var j=0;j<6.28;j+=0.07) {
|
||||
for (var i=0;i<6.28;i+=0.02) {
|
||||
var (c,d,e,f,g)=(sin(i),cos(j),sin(A),sin(j),cos(A));
|
||||
var h=d+2;
|
||||
var D=1/(c*h*e+f*g+5);
|
||||
@@ -40,7 +40,7 @@ var main = func(run_time) {
|
||||
}
|
||||
print("\e[H");
|
||||
var screen="";
|
||||
for(var k=0;k<1761;k+=1) {
|
||||
for (var k=0;k<1761;k+=1) {
|
||||
screen~=(mod(k,80)?b[k]:"\n");
|
||||
A+=0.00004;
|
||||
B+=0.00002;
|
||||
|
||||
@@ -8,8 +8,8 @@ var ppm = func(filename, width, height, RGB) {
|
||||
# P6 use binary character
|
||||
var fd = io.open(filename, "wb");
|
||||
io.write(fd, "P6\n"~width~" "~height~"\n255\n");
|
||||
for(var i = 0; i<height; i+=1) {
|
||||
for(var j = 0; j<width; j+=1) {
|
||||
for (var i = 0; i<height; i+=1) {
|
||||
for (var j = 0; j<width; j+=1) {
|
||||
io.write(fd, RGB(i, j));
|
||||
}
|
||||
}
|
||||
@@ -30,10 +30,10 @@ var RGB = func(h, w) {
|
||||
var (R, G, B) = (0, 0, 0);
|
||||
|
||||
var tmp = 0.5;
|
||||
for(var i = 0; i<50; i+=1) {
|
||||
for (var i = 0; i<50; i+=1) {
|
||||
tmp = r*tmp*(1-tmp);
|
||||
}
|
||||
for(var i = 0; i<150; i+=1) {
|
||||
for (var i = 0; i<150; i+=1) {
|
||||
tmp = r*tmp*(1-tmp);
|
||||
if (abs(tmp-x)<0.0005) {
|
||||
R = int(255*(150 - i)/150);
|
||||
|
||||
@@ -2,5 +2,5 @@ var fib = func(x) {
|
||||
if (x<2) return x;
|
||||
return fib(x-1)+fib(x-2);
|
||||
}
|
||||
for(var i=0;i<31;i+=1)
|
||||
for (var i=0;i<31;i+=1)
|
||||
print(fib(i),'\n');
|
||||
|
||||
@@ -16,8 +16,8 @@ while(1) {
|
||||
break;
|
||||
}
|
||||
var res = "\e[1;1H";
|
||||
for(var i = 0; i<20; i+=1) {
|
||||
for(var j = 0; j<40; j+=1) {
|
||||
for (var i = 0; i<20; i+=1) {
|
||||
for (var j = 0; j<40; j+=1) {
|
||||
res ~= "\e[38;5;" ~ int(rand()*256) ~ ";1m";
|
||||
res ~= chars[int(rand()*size(chars))];
|
||||
res ~= "\e[0m ";
|
||||
|
||||
@@ -38,21 +38,21 @@ var MAX_ITER_NUM = 0.5e5;
|
||||
|
||||
var append_vec = func {
|
||||
var res = [];
|
||||
for(var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
for (var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
append(res, [1, 2, 3, 4]);
|
||||
}
|
||||
}
|
||||
|
||||
var append_hash = func {
|
||||
var res = [];
|
||||
for(var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
for (var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
append(res, {a:1, b:2, c:3, d:4});
|
||||
}
|
||||
}
|
||||
|
||||
var append_func = func {
|
||||
var res = [];
|
||||
for(var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
for (var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
append(res, func {
|
||||
println(arg);
|
||||
});
|
||||
@@ -61,42 +61,42 @@ var append_func = func {
|
||||
|
||||
var append_vec_in_vec = func {
|
||||
var res = [];
|
||||
for(var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
for (var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
append(res, [[], [], [], []]);
|
||||
}
|
||||
}
|
||||
|
||||
var append_hash_in_vec = func {
|
||||
var res = [];
|
||||
for(var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
for (var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
append(res, [{}, {}, {}, {}]);
|
||||
}
|
||||
}
|
||||
|
||||
var append_vec_in_hash = func {
|
||||
var res = [];
|
||||
for(var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
for (var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
append(res, {a:[], b:[], c:[], d:[]});
|
||||
}
|
||||
}
|
||||
|
||||
var append_hash_in_hash = func {
|
||||
var res = [];
|
||||
for(var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
for (var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
append(res, {a:{}, b:{}, c:{}, d:{}});
|
||||
}
|
||||
}
|
||||
|
||||
var append_hash_vec_hash = func {
|
||||
var res = [];
|
||||
for(var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
for (var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
append(res, {a:[{}], b:[{}], c:[{}], d:[{}]});
|
||||
}
|
||||
}
|
||||
|
||||
var append_tree = func {
|
||||
var res = [];
|
||||
for(var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
for (var i=0; i<MAX_ITER_NUM; i+=1) {
|
||||
append(res, {
|
||||
a: {b: {c:[]}},
|
||||
d: {e: {}},
|
||||
|
||||
@@ -51,13 +51,13 @@ var hex_index=[0,0,0,0];
|
||||
var textprint = func(index) {
|
||||
var info="";
|
||||
if (os.platform()=="windows") {
|
||||
for(var i=index-cnt;i<index;i+=1)
|
||||
for (var i=index-cnt;i<index;i+=1)
|
||||
info~=(s[i]<32 or s[i]>=127)?".":chr(s[i]);
|
||||
} else {
|
||||
for(var i=index-cnt;i<index;i+=1)
|
||||
for (var i=index-cnt;i<index;i+=1)
|
||||
info~=(s[i]<32 or s[i]==127)?".":chr(s[i]);
|
||||
}
|
||||
for(var i=cnt;i<16;i+=1) {
|
||||
for (var i=cnt;i<16;i+=1) {
|
||||
info~=".";
|
||||
}
|
||||
return " |"~info~"|\n";
|
||||
@@ -70,7 +70,7 @@ var indexprint = func(index) {
|
||||
index=int(index/256);
|
||||
}
|
||||
var info="";
|
||||
for(var i=3;i>=0;i-=1)
|
||||
for (var i=3;i>=0;i-=1)
|
||||
info~=hex[hex_index[i]];
|
||||
return info~" ";
|
||||
}
|
||||
@@ -81,7 +81,7 @@ func() {
|
||||
return;
|
||||
}
|
||||
var info=indexprint(0);
|
||||
for(var i=0;i<size(s);i+=1) {
|
||||
for (var i=0;i<size(s);i+=1) {
|
||||
if (cnt==16) {
|
||||
info~=textprint(i);
|
||||
print(info);
|
||||
@@ -92,7 +92,7 @@ func() {
|
||||
cnt+=1;
|
||||
info~=hex[s[i]]~" ";
|
||||
}
|
||||
for(var l=cnt;l<16;l+=1)
|
||||
for (var l=cnt;l<16;l+=1)
|
||||
info~=" ";
|
||||
if (cnt<=8)
|
||||
info~=" ";
|
||||
|
||||
@@ -301,7 +301,7 @@ while(1) {
|
||||
if (size(args)==2) {
|
||||
path=args[0];
|
||||
args=split("=",args[1]);
|
||||
for(var i=0;i<size(args);i+=2)
|
||||
for (var i=0;i<size(args);i+=2)
|
||||
tmp[args[i]]=args[i+1];
|
||||
}
|
||||
if (path=="/" or path=="/index") {
|
||||
|
||||
@@ -98,7 +98,7 @@ var test_json = func(json) {
|
||||
var name = keys(hash)[0];
|
||||
hash[name] = [];
|
||||
print("\e[1000D", bar.bar(0));
|
||||
for(var i = 0; i<500; i+=1) {
|
||||
for (var i = 0; i<500; i+=1) {
|
||||
append(hash[name], {id:i, content:int(rand()*1e7)});
|
||||
print("\e[1000D", bar.bar((i+1)/500));
|
||||
}
|
||||
@@ -111,7 +111,7 @@ var test_json = func(json) {
|
||||
};
|
||||
|
||||
var stamp = maketimestamp();
|
||||
for(var i = 0; i<10; i += 1) {
|
||||
for (var i = 0; i<10; i += 1) {
|
||||
stamp.stamp();
|
||||
test_json(json);
|
||||
println("time usage: ", stamp.elapsedUSec()/1000, " ms");
|
||||
|
||||
@@ -7,8 +7,8 @@ var ppm = func(filename, width, height, RGB) {
|
||||
# P6 use binary character
|
||||
var fd = io.open(filename, "wb");
|
||||
io.write(fd, "P6\n"~width~" "~height~"\n255\n");
|
||||
for(var i = 0; i<height; i += 1) {
|
||||
for(var j = 0; j<width; j += 1) {
|
||||
for (var i = 0; i<height; i += 1) {
|
||||
for (var j = 0; j<width; j += 1) {
|
||||
io.write(fd, RGB(i, j));
|
||||
}
|
||||
}
|
||||
@@ -27,7 +27,7 @@ var f = func(i, j) {
|
||||
var (yDel, xDel) = (yMax-yMin, xMax-xMin);
|
||||
var (y, x) = (init_y, init_x);
|
||||
var (y0, x0) = ((i/height)*yDel+yMin, (j/width)*xDel+xMin);
|
||||
for(var iter = 0; iter<64; iter += 1) {
|
||||
for (var iter = 0; iter<64; iter += 1) {
|
||||
var (x1, y1) = ((x0*x0)-(y0*y0)+x, 2*x0*y0+y);
|
||||
(x0, y0) = (x1, y1);
|
||||
if ((x0*x0)+(y0*y0)>4) {
|
||||
|
||||
@@ -39,8 +39,8 @@ foreach(var a; ants) {
|
||||
var print_map = func {
|
||||
var pics = [" ", "[]"];
|
||||
var res = "\e[1;1H";
|
||||
for(var y = 0; y<30; y += 1) {
|
||||
for(var x = 0; x<60; x += 1) {
|
||||
for (var y = 0; y<30; y += 1) {
|
||||
for (var x = 0; x<60; x += 1) {
|
||||
res ~= "\e[38;5;"~map_color[x + y*60]~";1m";
|
||||
res ~= pics[map[x + y*60]] ~ "\e[0m";
|
||||
}
|
||||
|
||||
@@ -45,10 +45,10 @@ var run = func(width,height) {
|
||||
forindex(var j;map[i])
|
||||
map[i][j]=rand()<0.45?'O':'.';
|
||||
|
||||
for(var r=0;r<100;r+=1) {
|
||||
for (var r=0;r<100;r+=1) {
|
||||
prt(map);
|
||||
for(var i=0;i<height;i+=1)
|
||||
for(var j=0;j<width;j+=1) {
|
||||
for (var i=0;i<height;i+=1)
|
||||
for (var j=0;j<width;j+=1) {
|
||||
var cnt=check(j,i+1)+check(j+1,i)+check(j,i-1)+check(j-1,i)+check(j+1,i+1)+check(j-1,i-1)+check(j+1,i-1)+check(j-1,i+1);
|
||||
if (cnt==2) tmp[i][j]=map[i][j];
|
||||
elsif (cnt==3) tmp[i][j]='O';
|
||||
@@ -81,17 +81,17 @@ var ppm_gen = func(width,height) {
|
||||
iter_to_print=num(vec[2]);
|
||||
var data=vec[3];
|
||||
var n="1"[0];
|
||||
for(var i=0;i<pixels;i+=1) {
|
||||
for (var i=0;i<pixels;i+=1) {
|
||||
res[i]=data[i]==n?1:0;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
rand(time(0));
|
||||
for(var i=0;i<pixels;i+=1)
|
||||
for (var i=0;i<pixels;i+=1)
|
||||
res[i]=0;
|
||||
|
||||
for(var i=int(height/5*2);i<int(height/5*3);i+=1)
|
||||
for (var i=int(height/5*2);i<int(height/5*3);i+=1)
|
||||
forindex(var j;res[i])
|
||||
res[i*width+j]=rand()<0.5?1:0;
|
||||
return res;
|
||||
@@ -100,7 +100,7 @@ var ppm_gen = func(width,height) {
|
||||
var store = func() {
|
||||
var fd=io.open(".life_data","w");
|
||||
io.write(fd,str(width)~"\n"~str(height)~"\n"~str(iter_to_print)~"\n");
|
||||
for(var i=0;i<pixels;i+=1) {
|
||||
for (var i=0;i<pixels;i+=1) {
|
||||
io.write(fd,map[i]==1?"1":"0");
|
||||
}
|
||||
io.close(fd);
|
||||
@@ -113,7 +113,7 @@ var ppm_gen = func(width,height) {
|
||||
io.write(fd,"P6\n"~width~" "~height~"\n255\n");
|
||||
var white=char(255)~char(255)~char(255);
|
||||
var black=char(0)~char(0)~char(0);
|
||||
for(var i=0;i<pixels;i+=1) {
|
||||
for (var i=0;i<pixels;i+=1) {
|
||||
io.write(fd,map[i]==1?white:black);
|
||||
}
|
||||
io.close(fd);
|
||||
@@ -130,10 +130,10 @@ var ppm_gen = func(width,height) {
|
||||
return map[_height*width+_width]==1;
|
||||
}
|
||||
|
||||
for(var r=0;r<1001;r+=1) {
|
||||
for (var r=0;r<1001;r+=1) {
|
||||
ts.stamp();
|
||||
for(var i=0;i<height;i+=1) {
|
||||
for(var j=0;j<width;j+=1) {
|
||||
for (var i=0;i<height;i+=1) {
|
||||
for (var j=0;j<width;j+=1) {
|
||||
var cnt=check(j,i+1)+check(j+1,i)+check(j,i-1)+check(j-1,i)+check(j+1,i+1)+check(j-1,i-1)+check(j+1,i-1)+check(j-1,i+1);
|
||||
if (cnt==2) tmp[i*width+j]=map[i*width+j];
|
||||
elsif (cnt==3) tmp[i*width+j]=1;
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
for(;;)break;
|
||||
for(;;) {
|
||||
for (;;)break;
|
||||
for (;;) {
|
||||
var a=1;
|
||||
break;
|
||||
}
|
||||
for(var i=1;;)break;
|
||||
for(var i=1;;i+=1)break;
|
||||
for(var i=1;i<10;i+=1)
|
||||
for (var i=1;;)break;
|
||||
for (var i=1;;i+=1)break;
|
||||
for (var i=1;i<10;i+=1)
|
||||
print(i," ");
|
||||
print("\n");
|
||||
while(1)break;
|
||||
@@ -37,5 +37,5 @@ var f = func() {
|
||||
var x=0;
|
||||
return func() {x+=1;};
|
||||
}();
|
||||
for(var i=0;i<4e6;i+=1)
|
||||
for (var i=0;i<4e6;i+=1)
|
||||
f();
|
||||
@@ -1,12 +1,12 @@
|
||||
var (yMin, yMax, xMin, xMax, line) = (-0.2, 0.2, -1.5, -1.0, "");
|
||||
var (yDel, xDel) = (yMax-yMin, xMax-xMin);
|
||||
for(var yPixel = 0; yPixel < 24; yPixel += 1) {
|
||||
for (var yPixel = 0; yPixel < 24; yPixel += 1) {
|
||||
var y = (yPixel/24)*yDel+yMin;
|
||||
for(var xPixel = 0; xPixel < 80; xPixel += 1) {
|
||||
for (var xPixel = 0; xPixel < 80; xPixel += 1) {
|
||||
var x = (xPixel/80)*xDel+xMin;
|
||||
var pixel = " ";
|
||||
var (x0, y0) = (x, y);
|
||||
for(var iter = 0; iter < 100; iter += 1) {
|
||||
for (var iter = 0; iter < 100; iter += 1) {
|
||||
var x1 = (x0*x0)-(y0*y0)+x;
|
||||
var y1 = 2*x0*y0+y;
|
||||
(x0, y0) = (x1, y1);
|
||||
|
||||
@@ -7,8 +7,8 @@ var ppm = func(filename, width, height, RGB) {
|
||||
# P6 use binary character
|
||||
var fd = io.open(filename, "wb");
|
||||
io.write(fd, "P6\n"~width~" "~height~"\n255\n");
|
||||
for(var i = 0; i<height; i += 1) {
|
||||
for(var j = 0; j<width; j += 1) {
|
||||
for (var i = 0; i<height; i += 1) {
|
||||
for (var j = 0; j<width; j += 1) {
|
||||
io.write(fd, RGB(i, j));
|
||||
}
|
||||
}
|
||||
@@ -25,7 +25,7 @@ var f = func(i, j) {
|
||||
var (yDel, xDel) = (yMax-yMin, xMax-xMin);
|
||||
var (y, x) = ((i/height)*yDel+yMin, (j/width)*xDel+xMin);
|
||||
var (x0, y0) = (x, y);
|
||||
for(var iter = 0; iter<64; iter += 1) {
|
||||
for (var iter = 0; iter<64; iter += 1) {
|
||||
var (x1, y1) = ((x0*x0)-(y0*y0)+x, 2*x0*y0+y);
|
||||
(x0, y0) = (x1, y1);
|
||||
if ((x0*x0)+(y0*y0)>4) {
|
||||
|
||||
@@ -58,11 +58,11 @@ var mem_size=1024*1024*4; # memory size, byte
|
||||
var init = func() {
|
||||
println("[",os.time(),"] init ",reg_size," registers.");
|
||||
setsize(reg,reg_size); # 8 bit address wire
|
||||
for(var i=0;i<reg_size;i+=1)
|
||||
for (var i=0;i<reg_size;i+=1)
|
||||
reg[i]=0;
|
||||
println("[",os.time(),"] init memory, memory size: ",mem_size/1024/1024," MB.");
|
||||
setsize(mem,mem_size);
|
||||
for(var i=0;i<mem_size;i+=1)
|
||||
for (var i=0;i<mem_size;i+=1)
|
||||
mem[i]=0;
|
||||
println("[",os.time(),"] init completed.");
|
||||
}
|
||||
@@ -79,7 +79,7 @@ var ctx_info = func() {
|
||||
var cnt=0;
|
||||
println("pc : 0x",hex32(pc));
|
||||
println("instr : 0x",hex(ir[0]),hex(ir[1]),hex(ir[2]),hex(ir[3]));
|
||||
for(var i=0;i<reg_size;i+=1) {
|
||||
for (var i=0;i<reg_size;i+=1) {
|
||||
print("reg[",hex(i),"]: 0x",hex32(reg[i])," ");
|
||||
if (cnt==3) {
|
||||
print("\n");
|
||||
|
||||
@@ -23,13 +23,13 @@ var hex32str = func() {
|
||||
var ch=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"];
|
||||
var tbl=[];
|
||||
setsize(tbl,256);
|
||||
for(var i=0;i<16;i+=1) {
|
||||
for(var j=0;j<16;j+=1)
|
||||
for (var i=0;i<16;i+=1) {
|
||||
for (var j=0;j<16;j+=1)
|
||||
tbl[i*16+j]=ch[i]~ch[j];
|
||||
}
|
||||
return func(num) {
|
||||
var res="";
|
||||
for(var i=0;i<4;i+=1) {
|
||||
for (var i=0;i<4;i+=1) {
|
||||
res~=tbl[u32_bits_and(num,0xff)];
|
||||
num=floor(num/256);
|
||||
}
|
||||
@@ -63,14 +63,14 @@ var md5 = func() {
|
||||
];
|
||||
|
||||
var l = func(num,cx) {
|
||||
for(var i=0;i<cx;i+=1) {
|
||||
for (var i=0;i<cx;i+=1) {
|
||||
num=check(num*2);
|
||||
}
|
||||
return num;
|
||||
}
|
||||
var r = func(num,cx) {
|
||||
num=check(num);
|
||||
for(var i=0;i<cx;i+=1) {
|
||||
for (var i=0;i<cx;i+=1) {
|
||||
num=num/2;
|
||||
}
|
||||
return floor(num);
|
||||
@@ -113,7 +113,7 @@ var md5 = func() {
|
||||
return func(s) {
|
||||
var (s_size,len,res)=(size(s),size(s)*8,[]);
|
||||
setsize(res,s_size);
|
||||
for(var i=0;i<s_size;i+=1) {
|
||||
for (var i=0;i<s_size;i+=1) {
|
||||
res[i]=s[i];
|
||||
}
|
||||
# +------len------+--1~512--+--64--+
|
||||
@@ -129,17 +129,17 @@ var md5 = func() {
|
||||
}
|
||||
setsize(res,res_size);
|
||||
res[s_size]=0x80;
|
||||
for(var i=s_size+1;i<res_size;i+=1)
|
||||
for (var i=s_size+1;i<res_size;i+=1)
|
||||
res[i]=0;
|
||||
|
||||
# little endian
|
||||
setsize(res,size(res)+8);
|
||||
var (s_size,lower32,higher32)=(size(res),check(len),check(len/math.pow(2,32)));
|
||||
for(var i=4;i>0;i-=1) {
|
||||
for (var i=4;i>0;i-=1) {
|
||||
res[s_size-4-i]=floor(lower32-floor(lower32/256)*256);
|
||||
lower32=floor(lower32/256);
|
||||
}
|
||||
for(var i=4;i>0;i-=1) {
|
||||
for (var i=4;i>0;i-=1) {
|
||||
res[s_size-i]=floor(higher32-floor(higher32/256)*256);
|
||||
higher32=floor(higher32/256);
|
||||
}
|
||||
@@ -149,7 +149,7 @@ var md5 = func() {
|
||||
# this may only work when string's length is under 1<<51
|
||||
var tmp=[];
|
||||
setsize(tmp,size(res)/4);
|
||||
for(var i=0;i<size(res);i+=4) {
|
||||
for (var i=0;i<size(res);i+=4) {
|
||||
tmp[i/4]=res[i+3]*math.pow(2,24)+
|
||||
res[i+2]*math.pow(2,16)+
|
||||
res[i+1]*math.pow(2,8)+
|
||||
@@ -163,9 +163,9 @@ var md5 = func() {
|
||||
var D=0x10325476;
|
||||
|
||||
res_size=size(res);
|
||||
for(var i=0;i<res_size;i+=16) {
|
||||
for (var i=0;i<res_size;i+=16) {
|
||||
var (f,a,b,c,d)=(0,A,B,C,D);
|
||||
for(var j=0;j<64;j+=1) {
|
||||
for (var j=0;j<64;j+=1) {
|
||||
f=functions[j](b,c,d);
|
||||
(a,b,c,d)=(d,check(b+rol(a+f+K[j]+res[i+idx[j]],S[j])),b,c);
|
||||
}
|
||||
|
||||
@@ -19,9 +19,9 @@ var compare = func() {
|
||||
var timestamp = maketimestamp();
|
||||
timestamp.stamp();
|
||||
var bar = process_bar.high_resolution_bar(40);
|
||||
for(var i = begin; i<end; i += 1) {
|
||||
for (var i = begin; i<end; i += 1) {
|
||||
var s = "";
|
||||
for(var j = 0; j<i; j += 1) {
|
||||
for (var j = 0; j<i; j += 1) {
|
||||
s ~= ch[rand()*size(ch)];
|
||||
}
|
||||
byte += size(s);
|
||||
@@ -104,7 +104,7 @@ var filechecksum = func() {
|
||||
}
|
||||
|
||||
var randomchecksum = func() {
|
||||
for(var i = 0; i<2048; i += 256) {
|
||||
for (var i = 0; i<2048; i += 256) {
|
||||
compare(i, i+256);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -16,7 +16,7 @@ println("[time ] ", tm.elapsedMSec()," ms");
|
||||
println();
|
||||
|
||||
func() {
|
||||
for(var i = 0; i<256; i += 1) {
|
||||
for (var i = 0; i<256; i += 1) {
|
||||
var tmp = []; # try trigger gc here to test delete ghost
|
||||
}
|
||||
println();
|
||||
@@ -30,14 +30,14 @@ var speed_test = func() {
|
||||
var invoke = dylib.limitcall(1);
|
||||
var tm = maketimestamp();
|
||||
|
||||
for(var t=0; t<10; t+=1) {
|
||||
for (var t=0; t<10; t+=1) {
|
||||
tm.stamp();
|
||||
for(var i=0; i<5e5; i+=1) {
|
||||
for (var i=0; i<5e5; i+=1) {
|
||||
invoke(fd, 40);
|
||||
}
|
||||
println("[time ] limited call: ", int(5e5/tm.elapsedMSec()), " call/ms");
|
||||
tm.stamp();
|
||||
for(var i=0; i<5e5; i+=1) {
|
||||
for (var i=0; i<5e5; i+=1) {
|
||||
vec_call(fd, 40);
|
||||
}
|
||||
println("[time ] dynamic call: ", int(5e5/tm.elapsedMSec()), " call/ms");
|
||||
|
||||
@@ -62,23 +62,23 @@ func() {
|
||||
var f2 = func() {var a=1;return a+1;}
|
||||
var f3 = func() {var (a,b)=(1,1);return a+b+1;}
|
||||
tm.stamp();
|
||||
for(var i=0;i<1e6;i+=1);
|
||||
for (var i=0;i<1e6;i+=1);
|
||||
duration=tm.elapsedMSec();
|
||||
println(str(int(1e6/duration))," calc/ms");
|
||||
tm.stamp();
|
||||
for(var i=0;i<1e6;i+=1)f1();
|
||||
for (var i=0;i<1e6;i+=1)f1();
|
||||
duration=tm.elapsedMSec();
|
||||
println(str(int(1e6/duration))," calc/ms");
|
||||
tm.stamp();
|
||||
for(var i=0;i<1e6;i+=1)func {}();
|
||||
for (var i=0;i<1e6;i+=1)func {}();
|
||||
duration=tm.elapsedMSec();
|
||||
println(str(int(1e6/duration))," calc/ms");
|
||||
tm.stamp();
|
||||
for(var i=0;i<1e6;i+=1)f2();
|
||||
for (var i=0;i<1e6;i+=1)f2();
|
||||
duration=tm.elapsedMSec();
|
||||
println(str(int(1e6/duration))," calc/ms");
|
||||
tm.stamp();
|
||||
for(var i=0;i<1e6;i+=1)
|
||||
for (var i=0;i<1e6;i+=1)
|
||||
func {
|
||||
var a=1;
|
||||
return a+1;
|
||||
@@ -86,11 +86,11 @@ func() {
|
||||
duration=tm.elapsedMSec();
|
||||
println(str(int(1e6/duration))," calc/ms");
|
||||
tm.stamp();
|
||||
for(var i=0;i<1e6;i+=1)f3();
|
||||
for (var i=0;i<1e6;i+=1)f3();
|
||||
duration=tm.elapsedMSec();
|
||||
println(str(int(1e6/duration))," calc/ms");
|
||||
tm.stamp();
|
||||
for(var i=0;i<1e6;i+=1)
|
||||
for (var i=0;i<1e6;i+=1)
|
||||
func {
|
||||
var (a,b)=(1,1);
|
||||
return a+b+1;
|
||||
|
||||
@@ -40,7 +40,7 @@ var cpu_occupation = func() {
|
||||
unix.sleep(0.05);
|
||||
first_in = 0;
|
||||
} else {
|
||||
for(var i = 0; i < 10; i += 1) {
|
||||
for (var i = 0; i < 10; i += 1) {
|
||||
unix.sleep(0.05);
|
||||
coroutine.yield(nil);
|
||||
}
|
||||
@@ -76,7 +76,7 @@ var random_generator = func() {
|
||||
var statistics = [];
|
||||
setsize(statistics, 70);
|
||||
while(1) {
|
||||
for(var i=0;i<10;i+=1) {
|
||||
for (var i=0;i<10;i+=1) {
|
||||
total+=1;
|
||||
var u=rand()*rand()*(rand()>0.5?-1:1);
|
||||
statistics[int(size(statistics)/2+u*size(statistics)/2)]+=1;
|
||||
@@ -85,7 +85,7 @@ var random_generator = func() {
|
||||
foreach(var st; statistics) {
|
||||
var max_rate=100/size(statistics);
|
||||
var rate=st/total*100;
|
||||
for(var i=size(s)-1;i>=0;i-=1) {
|
||||
for (var i=size(s)-1;i>=0;i-=1) {
|
||||
if (rate>=max_rate) {
|
||||
s[i]~="█";
|
||||
rate-=max_rate;
|
||||
@@ -96,7 +96,7 @@ var random_generator = func() {
|
||||
}
|
||||
}
|
||||
var tmp="";
|
||||
for(var i=0;i<size(statistics);i+=1) {
|
||||
for (var i=0;i<size(statistics);i+=1) {
|
||||
tmp~="─";
|
||||
}
|
||||
println("\e[16;1H \e[32m│", s[0], "│\e[0m");
|
||||
@@ -148,7 +148,7 @@ func() {
|
||||
mem_occ=rand()*10+40;
|
||||
}
|
||||
|
||||
for(var i=0;i<size(cpu_occupation_log)-1;i+=1) {
|
||||
for (var i=0;i<size(cpu_occupation_log)-1;i+=1) {
|
||||
cpu_occupation_log[i]=cpu_occupation_log[i+1];
|
||||
mem_occupation_log[i]=mem_occupation_log[i+1];
|
||||
}
|
||||
@@ -163,7 +163,7 @@ func() {
|
||||
println("\e[6;1H\e[1m CPU occupation(%) : \e[0m",cpu_occ>90?"\e[91m":"\e[32m",bar.bar(cpu_occ/100)~" ",cpu_occ,"\e[0m ");
|
||||
|
||||
var tmp="";
|
||||
for(var i=0;i<70;i+=1) {
|
||||
for (var i=0;i<70;i+=1) {
|
||||
tmp~="─";
|
||||
}
|
||||
|
||||
@@ -171,7 +171,7 @@ func() {
|
||||
foreach(var occ;cpu_occupation_log) {
|
||||
var max_rate=50/size(s);
|
||||
var rate=occ;
|
||||
for(var i=size(s)-1;i>=0;i-=1) {
|
||||
for (var i=size(s)-1;i>=0;i-=1) {
|
||||
if (rate>=max_rate) {
|
||||
s[i]~="█";
|
||||
rate-=max_rate;
|
||||
@@ -191,7 +191,7 @@ func() {
|
||||
foreach(var occ;mem_occupation_log) {
|
||||
var max_rate=100/size(s);
|
||||
var rate=occ;
|
||||
for(var i=size(s)-1;i>=0;i-=1) {
|
||||
for (var i=size(s)-1;i>=0;i-=1) {
|
||||
if (rate>=max_rate) {
|
||||
s[i]~="█";
|
||||
rate-=max_rate;
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
var (t,res)=(1,0);
|
||||
for(var m=1;m<4e6;m+=2)
|
||||
for (var m=1;m<4e6;m+=2)
|
||||
{
|
||||
res+=t/m;
|
||||
t=-t;
|
||||
|
||||
@@ -1,14 +1,14 @@
|
||||
use std.math;
|
||||
|
||||
var is_prime = func(x) {
|
||||
for(var i=2;i<x;i+=1)
|
||||
for (var i=2;i<x;i+=1)
|
||||
if (x/i==int(x/i))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
var is_prime_sqrt = func(x) {
|
||||
for(var i=2;i<=math.sqrt(x);i+=1)
|
||||
for (var i=2;i<=math.sqrt(x);i+=1)
|
||||
if (x/i==int(x/i))
|
||||
return 0;
|
||||
return 1;
|
||||
@@ -20,7 +20,7 @@ var filter = func(x) {
|
||||
if (x/i==int(x/i))
|
||||
return 0;
|
||||
if (x>=i) {
|
||||
for(var j=i+1;j<=math.sqrt(x);j+=1)
|
||||
for (var j=i+1;j<=math.sqrt(x);j+=1)
|
||||
if (x/j==int(x/j))
|
||||
return 0;
|
||||
append(primes,x);
|
||||
@@ -33,7 +33,7 @@ var filter = func(x) {
|
||||
|
||||
func() {
|
||||
var cnt=0;
|
||||
for(var i=2;i<50000;i+=1)
|
||||
for (var i=2;i<50000;i+=1)
|
||||
if (filter(i))
|
||||
cnt+=1;
|
||||
println(cnt);
|
||||
|
||||
@@ -35,8 +35,8 @@ var code=[
|
||||
# enable unicode
|
||||
runtime.windows.set_utf8_output();
|
||||
var texture=[" ","██"];
|
||||
for(var i=0;i<size(code);i+=1) {
|
||||
for(var j=0;j<size(code[i]);j+=1)
|
||||
for (var i=0;i<size(code);i+=1) {
|
||||
for (var j=0;j<size(code[i]);j+=1)
|
||||
print(texture[code[i][j]]);
|
||||
print('\n');
|
||||
}
|
||||
@@ -29,10 +29,10 @@ var var_sort = func() {
|
||||
var vec = [];
|
||||
setsize(vec, 1e4);
|
||||
rand(time(0));
|
||||
for(var i=0;i<1e4;i+=1)
|
||||
for (var i=0;i<1e4;i+=1)
|
||||
vec[i] = int(rand()*1e5);
|
||||
sort(vec);
|
||||
for(var i=1;i<1e4;i+=1) {
|
||||
for (var i=1;i<1e4;i+=1) {
|
||||
if (vec[i]<vec[i-1]) {
|
||||
die("incorrect sort result");
|
||||
}
|
||||
@@ -41,7 +41,7 @@ for(var i=1;i<1e4;i+=1) {
|
||||
var test = func(n) {
|
||||
var a=[];
|
||||
setsize(a,n);
|
||||
for(var i=0;i<n;i+=1) {
|
||||
for (var i=0;i<n;i+=1) {
|
||||
a[i]=int(rand()*n);
|
||||
}
|
||||
var ts=maketimestamp();
|
||||
@@ -51,7 +51,7 @@ var test = func(n) {
|
||||
|
||||
var a=[];
|
||||
setsize(a,n);
|
||||
for(var i=0;i<n;i+=1) {
|
||||
for (var i=0;i<n;i+=1) {
|
||||
a[i]=int(rand()*n);
|
||||
}
|
||||
ts.stamp();
|
||||
@@ -59,6 +59,6 @@ var test = func(n) {
|
||||
println("[time] ",str(n)," in ",ts.elapsedMSec()/1000," sec (lambda cmp)");
|
||||
}
|
||||
|
||||
for(var i=1000;i<1e6;i*=10) {
|
||||
for (var i=1000;i<1e6;i*=10) {
|
||||
test(i);
|
||||
}
|
||||
@@ -88,7 +88,7 @@ listify(1, 2, 3, 4); # returns a list: [1, 2, 3, 4]
|
||||
# this is not a "declaration", just a qualifier on the "=" operator.
|
||||
#
|
||||
var innerFunc = func {
|
||||
for(var dist=0; dist<100; dist += 1) {
|
||||
for (var dist=0; dist<100; dist += 1) {
|
||||
# Does not interfere with the "dist" symbol defined above
|
||||
}
|
||||
}
|
||||
@@ -134,7 +134,7 @@ var doSomething = dummyFunc;
|
||||
var stillGoing = 0;
|
||||
while(stillGoing) { doSomething(); }
|
||||
|
||||
for(var i=0; i < 3; i = i+1) {
|
||||
for (var i=0; i < 3; i = i+1) {
|
||||
elem = list1[i];
|
||||
doSomething(elem);
|
||||
}
|
||||
@@ -208,7 +208,7 @@ var Class2 = {
|
||||
#
|
||||
var string = "abcdefghijklmnopqrstuvwxyz";
|
||||
var ascii_sum = 0;
|
||||
for(var i=0; i<size(string); i+=1) { ascii_sum += string[i]; }
|
||||
for (var i=0; i<size(string); i+=1) { ascii_sum += string[i]; }
|
||||
|
||||
#
|
||||
# You can use backquotes to write UTF8 character constants
|
||||
@@ -224,7 +224,7 @@ if (`©` != 169) { print("Unicode violation bug!\n"); }
|
||||
#
|
||||
var ascii_lc = func(string) {
|
||||
var mutable = string ~ "";
|
||||
for(var i=0; i<size(mutable); i+=1) {
|
||||
for (var i=0; i<size(mutable); i+=1) {
|
||||
if (mutable[i] >= `A` and mutable[i] <= `Z`) {
|
||||
mutable[i] += (`a` - `A`);
|
||||
}
|
||||
@@ -257,7 +257,7 @@ print(joined_list, "\n");
|
||||
#
|
||||
var invert = func(vec) {
|
||||
var hash = {};
|
||||
for(var i=0; i<size(vec); i = i+1) {
|
||||
for (var i=0; i<size(vec); i = i+1) {
|
||||
hash[vec[i]] = i;
|
||||
}
|
||||
return hash;
|
||||
@@ -287,9 +287,9 @@ var join = func {
|
||||
var doneWithInnerLoopEarly = dummyFunc;
|
||||
var completelyDone = dummyFunc;
|
||||
# not supported now
|
||||
for(#OUTER;
|
||||
for (#OUTER;
|
||||
var i=0; i<100; i = i+1) {
|
||||
for(var j=0; j<100; j = j+1) {
|
||||
for (var j=0; j<100; j = j+1) {
|
||||
if (doneWithInnerLoopEarly()) {
|
||||
break;
|
||||
} elsif (completelyDone()) {
|
||||
@@ -315,7 +315,7 @@ var dump = func(o) {
|
||||
} elsif (typeof(o) == "vector") {
|
||||
result = result ~ "[ ";
|
||||
if (size(o) > 0) { result = result ~ dump(o[0]); }
|
||||
for(i=1; i<size(o); i=i+1) {
|
||||
for (i=1; i<size(o); i=i+1) {
|
||||
result = result ~ ", " ~ dump(o[i]);
|
||||
}
|
||||
result = result ~ " ]";
|
||||
@@ -326,7 +326,7 @@ var dump = func(o) {
|
||||
var k = ks[0];
|
||||
result = result ~ k ~ ":" ~ dump(o[k]);
|
||||
}
|
||||
for(i=1; i<size(o); i=i+1) {
|
||||
for (i=1; i<size(o); i=i+1) {
|
||||
var k = ks[i];
|
||||
result = result ~ ", " ~ k ~ " : " ~ dump(o[k]);
|
||||
}
|
||||
|
||||
@@ -218,17 +218,17 @@ println("~ 0x8000000000000000: ",~0x8000000000000000);
|
||||
println(~0x80000000==~0x8000000000000000);
|
||||
|
||||
var h=split(" ","0 1 2 3 4 5 6 7 8 9 a b c d e f");
|
||||
for(var a=0;a<16;a+=1) {
|
||||
for(var b=0;b<16;b+=1) {
|
||||
for(var c=0;c<16;c+=1) {
|
||||
for (var a=0;a<16;a+=1) {
|
||||
for (var b=0;b<16;b+=1) {
|
||||
for (var c=0;c<16;c+=1) {
|
||||
if (((a^b)&c)!=(a^(b&c))) {
|
||||
println("0x"~h[a],"^","0x"~h[b],"&","0x"~h[c]," -> a^b&c = 0x",h[a^b&c]," (a^b)&c = 0x",h[(a^b)&c]," a^(b&c) = 0x",h[(a^(b&c))]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for(var a=0;a<16;a+=1) {
|
||||
for(var b=0;b<16;b+=1) {
|
||||
for (var a=0;a<16;a+=1) {
|
||||
for (var b=0;b<16;b+=1) {
|
||||
var temp=b;
|
||||
println("temp^=0x"~h[a]~" -> 0x",h[temp^=a]," temp&=0x"~h[a]~" -> 0x",h[temp&=a]," temp|=0x"~h[a]~" -> 0x",h[temp|=a]);
|
||||
}
|
||||
@@ -261,7 +261,7 @@ var closure_tester = func() {
|
||||
];
|
||||
}();
|
||||
|
||||
for(var i = 1; i<=10; i += 1) {
|
||||
for (var i = 1; i<=10; i += 1) {
|
||||
closure_tester[0]();
|
||||
if (closure_tester[1]()!=i) {
|
||||
die("test failed: expect " ~ i ~ ", but get " ~ closure_tester[1]());
|
||||
|
||||
@@ -9,7 +9,7 @@ var game = func(x,y) {
|
||||
var texture=[" ","██","\e[91m██\e[0m"];
|
||||
var edge0="╔";
|
||||
var edge1="╚";
|
||||
for(var i=0;i<x;i+=1) {
|
||||
for (var i=0;i<x;i+=1) {
|
||||
edge0~="══";
|
||||
edge1~="══";
|
||||
}
|
||||
@@ -18,10 +18,10 @@ var game = func(x,y) {
|
||||
|
||||
var vec=[];
|
||||
setsize(vec,x);
|
||||
for(var i=0;i<x;i+=1) {
|
||||
for (var i=0;i<x;i+=1) {
|
||||
vec[i]=[];
|
||||
setsize(vec[i],y);
|
||||
for(var j=0;j<y;j+=1)
|
||||
for (var j=0;j<y;j+=1)
|
||||
vec[i][j]=0;
|
||||
}
|
||||
|
||||
@@ -45,9 +45,9 @@ var game = func(x,y) {
|
||||
print:func() {
|
||||
var s="";
|
||||
var (fx,fy)=snake.front();
|
||||
for(var i=0;i<y;i+=1) {
|
||||
for (var i=0;i<y;i+=1) {
|
||||
s~="║";
|
||||
for(var j=0;j<x;j+=1) {
|
||||
for (var j=0;j<x;j+=1) {
|
||||
if (fx==j and fy==i)
|
||||
s~="\e[93m"~texture[vec[j][i]]~"\e[0m";
|
||||
else
|
||||
@@ -114,7 +114,7 @@ var game = func(x,y) {
|
||||
var co=coroutine.create(func() {
|
||||
while(1) {
|
||||
var moved=-1;
|
||||
for(var i=0;i<30;i+=1) {
|
||||
for (var i=0;i<30;i+=1) {
|
||||
var ch=libkey.nonblock();
|
||||
if (moved==-1 and ch!=nil) {
|
||||
moved=ch;
|
||||
|
||||
@@ -62,7 +62,7 @@ var color_count=0;
|
||||
var counter=0;
|
||||
var package=[0,1,2,3,4,5,6];
|
||||
var exchange = func() {
|
||||
for(var i=6;i>=0;i-=1) {
|
||||
for (var i=6;i>=0;i-=1) {
|
||||
var index=int(i*rand());
|
||||
(package[i],package[index])=(package[index],package[i]);
|
||||
}
|
||||
@@ -105,16 +105,16 @@ var mapgen = func(mapx,mapy) {
|
||||
|
||||
# use in print
|
||||
var line="";
|
||||
for(var i=0;i<mapx;i+=1)
|
||||
for (var i=0;i<mapx;i+=1)
|
||||
line~="══";
|
||||
var head="\e[32m╔"~line~"╗\e[0m\n";
|
||||
var tail="\e[32m╚"~line~"╝\e[0m\n";
|
||||
|
||||
# generate new map
|
||||
var map=[];
|
||||
for(var y=0;y<mapy;y+=1) {
|
||||
for (var y=0;y<mapy;y+=1) {
|
||||
var tmp=[];
|
||||
for(var x=0;x<mapx;x+=1)
|
||||
for (var x=0;x<mapx;x+=1)
|
||||
append(tmp,empty);
|
||||
append(map,tmp);
|
||||
}
|
||||
@@ -138,9 +138,9 @@ var mapgen = func(mapx,mapy) {
|
||||
# color print
|
||||
var map_print = func() {
|
||||
var s="\e[1;1H"~head;
|
||||
for(var y=0;y<mapy;y+=1) {
|
||||
for (var y=0;y<mapy;y+=1) {
|
||||
s~="\e[32m║\e[0m";
|
||||
for(var x=0;x<mapx;x+=1) {
|
||||
for (var x=0;x<mapx;x+=1) {
|
||||
var c=map[y][x];
|
||||
if (c==empty)
|
||||
s~=" ";
|
||||
@@ -239,10 +239,10 @@ var mapgen = func(mapx,mapy) {
|
||||
|
||||
var checkmap = func() {
|
||||
var lines=1;
|
||||
for(var y=mapy-1;y>=0;y-=1) {
|
||||
for (var y=mapy-1;y>=0;y-=1) {
|
||||
# check if this line is full of blocks
|
||||
var tmp=0;
|
||||
for(var x=0;x<mapx;x+=1) {
|
||||
for (var x=0;x<mapx;x+=1) {
|
||||
if (map[y][x]<full)
|
||||
break;
|
||||
tmp+=map[y][x];
|
||||
@@ -252,10 +252,10 @@ var mapgen = func(mapx,mapy) {
|
||||
if (x==mapx) {
|
||||
score+=lines*tmp;
|
||||
lines*=2;
|
||||
for(var t=y;t>=1;t-=1)
|
||||
for(var x=0;x<mapx;x+=1)
|
||||
for (var t=y;t>=1;t-=1)
|
||||
for (var x=0;x<mapx;x+=1)
|
||||
map[t][x]=map[t-1][x];
|
||||
for(var x=0;x<mapx;x+=1)
|
||||
for (var x=0;x<mapx;x+=1)
|
||||
map[0][x]=empty;
|
||||
y+=1;
|
||||
}
|
||||
|
||||
@@ -24,11 +24,11 @@ var class2={
|
||||
};
|
||||
|
||||
var class_obj=[];
|
||||
for(var i=0;i<10;i+=1) {
|
||||
for (var i=0;i<10;i+=1) {
|
||||
append(class_obj,class.new());
|
||||
class_obj[i].set(i);
|
||||
}
|
||||
for(var i=0;i<10;i+=1) {
|
||||
for (var i=0;i<10;i+=1) {
|
||||
append(class_obj,class2.new());
|
||||
class_obj[10+i].set(i);
|
||||
}
|
||||
|
||||
@@ -37,7 +37,7 @@ screen_state.put_pixel = func(x, y, c) {
|
||||
|
||||
var test_flush = func() {
|
||||
screen_state.clear_screen();
|
||||
for(var i=0; i<1e6; i+=1) {
|
||||
for (var i=0; i<1e6; i+=1) {
|
||||
unix.sleep(0.001);
|
||||
screen_state.update();
|
||||
screen_state.put_pixel(
|
||||
|
||||
@@ -48,8 +48,8 @@ var prt = func(state,pointer,paper,act=nil) {
|
||||
foreach(var i;paper)
|
||||
s~=i;
|
||||
s~='\n\t';
|
||||
for(var i=0;i<pointer;i+=1)
|
||||
for(var j=0;j<size(paper[i]);j+=1)
|
||||
for (var i=0;i<pointer;i+=1)
|
||||
for (var j=0;j<size(paper[i]);j+=1)
|
||||
s~=' ';
|
||||
print(s,'^\n',state," ");
|
||||
}
|
||||
|
||||
@@ -55,7 +55,7 @@ var emoji测试 = func() {
|
||||
var dotsgen = func() {
|
||||
var dots=[];
|
||||
var s="⠀";
|
||||
for(var i=0;i<256;i+=1) {
|
||||
for (var i=0;i<256;i+=1) {
|
||||
var v0=s[0];
|
||||
var v1=s[1]+int(i/64);
|
||||
var v2=s[2]+i;
|
||||
|
||||
@@ -76,7 +76,7 @@ var choice = func(above_block_char,
|
||||
|
||||
func() {
|
||||
if (vecindex(possible, " ")!=nil) {
|
||||
for(var i = 0; i < 64; i+= 1) {
|
||||
for (var i = 0; i < 64; i+= 1) {
|
||||
append(possible, " ");
|
||||
}
|
||||
}
|
||||
@@ -94,14 +94,14 @@ var print_whole_line = func(this_line) {
|
||||
|
||||
srand();
|
||||
var last_line = [];
|
||||
for(var i = 0; i<100; i+=1) {
|
||||
for (var i = 0; i<100; i+=1) {
|
||||
append(last_line, " ");
|
||||
}
|
||||
|
||||
for(var iteration_times = 0; iteration_times < 25; iteration_times += 1) {
|
||||
for (var iteration_times = 0; iteration_times < 25; iteration_times += 1) {
|
||||
var this_line = [];
|
||||
var left_block = " ";
|
||||
for(var i = 0; i < 100; i += 1) {
|
||||
for (var i = 0; i < 100; i += 1) {
|
||||
var this_block = choice(
|
||||
last_line[i],
|
||||
left_block,
|
||||
|
||||
@@ -38,7 +38,7 @@ var map = func() {
|
||||
append(tmp,elem);
|
||||
vec[1][0]=tmp[rand()*size(tmp)];
|
||||
|
||||
for(var j=1;j<x;j+=1) {
|
||||
for (var j=1;j<x;j+=1) {
|
||||
if (vec[0][j][3]==0 and vec[1][j-1][4]==0 and rand()>0.5) {
|
||||
vec[1][j]=table[-1];
|
||||
continue;
|
||||
@@ -57,9 +57,9 @@ var map = func() {
|
||||
new:func(_x=10) {
|
||||
x=_x;
|
||||
vec=[[],[]];
|
||||
for(var i=0;i<2;i+=1) {
|
||||
for (var i=0;i<2;i+=1) {
|
||||
setsize(vec[i],x);
|
||||
for(var j=0;j<x;j+=1)
|
||||
for (var j=0;j<x;j+=1)
|
||||
vec[i][j]=table[-1];
|
||||
}
|
||||
|
||||
@@ -69,7 +69,7 @@ var map = func() {
|
||||
append(tmp,elem);
|
||||
vec[0][0]=tmp[rand()*size(tmp)];
|
||||
|
||||
for(var i=1;i<x;i+=1) {
|
||||
for (var i=1;i<x;i+=1) {
|
||||
tmp=[];
|
||||
foreach(var elem;table)
|
||||
if (elem[2]==vec[0][i-1][4] and elem[1]==0) {
|
||||
@@ -99,7 +99,7 @@ var map = func() {
|
||||
runtime.windows.set_utf8_output();
|
||||
map.new(90);
|
||||
|
||||
for(var iter=0;iter<40;iter+=1) {
|
||||
for (var iter=0;iter<40;iter+=1) {
|
||||
map.print(1);
|
||||
map.next();
|
||||
}
|
||||
@@ -3,7 +3,7 @@ use std.io;
|
||||
|
||||
var to_lower = func(s) {
|
||||
var tmp="";
|
||||
for(var i=0;i<size(s);i+=1) {
|
||||
for (var i=0;i<size(s);i+=1) {
|
||||
var c=s[i];
|
||||
if ('a'[0]<=c and c<='z'[0])
|
||||
tmp~=chr(c);
|
||||
@@ -19,7 +19,7 @@ var spliter = func(content) {
|
||||
var token={};
|
||||
var len=size(content);
|
||||
var s="";
|
||||
for(var i=0;i<len;i+=1) {
|
||||
for (var i=0;i<len;i+=1) {
|
||||
var n=content[i];
|
||||
var c=chr(n);
|
||||
if (('a'[0]<=n and n<='z'[0]) or ('A'[0]<=n and n<='Z'[0])) {
|
||||
|
||||
@@ -4,13 +4,13 @@ var fib = func(f) {
|
||||
}(
|
||||
func(f) {
|
||||
return func(x) {
|
||||
if (x<2) return x;
|
||||
if (x < 2) return x;
|
||||
var tmp = f(f);
|
||||
return tmp(x-1)+tmp(x-2);
|
||||
return tmp(x - 1) + tmp(x - 2);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
for(var i = 1; i<31; i += 1) {
|
||||
for (var i = 1; i < 31; i += 1) {
|
||||
println(fib(i));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user