Negative String/Array Slices

BlitzMax Forums/BlitzMax Module Tweaks/Negative String/Array Slices

N	(Posted 2005) [#1]

Edit: Oh yes, I'd like to ask Mark to -please- incorporate these changes into the BlitzMax source code.

Edit 2: Added String.Truncate method (*Removed*)

Edit 3: Added a quick mod to Truncate so it can accept negative arguments (truncates off the beginning of strings).

First off, thanks to (Master) Beaker for helping with this- he came up with the string slicing code first (two lines that would forever change slicing!). Anyhow, I applied a few modifications to his changes.

Anyhow, I applied the string slice modifications to the Array modifications so now you can do myArray[-10..0] and get the last 10 elements of an array.

Now one change to the way this works is that if you specify 0 as the ending point of the array/string and the first point is negative then 0 will be set to the ending of the array (because 0-(len-10) would return a blank string, so I'm putting this option to use).

Alright, here are the changes- to make this easier, I'm pasting the entire source files so you won't have to worry about putting the changes in the right place.

CHECK BELOW

N	(Posted 2005) [#2]

Bumping this for Pert, nevermind it otherwise.

Dreamora

(Posted 2005) [#3]

myArray[-10..0] in your module is the same as

myArray[length(myArray)-10 .. length(MyArray)]

Perturbatio

(Posted 2005) [#4]

see! I'm not the only one!

N	(Posted 2005) [#5]

myArray[-10..0] in your module is the same as

myArray[length(myArray)-10 .. length(MyArray)]

That's the idea... it's just making it shorter so you don't have to type stuff you shouldn't have to.

N	(Posted 2006) [#6]

Updated for v1.16:

blitz_array.c


#include "blitz.h"

static void bbArrayFree( BBObject *o );

static BBDebugScope debugScope={
	BBDEBUGSCOPE_USERTYPE,
	"Array",
	BBDEBUGDECL_END
};

BBClass bbArrayClass={
	&bbObjectClass, //extends
	bbArrayFree,	//free
	&debugScope,	//DebugScope
	0,				//instance_size
	0,				//ctor
	0,				//dtor
	
	bbObjectToString,
	bbObjectCompare,
	bbObjectSendMessage,
	bbObjectReserved,
	bbObjectReserved,
	bbObjectReserved,
	
	bbArraySort,
	bbArrayDimensions
};

BBArray bbEmptyArray={
	&bbArrayClass,  //clas
	BBGC_MANYREFS,	//refs
	0,				//type
	0,				//dims
	0,				//size
	0				//scales[0]
};

static void bbArrayFree( BBObject *o ){
	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++;
			BBRELEASE( o );
		}
		break;
	}
	bbGCMemFree( arr,BBARRAYSIZE(arr->size,arr->dims) );
}

BBArray *bbArrayNew( const char *type,int dims,... ){
	void *init=0;
	int k,length=1,size=4,*arg;
	BBArray *arr;
	void **p;

	arg=&dims+1;	
	for( k=0;k<dims;++k ){
		int n=*arg++;
		if( n<=0 ) return &bbEmptyArray;
		length*=n;
	}
	
	switch( type[0] ){
	case 'b':size=1;break;
	case 's':size=2;break;
	case 'l':size=8;break;
	case 'd':size=8;break;
	case ':':init=&bbNullObject;break;
	case '$':init=&bbEmptyString;break;
	case '[':init=&bbEmptyArray;break;
	case '(':init=&brl_blitz_NullFunctionError;break;
	}
	size*=length;

	arr=(BBArray*)bbGCAlloc( BBARRAYSIZE(size,dims),(BBGCPool*)&bbArrayClass );
	arr->type=type;
	arr->dims=dims;
	arr->size=size;

	arg=&dims+1;
	for( k=0;k<dims;++k ) arr->scales[k]=*arg++;
	for( k=dims-2;k>=0;--k ) arr->scales[k]*=arr->scales[k+1];

	p=(void**)(BBARRAYDATA(arr,dims));
	
	if( init ){
		for( k=arr->scales[0];k>0;--k ) *p++=init;
	}else{
		memset( p,0,size );
	}
	
	return arr;
}

BBArray *bbArrayNew1D( const char *type,int length ){
	int k,size=4;
	void *init=0,**p;
	BBArray *arr;

	if( length<=0 ) return &bbEmptyArray;
	
	switch( type[0] ){
	case 'b':size=1;break;
	case 's':size=2;break;
	case 'l':size=8;break;
	case 'd':size=8;break;
	case ':':init=&bbNullObject;break;
	case '$':init=&bbEmptyString;break;
	case '[':init=&bbEmptyArray;break;
	case '(':init=&brl_blitz_NullFunctionError;break;
	}
	size*=length;

	arr=(BBArray*)bbGCAlloc( BBARRAYSIZE(size,1),(BBGCPool*)&bbArrayClass );
	arr->type=type;
	arr->dims=1;
	arr->size=size;
	arr->scales[0]=length;

	p=(void**)BBARRAYDATA(arr,1);
	
	if( init ){
		while( length-->0 ) *p++=init;
	}else{
		memset( p,0,size );
	}
	
	return arr;
}

BBArray *bbArraySlice( const char *type,BBArray *inarr,int beg,int end ){
	BBArray *arr;
	char *p;
	void *init=0;
	
	//int k,n,el_size=4,size,length,inlength;  // commented out ^_^
	
	// BEGIN CHANGE ( Noel Cower/Master Beaker   12:15 PM  01/29/06 )
	int k,n,el_size=4,size,length;
    int inlength=inarr->scales[0];
    
    if (beg<0)
    {
        beg+=inlength;
        if (end==0)
            end=inlength;
    }
    
    if (end<0)
        end+=inlength;
    // END CHANGE

	length=end-beg;
	if( length<=0 ) return &bbEmptyArray;

	switch( type[0] ){
	case 'b':el_size=1;break;
	case 's':el_size=2;break;
	case 'l':el_size=8;break;
	case 'd':el_size=8;break;
	case ':':init=&bbNullObject;break;
	case '$':init=&bbEmptyString;break;
	case '[':init=&bbEmptyArray;break;
	case '(':init=&brl_blitz_NullFunctionError;break;
	}
	size=el_size*length;

	arr=(BBArray*)bbGCAlloc( BBARRAYSIZE(size,1),(BBGCPool*)&bbArrayClass );
	arr->type=type;
	arr->dims=1;
	arr->size=size;
	arr->scales[0]=length;

	p=(char*)BBARRAYDATA(arr,1);
	inlength=inarr->scales[0];

	if( (n=-beg)>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;
		}
		if( (beg+=n)==end ) return arr;
	}
	if( (n=inlength-beg)>0 ){
		if( beg+n>end ) n=end-beg;
		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++;
				BBRETAIN( o );
				*dst++=o; 
			}
			p=(char*)dst;
		}else{
			memcpy( p,(char*)BBARRAYDATA(inarr,inarr->dims)+beg*el_size,n*el_size );
			p+=n*el_size;
		}
		if( (beg+=n)==end ) return arr;
	}
	if( (n=end-beg)>0 ){
		if( init ){
			void **dst=(void**)p;
			for( k=0;k<n;++k ) *dst++=init;
		}else{
			memset( p,0,n*el_size );
		}
	}
	return arr;
}

BBArray *bbArrayFromData( const char *type,int length,void *data ){
	int k,size;
	BBArray *arr;

	if( length<=0 ) return &bbEmptyArray;
	
	switch( type[0] ){
	case 'b':size=1;break;
	case 's':size=2;break;
	case 'l':size=8;break;
	case 'd':size=8;break;
	default:size=4;
	}
	size*=length;

	arr=(BBArray*)bbGCAlloc( BBARRAYSIZE(size,1),(BBGCPool*)&bbArrayClass );
	arr->type=type;
	arr->dims=1;
	arr->size=size;
	arr->scales[0]=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,size );
	}
	return arr;
}

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 *bbArrayCastFromObject( BBObject *o,const char *type ){
	BBArray *arr=(BBArray*)o;
	if( arr==&bbEmptyArray ) return arr;
	if( arr->clas!=&bbArrayClass ) return (BBArray*)BBNULL;
	if( strcmp( arr->type,":Object" ) ) return arr;
	if( strcmp( arr->type,type ) ) return (BBArray*)BBNULL;
	return arr;
}

#define SWAP(X,Y) {t=*(X);*(X)=*(Y);*(Y)=t;}
#define QSORTARRAY( TYPE,IDENT )\
static void IDENT( TYPE *lo,TYPE *hi ){\
	TYPE t;\
	TYPE *i;\
	TYPE *x;\
	TYPE *y;\
	if( hi<=lo ) return;\
	if( lo+1==hi ){\
		if( LESSTHAN(hi,lo) ) SWAP(lo,hi);\
		return;\
	}\
	i=(hi-lo)/2+lo;\
	if( LESSTHAN(i,lo) ) SWAP(i,lo);\
	if( LESSTHAN(hi,i) ){\
		SWAP(i,hi);\
		if( LESSTHAN(i,lo) ) SWAP(i,lo);\
	}\
	x=lo+1;\
	y=hi-1;\
	do{\
		while( LESSTHAN(x,i) ) ++x;\
		while( LESSTHAN(i,y) ) --y;\
		if( x>y ) break;\
		if( x<y ){\
			SWAP(x,y);\
			if( i==x ) i=y;\
			else if( i==y ) i=x;\
		}\
		++x;\
		--y;\
	}while( x<=y );\
	IDENT(lo,y);\
	IDENT(x,hi);\
}

#undef LESSTHAN
#define LESSTHAN(X,Y) (*(X)<*(Y))
QSORTARRAY( unsigned char,qsort_b )
QSORTARRAY( unsigned short,qsort_s )
QSORTARRAY( int,qsort_i )
QSORTARRAY( BBInt64,qsort_l );
QSORTARRAY( float,qsort_f );
QSORTARRAY( double,qsort_d );
#undef LESSTHAN
#define LESSTHAN(X,Y) ((*X)->clas->Compare(*(X),*(Y))<0)
QSORTARRAY( BBObject*,qsort_obj );
#undef LESSTHAN
#define LESSTHAN(X,Y) (*(X)>*(Y))
QSORTARRAY( unsigned char,qsort_b_d )
QSORTARRAY( unsigned short,qsort_s_d )
QSORTARRAY( int,qsort_i_d )
QSORTARRAY( BBInt64,qsort_l_d );
QSORTARRAY( float,qsort_f_d );
QSORTARRAY( double,qsort_d_d );
#undef LESSTHAN
#define LESSTHAN(X,Y) ((*X)->clas->Compare(*(X),*(Y))>0)
QSORTARRAY( BBObject*,qsort_obj_d );

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;
		}
	}
}

blitz_string.c


#include "blitz.h"

static void bbStringFree( BBObject *o );

static BBDebugScope debugScope={
	BBDEBUGSCOPE_USERTYPE,
	"String",
	BBDEBUGDECL_END
};

BBClass bbStringClass={
	&bbObjectClass, //super
	bbStringFree,   //free
	&debugScope,	//DebugScope
	0,				//instance_size
	0,				//ctor
	0,				//dtor

	(BBString*(*)(BBObject*))bbStringToString,
	(int(*)(BBObject*,BBObject*))bbStringCompare,
	bbObjectSendMessage,
	bbObjectReserved,
	bbObjectReserved,
	bbObjectReserved,
	
	bbStringFind,
	bbStringFindLast,
	bbStringTrim,
	bbStringReplace,
	
	bbStringToLower,
	bbStringToUpper,
	
	bbStringToInt,
	bbStringToLong,
	bbStringToFloat,
	bbStringToDouble,
	bbStringToCString,
	bbStringToWString,

	bbStringFromInt,
	bbStringFromLong,
	bbStringFromFloat,
	bbStringFromDouble,
	bbStringFromCString,
	bbStringFromWString,
	
	bbStringFromBytes,
	bbStringFromShorts
};

BBString bbEmptyString={
	&bbStringClass, //clas
	BBGC_MANYREFS,	//refs
	0				//length
};

static int wstrlen( const BBChar *p ){
	const BBChar *t=p;
	while( *t ) ++t;
	return t-p;
}

static void bbStringFree( BBObject *o ){
	BBString *str=(BBString*)o;

	if( str==&bbEmptyString ){
		str->refs=BBGC_MANYREFS;
		return;
	}

	bbGCMemFree( str,sizeof(BBString)+str->length*sizeof(BBChar) );
}

BBString *bbStringNew( int len ){
	BBString *str;
	if( !len ) return &bbEmptyString;
	str=(BBString*)bbGCAlloc( sizeof(BBString)+len*sizeof(BBChar),(BBGCPool*)&bbStringClass );
	str->length=len;
	return str;
}

BBString *bbStringFromChar( int c ){
	BBString *str=bbStringNew(1);
	str->buf[0]=c;
	return str;
}

BBString *bbStringFromInt( int n ){
	char buf[64],*p=buf+64;
	int neg=n<0;
	if( neg ){
		n=-n;if( n<0 ) return bbStringFromBytes( "-2147483648",11 );
	}
	do{
		*--p=n%10+'0';
	}while(n/=10);
	if( neg ) *--p='-';
	return bbStringFromBytes( p,buf+64-p );
}

BBString *bbStringFromLong( BBInt64 n ){
	char buf[64],*p=buf+64;
	int neg=n<0;
	if( neg ){
		n=-n;if( n<0 ) return bbStringFromBytes( "-9223372036854775808",20 );
	}
	do{
		*--p=n%10+'0';
	}while(n/=10);
	if( neg ) *--p='-';
	return bbStringFromBytes( p,buf+64-p );
}

BBString *bbStringFromFloat( float n ){
	char buf[64];
	sprintf( buf,"%#.9g",n );
	return bbStringFromCString(buf);
}

BBString *bbStringFromDouble( double n ){
	char buf[64];
	sprintf( buf,"%#.17lg",n );
	return bbStringFromCString(buf);
}

BBString *bbStringFromBytes( const char *p,int n ){
	int k;
	BBString *str;
	if( !n ) return &bbEmptyString;
	str=bbStringNew( n );
	for( k=0;k<n;++k ) str->buf[k]=(unsigned char)p[k];
	return str;
}

BBString *bbStringFromShorts( const unsigned short *p,int n ){
	BBString *str;
	if( !n ) return &bbEmptyString;
	str=bbStringNew( n );
	bbMemCopy( str->buf,p,n*sizeof(short) );
	return str;
}

BBString *bbStringFromInts( const int *p,int n ){
	int k;
	BBString *str;
	if( !n ) return &bbEmptyString;
	str=bbStringNew( n );
	for( k=0;k<n;++k ) str->buf[k]=p[k];
	return str;
}

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;
}

BBString *bbStringFromCString( const char *p ){
	return p ? bbStringFromBytes( p,strlen(p) ) : &bbEmptyString;
}

BBString *bbStringFromWString( const BBChar *p ){
	return p ? bbStringFromShorts( p,wstrlen(p) ) : &bbEmptyString;
}

BBString *bbStringToString( BBString *t ){
	return t;
}

int bbStringCompare( BBString *x,BBString *y ){
	int k,n,sz;
	sz=x->length<y->length ? x->length : y->length;
	for( k=0;k<sz;++k ) if( n=x->buf[k]-y->buf[k] ) return n;
	return x->length-y->length;
}

BBString *bbStringConcat( BBString *x,BBString *y ){
    int len=x->length+y->length;
    BBString *t=bbStringNew(len);
    memcpy( t->buf,x->buf,x->length*sizeof(BBChar) );
    memcpy( t->buf+x->length,y->buf,y->length*sizeof(BBChar) );
    return t;
}

BBString *bbStringSlice( BBString *in,int beg,int end ){
	BBChar *p;
	BBString *out;
	int k,n,len,inlen;
	
	// BEGIN CHANGE ( Noel Cower/Master Beaker   12:15 PM  01/29/06 )
    if (beg<0)
    {
        beg += in->length;
        if (end==0)
            end = in->length;
    }
    
    if (end<0)
        end += in->length;
    // END CHANGE
	
	len=end-beg;
	if( len<=0 ) return &bbEmptyString;

	out=bbStringNew( len );
	
	p=out->buf;
	inlen=in->length;

	if( (n=-beg)>0 ){
		if( beg+n>end ) n=end-beg;
		for( k=0;k<n;++k ) *p++=' ';
		if( (beg+=n)==end ) return out;
	}
	if( (n=inlen-beg)>0 ){
		BBChar *q=in->buf+beg;
		if( beg+n>end ) n=end-beg;
		for( k=0;k<n;++k ) *p++=*q++;
		if( (beg+=n)==end ) return out;
	}
	if( (n=end-beg)>0 ){
		for( k=0;k<n;++k ) *p++=' ';
	}
	return out;
}

BBString *bbStringTrim( BBString *str ){
	int b=0,e=str->length;
	while( b<e && str->buf[b]<=' ' ) ++b;
	if( b==e ) return &bbEmptyString;
	while( str->buf[e-1]<=' ' ) --e;
	if( e-b==str->length ) return str;
	return bbStringFromShorts( str->buf+b,e-b );
}

BBString *bbStringReplace( BBString *str,BBString *sub,BBString *rep ){
	int i,d,n,j,p;
	if( !sub->length ) return str;
	i=0;n=0;
	while( (i=bbStringFind(str,sub,i))!=-1 ) {i+=sub->length;n++;}
	if (!n) return str;
	d=rep->length-sub->length;
	BBString *t=bbStringNew( str->length+d*n );
	i=0;p=0;
	while( (j=bbStringFind(str,sub,i))!=-1 )
	{
		n=j-i;if (n) {memcpy( t->buf+p,str->buf+i,n*sizeof(BBChar) );p+=n;}
		n=rep->length;memcpy( t->buf+p,rep->buf,n*sizeof(BBChar) );p+=n;
		i=j+sub->length;		
	}
	n=str->length-i;
	if (n) memcpy( t->buf+p,str->buf+i,n*sizeof(BBChar) );
	return t;
}

int bbStringAsc( BBString *t ){
	return t->length ? t->buf[0] : -1;
}

static int charsEqual( unsigned short *a,unsigned short *b,int n ){
	//not sure...alignment issues?
	//for( ;n>=2;n-=2 ){
	//	if( *(int*)a!=*(int*)b ) return 0;
	//	a+=2;b+=2;
	//}
	while( n-- ){
		if (*a!=*b) return 0;
		a++;b++;
	}
	return 1;
}

int bbStringFind( BBString *x,BBString *y,int i ){
	bbassert( i>=0 );
	while( i+y->length<=x->length ){
		if( charsEqual( x->buf+i,y->buf,y->length ) ) return i;
		++i;
	}
	return -1;
}

int bbStringFindLast( BBString *x,BBString *y,int i ){
	bbassert( i>=0 );
	i=x->length-i;
	if (i+y->length>x->length) i=x->length-y->length;
	while (i>=0)
	{
		if( charsEqual( x->buf+i,y->buf,y->length ) ) return i;
		--i;
	}
	return -1;
}

/*
int bbStringFindLast( BBString *x,BBString *y,int i ){
	int p;
	bbassert( i>=0 );
	p=x->length-y->length;
	while( p>=i ){
		if( charsEqual( x->buf+p,y->buf,y->length ) ) return p;
		--p;
	}
	return -1;
}
*/
int bbStringToInt( BBString *t ){
	int i=0,neg=0,n=0;
	
	while( i<t->length && isspace(t->buf[i]) ) ++i;
	if( i==t->length ) return 0;
	
	if( t->buf[i]=='+' ) ++i;
	else if( neg=(t->buf[i]=='-') ) ++i;
	if( i==t->length ) return 0;

	if( t->buf[i]=='%' ){
		for( ++i;i<t->length;++i ){
			int c=t->buf[i];
			if( c!='0' && c!='1' ) break;
			n=n*2+(c-'0');
		}
	}else if( t->buf[i]=='$' ){
		for( ++i;i<t->length;++i ){
			int c=toupper(t->buf[i]);
			if( !isxdigit(c) ) break;
			if( c>='A' ) c-=('A'-'0'-10);
			n=n*16+(c-'0');
		}
	}else{
		for( ;i<t->length;++i ){
			int c=t->buf[i];
			if( !isdigit(c) ) break;
			n=n*10+(c-'0');
		}
	}
	return neg ? -n : n;
}

void bbStringToLong( BBString *t,BBInt64 *r ){
	int i=0,neg=0;
	BBInt64 n=0;
	
	while( i<t->length && isspace(t->buf[i]) ) ++i;
	if( i==t->length ){ *r=0;return; }
	
	if( t->buf[i]=='+' ) ++i;
	else if( neg=(t->buf[i]=='-') ) ++i;
	if( i==t->length ){ *r=0;return; }
	
	if( t->buf[i]=='%' ){
		for( ++i;i<t->length;++i ){
			int c=t->buf[i];
			if( c!='0' && c!='1' ) break;
			n=n*2+(c-'0');
		}
	}else if( t->buf[i]=='$' ){
		for( ++i;i<t->length;++i ){
			int c=toupper(t->buf[i]);
			if( !isxdigit(c) ) break;
			if( c>='A' ) c-=('A'-'0'-10);
			n=n*16+(c-'0');
		}
	}else{
		for( ;i<t->length;++i ){
			int c=t->buf[i];
			if( !isdigit(c) ) break;
			n=n*10+(c-'0');
		}
	}
	*r=neg ? -n : n;
}

float bbStringToFloat( BBString *t ){
	char *p=bbStringToCString( t );
	float n=atof( p );
	bbMemFree( p );
	return n;
}

double bbStringToDouble( BBString *t ){
	char *p=bbStringToCString( t );
	double n=atof( p );
	bbMemFree( p );
	return n;
}

BBString *bbStringToLower( BBString *str ){
	int k;
	BBString *t;
	t=bbStringNew( str->length );
	for( k=0;k<str->length;++k ){
		int c=str->buf[k];
		t->buf[k]=(c>='A' && c<='Z') ? (c|32) : c;
	}
	return t;
}

BBString *bbStringToUpper( BBString *str ){
	int k;
	BBString *t;
	t=bbStringNew( str->length );
	for( k=0;k<str->length;++k ){
		int c=str->buf[k];
		t->buf[k]=(c>='a' && c<='z') ? (c&~32) : c;
	}
	return t;
}

char *bbStringToCString( BBString *str ){
	char *p;
	int k,sz=str->length;
	p=(char*)bbMemAlloc( sz+1 );
	for( k=0;k<sz;++k ) p[k]=str->buf[k];
	p[sz]=0;
	return p;
}

BBChar *bbStringToWString( BBString *str ){
	BBChar *p;
	int k,sz=str->length;
	p=(BBChar*)bbMemAlloc( (sz+1)*sizeof(BBChar) );
	memcpy(p,str->buf,sz*sizeof(BBChar));
	p[sz]=0;
	return p;
}

These files are under mod/brl.mod/blitz.mod

They [i]shouldn't be OS dependent and from what I can tell they aren't. These changes will not affect existing code in any way. All they do is add relative slices to strings and arrays. This allows you to use negative values in place of [(arr.Length-begin)..(arr.Length-end)] and instead just do [-5..] (<- gets the last five elements in the array).

Anyone who uses Python or Ruby probably misses this feature to an extent. I know I do. That's why I added it in the first place. And now I'm adding it again. So have at it.

Jay Kyburz

(Posted 2006) [#7]

So if you do this myArray[-12..6] will you get the elements in the array 12 from the end and 6 from the start.

and myArray [1..-1], will this trim the start and end characters? That would be cool.

Make it official!

N	(Posted 2006) [#8]

Jay: That is correct. It's very good at saving time typing since you don't have to go "myArray.Length - 12".

I had also added a Truncate method, but apparently my definition and Mark's differ, so that was a no-go.

boomboommax

(Posted 2006) [#9]

this is good, its cool, add it XD or the boys will be around

Jay Kyburz

(Posted 2006) [#10]

I think this would be great.

I don't like making changes to my mods because i work on at least 3 machines. It's a pain to keep them updated so I really hope this makes it into an official release.

Please!

Beaker

(Posted 2006) [#11]

Hope this gets added soon.

TeaVirus

(Posted 2006) [#12]

I've been wanting this for a while. Thanks Noel!

N	(Posted 2006) [#13]

Bumpetty bump.

N	(Posted 2006) [#14]

I have come for your leader.

N	(Posted 2006) [#15]

The pants are strong with you.

Beaker

(Posted 2006) [#16]

I'd still really like to see this become part of the official mod. Lots of other languages have 'negative' slicing like this, why not BlitzMax?