move sources to src directory

src/parser/nodes.h

@@ -0,0 +1,791 @@
+
+#ifndef NODES_H
+#define NODES_H NODES_H
+
+#include <stdlib.h>                 /* exit() */
+
+#include <vector>
+#include <string>
+#include <iostream>
+
+#include "util/refptr.h"
+#include "util/Vector.h"
+#include "util/Scope.h"
+
+extern refptr<Scope> parser_scope;
+
+class Node
+{
+    public:
+        virtual ~Node();
+        void addChild(refptr<Node> child) { m_children.push_back(child); }
+        void addChildren(refptr<Node> other);
+        std::vector< refptr<Node> > & getChildren() { return m_children; }
+
+        virtual int getInteger() { return getNumber(); }
+
+        virtual double getNumber()
+        {
+            std::cerr << "Warning: Node::getNumber() called!" << std::endl;
+            return 0.0;
+        }
+        virtual refptr<Vector> getVector()
+        {
+            std::cerr << "Warning: Node::getVector() called!" << std::endl;
+            return refptr<Vector>(NULL);
+        }
+        virtual std::string getString()
+        {
+            std::cerr << "Warning: Node::getString() called!" << std::endl;
+            return "";
+        }
+        virtual refptr<Node> evaluate()
+        {
+            std::cerr << "Warning: Node::evaluate() called!" << std::endl;
+            return NULL;
+        }
+        virtual void evaluateChildren(refptr<Node> parent);
+
+        virtual bool isShape() { return false; }
+        virtual bool isMaterial() { return false; }
+        virtual bool isTransformBlock() { return false; }
+        virtual bool isExpression() { return false; }
+
+    protected:
+        std::vector< refptr<Node> > m_children;
+};
+
+typedef refptr<Node> NodeRef;
+
+
+class NumberNode : public Node
+{
+    public:
+        NumberNode(double number)
+            : m_number(number), m_direct(true)
+        {
+        }
+        NumberNode(NodeRef expr)
+            : m_direct(false)
+        {
+            m_expr = expr;
+        }
+        virtual double getNumber()
+        {
+            return m_direct ? m_number : m_expr->getNumber();
+        }
+        virtual refptr<Node> evaluate()
+        {
+            return m_direct
+                ? new NumberNode(m_number)
+                : new NumberNode(m_expr->evaluate());
+        }
+
+    protected:
+        double m_number;
+        bool m_direct;
+        NodeRef m_expr;
+};
+
+class VectorNode : public Node
+{
+    public:
+        VectorNode(NodeRef a, NodeRef b, NodeRef c)
+            : m_a(a), m_b(b), m_c(c), m_direct(true)
+        {
+        }
+        VectorNode(NodeRef node)
+            : m_vector(node), m_direct(false)
+        {
+        }
+        refptr<Vector> getVector()
+        {
+            return m_direct
+                ? new Vector(m_a->getNumber(),
+                        m_b->getNumber(),
+                        m_c->getNumber())
+                : m_vector->getVector();
+        }
+        virtual NodeRef evaluate()
+        {
+            return m_direct
+                ? new VectorNode(m_a->evaluate(),
+                        m_b->evaluate(),
+                        m_c->evaluate())
+                : m_vector->evaluate();
+        }
+    protected:
+        NodeRef m_a, m_b, m_c, m_vector;
+        bool m_direct;
+};
+
+
+class AmbientNode : public VectorNode
+{
+    public:
+        AmbientNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new AmbientNode(m_vector->evaluate());
+        }
+};
+
+class AmbientOcclusionNode : public NumberNode
+{
+    public:
+        AmbientOcclusionNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new AmbientOcclusionNode(m_expr->evaluate());
+        }
+};
+
+class BoxNode : public Node
+{
+    public:
+        bool isShape() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new BoxNode();
+        }
+};
+
+class CameraNode : public Node
+{
+    public:
+        virtual NodeRef evaluate()
+        {
+            return new CameraNode();
+        }
+};
+
+class ColorNode : public VectorNode
+{
+    public:
+        ColorNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new ColorNode(m_vector->evaluate());
+        }
+};
+
+class CylNode : public Node
+{
+    public:
+        bool isShape() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new CylNode();
+        }
+};
+
+class DiffuseNode : public VectorNode
+{
+    public:
+        DiffuseNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new DiffuseNode(m_vector->evaluate());
+        }
+};
+
+class ExposureNode : public NumberNode
+{
+    public:
+        ExposureNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new ExposureNode(m_expr->evaluate());
+        }
+};
+
+class ExtrudeNode : public Node
+{
+    public:
+        bool isShape() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new ExtrudeNode();
+        }
+};
+
+class HeightNode : public NumberNode
+{
+    public:
+        HeightNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new HeightNode(m_expr->evaluate());
+        }
+};
+
+class IdentifierNode : public Node
+{
+    public:
+        IdentifierNode(const std::string & str) { m_string = str; }
+        std::string getString() { return m_string; }
+        virtual NodeRef evaluate()
+        {
+            return new IdentifierNode(m_string);
+        }
+    protected:
+        std::string m_string;
+};
+
+class IntersectNode : public Node
+{
+    public:
+        bool isShape() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new IntersectNode();
+        }
+};
+
+class ItemsNode : public Node
+{
+    public:
+        virtual NodeRef evaluate()
+        {
+            return new ItemsNode();
+        }
+};
+
+class JitterNode : public NumberNode
+{
+    public:
+        JitterNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new JitterNode(m_expr->evaluate());
+        }
+};
+
+class LightNode : public Node
+{
+    public:
+        virtual NodeRef evaluate() { return new LightNode(); }
+};
+
+class LookAtNode : public VectorNode
+{
+    public:
+        LookAtNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new LookAtNode(m_vector->evaluate());
+        }
+};
+
+class MaterialNode : public Node
+{
+    public:
+        bool isMaterial() { return true; }
+        virtual NodeRef evaluate() { return new MaterialNode(); }
+};
+
+class MaterialDefinitionNode : public IdentifierNode
+{
+    public:
+        MaterialDefinitionNode(const std::string & str) : IdentifierNode(str) {}
+        virtual NodeRef evaluate()
+        {
+            return new MaterialDefinitionNode(m_string);
+        }
+};
+
+class MaterialRefNode : public IdentifierNode
+{
+    public:
+        MaterialRefNode(const std::string & str) : IdentifierNode(str) {}
+        bool isMaterial() { return true; }
+        virtual NodeRef evaluate() { return new MaterialRefNode(m_string); }
+};
+
+class MaxDepthNode : public NumberNode
+{
+    public:
+        MaxDepthNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new MaxDepthNode(m_expr->evaluate());
+        }
+};
+
+class MultisampleNode : public NumberNode
+{
+    public:
+        MultisampleNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new MultisampleNode(m_expr->evaluate());
+        }
+};
+
+class NGonNode : public NumberNode
+{
+    public:
+        NGonNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new NGonNode(m_expr->evaluate());
+        }
+};
+
+class OffsetNode : public NumberNode
+{
+    public:
+        OffsetNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new OffsetNode(m_expr->evaluate());
+        }
+};
+
+class OptionsNode : public Node
+{
+    public:
+        virtual NodeRef evaluate() { return new OptionsNode(); }
+};
+
+class PlaneNode : public Node
+{
+    public:
+        bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new PlaneNode(); }
+};
+
+class PlanePositionNode : public VectorNode
+{
+    public:
+        PlanePositionNode(NodeRef vec_node, NodeRef dist)
+            : VectorNode(vec_node)
+        {
+            m_dist = dist;
+        }
+        double getNumber() { return m_dist->getNumber(); }
+        virtual NodeRef evaluate()
+        {
+            return new PlanePositionNode(m_vector->evaluate(),
+                    m_dist->evaluate());
+        }
+
+    protected:
+        NodeRef m_dist;
+};
+
+class PolygonNode : public Node
+{
+    public:
+        virtual NodeRef evaluate() { return new PolygonNode(); }
+};
+
+class PositionNode : public VectorNode
+{
+    public:
+        PositionNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new PositionNode(m_vector->evaluate());
+        }
+};
+
+class RadiusNode : public NumberNode
+{
+    public:
+        RadiusNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new RadiusNode(m_expr->evaluate());
+        }
+};
+
+class ReflectanceNode : public NumberNode
+{
+    public:
+        ReflectanceNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new ReflectanceNode(m_expr->evaluate());
+        }
+};
+
+class RefractionNode : public NumberNode
+{
+    public:
+        RefractionNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new RefractionNode(m_expr->evaluate());
+        }
+};
+
+class RotateNode : public VectorNode
+{
+    public:
+        RotateNode(NodeRef angle, NodeRef vec_node)
+            : VectorNode(vec_node)
+        {
+            m_angle = angle;
+        }
+        double getNumber() { return m_angle->getNumber(); }
+        virtual NodeRef evaluate()
+        {
+            return new RotateNode(m_angle->evaluate(), m_vector->evaluate());
+        }
+
+    protected:
+        NodeRef m_angle;
+};
+
+class RotateBlockNode : public RotateNode
+{
+    public:
+        RotateBlockNode(NodeRef angle, NodeRef vec_node)
+            : RotateNode(angle, vec_node) {}
+        bool isTransformBlock() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new RotateBlockNode(m_angle->evaluate(), m_vector->evaluate());
+        }
+};
+
+class ScaleNode : public VectorNode
+{
+    public:
+        ScaleNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new ScaleNode(m_vector->evaluate());
+        }
+};
+
+class ScaleBlockNode : public ScaleNode
+{
+    public:
+        ScaleBlockNode(NodeRef vector) : ScaleNode(vector) {}
+        bool isTransformBlock() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new ScaleBlockNode(m_vector->evaluate());
+        }
+};
+
+class ScaleScalarNode : public Node
+{
+    public:
+        ScaleScalarNode(NodeRef expr)
+            : m_expr(expr)
+        {
+        }
+        virtual NodeRef evaluate()
+        {
+            NodeRef n = m_expr->evaluate();
+            return new VectorNode(n, n, n);
+        }
+    protected:
+        NodeRef m_expr;
+};
+
+class SceneNode : public Node
+{
+    public:
+        virtual NodeRef evaluate() { return new SceneNode(); }
+};
+
+class ShapeDefinitionNode : public IdentifierNode
+{
+    public:
+        ShapeDefinitionNode(const std::string & str) : IdentifierNode(str) {}
+        virtual NodeRef evaluate() { return new ShapeDefinitionNode(m_string); }
+};
+
+class ShapeRefNode : public IdentifierNode
+{
+    public:
+        ShapeRefNode(const std::string & str) : IdentifierNode(str) {}
+        bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new ShapeRefNode(m_string); }
+};
+
+class ShininessNode : public NumberNode
+{
+    public:
+        ShininessNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new ShininessNode(m_expr->evaluate());
+        }
+};
+
+class SizeNode : public VectorNode
+{
+    public:
+        SizeNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new SizeNode(m_vector->evaluate());
+        }
+};
+
+class SpecularNode : public VectorNode
+{
+    public:
+        SpecularNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new SpecularNode(m_vector->evaluate());
+        }
+};
+
+class SphereNode : public Node
+{
+    public:
+        bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new SphereNode(); }
+};
+
+class SubtractNode : public Node
+{
+    public:
+        bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new SubtractNode(); }
+};
+
+class TextureNode : public IdentifierNode
+{
+    public:
+        TextureNode(const std::string & str) : IdentifierNode(str) {}
+        virtual NodeRef evaluate() { return new TextureNode(m_string); }
+};
+
+class TranslateNode : public VectorNode
+{
+    public:
+        TranslateNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new TranslateNode(m_vector->evaluate());
+        }
+};
+
+class TranslateBlockNode : public TranslateNode
+{
+    public:
+        TranslateBlockNode(NodeRef vector) : TranslateNode(vector) {}
+        bool isTransformBlock() { return true; }
+        virtual NodeRef evaluate()
+        {
+            return new TranslateBlockNode(m_vector->evaluate());
+        }
+};
+
+class TransparencyNode : public NumberNode
+{
+    public:
+        TransparencyNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new TransparencyNode(m_expr->evaluate());
+        }
+};
+
+class UnionNode : public Node
+{
+    public:
+        bool isShape() { return true; }
+        virtual NodeRef evaluate() { return new UnionNode(); }
+};
+
+class UpNode : public VectorNode
+{
+    public:
+        UpNode(NodeRef vector) : VectorNode(vector) {}
+        virtual NodeRef evaluate()
+        {
+            return new UpNode(m_vector->evaluate());
+        }
+};
+
+class VFOVNode : public NumberNode
+{
+    public:
+        VFOVNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new VFOVNode(m_expr->evaluate());
+        }
+};
+
+class WidthNode : public NumberNode
+{
+    public:
+        WidthNode(NodeRef e) : NumberNode(e) {}
+        virtual NodeRef evaluate()
+        {
+            return new WidthNode(m_expr->evaluate());
+        }
+};
+
+/******** scripting nodes ********/
+
+class ExpressionNode : public Node
+{
+    public:
+        bool isExpression() { return true; }
+        virtual NodeRef evaluate() = 0;
+};
+
+class AssignmentNode : public ExpressionNode
+{
+    public:
+        AssignmentNode(NodeRef varref, NodeRef expr)
+            : m_varref(varref), m_expr(expr)
+        {
+        }
+        std::string getString() { return m_varref->getString(); }
+        virtual NodeRef evaluate()
+        {
+            double n = m_expr->evaluate()->getNumber();
+            parser_scope->putGlobal(getString(), n);
+            return new NumberNode(n);
+        }
+    protected:
+        NodeRef m_varref;
+        NodeRef m_expr;
+};
+
+class LocalAssignmentNode : public ExpressionNode
+{
+    public:
+        LocalAssignmentNode(NodeRef varref, NodeRef expr)
+            : m_varref(varref), m_expr(expr)
+        {
+        }
+        std::string getString() { return m_varref->getString(); }
+        virtual NodeRef evaluate()
+        {
+            double n = m_expr->evaluate()->getNumber();
+            parser_scope->putLocal(getString(), n);
+            return new NumberNode(n);
+        }
+    protected:
+        NodeRef m_varref;
+        NodeRef m_expr;
+};
+
+class LocalDeclNode : public ExpressionNode
+{
+    public:
+        LocalDeclNode(NodeRef varref) : m_varref(varref) { }
+        virtual NodeRef evaluate()
+        {
+            parser_scope->putLocal(m_varref->getString(), 0.0);
+            return NULL;
+        }
+    protected:
+        NodeRef m_varref;
+};
+
+class BinOpNode : public ExpressionNode
+{
+    public:
+        BinOpNode(char op, NodeRef one, NodeRef two)
+            : m_op(op), one(one), two(two)
+        {
+        }
+        virtual NodeRef evaluate();
+    protected:
+        char m_op;
+        NodeRef one;
+        NodeRef two;
+};
+
+class BoolExpressionNode : public Node
+{
+    public:
+        BoolExpressionNode(char op, NodeRef one, NodeRef two)
+            : m_op(op), one(one), two(two)
+        {
+        }
+        virtual NodeRef evaluate();
+    protected:
+        char m_op;
+        NodeRef one;
+        NodeRef two;
+};
+
+class VarRefNode : public Node
+{
+    public:
+        VarRefNode(const std::string & str) { m_string = str; }
+        std::string getString() { return m_string; }
+        virtual NodeRef evaluate()
+        {
+            if (parser_scope->contains(m_string))
+            {
+                return new NumberNode(parser_scope->get(m_string));
+            }
+            std::cerr << "Error: No identifier '" << m_string << "' in scope"
+                << std::endl;
+            exit(4);
+        }
+    protected:
+        std::string m_string;
+};
+
+class ForNode : public Node
+{
+    public:
+        ForNode(NodeRef e1, NodeRef e2, NodeRef e3)
+        {
+            m_nodes[0] = e1;
+            m_nodes[1] = e2;
+            m_nodes[2] = e3;
+        }
+        virtual NodeRef evaluate();
+    protected:
+        NodeRef m_nodes[3];
+};
+
+class IfNode : public Node
+{
+    public:
+        IfNode(NodeRef test_expr, NodeRef elses)
+        {
+            m_test_expr = test_expr;
+            m_elses = elses;
+        }
+        virtual NodeRef evaluate();
+    protected:
+        NodeRef m_test_expr, m_elses;
+};
+
+class ElseNode : public Node
+{
+    public:
+        virtual NodeRef evaluate();
+};
+
+class FunctionCallNode : public Node
+{
+    public:
+        FunctionCallNode(NodeRef name, NodeRef parameters)
+        {
+            m_name = name;
+            m_parameters = parameters;
+        }
+        virtual NodeRef evaluate();
+    protected:
+        NodeRef m_name, m_parameters;
+};
+
+/* this class is only used to hold a set of items coming out of a class's
+ * evaluate() from above. the evaluateChildren() top-level method will
+ * propagate children of this class up to the level of their parent */
+class EvaluatePropagateNode : public Node
+{
+};
+
+#endif
+