math.hhf

High Level assembly language(HLA)软件

#if( ! @defined( math_hhf ))
?math_hhf := true;

#includeonce( "hla.hhf" )

namespace math; @fast;

		
	// The following procedures all use ESP to access their
	// parameters.  Therefore, we've got to set an explicit
	// parmoffset value for each of these.
	//
	//	WARNING: These @parmoffset assignments must be kept
	//	in sync with the actual source code.  See the source
	//	code for details.
	
			  
	procedure addq( left:qword; right:qword; var dest:qword ); 
		@external( "MATH_ADDQ" );
	
	

	procedure addl( left:lword; right:lword; var dest:lword ); 
		@external( "MATH_ADDL" );


	procedure subq( left:qword; right:qword; var dest:qword ); 
		@external( "MATH_SUBQ" );
	

	procedure subl( left:lword; right:lword; var dest:lword ); 
		@external( "MATH_SUBL" );


	procedure andq( left:qword; right:qword; var dest:qword ); 
		@external( "MATH_ANDQ" );


	procedure andl( left:lword; right:lword; var dest:lword ); 
		@external( "MATH_ANDL" );


	procedure orq( left:qword; right:qword; var dest:qword ); 
		@external( "MATH_ORQ" );


	procedure orl( left:lword; right:lword; var dest:lword ); 
		@external( "MATH_ORL" );


	procedure xorq( left:qword; right:qword; var dest:qword ); 
		@external( "MATH_XORQ" );


	procedure xorl( left:lword; right:lword; var dest:lword ); 
		@external( "MATH_XORL" );


	procedure shlq( count:dword; source:qword; var dest:qword ); 
		@external( "MATH_SHLQ" );

	procedure shrq( count:dword; source:qword; var dest:qword ); 
		@external( "MATH_SHRQ" );

	procedure shll( count:dword; source:lword; var dest:lword ); 
		@external( "MATH_SHLL" );

	procedure shrl( count:dword; source:lword; var dest:lword ); 
		@external( "MATH_SHRL" );
		
		
		
	
	procedure negq( source:qword; var dest:qword ); 
		@external( "MATH_NEGQ" );

	procedure negl( source:lword; var dest:lword ); 
		@external( "MATH_NEGL" );
		
		
	
	procedure notq( source:qword; var dest:qword ); 
		@external( "MATH_NOTQ" );

	procedure notl( source:lword; var dest:lword ); 
		@external( "MATH_NOTL" );
	





	procedure mulq( left:qword; right:qword; var dest:qword );
		@external( "MATH_MULQ" );

	procedure mull( left:lword; right:lword; var dest:lword );
		@external( "MATH_MULL" );
		
	procedure imulq( left:qword; right:qword; var dest:qword );
		@external( "MATH_IMULQ" );

	procedure imull( left:lword; right:lword; var dest:lword );
		@external( "MATH_IMULL" );

	procedure divq( left:qword; right:qword; var dest:qword ); 
		@external( "MATH_DIVQ" );
	
	procedure divl( left:lword; right:lword; var dest:lword ); 
		@external( "MATH_DIVL" );

	procedure modq( left:qword; right:qword; var dest:qword ); 
		@external( "MATH_MODQ" );
	
	procedure modl( left:lword; right:lword; var dest:lword ); 
		@external( "MATH_MODL" );

	procedure idivq( left:qword; right:qword; var dest:qword ); 
		@external( "MATH_IDIVQ" );
	
	procedure idivl( left:lword; right:lword; var dest:lword ); 
		@external( "MATH_IDIVL" );

	procedure imodq( left:qword; right:qword; var dest:qword ); 
		@external( "MATH_IMODQ" );
	
	procedure imodl( left:lword; right:lword; var dest:lword ); 
		@external( "MATH_IMODL" );
	

	procedure div64
	( 
	    	Dividend:   qword; 
	    	Divisor:    qword; 
	    var QuotAdrs:   qword; 
	    var RmndrAdrs:  qword 
	);  @external( "MATH_DIV64" );

	procedure div128
	( 
	    	Dividend:   lword; 
	    	Divisor:    lword; 
	    var QuotAdrs:   lword; 
	    var RmndrAdrs:  lword 
	);  @external( "MATH_DIV128" );
		




	#macro sincos( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._sincos() )
			hla.signature( math.sincos32(real32) )
			hla.signature( math.sincos64(real64) )
			hla.signature( math.sincos80(real80) )
			
		hla.endoverload
		
	#endmacro


	procedure _sincos;					@returns( "st0" );
		@external( "MATH__SINCOS" );
		
	procedure sincos32( r32:real32 );		@returns( "st0" ); 
			@external( "MATH_SINCOS32" );

	procedure sincos64( r64:real64 );		@returns( "st0" ); 
			@external( "MATH_SINCOS64" );

	procedure sincos80( r80:real80 );		@returns( "st0" ); 
			@external( "MATH_SINCOS80" );

		

	#macro sin( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._sin() )
			hla.signature( math.sin32(real32) )
			hla.signature( math.sin64(real64) )
			hla.signature( math.sin80(real80) )
			
		hla.endoverload
		
	#endmacro


	procedure _sin;						@returns( "st0" );
		@external( "MATH__SIN" );
		
	procedure sin32( r32:real32 );		@returns( "st0" ); 
			@external( "MATH_SIN32" );

	procedure sin64( r64:real64 );		@returns( "st0" ); 
			@external( "MATH_SIN64" );

	procedure sin80( r80:real80 );		@returns( "st0" ); 
			@external( "MATH_SIN80" );

		

	#macro cos( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._cos() )
			hla.signature( math.cos32(real32) )
			hla.signature( math.cos64(real64) )
			hla.signature( math.cos80(real80) )
			
		hla.endoverload
		
	#endmacro


	procedure _cos;						@returns( "st0" );
		@external( "MATH__COS" );
		
	procedure cos32( r32:real32 );		@returns( "st0" ); 
			@external( "MATH_COS32" );

	procedure cos64( r64:real64 );		@returns( "st0" ); 
			@external( "MATH_COS64" );

	procedure cos80( r80:real80 );		@returns( "st0" ); 
			@external( "MATH_COS80" );

		

	#macro cot( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._cot() )
			hla.signature( math.cot32(real32) )
			hla.signature( math.cot64(real64) )
			hla.signature( math.cot80(real80) )
			
		hla.endoverload
		
	#endmacro


	procedure _cot; 					@returns( "st0" ); 
			@external( "MATH__COT" );

	procedure cot32( r32:real32 );		@returns( "st0" ); 
			@external( "MATH_COT32" );

	procedure cot64( r64:real64 );		@returns( "st0" ); 
			@external( "MATH_COT64" );

	procedure cot80( r80:real80 );		@returns( "st0" ); 
			@external( "MATH_COT80" );










	#macro csc( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._csc() )
			hla.signature( math.csc32(real32) )
			hla.signature( math.csc64(real64) )
			hla.signature( math.csc80(real80) )
			
		hla.endoverload
		
	#endmacro

	procedure _csc;						@returns( "st0" ); 
			@external( "MATH__CSC" );

	procedure csc32( r: real32 ); 		@returns( "st0" ); 
			@external( "MATH_CSC32" );

	procedure csc64( r: real64 ); 		@returns( "st0" ); 
			@external( "MATH_CSC64" );

	procedure csc80( r: real80 ); 		@returns( "st0" ); 
			@external( "MATH_CSC80" );






	#macro sec( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._sec() )
			hla.signature( math.sec32(real32) )
			hla.signature( math.sec64(real64) )
			hla.signature( math.sec80(real80) )
			
		hla.endoverload
		
	#endmacro

	procedure _sec;						@returns( "st0" ); 
			@external( "MATH__SEC" );

	procedure sec32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_SEC32" );

	procedure sec64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_SEC64" );

	procedure sec80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_SEC80" );






	#macro tan( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._tan() )
			hla.signature( math.tan32(real32) )
			hla.signature( math.tan64(real64) )
			hla.signature( math.tan80(real80) )
			
		hla.endoverload
		
	#endmacro

	procedure _tan;						@returns( "st0" ); 
			@external( "MATH__TAN" );

	procedure tan32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_TAN32" );

	procedure tan64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_TAN64" );

	procedure tan80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_TAN80" );





	#macro atan( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._atan() )
			hla.signature( math.atan32(real32) )
			hla.signature( math.atan64(real64) )
			hla.signature( math.atan80(real80) )
			
		hla.endoverload
		
	#endmacro

	procedure _atan;						@returns( "st0" ); 
			@external( "MATH__ATAN" );

	procedure atan32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_ATAN32" );

	procedure atan64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_ATAN64" );

	procedure atan80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_ATAN80" );


	


	#macro asin( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._asin() )
			hla.signature( math.asin32(real32) )
			hla.signature( math.asin64(real64) )
			hla.signature( math.asin80(real80) )
			
		hla.endoverload
		
	#endmacro

	
	procedure _asin; 					@returns( "st0" ); 
			@external( "MATH__ASIN" );

	procedure asin32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_ASIN32" );

	procedure asin64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_ASIN64" );

	procedure asin80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_ASIN80" );



	


	#macro acos( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._acos() )
			hla.signature( math.acos32(real32) )
			hla.signature( math.acos64(real64) )
			hla.signature( math.acos80(real80) )
			
		hla.endoverload
		
	#endmacro

	
	procedure _acos; 					@returns( "st0" ); 
			@external( "MATH__ACOS" );

	procedure acos32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_ACOS32" );

	procedure acos64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_ACOS64" );

	procedure acos80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_ACOS80" );


	
	
	
	

	#macro acot( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._acot() )
			hla.signature( math.acot32(real32) )
			hla.signature( math.acot64(real64) )
			hla.signature( math.acot80(real80) )
			
		hla.endoverload
		
	#endmacro

	
	
	procedure _acot; 					@returns( "st0" ); 
			@external( "MATH__ACOT" );

	procedure acot32( r:real32 ); 		@returns( "st0" );