/***************************************************************************** * * * The breve Simulation Environment * * Copyright (C) 2000, 2001, 2002, 2003 Jonathan Klein * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * * 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 General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the Free Software * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * *****************************************************************************/ #include #include #include #include // The breve Simulation Environment plugin API version 2.4 // // Documentation on using the breve plugin API is included in // the documentation distributed with breve. // These are deprecated symbol names, included here for backwards compatability #define stNewBreveCall brNewBreveCall #define stNewSteveCall brNewBreveCall #define stEval brEval #define stHash brEvalHash #define stEvalList brEvalList #define stEvalListHead brEvalListHead #define stNewEvalList() (new brEvalListHead()) #define brEvalListNew() (new brEvalListHead()) #define stPluginFindFile brPluginFindFile #define STINT BRINT #define STFLOAT BRFLOAT #define STDOUBLE BRDOUBLE #define STSTRING BRSTRING #define STVECTOR BRVECTOR #define STMATRIX BRMATRIX #define STINSTANCE BRINSTANCE #define STPOINTER BRPOINTER #define STDATA BRDATA #define STHASH BRHASH #define STLIST BRLIST #include #include /* Plugin entry-point functions should be declared as DLLEXPORT */ #if defined(_MSC_VER) || defined(__WIN32__) || defined(WINDOWS) #ifdef __cplusplus #define DLLEXPORT extern "C" __declspec(dllexport) #else #define DLLEXPORT __declspec(dllexport) #endif #elif defined(__cplusplus) #define DLLEXPORT extern "C" #else #define DLLEXPORT extern #endif typedef struct slVector slVector; typedef struct brEval brEval; typedef struct brEvalListHead brEvalListHead; typedef struct brEvalList brEvalList; typedef struct brEvalHash brEvalHash; typedef struct brData brData; typedef struct stInstance stInstance; typedef struct brInstance brInstance; // These entries appear in the brEval type field. enum atomicTypes { AT_INVALID = 0, AT_NULL, AT_INT, AT_DOUBLE, AT_STRING, AT_INSTANCE, AT_POINTER, AT_VECTOR, AT_MATRIX, AT_LIST, AT_ARRAY, AT_DATA, AT_HASH, AT_TYPE, AT_UNDEFINED }; struct slVector { double x, y, z; }; typedef double slMatrix[3][3]; #ifdef __cplusplus extern "C" { #endif void stGCUnretainAndCollectPointer(void *pointer, int type); void stGCRetainPointer(void *pointer, int type); class brEval { public: brEval() { _type = AT_NULL; } ~brEval() { collect(); } inline void collect() { if ( _type == AT_NULL || _type == AT_INT || _type == AT_MATRIX || _type == AT_VECTOR || _type == AT_DOUBLE ) return; stGCUnretainAndCollectPointer( _values.pointerValue, _type ); } inline void retain() { if ( _type == AT_NULL || _type == AT_INT || _type == AT_MATRIX || _type == AT_VECTOR || _type == AT_DOUBLE ) return; stGCRetainPointer( _values.pointerValue, _type ); } void clear() { collect(); _type = AT_NULL; } inline unsigned char type() { return _type; } inline void set( const double d ) { collect(); _values.doubleValue = d; _type = AT_DOUBLE; } inline void set( const int i ) { collect(); _values.intValue = i; _type = AT_INT; } inline void set( const slVector &v ) { collect(); memcpy(&_values.vectorValue, &v, sizeof( slVector ) ); _type = AT_VECTOR; } inline void set( const slMatrix &m ) { collect(); memcpy( _values.matrixValue, m, sizeof( slMatrix ) ); _type = AT_MATRIX; } inline void set( const char *s ) { collect(); _values.stringValue = strdup(s); _type = AT_STRING; } inline void set( void *p ) { collect(); _values.pointerValue = p; _type = AT_POINTER; retain(); } inline void set( brEvalHash *h ) { collect(); _values.hashValue = h; _type = AT_HASH; retain(); } inline void set( brData *d ) { collect(); _values.dataValue = d; _type = AT_DATA; retain(); } inline void set( brInstance *i ) { collect(); _values.instanceValue = i; _type = AT_INSTANCE; retain(); } inline void set( brEvalListHead *l ) { collect(); _values.listValue = l; _type = AT_LIST; retain(); } inline int &getInt() { return _values.intValue; } inline double &getDouble() { return _values.doubleValue; } inline slVector &getVector() { return _values.vectorValue; } inline slMatrix &getMatrix() { return _values.matrixValue; } inline void* &getPointer() { return _values.pointerValue; } inline char* &getString() { return _values.stringValue; } inline brEvalHash* &getHash() { return _values.hashValue; } inline brData* &getData() { return _values.dataValue; } inline brInstance* &getInstance() { return _values.instanceValue; } inline brEvalListHead* &getList() { return _values.listValue; } private: union { double doubleValue; int intValue; slVector vectorValue; slMatrix matrixValue; void *pointerValue; char *stringValue; brEvalHash *hashValue; brData *dataValue; brInstance *instanceValue; brEvalListHead *listValue; } _values; unsigned char _type; }; class brEvalObject { public: brEvalObject(); virtual ~brEvalObject(); int _retainCount; void retain(); void unretain(); void collect(); }; class brEvalListHead: public brEvalObject { public: brEvalListHead(); ~brEvalListHead(); std::vector< brEval* > _vector; inline std::vector< brEval* > &getVector() { return _vector; } }; class brData: public brEvalObject { public: brData( void *inData, int inLength ); ~brData(); unsigned char *data; int length; }; brData *brDataNew(void *data, int length); void brDataFree(brData *data); /* The following functions are used to create & edit evaluation lists. You can create brEvalLists to be returned by your functions. Don't worry about freeing brEvalLists, this is done by the engine. */ int brEvalListInsert( brEvalListHead *head, int index, brEval *value ); #define brEvalListAppend( a, eval ) brEvalListInsert( (a), (a)->_vector.size(), (eval) ) /* Use these macros to treat brEval pointers as specific types. */ #define BRINT(e) ( (e)->getInt() ) #define BRFLOAT(e) ( (e)->getDouble() ) #define BRDOUBLE(e) ( (e)->getDouble() ) #define BRSTRING(e) ( (e)->getString() ) #define BRVECTOR(e) ( (e)->getVector() ) #define BRMATRIX(e) ( (e)->getMatrix() ) #define BRINSTANCE(e) ( (e)->getInstance() ) #define BRPOINTER(e) ( (e)->getPointer() ) #define BRDATA(e) ( (e)->getData() ) #define BRHASH(e) ( (e)->getHash() ) #define BRLIST(e) ( (e)->getList() ) #define EC_ERROR -1 #define EC_OK 1 int brNewBreveCall(void *n, char *name, int (*call)(brEval argumentArray[], brEval *returnValue, void *callingInstance), int rtype, ...); /* * The brMethodCallByNameWithArgs() function calls the breve method * named by the string _name_ with _argcount_ number of arguments * in the array pointed to by _args_ and stores the return value of the * method (if any) in the brEval pointed to by _result_. * * The function returns EC_OK if successful. * If an error occurs while calling the specified method, EC_ERROR is * returned and the simulation is halted. */ // int brMethodCallByNameWithArgs(void *instance, char *name, brEval **args, int count, brEval *result); /* * The slMessage() function prints a formatted error message to the * breve console. The _level_ argument must always be DEBUG_ALL. * The _fmt_ specification (and associated arguments) may be any format * allowed by printf(3) or a simple string. */ #define DEBUG_ALL 0 void slMessage(int level, const char *fmt, ...); /* * Macros for obsolete functions. */ #define slMalloc(n) calloc(1,n) #define slRealloc(p,n) realloc(p,n) #define slFree(p) free(p) /* * The slStrdup() function allocates space for a copy of the string * pointed to by _s_, copies the string, and a returns a pointer * to the copied string. The returned pointer may subsequently be * used as an argument to the slFree() and slRealloc() functions. * * If the string cannot be copied, NULL is returned. */ char *slStrdup(const char *s); /* * The slGetLogFilePointer() function returns a FILE pointer * referring to the breve output log, typically stderr. */ FILE *slGetLogFilePointer(void *callingInstance); /* * The brPluginFindFile() function finds a file in the engine's * search path and returns the pathname to that file. * * The returned pointer, if it is not NULL, should be deallocated * with slFree() when it is no longer needed by the plugin. */ char *brPluginFindFile(char *file, void *callingInstance); #ifdef __cplusplus } #endif