#include <asm.h>
#include "ltoa.h"



// ----------------------------------------------------------------
// Function:	Normal
// Purpose:		Simple copy of the converted number into
//					the OutString buffer.
//
//	Example:		n = 0x1000
//					OutString[]="0000004096";
//
//					n = 0x1000
//					flags = LTOA_LIMITER|7<<8
//					OutString[]="0004096";
//

inline void LTOA_Normal(char *destbuf, unsigned long n, unsigned short flags)
{

	asm ("	.set	noat
   addiu	$29, $29 ,-4
	sw		$31, 0($29)

	move	$15, $4	
	move	$4, $5				
	
	jal	LTOA_Convert
	nop
	

	la		$14, asciinumb				
	andi	$1, $6, 4
	beq	$1, $0, xan_tstl


	li		$13, 10					
	li		$12, 48
	addiu	$24, $14, 10				
		
xacz_2:
		lbu	$11, 0($14)			
		addiu	$14, $14, 1
		bne	$11, $12, xacz_3
		addiu	$13, $13, -1
	bgtz	$13, xacz_2


xacz_3:	
	addiu	$14, $14, -1				


xacz_4:
		lbu	$8, 0($14)		
		addiu	$14, $14, 1	
		sb		$8, 0($15)			
		addiu	$15, $15, 1
	bne	$14, $24, xacz_4
	
	j		xan_x


	 	 
xan_tstl:

 	andi	$1, $6, 2	
	bne	$1, $0, xan_2		


xan_ign:
	la		$14, asciinumb			
	lbu	$8, 0($14)
	lbu	$9, 1($14)
	lbu	$10, 2($14)
	lbu	$11, 3($14)
	lbu	$12, 4($14)
	lbu	$13, 5($14)
	lbu	$24, 6($14)
	lbu	$25, 7($14)
	sb		$8, 0($15)
	sb		$9, 1($15)
	sb		$10, 2($15)
	lbu	$8, 8($14)
	sb		$11, 3($15)
	lbu	$9, 9($14)
	sb		$12, 4($15)
	sb		$13, 5($15)
	sb		$24, 6($15)
	sb		$25, 7($15)
	sb		$8, 8($15)
	sb		$9, 9($15)
	addiu	$15, $15, 10	
	j		xan_x

	
	
xan_2:
	
	srl	$7, $6, 8		
	andi	$7, $7, 255		
	
	beq	$7, $0, xan_ign
 	sltiu	$1, $7, 10		
 	beq	$1, $0, xan_ign
 	
 	la		$6, asciinumb+10	
	subu	$6, $6, $7		
	
	
xan_3:							
		lbu	$8, 0($6)		
		addiu	$6, $6, 1
		sb		$0, 0($15)
		addiu	$15, $15, 1
		addiu	$7, $7, -1
	bgtz	$7, xan_3
	
	

xan_x:
	sb		$0, 0($15)	
	
	lw		$31, 0($29)
	addiu	$29, $29, 4
	
	jr		$31 ");
	
}






// ----------------------------------------------------------------
// Function:	Formated
// Purpose:		Formated Number output with the option to cut
//					the leading zeros.
//					The seperator defines the char which is to be used.
//					Like: 1.024 or 1-024
//


inline void LTOA_Formated(char *destbuf, unsigned long n, unsigned short flags, char seperator) 
{

//	.set	reorder

	asm ("	addiu	$29, $29 ,-4
	sw		$31, 0($29)
	
	move	$15, $4
	move	$4, $5
	
	move	$3, $7
	jal	LTOA_Convert
	nop
	
 
	la		$14, asciinumb			
	addiu	$24, $14, 10			
 	
	andi	$1, $6, 4
	beq	$1, $0, xafc			
	
 	li		$13, 10					
	li		$12, 48
 		
xafl0:
		lbu	$11, 0($14)			
		addiu	$14, $14, 1
		bne	$11, $12, xafl1
		addiu	$13, $13, -1
	bgtz	$13, xafl0


xafl1:	
	addiu	$14, $14, -1		


xafc:
	subu	$25, $24, $14			
	
	andi	$1, $6, 2
	beq	$1, $0, xaf_nolimit
	andi	$1, $6, 4
	bne	$1, $0, xaf_nolimit
	
	srl	$7, $6, 8
	andi	$7, $7, 255

	beq	$7, $0, xaf_nolimit	
 	sltiu	$1, $7, 10					
 	beq	$1, $0, xaf_nolimit

	move	$25, $7				
	subu	$14, $24, $25			
	
	
xaf_nolimit:
	li		$8, 0
 	sltiu	$1, $25, 4				
 	bne	$1, $0, xan_noli		
 	
 	li		$8, 1						
 	sltiu	$1, $25, 7					
 	bne	$1, $0, xan_noli
 	
 	li		$0, 2							
 	sltiu	$1, $25, 10					
 	bne	$1, $0, xan_noli
 	
 	li		$0, 3
  
xan_noli:
	addu	$15, $15, $8
	addu	$15, $15, $25				
	sb		$0, 0($15)					
	addiu	$15, $15, -1
	la		$25, asciinumb+9		
	addiu	$14, $14, -1					
										
	
xan_format:
	li		$12, 3
	
xan_for0:
		lbu	$8, 0($25)		
		addiu	$25, $25, -1
		sb		$8, 0($15)
		addiu	$8, $8, -1

		beq	$25, $14, xan_fx		
		
		addiu	$12, $12, -1
	bgtz	$12, xan_for0
	
	sb		$3, 0($15)			
	addiu	$15, $15, -1
	j		xan_format
	

xan_fx:
	lw		$31, 0($29)
	addiu	$29, $29, 4
	
 	jr		$31 ");
}




// ----------------------------------------------------------------
// Function:	Time
// Purpose:		The parameter n indicates the frames.
//					The frames are divided by the paramter framerate to
//					evaluate the time.
//					The time string looks like:
//					00:00:12 or if you define '.' as seperator then
//					00.00.00
//

inline void LTOA_Time(char *destbuf, unsigned long n, unsigned short flags, unsigned short framerate, char seperator)
{


//	.set	reorder

	asm ("	lw		$3, 16($29)		
	addiu	$29, $29 ,-4
	sw		$31, 0($29)
	
	move	$15, $4
	move	$4, $5
	
	divu	$4, $7				
	mflo	$4				
	
  	la		$14, asciinumb
	
	li		$8, 3600
	divu	$4, $8
	mfhi	$7						
	mflo	$4					
 	
 	andi	$1, $6, 32
 	beq	$1, $0, tnoh
 	
 	jal	LTOA_Convert
 	nop
 	
 	lbu	$8, 8($14)		
 	lbu	$9, 9($14)
	sb		$8, 0($15)
	sb		$9, 1($15)
	addiu	$15, $15, 2	
	
	
tnoh:	
 	li		$8, 60
	divu	$7, $8
	mfhi	$7
	mflo	$4
	
	andi	$1, $6, 16
	beq	$1, $0, tnom
	
	andi	$1, $6, 32
	beq	$1, $0, tnoh1

	sb		$3, 0($15)		
	addiu	$15, $15, 1		

tnoh1:
	jal	LTOA_Convert
	nop
	
	lbu	$8, 8($14)
	lbu	$9, 9($14)
	sb		$8, 0($15)
	sb		$9, 1($15)
	addiu	$15, $15, 2	
	

tnom:

	move	$4, $7
	
	andi	$1, $6, 8
	beq	$1, $0, tnos
	
	andi	$1, $6, 16
	beq	$1, $0, tnom1
	
	sb		$3, 0($15)		
	addiu	$15, $15, 1			
	
tnom1:
	jal	LTOA_Convert
	nop
	
	lbu	$8, 8($14)
	lbu	$9, 9($14)
	sb		$8, 0($15)
	sb		$9, 1($15)
	addiu	$15, $15, 2
	
tnos:
	sb		$0, 0($15)		
	
	
	lw		$31, 0($29)
	addiu	$29, $29, 4

 	jr		$31 ");
}





// ----------------------------------------------------------------
// Function:	Convert
// Purpose:		Convert the unsigned long passed as parameter
//					into the private AscII-Number buffer.
//
// USES:			t0, t1, t2, t3, t4, t5, a0
//

inline void LTOA_Convert(unsigned long n)
{

//	.set	reorder

	asm ("	la		$8, pot
	la		$9, asciinumb
	li		$10, 10
	li		$12, 48


xac_l0:
		lw		$11, 0($8)
		addiu	$10, $10, -1
		addiu	$8, $8, 4
		divu	$4, $11
		mfhi	$4
		mflo	$13
		addu	$13, $13, $12
		sb		$13, 0($9)
		addiu	$9, $9, 1
 	bgtz 	$10, xac_l0
	
	jr		$31 " );
	
}