1 files changed, 40 insertions, 35 deletions

diff --git a/src/module.h b/src/module.h
index cc82f81..9f46d37 100644
--- a/src/module.h
+++ b/src/module.h
@@ -6,35 +6,39 @@
 #include <list>
 #include <boost/unordered_map.hpp>
 #include "value.h"
+#include "typedefs.h"
+#include "localscope.h"
 
 class ModuleInstantiation
 {
 public:
-	ModuleInstantiation(const std::string &name = "") 
-	: ctx(NULL), 
-		tag_root(false), tag_highlight(false), tag_background(false), modname(name) { }
+	ModuleInstantiation(const std::string &name = "")
+		: tag_root(false), tag_highlight(false), tag_background(false), recursioncount(0), modname(name) { }
 	virtual ~ModuleInstantiation();
 
 	std::string dump(const std::string &indent) const;
 	class AbstractNode *evaluate(const class Context *ctx) const;
-	std::vector<AbstractNode*> evaluateChildren(const Context *ctx = NULL) 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; }
+	std::string getAbsolutePath(const std::string &filename) const;
 
 	const std::string &name() const { return this->modname; }
 	bool isBackground() const { return this->tag_background; }
 	bool isHighlight() const { return this->tag_highlight; }
 	bool isRoot() const { return this->tag_root; }
 
-	std::vector<std::string> argnames;
-	std::vector<Value> argvalues;
-	std::vector<class Expression*> argexpr;
-	std::vector<ModuleInstantiation*> children;
-	const Context *ctx;
+	AssignmentList arguments;
+	LocalScope scope;
 
 	bool tag_root;
 	bool tag_highlight;
 	bool tag_background;
+	mutable int recursioncount;
 protected:
 	std::string modname;
+	std::string modpath;
 
 	friend class Module;
 };
@@ -43,54 +47,55 @@ class IfElseModuleInstantiation : public ModuleInstantiation {
 public:
 	IfElseModuleInstantiation() : ModuleInstantiation("if") { }
 	virtual ~IfElseModuleInstantiation();
-	std::vector<AbstractNode*> evaluateElseChildren(const Context *ctx = NULL) 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;
+	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();
-	virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
-	virtual std::string dump(const std::string &indent, const std::string &name) const;
-
-	void addChild(ModuleInstantiation *ch) { this->children.push_back(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();
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx = NULL) const;
+	virtual std::string dump(const std::string &indent, const std::string &name) const;
 
-	std::list<std::string> assignments_var;
-	typedef boost::unordered_map<std::string, Expression*> AssignmentContainer;
-	AssignmentContainer assignments;
+	AssignmentList definition_arguments;
 
-	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;
+// FIXME: A FileModule doesn't have definition arguments, so we shouldn't really
+// inherit from a Module
+class FileModule : public Module
+{
+public:
+	FileModule() : is_handling_dependencies(false) {}
+	virtual ~FileModule() {}
 
-	std::vector<std::string> argnames;
-	std::vector<Expression*> argexpr;
+	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();
+	virtual AbstractNode *instantiate(const Context *ctx, const ModuleInstantiation *inst, const EvalContext *evalctx = NULL) const;
 
-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;
 };
 
 #endif