strings.hhf

High Level assembly language(HLA)软件

		@external( "STR_A_UPPER" );

	#macro lower( parms[] );
	
		hla.overload( parms )
		
			hla.signature( str.lower1(string) )
			hla.signature( str.lower2(string, string) )
			
		hla.endoverload
		
	#endmacro

	procedure lower1( s: string ); 					@external( "STR_LOWER1" );
	procedure lower2( src: string; dest:string ); 	@external( "STR_LOWER2" );
	procedure a_lower( src: string );
		@returns( "(type string eax)" );
		@external( "STR_A_LOWER" );


	#macro translate( parms[] );
	
		hla.overload( parms )
		
			hla.signature( str.translate3(string, string, string ) )
			hla.signature( str.translate4(string, string, string, string) )
			
		hla.endoverload
		
	#endmacro

	procedure translate3
	( 
		src:string; 
		from:string; 
		toStr:string 
	);	@external( "STR_TRANSLATE3" );

	procedure translate4
	( 
		src:string; 
		from:string; 
		toStr:string; 
		dest:string 
	);	@external( "STR_TRANSLATE4" );

	procedure a_translate( src:string; from:string; toStr:string );
		@returns( "(type string eax)" ); 
		@external( "STR_A_TRANSLATE" );	
	

	#macro reverse( parms[] );
	
		hla.overload( parms )
		
			hla.signature( str.reverse1(string ) )
			hla.signature( str.reverse2(string, string ) )
			
		hla.endoverload
		
	#endmacro

	procedure reverse1( dest:string );
		@external( "STR_REVERSE1" );

	procedure reverse2( src:string; dest:string );
		@external( "STR_REVERSE2" );

	procedure a_reverse( src:string );
		@returns( "(type string eax)" );
		@external( "STR_A_REVERSE" );






	// String concatentation functions.
	
	#macro cat( parms[] );
	
		hla.overload( parms )
		
			hla.signature( str.cat2(string, string) )
			hla.signature( str.cat3(string, string, string) )
			
		hla.endoverload
		
	#endmacro


	procedure cat2( src:string; dest:string );		
		@external( "STR_CAT2" );

	procedure cat3( src1:string; src2:string; dest:string ); 
		@returns( "(type string eax)" ); 
		@external( "STR_CAT3" );

	procedure a_cat( src1:string; src2:string ); 
		@returns( "(type string eax)" ); 
		@external( "STR_A_CAT" );




	procedure catz( zsrc:zstring; dest:string ); 
		@external( "STR_CATZ" );

	procedure a_catz( zsrc:zstring; ssrc:string ); 
		@returns( "(type string eax)" ); 
		@external( "STR_A_CATZ" );



	#macro catsub( parms[] );
	
		hla.overload( parms )
		
			hla.signature( str.catsub4(string, dword, dword, string) )
			hla.signature( str.catsub5(string, dword, dword, string, string) )
			
		hla.endoverload
		
	#endmacro


	procedure catsub4( src:string; start:dword; len:dword; dest:string );		
		@external( "STR_CATSUB4" );

	procedure catsub5
	( 
		src2	:string; 
		start	:dword; 
		len		:dword; 
		src1	:string; 
		dest	:string 
	); 
		@external( "STR_CATSUB5" );

	procedure a_catsub( src2:string; start:dword; len:dword; src1:string ); 
		@returns( "(type string eax)" ); 
		@external( "STR_A_CATSUB" );



	const
		a_catbuf	:text := "str.a_catbuf3";
		catbuf		:text := "str.catbuf3a";
		
	procedure a_catbuf2( src1:@global:buf_t; src2:string );		
		@returns( "(type string eax)" ); 
		@external( "STR_A_CATBUF3" );		// Yes, STR_A_CATBUF3

	procedure a_catbuf3
	( 
		startBuf	:dword; 
		endBuf		:dword; 
		src			:string 
	); 
		@returns( "(type string eax)" ); 
		@external( "STR_A_CATBUF3" );



	procedure catbuf2( src:@global:buf_t; dest:string );		
		@external( "STR_CATBUF3A" );		// Yes, STR_CATBUF3A

	procedure catbuf3a
	( 
		startBuf	:dword; 
		endBuf		:dword; 
		dest		:string 
	); 
		@external( "STR_CATBUF3A" );

	procedure catbuf3b
	( 
		src1		:@global:buf_t; 
		src2		:string; 
		dest		:string 
	); 
		@external( "STR_CATBUF4" );	// Yes, STR_CATBUF4

	procedure catbuf4
	( 
		startBuf	:dword; 
		endBuf		:dword;
		src2		:string; 
		dest		:string 
	); 
		@external( "STR_CATBUF4" );





		
	// Value concatenation routines:
			   
	procedure catbool( dest:string;  b:boolean );
		@external( "STR_CATBOOL" );

	procedure catcSize( dest:string;  c:char; width:int32; fill:char );
		@external( "STR_CATCSIZE" );

	procedure catc( dest:string;  c:char );
		@external( "STR_CATC" );


	procedure cats( dest:string;  src:string );
		@external( "STR_CATS" );

	procedure catsSize( dest:string; s:string; width:int32; fill:char );
		@external( "STR_CATSSIZE" );


	procedure catzs( dest:string;  src:zstring );
		@external( "STR_CATZS" );

	procedure catzsSize( dest:string; s:zstring; width:int32; fill:char );
		@external( "STR_CATZSSIZE" );


	procedure catcset( dest:string;  c:cset );
		@external( "STR_CATCSET" );


	procedure catb( dest:string;  b:byte );
		@external( "STR_CATB" );

	procedure catw( dest:string;  w:word );
		@external( "STR_CATW" );

	procedure catd( dest:string;  d:dword );
		@external( "STR_CATD" );

	procedure catq( dest:string;  q:qword );
		@external( "STR_CATQ" );

	procedure cattb( dest:string;  tb:tbyte );
		@external( "STR_CATTB" );
		
	procedure catl( dest:string;  l:lword );
		@external( "STR_CATL" );


	// Note: catbSize, catwSize, ..., catlSize are all deprecated.
	
	procedure catbSize( dest:string;  b:byte; size:dword; fill:char );
		@external( "STR_CATH8SIZE" );

	procedure catwSize( dest:string;  w:word; size:dword; fill:char );
		@external( "STR_CATH16SIZE" );

	procedure catdSize( dest:string;  d:dword; size:dword; fill:char );
		@external( "STR_CATH32SIZE" );

	procedure catqSize( dest:string;  q:qword; size:dword; fill:char );
		@external( "STR_CATH64SIZE" );

	procedure cattbSize( dest:string;  tb:tbyte; size:dword; fill:char );
		@external( "STR_CATH80SIZE" );

	procedure catlSize( dest:string;  l:lword; size:dword; fill:char );
		@external( "STR_CATH128SIZE" );






	procedure cath8( dest:string;  b:byte );
		@external( "STR_CATH8" );

	procedure cath16( dest:string;  w:word );
		@external( "STR_CATH16" );

	procedure cath32( dest:string;  d:dword );
		@external( "STR_CATH32" );

	procedure cath64( dest:string;  q:qword );
		@external( "STR_CATH64" );

	procedure cath80( dest:string;  tb:tbyte );
		@external( "STR_CATH80" );

	procedure cath128( dest:string;  l:lword );
		@external( "STR_CATH128" );

		

	procedure cath8Size( dest:string;  b:byte; size:dword; fill:char );
		@external( "STR_CATH8SIZE" );

	procedure cath16Size( dest:string;  w:word; size:dword; fill:char );
		@external( "STR_CATH16SIZE" );

	procedure cath32Size( dest:string;  d:dword; size:dword; fill:char );
		@external( "STR_CATH32SIZE" );

	procedure cath64Size( dest:string;  q:qword; size:dword; fill:char );
		@external( "STR_CATH64SIZE" );

	procedure cath80Size( dest:string;  tb:tbyte; size:dword; fill:char );
		@external( "STR_CATH80SIZE" );

	procedure cath128Size( dest:string;  l:lword; size:dword; fill:char );
		@external( "STR_CATH128SIZE" );





	procedure catu8( dest:string;  u8:byte );
		@external( "STR_CATU8" );

	procedure catu8Size
	( 
		dest:string; 
		u8:byte; 
		width:int32; 
		fill:char 
	);
	@external( "STR_CATU8SIZE" );

	procedure catu16( dest:string;  u16:word );
		@external( "STR_CATU16" );

	procedure catu16Size
	( 
		dest:string; 
		u16:word; 
		width:int32;
		fill:char 
	);
	@external( "STR_CATU16SIZE" );

	procedure catu32( dest:string;  u32:dword );
		@external( "STR_CATU32" );

	procedure catu32Size
	( 
		dest:string;
		u32:dword; 
		width:int32;
		fill:char 
	);
	@external( "STR_CATU32SIZE" );

	procedure catu64( dest:string;  u64:qword );
		@external( "STR_CATU64" );

	procedure catu64Size
	( 
		dest:string;
		u64:qword; 
		width:int32;
		fill:char 
	);
	@external( "STR_CATU64SIZE" );

	procedure catu128( dest:string;  u128:lword );
		@external( "STR_CATU128" );

	procedure catu128Size
	( 
		dest:string;
		u128:lword; 
		width:int32;
		fill:char 
	);
	@external( "STR_CATU128SIZE" );







	procedure cati8( dest:string;  i8:byte );
		@external( "STR_CATI8" );

	procedure cati8Size
	( 
		dest:string;
		i8:byte; 
		width:int32; 
		fill:char 
	);
	@external( "STR_CATI8SIZE" );

	procedure cati16( dest:string;  i16:word );
		@external( "STR_CATI16" );

	procedure cati16Size
	( 
		dest:string;
		i16:word; 
		width:int32;
		fill:char 
	);
	@external( "STR_CATI16SIZE" );

	procedure cati32( dest:string;  i32:dword );
		@external( "STR_CATI32" );

	procedure cati32Size
	( 
		dest:string; 
		i32:dword; 
		width:int32;
		fill:char 
	);
	@external( "STR_CATI32SIZE" );

	procedure cati64( dest:string;  i64:qword );
		@external( "STR_CATI64" );

	procedure cati64Size
	( 
		dest:string; 
		i64:qword; 
		width:int32;
		fill:char 
	);
	@external( "STR_CATI64SIZE" );

	procedure cati128( dest:string;  i128:lword );
		@external( "STR_CATI128" );

	procedure cati128Size
	( 
		dest:string; 
		i128:lword; 
		width:int32;
		fill:char 
	);
	@external( "STR_CATI128SIZE" );


	procedure catr80
	( 
		dest:string; 
		r:real80; 
		width:int32; 
		decpts:uns32
	);  
	@external( "STR_CATR80" );

	procedure catr80pad
	( 
		dest:string; 
		r:real80; 
		width:int32; 
		decpts:uns32; 
		pad:char
	);  
	@external( "STR_CATR80PAD" );

	procedure catr64
	( 
		dest:string; 
		r:real64; 
		width:int32; 
		decpts:uns32
	);  
	@external( "STR_CATR64" );

	procedure catr64pad
	( 
		dest:string; 
		r:real64; 
		width:int32; 
		decpts:uns32; 
		pad:char
	);  
	@external( "STR_CATR64PAD" );

	procedure catr32
	( 
		dest:string; 
		r:real32; 
		width:int32; 
		decpts:uns32
	);  
	@external( "STR_CATR32" );

	procedure catr32pad
	( 
		dest:string; 
		r:real32; 
		width:int32; 
		decpts:uns32; 
		pad:char
	);  
	@external( "STR_CATR32PAD" );




	procedure cate80
	( 
		dest:string; 
		r:real80; 
		width:int32 
	);  
	@external( "STR_CATE80" );


	procedure cate64
	( 
		dest:string; 
		r:real64; 
		width:int32 
	);  
	@external( "STR_CATE64" );


	procedure cate32
	( 
		dest:string; 
		r:real32; 
		width:int32 
	);  
	@external( "STR_CATE32" );



	// The following macros provide the same interface to cate32, cate64,
	// and cate80 as the plain (without size/fill char) integer output
	// routines:
		
	
	#macro _cate80( _cate80_s_, _cate80_r_ );
	
		@global:str.cate80( _cate80_s_, _cate80_r_, 28 )
		
	#endmacro

	#macro _cate64( _cate64_s_, _cate64_r_ );
	
		@global:str.cate64( _cate64_s_, _cate64_r_, 22 )
		
	#endmacro

	#macro _cate32( _cate32_s_, _cate32_r_ );
	
		@global:str.cate32( _cate32_s_, _cate32_r_, 15 )
		
	#endmacro


	// The following macros provide the same interface (for the cat macro)
	// as the integerSize functions:
	
	#macro cate80_( _cate80_s_, _cate80_r_, _cate80_w_, _cate80_f_ );
	
		@global:str.cate80( _cate80_s_, _cate80_r_, _cate80_w_ )
		
	#endmacro


	#macro cate64_( _cate64_s_, _cate64_r_, _cate64_w_, _cate64_f_ );
	
		@global:str.cate64( _cate64_s_, _cate64_r_, _cate64_w_ )
		
	#endmacro


	#macro cate32_( _cate32_s_, _cate32_r_, _cate32_w_, _cate32_f_ );
	
		@global:str.cate32( _cate32_s_, _cate32_r_, _cate32_w_ )
		
	#endmacro



	#macro zlen( z );
	
		#print( "WARNING! str.zlen is deprecated, use zstr.len instead" )
		@global:zstr.len(z)
		
	#endmacro
	
	#macro zcmp( z );
	
		#print( "WARNING! str.zcmp is deprecated, use zstr.cmpstr instead" )
		@global:zstr.zcmp(z)
		
	#endmacro
	
	#macro zcpy( z );