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 (3 of 6)
Message-ID: <433@tikal.UUCP>
Date: Tue, 13-May-86 12:01:41 EDT
Article-I.D.: tikal.433
Posted: Tue May 13 12:01:41 1986
Date-Received: Fri, 16-May-86 01:47:22 EDT
Reply-To: bobc@tikal.UUCP (Bob Campbell)
Organization: Teltone Corp., Kirkland, WA
Lines: 4053

# The rest of this file is a shell script which will extract:
# MathLib0.MOD MathLib1.MOD MemoryManager.MOD MenuManager.MOD PascalStrings.MOD Pictures.MOD Regions.MOD
echo x - MathLib0.MOD
cat >MathLib0.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MathLib0;  (*Mathematical library 0 *)

FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
CONST
    GetRet  = 0285FH;   (* MOVEA (A7)+,A4       *)
    Return  = 04ED4H;   (* JMP  A4              *)
    SaveA7  = 0264FH;   (* MOVEA A7,A3      *)
    RestoreA7   = 02E4BH;   (* MOVEA A3,A7      *)
    
    FSQRTX  =   00012H;
    FSINX       =   00018H; (* ELEMS68K *)
    FCOSX       =   0001AH; (* ELEMS68K *)
    FATANX  =   0001EH; (* ELEMS68K *)
    FEXPX       =   00008H; (* ELEMS68K *)
    FLNX        =   00000H; (* ELEMS68K *)

    FTINTX      =   00016H;
    
    FX2S        =   01010H;
    FS2X        =   0100EH;
    FI2X        =   0200EH;
    FX2I        =   02010H;
    
    ELEMS68K    =   0A9ECH;
TYPE
    EXTENDED    =   RECORD
        Exp     :   INTEGER;
        Value   :   ARRAY [0..3] OF CARDINAL;
    END;

(*$S-*)
PROCEDURE DoFS2X(VAR Sgl : REAL; VAR Ext : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FS2X,-(SP)             *)  CODE(03F3CH);CODE(FS2X);
(*  _FP68K  ; A9EB                  *)  CODE(0A9EBH);
    CODE(RestoreA7);CODE(Return);
END DoFS2X;

PROCEDURE DoFX2S(VAR Ext : EXTENDED; VAR Sgl : REAL);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FX2S,-(SP)             *)  CODE(03F3CH);CODE(FX2S);
(*  _FP68K  ; A9EB                  *)  CODE(0A9EBH);
    CODE(RestoreA7);CODE(Return);
END DoFX2S;
(*$P+*)

PROCEDURE DoFX2I(VAR Ext : EXTENDED; VAR Sgl : INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FX2I,-(SP)             *)  CODE(03F3CH);CODE(FX2I);
(*  _FP68K  ; A9EB                  *)  CODE(0A9EBH);
    CODE(RestoreA7);CODE(Return);
END DoFX2I;
(*$P+*)

PROCEDURE DoFI2X(VAR I : INTEGER; VAR Ext : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FI2X,-(SP)             *)  CODE(03F3CH);CODE(FI2X);
(*  _FP68K  ; A9EB                  *)  CODE(0A9EBH);
    CODE(RestoreA7);CODE(Return);
END DoFI2X;
(*$P+*)

PROCEDURE DoFSQRTX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FSQRTX,-(SP)               *)  CODE(03F3CH);CODE(FSQRTX);
(*  _FP68K  ; A9EB                  *)  CODE(0A9EBH);
    CODE(RestoreA7);CODE(Return);
END DoFSQRTX;
(*$P+*)

PROCEDURE sqrt   (x: REAL) : REAL;
VAR
    xt  :   EXTENDED;
BEGIN
    DoFS2X(x,xt);
    DoFSQRTX(xt);
    DoFX2S(xt,x);
    RETURN(x)
END sqrt;

PROCEDURE DoFSINX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FSINX,-(SP)                *)  CODE(03F3CH);CODE(FSINX);
(*  _ELEMS68K   ; A9EC              *)  CODE(ELEMS68K);
    CODE(RestoreA7);CODE(Return);
END DoFSINX;
(*$P+*)

PROCEDURE sin(x: REAL) : REAL;
VAR
    xt  :   EXTENDED;
BEGIN
    DoFS2X(x,xt);
    DoFSINX(xt);
    DoFX2S(xt,x);
    RETURN(x)
END sin;

PROCEDURE DoFCOSX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FCOSX,-(SP)                *)  CODE(03F3CH);CODE(FCOSX);
(*  _ELEMS68K   ; A9EC              *)  CODE(ELEMS68K);
    CODE(RestoreA7);CODE(Return);
END DoFCOSX;
(*$P+*)

PROCEDURE cos    (x: REAL) : REAL;
VAR
    xt  :   EXTENDED;
BEGIN
    DoFS2X(x,xt);
    DoFCOSX(xt);
    DoFX2S(xt,x);
    RETURN(x)
END cos;

PROCEDURE DoFATANX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FATANX,-(SP)               *)  CODE(03F3CH);CODE(FATANX);
(*  _ELEMS68K   ; A9EC              *)  CODE(ELEMS68K);
    CODE(RestoreA7);CODE(Return);
END DoFATANX;
(*$P+*)

PROCEDURE arctan (x: REAL) : REAL;
VAR
    xt  :   EXTENDED;
BEGIN
    DoFS2X(x,xt);
    DoFATANX(xt);
    DoFX2S(xt,x);
    RETURN(x)
END arctan;

PROCEDURE DoFEXPX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FEXPX,-(SP)                *)  CODE(03F3CH);CODE(FEXPX);
(*  _ELEMS68K   ; A9EC              *)  CODE(ELEMS68K);
    CODE(RestoreA7);CODE(Return);
END DoFEXPX;
(*$P+*)

PROCEDURE exp    (x: REAL) : REAL;
VAR
    xt  :   EXTENDED;
BEGIN
    DoFS2X(x,xt);
    DoFEXPX(xt);
    DoFX2S(xt,x);
    RETURN(x)
END exp;

PROCEDURE DoFLNX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FLNX,-(SP)             *)  CODE(03F3CH);CODE(FLNX);
(*  _ELEMS68K   ; A9EC              *)  CODE(ELEMS68K);
    CODE(RestoreA7);CODE(Return);
END DoFLNX;
(*$P+*)

PROCEDURE ln    (x: REAL) : REAL;
VAR
    xt  :   EXTENDED;
BEGIN
    DoFS2X(x,xt);
    DoFLNX(xt);
    DoFX2S(xt,x);
    RETURN(x)
END ln;

PROCEDURE DoFTINTX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FTINTX,-(SP)               *)  CODE(03F3CH);CODE(FTINTX);
(*  _ELEMS68K   ; A9EC              *)  CODE(ELEMS68K);
    CODE(RestoreA7);CODE(Return);
END DoFTINTX;
(*$P+*)

PROCEDURE entier (x: REAL) : INTEGER;
VAR
    xt  :   EXTENDED;
    i   :   INTEGER;
BEGIN
    DoFS2X(x,xt);
    DoFTINTX(xt);
    DoFX2I(xt,i);
    RETURN(i)
END entier;

PROCEDURE real   (x: INTEGER) : REAL;
VAR
    xt  :   EXTENDED;
    r   :   REAL;
BEGIN
    DoFI2X(x,xt);
    DoFX2S(xt,r);
    RETURN(r)
END real;

END MathLib0.





!Funky!Stuff!
echo x - MathLib1.MOD
cat >MathLib1.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MathLib1;  (* Math. library 1 *)
(* additional mathematical functions*)

(* M. Schneider  4. Juli 1983 *)

FROM SYSTEM IMPORT ADDRESS,CODE,ADR,WORD;
CONST
    GetRet  = 0285FH;   (* MOVEA (A7)+,A4       *)
    Return  = 04ED4H;   (* JMP  A4              *)
    SaveA7  = 0264FH;   (* MOVEA A7,A3      *)
    RestoreA7   = 02E4BH;   (* MOVEA A3,A7      *)
        
    FTINTX      =   00016H;
    
    FX2S        =   01010H;
    FS2X        =   0100EH;
    FI2X        =   0200EH;
    FX2I        =   02010H;
    
    FLOG2X  =   00002H;
    FEXP2X  =   0000AH;
    FTANX       =   0001CH;
    FRANDX  =   00020H;
    FSCALBX =   00018H;
    (* scalb(I,X) : X *)
    
    pi          =   3.1415926536;
    
    ELEMS68K    =   0A9ECH;
    FP68K       =   0A9EBH;

TYPE
    EXTENDED    =   RECORD
        Exp     :   INTEGER;
        Value   :   ARRAY [0..3] OF CARDINAL;
    END;

PROCEDURE ELEMS68K2(VAR src,dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  _ELEMS68K   ; A9EB                  *)  CODE(ELEMS68K);
    CODE(RestoreA7);CODE(Return);
END ELEMS68K2;

PROCEDURE ELEMS68K1(VAR dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  _ELEMS68K   ; A9EB          *)  CODE(ELEMS68K);
    CODE(RestoreA7);CODE(Return);
END ELEMS68K1;

PROCEDURE FP68K2(VAR src,dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  _FP68K  ; A9EB                  *)  CODE(FP68K);
    CODE(RestoreA7);CODE(Return);
END FP68K2;

PROCEDURE FP68K1(VAR dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  _FP68K  ; A9EB                  *)  CODE(FP68K);
    CODE(RestoreA7);CODE(Return);
END FP68K1;

PROCEDURE DoFS2X(VAR Sgl : REAL; VAR Ext : EXTENDED);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FS2X,-(SP)             *)  CODE(03F3CH);CODE(FS2X);
(*  _FP68K  ; A9EB                  *)  CODE(0A9EBH);
    CODE(RestoreA7);CODE(Return);
END DoFS2X;

PROCEDURE DoFX2S(VAR Ext : EXTENDED; VAR Sgl : REAL);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FX2S,-(SP)             *)  CODE(03F3CH);CODE(FX2S);
(*  _FP68K  ; A9EB                  *)  CODE(0A9EBH);
    CODE(RestoreA7);CODE(Return);
END DoFX2S;
(*$P+*)(*$S-*)

PROCEDURE exp2 ( x: REAL ): REAL;
VAR
    p   :   EXTENDED;
BEGIN
    DoFS2X(x,p);
    ELEMS68K1(p,FEXP2X);
    DoFX2S(p,x);
END exp2;

PROCEDURE log2 ( x: REAL ): REAL;
VAR
    p   :   EXTENDED;
BEGIN
    DoFS2X(x,p);
    ELEMS68K1(p,FLOG2X);
    DoFX2S(p,x);
END log2;

PROCEDURE tan ( x: REAL ): REAL;
VAR
    p   :   EXTENDED;
BEGIN
    DoFS2X(x,p);
    ELEMS68K1(p,FTANX);
    DoFX2S(p,x);
END tan;

VAR 
    Seed:EXTENDED;
    Convert:REAL;

PROCEDURE scalb(VAR i:INTEGER;VAR x:EXTENDED);  
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
(*  MOVE    #FSCALBX,-(SP)          *)  CODE(03F3CH);CODE(FSCALBX);
(*  _FP68K  ; A9EB                  *)  CODE(0A9EBH);
    CODE(RestoreA7);CODE(Return);
END scalb;
(*$P+*)
PROCEDURE random(): REAL;
            (* range: 0.0 <= random < 1.0 *)
VAR
    p   :   EXTENDED;
    i   :   INTEGER;
BEGIN
    ELEMS68K1(p,FRANDX);
    i := 1;
    scalb(i,p);
    DoFX2S(p,Convert);
    RETURN(Convert);
END random;

PROCEDURE setrandom( x0: REAL );
BEGIN
    DoFS2X(x0,Seed);
END setrandom;

PROCEDURE PI(): REAL;
BEGIN
    RETURN(pi)
END PI;

BEGIN
     Convert := 0.0;
     DoFS2X(Convert,Seed);
END MathLib1.

!Funky!Stuff!
echo x - MemoryManager.MOD
cat >MemoryManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MemoryManager;
FROM SYSTEM IMPORT ADDRESS,CODE,ADR,REGISTER,SETREG;
FROM MacSYSTEM IMPORT Handle,LONGINT,OSErr;

CONST
    GetRet  = 0285FH;   (* MOVEA (A7)+,A4   *)
    Return  = 04ED4H;   (* JMP  A4      *)
    SaveA7  = 0264FH;   (* MOVEA A7,A3  *)
    RestoreA7   = 02E4BH;   (* MOVEA A3,A7  *)
    
    RD0 =   0;  RA0 =   8;
    RD1 =   1;  RA1 =   9;
    RD2 =   2;  RA2 =   0AH;
    RD3 =   3;  RA3 =   0BH;
    RD4 =   4;  RA4 =   0CH;
    RD5 =   5;  RA5 =   0DH;
    RD6 =   6;  RA6 =   0EH;
    RD7 =   7;  RA7 =   0FH;

VAR
    MMError:OSErr;
    
(* Routines *)

(* Initialization and Allocation *)

PROCEDURE InitApplZone;
(*$S-*)
BEGIN
    CODE(0A20CH);
    MMError := OSErr(REGISTER(RD0));
END InitApplZone;

PROCEDURE SetApplBase(startPtr:ADDRESS);
(*$S-*)
BEGIN
    SETREG(RA0,startPtr);
    CODE(0A857H);
    MMError := OSErr(REGISTER(RD0));
END SetApplBase;

PROCEDURE InitZone(pGrowZone:ADDRESS;cMoreMasters:INTEGER;
    limitPtr,startPtr:ADDRESS);
BEGIN
    SETREG(RA0,ADR(startPtr));
    MMError := OSErr(REGISTER(RD0));
END InitZone;

PROCEDURE GetApplLimit():ADDRESS;
(*$P+*)(*$S-*)
BEGIN
    RETURN(ApplLimit)
END GetApplLimit;
    
PROCEDURE SetApplLimit(zoneLimit:ADDRESS);
BEGIN
    SETREG(RA0,zoneLimit);
    CODE(0A02DH);
    MMError := OSErr(REGISTER(RD0));
END SetApplLimit;

PROCEDURE MaxApplZone; (* No trap Macro *)
(*$P+*)
BEGIN
END MaxApplZone;

PROCEDURE MoreMasters;
BEGIN
    CODE(0A036H);
    MMError := OSErr(REGISTER(RD0));
END MoreMasters;

(* Heap Zone Access *)

PROCEDURE GetZone():THz;
BEGIN
    CODE(0A11AH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END GetZone;

PROCEDURE SetZone(hz:THz);
BEGIN
    SETREG(RA0,hz);
    CODE(0A01BH);
    MMError := OSErr(REGISTER(RD0));
END SetZone;

PROCEDURE SystemZone():THz; (* No trap macro *)
BEGIN
  RETURN(THz(SysZone))
END SystemZone;

PROCEDURE ApplicZone():THz; (* No trap macro *)
BEGIN
  RETURN(THz(ApplZone))
END ApplicZone;

(* Allocating and Releasing Relocatable Blocks *)

PROCEDURE NewHandle(logicalSize:Size):Handle;
BEGIN
    SETREG(RD0,logicalSize);
    CODE(0A122H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END NewHandle;

PROCEDURE DisposHandle(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A023H);
    MMError := OSErr(REGISTER(RD0));
END DisposHandle;

PROCEDURE GetHandleSize(h:Handle):Size;
BEGIN
    SETREG(RA0,h);
    CODE(0A025H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END GetHandleSize;

PROCEDURE SetHandleSize(h:Handle;newSize:Size);
BEGIN
    SETREG(RA0,h);
    SETREG(RD0,newSize);
    CODE(0A024H);
    MMError := OSErr(REGISTER(RD0));
END SetHandleSize;

PROCEDURE HandleZone(h:Handle):THz;
BEGIN
    SETREG(RA0,h);
    CODE(0A126H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END HandleZone;

PROCEDURE RecoverHandle(p:ADDRESS):Handle;
BEGIN
    SETREG(RA0,p);
    CODE(0A128H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END RecoverHandle;

PROCEDURE ReallocHandle(h:Handle;logicalSize:Size);
BEGIN
    SETREG(RA0,h);
    SETREG(RD0,logicalSize);
    CODE(0A127H);
    MMError := OSErr(REGISTER(RD0));
END ReallocHandle;

(* Allocating and Releasing Nonrelocatable Blocks *)

PROCEDURE NewPtr(logicalSize:Size):ADDRESS;
BEGIN
    SETREG(RD0,logicalSize);
    CODE(0A1EH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END NewPtr;

PROCEDURE DisposPtr(p:ADDRESS);
BEGIN
    SETREG(RA0,p);
    CODE(0A01FH);
    MMError := OSErr(REGISTER(RD0));
END DisposPtr;

PROCEDURE GetPtrSize(p:ADDRESS):Size;
BEGIN
    SETREG(RA0,p);
    CODE(0A021H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END GetPtrSize;

PROCEDURE SetPtrSize(p:ADDRESS;newSize:Size);
BEGIN
    SETREG(RA0,p);
    SETREG(RD0,newSize);
    CODE(0A020H);
    MMError := OSErr(REGISTER(RD0));
END SetPtrSize;

PROCEDURE PtrZone(p:ADDRESS):THz;
BEGIN
    SETREG(RA0,p);
    CODE(0A148H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END PtrZone;

(* Freeing Space in the Heap *)

PROCEDURE FreeMem():LONGINT;
BEGIN
    CODE(0A01CH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END FreeMem;

PROCEDURE MaxMem(VAR grow:Size):Size;
BEGIN
    CODE(0A01DH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END MaxMem;

PROCEDURE CompactMem(cbNeeded:Size):Size;
BEGIN
    SETREG(RD0,cbNeeded);
    CODE(0A04CH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END CompactMem;

PROCEDURE ResrvMem(cbNeeded:Size);
BEGIN
    SETREG(RD0,cbNeeded);
    CODE(0A040H);
    MMError := OSErr(REGISTER(RD0));
END ResrvMem;

PROCEDURE PurgeMem(cbNeeded:Size);
BEGIN
    SETREG(RD0,cbNeeded);
    CODE(0A04DH);
    MMError := OSErr(REGISTER(RD0));
END PurgeMem;

PROCEDURE EmptyHandle(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A02BH);
    MMError := OSErr(REGISTER(RD0));
END EmptyHandle;

(* Properties of Relocatable Blocks *)

PROCEDURE HLock(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A029H);
    MMError := OSErr(REGISTER(RD0));
END HLock;

PROCEDURE HUnlock(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A02AH);
    MMError := OSErr(REGISTER(RD0));
END HUnlock;

PROCEDURE HPurge(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A049H);
    MMError := OSErr(REGISTER(RD0));
END HPurge;

PROCEDURE HNoPurge(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A049H);
    MMError := OSErr(REGISTER(RD0));
END HNoPurge;

(* Grow Zone Operations *)
PROCEDURE SetGrowZone(growZone:ADDRESS);
BEGIN
    SETREG(RA0,growZone);
    CODE(0A04BH);
    MMError := OSErr(REGISTER(RD0));
END SetGrowZone;

PROCEDURE GZSaveHnd():Handle;   (* No trap macro *)
BEGIN
    RETURN(GZRootHnd)
END GZSaveHnd;

(* Miscellaneous Routines *)

PROCEDURE BlockMove(src,dst:ADDRESS;count:Size);
BEGIN
    SETREG(RA0,src);
    SETREG(RA1,dst);
    SETREG(RD0,count);
    CODE(0A02EH);
    MMError := OSErr(REGISTER(RD0));
END BlockMove;

PROCEDURE TopMem():ADDRESS; (* No trap macro *)
BEGIN
    RETURN(MemTop)
END TopMem;

PROCEDURE MoveHHi(h:Handle);
BEGIN
END MoveHHi;

PROCEDURE MemError():OSErr; (* No trap macro *)
BEGIN
    RETURN(MMError)
END MemError;

(* Grow Zone Function *)
END MemoryManager.
!Funky!Stuff!
echo x - MenuManager.MOD
cat >MenuManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MenuManager;
FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR;
FROM MacSYSTEM IMPORT LONGINT,Handle;
FROM PascalStrings IMPORT MakePascalString,MakeModulaString;
FROM QuickDraw IMPORT Point,Rect,Style;
FROM WindowManager IMPORT inMenuBar; (* Init WindowManager First *)
FROM ResourceManager IMPORT ResType,ParamResType;

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


PROCEDURE xNewMenu(menuID:INTEGER;menuTitle:ADDRESS):MenuHandle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A931H);
    CODE(RestoreA7);CODE(Return);
END xNewMenu;
PROCEDURE NewMenu(menuID:INTEGER;VAR menuTitle:ARRAY OF CHAR):MenuHandle;
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
    MakePascalString(menuTitle,Str);
    RETURN(xNewMenu(menuID,ADR(Str)))
END NewMenu;
PROCEDURE GetMenu(resourceID:INTEGER):MenuHandle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9BFH);
    CODE(RestoreA7);CODE(Return);
END GetMenu;
PROCEDURE DisposeMenu(theMenu:MenuHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A932H);
    CODE(RestoreA7);CODE(Return);
END DisposeMenu;

(*Forming the Menus*)
PROCEDURE xAppendMenu(theMenu:MenuHandle;data:ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A933H);
    CODE(RestoreA7);CODE(Return);
END xAppendMenu;
PROCEDURE AppendMenu(theMenu:MenuHandle;VAR data:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
    MakePascalString(data,Str);
    xAppendMenu(theMenu,ADR(Str))
END AppendMenu;
PROCEDURE xAddResMenu(theMenu:MenuHandle;theType:LONGINT);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A94DH);
    CODE(RestoreA7);CODE(Return);
END xAddResMenu;
PROCEDURE AddResMenu(theMenu:MenuHandle;theType:ResType);
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
    x.res := theType;
    xAddResMenu(theMenu,x.param);
END AddResMenu;

PROCEDURE xInsertResMenu(theMenu:MenuHandle;theType:LONGINT;
    afterItem:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A951H);
    CODE(RestoreA7);CODE(Return);
END xInsertResMenu;
PROCEDURE InsertResMenu(theMenu:MenuHandle;theType:ResType;
    afterItem:INTEGER);
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
    x.res := theType;
    xInsertResMenu(theMenu,x.param,afterItem)
END InsertResMenu;

(*Forming the Menus*)
PROCEDURE InsertMenu(theMenu:MenuHandle;beforeID:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A935H);
    CODE(RestoreA7);CODE(Return);
END InsertMenu;
PROCEDURE DrawMenuBar;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A937H);
    CODE(RestoreA7);CODE(Return);
END DrawMenuBar;
PROCEDURE DeleteMenu(menuID:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A936H);
    CODE(RestoreA7);CODE(Return);
END DeleteMenu;
PROCEDURE ClearMenuBar;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A934H);
    CODE(RestoreA7);CODE(Return);
END ClearMenuBar;
PROCEDURE GetNewMBar(menuBarID:INTEGER):Handle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9C0H);
    CODE(RestoreA7);CODE(Return);
END GetNewMBar;
PROCEDURE GetMenuBar():Handle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A93BH);
    CODE(RestoreA7);CODE(Return);
END GetMenuBar;
PROCEDURE SetMenuBar(menuList:Handle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A93CH);
    CODE(RestoreA7);CODE(Return);
END SetMenuBar;

(*Choosing from a menu*)
PROCEDURE xMenuSelect(startPt:LONGINT):LONGINT;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A93DH);
    CODE(RestoreA7);CODE(Return);
END xMenuSelect;
PROCEDURE MenuSelect(startPt:Point):LONGINT;
(*$P+*)(*$S-*)
BEGIN
    RETURN(xMenuSelect(startPt.param))
END MenuSelect;
PROCEDURE xMenuKey(ch:CARDINAL):LONGINT;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A93EH);
    CODE(RestoreA7);CODE(Return);
END xMenuKey;
PROCEDURE MenuKey(ch:CHAR):LONGINT;
(*$P+*)(*$S-*)
BEGIN
    RETURN(xMenuKey(ORD(ch)))
END MenuKey;
PROCEDURE HiliteMenu(menuID:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A938H);
    CODE(RestoreA7);CODE(Return);
END HiliteMenu;

(*Controlling Items' Appearance*)
PROCEDURE xSetItem(theMenu:MenuHandle;item:INTEGER;itemString:ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A947H);
    CODE(RestoreA7);CODE(Return);
END xSetItem;
PROCEDURE SetItem(theMenu:MenuHandle;item:INTEGER;VAR itemString:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
    MakePascalString(itemString,Str);
    xSetItem(theMenu,item,ADR(Str))
END SetItem;

PROCEDURE xGetItem(theMenu:MenuHandle;item:INTEGER;itemString:ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A946H);
    CODE(RestoreA7);CODE(Return);
END xGetItem;
PROCEDURE GetItem(theMenu:MenuHandle;item:INTEGER;VAR itemString:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
    xGetItem(theMenu,item,ADR(Str));
    MakeModulaString(Str,itemString)
END GetItem;

PROCEDURE DisableItem(theMenu:MenuHandle;item:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A93AH);
    CODE(RestoreA7);CODE(Return);
END DisableItem;
PROCEDURE EnableItem(theMenu:MenuHandle;item:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A939H);
    CODE(RestoreA7);CODE(Return);
END EnableItem;
PROCEDURE CheckItem(theMenu:MenuHandle;item:INTEGER;checked:BOOLEAN);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A945H);
    CODE(RestoreA7);CODE(Return);
END CheckItem;
PROCEDURE xSetItemMark(theMenu:MenuHandle;item:INTEGER;markChar:CARDINAL);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A944H);
    CODE(RestoreA7);CODE(Return);
END xSetItemMark;
PROCEDURE SetItemMark(theMenu:MenuHandle;item:INTEGER;markChar:CHAR);
(*$P+*)(*$S-*)
BEGIN
    xSetItemMark(theMenu,item,ORD(markChar))
END SetItemMark;
PROCEDURE GetItemMark(theMenu:MenuHandle;item:INTEGER;VAR markChar:CHAR);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A943H);
    CODE(RestoreA7);CODE(Return);
END GetItemMark;
PROCEDURE xSetItemIcon(theMenu:MenuHandle;item:INTEGER;icon:CARDINAL);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A940H);
    CODE(RestoreA7);CODE(Return);
END xSetItemIcon;
PROCEDURE SetItemIcon(theMenu:MenuHandle;item:INTEGER;icon:CHAR);
(*$P+*)(*$S-*)
BEGIN
    xSetItemIcon(theMenu,item,ORD(icon))
END SetItemIcon;
PROCEDURE GetItemIcon(theMenu:MenuHandle;item:INTEGER;VAR icon:CHAR);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A93FH);
    CODE(RestoreA7);CODE(Return);
END GetItemIcon;
PROCEDURE SetItemStyle(theMenu:MenuHandle;item:INTEGER;chStyle:Style);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A942H);
    CODE(RestoreA7);CODE(Return);
END SetItemStyle;
PROCEDURE GetItemStyle (theMenu: MenuHandle;item:INTEGER; VAR chStyle:Style);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A941H);
    CODE(RestoreA7);CODE(Return);
END GetItemStyle;

(*Miscellaneous Routines*)
PROCEDURE CalcMenuSize(theMenu:MenuHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A948H);
    CODE(RestoreA7);CODE(Return);
END CalcMenuSize;
PROCEDURE CountMItems(theMenu:MenuHandle):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A950H);
    CODE(RestoreA7);CODE(Return);
END CountMItems;
PROCEDURE GetMHandle(menuID:INTEGER):MenuHandle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A949H);
    CODE(RestoreA7);CODE(Return);
END GetMHandle;
PROCEDURE FlashMenuBar(menuID:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A94CH);
    CODE(RestoreA7);CODE(Return);
END FlashMenuBar;
PROCEDURE SetMenuFlash(count:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A94AH);
    CODE(RestoreA7);CODE(Return);
END SetMenuFlash;

(*Menu Definition Procedure*)
BEGIN
    CODE(0A930H); (*InitMenus*)
END MenuManager.
!Funky!Stuff!
echo x - PascalStrings.MOD
cat >PascalStrings.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE PascalStrings;

PROCEDURE MakePascalString(VAR in: ARRAY OF CHAR; VAR out: ARRAY OF CHAR);
VAR
    i:CARDINAL;
(*$S-*)
(*$T-*)
BEGIN
    i := 0;
    WHILE ((i <= HIGH(in)) AND (i < HIGH(out)) AND (in[i] <> 0C)) DO
        out[i + 1]:=in[i];
        INC(i)
    END;
    out[0] := CHAR(i);
END MakePascalString;

PROCEDURE MakeModulaString(VAR in: ARRAY OF CHAR; VAR out: ARRAY OF CHAR);
VAR 
    i:CARDINAL;
(*$S-*)
BEGIN
    i := 0;
    WHILE ((i < ORD(in[0])) AND (i <= HIGH(out))) DO
        out[i]:=in[i + 1];
        INC(i)
    END;
 IF (i <= HIGH(out)) THEN
     out[i] := 0C;
 END
END MakeModulaString;
PROCEDURE emptyPascalString(VAR string:ARRAY OF CHAR);
(*$S-*)
BEGIN
    string[0] := 0C
END emptyPascalString;
END PascalStrings.
!Funky!Stuff!
echo x - Pictures.MOD
cat >Pictures.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE Pictures;

FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
FROM QuickDraw IMPORT Rect;

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

(* Picture Routines *)
PROCEDURE GetPicture(picID:INTEGER):PicHandle;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(0A9BCH);
  CODE(RestoreA7);
  CODE(Return);
END GetPicture;

PROCEDURE OpenPicture (VAR picFrame:Rect):PicHandle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8F3H);
    CODE(RestoreA7);CODE(Return);
END OpenPicture;

PROCEDURE   ClosePicture;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8F4H);
    CODE(RestoreA7);CODE(Return);
END ClosePicture;

PROCEDURE   KillPicture (thePicture:PicHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8F5H);
    CODE(RestoreA7);CODE(Return);
END KillPicture;

PROCEDURE   DrawPicture (thePicture:PicHandle;VAR inRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8F6H);
    CODE(RestoreA7);CODE(Return);
END DrawPicture;

PROCEDURE   PicComment  (kind,dataSize:INTEGER;data:PicHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8F2H);
    CODE(RestoreA7);CODE(Return);
END PicComment;

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

FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR,REGISTER;
FROM MacSYSTEM IMPORT LONGINT;
FROM QuickDraw IMPORT RgnHandle,RgnPtr,Region,Point,Rect,Pattern;
FROM PascalStrings IMPORT MakePascalString;

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

(* Region Calculations *)
PROCEDURE   NewRgn():RgnHandle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8D8H);
    CODE(RestoreA7);CODE(Return);
END NewRgn;

PROCEDURE   OpenRgn;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8DAH);
    CODE(RestoreA7);CODE(Return);
END OpenRgn;

PROCEDURE   CloseRgn    (theRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8DBH);
    CODE(RestoreA7);CODE(Return);
END CloseRgn;

PROCEDURE   DisposeRgn  (theRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8D9H);
    CODE(RestoreA7);CODE(Return);
END DisposeRgn;

PROCEDURE   SetEmptyRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8DDH);
    CODE(RestoreA7);CODE(Return);
END SetEmptyRgn;

PROCEDURE RectRgn (theRegion:RgnHandle;VAR theRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8DFH);
    CODE(RestoreA7);CODE(Return);
END RectRgn;

PROCEDURE SetRectRgn (theRegion:RgnHandle;left,top,right,bottom:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8DEH);
    CODE(RestoreA7);CODE(Return);
END SetRectRgn;

PROCEDURE   CopyRgn     (fromRegion,toRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8DCH);
    CODE(RestoreA7);CODE(Return);
END CopyRgn;

PROCEDURE xPtInRgn (thePoint:LONGINT;theRegion:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E8H);
    CODE(RestoreA7);CODE(Return);
END xPtInRgn;

PROCEDURE PtInRgn (thePoint:Point;theRegion:RgnHandle):BOOLEAN;
(*$P+*)(*$S-*)
BEGIN
    RETURN(xPtInRgn(thePoint.param,theRegion))
END PtInRgn;

PROCEDURE   RectInRgn   (VAR theRect:Rect;theRegion:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E9H);
    CODE(RestoreA7);CODE(Return);
END RectInRgn;

PROCEDURE OffsetRgn (theRegion:RgnHandle;hOffset,vOffset:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E0H);
    CODE(RestoreA7);CODE(Return);
END OffsetRgn;

PROCEDURE InsetRgn (theRegion:RgnHandle;hInset,vInset:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E1H);
    CODE(RestoreA7);CODE(Return);
END InsetRgn;

PROCEDURE EmptyRgn (theRegion:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E2H);
    CODE(RestoreA7);CODE(Return);
END EmptyRgn;

PROCEDURE   UnionRgn    (region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E5H);
    CODE(RestoreA7);CODE(Return);
END UnionRgn;

PROCEDURE   SectRgn     (region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E4H);
    CODE(RestoreA7);CODE(Return);
END SectRgn;

PROCEDURE   DiffRgn     (region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E6H);
    CODE(RestoreA7);CODE(Return);
END DiffRgn;

PROCEDURE   XOrRgn      (region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E7H);
    CODE(RestoreA7);CODE(Return);
END XOrRgn;

PROCEDURE EqualRgn (region1,region2:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8E3H);
    CODE(RestoreA7);CODE(Return);
END EqualRgn;

PROCEDURE   MapRgn      (theRegion:RgnHandle;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8FBH);
   CODE(RestoreA7);CODE(Return);
END MapRgn;

(* Drawing Regions *)
PROCEDURE FrameRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8D2H);
    CODE(RestoreA7);CODE(Return);
END FrameRgn;

PROCEDURE PaintRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8D3H);
    CODE(RestoreA7);CODE(Return);
END PaintRgn;

PROCEDURE FillRgn (theRegion:RgnHandle;VAR fillPat:Pattern);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8D6H);
    CODE(RestoreA7);CODE(Return);
END FillRgn;

PROCEDURE EraseRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8D4H);
    CODE(RestoreA7);CODE(Return);
END EraseRgn;

PROCEDURE InvertRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8D5H);
    CODE(RestoreA7);CODE(Return);
END InvertRgn;

END Regions.
!Funky!Stuff!
# The rest of this file is a shell script which will extract:
# MathLib0.MOD MathLib1.MOD MemoryManager.MOD MenuManager.MOD PascalStrings.MOD Pictures.MOD Regions.MOD
echo x - MathLib0.MOD
cat >MathLib0.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MathLib0;  (*Mathematical library 0 *)

FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
CONST
	GetRet 	= 0285FH;	(* MOVEA (A7)+,A4		*)
	Return 	= 04ED4H;	(* JMP	A4				*)
	SaveA7	= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)
	
	FSQRTX	=	00012H;
	FSINX		=	00018H;	(* ELEMS68K *)
	FCOSX		=	0001AH;	(* ELEMS68K *)
	FATANX	=	0001EH;	(* ELEMS68K *)
	FEXPX		=	00008H;	(* ELEMS68K *)
	FLNX		=	00000H;	(* ELEMS68K *)

	FTINTX		=	00016H;
	
	FX2S		=	01010H;
	FS2X		=	0100EH;
	FI2X		=	0200EH;
	FX2I		=	02010H;
	
	ELEMS68K	=	0A9ECH;
TYPE
	EXTENDED	=	RECORD
		Exp		:	INTEGER;
		Value	:	ARRAY [0..3] OF CARDINAL;
	END;

(*$S-*)
PROCEDURE DoFS2X(VAR Sgl : REAL; VAR Ext : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FS2X,-(SP)				*)	CODE(03F3CH);CODE(FS2X);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFS2X;

PROCEDURE DoFX2S(VAR Ext : EXTENDED; VAR Sgl : REAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FX2S,-(SP)				*)	CODE(03F3CH);CODE(FX2S);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFX2S;
(*$P+*)

PROCEDURE DoFX2I(VAR Ext : EXTENDED; VAR Sgl : INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FX2I,-(SP)				*)	CODE(03F3CH);CODE(FX2I);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFX2I;
(*$P+*)

PROCEDURE DoFI2X(VAR I : INTEGER; VAR Ext : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FI2X,-(SP)				*)	CODE(03F3CH);CODE(FI2X);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFI2X;
(*$P+*)

PROCEDURE DoFSQRTX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FSQRTX,-(SP)				*)	CODE(03F3CH);CODE(FSQRTX);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFSQRTX;
(*$P+*)

PROCEDURE sqrt   (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFSQRTX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END sqrt;

PROCEDURE DoFSINX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FSINX,-(SP)				*)	CODE(03F3CH);CODE(FSINX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFSINX;
(*$P+*)

PROCEDURE sin(x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFSINX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END sin;

PROCEDURE DoFCOSX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FCOSX,-(SP)				*)	CODE(03F3CH);CODE(FCOSX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFCOSX;
(*$P+*)

PROCEDURE cos    (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFCOSX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END cos;

PROCEDURE DoFATANX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FATANX,-(SP)				*)	CODE(03F3CH);CODE(FATANX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFATANX;
(*$P+*)

PROCEDURE arctan (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFATANX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END arctan;

PROCEDURE DoFEXPX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FEXPX,-(SP)				*)	CODE(03F3CH);CODE(FEXPX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFEXPX;
(*$P+*)

PROCEDURE exp    (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFEXPX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END exp;

PROCEDURE DoFLNX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FLNX,-(SP)				*)	CODE(03F3CH);CODE(FLNX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFLNX;
(*$P+*)

PROCEDURE ln    (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFLNX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END ln;

PROCEDURE DoFTINTX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FTINTX,-(SP)				*)	CODE(03F3CH);CODE(FTINTX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFTINTX;
(*$P+*)

PROCEDURE entier (x: REAL) : INTEGER;
VAR
	xt	:	EXTENDED;
	i	:	INTEGER;
BEGIN
	DoFS2X(x,xt);
	DoFTINTX(xt);
	DoFX2I(xt,i);
	RETURN(i)
END entier;

PROCEDURE real   (x: INTEGER) : REAL;
VAR
	xt	:	EXTENDED;
	r	:	REAL;
BEGIN
	DoFI2X(x,xt);
	DoFX2S(xt,r);
	RETURN(r)
END real;

END MathLib0.





!Funky!Stuff!
echo x - MathLib1.MOD
cat >MathLib1.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MathLib1;  (* Math. library 1 *)
(* additional mathematical functions*)

(* M. Schneider  4. Juli 1983 *)

FROM SYSTEM IMPORT ADDRESS,CODE,ADR,WORD;
CONST
	GetRet 	= 0285FH;	(* MOVEA (A7)+,A4		*)
	Return 	= 04ED4H;	(* JMP	A4				*)
	SaveA7	= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)
		
	FTINTX		=	00016H;
	
	FX2S		=	01010H;
	FS2X		=	0100EH;
	FI2X		=	0200EH;
	FX2I		=	02010H;
	
	FLOG2X	=	00002H;
	FEXP2X	=	0000AH;
	FTANX		=	0001CH;
	FRANDX	=	00020H;
	FSCALBX	=	00018H;
	(* scalb(I,X) : X *)
	
	pi			=	3.1415926536;
	
	ELEMS68K	=	0A9ECH;
	FP68K		=	0A9EBH;

TYPE
	EXTENDED	=	RECORD
		Exp		:	INTEGER;
		Value	:	ARRAY [0..3] OF CARDINAL;
	END;

PROCEDURE ELEMS68K2(VAR src,dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	_ELEMS68K	; A9EB					*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END ELEMS68K2;

PROCEDURE ELEMS68K1(VAR dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	_ELEMS68K	; A9EB			*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END ELEMS68K1;

PROCEDURE FP68K2(VAR src,dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	_FP68K	; A9EB					*)	CODE(FP68K);
	CODE(RestoreA7);CODE(Return);
END FP68K2;

PROCEDURE FP68K1(VAR dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	_FP68K	; A9EB					*)	CODE(FP68K);
	CODE(RestoreA7);CODE(Return);
END FP68K1;

PROCEDURE DoFS2X(VAR Sgl : REAL; VAR Ext : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FS2X,-(SP)				*)	CODE(03F3CH);CODE(FS2X);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFS2X;

PROCEDURE DoFX2S(VAR Ext : EXTENDED; VAR Sgl : REAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FX2S,-(SP)				*)	CODE(03F3CH);CODE(FX2S);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFX2S;
(*$P+*)(*$S-*)

PROCEDURE exp2 ( x: REAL ): REAL;
VAR
	p	:	EXTENDED;
BEGIN
	DoFS2X(x,p);
	ELEMS68K1(p,FEXP2X);
	DoFX2S(p,x);
END exp2;

PROCEDURE log2 ( x: REAL ): REAL;
VAR
	p	:	EXTENDED;
BEGIN
	DoFS2X(x,p);
	ELEMS68K1(p,FLOG2X);
	DoFX2S(p,x);
END log2;

PROCEDURE tan ( x: REAL ): REAL;
VAR
	p	:	EXTENDED;
BEGIN
	DoFS2X(x,p);
	ELEMS68K1(p,FTANX);
	DoFX2S(p,x);
END tan;

VAR 
	Seed:EXTENDED;
	Convert:REAL;

PROCEDURE scalb(VAR i:INTEGER;VAR x:EXTENDED);	
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FSCALBX,-(SP)			*)	CODE(03F3CH);CODE(FSCALBX);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END scalb;
(*$P+*)
PROCEDURE random(): REAL;
            (* range: 0.0 <= random < 1.0 *)
VAR
	p	:	EXTENDED;
	i	:	INTEGER;
BEGIN
	ELEMS68K1(p,FRANDX);
	i := 1;
	scalb(i,p);
	DoFX2S(p,Convert);
	RETURN(Convert);
END random;

PROCEDURE setrandom( x0: REAL );
BEGIN
	DoFS2X(x0,Seed);
END setrandom;

PROCEDURE PI(): REAL;
BEGIN
	RETURN(pi)
END PI;

BEGIN
	 Convert := 0.0;
	 DoFS2X(Convert,Seed);
END MathLib1.

!Funky!Stuff!
echo x - MemoryManager.MOD
cat >MemoryManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MemoryManager;
FROM SYSTEM IMPORT ADDRESS,CODE,ADR,REGISTER,SETREG;
FROM MacSYSTEM IMPORT Handle,LONGINT,OSErr;

CONST
    GetRet 	= 0285FH;	(* MOVEA (A7)+,A4	*)
    Return	= 04ED4H;	(* JMP	A4		*)
    SaveA7	= 0264FH;	(* MOVEA A7,A3	*)
    RestoreA7	= 02E4BH;	(* MOVEA A3,A7	*)
    
    RD0 =   0;	RA0 =	8;
    RD1	=   1;  RA1 =	9;
    RD2 =   2;	RA2 =	0AH;
    RD3 =   3;	RA3 =	0BH;
    RD4 =   4;	RA4 =	0CH;
    RD5 =   5;	RA5 =	0DH;
    RD6 =   6;	RA6 =	0EH;
    RD7 =   7;	RA7 =	0FH;

VAR
    MMError:OSErr;
    
(* Routines *)

(* Initialization and Allocation *)

PROCEDURE InitApplZone;
(*$S-*)
BEGIN
    CODE(0A20CH);
    MMError := OSErr(REGISTER(RD0));
END InitApplZone;

PROCEDURE SetApplBase(startPtr:ADDRESS);
(*$S-*)
BEGIN
    SETREG(RA0,startPtr);
    CODE(0A857H);
    MMError := OSErr(REGISTER(RD0));
END SetApplBase;

PROCEDURE InitZone(pGrowZone:ADDRESS;cMoreMasters:INTEGER;
    limitPtr,startPtr:ADDRESS);
BEGIN
    SETREG(RA0,ADR(startPtr));
    MMError := OSErr(REGISTER(RD0));
END InitZone;

PROCEDURE GetApplLimit():ADDRESS;
(*$P+*)(*$S-*)
BEGIN
    RETURN(ApplLimit)
END GetApplLimit;
    
PROCEDURE SetApplLimit(zoneLimit:ADDRESS);
BEGIN
    SETREG(RA0,zoneLimit);
    CODE(0A02DH);
    MMError := OSErr(REGISTER(RD0));
END SetApplLimit;

PROCEDURE MaxApplZone; (* No trap Macro *)
(*$P+*)
BEGIN
END MaxApplZone;

PROCEDURE MoreMasters;
BEGIN
    CODE(0A036H);
    MMError := OSErr(REGISTER(RD0));
END MoreMasters;

(* Heap Zone Access *)

PROCEDURE GetZone():THz;
BEGIN
    CODE(0A11AH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END GetZone;

PROCEDURE SetZone(hz:THz);
BEGIN
    SETREG(RA0,hz);
    CODE(0A01BH);
    MMError := OSErr(REGISTER(RD0));
END SetZone;

PROCEDURE SystemZone():THz; (* No trap macro *)
BEGIN
  RETURN(THz(SysZone))
END SystemZone;

PROCEDURE ApplicZone():THz; (* No trap macro *)
BEGIN
  RETURN(THz(ApplZone))
END ApplicZone;

(* Allocating and Releasing Relocatable Blocks *)

PROCEDURE NewHandle(logicalSize:Size):Handle;
BEGIN
    SETREG(RD0,logicalSize);
    CODE(0A122H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END NewHandle;

PROCEDURE DisposHandle(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A023H);
    MMError := OSErr(REGISTER(RD0));
END DisposHandle;

PROCEDURE GetHandleSize(h:Handle):Size;
BEGIN
    SETREG(RA0,h);
    CODE(0A025H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END GetHandleSize;

PROCEDURE SetHandleSize(h:Handle;newSize:Size);
BEGIN
    SETREG(RA0,h);
    SETREG(RD0,newSize);
    CODE(0A024H);
    MMError := OSErr(REGISTER(RD0));
END SetHandleSize;

PROCEDURE HandleZone(h:Handle):THz;
BEGIN
    SETREG(RA0,h);
    CODE(0A126H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END HandleZone;

PROCEDURE RecoverHandle(p:ADDRESS):Handle;
BEGIN
    SETREG(RA0,p);
    CODE(0A128H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END RecoverHandle;

PROCEDURE ReallocHandle(h:Handle;logicalSize:Size);
BEGIN
    SETREG(RA0,h);
    SETREG(RD0,logicalSize);
    CODE(0A127H);
    MMError := OSErr(REGISTER(RD0));
END ReallocHandle;

(* Allocating and Releasing Nonrelocatable Blocks *)

PROCEDURE NewPtr(logicalSize:Size):ADDRESS;
BEGIN
    SETREG(RD0,logicalSize);
    CODE(0A1EH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END NewPtr;

PROCEDURE DisposPtr(p:ADDRESS);
BEGIN
    SETREG(RA0,p);
    CODE(0A01FH);
    MMError := OSErr(REGISTER(RD0));
END DisposPtr;

PROCEDURE GetPtrSize(p:ADDRESS):Size;
BEGIN
    SETREG(RA0,p);
    CODE(0A021H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END GetPtrSize;

PROCEDURE SetPtrSize(p:ADDRESS;newSize:Size);
BEGIN
    SETREG(RA0,p);
    SETREG(RD0,newSize);
    CODE(0A020H);
    MMError := OSErr(REGISTER(RD0));
END SetPtrSize;

PROCEDURE PtrZone(p:ADDRESS):THz;
BEGIN
    SETREG(RA0,p);
    CODE(0A148H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END PtrZone;

(* Freeing Space in the Heap *)

PROCEDURE FreeMem():LONGINT;
BEGIN
    CODE(0A01CH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END FreeMem;

PROCEDURE MaxMem(VAR grow:Size):Size;
BEGIN
    CODE(0A01DH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END MaxMem;

PROCEDURE CompactMem(cbNeeded:Size):Size;
BEGIN
    SETREG(RD0,cbNeeded);
    CODE(0A04CH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END CompactMem;

PROCEDURE ResrvMem(cbNeeded:Size);
BEGIN
    SETREG(RD0,cbNeeded);
    CODE(0A040H);
    MMError := OSErr(REGISTER(RD0));
END ResrvMem;

PROCEDURE PurgeMem(cbNeeded:Size);
BEGIN
    SETREG(RD0,cbNeeded);
    CODE(0A04DH);
    MMError := OSErr(REGISTER(RD0));
END PurgeMem;

PROCEDURE EmptyHandle(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A02BH);
    MMError := OSErr(REGISTER(RD0));
END EmptyHandle;

(* Properties of Relocatable Blocks *)

PROCEDURE HLock(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A029H);
    MMError := OSErr(REGISTER(RD0));
END HLock;

PROCEDURE HUnlock(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A02AH);
    MMError := OSErr(REGISTER(RD0));
END HUnlock;

PROCEDURE HPurge(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A049H);
    MMError := OSErr(REGISTER(RD0));
END HPurge;

PROCEDURE HNoPurge(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A049H);
    MMError := OSErr(REGISTER(RD0));
END HNoPurge;

(* Grow Zone Operations *)
PROCEDURE SetGrowZone(growZone:ADDRESS);
BEGIN
    SETREG(RA0,growZone);
    CODE(0A04BH);
    MMError := OSErr(REGISTER(RD0));
END SetGrowZone;

PROCEDURE GZSaveHnd():Handle;	(* No trap macro *)
BEGIN
    RETURN(GZRootHnd)
END GZSaveHnd;

(* Miscellaneous Routines *)

PROCEDURE BlockMove(src,dst:ADDRESS;count:Size);
BEGIN
    SETREG(RA0,src);
    SETREG(RA1,dst);
    SETREG(RD0,count);
    CODE(0A02EH);
    MMError := OSErr(REGISTER(RD0));
END BlockMove;

PROCEDURE TopMem():ADDRESS; (* No trap macro *)
BEGIN
    RETURN(MemTop)
END TopMem;

PROCEDURE MoveHHi(h:Handle);
BEGIN
END MoveHHi;

PROCEDURE MemError():OSErr; (* No trap macro *)
BEGIN
    RETURN(MMError)
END MemError;

(* Grow Zone Function *)
END MemoryManager.
!Funky!Stuff!
echo x - MenuManager.MOD
cat >MenuManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MenuManager;
FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR;
FROM MacSYSTEM IMPORT LONGINT,Handle;
FROM PascalStrings IMPORT MakePascalString,MakeModulaString;
FROM QuickDraw IMPORT Point,Rect,Style;
FROM WindowManager IMPORT inMenuBar; (* Init WindowManager First *)
FROM ResourceManager IMPORT ResType,ParamResType;

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


PROCEDURE xNewMenu(menuID:INTEGER;menuTitle:ADDRESS):MenuHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A931H);
	CODE(RestoreA7);CODE(Return);
END xNewMenu;
PROCEDURE NewMenu(menuID:INTEGER;VAR menuTitle:ARRAY OF CHAR):MenuHandle;
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(menuTitle,Str);
	RETURN(xNewMenu(menuID,ADR(Str)))
END NewMenu;
PROCEDURE GetMenu(resourceID:INTEGER):MenuHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9BFH);
	CODE(RestoreA7);CODE(Return);
END GetMenu;
PROCEDURE DisposeMenu(theMenu:MenuHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A932H);
	CODE(RestoreA7);CODE(Return);
END DisposeMenu;

(*Forming the Menus*)
PROCEDURE xAppendMenu(theMenu:MenuHandle;data:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A933H);
	CODE(RestoreA7);CODE(Return);
END xAppendMenu;
PROCEDURE AppendMenu(theMenu:MenuHandle;VAR data:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(data,Str);
	xAppendMenu(theMenu,ADR(Str))
END AppendMenu;
PROCEDURE xAddResMenu(theMenu:MenuHandle;theType:LONGINT);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A94DH);
	CODE(RestoreA7);CODE(Return);
END xAddResMenu;
PROCEDURE AddResMenu(theMenu:MenuHandle;theType:ResType);
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	xAddResMenu(theMenu,x.param);
END AddResMenu;

PROCEDURE xInsertResMenu(theMenu:MenuHandle;theType:LONGINT;
	afterItem:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A951H);
	CODE(RestoreA7);CODE(Return);
END xInsertResMenu;
PROCEDURE InsertResMenu(theMenu:MenuHandle;theType:ResType;
	afterItem:INTEGER);
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	xInsertResMenu(theMenu,x.param,afterItem)
END InsertResMenu;

(*Forming the Menus*)
PROCEDURE InsertMenu(theMenu:MenuHandle;beforeID:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A935H);
	CODE(RestoreA7);CODE(Return);
END InsertMenu;
PROCEDURE DrawMenuBar;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A937H);
	CODE(RestoreA7);CODE(Return);
END DrawMenuBar;
PROCEDURE DeleteMenu(menuID:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A936H);
	CODE(RestoreA7);CODE(Return);
END DeleteMenu;
PROCEDURE ClearMenuBar;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A934H);
	CODE(RestoreA7);CODE(Return);
END ClearMenuBar;
PROCEDURE GetNewMBar(menuBarID:INTEGER):Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9C0H);
	CODE(RestoreA7);CODE(Return);
END GetNewMBar;
PROCEDURE GetMenuBar():Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93BH);
	CODE(RestoreA7);CODE(Return);
END GetMenuBar;
PROCEDURE SetMenuBar(menuList:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93CH);
	CODE(RestoreA7);CODE(Return);
END SetMenuBar;

(*Choosing from a menu*)
PROCEDURE xMenuSelect(startPt:LONGINT):LONGINT;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93DH);
	CODE(RestoreA7);CODE(Return);
END xMenuSelect;
PROCEDURE MenuSelect(startPt:Point):LONGINT;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xMenuSelect(startPt.param))
END MenuSelect;
PROCEDURE xMenuKey(ch:CARDINAL):LONGINT;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93EH);
	CODE(RestoreA7);CODE(Return);
END xMenuKey;
PROCEDURE MenuKey(ch:CHAR):LONGINT;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xMenuKey(ORD(ch)))
END MenuKey;
PROCEDURE HiliteMenu(menuID:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A938H);
	CODE(RestoreA7);CODE(Return);
END HiliteMenu;

(*Controlling Items' Appearance*)
PROCEDURE xSetItem(theMenu:MenuHandle;item:INTEGER;itemString:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A947H);
	CODE(RestoreA7);CODE(Return);
END xSetItem;
PROCEDURE SetItem(theMenu:MenuHandle;item:INTEGER;VAR itemString:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(itemString,Str);
	xSetItem(theMenu,item,ADR(Str))
END SetItem;

PROCEDURE xGetItem(theMenu:MenuHandle;item:INTEGER;itemString:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A946H);
	CODE(RestoreA7);CODE(Return);
END xGetItem;
PROCEDURE GetItem(theMenu:MenuHandle;item:INTEGER;VAR itemString:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	xGetItem(theMenu,item,ADR(Str));
	MakeModulaString(Str,itemString)
END GetItem;

PROCEDURE DisableItem(theMenu:MenuHandle;item:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93AH);
	CODE(RestoreA7);CODE(Return);
END DisableItem;
PROCEDURE EnableItem(theMenu:MenuHandle;item:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A939H);
	CODE(RestoreA7);CODE(Return);
END EnableItem;
PROCEDURE CheckItem(theMenu:MenuHandle;item:INTEGER;checked:BOOLEAN);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A945H);
	CODE(RestoreA7);CODE(Return);
END CheckItem;
PROCEDURE xSetItemMark(theMenu:MenuHandle;item:INTEGER;markChar:CARDINAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A944H);
	CODE(RestoreA7);CODE(Return);
END xSetItemMark;
PROCEDURE SetItemMark(theMenu:MenuHandle;item:INTEGER;markChar:CHAR);
(*$P+*)(*$S-*)
BEGIN
	xSetItemMark(theMenu,item,ORD(markChar))
END SetItemMark;
PROCEDURE GetItemMark(theMenu:MenuHandle;item:INTEGER;VAR markChar:CHAR);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A943H);
	CODE(RestoreA7);CODE(Return);
END GetItemMark;
PROCEDURE xSetItemIcon(theMenu:MenuHandle;item:INTEGER;icon:CARDINAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A940H);
	CODE(RestoreA7);CODE(Return);
END xSetItemIcon;
PROCEDURE SetItemIcon(theMenu:MenuHandle;item:INTEGER;icon:CHAR);
(*$P+*)(*$S-*)
BEGIN
	xSetItemIcon(theMenu,item,ORD(icon))
END SetItemIcon;
PROCEDURE GetItemIcon(theMenu:MenuHandle;item:INTEGER;VAR icon:CHAR);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93FH);
	CODE(RestoreA7);CODE(Return);
END GetItemIcon;
PROCEDURE SetItemStyle(theMenu:MenuHandle;item:INTEGER;chStyle:Style);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A942H);
	CODE(RestoreA7);CODE(Return);
END SetItemStyle;
PROCEDURE GetItemStyle (theMenu: MenuHandle;item:INTEGER; VAR chStyle:Style);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A941H);
	CODE(RestoreA7);CODE(Return);
END GetItemStyle;

(*Miscellaneous Routines*)
PROCEDURE CalcMenuSize(theMenu:MenuHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A948H);
	CODE(RestoreA7);CODE(Return);
END CalcMenuSize;
PROCEDURE CountMItems(theMenu:MenuHandle):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A950H);
	CODE(RestoreA7);CODE(Return);
END CountMItems;
PROCEDURE GetMHandle(menuID:INTEGER):MenuHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A949H);
	CODE(RestoreA7);CODE(Return);
END GetMHandle;
PROCEDURE FlashMenuBar(menuID:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A94CH);
	CODE(RestoreA7);CODE(Return);
END FlashMenuBar;
PROCEDURE SetMenuFlash(count:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A94AH);
	CODE(RestoreA7);CODE(Return);
END SetMenuFlash;

(*Menu Definition Procedure*)
BEGIN
	CODE(0A930H); (*InitMenus*)
END MenuManager.
!Funky!Stuff!
echo x - PascalStrings.MOD
cat >PascalStrings.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE PascalStrings;

PROCEDURE MakePascalString(VAR in: ARRAY OF CHAR; VAR out: ARRAY OF CHAR);
VAR
	i:CARDINAL;
(*$S-*)
(*$T-*)
BEGIN
	i := 0;
	WHILE ((i <= HIGH(in)) AND (i < HIGH(out)) AND (in[i] <> 0C)) DO
		out[i + 1]:=in[i];
		INC(i)
	END;
	out[0] := CHAR(i);
END MakePascalString;

PROCEDURE MakeModulaString(VAR in: ARRAY OF CHAR; VAR out: ARRAY OF CHAR);
VAR 
	i:CARDINAL;
(*$S-*)
BEGIN
	i := 0;
	WHILE ((i < ORD(in[0])) AND (i <= HIGH(out))) DO
		out[i]:=in[i + 1];
		INC(i)
	END;
 IF (i <= HIGH(out)) THEN
	 out[i] := 0C;
 END
END MakeModulaString;
PROCEDURE emptyPascalString(VAR string:ARRAY OF CHAR);
(*$S-*)
BEGIN
	string[0] := 0C
END emptyPascalString;
END PascalStrings.
!Funky!Stuff!
echo x - Pictures.MOD
cat >Pictures.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE Pictures;

FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
FROM QuickDraw IMPORT Rect;

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

(* Picture Routines *)
PROCEDURE GetPicture(picID:INTEGER):PicHandle;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(0A9BCH);
  CODE(RestoreA7);
  CODE(Return);
END GetPicture;

PROCEDURE OpenPicture (VAR picFrame:Rect):PicHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F3H);
	CODE(RestoreA7);CODE(Return);
END OpenPicture;

PROCEDURE	ClosePicture;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F4H);
	CODE(RestoreA7);CODE(Return);
END ClosePicture;

PROCEDURE	KillPicture	(thePicture:PicHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F5H);
	CODE(RestoreA7);CODE(Return);
END KillPicture;

PROCEDURE	DrawPicture	(thePicture:PicHandle;VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F6H);
	CODE(RestoreA7);CODE(Return);
END DrawPicture;

PROCEDURE	PicComment	(kind,dataSize:INTEGER;data:PicHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F2H);
	CODE(RestoreA7);CODE(Return);
END PicComment;

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

FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR,REGISTER;
FROM MacSYSTEM IMPORT LONGINT;
FROM QuickDraw IMPORT RgnHandle,RgnPtr,Region,Point,Rect,Pattern;
FROM PascalStrings IMPORT MakePascalString;

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

(* Region Calculations *)
PROCEDURE	NewRgn():RgnHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D8H);
	CODE(RestoreA7);CODE(Return);
END NewRgn;

PROCEDURE	OpenRgn;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DAH);
	CODE(RestoreA7);CODE(Return);
END OpenRgn;

PROCEDURE	CloseRgn	(theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DBH);
	CODE(RestoreA7);CODE(Return);
END CloseRgn;

PROCEDURE	DisposeRgn	(theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D9H);
	CODE(RestoreA7);CODE(Return);
END DisposeRgn;

PROCEDURE	SetEmptyRgn	(theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DDH);
	CODE(RestoreA7);CODE(Return);
END SetEmptyRgn;

PROCEDURE RectRgn (theRegion:RgnHandle;VAR theRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DFH);
	CODE(RestoreA7);CODE(Return);
END RectRgn;

PROCEDURE SetRectRgn (theRegion:RgnHandle;left,top,right,bottom:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DEH);
	CODE(RestoreA7);CODE(Return);
END SetRectRgn;

PROCEDURE	CopyRgn		(fromRegion,toRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DCH);
	CODE(RestoreA7);CODE(Return);
END CopyRgn;

PROCEDURE xPtInRgn (thePoint:LONGINT;theRegion:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E8H);
	CODE(RestoreA7);CODE(Return);
END xPtInRgn;

PROCEDURE PtInRgn (thePoint:Point;theRegion:RgnHandle):BOOLEAN;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xPtInRgn(thePoint.param,theRegion))
END PtInRgn;

PROCEDURE	RectInRgn	(VAR theRect:Rect;theRegion:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E9H);
	CODE(RestoreA7);CODE(Return);
END RectInRgn;

PROCEDURE OffsetRgn (theRegion:RgnHandle;hOffset,vOffset:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E0H);
	CODE(RestoreA7);CODE(Return);
END OffsetRgn;

PROCEDURE InsetRgn (theRegion:RgnHandle;hInset,vInset:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E1H);
	CODE(RestoreA7);CODE(Return);
END InsetRgn;

PROCEDURE EmptyRgn (theRegion:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E2H);
	CODE(RestoreA7);CODE(Return);
END EmptyRgn;

PROCEDURE	UnionRgn	(region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E5H);
	CODE(RestoreA7);CODE(Return);
END UnionRgn;

PROCEDURE	SectRgn		(region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E4H);
	CODE(RestoreA7);CODE(Return);
END SectRgn;

PROCEDURE	DiffRgn		(region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E6H);
	CODE(RestoreA7);CODE(Return);
END DiffRgn;

PROCEDURE	XOrRgn		(region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E7H);
	CODE(RestoreA7);CODE(Return);
END XOrRgn;

PROCEDURE EqualRgn (region1,region2:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E3H);
	CODE(RestoreA7);CODE(Return);
END EqualRgn;

PROCEDURE	MapRgn		(theRegion:RgnHandle;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8FBH);
	CODE(RestoreA7);CODE(Return);
END MapRgn;

(* Drawing Regions *)
PROCEDURE FrameRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D2H);
	CODE(RestoreA7);CODE(Return);
END FrameRgn;

PROCEDURE PaintRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D3H);
	CODE(RestoreA7);CODE(Return);
END PaintRgn;

PROCEDURE FillRgn (theRegion:RgnHandle;VAR fillPat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D6H);
	CODE(RestoreA7);CODE(Return);
END FillRgn;

PROCEDURE EraseRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D4H);
	CODE(RestoreA7);CODE(Return);
END EraseRgn;

PROCEDURE InvertRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D5H);
	CODE(RestoreA7);CODE(Return);
END InvertRgn;

END Regions.
!Funky!Stuff!
# The rest of this file is a shell script which will extract:
# MathLib0.MOD MathLib1.MOD MemoryManager.MOD MenuManager.MOD PascalStrings.MOD Pictures.MOD Regions.MOD
echo x - MathLib0.MOD
cat >MathLib0.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MathLib0;  (*Mathematical library 0 *)

FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
CONST
	GetRet 	= 0285FH;	(* MOVEA (A7)+,A4		*)
	Return 	= 04ED4H;	(* JMP	A4				*)
	SaveA7	= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)
	
	FSQRTX	=	00012H;
	FSINX		=	00018H;	(* ELEMS68K *)
	FCOSX		=	0001AH;	(* ELEMS68K *)
	FATANX	=	0001EH;	(* ELEMS68K *)
	FEXPX		=	00008H;	(* ELEMS68K *)
	FLNX		=	00000H;	(* ELEMS68K *)

	FTINTX		=	00016H;
	
	FX2S		=	01010H;
	FS2X		=	0100EH;
	FI2X		=	0200EH;
	FX2I		=	02010H;
	
	ELEMS68K	=	0A9ECH;
TYPE
	EXTENDED	=	RECORD
		Exp		:	INTEGER;
		Value	:	ARRAY [0..3] OF CARDINAL;
	END;

(*$S-*)
PROCEDURE DoFS2X(VAR Sgl : REAL; VAR Ext : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FS2X,-(SP)				*)	CODE(03F3CH);CODE(FS2X);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFS2X;

PROCEDURE DoFX2S(VAR Ext : EXTENDED; VAR Sgl : REAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FX2S,-(SP)				*)	CODE(03F3CH);CODE(FX2S);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFX2S;
(*$P+*)

PROCEDURE DoFX2I(VAR Ext : EXTENDED; VAR Sgl : INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FX2I,-(SP)				*)	CODE(03F3CH);CODE(FX2I);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFX2I;
(*$P+*)

PROCEDURE DoFI2X(VAR I : INTEGER; VAR Ext : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FI2X,-(SP)				*)	CODE(03F3CH);CODE(FI2X);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFI2X;
(*$P+*)

PROCEDURE DoFSQRTX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FSQRTX,-(SP)				*)	CODE(03F3CH);CODE(FSQRTX);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFSQRTX;
(*$P+*)

PROCEDURE sqrt   (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFSQRTX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END sqrt;

PROCEDURE DoFSINX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FSINX,-(SP)				*)	CODE(03F3CH);CODE(FSINX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFSINX;
(*$P+*)

PROCEDURE sin(x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFSINX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END sin;

PROCEDURE DoFCOSX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FCOSX,-(SP)				*)	CODE(03F3CH);CODE(FCOSX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFCOSX;
(*$P+*)

PROCEDURE cos    (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFCOSX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END cos;

PROCEDURE DoFATANX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FATANX,-(SP)				*)	CODE(03F3CH);CODE(FATANX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFATANX;
(*$P+*)

PROCEDURE arctan (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFATANX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END arctan;

PROCEDURE DoFEXPX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FEXPX,-(SP)				*)	CODE(03F3CH);CODE(FEXPX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFEXPX;
(*$P+*)

PROCEDURE exp    (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFEXPX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END exp;

PROCEDURE DoFLNX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FLNX,-(SP)				*)	CODE(03F3CH);CODE(FLNX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFLNX;
(*$P+*)

PROCEDURE ln    (x: REAL) : REAL;
VAR
	xt	:	EXTENDED;
BEGIN
	DoFS2X(x,xt);
	DoFLNX(xt);
	DoFX2S(xt,x);
	RETURN(x)
END ln;

PROCEDURE DoFTINTX(VAR Dst : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FTINTX,-(SP)				*)	CODE(03F3CH);CODE(FTINTX);
(*	_ELEMS68K	; A9EC				*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END DoFTINTX;
(*$P+*)

PROCEDURE entier (x: REAL) : INTEGER;
VAR
	xt	:	EXTENDED;
	i	:	INTEGER;
BEGIN
	DoFS2X(x,xt);
	DoFTINTX(xt);
	DoFX2I(xt,i);
	RETURN(i)
END entier;

PROCEDURE real   (x: INTEGER) : REAL;
VAR
	xt	:	EXTENDED;
	r	:	REAL;
BEGIN
	DoFI2X(x,xt);
	DoFX2S(xt,r);
	RETURN(r)
END real;

END MathLib0.





!Funky!Stuff!
echo x - MathLib1.MOD
cat >MathLib1.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MathLib1;  (* Math. library 1 *)
(* additional mathematical functions*)

(* M. Schneider  4. Juli 1983 *)

FROM SYSTEM IMPORT ADDRESS,CODE,ADR,WORD;
CONST
	GetRet 	= 0285FH;	(* MOVEA (A7)+,A4		*)
	Return 	= 04ED4H;	(* JMP	A4				*)
	SaveA7	= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)
		
	FTINTX		=	00016H;
	
	FX2S		=	01010H;
	FS2X		=	0100EH;
	FI2X		=	0200EH;
	FX2I		=	02010H;
	
	FLOG2X	=	00002H;
	FEXP2X	=	0000AH;
	FTANX		=	0001CH;
	FRANDX	=	00020H;
	FSCALBX	=	00018H;
	(* scalb(I,X) : X *)
	
	pi			=	3.1415926536;
	
	ELEMS68K	=	0A9ECH;
	FP68K		=	0A9EBH;

TYPE
	EXTENDED	=	RECORD
		Exp		:	INTEGER;
		Value	:	ARRAY [0..3] OF CARDINAL;
	END;

PROCEDURE ELEMS68K2(VAR src,dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	_ELEMS68K	; A9EB					*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END ELEMS68K2;

PROCEDURE ELEMS68K1(VAR dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	_ELEMS68K	; A9EB			*)	CODE(ELEMS68K);
	CODE(RestoreA7);CODE(Return);
END ELEMS68K1;

PROCEDURE FP68K2(VAR src,dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	_FP68K	; A9EB					*)	CODE(FP68K);
	CODE(RestoreA7);CODE(Return);
END FP68K2;

PROCEDURE FP68K1(VAR dst:EXTENDED; code:WORD);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	_FP68K	; A9EB					*)	CODE(FP68K);
	CODE(RestoreA7);CODE(Return);
END FP68K1;

PROCEDURE DoFS2X(VAR Sgl : REAL; VAR Ext : EXTENDED);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FS2X,-(SP)				*)	CODE(03F3CH);CODE(FS2X);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFS2X;

PROCEDURE DoFX2S(VAR Ext : EXTENDED; VAR Sgl : REAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FX2S,-(SP)				*)	CODE(03F3CH);CODE(FX2S);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END DoFX2S;
(*$P+*)(*$S-*)

PROCEDURE exp2 ( x: REAL ): REAL;
VAR
	p	:	EXTENDED;
BEGIN
	DoFS2X(x,p);
	ELEMS68K1(p,FEXP2X);
	DoFX2S(p,x);
END exp2;

PROCEDURE log2 ( x: REAL ): REAL;
VAR
	p	:	EXTENDED;
BEGIN
	DoFS2X(x,p);
	ELEMS68K1(p,FLOG2X);
	DoFX2S(p,x);
END log2;

PROCEDURE tan ( x: REAL ): REAL;
VAR
	p	:	EXTENDED;
BEGIN
	DoFS2X(x,p);
	ELEMS68K1(p,FTANX);
	DoFX2S(p,x);
END tan;

VAR 
	Seed:EXTENDED;
	Convert:REAL;

PROCEDURE scalb(VAR i:INTEGER;VAR x:EXTENDED);	
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
(*	MOVE	#FSCALBX,-(SP)			*)	CODE(03F3CH);CODE(FSCALBX);
(*	_FP68K	; A9EB					*)	CODE(0A9EBH);
	CODE(RestoreA7);CODE(Return);
END scalb;
(*$P+*)
PROCEDURE random(): REAL;
            (* range: 0.0 <= random < 1.0 *)
VAR
	p	:	EXTENDED;
	i	:	INTEGER;
BEGIN
	ELEMS68K1(p,FRANDX);
	i := 1;
	scalb(i,p);
	DoFX2S(p,Convert);
	RETURN(Convert);
END random;

PROCEDURE setrandom( x0: REAL );
BEGIN
	DoFS2X(x0,Seed);
END setrandom;

PROCEDURE PI(): REAL;
BEGIN
	RETURN(pi)
END PI;

BEGIN
	 Convert := 0.0;
	 DoFS2X(Convert,Seed);
END MathLib1.

!Funky!Stuff!
echo x - MemoryManager.MOD
cat >MemoryManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MemoryManager;
FROM SYSTEM IMPORT ADDRESS,CODE,ADR,REGISTER,SETREG;
FROM MacSYSTEM IMPORT Handle,LONGINT,OSErr;

CONST
    GetRet 	= 0285FH;	(* MOVEA (A7)+,A4	*)
    Return	= 04ED4H;	(* JMP	A4		*)
    SaveA7	= 0264FH;	(* MOVEA A7,A3	*)
    RestoreA7	= 02E4BH;	(* MOVEA A3,A7	*)
    
    RD0 =   0;	RA0 =	8;
    RD1	=   1;  RA1 =	9;
    RD2 =   2;	RA2 =	0AH;
    RD3 =   3;	RA3 =	0BH;
    RD4 =   4;	RA4 =	0CH;
    RD5 =   5;	RA5 =	0DH;
    RD6 =   6;	RA6 =	0EH;
    RD7 =   7;	RA7 =	0FH;

VAR
    MMError:OSErr;
    
(* Routines *)

(* Initialization and Allocation *)

PROCEDURE InitApplZone;
(*$S-*)
BEGIN
    CODE(0A20CH);
    MMError := OSErr(REGISTER(RD0));
END InitApplZone;

PROCEDURE SetApplBase(startPtr:ADDRESS);
(*$S-*)
BEGIN
    SETREG(RA0,startPtr);
    CODE(0A857H);
    MMError := OSErr(REGISTER(RD0));
END SetApplBase;

PROCEDURE InitZone(pGrowZone:ADDRESS;cMoreMasters:INTEGER;
    limitPtr,startPtr:ADDRESS);
BEGIN
    SETREG(RA0,ADR(startPtr));
    MMError := OSErr(REGISTER(RD0));
END InitZone;

PROCEDURE GetApplLimit():ADDRESS;
(*$P+*)(*$S-*)
BEGIN
    RETURN(ApplLimit)
END GetApplLimit;
    
PROCEDURE SetApplLimit(zoneLimit:ADDRESS);
BEGIN
    SETREG(RA0,zoneLimit);
    CODE(0A02DH);
    MMError := OSErr(REGISTER(RD0));
END SetApplLimit;

PROCEDURE MaxApplZone; (* No trap Macro *)
(*$P+*)
BEGIN
END MaxApplZone;

PROCEDURE MoreMasters;
BEGIN
    CODE(0A036H);
    MMError := OSErr(REGISTER(RD0));
END MoreMasters;

(* Heap Zone Access *)

PROCEDURE GetZone():THz;
BEGIN
    CODE(0A11AH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END GetZone;

PROCEDURE SetZone(hz:THz);
BEGIN
    SETREG(RA0,hz);
    CODE(0A01BH);
    MMError := OSErr(REGISTER(RD0));
END SetZone;

PROCEDURE SystemZone():THz; (* No trap macro *)
BEGIN
  RETURN(THz(SysZone))
END SystemZone;

PROCEDURE ApplicZone():THz; (* No trap macro *)
BEGIN
  RETURN(THz(ApplZone))
END ApplicZone;

(* Allocating and Releasing Relocatable Blocks *)

PROCEDURE NewHandle(logicalSize:Size):Handle;
BEGIN
    SETREG(RD0,logicalSize);
    CODE(0A122H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END NewHandle;

PROCEDURE DisposHandle(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A023H);
    MMError := OSErr(REGISTER(RD0));
END DisposHandle;

PROCEDURE GetHandleSize(h:Handle):Size;
BEGIN
    SETREG(RA0,h);
    CODE(0A025H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END GetHandleSize;

PROCEDURE SetHandleSize(h:Handle;newSize:Size);
BEGIN
    SETREG(RA0,h);
    SETREG(RD0,newSize);
    CODE(0A024H);
    MMError := OSErr(REGISTER(RD0));
END SetHandleSize;

PROCEDURE HandleZone(h:Handle):THz;
BEGIN
    SETREG(RA0,h);
    CODE(0A126H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END HandleZone;

PROCEDURE RecoverHandle(p:ADDRESS):Handle;
BEGIN
    SETREG(RA0,p);
    CODE(0A128H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END RecoverHandle;

PROCEDURE ReallocHandle(h:Handle;logicalSize:Size);
BEGIN
    SETREG(RA0,h);
    SETREG(RD0,logicalSize);
    CODE(0A127H);
    MMError := OSErr(REGISTER(RD0));
END ReallocHandle;

(* Allocating and Releasing Nonrelocatable Blocks *)

PROCEDURE NewPtr(logicalSize:Size):ADDRESS;
BEGIN
    SETREG(RD0,logicalSize);
    CODE(0A1EH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END NewPtr;

PROCEDURE DisposPtr(p:ADDRESS);
BEGIN
    SETREG(RA0,p);
    CODE(0A01FH);
    MMError := OSErr(REGISTER(RD0));
END DisposPtr;

PROCEDURE GetPtrSize(p:ADDRESS):Size;
BEGIN
    SETREG(RA0,p);
    CODE(0A021H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END GetPtrSize;

PROCEDURE SetPtrSize(p:ADDRESS;newSize:Size);
BEGIN
    SETREG(RA0,p);
    SETREG(RD0,newSize);
    CODE(0A020H);
    MMError := OSErr(REGISTER(RD0));
END SetPtrSize;

PROCEDURE PtrZone(p:ADDRESS):THz;
BEGIN
    SETREG(RA0,p);
    CODE(0A148H);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RA0))
END PtrZone;

(* Freeing Space in the Heap *)

PROCEDURE FreeMem():LONGINT;
BEGIN
    CODE(0A01CH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END FreeMem;

PROCEDURE MaxMem(VAR grow:Size):Size;
BEGIN
    CODE(0A01DH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END MaxMem;

PROCEDURE CompactMem(cbNeeded:Size):Size;
BEGIN
    SETREG(RD0,cbNeeded);
    CODE(0A04CH);
    MMError := OSErr(REGISTER(RD0));
    RETURN(REGISTER(RD0))
END CompactMem;

PROCEDURE ResrvMem(cbNeeded:Size);
BEGIN
    SETREG(RD0,cbNeeded);
    CODE(0A040H);
    MMError := OSErr(REGISTER(RD0));
END ResrvMem;

PROCEDURE PurgeMem(cbNeeded:Size);
BEGIN
    SETREG(RD0,cbNeeded);
    CODE(0A04DH);
    MMError := OSErr(REGISTER(RD0));
END PurgeMem;

PROCEDURE EmptyHandle(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A02BH);
    MMError := OSErr(REGISTER(RD0));
END EmptyHandle;

(* Properties of Relocatable Blocks *)

PROCEDURE HLock(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A029H);
    MMError := OSErr(REGISTER(RD0));
END HLock;

PROCEDURE HUnlock(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A02AH);
    MMError := OSErr(REGISTER(RD0));
END HUnlock;

PROCEDURE HPurge(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A049H);
    MMError := OSErr(REGISTER(RD0));
END HPurge;

PROCEDURE HNoPurge(h:Handle);
BEGIN
    SETREG(RA0,h);
    CODE(0A049H);
    MMError := OSErr(REGISTER(RD0));
END HNoPurge;

(* Grow Zone Operations *)
PROCEDURE SetGrowZone(growZone:ADDRESS);
BEGIN
    SETREG(RA0,growZone);
    CODE(0A04BH);
    MMError := OSErr(REGISTER(RD0));
END SetGrowZone;

PROCEDURE GZSaveHnd():Handle;	(* No trap macro *)
BEGIN
    RETURN(GZRootHnd)
END GZSaveHnd;

(* Miscellaneous Routines *)

PROCEDURE BlockMove(src,dst:ADDRESS;count:Size);
BEGIN
    SETREG(RA0,src);
    SETREG(RA1,dst);
    SETREG(RD0,count);
    CODE(0A02EH);
    MMError := OSErr(REGISTER(RD0));
END BlockMove;

PROCEDURE TopMem():ADDRESS; (* No trap macro *)
BEGIN
    RETURN(MemTop)
END TopMem;

PROCEDURE MoveHHi(h:Handle);
BEGIN
END MoveHHi;

PROCEDURE MemError():OSErr; (* No trap macro *)
BEGIN
    RETURN(MMError)
END MemError;

(* Grow Zone Function *)
END MemoryManager.
!Funky!Stuff!
echo x - MenuManager.MOD
cat >MenuManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE MenuManager;
FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR;
FROM MacSYSTEM IMPORT LONGINT,Handle;
FROM PascalStrings IMPORT MakePascalString,MakeModulaString;
FROM QuickDraw IMPORT Point,Rect,Style;
FROM WindowManager IMPORT inMenuBar; (* Init WindowManager First *)
FROM ResourceManager IMPORT ResType,ParamResType;

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


PROCEDURE xNewMenu(menuID:INTEGER;menuTitle:ADDRESS):MenuHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A931H);
	CODE(RestoreA7);CODE(Return);
END xNewMenu;
PROCEDURE NewMenu(menuID:INTEGER;VAR menuTitle:ARRAY OF CHAR):MenuHandle;
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(menuTitle,Str);
	RETURN(xNewMenu(menuID,ADR(Str)))
END NewMenu;
PROCEDURE GetMenu(resourceID:INTEGER):MenuHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9BFH);
	CODE(RestoreA7);CODE(Return);
END GetMenu;
PROCEDURE DisposeMenu(theMenu:MenuHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A932H);
	CODE(RestoreA7);CODE(Return);
END DisposeMenu;

(*Forming the Menus*)
PROCEDURE xAppendMenu(theMenu:MenuHandle;data:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A933H);
	CODE(RestoreA7);CODE(Return);
END xAppendMenu;
PROCEDURE AppendMenu(theMenu:MenuHandle;VAR data:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(data,Str);
	xAppendMenu(theMenu,ADR(Str))
END AppendMenu;
PROCEDURE xAddResMenu(theMenu:MenuHandle;theType:LONGINT);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A94DH);
	CODE(RestoreA7);CODE(Return);
END xAddResMenu;
PROCEDURE AddResMenu(theMenu:MenuHandle;theType:ResType);
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	xAddResMenu(theMenu,x.param);
END AddResMenu;

PROCEDURE xInsertResMenu(theMenu:MenuHandle;theType:LONGINT;
	afterItem:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A951H);
	CODE(RestoreA7);CODE(Return);
END xInsertResMenu;
PROCEDURE InsertResMenu(theMenu:MenuHandle;theType:ResType;
	afterItem:INTEGER);
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	xInsertResMenu(theMenu,x.param,afterItem)
END InsertResMenu;

(*Forming the Menus*)
PROCEDURE InsertMenu(theMenu:MenuHandle;beforeID:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A935H);
	CODE(RestoreA7);CODE(Return);
END InsertMenu;
PROCEDURE DrawMenuBar;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A937H);
	CODE(RestoreA7);CODE(Return);
END DrawMenuBar;
PROCEDURE DeleteMenu(menuID:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A936H);
	CODE(RestoreA7);CODE(Return);
END DeleteMenu;
PROCEDURE ClearMenuBar;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A934H);
	CODE(RestoreA7);CODE(Return);
END ClearMenuBar;
PROCEDURE GetNewMBar(menuBarID:INTEGER):Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9C0H);
	CODE(RestoreA7);CODE(Return);
END GetNewMBar;
PROCEDURE GetMenuBar():Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93BH);
	CODE(RestoreA7);CODE(Return);
END GetMenuBar;
PROCEDURE SetMenuBar(menuList:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93CH);
	CODE(RestoreA7);CODE(Return);
END SetMenuBar;

(*Choosing from a menu*)
PROCEDURE xMenuSelect(startPt:LONGINT):LONGINT;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93DH);
	CODE(RestoreA7);CODE(Return);
END xMenuSelect;
PROCEDURE MenuSelect(startPt:Point):LONGINT;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xMenuSelect(startPt.param))
END MenuSelect;
PROCEDURE xMenuKey(ch:CARDINAL):LONGINT;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93EH);
	CODE(RestoreA7);CODE(Return);
END xMenuKey;
PROCEDURE MenuKey(ch:CHAR):LONGINT;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xMenuKey(ORD(ch)))
END MenuKey;
PROCEDURE HiliteMenu(menuID:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A938H);
	CODE(RestoreA7);CODE(Return);
END HiliteMenu;

(*Controlling Items' Appearance*)
PROCEDURE xSetItem(theMenu:MenuHandle;item:INTEGER;itemString:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A947H);
	CODE(RestoreA7);CODE(Return);
END xSetItem;
PROCEDURE SetItem(theMenu:MenuHandle;item:INTEGER;VAR itemString:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(itemString,Str);
	xSetItem(theMenu,item,ADR(Str))
END SetItem;

PROCEDURE xGetItem(theMenu:MenuHandle;item:INTEGER;itemString:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A946H);
	CODE(RestoreA7);CODE(Return);
END xGetItem;
PROCEDURE GetItem(theMenu:MenuHandle;item:INTEGER;VAR itemString:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	xGetItem(theMenu,item,ADR(Str));
	MakeModulaString(Str,itemString)
END GetItem;

PROCEDURE DisableItem(theMenu:MenuHandle;item:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93AH);
	CODE(RestoreA7);CODE(Return);
END DisableItem;
PROCEDURE EnableItem(theMenu:MenuHandle;item:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A939H);
	CODE(RestoreA7);CODE(Return);
END EnableItem;
PROCEDURE CheckItem(theMenu:MenuHandle;item:INTEGER;checked:BOOLEAN);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A945H);
	CODE(RestoreA7);CODE(Return);
END CheckItem;
PROCEDURE xSetItemMark(theMenu:MenuHandle;item:INTEGER;markChar:CARDINAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A944H);
	CODE(RestoreA7);CODE(Return);
END xSetItemMark;
PROCEDURE SetItemMark(theMenu:MenuHandle;item:INTEGER;markChar:CHAR);
(*$P+*)(*$S-*)
BEGIN
	xSetItemMark(theMenu,item,ORD(markChar))
END SetItemMark;
PROCEDURE GetItemMark(theMenu:MenuHandle;item:INTEGER;VAR markChar:CHAR);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A943H);
	CODE(RestoreA7);CODE(Return);
END GetItemMark;
PROCEDURE xSetItemIcon(theMenu:MenuHandle;item:INTEGER;icon:CARDINAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A940H);
	CODE(RestoreA7);CODE(Return);
END xSetItemIcon;
PROCEDURE SetItemIcon(theMenu:MenuHandle;item:INTEGER;icon:CHAR);
(*$P+*)(*$S-*)
BEGIN
	xSetItemIcon(theMenu,item,ORD(icon))
END SetItemIcon;
PROCEDURE GetItemIcon(theMenu:MenuHandle;item:INTEGER;VAR icon:CHAR);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A93FH);
	CODE(RestoreA7);CODE(Return);
END GetItemIcon;
PROCEDURE SetItemStyle(theMenu:MenuHandle;item:INTEGER;chStyle:Style);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A942H);
	CODE(RestoreA7);CODE(Return);
END SetItemStyle;
PROCEDURE GetItemStyle (theMenu: MenuHandle;item:INTEGER; VAR chStyle:Style);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A941H);
	CODE(RestoreA7);CODE(Return);
END GetItemStyle;

(*Miscellaneous Routines*)
PROCEDURE CalcMenuSize(theMenu:MenuHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A948H);
	CODE(RestoreA7);CODE(Return);
END CalcMenuSize;
PROCEDURE CountMItems(theMenu:MenuHandle):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A950H);
	CODE(RestoreA7);CODE(Return);
END CountMItems;
PROCEDURE GetMHandle(menuID:INTEGER):MenuHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A949H);
	CODE(RestoreA7);CODE(Return);
END GetMHandle;
PROCEDURE FlashMenuBar(menuID:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A94CH);
	CODE(RestoreA7);CODE(Return);
END FlashMenuBar;
PROCEDURE SetMenuFlash(count:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A94AH);
	CODE(RestoreA7);CODE(Return);
END SetMenuFlash;

(*Menu Definition Procedure*)
BEGIN
	CODE(0A930H); (*InitMenus*)
END MenuManager.
!Funky!Stuff!
echo x - PascalStrings.MOD
cat >PascalStrings.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE PascalStrings;

PROCEDURE MakePascalString(VAR in: ARRAY OF CHAR; VAR out: ARRAY OF CHAR);
VAR
	i:CARDINAL;
(*$S-*)
(*$T-*)
BEGIN
	i := 0;
	WHILE ((i <= HIGH(in)) AND (i < HIGH(out)) AND (in[i] <> 0C)) DO
		out[i + 1]:=in[i];
		INC(i)
	END;
	out[0] := CHAR(i);
END MakePascalString;

PROCEDURE MakeModulaString(VAR in: ARRAY OF CHAR; VAR out: ARRAY OF CHAR);
VAR 
	i:CARDINAL;
(*$S-*)
BEGIN
	i := 0;
	WHILE ((i < ORD(in[0])) AND (i <= HIGH(out))) DO
		out[i]:=in[i + 1];
		INC(i)
	END;
 IF (i <= HIGH(out)) THEN
	 out[i] := 0C;
 END
END MakeModulaString;
PROCEDURE emptyPascalString(VAR string:ARRAY OF CHAR);
(*$S-*)
BEGIN
	string[0] := 0C
END emptyPascalString;
END PascalStrings.
!Funky!Stuff!
echo x - Pictures.MOD
cat >Pictures.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE Pictures;

FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
FROM QuickDraw IMPORT Rect;

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

(* Picture Routines *)
PROCEDURE GetPicture(picID:INTEGER):PicHandle;
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(0A9BCH);
  CODE(RestoreA7);
  CODE(Return);
END GetPicture;

PROCEDURE OpenPicture (VAR picFrame:Rect):PicHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F3H);
	CODE(RestoreA7);CODE(Return);
END OpenPicture;

PROCEDURE	ClosePicture;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F4H);
	CODE(RestoreA7);CODE(Return);
END ClosePicture;

PROCEDURE	KillPicture	(thePicture:PicHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F5H);
	CODE(RestoreA7);CODE(Return);
END KillPicture;

PROCEDURE	DrawPicture	(thePicture:PicHandle;VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F6H);
	CODE(RestoreA7);CODE(Return);
END DrawPicture;

PROCEDURE	PicComment	(kind,dataSize:INTEGER;data:PicHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F2H);
	CODE(RestoreA7);CODE(Return);
END PicComment;

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

FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR,REGISTER;
FROM MacSYSTEM IMPORT LONGINT;
FROM QuickDraw IMPORT RgnHandle,RgnPtr,Region,Point,Rect,Pattern;
FROM PascalStrings IMPORT MakePascalString;

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

(* Region Calculations *)
PROCEDURE	NewRgn():RgnHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D8H);
	CODE(RestoreA7);CODE(Return);
END NewRgn;

PROCEDURE	OpenRgn;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DAH);
	CODE(RestoreA7);CODE(Return);
END OpenRgn;

PROCEDURE	CloseRgn	(theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DBH);
	CODE(RestoreA7);CODE(Return);
END CloseRgn;

PROCEDURE	DisposeRgn	(theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D9H);
	CODE(RestoreA7);CODE(Return);
END DisposeRgn;

PROCEDURE	SetEmptyRgn	(theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DDH);
	CODE(RestoreA7);CODE(Return);
END SetEmptyRgn;

PROCEDURE RectRgn (theRegion:RgnHandle;VAR theRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DFH);
	CODE(RestoreA7);CODE(Return);
END RectRgn;

PROCEDURE SetRectRgn (theRegion:RgnHandle;left,top,right,bottom:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DEH);
	CODE(RestoreA7);CODE(Return);
END SetRectRgn;

PROCEDURE	CopyRgn		(fromRegion,toRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8DCH);
	CODE(RestoreA7);CODE(Return);
END CopyRgn;

PROCEDURE xPtInRgn (thePoint:LONGINT;theRegion:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E8H);
	CODE(RestoreA7);CODE(Return);
END xPtInRgn;

PROCEDURE PtInRgn (thePoint:Point;theRegion:RgnHandle):BOOLEAN;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xPtInRgn(thePoint.param,theRegion))
END PtInRgn;

PROCEDURE	RectInRgn	(VAR theRect:Rect;theRegion:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E9H);
	CODE(RestoreA7);CODE(Return);
END RectInRgn;

PROCEDURE OffsetRgn (theRegion:RgnHandle;hOffset,vOffset:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E0H);
	CODE(RestoreA7);CODE(Return);
END OffsetRgn;

PROCEDURE InsetRgn (theRegion:RgnHandle;hInset,vInset:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E1H);
	CODE(RestoreA7);CODE(Return);
END InsetRgn;

PROCEDURE EmptyRgn (theRegion:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E2H);
	CODE(RestoreA7);CODE(Return);
END EmptyRgn;

PROCEDURE	UnionRgn	(region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E5H);
	CODE(RestoreA7);CODE(Return);
END UnionRgn;

PROCEDURE	SectRgn		(region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E4H);
	CODE(RestoreA7);CODE(Return);
END SectRgn;

PROCEDURE	DiffRgn		(region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E6H);
	CODE(RestoreA7);CODE(Return);
END DiffRgn;

PROCEDURE	XOrRgn		(region1,region2,resultRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E7H);
	CODE(RestoreA7);CODE(Return);
END XOrRgn;

PROCEDURE EqualRgn (region1,region2:RgnHandle):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8E3H);
	CODE(RestoreA7);CODE(Return);
END EqualRgn;

PROCEDURE	MapRgn		(theRegion:RgnHandle;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8FBH);
	CODE(RestoreA7);CODE(Return);
END MapRgn;

(* Drawing Regions *)
PROCEDURE FrameRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D2H);
	CODE(RestoreA7);CODE(Return);
END FrameRgn;

PROCEDURE PaintRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D3H);
	CODE(RestoreA7);CODE(Return);
END PaintRgn;

PROCEDURE FillRgn (theRegion:RgnHandle;VAR fillPat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D6H);
	CODE(RestoreA7);CODE(Return);
END FillRgn;

PROCEDURE EraseRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D4H);
	CODE(RestoreA7);CODE(Return);
END EraseRgn;

PROCEDURE InvertRgn (theRegion:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8D5H);
	CODE(RestoreA7);CODE(Return);
END InvertRgn;

END Regions.
!Funky!Stuff!