Added longint and ulongint types

blitz.mod/blitz_array.c

@@ -69,6 +69,8 @@ static int arrayCellSize(const char * type, unsigned short data_size, int * flag
 		case '[':size=sizeof(void*);*flags=0;break;
 		case '(':size=sizeof(void*);break;
 		case 'z':size=sizeof(BBSIZET);break;
+		case 'v':size=sizeof(BBLONGINT);break;
+		case 'e':size=sizeof(BBULONGINT);break;
 		#ifdef _WIN32
 		case 'w':size=sizeof(WPARAM);break;
 		case 'x':size=sizeof(LPARAM);break;
@@ -451,6 +453,8 @@ QSORTARRAY( BBUInt64,qsort_y )
 QSORTARRAY( float,qsort_f )
 QSORTARRAY( double,qsort_d )
 QSORTARRAY( BBSIZET,qsort_z )
+QSORTARRAY( BBLONGINT,qsort_v )
+QSORTARRAY( BBULONGINT,qsort_e )
 #ifdef _WIN32
 QSORTARRAY( WPARAM,qsort_w )
 QSORTARRAY( LPARAM,qsort_x )
@@ -469,6 +473,8 @@ QSORTARRAY( BBUInt64,qsort_y_d )
 QSORTARRAY( float,qsort_f_d )
 QSORTARRAY( double,qsort_d_d )
 QSORTARRAY( BBSIZET,qsort_z_d )
+QSORTARRAY( BBLONGINT,qsort_v_d )
+QSORTARRAY( BBULONGINT,qsort_e_d )
 #ifdef _WIN32
 QSORTARRAY( WPARAM,qsort_w_d )
 QSORTARRAY( LPARAM,qsort_x_d )
@@ -495,6 +501,8 @@ void bbArraySort( BBArray *arr,int ascending ){
 		case 'd':qsort_d( (double*)p,(double*)p+n );break;
 		case '$':case ':':qsort_obj( (BBObject**)p,(BBObject**)p+n );break;
 		case 'z':qsort_z( (BBSIZET*)p,(BBSIZET*)p+n );break;
+		case 'v':qsort_v( (BBLONGINT*)p,(BBLONGINT*)p+n );break;
+		case 'e':qsort_e( (BBULONGINT*)p,(BBULONGINT*)p+n );break;
 #ifdef _WIN32
 		case 'w':qsort_w( (WPARAM*)p,(WPARAM*)p+n );break;
 		case 'x':qsort_x( (LPARAM*)p,(LPARAM*)p+n );break;
@@ -512,6 +520,8 @@ void bbArraySort( BBArray *arr,int ascending ){
 		case 'd':qsort_d_d( (double*)p,(double*)p+n );break;
 		case '$':case ':':qsort_obj_d( (BBObject**)p,(BBObject**)p+n );break;
 		case 'z':qsort_z_d( (BBSIZET*)p,(BBSIZET*)p+n );break;
+		case 'v':qsort_v_d( (BBLONGINT*)p,(BBLONGINT*)p+n );break;
+		case 'e':qsort_e_d( (BBULONGINT*)p,(BBULONGINT*)p+n );break;
 #ifdef _WIN32
 		case 'w':qsort_w_d( (WPARAM*)p,(WPARAM*)p+n );break;
 		case 'x':qsort_x_d( (LPARAM*)p,(LPARAM*)p+n );break;

blitz.mod/blitz_classes.i

@@ -70,6 +70,11 @@ String^Object{
 	+FromUTF32Bytes:String( utf32String:UInt Ptr, count )="bbStringFromUTF32Bytes"
 
 	-ToWStringBuffer:Short Ptr(buf:Short Ptr, length:Size_T Var)="bbStringToWStringBuffer"
+
+	-ToLongInt:LongInt()="bbStringToLongInt"
+	+FromLongInt:String( longIntValue:LongInt )="bbStringFromLongInt"
+	-ToULongInt:ULongInt()="bbStringToULongInt"
+	+FromULongInt:String( ulongIntValue:ULongInt )="bbStringFromULongInt"
 }AF="bbStringClass"
 
 ___Array^Object{

blitz.mod/blitz_classes.win32.i

@@ -75,6 +75,11 @@ String^Object{
 	+FromUTF32Bytes:String( utf32String:UInt Ptr, count )="bbStringFromUTF32Bytes"
 
 	-ToWStringBuffer:Short Ptr(buf:Short Ptr, length:Size_T Var)="bbStringToWStringBuffer"
+
+	-ToLongInt:LongInt()="bbStringToLongInt"
+	+FromLongInt:String( longIntValue:LongInt )="bbStringFromLongInt"
+	-ToULongInt:ULongInt()="bbStringToULongInt"
+	+FromULongInt:String( ulongIntValue:ULongInt )="bbStringFromULongInt"
 }AF="bbStringClass"
 
 ___Array^Object{

blitz.mod/blitz_string.c

@@ -97,6 +97,11 @@ struct BBClass_String bbStringClass={
 	bbStringFromUTF32String,
 	bbStringFromUTF32Bytes,
 	bbStringToWStringBuffer,
+
+	bbStringToLongInt,
+	bbStringFromLongInt,
+	bbStringToULongInt,
+	bbStringFromULongInt
 };
 
 BBString bbEmptyString={
@@ -191,6 +196,22 @@ BBString *bbStringFromSizet( BBSIZET n ){
 	return bbStringFromBytes( (unsigned char*)buf, strlen(buf) );
 }
 
+BBString *bbStringFromLongInt( BBLONGINT n ){
+	char buf[64];
+
+	sprintf(buf, "%ld", n);
+
+	return bbStringFromBytes( (unsigned char*)buf,strlen(buf) );
+}
+
+BBString *bbStringFromULongInt( BBULONGINT n ){
+	char buf[64];
+
+	sprintf(buf, "%lu", n);
+
+	return bbStringFromBytes( (unsigned char*)buf,strlen(buf) );
+}
+
 BBString *bbStringFromFloat( float n ){
 	char buf[64];
 	sprintf( buf,"%#.9g",n );
@@ -607,6 +628,75 @@ BBSIZET bbStringToSizet( BBString *t ){
 	return neg ? -n : n;
 }
 
+BBLONGINT bbStringToLongInt( BBString *t ){
+	int i=0,neg=0;
+	BBLONGINT 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');
+		}
+	}
+	//*r=neg ? -n : n;
+	return neg ? -n : n;
+}
+
+BBULONGINT bbStringToULongInt( BBString *t ){
+	int i=0,neg=0;
+	BBULONGINT 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;
+}
+
 float bbStringToFloat( BBString *t ){
 	char *p=(char*)bbStringToCString( t );
 	float n=atof( p );

blitz.mod/blitz_string.h

@@ -99,6 +99,11 @@ struct BBClass_String{
 	BBString* (*bbStringFromUTF32String)( const BBUINT *p );
 	BBString* (*bbStringFromUTF32Bytes)( const BBUINT *p, int n );
 	BBChar* (*bbStringToWStringBuffer)( BBString *str, BBChar * buf, size_t * length );
+
+	BBLONGINT (*bbStringToLongInt)( BBString *t );
+	BBString* (*bbStringFromLongInt)( BBLONGINT n );
+	BBULONGINT (*bbStringToULongInt)( BBString *t );
+	BBString* (*bbStringFromULongInt)( BBULONGINT n );
 };
 
 extern	struct BBClass_String bbStringClass;
@@ -123,6 +128,8 @@ BBString*	bbStringFromCString( const char *p );
 BBString*bbStringFromWString( const BBChar *p );
 BBString*bbStringFromUTF8String( const unsigned char *p );
 BBString *bbStringFromUTF8Bytes( const unsigned char *p,int n );
+BBString*	bbStringFromLongInt( BBLONGINT n );
+BBString*	bbStringFromULongInt( BBULONGINT n );
 
 BBString*	bbStringToString( BBString *t );
 int		bbStringCompare( BBString *x,BBString *y );
@@ -152,6 +159,8 @@ BBSIZET bbStringToSizet( BBString *str );
 unsigned char* bbStringToCString( BBString *str );
 BBChar*	bbStringToWString( BBString *str );
 unsigned char* bbStringToUTF8String( BBString *str );
+BBLONGINT bbStringToLongInt( BBString *str );
+BBULONGINT bbStringToULongInt( BBString *str );
 
 BBUINT* bbStringToUTF32String( BBString *str );
 BBString* bbStringFromUTF32String( const BBUINT *p );

blitz.mod/blitz_types.c

@@ -9,6 +9,8 @@ const char *bbUIntTypeTag="u";
 const char *bbLongTypeTag="l";
 const char *bbULongTypeTag="y";
 const char *bbSizetTypeTag="z";
+const char *bbLongIntTypeTag="v";
+const char *bbULongIntTypeTag="e";
 const char *bbFloatTypeTag="f";
 const char *bbDoubleTypeTag="d";
 const char *bbStringTypeTag="$";
@@ -24,6 +26,8 @@ BBINT bbConvertToInt( struct bbDataDef * data ){
 	case 'l':return data->l;
 	case 'y':return data->y;
 	case 'z':return data->z;
+	case 'v':return data->v;
+	case 'e':return data->e;
 	case 'f':return data->f;
 	case 'd':return data->d;
 	case '$':return bbStringToInt( data->t );
@@ -40,6 +44,8 @@ BBUINT bbConvertToUInt( struct bbDataDef * data ){
 	case 'l':return data->l;
 	case 'y':return data->y;
 	case 'z':return data->z;
+	case 'v':return data->v;
+	case 'e':return data->e;
 	case 'f':return data->f;
 	case 'd':return data->d;
 	case '$':return bbStringToUInt( data->t );
@@ -56,6 +62,8 @@ BBLONG bbConvertToLong( struct bbDataDef * data ){
 	case 'l':return data->l;
 	case 'y':return data->y;
 	case 'z':return data->z;
+	case 'v':return data->v;
+	case 'e':return data->e;
 	case 'f':return data->f;
 	case 'd':return data->d;
 	case '$':return bbStringToLong( data->t );
@@ -72,6 +80,8 @@ BBULONG bbConvertToULong( struct bbDataDef * data ){
 	case 'l':return data->l;
 	case 'y':return data->y;
 	case 'z':return data->z;
+	case 'v':return data->v;
+	case 'e':return data->e;
 	case 'f':return data->f;
 	case 'd':return data->d;
 	case '$':return bbStringToULong( data->t );
@@ -88,6 +98,8 @@ BBFLOAT bbConvertToFloat( struct bbDataDef * data ){
 	case 'l':return data->l;
 	case 'y':return data->y;
 	case 'z':return data->z;
+	case 'v':return data->v;
+	case 'e':return data->e;
 	case 'f':return data->f;
 	case 'd':return data->d;
 	case '$':return bbStringToFloat( data->t );
@@ -104,6 +116,8 @@ BBDOUBLE bbConvertToDouble( struct bbDataDef * data ){
 	case 'l':return data->l;
 	case 'y':return data->y;
 	case 'z':return data->z;
+	case 'v':return data->v;
+	case 'e':return data->e;
 	case 'f':return data->f;
 	case 'd':return data->d;
 	case '$':return bbStringToFloat( data->t );
@@ -120,6 +134,8 @@ BBSTRING bbConvertToString( struct bbDataDef * data ){
 	case 'l':return bbStringFromLong( data->l );
 	case 'y':return bbStringFromULong( data->y );
 	case 'z':return bbStringFromSizet( data->z );
+	case 'v':return bbStringFromLongInt( data->v );
+	case 'e':return bbStringFromULongInt( data->e );
 	case 'f':return bbStringFromFloat( data->f );
 	case 'd':return bbStringFromFloat( data->d );
 	case '$':return data->t;
@@ -136,9 +152,47 @@ BBSIZET bbConvertToSizet( struct bbDataDef * data ){
 	case 'l':return data->l;
 	case 'y':return data->y;
 	case 'z':return data->z;
+	case 'v':return data->v;
+	case 'e':return data->e;
 	case 'f':return data->f;
 	case 'd':return data->d;
 	case '$':return bbStringToSizet( data->t );
 	}
 	return 0;
 }
+
+BBLONGINT bbConvertToLongInt( 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 'v':return data->v;
+	case 'e':return data->e;
+	case 'f':return data->f;
+	case 'd':return data->d;
+	case '$':return bbStringToLongInt( data->t );
+	}
+	return 0;
+}
+
+BBULONGINT bbConvertToULongInt( 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 'v':return data->v;
+	case 'e':return data->e;
+	case 'f':return data->f;
+	case 'd':return data->d;
+	case '$':return bbStringToULongInt( data->t );
+	}
+	return 0;
+}

blitz.mod/blitz_types.h

@@ -36,6 +36,8 @@ typedef BBUInt64		BBULONG;
 typedef float			BBFLOAT;
 typedef double			BBDOUBLE;
 typedef size_t			BBSIZET;
+typedef long			BBLONGINT;
+typedef unsigned long	BBULONGINT;
 typedef BBClass*		BBCLASS;
 typedef BBObject*		BBOBJECT;
 typedef BBString*		BBSTRING;
@@ -61,6 +63,8 @@ extern const char *bbUIntTypeTag;	//"u"
 extern const char *bbLongTypeTag;	//"l"
 extern const char *bbULongTypeTag;	//"y"
 extern const char *bbSizetTypeTag;	//"z"
+extern const char *bbLongIntTypeTag; //"v"
+extern const char *bbULongIntTypeTag; //"e"
 extern const char *bbFloatTypeTag;	//"f"
 extern const char *bbDoubleTypeTag;	//"d"
 extern const char *bbStringTypeTag;	//"$"
@@ -78,6 +82,8 @@ struct bbDataDef {
 		BBLONG l;
 		BBULONG y;
 		BBSIZET z;
+		BBLONGINT v;
+		BBULONGINT e;
 		BBFLOAT f;
 		BBDOUBLE d;
 		BBSTRING t;
@@ -92,6 +98,8 @@ BBFLOAT bbConvertToFloat( struct bbDataDef * data );
 BBDOUBLE bbConvertToDouble( struct bbDataDef * data );
 BBSTRING bbConvertToString( struct bbDataDef * data );
 BBSIZET bbConvertToSizet( struct bbDataDef * data );
+BBLONGINT bbConvertToLongInt( struct bbDataDef * data );
+BBULONGINT bbConvertToULongInt( struct bbDataDef * data );
 
 #ifdef __cplusplus
 }