Asembler procesora 68000     Konwersja danych      Kompilacja



1. Konwersja danych binarnych do systemu dziesiętnego/ósemkowego ASCIIZ:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConBDKonwersja bajtu do systemu DEC-ASCIIZD1.btextbuf
Con8DKonwersja 8-bitów do systemu DEC-ASCIIZD1.btextbuf
ConWDKonwersja słowa (16-bit) do systemu DEC-ASCIIZD1.wtextbuf
Con16DKonwersja 16-bitów do systemu DEC-ASCIIZD1.wtextbuf
Con20D Konwersja 20-bitów do systemu DEC-ASCIIZD1.ltextbuf
Con24DKonwersja 24-bitów do systemu DEC-ASCIIZD1.ltextbuf
ConLDKonwersja długiego słowa (32-bit) do systemu DEC-ASCIIZ D1.ltextbuf
Con32DKonwersja 32-bitów do systemu DEC-ASCIIZD1.ltextbuf
ConBOKonwersja bajtu do systemu OCT-ASCIIZD1.btextbuf
Con8OKonwersja 8-bitów do systemu OCT-ASCIIZD1.btextbuf
ConWOKonwersja słowa (16-bit) do systemu OCT-ASCIIZD1.wtextbuf
Con16OKonwersja 16-bitów do systemu OCT-ASCIIZD1.wtextbuf
ConLOKonwersja długiego słowa (32-bit) do systemu OCT-ASCIIZD1.ltextbuf
Con32OKonwersja 32-bitów do systemu OCT-ASCIIZD1.ltextbuf
 Opracowano na podstawie procedury, zawartej pod adresem $F82762 w pamięci Kickstart 2.05 (37.299).

2. Konwersja liczby dziesiętnej/ósemkowej ASCIIZ do systemu binarnego:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConD6Konwersja 6-cyfrowej liczby DEC-ASCIIZ do systemu binarnegotextbufD1.l
ConD10 Konwersja 10-cyfrowej liczby DEC-ASCIIZ do systemu binarnego textbufD1.l
ConO11Konwersja 11-cyfrowej liczby OCT-ASCIIZ do systemu binarnegotextbufD1.l

3. Konwersja danych binarnych do systemu szesnastkowego ASCIIZ:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConBHKonwersja bajtu do systemu HEX-ASCIIZD1.btextbuf
ConWH Konwersja słowa (16-bit) do systemu HEX-ASCIIZD1.wtextbuf
ConLHKonwersja długiego słowa (32-bit) do systemu HEX-ASCIIZ D1.ltextbuf

4. Konwersja liczby szesnastkowej ASCIIZ do systemu binarnego:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConH8Konwersja 8-cyfrowej liczby HEX-ASCIIZ do systemu binarnegotextbufD1.l
ConH8s Konwersja 8-cyfrowej liczby HEX-ASCIIZ do systemu binarnego (duże/małe litery) textbufD1.l

5. Konwersja danych binarnych do systemu dwójkowego ASCIIZ:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConBBKonwersja bajtu do systemu BIN-ASCIIZD1.btextbuf
ConWB Konwersja słowa (16-bit) do systemu BIN-ASCIIZD1.wtextbuf
ConLBKonwersja długiego słowa (32-bit) do systemu BIN-ASCIIZ D1.ltextbuf

6. Konwersja liczby dwójkowej ASCIIZ do systemu binarnego:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConB32 Konwersja 32-cyfrowej liczby BIN-ASCIIZ do systemu binarnego textbufD1.l

7. Konwersja danych binarnych do systemu binarnego BCD/BCO:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConBBDKonwersja bajtu do systemu binarnego BCDD1.bD2.w
Con20BD Konwersja 20-bitów do systemu binarnego BCDD1.lD2.l
Con24BDKonwersja 24-bitów do systemu binarnego BCDD1.lD2.l
Con28BDKonwersja 28-bitów do systemu binarnego BCDD1.lD2.l
ConBBOKonwersja bajtu do systemu binarnego BCOD1.bD2.w
ConWBOKonwersja słowa (16-bit) do systemu binarnego BCO D1.wD2.l
Con24BOKonwersja 24-bitów do systemu binarnego BCOD1.lD2.l
 Opracowano na podstawie procedury, zawartej pod adresem $F82762 w pamięci Kickstart 2.05 (37.299).

8. Konwersja danych binarnych BCD/BCO do systemu binarnego:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConBDBKonwersja bajtu BCD do systemu binarnegoD1.bD2.b
ConBDWKonwersja słowa (16-bit) BCD do systemu binarnegoD1.wD2.w
ConBD24 Konwersja 24-bitów BCD do systemu binarnegoD1.lD2.l
ConBDLKonwersja długiego słowa (32-bit) BCD do systemu binarnego D1.lD2.l
ConBOBKonwersja bajtu BCO do systemu binarnegoD1.bD2.b
ConBOWKonwersja słowa (16-bit) BCO do systemu binarnegoD1.wD2.w
ConBOLKonwersja długiego słowa (32-bit) BCO do systemu binarnegoD1.lD2.l

9. Konwersja danych binarnych BCD/BCO do systemu dziesiętnego/ósemkowego ASCIIZ:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConBDBDKonwersja bajtu BCD do systemu DEC-ASCIIZD1.btextbuf
ConBDWD Konwersja słowa (16-bit) BCD do systemu DEC-ASCIIZD1.wtextbuf
ConBDLDKonwersja długiego słowa (32-bit) BCD do systemu DEC-ASCIIZ D1.ltextbuf
ConBOBOKonwersja bajtu BCO do systemu OCT-ASCIIZD1.btextbuf
ConBOWOKonwersja słowa (16-bit) BCO do systemu OCT-ASCIIZD1.wtextbuf
ConBOLOKonwersja długiego słowa (32-bit) BCO do systemu OCT-ASCIIZD1.ltextbuf

10. Konwersja liczby dziesiętnej/ósemkowej ASCIIZ do systemu binarnego BCD/BCO:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConD8BD Konwersja 8-cyfrowej liczby DEC-ASCIIZ do systemu binarnego BCD textbufD1.l
ConO8BOKonwersja 8-cyfrowej liczby OCT-ASCIIZ do systemu binarnego BCOtextbufD1.l

11. Konwersja danych binarnych do systemu ASCIIZ:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConBAKonwersja bajtu do systemu ASCIIZD1.btextbuf
ConWA Konwersja słowa (16-bit) do systemu ASCIIZD1.wtextbuf
ConLAKonwersja długiego słowa (32-bit) do systemu ASCIIZ D1.ltextbuf

12. Konwersja ciągu ASCIIZ do systemu binarnego:
NAZWA
OPIS
ARGUMENTY
WEJŚCIOWE		WYJŚCIE
DANYCH
ConA4Konwersja 4-znakowego ciągu ASCIIZ do systemu binarnego textbufD1.l

Objaśnienia:
D1, D2 - rejestr danych
Dx.b - najmłodszy bajt rejestru danych (8-bitów)
Dx.w - młodsze słowo rejestru danych (16-bitów)
Dx.l - cały rejestr danych (32-bity)
textbuf - pamięć dla danych wejściowych/wyjściowych (RAM)

 
 ConBD: moveq    #$00,D1    ;bajt do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$64,D2
ConBD0: move.b   #$2F,(A0)
ConBD1: addq.b   #1,(A0)
        sub.b    D2,D1
        bcc.s    ConBD1
        add.b    D2,D1
        addq.l   #1,A0
        divu     #$0A,D2
        bne.s    ConBD0
        clr.b	 (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "255" ($FF)
;Rozmiar: 34 B, linii kodu: 13

 Con8D: moveq    #$00,D1    ;bajt do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$0A,D5
        moveq    #$03,D2    ;maksymalna liczba cyfr
        add.l    D2,A0
        clr.b	 (A0)
Con8D0: moveq    #$08,D3    ;liczba bitów do konwersji
        clr.b    D4
Con8D1: roxl.b   #1,D4
        cmp.b    D5,D4
        bcs.s    Con8D2
        sub.b    D5,D4
        or.b     #$10,CCR   ;ustawienie flagi X w rejestrze CCR
Con8D2: roxl.b   #1,D1
        dbf      D3,Con8D1
        add.b    #$30,D4
        move.b   D4,-(A0)
        subq.b   #1,D2
        bne.s    Con8D0
        rts

;Maksymalna wartość liczby wyjściowej: "255" ($FF)
;Rozmiar: 50 B, linii kodu: 20

 ConWD: move.w   #$00,D1    ;dane do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        move.l   #$2710,D2
ConWD0: move.b   #$2F,(A0)
ConWD1: addq.b   #1,(A0)
        sub.w    D2,D1
        bcc.s    ConWD1
        add.w    D2,D1
        addq.l   #1,A0
        divu     #$0A,D2
        bne.s    ConWD0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "65535" ($FFFF)
;Rozmiar: 40 B, linii kodu: 13

 Con16D: move.w   #$00,D1    ;dane do konwersji
         lea      textbuf,A0 ;adres wyjścia danych
         moveq    #$0A,D5
         moveq    #$05,D2    ;maksymalna liczba cyfr
         add.l    D2,A0
         clr.b	  (A0)
Con16D0: moveq    #$10,D3    ;liczba bitów do konwersji
         clr.b    D4
Con16D1: roxl.b   #1,D4
         cmp.b    D5,D4
         bcs.s    Con16D2
         sub.b    D5,D4
         or.b     #$10,CCR   ;ustawienie flagi X w rejestrze CCR
Con16D2: roxl.w   #1,D1
         dbf      D3,Con16D1
         add.b    #$30,D4
         move.b   D4,-(A0)
         subq.b   #1,D2
         bne.s    Con16D0
         rts

;Maksymalna wartość liczby wyjściowej: "65535" ($FFFF)
;Rozmiar: 52 B, linii kodu: 20

 Con20D: move.l   #$00,D1     ;dane do konwersji
         lea      textbuf,A0  ;adres wyjścia danych
         move.l   #$0186A0,D2
Con20D0: move.b   #$2F,(A0)
Con20D1: addq.b   #1,(A0)
         sub.l    D2,D1
         bcc.s    Con20D1
         add.l    D2,D1
         addq.l   #1,A0
         divu     #$0A,D2
         bne.s    Con20D0
         clr.b	  (A0)
         rts

;Maksymalna wartość liczby wyjściowej: "999999" ($0F423F), wynika z ograniczeń ALU
;(dzielenie instrukcją DIVU). Jeśli konwertowane dane będą miały wartość większą od
;$0F423F, to liczba wyjściowa nie będzie prawidłowa.
;Rozmiar: 42 B, linii kodu: 13

 Con24D: move.l   #$00,D1     ;dane do konwersji
         lea      textbuf,A0  ;adres wyjścia danych
         move.l   #$0F4240,D2
         move.l   #$0927C0,D3
Con24D0: move.b   #$2F,(A0)
Con24D1: addq.b   #1,(A0)
         sub.l    D2,D1
         bcc.s    Con24D1
         add.l    D2,D1
         addq.l   #1,A0
         sub.l    D3,D2
         divu     #$0A,D3
         lsr.l    #2,D2
         tst.b    D2
         bne.s    Con24D0
         clr.b	  (A0)
         rts

;Maksymalna wartość liczby wyjściowej: "9999999" ($98967F), wynika z ograniczeń ALU
;(dzielenie instrukcją DIVU). Jeśli konwertowane dane będą miały wartość większą od
;$98967F, to liczba wyjściowa nie będzie prawidłowa.
;Rozmiar: 54 B, linii kodu: 17

 ConLD: move.l   #$00,D1       ;dane do konwersji
        lea      textbuf,A0    ;adres wyjścia danych
        lea      ConLD2(pc),A1
ConLD0: move.b   #$2F,(A0)
ConLD1: addq.b   #1,(A0)
        sub.l    (A1),D1
        bcc.s    ConLD1
        add.l    (A1)+,D1
        addq.l   #1,A0
        tst.b    (A1)
        bpl.s    ConLD0
        clr.b    (A0)
        rts
ConLD2: dc.l     1000000000,100000000,10000000,1000000,100000,10000,1000,100,10,1
        dc.b     $80

;Maksymalna wartość liczby wyjściowej: "4294967295" ($FFFFFFFF)
;Rozmiar: 79 B, linii kodu: 15

 Con32D: move.l   #$00,D1    ;dane do konwersji
         lea      textbuf,A0 ;adres wyjścia danych
         moveq    #$0A,D5
         moveq    #$0A,D2    ;maksymalna liczba cyfr
         add.l    D2,A0
         clr.b	  (A0)
Con32D0: moveq    #$20,D3    ;liczba bitów do konwersji
         clr.b    D4
Con32D1: roxl.b   #1,D4
         cmp.b    D5,D4
         bcs.s    Con32D2
         sub.b    D5,D4
         or.b     #$10,CCR   ;ustawienie flagi X w rejestrze CCR
Con32D2: roxl.l   #1,D1
         dbf      D3,Con32D1
         add.b    #$30,D4
         move.b   D4,-(A0)
         subq.b   #1,D2
         bne.s    Con32D0
         rts

;Maksymalna wartość liczby wyjściowej: "4294967295" ($FFFFFFFF)
;Rozmiar: 54 B, linii kodu: 20

 ConBO: moveq    #$00,D1    ;bajt do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$40,D2
ConBO0: move.b   #$2F,(A0)
ConBO1: addq.b   #1,(A0)
        sub.b    D2,D1
        bcc.s    ConBO1
        add.b    D2,D1
        addq.l   #1,A0
        lsr.b    #3,D2
        bne.s    ConBO0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "377" ($FF)
;Rozmiar: 32 B, linii kodu: 13

 Con8O: moveq    #$00,D1    ;bajt do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$08,D5
        moveq    #$03,D2    ;maksymalna liczba cyfr
        add.l    D2,A0
        clr.b	 (A0)
Con8O0: moveq    #$08,D3    ;liczba bitów do konwersji
        clr.b    D4
Con8O1: roxl.b   #1,D4
        cmp.b    D5,D4
        bcs.s    Con8O2
        sub.b    D5,D4
        or.b     #$10,CCR   ;ustawienie flagi X w rejestrze CCR
Con8O2: roxl.b   #1,D1
        dbf      D3,Con8O1
        add.b    #$30,D4
        move.b   D4,-(A0)
        subq.b   #1,D2
        bne.s    Con8O0
        rts

;Maksymalna wartość liczby wyjściowej: "377" ($FF)
;Rozmiar: 50 B, linii kodu: 20

 ConWO: move.w   #$00,D1    ;dane do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        move.w   #$8000,D2
ConWO0: move.b   #$2F,(A0)
ConWO1: addq.b   #1,(A0)
        sub.w    D2,D1
        bcc.s    ConWO1
        add.w    D2,D1
        addq.l   #1,A0
        lsr.w    #3,D2
        bne.s    ConWO0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "177777" ($FFFF)
;Rozmiar: 36 B, linii kodu: 13

 Con16O: move.w   #$00,D1    ;dane do konwersji
         lea      textbuf,A0 ;adres wyjścia danych
         moveq    #$08,D5
         moveq    #$06,D2    ;maksymalna liczba cyfr
         add.l    D2,A0
         clr.b	  (A0)
Con16O0: moveq    #$10,D3    ;liczba bitów do konwersji
         clr.b    D4
Con16O1: roxl.b   #1,D4
         cmp.b    D5,D4
         bcs.s    Con16O2
         sub.b    D5,D4
         or.b     #$10,CCR   ;ustawienie flagi X w rejestrze CCR
Con16O2: roxl.w   #1,D1
         dbf      D3,Con16O1
         add.b    #$30,D4
         move.b   D4,-(A0)
         subq.b   #1,D2
         bne.s    Con16O0
         rts

;Maksymalna wartość liczby wyjściowej: "177777" ($FFFF)
;Rozmiar: 52 B, linii kodu: 20

 ConLO: move.l   #$00,D1    ;dane do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$40,D2
        ror.l    #8,D2
ConLO0: move.b   #$2F,(A0)
ConLO1: addq.b   #1,(A0)
        sub.l    D2,D1
        bcc.s    ConLO1
        add.l    D2,D1
        addq.l   #1,A0
        lsr.l    #3,D2
        bne.s    ConLO0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "37777777777" ($FFFFFFFF)
;Rozmiar: 38 B, linii kodu: 14

 Con32O: move.l   #$00,D1    ;dane do konwersji
         lea      textbuf,A0 ;adres wyjścia danych
         moveq    #$08,D5
         moveq    #$0B,D2    ;maksymalna liczba cyfr
         add.l    D2,A0
         clr.b	  (A0)
Con32O0: moveq    #$20,D3    ;liczba bitów do konwersji
         clr.b    D4
Con32O1: roxl.b   #1,D4
         cmp.b    D5,D4
         bcs.s    Con32O2
         sub.b    D5,D4
         or.b     #$10,CCR   ;ustawienie flagi X w rejestrze CCR
Con32O2: roxl.l   #1,D1
         dbf      D3,Con32O1
         add.b    #$30,D4
         move.b   D4,-(A0)
         subq.b   #1,D2
         bne.s    Con32O0
         rts

;Maksymalna wartość liczby wyjściowej: "37777777777" ($FFFFFFFF)
;Rozmiar: 54 B, linii kodu: 20

 ConD6: moveq    #$00,D1    ;wynik konwersji
        lea      textbuf,A0 ;adres wejścia danych
        bra.s    ConD6b
ConD6a: moveq    #$0A,D2
        sub.b    #$30,(A0)
        mulu     D2,D1
        move.b   (A0)+,D2
        add.l    D2,D1
ConD6b: tst.b    (A0)
        bne.s    ConD6a
        rts

;Maksymalna wartość liczby wejściowej: "655359" ($09FFFF), wynika z ograniczeń ALU
;(mnożenie instrukcją MULU). Jeśli liczba wejściowa będzie większa od "655359",
;to wynik konwersji przepełni się (będzie liczony od zera).
;Rozmiar: 28 B, linii kodu: 11

 ConD10: moveq    #$00,D1    ;wynik konwersji
         lea      textbuf,A0 ;adres wejścia danych
         bra.s    ConD10b
ConD10a: sub.b    #$30,(A0)
         move.l   D1,D2
         lsl.l    #3,D1
         add.l    D2,D1
         add.l    D2,D1
         moveq    #$00,D2
         move.b   (A0)+,D2
         add.l    D2,D1
ConD10b: tst.b    (A0)
         bne.s    ConD10a
         rts

;Maksymalna wartość liczby wejściowej: "4294967295" ($FFFFFFFF)
;Jeśli liczba wejściowa będzie większa od "4294967295",
;to wynik konwersji przepełni się (będzie liczony od zera).
;Rozmiar: 34 B, linii kodu: 14

 ConO11: moveq    #$00,D1    ;wynik konwersji
         lea      textbuf,A0 ;adres wejścia danych
         bra.s    ConO11b
ConO11a: moveq    #$08,D2
         sub.b    #$30,(A0)
         lsl.l    #3,D1
         move.b   (A0)+,D2
         add.l    D2,D1
ConO11b: tst.b    (A0)
         bne.s    ConO11a
         rts

;Maksymalna wartość liczby wejściowej: "37777777777" ($FFFFFFFF)
;Jeśli liczba wejściowa będzie większa od "37777777777",
;to wynik konwersji przepełni się (będzie liczony od zera).
;Rozmiar: 28 B, linii kodu: 11

 ConBH: moveq    #$00,D1    ;bajt do konwersji
        moveq    #$01,D2
        lea      textbuf,A0 ;adres wyjścia danych
ConBH0: rol.b    #4,D1
        move.b   D1,D3
        lsl.b    #4,D3
        addq.b   #3,D3
        rol.b    #4,D3
        cmp.b    #$3A,D3
        bcs.s    ConBH1
        addq.b   #7,D3      ;add.b #$27,D3 - małe litery (a-f)
ConBH1: move.b   D3,(A0)+
        dbf      D2,ConBH0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "FF" ($FF)
;Procedura generuje duże lub małe litery (a-f)
;Rozmiar: 38 B, linii kodu: 15

 ConWH: move.w   #$00,D1    ;dane do konwersji
        moveq    #$03,D2
        lea      textbuf,A0 ;adres wyjścia danych
ConWH0: rol.w    #4,D1
        move.b   D1,D3
        lsl.b    #4,D3
        addq.b   #3,D3
        rol.b    #4,D3
        cmp.b    #$3A,D3
        bcs.s    ConWH1
        addq.b   #7,D3      ;add.b #$27,D3 - małe litery (a-f)
ConWH1: move.b   D3,(A0)+
        dbf      D2,ConWH0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "FFFF" ($FFFF)
;Procedura generuje duże lub małe litery (a-f)
;Rozmiar: 40 B, linii kodu: 15

 ConLH: move.l   #$00,D1    ;dane do konwersji
        moveq    #$07,D2
        lea      textbuf,A0 ;adres wyjścia danych
ConLH0: rol.l    #4,D1
        move.b   D1,D3
        lsl.b    #4,D3
        addq.b   #3,D3
        rol.b    #4,D3
        cmp.b    #$3A,D3
        bcs.s    ConLH1
        addq.b   #7,D3      ;add.b #$27,D3 - małe litery (a-f)
ConLH1: move.b   D3,(A0)+
        dbf      D2,ConLH0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "FFFFFFFF" ($FFFFFFFF)
;Procedura generuje duże lub małe litery (a-f)
;Rozmiar: 42 B, linii kodu: 15

 ConH8: moveq    #$00,D1    ;wynik konwersji
        lea      textbuf,A0 ;adres wejścia danych
        bra.s    ConH8c
ConH8a: sub.b    #$30,(A0)
        cmp.b    #$0A,(A0)
        bcs.s    ConH8b
        subq.b   #7,(A0)    ;sub.b #$27,(A0) - małe litery (a-f)
ConH8b: lsl.l    #4,D1
        add.b    (A0)+,D1
ConH8c: tst.b    (A0)
        bne.s    ConH8a
        rts

;Maksymalna wartość liczby wejściowej: "FFFFFFFF" ($FFFFFFFF)
;Procedura konwertuje duże lub małe litery (a-f)
;Jeśli liczba wejściowa będzie dłuższa, to wynik konwersji zostanie ustalony przez jej ostatnie 8-cyfr
;Rozmiar: 32 B, linii kodu: 12

 ConH8s: moveq    #$00,D1    ;wynik konwersji
         lea      textbuf,A0 ;adres wejścia danych
         bra.s    ConH8s2
ConH8s0: sub.b    #$30,(A0)
         cmp.b    #$0A,(A0)
         bcs.s    ConH8s1
         subq.b   #7,(A0)
         cmp.b    #$0F,(A0)
         bls.s    ConH8s1
         sub.b    #$20,(A0)
ConH8s1: lsl.l    #4,D1
         add.b    (A0)+,D1
ConH8s2: tst.b    (A0)
         bne.s    ConH8s0
         rts

;Maksymalna wartość liczby wejściowej: "FfFfFfFf" ($FFFFFFFF)
;Procedura konwertuje duże i małe litery (a-f)
;Jeśli liczba wejściowa będzie dłuższa, to wynik konwersji zostanie ustalony przez jej ostatnie 8-cyfr
;Rozmiar: 42 B, linii kodu: 15

 ConBB: moveq    #$00,D1    ;bajt do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$07,D2    ;liczba bitów do konwersji (-1 bit)
ConBB0: moveq    #$30,D3
        btst     D2,D1
        beq.s    ConBB1
        addq.b   #1,D3
ConBB1: move.b   D3,(A0)+
        dbf      D2,ConBB0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "11111111" ($FF)
;Rozmiar: 28 B, linii kodu: 11

 ConWB: move.w   #$00,D1    ;dane do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$0F,D2    ;liczba bitów do konwersji (-1 bit)
ConWB0: moveq    #$30,D3
        btst     D2,D1
        beq.s    ConWB1
        addq.b   #1,D3
ConWB1: move.b   D3,(A0)+
        dbf      D2,ConWB0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "1111111111111111" ($FFFF)
;Rozmiar: 30 B, linii kodu: 11

 ConLB: move.l   #$00,D1    ;dane do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$1F,D2    ;liczba bitów do konwersji (-1 bit)
ConLB0: moveq    #$30,D3
        btst     D2,D1
        beq.s    ConLB1
        addq.b   #1,D3
ConLB1: move.b   D3,(A0)+
        dbf      D2,ConLB0
        clr.b    (A0)
        rts

;Maksymalna wartość liczby wyjściowej: "11111111111111111111111111111111" ($FFFFFFFF)
;Rozmiar: 32 B, linii kodu: 11

 ConB32: moveq    #$00,D1    ;wynik konwersji
         lea      textbuf,A0 ;adres wejścia danych
         bra.s    ConB32b
ConB32a: sub.b    #$30,(A0)
         lsl.l    #1,D1
         add.b    (A0)+,D1
ConB32b: tst.b    (A0)
         bne.s    ConB32a
         rts

;Maksymalna wartość liczby wejściowej: "11111111111111111111111111111111" ($FFFFFFFF)
;Jeśli liczba wejściowa będzie dłuższa, to wynik konwersji
;zostanie ustalony przez jej ostatnie 32-cyfry
;Rozmiar: 24 B, linii kodu: 9

 ConBBD: moveq    #$00,D1 ;bajt do konwersji
         clr.w    D2      ;wynik konwersji
         moveq    #$64,D3
ConBBD0: lsl.w    #4,D2
         add.b    #$FF,D2
ConBBD1: addq.b   #1,D2
         sub.b    D3,D1
         bcc.s    ConBBD1
         add.b    D3,D1
         divu     #$0A,D3
         bne.s    ConBBD0
         rts

;Maksymalna wartość danych wyjściowych: $0255 ($FF)
;Rozmiar: 28 B, linii kodu: 12

 Con20BD: move.l   #$00,D1     ;dane do konwersji
          moveq    #$00,D2     ;wynik konwersji
          move.l   #$0186A0,D3
Con20BD0: lsl.l    #4,D2
          add.b    #$FF,D2
Con20BD1: addq.b   #1,D2
          sub.l    D3,D1
          bcc.s    Con20BD1
          add.l    D3,D1
          divu     #$0A,D3
          bne.s    Con20BD0
          rts

;Maksymalna wartość danych wyjściowych: $999999 ($0F423F), wynika z ograniczeń ALU
;(dzielenie instrukcją DIVU). Jeśli konwertowane dane będą miały wartość większą od
;$0F423F, to wynik konwersji nie będzie prawidłowy.
;Rozmiar: 36 B, linii kodu: 12

 Con24BD: move.l   #$00,D1     ;dane do konwersji
          moveq    #$00,D2     ;wynik konwersji
          move.l   #$0F4240,D3
          move.l   #$0927C0,D4
Con24BD0: lsl.l    #4,D2
          add.b    #$FF,D2
Con24BD1: addq.b   #1,D2
          sub.l    D3,D1
          bcc.s    Con24BD1
          add.l    D3,D1
          sub.l    D4,D3
          divu     #$0A,D4
          lsr.l    #2,D3
          tst.b    D3
          bne.s    Con24BD0
          rts

;Maksymalna wartość danych wyjściowych: $09999999 ($98967F), wynika z ograniczeń ALU
;(dzielenie instrukcją DIVU). Jeśli konwertowane dane będą miały wartość większą od
;$98967F, to wynik konwersji nie będzie prawidłowy.
;Rozmiar: 48 B, linii kodu: 16

 Con28BD: move.l   #$00,D1         ;dane do konwersji
          moveq    #$00,D2         ;wynik konwersji
          lea      Con28BD2(pc),A0
Con28BD0: lsl.l    #4,D2
          add.b    #$FF,D2
Con28BD1: addq.b   #1,D2
          sub.l    (A0),D1
          bcc.s    Con28BD1
          add.l    (A0)+,D1
          tst.b    (A0)
          beq.s    Con28BD0
          rts
Con28BD2: dc.l     100000000,10000000,1000000,100000,10000,1000,100,10,1
          dc.b     $FF

;Maksymalna wartość danych wyjściowych: $99999999 ($05F5E0FF)
;Jeśli konwertowane dane będą miały wartość większą od $05F5E0FF,
;to wynik konwersji przepełni się (będzie liczony od zera).
;Rozmiar: 69 B, linii kodu: 14

 ConBBO: moveq    #$00,D1 ;bajt do konwersji
         clr.w    D2      ;wynik konwersji
         moveq    #$40,D3
ConBBO0: lsl.w    #4,D2
         add.b    #$FF,D2
ConBBO1: addq.b   #1,D2
         sub.b    D3,D1
         bcc.s    ConBBO1
         add.b    D3,D1
         lsr.b    #3,D3
         bne.s    ConBBO0
         rts

;Maksymalna wartość danych wyjściowych: $0377 ($FF)
;Rozmiar: 26 B, linii kodu: 12

 ConWBO: move.w   #$00,D1   ;dane do konwersji
         moveq    #$00,D2   ;wynik konwersji
         move.w   #$8000,D3
ConWBO0: lsl.l    #4,D2
         add.b    #$FF,D2
ConWBO1: addq.b   #1,D2
         sub.w    D3,D1
         bcc.s    ConWBO1
         add.w    D3,D1
         lsr.w    #3,D3
         bne.s    ConWBO0
         rts

;Maksymalna wartość danych wyjściowych: $177777 ($FFFF)
;Rozmiar: 30 B, linii kodu: 12

 Con24BO: move.l   #$00,D1  ;dane do konwersji
          moveq    #$00,D2  ;wynik konwersji
          moveq    #$40,D3
          ror.l    #8,D3
Con24BO0: lsl.l    #4,D2
          add.b    #$FF,D2
Con24BO1: addq.b   #1,D2
          sub.l    D3,D1
          bcc.s    Con24BO1
          add.l    D3,D1
          lsr.l    #3,D3
          bne.s    Con24BO0
          rts

;Maksymalna wartość danych wyjściowych: $77777777 ($xxFFFFFF)
;Wartość najstarszego bajtu konwertowanych danych, nie wpływa na wynik konwersji
;Rozmiar: 32 B, linii kodu: 13

 ConBDB: moveq    #$00,D1     ;bajt do konwersji
         clr.b    D2          ;wynik konwersji
         moveq    #$01,D3
ConBDB0: rol.b    #4,D1
         move.b   D1,D4
         lsl.b    #4,D4
         ror.b    #4,D4
         mulu     #$0A,D2
         add.b    D4,D2
         dbf      D3,ConBDB0
         rts

;Maksymalna wartość danych wejściowych: $99 ($63)
;Rozmiar: 26 B, linii kodu: 11

 ConBDW: move.w   #$00,D1     ;dane do konwersji
         clr.w    D2          ;wynik konwersji
         moveq    #$03,D3
         clr.w    D4
ConBDW0: rol.w    #4,D1
         move.b   D1,D4
         lsl.b    #4,D4
         ror.b    #4,D4
         mulu     #$0A,D2
         add.w    D4,D2
         dbf      D3,ConBDW0
         rts

;Maksymalna wartość danych wejściowych: $9999 ($270F)
;Rozmiar: 30 B, linii kodu: 12

 ConBD24: move.l   #$00,D1      ;dane do konwersji
          moveq    #$00,D2      ;wynik konwersji
          moveq    #$07,D3
          moveq    #$00,D4
ConBD24a: rol.l    #4,D1
          move.b   D1,D4
          lsl.b    #4,D4
          ror.b    #4,D4
          mulu     #$0A,D2
          add.l    D4,D2
          dbf      D3,ConBD24a
          rts

;Maksymalna wartość danych wejściowych: $655359 ($09FFFF), wynika z ograniczeń ALU
;(mnożenie instrukcją MULU). Jeśli konwertowane dane będą miały wartość większą od
;$655359, to wynik konwersji przepełni się (będzie liczony od zera).
;Rozmiar: 32 B, linii kodu: 12

 ConBDL: move.l   #$00,D1     ;dane do konwersji
         moveq    #$00,D2     ;wynik konwersji
         moveq    #$07,D3
ConBDL0: move.l   D2,D4
         rol.l    #3,D2
         add.l    D4,D2
         add.l    D4,D2
         moveq    #$00,D4
         rol.l    #4,D1
         move.b   D1,D4
         lsl.b    #4,D4
         ror.b    #4,D4
         add.l    D4,D2
         dbf      D3,ConBDL0
         rts

;Maksymalna wartość danych wejściowych: $99999999 ($05F5E0FF)
;Rozmiar: 36 B, linii kodu: 15

 ConBOB: moveq    #$00,D1     ;bajt do konwersji
         clr.b    D2          ;wynik konwersji
         moveq    #$01,D3
ConBOB0: rol.b    #4,D1
         move.b   D1,D4
         lsl.b    #4,D4
         ror.b    #4,D4
         rol.b    #3,D2
         add.b    D4,D2
         dbf      D3,ConBOB0
         rts

;Maksymalna wartość danych wejściowych: $77 ($3F)
;Rozmiar: 24 B, linii kodu: 11

 ConBOW: move.w   #$00,D1     ;dane do konwersji
         clr.w    D2          ;wynik konwersji
         moveq    #$03,D3
         clr.w    D4
ConBOW0: rol.w    #4,D1
         move.b   D1,D4
         lsl.b    #4,D4
         ror.b    #4,D4
         rol.w    #3,D2
         add.w    D4,D2
         dbf      D3,ConBOW0
         rts

;Maksymalna wartość danych wejściowych: $7777 ($0FFF)
;Rozmiar: 28 B, linii kodu: 12

 ConBOL: move.l   #$00,D1     ;dane do konwersji
         moveq    #$00,D2     ;wynik konwersji
         moveq    #$07,D3
         moveq    #$00,D4
ConBOL0: rol.l    #4,D1
         move.b   D1,D4
         lsl.b    #4,D4
         ror.b    #4,D4
         rol.l    #3,D2
         add.l    D4,D2
         dbf      D3,ConBOL0
         rts

;Maksymalna wartość danych wejściowych: $77777777 ($FFFFFF)
;Rozmiar: 30 B, linii kodu: 12

 ConBDBD: moveq    #$00,D1      ;bajt do konwersji
          lea      textbuf,A0   ;adres wyjścia danych
          moveq    #$01,D2
ConBDBD0: rol.b    #4,D1
          move.b   D1,D3
          lsl.b    #4,D3
          addq.b   #3,D3
          rol.b    #4,D3
          move.b   D3,(A0)+
          dbf      D2,ConBDBD0
          clr.b    (A0)
          rts

;Maksymalna wartość liczby wyjściowej: "99" ($99)
;Rozmiar: 30 B, linii kodu: 12

 ConBDWD: move.w   #$00,D1      ;dane do konwersji
          lea      textbuf,A0   ;adres wyjścia danych
          moveq    #$03,D2
ConBDWD0: rol.w    #4,D1
          move.b   D1,D3
          lsl.b    #4,D3
          addq.b   #3,D3
          rol.b    #4,D3
          move.b   D3,(A0)+
          dbf      D2,ConBDWD0
          clr.b    (A0)
          rts

;Maksymalna wartość liczby wyjściowej: "9999" ($9999)
;Rozmiar: 32 B, linii kodu: 12

 ConBDLD: move.l   #$00,D1      ;dane do konwersji
          lea      textbuf,A0   ;adres wyjścia danych
          moveq    #$07,D2
ConBDLD0: rol.l    #4,D1
          move.b   D1,D3
          lsl.b    #4,D3
          addq.b   #3,D3
          rol.b    #4,D3
          move.b   D3,(A0)+
          dbf      D2,ConBDLD0
          clr.b    (A0)
          rts

;Maksymalna wartość liczby wyjściowej: "99999999" ($99999999)
;Rozmiar: 34 B, linii kodu: 12

 ConBOBO: moveq    #$00,D1      ;bajt do konwersji
          lea      textbuf,A0   ;adres wyjścia danych
          moveq    #$01,D2
ConBOBO0: rol.b    #4,D1
          move.b   D1,D3
          lsl.b    #4,D3
          addq.b   #3,D3
          rol.b    #4,D3
          move.b   D3,(A0)+
          dbf      D2,ConBOBO0
          clr.b    (A0)
          rts

;Maksymalna wartość liczby wyjściowej: "77" ($77)
;Rozmiar: 30 B, linii kodu: 12

 ConBOWO: move.w   #$00,D1      ;dane do konwersji
          lea      textbuf,A0   ;adres wyjścia danych
          moveq    #$03,D2
ConBOWO0: rol.w    #4,D1
          move.b   D1,D3
          lsl.b    #4,D3
          addq.b   #3,D3
          rol.b    #4,D3
          move.b   D3,(A0)+
          dbf      D2,ConBOWO0
          clr.b    (A0)
          rts

;Maksymalna wartość liczby wyjściowej: "7777" ($7777)
;Rozmiar: 32 B, linii kodu: 12

 ConBOLO: move.l   #$00,D1      ;dane do konwersji
          lea      textbuf,A0   ;adres wyjścia danych
          moveq    #$07,D2
ConBOLO0: rol.l    #4,D1
          move.b   D1,D3
          lsl.b    #4,D3
          addq.b   #3,D3
          rol.b    #4,D3
          move.b   D3,(A0)+
          dbf      D2,ConBOLO0
          clr.b    (A0)
          rts

;Maksymalna wartość liczby wyjściowej: "77777777" ($77777777)
;Rozmiar: 34 B, linii kodu: 12

 ConD8BD: moveq    #$00,D1    ;wynik konwersji
          lea      textbuf,A0 ;adres wejścia danych
          bra.s    ConD8BD1
ConD8BD0: sub.b    #$30,(A0)
          lsl.l    #4,D1
          add.b    (A0)+,D1
ConD8BD1: tst.b    (A0)
          bne.s    ConD8BD0
          rts

;Maksymalna wartość liczby wejściowej: "99999999" ($99999999)
;Jeśli liczba wejściowa będzie dłuższa, to wynik konwersji zostanie ustalony przez jej ostatnie 8-cyfr
;Rozmiar: 24 B, linii kodu: 9

 ConO8BO: moveq    #$00,D1    ;wynik konwersji
          lea      textbuf,A0 ;adres wejścia danych
          bra.s    ConO8BO1
ConO8BO0: sub.b    #$30,(A0)
          lsl.l    #4,D1
          add.b    (A0)+,D1
ConO8BO1: tst.b    (A0)
          bne.s    ConO8BO0
          rts

;Maksymalna wartość liczby wejściowej: "77777777" ($77777777)
;Jeśli liczba wejściowa będzie dłuższa, to wynik konwersji zostanie ustalony przez jej ostatnie 8-cyfr
;Rozmiar: 24 B, linii kodu: 9

 ConBA: moveq    #$00,D1    ;bajt do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        cmp.b    #$20,D1
        bcs.s    ConBA0
        cmp.b    #$7F,D1
        bcs.s    ConBA1
ConBA0: moveq    #$2E,D1    ;znak xx
ConBA1: move.b   D1,(A0)+
        clr.b    (A0)
        rts

;Maksymalna wartość ciągu wyjściowego: "~" ($7E)
;Jeśli konwertowany bajt będzie miał wartość <$20 lub >$7E,
;to w ciągu wyjściowym zostanie on zastąpiony znakiem xx.
;Rozmiar: 28 B, linii kodu: 10

 ConWA: move.w   #$00,D1    ;dane do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$01,D2
ConWA0: rol.w    #8,D1
        cmp.b    #$20,D1
        bcs.s    ConWA1
        cmp.b    #$7F,D1
        bcs.s    ConWA2
ConWA1: move.b   #$2E,D1    ;znak xx
ConWA2: move.b   D1,(A0)+
        dbf      D2,ConWA0
        clr.b    (A0)
        rts

;Maksymalna wartość ciągu wyjściowego: "~~" ($7E7E)
;Jeśli konwertowany bajt będzie miał wartość <$20 lub >$7E,
;to w ciągu wyjściowym zostanie on zastąpiony znakiem xx.
;Rozmiar: 40 B, linii kodu: 13

 ConLA: move.l   #$00,D1    ;dane do konwersji
        lea      textbuf,A0 ;adres wyjścia danych
        moveq    #$03,D2
ConLA0: rol.l    #8,D1
        cmp.b    #$20,D1
        bcs.s    ConLA1
        cmp.b    #$7F,D1
        bcs.s    ConLA2
ConLA1: move.b   #$2E,D1    ;znak xx
ConLA2: move.b   D1,(A0)+
        dbf      D2,ConLA0
        clr.b    (A0)
        rts

;Maksymalna wartość ciągu wyjściowego: "~~~~" ($7E7E7E7E)
;Jeśli konwertowany bajt będzie miał wartość <$20 lub >$7E,
;to w ciągu wyjściowym zostanie on zastąpiony znakiem xx.
;Rozmiar: 42 B, linii kodu: 13

 ConA4: moveq    #$00,D1    ;wynik konwersji
        lea      textbuf,A0 ;adres wejścia danych
        bra.s    ConA4b
ConA4a: rol.l    #8,D1
        move.b   (A0)+,D1
ConA4b: tst.b    (A0)
        bne.s    ConA4a
        rts

;Maksymalna wartość ciągu wejściowego: "~~~~" ($7E7E7E7E)
;Jeśli ciąg wejściowy będzie dłuższy, to wynik konwersji zostanie ustalony przez jego ostatnie 4-znaki
;Rozmiar: 20 B, linii kodu: 8