Add option to specify gpg recipients - leo - Leo is a simple backup program

diff options

author	Andinus <andinus@nand.sh>	2020-10-15 18:23:26 +0530
committer	Andinus <andinus@nand.sh>	2020-10-15 18:23:26 +0530
commit	5924071b7c85e90f37b61ddfb755483686de76a1 (patch)
tree	3d71e759b89f4464dd184b6998b5f6a0db4d8248 /cpanfile
parent	561874a1000dfb4ab60fa4e679c50e869896b976 (diff)
download	leo-5924071b7c85e90f37b61ddfb755483686de76a1.tar.gz

Add option to specify gpg recipients

Diffstat (limited to 'cpanfile')

0 files changed, 0 insertions, 0 deletions

//: Phase 3: Start running a loaded and transformed recipe. //: //: The process of running Mu code: //: load -> transform -> run //: //: So far we've seen recipes as lists of instructions, and instructions point //: at other recipes. To kick things off Mu needs to know how to run certain //: 'primitive' recipes. That will then give the ability to run recipes //: containing these primitives. //: //: This layer defines a skeleton with just two primitive recipes: IDLE which //: does nothing, and COPY, which can copy numbers from one memory location to //: another. Later layers will add more primitives. void test_copy_literal() { run( "def main [\n" " 1:num <- copy 23\n" "]\n" ); CHECK_TRACE_CONTENTS( "run: {1: \"number\"} <- copy {23: \"literal\"}\n" "mem: storing 23 in location 1\n" ); } void test_copy() { run( "def main [\n" " 1:num <- copy 23\n" " 2:num <- copy 1:num\n" "]\n" ); CHECK_TRACE_CONTENTS( "run: {2: \"number\"} <- copy {1: \"number\"}\n" "mem: location 1 is 23\n" "mem: storing 23 in location 2\n" ); } void test_copy_multiple() { run( "def main [\n" " 1:num, 2:num <- copy 23, 24\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 23 in location 1\n" "mem: storing 24 in location 2\n" ); } :(before "End Types") // Book-keeping while running a recipe. //: Later layers will replace this to support running multiple routines at once. struct routine { recipe_ordinal running_recipe; int running_step_index; routine(recipe_ordinal r) :running_recipe(r), running_step_index(0) {} bool completed() const; const vector<instruction>& steps() const; }; :(before "End Globals") routine* Current_routine = NULL; :(before "End Reset") Current_routine = NULL; :(code) void run(const recipe_ordinal r) { routine rr(r); Current_routine = &rr; run_current_routine(); Current_routine = NULL; } void run_current_routine() { while (should_continue_running(Current_routine)) { // beware: may modify Current_routine // Running One Instruction if (current_instruction().is_label) { ++current_step_index(); continue; } trace(Callstack_depth, "run") << to_string(current_instruction()) << end(); //? if (Foo) cerr << "run: " << to_string(current_instruction()) << '\n'; if (get_or_insert(Memory, 0) != 0) { raise << "something wrote to location 0; this should never happen\n" << end(); put(Memory, 0, 0); } // read all ingredients from memory, each potentially spanning multiple locations vector<vector<double> > ingredients; if (should_copy_ingredients()) { for (int i = 0; i < SIZE(current_instruction().ingredients); ++i) ingredients.push_back(read_memory(current_instruction().ingredients.at(i))); } // instructions below will write to 'products' vector<vector<double> > products; //: This will be a large switch that later layers will often insert cases //: into. Never call 'continue' within it. Instead, we'll explicitly //: control which of the following stages after the switch we run for each //: instruction. bool write_products = true; bool fall_through_to_next_instruction = true; switch (current_instruction().operation) { // Primitive Recipe Implementations case COPY: { copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin())); break; } // End Primitive Recipe Implementations default: { raise << "not a primitive op: " << current_instruction().operation << '\n' << end(); } } //: used by a later layer if (write_products) { if (SIZE(products) < SIZE(current_instruction().products)) { raise << SIZE(products) << " vs " << SIZE(current_instruction().products) << ": failed to write to all products in '" << to_original_string(current_instruction()) << "'\n" << end(); } else { for (int i = 0; i < SIZE(current_instruction().products); ++i) { // Writing Instruction Product(i) write_memory(current_instruction().products.at(i), products.at(i)); } } } // End Running One Instruction if (fall_through_to_next_instruction) ++current_step_index(); } stop_running_current_routine:; } //: Helpers for managing trace depths //: //: We're going to use trace depths primarily to segment code running at //: different frames of the call stack. This will make it easy for the trace //: browser to collapse over entire calls. //: //: The entire map of possible depths is as follows: //: //: Errors will be depth 0. //: Mu 'applications' will be able to use depths 1-99 as they like. //: Primitive statements will occupy 100 and up to Max_depth, organized by //: stack frames. :(before "End Globals") extern const int Initial_callstack_depth = 100; int Callstack_depth = Initial_callstack_depth; :(before "End Reset") Callstack_depth = Initial_callstack_depth; //: Other helpers for the VM. :(code) //: hook replaced in a later layer bool should_continue_running(const routine* current_routine) { assert(current_routine == Current_routine); // argument passed in just to make caller readable above return !Current_routine->completed(); } bool should_copy_ingredients() { // End should_copy_ingredients Special-cases return true; } bool is_mu_scalar(reagent/*copy*/ r) { return is_mu_scalar(r.type); } bool is_mu_scalar(const type_tree* type) { if (!type) return false; if (is_mu_address(type)) return false; if (!type->atom) return false; if (is_literal(type)) return type->name != "literal-string"; return size_of(type) == 1; } bool is_mu_address(reagent/*copy*/ r) { // End Preprocess is_mu_address(reagent r) return is_mu_address(r.type); } bool is_mu_address(const type_tree* type) { if (!type) return false; if (is_literal(type)) return false; if (type->atom) return false; if (!type->left->atom) { raise << "invalid type " << to_string(type) << '\n' << end(); return false; } return type->left->value == Address_type_ordinal; } //: Some helpers. //: Important that they return references into the current routine. //: hook replaced in a later layer int& current_step_index() { return Current_routine->running_step_index; } //: hook replaced in a later layer recipe_ordinal currently_running_recipe() { return Current_routine->running_recipe; } //: hook replaced in a later layer const string& current_recipe_name() { return get(Recipe, Current_routine->running_recipe).name; } //: hook replaced in a later layer const recipe& current_recipe() { return get(Recipe, Current_routine->running_recipe); } //: hook replaced in a later layer const instruction& current_instruction() { return get(Recipe, Current_routine->running_recipe).steps.at(Current_routine->running_step_index); } //: hook replaced in a later layer bool routine::completed() const { return running_step_index >= SIZE(get(Recipe, running_recipe).steps); } //: hook replaced in a later layer const vector<instruction>& routine::steps() const { return get(Recipe, running_recipe).steps; } //:: Startup flow :(before "End Mu Prelude") load_file_or_directory("core.mu"); //? DUMP(""); //? exit(0); //: Step 2: load any .mu files provided at the commandline :(before "End Commandline Parsing") // Check For .mu Files if (argc > 1) { // skip argv[0] ++argv; --argc; while (argc > 0) { // ignore argv past '--'; that's commandline args for 'main' if (string(*argv) == "--") break; if (starts_with(*argv, "--")) cerr << "treating " << *argv << " as a file rather than an option\n"; load_file_or_directory(*argv); --argc; ++argv; } if (Run_tests) Recipe.erase(get(Recipe_ordinal, "main")); } transform_all(); //? cerr << to_original_string(get(Type_ordinal, "editor")) << '\n'; //? cerr << to_original_string(get(Recipe, get(Recipe_ordinal, "event-loop"))) << '\n'; //? DUMP(""); //? exit(0); if (trace_contains_errors()) return 1; if (Trace_stream && Run_tests) { // We'll want a trace per test. Clear the trace. delete Trace_stream; Trace_stream = NULL; } save_snapshots(); //: Step 3: if we aren't running tests, locate a recipe called 'main' and //: start running it. :(before "End Main") if (!Run_tests && contains_key(Recipe_ordinal, "main") && contains_key(Recipe, get(Recipe_ordinal, "main"))) { // Running Main reset(); trace(2, "run") << "=== Starting to run" << end(); assert(Num_calls_to_transform_all == 1); run_main(argc, argv); } :(code) void run_main(int argc, char* argv[]) { recipe_ordinal r = get(Recipe_ordinal, "main"); if (r) run(r); } void load_file_or_directory(string filename) { if (is_directory(filename)) { load_all(filename); return; } ifstream fin(filename.c_str()); if (!fin) { cerr << "no such file '" << filename << "'\n" << end(); // don't raise, just warn. just in case it's just a name for a test to run. return; } trace(2, "load") << "=== " << filename << end(); load(fin); fin.close(); } bool is_directory(string path) { struct stat info; if (stat(path.c_str(), &info)) return false; // error return info.st_mode & S_IFDIR; } void load_all(string dir) { dirent** files; int num_files = scandir(dir.c_str(), &files, NULL, alphasort); for (int i = 0; i < num_files; ++i) { string curr_file = files[i]->d_name; if (isdigit(curr_file.at(0)) && ends_with(curr_file, ".mu")) load_file_or_directory(dir+'/'+curr_file); free(files[i]); files[i] = NULL; } free(files); } bool ends_with(const string& s, const string& pat) { for (string::const_reverse_iterator p = s.rbegin(), q = pat.rbegin(); q != pat.rend(); ++p, ++q) { if (p == s.rend()) return false; // pat too long if (*p != *q) return false; } return true; } :(before "End Includes") #include <dirent.h> #include <sys/stat.h> //:: Reading from memory, writing to memory. :(code) vector<double> read_memory(reagent/*copy*/ x) { // Begin Preprocess read_memory(x) vector<double> result; if (x.name == "null") result.push_back(/*alloc id*/0); if (is_literal(x)) { result.push_back(x.value); return result; } // End Preprocess read_memory(x) int size = size_of(x); for (int offset = 0; offset < size; ++offset) { double val = get_or_insert(Memory, x.value+offset); trace(Callstack_depth+1, "mem") << "location " << x.value+offset << " is " << no_scientific(val) << end(); result.push_back(val); } return result; } void write_memory(reagent/*copy*/ x, const vector<double>& data) { assert(Current_routine); // run-time only // Begin Preprocess write_memory(x, data) if (!x.type) { raise << "can't write to '" << to_string(x) << "'; no type\n" << end(); return; } if (is_dummy(x)) return; if (is_literal(x)) return; // End Preprocess write_memory(x, data) if (x.value == 0) { raise << "can't write to location 0 in '" << to_original_string(current_instruction()) << "'\n" << end(); return; } if (size_mismatch(x, data)) { raise << maybe(current_recipe_name()) << "size mismatch in storing to '" << x.original_string << "' (" << size_of(x) << " vs " << SIZE(data) << ") at '" << to_original_string(current_instruction()) << "'\n" << end(); return; } // End write_memory(x) Special-cases for (int offset = 0; offset < SIZE(data); ++offset) { assert(x.value+offset > 0); trace(Callstack_depth+1, "mem") << "storing " << no_scientific(data.at(offset)) << " in location " << x.value+offset << end(); //? if (Foo) cerr << "mem: storing " << no_scientific(data.at(offset)) << " in location " << x.value+offset << '\n'; put(Memory, x.value+offset, data.at(offset)); } } :(code) int size_of(const reagent& r) { if (!r.type) return 0; // End size_of(reagent r) Special-cases return size_of(r.type); } int size_of(const type_tree* type) { if (!type) return 0; if (type->atom) { if (type->value == -1) return 1; // error value, but we'll raise it elsewhere if (type->value == 0) return 1; // End size_of(type) Atom Special-cases } else { if (!type->left->atom) { raise << "invalid type " << to_string(type) << '\n' << end(); return 0; } if (type->left->value == Address_type_ordinal) return 2; // address and alloc id // End size_of(type) Non-atom Special-cases } // End size_of(type) Special-cases return 1; } bool size_mismatch(const reagent& x, const vector<double>& data) { if (!x.type) return true; // End size_mismatch(x) Special-cases //? if (size_of(x) != SIZE(data)) cerr << size_of(x) << " vs " << SIZE(data) << '\n'; return size_of(x) != SIZE(data); } bool is_literal(const reagent& r) { return is_literal(r.type); } bool is_literal(const type_tree* type) { if (!type) return false; if (!type->atom) return false; return type->value == 0; } bool scalar(const vector<int>& x) { return SIZE(x) == 1; } bool scalar(const vector<double>& x) { return SIZE(x) == 1; } // helper for tests void run(const string& form) { vector<recipe_ordinal> tmp = load(form); transform_all(); if (tmp.empty()) return; if (trace_contains_errors()) return; // if a test defines main, it probably wants to start there regardless of // definition order if (contains_key(Recipe, get(Recipe_ordinal, "main"))) run(get(Recipe_ordinal, "main")); else run(tmp.front()); } void test_run_label() { run( "def main [\n" " +foo\n" " 1:num <- copy 23\n" " 2:num <- copy 1:num\n" "]\n" ); CHECK_TRACE_CONTENTS( "run: {1: \"number\"} <- copy {23: \"literal\"}\n" "run: {2: \"number\"} <- copy {1: \"number\"}\n" ); CHECK_TRACE_DOESNT_CONTAIN("run: +foo"); } void test_run_dummy() { run( "def main [\n" " _ <- copy 0\n" "]\n" ); CHECK_TRACE_CONTENTS( "run: _ <- copy {0: \"literal\"}\n" ); } void test_run_null() { run( "def main [\n" " 1:&:num <- copy null\n" "]\n" ); } void test_write_to_0_disallowed() { Hide_errors = true; run( "def main [\n" " 0:num <- copy 34\n" "]\n" ); CHECK_TRACE_DOESNT_CONTAIN("mem: storing 34 in location 0"); } //: Mu is robust to various combinations of commas and spaces. You just have //: to put spaces around the '<-'. void test_comma_without_space() { run( "def main [\n" " 1:num, 2:num <- copy 2,2\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 2 in location 1\n" ); } void test_space_without_comma() { run( "def main [\n" " 1:num, 2:num <- copy 2 2\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 2 in location 1\n" ); } void test_comma_before_space() { run( "def main [\n" " 1:num, 2:num <- copy 2, 2\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 2 in location 1\n" ); } void test_comma_after_space() { run( "def main [\n" " 1:num, 2:num <- copy 2 ,2\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 2 in location 1\n" ); } //:: Counters for trying to understand where Mu programs are spending their //:: time. :(before "End Globals") bool Run_profiler = false; // We'll key profile information by recipe_ordinal rather than name because // it's more efficient, and because later layers will show more than just the // name of a recipe. // // One drawback: if you're clearing recipes your profile will be inaccurate. // So far that happens in tests, and in 'run-sandboxed' in a later layer. map<recipe_ordinal, int> Instructions_running; :(before "End Commandline Options(*arg)") else if (is_equal(*arg, "--profile")) { Run_profiler = true; } :(after "Running One Instruction") if (Run_profiler) Instructions_running[currently_running_recipe()]++; :(before "End One-time Setup") atexit(dump_profile); :(code) void dump_profile() { if (!Run_profiler) return; if (Run_tests) { cerr << "It's not a good idea to profile a run with tests, since tests can create conflicting recipes and mislead you. To try it anyway, comment out this check in the code.\n"; return; } ofstream fout; fout.open("profile.instructions"); if (fout) { for (map<recipe_ordinal, int>::iterator p = Instructions_running.begin(); p != Instructions_running.end(); ++p) { fout << std::setw(9) << p->second << ' ' << header_label(p->first) << '\n'; } } fout.close(); // End dump_profile } // overridden in a later layer string header_label(const recipe_ordinal r) { return get(Recipe, r).name; }


context:
space:
mode: