void finish_for_loop(Term* forTerm)
{
Block* contents = nested_contents(forTerm);
// Need to finish here to prevent error
block_finish_changes(contents);
// Add a a primary output
Term* primaryOutput = apply(contents, FUNCS.output,
TermList(loop_get_primary_result(contents)));
primaryOutput->setBoolProp("accumulatingOutput", true);
respecialize_type(primaryOutput);
// pack_any_open_state_vars(contents);
for_loop_fix_state_input(contents);
check_to_add_state_output_placeholder(contents);
add_implicit_placeholders(forTerm);
repoint_terms_to_use_input_placeholders(contents);
check_to_insert_implicit_inputs(forTerm);
update_extra_outputs(forTerm);
block_finish_changes(contents);
}
void finish_while_loop(Block* block)
{
block_finish_changes(block);
// Add a a primary output
apply(block, FUNCS.output, TermList(NULL));
// Add looped_inputs
insert_looped_placeholders(block);
update_extra_outputs(block->owningTerm, block);
update_for_control_flow(block);
block_finish_changes(block);
}
void for_loop_remake_zero_block(Block* forContents)
{
Block* zero = for_loop_get_zero_block(forContents);
clear_block(zero);
// Clone inputs
for (int i=0;; i++) {
Term* placeholder = get_input_placeholder(forContents, i);
if (placeholder == NULL)
break;
Term* clone = append_input_placeholder(zero);
rename(clone, placeholder->nameSymbol);
}
Term* loopOutput = create_list(zero);
// Clone outputs
for (int i=0;; i++) {
Term* placeholder = get_output_placeholder(forContents, i);
if (placeholder == NULL)
break;
// Find the appropriate connection
Term* result = find_local_name(zero, placeholder->name.c_str());
if (i == 0)
result = loopOutput;
Term* clone = append_output_placeholder(zero, result);
rename(clone, placeholder->nameSymbol);
}
block_finish_changes(zero);
}
void finish_for_loop(Term* forTerm)
{
Block* block = nested_contents(forTerm);
// Need to finish here to prevent error
block_finish_changes(block);
Term* primaryResult = loop_get_primary_result(block);
Term* iterator = loop_find_iterator(block);
Term* nextCall = apply_dynamic_method(block, s_advance, TermList(iterator));
hide_from_source(nextCall);
// Add a a primary output
Term* primaryOutput = apply(block, FUNCS.output, TermList(primaryResult));
primaryOutput->setBoolProp(s_AccumulatingOutput, true); // TODO: can delete?
respecialize_type(primaryOutput);
insert_looped_placeholders(block);
update_extra_outputs(forTerm, block);
block_finish_changes(block);
}
int run_command_line(caWorld* world, caValue* args)
{
RawOutputPrefs rawOutputPrefs;
bool printRaw = false;
bool printState = false;
bool dontRunScript = false;
bool printTrace = false;
// Prepended options
while (true) {
if (list_length(args) == 0)
break;
if (string_eq(list_get(args, 0), "-break-on")) {
DEBUG_BREAK_ON_TERM = atoi(as_cstring(list_get(args, 1)));
list_remove_index(args, 0);
list_remove_index(args, 0);
std::cout << "breaking on creation of term: " << DEBUG_BREAK_ON_TERM << std::endl;
continue;
}
if (string_eq(list_get(args, 0), "-path")) {
// Add a module path
module_add_search_path(world, as_cstring(list_get(args, 1)));
list_remove_index(args, 0);
list_remove_index(args, 0);
continue;
}
if (string_eq(list_get(args, 0), "-p")) {
printRaw = true;
list_remove_index(args, 0);
continue;
}
if (string_eq(list_get(args, 0), "-pp")) {
printRaw = true;
rawOutputPrefs.showProperties = true;
list_remove_index(args, 0);
continue;
}
if (string_eq(list_get(args, 0), "-b") || string_eq(list_get(args, 0), "-pb")) {
printRaw = true;
rawOutputPrefs.showBytecode = true;
list_remove_index(args, 0);
continue;
}
if (string_eq(list_get(args, 0), "-n")) {
dontRunScript = true;
list_remove_index(args, 0);
continue;
}
if (string_eq(list_get(args, 0), "-print-state")) {
printState = true;
list_remove_index(args, 0);
continue;
}
if (string_eq(list_get(args, 0), "-t")) {
printTrace = true;
list_remove_index(args, 0);
continue;
}
if (string_eq(list_get(args, 0), "-load")) {
caValue* filename = list_get(args, 1);
Value moduleName;
module_get_default_name_from_filename(filename, &moduleName);
list_remove_index(args, 0);
list_remove_index(args, 0);
continue;
}
break;
}
// No arguments remaining
if (list_length(args) == 0) {
print_usage();
return 0;
}
Block* mainBlock = fetch_module(world, "main");
// Check to handle args[0] as a dash-command.
// Print help
if (string_eq(list_get(args, 0), "-help")) {
print_usage();
return 0;
}
// Eval mode
if (string_eq(list_get(args, 0), "-e")) {
list_remove_index(args, 0);
Value command;
set_string(&command, "");
bool firstArg = true;
while (!list_empty(args)) {
if (!firstArg)
string_append(&command, " ");
string_append(&command, list_get(args, 0));
list_remove_index(args, 0);
firstArg = false;
}
caValue* result = term_value(mainBlock->eval(as_cstring(&command)));
std::cout << to_string(result) << std::endl;
return 0;
}
// Start repl
if (string_eq(list_get(args, 0), "-repl")) {
run_repl_stdin(world);
return 0;
}
if (string_eq(list_get(args, 0), "-call")) {
Symbol loadResult = load_script(mainBlock, as_cstring(list_get(args, 1)));
if (loadResult == sym_Failure) {
std::cout << "Failed to load file: " << as_cstring(list_get(args, 1)) << std::endl;
return -1;
}
block_finish_changes(mainBlock);
caStack* stack = circa_alloc_stack(world);
// Push function
caBlock* func = circa_find_function_local(mainBlock, as_cstring(list_get(args, 2)));
circa_push_function(stack, func);
// Push inputs
for (int i=3, inputIndex = 0; i < circa_count(args); i++) {
caValue* val = circa_input(stack, inputIndex++);
circa_parse_string(as_cstring(list_get(args, i)), val);
}
circa_run(stack);
if (circa_has_error(stack)) {
circa_print_error_to_stdout(stack);
}
// Print outputs
for (int i=0;; i++) {
caValue* out = circa_output(stack, i);
if (out == NULL)
break;
std::cout << to_string(circa_output(stack, i)) << std::endl;
}
circa_dealloc_stack(stack);
}
// Start debugger repl
if (string_eq(list_get(args, 0), "-d"))
return run_debugger_repl(as_cstring(list_get(args, 1)));
// Generate cpp headers
if (string_eq(list_get(args, 0), "-gh")) {
load_script(mainBlock, as_cstring(list_get(args, 1)));
std::cout << generate_cpp_headers(mainBlock);
return 0;
}
// Run file checker
if (string_eq(list_get(args, 0), "-check"))
return run_file_checker(as_cstring(list_get(args, 1)));
// Export parsed information
if (string_eq(list_get(args, 0), "-export")) {
const char* filename = "";
const char* format = "";
if (list_length(args) >= 2)
format = as_cstring(list_get(args, 1));
if (list_length(args) >= 3)
filename = as_cstring(list_get(args, 2));
return run_exporting_parser(format, filename);
}
// Build tool
if (string_eq(list_get(args, 0), "-build")) {
return run_build_tool(args);
}
// C++ gen
if (string_eq(list_get(args, 0), "-cppgen")) {
Value remainingArgs;
list_slice(args, 1, -1, &remainingArgs);
run_generate_cpp(&remainingArgs);
return 0;
}
// Command reader (from stdin)
if (string_eq(list_get(args, 0), "-run-stdin")) {
run_commands_from_stdin();
return 0;
}
// Reproduce source text
if (string_eq(list_get(args, 0), "-source-repro")) {
load_script(mainBlock, as_cstring(list_get(args, 1)));
std::cout << get_block_source_text(mainBlock);
return 0;
}
// Rewrite source, this is useful for upgrading old source
if (string_eq(list_get(args, 0), "-rewrite-source")) {
load_script(mainBlock, as_cstring(list_get(args, 1)));
std::string contents = get_block_source_text(mainBlock);
write_text_file(as_cstring(list_get(args, 1)), contents.c_str());
return 0;
}
// Default behavior with no flags: run args[0] as a script filename.
// Add the script's folder to module search paths.
caValue* filename = list_get(args, 0);
Value directory;
get_directory_for_filename(filename, &directory);
module_add_search_path(world, as_cstring(&directory));
load_script(mainBlock, as_cstring(filename));
block_finish_changes(mainBlock);
refresh_bytecode(mainBlock);
if (printRaw)
print_block(mainBlock, &rawOutputPrefs, std::cout);
if (dontRunScript)
return 0;
Stack* stack = alloc_stack(world);
push_frame(stack, mainBlock);
run_interpreter(stack);
if (printState)
std::cout << to_string(&stack->state) << std::endl;
if (error_occurred(stack)) {
std::cout << "Error occurred:\n";
print_error_stack(stack, std::cout);
std::cout << std::endl;
std::cout << "Stack:\n";
dump(stack);
return 1;
}
return 0;
}
