Expression.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 Expression_h
#define Expression_h

#include <string>
#include <map>
#include <set>
#include <vector>
#include <iomanip>
#include <stdint.h>
#include "ExprConfig.h"
#include "Vec.h"
#include "Context.h"
#include "ExprEnv.h"

namespace llvm {
class ExecutionEngine;
class LLVMContext;
}

namespace SeExpr2 {

class ExprNode;
class ExprVarNode;
class ExprFunc;
class Expression;
class Interpreter;

class ExprVarRef {
    ExprVarRef() : _type(ExprType().Error().Varying()) {};

  public:
    ExprVarRef(const ExprType& type) : _type(type) {};

    virtual ~ExprVarRef() {}

    virtual void setType(const ExprType& type) {
        _type = type;
    };

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

    virtual void eval(double* result) = 0;
    virtual void eval(const char** resultStr) = 0;

  private:
    ExprType _type;
};

class LLVMEvaluator;
class VarBlock;
class VarBlockCreator;

class Expression {
  public:
    enum EvaluationStrategy {
        UseInterpreter,
        UseLLVM
    };
    static EvaluationStrategy defaultEvaluationStrategy;
    static bool debugging;

    // typedef std::map<std::string, ExprLocalVarRef> LocalVarTable;

    struct Error {
        std::string error;

        int startPos;

        int endPos;

        Error(const std::string& errorIn, const int startPosIn, const int endPosIn)
            : error(errorIn), startPos(startPosIn), endPos(endPosIn) {}
    };

    Expression(EvaluationStrategy be = Expression::defaultEvaluationStrategy);
    Expression(const std::string& e,
               const ExprType& type = ExprType().FP(3),
               EvaluationStrategy be = Expression::defaultEvaluationStrategy,
               const Context& context = Context::global());

    virtual ~Expression();

    void setDesiredReturnType(const ExprType& type);

    void setExpr(const std::string& e);

    const std::string& getExpr() const { return _expression; }

    bool syntaxOK() const;

    bool isValid() const {
        prepIfNeeded();
        return _isValid;
    }

    const std::string& parseError() const { return _parseError; }

    const std::vector<Error>& getErrors() const { return _errors; }

    const std::vector<std::pair<int, int> >& getComments() const { return _comments; }

    bool isConstant() const;

    bool usesVar(const std::string& name) const;

    bool usesFunc(const std::string& name) const;

    bool isThreadSafe() const { return _threadUnsafeFunctionCalls.size() == 0; }

    void setThreadUnsafe(const std::string& functionName) const { _threadUnsafeFunctionCalls.push_back(functionName); }

    const std::vector<std::string>& getThreadUnsafeFunctionCalls() const { return _threadUnsafeFunctionCalls; }

    bool wantVec() const { return _wantVec; }

    bool isVec() const;

    const ExprType& returnType() const;

    void evalMultiple(VarBlock* varBlock, int outputVarBlockOffset, size_t rangeStart, size_t rangeEnd) const;

    // TODO: make this deprecated
    const double* evalFP(VarBlock* varBlock = nullptr) const;

    // TODO: make this deprecated
    const char* evalStr(VarBlock* varBlock = nullptr) const;

    void reset();

    virtual ExprVarRef* resolveVar(const std::string& name) const { return 0; }

    virtual ExprFunc* resolveFunc(const std::string& name) const { return 0; }

    void addError(const std::string& error, const int startPos, const int endPos) const {
        _errors.push_back(Error(error, startPos, endPos));
    }

    void addComment(int pos, int length) { _comments.push_back(std::pair<int, int>(pos, length + pos - 1)); }

    // const LocalVarTable& getLocalVars() const {return _localVars;}

    const Context& context() const { return *_context; }
    void setContext(const Context& context);

    void debugPrintParseTree() const;

    void debugPrintInterpreter() const;

    void debugPrintLLVM() const;

    void setVarBlockCreator(const VarBlockCreator* varBlockCreator);

    const VarBlockCreator* varBlockCreator() const { return _varBlockCreator; }

  private:
    Expression(const Expression& e);
    Expression& operator=(const Expression& e);

    void parse() const;

    void parseIfNeeded() const {
        if (!_parsed) parse();
    }

    void prep() const;

    bool _wantVec;

    mutable ExprType _returnType;

    std::string _expression;

    EvaluationStrategy _evaluationStrategy;

    const Context* _context;

  protected:
    mutable ExprType _desiredReturnType;

    mutable ExprVarEnvBuilder _envBuilder;
    mutable ExprNode* _parseTree;

    void prepIfNeeded() const {
        if (!_prepped) prep();
    }

  private:
    mutable bool _isValid;
    mutable bool _parsed, _prepped;

    mutable std::string _parseError;

    mutable std::vector<Error> _errors;

    mutable std::vector<std::pair<int, int> > _comments;

    mutable std::set<std::string> _vars;

    mutable std::set<std::string> _funcs;

    // mutable LocalVarTable _localVars;

    mutable std::vector<std::string> _threadUnsafeFunctionCalls;

    mutable Interpreter* _interpreter;
    mutable int _returnSlot;

    // LLVM evaluation layer
    mutable LLVMEvaluator* _llvmEvaluator;

    // Var block creator
    const VarBlockCreator* _varBlockCreator = 0;

    /* internal */ public:

    void addVar(const char* n) const { _vars.insert(n); }

    void addFunc(const char* n) const { _funcs.insert(n); }

    // ExprVarRef* resolveLocalVar(const char* n) const {
    //    LocalVarTable::iterator iter = _localVars.find(n);
    //    if (iter != _localVars.end()) return &iter->second;
    //    return 0;
    //}

    /* ExprLocalVarRef* getLocalVar(const char* n) const { */
    /*     return &_localVars[n];  */
    /* } */
};
}

#endif