//: 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& 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 > 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 > 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

# Copyright (C) 2009, 2010  Roman Zimbelmann <romanz@lavabit.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

if __name__ == '__main__': from __init__ import init; init()

from os.path import realpath, join, dirname

from ranger import fsobject
from ranger.fsobject.file import File
from ranger.fsobject.directory import Directory
from ranger.shared.settings import SettingsAware

SettingsAware._setup()

TESTDIR = realpath(join(dirname(__file__), 'testdir'))
TESTFILE = join(TESTDIR, 'testfile5234148')
NONEXISTANT_DIR = join(TESTDIR, 'nonexistant')

import unittest
class Test1(unittest.TestCase):
	def test_initial_condition(self):
		# Check for the expected initial condition
		dir = Directory(TESTDIR)

		self.assertEqual(dir.path, TESTDIR)
		self.assertFalse(dir.content_loaded)
		self.assertEqual(dir.filenames, None)