Peter,

your routine assumes 1 BCD digit per "occurence", this is the most common case when you e.g. receive digits via UART (in ASCII form, so first you need to convert from ASCII into BCD). However, my task was to convert packed BCD, i.e. 2 digits per "occurence"; hence the multiply by 100 (it is less than 256 so the routine itself is the same). My "less efficient" algorithm is written almost the same as yours, except it is for the "2 digits per occurence" and is explicitly unrolled - code space inefficient, but faster. Of course, optimisation is often a balancing act between the resources...

But sometimes one does not need to make compromises and the optimisation can save all the resources. For example, let me optimize your routine a little bit, saving some 1 cycle, 1 code byte and 1 register :-)

amula10:
        mov     r2, #4          ;4 byte value
_amu1:
                   ;digit to add in acc
        xch     a, @r0
        mov     b, #10
        mul     ab              ;* 10
        add     a, @r0           ;add digit or carry
        mov     @r0, a
        clr     a
        addc    a, b            ;add carry
        inc     r0              ;next byte
        djnz    r2, _amu1
        ret

Have fun!

Jan Waclawek