src/parser/impcomp/UnresOpSeq.h

#ifndef UNRESOPSEQ_H_
#define UNRESOPSEQ_H_

#include "engine/Variable.h"
#include "engine/VariableTableTemplate.h"
#include "OpSeq.h"



namespace green
{
class MessageTemplateTable;
class EntityTemplateTable;

typedef boost::shared_ptr<MessageTemplateTable> MessageTemplateTablePtr;
typedef boost::shared_ptr<EntityTemplateTable> EntityTemplateTablePtr;


class UnresOpSeq
        {


        private:
                class OpNode
                        {
                        public:
                                enum  NodeType { OPCODE, OPERATOR, VAR, LITERAL, LABEL, LABELREF, ENTRY, DECL,
                                                 MESSAGE, ENTITY };
                                union Data
                                        {
                                        OpSeq::BinEnum binNo;  //entity(1,2,3) or behavior or such
                                        OpSeq::OpCodeEnum opCode;
                                        OpSeq::OperatorEnum operCode;
                                        int integer;  //when it doesnt matter
                                        float real;  //for float vals
                                        };

                                NodeType type;
                                Data data;
                                std::string varName;
                                Variable::Type varType;

                                int curNum;
                        };


                std::vector<OpNode*> seq;
                int curNum;

                VariableTableTemplatePtr whoBelongs;
                int isInit;

//Helper functions
                void addNode(OpNode::NodeType typeIn,OpNode::Data dataIn,std::string& strIn,
                             int curNumInc,Variable::Type varTypeIn);
                void addNode(OpNode::NodeType typeIn,OpNode::Data dataIn,int curNumInc,
                             Variable::Type varTypeIn);
                int findLabel(std::string& inStr);

                void resolveVar(OpNode* node,OpSeqPtr opSeq,
                                VariableTableTemplatePtr inTable,
                                std::vector<Variable::Type>& localTypes,
                            std::map<std::string,int>& localMap);


        public:
                UnresOpSeq(VariableTableTemplatePtr whoBelongIn,int isInitIn);
                ~UnresOpSeq();

                void addInt(int entryIn);
                void addVarDec(Variable::Type typeIn,std::string& varName,std::string& initValStr);
                void addOpCode(OpSeq::OpCodeEnum opCodeIn);
                void addOperator(OpSeq::OperatorEnum operatorIn);
                void addVarRef(std::string& varNameIn,std::string& binNameIn);
                void addIntLiteral(int litIn);
                void addFloatLiteral(float litIn);
                void addLabel(std::string& labelName);
                void addLabelRef(std::string& labelName);

                void addEntityTag(std::string& entityName);
                void addMessageTag(std::string& messageName);


                OpSeqPtr resolveOpSeq(VariableTableTemplatePtr inTable,
                              EntityTemplateTablePtr entityLookup,
                              MessageTemplateTablePtr messageLookup);

                void dumpScreen();
};

typedef boost::shared_ptr<UnresOpSeq> UnresOpSeqPtr;

};

#endif

---