ExprNode.h

Go to the documentation of this file.

/*
 Copyright Disney Enterprises, Inc.  All rights reserved.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License
 and the following modification to it: Section 6 Trademarks.
 deleted and replaced with:

 6. Trademarks. This License does not grant permission to use the
 trade names, trademarks, service marks, or product names of the
 Licensor and its affiliates, except as required for reproducing
 the content of the NOTICE file.

 You may obtain a copy of the License at
 http://www.apache.org/licenses/LICENSE-2.0
*/

#ifndef ExprNode_h
#define ExprNode_h

#include <cstdlib>

// TODO: get rid of makedepends everywhere
#ifndef MAKEDEPEND
#include <string.h>
#include <string>
#include <vector>
#endif

#include "ExprConfig.h"
#include "ExprLLVM.h"
#include "Expression.h"
#include "ExprType.h"
#include "ExprEnv.h"
#include "Vec.h"
#include "Interpreter.h"

namespace SeExpr2 {
class ExprFunc;
class ExprFuncX;

class ExprNode {
  public:
    ExprNode(const Expression* expr);
    ExprNode(const Expression* expr, const ExprType& type);
    ExprNode(const Expression* expr, ExprNode* a);
    ExprNode(const Expression* expr, ExprNode* a, const ExprType& type);
    ExprNode(const Expression* expr, ExprNode* a, ExprNode* b);
    ExprNode(const Expression* expr, ExprNode* a, ExprNode* b, const ExprType& type);
    ExprNode(const Expression* expr, ExprNode* a, ExprNode* b, ExprNode* c);
    ExprNode(const Expression* expr, ExprNode* a, ExprNode* b, ExprNode* c, const ExprType& type);
    virtual ~ExprNode();


    virtual ExprType prep(bool dontNeedScalar, ExprVarEnvBuilder& envBuilder);

    virtual int buildInterpreter(Interpreter* interpreter) const;

    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

    bool isVec() const { return _isVec; }

    const Expression* expr() const { return _expr; }

    std::string toString() const {
        return expr()->getExpr().substr(startPos(), length());
    };


    const ExprNode* parent() const { return _parent; }
    int numChildren() const { return _children.size(); }

    const ExprNode* child(size_t i) const { return _children[i]; }

    ExprNode* child(size_t i) { return _children[i]; }

    void swapChildren(size_t i, size_t j) {
        assert(i != j && i < _children.size() && j < _children.size());
        std::swap(_children[i], _children[j]);
    }

    void removeLastChild() {
        if (_children.size()) {
            delete _children.back();
            _children.pop_back();
        }
    }

    void addChild(ExprNode* child);

    void addChildren(ExprNode* surrogate);


    const ExprType& type() const {
        return _type;
    };


    inline void setPosition(const short int startPos, const short int endPos) {
        _startPos = startPos;
        _endPos = endPos;
    }
    inline short int startPos() const { return _startPos; }
    inline short int endPos() const { return _endPos; }
    inline short int length() const {
        return endPos() - startPos();
    };


    inline void addError(const std::string& error) const { _expr->addError(error, _startPos, _endPos); }

  protected: /*protected functions*/
    inline void setType(const ExprType& t) {
        _type = t;
    };
    inline void setTypeWithChildLife(const ExprType& t) {
        setType(t);
        int num = numChildren();
        if (num > 0) {
            _type.setLifetime(child(0)->type());
            for (int i = 1; i < num; i++) _type.setLifetime(_type, child(i)->type());
        } else  // no children life is constant!
            _type.Constant();
    };


  public:
    inline bool checkCondition(bool check, const std::string& message, bool& error) {
        if (!check) {
            addError(message);
            error = true;
        }
        return check;
    };
    bool checkIsValue(const ExprType& type, bool& error) {
        return checkCondition(type.isValue(), "Expected String or Float[d]", error);
    }
    bool checkIsFP(const ExprType& type, bool& error) {
        return checkCondition(type.isFP(), "Expected Float[d]", error);
    }
    bool checkIsFP(int d, const ExprType& type, bool& error) {
        if (!type.isFP(d)) {  // Defer creating expensive string creation unless error
            std::stringstream s;
            s << "Expected Float[" << d << "]" << std::endl;
            return checkCondition(false, s.str(), error);
        }
        return false;
    }
    inline bool checkTypesCompatible(const ExprType& first, const ExprType& second, bool& error) {
        if (!ExprType::valuesCompatible(first, second)) {
            return checkCondition(
                false, "Type mismatch. First: " + first.toString() + " Second: " + second.toString(), error);
        } else
            return false;
    }
  protected: /*protected data members*/
    const Expression* _expr;

    ExprNode* _parent;

    std::vector<ExprNode*> _children;

    bool _isVec;

    // Type of node
    ExprType _type;
    int _maxChildDim;

    unsigned short int _startPos, _endPos;
};

class ExprModuleNode : public ExprNode {
  public:
    ExprModuleNode(const Expression* expr) : ExprNode(expr) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;
};

class ExprPrototypeNode : public ExprNode {
  public:
    ExprPrototypeNode(const Expression* expr, const std::string& name, const ExprType& retType)
        : ExprNode(expr), _name(name), _retTypeSet(true), _retType(retType), _argTypes() {}

    ExprPrototypeNode(const Expression* expr, const std::string& name)
        : ExprNode(expr), _name(name), _retTypeSet(false), _argTypes() {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);

    void addArgTypes(ExprNode* surrogate);
    void addArgs(ExprNode* surrogate);

    inline void setReturnType(const ExprType& type) {
        _retType = type;
        _retTypeSet = true;
    };

    inline bool isReturnTypeSet() const {
        return _retTypeSet;
    };

    inline ExprType returnType() const {
        return (_retTypeSet ? _retType : ExprType().Error().Varying());
    };

    inline ExprType argType(int i) const {
        return _argTypes[i];
    };
    inline const ExprNode* arg(int i) const {
        return child(i);
    };

    const std::string& name() const { return _name; }

    int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;
    int interpreterOps(int c) const { return _interpreterOps.at(c); }

  private:
    std::string _name;
    bool _retTypeSet;
    ExprType _retType;
    std::vector<ExprType> _argTypes;
    mutable std::vector<int> _interpreterOps;  // operands for interpreter // TODO: this sucks... maybe a better place
                                               // for this.
};

class ExprFuncNode;
class ExprLocalFunctionNode : public ExprNode {
  public:
    ExprLocalFunctionNode(const Expression* expr, ExprPrototypeNode* prototype, ExprNode* block)
        : ExprNode(expr, prototype, block) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual ExprType prep(ExprFuncNode* callerNode, bool scalarWanted, ExprVarEnvBuilder& envBuilder) const;
    const ExprPrototypeNode* prototype() const { return static_cast<const ExprPrototypeNode*>(child(0)); }

    int buildInterpreter(Interpreter* interpreter) const;
    int buildInterpreterForCall(const ExprFuncNode* callerNode, Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

  private:
    mutable int _procedurePC;
    mutable int _returnedDataOp;
};

class ExprBlockNode : public ExprNode {
  public:
    ExprBlockNode(const Expression* expr, ExprNode* a, ExprNode* b) : ExprNode(expr, a, b) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;
};

class ExprIfThenElseNode : public ExprNode {
  public:
    ExprIfThenElseNode(const Expression* expr, ExprNode* a, ExprNode* b, ExprNode* c) : ExprNode(expr, a, b, c), _varEnv(nullptr), _varEnvMergeIndex(0) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

    ExprVarEnv* _varEnv;
    size_t _varEnvMergeIndex;
};

class ExprAssignNode : public ExprNode {
  public:
    ExprAssignNode(const Expression* expr, const char* name, ExprNode* e)
        : ExprNode(expr, e), _name(name), _localVar(0) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    // virtual void eval(Vec3d& result) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

    const std::string& name() const {
        return _name;
    };
    const ExprType& assignedType() const {
        return _assignedType;
    };
    const ExprLocalVar* localVar() const { return _localVar; }

  private:
    std::string _name;
    ExprLocalVar* _localVar;
    ExprType _assignedType;
};

// TODO three scalars?  Or 2 to 16 scalars??
class ExprVecNode : public ExprNode {
  public:
    ExprVecNode(const Expression* expr) : ExprNode(expr) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

    Vec3d value() const;
};

class ExprUnaryOpNode : public ExprNode {
  public:
    ExprUnaryOpNode(const Expression* expr, ExprNode* a, char op) : ExprNode(expr, a), _op(op) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

    char _op;
};

class ExprCondNode : public ExprNode {
  public:
    ExprCondNode(const Expression* expr, ExprNode* a, ExprNode* b, ExprNode* c) : ExprNode(expr, a, b, c) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;
};

class ExprSubscriptNode : public ExprNode {
  public:
    ExprSubscriptNode(const Expression* expr, ExprNode* a, ExprNode* b) : ExprNode(expr, a, b) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;
};

class ExprCompareEqNode : public ExprNode {
  public:
    ExprCompareEqNode(const Expression* expr, ExprNode* a, ExprNode* b, char op) : ExprNode(expr, a, b), _op(op) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

    char _op;
};

class ExprCompareNode : public ExprNode {
  public:
    ExprCompareNode(const Expression* expr, ExprNode* a, ExprNode* b, char op) : ExprNode(expr, a, b), _op(op) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

    char _op;
};

class ExprBinaryOpNode : public ExprNode {
  public:
    ExprBinaryOpNode(const Expression* expr, ExprNode* a, ExprNode* b, char op) : ExprNode(expr, a, b), _op(op) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

    char _op;
};

class ExprVarNode : public ExprNode {
  public:
    ExprVarNode(const Expression* expr, const char* name) : ExprNode(expr), _name(name), _localVar(0), _var(0) {}

    ExprVarNode(const Expression* expr, const char* name, const ExprType& type)
        : ExprNode(expr, type), _name(name), _localVar(0), _var(0) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;
    const char* name() const { return _name.c_str(); }
    const ExprLocalVar* localVar() const { return _localVar; }
    const ExprVarRef* var() const { return _var; }

  private:
    std::string _name;
    ExprLocalVar* _localVar;
    ExprVarRef* _var;
};

class ExprNumNode : public ExprNode {
  public:
    ExprNumNode(const Expression* expr, double val) : ExprNode(expr), _val(val) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;
    double value() const {
        return _val;
    };

  private:
    double _val;
};

class ExprStrNode : public ExprNode {
  public:
    ExprStrNode(const Expression* expr, const char* str) : ExprNode(expr), _str(str) {}

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;
    const char* str() const { return _str.c_str(); }
    void str(const char* newstr) { _str = newstr; }

  private:
    std::string _str;
};

class ExprFuncNode : public ExprNode {
  public:
    ExprFuncNode(const Expression* expr, const char* name)
        : ExprNode(expr), _name(name), _func(0), _localFunc(0), _data(0) {
        expr->addFunc(name);
    }
    virtual ~ExprFuncNode() {/* TODO: fix delete _data;*/
    }

    virtual ExprType prep(bool wantScalar, ExprVarEnvBuilder& envBuilder);
    virtual int buildInterpreter(Interpreter* interpreter) const;
    virtual LLVM_VALUE codegen(LLVM_BUILDER) LLVM_BODY;

    const char* name() const { return _name.c_str(); }
    bool checkArg(int argIndex, ExprType type, ExprVarEnvBuilder& envBuilder);

#if 0
    virtual void eval(Vec3d& result) const;
    void setIsVec(bool isVec) { _isVec = isVec; }

    int nargs() const { return _nargs; }

#if 0
    double* scalarArgs() const { return &_scalarArgs[0]; }
    Vec3d* vecArgs() const { return &_vecArgs[0]; }

    Vec3d* evalArgs() const;

    Vec3d evalArg(int n) const;

    bool isStrArg(int n) const;

    std::string getStrArg(int n) const;
#endif

#endif

    // TODO: Remove those two methods.
    bool isStrArg(int n) const { return n < numChildren() && dynamic_cast<const ExprStrNode*>(child(n)) != 0; }
    std::string getStrArg(int n) const {
        if (n < numChildren()) return static_cast<const ExprStrNode*>(child(n))->str();
        return "";
    }

    struct Data {
        virtual ~Data() {}
    };

    /***
        Use this to set data associated with the node. Equivalently this is data
        associated with a specific evaluation point of a function.
        Examples would be tokenized values,
        sorted lists for binary searches in curve evaluation, etc. This should be done
        in ExprFuncX::prep().
    */
    void setData(Data* data) const { _data = data; }

    /***
        Use this to get data associated in the prep() routine. This is typically
        used from ExprFuncX::eval()
    */
    Data* getData() const { return _data; }
    int promote(int i) const { return _promote[i]; }
    const ExprFunc* func() const { return _func; }

  private:
    std::string _name;
    const ExprFunc* _func;
    const ExprLocalFunctionNode* _localFunc;  // TODO: it is dirty to have to have both.
                                              //    int _nargs;
                                              //    mutable std::vector<double> _scalarArgs;
                                              //    mutable std::vector<Vec3d> _vecArgs;
    mutable std::vector<int> _promote;
    mutable Data* _data;
};

class ExprNodePolicy {
    typedef ExprNode Base;
    // TODO: fix this once we switch to a c++11 compiler
    // typedef std::unique_ptr<Base*> Ptr;

    typedef ExprModuleNode Module;
    typedef ExprPrototypeNode Prototype;
    typedef ExprLocalFunctionNode LocalFunction;
    typedef ExprBlockNode Block;
    typedef ExprIfThenElseNode IfThenElse;
    typedef ExprAssignNode Assign;
    typedef ExprVecNode Vec;
    typedef ExprUnaryOpNode UnaryOp;
    typedef ExprCondNode Cond;
    typedef ExprCompareEqNode CompareEq;
    typedef ExprCompareNode Compare;
    typedef ExprBinaryOpNode BinaryOp;
    typedef ExprVarNode Var;
    typedef ExprNumNode Num;
    typedef ExprStrNode Str;
    typedef ExprFuncNode Func;
};
}

#endif