Refactoring: Split out FileModule from Module, Added LocalScope renamed some confusing 'evaluate' methods to 'instantiate', added FileContext (not yet used)

31 files changed, 281 insertions, 208 deletions

diff --git a/src/MainWindow.h b/src/MainWindow.h
index 65deb15..7bb008a 100644
--- a/src/MainWindow.h
+++ b/src/MainWindow.h
@@ -30,7 +30,7 @@ public:
 	std::string autoReloadId;
 
 	ModuleContext root_ctx;
-	Module *root_module;      // Result of parsing
+	FileModule *root_module;      // Result of parsing
 	ModuleInstantiation root_inst;    // Top level instance
 	AbstractNode *absolute_root_node; // Result of tree evaluation
 	AbstractNode *root_node;          // Root if the root modifier (!) is used
diff --git a/src/ModuleCache.cc b/src/ModuleCache.cc
index 19a3f84..4944495 100644
--- a/src/ModuleCache.cc
+++ b/src/ModuleCache.cc
@@ -28,9 +28,9 @@ static bool is_modified(const std::string &filename, const time_t &mtime)
 	return (st.st_mtime > mtime);
 }
 
-Module *ModuleCache::evaluate(const std::string &filename)
+FileModule *ModuleCache::evaluate(const std::string &filename)
 {
-	Module *lib_mod = NULL;
+	FileModule *lib_mod = NULL;
 
   // Create cache ID
 	struct stat st;
@@ -48,7 +48,7 @@ Module *ModuleCache::evaluate(const std::string &filename)
 #endif
 		lib_mod = &(*this->entries[filename].module);
 
-		BOOST_FOREACH(const Module::IncludeContainer::value_type &item, lib_mod->includes) {
+		BOOST_FOREACH(const FileModule::IncludeContainer::value_type &item, lib_mod->includes) {
 			if (is_modified(item.first, item.second)) {
 				lib_mod = NULL;
 				break;
@@ -78,7 +78,7 @@ Module *ModuleCache::evaluate(const std::string &filename)
 
 		print_messages_push();
 
-		Module *oldmodule = NULL;
+		FileModule *oldmodule = NULL;
 		cache_entry e = { NULL, cache_id };
 		if (this->entries.find(filename) != this->entries.end()) {
 			oldmodule = this->entries[filename].module;
@@ -86,7 +86,7 @@ Module *ModuleCache::evaluate(const std::string &filename)
 		this->entries[filename] = e;
 		
 		std::string pathname = boosty::stringy(fs::path(filename).parent_path());
-		lib_mod = dynamic_cast<Module*>(parse(textbuf.str().c_str(), pathname.c_str(), false));
+		lib_mod = dynamic_cast<FileModule*>(parse(textbuf.str().c_str(), pathname.c_str(), false));
 		PRINTB_NOCACHE("  compiled module: %p", lib_mod);
 		
 		if (lib_mod) {
diff --git a/src/ModuleCache.h b/src/ModuleCache.h
index 1e6373d..b8ded38 100644
--- a/src/ModuleCache.h
+++ b/src/ModuleCache.h
@@ -1,11 +1,14 @@
 #include <string>
 #include <boost/unordered_map.hpp>
 
+/*!
+	Caches FileModules based on their filenames
+*/
 class ModuleCache
 {
 public:
 	static ModuleCache *instance() { if (!inst) inst = new ModuleCache; return inst; }
-	class Module *evaluate(const std::string &filename);
+	class FileModule *evaluate(const std::string &filename);
 	size_t size() { return this->entries.size(); }
 	void clear();
 
@@ -16,7 +19,7 @@ private:
 	static ModuleCache *inst;
 
 	struct cache_entry {
-		class Module *module;
+		class FileModule *module;
 		std::string cache_id;
 	};
 	boost::unordered_map<std::string, cache_entry> entries;
diff --git a/src/builtin.cc b/src/builtin.cc
index 37abde6..a8b60df 100644
--- a/src/builtin.cc
+++ b/src/builtin.cc
@@ -16,12 +16,12 @@ Builtins *Builtins::instance(bool erase)
 
 void Builtins::init(const char *name, class AbstractModule *module)
 {
-	Builtins::instance()->rootmodule.modules[name] = module;
+	Builtins::instance()->rootmodule.scope.modules[name] = module;
 }
 
 void Builtins::init(const char *name, class AbstractFunction *function)
 {
-	Builtins::instance()->rootmodule.functions[name] = function;
+	Builtins::instance()->rootmodule.scope.functions[name] = function;
 }
 
 extern void register_builtin_functions();
@@ -80,18 +80,18 @@ std::string Builtins::isDeprecated(const std::string &name)
 
 Builtins::Builtins()
 {
-	this->rootmodule.assignments.push_back(Assignment("$fn", new Expression(Value(0.0))));
-	this->rootmodule.assignments.push_back(Assignment("$fs", new Expression(Value(2.0))));
-	this->rootmodule.assignments.push_back(Assignment("$fa", new Expression(Value(12.0))));
-	this->rootmodule.assignments.push_back(Assignment("$t", new Expression(Value(0.0))));
+	this->rootmodule.scope.assignments.push_back(Assignment("$fn", new Expression(Value(0.0))));
+	this->rootmodule.scope.assignments.push_back(Assignment("$fs", new Expression(Value(2.0))));
+	this->rootmodule.scope.assignments.push_back(Assignment("$fa", new Expression(Value(12.0))));
+	this->rootmodule.scope.assignments.push_back(Assignment("$t", new Expression(Value(0.0))));
 
 	Value::VectorType zero3;
 	zero3.push_back(Value(0.0));
 	zero3.push_back(Value(0.0));
 	zero3.push_back(Value(0.0));
 	Value zero3val(zero3);
-	this->rootmodule.assignments.push_back(Assignment("$vpt", new Expression(zero3val)));
-	this->rootmodule.assignments.push_back(Assignment("$vpr", new Expression(zero3val)));
+	this->rootmodule.scope.assignments.push_back(Assignment("$vpt", new Expression(zero3val)));
+	this->rootmodule.scope.assignments.push_back(Assignment("$vpr", new Expression(zero3val)));
 }
 
 Builtins::~Builtins()
diff --git a/src/cgaladv.cc b/src/cgaladv.cc
index aad3a95..70590f7 100644
--- a/src/cgaladv.cc
+++ b/src/cgaladv.cc
@@ -39,10 +39,10 @@ class CgaladvModule : public AbstractModule
 public:
 	cgaladv_type_e type;
 	CgaladvModule(cgaladv_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
-AbstractNode *CgaladvModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *CgaladvModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	CgaladvNode *node = new CgaladvNode(inst, type);
 
@@ -110,8 +110,8 @@ AbstractNode *CgaladvModule::evaluate(const Context *ctx, const ModuleInstantiat
 	if (node->level <= 1)
 		node->level = 1;
 
-	std::vector<AbstractNode *> evaluatednodes = inst->evaluateChildren(evalctx);
-	node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+	std::vector<AbstractNode *> instantiatednodes = inst->instantiateChildren(evalctx);
+	node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 
 	return node;
 }
diff --git a/src/color.cc b/src/color.cc
index 6c3aaef..7fef030 100644
--- a/src/color.cc
+++ b/src/color.cc
@@ -40,14 +40,14 @@ class ColorModule : public AbstractModule
 {
 public:
 	ColorModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 
 private:
 	static boost::unordered_map<std::string, Color4f> colormap;
 };
 
 #include "colormap.h"
-AbstractNode *ColorModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *ColorModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	ColorNode *node = new ColorNode(inst);
 
@@ -87,8 +87,8 @@ AbstractNode *ColorModule::evaluate(const Context *ctx, const ModuleInstantiatio
 		node->color[3] = alpha.toDouble();
 	}
 
-	std::vector<AbstractNode *> evaluatednodes = inst->evaluateChildren(evalctx);
-	node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+	std::vector<AbstractNode *> instantiatednodes = inst->instantiateChildren(evalctx);
+	node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 
 	return node;
 }
diff --git a/src/context.cc b/src/context.cc
index ea48dad..a7273a4 100644
--- a/src/context.cc
+++ b/src/context.cc
@@ -124,9 +124,9 @@ Value Context::evaluate_function(const std::string &name, const EvalContext *eva
 	return Value();
 }
 
-AbstractNode *Context::evaluate_module(const ModuleInstantiation &inst, const EvalContext *evalctx) const
+AbstractNode *Context::instantiate_module(const ModuleInstantiation &inst, const EvalContext *evalctx) const
 {
-	if (this->parent) return this->parent->evaluate_module(inst, evalctx);
+	if (this->parent) return this->parent->instantiate_module(inst, evalctx);
 	PRINTB("WARNING: Ignoring unknown module '%s'.", inst.name());
 	return NULL;
 }
diff --git a/src/context.h b/src/context.h
index 51fc45c..5be1efd 100644
--- a/src/context.h
+++ b/src/context.h
@@ -14,7 +14,7 @@ public:
 	virtual ~Context();
 
 	virtual Value evaluate_function(const std::string &name, const class EvalContext *evalctx) const;
-	virtual class AbstractNode *evaluate_module(const class ModuleInstantiation &inst, const EvalContext *evalctx) const;
+	virtual class AbstractNode *instantiate_module(const class ModuleInstantiation &inst, const EvalContext *evalctx) const;
 
 	void setVariables(const AssignmentList &args,
 										const class EvalContext *evalctx = NULL);
diff --git a/src/control.cc b/src/control.cc
index d45ee02..7786e36 100644
--- a/src/control.cc
+++ b/src/control.cc
@@ -46,7 +46,7 @@ class ControlModule : public AbstractModule
 public:
 	control_type_e type;
 	ControlModule(control_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
 void for_eval(AbstractNode &node, const ModuleInstantiation &inst, size_t l, 
@@ -81,12 +81,12 @@ void for_eval(AbstractNode &node, const ModuleInstantiation &inst, size_t l,
 			for_eval(node, inst, l+1, &c, evalctx);
 		}
 	} else if (l > 0) {
-		std::vector<AbstractNode *> evaluatednodes = inst.evaluateChildren(ctx);
-		node.children.insert(node.children.end(), evaluatednodes.begin(), evaluatednodes.end());
+		std::vector<AbstractNode *> instantiatednodes = inst.instantiateChildren(ctx);
+		node.children.insert(node.children.end(), instantiatednodes.begin(), instantiatednodes.end());
 	}
 }
 
-AbstractNode *ControlModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *ControlModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	AbstractNode *node = NULL;
 
@@ -115,7 +115,7 @@ AbstractNode *ControlModule::evaluate(const Context *ctx, const ModuleInstantiat
 
 				if (filectx->evalctx) {
 					if (n < filectx->evalctx->numChildren()) {
-						node = filectx->evalctx->getChild(n)->evaluate_instance(filectx->evalctx);
+						node = filectx->evalctx->getChild(n)->evaluate(filectx->evalctx);
 					}
 					else {
 						// How to deal with negative objects in this case?
@@ -155,8 +155,8 @@ AbstractNode *ControlModule::evaluate(const Context *ctx, const ModuleInstantiat
 			if (!evalctx->getArgName(i).empty())
 				c.set_variable(evalctx->getArgName(i), evalctx->getArgValue(i));
 		}
-		std::vector<AbstractNode *> evaluatednodes = inst->evaluateChildren(&c);
-		node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+		std::vector<AbstractNode *> instantiatednodes = inst->instantiateChildren(&c);
+		node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 	}
 
 	if (type == FOR || type == INT_FOR)
@@ -168,12 +168,12 @@ AbstractNode *ControlModule::evaluate(const Context *ctx, const ModuleInstantiat
 	{
 		const IfElseModuleInstantiation *ifelse = dynamic_cast<const IfElseModuleInstantiation*>(inst);
 		if (evalctx->numArgs() > 0 && evalctx->getArgValue(0).toBool()) {
-			std::vector<AbstractNode *> evaluatednodes = ifelse->evaluateChildren(evalctx);
-			node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+			std::vector<AbstractNode *> instantiatednodes = ifelse->instantiateChildren(evalctx);
+			node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 		}
 		else {
-			std::vector<AbstractNode *> evaluatednodes = ifelse->evaluateElseChildren(evalctx);
-			node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+			std::vector<AbstractNode *> instantiatednodes = ifelse->instantiateElseChildren(evalctx);
+			node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 		}
 	}
 
diff --git a/src/csgops.cc b/src/csgops.cc
index 425b747..92b97e7 100644
--- a/src/csgops.cc
+++ b/src/csgops.cc
@@ -38,14 +38,14 @@ class CsgModule : public AbstractModule
 public:
 	csg_type_e type;
 	CsgModule(csg_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
-AbstractNode *CsgModule::evaluate(const Context*, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *CsgModule::instantiate(const Context*, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	CsgNode *node = new CsgNode(inst, type);
-	std::vector<AbstractNode *> evaluatednodes = inst->evaluateChildren(evalctx);
-	node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+	std::vector<AbstractNode *> instantiatednodes = inst->instantiateChildren(evalctx);
+	node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 	return node;
 }
 
diff --git a/src/evalcontext.cc b/src/evalcontext.cc
index 25b6716..57c206f 100644
--- a/src/evalcontext.cc
+++ b/src/evalcontext.cc
@@ -4,6 +4,7 @@
 #include "function.h"
 #include "printutils.h"
 #include "builtin.h"
+#include "localscope.h"
 
 #include <boost/foreach.hpp>
 
@@ -20,6 +21,16 @@ Value EvalContext::getArgValue(size_t i, const Context *ctx) const
 	return arg.second ? arg.second->evaluate(ctx ? ctx : this) : Value();
 }
 
+size_t EvalContext::numChildren() const
+{
+	return this->scope ? this->scope->children.size() : 0;
+}
+
+ModuleInstantiation *EvalContext::getChild(size_t i) const
+{
+	return this->scope ? this->scope->children[i] : NULL; 
+}
+
 #ifdef DEBUG
 void EvalContext::dump(const AbstractModule *mod, const ModuleInstantiation *inst)
 {
@@ -33,9 +44,9 @@ void EvalContext::dump(const AbstractModule *mod, const ModuleInstantiation *ins
 	for (int i=0;i<this->eval_arguments.size();i++) {
 		PRINTB("    %s = %s", this->eval_arguments[i].first % this->eval_arguments[i].second);
 	}
-	if (this->children && this->children->size() > 0) {
+	if (this->scope && this->scope->children.size() > 0) {
 		PRINT("    children:");
-		BOOST_FOREACH(const ModuleInstantiation *ch, *this->children) {
+		BOOST_FOREACH(const ModuleInstantiation *ch, this->scope->children) {
 			PRINTB("      %s", ch->name());
 		}
 	}
diff --git a/src/evalcontext.h b/src/evalcontext.h
index 26a4a68..34f339a 100644
--- a/src/evalcontext.h
+++ b/src/evalcontext.h
@@ -13,16 +13,16 @@ public:
 	typedef std::vector<class ModuleInstantiation *> InstanceList;
 
 	EvalContext(const Context *parent, 
-							const AssignmentList &args, const InstanceList *const children = NULL)
-		: Context(parent), eval_arguments(args), children(children) {}
+							const AssignmentList &args, const class LocalScope *const scope = NULL)
+		: Context(parent), eval_arguments(args), scope(scope) {}
 	virtual ~EvalContext() {}
 
 	size_t numArgs() const { return this->eval_arguments.size(); }
 	const std::string &getArgName(size_t i) const;
 	Value getArgValue(size_t i, const Context *ctx = NULL) const;
 
-	size_t numChildren() const { return this->children ? this->children->size() : 0; }
-	ModuleInstantiation *getChild(size_t i) const { return this->children ? (*this->children)[i] : NULL; }
+	size_t numChildren() const;
+	ModuleInstantiation *getChild(size_t i) const;
 
 #ifdef DEBUG
 	virtual void dump(const class AbstractModule *mod, const ModuleInstantiation *inst);
@@ -31,7 +31,7 @@ public:
 private:
 	const AssignmentList &eval_arguments;
 	std::vector<std::pair<std::string, Value> > eval_values;
-	const InstanceList *const children;
+	const LocalScope *const scope;
 };
 
 #endif
diff --git a/src/import.cc b/src/import.cc
index 927c9d8..da79322 100644
--- a/src/import.cc
+++ b/src/import.cc
@@ -60,10 +60,10 @@ class ImportModule : public AbstractModule
 public:
 	import_type_e type;
 	ImportModule(import_type_e type = TYPE_UNKNOWN) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
-AbstractNode *ImportModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *ImportModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	AssignmentList args;
 	args += Assignment("file", NULL), Assignment("layer", NULL), Assignment("convexity", NULL), Assignment("origin", NULL), Assignment("scale", NULL);
diff --git a/src/lexer.l b/src/lexer.l
index 6766abc..6dfe9bc 100644
--- a/src/lexer.l
+++ b/src/lexer.l
@@ -55,7 +55,7 @@ static void yyunput(int, char*) __attribute__((unused));
 #endif
 extern const char *parser_input_buffer;
 extern std::string parser_source_path;
-extern Module *currmodule;
+extern FileModule *rootmodule;
 
 #define YY_INPUT(buf,result,max_size) {   \
   if (yyin && yyin != stdin) {            \
@@ -248,7 +248,7 @@ void includefile()
   path_stack.push_back(finfo.parent_path());
 
   handle_dep(fullname);
-  currmodule->registerInclude(fullname);
+  rootmodule->registerInclude(fullname);
   yyin = fopen(fullname.c_str(), "r");
   if (!yyin) {
     PRINTB("WARNING: Can't open 'include' file '%s'.", filename);
diff --git a/src/linearextrude.cc b/src/linearextrude.cc
index a3337e8..c64a235 100644
--- a/src/linearextrude.cc
+++ b/src/linearextrude.cc
@@ -45,10 +45,10 @@ class LinearExtrudeModule : public AbstractModule
 {
 public:
 	LinearExtrudeModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
-AbstractNode *LinearExtrudeModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *LinearExtrudeModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	LinearExtrudeNode *node = new LinearExtrudeNode(inst);
 
@@ -116,8 +116,8 @@ AbstractNode *LinearExtrudeModule::evaluate(const Context *ctx, const ModuleInst
 	}
 
 	if (node->filename.empty()) {
-		std::vector<AbstractNode *> evaluatednodes = inst->evaluateChildren(evalctx);
-		node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+		std::vector<AbstractNode *> instantiatednodes = inst->instantiateChildren(evalctx);
+		node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 	}
 
 	return node;
diff --git a/src/localscope.h b/src/localscope.h
new file mode 100644
index 0000000..e631028
--- /dev/null
+++ b/src/localscope.h
@@ -0,0 +1,25 @@
+#ifndef LOCALSCOPE_H_
+#define LOCALSCOPE_H_
+
+#include "typedefs.h"
+#include <boost/unordered_map.hpp>
+
+class LocalScope
+{
+public:
+	LocalScope();
+	~LocalScope();
+
+	size_t numElements() const { return assignments.size() + children.size(); }
+	std::string dump(const std::string &indent) const;
+	std::vector<class AbstractNode*> instantiateChildren(const class Context *evalctx) const;
+
+	AssignmentList assignments;
+  ModuleInstantiationList children;
+	typedef boost::unordered_map<std::string, class AbstractFunction*> FunctionContainer;
+	FunctionContainer functions;
+	typedef boost::unordered_map<std::string, class AbstractModule*> AbstractModuleContainer;
+	AbstractModuleContainer	modules;
+};
+
+#endif
diff --git a/src/mainwin.cc b/src/mainwin.cc
index 2e69ec2..87ec744 100644
--- a/src/mainwin.cc
+++ b/src/mainwin.cc
@@ -644,7 +644,7 @@ bool MainWindow::compile(bool reload, bool procevents)
 		
 		AbstractNode::resetIndexCounter();
 		this->root_inst = ModuleInstantiation("group");
-		this->absolute_root_node = this->root_module->evaluate(&this->root_ctx, &this->root_inst, NULL);
+		this->absolute_root_node = this->root_module->instantiate(&this->root_ctx, &this->root_inst, NULL);
 		
 		if (this->absolute_root_node) {
 			// Do we have an explicit root node (! modifier)?
@@ -1022,7 +1022,7 @@ static bool is_modified(const std::string &filename, const time_t &mtime)
 bool MainWindow::includesChanged()
 {
 	if (this->root_module) {
-		BOOST_FOREACH(const Module::IncludeContainer::value_type &item, this->root_module->includes) {
+		BOOST_FOREACH(const FileModule::IncludeContainer::value_type &item, this->root_module->includes) {
 			if (is_modified(item.first, item.second)) return true;
 		}
 	}
diff --git a/src/modcontext.cc b/src/modcontext.cc
index 83ad7c2..df341f9 100644
--- a/src/modcontext.cc
+++ b/src/modcontext.cc
@@ -8,16 +8,9 @@
 #include <boost/foreach.hpp>
 
 ModuleContext::ModuleContext(const class Module *module, const Context *parent, const EvalContext *evalctx)
-	: Context(parent)
+	: Context(parent), functions_p(NULL), modules_p(NULL), usedlibs_p(NULL)
 {
-	if (module) {
-		setModule(*module, evalctx);
-	}
-	else {
-		this->functions_p = NULL;
-		this->modules_p = NULL;
-		this->usedlibs_p = NULL;
-	}
+	if (module) setModule(*module, evalctx);
 }
 
 ModuleContext::~ModuleContext()
@@ -29,15 +22,19 @@ void ModuleContext::setModule(const Module &module, const EvalContext *evalctx)
 	this->setVariables(module.definition_arguments, evalctx);
 	this->evalctx = evalctx;
 
+  // FIXME: Hack - split out file context into separate class?
+	const FileModule *fm = dynamic_cast<const FileModule*>(&module);
+	if (fm) {
+		this->usedlibs_p = &(fm->usedlibs);
+		if (!fm->modulePath().empty()) this->document_path = fm->modulePath();
+	}
+	
 	// FIXME: Don't access module members directly
-	this->functions_p = &module.functions;
-	this->modules_p = &module.modules;
-	this->usedlibs_p = &module.usedlibs;
-	BOOST_FOREACH(const Assignment &ass, module.assignments) {
+	this->functions_p = &module.scope.functions;
+	this->modules_p = &module.scope.modules;
+	BOOST_FOREACH(const Assignment &ass, module.scope.assignments) {
 		this->set_variable(ass.first, ass.second->evaluate(this));
 	}
-	
-	if (!module.modulePath().empty()) this->document_path = module.modulePath();
 }
 
 /*!
@@ -45,6 +42,8 @@ void ModuleContext::setModule(const Module &module, const EvalContext *evalctx)
 */
 void ModuleContext::registerBuiltin()
 {
+	// FIXME: built-ins only contains variables, setModule isn't really needed for this
+  // FIXME: Where to put set_variable from setModule?
 	this->setModule(Builtins::instance()->getRootModule());
 	this->set_constant("PI",Value(M_PI));
 }
@@ -75,22 +74,22 @@ Value ModuleContext::evaluate_function(const std::string &name, const EvalContex
 	}
 	
 	if (this->usedlibs_p) {
-		BOOST_FOREACH(const ModuleContainer::value_type &m, *this->usedlibs_p) {
-			if (m.second->functions.find(name) != m.second->functions.end()) {
+		BOOST_FOREACH(const FileModule::ModuleContainer::value_type &m, *this->usedlibs_p) {
+			if (m.second->scope.functions.find(name) != m.second->scope.functions.end()) {
 				ModuleContext ctx(m.second, this->parent);
 				// FIXME: Set document path
 #if 0 && DEBUG
 				PRINTB("New lib Context for %s func:", name);
 				ctx.dump(NULL, NULL);
 #endif
-				return m.second->functions[name]->evaluate(&ctx, evalctx);
+				return m.second->scope.functions[name]->evaluate(&ctx, evalctx);
 			}
 		}
 	}
 	return Context::evaluate_function(name, evalctx);
 }
 
-AbstractNode *ModuleContext::evaluate_module(const ModuleInstantiation &inst, const EvalContext *evalctx) const
+AbstractNode *ModuleContext::instantiate_module(const ModuleInstantiation &inst, const EvalContext *evalctx) const
 {
 	if (this->modules_p && this->modules_p->find(inst.name()) != this->modules_p->end()) {
 		AbstractModule *m = this->modules_p->find(inst.name())->second;
@@ -98,25 +97,25 @@ AbstractNode *ModuleContext::evaluate_module(const ModuleInstantiation &inst, co
 		if (!replacement.empty()) {
 			PRINTB("DEPRECATED: The %s() module will be removed in future releases. Use %s() instead.", inst.name() % replacement);
 		}
-		return m->evaluate(this, &inst, evalctx);
+		return m->instantiate(this, &inst, evalctx);
 	}
 
 	if (this->usedlibs_p) {
-		BOOST_FOREACH(const ModuleContainer::value_type &m, *this->usedlibs_p) {
+		BOOST_FOREACH(const FileModule::ModuleContainer::value_type &m, *this->usedlibs_p) {
 			assert(m.second);
-			if (m.second->modules.find(inst.name()) != m.second->modules.end()) {
+			if (m.second->scope.modules.find(inst.name()) != m.second->scope.modules.end()) {
 				ModuleContext ctx(m.second, this->parent);
 				// FIXME: Set document path
 #if 0 && DEBUG
 				PRINT("New lib Context:");
 				ctx.dump(NULL, &inst);
 #endif
-				return m.second->modules[inst.name()]->evaluate(&ctx, &inst, evalctx);
+				return m.second->scope.modules[inst.name()]->instantiate(&ctx, &inst, evalctx);
 			}
 		}
 	}
 
-	return Context::evaluate_module(inst, evalctx);
+	return Context::instantiate_module(inst, evalctx);
 }
 
 #ifdef DEBUG
@@ -150,3 +149,11 @@ void ModuleContext::dump(const AbstractModule *mod, const ModuleInstantiation *i
 
 }
 #endif
+
+FileContext::FileContext(const class FileModule &module, 
+												 const Context *parent, const EvalContext *evalctx)
+	:ModuleContext(&module, parent, evalctx)
+{
+	
+}
+
diff --git a/src/modcontext.h b/src/modcontext.h
index 5fce88f..d9965c5 100644
--- a/src/modcontext.h
+++ b/src/modcontext.h
@@ -2,13 +2,14 @@
 #define FILECONTEXT_H_
 
 #include "context.h"
+#include "module.h"
 #include <boost/unordered_map.hpp>
 
 /*!
 	This holds the context for a Module definition; keeps track of
 	global variables, submodules and functions defined inside a module.
 
-	NB! every .scad file defines an implicit unnamed module holding the contents of the file.
+	NB! every .scad file defines a FileModule holding the contents of the file.
 */
 class ModuleContext : public Context
 {
@@ -20,12 +21,11 @@ public:
 	void registerBuiltin();
 
 	virtual Value evaluate_function(const std::string &name, const EvalContext *evalctx) const;
-	virtual AbstractNode *evaluate_module(const ModuleInstantiation &inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate_module(const ModuleInstantiation &inst, const EvalContext *evalctx) const;
 
 	const boost::unordered_map<std::string, class AbstractFunction*> *functions_p;
 	const boost::unordered_map<std::string, class AbstractModule*> *modules_p;
-	typedef boost::unordered_map<std::string, class Module*> ModuleContainer;
-	const ModuleContainer *usedlibs_p;
+	const FileModule::ModuleContainer *usedlibs_p;
 
   // FIXME: Points to the eval context for the call to this module. Not sure where it belongs
 	const class EvalContext *evalctx;
@@ -37,4 +37,11 @@ public:
 	mutable boost::unordered_map<std::string, int> recursioncount;
 };
 
+class FileContext : public ModuleContext
+{
+public:
+	FileContext(const class FileModule &module, const Context *parent = NULL, const EvalContext *evalctx = NULL);
+	virtual ~FileContext() {}
+};
+
 #endif
diff --git a/src/module.cc b/src/module.cc
index 3b1ec0a..a9e3cbf 100644
--- a/src/module.cc
+++ b/src/module.cc
@@ -40,15 +40,59 @@ namespace fs = boost::filesystem;
 #include <sstream>
 #include <sys/stat.h>
 
+LocalScope::LocalScope()
+{
+}
+
+LocalScope::~LocalScope()
+{
+	BOOST_FOREACH(ModuleInstantiation *v, children) delete v;
+	BOOST_FOREACH (const Assignment &v, assignments) delete v.second;
+	BOOST_FOREACH (FunctionContainer::value_type &f, functions) delete f.second;
+	BOOST_FOREACH (AbstractModuleContainer::value_type &m, modules) delete m.second;
+}
+
+std::string LocalScope::dump(const std::string &indent) const
+{
+	std::stringstream dump;
+	BOOST_FOREACH(const FunctionContainer::value_type &f, this->functions) {
+		dump << f.second->dump(indent, f.first);
+	}
+	BOOST_FOREACH(const AbstractModuleContainer::value_type &m, this->modules) {
+		dump << m.second->dump(indent, m.first);
+	}
+	BOOST_FOREACH(const Assignment &ass, this->assignments) {
+		dump << indent << ass.first << " = " << *ass.second << ";\n";
+	}
+	BOOST_FOREACH(const ModuleInstantiation *inst, this->children) {
+		dump << inst->dump(indent);
+	}
+	return dump.str();
+}
+
+std::vector<AbstractNode*> LocalScope::instantiateChildren(const Context *evalctx) const
+{
+	Context c(evalctx); // FIXME: Is this correct, or should we use the parent?
+	BOOST_FOREACH (const Assignment &ass, this->assignments) {
+		c.set_variable(ass.first, ass.second->evaluate(&c));
+	}
+	std::vector<AbstractNode*> childnodes;
+	BOOST_FOREACH (ModuleInstantiation *modinst, this->children) {
+		AbstractNode *node = modinst->evaluate(&c);
+		if (node) childnodes.push_back(node);
+	}
+	return childnodes;
+}
+
 AbstractModule::~AbstractModule()
 {
 }
 
-AbstractNode *AbstractModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *AbstractModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	AbstractNode *node = new AbstractNode(inst);
 
-	node->children = inst->evaluateChildren(evalctx);
+	node->children = inst->instantiateChildren(evalctx);
 
 	return node;
 }
@@ -63,12 +107,10 @@ std::string AbstractModule::dump(const std::string &indent, const std::string &n
 ModuleInstantiation::~ModuleInstantiation()
 {
 	BOOST_FOREACH(const Assignment &arg, this->arguments) delete arg.second;
-	BOOST_FOREACH(ModuleInstantiation *v, children) delete v;
 }
 
 IfElseModuleInstantiation::~IfElseModuleInstantiation()
 {
-	BOOST_FOREACH (ModuleInstantiation *v, else_children) delete v;
 }
 
 /*!
@@ -95,76 +137,63 @@ std::string ModuleInstantiation::dump(const std::string &indent) const
 		if (!arg.first.empty()) dump << arg.first << " = ";
 		dump << *arg.second;
 	}
-	if (children.size() == 0) {
+	if (scope.numElements() == 0) {
 		dump << ");\n";
-	} else if (children.size() == 1) {
+	} else if (scope.numElements() == 1) {
 		dump << ")\n";
-		dump << children[0]->dump(indent + "\t");
+		dump << scope.dump(indent + "\t");
 	} else {
 		dump << ") {\n";
-		for (size_t i = 0; i < children.size(); i++) {
-			dump << children[i]->dump(indent + "\t");
-		}
+		scope.dump(indent + "\t");
 		dump << indent << "}\n";
 	}
 	return dump.str();
 }
 
-AbstractNode *ModuleInstantiation::evaluate_instance(const Context *ctx) const
+AbstractNode *ModuleInstantiation::evaluate(const Context *ctx) const
 {
-	EvalContext c(ctx, this->arguments, &this->children);
+	EvalContext c(ctx, this->arguments, &this->scope);
 
 #if 0 && DEBUG
 	PRINT("New eval ctx:");
 	c.dump(NULL, this);
 #endif
-	AbstractNode *node = ctx->evaluate_module(*this, &c); // Passes c as evalctx
+	AbstractNode *node = ctx->instantiate_module(*this, &c); // Passes c as evalctx
 	return node;
 }
 
-std::vector<AbstractNode*> ModuleInstantiation::evaluateChildren(const Context *evalctx) const
+std::vector<AbstractNode*> ModuleInstantiation::instantiateChildren(const Context *evalctx) const
 {
-	std::vector<AbstractNode*> childnodes;
-	BOOST_FOREACH (ModuleInstantiation *modinst, this->children) {
-		AbstractNode *node = modinst->evaluate_instance(evalctx);
-		if (node) childnodes.push_back(node);
-	}
-	return childnodes;
+	return this->scope.instantiateChildren(evalctx);
 }
 
-std::vector<AbstractNode*> IfElseModuleInstantiation::evaluateElseChildren(const Context *evalctx) const
+std::vector<AbstractNode*> IfElseModuleInstantiation::instantiateElseChildren(const Context *evalctx) const
 {
-	std::vector<AbstractNode*> childnodes;
-	BOOST_FOREACH (ModuleInstantiation *modinst, this->else_children) {
-		AbstractNode *node = modinst->evaluate_instance(evalctx);
-		if (node != NULL) childnodes.push_back(node);
-	}
-	return childnodes;
+	return this->else_scope.instantiateChildren(evalctx);
 }
 
 Module::~Module()
 {
-	BOOST_FOREACH (const Assignment &v, assignments) delete v.second;
-	BOOST_FOREACH (FunctionContainer::value_type &f, functions) delete f.second;
-	BOOST_FOREACH (AbstractModuleContainer::value_type &m, modules) delete m.second;
-	BOOST_FOREACH (ModuleInstantiation *v, children) delete v;
 }
 
-AbstractNode *Module::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+void Module::addChild(ModuleInstantiation *ch) 
+{
+	this->scope.children.push_back(ch); 
+}
+
+AbstractNode *Module::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	ModuleContext c(this, ctx, evalctx);
 	// FIXME: Set document path to the path of the module
-	c.set_variable("$children", Value(double(inst->children.size())));
+	c.set_variable("$children", Value(double(inst->scope.children.size())));
 #if 0 && DEBUG
 	c.dump(this, inst);
 #endif
 
+	// FIXME: this->scope.instantiateChildren(&c) and ModuleContext c() causes set_variable to be called twice, causing duplicate warning output in e.g. echotest_search-tests
 	AbstractNode *node = new AbstractNode(inst);
-	for (size_t i = 0; i < children.size(); i++) {
-		AbstractNode *n = children[i]->evaluate_instance(&c);
-		if (n != NULL)
-			node->children.push_back(n);
-	}
+	std::vector<AbstractNode *> instantiatednodes = this->scope.instantiateChildren(&c);
+	node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 
 	return node;
 }
@@ -184,25 +213,14 @@ std::string Module::dump(const std::string &indent, const std::string &name) con
 		dump << ") {\n";
 		tab = "\t";
 	}
-	BOOST_FOREACH(const FunctionContainer::value_type &f, functions) {
-		dump << f.second->dump(indent + tab, f.first);
-	}
-	BOOST_FOREACH(const AbstractModuleContainer::value_type &m, modules) {
-		dump << m.second->dump(indent + tab, m.first);
-	}
-	BOOST_FOREACH(const Assignment &ass, assignments) {
-		dump << indent << tab << ass.first << " = " << *ass.second << ";\n";
-	}
-	for (size_t i = 0; i < children.size(); i++) {
-		dump << children[i]->dump(indent + tab);
-	}
+	dump << scope.dump(indent + tab);
 	if (!name.empty()) {
 		dump << indent << "}\n";
 	}
 	return dump.str();
 }
 
-void Module::registerInclude(const std::string &filename)
+void FileModule::registerInclude(const std::string &filename)
 {
 	struct stat st;
 	memset(&st, 0, sizeof(struct stat));
@@ -214,17 +232,17 @@ void Module::registerInclude(const std::string &filename)
 	Check if any dependencies have been modified and recompile them.
 	Returns true if anything was recompiled.
 */
-bool Module::handleDependencies()
+bool FileModule::handleDependencies()
 {
 	if (this->is_handling_dependencies) return false;
 	this->is_handling_dependencies = true;
 
 	bool changed = false;
 	// Iterating manually since we want to modify the container while iterating
-	Module::ModuleContainer::iterator iter = this->usedlibs.begin();
+	FileModule::ModuleContainer::iterator iter = this->usedlibs.begin();
 	while (iter != this->usedlibs.end()) {
-		Module::ModuleContainer::iterator curr = iter++;
-		Module *oldmodule = curr->second;
+		FileModule::ModuleContainer::iterator curr = iter++;
+		FileModule *oldmodule = curr->second;
 		curr->second = ModuleCache::instance()->evaluate(curr->first);
 		if (curr->second != oldmodule) {
 			changed = true;
diff --git a/src/module.h b/src/module.h
index 94de25e..39d4bba 100644
--- a/src/module.h
+++ b/src/module.h
@@ -7,6 +7,7 @@
 #include <boost/unordered_map.hpp>
 #include "value.h"
 #include "typedefs.h"
+#include "localscope.h"
 
 class ModuleInstantiation
 {
@@ -16,8 +17,8 @@ public:
 	virtual ~ModuleInstantiation();
 
 	std::string dump(const std::string &indent) const;
-	class AbstractNode *evaluate_instance(const class Context *ctx) const;
-	std::vector<AbstractNode*> evaluateChildren(const Context *evalctx) const;
+	class AbstractNode *evaluate(const class Context *ctx) const;
+	std::vector<AbstractNode*> instantiateChildren(const Context *evalctx) const;
 
 	void setPath(const std::string &path) { this->modpath = path; }
 	const std::string &path() const { return this->modpath; }
@@ -29,7 +30,7 @@ public:
 	bool isRoot() const { return this->tag_root; }
 
 	AssignmentList arguments;
-	std::vector<ModuleInstantiation*> children;
+	LocalScope scope;
 
 	bool tag_root;
 	bool tag_highlight;
@@ -45,55 +46,53 @@ class IfElseModuleInstantiation : public ModuleInstantiation {
 public:
 	IfElseModuleInstantiation() : ModuleInstantiation("if") { }
 	virtual ~IfElseModuleInstantiation();
-	std::vector<AbstractNode*> evaluateElseChildren(const Context *evalctx) const;
+	std::vector<AbstractNode*> instantiateElseChildren(const Context *evalctx) const;
 
-	std::vector<ModuleInstantiation*> else_children;
+	LocalScope else_scope;
 };
 
 class AbstractModule
 {
 public:
 	virtual ~AbstractModule();
-	virtual class AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const class EvalContext *evalctx = NULL) const;
+	virtual class AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const class EvalContext *evalctx = NULL) const;
 	virtual std::string dump(const std::string &indent, const std::string &name) const;
 };
 
 class Module : public AbstractModule
 {
 public:
-	Module() : is_handling_dependencies(false) { }
+	Module() { }
 	virtual ~Module();
 
-	void setModulePath(const std::string &path) { this->path = path; }
-	const std::string &modulePath() const { return this->path; }
-
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 	virtual std::string dump(const std::string &indent, const std::string &name) const;
 
-	void addChild(ModuleInstantiation *ch) { this->children.push_back(ch); }
+	void addChild(ModuleInstantiation *ch);
 
-	typedef boost::unordered_map<std::string, class Module*> ModuleContainer;
-	ModuleContainer usedlibs;
-	void registerInclude(const std::string &filename);
-	typedef boost::unordered_map<std::string, time_t> IncludeContainer;
-	IncludeContainer includes;
-	bool is_handling_dependencies;
-	bool handleDependencies();
+	AssignmentList definition_arguments;
 
-	AssignmentList assignments;
-
-	typedef boost::unordered_map<std::string, class AbstractFunction*> FunctionContainer;
-	FunctionContainer functions;
-	typedef boost::unordered_map<std::string, AbstractModule*> AbstractModuleContainer;
-	AbstractModuleContainer	modules;
+	LocalScope scope;
+};
 
-	std::vector<ModuleInstantiation*> children;
+class FileModule : public Module
+{
+public:
+	FileModule() : is_handling_dependencies(false) {}
+	virtual ~FileModule() {}
 
-	std::vector<Assignment> definition_arguments;
+	void setModulePath(const std::string &path) { this->path = path; }
+	const std::string &modulePath() const { return this->path; }
+	void registerInclude(const std::string &filename);
+	bool handleDependencies();
 
-protected:
+	typedef boost::unordered_map<std::string, class FileModule*> ModuleContainer;
+	ModuleContainer usedlibs;
+	typedef boost::unordered_map<std::string, time_t> IncludeContainer;
+	IncludeContainer includes;
 
 private:
+	bool is_handling_dependencies;
 	std::string path;
 };
 
diff --git a/src/openscad.cc b/src/openscad.cc
index 3b960f3..96dcf4e 100644
--- a/src/openscad.cc
+++ b/src/openscad.cc
@@ -327,7 +327,7 @@ int main(int argc, char **argv)
 
 		if (!filename) help(argv[0]);
 
-		Module *root_module;
+		FileModule *root_module;
 		ModuleInstantiation root_inst("group");
 		AbstractNode *root_node;
 		AbstractNode *absolute_root_node;
@@ -359,7 +359,7 @@ int main(int argc, char **argv)
 		fs::current_path(fparent);
 
 		AbstractNode::resetIndexCounter();
-		absolute_root_node = root_module->evaluate(&root_ctx, &root_inst, NULL);
+		absolute_root_node = root_module->instantiate(&root_ctx, &root_inst, NULL);
 
 		// Do we have an explicit root node (! modifier)?
 		if (!(root_node = find_root_tag(absolute_root_node)))
diff --git a/src/openscad.h b/src/openscad.h
index 8d9a01e..dd379a9 100644
--- a/src/openscad.h
+++ b/src/openscad.h
@@ -27,7 +27,7 @@
 #ifndef OPENSCAD_H
 #define OPENSCAD_H
 
-extern class Module *parse(const char *text, const char *path, int debug);
+extern class FileModule *parse(const char *text, const char *path, int debug);
 extern int get_fragments_from_r(double r, double fn, double fs, double fa);
 
 #include <string>
diff --git a/src/parser.y b/src/parser.y
index 096bb89..0cd1fbd 100644
--- a/src/parser.y
+++ b/src/parser.y
@@ -58,6 +58,7 @@
 
   std::vector<Module*> module_stack;
   Module *currmodule;
+  FileModule *rootmodule;
 
   extern void lexerdestroy();
   extern FILE *lexerin;
@@ -130,7 +131,7 @@
 
 input: 
 /* empty */ |
-TOK_USE { currmodule->usedlibs[$1] = NULL; } input |
+TOK_USE { rootmodule->usedlibs[$1] = NULL; } input |
 statement input ;
 
 inner_input: 
@@ -148,21 +149,21 @@ module_instantiation {
   }
 } |
 TOK_ID '=' expr ';' {
-  for (AssignmentList::iterator iter = currmodule->assignments.begin(); 
-       iter != currmodule->assignments.end(); 
+  for (AssignmentList::iterator iter = currmodule->scope.assignments.begin(); 
+       iter != currmodule->scope.assignments.end(); 
        iter++) {
     if (iter->first == $1) {
-      currmodule->assignments.erase(iter);
+      currmodule->scope.assignments.erase(iter);
       break;
     }
   }
-  currmodule->assignments.push_back(Assignment($1, $3));
+  currmodule->scope.assignments.push_back(Assignment($1, $3));
 } |
 TOK_MODULE TOK_ID '(' arguments_decl optional_commas ')' {
   Module *p = currmodule;
   module_stack.push_back(currmodule);
   currmodule = new Module();
-  p->modules[$2] = currmodule;
+  p->scope.modules[$2] = currmodule;
   currmodule->definition_arguments = *$4;
   free($2);
   delete $4;
@@ -174,11 +175,11 @@ TOK_MODULE TOK_ID '(' arguments_decl optional_commas ')' {
     Function *func = new Function();
     func->definition_arguments = *$4;
     func->expr = $8;
-    currmodule->functions[$2] = func;
+    currmodule->scope.functions[$2] = func;
     free($2);
     delete $4;
   } ';' ;
-
+          
 /* Will return a dummy parent node with zero or more children */
 children_instantiation:
 module_instantiation {
@@ -196,9 +197,9 @@ TOK_IF '(' expr ')' children_instantiation {
   $$ = new IfElseModuleInstantiation();
   $$->arguments.push_back(Assignment("", $3));
   $$->setPath(parser_source_path);
-
+  
   if ($$) {
-    $$->children = *$5;
+    $$->scope.children = *$5;
   } else {
     for (size_t i = 0; i < $5->size(); i++)
       delete (*$5)[i];
@@ -213,7 +214,7 @@ if_statement {
 if_statement TOK_ELSE children_instantiation {
   $$ = $1;
   if ($$) {
-    $$->else_children = *$3;
+    $$->else_scope.children = *$3;
   } else {
     for (size_t i = 0; i < $3->size(); i++)
       delete (*$3)[i];
@@ -244,7 +245,7 @@ single_module_instantiation ';' {
 single_module_instantiation children_instantiation {
   $$ = $1;
   if ($$) {
-    $$->children = *$2;
+    $$->scope.children = *$2;
   } else {
     for (size_t i = 0; i < $2->size(); i++)
       delete (*$2)[i];
@@ -521,7 +522,7 @@ void yyerror (char const *s)
   currmodule = NULL;
 }
 
-Module *parse(const char *text, const char *path, int debug)
+FileModule *parse(const char *text, const char *path, int debug)
 {
   lexerin = NULL;
   parser_error_pos = -1;
@@ -529,7 +530,8 @@ Module *parse(const char *text, const char *path, int debug)
   parser_source_path = boosty::absolute(std::string(path)).string();
 
   module_stack.clear();
-  Module *rootmodule = currmodule = new Module();
+  rootmodule = new FileModule();
+  currmodule = rootmodule;
   rootmodule->setModulePath(path);
   //        PRINTB_NOCACHE("New module: %s %p", "root" % rootmodule);
 
diff --git a/src/primitives.cc b/src/primitives.cc
index 184b40c..be1ec6f 100644
--- a/src/primitives.cc
+++ b/src/primitives.cc
@@ -56,7 +56,7 @@ class PrimitiveModule : public AbstractModule
 public:
 	primitive_type_e type;
 	PrimitiveModule(primitive_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
 class PrimitiveNode : public AbstractPolyNode
@@ -105,7 +105,7 @@ public:
 	virtual PolySet *evaluate_polyset(class PolySetEvaluator *) const;
 };
 
-AbstractNode *PrimitiveModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *PrimitiveModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	PrimitiveNode *node = new PrimitiveNode(inst, this->type);
 
@@ -137,7 +137,7 @@ AbstractNode *PrimitiveModule::evaluate(const Context *ctx, const ModuleInstanti
 		args += Assignment("points", NULL), Assignment("paths", NULL), Assignment("convexity", NULL);
 		break;
 	default:
-		assert(false && "PrimitiveModule::evaluate(): Unknown node type");
+		assert(false && "PrimitiveModule::instantiate(): Unknown node type");
 	}
 
 	Context c(ctx);
diff --git a/src/projection.cc b/src/projection.cc
index eeed411..8d8cee6 100644
--- a/src/projection.cc
+++ b/src/projection.cc
@@ -41,10 +41,10 @@ class ProjectionModule : public AbstractModule
 {
 public:
 	ProjectionModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
-AbstractNode *ProjectionModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *ProjectionModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	ProjectionNode *node = new ProjectionNode(inst);
 
@@ -62,8 +62,8 @@ AbstractNode *ProjectionModule::evaluate(const Context *ctx, const ModuleInstant
 	if (cut.type() == Value::BOOL)
 		node->cut_mode = cut.toBool();
 
-	std::vector<AbstractNode *> evaluatednodes = inst->evaluateChildren(evalctx);
-	node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+	std::vector<AbstractNode *> instantiatednodes = inst->instantiateChildren(evalctx);
+	node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 
 	return node;
 }
diff --git a/src/render.cc b/src/render.cc
index bb08c0c..5097661 100644
--- a/src/render.cc
+++ b/src/render.cc
@@ -38,10 +38,10 @@ class RenderModule : public AbstractModule
 {
 public:
 	RenderModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
-AbstractNode *RenderModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *RenderModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	RenderNode *node = new RenderNode(inst);
 
@@ -55,8 +55,8 @@ AbstractNode *RenderModule::evaluate(const Context *ctx, const ModuleInstantiati
 	if (v.type() == Value::NUMBER)
 		node->convexity = (int)v.toDouble();
 
-	std::vector<AbstractNode *> evaluatednodes = inst->evaluateChildren(evalctx);
-	node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+	std::vector<AbstractNode *> instantiatednodes = inst->instantiateChildren(evalctx);
+	node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 
 	return node;
 }
diff --git a/src/rotateextrude.cc b/src/rotateextrude.cc
index b6edb8b..2f9a28b 100644
--- a/src/rotateextrude.cc
+++ b/src/rotateextrude.cc
@@ -45,10 +45,10 @@ class RotateExtrudeModule : public AbstractModule
 {
 public:
 	RotateExtrudeModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
-AbstractNode *RotateExtrudeModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *RotateExtrudeModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	RotateExtrudeNode *node = new RotateExtrudeNode(inst);
 
@@ -85,8 +85,8 @@ AbstractNode *RotateExtrudeModule::evaluate(const Context *ctx, const ModuleInst
 		node->scale = 1;
 
 	if (node->filename.empty()) {
-		std::vector<AbstractNode *> evaluatednodes = inst->evaluateChildren(evalctx);
-		node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+		std::vector<AbstractNode *> instantiatednodes = inst->instantiateChildren(evalctx);
+		node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 	}
 
 	return node;
diff --git a/src/surface.cc b/src/surface.cc
index d8fa422..b3246c1 100644
--- a/src/surface.cc
+++ b/src/surface.cc
@@ -50,7 +50,7 @@ class SurfaceModule : public AbstractModule
 {
 public:
 	SurfaceModule() { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
 class SurfaceNode : public AbstractPolyNode
@@ -69,7 +69,7 @@ public:
 	virtual PolySet *evaluate_polyset(class PolySetEvaluator *) const;
 };
 
-AbstractNode *SurfaceModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *SurfaceModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	SurfaceNode *node = new SurfaceNode(inst);
 	node->center = false;
diff --git a/src/transform.cc b/src/transform.cc
index cc026fb..ddf222a 100644
--- a/src/transform.cc
+++ b/src/transform.cc
@@ -50,10 +50,10 @@ class TransformModule : public AbstractModule
 public:
 	transform_type_e type;
 	TransformModule(transform_type_e type) : type(type) { }
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const;
 };
 
-AbstractNode *TransformModule::evaluate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
+AbstractNode *TransformModule::instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx) const
 {
 	TransformNode *node = new TransformNode(inst);
 
@@ -175,8 +175,8 @@ AbstractNode *TransformModule::evaluate(const Context *ctx, const ModuleInstanti
 		}
 	}
 
-	std::vector<AbstractNode *> evaluatednodes = inst->evaluateChildren(evalctx);
-	node->children.insert(node->children.end(), evaluatednodes.begin(), evaluatednodes.end());
+	std::vector<AbstractNode *> instantiatednodes = inst->instantiateChildren(evalctx);
+	node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
 
 	return node;
 }
diff --git a/src/typedefs.h b/src/typedefs.h
index a6e9077..fd676e2 100644
--- a/src/typedefs.h
+++ b/src/typedefs.h
@@ -6,5 +6,6 @@
 
 typedef std::pair<std::string, class Expression*> Assignment;
 typedef std::vector<Assignment> AssignmentList;
+typedef std::vector<class ModuleInstantiation*> ModuleInstantiationList;
 
 #endif