OldComp.cz

1+++++++++++++++ ticho, ale nepouzivat kvuli trvalemu napeti
1++++++++++++++0 hlasitejsi pocit, ale nepouzivat kvuli tomu ze je beeper delsi cas pod napetim
1+++++++++++++0- hlasitejsi pocit, ale nepouzivat kvuli tomu ze je beeper delsi cas pod napetim
1++++++++++++0-- hlasitejsi pocit, ale nepouzivat kvuli tomu ze je beeper delsi cas pod napetim
1+++++++++++0--- hlasitejsi pocit, ale nepouzivat kvuli tomu ze je beeper delsi cas pod napetim
1++++++++++0---- hlasitejsi pocit, ale nepouzivat kvuli tomu ze je beeper delsi cas pod napetim
1+++++++++0----- hlasitejsi pocit, ale nepouzivat kvuli tomu ze je beeper delsi cas pod napetim
1++++++++0------ hlasitejsi pocit, ale nepouzivat kvuli tomu ze je beeper delsi cas pod napetim
0-------1+++++++ nejhlasitejsi pocit, ale nepouzivat protoze to konci v 1
1+++++++0------- nejhlasitejsi pocit
1++++++0-------- jemnejsi pocit
1+++++0--------- jemnejsi pocit
1++++0---------- jemnejsi pocit
1+++0----------- jemnejsi pocit
1++0------------ jemnejsi pocit
1+0------------- jemnejsi pocit
10-------------- jemnejsi pocit
0--------------- ticho

 1: octode     test
 2: octode2k15 test
3: octode2k16 test
4: alf2_zalza
5: pd_dawn
6: _first_last_
7: exit

#!/bin/sh

#handle command line options
if [ "$1" = "-t" ]
   then title=$2
   elif [ "$1" = "-a" ]
      then addr="$2"
   elif [ "$1" = "-c" ]
      then composer="$2"
fi

if [ "$3" = "-c" ]
   then composer="$4"
   elif [ "$3" = "-a" ]
      then addr="$4"
fi

if [ "$5" = "-a" ]
   then addr="$6"
fi

#!/bin/sh

#check ./xm2octode2k16
if [ ! -f ./xm2octode2k16 ] ; then
   g++ ./xm2octode2k16.cpp -o xm2octode2k16
fi
if [ ! -f ./xm2octode2k16 ] ; then
   echo "File ./xm2octode2k16 not found!" >&2
   exit 2
fi
   
#handle command line options
while [ $# -gt 0 ] ; do
   if [ "$1" = "-t" ] ; then
      title=$2
   elif [ "$1" = "-a" ] ; then
      addr="$2"
   elif [ "$1" = "-c" ] ; then
      composer="$2"
   elif [ "$1" = "-f" ] ; then
      file="$2"
   else
      echo "Bad parameter: $1" >&2
      echo "Use: $0 -t title -a addr -c composer -f file" >&2
      echo "Default:" >&2
      echo "   title: " >&2
      echo "   composer: " >&2
      echo "   file: music.xm" >&2
      echo "   addr: 32768" >&2
      exit 1
   fi
   shift
   shift
done

#!/bin/sh

# Use:
#   compile.sh name_without_suffix
#   compile.sh name_without_suffix start_addr
#   compile.sh name_without_suffix start_addr no_emul
#   compile.sh name_without_suffix start_addr emulator parameters

# ------------------- Parameter reading

[ $# -lt 1 ] && printf "Error: Need filename!\n" >&2 && exit 1

name=$1
shift

[ ! -s $name.m4 ] && printf "Error: $name.m4 not found!\n" >&2 && exit 2

case $1 in
    0x[0-9a-fA-F]*) addr=$(printf "%d" $1); shift ;;
    ''|*[!0-9]*) ;;
    *) addr=$1; shift ;;
esac

[ ! -z $1 ] && emul=$1 && shift

printf "name: $name.m4\n"
printf "addr: $addr\n"
printf "emul: $emul\n"
printf "parameters: $*\n\n"

# ------------------- Compilation m4>asm

printf "Compilation m4>asm: ...";

m4 $name.m4 > $name.asm

error=$?     
[ $error != 0 ] && printf "fail!\nError: $error\n" && exit 3
printf "ok!\n";

if [ -f $name.bin ] ; then
    old=$(ls -l $name.bin)
else
    old="not exist"
fi

# ------------------- Compilation asm>bin

printf "Compilation asm>bin: ...";

if [ -z $addr ] ; then
    pasmo -d                   $name.asm $name.bin > smaz
    pasmo --tap                $name.asm $name.tap 2>/dev/null
else
    pasmo -d    --equ __ORG=$addr $name.asm $name.bin > smaz
    pasmo --tap --equ __ORG=$addr $name.asm $name.tap 2>/dev/null
fi

error=$?     
[ $error != 0 ] && printf "fail!\nError: $error\n" && exit 4
[ ! -s $name.bin ] && printf "fail!\nError: $name.bin not exist or is empty\n" && exit 5
printf "ok!\n";

printf "old: $old\n"
printf "new: "
ls -l $name.bin

[ -z $addr ] && exit 0

# ------------------- Generate loader if addr exist

if [ ! -f loader.bas ] ; then
    printf "Generate basic loader...\n"
    printf "10 LOAD \"\" CODE\n" > loader.bas
    printf "20 POKE 23672,0: POKE 23673,0: POKE 23674,0\n" >> loader.bas
    printf "30 RANDOMIZE USR $addr\n" >> loader.bas
    printf "40 PAUSE 1: LET s=PEEK 23672+256*PEEK 23673+65536*PEEK 23674: LET s=s/50: LET m=INT (INT s/60): LET h=INT (m/60): PRINT \"Time: \";h;\"h \";m-60*h;\"min \";INT ((s-60*m)*100)/100;\"s \";: PAUSE 0: STOP\n" >> loader.bas
else
    printf "The existing loader.bas will be used\n"
fi

printf "Compilation bas>tap: ...";

zmakebas -o loader.tap loader.bas

error=$?     
[ $error != 0 ] && printf "fail!\nError: $error\n" && exit 6

printf "ok!\n";

# ------------------- Concatenate loader with code and clean

mv ./$name.tap ./${name}_bin.tap
cat loader.tap ${name}_bin.tap > $name.tap
rm loader.tap
rm ${name}_bin.tap

# ------------------- Run the ZX Spectrum emulator

[ "$emul" = "no_emul" ] && exit 0

if [ ! -z $emul ] ; then
    [ ! -x "$(command -v $emul)" ] && printf "Error: $emul not found!\n" >&2 && exit 7
    $emul $* $name.tap
    exit 0
fi

if [ -x "$(command -v fuse)" ] ; then
    fuse -m 48 -t $name.tap
    exit 0
fi

if [ -x "$(command -v fuse-sdl)" ] ; then
    fuse-sdl -m 48 -t $name.tap
    exit 0
fi

if [ -x "$(command -v fbzx)" ] ; then
    fbzx $name.tap
    exit 0
fi

printf "No ZX Spectrum emulator found installed. Tried fuse, fuse-sdl and fbzx."

loop
     dw ptn0
     dw 0
ptn0
     dw #300,row0
     dw #380,#0080,row1
     db #40
row0
     dw #200,#400,#300,#0,#0,#0,#0,#0
row1
     dw #0,#200,#e41,#0,#0,#0,#0,#0

filename_loop:
     dw filename_ptn0
     dw 0
filename_ptn0:
     dw 0x300,filename_row0
     dw 0x380,0x0080,filename_row1
     db 0x40
filename_row0:
     dw 0x200,0x400,0x300,0x0,0x0,0x0,0x0,0x0
filename_row1:
     dw 0x0,0x200,0xe41,0x0,0x0,0x0,0x0,0x0

  ifndef filename
filename equ $
  endif
filename_loop equ filename+0x0
     dw filename_ptn0
     dw 0
filename_ptn0 equ filename+0x4
     dw 0x300,filename_row0
     dw 0x380,0x0080,filename_row1
     db 0x40
filename_rows equ filename+0x9
filename_row0 equ filename_rows+0x0
     dw 0x200,0x400,0x300,0x0,0x0,0x0,0x0,0x0
filename_row0 equ filename_rows+0x1
     dw 0x0,0x200,0xe41,0x0,0x0,0x0,0x0,0x0

dworkin@dw-A15:~/Programovani/ZX/Forth/LZE_test$ ../check_word.sh 'define({USE_LZE})'
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Busy soft ;; LZE optimized depacker ;; 08.07.2016 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

DEPREP_LZE:             ;           depack_lze
    push BC             ; 1:11      depack_lze      Save block length
    ld    A, 0x7F       ; 2:7       depack_lze
    call DEPNUM_LZE     ; 3:17      depack_lze      Get relative offset of packed sequence
    ex  (SP),HL         ; 1:19      depack_lze
    push HL             ; 1:11      depack_lze
    ld    H, D          ; 1:4       depack_lze      DE = destination address
    ld    L, E          ; 1:4       depack_lze
    sbc  HL, BC         ; 2:15      depack_lze      HL = begin of source sequence in already unpacked data
    pop  BC             ; 1:10      depack_lze      BC = length of sequence
    ldir                ; 2:16/21   depack_lze      Copy sequence
    pop  HL             ; 1:10      depack_lze
   
;; Input:
;;  HL = address of source packed data
;;  DE = address of destination to depack data
DEPACK_LZE:             ;           depack_lze   
    bit   6,(HL)        ; 2:12      depack_lze      Get identification of block: 0=unpacked, 1=packed
    push AF             ; 1:11      depack_lze
    ld    A, 0x3F       ; 2:7       depack_lze   
    call DEPNUM_LZE     ; 3:17      depack_lze      Get length of block
    pop  AF             ; 1:10      depack_lze
    jr   nz, DEPREP_LZE ; 2:7/12    depack_lze      If packed block then jump
    ld    A, B          ; 1:4       depack_lze
    or    C             ; 1:4       depack_lze      If length = 0 then end of depacking
    ret   z             ; 1:5/11    depack_lze
    ldir                ; 2:16/21   depack_lze      Copy unpacked data block
    jr   DEPACK_LZE     ; 2:12      depack_lze
DEPNUM_LZE:             ;           depack_lze
    and (HL)            ; 1:7       depack_lze      Mask one-byte value or high byte of two-byte value
    ld    C, A          ; 1:4       depack_lze
    ld    B, 0x00       ; 2:7       depack_lze      BC = value or high type of value
    bit   7,(HL)        ; 2:12      depack_lze
    inc  HL             ; 1:6       depack_lze
    ret   z             ; 1:5/11    depack_lze      If short value then return
    ld    B, C          ; 1:4       depack_lze
    ld    C,(HL)        ; 1:7       depack_lze      Get low byte of two-byte value
    inc  HL             ; 1:6       depack_lze
    ret                 ; 1:10      depack_lze
                       ;[46:]
   
;; Format of packed data
;; ~~~~~~~~~~~~~~~~~~~~~
;; <Block><Block>...<Block><EndMark>
;;
;; Unpacked data blk:  <BlockLength> <Data..>
;; Repeated sequence:  <BlockLength> <Offset>
;;
;; <BlockLength>
;;   bit 6 ..... Identification: 0 = unpacked data, 1 = repeated sequence
;;   bit 7 ..... Length store: 0 = 6-bit length 0..63, 1 = 14-bit length 0..16383
;;   bit 0-5 ... whole 6-bit length  or  high byte of 14-bit length
;;   Additonal second byte: low byte of length in case of 14-bit length
;;
;; <Data..>
;;   Data bytes what are directly copied by LDIR
;;
;; <Offset>
;;   bit 7 ..... Offset store: 0 = 7-bit offset 0..127, 1 = 15-bit offset 0..32767
;;   bit 0-6 ... whole 7-bit offset  or  high byte of 15-bit offset
;;   Additonal second byte: low byte of offset in case of 15-bit offset
;;
;; Length = 0 means end mark.
; seconds: 0           ;[46:297]

DEPREP_LZE:             ;           depack_lze
    push BC             ; 1:11      depack_lze      Save block length
    ld    A, 0x7F       ; 2:7       depack_lze
    call DEPNUM_LZE     ; 3:17      depack_lze      Get relative offset of packed sequence
    ex  (SP),HL         ; 1:19      depack_lze
    push HL             ; 1:11      depack_lze
    ld    H, D          ; 1:4       depack_lze      DE = destination address
    ld    L, E          ; 1:4       depack_lze
    sbc  HL, BC         ; 2:15      depack_lze      HL = begin of source sequence in already unpacked data
    pop  BC             ; 1:10      depack_lze      BC = length of sequence
    ldir                ; 2:16/21   depack_lze      Copy sequence
    pop  HL             ; 1:10      depack_lze
                       ;[16:124]
;   ...fall down to depack_lze

DEPREP_LZE:             ;           depack_lze
    push BC             ; 1:11      depack_lze      Save block length
    ld    A,(HL)        ; 1:7       depack_lze      A = %6543210D; D = Double bit
    call DEPNUM_LZE     ; 3:17      depack_lze      Get relative offset of packed sequence
    ex  (SP),HL         ; 1:19      depack_lze      Load block lengt and save address of source packed data
    push HL             ; 1:11      depack_lze      Save block length
    ld    H, D          ; 1:4       depack_lze      DE = destination address
    ld    L, E          ; 1:4       depack_lze
    sbc  HL, BC         ; 2:15      depack_lze      HL = begin of source sequence in already unpacked data
    pop  BC             ; 1:10      depack_lze      BC = length of sequence
    ldir                ; 2:16/21   depack_lze      Copy sequence
    pop  HL             ; 1:10      depack_lze
                        ;[15:124]

;# Input:
;#  HL = address of source packed data
;#  DE = address of destination to depack data
;# ===========================================
DEPACK_LZE:             ;           depack_lze   
    bit   6,(HL)        ; 2:12      depack_lze      Get identification of block: 0=unpacked, 1=packed
    push AF             ; 1:11      depack_lze
    ld    A, 0x3F       ; 2:7       depack_lze   
    call DEPNUM_LZE     ; 3:17      depack_lze      Get length of block
    pop  AF             ; 1:10      depack_lze
    jr   nz, DEPREP_LZE ; 2:7/12    depack_lze      If packed block then jump
                       ;[11:64]

    ld    A, B          ; 1:4       depack_lze
    or    C             ; 1:4       depack_lze      If length = 0 then end of depacking
    ret   z             ; 1:5/11    depack_lze

    ldir                ; 2:16/21   depack_lze      Copy unpacked data block
    jr   DEPACK_LZE     ; 2:12      depack_lze
                       ;[18:105]

;# Input:
;#  HL = address of source packed data
;#  DE = address of destination to depack data
;# ===========================================
DEPACK_LZE:             ;           depack_lze   
    ld    A,(HL)        ; 1:7       depack_lze      A = %P543210D; P = Packed bit; D = Double bit
    or    A             ; 1:4       depack_lze      Reset carry and set sign and zero flag
    rla                 ; 1:4       depack_lze      A = %??????D0; sign unaffected
    rrca                ; 1:4       depack_lze      A = %0??????D; sign unaffected, reset carry
    call DEPNUM_LZE     ; 3:17      depack_lze      Get length of block; sign and zero flag unaffected
    jp    m, DEPREP_LZE ; 3:10      depack_lze      If packed block then jump
                        ;[10:46]

    ret   z             ; 1:5/11    depack_lze      If zero then end of depacking

    ldir                ; 2:16/21   depack_lze      Copy unpacked data block
    jr   DEPACK_LZE     ; 2:12      depack_lze

DEPNUM_LZE:             ;           depack_lze
    and (HL)            ; 1:7       depack_lze      Mask one-byte value or high byte of two-byte value
    ld    C, A          ; 1:4       depack_lze
    ld    B, 0x00       ; 2:7       depack_lze      BC = value or high type of value
    bit   7,(HL)        ; 2:12      depack_lze
    inc  HL             ; 1:6       depack_lze
    ret   z             ; 1:5/11    depack_lze      If short value then return
                       ;[ 8:41]
   
    ld    B, C          ; 1:4       depack_lze
    ld    C,(HL)        ; 1:7       depack_lze      Get low byte of two-byte value
    inc  HL             ; 1:6       depack_lze
    ret                 ; 1:10      depack_lze
                        ;[4:27]

;# Input:
;#      reset carry
;#      A  = (HL)
;#      HL = address of source packed data
;# Output1:
;#      carry and sign and zero flag unaffected
;#      BC = %0000 0000 0s?? ????
;#      HL++
;# Output2:
;#      carry and sign and zero flag unaffected
;#      BC = %0s?? ???? ???? ????
;#      HL+= 2
DEPNUM_LZE:             ;           depack_lze     
    inc  HL             ; 1:6       depack_lze
    rra                 ; 1:4       depack_lze      6543210D -> .6543210 carry=D
    ld    C, A          ; 1:4       depack_lze
    ld    B, 0x00       ; 2:7       depack_lze
    ret  nc             ; 1:5/11    depack_lze      If short value then return BC = %0000 0000 0??? ????
                       ;[ 6:26]

    ccf                 ; 1:4       depack_lze
    ld    B, C          ; 1:4       depack_lze
    ld    C,(HL)        ; 1:7       depack_lze      Get low byte of two-byte value
    inc  HL             ; 1:6       depack_lze
    ret                 ; 1:10      depack_lze      BC = %0??? ???? ???? ????
                        ;[5:31]