Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!linus!philabs!cmcl2!seismo!rochester!bullwinkle!uw-beaver!tikal!bobc
From: bobc@tikal.UUCP (Bob Campbell)
Newsgroups: net.sources.mac
Subject: ETHZ Standalone Implementation Modules (2 of 6)
Message-ID: <432@tikal.UUCP>
Date: Tue, 13-May-86 11:59:42 EDT
Article-I.D.: tikal.432
Posted: Tue May 13 11:59:42 1986
Date-Received: Thu, 15-May-86 08:21:21 EDT
Reply-To: bobc@tikal.UUCP (Bob Campbell)
Organization: Teltone Corp., Kirkland, WA
Lines: 3622

# The rest of this file is a shell script which will extract:
# EventManager.MOD FileManager.MOD FileTypes.MOD FontManager.MOD IUPackage.MOD InOut.MOD MacSYSTEM.MOD
echo x - EventManager.MOD
cat >EventManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE EventManager;
   (* MacIntosh ToolBox Event Manager Operations *)

FROM MacSYSTEM IMPORT LONGINT,OSErr;
FROM QuickDraw IMPORT Point;
FROM SYSTEM IMPORT ADDRESS,CODE,SETREG,REGISTER,ADR,WORD;

CONST
    GetRet = 0285FH;    (* MOVEA (A7)+,A4       *)
    Return = 04ED4H;    (* JMP  A4              *)
    SaveA7      = 0264FH;   (* MOVEA A7,A3      *)
    RestoreA7   = 02E4BH;   (* MOVEA A3,A7      *)

VAR
    SysEvtMask[00000144H]:CARDINAL;

PROCEDURE EventAvail(mask:WORD; VAR theEvent: EventRecord):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A971H);
    CODE(RestoreA7);CODE(Return);
END EventAvail;

PROCEDURE  GetNextEvent(mask:WORD; VAR theEvent: EventRecord):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A970H);
    CODE(RestoreA7);CODE(Return);
END GetNextEvent;

PROCEDURE StillDown():BOOLEAN;
(*    INLINE $A973;*)
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A973H);
    CODE(RestoreA7);CODE(Return);
END StillDown;

PROCEDURE WaitMouseUp():BOOLEAN;
(*   INLINE $A977;*)
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A977H);
    CODE(RestoreA7);CODE(Return);
END WaitMouseUp;

PROCEDURE xGetMouse (VAR pt: LONGINT);
(* INLINE $A972;*)
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A972H);
    CODE(RestoreA7);CODE(Return);
END xGetMouse;

PROCEDURE GetMouse (VAR pt: Point);
(*$P+*)(*$S-*)
BEGIN
    xGetMouse(pt.param);
END GetMouse;

PROCEDURE TickCount():LONGINT;
(* INLINE $A975;*)
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A975H);
    CODE(RestoreA7);CODE(Return);
END TickCount;

PROCEDURE Button():BOOLEAN;
(*INLINE $A974;*)
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A974H);
    CODE(RestoreA7);CODE(Return);
END Button;

PROCEDURE GetKeys(VAR k: KeyMap);
(*INLINE $A976;*)
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A976H);
    CODE(RestoreA7);CODE(Return);
END GetKeys;

PROCEDURE PostEvent (eventNum: WORD; eventMsg: LONGINT): OSErr;
(*$P+*)(*$S-*)
BEGIN
    SETREG(8,eventNum);
    SETREG(0,eventMsg);
    CODE(0A02FH);
    RETURN(INTEGER(REGISTER(0)));
END PostEvent;

PROCEDURE FlushEvents (whichMask,stopMask: WORD);
(*$P+*)(*$S-*)
BEGIN
    CODE(0202EH);CODE(00008H);  (* MOVE.L 8(A6),D0 *)
    CODE(0A032H);
END FlushEvents;

PROCEDURE SetEventMask (theMask: WORD);
BEGIN
    SysEvtMask := CARDINAL(theMask)
END SetEventMask;

PROCEDURE OSEventAvail (mask: WORD; VAR theEvent: EventRecord): BOOLEAN;
BEGIN
    SETREG(8,ADR(theEvent));
    SETREG(0,mask);
    CODE(0A030H);
    RETURN(REGISTER(0) = 0)
END OSEventAvail;

PROCEDURE GetOSEvent  (mask: WORD; VAR theEvent: EventRecord): BOOLEAN;
BEGIN
    SETREG(8,ADR(theEvent));
    SETREG(0,mask);
    CODE(0A031H);
    RETURN(REGISTER(0) = 0);
END GetOSEvent;

END EventManager.



!Funky!Stuff!
echo x - FileManager.MOD
cat >FileManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE FileManager;

FROM SYSTEM IMPORT ADR,REGISTER,SETREG,CODE,ADDRESS,WORD;
FROM Storage IMPORT ALLOCATE,DEALLOCATE;
FROM PascalStrings IMPORT MakeModulaString,MakePascalString;
FROM MacSYSTEM IMPORT LONGINT,StringPtr,OSErr,noErr;
FROM FileTypes IMPORT
(*CONST*)
    opWrErr,permErr,
(*TYPE*)
    OSType,FInfo,ParamBlkPtr,ParamBlkType,ParamBlockRec;

CONST
    OpenTrap    =   0A000H;
    CloseTrap   =   0A001H;
    ReadTrap    =   0A002H;
    WriteTrap   =   0A003H;
    ControlTrap =   0A004H;
    StatusTrap  =   0A005H;
    KillIOTrap  =   0A006H;
    GetVolInfoTrap  =   0A007H;
    CreateTrap  =   0A008H;
    DeleteTrap  =   0A009H;
    OpenRFTrap  =   0A00AH;
    RenameTrap  =   0A00BH;
    GetFileInfoTrap =   0A00CH;
    SetFileInfoTrap =   0A00DH;
    UnmountVolTrap  =   0A00EH;
    MountVolTrap    =   0A00FH;
  
    AllocateTrap    =   0A010H;
    GetEOFTrap  =   0A011H;
    SetEOFTrap  =   0A012H;
    FlushVolTrap    =   0A013H;
    GetVolTrap  =   0A014H;
    SetVolTrap  =   0A015H;
    FInitQueueTrap  =   0A016H;
    EjectTrap   =   0A017H;
    GetFPosTrap =   0A018H;
  
    SetFilLockTrap  =   0A041H;
    RstFilLockTrap  =   0A042H;
    SetFilTypeTrap  =   0A043H;
    SetFPosTrap =   0A044H;
    FlushFileTrap   =   0A045H;

TYPE
    SaveRecPtr= POINTER TO SaveRec;
    SaveRec = RECORD
    Next :      SaveRecPtr;
    Buffer :    ADDRESS;
    FileNum:    INTEGER
    END;

VAR
    HEAD : SaveRecPtr;

PROCEDURE SaveBuffer(ref:INTEGER; buf : ADDRESS);
(* remember the address of the file buffer *)
VAR
    p : SaveRecPtr;
BEGIN
    NEW(p);
    IF (p # NIL) THEN
    p^.Buffer := buf;
    p^.FileNum := ref;
    p^.Next := HEAD;
    HEAD := p
    END
END SaveBuffer;

PROCEDURE FreeBuffer(ref:INTEGER);
(* free up the file buffer *)
VAR
    p,q : SaveRecPtr;
BEGIN
    p := HEAD;
    q := NIL;
    WHILE (p # NIL) DO
    IF (p^.FileNum = ref) THEN
        DEALLOCATE(p^.Buffer,524);
        p^.FileNum := 0;
        IF (q = NIL) THEN
        HEAD := p^.Next
        ELSE
        q^.Next := p^.Next
        END;
        DISPOSE(p);
        RETURN
    END;
    q := p;
    p := q^.Next
    END
END FreeBuffer;

(* Accessing Volumes *)
PROCEDURE GetVInfo(drive:INTEGER;vol:StringPtr;
    VAR vRef:INTEGER;VAR free:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
    TmpString:  ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (vol # NIL) AND (vol # StringPtr(0)) THEN
    PB.ioNamePtr := ADR(TmpString);
    MakePascalString(vol^,PB.ioNamePtr^);
    ELSE
    PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVolIndex   := drive;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(GetVolInfoTrap);
    IF (vol # NIL) AND (vol # StringPtr(0)) THEN
    MakeModulaString(PB.ioNamePtr^,vol^);
    END;
    vRef := PB.ioVRefNum;
    free := LONGINT(PB.ioVFrBlk) * PB.ioVAlBlkSiz;
    RETURN(PB.ioResult);
END GetVInfo;

PROCEDURE GetVol(volName:StringPtr;VAR vRefNum:INTEGER):OSErr;

VAR PB:ParamBlockRec;
    TmpString:  ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # StringPtr(0)) AND (volName # NIL) THEN
    PB.ioNamePtr := StringPtr(0)
    ELSE
    PB.ioNamePtr := ADR(TmpString);
    END;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(GetVolTrap);
    IF (volName # StringPtr(0)) AND (volName # NIL) THEN
    MakeModulaString(PB.ioNamePtr^,volName^);
    END;
    vRefNum := PB.ioVRefNum;
    RETURN(PB.ioResult);
END GetVol;

PROCEDURE SetVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # StringPtr(0)) AND (volName # NIL) THEN
    MakePascalString(volName^,Str);
    PB.ioNamePtr := ADR(Str);
    ELSE
    PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(SetVolTrap);
    RETURN(PB.ioResult);
END SetVol;

PROCEDURE FlushVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # NIL) AND (volName # StringPtr(0)) THEN
    MakePascalString(volName^,Str);
    PB.ioNamePtr := ADR(Str)
    ELSE
    PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(FlushVolTrap);
    RETURN(PB.ioResult);
END FlushVol;

PROCEDURE UnmountVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # NIL) AND (volName # StringPtr(0)) THEN
    MakePascalString(volName^,Str);
    PB.ioNamePtr := ADR(Str)
    ELSE
    PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(UnmountVolTrap);
    RETURN(PB.ioResult);
END UnmountVol;

PROCEDURE Eject(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # NIL) AND (volName # StringPtr(0)) THEN
    MakePascalString(volName^,Str);
    PB.ioNamePtr := ADR(Str)
    ELSE
    PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(EjectTrap);
    RETURN(PB.ioResult);
END Eject;

(* Changine File Contents *)
PROCEDURE Create(VAR Name:ARRAY OF CHAR;vRef:INTEGER;
    creator,type:OSType):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
    f:FInfo;
    ret:OSErr;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(Name,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioFVersNum := 0C;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(CreateTrap);
    IF (PB.ioResult <> noErr) THEN
    RETURN(PB.ioResult);
    END;
    ret := GetFInfo(Name,vRef,f);
    IF (ret <>noErr) THEN
    RETURN(ret)
    END;
    f.fdType := type;
    f.fdCreator := creator;
    RETURN(SetFInfo(Name,vRef,f));
END Create;

PROCEDURE FSOpen(VAR Name:ARRAY OF CHAR;vRef:INTEGER;
    VAR ref:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(Name,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    PB.ioPermssn := 0C;
    ALLOCATE(PB.ioMisc,524);
    IF (PB.ioMisc = NIL) THEN
    PB.ioMisc := ADDRESS(0)
    END;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(OpenTrap);
    ref := PB.ioRefNum;
    IF (PB.ioMisc # ADDRESS(0)) THEN
    IF ((PB.ioResult = noErr) OR (PB.ioResult = opWrErr)
       OR (PB.ioResult = permErr)) THEN
        SaveBuffer(ref,PB.ioMisc);
    ELSE
        DEALLOCATE(PB.ioMisc,524)
    END
    END;
    RETURN(PB.ioResult);
END FSOpen;
 
PROCEDURE FSRead(refNum:INTEGER;VAR count:LONGINT;buff:ADDRESS):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := refNum;
    PB.ioReqCount := count;
    PB.ioPosMode := 0;
    PB.ioPosOffset := 0;
    PB.ioBuffer := buff;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(ReadTrap);
    count := PB.ioActCount;
    RETURN(PB.ioResult);
END FSRead;

PROCEDURE FSWrite(ref:INTEGER;VAR count:LONGINT;buff:ADDRESS):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioReqCount := count;
    PB.ioPosMode := 0;
    PB.ioPosOffset := 0;
    PB.ioBuffer := buff;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(WriteTrap);
    count := PB.ioActCount;
    RETURN(PB.ioResult);
END FSWrite;

PROCEDURE GetFPos(refNum:INTEGER;VAR filePos:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := refNum;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(GetFPosTrap);
    filePos := PB.ioPosOffset;
    RETURN(PB.ioResult);
END GetFPos;

PROCEDURE SetFPos(ref:INTEGER;posMode:INTEGER;posOff:LONGINT):OSErr;
VAR PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioPosMode := posMode;
    PB.ioPosOffset := posOff;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(SetFPosTrap);
    RETURN(PB.ioResult)
END SetFPos;

PROCEDURE GetEOF(ref:INTEGER;VAR logEOF:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(GetEOFTrap);
    logEOF := PB.ioMisc;
    RETURN(PB.ioResult);
END GetEOF;
 
PROCEDURE SetEOF(ref:INTEGER;logEOF:LONGINT):OSErr;
VAR PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioMisc := ADDRESS(logEOF);
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(SetEOFTrap);
    RETURN(PB.ioResult);
END SetEOF;
  
PROCEDURE Allocate(ref:INTEGER;VAR count:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioReqCount := count;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(AllocateTrap);
    count := PB.ioActCount;
    RETURN(PB.ioResult);
END Allocate;

PROCEDURE FSClose(ref:INTEGER):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    FreeBuffer(ref);
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(CloseTrap);
    RETURN(PB.ioResult);
END FSClose;

(* Changing Information About Files *)
PROCEDURE GetFInfo(VAR file:ARRAY OF CHAR;vRef:INTEGER;VAR fndr:FInfo):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    PB.ioFDirIndex := 0;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(GetFileInfoTrap);
    IF (PB.ioResult = noErr) THEN
    fndr := PB.ioFlFndrInfo
    END;
    RETURN(PB.ioResult);
END GetFInfo;

PROCEDURE SetFInfo(VAR file:ARRAY OF CHAR;vRef:INTEGER;fndrInfo:FInfo):OSErr;
VAR
    PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    PB.ioFDirIndex := 0;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(GetFileInfoTrap);   (* get create/modification times *)
    PB.ioFlFndrInfo := fndrInfo;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(SetFileInfoTrap);
    RETURN(PB.ioResult);
END SetFInfo;

PROCEDURE SetFLock(VAR file:ARRAY OF CHAR;vRef:INTEGER):OSErr;
VAR
    PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(SetFilLockTrap);
    RETURN(PB.ioResult);
END SetFLock;

PROCEDURE RstFLock(VAR file:ARRAY OF CHAR;vRef:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(RstFilLockTrap);
    RETURN(PB.ioResult);
END RstFLock;

PROCEDURE Rename(VAR old:ARRAY OF CHAR;vRef:INTEGER;
    VAR new:ARRAY OF CHAR):OSErr;
VAR
    PB:ParamBlockRec;
    Str,Str2:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(old,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    MakePascalString(new,Str2);
    PB.ioMisc := ADR(Str2);
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(RenameTrap);
    RETURN(PB.ioResult);
END Rename;

PROCEDURE FSDelete(VAR name:ARRAY OF CHAR;vRef:INTEGER):OSErr;
VAR
    PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(name,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    SETREG(8,ADR(PB));      (* A0 := ADR(PB) *)
    CODE(DeleteTrap);
    RETURN(PB.ioResult);
END FSDelete;

BEGIN
    HEAD := NIL
END FileManager.
!Funky!Stuff!
echo x - FileTypes.MOD
cat >FileTypes.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE FileTypes;

(*
 * Empty implementation
 *)

END FileTypes.
!Funky!Stuff!
echo x - FontManager.MOD
cat >FontManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE FontManager;
FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR,REGISTER;
FROM MacSYSTEM IMPORT LONGINT;
FROM PascalStrings IMPORT MakePascalString,MakeModulaString;

CONST
    GetRet = 0285FH;    (* MOVEA (A7)+,A4       *)
    Return = 04ED4H;    (* JMP  A4              *)
    SaveA7      = 0264FH;   (* MOVEA A7,A3      *)
    RestoreA7   = 02E4BH;   (* MOVEA A3,A7      *)

PROCEDURE xGetFontName(fontNumber:INTEGER;name:ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8FFH);
    CODE(RestoreA7);CODE(Return);
END xGetFontName;
PROCEDURE GetFontName(fontNumber:INTEGER;VAR name:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR s1:ARRAY [0..255] OF CHAR;
BEGIN
    xGetFontName(fontNumber,ADR(s1));
    MakeModulaString(s1,name);
END GetFontName;
PROCEDURE xGetFNum(name:ADDRESS;VAR fontNumber:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A900H);
    CODE(RestoreA7);CODE(Return);
END xGetFNum;
PROCEDURE GetFNum(VAR name:ARRAY OF CHAR;VAR fontNumber:INTEGER);
(*$P+*)(*$S-*)
VAR s1:ARRAY [0..255] OF CHAR;
BEGIN
    MakePascalString(name,s1);
    xGetFNum(ADR(s1),fontNumber)
END GetFNum;
PROCEDURE RealFont(fontNumber:INTEGER;pointSize:INTEGER):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A902H);
    CODE(RestoreA7);CODE(Return);
END RealFont;

PROCEDURE GetFontInfo(VAR info:FontInfo);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A88BH);
    CODE(RestoreA7);CODE(Return);
END GetFontInfo;

PROCEDURE SetFontLock(lock:BOOLEAN);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A903H);
    CODE(RestoreA7);CODE(Return);
END SetFontLock;

PROCEDURE FMSwapFont (inRec: FMInput) : FMOutPtr;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A901H);
    CODE(RestoreA7);CODE(Return);
END FMSwapFont;

BEGIN
    CODE(0A8FEH); (* INIT FONTS *)
END FontManager.
!Funky!Stuff!
echo x - IUPackage.MOD
cat >IUPackage.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE IUPackage;
FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
FROM MacSYSTEM IMPORT LONGINT,Handle;
FROM PascalStrings IMPORT MakeModulaString;

CONST
    GetRet      = 0285FH;   (* MOVEA (A7)+,A4       *)
    Return      = 04ED4H;   (* JMP  A4              *)
    SaveA7      = 0264FH;   (* MOVEA A7,A3      *)
    RestoreA7   = 02E4BH;   (* MOVEA A3,A7      *)
    Pack6       = 0A9EDH;
    pIUDatePString  =   14;
    pIUDateString   =   0;
    pIUGetIntl      =   6;
    pIUMagIDString  =   12;
    pIUMagString        =   10;
    pIUMetric       =   4;
    pIUSetIntl      =   8;
    pIUTimePString  =   16;
    pIUTimeString   =   2;
    Push        = 03F3CH;     (* MOVE #VAL,-(A7) *)

(* Routines *)
PROCEDURE xIUDateString (dateTime:LONGINT;form:DateForm;result:ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUDateString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUDateString;

PROCEDURE IUDateString (dateTime:LONGINT;form:DateForm;
  VAR result:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUDateString(dateTime,form,ADR(Str));
  MakeModulaString(Str,result)
END IUDateString;
  
PROCEDURE xIUDatePString (dateTime:LONGINT;form:DateForm;
 result:ADDRESS;intlParam:Handle);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUDatePString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUDatePString;

PROCEDURE IUDatePString (dateTime:LONGINT;form:DateForm;
    VAR result:ARRAY OF CHAR;intlParam:Handle);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUDatePString(dateTime,form,ADR(Str),intlParam);
  MakeModulaString(Str,result)
END IUDatePString;

PROCEDURE xIUTimeString(dateTime:LONGINT;wantSeconds:BOOLEAN;result:ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUTimeString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUTimeString;

PROCEDURE IUTimeString(dateTime:LONGINT;wantSeconds:BOOLEAN;
    VAR result:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUTimeString(dateTime,wantSeconds,ADR(Str));
  MakeModulaString(Str,result)
END IUTimeString;

PROCEDURE xIUTimePString(dateTime:LONGINT;wantSeconds:BOOLEAN;
    result:ADDRESS; intlParam:Handle);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUTimePString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUTimePString;

PROCEDURE IUTimePString(dateTime:LONGINT;wantSeconds:BOOLEAN;
    VAR result:ARRAY OF CHAR; intlParam:Handle);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUTimePString(dateTime,wantSeconds,ADR(Str),intlParam);
  MakeModulaString(Str,result);
END IUTimePString;

PROCEDURE IUMetric():BOOLEAN;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUMetric);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUMetric;

PROCEDURE IUGetIntl(theID:INTEGER):Handle;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUGetIntl);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUGetIntl;

PROCEDURE IUSetIntl(refNum:INTEGER; theID:INTEGER;intlParam:Handle);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUSetIntl);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUSetIntl;

PROCEDURE IUCompString(VAR aStr,bStr:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR
BEGIN
  RETURN(IUMagString(ADR(aStr),ADR(bStr),HIGH(aStr),HIGH(bStr)))
END IUCompString;

PROCEDURE IUMagString(aPtr,bPtr:ADDRESS;aLen,bLen:INTEGER):INTEGER;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUMagString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUMagString;

PROCEDURE IUEqualString(VAR aStr,bStr:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  RETURN(IUMagIDString(ADR(aStr),ADR(bStr),HIGH(aStr),HIGH(bStr)))
END IUEqualString;

PROCEDURE IUMagIDString(aPtr,bPtr:ADDRESS;aLen,bLen:INTEGER):INTEGER;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUMagIDString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUMagIDString;

END IUPackage.
!Funky!Stuff!
echo x - InOut.MOD
cat >InOut.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE InOut;

(*
 *  copied from the  book "PROGRAMMING IN
 *  MODULA-2" by Miklaus Wirth Edited by
 *  David Gries pages 103 and 104.
 *)
    
FROM SYSTEM IMPORT ADDRESS,WORD,ADR;
FROM MacSYSTEM IMPORT LONGINT,OSErr;
FROM QuickDraw IMPORT Point;
IMPORT Terminal;
FROM FileManager IMPORT 
    OSType,FSOpen,FSClose,Create,FSRead,FSWrite,FSDelete,eofErr,opWrErr;
FROM SFPackage IMPORT SFPutFile,SFGetFile,SFReply,SFTypeList,NoFileFilter,NoDlg;
FROM Conversions IMPORT OctToStr, HexToStr,CardToStr,
    IntToStr,StrToOct,StrToHex,StrToCard,StrToInt;
    
VAR
    InIsTerm:   BOOLEAN;
    OutIsTerm:  BOOLEAN;
    In:     INTEGER;
    Out:        INTEGER;
        
PROCEDURE OpenInput (VAR defext: ARRAY OF CHAR);
VAR
    Reply:      SFReply;
    List:       SFTypeList;
    P:          Point;
    Ret:        INTEGER;
        
(*  request a file name and open input file "in".
 *  Done := "file was successfully opened".
 *  If open, subsequent input is read from this
 *  file.  If name ends with ".", append extension defext
 *)
(*  This procedure will used the SFPackage on the Mac,
 *  and the defext will not be used.                     BC
 *)
BEGIN
    List[0] := 'TEXT';
    P.h := 70;
    P.v := 100;
    SFGetFile(P,'Open What File?',NoFileFilter(),1,List,ADDRESS(0),Reply);
    IF (Reply.good) THEN
    Ret := FSOpen(Reply.fName,Reply.vRefNum,In);
    IF (Ret = 0) OR (Ret = opWrErr) THEN
        InIsTerm := FALSE;
        Done := TRUE
    ELSE
        Done := FALSE
    END;
    ELSE
    Done := FALSE;
    END
END OpenInput;
     
PROCEDURE OpenOutput    (VAR defext: ARRAY OF CHAR);
VAR
    DefName:    ARRAY [0..255] OF CHAR;
    Reply:  SFReply;
    P:      Point;
(*  request a file name and open output file "out"
 *  Done := "file was successfully opened.
 *  If open, subsequent output is written on this file
 *)
(* This procedure will also use the SFPackage on the Mac BC *)
    

BEGIN
    P.h := 70;
    P.v := 100;
    SFPutFile(P,'Create What File?','OUTPUT.TEXT',NoDlg(),Reply);
    IF (Reply.good) THEN
    Done := FSDelete(Reply.fName,Reply.vRefNum) = 0;
    Done := Create(Reply.fName,Reply.vRefNum,'EDIT','TEXT') = 0;
    IF (FSOpen(Reply.fName,Reply.vRefNum,Out) = 0) THEN
        OutIsTerm := FALSE;
        Done := TRUE
    ELSE
        Done := TRUE
    END
    ELSE
    Done := FALSE;
    END
END OpenOutput; 

PROCEDURE CloseInput;
(*  closes input file; returns input to the terminal *)
BEGIN
    Done := FSClose(In) = 0;
    InIsTerm := TRUE;
    (* even if Close Fails Input becomes terminal again *)
END CloseInput;
    
PROCEDURE CloseOutput;
(* closes output file; returns output to terminal*)
BEGIN
    IF (NOT OutIsTerm) THEN
    Done := FSClose(Out) = 0;
    OutIsTerm := TRUE;
    END 
    (* even if Close Fails Input becomes terminal again *)
END CloseOutput;
    
    
PROCEDURE Read  (VAR ch:CHAR);
(* Done := NOT in.eof *)
VAR
    count   :   LONGINT;
BEGIN
    IF (InIsTerm) THEN
    Terminal.Read(ch);
    (* Terminal Input can't fail? *)
    Done := TRUE;
    ELSE
    count := 1;
    Done := FSRead(In,count,ADR(ch)) = 0;
    IF (NOT Done) THEN ch := 0C END
    END
END Read;
    
PROCEDURE ReadString    (VAR s:ARRAY OF CHAR);
(*  read string, i.e. sequence of characters not containing
 *  blanks nor control characters; leading blanks are ignored.
 *  Input is terminated by any character <= " ";
 *  this character is assigned to termCH.
 *  DEL is used for backspacing when input from terminal*)
(* I will make this a backspace for the Mac BC *)
VAR
    I:  CARDINAL;
BEGIN
    I := 0;
    REPEAT
    Read(s[I])
    UNTIL ((s[I] # ' ') OR (NOT Done));
    LOOP
    IF (s[I] = 10C) THEN (* BackSpace *)
        IF (I > 0) THEN
        I := I - 1
        END
    ELSIF (s[I] <= ' ') THEN
        termCH := s[I];
        s[I] := 0C;         (* NULL TERMINATED STRINGS *)
        EXIT
    ELSIF (I >= HIGH(s)) THEN
        termCH := 0C;
        EXIT
    ELSE
        INC(I);
        Read(s[I]);
        IF (NOT Done) THEN
        s[I] := 0C;
        termCH := 0C;
        IF (I = 0) THEN
            Done := FALSE;  (* End Of File *)
        ELSE
            Done := TRUE
        END;
        EXIT
        END
    END
    END (* LOOP *)
END ReadString;     
     
PROCEDURE ReadInt   (VAR x:INTEGER);
(*  read strings and convert to integer. Syntax:
 *  integer = ["+"|"-"]digit{digit}.
 *  leading blanks are ignored.
 *  Done := "integer was read" *)
VAR
    String: ARRAY [0..30] OF CHAR;
BEGIN
    ReadString(String);
    Done := StrToInt(String,x);
END ReadInt;
            
        
PROCEDURE ReadCard  (VAR x:CARDINAL);
(*  read string and convert to cardinal. Syntax:
 *  cardinal = digit {digit}
 *  Leading blanks are ignored.
 *  Done := "cardinal was read"
 *)
VAR
    String: ARRAY [0..30] OF CHAR;
BEGIN
    ReadString(String);
    Done := StrToCard(String,x);
END ReadCard;
    
PROCEDURE Write (ch:CHAR);
VAR
    count   :   LONGINT;
BEGIN
    IF (OutIsTerm) THEN
    IF (ch = EOL) THEN
        Terminal.WriteLn
    ELSE
        Terminal.Write(ch)
    END;
    Done := TRUE
    ELSE
    count := 1;
    Done := FSWrite(Out,count,ADR(ch)) = 0;
    END
END Write;
    
PROCEDURE WriteLn; (*terminate line*)
BEGIN
    Write(EOL);
END WriteLn;
    
PROCEDURE WriteString   (VAR s:ARRAY OF CHAR);
(*  I will follow the convention here that a String Is upto
 *  The LENGTH of the STRING or Ends at the First Null
 *)
VAR
    i:  CARDINAL;
BEGIN
    i := 0;
    REPEAT
    IF (i <= HIGH(s)) THEN
        IF (s[i] = 0C) THEN
            i := HIGH(s) + 1; (* Let's Try This *)
        ELSE
            Write(s[i]);
            INC(i)
        END
    END
    UNTIL (i > HIGH(s))
END WriteString;
        
    
PROCEDURE WriteInt  (x: INTEGER; n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
    FOR i := 1 TO n - 8 DO
        Write(' ')
    END;
    n := 7;
    END;
    Done := IntToStr(x,str,n);
    WriteString(str);
END WriteInt;
    
PROCEDURE WriteCard (x,n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
    FOR i := 1 TO n - 8 DO
        Write(' ')
    END;
    n := 7;
    END;
    Done := CardToStr(x,str,n);
    WriteString(str);
END WriteCard;
            
PROCEDURE WriteOct  (x: WORD; n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
    FOR i := 1 TO n - 8 DO
        Write(' ')
    END;
    n := 7;
    END;
    Done := OctToStr(x,str,n);
    WriteString(str);
END WriteOct;
            
PROCEDURE WriteHex  (x:WORD;n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
    FOR i := 1 TO n - 8 DO
        Write(' ')
    END;
    n := 7;
    END;
    Done := HexToStr(x,str,n);
    WriteString(str);
END WriteHex;
    
BEGIN (* InOut Init *)
    InIsTerm := TRUE;
    OutIsTerm := TRUE;
END InOut.
!Funky!Stuff!
echo x - MacSYSTEM.MOD
cat >MacSYSTEM.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MacSYSTEM;

(* EMPTY IMPLEMENTATION *)

END MacSYSTEM.
!Funky!Stuff!
# The rest of this file is a shell script which will extract:
# EventManager.MOD FileManager.MOD FileTypes.MOD FontManager.MOD IUPackage.MOD InOut.MOD MacSYSTEM.MOD
echo x - EventManager.MOD
cat >EventManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE EventManager;
   (* MacIntosh ToolBox Event Manager Operations *)

FROM MacSYSTEM IMPORT LONGINT,OSErr;
FROM QuickDraw IMPORT Point;
FROM SYSTEM IMPORT ADDRESS,CODE,SETREG,REGISTER,ADR,WORD;

CONST
	GetRet = 0285FH;	(* MOVEA (A7)+,A4		*)
	Return = 04ED4H;	(* JMP	A4				*)
	SaveA7		= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)

VAR
	SysEvtMask[00000144H]:CARDINAL;

PROCEDURE EventAvail(mask:WORD; VAR theEvent: EventRecord):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A971H);
	CODE(RestoreA7);CODE(Return);
END EventAvail;

PROCEDURE  GetNextEvent(mask:WORD; VAR theEvent: EventRecord):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A970H);
	CODE(RestoreA7);CODE(Return);
END GetNextEvent;

PROCEDURE StillDown():BOOLEAN;
(*    INLINE $A973;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A973H);
	CODE(RestoreA7);CODE(Return);
END StillDown;

PROCEDURE WaitMouseUp():BOOLEAN;
(*   INLINE $A977;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A977H);
	CODE(RestoreA7);CODE(Return);
END WaitMouseUp;

PROCEDURE xGetMouse (VAR pt: LONGINT);
(* INLINE $A972;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A972H);
	CODE(RestoreA7);CODE(Return);
END xGetMouse;

PROCEDURE GetMouse (VAR pt: Point);
(*$P+*)(*$S-*)
BEGIN
	xGetMouse(pt.param);
END GetMouse;

PROCEDURE TickCount():LONGINT;
(* INLINE $A975;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A975H);
	CODE(RestoreA7);CODE(Return);
END TickCount;

PROCEDURE Button():BOOLEAN;
(*INLINE $A974;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A974H);
	CODE(RestoreA7);CODE(Return);
END Button;

PROCEDURE GetKeys(VAR k: KeyMap);
(*INLINE $A976;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A976H);
	CODE(RestoreA7);CODE(Return);
END GetKeys;

PROCEDURE PostEvent (eventNum: WORD; eventMsg: LONGINT): OSErr;
(*$P+*)(*$S-*)
BEGIN
	SETREG(8,eventNum);
	SETREG(0,eventMsg);
	CODE(0A02FH);
	RETURN(INTEGER(REGISTER(0)));
END PostEvent;

PROCEDURE FlushEvents (whichMask,stopMask: WORD);
(*$P+*)(*$S-*)
BEGIN
	CODE(0202EH);CODE(00008H);	(* MOVE.L 8(A6),D0 *)
	CODE(0A032H);
END FlushEvents;

PROCEDURE SetEventMask (theMask: WORD);
BEGIN
	SysEvtMask := CARDINAL(theMask)
END SetEventMask;

PROCEDURE OSEventAvail (mask: WORD; VAR theEvent: EventRecord): BOOLEAN;
BEGIN
	SETREG(8,ADR(theEvent));
	SETREG(0,mask);
	CODE(0A030H);
	RETURN(REGISTER(0) = 0)
END OSEventAvail;

PROCEDURE GetOSEvent  (mask: WORD; VAR theEvent: EventRecord): BOOLEAN;
BEGIN
	SETREG(8,ADR(theEvent));
	SETREG(0,mask);
	CODE(0A031H);
	RETURN(REGISTER(0) = 0);
END GetOSEvent;

END EventManager.



!Funky!Stuff!
echo x - FileManager.MOD
cat >FileManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE FileManager;

FROM SYSTEM IMPORT ADR,REGISTER,SETREG,CODE,ADDRESS,WORD;
FROM Storage IMPORT ALLOCATE,DEALLOCATE;
FROM PascalStrings IMPORT MakeModulaString,MakePascalString;
FROM MacSYSTEM IMPORT LONGINT,StringPtr,OSErr,noErr;
FROM FileTypes IMPORT
(*CONST*)
    opWrErr,permErr,
(*TYPE*)
    OSType,FInfo,ParamBlkPtr,ParamBlkType,ParamBlockRec;

CONST
    OpenTrap	=   0A000H;
    CloseTrap	=   0A001H;
    ReadTrap	=   0A002H;
    WriteTrap	=   0A003H;
    ControlTrap =   0A004H;
    StatusTrap	=   0A005H;
    KillIOTrap	=   0A006H;
    GetVolInfoTrap  =	0A007H;
    CreateTrap	=   0A008H;
    DeleteTrap	=   0A009H;
    OpenRFTrap	=   0A00AH;
    RenameTrap	=   0A00BH;
    GetFileInfoTrap =	0A00CH;
    SetFileInfoTrap =	0A00DH;
    UnmountVolTrap  =	0A00EH;
    MountVolTrap    =	0A00FH;
  
    AllocateTrap    =	0A010H;
    GetEOFTrap	=   0A011H;
    SetEOFTrap	=   0A012H;
    FlushVolTrap    =	0A013H;
    GetVolTrap	=   0A014H;
    SetVolTrap	=   0A015H;
    FInitQueueTrap  =	0A016H;
    EjectTrap	=   0A017H;
    GetFPosTrap =   0A018H;
  
    SetFilLockTrap  =	0A041H;
    RstFilLockTrap  =	0A042H;
    SetFilTypeTrap  =	0A043H;
    SetFPosTrap =   0A044H;
    FlushFileTrap   =	0A045H;

TYPE
    SaveRecPtr= POINTER TO SaveRec;
    SaveRec = RECORD
	Next :	    SaveRecPtr;
	Buffer :    ADDRESS;
	FileNum:    INTEGER
    END;

VAR
    HEAD : SaveRecPtr;

PROCEDURE SaveBuffer(ref:INTEGER; buf : ADDRESS);
(* remember the address of the file buffer *)
VAR
    p : SaveRecPtr;
BEGIN
    NEW(p);
    IF (p # NIL) THEN
	p^.Buffer := buf;
	p^.FileNum := ref;
	p^.Next := HEAD;
	HEAD := p
    END
END SaveBuffer;

PROCEDURE FreeBuffer(ref:INTEGER);
(* free up the file buffer *)
VAR
    p,q : SaveRecPtr;
BEGIN
    p := HEAD;
    q := NIL;
    WHILE (p # NIL) DO
	IF (p^.FileNum = ref) THEN
	    DEALLOCATE(p^.Buffer,524);
	    p^.FileNum := 0;
	    IF (q = NIL) THEN
		HEAD := p^.Next
	    ELSE
		q^.Next := p^.Next
	    END;
	    DISPOSE(p);
	    RETURN
	END;
	q := p;
	p := q^.Next
    END
END FreeBuffer;

(* Accessing Volumes *)
PROCEDURE GetVInfo(drive:INTEGER;vol:StringPtr;
    VAR vRef:INTEGER;VAR free:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
    TmpString:	ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (vol # NIL) AND (vol # StringPtr(0)) THEN
	PB.ioNamePtr := ADR(TmpString);
	MakePascalString(vol^,PB.ioNamePtr^);
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVolIndex   := drive;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetVolInfoTrap);
    IF (vol # NIL) AND (vol # StringPtr(0)) THEN
	MakeModulaString(PB.ioNamePtr^,vol^);
    END;
    vRef := PB.ioVRefNum;
    free := LONGINT(PB.ioVFrBlk) * PB.ioVAlBlkSiz;
    RETURN(PB.ioResult);
END GetVInfo;

PROCEDURE GetVol(volName:StringPtr;VAR vRefNum:INTEGER):OSErr;

VAR PB:ParamBlockRec;
    TmpString:	ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # StringPtr(0)) AND (volName # NIL) THEN
	PB.ioNamePtr := StringPtr(0)
    ELSE
	PB.ioNamePtr := ADR(TmpString);
    END;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetVolTrap);
    IF (volName # StringPtr(0)) AND (volName # NIL) THEN
	MakeModulaString(PB.ioNamePtr^,volName^);
    END;
    vRefNum := PB.ioVRefNum;
    RETURN(PB.ioResult);
END GetVol;

PROCEDURE SetVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # StringPtr(0)) AND (volName # NIL) THEN
	MakePascalString(volName^,Str);
	PB.ioNamePtr := ADR(Str);
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetVolTrap);
    RETURN(PB.ioResult);
END SetVol;

PROCEDURE FlushVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # NIL) AND (volName # StringPtr(0)) THEN
	MakePascalString(volName^,Str);
	PB.ioNamePtr := ADR(Str)
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(FlushVolTrap);
    RETURN(PB.ioResult);
END FlushVol;

PROCEDURE UnmountVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # NIL) AND (volName # StringPtr(0)) THEN
	MakePascalString(volName^,Str);
	PB.ioNamePtr := ADR(Str)
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(UnmountVolTrap);
    RETURN(PB.ioResult);
END UnmountVol;

PROCEDURE Eject(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # NIL) AND (volName # StringPtr(0)) THEN
	MakePascalString(volName^,Str);
	PB.ioNamePtr := ADR(Str)
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(EjectTrap);
    RETURN(PB.ioResult);
END Eject;

(* Changine File Contents *)
PROCEDURE Create(VAR Name:ARRAY OF CHAR;vRef:INTEGER;
    creator,type:OSType):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
    f:FInfo;
    ret:OSErr;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(Name,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioFVersNum := 0C;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(CreateTrap);
    IF (PB.ioResult <> noErr) THEN
	RETURN(PB.ioResult);
    END;
    ret := GetFInfo(Name,vRef,f);
    IF (ret <>noErr) THEN
	RETURN(ret)
    END;
    f.fdType := type;
    f.fdCreator := creator;
    RETURN(SetFInfo(Name,vRef,f));
END Create;

PROCEDURE FSOpen(VAR Name:ARRAY OF CHAR;vRef:INTEGER;
    VAR ref:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(Name,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    PB.ioPermssn := 0C;
    ALLOCATE(PB.ioMisc,524);
    IF (PB.ioMisc = NIL) THEN
	PB.ioMisc := ADDRESS(0)
    END;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(OpenTrap);
    ref := PB.ioRefNum;
    IF (PB.ioMisc # ADDRESS(0)) THEN
	IF ((PB.ioResult = noErr) OR (PB.ioResult = opWrErr)
	   OR (PB.ioResult = permErr)) THEN
	    SaveBuffer(ref,PB.ioMisc);
	ELSE
	    DEALLOCATE(PB.ioMisc,524)
	END
    END;
    RETURN(PB.ioResult);
END FSOpen;
 
PROCEDURE FSRead(refNum:INTEGER;VAR count:LONGINT;buff:ADDRESS):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := refNum;
    PB.ioReqCount := count;
    PB.ioPosMode := 0;
    PB.ioPosOffset := 0;
    PB.ioBuffer := buff;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(ReadTrap);
    count := PB.ioActCount;
    RETURN(PB.ioResult);
END FSRead;

PROCEDURE FSWrite(ref:INTEGER;VAR count:LONGINT;buff:ADDRESS):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioReqCount := count;
    PB.ioPosMode := 0;
    PB.ioPosOffset := 0;
    PB.ioBuffer := buff;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(WriteTrap);
    count := PB.ioActCount;
    RETURN(PB.ioResult);
END FSWrite;

PROCEDURE GetFPos(refNum:INTEGER;VAR filePos:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := refNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetFPosTrap);
    filePos := PB.ioPosOffset;
    RETURN(PB.ioResult);
END GetFPos;

PROCEDURE SetFPos(ref:INTEGER;posMode:INTEGER;posOff:LONGINT):OSErr;
VAR PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioPosMode := posMode;
    PB.ioPosOffset := posOff;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetFPosTrap);
    RETURN(PB.ioResult)
END SetFPos;

PROCEDURE GetEOF(ref:INTEGER;VAR logEOF:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetEOFTrap);
    logEOF := PB.ioMisc;
    RETURN(PB.ioResult);
END GetEOF;
 
PROCEDURE SetEOF(ref:INTEGER;logEOF:LONGINT):OSErr;
VAR PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioMisc := ADDRESS(logEOF);
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetEOFTrap);
    RETURN(PB.ioResult);
END SetEOF;
  
PROCEDURE Allocate(ref:INTEGER;VAR count:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioReqCount := count;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(AllocateTrap);
    count := PB.ioActCount;
    RETURN(PB.ioResult);
END Allocate;

PROCEDURE FSClose(ref:INTEGER):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    FreeBuffer(ref);
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(CloseTrap);
    RETURN(PB.ioResult);
END FSClose;

(* Changing Information About Files *)
PROCEDURE GetFInfo(VAR file:ARRAY OF CHAR;vRef:INTEGER;VAR fndr:FInfo):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    PB.ioFDirIndex := 0;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetFileInfoTrap);
    IF (PB.ioResult = noErr) THEN
	fndr := PB.ioFlFndrInfo
    END;
    RETURN(PB.ioResult);
END GetFInfo;

PROCEDURE SetFInfo(VAR file:ARRAY OF CHAR;vRef:INTEGER;fndrInfo:FInfo):OSErr;
VAR
    PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    PB.ioFDirIndex := 0;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetFileInfoTrap);   (* get create/modification times *)
    PB.ioFlFndrInfo := fndrInfo;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetFileInfoTrap);
    RETURN(PB.ioResult);
END SetFInfo;

PROCEDURE SetFLock(VAR file:ARRAY OF CHAR;vRef:INTEGER):OSErr;
VAR
    PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetFilLockTrap);
    RETURN(PB.ioResult);
END SetFLock;

PROCEDURE RstFLock(VAR file:ARRAY OF CHAR;vRef:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(RstFilLockTrap);
    RETURN(PB.ioResult);
END RstFLock;

PROCEDURE Rename(VAR old:ARRAY OF CHAR;vRef:INTEGER;
    VAR new:ARRAY OF CHAR):OSErr;
VAR
    PB:ParamBlockRec;
    Str,Str2:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(old,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    MakePascalString(new,Str2);
    PB.ioMisc := ADR(Str2);
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(RenameTrap);
    RETURN(PB.ioResult);
END Rename;

PROCEDURE FSDelete(VAR name:ARRAY OF CHAR;vRef:INTEGER):OSErr;
VAR
    PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(name,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(DeleteTrap);
    RETURN(PB.ioResult);
END FSDelete;

BEGIN
    HEAD := NIL
END FileManager.
!Funky!Stuff!
echo x - FileTypes.MOD
cat >FileTypes.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE FileTypes;

(*
 * Empty implementation
 *)

END FileTypes.
!Funky!Stuff!
echo x - FontManager.MOD
cat >FontManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE FontManager;
FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR,REGISTER;
FROM MacSYSTEM IMPORT LONGINT;
FROM PascalStrings IMPORT MakePascalString,MakeModulaString;

CONST
	GetRet = 0285FH;	(* MOVEA (A7)+,A4		*)
	Return = 04ED4H;	(* JMP	A4				*)
	SaveA7		= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)

PROCEDURE xGetFontName(fontNumber:INTEGER;name:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8FFH);
	CODE(RestoreA7);CODE(Return);
END xGetFontName;
PROCEDURE GetFontName(fontNumber:INTEGER;VAR name:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR	s1:ARRAY [0..255] OF CHAR;
BEGIN
	xGetFontName(fontNumber,ADR(s1));
	MakeModulaString(s1,name);
END GetFontName;
PROCEDURE xGetFNum(name:ADDRESS;VAR fontNumber:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A900H);
	CODE(RestoreA7);CODE(Return);
END xGetFNum;
PROCEDURE GetFNum(VAR name:ARRAY OF CHAR;VAR fontNumber:INTEGER);
(*$P+*)(*$S-*)
VAR s1:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(name,s1);
	xGetFNum(ADR(s1),fontNumber)
END GetFNum;
PROCEDURE RealFont(fontNumber:INTEGER;pointSize:INTEGER):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A902H);
	CODE(RestoreA7);CODE(Return);
END RealFont;

PROCEDURE GetFontInfo(VAR info:FontInfo);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88BH);
	CODE(RestoreA7);CODE(Return);
END GetFontInfo;

PROCEDURE SetFontLock(lock:BOOLEAN);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A903H);
	CODE(RestoreA7);CODE(Return);
END SetFontLock;

PROCEDURE FMSwapFont (inRec: FMInput) : FMOutPtr;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A901H);
	CODE(RestoreA7);CODE(Return);
END FMSwapFont;

BEGIN
	CODE(0A8FEH); (* INIT FONTS *)
END FontManager.
!Funky!Stuff!
echo x - IUPackage.MOD
cat >IUPackage.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE IUPackage;
FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
FROM MacSYSTEM IMPORT LONGINT,Handle;
FROM PascalStrings IMPORT MakeModulaString;

CONST
	GetRet		= 0285FH;	(* MOVEA (A7)+,A4		*)
	Return		= 04ED4H;	(* JMP	A4				*)
	SaveA7		= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)
	Pack6       = 0A9EDH;
	pIUDatePString	=	14;
	pIUDateString	=	0;
	pIUGetIntl		=	6;
	pIUMagIDString	=	12;
	pIUMagString		=	10;
	pIUMetric		=	4;
	pIUSetIntl		=	8;
	pIUTimePString	=	16;
	pIUTimeString	=	2;
	Push        = 03F3CH;     (* MOVE #VAL,-(A7) *)

(* Routines *)
PROCEDURE xIUDateString (dateTime:LONGINT;form:DateForm;result:ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUDateString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUDateString;

PROCEDURE IUDateString (dateTime:LONGINT;form:DateForm;
  VAR result:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUDateString(dateTime,form,ADR(Str));
  MakeModulaString(Str,result)
END IUDateString;
  
PROCEDURE xIUDatePString (dateTime:LONGINT;form:DateForm;
 result:ADDRESS;intlParam:Handle);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUDatePString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUDatePString;

PROCEDURE IUDatePString (dateTime:LONGINT;form:DateForm;
	VAR result:ARRAY OF CHAR;intlParam:Handle);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUDatePString(dateTime,form,ADR(Str),intlParam);
  MakeModulaString(Str,result)
END IUDatePString;

PROCEDURE xIUTimeString(dateTime:LONGINT;wantSeconds:BOOLEAN;result:ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUTimeString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUTimeString;

PROCEDURE IUTimeString(dateTime:LONGINT;wantSeconds:BOOLEAN;
	VAR result:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUTimeString(dateTime,wantSeconds,ADR(Str));
  MakeModulaString(Str,result)
END IUTimeString;

PROCEDURE xIUTimePString(dateTime:LONGINT;wantSeconds:BOOLEAN;
	result:ADDRESS; intlParam:Handle);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUTimePString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUTimePString;

PROCEDURE IUTimePString(dateTime:LONGINT;wantSeconds:BOOLEAN;
	VAR result:ARRAY OF CHAR; intlParam:Handle);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUTimePString(dateTime,wantSeconds,ADR(Str),intlParam);
  MakeModulaString(Str,result);
END IUTimePString;

PROCEDURE IUMetric():BOOLEAN;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUMetric);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUMetric;

PROCEDURE IUGetIntl(theID:INTEGER):Handle;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUGetIntl);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUGetIntl;

PROCEDURE IUSetIntl(refNum:INTEGER; theID:INTEGER;intlParam:Handle);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUSetIntl);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUSetIntl;

PROCEDURE IUCompString(VAR aStr,bStr:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR
BEGIN
  RETURN(IUMagString(ADR(aStr),ADR(bStr),HIGH(aStr),HIGH(bStr)))
END IUCompString;

PROCEDURE IUMagString(aPtr,bPtr:ADDRESS;aLen,bLen:INTEGER):INTEGER;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUMagString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUMagString;

PROCEDURE IUEqualString(VAR aStr,bStr:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  RETURN(IUMagIDString(ADR(aStr),ADR(bStr),HIGH(aStr),HIGH(bStr)))
END IUEqualString;

PROCEDURE IUMagIDString(aPtr,bPtr:ADDRESS;aLen,bLen:INTEGER):INTEGER;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUMagIDString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUMagIDString;

END IUPackage.
!Funky!Stuff!
echo x - InOut.MOD
cat >InOut.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE InOut;

(*
 *	copied from the  book "PROGRAMMING IN
 *	MODULA-2" by Miklaus Wirth Edited by
 *	David Gries pages 103 and 104.
 *)
	
FROM SYSTEM IMPORT ADDRESS,WORD,ADR;
FROM MacSYSTEM IMPORT LONGINT,OSErr;
FROM QuickDraw IMPORT Point;
IMPORT Terminal;
FROM FileTypes IMPORT OSType;
FROM Streams IMPORT STREAM, OpenMode, ReadChar, WriteChar,
	Open,Close,Create,EOS;
FROM SFPackage IMPORT SFPutFile,SFGetFile,SFReply,SFTypeList,NoFileFilter,NoDlg;
FROM Conversions IMPORT OctToStr, HexToStr,CardToStr,
	IntToStr,StrToOct,StrToHex,StrToCard,StrToInt;
	
VAR
	InIsTerm:	BOOLEAN;
	OutIsTerm:	BOOLEAN;
	InStream:	STREAM;
	OutStream:	STREAM;
		
PROCEDURE OpenInput	(VAR defext: ARRAY OF CHAR);
VAR
	Reply:		SFReply;
	List:		SFTypeList;
	P:		Point;
	Ret:		INTEGER;
		
(*	request a file name and open input file "in".
 *	Done := "file was successfully opened".
 *	If open, subsequent input is read from this
 *	file.  If name ends with ".", append extension defext
 *)
(*	This procedure will used the SFPackage on the Mac,
 *	and the defext will not be used.					 BC
 *)
BEGIN
    List[0] := 'TEXT';
    P.h := 70;
    P.v := 100;
    SFGetFile(P,'Open What File?',NoFileFilter(),1,List,ADDRESS(0),Reply);
    IF (Reply.good) THEN
	Open(InStream,Reply.fName,Reply.vRefNum,ReadOnly);
	IF InStream # NIL THEN
	    InIsTerm := FALSE;
	    Done := TRUE
	ELSE
	    Done := FALSE
	END;
    ELSE
	Done := FALSE;
    END
END OpenInput;
	 
PROCEDURE OpenOutput	(VAR defext: ARRAY OF CHAR);
VAR
    DefName:	ARRAY [0..255] OF CHAR;
    Reply:	SFReply;
    P:		Point;
(*	request a file name and open output file "out"
 *	Done := "file was successfully opened.
 *	If open, subsequent output is written on this file
 *)
(* This procedure will also use the SFPackage on the Mac BC *)
	

BEGIN
    P.h := 70;
    P.v := 100;
    SFPutFile(P,'Create What File?','OUTPUT.TEXT',NoDlg(),Reply);
    IF (Reply.good) THEN
	Create(Reply.fName,Reply.vRefNum,'EDIT','TEXT');
	Open(OutStream,Reply.fName,Reply.vRefNum,WriteOnly);
	IF (OutStream # NIL) THEN
	    OutIsTerm := FALSE;
	    Done := TRUE
	ELSE
	    Done := TRUE
	END
    ELSE
	Done := FALSE;
    END
END OpenOutput;	

PROCEDURE CloseInput;
(*	closes input file; returns input to the terminal *)
BEGIN
    IF (NOT InIsTerm) THEN
    	Close(InStream);
	Done := TRUE
    END;
    InIsTerm := TRUE;
    (* even if Close Fails Input becomes terminal again *)
END CloseInput;
	
PROCEDURE CloseOutput;
(* closes output file; returns output to terminal*)
BEGIN
    IF (NOT OutIsTerm) THEN
	Close(OutStream);
	Done := TRUE;
	OutIsTerm := TRUE;
    END	
    (* even if Close Fails Input becomes terminal again *)
END CloseOutput;
	
	
PROCEDURE Read	(VAR ch:CHAR);
(* Done := NOT in.eof *)
VAR
    count	:	LONGINT;
BEGIN
    IF (InIsTerm) THEN
	Terminal.Read(ch);
	(* Terminal Input can't fail? *)
	Done := TRUE;
    ELSE
	count := 1;
	IF (NOT EOS(InStream)) THEN
		ReadChar(InStream,ch);
		Done := TRUE
	ELSE
		ch := 0C;
		Done := FALSE
	END
    END
END Read;
	
PROCEDURE ReadString	(VAR s:ARRAY OF CHAR);
(*	read string, i.e. sequence of characters not containing
 *	blanks nor control characters; leading blanks are ignored.
 *	Input is terminated by any character <= " ";
 *	this character is assigned to termCH.
 *	DEL is used for backspacing when input from terminal*)
(* I will make this a backspace for the Mac BC *)
VAR
    I:	CARDINAL;
BEGIN
    I := 0;
    REPEAT
	Read(s[I])
    UNTIL ((s[I] # ' ') OR (NOT Done));
    LOOP
	IF (s[I] = 10C) THEN (* BackSpace *)
	    IF (I > 0) THEN
		I := I - 1
	    END
	ELSIF (s[I] <= ' ') THEN
	    termCH := s[I];
	    s[I] := 0C;			(* NULL TERMINATED STRINGS *)
	    EXIT
	ELSIF (I >= HIGH(s)) THEN
	    termCH := 0C;
	    EXIT
	ELSE
	    INC(I);
	    Read(s[I]);
	    IF (NOT Done) THEN
		s[I] := 0C;
		termCH := 0C;
		IF (I = 0) THEN
		    Done := FALSE;	(* End Of File *)
		ELSE
		    Done := TRUE
		END;
		EXIT
	    END
	END
    END (* LOOP *)
END ReadString;		
	 
PROCEDURE ReadInt	(VAR x:INTEGER);
(*	read strings and convert to integer. Syntax:
 *	integer = ["+"|"-"]digit{digit}.
 *	leading blanks are ignored.
 *	Done := "integer was read" *)
VAR
	String:	ARRAY [0..30] OF CHAR;
BEGIN
    ReadString(String);
    Done := StrToInt(String,x);
END ReadInt;
			
		
PROCEDURE ReadCard	(VAR x:CARDINAL);
(*	read string and convert to cardinal. Syntax:
 *	cardinal = digit {digit}
 *	Leading blanks are ignored.
 *	Done := "cardinal was read"
 *)
VAR
	String:	ARRAY [0..30] OF CHAR;
BEGIN
    ReadString(String);
    Done := StrToCard(String,x);
END ReadCard;
	
PROCEDURE Write	(ch:CHAR);
VAR
    count	:	LONGINT;
BEGIN
    IF (OutIsTerm) THEN
	IF (ch = EOL) THEN
		Terminal.WriteLn
	ELSE
		Terminal.Write(ch)
	END;
	Done := TRUE
    ELSE
	count := 1;
	Done := TRUE;
	WriteChar(OutStream,ch)
    END
END Write;
	
PROCEDURE WriteLn; (*terminate line*)
BEGIN
    Write(EOL);
END WriteLn;
	
PROCEDURE WriteString	(VAR s:ARRAY OF CHAR);
(*	I will follow the convention here that a String Is upto
 *	The LENGTH of the STRING or Ends at the First Null
 *)
VAR
	i:	CARDINAL;
BEGIN
    i := 0;
    REPEAT
	IF (i <= HIGH(s)) THEN
	    IF (s[i] = 0C) THEN
		    i := HIGH(s) + 1; (* Let's Try This *)
	    ELSE
		    Write(s[i]);
		    INC(i)
	    END
	END
    UNTIL (i > HIGH(s))
END WriteString;
		
	
PROCEDURE WriteInt	(x: INTEGER; n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
	FOR i := 1 TO n - 8 DO
	    Write(' ')
	END;
	n := 7;
    END;
    Done := IntToStr(x,str,n);
    WriteString(str);
END WriteInt;
	
PROCEDURE WriteCard (x,n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
	FOR i := 1 TO n - 8 DO
	    Write(' ')
	END;
	n := 7;
    END;
    Done := CardToStr(x,str,n);
    WriteString(str);
END WriteCard;
			
PROCEDURE WriteOct	(x: WORD; n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
	FOR i := 1 TO n - 8 DO
		Write(' ')
	END;
	n := 7;
    END;
    Done := OctToStr(x,str,n);
    WriteString(str);
END WriteOct;
			
PROCEDURE WriteHex	(x:WORD;n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
	FOR i := 1 TO n - 8 DO
	    Write(' ')
	END;
	n := 7;
    END;
    Done := HexToStr(x,str,n);
    WriteString(str);
END WriteHex;
	
BEGIN (* InOut Init *)
    InIsTerm := TRUE;
    OutIsTerm := TRUE;
END InOut.
!Funky!Stuff!
echo x - MacSYSTEM.MOD
cat >MacSYSTEM.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MacSYSTEM;

(* EMPTY IMPLEMENTATION *)

END MacSYSTEM.
!Funky!Stuff!
# The rest of this file is a shell script which will extract:
# EventManager.MOD FileManager.MOD FileTypes.MOD FontManager.MOD IUPackage.MOD InOut.MOD MacSYSTEM.MOD
echo x - EventManager.MOD
cat >EventManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE EventManager;
   (* MacIntosh ToolBox Event Manager Operations *)

FROM MacSYSTEM IMPORT LONGINT,OSErr;
FROM QuickDraw IMPORT Point;
FROM SYSTEM IMPORT ADDRESS,CODE,SETREG,REGISTER,ADR,WORD;

CONST
	GetRet = 0285FH;	(* MOVEA (A7)+,A4		*)
	Return = 04ED4H;	(* JMP	A4				*)
	SaveA7		= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)

VAR
	SysEvtMask[00000144H]:CARDINAL;

PROCEDURE EventAvail(mask:WORD; VAR theEvent: EventRecord):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A971H);
	CODE(RestoreA7);CODE(Return);
END EventAvail;

PROCEDURE  GetNextEvent(mask:WORD; VAR theEvent: EventRecord):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A970H);
	CODE(RestoreA7);CODE(Return);
END GetNextEvent;

PROCEDURE StillDown():BOOLEAN;
(*    INLINE $A973;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A973H);
	CODE(RestoreA7);CODE(Return);
END StillDown;

PROCEDURE WaitMouseUp():BOOLEAN;
(*   INLINE $A977;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A977H);
	CODE(RestoreA7);CODE(Return);
END WaitMouseUp;

PROCEDURE xGetMouse (VAR pt: LONGINT);
(* INLINE $A972;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A972H);
	CODE(RestoreA7);CODE(Return);
END xGetMouse;

PROCEDURE GetMouse (VAR pt: Point);
(*$P+*)(*$S-*)
BEGIN
	xGetMouse(pt.param);
END GetMouse;

PROCEDURE TickCount():LONGINT;
(* INLINE $A975;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A975H);
	CODE(RestoreA7);CODE(Return);
END TickCount;

PROCEDURE Button():BOOLEAN;
(*INLINE $A974;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A974H);
	CODE(RestoreA7);CODE(Return);
END Button;

PROCEDURE GetKeys(VAR k: KeyMap);
(*INLINE $A976;*)
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A976H);
	CODE(RestoreA7);CODE(Return);
END GetKeys;

PROCEDURE PostEvent (eventNum: WORD; eventMsg: LONGINT): OSErr;
(*$P+*)(*$S-*)
BEGIN
	SETREG(8,eventNum);
	SETREG(0,eventMsg);
	CODE(0A02FH);
	RETURN(INTEGER(REGISTER(0)));
END PostEvent;

PROCEDURE FlushEvents (whichMask,stopMask: WORD);
(*$P+*)(*$S-*)
BEGIN
	CODE(0202EH);CODE(00008H);	(* MOVE.L 8(A6),D0 *)
	CODE(0A032H);
END FlushEvents;

PROCEDURE SetEventMask (theMask: WORD);
BEGIN
	SysEvtMask := CARDINAL(theMask)
END SetEventMask;

PROCEDURE OSEventAvail (mask: WORD; VAR theEvent: EventRecord): BOOLEAN;
BEGIN
	SETREG(8,ADR(theEvent));
	SETREG(0,mask);
	CODE(0A030H);
	RETURN(REGISTER(0) = 0)
END OSEventAvail;

PROCEDURE GetOSEvent  (mask: WORD; VAR theEvent: EventRecord): BOOLEAN;
BEGIN
	SETREG(8,ADR(theEvent));
	SETREG(0,mask);
	CODE(0A031H);
	RETURN(REGISTER(0) = 0);
END GetOSEvent;

END EventManager.



!Funky!Stuff!
echo x - FileManager.MOD
cat >FileManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE FileManager;

FROM SYSTEM IMPORT ADR,REGISTER,SETREG,CODE,ADDRESS,WORD;
FROM Storage IMPORT ALLOCATE,DEALLOCATE;
FROM PascalStrings IMPORT MakeModulaString,MakePascalString;
FROM MacSYSTEM IMPORT LONGINT,StringPtr,OSErr,noErr;
FROM FileTypes IMPORT
(*CONST*)
    opWrErr,permErr,
(*TYPE*)
    OSType,FInfo,ParamBlkPtr,ParamBlkType,ParamBlockRec;

CONST
    OpenTrap	=   0A000H;
    CloseTrap	=   0A001H;
    ReadTrap	=   0A002H;
    WriteTrap	=   0A003H;
    ControlTrap =   0A004H;
    StatusTrap	=   0A005H;
    KillIOTrap	=   0A006H;
    GetVolInfoTrap  =	0A007H;
    CreateTrap	=   0A008H;
    DeleteTrap	=   0A009H;
    OpenRFTrap	=   0A00AH;
    RenameTrap	=   0A00BH;
    GetFileInfoTrap =	0A00CH;
    SetFileInfoTrap =	0A00DH;
    UnmountVolTrap  =	0A00EH;
    MountVolTrap    =	0A00FH;
  
    AllocateTrap    =	0A010H;
    GetEOFTrap	=   0A011H;
    SetEOFTrap	=   0A012H;
    FlushVolTrap    =	0A013H;
    GetVolTrap	=   0A014H;
    SetVolTrap	=   0A015H;
    FInitQueueTrap  =	0A016H;
    EjectTrap	=   0A017H;
    GetFPosTrap =   0A018H;
  
    SetFilLockTrap  =	0A041H;
    RstFilLockTrap  =	0A042H;
    SetFilTypeTrap  =	0A043H;
    SetFPosTrap =   0A044H;
    FlushFileTrap   =	0A045H;

TYPE
    SaveRecPtr= POINTER TO SaveRec;
    SaveRec = RECORD
	Next :	    SaveRecPtr;
	Buffer :    ADDRESS;
	FileNum:    INTEGER
    END;

VAR
    HEAD : SaveRecPtr;

PROCEDURE SaveBuffer(ref:INTEGER; buf : ADDRESS);
(* remember the address of the file buffer *)
VAR
    p : SaveRecPtr;
BEGIN
    NEW(p);
    IF (p # NIL) THEN
	p^.Buffer := buf;
	p^.FileNum := ref;
	p^.Next := HEAD;
	HEAD := p
    END
END SaveBuffer;

PROCEDURE FreeBuffer(ref:INTEGER);
(* free up the file buffer *)
VAR
    p,q : SaveRecPtr;
BEGIN
    p := HEAD;
    q := NIL;
    WHILE (p # NIL) DO
	IF (p^.FileNum = ref) THEN
	    DEALLOCATE(p^.Buffer,524);
	    p^.FileNum := 0;
	    IF (q = NIL) THEN
		HEAD := p^.Next
	    ELSE
		q^.Next := p^.Next
	    END;
	    DISPOSE(p);
	    RETURN
	END;
	q := p;
	p := q^.Next
    END
END FreeBuffer;

(* Accessing Volumes *)
PROCEDURE GetVInfo(drive:INTEGER;vol:StringPtr;
    VAR vRef:INTEGER;VAR free:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
    TmpString:	ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (vol # NIL) AND (vol # StringPtr(0)) THEN
	PB.ioNamePtr := ADR(TmpString);
	MakePascalString(vol^,PB.ioNamePtr^);
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVolIndex   := drive;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetVolInfoTrap);
    IF (vol # NIL) AND (vol # StringPtr(0)) THEN
	MakeModulaString(PB.ioNamePtr^,vol^);
    END;
    vRef := PB.ioVRefNum;
    free := LONGINT(PB.ioVFrBlk) * PB.ioVAlBlkSiz;
    RETURN(PB.ioResult);
END GetVInfo;

PROCEDURE GetVol(volName:StringPtr;VAR vRefNum:INTEGER):OSErr;

VAR PB:ParamBlockRec;
    TmpString:	ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # StringPtr(0)) AND (volName # NIL) THEN
	PB.ioNamePtr := StringPtr(0)
    ELSE
	PB.ioNamePtr := ADR(TmpString);
    END;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetVolTrap);
    IF (volName # StringPtr(0)) AND (volName # NIL) THEN
	MakeModulaString(PB.ioNamePtr^,volName^);
    END;
    vRefNum := PB.ioVRefNum;
    RETURN(PB.ioResult);
END GetVol;

PROCEDURE SetVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # StringPtr(0)) AND (volName # NIL) THEN
	MakePascalString(volName^,Str);
	PB.ioNamePtr := ADR(Str);
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetVolTrap);
    RETURN(PB.ioResult);
END SetVol;

PROCEDURE FlushVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # NIL) AND (volName # StringPtr(0)) THEN
	MakePascalString(volName^,Str);
	PB.ioNamePtr := ADR(Str)
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(FlushVolTrap);
    RETURN(PB.ioResult);
END FlushVol;

PROCEDURE UnmountVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # NIL) AND (volName # StringPtr(0)) THEN
	MakePascalString(volName^,Str);
	PB.ioNamePtr := ADR(Str)
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(UnmountVolTrap);
    RETURN(PB.ioResult);
END UnmountVol;

PROCEDURE Eject(volName:StringPtr;vRefNum:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    IF (volName # NIL) AND (volName # StringPtr(0)) THEN
	MakePascalString(volName^,Str);
	PB.ioNamePtr := ADR(Str)
    ELSE
	PB.ioNamePtr := StringPtr(0)
    END;
    PB.ioVRefNum := vRefNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(EjectTrap);
    RETURN(PB.ioResult);
END Eject;

(* Changine File Contents *)
PROCEDURE Create(VAR Name:ARRAY OF CHAR;vRef:INTEGER;
    creator,type:OSType):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
    f:FInfo;
    ret:OSErr;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(Name,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioFVersNum := 0C;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(CreateTrap);
    IF (PB.ioResult <> noErr) THEN
	RETURN(PB.ioResult);
    END;
    ret := GetFInfo(Name,vRef,f);
    IF (ret <>noErr) THEN
	RETURN(ret)
    END;
    f.fdType := type;
    f.fdCreator := creator;
    RETURN(SetFInfo(Name,vRef,f));
END Create;

PROCEDURE FSOpen(VAR Name:ARRAY OF CHAR;vRef:INTEGER;
    VAR ref:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(Name,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    PB.ioPermssn := 0C;
    ALLOCATE(PB.ioMisc,524);
    IF (PB.ioMisc = NIL) THEN
	PB.ioMisc := ADDRESS(0)
    END;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(OpenTrap);
    ref := PB.ioRefNum;
    IF (PB.ioMisc # ADDRESS(0)) THEN
	IF ((PB.ioResult = noErr) OR (PB.ioResult = opWrErr)
	   OR (PB.ioResult = permErr)) THEN
	    SaveBuffer(ref,PB.ioMisc);
	ELSE
	    DEALLOCATE(PB.ioMisc,524)
	END
    END;
    RETURN(PB.ioResult);
END FSOpen;
 
PROCEDURE FSRead(refNum:INTEGER;VAR count:LONGINT;buff:ADDRESS):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := refNum;
    PB.ioReqCount := count;
    PB.ioPosMode := 0;
    PB.ioPosOffset := 0;
    PB.ioBuffer := buff;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(ReadTrap);
    count := PB.ioActCount;
    RETURN(PB.ioResult);
END FSRead;

PROCEDURE FSWrite(ref:INTEGER;VAR count:LONGINT;buff:ADDRESS):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioReqCount := count;
    PB.ioPosMode := 0;
    PB.ioPosOffset := 0;
    PB.ioBuffer := buff;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(WriteTrap);
    count := PB.ioActCount;
    RETURN(PB.ioResult);
END FSWrite;

PROCEDURE GetFPos(refNum:INTEGER;VAR filePos:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := refNum;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetFPosTrap);
    filePos := PB.ioPosOffset;
    RETURN(PB.ioResult);
END GetFPos;

PROCEDURE SetFPos(ref:INTEGER;posMode:INTEGER;posOff:LONGINT):OSErr;
VAR PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioPosMode := posMode;
    PB.ioPosOffset := posOff;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetFPosTrap);
    RETURN(PB.ioResult)
END SetFPos;

PROCEDURE GetEOF(ref:INTEGER;VAR logEOF:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetEOFTrap);
    logEOF := PB.ioMisc;
    RETURN(PB.ioResult);
END GetEOF;
 
PROCEDURE SetEOF(ref:INTEGER;logEOF:LONGINT):OSErr;
VAR PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioMisc := ADDRESS(logEOF);
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetEOFTrap);
    RETURN(PB.ioResult);
END SetEOF;
  
PROCEDURE Allocate(ref:INTEGER;VAR count:LONGINT):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    PB.ioReqCount := count;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(AllocateTrap);
    count := PB.ioActCount;
    RETURN(PB.ioResult);
END Allocate;

PROCEDURE FSClose(ref:INTEGER):OSErr;
VAR
    PB:ParamBlockRec;
BEGIN
    FreeBuffer(ref);
    PB.ioCompletion := ADDRESS(0);
    PB.ioRefNum := ref;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(CloseTrap);
    RETURN(PB.ioResult);
END FSClose;

(* Changing Information About Files *)
PROCEDURE GetFInfo(VAR file:ARRAY OF CHAR;vRef:INTEGER;VAR fndr:FInfo):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    PB.ioFDirIndex := 0;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetFileInfoTrap);
    IF (PB.ioResult = noErr) THEN
	fndr := PB.ioFlFndrInfo
    END;
    RETURN(PB.ioResult);
END GetFInfo;

PROCEDURE SetFInfo(VAR file:ARRAY OF CHAR;vRef:INTEGER;fndrInfo:FInfo):OSErr;
VAR
    PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    PB.ioFDirIndex := 0;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(GetFileInfoTrap);   (* get create/modification times *)
    PB.ioFlFndrInfo := fndrInfo;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetFileInfoTrap);
    RETURN(PB.ioResult);
END SetFInfo;

PROCEDURE SetFLock(VAR file:ARRAY OF CHAR;vRef:INTEGER):OSErr;
VAR
    PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(SetFilLockTrap);
    RETURN(PB.ioResult);
END SetFLock;

PROCEDURE RstFLock(VAR file:ARRAY OF CHAR;vRef:INTEGER):OSErr;
VAR PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(file,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(RstFilLockTrap);
    RETURN(PB.ioResult);
END RstFLock;

PROCEDURE Rename(VAR old:ARRAY OF CHAR;vRef:INTEGER;
    VAR new:ARRAY OF CHAR):OSErr;
VAR
    PB:ParamBlockRec;
    Str,Str2:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(old,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    MakePascalString(new,Str2);
    PB.ioMisc := ADR(Str2);
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(RenameTrap);
    RETURN(PB.ioResult);
END Rename;

PROCEDURE FSDelete(VAR name:ARRAY OF CHAR;vRef:INTEGER):OSErr;
VAR
    PB:ParamBlockRec;
    Str:ARRAY[0..255] OF CHAR;
BEGIN
    PB.ioCompletion := ADDRESS(0);
    MakePascalString(name,Str);
    PB.ioNamePtr := ADR(Str);
    PB.ioVRefNum := vRef;
    PB.ioVersNum := 0C;
    SETREG(8,ADR(PB));	    (* A0 := ADR(PB) *)
    CODE(DeleteTrap);
    RETURN(PB.ioResult);
END FSDelete;

BEGIN
    HEAD := NIL
END FileManager.
!Funky!Stuff!
echo x - FileTypes.MOD
cat >FileTypes.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE FileTypes;

(*
 * Empty implementation
 *)

END FileTypes.
!Funky!Stuff!
echo x - FontManager.MOD
cat >FontManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE FontManager;
FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR,REGISTER;
FROM MacSYSTEM IMPORT LONGINT;
FROM PascalStrings IMPORT MakePascalString,MakeModulaString;

CONST
	GetRet = 0285FH;	(* MOVEA (A7)+,A4		*)
	Return = 04ED4H;	(* JMP	A4				*)
	SaveA7		= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)

PROCEDURE xGetFontName(fontNumber:INTEGER;name:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8FFH);
	CODE(RestoreA7);CODE(Return);
END xGetFontName;
PROCEDURE GetFontName(fontNumber:INTEGER;VAR name:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR	s1:ARRAY [0..255] OF CHAR;
BEGIN
	xGetFontName(fontNumber,ADR(s1));
	MakeModulaString(s1,name);
END GetFontName;
PROCEDURE xGetFNum(name:ADDRESS;VAR fontNumber:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A900H);
	CODE(RestoreA7);CODE(Return);
END xGetFNum;
PROCEDURE GetFNum(VAR name:ARRAY OF CHAR;VAR fontNumber:INTEGER);
(*$P+*)(*$S-*)
VAR s1:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(name,s1);
	xGetFNum(ADR(s1),fontNumber)
END GetFNum;
PROCEDURE RealFont(fontNumber:INTEGER;pointSize:INTEGER):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A902H);
	CODE(RestoreA7);CODE(Return);
END RealFont;

PROCEDURE GetFontInfo(VAR info:FontInfo);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88BH);
	CODE(RestoreA7);CODE(Return);
END GetFontInfo;

PROCEDURE SetFontLock(lock:BOOLEAN);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A903H);
	CODE(RestoreA7);CODE(Return);
END SetFontLock;

PROCEDURE FMSwapFont (inRec: FMInput) : FMOutPtr;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A901H);
	CODE(RestoreA7);CODE(Return);
END FMSwapFont;

BEGIN
	CODE(0A8FEH); (* INIT FONTS *)
END FontManager.
!Funky!Stuff!
echo x - IUPackage.MOD
cat >IUPackage.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE IUPackage;
FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
FROM MacSYSTEM IMPORT LONGINT,Handle;
FROM PascalStrings IMPORT MakeModulaString;

CONST
	GetRet		= 0285FH;	(* MOVEA (A7)+,A4		*)
	Return		= 04ED4H;	(* JMP	A4				*)
	SaveA7		= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)
	Pack6       = 0A9EDH;
	pIUDatePString	=	14;
	pIUDateString	=	0;
	pIUGetIntl		=	6;
	pIUMagIDString	=	12;
	pIUMagString		=	10;
	pIUMetric		=	4;
	pIUSetIntl		=	8;
	pIUTimePString	=	16;
	pIUTimeString	=	2;
	Push        = 03F3CH;     (* MOVE #VAL,-(A7) *)

(* Routines *)
PROCEDURE xIUDateString (dateTime:LONGINT;form:DateForm;result:ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUDateString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUDateString;

PROCEDURE IUDateString (dateTime:LONGINT;form:DateForm;
  VAR result:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUDateString(dateTime,form,ADR(Str));
  MakeModulaString(Str,result)
END IUDateString;
  
PROCEDURE xIUDatePString (dateTime:LONGINT;form:DateForm;
 result:ADDRESS;intlParam:Handle);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUDatePString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUDatePString;

PROCEDURE IUDatePString (dateTime:LONGINT;form:DateForm;
	VAR result:ARRAY OF CHAR;intlParam:Handle);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUDatePString(dateTime,form,ADR(Str),intlParam);
  MakeModulaString(Str,result)
END IUDatePString;

PROCEDURE xIUTimeString(dateTime:LONGINT;wantSeconds:BOOLEAN;result:ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUTimeString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUTimeString;

PROCEDURE IUTimeString(dateTime:LONGINT;wantSeconds:BOOLEAN;
	VAR result:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUTimeString(dateTime,wantSeconds,ADR(Str));
  MakeModulaString(Str,result)
END IUTimeString;

PROCEDURE xIUTimePString(dateTime:LONGINT;wantSeconds:BOOLEAN;
	result:ADDRESS; intlParam:Handle);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUTimePString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END xIUTimePString;

PROCEDURE IUTimePString(dateTime:LONGINT;wantSeconds:BOOLEAN;
	VAR result:ARRAY OF CHAR; intlParam:Handle);
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  xIUTimePString(dateTime,wantSeconds,ADR(Str),intlParam);
  MakeModulaString(Str,result);
END IUTimePString;

PROCEDURE IUMetric():BOOLEAN;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUMetric);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUMetric;

PROCEDURE IUGetIntl(theID:INTEGER):Handle;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUGetIntl);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUGetIntl;

PROCEDURE IUSetIntl(refNum:INTEGER; theID:INTEGER;intlParam:Handle);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUSetIntl);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUSetIntl;

PROCEDURE IUCompString(VAR aStr,bStr:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR
BEGIN
  RETURN(IUMagString(ADR(aStr),ADR(bStr),HIGH(aStr),HIGH(bStr)))
END IUCompString;

PROCEDURE IUMagString(aPtr,bPtr:ADDRESS;aLen,bLen:INTEGER):INTEGER;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUMagString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUMagString;

PROCEDURE IUEqualString(VAR aStr,bStr:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR
  Str:ARRAY [0..255] OF CHAR;
BEGIN
  RETURN(IUMagIDString(ADR(aStr),ADR(bStr),HIGH(aStr),HIGH(bStr)))
END IUEqualString;

PROCEDURE IUMagIDString(aPtr,bPtr:ADDRESS;aLen,bLen:INTEGER):INTEGER;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(pIUMagIDString);
  CODE(Pack6);
  CODE(RestoreA7);
  CODE(Return);
END IUMagIDString;

END IUPackage.
!Funky!Stuff!
echo x - InOut.MOD
cat >InOut.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE InOut;

(*
 *	copied from the  book "PROGRAMMING IN
 *	MODULA-2" by Miklaus Wirth Edited by
 *	David Gries pages 103 and 104.
 *)
	
FROM SYSTEM IMPORT ADDRESS,WORD,ADR;
FROM MacSYSTEM IMPORT LONGINT,OSErr;
FROM QuickDraw IMPORT Point;
IMPORT Terminal;
FROM FileTypes IMPORT OSType;
FROM Streams IMPORT STREAM, OpenMode, ReadChar, WriteChar,
	Open,Close,Create,EOS;
FROM SFPackage IMPORT SFPutFile,SFGetFile,SFReply,SFTypeList,NoFileFilter,NoDlg;
FROM Conversions IMPORT OctToStr, HexToStr,CardToStr,
	IntToStr,StrToOct,StrToHex,StrToCard,StrToInt;
	
VAR
	InIsTerm:	BOOLEAN;
	OutIsTerm:	BOOLEAN;
	InStream:	STREAM;
	OutStream:	STREAM;
		
PROCEDURE OpenInput	(VAR defext: ARRAY OF CHAR);
VAR
	Reply:		SFReply;
	List:		SFTypeList;
	P:		Point;
	Ret:		INTEGER;
		
(*	request a file name and open input file "in".
 *	Done := "file was successfully opened".
 *	If open, subsequent input is read from this
 *	file.  If name ends with ".", append extension defext
 *)
(*	This procedure will used the SFPackage on the Mac,
 *	and the defext will not be used.					 BC
 *)
BEGIN
    List[0] := 'TEXT';
    P.h := 70;
    P.v := 100;
    SFGetFile(P,'Open What File?',NoFileFilter(),1,List,ADDRESS(0),Reply);
    IF (Reply.good) THEN
	Open(InStream,Reply.fName,Reply.vRefNum,ReadOnly);
	IF InStream # NIL THEN
	    InIsTerm := FALSE;
	    Done := TRUE
	ELSE
	    Done := FALSE
	END;
    ELSE
	Done := FALSE;
    END
END OpenInput;
	 
PROCEDURE OpenOutput	(VAR defext: ARRAY OF CHAR);
VAR
    DefName:	ARRAY [0..255] OF CHAR;
    Reply:	SFReply;
    P:		Point;
(*	request a file name and open output file "out"
 *	Done := "file was successfully opened.
 *	If open, subsequent output is written on this file
 *)
(* This procedure will also use the SFPackage on the Mac BC *)
	

BEGIN
    P.h := 70;
    P.v := 100;
    SFPutFile(P,'Create What File?','OUTPUT.TEXT',NoDlg(),Reply);
    IF (Reply.good) THEN
	Create(Reply.fName,Reply.vRefNum,'EDIT','TEXT');
	Open(OutStream,Reply.fName,Reply.vRefNum,WriteOnly);
	IF (OutStream # NIL) THEN
	    OutIsTerm := FALSE;
	    Done := TRUE
	ELSE
	    Done := TRUE
	END
    ELSE
	Done := FALSE;
    END
END OpenOutput;	

PROCEDURE CloseInput;
(*	closes input file; returns input to the terminal *)
BEGIN
    IF (NOT InIsTerm) THEN
    	Close(InStream);
	Done := TRUE
    END;
    InIsTerm := TRUE;
    (* even if Close Fails Input becomes terminal again *)
END CloseInput;
	
PROCEDURE CloseOutput;
(* closes output file; returns output to terminal*)
BEGIN
    IF (NOT OutIsTerm) THEN
	Close(OutStream);
	Done := TRUE;
	OutIsTerm := TRUE;
    END	
    (* even if Close Fails Input becomes terminal again *)
END CloseOutput;
	
	
PROCEDURE Read	(VAR ch:CHAR);
(* Done := NOT in.eof *)
VAR
    count	:	LONGINT;
BEGIN
    IF (InIsTerm) THEN
	Terminal.Read(ch);
	(* Terminal Input can't fail? *)
	Done := TRUE;
    ELSE
	count := 1;
	IF (NOT EOS(InStream)) THEN
		ReadChar(InStream,ch);
		Done := TRUE
	ELSE
		ch := 0C;
		Done := FALSE
	END
    END
END Read;
	
PROCEDURE ReadString	(VAR s:ARRAY OF CHAR);
(*	read string, i.e. sequence of characters not containing
 *	blanks nor control characters; leading blanks are ignored.
 *	Input is terminated by any character <= " ";
 *	this character is assigned to termCH.
 *	DEL is used for backspacing when input from terminal*)
(* I will make this a backspace for the Mac BC *)
VAR
    I:	CARDINAL;
BEGIN
    I := 0;
    REPEAT
	Read(s[I])
    UNTIL ((s[I] # ' ') OR (NOT Done));
    LOOP
	IF (s[I] = 10C) THEN (* BackSpace *)
	    IF (I > 0) THEN
		I := I - 1
	    END
	ELSIF (s[I] <= ' ') THEN
	    termCH := s[I];
	    s[I] := 0C;			(* NULL TERMINATED STRINGS *)
	    EXIT
	ELSIF (I >= HIGH(s)) THEN
	    termCH := 0C;
	    EXIT
	ELSE
	    INC(I);
	    Read(s[I]);
	    IF (NOT Done) THEN
		s[I] := 0C;
		termCH := 0C;
		IF (I = 0) THEN
		    Done := FALSE;	(* End Of File *)
		ELSE
		    Done := TRUE
		END;
		EXIT
	    END
	END
    END (* LOOP *)
END ReadString;		
	 
PROCEDURE ReadInt	(VAR x:INTEGER);
(*	read strings and convert to integer. Syntax:
 *	integer = ["+"|"-"]digit{digit}.
 *	leading blanks are ignored.
 *	Done := "integer was read" *)
VAR
	String:	ARRAY [0..30] OF CHAR;
BEGIN
    ReadString(String);
    Done := StrToInt(String,x);
END ReadInt;
			
		
PROCEDURE ReadCard	(VAR x:CARDINAL);
(*	read string and convert to cardinal. Syntax:
 *	cardinal = digit {digit}
 *	Leading blanks are ignored.
 *	Done := "cardinal was read"
 *)
VAR
	String:	ARRAY [0..30] OF CHAR;
BEGIN
    ReadString(String);
    Done := StrToCard(String,x);
END ReadCard;
	
PROCEDURE Write	(ch:CHAR);
VAR
    count	:	LONGINT;
BEGIN
    IF (OutIsTerm) THEN
	IF (ch = EOL) THEN
		Terminal.WriteLn
	ELSE
		Terminal.Write(ch)
	END;
	Done := TRUE
    ELSE
	count := 1;
	Done := TRUE;
	WriteChar(OutStream,ch)
    END
END Write;
	
PROCEDURE WriteLn; (*terminate line*)
BEGIN
    Write(EOL);
END WriteLn;
	
PROCEDURE WriteString	(VAR s:ARRAY OF CHAR);
(*	I will follow the convention here that a String Is upto
 *	The LENGTH of the STRING or Ends at the First Null
 *)
VAR
	i:	CARDINAL;
BEGIN
    i := 0;
    REPEAT
	IF (i <= HIGH(s)) THEN
	    IF (s[i] = 0C) THEN
		    i := HIGH(s) + 1; (* Let's Try This *)
	    ELSE
		    Write(s[i]);
		    INC(i)
	    END
	END
    UNTIL (i > HIGH(s))
END WriteString;
		
	
PROCEDURE WriteInt	(x: INTEGER; n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
	FOR i := 1 TO n - 8 DO
	    Write(' ')
	END;
	n := 7;
    END;
    Done := IntToStr(x,str,n);
    WriteString(str);
END WriteInt;
	
PROCEDURE WriteCard (x,n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
	FOR i := 1 TO n - 8 DO
	    Write(' ')
	END;
	n := 7;
    END;
    Done := CardToStr(x,str,n);
    WriteString(str);
END WriteCard;
			
PROCEDURE WriteOct	(x: WORD; n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
	FOR i := 1 TO n - 8 DO
		Write(' ')
	END;
	n := 7;
    END;
    Done := OctToStr(x,str,n);
    WriteString(str);
END WriteOct;
			
PROCEDURE WriteHex	(x:WORD;n: CARDINAL);
VAR
    str : ARRAY [0..7] OF CHAR;
    i : CARDINAL;
BEGIN
    IF (n > 8) THEN
	FOR i := 1 TO n - 8 DO
	    Write(' ')
	END;
	n := 7;
    END;
    Done := HexToStr(x,str,n);
    WriteString(str);
END WriteHex;
	
BEGIN (* InOut Init *)
    InIsTerm := TRUE;
    OutIsTerm := TRUE;
END InOut.
!Funky!Stuff!
echo x - MacSYSTEM.MOD
cat >MacSYSTEM.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MacSYSTEM;

(* EMPTY IMPLEMENTATION *)

END MacSYSTEM.
!Funky!Stuff!