Interpreter.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 _Interpreter_h_
#define _Interpreter_h_

#include <vector>
#include <stack>

namespace SeExpr2 {
class ExprLocalVar;

template <int d>
struct Promote {
    // TODO: this needs a name that is prefixed by Se!
    static int f(int* opData, double* fp, char** c, std::vector<int>& callStack) {
        int posIn = opData[0];
        int posOut = opData[1];
        for (int k = posOut; k < posOut + d; k++) fp[k] = fp[posIn];
        return 1;
    }
};

class Interpreter {
  public:
    std::vector<double> d;
    std::vector<char*> s;
    std::vector<int> opData;

    typedef std::map<const ExprLocalVar*, int> VarToLoc;
    VarToLoc varToLoc;

    typedef int (*OpF)(int*, double*, char**, std::vector<int>&);

    std::vector<std::pair<OpF, int> > ops;
    std::vector<int> callStack;

  private:
    bool _startedOp;
    int _pcStart;

  public:
    Interpreter() : _startedOp(false) {
        s.push_back(nullptr);  // reserved for double** of variable block
        s.push_back(nullptr);  // reserved for double** of variable block
    }

    int nextPC() { return ops.size(); }

    int addOp(OpF op) {
        if (_startedOp) {
            assert(false && "addOp called within another addOp");
        }
        _startedOp = true;
        int pc = ops.size();
        ops.push_back(std::make_pair(op, opData.size()));
        return pc;
    }

    void endOp(bool execute = true) {
        _startedOp = false;
        if (execute) {
            double* fp = &d[0];
            char** str = &s[0];
            int pc = ops.size() - 1;
            const std::pair<OpF, int>& op = ops[pc];
            int* opCurr = &opData[0] + op.second;
            pc += op.first(opCurr, fp, str, callStack);
        }
    }

    int addOperand(int param) {
        assert(_startedOp);
        int ret = opData.size();
        opData.push_back(param);
        return ret;
    }

    int allocFP(int n) {
        int ret = d.size();
        for (int k = 0; k < n; k++) d.push_back(0);
        return ret;
    }

    int allocPtr() {
        int ret = s.size();
        s.push_back(0);
        return ret;
    }

    void eval(VarBlock* varBlock, bool debug = false);
    void print(int pc = -1) const;

    void setPCStart(int pcStart) { _pcStart = pcStart; }
};

template <template <int d> class T,class T_FUNCTYPE=Interpreter::OpF>
T_FUNCTYPE getTemplatizedOp(int i) {
    switch (i) {
        case 1:
            return T<1>::f;
        case 2:
            return T<2>::f;
        case 3:
            return T<3>::f;
        case 4:
            return T<4>::f;
        case 5:
            return T<5>::f;
        case 6:
            return T<6>::f;
        case 7:
            return T<7>::f;
        case 8:
            return T<8>::f;
        case 9:
            return T<9>::f;
        case 10:
            return T<10>::f;
        case 11:
            return T<11>::f;
        case 12:
            return T<12>::f;
        case 13:
            return T<13>::f;
        case 14:
            return T<14>::f;
        case 15:
            return T<15>::f;
        case 16:
            return T<16>::f;
        default:
            assert(false && "Invalid dynamic parameter (not supported template)");
            break;
    }
    return 0;
}
}

#endif