vm.h

Go to the documentation of this file.

/*
    Aseba - an event-based framework for distributed robot control
    Copyright (C) 2007--2016:
        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);

#ifdef DISABLE_WEAK_CALLBACKS
static void AsebaVMRunCB(AsebaVMState *vm) {}
#else // DISABLE_WEAK_CALLBACKS
void __attribute__((weak)) AsebaVMRunCB(AsebaVMState *vm);
#endif // DISABLE_WEAK_CALLBACKS

#ifdef DISABLE_WEAK_CALLBACKS
static void AsebaVMResetCB(AsebaVMState *vm) {}
#else // DISABLE_WEAK_CALLBACKS
void __attribute__((weak)) AsebaVMResetCB(AsebaVMState *vm);
#endif // DISABLE_WEAK_CALLBACKS

#ifdef DISABLE_WEAK_CALLBACKS
static void AsebaVMErrorCB(AsebaVMState *vm, const char* message) {}
#else // DISABLE_WEAK_CALLBACKS
void __attribute__((weak)) AsebaVMErrorCB(AsebaVMState *vm, const char* message);
#endif // DISABLE_WEAK_CALLBACKS


// 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