;

;Set start of program high enough for

;Atari DOS II & 2.5

;

SET 14=$2000

SET $491=$2000

;

;This should make it Sparta DOS

;compatible

;

PROC SD()

RETURN

;

;Procedures necessary to make the

;program run without the cartridge

;from Jeff Riesner's PD files

;



PROC _CPYPRM=*()

SET $4EE = _CPYPRM

;Called when subroutine has more

;than 2 bytes of parameters.

[$85$A0$86$A1$84$A2$18$68$85$84$69$03

$A8$68$85$85$69$00$48$98$48$A0$01$B1

$84$85$82$C8$B1$84$85$83$C8$B1$84$A8

$B9$A0$00$91$82$88$10$F8$60]



PROC _CHGSGN=*()

;utility for math routines.

[$85$C0$86$C1$38$A9$00$E5$C0$48$A9$00

$E5$C1$AA$68$60]



PROC _FIXSGN=*()

;utility for math routines.

[$86$C2$E0$00$10$03$20 _CHGSGN $85$82

$86$83$A5$85$45$C2$85$C2$A6$85$10$09

$A5$84$20 _CHGSGN $85$84$86$85$60]



PROC _FIXRES=*()

;utility for math routines.

[$A5$86$A6$87$A4$C2$10$03$4C _CHGSGN

$60]



PROC _MUL=*()

SET $4E8 = _MUL

;integer multiplication.

[$20 _FIXSGN $A9$00$85$86$85$87$A5$82

$D0$04$A5$83$F0$22$A5$84$D0$04$A5$85

$F0$1A$46$85$66$84$90$0D$18$A5$86$65

$82$85$86$A5$87$65$83$85$87$06$82$26

$83$38$B0$D6$4C _FIXRES]



PROC _DIV=*()

SET $4EA = _DIV

;integer division.

[$20 _FIXSGN $A9$00$85$86$85$87$85$C1

$A9$01$85$C0$A5$82$D0$04$A5$83$F0$5F

$A5$84$D0$04$A5$85$F0$57$A5$82$C5$84

$A5$83$E5$85$90$0F$A5$C1$30$0B$06$84

$26$85$06$C0$26$C1$38$B0$E7$A5$C0$D0

$04$A5$C1$F0$36$A5$82$D0$04$A5$83$F0

$2E$A5$82$C5$84$A5$83$E5$85$90$19$38

$A5$82$E5$84$85$82$A5$83$E5$85$85$83

$A5$86$05$C0$85$86$A5$87$05$C1$85$87

$46$85$66$84$46$C1$66$C0$38$B0$C2$4C

_FIXRES]



PROC _MODOP=*()

SET $4EC = _MODOP

;MOD operation. Actually just

;remainder of division.

[$20 _DIV $A5$82$A6$83$60]



PROC _ERROU=*()

;Error routine.

[$A9$70$AA$A9$0C$9D$42$03$20$56$E4$8A

$38$E9$10$D0$F1$6C$0A$00]



PROC _ERRVEC=*()

[_ERROU]



PROC _DEVIC=*()

[$00]



MODULE

CARD Error=_ERRVEC

BYTE device=_DEVIC



PROC _GOCIO=*()

;JSR to CIO routine and check

;for errors.

[$20$56$E4$10$1A$C0$88$F0$06$68$68$98

$6C _ERRVEC $48$8A$48$4A$4A$4A$4A$AA

$A9$01$9D$C0$05$68$AA$68$60]



PROC _LODCHN=*()

;Check A reg for illegal IOCB #.

;If ok, X reg = A reg * 16.

[$C9$08$90$07$68$68$A9$86$6C _ERRVEC

$0A$0A$0A$0A$AA$60]



PROC _STONAM=*()

;I/O utility.

[$18$69$01$9D$44$03$98$69$00$9D$45$03

$60]



PROC _SHFTR=*()

;I/O utility.

[$48$8A$A8$68$AA$AD _DEVIC $60]



PROC _CLREOL=*()

;Clear EOL flag.

[$48$A9$00$85$A5$68$60]



PROC _SETEOL=*()

;Set EOL flag.

[$48$A9$01$85$A5$68$60]



PROC _PRECON=*()

;I/O utility.

[$8A$48$98$AA$68$A0$03$84$A3$A0$FD$60]



PROC _DOPRNT=*()

;Print a string.

[$86$A3$84$A4$20 _LODCHN $A9$00$9D$49

$03$A8$B1$A3$F0$1A$9D$48$03$18$A5$A3

$69$01$9D$44$03$A5$A4$69$00$9D$45$03

$A9$0B$9D$42$03$20 _GOCIO $A5$A5$F0

$12$A9$00$9D$48$03$9D$49$03$A9$0B$9D

$42$03$A9$9B$20 _GOCIO $60]



PROC StrC=*(CARD c, s)

[$85$D4$86$D5$84$A2$20$AA$D9$20$E6$D8

$A0$00$B1$F3$30$06$C8$91$A2$38$B0$F6

$29$7F$C8$91$A2$98$A0$00$91$A2$60]



PROC _DOPRNC=*()

;Print a CARD.

[$48$20 _PRECON $20 StrC $68$A2$FD$A0

$03$4C _DOPRNT]



PROC PrintCDE=*(BYTE d CARD c)

[$20 _SETEOL $4C _DOPRNC]



PROC PrintCE=*(CARD c)

[$20 _SHFTR $4C PrintCDE]



PROC PrintD=*(BYTE d CARD s)

[$20 _CLREOL $4C _DOPRNT]



PROC Print=*(CARD s)

[$20 _SHFTR $4C PrintD]



PROC PrintDE=*(BYTE d CARD s)

[$20 _SETEOL $4C _DOPRNT]



PROC PrintE=*(CARD s)

[$20 _SHFTR $4C PrintDE]



PROC PutD=*(BYTE d, c)

[$86$A0$20 _LODCHN $A9$00$9D$48$03$9D

$49$03$A9$0B$9D$42$03$A5$A0$20 _GOCIO

$60]



PROC Put=*(BYTE c)

[$AA$AD _DEVIC $4C PutD]



PROC PutE=*()

[$A9$9B$4C Put]



PROC PutDE=*(BYTE d)

[$A2$9B$4C PutD]



BYTE FUNC ValB=*(CARD a)

CARD FUNC ValC=*(CARD a)

INT FUNC ValI=*(CARD a)

[$85$A2$86$A3$A9$00$85$A0$85$A1$85$A5

$A8$B1$A2$85$A4$C8$B1$A2$C9$20$F0$F9

$C9$2D$D0$0B$C6$A5$C8$C4$A4$F0$02$B0

$31$B1$A2$38$E9$30$90$2A$C9$0A$B0$26

$48$06$A0$26$A1$A5$A0$A6$A1$0A$26$A1

$0A$26$A1$18$65$A0$85$A0$8A$65$A1$85

$A1$18$68$65$A0$85$A0$90$CD$E6$A1$38

$B0$C8$A5$A5$F0$0D$38$A9$00$E5$A0$85

$A0$A9$00$E5$A1$85$A1$60]



PROC _DOINPT=*()

;Called by all input routines.

[$86$A4$84$A5$20 _LODCHN $18$A5$A4$69

$01$9D$44$03$A5$A5$69$00$9D$45$03$A5

$A3$F0$18$9D$48$03$A9$00$9D$49$03$A9

$05$9D$42$03$20 _GOCIO $BD$48$03$F0

$03$38$E9$01$A0$00$91$A4$A5$A6$F0$07

$A5$A4$A6$A5$4C ValC $60]



BYTE FUNC InputBD=*(BYTE d)

CARD FUNC InputCD=*(BYTE d)

INT FUNC InputID=*(BYTE d)

[$48$A9$78$85$A3$A9$01$85$A6$68$A2$FD

$A0$03$4C _DOINPT]



BYTE FUNC InputB=*()

CARD FUNC InputC=*()

INT FUNC InputI=*()

[$AD _DEVIC$4C InputCD]



PROC InputMD=*(BYTE d CARD s BYTE l)

[$48$A9$00$85$A6$68$4C _DOINPT]



PROC InputSD=*(BYTE d CARD s)

[$48$A9$FF$85$A3$68$4C InputMD]



PROC InputS=*(CARD s)

[$20 _SHFTR $4C InputSD]



CHAR FUNC GetD=*(BYTE d)

[$20 _LODCHN $A9$00$9D$48$03

$9D$49$03$A9$07$9D$42$03$20 _GOCIO

$85$A0$60]



PROC Open=*(BYTE d CARD s BYTE m, a)

[$86$A1$20 _LODCHN $A5$A1$20

 _STONAM $A5$A3$9D$4A$03$A5$A4$9D$4B

$03$A9$03$9D$42$03$20 _GOCIO $8A$4A

$4A$4A$4A$AA$A9$00$9D$C0$05$60]



PROC Close=*(BYTE d)

[$20 _LODCHN $A9$0C$9D$42$03$20

_GOCIO $60]



PROC Graphics=*(BYTE m)

[$48$A2$60$A9$0C$9D$42$03$20$56$E4$68

$9D$4B$03$49$10$09$0C$9D$4A$03$A9$53

$85$A0$A9$3A$85$A1$A9$A0$9D$44$03$A9

$00$9D$45$03$A9$03$9D$42$03$20 _GOCIO

$60]



PROC Position=*(CARD x BYTE y)

[$85$55$86$56$84$54$60]



PROC SCopy=*(CARD d, s)

[$85$A0$86$A1$84$A2$A0$00$B1$A2$A8$B1

$A2$91$A0$C0$00$F0$04$88$38$B0$F4$60]



MODULE

;

;*IF* I really wanted to, there's

;nothing wrong with just having

;a small buffer & maybe keeping a

;file open on another drive for

;huge transfers, but it assumes

;everyone has 2 drives. I could also

;read/write the thing in hunks, but

;I've transferred 27K files with SDX

;& the program compiled from disk. I

;can't imagine needing much more then

;that. More features=> smaller buffer

;

BYTE me, DCOMND=770,DUNIT=769,

     DSTATS=771,Key=764,drivetype,

     DDEVIC=768

BYTE POINTER Bptr

CARD SNUM=778,DBUF=772,DBYTE=776,

     DTIME=774,Flen,S,T,C

CARD ARRAY secmap(360)

BYTE ARRAY GPB(256),buf(24000)



DEFINE

 Wait="WHILE Key=255 DO OD Key=255"



PROC Makemap()



CARD MAX



Position(0,8)

PrintE("    Pick 1) For a stock 1050")

PrintE("    Pick 2) For a US Doubler")

Position(10,12)

Put('?)

drivetype=InputB()

IF drivetype=2

 THEN drivetype=18

      MAX=702

 ELSE drivetype=26

      MAX=1014

FI

C=1

;

;Definition for a STOCK 1050 =>26

;US Doubler would be 18

;Percom, ATR or XF551?????

;

FOR T=0 TO MAX STEP drivetype

 DO

  FOR S=1 TO 9

   DO

    secmap(C)=S+T

    C==+1

   OD

 OD

RETURN



PROC DINV=$E453()

RETURN



PROC SIOV=$E459()

RETURN



PROC Write()



PrintE("     Input file name & Drive")

Put(127)

Put('?)

InputS(GPB)

Close(1)

Open(1,GPB,4,0)

Flen=0

WHILE EOF(1)<>1

 DO

  buf(Flen)=GetD(1) XOR $FF

  Flen==+1

 OD

Flen==-1

Print("File Length=")

PrintCE(Flen)

PrintE("     Insert a Mule disk now")

Print("        then press a key ")

Wait

PutE()

;

;I.D. with Hello Atari

;

DUNIT=1 ;DRIVE D1:

DCOMND='W ;write

SNUM=1;I.D. sector

SCopy (GPB,"Hello Atari")

Bptr=GPB+GPB(0)+1

Bptr^=0;'C end of string for IBM side

FOR Bptr=GPB TO GPB+127

 DO

  Bptr^==XOR $FF

 OD

DBUF=GPB+1

 PrintE("Writing Sector #1")

DINV()

;

;File length in sector #2

;

PrintE("Writing Sector #2")

GPB(0)=Flen MOD 256 XOR $FF

GPB(1)=Flen/256 XOR $FF

DUNIT=1 ;DRIVE D1:

DCOMND='W ;write

DBUF=GPB

SNUM=2;FILE LENGTH SECTOR

DINV()

;

;1ST PART OF FILE IN SECTOR #3

;

PrintE("Writing Sector #3")

DUNIT=1 ;DRIVE D1:

DCOMND='W ;write

DBUF=buf

SNUM=3;1st data SECTOR

DINV()

;

;I believe DUNIT  etc have to be reset

;every pass. Certainly doesn't hurt

;

T=Flen/128+3

IF (Flen MOD 128)

 THEN T==+1

FI

FOR C=4 TO T

DO

 Print("Writing Sector #")

 PrintCE(C)

 SNUM=secmap(C)

 DDEVIC='1

 DUNIT=1 ;DRIVE D1:

 DCOMND='W ;write

 DBUF=buf+128*(C-3)

 DSTATS=$80;SIO direction=>output to D1:

 DTIME=3  ;reasonable time out value

  IF drivetype=18

   THEN

    DBYTE=$100;256 byte SECTOR

  ELSE DBYTE=$80

  FI

 SIOV()

OD



RETURN



PROC Read()



PrintE(" INSERT MULE DISK IN D1:")

Print("  PRESS a key when ready")

Wait

DUNIT=1 ;DRIVE D1:

DCOMND='R ;READ

SNUM=1

DBUF=GPB

DINV()

FOR Bptr=GPB TO GPB+10

 DO

  Bptr^==XOR $FF

  Put(Bptr^)

 OD

PutE()

IF GPB(0)<> 'H THEN

PrintE("   Probably not a Mule disk!")

PrintE("  REMOVE & REINSERT THE DISK")

Print("   PRESS ANY KEY TO CONTINUE ")

Wait

RETURN

FI

SNUM=2

DINV()

Flen=(GPB(1) XOR $FF)*256

Flen==+(GPB(0) XOR $FF)

Print("File length=")

PrintCE(Flen)

S=3

T=Flen/128+2

IF (Flen MOD 128)

 THEN T==+1 FI

FOR C=S TO T

DO

 SNUM=secmap(C)

 DBUF=buf+128*(C-3)

 Print("  Reading Sector #")

 PrintCE(C)

 DINV()

 FOR

  Bptr=buf+128*(C-3)

     TO

  buf+128*(C-3)+127

   DO

    Bptr^==XOR $FF

   OD

OD

PrintE("   PUT an Atari disk in D1:")

Print("   PRESS ANY KEY TO CONTINUE ")

Wait

PutE()

Close(1)

Open(1,"D1:MULE.DAT",8,0)

Put(127)

PrintE("Writing FILE as D1:MULE.DAT")

FOR Bptr=buf TO buf+Flen-1

DO

 PutD(1,Bptr^)

OD

Close(1)

RETURN



BYTE FUNC Menu()



Put(125)

Position(0,8)

PrintE("  Enter 0 or <RETURN> to quit")

PrintE("     1 to WRITE a MULE disk")

PrintE("     2 to READ a MULE disk")

Position(14,12)

Put('?)

me=InputB()



RETURN(me)



PROC Main()

BYTE choice=[1],rmarg=82



rmarg=0

Graphics(0)

Makemap()

WHILE choice<>0

DO

choice=Menu()

IF choice=1

 THEN

  Write()

FI

IF choice=2

 THEN

  Read()

FI

OD