This is the open source Pawn interpreter ported to mbed. See here: http://www.compuphase.com/pawn/pawn.htm and here: http://code.google.com/p/pawnscript/
Some instructions:
- Put the attached include folder next to your source, so when you compile you get all the proper definitions
- Use the attached main.p as a starting point if you wish
- Compile your main.p into main.amx - Put your main.amx on the mbed 'drive'
- Reset and be amazed.
Important Compile Notes:
- You should use the -S# option to define a smaller default stack size. Start with -S64 and go up from there if needed.
- To use on the Cortex-M0 version of the mbed (LPC11U24), you MUST include the TARGET=3 command-line option as well, so the pin names are properly defined. In the future this may be handled on the native code side.
Known Issues:
At the moment it appears the kbhit() function is not working right - at least on my mac. Will continue testing on Windows.Working fine.
Todo:
- Add more wrappers for the mbed peripherals
- Add Pawn overlay support, to allow much larger scripts to run (even on the LPC11U24)
Diff: amx.h
- Revision:
- 0:3ab1d2d14eb3
diff -r 000000000000 -r 3ab1d2d14eb3 amx.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/amx.h Thu Nov 15 17:41:21 2012 +0000 @@ -0,0 +1,519 @@ +/* Pawn Abstract Machine (for the Pawn language) + * + * Copyright (c) ITB CompuPhase, 1997-2012 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy + * of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + * + * Version: $Id: amx.h 4731 2012-06-21 11:11:18Z thiadmer $ + */ + +#ifndef AMX_H_INCLUDED +#define AMX_H_INCLUDED + +#include <stdlib.h> /* for size_t */ +#include <limits.h> + +#if defined __linux || defined __linux__ + #define __LINUX__ +#endif +#if defined FREEBSD && !defined __FreeBSD__ + #define __FreeBSD__ +#endif +#if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ + #include <sclinux.h> +#endif + +#if !defined HAVE_STDINT_H + #if (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) \ + || defined __GNUC__ || defined __LCC__ || defined __DMC__ \ + || (defined __WATCOMC__ && __WATCOMC__ >= 1200) + #define HAVE_STDINT_H 1 + #endif +#endif +#if !defined HAVE_INTTYPES_H + #if defined __FreeBSD__ + #define HAVE_INTTYPES_H 1 + #endif +#endif +#if defined HAVE_STDINT_H + #include <stdint.h> +#elif defined HAVE_INTTYPES_H + #include <inttypes.h> +#else + #if defined __MACH__ + #include <ppc/types.h> + #endif + typedef short int int16_t; + typedef unsigned short int uint16_t; + #if defined SN_TARGET_PS2 + typedef int int32_t; + typedef unsigned int uint32_t; + #else + typedef long int int32_t; + typedef unsigned long int uint32_t; + #endif + #if defined __WIN32__ || defined _WIN32 || defined WIN32 + typedef __int64 int64_t; + typedef unsigned __int64 uint64_t; + #define HAVE_I64 + #endif + #if !defined _INTPTR_T_DEFINED + #if defined _LP64 || defined WIN64 || defined _WIN64 + typedef __int64 intptr_t; + #else + typedef int32_t intptr_t; + #endif + #endif +#endif +#if defined _LP64 || defined WIN64 || defined _WIN64 + #if !defined __64BIT__ + #define __64BIT__ + #endif +#endif + +#if !defined HAVE_ALLOCA_H + #if defined __GNUC__ || defined __LCC__ || defined __DMC__ || defined __ARMCC_VERSION + #define HAVE_ALLOCA_H 1 + #elif defined __WATCOMC__ && __WATCOMC__ >= 1200 + #define HAVE_ALLOCA_H 1 + #endif +#endif +#if defined HAVE_ALLOCA_H && HAVE_ALLOCA_H + #include <alloca.h> +#elif defined __BORLANDC__ + #include <malloc.h> +#endif +#if defined __WIN32__ || defined _WIN32 || defined WIN32 /* || defined __MSDOS__ */ + #if !defined alloca + #define alloca(n) _alloca(n) + #endif +#endif + +#if !defined assert_static + /* see "Compile-Time Assertions" by Greg Miller, + * (with modifications to port it to C) + */ + #define _ASSERT_STATIC_SYMBOL_INNER(line) __ASSERT_STATIC_ ## line + #define _ASSERT_STATIC_SYMBOL(line) _ASSERT_STATIC_SYMBOL_INNER(line) + #define assert_static(test) \ + do { \ + typedef char _ASSERT_STATIC_SYMBOL(__LINE__)[ ((test) ? 1 : -1) ]; \ + } while (0) +#endif + +#if defined __cplusplus +extern "C" { +#endif + +#if defined PAWN_DLL + #if !defined AMX_NATIVE_CALL + #define AMX_NATIVE_CALL __stdcall + #endif + #if !defined AMXAPI + #define AMXAPI __stdcall + #endif + #if !defined AMXEXPORT + #define AMXEXPORT __declspec(dllexport) + #endif +#endif + +/* calling convention for native functions */ +#if !defined AMX_NATIVE_CALL + #define AMX_NATIVE_CALL +#endif +/* calling convention for all interface functions and callback functions */ +#if !defined AMXAPI + #if defined STDECL + #define AMXAPI __stdcall + #elif defined CDECL + #define AMXAPI __cdecl + #elif defined GCC_HASCLASSVISIBILITY + #define AMXAPI __attribute__((visibility("default"))) + #else + #define AMXAPI + #endif +#endif +#if !defined AMXEXPORT + #define AMXEXPORT +#endif + +/* File format version (in CUR_FILE_VERSION) + * 0 original version + * 1 opcodes JUMP.pri, SWITCH and CASETBL + * 2 compressed files + * 3 public variables + * 4 opcodes SWAP.pri/alt and PUSHADDR + * 5 tagnames table + * 6 reformatted header + * 7 name table, opcodes SYMTAG & SYSREQ.D + * 8 opcode BREAK, renewed debug interface + * 9 macro opcodes + * 10 position-independent code, overlays, packed instructions + * 11 relocating instructions for the native interface, reorganized instruction set + * MIN_FILE_VERSION is the lowest file version number that the current AMX + * implementation supports. If the AMX file header gets new fields, this number + * often needs to be incremented. MIN_AMX_VERSION is the lowest AMX version that + * is needed to support the current file version. When there are new opcodes, + * this number needs to be incremented. + * The file version supported by the JIT may run behind MIN_AMX_VERSION. So + * there is an extra constant for it: MAX_FILE_VER_JIT. + */ +#define CUR_FILE_VERSION 11 /* current file version; also the current AMX version */ +#define MIN_FILE_VERSION 11 /* lowest supported file format version for the current AMX version */ +#define MIN_AMX_VERSION 11 /* minimum AMX version needed to support the current file format */ +#define MAX_FILE_VER_JIT 11 /* file version supported by the JIT */ +#define MIN_AMX_VER_JIT 11 /* AMX version supported by the JIT */ + +#if !defined PAWN_CELL_SIZE + #define PAWN_CELL_SIZE 32 /* by default, use 32-bit cells */ +#endif +#if PAWN_CELL_SIZE==16 + typedef uint16_t ucell; + typedef int16_t cell; +#elif PAWN_CELL_SIZE==32 + typedef uint32_t ucell; + typedef int32_t cell; +#elif PAWN_CELL_SIZE==64 + typedef uint64_t ucell; + typedef int64_t cell; +#else + #error Unsupported cell size (PAWN_CELL_SIZE) +#endif + +#define UNPACKEDMAX (((cell)1 << (sizeof(cell)-1)*8) - 1) +#define UNLIMITED (~1u >> 1) + +struct tagAMX; +typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, const cell *params); +typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index, + cell *result, const cell *params); +typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx); +typedef int (AMXAPI *AMX_OVERLAY)(struct tagAMX *amx, int index); +typedef int (AMXAPI *AMX_IDLE)(struct tagAMX *amx, int AMXAPI Exec(struct tagAMX *, cell *, int)); +#if !defined _FAR + #define _FAR +#endif + +#if defined _MSC_VER + #pragma warning(disable:4103) /* disable warning message 4103 that complains + * about pragma pack in a header file */ + #pragma warning(disable:4100) /* "'%$S' : unreferenced formal parameter" */ + #pragma warning(disable:4996) /* POSIX name is deprecated */ +#endif + +/* Some compilers do not support the #pragma align, which should be fine. Some + * compilers give a warning on unknown #pragmas, which is not so fine... + */ +#if (defined SN_TARGET_PS2 || defined __GNUC__) && !defined AMX_NO_ALIGN + #define AMX_NO_ALIGN +#endif + +#if defined __GNUC__ + #define PACKED __attribute__((packed)) +#else + #define PACKED +#endif + +#if !defined AMX_NO_ALIGN + #if defined __LINUX__ || defined __FreeBSD__ + #pragma pack(1) /* structures must be packed (byte-aligned) */ + #elif defined MACOS && defined __MWERKS__ + #pragma options align=mac68k + #else + #pragma pack(push) + #pragma pack(1) /* structures must be packed (byte-aligned) */ + #if defined __TURBOC__ + #pragma option -a- /* "pack" pragma for older Borland compilers */ + #endif + #endif +#endif + +typedef struct tagAMX_NATIVE_INFO { + const char _FAR *name; + AMX_NATIVE func; +} PACKED AMX_NATIVE_INFO; + +#if !defined AMX_USERNUM +#define AMX_USERNUM 4 +#endif +#define sEXPMAX 19 /* maximum name length for file version <= 6 */ +#define sNAMEMAX 31 /* maximum name length of symbol name */ + +typedef struct tagFUNCSTUB { + uint32_t address; + uint32_t nameofs; +} PACKED AMX_FUNCSTUB; + +typedef struct tagOVERLAYINFO { + int32_t offset; /* offset relative to the start of the code block */ + int32_t size; /* size in bytes */ +} PACKED AMX_OVERLAYINFO; + +/* The AMX structure is the internal structure for many functions. Not all + * fields are valid at all times; many fields are cached in local variables. + */ +typedef struct tagAMX { + unsigned char _FAR *base; /* points to the AMX header, perhaps followed by P-code and data */ + unsigned char _FAR *code; /* points to P-code block, possibly in ROM or in an overlay pool */ + unsigned char _FAR *data; /* points to separate data+stack+heap, may be NULL */ + AMX_CALLBACK callback; /* native function callback */ + AMX_DEBUG debug; /* debug callback */ + AMX_OVERLAY overlay; /* overlay reader callback */ + /* for external functions a few registers must be accessible from the outside */ + cell cip; /* instruction pointer: relative to base + amxhdr->cod */ + cell frm; /* stack frame base: relative to base + amxhdr->dat */ + cell hea; /* top of the heap: relative to base + amxhdr->dat */ + cell hlw; /* bottom of the heap: relative to base + amxhdr->dat */ + cell stk; /* stack pointer: relative to base + amxhdr->dat */ + cell stp; /* top of the stack: relative to base + amxhdr->dat */ + int flags; /* current status, see amx_Flags() */ + /* user data */ + #if AMX_USERNUM > 0 + long usertags[AMX_USERNUM]; + void _FAR *userdata[AMX_USERNUM]; + #endif + /* native functions can raise an error */ + int error; + /* passing parameters requires a "count" field */ + int paramcount; + /* the sleep opcode needs to store the full AMX status */ + cell pri; + cell alt; + cell reset_stk; + cell reset_hea; + /* extra fields for increased performance */ + cell sysreq_d; /* relocated address/value for the SYSREQ.D opcode */ + /* fields for overlay support and JIT support */ + int ovl_index; /* current overlay index */ + long codesize; /* size of the overlay, or estimated memory footprint of the native code */ + #if defined AMX_JIT + /* support variables for the JIT */ + int reloc_size; /* required temporary buffer for relocations */ + #endif +} PACKED AMX; + +/* The AMX_HEADER structure is both the memory format as the file format. The + * structure is used internaly. + */ +typedef struct tagAMX_HEADER { + int32_t size; /* size of the "file" */ + uint16_t magic; /* signature */ + char file_version; /* file format version */ + char amx_version; /* required version of the AMX */ + int16_t flags; + int16_t defsize; /* size of a definition record */ + int32_t cod; /* initial value of COD - code block */ + int32_t dat; /* initial value of DAT - data block */ + int32_t hea; /* initial value of HEA - start of the heap */ + int32_t stp; /* initial value of STP - stack top */ + int32_t cip; /* initial value of CIP - the instruction pointer */ + int32_t publics; /* offset to the "public functions" table */ + int32_t natives; /* offset to the "native functions" table */ + int32_t libraries; /* offset to the table of libraries */ + int32_t pubvars; /* offset to the "public variables" table */ + int32_t tags; /* offset to the "public tagnames" table */ + int32_t nametable; /* offset to the name table */ + int32_t overlays; /* offset to the overlay table */ +} PACKED AMX_HEADER; + +#define AMX_MAGIC_16 0xf1e2 +#define AMX_MAGIC_32 0xf1e0 +#define AMX_MAGIC_64 0xf1e1 +#if PAWN_CELL_SIZE==16 + #define AMX_MAGIC AMX_MAGIC_16 +#elif PAWN_CELL_SIZE==32 + #define AMX_MAGIC AMX_MAGIC_32 +#elif PAWN_CELL_SIZE==64 + #define AMX_MAGIC AMX_MAGIC_64 +#endif + +enum { + AMX_ERR_NONE, + /* reserve the first 15 error codes for exit codes of the abstract machine */ + AMX_ERR_EXIT, /* forced exit */ + AMX_ERR_ASSERT, /* assertion failed */ + AMX_ERR_STACKERR, /* stack/heap collision */ + AMX_ERR_BOUNDS, /* index out of bounds */ + AMX_ERR_MEMACCESS, /* invalid memory access */ + AMX_ERR_INVINSTR, /* invalid instruction */ + AMX_ERR_STACKLOW, /* stack underflow */ + AMX_ERR_HEAPLOW, /* heap underflow */ + AMX_ERR_CALLBACK, /* no callback, or invalid callback */ + AMX_ERR_NATIVE, /* native function failed */ + AMX_ERR_DIVIDE, /* divide by zero */ + AMX_ERR_SLEEP, /* go into sleepmode - code can be restarted */ + AMX_ERR_INVSTATE, /* no implementation for this state, no fall-back */ + + AMX_ERR_MEMORY = 16, /* out of memory */ + AMX_ERR_FORMAT, /* invalid file format */ + AMX_ERR_VERSION, /* file is for a newer version of the AMX */ + AMX_ERR_NOTFOUND, /* function not found */ + AMX_ERR_INDEX, /* invalid index parameter (bad entry point) */ + AMX_ERR_DEBUG, /* debugger cannot run */ + AMX_ERR_INIT, /* AMX not initialized (or doubly initialized) */ + AMX_ERR_USERDATA, /* unable to set user data field (table full) */ + AMX_ERR_INIT_JIT, /* cannot initialize the JIT */ + AMX_ERR_PARAMS, /* parameter error */ + AMX_ERR_DOMAIN, /* domain error, expression result does not fit in range */ + AMX_ERR_GENERAL, /* general error (unknown or unspecific error) */ + AMX_ERR_OVERLAY, /* overlays are unsupported (JIT) or uninitialized */ +}; + +#define AMX_FLAG_OVERLAY 0x01 /* all function calls use overlays */ +#define AMX_FLAG_DEBUG 0x02 /* symbolic info. available */ +#define AMX_FLAG_NOCHECKS 0x04 /* no array bounds checking; no BREAK opcodes */ +#define AMX_FLAG_SLEEP 0x08 /* script uses the sleep instruction (possible re-entry or power-down mode) */ +#define AMX_FLAG_CRYPT 0x10 /* file is encrypted */ +#define AMX_FLAG_DSEG_INIT 0x20 /* data section is explicitly initialized */ +#define AMX_FLAG_SYSREQN 0x800 /* script uses new (optimized) version of SYSREQ opcode */ +#define AMX_FLAG_NTVREG 0x1000 /* all native functions are registered */ +#define AMX_FLAG_JITC 0x2000 /* abstract machine is JIT compiled */ +#define AMX_FLAG_VERIFY 0x4000 /* busy verifying P-code */ +#define AMX_FLAG_INIT 0x8000 /* AMX has been initialized */ + +#define AMX_EXEC_MAIN (-1) /* start at program entry point */ +#define AMX_EXEC_CONT (-2) /* continue from last address */ + +#define AMX_USERTAG(a,b,c,d) ((a) | ((b)<<8) | ((long)(c)<<16) | ((long)(d)<<24)) + +/* for native functions that use floating point parameters, the following + * two macros are convenient for casting a "cell" into a "float" type _without_ + * changing the bit pattern + */ +#if PAWN_CELL_SIZE==32 + #define amx_ftoc(f) ( * ((cell*)&f) ) /* float to cell */ + #define amx_ctof(c) ( * ((float*)&c) ) /* cell to float */ +#elif PAWN_CELL_SIZE==64 + #define amx_ftoc(f) ( * ((cell*)&f) ) /* float to cell */ + #define amx_ctof(c) ( * ((double*)&c) ) /* cell to float */ +#else + // amx_ftoc() and amx_ctof() cannot be used +#endif + +/* when a pointer cannot be stored in a cell, cells that hold relocated + * addresses need to be expanded + */ +#if defined __64BIT__ && PAWN_CELL_SIZE<64 + #define CELLMASK (((int64_t)1 << PAWN_CELL_SIZE) - 1) + #define amx_Address(amx,addr) \ + (cell*)(((int64_t)((amx)->data ? (amx)->data : (amx)->code) & ~CELLMASK) | ((int64_t)(addr) & CELLMASK)) +#elif defined __32BIT__ && PAWN_CELL_SIZE<32 + #define CELLMASK ((1L << PAWN_CELL_SIZE) - 1) + #define amx_Address(amx,addr) \ + (cell*)(((int32_t)((amx)->data ? (amx)->data : (amx)->code) & ~CELLMASK) | ((int32_t)(addr) & CELLMASK)) +#else + #define amx_Address(amx,addr) ((void)(amx),(cell*)(addr)) +#endif + +#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L + /* C99: use variable-length arrays */ + #define amx_StrParam_Type(amx,param,result,type) \ + int result##_length_; \ + amx_StrLen(amx_Address(amx,param),&result##_length_); \ + char result##_vla_[(result##_length_+1)*sizeof(*(result))]; \ + (result)=(type)result##_vla_; \ + amx_GetString((char*)(result),amx_Address(amx,param), \ + sizeof(*(result))>1,result##_length_+1) + #define amx_StrParam(amx,param,result) \ + amx_StrParam_Type(amx,param,result,void*) +#else + /* macro using alloca() */ + #define amx_StrParam_Type(amx,param,result,type) \ + do { \ + int result##_length_; \ + amx_StrLen(amx_Address(amx,param),&result##_length_); \ + if (result##_length_>0 && \ + ((result)=(type)alloca((result##_length_+1)*sizeof(*(result))))!=NULL) \ + amx_GetString((char*)(result),amx_Address(amx,param), \ + sizeof(*(result))>1,result##_length_+1); \ + else (result) = NULL; \ + } while (0) + #define amx_StrParam(amx,param,result) \ + amx_StrParam_Type(amx,param,result,void*) +#endif + +uint16_t * AMXAPI amx_Align16(uint16_t *v); +uint32_t * AMXAPI amx_Align32(uint32_t *v); +#if defined _I64_MAX || defined INT64_MAX || defined HAVE_I64 + uint64_t * AMXAPI amx_Align64(uint64_t *v); +#endif +int AMXAPI amx_Allot(AMX *amx, int cells, cell **address); +int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, const cell *params); +int AMXAPI amx_Cleanup(AMX *amx); +int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data); +int AMXAPI amx_Exec(AMX *amx, cell *retval, int index); +int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index); +int AMXAPI amx_FindPublic(AMX *amx, const char *name, int *index); +int AMXAPI amx_FindPubVar(AMX *amx, const char *name, cell **address); +int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname); +int AMXAPI amx_Flags(AMX *amx,uint16_t *flags); +int AMXAPI amx_GetNative(AMX *amx, int index, char *name); +int AMXAPI amx_GetPublic(AMX *amx, int index, char *name, ucell *address); +int AMXAPI amx_GetPubVar(AMX *amx, int index, char *name, cell **address); +int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar, size_t size); +int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id); +int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr); +int AMXAPI amx_Init(AMX *amx, void *program); +int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code); +int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap); +int AMXAPI amx_NameLength(AMX *amx, int *length); +AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name, AMX_NATIVE func); +int AMXAPI amx_NumNatives(AMX *amx, int *number); +int AMXAPI amx_NumPublics(AMX *amx, int *number); +int AMXAPI amx_NumPubVars(AMX *amx, int *number); +int AMXAPI amx_NumTags(AMX *amx, int *number); +int AMXAPI amx_Push(AMX *amx, cell value); +int AMXAPI amx_PushAddress(AMX *amx, cell *address); +int AMXAPI amx_PushArray(AMX *amx, cell **address, const cell array[], int numcells); +int AMXAPI amx_PushString(AMX *amx, cell **address, const char *string, int pack, int use_wchar); +int AMXAPI amx_RaiseError(AMX *amx, int error); +int AMXAPI amx_Register(AMX *amx, const AMX_NATIVE_INFO *nativelist, int number); +int AMXAPI amx_Release(AMX *amx, cell *address); +int AMXAPI amx_SetCallback(AMX *amx, AMX_CALLBACK callback); +int AMXAPI amx_SetDebugHook(AMX *amx, AMX_DEBUG debug); +int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar, size_t size); +int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr); +int AMXAPI amx_StrLen(const cell *cstring, int *length); +int AMXAPI amx_UTF8Check(const char *string, int *length); +int AMXAPI amx_UTF8Get(const char *string, const char **endptr, cell *value); +int AMXAPI amx_UTF8Len(const cell *cstr, int *length); +int AMXAPI amx_UTF8Put(char *string, char **endptr, int maxchars, cell value); + +#if PAWN_CELL_SIZE==16 + #define amx_AlignCell(v) amx_Align16(v) +#elif PAWN_CELL_SIZE==32 + #define amx_AlignCell(v) amx_Align32(v) +#elif PAWN_CELL_SIZE==64 && (defined _I64_MAX || defined INT64_MAX || defined HAVE_I64) + #define amx_AlignCell(v) amx_Align64(v) +#else + #error Unsupported cell size +#endif + +#define amx_RegisterFunc(amx, name, func) \ + amx_Register((amx), amx_NativeInfo((name),(func)), 1); + +#if !defined AMX_NO_ALIGN + #if defined __LINUX__ || defined __FreeBSD__ + #pragma pack() /* reset default packing */ + #elif defined MACOS && defined __MWERKS__ + #pragma options align=reset + #else + #pragma pack(pop) /* reset previous packing */ + #endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* AMX_H_INCLUDED */