//: Arrays contain a variable number of elements of the same type. //: //: You can create arrays of containers, but containers can only contain //: elements of a fixed size, so you can't create containers containing arrays. //: Create containers containing addresses to arrays instead. :(scenario copy_array) # Arrays can be copied around with a single instruction just like integers, # no matter how large they are. recipe main [ 1:integer <- copy 3:literal 2:integer <- copy 14:literal 3:integer <- copy 15:literal 4:integer <- copy 16:literal 5:array:integer <- copy 1:array:integer ] +run: instruction main/4 +run: ingredient 0 is 1 +mem: location 1 is 3 +mem: location 2 is 14 +mem: location 3 is 15 +mem: location 4 is 16 +mem: storing 3 in location 5 +mem: storing 14 in location 6 +mem: storing 15 in location 7 +mem: storing 16 in location 8 :(scenario copy_array_indirect) recipe main [ 1:integer <- copy 3:literal 2:integer <- copy 14:literal 3:integer <- copy 15:literal 4:integer <- copy 16:literal 5:address:array:integer <- copy 1:literal 6:array:integer <- copy 5:address:array:integer/deref ] +run: instruction main/5 +run: ingredient 0 is 5 +mem: location 1 is 3 +mem: location 2 is 14 +mem: location 3 is 15 +mem: location 4 is 16 +mem: storing 3 in location 6 +mem: storing 14 in location 7 +mem: storing 15 in location 8 +mem: storing 16 in location 9 //: disable the size mismatch check since the destination array need not be initialized :(replace "if (size_of(x) != data.size())" following "void write_memory(reagent x, vector data)") if (x.types[0] != Type_number["array"] && size_of(x) != data.size()) :(after "size_t size_of(const reagent& r)") static const int ARRAY = Type_number["array"]; if (r.types[0] == ARRAY) { assert(r.types.size() > 1); // skip the 'array' type to get at the element type return 1 + Memory[r.value]*size_of(array_element(r.types)); } //:: To access elements of an array, use 'index' :(scenario "index") recipe main [ 1:integer <- copy 3:literal 2:integer <- copy 14:literal 3:integer <- copy 15:literal 4:integer <- copy 16:literal 5:integer <- index 1:array:integer, 0:literal ] +run: instruction main/4 +run: address to copy is 2 +run: its type is 1 +mem: location 2 is 14 +run: product 0 is 14 +mem: storing 14 in location 5 :(scenario "index_direct_offset") recipe main [ 1:integer <- copy 3:literal 2:integer <- copy 14:literal 3:integer <- copy 15:literal 4:integer <- copy 16:literal 5:integer <- copy 0:literal 6:integer <- index 1:array:integer, 5:integer ] +run: instruction main/5 +run: address to copy is 2 +run: its type is 1 +mem: location 2 is 14 +run: product 0 is 14 +mem: storing 14 in location 6 :(before "End Primitive Recipe Declarations") INDEX, :(before "End Primitive Recipe Numbers") Recipe_number["index"] = INDEX; :(before "End Primitive Recipe Implementations") case INDEX: { static const int ARRAY = Type_number["array"]; //? if (Trace_stream) Trace_stream->dump_layer = "run"; //? 1 trace("run") << "ingredient 0 is " << instructions[pc].ingredients[0].to_string(); reagent base = canonize(instructions[pc].ingredients[0]); //? trace("run") << "ingredient 0 after canonize: " << base.to_string(); //? 1 int base_address = base.value; assert(base.types[0] == ARRAY); trace("run") << "ingredient 1 is " << instructions[pc].ingredients[1].to_string(); reagent offset = canonize(instructions[pc].ingredients[1]); //? trace("run") << "ingredient 1 after canonize: " << offset.to_string(); //? 1 vector offset_val(read_memory(offset)); vector element_type = array_element(base.types); //? trace("run") << "offset: " << offset_val[0]; //? 1 //? trace("run") << "size of elements: " << size_of(element_type); //? 1 int src = base_address + 1 + offset_val[0]*size_of(element_type); trace("run") << "address to copy is " << src; trace("run") << "its type is " << element_type[0]; reagent tmp; tmp.set_value(src); copy(element_type.begin(), element_type.end(), inserter(tmp.types, tmp.types.begin())); //? trace("run") << "AAA: " << tmp.to_string() << '\n'; //? 3 vector result(read_memory(tmp)); trace("run") << "produ