246 lines
9.0 KiB
C++
246 lines
9.0 KiB
C++
//: Clean syntax to manipulate and check the file system in scenarios.
|
|
//: Instruction 'assume-resources' implicitly creates a variable called
|
|
//: 'resources' that is accessible to later instructions in the scenario.
|
|
|
|
void test_simple_filesystem() {
|
|
run_mu_scenario(
|
|
"scenario simple-filesystem [\n"
|
|
" local-scope\n"
|
|
" assume-resources [\n"
|
|
// file 'a' containing two lines of data
|
|
" [a] <- [\n"
|
|
" |a bc|\n"
|
|
" |de f|\n"
|
|
" ]\n"
|
|
// directory 'b' containing two files, 'c' and 'd'
|
|
" [b/c] <- []\n"
|
|
" [b/d] <- [\n"
|
|
" |xyz|\n"
|
|
" ]\n"
|
|
" ]\n"
|
|
" data:&:@:resource <- get *resources, data:offset\n"
|
|
" file1:resource <- index *data, 0\n"
|
|
" file1-name:text <- get file1, name:offset\n"
|
|
" 10:@:char/raw <- copy *file1-name\n"
|
|
" file1-contents:text <- get file1, contents:offset\n"
|
|
" 100:@:char/raw <- copy *file1-contents\n"
|
|
" file2:resource <- index *data, 1\n"
|
|
" file2-name:text <- get file2, name:offset\n"
|
|
" 30:@:char/raw <- copy *file2-name\n"
|
|
" file2-contents:text <- get file2, contents:offset\n"
|
|
" 40:@:char/raw <- copy *file2-contents\n"
|
|
" file3:resource <- index *data, 2\n"
|
|
" file3-name:text <- get file3, name:offset\n"
|
|
" 50:@:char/raw <- copy *file3-name\n"
|
|
" file3-contents:text <- get file3, contents:offset\n"
|
|
" 60:@:char/raw <- copy *file3-contents\n"
|
|
" memory-should-contain [\n"
|
|
" 10:array:character <- [a]\n"
|
|
" 100:array:character <- [a bc\n"
|
|
"de f\n"
|
|
"]\n"
|
|
" 30:array:character <- [b/c]\n"
|
|
" 40:array:character <- []\n"
|
|
" 50:array:character <- [b/d]\n"
|
|
" 60:array:character <- [xyz\n"
|
|
"]\n"
|
|
" ]\n"
|
|
"]\n"
|
|
);
|
|
}
|
|
|
|
void test_escaping_file_contents() {
|
|
run_mu_scenario(
|
|
"scenario escaping-file-contents [\n"
|
|
" local-scope\n"
|
|
" assume-resources [\n"
|
|
// file 'a' containing a '|'
|
|
// need to escape '\\' once for each block
|
|
" [a] <- [\n"
|
|
" |x\\\\\\\\|yz|\n"
|
|
" ]\n"
|
|
" ]\n"
|
|
" data:&:@:resource <- get *resources, data:offset\n"
|
|
" file1:resource <- index *data, 0\n"
|
|
" file1-name:text <- get file1, name:offset\n"
|
|
" 10:@:char/raw <- copy *file1-name\n"
|
|
" file1-contents:text <- get file1, contents:offset\n"
|
|
" 20:@:char/raw <- copy *file1-contents\n"
|
|
" memory-should-contain [\n"
|
|
" 10:array:character <- [a]\n"
|
|
" 20:array:character <- [x|yz\n"
|
|
"]\n"
|
|
" ]\n"
|
|
"]\n"
|
|
);
|
|
}
|
|
|
|
:(before "End Globals")
|
|
extern const int RESOURCES = next_predefined_global_for_scenarios(/*size_of(address:resources)*/2);
|
|
//: give 'resources' a fixed location in scenarios
|
|
:(before "End Special Scenario Variable Names(r)")
|
|
Name[r]["resources"] = RESOURCES;
|
|
//: make 'resources' always a raw location in scenarios
|
|
:(before "End is_special_name Special-cases")
|
|
if (s == "resources") return true;
|
|
:(before "End Initialize Type Of Special Name In Scenario(r)")
|
|
if (r.name == "resources") r.type = new_type_tree("address:resources");
|
|
|
|
:(before "End initialize_transform_rewrite_literal_string_to_text()")
|
|
recipes_taking_literal_strings.insert("assume-resources");
|
|
|
|
//: screen-should-contain is a regular instruction
|
|
:(before "End Primitive Recipe Declarations")
|
|
ASSUME_RESOURCES,
|
|
:(before "End Primitive Recipe Numbers")
|
|
put(Recipe_ordinal, "assume-resources", ASSUME_RESOURCES);
|
|
:(before "End Primitive Recipe Checks")
|
|
case ASSUME_RESOURCES: {
|
|
break;
|
|
}
|
|
:(before "End Primitive Recipe Implementations")
|
|
case ASSUME_RESOURCES: {
|
|
assert(scalar(ingredients.at(0)));
|
|
assume_resources(current_instruction().ingredients.at(0).name, current_recipe_name());
|
|
break;
|
|
}
|
|
|
|
:(code)
|
|
void assume_resources(const string& data, const string& caller) {
|
|
map<string, string> contents;
|
|
parse_resources(data, contents, caller);
|
|
construct_resources_object(contents);
|
|
}
|
|
|
|
void parse_resources(const string& data, map<string, string>& out, const string& caller) {
|
|
istringstream in(data);
|
|
in >> std::noskipws;
|
|
while (true) {
|
|
if (!has_data(in)) break;
|
|
skip_whitespace_and_comments(in);
|
|
if (!has_data(in)) break;
|
|
string filename = next_word(in);
|
|
if (filename.empty()) {
|
|
assert(!has_data(in));
|
|
raise << "incomplete 'resources' block at end of file (0)\n" << end();
|
|
return;
|
|
}
|
|
if (*filename.begin() != '[') {
|
|
raise << caller << ": assume-resources: filename '" << filename << "' must begin with a '['\n" << end();
|
|
break;
|
|
}
|
|
if (*filename.rbegin() != ']') {
|
|
raise << caller << ": assume-resources: filename '" << filename << "' must end with a ']'\n" << end();
|
|
break;
|
|
}
|
|
filename.erase(0, 1);
|
|
filename.erase(SIZE(filename)-1);
|
|
if (!has_data(in)) {
|
|
raise << caller << ": assume-resources: no data for filename '" << filename << "'\n" << end();
|
|
break;
|
|
}
|
|
string arrow = next_word(in);
|
|
if (arrow.empty()) {
|
|
assert(!has_data(in));
|
|
raise << "incomplete 'resources' block at end of file (1)\n" << end();
|
|
return;
|
|
}
|
|
if (arrow != "<-") {
|
|
raise << caller << ": assume-resources: expected '<-' after filename '" << filename << "' but got '" << arrow << "'\n" << end();
|
|
break;
|
|
}
|
|
if (!has_data(in)) {
|
|
raise << caller << ": assume-resources: no data for filename '" << filename << "' after '<-'\n" << end();
|
|
break;
|
|
}
|
|
string contents = next_word(in);
|
|
if (contents.empty()) {
|
|
assert(!has_data(in));
|
|
raise << "incomplete 'resources' block at end of file (2)\n" << end();
|
|
return;
|
|
}
|
|
if (*contents.begin() != '[') {
|
|
raise << caller << ": assume-resources: file contents '" << contents << "' for filename '" << filename << "' must begin with a '['\n" << end();
|
|
break;
|
|
}
|
|
if (*contents.rbegin() != ']') {
|
|
raise << caller << ": assume-resources: file contents '" << contents << "' for filename '" << filename << "' must end with a ']'\n" << end();
|
|
break;
|
|
}
|
|
contents.erase(0, 1);
|
|
contents.erase(SIZE(contents)-1);
|
|
put(out, filename, munge_resources_contents(contents, filename, caller));
|
|
}
|
|
}
|
|
|
|
string munge_resources_contents(const string& data, const string& filename, const string& caller) {
|
|
if (data.empty()) return "";
|
|
istringstream in(data);
|
|
in >> std::noskipws;
|
|
skip_whitespace_and_comments(in);
|
|
ostringstream out;
|
|
while (true) {
|
|
if (!has_data(in)) break;
|
|
skip_whitespace(in);
|
|
if (!has_data(in)) break;
|
|
if (in.peek() != '|') {
|
|
raise << caller << ": assume-resources: file contents for filename '" << filename << "' must be delimited in '|'s\n" << end();
|
|
break;
|
|
}
|
|
in.get(); // skip leading '|'
|
|
string line;
|
|
getline(in, line);
|
|
for (int i = 0; i < SIZE(line); ++i) {
|
|
if (line.at(i) == '|') break;
|
|
if (line.at(i) == '\\') {
|
|
++i; // skip
|
|
if (i == SIZE(line)) {
|
|
raise << caller << ": assume-resources: file contents can't end a line with '\\'\n" << end();
|
|
break;
|
|
}
|
|
}
|
|
out << line.at(i);
|
|
}
|
|
// todo: some way to represent a file without a final newline
|
|
out << '\n';
|
|
}
|
|
return out.str();
|
|
}
|
|
|
|
void construct_resources_object(const map<string, string>& contents) {
|
|
int resources_data_address = allocate(SIZE(contents) * /*size of resource*/4 + /*array length*/1);
|
|
int curr = resources_data_address + /*skip alloc id*/1 + /*skip array length*/1;
|
|
for (map<string, string>::const_iterator p = contents.begin(); p != contents.end(); ++p) {
|
|
++curr; // skip alloc id of resource.name
|
|
put(Memory, curr, new_mu_text(p->first));
|
|
trace(Callstack_depth+1, "mem") << "storing file name " << get(Memory, curr) << " in location " << curr << end();
|
|
++curr;
|
|
++curr; // skip alloc id of resource.contents
|
|
put(Memory, curr, new_mu_text(p->second));
|
|
trace(Callstack_depth+1, "mem") << "storing file contents " << get(Memory, curr) << " in location " << curr << end();
|
|
++curr;
|
|
}
|
|
curr = resources_data_address + /*skip alloc id of resources.data*/1;
|
|
put(Memory, curr, SIZE(contents)); // array length
|
|
trace(Callstack_depth+1, "mem") << "storing resources size " << get(Memory, curr) << " in location " << curr << end();
|
|
// wrap the resources data in a 'resources' object
|
|
int resources_address = allocate(size_of_resources());
|
|
curr = resources_address+/*alloc id*/1+/*offset of 'data' element*/1+/*skip alloc id of 'data' element*/1;
|
|
put(Memory, curr, resources_data_address);
|
|
trace(Callstack_depth+1, "mem") << "storing resources data address " << resources_data_address << " in location " << curr << end();
|
|
// save in product
|
|
put(Memory, RESOURCES+/*skip alloc id*/1, resources_address);
|
|
trace(Callstack_depth+1, "mem") << "storing resources address " << resources_address << " in location " << RESOURCES << end();
|
|
}
|
|
|
|
int size_of_resources() {
|
|
// memoize result if already computed
|
|
static int result = 0;
|
|
if (result) return result;
|
|
assert(get(Type_ordinal, "resources"));
|
|
type_tree* type = new type_tree("resources");
|
|
result = size_of(type);
|
|
delete type;
|
|
return result;
|
|
}
|