vm.h

Go to the documentation of this file.

/*
        Aseba - an event-based framework for distributed robot control
        Copyright (C) 2007--2012:
                Stephane Magnenat <stephane at magnenat dot net>
                (http://stephane.magnenat.net)
                and other contributors, see authors.txt for details
        
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU Lesser General Public License as published
        by the Free Software Foundation, version 3 of the License.
        
        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU Lesser General Public License for more details.
        
        You should have received a copy of the GNU Lesser General Public License
        along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __ASEBA_VM_H
#define __ASEBA_VM_H

#ifdef __cplusplus
extern "C" {
#endif

#include "../common/types.h"


enum
{
        ASEBA_MAX_BREAKPOINTS = 16              
};

typedef struct
{
        // node id
        uint16 nodeId;
        
        // bytecode
        uint16 bytecodeSize; 
        uint16 * bytecode; 
        // variables
        uint16 variablesSize; 
        sint16 * variables; 
        // execution stack
        uint16 stackSize; 
        sint16 * stack; 
        // execution
        uint16 flags;
        uint16 pc;
        sint16 sp;
        
        // breakpoint
        uint16 breakpoints[ASEBA_MAX_BREAKPOINTS];
        uint16 breakpointsCount;
} AsebaVMState;

// Macros to work with masks

#define AsebaMaskSet(v, m) ((v) |= (m))

#define AsebaMaskClear(v, m) ((v) &= (~(m)))

#define AsebaMaskIsSet(v, m) (((v) & (m)) != 0)

#define AsebaMaskIsClear(v, m) (((v) & (m)) == 0)


// Functions provided by aseba-core


void AsebaVMInit(AsebaVMState *vm);

uint16 AsebaVMGetEventAddress(AsebaVMState *vm, uint16 event);

uint16 AsebaVMSetupEvent(AsebaVMState *vm, uint16 event);

uint16 AsebaVMRun(AsebaVMState *vm, uint16 stepsLimit);

void AsebaVMDebugMessage(AsebaVMState *vm, uint16 id, uint16 *data, uint16 dataLength);

void AsebaVMEmitNodeSpecificError(AsebaVMState *vm, const char* message);

uint16 AsebaVMShouldDropPacket(AsebaVMState *vm, uint16 source, const uint8* data);

// Functions implemented outside by the glue/transport layer

void AsebaSendMessage(AsebaVMState *vm, uint16 id, const void *data, uint16 size);

#ifdef __BIG_ENDIAN__

void AsebaSendMessageWords(AsebaVMState *vm, uint16 type, const uint16* data, uint16 count);
#else
        #define AsebaSendMessageWords(vm,type,data,size) AsebaSendMessage(vm,type,data,(size)*2)
#endif

void AsebaSendVariables(AsebaVMState *vm, uint16 start, uint16 length);

void AsebaSendDescription(AsebaVMState *vm);

void AsebaNativeFunction(AsebaVMState *vm, uint16 id);

void AsebaWriteBytecode(AsebaVMState *vm);

void AsebaResetIntoBootloader(AsebaVMState *vm);

void AsebaPutVmToSleep(AsebaVMState *vm);

void __attribute__((weak)) AsebaVMRunCB(AsebaVMState *vm);

void __attribute__((weak)) AsebaVMErrorCB(AsebaVMState *vm, const char* message);

// Function optionally implemented

#ifdef ASEBA_ASSERT

typedef enum
{
        ASEBA_ASSERT_UNKNOWN = 0,
        ASEBA_ASSERT_UNKNOWN_UNARY_OPERATOR,
        ASEBA_ASSERT_UNKNOWN_BINARY_OPERATOR,
        ASEBA_ASSERT_UNKNOWN_BYTECODE,
        ASEBA_ASSERT_STACK_OVERFLOW,
        ASEBA_ASSERT_STACK_UNDERFLOW,
        ASEBA_ASSERT_OUT_OF_VARIABLES_BOUNDS,
        ASEBA_ASSERT_OUT_OF_BYTECODE_BOUNDS,
        ASEBA_ASSERT_STEP_OUT_OF_RUN,
        ASEBA_ASSERT_BREAKPOINT_OUT_OF_BYTECODE_BOUNDS,
        ASEBA_ASSERT_EMIT_BUFFER_TOO_LONG,
} AsebaAssertReason;

void AsebaAssert(AsebaVMState *vm, AsebaAssertReason reason);

#endif /* ASEBA_ASSERT */

#ifdef __cplusplus
} /* closing brace for extern "C" */
#endif

#endif