src/parser/impcomp/OpSeq.h

#ifndef OPSEQ_H_
#define OPSEQ_H_

#include <boost/shared_ptr.hpp>
#include <vector>
#include "engine/Variable.h"


class SymbolTable;
class VarTable;


class ParseException
{

public:
        ParseException(char* inStr)
                {

                }
};


namespace green
{

class OpSeq
{
public:

/*
        Var/Literal struture:
                vartype-8 bin-8 reserved-16 offset/value-32

                vartype- what type of the var is, literal or var; real or int
                        bit(from lowest):
                                0: 0-var 1-literal
                                1: 0-int 1-float

                bin- which bin its from:
                        0-entity current
                        1-entity last
                        2-entity previous frame
                        3-behavior
                        4-local stack frame
                        5-local stack pointer (push and pop is really this)
                        6-heap ... eventually
                        7-globals ... also eventually


        Possable statements: each < > is a 32 bit int
                Binary Operation: 8 long - this does a binary operation vars is dest
                        src1 src2
                        <OpCode> <Operator> <src1 var1> <src1 var2> <src2 var1> <src2 var2> <dest var 1> <dest var 2>

                Unary Operation: 6 long - does a unary op on the source var and puts
                        it in the dest var
                        <OpCode> <Operator> <src1 var1> <src1 var2> <dest var 1> <dest var 2>

                Goto: 3 long - unconditional jump, a variable is a jump to a variable
                        place, a literal is a jump to a fixed place, a float literal is
                        an error.
                        <OpCode> <dest var1> <dest var2>

                Goto if: 8 long - conditional goto, evaluates expression on the right
                        uses that to decide jump, 2 kinds jump if true or jump if false
                        <OpCode> <Operator> <goto var1> <goto var2> <src1 var1> <src1 var2> <src2 var1> <src2 var2>

                Push/Pop: 2 long - allocates or deallocates a size on the stack
                        <OpCode> <size>

                Function Call: variable - calls the function handler, there are
                        probably internal functions implemented by push return address
                        jumps and such that is not this
                        <OpCode> <funcid> <var1-1> <var1-2> <var2-1> <var2-2> ... <ENDTERM>

                Return: 1 - terminates parsing, every sequence must have atleast one
                        <OpCode>
*/


        enum OpCodeEnum
                {
                C_IBIN, //any integer binary operation
                C_FBIN, //float binary operation
                C_UNARY,        //unary op, this checks var type

                C_GOTO,         //unconditional goto
                C_GOTO_IF,      //goto if true
                C_GOTO_IFN,     //goto if false

                C_DECL_INT,     //declare an int
                C_DECL_FLOAT,   //declare a float
                C_FUNC,         //function call

                C_ENDTERM,      //the terminator for variable length expressions
                C_RETURN                //ends parsing
                };

        enum OperatorEnum
                {
                O_BIN_ADD,      //binary ops
                O_BIN_SUB,
                O_BIN_MUL,
                O_BIN_DIV,
                O_BIN_MOD,

                O_BIN_LT,
                O_BIN_GT,
                O_BIN_LE,
                O_BIN_GE,
                O_BIN_EQ,
                O_BIN_NE,

                O_BIN_AND,
                O_BIN_OR,

                O_UNARY_NEG,    //unary ops, these do type converting between int and float
                O_UNARY_NOT,  //except this one which only accepts ints
                O_UNARY_NOTH //does nothing operator, used for copying, 
                };

        static const int BIN_ENUM_COUNT = 6;
        enum BinEnum
                {
                B_ETHIS = 0,
                B_EPREV = 1,
                B_ELAST = 2,
                B_BEH = 3,
                B_LOCAL = 4,
                B_PARAM = 5
                };

        enum FuncEnum
                {
                F_SPAWN,
                F_DELETE,
                F_SEND,
                F_RECIEVE,
                F_GETMSGNUM
                };

private:
        std::vector<uint> seqData;

//Helper functions
        void dispVarFormat(int& cur);

public:

        OpSeq();
        OpSeq(int* inSeq);

        void addValue(int value);
        void addVar(int isLit,Variable::Type typeIn,OpSeq::BinEnum binNo,int offset);


        int getSize();

        void dumpScreen();

//private:
        std::vector<uint>::iterator getSequence();
};

typedef boost::shared_ptr<OpSeq> OpSeqPtr;

};

#endif

---