void __attribute__((__stkparm__)) __sprintf_ushort_16__(unsigned char *str, unsigned short val);
asm("
__sprintf_ushort_16__:
movem.l %d0-%d6/%a0-%a1,-(%sp)
lea -6(%sp),%sp
movea.l %sp,%a0
moveq #0x30,%d1
moveq #0x41-10,%d2
moveq #0xF,%d3
moveq #0x9,%d4
movea.l 46(%sp),%a1
move.w 50(%sp),%d5
bne.s __sus16_loop__
move.b %d1,(%a1)+
bra.s __sus16_cleanup_and_bye__
___sus16_loop__:
lsr.w #4,%d5
__sus16_loop__:
move.w %d5,%d6
beq.s __sus16_prepare_copy__
and.w %d3,%d6
cmp.w %d4,%d6
bhi.s _sus16_loop__
add.w %d1,%d6
move.b %d6,(%a0)+
bra.s ___sus16_loop__
_sus16_loop__:
add.w %d2,%d6
move.b %d6,(%a0)+
bra.s ___sus16_loop__
__sus16_prepare_copy__:
move.l %a0,%d0
sub.l %sp,%d0
subq.b #1,%d0
__sus16_copy__:
move.b -(%a0),(%a1)+
dbf %d0,__sus16_copy__
__sus16_cleanup_and_bye__:
clr.b (%a1)
lea 6(%sp),%sp
movem.l (%sp)+,%d0-%d6/%a0-%a1
rts");
void __attribute__((__stkparm__)) __sprintf_ulong_16__(unsigned char *str, unsigned long val);
asm("
__sprintf_ulong_16__:
movem.l %d0-%d6/%a0-%a1,-(%sp)
lea -12(%sp),%sp
movea.l %sp,%a0
moveq #0x30,%d1
moveq #0x41-10,%d2
moveq #0xF,%d3
moveq #0x9,%d4
movea.l 52(%sp),%a1
move.l 56(%sp),%d5
bne.s __sul16_loop__
move.b %d1,(%a1)+
bra.s __sul16_cleanup_and_bye__
___sul16_loop__:
lsr.l #4,%d5
__sul16_loop__:
move.l %d5,%d6
beq.s __sul16_prepare_copy__
and.w %d3,%d6
cmp.w %d4,%d6
bhi.s _sul16_loop__
add.w %d1,%d6
move.b %d6,(%a0)+
bra.s ___sul16_loop__
_sul16_loop__:
add.w %d2,%d6
move.b %d6,(%a0)+
bra.s ___sul16_loop__
__sul16_prepare_copy__:
move.l %a0,%d0
sub.l %sp,%d0
subq.b #1,%d0
__sul16_copy__:
move.b -(%a0),(%a1)+
dbf %d0,__sul16_copy__
__sul16_cleanup_and_bye__:
clr.b (%a1)
lea 12(%sp),%sp
movem.l (%sp)+,%d0-%d6/%a0-%a1
rts");
void __attribute__((__stkparm__)) __sprintf_ushort_10__(unsigned char *str, unsigned short val);
asm("
__sprintf_ushort_10__:
movem.l %d0-%d3/%a0-%a1,-(%sp)
lea -6(%sp),%sp
movea.l %sp,%a0
moveq #0x30,%d1
movea.l 34(%sp),%a1
move.w 38(%sp),%d2
cmpi.w #9,%d2
bhi.s __sus10_loop__
___sus10_prepare_copy__:
add.b %d1,%d2
move.b %d2,(%a1)+
bra.s __sus10_cleanup_and_bye__
__sus10_loop__:
divu.w #10,%d2
swap %d2
beq.s __sus10_prepare_copy__
move.w %d2,%d3
add.b %d1,%d3
move.b %d3,(%a0)+
clr.w %d2
swap %d2
bra.s __sus10_loop__
__sus10_prepare_copy__:
move.l %a0,%d0
sub.l %sp,%d0
subq.b #1,%d0
__sus10_copy__:
move.b -(%a0),(%a1)+
dbf %d0,__sus10_copy__
__sus10_cleanup_and_bye__:
clr.b (%a1)
lea 6(%sp),%sp
movem.l (%sp)+,%d0-%d3/%a0-%a1
rts");
void __attribute__((__stkparm__)) __sprintf_ulong_10__(unsigned char *str, unsigned long val);
asm("
__sprintf_ulong_10__:
movem.l %d0-%d3/%a0-%a1,-(%sp)
lea -12(%sp),%sp
movea.l %sp,%a0
moveq #0x30,%d1
moveq #0x9,%d7
movea.l 40(%sp),%a1
move.l 44(%sp),%d2
cmp.l %d7,%d2
bhi.s _sul10_loop__
___sul10_prepare_copy__:
add.b %d1,%d2
move.b %d2,(%a1)+
bra.s __sul10_cleanup_and_bye__
_sul10_loop__:
| To have 10 and not 9 in d7. This is done in order to avoid a cmpi.l #9,%d2
| above...
addq.b #1,%d7
__sul10_loop__:
| The following may seem very stupid, but is there a faster way to test if
| a data register is equal to 0 ?
move.l %d2,%d2
beq.s __sul10_prepare_copy__
| Clear the registers...
moveq #0,%d3
moveq #0,%d4
| Copy to the registers
move.w %d2,%d3
swap %d2
move.w %d2,%d4
move.w %d3,%d5
| Make the divisions
divu.w %d7,%d3
divu.w %d7,%d4
move.l %d4,%d2
clr.w %d2
move.w %d5,%d2
divu.w %d7,%d2
swap %d2
| d6.w = remainder in the division of d2 by 10.
move.w %d2,%d6
move.w %d4,%d2
swap %d2
add.b %d1,%d6
move.b %d6,(%a0)+
bra.s __sul10_loop__
__sul10_prepare_copy__:
move.l %a0,%d0
sub.l %sp,%d0
subq.b #1,%d0
__sul10_copy__:
move.b -(%a0),(%a1)+
dbf %d0,__sul10_copy__
__sul10_cleanup_and_bye__:
clr.b (%a1)
lea 12(%sp),%sp
movem.l (%sp)+,%d0-%d3/%a0-%a1
rts");
Merci d'avance.
