by Raymond Filiatreault
Copyright 2005
Latest revision April 2005


The das instruction is used to adjust the content of the AL register after that register is used to perform the subtraction of two packed BCDs. The CPU uses the following logic:

   CF_old = CF
IF (al AND 0Fh > 9) or (the Auxilliary Flag is set)
   al = al-6
   CF = CF or CF_old
   AF set
IF (al > 99h) or (Carry Flag is set)
   al = al - 60h
   CF set
Although this instruction should be used immediately after the subtraction instruction, it could be used later as long as no other intervening instruction would have changed the AF or CF flags (such as a mov instruction).
Example 1:
   mov   al,73h        ;packed decimal "73"
   sub   al,45h        ;subtract packed decimal "45"
   daa                 ;AL = 2Eh -> 28h  (with CF clear = 28 packed decimal)

                            AL    CF      AF
; after subtraction        2Eh   clear    set
; daa 1st part (al-6)      28h   clear    set   (because al AND 0Fh > 9)
; daa 2nd part (nothing)   28h   clear    set   (al !> 99h && CF clear)
Example 2:
   mov   al,38h        ;packed decimal "38"
   sub   al,74h        ;subtract packed decimal "74"
   daa                 ;AL = 0C4h -> 64h  with borrow from next digit

                            AL     CF      AF
; after subtraction        0C4h    set   clear
; daa 1st part (nothing)   0C4h    set   clear  (al AND 0Fh !> 9 && AF clear)
; daa 2nd part (al-60h)     64h    set   clear  (because CF set)
Example 3:
   mov   al,47h        ;packed decimal "47"
   sub   al,49h        ;subtract packed decimal "49"
   daa                 ;AL = 0FEh -> 98h  with borrow from next digit

                            AL     CF      AF
; after subtraction        0FEh    set     set
; daa 1st part (al-6)      0F8h    set     set   (because al AND 0Fh > 9)
; daa 2nd part (al-60h)     98h    set     set   (because CF set)
The resulting Carry Flag must always be used with the next subtraction. There should never be any carry from the subtraction of the last packed byte; otherwise, the result would be erroneous. The smaller number must always be subtracted from the larger one and a negative sign inserted with the result if necessary.

The following code is an example of subtracting two large packed BCD numbers in "string" order, (i.e. num1 - num2). It assumes that neither number has leading 0 bytes reflected in its size. Otherwise, a longer number with such leading 0 bytes could actually be smaller than the other with fewer bytes and lead to an erroneous result.

Code is also added to convert the resulting packed BCD result to a null-terminated string without any leading "0" character. The byte count of each source number has been initialized in the data section to save coding instructions (the byte count could be obtained otherwise by several means).

   answer   db    16 dup(0)
   num1size dd    7
   num2size dd    8
   num1     db    78h,96h,19h,03h,21h,38h,55h    ; 78961903213855 packed
   num2     db    7h,27h,52h,83h,61h,84h,68h,15h ;727528361846815 packed
   signbit  db    ?                              ;0=positive, !0=negative
   txtbuf   db    32 dup(?)

   mov   edi,offset num1
   mov   esi,offset num2
   mov   ecx,num1size
   mov   edx,num2size
   mov   signbit,0

   .if   ecx < edx      ;result would be negative
      xchg  esi,edi     ;use EDI to point to longest number
      xchg  ecx,edx     ;use ECX to hold largest count of packed bytes
      mov   signbit,1
   .elseif ecx == edx
      push  esi
      push  edi
      push  ecx
      repz  cmpsb       ;compare the two numbers
      pop   ecx
      pop   edi
      pop   esi
      .if   ZERO?       ;both numbers are equal
         mov   answer,0
         mov   txtbuf,"0"
         jmp   exit
      jnc   negative    ;num2 > num1

   add   edi,ecx        ;must start with least significant digits
   add   esi,edx        ;   idem

   mov   ebx,offset answer
   clc                  ;start with CF clear
   dec   edi
   dec   esi
   mov   al,[edi]
   sbb   al,[esi]
   das                  ;decimal adjust subtraction result
   mov   [ebx],al       ;store it
   inc   ebx
   dec   ecx
   dec   edx
   jnz   @B             ;process all bytes of smallest number

   pushfd               ;keep current flags
   or    ecx,ecx        ;is longest number also completed?
   jz    no_more

   popfd                ;retrieve flags
   dec   edi
   mov   al,[edi]
   sbb   al,0
   mov   [ebx],al
   inc   ebx
   dec   ecx
   jnz   @B             ;process remaining bytes of longest number

   mov   ecx,ebx        ;EBX points to byte following most significant one
   mov   edx,offset answer
   sub   ecx,edx        ;ECX = number of packed bytes in answer
   mov   edi,offset txtbuf

; The following is to convert the result to ASCII
; First insert negative sign if necessary

   .if   signbit != 0
      mov   al,"-"

; Remove any leading packed BCD 0's

   dec   ebx
   mov   al,[ebx]
   or    al,al
   jnz   @F
   dec   ecx            ;adjust count of bytes in answer
   jmp   @B             ;check next byte

; Then process separately a leading 0 in the most significant byte

   .if   al < 10        ;no high nibble
      add   al,30h
      jmp   nextbyte

; Process the other bytes

   movzx eax,byte ptr[ebx]
   ror   ax,4           ;shift most significant nibble to least significant
                        ;while least significant transfers to AH
   ror   ah,4           ;do same with AH which contains the least
                        ;significant nibble of AL in the upper 4 bits
   add   ax,3030h       ;convert both digits to ASCII
   stosw                ;store both characters
              ;the more significant of the two having been kept in AL will
              ;get stored ahead of the less significant one in the string
   dec   ebx
   dec   ecx
   jnz   @B
   mov   [edi],cl       ;add string terminating 0

; The ASCII representation of the packed BCD result is now available as a
; null-terminated string at the txtbuf address.