Merge branch 'bom-tree-std-stack' of git://github.com/steelman/openscad into steelman-bom-tree-std-stack

Conflicts:
	src/module.cc

3 files changed, 36 insertions, 0 deletions

diff --git a/src/func.cc b/src/func.cc
index 20f487a..865a2b4 100644
--- a/src/func.cc
+++ b/src/func.cc
@@ -528,6 +528,29 @@ Value builtin_version_num(const Context *ctx, const EvalContext *evalctx)
 	return Value(y * 10000 + m * 100 + d);
 }
 
+Value builtin_parent_module(const Context *, const EvalContext *evalctx)
+{
+	int n;
+	double d;
+	int s = Module::stack_size();
+	if (evalctx->numArgs() == 0)
+		d=1; // parent module
+	else if (evalctx->numArgs() == 1 && evalctx->getArgValue(0).type() == Value::NUMBER)
+		evalctx->getArgValue(0).getDouble(d);
+	else
+			return Value();
+	n=trunc(d);
+	if (n < 0) {
+		PRINTB("WARNING: Negative parent module index (%d) not allowed", n);
+		return Value();
+	}
+	if (n >= s) {
+		PRINTB("WARNING: Parent module index (%d) greater than the number of modules on the stack", n);
+		return Value();
+	}
+	return Value(Module::stack_element(s - 1 - n));
+}
+
 void register_builtin_functions()
 {
 	Builtins::init("abs", new BuiltinFunction(&builtin_abs));
@@ -556,4 +579,5 @@ void register_builtin_functions()
 	Builtins::init("search", new BuiltinFunction(&builtin_search));
 	Builtins::init("version", new BuiltinFunction(&builtin_version));
 	Builtins::init("version_num", new BuiltinFunction(&builtin_version_num));
+	Builtins::init("parent_module", new BuiltinFunction(&builtin_parent_module));
 }
diff --git a/src/module.cc b/src/module.cc
index f66c8ef..e3a992b 100644
--- a/src/module.cc
+++ b/src/module.cc
@@ -153,6 +153,8 @@ std::vector<AbstractNode*> IfElseModuleInstantiation::instantiateElseChildren(co
 	return this->else_scope.instantiateChildren(evalctx);
 }
 
+std::deque<std::string> Module::module_stack;
+
 Module::~Module()
 {
 }
@@ -183,6 +185,9 @@ AbstractNode *Module::instantiate(const Context *ctx, const ModuleInstantiation
 	// set $children first since we might have variables depending on it
 	c.set_variable("$children", Value(double(inst->scope.children.size())));
 	c.initializeModule(*this);
+	module_stack.push_back(inst->name());
+	c.set_variable("$parent_modules", Value(double(module_stack.size())));
+	c.initializeModule(*this);
 	// FIXME: Set document path to the path of the module
 #if 0 && DEBUG
 	c.dump(this, inst);
@@ -191,6 +196,7 @@ AbstractNode *Module::instantiate(const Context *ctx, const ModuleInstantiation
 	AbstractNode *node = new AbstractNode(inst);
 	std::vector<AbstractNode *> instantiatednodes = this->scope.instantiateChildren(&c);
 	node->children.insert(node->children.end(), instantiatednodes.begin(), instantiatednodes.end());
+	module_stack.pop_back();
 
 	return node;
 }
diff --git a/src/module.h b/src/module.h
index b5c58af..8414706 100644
--- a/src/module.h
+++ b/src/module.h
@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 #include <list>
+#include <deque>
 #include <boost/unordered_map.hpp>
 #include <boost/unordered_set.hpp>
 #include <time.h>
@@ -73,10 +74,15 @@ public:
 
 	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;
+	static const std::string& stack_element(int n) { return module_stack[n]; };
+	static int stack_size() { return module_stack.size(); };
 
 	AssignmentList definition_arguments;
 
 	LocalScope scope;
+
+private:
+	static std::deque<std::string> module_stack;
 };
 
 // FIXME: A FileModule doesn't have definition arguments, so we shouldn't really