Added UInt and ULong types.

blitz.mod/blitz_array.c

@@ -82,6 +82,7 @@ static BBArray *allocateArray( const char *type,int dims,int *lens ){
 	case 'b':size=1;break;
 	case 's':size=2;break;
 	case 'l':size=8;break;
+	case 'y':size=8;break;
 	case 'd':size=8;break;
 	case '*':size=sizeof(void*);break;
 	case ':':size=sizeof(void*);flags=0;break;
@@ -358,7 +359,9 @@ static void IDENT( TYPE *lo,TYPE *hi ){\
 QSORTARRAY( unsigned char,_qsort_b )
 QSORTARRAY( unsigned short,qsort_s )
 QSORTARRAY( int,qsort_i )
+QSORTARRAY( unsigned int,qsort_u )
 QSORTARRAY( BBInt64,qsort_l );
+QSORTARRAY( BBUInt64,qsort_y );
 QSORTARRAY( float,qsort_f );
 QSORTARRAY( double,qsort_d );
 QSORTARRAY( BBSIZET,qsort_z );
@@ -370,7 +373,9 @@ QSORTARRAY( BBObject*,qsort_obj );
 QSORTARRAY( unsigned char,qsort_b_d )
 QSORTARRAY( unsigned short,qsort_s_d )
 QSORTARRAY( int,qsort_i_d )
+QSORTARRAY( unsigned int,qsort_u_d )
 QSORTARRAY( BBInt64,qsort_l_d );
+QSORTARRAY( BBUInt64,qsort_y_d );
 QSORTARRAY( float,qsort_f_d );
 QSORTARRAY( double,qsort_d_d );
 QSORTARRAY( BBSIZET,qsort_z_d );
@@ -389,7 +394,9 @@ void bbArraySort( BBArray *arr,int ascending ){
 		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 'u':qsort_u( (unsigned int*)p,(unsigned int*)p+n );break;
 		case 'l':qsort_l( (BBInt64*)p,(BBInt64*)p+n );break;
+		case 'y':qsort_y( (BBUInt64*)p,(BBUInt64*)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;
@@ -400,7 +407,9 @@ void bbArraySort( BBArray *arr,int ascending ){
 		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 'u':qsort_u_d( (unsigned int*)p,(unsigned int*)p+n );break;
 		case 'l':qsort_l_d( (BBInt64*)p,(BBInt64*)p+n );break;
+		case 'y':qsort_y_d( (BBUInt64*)p,(BBUInt64*)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.mod/blitz_cclib.c

@@ -137,3 +137,29 @@ BBSIZET bbSizetMin( BBSIZET x,BBSIZET y ){
 BBSIZET bbSizetMax( BBSIZET x,BBSIZET y ){ 
 	return x>y ? x : y;
 }
+
+BBUINT bbUIntAbs( BBUINT x ){
+	return x>=0 ? x : -x;
+}
+BBUINT bbUIntSgn( BBUINT x ){
+	return x==0 ? 0 : (x>0 ? 1 : -1);
+}
+BBUINT bbUIntMin( BBUINT x,BBUINT y ){
+	return x<y ? x : y;
+}
+BBUINT bbUIntMax( BBUINT x,BBUINT y ){ 
+	return x>y ? x : y;
+}
+
+BBULONG bbULongAbs( BBULONG x ){
+	return x>=0 ? x : -x;
+}
+BBULONG bbULongSgn( BBULONG x ){
+	return x==0 ? 0 : (x>0 ? 1 : -1);
+}
+BBULONG bbULongMin( BBULONG x,BBULONG y ){
+	return x<y ? x : y;
+}
+BBULONG bbULongMax( BBULONG x,BBULONG y ){ 
+	return x>y ? x : y;
+}

blitz.mod/blitz_cclib.h

@@ -64,6 +64,16 @@ BBSIZET bbSizetMax( BBSIZET x,BBSIZET y );
 BBSIZET bbSizetSgn( BBSIZET x );
 BBSIZET bbSizetAbs( BBSIZET x );
 
+BBUINT bbUIntMin( BBUINT x, BBUINT y );
+BBUINT bbUIntMax( BBUINT x, BBUINT y );
+BBUINT bbUIntSgn( BBUINT x );
+BBUINT bbUIntAbs( BBUINT x );
+
+BBULONG bbULongMin( BBULONG x, BBULONG y );
+BBULONG bbULongMax( BBULONG x, BBULONG y );
+BBULONG bbULongSgn( BBULONG x );
+BBULONG bbULongAbs( BBULONG x );
+
 #ifdef __cplusplus
 }
 #endif

blitz.mod/blitz_classes.i

@@ -60,6 +60,11 @@ String^Object{
 	-ToSizet:size_t()="bbStringToSizet"
 	+FromSizet:String( sizetValue:size_t )="bbStringFromSizet"
 
+	-ToUInt:UInt()="bbStringToUInt"
+	+FromUInt:String( uintValue:UInt )="bbStringFromUInt"
+	-ToULong:ULong()="bbStringToULong"
+	+FromULong:String( ulongValue:ULong )="bbStringFromULong"
+
 }AF="bbStringClass"
 
 ___Array^Object{

blitz.mod/blitz_string.c

@@ -64,7 +64,12 @@ BBClass bbStringClass={
 	bbStringToUTF8String,
 	
 	bbStringToSizet,
-	bbStringFromSizet
+	bbStringFromSizet,
+
+	bbStringToUInt,
+	bbStringFromUInt,
+	bbStringToULong,
+	bbStringFromULong
 
 };
 
@@ -127,6 +132,14 @@ BBString *bbStringFromInt( int n ){
 	return bbStringFromBytes( p,buf+64-p );
 }
 
+BBString *bbStringFromUInt( unsigned int n ){
+	char buf[64],*p=buf+64;
+	do{
+		*--p=n%10+'0';
+	}while(n/=10);
+	return bbStringFromBytes( p,buf+64-p );
+}
+
 BBString *bbStringFromLong( BBInt64 n ){
 	char buf[64],*p=buf+64;
 	int neg=n<0;
@@ -140,6 +153,14 @@ BBString *bbStringFromLong( BBInt64 n ){
 	return bbStringFromBytes( p,buf+64-p );
 }
 
+BBString *bbStringFromULong( BBUInt64 n ){
+	char buf[64],*p=buf+64;
+	do{
+		*--p=n%10+'0';
+	}while(n/=10);
+	return bbStringFromBytes( p,buf+64-p );
+}
+
 BBString *bbStringFromSizet( BBSIZET n ){
 	char buf[64],*p=buf+64;
 	do{
@@ -186,6 +207,15 @@ BBString *bbStringFromInts( const int *p,int n ){
 	return str;
 }
 
+BBString *bbStringFromUInts( const unsigned 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;
@@ -404,6 +434,40 @@ int bbStringToInt( BBString *t ){
 	return neg ? -n : n;
 }
 
+unsigned int bbStringToUInt( BBString *t ){
+	int i=0;
+	unsigned n=0;
+	
+	while( i<t->length && isspace(t->buf[i]) ) ++i;
+	if( i==t->length ) return 0;
+	
+	if( t->buf[i]=='+' ) ++i;
+	else if( 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 n;
+}
+
 BBInt64 bbStringToLong( BBString *t ){
 	int i=0,neg=0;
 	BBInt64 n=0;
@@ -439,6 +503,40 @@ BBInt64 bbStringToLong( BBString *t ){
 	return neg ? -n : n;
 }
 
+BBUInt64 bbStringToULong( BBString *t ){
+	int i=0;
+	BBUInt64 n=0;
+	
+	while( i<t->length && isspace(t->buf[i]) ) ++i;
+	if( i==t->length ){ return 0; }
+	
+	if( t->buf[i]=='+' ) ++i;
+	else if( 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 n;
+}
+
 BBSIZET bbStringToSizet( BBString *t ){
 	int i=0,neg=0;
 	BBSIZET n=0;

blitz.mod/blitz_string.h

@@ -22,14 +22,17 @@ extern	BBString bbEmptyString;
 BBString*bbStringNew( int len );
 BBString*bbStringFromChar( int c );
 
-BBString*bbStringFromInt( int n );
+BBString* bbStringFromInt( int n );
+BBString* bbStringFromUInt( unsigned int n );
 BBString*	bbStringFromLong( BBInt64 n );
+BBString*	bbStringFromULong( BBUInt64 n );
 BBString*	bbStringFromSizet( BBSIZET n );
 BBString*bbStringFromFloat( float n );
 BBString*	bbStringFromDouble( double n );
 BBString*	bbStringFromBytes( const char *p,int n );
 BBString*	bbStringFromShorts( const unsigned short *p,int n );
 BBString*	bbStringFromInts( const int *p,int n );
+BBString*	bbStringFromUInts( const unsigned int *p,int n );
 BBString*bbStringFromArray( BBArray *arr );
 BBString*	bbStringFromCString( const char *p );
 BBString*bbStringFromWString( const BBChar *p );
@@ -54,9 +57,11 @@ BBString*	bbStringToLower( BBString *str );
 BBString*	bbStringToUpper( BBString *str );
 
 int		bbStringToInt( BBString *str );
+unsigned int bbStringToUInt( BBString *str );
 float	bbStringToFloat( BBString *str );
 double	bbStringToDouble( BBString *str );
 BBInt64 bbStringToLong( BBString *str );
+BBUInt64 bbStringToULong( BBString *str );
 BBSIZET bbStringToSizet( BBString *str );
 char*	bbStringToCString( BBString *str );
 BBChar*	bbStringToWString( BBString *str );

blitz.mod/blitz_types.c

@@ -5,7 +5,9 @@ const char *bbVoidTypeTag="?";
 const char *bbByteTypeTag="b";
 const char *bbShortTypeTag="s";
 const char *bbIntTypeTag="i";
+const char *bbUIntTypeTag="u";
 const char *bbLongTypeTag="l";
+const char *bbULongTypeTag="y";
 const char *bbSizetTypeTag="z";
 const char *bbFloatTypeTag="f";
 const char *bbDoubleTypeTag="d";
@@ -18,7 +20,9 @@ BBINT bbConvertToInt( struct bbDataDef * data ){
 	case 'b':return data->b;
 	case 's':return data->s;
 	case 'i':return data->i;
+	case 'u':return data->u;
 	case 'l':return data->l;
+	case 'y':return data->y;
 	case 'z':return data->z;
 	case 'f':return data->f;
 	case 'd':return data->d;
@@ -27,12 +31,30 @@ BBINT bbConvertToInt( struct bbDataDef * data ){
 	return 0;
 }
 
+BBUINT bbConvertToUInt( struct bbDataDef * data ){
+	switch( data->type[0] ){
+	case 'b':return data->b;
+	case 's':return data->s;
+	case 'i':return data->i;
+	case 'u':return data->u;
+	case 'l':return data->l;
+	case 'y':return data->y;
+	case 'z':return data->z;
+	case 'f':return data->f;
+	case 'd':return data->d;
+	case '$':return bbStringToUInt( data->t );
+	}
+	return 0;
+}
+
 BBLONG bbConvertToLong( struct bbDataDef * data ){
 	switch( data->type[0] ){
 	case 'b':return data->b;
 	case 's':return data->s;
 	case 'i':return data->i;
+	case 'u':return data->u;
 	case 'l':return data->l;
+	case 'y':return data->y;
 	case 'z':return data->z;
 	case 'f':return data->f;
 	case 'd':return data->d;
@@ -41,12 +63,30 @@ BBLONG bbConvertToLong( struct bbDataDef * data ){
 	return 0;
 }
 
+BBULONG bbConvertToULong( struct bbDataDef * data ){
+	switch( data->type[0] ){
+	case 'b':return data->b;
+	case 's':return data->s;
+	case 'i':return data->i;
+	case 'u':return data->u;
+	case 'l':return data->l;
+	case 'y':return data->y;
+	case 'z':return data->z;
+	case 'f':return data->f;
+	case 'd':return data->d;
+	case '$':return bbStringToULong( data->t );
+	}
+	return 0;
+}
+
 BBFLOAT bbConvertToFloat( struct bbDataDef * data ){
 	switch( data->type[0] ){
 	case 'b':return data->b;
 	case 's':return data->s;
 	case 'i':return data->i;
+	case 'u':return data->u;
 	case 'l':return data->l;
+	case 'y':return data->y;
 	case 'z':return data->z;
 	case 'f':return data->f;
 	case 'd':return data->d;
@@ -60,7 +100,9 @@ BBDOUBLE bbConvertToDouble( struct bbDataDef * data ){
 	case 'b':return data->b;
 	case 's':return data->s;
 	case 'i':return data->i;
+	case 'u':return data->u;
 	case 'l':return data->l;
+	case 'y':return data->y;
 	case 'z':return data->z;
 	case 'f':return data->f;
 	case 'd':return data->d;
@@ -74,7 +116,9 @@ BBSTRING bbConvertToString( struct bbDataDef * data ){
 	case 'b':return bbStringFromInt( data->b );
 	case 's':return bbStringFromInt( data->s );
 	case 'i':return bbStringFromInt( data->i );
+	case 'u':return bbStringFromUInt( data->u );
 	case 'l':return bbStringFromLong( data->l );
+	case 'y':return bbStringFromULong( data->y );
 	case 'z':return bbStringFromSizet( data->z );
 	case 'f':return bbStringFromFloat( data->f );
 	case 'd':return bbStringFromFloat( data->d );
@@ -88,7 +132,9 @@ BBSIZET bbConvertToSizet( struct bbDataDef * data ){
 	case 'b':return data->b;
 	case 's':return data->s;
 	case 'i':return data->i;
+	case 'u':return data->u;
 	case 'l':return data->l;
+	case 'y':return data->y;
 	case 'z':return data->z;
 	case 'f':return data->f;
 	case 'd':return data->d;

blitz.mod/blitz_types.h

@@ -27,7 +27,9 @@ typedef struct BBInterfaceOffsets BBInterfaceOffsets;
 typedef unsigned char	BBBYTE;
 typedef unsigned short	BBSHORT;
 typedef signed int		BBINT;
+typedef unsigned int	BBUINT;
 typedef BBInt64			BBLONG;
+typedef BBUInt64		BBULONG;
 typedef float			BBFLOAT;
 typedef double			BBDOUBLE;
 typedef size_t			BBSIZET;
@@ -43,7 +45,9 @@ extern const char *bbVoidTypeTag;	//"?"
 extern const char *bbByteTypeTag;	//"b"
 extern const char *bbShortTypeTag;	//"s"
 extern const char *bbIntTypeTag;	//"i"
+extern const char *bbUIntTypeTag;	//"u"
 extern const char *bbLongTypeTag;	//"l"
+extern const char *bbULongTypeTag;	//"y"
 extern const char *bbSizetTypeTag;	//"z"
 extern const char *bbFloatTypeTag;	//"f"
 extern const char *bbDoubleTypeTag;	//"d"
@@ -57,7 +61,9 @@ struct bbDataDef {
 		BBBYTE b;
 		BBSHORT s;
 		BBINT i;
+		BBUINT u;
 		BBLONG l;
+		BBULONG y;
 		BBSIZET z;
 		BBFLOAT f;
 		BBDOUBLE d;