Web alhem.net

CodeTool Class Reference

#include <CodeTool.h>

Collaboration diagram for CodeTool:

[legend]List of all members.

Public Member Functions
	CodeTool (RobotXMLFile &ref)
	~CodeTool ()
void	SetRobot (Robot *x)
bool	Sane ()
void	Call (const std::string &method)
int	GetOpsize (unsigned char op)
const std::string &	GetOpcode (unsigned char op)
unsigned char	GetCode (int ptr)
size_t	GetCodesize ()
const unsigned char *	GetBuf ()
unsigned char	Execute ()
void	Jump (short)
long	get_property (int, int)
void	set_property (int, int, long)
long	call_method (int, int)
Private Attributes
RobotXMLFile &	m_config
Robot *	m_robot
size_t	m_codesize
unsigned char *	m_code
std::map< std::string, int >	m_methodmap
std::string	m_opcode [256]
int	m_opsize [256]
std::vector< VARIABLE * >	m_variables
size_t	m_ptr
long	m_register1
long	m_register2
stack_v	m_stack
std::vector< MapObject * > *	m_loop
std::vector< MapObject * >::iterator	m_loop_iterator
bool	m_loop_init

---

Detailed Description

Definition at line 14 of file CodeTool.h.

---

Constructor & Destructor Documentation

CodeTool::CodeTool

(

RobotXMLFile &

ref

)

Definition at line 10 of file CodeTool.cpp.

References RobotXMLFile::GetMethods(), RobotXMLFile::GetString(), RobotXMLFile::GetVariables(), m_code, m_codesize, m_config, m_methodmap, m_opcode, m_opsize, and m_variables.

                                    : m_config(ref)
,m_robot(NULL)
,m_codesize(0)
,m_code(NULL)
// code runner
,m_ptr(0)
,m_register1(0)
,m_register2(0)
,m_loop(NULL)
,m_loop_init(false)
{
        Base64 bb;
        std::string codestr64 = m_config.GetString("code");
        bb.decode(codestr64, NULL, m_codesize);
        m_code = new unsigned char[m_codesize + 1];
        bb.decode(codestr64, m_code, m_codesize);
        m_config.GetMethods( m_methodmap );
        m_config.GetVariables( m_variables );

        m_opcode[0x01] = "ld    ";
        m_opcode[0x02] = "push  ";
        m_opcode[0x03] = "ld    ";
        m_opcode[0x04] = "pop   ";
        m_opcode[0x05] = "add   ";
        m_opcode[0x06] = "sub   ";
        m_opcode[0x07] = "mul   ";
        m_opcode[0x08] = "div   ";
        m_opcode[0x09] = "eq    ";
        m_opcode[0x0a] = "jz    ";
        m_opcode[0x0b] = "jnz   ";
        m_opcode[0x0c] = "ld    ";
        m_opcode[0x0d] = "st    ";
        m_opcode[0x0e] = "call  ";
        m_opcode[0x0f] = "st    ";

        m_opcode[0x10] = "ld    ";
        m_opcode[0x11] = "init  ";
        m_opcode[0x12] = "not   ";
        m_opcode[0x13] = "neq   ";
        m_opcode[0x14] = "and   ";
        m_opcode[0x15] = "or    ";

        m_opcode[0x21] = "ld    ";
        m_opcode[0x22] = "push  ";
        m_opcode[0x23] = "ld    ";
        m_opcode[0x24] = "pop   ";
        m_opcode[0x25] = "add   ";
        m_opcode[0x26] = "sub   ";
        m_opcode[0x27] = "mul   ";
        m_opcode[0x28] = "div   ";
        m_opcode[0x29] = "eq    ";
        m_opcode[0x2a] = "jz    ";
        m_opcode[0x2b] = "jnz   ";
        m_opcode[0x2c] = "ld    ";
        m_opcode[0x2d] = "st    ";
        m_opcode[0x2e] = "call  ";
        m_opcode[0x2f] = "st    ";

        m_opcode[0x32] = "not   ";
        m_opcode[0x33] = "neq   ";
        m_opcode[0x34] = "and   ";
        m_opcode[0x35] = "or    ";

        m_opcode[0x81] = "jmp   ";
        m_opcode[0x82] = "init  "; // loop
        m_opcode[0x83] = "loop  ";
        m_opcode[0x84] = "ret   ";

        for (int opcode = 0; opcode < 256; opcode++)
        {
                int opsize = -1;
                switch (opcode)
                {
                // register1
                case 0x01:
                        opsize = 2;
                        break;
                case 0x02:
                        opsize = 0;
                        break;
                case 0x03:
                        opsize = 4;
                        break;
                case 0x04:
                case 0x05:
                case 0x06:
                case 0x07:
                case 0x08:
                case 0x09:
                        opsize = 0;
                        break;
                case 0x0a:
                case 0x0b:
                case 0x0c:
                case 0x0d:
                case 0x0e:
                case 0x0f:
                        opsize = 2;
                        break;
                case 0x10: // ...
                case 0x11: // loop init
                        opsize = -2;
                        break;
                case 0x12:
                case 0x13:
                case 0x14:
                case 0x15:
                        opsize = 0;
                        break;
                // register2
                case 0x21:
                        opsize = 2;
                        break;
                case 0x22:
                        opsize = 0;
                        break;
                case 0x23:
                        opsize = 4;
                        break;
                case 0x24:
                case 0x25:
                case 0x26:
                case 0x27:
                case 0x28:
                case 0x29:
                        opsize = 0;
                        break;
                case 0x2a:
                case 0x2b:
                case 0x2c:
                case 0x2d:
                case 0x2e:
                case 0x2f:
                        opsize = 2;
                        break;

                case 0x32:
                case 0x33:
                case 0x34:
                case 0x35:
                        opsize = 0;
                        break;

                case 0x81: // jmp
                case 0x82: // loop init
                case 0x83: // loop
                        opsize = 2;
                        break;
                case 0x84: // ret
                        opsize = 0;
                        break;

                }
                m_opsize[opcode] = opsize;
        }
}

CodeTool::~CodeTool

(

)

Definition at line 168 of file CodeTool.cpp.

References m_code, and m_variables.

{
        delete m_code;
        for (std::vector<VARIABLE *>::iterator it = m_variables.begin(); it != m_variables.end(); it++)
        {
                VARIABLE *p = *it;
                delete p;
        }
}

---

Member Function Documentation

void CodeTool::SetRobot

(

Robot *

x

)

[inline]

Definition at line 19 of file CodeTool.h.

References m_robot.

{ m_robot = x; }

bool CodeTool::Sane

(

)

Definition at line 199 of file CodeTool.cpp.

References m_code, m_codesize, and m_opsize.

{
        size_t ptr = 0;
        while (ptr < m_codesize)
        {
                unsigned char opcode = m_code[ptr++];
                int opsize = m_opsize[opcode];
                if (opsize == -1)
                {
                        return false;
                }
                else
                if (opsize == -2)
                {
                        ptr += 2;
                        unsigned char len = m_code[ptr++];
                        ptr += len;
                }
                else
                {
                        ptr += opsize;
                }
                if (opcode == 0x11 || opcode == 0x82)
                {
                        ptr += 2; // loop body length
                }
        }
        return true;
}

void CodeTool::Call

(

const std::string &

method

)

Definition at line 179 of file CodeTool.cpp.

References Execute(), m_methodmap, and m_ptr.

{
        for (std::map<std::string,int>::iterator it = m_methodmap.begin(); it != m_methodmap.end(); it++)
        {
                std::string name = (*it).first;
                int entry = (*it).second;
                if (name == method)
                {
                        // ok to call
                        m_ptr = entry;
                        unsigned char c = Execute();
                        while (c && c != 0x84) // ret
                        {
                                c = Execute();
                        }
                }
        }
}

int CodeTool::GetOpsize

(

unsigned char

op

)

[inline]

Definition at line 23 of file CodeTool.h.

References m_opsize.

{ return m_opsize[op]; }

const std::string& CodeTool::GetOpcode

(

unsigned char

op

)

[inline]

Definition at line 24 of file CodeTool.h.

References m_opcode.

{ return m_opcode[op]; }

unsigned char CodeTool::GetCode

(

int

ptr

)

[inline]

Definition at line 25 of file CodeTool.h.

References m_code, and m_codesize.

{ return (ptr >= 0 && ptr < (int)m_codesize) ? m_code[ptr] : 0; }

size_t CodeTool::GetCodesize

(

)

[inline]

Definition at line 26 of file CodeTool.h.

References m_codesize.

{ return m_codesize; }

const unsigned char* CodeTool::GetBuf

(

)

[inline]

Definition at line 27 of file CodeTool.h.

References m_code.

{ return m_code; }

unsigned char CodeTool::Execute

(

)

Definition at line 230 of file CodeTool.cpp.

References call_method(), get_property(), Jump(), m_code, m_codesize, m_loop, m_loop_init, m_loop_iterator, m_opsize, m_ptr, m_register1, m_register2, m_robot, m_stack, m_variables, ROBOTOBJECT_ROBOT, and set_property().

Referenced by Call().

{
        if (m_ptr >= m_codesize)
                return 0; // outside program limits
        unsigned char opcode = m_code[m_ptr++];
        int opsize = m_opsize[opcode];
        if (opsize == -1)
        {
                return 0; // illegal instruction
        }
        std::string tmpstr;
        short tmpvals = 0;
        long tmpvall = 0;
        short bodylen = 0;
        if (opsize == -2)
        {
                tmpvals = m_code[m_ptr++];
                tmpvals *= 256;
                tmpvals += m_code[m_ptr++];
                unsigned char tmplen = m_code[m_ptr++];
                char slask[256];
                memcpy(slask,m_code + m_ptr,tmplen);
                slask[tmplen] = 0;
                tmpstr = slask;
                m_ptr += tmplen;
        }
        else
        if (opsize == 2)
        {
                tmpvals = m_code[m_ptr++];
                tmpvals *= 256;
                tmpvals += m_code[m_ptr++];
        }
        else
        if (opsize == 4)
        {
                tmpvall = m_code[m_ptr++];
                tmpvall *= 256;
                tmpvall += m_code[m_ptr++];
                tmpvall *= 256;
                tmpvall += m_code[m_ptr++];
                tmpvall *= 256;
                tmpvall += m_code[m_ptr++];
        }
        if (opcode == 0x11 || opcode == 0x82)
        {
                bodylen = m_code[m_ptr++];
                bodylen *= 256;
                bodylen += m_code[m_ptr++];
        }
        int objx = tmpvals / 256;
        int prop = tmpvals % 256;
        int stacksize = m_stack.size();
        switch (opcode)
        {
        case 0x01: // 01 xx yy  register1 = property yy from object type xx
                m_register1 = get_property(objx, prop);
                break;
        case 0x02: // 02                Push register1
                m_stack.push_back(m_register1);
                break;
        case 0x03: // 03 zz zz zz zz    register1 = long integer ( zz zz zz zz == %08X )
                m_register1 = tmpvall;
                break;
        case 0x04: // 04                Pop register1
                if (stacksize)
                {
                        m_register1 = m_stack[stacksize - 1];
                        for (stack_v::iterator it = m_stack.begin(); it != m_stack.end(); it++)
                        {
                                if (stacksize-- == 1)
                                {
                                        m_stack.erase(it);
                                        break;
                                }
                        }
                }
                break;
        case 0x05: // 05                Add register1 (register1 = register1 + register1)
                m_register1 += m_register1;
                break;
        case 0x06: // 06                Sub register1
                m_register1 -= m_register1;
                break;
        case 0x07: // 07                Mul register1
                m_register1 *= m_register1;
                break;
        case 0x08: // 08                Div register1
                if (m_register1)
                {
                        m_register1 /= m_register1;
                }
                break;
        case 0x09: // 09                Eq register1
                m_register1 = m_register1 == m_register1;
                break;
        case 0x0a: // 0a zz zz  Jz +/- zz zz bytes ( zz zz == %04X ) if register1 == 0
                if (!m_register1)
                {
                        Jump(tmpvals);
                }
                break;
        case 0x0b: // 0b zz zz  Jnz +/- zz zz bytes if register1 != 0
                if (m_register1)
                {
                        Jump(tmpvals);
                }
                break;
        case 0x0c: // 0c zz zz  register1 = variable[zz zz]
                if (tmpvals >= 0 && tmpvals < (int)m_variables.size())
                {
                        m_register1 = m_variables[tmpvals] -> value;
                }
                else
                {
                        printf("Bad variable index: %d\n",tmpvals);
                }
                break;
        case 0x0d: // 0d zz zz  variable[zz zz] = register1
                if (tmpvals >= 0 && tmpvals < (int)m_variables.size())
                {
                        m_variables[tmpvals] -> value = m_register1;
                }
                else
                {
                        printf("Bad variable index: %d\n",tmpvals);
                }
                break;
        case 0x0e: // 0e xx yy  register1 = call method yy on object type xx
                m_register1 = call_method(objx, prop);
                break;
        case 0x0f: // 0f xx yy  assign property yy on object xx the value of register1
                set_property(objx, prop, m_register1);
                break;

        case 0x10: // 10 zz zz ll nn    register1 = property nn[ll] on object variable[zz zz]
                if (tmpvals >= 0 && tmpvals < (int)m_variables.size())
                {
                        VARIABLE *p = m_variables[tmpvals];
                        if (p -> type == 2)
                        {
                                MapObject *p2 = dynamic_cast<MapObject *>(p -> object);
                                if (p2)
                                {
                                        m_register1 = p2 -> get_property( tmpstr );
                                }
                        }
                }
                else
                {
                        printf("Bad variable index: %d\n",tmpvals);
                }
                break;
        case 0x11: // 11 zz zz ll nn    loop init: get list nn[ll] from object variable[zz zz]
                // m_loop
                // m_loop_iterator = m_loop -> begin()
                // m_loop_init
                // bodylen
                // loop end = m_ptr + bodylen
                break;
        case 0x12: // not
                m_register1 = !m_register1;
                break;
        case 0x13: // neq
                m_register1 = m_register1 != m_register1;
                break;
        case 0x14: // and
                m_register1 = m_register1 && m_register1;
                break;
        case 0x15: // or
                m_register1 = m_register1 || m_register1;
                break;

        case 0x21: // 01 xx yy  register2 = property yy from object type xx
                m_register2 = get_property(objx, prop);
                break;
        case 0x22: // 02                Push register2
                m_stack.push_back(m_register2);
                break;
        case 0x23: // 03 zz zz zz zz    register2 = long integer ( zz zz zz zz == %08X )
                m_register2 = tmpvall;
                break;
        case 0x24: // 04                Pop register2
                if (stacksize)
                {
                        m_register2 = m_stack[stacksize - 1];
                        for (stack_v::iterator it = m_stack.begin(); it != m_stack.end(); it++)
                        {
                                if (stacksize-- == 1)
                                {
                                        m_stack.erase(it);
                                        break;
                                }
                        }
                }
                break;
        case 0x25: // 05                Add register2 (register1 = register1 + register2)
                m_register1 += m_register2;
                break;
        case 0x26: // 06                Sub register2
                m_register1 -= m_register2;
                break;
        case 0x27: // 07                Mul register2
                m_register1 *= m_register2;
                break;
        case 0x28: // 08                Div register2
                if (m_register2)
                {
                        m_register1 /= m_register2;
                }
                else
                {
                        m_register1 = 0;
                }
                break;
        case 0x29: // 09                Eq register2
                m_register1 = m_register1 == m_register2;
                break;
        case 0x2a: // 0a zz zz  Jz +/- zz zz bytes ( zz zz == %04X ) if register2 == 0
                if (!m_register2)
                {
                        Jump(tmpvals);
                }
                break;
        case 0x2b: // 0b zz zz  Jnz +/- zz zz bytes if register2 != 0
                if (m_register2)
                {
                        Jump(tmpvals);
                }
                break;
        case 0x2c: // 0c zz zz  register2 = variable[zz zz]
                if (tmpvals >= 0 && tmpvals < (int)m_variables.size())
                {
                        m_register2 = m_variables[tmpvals] -> value;
                }
                else
                {
                        printf("Bad variable index: %d\n",tmpvals);
                }
                break;
        case 0x2d: // 0d zz zz  variable[zz zz] = register2
                if (tmpvals >= 0 && tmpvals < (int)m_variables.size())
                {
                        m_variables[tmpvals] -> value = m_register2;
                }
                else
                {
                        printf("Bad variable index: %d\n",tmpvals);
                }
                break;
        case 0x2e: // 0e xx yy  register2 = call method yy on object type xx
                m_register2 = call_method(objx, prop);
                break;
        case 0x2f: // 0f xx yy  assign property yy on object xx the value of register2
                set_property(objx, prop, m_register2);
                break;

        case 0x32:
                m_register1 = !m_register2;
                break;
        case 0x33: // neq
                m_register1 = m_register1 != m_register2;
                break;
        case 0x34: // and
                m_register1 = m_register1 && m_register2;
                break;
        case 0x35: // or
                m_register1 = m_register1 || m_register2;
                break;

        case 0x81: // 81 zz zz  Jmp +/- zz zz bytes ( zz zz == %04X )
                Jump(tmpvals);
                break;
        case 0x82: // 82 xx yy  loop init: get list yy from object xx
                // m_loop
                // m_loop_iterator = m_loop -> begin()
                // m_loop_init
                // bodylen
                // loop end = m_ptr + bodylen
                if (objx == ROBOTOBJECT_ROBOT && prop == 4)
                {
                        if (m_robot)
                        {
                                m_loop = &m_robot -> GetInventory();
                                m_loop_iterator = m_loop -> begin();
                                m_loop_init = true;
                        }
                }
                break;
        case 0x83: // 83 zz zz  variable[zz zz] = loop object, increase loop iterator
                if (m_loop_init)
                {
                        if (tmpvals >= 0 && tmpvals < (int)m_variables.size())
                        {
                                if (m_loop_iterator != m_loop -> end())
                                {
                                        m_variables[tmpvals] -> object = *m_loop_iterator;
                                        m_loop_iterator++;
                                        m_register1 = 1;
                                }
                                else
                                {
                                        m_register1 = 0;
                                        m_loop_init = false;
                                }
                        }
                        else
                        {
                                printf("Bad variable index: %d\n",tmpvals);
                        }
                }
                break;
        case 0x84: // 84                ret - End of Program
                break;

        default:
                return 0;
        }
        return opcode;
}

void CodeTool::Jump

(

short

)

Definition at line 552 of file CodeTool.cpp.

References m_ptr.

Referenced by Execute().

{
        if (tmpvals & 0x8000) // -
        {
                tmpvals &= 0x7fff;
                m_ptr -= tmpvals;
                m_ptr -= 3;
        }
        else
        {
                m_ptr += tmpvals;
        }
}

long CodeTool::get_property	(	int	,
		int
	)

Definition at line 567 of file CodeTool.cpp.

References Robot::get_property(), m_robot, ROBOTOBJECT_GUN, ROBOTOBJECT_RADAR, ROBOTOBJECT_ROBOT, ROBOTOBJECT_SHIELDS, and ROBOTOBJECT_TURRET.

Referenced by Execute().

{
        if (!m_robot)
                return 0;
        switch (obj)
        {
        case ROBOTOBJECT_ROBOT:
                return m_robot -> get_property( prop );
        case ROBOTOBJECT_RADAR:
                return m_robot -> PartRadar().get_property( prop );
        case ROBOTOBJECT_TURRET:
                return m_robot -> PartTurret().get_property( prop );
        case ROBOTOBJECT_GUN:
                return m_robot -> PartGun().get_property( prop );
        case ROBOTOBJECT_SHIELDS:
                return m_robot -> PartShields().get_property( prop );
        }
        printf("Bad object: %d\n",obj);
        return 0;
}

void CodeTool::set_property	(	int	,
		int	,
		long
	)

Definition at line 589 of file CodeTool.cpp.

References m_robot, ROBOTOBJECT_GUN, ROBOTOBJECT_RADAR, ROBOTOBJECT_ROBOT, ROBOTOBJECT_SHIELDS, ROBOTOBJECT_TURRET, and Robot::set_property().

Referenced by Execute().

{
        if (!m_robot)
                return;
        switch (obj)
        {
        case ROBOTOBJECT_ROBOT:
                m_robot -> set_property( prop, value );
                break;
        case ROBOTOBJECT_RADAR:
                m_robot -> PartRadar().set_property( prop, value );
                break;
        case ROBOTOBJECT_TURRET:
                m_robot -> PartTurret().set_property( prop, value );
                break;
        case ROBOTOBJECT_GUN:
                m_robot -> PartGun().set_property( prop, value );
                break;
        case ROBOTOBJECT_SHIELDS:
                m_robot -> PartShields().set_property( prop, value );
                break;
        default:
                printf("Bad object: %d\n",obj);
        }
}

long CodeTool::call_method	(	int	,
		int
	)

Definition at line 616 of file CodeTool.cpp.

References Robot::call_method(), m_robot, m_stack, ROBOTOBJECT_GUN, ROBOTOBJECT_RADAR, ROBOTOBJECT_ROBOT, ROBOTOBJECT_SHIELDS, and ROBOTOBJECT_TURRET.

Referenced by Execute().

{
        if (!m_robot)
                return 0;
        switch (obj)
        {
        case ROBOTOBJECT_ROBOT:
                return m_robot -> call_method( method, m_stack );
        case ROBOTOBJECT_RADAR:
                return m_robot -> PartRadar().call_method( method, m_stack );
        case ROBOTOBJECT_TURRET:
                return m_robot -> PartTurret().call_method( method, m_stack );
        case ROBOTOBJECT_GUN:
                return m_robot -> PartGun().call_method( method, m_stack );
        case ROBOTOBJECT_SHIELDS:
                return m_robot -> PartShields().call_method( method, m_stack );
        }
        printf("Bad object: %d\n",obj);
        return 0;
}

---

Member Data Documentation

RobotXMLFile& CodeTool::m_config [private]

Definition at line 37 of file CodeTool.h.

Referenced by CodeTool().

Robot* CodeTool::m_robot [private]

Definition at line 38 of file CodeTool.h.

Referenced by call_method(), Execute(), get_property(), set_property(), and SetRobot().

size_t CodeTool::m_codesize [private]

Definition at line 39 of file CodeTool.h.

Referenced by CodeTool(), Execute(), GetCode(), GetCodesize(), and Sane().

unsigned char* CodeTool::m_code [private]

Definition at line 40 of file CodeTool.h.

Referenced by CodeTool(), Execute(), GetBuf(), GetCode(), Sane(), and ~CodeTool().

std::map<std::string,int> CodeTool::m_methodmap [private]

Definition at line 41 of file CodeTool.h.

Referenced by Call(), and CodeTool().

std::string CodeTool::m_opcode[256] [private]

Definition at line 42 of file CodeTool.h.

Referenced by CodeTool(), and GetOpcode().

int CodeTool::m_opsize[256] [private]

Definition at line 43 of file CodeTool.h.

Referenced by CodeTool(), Execute(), GetOpsize(), and Sane().

std::vector<VARIABLE *> CodeTool::m_variables [private]

Definition at line 44 of file CodeTool.h.

Referenced by CodeTool(), Execute(), and ~CodeTool().

size_t CodeTool::m_ptr [private]

Definition at line 47 of file CodeTool.h.

Referenced by Call(), Execute(), and Jump().

long CodeTool::m_register1 [private]

Definition at line 48 of file CodeTool.h.

Referenced by Execute().

long CodeTool::m_register2 [private]

Definition at line 49 of file CodeTool.h.

Referenced by Execute().

stack_v CodeTool::m_stack [private]

Definition at line 50 of file CodeTool.h.

Referenced by call_method(), and Execute().

std::vector<MapObject *>* CodeTool::m_loop [private]

Definition at line 51 of file CodeTool.h.

Referenced by Execute().

std::vector<MapObject *>::iterator CodeTool::m_loop_iterator [private]

Definition at line 52 of file CodeTool.h.

Referenced by Execute().

bool CodeTool::m_loop_init [private]

Definition at line 53 of file CodeTool.h.

Referenced by Execute().

---

The documentation for this class was generated from the following files:

• CodeTool.h
• CodeTool.cpp

---

Page, code, and content Copyright (C) 2004 by Anders Hedström