BBArray *bbArrayConcat( const char *type,BBArray *x,BBArray *y ){
BBArray *arr;
char *data;
int length=x->scales[0]+y->scales[0];
if( length<=0 ) return &bbEmptyArray;
arr=allocateArray( type,1,&length );
data=(char*)BBARRAYDATA( arr,1 );
memcpy( data,BBARRAYDATA( x,1 ),x->size );
memcpy( data+x->size,BBARRAYDATA( y,1 ),y->size );
#ifdef BB_GC_RC
if( type[0]==':' || type[0]=='$' || type[0]=='[' ){
int i;
BBObject **p=(BBObject**)data;
for( i=0;i<length;++i ){
BBObject *o=*p++;
BBINCREFS( o );
}
}
#endif
return arr;
}
void bbArraySort( BBArray *arr,int ascending ){
int n;
void *p;
n=arr->scales[0]-1;
if( n<=0 ) return;
p=BBARRAYDATA(arr,arr->dims);
if( ascending ){
switch( arr->type[0] ){
case 'b':_qsort_b( (unsigned char*)p,(unsigned char*)p+n );break;
case 's':_qsort_s( (unsigned short*)p,(unsigned short*)p+n );break;
case 'i':qsort_i( (int*)p,(int*)p+n );break;
case 'l':qsort_l( (BBInt64*)p,(BBInt64*)p+n );break;
case 'f':qsort_f( (float*)p,(float*)p+n );break;
case 'd':qsort_d( (double*)p,(double*)p+n );break;
case '$':case ':':qsort_obj( (BBObject**)p,(BBObject**)p+n );break;
}
}else{
switch( arr->type[0] ){
case 'b':qsort_b_d( (unsigned char*)p,(unsigned char*)p+n );break;
case 's':qsort_s_d( (unsigned short*)p,(unsigned short*)p+n );break;
case 'i':qsort_i_d( (int*)p,(int*)p+n );break;
case 'l':qsort_l_d( (BBInt64*)p,(BBInt64*)p+n );break;
case 'f':qsort_f_d( (float*)p,(float*)p+n );break;
case 'd':qsort_d_d( (double*)p,(double*)p+n );break;
case '$':case ':':qsort_obj_d( (BBObject**)p,(BBObject**)p+n );break;
}
}
}
BBArray * bmx_filesystem_loaddir(BBString * dir) {
boost::filesystem::path p(bbStringToPath(dir));
std::vector<boost::filesystem::path> v;
if (boost::filesystem::exists(p)) {
copy(boost::filesystem::directory_iterator(p), boost::filesystem::directory_iterator(), back_inserter(v));
int n = v.size();
if (n > 0) {
int i = 0;
BBArray *arr = bbArrayNew1D( "$",n );
BBString **s = (BBString**)BBARRAYDATA( arr, arr->dims );
for (std::vector<boost::filesystem::path>::const_iterator it (v.begin()); it != v.end(); ++it) {
boost::filesystem::path path((*it).filename());
s[i] = bbStringFromPath( path );
BBRETAIN( s[i] );
i++;
}
return arr;
}
}
return &bbEmptyArray;
}
BBArray *vertsToBBFloatArray( int num, cpVect *verts ){
BBArray *p=bbArrayNew1D( "f", num * 2 );
cpFloat *s=(cpFloat*)BBARRAYDATA( p,p->dims );
for( int i=0;i < num;++i ){
s[i * 2] = verts[i].x;
s[i * 2 + 1] = verts[i].y;
}
return p;
}
void bmx_wxgraphicscontext_strokedisconnectedlines(wxGraphicsContext * context, BBArray * sp, BBArray * ep) {
int n = sp->scales[0] / 2;
double *s=(double*)BBARRAYDATA( sp,sp->dims );
double *e=(double*)BBARRAYDATA( ep,ep->dims );
wxPoint2DDouble * startPoints = new wxPoint2DDouble[n];
wxPoint2DDouble * endPoints = new wxPoint2DDouble[n];
for (int i = 0; i < n; i++) {
startPoints[i].m_x = s[i * 2];
startPoints[i].m_y = s[i * 2 + 1];
endPoints[i].m_x = e[i * 2];
endPoints[i].m_y = e[i * 2 + 1];
}
context->StrokeLines(n, startPoints, endPoints);
delete [] startPoints;
delete [] endPoints;
}
BBArray *bbArrayFromData( const char *type,int length,void *data ){
int k;
BBArray *arr;
if( length<=0 ) return &bbEmptyArray;
arr=allocateArray( type,1,&length );
if( type[0]=='b' ){
unsigned char *p=BBARRAYDATA( arr,1 );
for( k=0;k<length;++k ) p[k]=((int*)data)[k];
}else if( type[0]=='s' ){
unsigned short *p=BBARRAYDATA( arr,1 );
for( k=0;k<length;++k ) p[k]=((int*)data)[k];
}else{
memcpy( BBARRAYDATA( arr,1 ),data,arr->size );
}
return arr;
}
void bmx_wxgraphicscontext_strokelines(wxGraphicsContext * context, BBArray * p) {
int n = p->scales[0] / 2;
double *s=(double*)BBARRAYDATA( p,p->dims );
wxPoint2DDouble * points = new wxPoint2DDouble[n];
for (int i = 0; i < n; i++) {
points[i].m_x = s[i * 2];
points[i].m_y = s[i * 2 + 1];
}
context->StrokeLines(n, points);
delete [] points;
}
BBString *bbStringFromArray( BBArray *arr ){
int n;
void *p;
if( arr->dims!=1 ) return &bbEmptyString;
n=arr->scales[0];
p=BBARRAYDATA(arr,arr->dims);
switch( arr->type[0] ){
case 'b':return bbStringFromBytes( p,n );
case 's':return bbStringFromShorts( p,n );
case 'i':return bbStringFromInts( p,n );
}
return &bbEmptyString;
}
void bmx_wxgraphicscontext_drawlines(wxGraphicsContext * context, BBArray * p, int fillStyle) {
int n = p->scales[0] / 2;
double *s=(double*)BBARRAYDATA( p,p->dims );
wxPoint2DDouble * points = new wxPoint2DDouble[n];
for (int i = 0; i < n; i++) {
points[i].m_x = s[i * 2];
points[i].m_y = s[i * 2 + 1];
}
context->DrawLines(n, points, static_cast<wxPolygonFillMode>(fillStyle));
delete [] points;
}
FMOD_RESULT bmx_FMOD_System_GetSpectrum(FMOD_SYSTEM *system, BBArray * spectrumArray, int channelOffset, FMOD_DSP_FFT_WINDOW windowType) {
int size = spectrumArray->scales[0];
float arr[size];
FMOD_RESULT res = FMOD_System_GetSpectrum(system, &arr[0], size, channelOffset, windowType);
float *s=(float*)BBARRAYDATA( spectrumArray, spectrumArray->dims );
for (int i = 0; i < size; i ++) {
s[i] = arr[i];
}
return res;
}
FMOD_RESULT bmx_FMOD_Channel_GetSpectrum(MAX_FMOD_CHANNEL *channel, BBArray * spectrumArray, int channelOffset, FMOD_DSP_FFT_WINDOW windowType) {
int size = spectrumArray->scales[0];
float arr[size];
FMOD_RESULT res = FMOD_Channel_GetSpectrum(channel->channel, &arr[0], size, channelOffset, windowType);
float *s=(float*)BBARRAYDATA( spectrumArray, spectrumArray->dims );
for (int i = 0; i < size; i ++) {
s[i] = arr[i];
}
return res;
}
static void initializeArray( BBArray *arr ){
void *init,**p;
if( !arr->size ) return;
init=arrayInitializer( arr );
p=(void**)(BBARRAYDATA( arr,arr->dims ));
if( init ){
int k;
for( k=arr->scales[0];k>0;--k ) *p++=init;
}else{
memset( p,0,arr->size );
}
}
void XMLCALL bmx_expat_StartElementHandler(void *userData, const char *name, const char **atts) {
int n;
for (n = 0; atts[n]; n += 2) {}
BBArray *p = bbArrayNew1D( "$",n );
BBString **s = (BBString**)BBARRAYDATA( p,p->dims );
for( int i = 0; i < n; ++i ){
s[i] = bbStringFromUTF8String(atts[i]);
BBRETAIN(s[i]);
}
_bah_expat_TXMLParser__StartElementHandler((BBObject *)userData, bbStringFromUTF8String(name), p);
}
CFMutableArrayRef CFArrayFromBBStringArray(BBArray * array) {
int size = array->scales[0];
CFMutableArrayRef list = CFArrayCreateMutable(kCFAllocatorDefault,
size, &kCFTypeArrayCallBacks);
BBString **s=(BBString**)BBARRAYDATA(array, array->dims);
for (int i = 0; i < size; i++) {
CFStringRef value = CFStringFromBBString(s[i]);
CFArrayAppendValue(list, value);
CFRelease(value);
}
return list;
}
void bmx_stringbuffer_join(struct MaxStringBuffer * buf, BBArray * bits, struct MaxStringBuffer * newbuf) {
if(bits == &bbEmptyArray) {
return;
}
int i;
int n_bits = bits->scales[0];
BBString **p = (BBString**)BBARRAYDATA( bits,1 );
for(i = 0; i < n_bits; ++i) {
if (i) {
bmx_stringbuffer_append_stringbuffer(newbuf, buf);
}
BBString *bit = *p++;
bmx_stringbuffer_append_string(newbuf, bit);
}
}
BBArray *bbArrayDimensions( BBArray *arr ){
int *p,i,n;
BBArray *dims;
if( !arr->scales[0] ) return &bbEmptyArray;
n=arr->dims;
dims=bbArrayNew1D( "i",n );
p=(int*)BBARRAYDATA( dims,1 );
for( i=0;i<n-1;++i ){
p[i]=arr->scales[i]/arr->scales[i+1];
}
p[i]=arr->scales[i];
return dims;
}
BBArray * bmx_stringbuffer_splitbuffer_toarray(struct MaxSplitBuffer * buf) {
int i, n;
BBString **p,*bit;
BBArray *bits;
n = buf->count;
bits = bbArrayNew1D("$", n);
p = (BBString**)BBARRAYDATA(bits, 1);
i = 0;
while (n--) {
bit = bmx_stringbuffer_substring(buf->buffer, buf->startIndex[i], buf->endIndex[i]);
BBINCREFS( bit );
*p++ = bit;
i++;
}
return bits;
}
//***** Note: Only used by ref counting GC.
static void bbArrayFree( BBObject *o ){
#ifdef BB_GC_RC
int k;
BBObject **p;
BBArray *arr=(BBArray*)o;
if( arr==&bbEmptyArray ){
arr->refs=BBGC_MANYREFS;
return;
}
switch( arr->type[0] ){
case ':':case '$':case '[':
p=(BBObject**)BBARRAYDATA(arr,arr->dims);
for( k=arr->scales[0];k>0;--k ){
BBObject *o=*p++;
BBDECREFS( o );
}
break;
}
bbGCDeallocObject( arr,BBARRAYSIZE( arr->size,arr->dims ) );
#endif
}
void bmx_wxstatusbar_setstatusstyles(wxStatusBar * statusbar, BBArray * styles) {
statusbar->SetStatusStyles(styles->scales[0], (int*)BBARRAYDATA( styles, styles->dims ));
}
FMOD_RESULT bmx_FMOD_Channel_GetSpeakerLevels(MAX_FMOD_CHANNEL *channel, FMOD_SPEAKER speaker, BBArray * levels) {
int n = levels->scales[0];
float *f=(float*)BBARRAYDATA( levels,levels->dims );
return FMOD_Channel_GetSpeakerLevels(channel->channel, speaker, f, n);
}
FMOD_RESULT bmx_FMOD_Channel_GetWaveData(MAX_FMOD_CHANNEL *channel, BBArray * waveArray, int channelOffset) {
int n = waveArray->scales[0];
float *f=(float*)BBARRAYDATA( waveArray, waveArray->dims );
return FMOD_Channel_GetWaveData(channel->channel, f, n, channelOffset);
}
/* Converts a Lua table to a BMax array - the type of the array is determined by the first value in the table (at index 1) */
BBArray *lua_tobmaxarray(lua_State *state, int index) {
switch (lua_type(state, index))
{
case LUA_TNONE:
luaL_error(state, ERRORSTR("@lua_tobmaxarray: Invalid index (%d)"), index);
return &bbEmptyArray;
case LUA_TNIL:
return &bbEmptyArray;
case LUA_TUSERDATA:
if ( lua_isbmaxobject(state, index) ) {
BBObject *obj = lua_tobmaxobject(state, index);
if ( obj->clas == &bbArrayClass ) {
return (BBArray*)obj;
}
else {
luaL_error(state, ERRORSTR("@lua_tobmaxarray: Value at index (%d) is not an array."), index);
return &bbEmptyArray;
}
}
case LUA_TTABLE: /* code below */
break;
default:
if (lua_type(state, index) != LUA_TTABLE) {
luaL_error(state, ERRORSTR("@lua_tobmaxarray: Value at index (%d) is not a table."), index);
return &bbEmptyArray;
}
}
/* make the index absolute, since we're now dealing with more than one value on the stack */
if (index < 0 && index > LUA_REGISTRYINDEX)
index = lua_gettop(state)+(index+1);
/* the index into the array */
size_t table_index;
BBArray *arr = NULL;
size_t len = lua_objlen(state, index);
if ( len == 0 )
return &bbEmptyArray;
/* get the first item of the table */
lua_pushinteger(state, 1);
lua_gettable(state, index);
/* starting at index 2 when iterating */
table_index = 2;
/* determine what type of array to create based on the first value in the table (at index 0) */
switch (lua_type(state, -1)) {
case LUA_TNUMBER: { /* array of doubles */
double *p;
arr = bbArrayNew1D("d", len);
p = (double*)BBARRAYDATA(arr, arr->dims);
*p++ = lua_tonumber(state, -1);
lua_pop(state, 1);
for (; table_index <= len; ++table_index) {
lua_pushinteger(state, table_index);
lua_gettable(state, index);
*p++ = lua_tonumber(state, -1);
lua_pop(state, 1);
}
return arr;
}
case LUA_TBOOLEAN: { /* array of integers */
int *p;
arr = bbArrayNew1D("i", len);
p = (int*)BBARRAYDATA(arr, arr->dims);
*p++ = lua_toboolean(state, -1);
lua_pop(state, 1);
for (; table_index <= len; ++table_index) {
lua_pushinteger(state, table_index);
lua_gettable(state, index);
*p++ = lua_toboolean(state, -1);
lua_pop(state, 1);
}
return arr;
}
case LUA_TSTRING: { /* array of strings */
BBString **p;
arr = bbArrayNew1D("$", len);
p = (BBString**)BBARRAYDATA(arr, arr->dims);
*p = bbStringFromCString(lua_tostring(state, -1));
BBRETAIN((BBObject*)*p++);
lua_pop(state, 1);
for (; table_index <= len; ++table_index) {
lua_pushinteger(state, table_index);
lua_gettable(state, index);
*p = bbStringFromCString(lua_tostring(state, -1));
BBRETAIN((BBObject*)*p++);
lua_pop(state, 1);
}
return arr;
}
case LUA_TTABLE: /* array of arrays (arrays inside of arrays do not have to be the same type) */
case LUA_TUSERDATA:
{
BBObject **p;
arr = bbArrayNew1D(":Object", len);
p = (BBObject**)BBARRAYDATA(arr, arr->dims);
*p = lua_tobmaxobject(state, -1);
BBRETAIN(*p++);
lua_pop(state, 1);
for (; table_index <= len; ++table_index) {
lua_pushinteger(state, table_index);
lua_gettable(state, index);
*p = lua_tobmaxobject(state, -1);
BBRETAIN(*p++);
lua_pop(state, 1);
}
return arr;
}
default:
luaL_error(state, ERRORSTR("@lua_tobmaxarray: Arrays of type %s are not unsupported"), lua_typename(state, lua_type(state, -1)));
return &bbEmptyArray;
} /* switch lua type */
return arr;
} /* lua_tobmaxarray */
static int lugi_newindex_array(lua_State *state) {
if (lua_isnumber(state, 2) == 1) {
BBArray *arr = lua_tobmaxarray(state, 1);
lua_Integer index = lua_tointeger(state, 2);
if ( index < 0 || arr->scales[0] <= index ) {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Attempt to index array failed: index (%d) out of bounds"), index);
}
switch (arr->type[0]) {
case 'b': /* byte */
if ( lua_isnumber(state, 3) ) {
((BBBYTE*)BBARRAYDATA(arr, arr->dims))[index] = (BBBYTE)lua_tointeger(state, 3);
}
else {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Cannot assign value with type %s to element of byte array"), lua_typename(state, lua_type(state, 3)));
}
break;
case 's': /* short */
if ( lua_isnumber(state, 3) ) {
((BBSHORT*)BBARRAYDATA(arr, arr->dims))[index] = (BBSHORT)lua_tointeger(state, 3);
}
else {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Cannot assign value with type %s to element of short array"), lua_typename(state, lua_type(state, 3)));
}
break;
case 'i': /* int */
if ( lua_isnumber(state, 3) ) {
((BBINT*)BBARRAYDATA(arr, arr->dims))[index] = (BBINT)lua_tointeger(state, 3);
}
else {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Cannot assign value with type %s to element of integer array"), lua_typename(state, lua_type(state, 3)));
}
break;
case 'l': /* long */
if ( lua_isnumber(state, 3) ) {
((BBLONG*)BBARRAYDATA(arr, arr->dims))[index] = (BBLONG)lua_tointeger(state, 3);
}
else {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Cannot assign value with type %s to element of long array"), lua_typename(state, lua_type(state, 3)));
}
break;
case 'f': /* float */
if ( lua_isnumber(state, 3) ) {
((BBFLOAT*)BBARRAYDATA(arr, arr->dims))[index] = (BBFLOAT)lua_tonumber(state, 3);
}
else {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Cannot assign value with type %s to element of short array"), lua_typename(state, lua_type(state, 3)));
}
break;
case 'd': /* double */
if ( lua_isnumber(state, 3) ) {
((BBDOUBLE*)BBARRAYDATA(arr, arr->dims))[index] = (BBDOUBLE)lua_tonumber(state, 3);
}
else {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Cannot assign value with type %s to element of short array"), lua_typename(state, lua_type(state, 3)));
}
break;
case '$': /* string */
{
BBString **data = ((BBString**)BBARRAYDATA(arr, arr->dims));
if ( lua_isstring(state, 3) ) {
BBString *newstring = bbStringFromCString(lua_tostring(state, 3));
BBRETAIN((BBObject*)newstring);
BBRELEASE((BBObject*)data[index]);
data[index] = newstring;
}
else if ( lua_isnil(state, 3 ) ) {
BBRELEASE((BBObject*)data[index]);
data[index] = &bbEmptyString;
}
else {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Cannot assign value with type %s to element of string array"), lua_typename(state, lua_type(state, 3)));
}
}
break;
case ':': /* any type of object */
{
BBObject *value = lua_tobmaxobject(state, 3);
BBClass *arrclas = NULL;
{ /* search for the array element type's class */
const char *arrtypename = arr->type+1;
int numTypes = 0;
int regidx = 0;
BBClass **regtypes = bbObjectRegisteredTypes(&numTypes);
for (; regidx < numTypes; ++regidx) {
if ( strcmp(regtypes[regidx]->debug_scope->name, arrtypename) == 0 ) {
arrclas = regtypes[regidx];
break;
}
}
}
if ( arrclas == NULL ) {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Undefined array type encountered: %s"), arr->type);
}
value = bbObjectDowncast(value, arrclas);
BBObject **data = (BBObject**)BBARRAYDATA(arr, arr->dims);
BBRETAIN(value);
BBRELEASE(data[index]);
data[index] = value;
}
break;
case '[': {
BBArray *value = lua_tobmaxarray(state, 3);
if ( (BBObject*)value == &bbNullObject ) {
value = &bbEmptyArray;
}
if ( value == &bbEmptyArray || strcmp(arr->type+2, value->type) == 0 ) {
BBArray **data = (BBArray**)BBARRAYDATA(arr, arr->dims);
BBRETAIN((BBObject*)value);
BBRELEASE((BBObject*)data[index]);
data[index] = value;
}
else {
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Cannot assign array value to an element of an array of a differing type"));
}
}
break;
default:
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Unsupported array element type: %s"), arr->type);
}
return 0;
} /* key is a valid type of index for an array */
return luaL_error(state, ERRORSTR("@lugi_newindex_array: Invalid type for an array index (%s), must be an integer or a string convertible to an integer"), lua_typename(state, lua_type(state, 2)));
}
FMOD_RESULT bmx_FMOD_Channel_SetInputChannelMix(MAX_FMOD_CHANNEL *channel, BBArray * levels) {
int n = levels->scales[0];
float *f=(float*)BBARRAYDATA( levels, levels->dims );
return FMOD_Channel_SetInputChannelMix(channel->channel, f, n);
}
void bbStartup( int argc,char *argv[],void *dummy1,void *dummy2 ){
int i,k;
BBString **p;
//Start up GC and create bbAppFile, bbAppDir and bbLaunchDir
#if _WIN32
char *ebp;
OSVERSIONINFO os={ sizeof(os) };
//asm( "movl %%ebp,%0;":"=r"(ebp) );//::"%ebp" );
//bbGCStackTop=ebp+28;
// BaH bbThreadStartup();
bbGCStartup();
if( GetVersionEx( &os ) ){
if( os.dwPlatformId==VER_PLATFORM_WIN32_NT ){
_bbusew=1;
}
}
if( _bbusew ){
int e=0;
wchar_t buf[MAX_PATH];
_wgetcwd( buf,MAX_PATH );
for( i=0;buf[i];++i ){
if( buf[i]=='\\' ) buf[i]='/';
}
bbLaunchDir=bbStringFromWString( buf );
GetModuleFileNameW( GetModuleHandleW(0),buf,MAX_PATH );
for( i=0;buf[i];++i ){
if( buf[i]=='\\' ) buf[i]='/';
if( buf[i]=='/' ) e=i;
}
bbAppFile=bbStringFromWString( buf );
if( e ){
if( buf[e-1]==':' ) ++e;
bbAppDir=bbStringFromShorts( buf,e );
}else{
bbAppDir=&bbEmptyString;
}
_wchdir( bbTmpWString( bbAppDir ) );
}else{
int e=0;
char buf[MAX_PATH];
_getcwd( buf,MAX_PATH );
for( i=0;buf[i];++i ){
if( buf[i]=='\\' ) buf[i]='/';
}
bbLaunchDir=bbStringFromCString( buf );
GetModuleFileNameA( GetModuleHandleA(0),buf,MAX_PATH );
for( i=0;buf[i];++i ){
if( buf[i]=='\\' ) buf[i]='/';
if( buf[i]=='/' ) e=i;
}
bbAppFile=bbStringFromCString( buf );
if( e ){
if( buf[e-1]==':' ) ++e;
bbAppDir=bbStringFromBytes( buf,e );
}else{
bbAppDir=&bbEmptyString;
}
_chdir( bbTmpCString( bbAppDir ) );
}
#elif __linux
char *ebp;
char buf[PATH_MAX];
char lnk[PATH_MAX];
pid_t pid;
// asm( "movl %%ebp,%0;":"=r"(ebp) );//::"%ebp" );
bbGCStackTop=ebp+28;
// BaH bbThreadStartup();
bbGCStartup();
getcwd( buf,PATH_MAX );
bbLaunchDir=bbStringFromUTF8String( buf );
pid=getpid();
sprintf( lnk,"/proc/%i/exe",pid );
i=readlink( lnk,buf,PATH_MAX );
if( i>0 ){
char *p;
buf[i]=0;
bbAppFile=bbStringFromUTF8String( buf );
p=strrchr( buf,'/' );
if( p ){
*p=0;
bbAppDir=bbStringFromUTF8String( buf );
}else{
bbAppDir=&bbEmptyString;
}
}else{
bbAppFile=&bbEmptyString;
bbAppDir=&bbEmptyString;
}
chdir( bbTmpUTF8String( bbAppDir ) );
#elif __APPLE__
CFURLRef url;
char buf[PATH_MAX],*e;
//#if BB_ARGP
// bbGCStackTop=bbArgp(0);
//#else
bbGCStackTop=&argc;
//#endif
// BaH bbThreadStartup();
bbGCStartup();
getcwd( buf,PATH_MAX );
bbLaunchDir=bbStringFromUTF8String( buf );
url=CFBundleCopyExecutableURL( CFBundleGetMainBundle() );
CFURLGetFileSystemRepresentation( url,true,(UInt8*)buf,PATH_MAX );
CFRelease( url );
bbAppFile=bbStringFromUTF8String( buf );
if( e=strstr( buf,".app/Contents/MacOS/" ) ){
*e=0;
}
if( e=strrchr( buf,'/' ) ){
*e=0;
bbAppDir=bbStringFromUTF8String( buf );
}else{
bbAppDir=&bbEmptyString;
}
chdir( bbTmpUTF8String( bbAppDir ) );
#endif
BBINCREFS( bbLaunchDir );
BBINCREFS( bbAppDir );
BBINCREFS( bbAppFile );
bbAppTitle=bbStringFromCString( "BlitzMax Application" );
BBINCREFS( bbAppTitle );
bbAppArgs=bbArrayNew1D( "$",argc );
BBINCREFS( bbAppArgs );
p=(BBString**)BBARRAYDATA( bbAppArgs,1 );
for( k=0;k<argc;++k ){
BBString *arg=bbStringFromCString( argv[k] );
BBINCREFS( arg );
*p++=arg;
}
startup();
}
void bmx_wxstatusbar_setstatuswidths(wxStatusBar * statusbar, BBArray * widths) {
statusbar->SetStatusWidths(widths->scales[0], (int*)BBARRAYDATA( widths, widths->dims ));
}
FMOD_RESULT bmx_FMOD_Sound_SetSubSoundSentence(FMOD_SOUND * sound, BBArray * soundList) {
int length = soundList->scales[0];
int *s=(int*)BBARRAYDATA( soundList, soundList->dims );
return FMOD_Sound_SetSubSoundSentence(sound, s, length);
}
BBArray * bmx_bass_channelgettags(DWORD handle, DWORD tags) {
const char * text;
TAG_ID3 *id3;
switch (tags) {
case BASS_TAG_ID3:
id3 = (TAG_ID3*) BASS_ChannelGetTags(handle, BASS_TAG_ID3); // get the ID3 tags
if (id3) {
char buffer[4];
BBArray * p = bbArrayNew1D("$", 7);
BBString **s = (BBString**)BBARRAYDATA( p,p->dims );
sprintf(buffer, "%.3s", id3->id);
s[0] = bbStringFromCString(buffer);
BBRETAIN( s[0] );
s[1] = bbStringFromCString(id3->title);
BBRETAIN( s[1] );
s[2] = bbStringFromCString(id3->artist);
BBRETAIN( s[2] );
s[3] = bbStringFromCString(id3->album);
BBRETAIN( s[3] );
sprintf(buffer, "%.4s", id3->year);
s[4] = bbStringFromCString(buffer);
BBRETAIN( s[4] );
s[5] = bbStringFromCString(id3->comment);
BBRETAIN( s[5] );
sprintf(buffer, "%d", id3->genre);
s[6] = bbStringFromCString(buffer);
BBRETAIN( s[6] );
return p;
} else {
return &bbEmptyArray;
}
case BASS_TAG_META:
case BASS_TAG_LYRICS3:
case BASS_TAG_VENDOR:
case BASS_TAG_MUSIC_NAME:
case BASS_TAG_MUSIC_MESSAGE:
text = BASS_ChannelGetTags(handle, tags);
if (text) {
BBArray * p = bbArrayNew1D("$", 1);
BBString **s = (BBString**)BBARRAYDATA( p,p->dims );
s[0] = bbStringFromCString( text );
BBRETAIN( s[0] );
return p;
} else {
return &bbEmptyArray;
}
default:
text = BASS_ChannelGetTags(handle, tags);
if (text) {
int count = 0;
const char * current = text;
while (*current) {
current += strlen(current) + 1;
count++;
}
BBArray * p = bbArrayNew1D("$", count);
BBString **s = (BBString**)BBARRAYDATA( p,p->dims );
count = 0;
current = text;
while (*current) {
s[count] = bbStringFromCString( current );
BBRETAIN( s[count] );
current += strlen(current) + 1;
count++;
}
return p;
} else {
return &bbEmptyArray;
}
}
}
MaxPalette * bmx_wxpalette_create(BBArray * r, BBArray * g, BBArray *b) {
wxPalette p(r->scales[0], (unsigned char*)BBARRAYDATA( r,r->dims ),
(unsigned char*)BBARRAYDATA( g,g->dims ), (unsigned char*)BBARRAYDATA( b,b->dims ));
return new MaxPalette(p);
}
BBArray *bbArraySlice( const char *type,BBArray *inarr,int beg,int end ){
char *p;
void *init;
BBArray *arr;
int n,k,el_size;
int length=end-beg;
if( length<=0 ) return &bbEmptyArray;
arr=allocateArray( type,1,&length );
el_size=arr->size/length;
init=arrayInitializer( arr );
p=(char*)BBARRAYDATA( arr,1 );
n=-beg;
if( n>0 ){
if( beg+n>end ) n=end-beg;
if( init ){
void **dst=(void**)p;
for( k=0;k<n;++k ) *dst++=init;
p=(char*)dst;
}else{
memset( p,0,n*el_size );
p+=n*el_size;
}
beg+=n;
if( beg==end ) return arr;
}
n=inarr->scales[0]-beg;
if( n>0 ){
if( beg+n>end ) n=end-beg;
#ifdef BB_GC_RC
if( type[0]==':' || type[0]=='$' || type[0]=='[' ){
BBObject **dst=(BBObject**)p;
BBObject **src=(BBObject**)BBARRAYDATA(inarr,inarr->dims)+beg;
for( k=0;k<n;++k ){
BBObject *o=*src++;
BBINCREFS( o );
*dst++=o;
}
p=(char*)dst;
}else{
memcpy( p,(char*)BBARRAYDATA(inarr,inarr->dims)+beg*el_size,n*el_size );
p+=n*el_size;
}
#else
memcpy( p,(char*)BBARRAYDATA(inarr,inarr->dims)+beg*el_size,n*el_size );
p+=n*el_size;
#endif
beg+=n;
if( beg==end ) return arr;
}
n=end-beg;
if( n>0 ){
if( init ){
void **dst=(void**)p;
for( k=0;k<n;++k ) *dst++=init;
}else{
memset( p,0,n*el_size );
}
}
return arr;
}
