runtime: CMake-ify
This commit is contained in:
Michael Fabian 'Xaymar' Dirks
@@ -0,0 +1,593 @@
|
||||
#include "std.hpp"
|
||||
#include "bbsys.hpp"
|
||||
|
||||
//how many strings allocated
|
||||
static int stringCnt;
|
||||
|
||||
//how many objects new'd but not deleted
|
||||
static int objCnt;
|
||||
|
||||
//how many objects deleted but not released
|
||||
static int unrelObjCnt;
|
||||
|
||||
//how many objects to alloc per block
|
||||
static const int OBJ_NEW_INC = 512;
|
||||
|
||||
//how many strings to alloc per block
|
||||
static const int STR_NEW_INC = 512;
|
||||
|
||||
//current data ptr
|
||||
static BBData *dataPtr;
|
||||
|
||||
//chunks of mem - WHAT THE FUCK WAS I ON?!?!?!?
|
||||
//static list<char*> memBlks;
|
||||
|
||||
//strings
|
||||
static BBStr usedStrs, freeStrs;
|
||||
|
||||
//object handle number
|
||||
static int next_handle;
|
||||
|
||||
//object<->handle maps
|
||||
static map<int, BBObj*> handle_map;
|
||||
static map<BBObj*, int> object_map;
|
||||
|
||||
static BBType _bbIntType(BBTYPE_INT);
|
||||
static BBType _bbFltType(BBTYPE_FLT);
|
||||
static BBType _bbStrType(BBTYPE_STR);
|
||||
static BBType _bbCStrType(BBTYPE_CSTR);
|
||||
|
||||
static void *bbMalloc(int size) {
|
||||
return malloc(size);
|
||||
/*
|
||||
char *c=new char[ size ];
|
||||
memBlks.push_back( c );
|
||||
return c;
|
||||
*/
|
||||
}
|
||||
|
||||
static void bbFree(void *q) {
|
||||
free(q);
|
||||
/*
|
||||
if( !q ) return;
|
||||
char *c=(char*)q;
|
||||
memBlks.remove( c );
|
||||
delete [] c;
|
||||
*/
|
||||
}
|
||||
|
||||
static void removeStr(BBStr *str) {
|
||||
str->next->prev = str->prev;
|
||||
str->prev->next = str->next;
|
||||
}
|
||||
|
||||
static void insertStr(BBStr *str, BBStr *next) {
|
||||
str->next = next;
|
||||
str->prev = next->prev;
|
||||
str->prev->next = str;
|
||||
next->prev = str;
|
||||
}
|
||||
|
||||
void *BBStr::operator new(size_t size) {
|
||||
if (freeStrs.next == &freeStrs) {
|
||||
BBStr *t = (BBStr*)bbMalloc(sizeof(BBStr)*STR_NEW_INC);
|
||||
for (int k = 0; k < STR_NEW_INC; ++k) insertStr(t++, &freeStrs);
|
||||
}
|
||||
BBStr *t = freeStrs.next;
|
||||
removeStr(t); insertStr(t, &usedStrs);
|
||||
return t;
|
||||
}
|
||||
|
||||
void BBStr::operator delete(void *q) {
|
||||
if (!q) return;
|
||||
BBStr *t = (BBStr*)q;
|
||||
removeStr(t); insertStr(t, &freeStrs);
|
||||
}
|
||||
|
||||
BBStr::BBStr() {
|
||||
++stringCnt;
|
||||
}
|
||||
|
||||
BBStr::BBStr(const char *s) :string(s) {
|
||||
++stringCnt;
|
||||
}
|
||||
|
||||
BBStr::BBStr(const char *s, int n) : string(s, n) {
|
||||
++stringCnt;
|
||||
}
|
||||
|
||||
BBStr::BBStr(const BBStr &s) : string(s) {
|
||||
++stringCnt;
|
||||
}
|
||||
|
||||
BBStr::BBStr(const string &s) : string(s) {
|
||||
++stringCnt;
|
||||
}
|
||||
|
||||
BBStr &BBStr::operator=(const char *s) {
|
||||
string::operator=(s); return *this;
|
||||
}
|
||||
|
||||
BBStr &BBStr::operator=(const BBStr &s) {
|
||||
string::operator=(s); return *this;
|
||||
}
|
||||
|
||||
BBStr &BBStr::operator=(const string &s) {
|
||||
string::operator=(s); return *this;
|
||||
}
|
||||
|
||||
BBStr::~BBStr() {
|
||||
--stringCnt;
|
||||
}
|
||||
|
||||
BBStr *_bbStrLoad(BBStr **var) {
|
||||
return *var ? new BBStr(**var) : new BBStr();
|
||||
}
|
||||
|
||||
void _bbStrRelease(BBStr *str) {
|
||||
delete str;
|
||||
}
|
||||
|
||||
void _bbStrStore(BBStr **var, BBStr *str) {
|
||||
_bbStrRelease(*var); *var = str;
|
||||
}
|
||||
|
||||
BBStr *_bbStrConcat(BBStr *s1, BBStr *s2) {
|
||||
*s1 += *s2; delete s2; return s1;
|
||||
}
|
||||
|
||||
int _bbStrCompare(BBStr *lhs, BBStr *rhs) {
|
||||
int n = lhs->compare(*rhs);
|
||||
delete lhs; delete rhs; return n;
|
||||
}
|
||||
|
||||
int _bbStrToInt(BBStr *s) {
|
||||
int n = atoi(*s);
|
||||
delete s; return n;
|
||||
}
|
||||
|
||||
BBStr *_bbStrFromInt(int n) {
|
||||
return new BBStr(itoa(n));
|
||||
}
|
||||
|
||||
float _bbStrToFloat(BBStr *s) {
|
||||
float n = (float)atof(*s);
|
||||
delete s; return n;
|
||||
}
|
||||
|
||||
BBStr *_bbStrFromFloat(float n) {
|
||||
return new BBStr(ftoa(n));
|
||||
}
|
||||
|
||||
BBStr *_bbStrConst(const char *s) {
|
||||
return new BBStr(s);
|
||||
}
|
||||
|
||||
void * _bbVecAlloc(BBVecType *type) {
|
||||
void *vec = bbMalloc(type->size * 4);
|
||||
memset(vec, 0, type->size * 4);
|
||||
return vec;
|
||||
}
|
||||
|
||||
void _bbVecFree(void *vec, BBVecType *type) {
|
||||
if (type->elementType->type == BBTYPE_STR) {
|
||||
BBStr **p = (BBStr**)vec;
|
||||
for (int k = 0; k < type->size; ++p, ++k) {
|
||||
if (*p) _bbStrRelease(*p);
|
||||
}
|
||||
} else if (type->elementType->type == BBTYPE_OBJ) {
|
||||
BBObj **p = (BBObj**)vec;
|
||||
for (int k = 0; k < type->size; ++p, ++k) {
|
||||
if (*p) _bbObjRelease(*p);
|
||||
}
|
||||
}
|
||||
bbFree(vec);
|
||||
}
|
||||
|
||||
void _bbVecBoundsEx() {
|
||||
ThrowRuntimeException("Blitz array index out of bounds");
|
||||
}
|
||||
|
||||
void _bbUndimArray(BBArray *array) {
|
||||
if (void *t = array->data) {
|
||||
if (array->elementType == BBTYPE_STR) {
|
||||
BBStr **p = (BBStr**)t;
|
||||
int size = array->scales[array->dims - 1];
|
||||
for (int k = 0; k < size; ++p, ++k) {
|
||||
if (*p) _bbStrRelease(*p);
|
||||
}
|
||||
} else if (array->elementType == BBTYPE_OBJ) {
|
||||
BBObj **p = (BBObj**)t;
|
||||
int size = array->scales[array->dims - 1];
|
||||
for (int k = 0; k < size; ++p, ++k) {
|
||||
if (*p) _bbObjRelease(*p);
|
||||
}
|
||||
}
|
||||
bbFree(t);
|
||||
array->data = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void _bbDimArray(BBArray *array) {
|
||||
int k;
|
||||
for (k = 0; k < array->dims; ++k) ++array->scales[k];
|
||||
for (k = 1; k < array->dims; ++k) {
|
||||
array->scales[k] *= array->scales[k - 1];
|
||||
}
|
||||
int size = array->scales[array->dims - 1];
|
||||
array->data = bbMalloc(size * 4);
|
||||
memset(array->data, 0, size * 4);
|
||||
}
|
||||
|
||||
void _bbArrayBoundsEx() {
|
||||
ThrowRuntimeException("Array index out of bounds");
|
||||
}
|
||||
|
||||
static void unlinkObj(BBObj *obj) {
|
||||
obj->next->prev = obj->prev;
|
||||
obj->prev->next = obj->next;
|
||||
}
|
||||
|
||||
static void insertObj(BBObj *obj, BBObj *next) {
|
||||
obj->next = next;
|
||||
obj->prev = next->prev;
|
||||
next->prev->next = obj;
|
||||
next->prev = obj;
|
||||
}
|
||||
|
||||
BBObj *_bbObjNew(BBObjType *type) {
|
||||
if (type->free.next == &type->free) {
|
||||
int obj_size = sizeof(BBObj) + type->fieldCnt * 4;
|
||||
BBObj *o = (BBObj*)bbMalloc(obj_size*OBJ_NEW_INC);
|
||||
for (int k = 0; k < OBJ_NEW_INC; ++k) {
|
||||
insertObj(o, &type->free);
|
||||
o = (BBObj*)((char*)o + obj_size);
|
||||
}
|
||||
}
|
||||
BBObj *o = type->free.next;
|
||||
unlinkObj(o);
|
||||
o->type = type;
|
||||
o->ref_cnt = 1;
|
||||
o->fields = (BBField*)(o + 1);
|
||||
for (int k = 0; k < type->fieldCnt; ++k) {
|
||||
switch (type->fieldTypes[k]->type) {
|
||||
case BBTYPE_VEC:
|
||||
o->fields[k].VEC = _bbVecAlloc((BBVecType*)type->fieldTypes[k]);
|
||||
break;
|
||||
default:
|
||||
o->fields[k].INT = 0;
|
||||
}
|
||||
}
|
||||
insertObj(o, &type->used);
|
||||
++unrelObjCnt;
|
||||
++objCnt;
|
||||
return o;
|
||||
}
|
||||
|
||||
void _bbObjDelete(BBObj *obj) {
|
||||
if (!obj) return;
|
||||
BBField *fields = obj->fields;
|
||||
if (!fields) return;
|
||||
BBObjType *type = obj->type;
|
||||
for (int k = 0; k < type->fieldCnt; ++k) {
|
||||
switch (type->fieldTypes[k]->type) {
|
||||
case BBTYPE_STR:
|
||||
_bbStrRelease(fields[k].STR);
|
||||
break;
|
||||
case BBTYPE_OBJ:
|
||||
_bbObjRelease(fields[k].OBJ);
|
||||
break;
|
||||
case BBTYPE_VEC:
|
||||
_bbVecFree(fields[k].VEC, (BBVecType*)type->fieldTypes[k]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
map<BBObj*, int>::iterator it = object_map.find(obj);
|
||||
if (it != object_map.end()) {
|
||||
handle_map.erase(it->second);
|
||||
object_map.erase(it);
|
||||
}
|
||||
obj->fields = 0;
|
||||
_bbObjRelease(obj);
|
||||
--objCnt;
|
||||
}
|
||||
|
||||
void _bbObjDeleteEach(BBObjType *type) {
|
||||
BBObj *obj = type->used.next;
|
||||
while (obj->type) {
|
||||
BBObj *next = obj->next;
|
||||
if (obj->fields) _bbObjDelete(obj);
|
||||
obj = next;
|
||||
}
|
||||
}
|
||||
|
||||
extern void bbDebugLog(BBStr *t);
|
||||
extern void bbStop();
|
||||
|
||||
void _bbObjRelease(BBObj *obj) {
|
||||
if (!obj || --obj->ref_cnt) return;
|
||||
unlinkObj(obj);
|
||||
insertObj(obj, &obj->type->free);
|
||||
--unrelObjCnt;
|
||||
}
|
||||
|
||||
void _bbObjStore(BBObj **var, BBObj *obj) {
|
||||
if (obj) ++obj->ref_cnt; //do this first incase of self-assignment
|
||||
_bbObjRelease(*var);
|
||||
*var = obj;
|
||||
}
|
||||
|
||||
int _bbObjCompare(BBObj *o1, BBObj *o2) {
|
||||
return (o1 ? o1->fields : 0) != (o2 ? o2->fields : 0);
|
||||
}
|
||||
|
||||
BBObj *_bbObjNext(BBObj *obj) {
|
||||
do {
|
||||
obj = obj->next;
|
||||
if (!obj->type) return 0;
|
||||
} while (!obj->fields);
|
||||
return obj;
|
||||
}
|
||||
|
||||
BBObj *_bbObjPrev(BBObj *obj) {
|
||||
do {
|
||||
obj = obj->prev;
|
||||
if (!obj->type) return 0;
|
||||
} while (!obj->fields);
|
||||
return obj;
|
||||
}
|
||||
|
||||
BBObj *_bbObjFirst(BBObjType *type) {
|
||||
return _bbObjNext(&type->used);
|
||||
}
|
||||
|
||||
BBObj *_bbObjLast(BBObjType *type) {
|
||||
return _bbObjPrev(&type->used);
|
||||
}
|
||||
|
||||
void _bbObjInsBefore(BBObj *o1, BBObj *o2) {
|
||||
if (o1 == o2) return;
|
||||
unlinkObj(o1);
|
||||
insertObj(o1, o2);
|
||||
}
|
||||
|
||||
void _bbObjInsAfter(BBObj *o1, BBObj *o2) {
|
||||
if (o1 == o2) return;
|
||||
unlinkObj(o1);
|
||||
insertObj(o1, o2->next);
|
||||
}
|
||||
|
||||
int _bbObjEachFirst(BBObj **var, BBObjType *type) {
|
||||
_bbObjStore(var, _bbObjFirst(type));
|
||||
return *var != 0;
|
||||
}
|
||||
|
||||
int _bbObjEachNext(BBObj **var) {
|
||||
_bbObjStore(var, _bbObjNext(*var));
|
||||
return *var != 0;
|
||||
}
|
||||
|
||||
int _bbObjEachFirst2(BBObj **var, BBObjType *type) {
|
||||
*var = _bbObjFirst(type);
|
||||
return *var != 0;
|
||||
}
|
||||
|
||||
int _bbObjEachNext2(BBObj **var) {
|
||||
*var = _bbObjNext(*var);
|
||||
return *var != 0;
|
||||
}
|
||||
|
||||
BBStr *_bbObjToStr(BBObj *obj) {
|
||||
if (!obj || !obj->fields) return new BBStr("[NULL]");
|
||||
|
||||
static BBObj *root;
|
||||
static int recurs_cnt;
|
||||
|
||||
if (obj == root) return new BBStr("[ROOT]");
|
||||
if (recurs_cnt == 8) return new BBStr("....");
|
||||
|
||||
++recurs_cnt;
|
||||
BBObj *oldRoot = root;
|
||||
if (!root) root = obj;
|
||||
|
||||
BBObjType *type = obj->type;
|
||||
BBField *fields = obj->fields;
|
||||
BBStr *s = new BBStr("["), *t;
|
||||
for (int k = 0; k < type->fieldCnt; ++k) {
|
||||
if (k) *s += ',';
|
||||
switch (type->fieldTypes[k]->type) {
|
||||
case BBTYPE_INT:
|
||||
t = _bbStrFromInt(fields[k].INT); *s += *t; delete t;
|
||||
break;
|
||||
case BBTYPE_FLT:
|
||||
t = _bbStrFromFloat(fields[k].FLT); *s += *t; delete t;
|
||||
break;
|
||||
case BBTYPE_STR:
|
||||
if (fields[k].STR) *s += '\"' + *fields[k].STR + '\"';
|
||||
else *s += "\"\"";
|
||||
break;
|
||||
case BBTYPE_OBJ:
|
||||
t = _bbObjToStr(fields[k].OBJ); *s += *t; delete t;
|
||||
break;
|
||||
default:
|
||||
*s += "???";
|
||||
}
|
||||
}
|
||||
*s += ']';
|
||||
root = oldRoot;
|
||||
--recurs_cnt;
|
||||
return s;
|
||||
}
|
||||
|
||||
int _bbObjToHandle(BBObj *obj) {
|
||||
if (!obj || !obj->fields) return 0;
|
||||
map<BBObj*, int>::const_iterator it = object_map.find(obj);
|
||||
if (it != object_map.end()) return it->second;
|
||||
++next_handle;
|
||||
object_map[obj] = next_handle;
|
||||
handle_map[next_handle] = obj;
|
||||
return next_handle;
|
||||
}
|
||||
|
||||
BBObj *_bbObjFromHandle(int handle, BBObjType *type) {
|
||||
map<int, BBObj*>::const_iterator it = handle_map.find(handle);
|
||||
if (it == handle_map.end()) return 0;
|
||||
BBObj *obj = it->second;
|
||||
return obj->type == type ? obj : 0;
|
||||
}
|
||||
|
||||
void _bbNullObjEx() {
|
||||
ThrowRuntimeException("Object does not exist");
|
||||
}
|
||||
|
||||
void _bbRestore(BBData *data) {
|
||||
dataPtr = data;
|
||||
}
|
||||
|
||||
int _bbReadInt() {
|
||||
switch (dataPtr->fieldType) {
|
||||
case BBTYPE_END:ThrowRuntimeException("Out of data"); return 0;
|
||||
case BBTYPE_INT:return dataPtr++->field.INT;
|
||||
case BBTYPE_FLT:return dataPtr++->field.FLT;
|
||||
case BBTYPE_CSTR:return atoi(dataPtr++->field.CSTR);
|
||||
default:ThrowRuntimeException("Bad data type"); return 0;
|
||||
}
|
||||
}
|
||||
|
||||
float _bbReadFloat() {
|
||||
switch (dataPtr->fieldType) {
|
||||
case BBTYPE_END:ThrowRuntimeException("Out of data"); return 0;
|
||||
case BBTYPE_INT:return dataPtr++->field.INT;
|
||||
case BBTYPE_FLT:return dataPtr++->field.FLT;
|
||||
case BBTYPE_CSTR:return atof(dataPtr++->field.CSTR);
|
||||
default:ThrowRuntimeException("Bad data type"); return 0;
|
||||
}
|
||||
}
|
||||
|
||||
BBStr *_bbReadStr() {
|
||||
switch (dataPtr->fieldType) {
|
||||
case BBTYPE_END:ThrowRuntimeException("Out of data"); return 0;
|
||||
case BBTYPE_INT:return new BBStr(itoa(dataPtr++->field.INT));
|
||||
case BBTYPE_FLT:return new BBStr(ftoa(dataPtr++->field.FLT));
|
||||
case BBTYPE_CSTR:return new BBStr(dataPtr++->field.CSTR);
|
||||
default:ThrowRuntimeException("Bad data type"); return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int _bbAbs(int n) {
|
||||
return n >= 0 ? n : -n;
|
||||
}
|
||||
|
||||
int _bbSgn(int n) {
|
||||
return n > 0 ? 1 : (n < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
int _bbMod(int x, int y) {
|
||||
return x%y;
|
||||
}
|
||||
|
||||
float _bbFAbs(float n) {
|
||||
return n >= 0 ? n : -n;
|
||||
}
|
||||
|
||||
float _bbFSgn(float n) {
|
||||
return n > 0 ? 1 : (n < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
float _bbFMod(float x, float y) {
|
||||
return (float)fmod(x, y);
|
||||
}
|
||||
|
||||
float _bbFPow(float x, float y) {
|
||||
return (float)pow(x, y);
|
||||
}
|
||||
|
||||
void bbRuntimeStats() {
|
||||
gx_runtime->debugLog(("Active strings :" + itoa(stringCnt)).c_str());
|
||||
gx_runtime->debugLog(("Active objects :" + itoa(objCnt)).c_str());
|
||||
gx_runtime->debugLog(("Unreleased objs:" + itoa(unrelObjCnt)).c_str());
|
||||
/*
|
||||
clog<<"Active strings:"<<stringCnt<<endl;
|
||||
clog<<"Active objects:"<<objCnt<<endl;
|
||||
clog<<"Unreleased Objects:"<<unrelObjCnt<<endl;
|
||||
for( BBStr *t=usedStrs.next;t!=&usedStrs;t=t->next ){
|
||||
clog<<"string@"<<(void*)t<<endl;
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
bool basic_create() {
|
||||
next_handle = 0;
|
||||
// memBlks.clear();
|
||||
handle_map.clear();
|
||||
object_map.clear();
|
||||
stringCnt = objCnt = unrelObjCnt = 0;
|
||||
usedStrs.next = usedStrs.prev = &usedStrs;
|
||||
freeStrs.next = freeStrs.prev = &freeStrs;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool basic_destroy() {
|
||||
while (usedStrs.next != &usedStrs) delete usedStrs.next;
|
||||
// while( memBlks.size() ) bbFree( memBlks.back() );
|
||||
handle_map.clear();
|
||||
object_map.clear();
|
||||
return true;
|
||||
}
|
||||
|
||||
void basic_link(void(*rtSym)(const char *sym, void *pc)) {
|
||||
|
||||
rtSym("_bbIntType", &_bbIntType);
|
||||
rtSym("_bbFltType", &_bbFltType);
|
||||
rtSym("_bbStrType", &_bbStrType);
|
||||
rtSym("_bbCStrType", &_bbCStrType);
|
||||
|
||||
rtSym("_bbStrLoad", _bbStrLoad);
|
||||
rtSym("_bbStrRelease", _bbStrRelease);
|
||||
rtSym("_bbStrStore", _bbStrStore);
|
||||
rtSym("_bbStrCompare", _bbStrCompare);
|
||||
rtSym("_bbStrConcat", _bbStrConcat);
|
||||
rtSym("_bbStrToInt", _bbStrToInt);
|
||||
rtSym("_bbStrFromInt", _bbStrFromInt);
|
||||
rtSym("_bbStrToFloat", _bbStrToFloat);
|
||||
rtSym("_bbStrFromFloat", _bbStrFromFloat);
|
||||
rtSym("_bbStrConst", _bbStrConst);
|
||||
rtSym("_bbDimArray", _bbDimArray);
|
||||
rtSym("_bbUndimArray", _bbUndimArray);
|
||||
rtSym("_bbArrayBoundsEx", _bbArrayBoundsEx);
|
||||
rtSym("_bbVecAlloc", _bbVecAlloc);
|
||||
rtSym("_bbVecFree", _bbVecFree);
|
||||
rtSym("_bbVecBoundsEx", _bbVecBoundsEx);
|
||||
rtSym("_bbObjNew", _bbObjNew);
|
||||
rtSym("_bbObjDelete", _bbObjDelete);
|
||||
rtSym("_bbObjDeleteEach", _bbObjDeleteEach);
|
||||
rtSym("_bbObjRelease", _bbObjRelease);
|
||||
rtSym("_bbObjStore", _bbObjStore);
|
||||
rtSym("_bbObjCompare", _bbObjCompare);
|
||||
rtSym("_bbObjNext", _bbObjNext);
|
||||
rtSym("_bbObjPrev", _bbObjPrev);
|
||||
rtSym("_bbObjFirst", _bbObjFirst);
|
||||
rtSym("_bbObjLast", _bbObjLast);
|
||||
rtSym("_bbObjInsBefore", _bbObjInsBefore);
|
||||
rtSym("_bbObjInsAfter", _bbObjInsAfter);
|
||||
rtSym("_bbObjEachFirst", _bbObjEachFirst);
|
||||
rtSym("_bbObjEachNext", _bbObjEachNext);
|
||||
rtSym("_bbObjEachFirst2", _bbObjEachFirst2);
|
||||
rtSym("_bbObjEachNext2", _bbObjEachNext2);
|
||||
rtSym("_bbObjToStr", _bbObjToStr);
|
||||
rtSym("_bbObjToHandle", _bbObjToHandle);
|
||||
rtSym("_bbObjFromHandle", _bbObjFromHandle);
|
||||
rtSym("_bbNullObjEx", _bbNullObjEx);
|
||||
rtSym("_bbRestore", _bbRestore);
|
||||
rtSym("_bbReadInt", _bbReadInt);
|
||||
rtSym("_bbReadFloat", _bbReadFloat);
|
||||
rtSym("_bbReadStr", _bbReadStr);
|
||||
rtSym("_bbAbs", _bbAbs);
|
||||
rtSym("_bbSgn", _bbSgn);
|
||||
rtSym("_bbMod", _bbMod);
|
||||
rtSym("_bbFAbs", _bbFAbs);
|
||||
rtSym("_bbFSgn", _bbFSgn);
|
||||
rtSym("_bbFMod", _bbFMod);
|
||||
rtSym("_bbFPow", _bbFPow);
|
||||
rtSym("RuntimeStats", bbRuntimeStats);
|
||||
}
|
||||
Reference in New Issue
Block a user