Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!linus!philabs!cmcl2!harvard!seismo!rochester!bullwinkle!uw-beaver!tikal!bobc
From: bobc@tikal.UUCP (Bob Campbell)
Newsgroups: net.sources.mac
Subject: ETHZ Standalone Implementation Modules (4 of 6)
Message-ID: <434@tikal.UUCP>
Date: Wed, 14-May-86 10:55:17 EDT
Article-I.D.: tikal.434
Posted: Wed May 14 10:55:17 1986
Date-Received: Sun, 18-May-86 11:35:25 EDT
Reply-To: bobc@tikal.UUCP (Bob Campbell)
Organization: Teltone Corp., Kirkland, WA
Lines: 4002

# The rest of this file is a shell script which will extract:
# QuickDraw.MOD ResourceManager.MOD SFPackage.MOD
echo x - QuickDraw.MOD
cat >QuickDraw.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE QuickDraw;
FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR,REGISTER;
FROM MacSYSTEM IMPORT LONGINT;
FROM PascalStrings IMPORT MakePascalString;
(*EXPORT QUALIFIED...*)
(* GrafPort Routines *)
CONST
    GetRet = 0285FH;    (* MOVEA (A7)+,A4       *)
    Return = 04ED4H;    (* JMP  A4              *)
    SaveA7      = 0264FH;   (* MOVEA A7,A3      *)
    RestoreA7   = 02E4BH;   (* MOVEA A3,A7      *)
    
PROCEDURE InitGraf (globalPtr: ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A86EH);
    CODE(RestoreA7);CODE(Return);
END InitGraf;
PROCEDURE OpenPort (port: GrafPtr);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A86FH);
    CODE(RestoreA7);CODE(Return);
END OpenPort;
PROCEDURE InitPort (port:GrafPtr);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A86DH);
    CODE(RestoreA7);CODE(Return);
END InitPort;
PROCEDURE ClosePort (port:GrafPtr);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A87DH);
    CODE(RestoreA7);CODE(Return);
END ClosePort;
PROCEDURE SetPort (port: GrafPtr);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A873H);
    CODE(RestoreA7);CODE(Return);
END SetPort;
PROCEDURE GetPort (VAR port: GrafPtr);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A874H);
    CODE(RestoreA7);CODE(Return);
END GetPort;
PROCEDURE GrafDevice (device: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A872H);
    CODE(RestoreA7);CODE(Return);
END GrafDevice;
PROCEDURE SetPortBits(VAR bm: BitMap);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A875H);
    CODE(RestoreA7);CODE(Return);
END SetPortBits;
PROCEDURE PortSize   (width,height: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A876H);
    CODE(RestoreA7);CODE(Return);
END PortSize;
PROCEDURE MovePortTo (leftGlobal,topGlobal: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A877H);
    CODE(RestoreA7);CODE(Return);
END MovePortTo;
PROCEDURE SetOrigin (h,v: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A878H);
    CODE(RestoreA7);CODE(Return);
END SetOrigin;
PROCEDURE SetClip (rgn:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A879H);
    CODE(RestoreA7);CODE(Return);
END SetClip;
PROCEDURE GetClip (rgn: RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A87AH);
    CODE(RestoreA7);CODE(Return);
END GetClip;
PROCEDURE ClipRect (VAR r:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A87BH);
    CODE(RestoreA7);CODE(Return);
END ClipRect;
PROCEDURE BackPat (VAR pat: Pattern);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A87CH);
    CODE(RestoreA7);CODE(Return);
END BackPat;

(* Line Routines *)
PROCEDURE HidePen;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A896H);
    CODE(RestoreA7);CODE(Return);
END HidePen;
PROCEDURE ShowPen;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A897H);
    CODE(RestoreA7);CODE(Return);
END ShowPen;
PROCEDURE GetPen(VAR pt:Point);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A89AH);
    CODE(RestoreA7);CODE(Return);
END GetPen;
PROCEDURE GetPenState(VAR pnState:PenState);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A898H);
    CODE(RestoreA7);CODE(Return);
END GetPenState;
PROCEDURE SetPenState(VAR pnState: PenState);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A899H);
    CODE(RestoreA7);CODE(Return);
END SetPenState;
PROCEDURE PenSize (width,height: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A89BH);
    CODE(RestoreA7);CODE(Return);
END PenSize;
PROCEDURE PenMode (mode: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A89CH);
    CODE(RestoreA7);CODE(Return);
END PenMode;
PROCEDURE PenPat (VAR pat: Pattern);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A89DH);
    CODE(RestoreA7);CODE(Return);
END PenPat;
PROCEDURE PenNormal;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A89EH);
    CODE(RestoreA7);CODE(Return);
END PenNormal;
PROCEDURE MoveTo (h,v: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A893H);
    CODE(RestoreA7);CODE(Return);
END MoveTo;
PROCEDURE Move (dh,dv: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A894H);
    CODE(RestoreA7);CODE(Return);
END Move;
PROCEDURE LineTo (h,v: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A891H);
    CODE(RestoreA7);CODE(Return);
END LineTo;
PROCEDURE Line (dh,dv: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A892H);
    CODE(RestoreA7);CODE(Return);
END Line;


(* Text Routines *)
PROCEDURE TextFont (font: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A887H);
    CODE(RestoreA7);CODE(Return);
END TextFont;
PROCEDURE TextFace (face: Style);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A888H);
    CODE(RestoreA7);CODE(Return);
END TextFace;
PROCEDURE TextMode (mode: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A889H);
    CODE(RestoreA7);CODE(Return);
END TextMode;
PROCEDURE TextSize (size: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A88AH);
    CODE(RestoreA7);CODE(Return);
END TextSize;
PROCEDURE SpaceExtra (extra: LONGINT);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A88EH);
    CODE(RestoreA7);CODE(Return);
END SpaceExtra;
PROCEDURE xDrawChar (ch: CARDINAL);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A883H);
    CODE(RestoreA7);CODE(Return);
END xDrawChar;
PROCEDURE DrawChar (ch: CHAR);
(*$P+*)(*$S-*)
BEGIN
    xDrawChar(ORD(ch))
END DrawChar;
PROCEDURE xDrawString   (s:ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A884H);
    CODE(RestoreA7);CODE(Return);
END xDrawString;
PROCEDURE DrawString   (VAR s:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR
    s1:ARRAY[0..255] OF CHAR;
BEGIN
    MakePascalString(s,s1);
    xDrawString(ADR(s1))
END DrawString;
PROCEDURE DrawText (textBuf: ADDRESS; firstByte,byteCount: INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A885H);
    CODE(RestoreA7);CODE(Return);
END DrawText;
PROCEDURE xCharWidth (ch: CARDINAL):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A88DH);
    CODE(RestoreA7);CODE(Return);
END xCharWidth;
PROCEDURE CharWidth    (ch: CHAR): INTEGER;
(*$P+*)(*$S-*)
BEGIN
    RETURN(xCharWidth(ORD(ch)));
END CharWidth;
PROCEDURE xStringWidth  (stringPtr:ADDRESS):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A88CH);
    CODE(RestoreA7);CODE(Return);
END xStringWidth;
PROCEDURE StringWidth  (VAR s:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
    MakePascalString(s,Str);
    RETURN(xStringWidth(ADR(Str)));
END StringWidth;

PROCEDURE TextWidth(textBuf:ADDRESS;firstByte,byteCount:INTEGER):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A886H);
    CODE(RestoreA7);CODE(Return);
END TextWidth;

(* Point Calculations *)
PROCEDURE xAddPt (src:LONGINT;VAR dst:Point);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A87EH);
    CODE(RestoreA7);CODE(Return);
END xAddPt;

PROCEDURE AddPt (src:Point;VAR dst:Point);
(*$P+*)(*$S-*)
BEGIN
    xAddPt(src.param,dst)
END AddPt;

PROCEDURE xSubPt (src:LONGINT;VAR dst:Point);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A87FH);
    CODE(RestoreA7);CODE(Return);
END xSubPt;
PROCEDURE SubPt(src:Point;VAR dst:Point);
(*$P+*)(*$S-*)
BEGIN
    xSubPt(src.param,dst)
END SubPt;
PROCEDURE SetPt (VAR pt: Point;h,v:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A880H);
    CODE(RestoreA7);CODE(Return);
END SetPt;
PROCEDURE xEqualPt (pt1,pt2:LONGINT) :BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A881H);
    CODE(RestoreA7);CODE(Return);
END xEqualPt;
PROCEDURE EqualPt (pt1,pt2: Point) :BOOLEAN;
(*$P+*)(*$S-*)
BEGIN
    RETURN(xEqualPt(pt1.param,pt2.param))
END EqualPt;
PROCEDURE ScalePt (VAR pt:Point;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8F8H);
    CODE(RestoreA7);CODE(Return);
END ScalePt;
PROCEDURE MapPt(VAR pt:Point;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8F9H);
    CODE(RestoreA7);CODE(Return);
END MapPt;
PROCEDURE LocalToGlobal(VAR pt:Point);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A870H);
    CODE(RestoreA7);CODE(Return);
END LocalToGlobal;
PROCEDURE GlobalToLocal(VAR pt:Point);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A871H);
    CODE(RestoreA7);CODE(Return);
END GlobalToLocal;

(* Rectangle Calculations *)
PROCEDURE   SetRect (VAR r:Rect;left,top,right,bottom:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8A7H);
    CODE(RestoreA7);CODE(Return);
END SetRect;
PROCEDURE EqualRect(VAR rect1,rect2:Rect):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8A6H);
    CODE(RestoreA7);CODE(Return);
END EqualRect;
PROCEDURE EmptyRect(VAR r:Rect):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8AEH);
    CODE(RestoreA7);CODE(Return);
END EmptyRect;

PROCEDURE OffsetRect(VAR r:Rect;dh,dv:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8A8H);
    CODE(RestoreA7);CODE(Return);
END OffsetRect;
PROCEDURE MapRect(VAR r:Rect;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8FAH);
    CODE(RestoreA7);CODE(Return);
END MapRect;
PROCEDURE InsetRect(VAR r:Rect;dh,dv:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8A9H);
    CODE(RestoreA7);CODE(Return);
END InsetRect;
PROCEDURE SectRect (VAR src1,src2:Rect;VAR dstRect:Rect):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8AAH);
    CODE(RestoreA7);CODE(Return);
END SectRect;
PROCEDURE UnionRect(VAR src1,src2:Rect;VAR dstRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8ABH);
    CODE(RestoreA7);CODE(Return);
END UnionRect;
PROCEDURE xPtInRect(pt: LONGINT;VAR dstRect:Rect):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8ADH);
    CODE(RestoreA7);CODE(Return);
END xPtInRect;
PROCEDURE PtInRect(pt: Point;dstRect:Rect):BOOLEAN;
(*$P+*)(*$S-*)
BEGIN
    RETURN(xPtInRect(pt.param,dstRect));
END PtInRect;

PROCEDURE   xPt2Rect (pt1,pt2:LONGINT;VAR dstRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8ACH);
    CODE(RestoreA7);CODE(Return);
END xPt2Rect;
PROCEDURE   Pt2Rect (pt1,pt2:Point;VAR dstRect:Rect);
(*$P+*)(*$S-*)
BEGIN
    xPt2Rect(pt1.param,pt2.param,dstRect)
END Pt2Rect;

(* Graphical Operations on Rectangles *)
PROCEDURE FrameRect  (VAR r: Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8A1H);
    CODE(RestoreA7);CODE(Return);
END FrameRect;
PROCEDURE PaintRect  (VAR r: Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8A2H);
    CODE(RestoreA7);CODE(Return);
END PaintRect;
PROCEDURE EraseRect  (VAR r: Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8A3H);
    CODE(RestoreA7);CODE(Return);
END EraseRect;
PROCEDURE InvertRect (VAR r: Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8A4H);
    CODE(RestoreA7);CODE(Return);
END InvertRect;
PROCEDURE FillRect   (VAR r: Rect;VAR  pat: Pattern);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8A5H);
    CODE(RestoreA7);CODE(Return);
END FillRect;

(* RoundRect Routines *)
PROCEDURE FrameRoundRect(VAR theRect:Rect;cornerWidth,cornerHeigth:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8B0H);
    CODE(RestoreA7);CODE(Return);
END FrameRoundRect;
PROCEDURE PaintRoundRect(VAR theRect:Rect;cornerWidth,cornerHeight:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8B1H);
    CODE(RestoreA7);CODE(Return);
END PaintRoundRect;
PROCEDURE FillRoundRect(VAR theRect:Rect;
        cornerWidth,cornerHeigth:INTEGER;
        VAR fillPat:Pattern);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8B4H);
    CODE(RestoreA7);CODE(Return);
END FillRoundRect;
PROCEDURE EraseRoundRect(VAR theRect:Rect;cornerWidth,cornerHeight:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8B2H);
    CODE(RestoreA7);CODE(Return);
END EraseRoundRect;
PROCEDURE InvertRoundRect(VAR theRect:Rect;cornerWidth,cornerHeigth:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8B3H);
    CODE(RestoreA7);CODE(Return);
END InvertRoundRect;

(* Drawing Ovals *)
PROCEDURE FrameOval(VAR inRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8B7H);
    CODE(RestoreA7);CODE(Return);
END FrameOval;
PROCEDURE PaintOval(VAR inRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8B8H);
    CODE(RestoreA7);CODE(Return);
END PaintOval;
PROCEDURE EraseOval(VAR inRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8B9H);
    CODE(RestoreA7);CODE(Return);
END EraseOval;
PROCEDURE InvertOval(VAR inRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8BAH);
    CODE(RestoreA7);CODE(Return);
END InvertOval;
PROCEDURE FillOval(VAR inRect:Rect;VAR pat:Pattern);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8BBH);
    CODE(RestoreA7);CODE(Return);
END FillOval;

(* Arc Routines *)
PROCEDURE FrameArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8BEH);
    CODE(RestoreA7);CODE(Return);
END FrameArc;
PROCEDURE PaintArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8BFH);
    CODE(RestoreA7);CODE(Return);
END PaintArc;
PROCEDURE FillArc(VAR inRect:Rect;
    startAngle,arcAngle:INTEGER;
    VAR fillpat:Pattern);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8C2H);
    CODE(RestoreA7);CODE(Return);
END FillArc;
PROCEDURE EraseArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8C0H);
    CODE(RestoreA7);CODE(Return);
END EraseArc;
PROCEDURE InvertArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8C1H);
    CODE(RestoreA7);CODE(Return);
END InvertArc;
PROCEDURE xPtToAngle(VAR inRect:Rect;P:LONGINT;VAR theAngle:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8C3H);
    CODE(RestoreA7);CODE(Return);
END xPtToAngle;
PROCEDURE PtToAngle (inRect:Rect;thePoint:Point;VAR theAngle:INTEGER);
(*$P+*)(*$S-*)
BEGIN
    xPtToAngle(inRect,thePoint.param,theAngle)
END PtToAngle;

(* Polygon Routines *)
PROCEDURE OpenPoly():PolyHandle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8CBH);
    CODE(RestoreA7);CODE(Return);
END OpenPoly;
PROCEDURE ClosePoly;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8CCH);
    CODE(RestoreA7);CODE(Return);
END ClosePoly;
PROCEDURE KillPoly(thePolygon:PolyHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8CDH);
    CODE(RestoreA7);CODE(Return);
END KillPoly;
PROCEDURE OffsetPoly(thePolygon:PolyHandle;hOffset,vOffset:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8CEH);
    CODE(RestoreA7);CODE(Return);
END OffsetPoly;
PROCEDURE MapPoly (thePolygon:PolyHandle;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8FCH);
    CODE(RestoreA7);CODE(Return);
END MapPoly;
PROCEDURE FramePoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8C6H);
    CODE(RestoreA7);CODE(Return);
END FramePoly;
PROCEDURE PaintPoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8C7H);
    CODE(RestoreA7);CODE(Return);
END PaintPoly;
PROCEDURE FillPoly (thePolygon:PolyHandle;VAR fillPat:Pattern);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8CAH);
    CODE(RestoreA7);CODE(Return);
END FillPoly;
PROCEDURE ErasePoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8C8H);
    CODE(RestoreA7);CODE(Return);
END ErasePoly;
PROCEDURE InvertPoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8C9H);
    CODE(RestoreA7);CODE(Return);
END InvertPoly;

(* Graphical Operations on BitMaps *)
PROCEDURE ScrollRect(VAR dstRect:Rect;dh,dv:INTEGER;updateRgn:RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8EFH);
    CODE(RestoreA7);CODE(Return);
END ScrollRect;
PROCEDURE CopyBits  (VAR srcBits,dstBits: BitMap;
                     VAR srcRect,dstRect: Rect;
                     mode:            INTEGER;
                     maskRgn:         RgnHandle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A8ECH);
    CODE(RestoreA7);CODE(Return);
END CopyBits;
(* later...
PROCEDURE SetStdProcs
PROCEDURE StdText
PROCEDURE StdLine
PROCEDURE StdRect
PROCEDURE StdRRect
PROCEDURE StdOval
PROCEDURE StdArc
PROCEDURE StdPoly
PROCEDURE StdRgn
PROCEDURE StdBits
PROCEDURE StdComment
PROCEDURE StdTxMeas
PROCEDURE StdGetPic
PROCEDURE StdPutPic
*)
(* Misc Utility Routines *)
PROCEDURE GetPixel(h,v:INTEGER):BOOLEAN;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A865H);
    CODE(RestoreA7);CODE(Return);
END GetPixel;
PROCEDURE ForeColor (color:LONGINT);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A862H);
    CODE(RestoreA7);CODE(Return);
END ForeColor;
PROCEDURE BackColor (color:LONGINT);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A863H);
    CODE(RestoreA7);CODE(Return);
END BackColor;
PROCEDURE ColorBit (whichBit:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A864H);
    CODE(RestoreA7);CODE(Return);
END ColorBit;

BEGIN
    InitGraf(ADR(thePort));
END QuickDraw.
!Funky!Stuff!
echo x - ResourceManager.MOD
cat >ResourceManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE ResourceManager;
FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
FROM MacSYSTEM IMPORT LONGINT,Handle;
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 *)


(* Opening and Closing Resource Files *)
PROCEDURE xCreateResFile(fileName:ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9B1H);
    CODE(RestoreA7);CODE(Return);
END xCreateResFile;
PROCEDURE CreateResFile(VAR fileName:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
    MakePascalString(fileName,Str);
    xCreateResFile(ADR(Str))
END CreateResFile;

PROCEDURE xOpenResFile(fileName:ADDRESS):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A997H);
    CODE(RestoreA7);CODE(Return);
END xOpenResFile;
PROCEDURE OpenResFile(VAR fileName:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
    MakePascalString(fileName,Str);
    RETURN(xOpenResFile(ADR(Str)))
END OpenResFile;

PROCEDURE CloseResFile(refNum:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A99AH);
    CODE(RestoreA7);CODE(Return);
END CloseResFile;

(* Checking for Errors *)
PROCEDURE ResError():INTEGER;
BEGIN
    RETURN(ResErr);
END ResError;

(* Setting the Current Resource File *)
PROCEDURE CurResFile():INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A994H);
    CODE(RestoreA7);CODE(Return);
END CurResFile;

PROCEDURE HomeResFile(theResource:Handle):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A4H);
    CODE(RestoreA7);CODE(Return);
END HomeResFile;

PROCEDURE UseResFile(refNum:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A998H);
    CODE(RestoreA7);CODE(Return);
END UseResFile;

(* Getting Resource Types *)
PROCEDURE CountTypes():INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A99EH);
    CODE(RestoreA7);CODE(Return);
END CountTypes;

PROCEDURE GetIndType(VAR theType:ResType;index:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A99FH);
    CODE(RestoreA7);CODE(Return);
END GetIndType;


(* Getting and Disposing of Resources *)
PROCEDURE SetResLoad(load:BOOLEAN);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A99BH);
    CODE(RestoreA7);CODE(Return);
END SetResLoad;
PROCEDURE xCountResources(theType:LONGINT):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A99CH);
    CODE(RestoreA7);CODE(Return);
END xCountResources;
PROCEDURE CountResources(theType:ResType):INTEGER;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
    x.res := theType;
    RETURN(xCountResources(x.param))
END CountResources;

PROCEDURE xGetIndResource(theType:LONGINT;index:INTEGER):Handle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A99DH);
    CODE(RestoreA7);CODE(Return);
END xGetIndResource;
PROCEDURE GetIndResource(theType:ResType;index:INTEGER):Handle;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
    x.res := theType;
    RETURN(xGetIndResource(x.param,index))
END GetIndResource;

PROCEDURE xGetResource(theType:LONGINT;theID:INTEGER):Handle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A0H);
    CODE(RestoreA7);CODE(Return);
END xGetResource;
PROCEDURE GetResource(theType:ResType;theID:INTEGER):Handle;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
    x.res := theType;
    RETURN(xGetResource(x.param,theID))
END GetResource;

PROCEDURE xGetNamedResource(theType:LONGINT;name:ADDRESS):Handle;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A1H);
    CODE(RestoreA7);CODE(Return);
END xGetNamedResource;
PROCEDURE GetNamedResource(theType:ResType;VAR name:ARRAY OF CHAR):Handle;
(*$P+*)(*$S-*)
VAR
    x:ParamResType;
    Str:ARRAY [0..255] OF CHAR;
BEGIN
    x.res := theType;
    MakePascalString(name,Str);
    RETURN(xGetNamedResource(x.param,ADR(Str)))
END GetNamedResource;

PROCEDURE LoadResource(theResource:Handle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A2H);
    CODE(RestoreA7);CODE(Return);
END LoadResource;
PROCEDURE ReleaseResource(theResource:Handle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A3H);
    CODE(RestoreA7);CODE(Return);
END ReleaseResource;
PROCEDURE DetachResource(theResource:Handle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A992H);
    CODE(RestoreA7);CODE(Return);
END DetachResource;

(* Getting Resource Information *)
PROCEDURE xUniqueID(theType:LONGINT):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9ABH);
    CODE(RestoreA7);CODE(Return);
END xUniqueID;
PROCEDURE UniqueID(theType:ResType):INTEGER;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
    x.res := theType;
    RETURN(xUniqueID(x.param))
END UniqueID;

PROCEDURE xGetResInfo(theResource:Handle;VAR theID:INTEGER;
    VAR theType:ResType; name:ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A8H);
    CODE(RestoreA7);CODE(Return);
END xGetResInfo;
PROCEDURE GetResInfo(theResource:Handle;VAR theID:INTEGER;
    VAR theType:ResType; VAR name:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
    xGetResInfo(theResource,theID,theType,ADR(Str));
    MakeModulaString(Str,name)
END GetResInfo;
PROCEDURE GetResAttrs(theResource:Handle):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A6H);
    CODE(RestoreA7);CODE(Return);
END GetResAttrs;
PROCEDURE SizeResource(theResource:Handle):LONGINT;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A5H);
    CODE(RestoreA7);CODE(Return);
END SizeResource;

(* Modifying Resources *)
PROCEDURE xSetResInfo(theResource:Handle; theID:INTEGER;name:ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A9H);
    CODE(RestoreA7);CODE(Return);
END xSetResInfo;
PROCEDURE SetResInfo(theResource:Handle; theID:INTEGER;VAR name:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
    MakePascalString(name,Str);
    xSetResInfo(theResource,theID,ADR(Str))
END SetResInfo;

PROCEDURE SetResAttrs(theResource:Handle;attrs:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9A7H);
    CODE(RestoreA7);CODE(Return);
END SetResAttrs;
PROCEDURE ChangedResource(theResource:Handle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9AAH);
    CODE(RestoreA7);CODE(Return);
END ChangedResource;
PROCEDURE xAddResource(theData:Handle;theType:LONGINT;theID:INTEGER;
    name:ADDRESS);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9ABH);
    CODE(RestoreA7);CODE(Return);
END xAddResource;
PROCEDURE AddResource(theData:Handle;theType:ResType;theID:INTEGER;
    VAR name:ARRAY OF CHAR);
(*$P+*)(*$S+*)
VAR Str:ARRAY [0..255] OF CHAR;
    x:ParamResType;
BEGIN
    x.res := theType;
    MakePascalString(name,Str);
    xAddResource(theData,x.param,theID,ADR(Str));
END AddResource;

PROCEDURE RmveResource(theResource:Handle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9ADH);
    CODE(RestoreA7);CODE(Return);
END RmveResource;
PROCEDURE UpdateResFile(refNum:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A999H);
    CODE(RestoreA7);CODE(Return);
END UpdateResFile;
PROCEDURE WriteResource(theResource:Handle);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9B0H);
    CODE(RestoreA7);CODE(Return);
END WriteResource;
PROCEDURE SetResPurge(install:BOOLEAN);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A993H);
    CODE(RestoreA7);CODE(Return);
END SetResPurge;

(* Advanced Routines *)
PROCEDURE GetResFileAttrs(refNum:INTEGER):INTEGER;
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9F6H);
    CODE(RestoreA7);CODE(Return);
END GetResFileAttrs;
PROCEDURE SetResFileAttrs(refNum:INTEGER;attrs:INTEGER);
(*$P-*)
BEGIN
    CODE(GetRet);CODE(SaveA7);
    CODE(0A9F7H);
    CODE(RestoreA7);CODE(Return);
END SetResFileAttrs;

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

FROM    SYSTEM IMPORT ADDRESS,WORD,ADR,CODE,REGISTER,SETREG;
FROM    MacSYSTEM IMPORT LONGINT;
FROM    QuickDraw IMPORT Point;
FROM    FileTypes IMPORT OSType;
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 *)
    Pack3       = 0A9EAH;
    SFGetF      = 2;
    SFPGetF     = 4;
    SFPPutF     = 3;
    SFPutF      = 1;
    Push        = 03F3CH;     (* MOVE #VAL,-(A7) *)

PROCEDURE NoDlg():ADDRESS; (*??*)
BEGIN
    RETURN(ADDRESS(0))
END NoDlg;

VAR ProcDlg :   MyDlgType;

PROCEDURE DlgInterface;
(*$P-*)
BEGIN
    CODE(04E56H);CODE(0);       (* LINK    A6,#0                *)
    CODE(048E7H);CODE(0FFFCH);  (* MOVEM.L D0-D7/A0-A5,-(A7)    *)
    CODE(02F2EH);CODE(0AH);     (* MOVE.L  0A(A6),-(A7)         *)
    CODE(03F2EH);CODE(08H);     (* MOVE.W  08(A6),-(A7)         *)
    SETREG(8,ProcDlg);
    CODE(04E90H);               (* JSR     (A6)                 *)
    CODE(05C8FH);               (* ADDQ.L  #6,A7                *)
    CODE(04CDFH);CODE(03FFFH);  (* MOVEM.L (A7)+,D0-D7/A0-A4    *)
    CODE(04E5EH);               (* UNLK    A6                   *)
    CODE(02F5FH);CODE(2H);      (* MOVE.L  (A7)+,2(A7)          *)
    CODE(0548FH);               (* ADDQ.L  #2,A7                *)
    CODE(04E75H);               (* RTS                          *)
END DlgInterface;

PROCEDURE UseDlg(Dlg:MyDlgType):ADDRESS;
(*$P+*)(*$S-*)
BEGIN
    ProcDlg := Dlg;
    SETREG(8,DlgInterface);
    RETURN(REGISTER(8))
END UseDlg;

PROCEDURE NoFileFilter():ADDRESS;
BEGIN
    RETURN(ADDRESS(0))
END NoFileFilter;

VAR ProcFilter  :   MyFileFilterType;

PROCEDURE FilterInterface;
(*$P-*)
BEGIN
    CODE(04E56H);CODE(0);           (* LINK    A6,#0                    *)
    CODE(048E7H);CODE(0FFFCH);  (* MOVEM.L D0-D7/A0-A5,-(A7)    *)
    CODE(02F2EH);CODE(08H);     (* MOVE.L  0A(A6),-(A7)         *)
    SETREG(8,ProcFilter);
    CODE(04E90H);                   (* JSR      (A6)                    *)
    CODE(0588FH);                   (* ADDQ.L   #4,A7                   *)
    CODE(04CDFH);CODE(03FFFH);  (* MOVEM.L (A7)+,D0-D7/A0-A4    *)
    CODE(04E5EH);                   (* UNLK A6                      *)
    CODE(02E9FH);                   (* MOVE.L   (A7)+,(A7)              *)
    CODE(04E75H);                   (* RTS                              *)
END FilterInterface;

PROCEDURE UseFileFilter(FileFilter:MyFileFilterType):ADDRESS;
(*$P+*)(*$S-*)
BEGIN
    ProcFilter := FileFilter;
    SETREG(8,FilterInterface);
    RETURN(REGISTER(8))
END UseFileFilter;

PROCEDURE xSFPutFile(lefttop:LONGINT;prompt: ADDRESS;
    origName: ADDRESS;dlgHook: ADDRESS;
    VAR reply: SFReply);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFPutF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFPutFile;

PROCEDURE SFPutFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
    VAR origName: ARRAY OF CHAR;dlgHook: ADDRESS;
    VAR reply: SFReply);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name:ARRAY [0..63] OF CHAR;
    I:CARDINAL;
BEGIN
    MakePascalString(prompt,p);
    MakePascalString(origName,name);
    xSFPutFile(lefttop.param,ADR(p),ADR(name),dlgHook,reply);
    MakeModulaString(reply.fName,name);
    FOR I := 0 TO 63 DO
        reply.fName[I] := name[I]
    END
END SFPutFile;

PROCEDURE xSFPPutFile(lefttop:LONGINT;prompt: ADDRESS;
  origName: ADDRESS;dlgHook: ADDRESS; VAR reply: SFReply;
  dlgID: INTEGER;filterProc: ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFPPutF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFPPutFile;
 
PROCEDURE SFPPutFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
  VAR origName: ARRAY OF CHAR;dlgHook: ADDRESS; VAR reply: SFReply;
  dlgID: INTEGER;filterProc: ADDRESS);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name:ARRAY [0..63] OF CHAR;
    I:INTEGER;
BEGIN
  MakePascalString(prompt,p);
  MakePascalString(origName,name);
  xSFPPutFile(lefttop.param,ADR(p),ADR(name),dlgHook,reply,dlgID,filterProc);
  MakeModulaString(reply.fName,name);
    FOR I := 0 TO 63 DO
        reply.fName[I] := name[I]
    END
END SFPPutFile;

PROCEDURE xSFGetFile(lefttop:LONGINT;prompt: ADDRESS;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFGetF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFGetFile;

PROCEDURE SFGetFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name : ARRAY [0..63] OF CHAR;
    I:INTEGER;
BEGIN
    MakePascalString(prompt,p);
    xSFGetFile(lefttop.param,ADR(p),fileFilter,numTypes,typeList,
    dlgHook,reply);
    MakeModulaString(reply.fName,name);
    FOR I := 0 TO 63 DO
        reply.fName[I] := name[I]
    END
END SFGetFile;

PROCEDURE xSFPGetFile(lefttop:LONGINT;prompt: ADDRESS;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply; dlgID: INTEGER;
    filterProc: ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFPGetF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFPGetFile;
 
PROCEDURE SFPGetFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply; dlgID: INTEGER;
    filterProc: ADDRESS);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name:ARRAY [0..63] OF CHAR;
    I:INTEGER;
BEGIN
    MakePascalString(prompt,p);
    xSFPGetFile(lefttop.param,ADR(p),fileFilter,numTypes,typeList,
    dlgHook,reply,dlgID,filterProc);
    MakeModulaString(reply.fName,name);
    FOR I := 0 TO 63 DO
        reply.fName[I] := name[I]
    END
END SFPGetFile;

END  SFPackage.
!Funky!Stuff!
# The rest of this file is a shell script which will extract:
# QuickDraw.MOD ResourceManager.MOD SFPackage.MOD
echo x - QuickDraw.MOD
cat >QuickDraw.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE QuickDraw;
FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR,REGISTER;
FROM MacSYSTEM IMPORT LONGINT;
FROM PascalStrings IMPORT MakePascalString;
(*EXPORT QUALIFIED...*)
(* GrafPort Routines *)
CONST
	GetRet = 0285FH;	(* MOVEA (A7)+,A4		*)
	Return = 04ED4H;	(* JMP	A4				*)
	SaveA7		= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)
	
PROCEDURE InitGraf (globalPtr: ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A86EH);
	CODE(RestoreA7);CODE(Return);
END InitGraf;
PROCEDURE OpenPort (port: GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A86FH);
	CODE(RestoreA7);CODE(Return);
END OpenPort;
PROCEDURE InitPort (port:GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A86DH);
	CODE(RestoreA7);CODE(Return);
END InitPort;
PROCEDURE ClosePort (port:GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87DH);
	CODE(RestoreA7);CODE(Return);
END ClosePort;
PROCEDURE SetPort (port: GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A873H);
	CODE(RestoreA7);CODE(Return);
END SetPort;
PROCEDURE GetPort (VAR port: GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A874H);
	CODE(RestoreA7);CODE(Return);
END GetPort;
PROCEDURE GrafDevice (device: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A872H);
	CODE(RestoreA7);CODE(Return);
END GrafDevice;
PROCEDURE SetPortBits(VAR bm: BitMap);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A875H);
	CODE(RestoreA7);CODE(Return);
END SetPortBits;
PROCEDURE PortSize   (width,height: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A876H);
	CODE(RestoreA7);CODE(Return);
END PortSize;
PROCEDURE MovePortTo (leftGlobal,topGlobal: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A877H);
	CODE(RestoreA7);CODE(Return);
END MovePortTo;
PROCEDURE SetOrigin (h,v: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A878H);
	CODE(RestoreA7);CODE(Return);
END SetOrigin;
PROCEDURE SetClip (rgn:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A879H);
	CODE(RestoreA7);CODE(Return);
END SetClip;
PROCEDURE GetClip (rgn: RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87AH);
	CODE(RestoreA7);CODE(Return);
END GetClip;
PROCEDURE ClipRect (VAR r:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87BH);
	CODE(RestoreA7);CODE(Return);
END ClipRect;
PROCEDURE BackPat (VAR pat: Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87CH);
	CODE(RestoreA7);CODE(Return);
END BackPat;

(* Line Routines *)
PROCEDURE HidePen;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A896H);
	CODE(RestoreA7);CODE(Return);
END HidePen;
PROCEDURE ShowPen;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A897H);
	CODE(RestoreA7);CODE(Return);
END ShowPen;
PROCEDURE GetPen(VAR pt:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89AH);
	CODE(RestoreA7);CODE(Return);
END GetPen;
PROCEDURE GetPenState(VAR pnState:PenState);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A898H);
	CODE(RestoreA7);CODE(Return);
END GetPenState;
PROCEDURE SetPenState(VAR pnState: PenState);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A899H);
	CODE(RestoreA7);CODE(Return);
END SetPenState;
PROCEDURE PenSize (width,height: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89BH);
	CODE(RestoreA7);CODE(Return);
END PenSize;
PROCEDURE PenMode (mode: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89CH);
	CODE(RestoreA7);CODE(Return);
END PenMode;
PROCEDURE PenPat (VAR pat: Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89DH);
	CODE(RestoreA7);CODE(Return);
END PenPat;
PROCEDURE PenNormal;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89EH);
	CODE(RestoreA7);CODE(Return);
END PenNormal;
PROCEDURE MoveTo (h,v: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A893H);
	CODE(RestoreA7);CODE(Return);
END MoveTo;
PROCEDURE Move (dh,dv: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A894H);
	CODE(RestoreA7);CODE(Return);
END Move;
PROCEDURE LineTo (h,v: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A891H);
	CODE(RestoreA7);CODE(Return);
END LineTo;
PROCEDURE Line (dh,dv: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A892H);
	CODE(RestoreA7);CODE(Return);
END Line;


(* Text Routines *)
PROCEDURE TextFont (font: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A887H);
	CODE(RestoreA7);CODE(Return);
END TextFont;
PROCEDURE TextFace (face: Style);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A888H);
	CODE(RestoreA7);CODE(Return);
END TextFace;
PROCEDURE TextMode (mode: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A889H);
	CODE(RestoreA7);CODE(Return);
END TextMode;
PROCEDURE TextSize (size: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88AH);
	CODE(RestoreA7);CODE(Return);
END TextSize;
PROCEDURE SpaceExtra (extra: LONGINT);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88EH);
	CODE(RestoreA7);CODE(Return);
END SpaceExtra;
PROCEDURE xDrawChar (ch: CARDINAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A883H);
	CODE(RestoreA7);CODE(Return);
END xDrawChar;
PROCEDURE DrawChar (ch: CHAR);
(*$P+*)(*$S-*)
BEGIN
	xDrawChar(ORD(ch))
END DrawChar;
PROCEDURE xDrawString   (s:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A884H);
	CODE(RestoreA7);CODE(Return);
END xDrawString;
PROCEDURE DrawString   (VAR s:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR
	s1:ARRAY[0..255] OF CHAR;
BEGIN
	MakePascalString(s,s1);
	xDrawString(ADR(s1))
END DrawString;
PROCEDURE DrawText (textBuf: ADDRESS; firstByte,byteCount: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A885H);
	CODE(RestoreA7);CODE(Return);
END DrawText;
PROCEDURE xCharWidth (ch: CARDINAL):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88DH);
	CODE(RestoreA7);CODE(Return);
END xCharWidth;
PROCEDURE CharWidth    (ch: CHAR): INTEGER;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xCharWidth(ORD(ch)));
END CharWidth;
PROCEDURE xStringWidth  (stringPtr:ADDRESS):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88CH);
	CODE(RestoreA7);CODE(Return);
END xStringWidth;
PROCEDURE StringWidth  (VAR s:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(s,Str);
	RETURN(xStringWidth(ADR(Str)));
END StringWidth;

PROCEDURE TextWidth(textBuf:ADDRESS;firstByte,byteCount:INTEGER):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A886H);
	CODE(RestoreA7);CODE(Return);
END TextWidth;

(* Point Calculations *)
PROCEDURE xAddPt (src:LONGINT;VAR dst:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87EH);
	CODE(RestoreA7);CODE(Return);
END xAddPt;

PROCEDURE AddPt (src:Point;VAR dst:Point);
(*$P+*)(*$S-*)
BEGIN
	xAddPt(src.param,dst)
END AddPt;

PROCEDURE xSubPt (src:LONGINT;VAR dst:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87FH);
	CODE(RestoreA7);CODE(Return);
END xSubPt;
PROCEDURE SubPt(src:Point;VAR dst:Point);
(*$P+*)(*$S-*)
BEGIN
	xSubPt(src.param,dst)
END SubPt;
PROCEDURE SetPt (VAR pt: Point;h,v:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A880H);
	CODE(RestoreA7);CODE(Return);
END SetPt;
PROCEDURE xEqualPt (pt1,pt2:LONGINT) :BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A881H);
	CODE(RestoreA7);CODE(Return);
END xEqualPt;
PROCEDURE EqualPt (pt1,pt2: Point) :BOOLEAN;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xEqualPt(pt1.param,pt2.param))
END EqualPt;
PROCEDURE ScalePt (VAR pt:Point;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F8H);
	CODE(RestoreA7);CODE(Return);
END ScalePt;
PROCEDURE MapPt(VAR pt:Point;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F9H);
	CODE(RestoreA7);CODE(Return);
END MapPt;
PROCEDURE LocalToGlobal(VAR pt:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A870H);
	CODE(RestoreA7);CODE(Return);
END LocalToGlobal;
PROCEDURE GlobalToLocal(VAR pt:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A871H);
	CODE(RestoreA7);CODE(Return);
END GlobalToLocal;

(* Rectangle Calculations *)
PROCEDURE	SetRect (VAR r:Rect;left,top,right,bottom:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A7H);
	CODE(RestoreA7);CODE(Return);
END SetRect;
PROCEDURE EqualRect(VAR rect1,rect2:Rect):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A6H);
	CODE(RestoreA7);CODE(Return);
END EqualRect;
PROCEDURE EmptyRect(VAR r:Rect):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8AEH);
	CODE(RestoreA7);CODE(Return);
END EmptyRect;

PROCEDURE OffsetRect(VAR r:Rect;dh,dv:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A8H);
	CODE(RestoreA7);CODE(Return);
END OffsetRect;
PROCEDURE MapRect(VAR r:Rect;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8FAH);
	CODE(RestoreA7);CODE(Return);
END MapRect;
PROCEDURE InsetRect(VAR r:Rect;dh,dv:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A9H);
	CODE(RestoreA7);CODE(Return);
END InsetRect;
PROCEDURE SectRect (VAR src1,src2:Rect;VAR dstRect:Rect):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8AAH);
	CODE(RestoreA7);CODE(Return);
END SectRect;
PROCEDURE UnionRect(VAR src1,src2:Rect;VAR dstRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8ABH);
	CODE(RestoreA7);CODE(Return);
END UnionRect;
PROCEDURE xPtInRect(pt: LONGINT;VAR dstRect:Rect):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8ADH);
	CODE(RestoreA7);CODE(Return);
END xPtInRect;
PROCEDURE PtInRect(pt: Point;dstRect:Rect):BOOLEAN;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xPtInRect(pt.param,dstRect));
END PtInRect;

PROCEDURE	xPt2Rect (pt1,pt2:LONGINT;VAR dstRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8ACH);
	CODE(RestoreA7);CODE(Return);
END xPt2Rect;
PROCEDURE	Pt2Rect (pt1,pt2:Point;VAR dstRect:Rect);
(*$P+*)(*$S-*)
BEGIN
	xPt2Rect(pt1.param,pt2.param,dstRect)
END Pt2Rect;

(* Graphical Operations on Rectangles *)
PROCEDURE FrameRect  (VAR r: Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A1H);
	CODE(RestoreA7);CODE(Return);
END FrameRect;
PROCEDURE PaintRect  (VAR r: Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A2H);
	CODE(RestoreA7);CODE(Return);
END PaintRect;
PROCEDURE EraseRect  (VAR r: Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A3H);
	CODE(RestoreA7);CODE(Return);
END EraseRect;
PROCEDURE InvertRect (VAR r: Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A4H);
	CODE(RestoreA7);CODE(Return);
END InvertRect;
PROCEDURE FillRect   (VAR r: Rect;VAR  pat: Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A5H);
	CODE(RestoreA7);CODE(Return);
END FillRect;

(* RoundRect Routines *)
PROCEDURE FrameRoundRect(VAR theRect:Rect;cornerWidth,cornerHeigth:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B0H);
	CODE(RestoreA7);CODE(Return);
END FrameRoundRect;
PROCEDURE PaintRoundRect(VAR theRect:Rect;cornerWidth,cornerHeight:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B1H);
	CODE(RestoreA7);CODE(Return);
END PaintRoundRect;
PROCEDURE FillRoundRect(VAR theRect:Rect;
		cornerWidth,cornerHeigth:INTEGER;
		VAR fillPat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B4H);
	CODE(RestoreA7);CODE(Return);
END FillRoundRect;
PROCEDURE EraseRoundRect(VAR theRect:Rect;cornerWidth,cornerHeight:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B2H);
	CODE(RestoreA7);CODE(Return);
END EraseRoundRect;
PROCEDURE InvertRoundRect(VAR theRect:Rect;cornerWidth,cornerHeigth:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B3H);
	CODE(RestoreA7);CODE(Return);
END InvertRoundRect;

(* Drawing Ovals *)
PROCEDURE FrameOval(VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B7H);
	CODE(RestoreA7);CODE(Return);
END FrameOval;
PROCEDURE PaintOval(VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B8H);
	CODE(RestoreA7);CODE(Return);
END PaintOval;
PROCEDURE EraseOval(VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B9H);
	CODE(RestoreA7);CODE(Return);
END EraseOval;
PROCEDURE InvertOval(VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8BAH);
	CODE(RestoreA7);CODE(Return);
END InvertOval;
PROCEDURE FillOval(VAR inRect:Rect;VAR pat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8BBH);
	CODE(RestoreA7);CODE(Return);
END FillOval;

(* Arc Routines *)
PROCEDURE FrameArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8BEH);
	CODE(RestoreA7);CODE(Return);
END FrameArc;
PROCEDURE PaintArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8BFH);
	CODE(RestoreA7);CODE(Return);
END PaintArc;
PROCEDURE FillArc(VAR inRect:Rect;
	startAngle,arcAngle:INTEGER;
	VAR fillpat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C2H);
	CODE(RestoreA7);CODE(Return);
END FillArc;
PROCEDURE EraseArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C0H);
	CODE(RestoreA7);CODE(Return);
END EraseArc;
PROCEDURE InvertArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C1H);
	CODE(RestoreA7);CODE(Return);
END InvertArc;
PROCEDURE xPtToAngle(VAR inRect:Rect;P:LONGINT;VAR theAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C3H);
	CODE(RestoreA7);CODE(Return);
END xPtToAngle;
PROCEDURE PtToAngle (inRect:Rect;thePoint:Point;VAR theAngle:INTEGER);
(*$P+*)(*$S-*)
BEGIN
	xPtToAngle(inRect,thePoint.param,theAngle)
END PtToAngle;

(* Polygon Routines *)
PROCEDURE OpenPoly():PolyHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CBH);
	CODE(RestoreA7);CODE(Return);
END OpenPoly;
PROCEDURE ClosePoly;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CCH);
	CODE(RestoreA7);CODE(Return);
END ClosePoly;
PROCEDURE KillPoly(thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CDH);
	CODE(RestoreA7);CODE(Return);
END KillPoly;
PROCEDURE OffsetPoly(thePolygon:PolyHandle;hOffset,vOffset:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CEH);
	CODE(RestoreA7);CODE(Return);
END OffsetPoly;
PROCEDURE MapPoly (thePolygon:PolyHandle;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8FCH);
	CODE(RestoreA7);CODE(Return);
END MapPoly;
PROCEDURE FramePoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C6H);
	CODE(RestoreA7);CODE(Return);
END FramePoly;
PROCEDURE PaintPoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C7H);
	CODE(RestoreA7);CODE(Return);
END PaintPoly;
PROCEDURE FillPoly (thePolygon:PolyHandle;VAR fillPat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CAH);
	CODE(RestoreA7);CODE(Return);
END FillPoly;
PROCEDURE ErasePoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C8H);
	CODE(RestoreA7);CODE(Return);
END ErasePoly;
PROCEDURE InvertPoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C9H);
	CODE(RestoreA7);CODE(Return);
END InvertPoly;

(* Graphical Operations on BitMaps *)
PROCEDURE ScrollRect(VAR dstRect:Rect;dh,dv:INTEGER;updateRgn:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8EFH);
	CODE(RestoreA7);CODE(Return);
END ScrollRect;
PROCEDURE CopyBits  (VAR srcBits,dstBits: BitMap;
                     VAR srcRect,dstRect: Rect;
                     mode:            INTEGER;
                     maskRgn:         RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8ECH);
	CODE(RestoreA7);CODE(Return);
END CopyBits;
(* later...
PROCEDURE SetStdProcs
PROCEDURE StdText
PROCEDURE StdLine
PROCEDURE StdRect
PROCEDURE StdRRect
PROCEDURE StdOval
PROCEDURE StdArc
PROCEDURE StdPoly
PROCEDURE StdRgn
PROCEDURE StdBits
PROCEDURE StdComment
PROCEDURE StdTxMeas
PROCEDURE StdGetPic
PROCEDURE StdPutPic
*)
(* Misc Utility Routines *)
PROCEDURE GetPixel(h,v:INTEGER):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A865H);
	CODE(RestoreA7);CODE(Return);
END GetPixel;
PROCEDURE ForeColor (color:LONGINT);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A862H);
	CODE(RestoreA7);CODE(Return);
END ForeColor;
PROCEDURE BackColor (color:LONGINT);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A863H);
	CODE(RestoreA7);CODE(Return);
END BackColor;
PROCEDURE ColorBit (whichBit:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A864H);
	CODE(RestoreA7);CODE(Return);
END ColorBit;

BEGIN
	InitGraf(ADR(thePort));
END QuickDraw.
!Funky!Stuff!
echo x - ResourceManager.MOD
cat >ResourceManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE ResourceManager;
FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
FROM MacSYSTEM IMPORT LONGINT,Handle;
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 *)


(* Opening and Closing Resource Files *)
PROCEDURE xCreateResFile(fileName:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9B1H);
	CODE(RestoreA7);CODE(Return);
END xCreateResFile;
PROCEDURE CreateResFile(VAR fileName:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(fileName,Str);
	xCreateResFile(ADR(Str))
END CreateResFile;

PROCEDURE xOpenResFile(fileName:ADDRESS):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A997H);
	CODE(RestoreA7);CODE(Return);
END xOpenResFile;
PROCEDURE OpenResFile(VAR fileName:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(fileName,Str);
	RETURN(xOpenResFile(ADR(Str)))
END OpenResFile;

PROCEDURE CloseResFile(refNum:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99AH);
	CODE(RestoreA7);CODE(Return);
END CloseResFile;

(* Checking for Errors *)
PROCEDURE ResError():INTEGER;
BEGIN
	RETURN(ResErr);
END ResError;

(* Setting the Current Resource File *)
PROCEDURE CurResFile():INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A994H);
	CODE(RestoreA7);CODE(Return);
END CurResFile;

PROCEDURE HomeResFile(theResource:Handle):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A4H);
	CODE(RestoreA7);CODE(Return);
END HomeResFile;

PROCEDURE UseResFile(refNum:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A998H);
	CODE(RestoreA7);CODE(Return);
END UseResFile;

(* Getting Resource Types *)
PROCEDURE CountTypes():INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99EH);
	CODE(RestoreA7);CODE(Return);
END CountTypes;

PROCEDURE GetIndType(VAR theType:ResType;index:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99FH);
	CODE(RestoreA7);CODE(Return);
END GetIndType;


(* Getting and Disposing of Resources *)
PROCEDURE SetResLoad(load:BOOLEAN);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99BH);
	CODE(RestoreA7);CODE(Return);
END SetResLoad;
PROCEDURE xCountResources(theType:LONGINT):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99CH);
	CODE(RestoreA7);CODE(Return);
END xCountResources;
PROCEDURE CountResources(theType:ResType):INTEGER;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	RETURN(xCountResources(x.param))
END CountResources;

PROCEDURE xGetIndResource(theType:LONGINT;index:INTEGER):Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99DH);
	CODE(RestoreA7);CODE(Return);
END xGetIndResource;
PROCEDURE GetIndResource(theType:ResType;index:INTEGER):Handle;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	RETURN(xGetIndResource(x.param,index))
END GetIndResource;

PROCEDURE xGetResource(theType:LONGINT;theID:INTEGER):Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A0H);
	CODE(RestoreA7);CODE(Return);
END xGetResource;
PROCEDURE GetResource(theType:ResType;theID:INTEGER):Handle;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	RETURN(xGetResource(x.param,theID))
END GetResource;

PROCEDURE xGetNamedResource(theType:LONGINT;name:ADDRESS):Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A1H);
	CODE(RestoreA7);CODE(Return);
END xGetNamedResource;
PROCEDURE GetNamedResource(theType:ResType;VAR name:ARRAY OF CHAR):Handle;
(*$P+*)(*$S-*)
VAR
	x:ParamResType;
	Str:ARRAY [0..255] OF CHAR;
BEGIN
	x.res := theType;
	MakePascalString(name,Str);
	RETURN(xGetNamedResource(x.param,ADR(Str)))
END GetNamedResource;

PROCEDURE LoadResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A2H);
	CODE(RestoreA7);CODE(Return);
END LoadResource;
PROCEDURE ReleaseResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A3H);
	CODE(RestoreA7);CODE(Return);
END ReleaseResource;
PROCEDURE DetachResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A992H);
	CODE(RestoreA7);CODE(Return);
END DetachResource;

(* Getting Resource Information *)
PROCEDURE xUniqueID(theType:LONGINT):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9ABH);
	CODE(RestoreA7);CODE(Return);
END xUniqueID;
PROCEDURE UniqueID(theType:ResType):INTEGER;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	RETURN(xUniqueID(x.param))
END UniqueID;

PROCEDURE xGetResInfo(theResource:Handle;VAR theID:INTEGER;
	VAR theType:ResType; name:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A8H);
	CODE(RestoreA7);CODE(Return);
END xGetResInfo;
PROCEDURE GetResInfo(theResource:Handle;VAR theID:INTEGER;
	VAR theType:ResType; VAR name:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	xGetResInfo(theResource,theID,theType,ADR(Str));
	MakeModulaString(Str,name)
END GetResInfo;
PROCEDURE GetResAttrs(theResource:Handle):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A6H);
	CODE(RestoreA7);CODE(Return);
END GetResAttrs;
PROCEDURE SizeResource(theResource:Handle):LONGINT;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A5H);
	CODE(RestoreA7);CODE(Return);
END SizeResource;

(* Modifying Resources *)
PROCEDURE xSetResInfo(theResource:Handle; theID:INTEGER;name:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A9H);
	CODE(RestoreA7);CODE(Return);
END xSetResInfo;
PROCEDURE SetResInfo(theResource:Handle; theID:INTEGER;VAR name:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(name,Str);
	xSetResInfo(theResource,theID,ADR(Str))
END SetResInfo;

PROCEDURE SetResAttrs(theResource:Handle;attrs:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A7H);
	CODE(RestoreA7);CODE(Return);
END SetResAttrs;
PROCEDURE ChangedResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9AAH);
	CODE(RestoreA7);CODE(Return);
END ChangedResource;
PROCEDURE xAddResource(theData:Handle;theType:LONGINT;theID:INTEGER;
	name:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9ABH);
	CODE(RestoreA7);CODE(Return);
END xAddResource;
PROCEDURE AddResource(theData:Handle;theType:ResType;theID:INTEGER;
	VAR name:ARRAY OF CHAR);
(*$P+*)(*$S+*)
VAR Str:ARRAY [0..255] OF CHAR;
	x:ParamResType;
BEGIN
	x.res := theType;
	MakePascalString(name,Str);
	xAddResource(theData,x.param,theID,ADR(Str));
END AddResource;

PROCEDURE RmveResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9ADH);
	CODE(RestoreA7);CODE(Return);
END RmveResource;
PROCEDURE UpdateResFile(refNum:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A999H);
	CODE(RestoreA7);CODE(Return);
END UpdateResFile;
PROCEDURE WriteResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9B0H);
	CODE(RestoreA7);CODE(Return);
END WriteResource;
PROCEDURE SetResPurge(install:BOOLEAN);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A993H);
	CODE(RestoreA7);CODE(Return);
END SetResPurge;

(* Advanced Routines *)
PROCEDURE GetResFileAttrs(refNum:INTEGER):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9F6H);
	CODE(RestoreA7);CODE(Return);
END GetResFileAttrs;
PROCEDURE SetResFileAttrs(refNum:INTEGER;attrs:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9F7H);
	CODE(RestoreA7);CODE(Return);
END SetResFileAttrs;

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

FROM    SYSTEM IMPORT ADDRESS,WORD,ADR,CODE,REGISTER,SETREG;
FROM	MacSYSTEM IMPORT LONGINT;
FROM	QuickDraw IMPORT Point;
FROM	FileTypes IMPORT OSType;
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 *)
	Pack3       = 0A9EAH;
	SFGetF      = 2;
	SFPGetF     = 4;
	SFPPutF		= 3;
	SFPutF		= 1;
	Push        = 03F3CH;     (* MOVE #VAL,-(A7) *)

PROCEDURE NoDlg():ADDRESS; (*??*)
BEGIN
	RETURN(ADDRESS(0))
END NoDlg;

VAR	ProcDlg	:	MyDlgType;

PROCEDURE DlgInterface;
(*$P-*)
BEGIN
	CODE(04E56H);CODE(0);		(* LINK    A6,#0				*)
	CODE(048E7H);CODE(0FFFCH);	(* MOVEM.L D0-D7/A0-A5,-(A7)	*)
	CODE(02F2EH);CODE(0AH);		(* MOVE.L  0A(A6),-(A7)			*)
	CODE(03F2EH);CODE(08H);		(* MOVE.W  08(A6),-(A7)			*)
	SETREG(8,ProcDlg);
	CODE(04E90H);				(* JSR     (A6)                 *)
	CODE(05C8FH);				(* ADDQ.L  #6,A7				*)
	CODE(04CDFH);CODE(03FFFH);	(* MOVEM.L (A7)+,D0-D7/A0-A4	*)
	CODE(04E5EH);				(* UNLK    A6                   *)
	CODE(02F5FH);CODE(2H);		(* MOVE.L  (A7)+,2(A7)          *)
	CODE(0548FH);				(* ADDQ.L  #2,A7                *)
	CODE(04E75H);				(* RTS							*)
END DlgInterface;

PROCEDURE UseDlg(Dlg:MyDlgType):ADDRESS;
(*$P+*)(*$S-*)
BEGIN
	ProcDlg := Dlg;
	SETREG(8,DlgInterface);
	RETURN(REGISTER(8))
END UseDlg;

PROCEDURE NoFileFilter():ADDRESS;
BEGIN
	RETURN(ADDRESS(0))
END NoFileFilter;

VAR	ProcFilter	:	MyFileFilterType;

PROCEDURE FilterInterface;
(*$P-*)
BEGIN
	CODE(04E56H);CODE(0);			(* LINK    A6,#0					*)
	CODE(048E7H);CODE(0FFFCH);	(* MOVEM.L D0-D7/A0-A5,-(A7)	*)
	CODE(02F2EH);CODE(08H);		(* MOVE.L  0A(A6),-(A7)			*)
	SETREG(8,ProcFilter);
	CODE(04E90H);					(* JSR		(A6)					*)
	CODE(0588FH);					(* ADDQ.L	#4,A7					*)
	CODE(04CDFH);CODE(03FFFH);	(* MOVEM.L (A7)+,D0-D7/A0-A4	*)
	CODE(04E5EH);					(* UNLK	A6						*)
	CODE(02E9FH);					(* MOVE.L	(A7)+,(A7)				*)
	CODE(04E75H);					(* RTS								*)
END FilterInterface;

PROCEDURE UseFileFilter(FileFilter:MyFileFilterType):ADDRESS;
(*$P+*)(*$S-*)
BEGIN
	ProcFilter := FileFilter;
	SETREG(8,FilterInterface);
	RETURN(REGISTER(8))
END UseFileFilter;

PROCEDURE xSFPutFile(lefttop:LONGINT;prompt: ADDRESS;
	origName: ADDRESS;dlgHook: ADDRESS;
	VAR reply: SFReply);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFPutF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFPutFile;

PROCEDURE SFPutFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
	VAR origName: ARRAY OF CHAR;dlgHook: ADDRESS;
	VAR reply: SFReply);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name:ARRAY [0..63] OF CHAR;
	I:CARDINAL;
BEGIN
	MakePascalString(prompt,p);
	MakePascalString(origName,name);
	xSFPutFile(lefttop.param,ADR(p),ADR(name),dlgHook,reply);
	MakeModulaString(reply.fName,name);
	FOR I := 0 TO 63 DO
		reply.fName[I] := name[I]
	END
END SFPutFile;

PROCEDURE xSFPPutFile(lefttop:LONGINT;prompt: ADDRESS;
  origName: ADDRESS;dlgHook: ADDRESS; VAR reply: SFReply;
  dlgID: INTEGER;filterProc: ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFPPutF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFPPutFile;
 
PROCEDURE SFPPutFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
  VAR origName: ARRAY OF CHAR;dlgHook: ADDRESS; VAR reply: SFReply;
  dlgID: INTEGER;filterProc: ADDRESS);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name:ARRAY [0..63] OF CHAR;
	I:INTEGER;
BEGIN
  MakePascalString(prompt,p);
  MakePascalString(origName,name);
  xSFPPutFile(lefttop.param,ADR(p),ADR(name),dlgHook,reply,dlgID,filterProc);
  MakeModulaString(reply.fName,name);
	FOR I := 0 TO 63 DO
		reply.fName[I] := name[I]
	END
END SFPPutFile;

PROCEDURE xSFGetFile(lefttop:LONGINT;prompt: ADDRESS;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFGetF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFGetFile;

PROCEDURE SFGetFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name : ARRAY [0..63] OF CHAR;
	I:INTEGER;
BEGIN
	MakePascalString(prompt,p);
	xSFGetFile(lefttop.param,ADR(p),fileFilter,numTypes,typeList,
	dlgHook,reply);
	MakeModulaString(reply.fName,name);
	FOR I := 0 TO 63 DO
		reply.fName[I] := name[I]
	END
END SFGetFile;

PROCEDURE xSFPGetFile(lefttop:LONGINT;prompt: ADDRESS;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply; dlgID: INTEGER;
    filterProc: ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFPGetF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFPGetFile;
 
PROCEDURE SFPGetFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply; dlgID: INTEGER;
    filterProc: ADDRESS);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
	name:ARRAY [0..63] OF CHAR;
	I:INTEGER;
BEGIN
	MakePascalString(prompt,p);
	xSFPGetFile(lefttop.param,ADR(p),fileFilter,numTypes,typeList,
	dlgHook,reply,dlgID,filterProc);
	MakeModulaString(reply.fName,name);
	FOR I := 0 TO 63 DO
		reply.fName[I] := name[I]
	END
END SFPGetFile;

END  SFPackage.
!Funky!Stuff!
# The rest of this file is a shell script which will extract:
# QuickDraw.MOD ResourceManager.MOD SFPackage.MOD
echo x - QuickDraw.MOD
cat >QuickDraw.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE QuickDraw;
FROM SYSTEM IMPORT ADDRESS,WORD,CODE,ADR,REGISTER;
FROM MacSYSTEM IMPORT LONGINT;
FROM PascalStrings IMPORT MakePascalString;
(*EXPORT QUALIFIED...*)
(* GrafPort Routines *)
CONST
	GetRet = 0285FH;	(* MOVEA (A7)+,A4		*)
	Return = 04ED4H;	(* JMP	A4				*)
	SaveA7		= 0264FH;	(* MOVEA A7,A3		*)
	RestoreA7	= 02E4BH;	(* MOVEA A3,A7		*)
	
PROCEDURE InitGraf (globalPtr: ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A86EH);
	CODE(RestoreA7);CODE(Return);
END InitGraf;
PROCEDURE OpenPort (port: GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A86FH);
	CODE(RestoreA7);CODE(Return);
END OpenPort;
PROCEDURE InitPort (port:GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A86DH);
	CODE(RestoreA7);CODE(Return);
END InitPort;
PROCEDURE ClosePort (port:GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87DH);
	CODE(RestoreA7);CODE(Return);
END ClosePort;
PROCEDURE SetPort (port: GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A873H);
	CODE(RestoreA7);CODE(Return);
END SetPort;
PROCEDURE GetPort (VAR port: GrafPtr);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A874H);
	CODE(RestoreA7);CODE(Return);
END GetPort;
PROCEDURE GrafDevice (device: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A872H);
	CODE(RestoreA7);CODE(Return);
END GrafDevice;
PROCEDURE SetPortBits(VAR bm: BitMap);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A875H);
	CODE(RestoreA7);CODE(Return);
END SetPortBits;
PROCEDURE PortSize   (width,height: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A876H);
	CODE(RestoreA7);CODE(Return);
END PortSize;
PROCEDURE MovePortTo (leftGlobal,topGlobal: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A877H);
	CODE(RestoreA7);CODE(Return);
END MovePortTo;
PROCEDURE SetOrigin (h,v: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A878H);
	CODE(RestoreA7);CODE(Return);
END SetOrigin;
PROCEDURE SetClip (rgn:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A879H);
	CODE(RestoreA7);CODE(Return);
END SetClip;
PROCEDURE GetClip (rgn: RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87AH);
	CODE(RestoreA7);CODE(Return);
END GetClip;
PROCEDURE ClipRect (VAR r:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87BH);
	CODE(RestoreA7);CODE(Return);
END ClipRect;
PROCEDURE BackPat (VAR pat: Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87CH);
	CODE(RestoreA7);CODE(Return);
END BackPat;

(* Line Routines *)
PROCEDURE HidePen;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A896H);
	CODE(RestoreA7);CODE(Return);
END HidePen;
PROCEDURE ShowPen;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A897H);
	CODE(RestoreA7);CODE(Return);
END ShowPen;
PROCEDURE GetPen(VAR pt:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89AH);
	CODE(RestoreA7);CODE(Return);
END GetPen;
PROCEDURE GetPenState(VAR pnState:PenState);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A898H);
	CODE(RestoreA7);CODE(Return);
END GetPenState;
PROCEDURE SetPenState(VAR pnState: PenState);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A899H);
	CODE(RestoreA7);CODE(Return);
END SetPenState;
PROCEDURE PenSize (width,height: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89BH);
	CODE(RestoreA7);CODE(Return);
END PenSize;
PROCEDURE PenMode (mode: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89CH);
	CODE(RestoreA7);CODE(Return);
END PenMode;
PROCEDURE PenPat (VAR pat: Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89DH);
	CODE(RestoreA7);CODE(Return);
END PenPat;
PROCEDURE PenNormal;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A89EH);
	CODE(RestoreA7);CODE(Return);
END PenNormal;
PROCEDURE MoveTo (h,v: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A893H);
	CODE(RestoreA7);CODE(Return);
END MoveTo;
PROCEDURE Move (dh,dv: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A894H);
	CODE(RestoreA7);CODE(Return);
END Move;
PROCEDURE LineTo (h,v: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A891H);
	CODE(RestoreA7);CODE(Return);
END LineTo;
PROCEDURE Line (dh,dv: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A892H);
	CODE(RestoreA7);CODE(Return);
END Line;


(* Text Routines *)
PROCEDURE TextFont (font: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A887H);
	CODE(RestoreA7);CODE(Return);
END TextFont;
PROCEDURE TextFace (face: Style);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A888H);
	CODE(RestoreA7);CODE(Return);
END TextFace;
PROCEDURE TextMode (mode: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A889H);
	CODE(RestoreA7);CODE(Return);
END TextMode;
PROCEDURE TextSize (size: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88AH);
	CODE(RestoreA7);CODE(Return);
END TextSize;
PROCEDURE SpaceExtra (extra: LONGINT);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88EH);
	CODE(RestoreA7);CODE(Return);
END SpaceExtra;
PROCEDURE xDrawChar (ch: CARDINAL);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A883H);
	CODE(RestoreA7);CODE(Return);
END xDrawChar;
PROCEDURE DrawChar (ch: CHAR);
(*$P+*)(*$S-*)
BEGIN
	xDrawChar(ORD(ch))
END DrawChar;
PROCEDURE xDrawString   (s:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A884H);
	CODE(RestoreA7);CODE(Return);
END xDrawString;
PROCEDURE DrawString   (VAR s:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR
	s1:ARRAY[0..255] OF CHAR;
BEGIN
	MakePascalString(s,s1);
	xDrawString(ADR(s1))
END DrawString;
PROCEDURE DrawText (textBuf: ADDRESS; firstByte,byteCount: INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A885H);
	CODE(RestoreA7);CODE(Return);
END DrawText;
PROCEDURE xCharWidth (ch: CARDINAL):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88DH);
	CODE(RestoreA7);CODE(Return);
END xCharWidth;
PROCEDURE CharWidth    (ch: CHAR): INTEGER;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xCharWidth(ORD(ch)));
END CharWidth;
PROCEDURE xStringWidth  (stringPtr:ADDRESS):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A88CH);
	CODE(RestoreA7);CODE(Return);
END xStringWidth;
PROCEDURE StringWidth  (VAR s:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(s,Str);
	RETURN(xStringWidth(ADR(Str)));
END StringWidth;

PROCEDURE TextWidth(textBuf:ADDRESS;firstByte,byteCount:INTEGER):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A886H);
	CODE(RestoreA7);CODE(Return);
END TextWidth;

(* Point Calculations *)
PROCEDURE xAddPt (src:LONGINT;VAR dst:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87EH);
	CODE(RestoreA7);CODE(Return);
END xAddPt;

PROCEDURE AddPt (src:Point;VAR dst:Point);
(*$P+*)(*$S-*)
BEGIN
	xAddPt(src.param,dst)
END AddPt;

PROCEDURE xSubPt (src:LONGINT;VAR dst:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A87FH);
	CODE(RestoreA7);CODE(Return);
END xSubPt;
PROCEDURE SubPt(src:Point;VAR dst:Point);
(*$P+*)(*$S-*)
BEGIN
	xSubPt(src.param,dst)
END SubPt;
PROCEDURE SetPt (VAR pt: Point;h,v:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A880H);
	CODE(RestoreA7);CODE(Return);
END SetPt;
PROCEDURE xEqualPt (pt1,pt2:LONGINT) :BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A881H);
	CODE(RestoreA7);CODE(Return);
END xEqualPt;
PROCEDURE EqualPt (pt1,pt2: Point) :BOOLEAN;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xEqualPt(pt1.param,pt2.param))
END EqualPt;
PROCEDURE ScalePt (VAR pt:Point;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F8H);
	CODE(RestoreA7);CODE(Return);
END ScalePt;
PROCEDURE MapPt(VAR pt:Point;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8F9H);
	CODE(RestoreA7);CODE(Return);
END MapPt;
PROCEDURE LocalToGlobal(VAR pt:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A870H);
	CODE(RestoreA7);CODE(Return);
END LocalToGlobal;
PROCEDURE GlobalToLocal(VAR pt:Point);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A871H);
	CODE(RestoreA7);CODE(Return);
END GlobalToLocal;

(* Rectangle Calculations *)
PROCEDURE	SetRect (VAR r:Rect;left,top,right,bottom:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A7H);
	CODE(RestoreA7);CODE(Return);
END SetRect;
PROCEDURE EqualRect(VAR rect1,rect2:Rect):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A6H);
	CODE(RestoreA7);CODE(Return);
END EqualRect;
PROCEDURE EmptyRect(VAR r:Rect):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8AEH);
	CODE(RestoreA7);CODE(Return);
END EmptyRect;

PROCEDURE OffsetRect(VAR r:Rect;dh,dv:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A8H);
	CODE(RestoreA7);CODE(Return);
END OffsetRect;
PROCEDURE MapRect(VAR r:Rect;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8FAH);
	CODE(RestoreA7);CODE(Return);
END MapRect;
PROCEDURE InsetRect(VAR r:Rect;dh,dv:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A9H);
	CODE(RestoreA7);CODE(Return);
END InsetRect;
PROCEDURE SectRect (VAR src1,src2:Rect;VAR dstRect:Rect):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8AAH);
	CODE(RestoreA7);CODE(Return);
END SectRect;
PROCEDURE UnionRect(VAR src1,src2:Rect;VAR dstRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8ABH);
	CODE(RestoreA7);CODE(Return);
END UnionRect;
PROCEDURE xPtInRect(pt: LONGINT;VAR dstRect:Rect):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8ADH);
	CODE(RestoreA7);CODE(Return);
END xPtInRect;
PROCEDURE PtInRect(pt: Point;dstRect:Rect):BOOLEAN;
(*$P+*)(*$S-*)
BEGIN
	RETURN(xPtInRect(pt.param,dstRect));
END PtInRect;

PROCEDURE	xPt2Rect (pt1,pt2:LONGINT;VAR dstRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8ACH);
	CODE(RestoreA7);CODE(Return);
END xPt2Rect;
PROCEDURE	Pt2Rect (pt1,pt2:Point;VAR dstRect:Rect);
(*$P+*)(*$S-*)
BEGIN
	xPt2Rect(pt1.param,pt2.param,dstRect)
END Pt2Rect;

(* Graphical Operations on Rectangles *)
PROCEDURE FrameRect  (VAR r: Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A1H);
	CODE(RestoreA7);CODE(Return);
END FrameRect;
PROCEDURE PaintRect  (VAR r: Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A2H);
	CODE(RestoreA7);CODE(Return);
END PaintRect;
PROCEDURE EraseRect  (VAR r: Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A3H);
	CODE(RestoreA7);CODE(Return);
END EraseRect;
PROCEDURE InvertRect (VAR r: Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A4H);
	CODE(RestoreA7);CODE(Return);
END InvertRect;
PROCEDURE FillRect   (VAR r: Rect;VAR  pat: Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8A5H);
	CODE(RestoreA7);CODE(Return);
END FillRect;

(* RoundRect Routines *)
PROCEDURE FrameRoundRect(VAR theRect:Rect;cornerWidth,cornerHeigth:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B0H);
	CODE(RestoreA7);CODE(Return);
END FrameRoundRect;
PROCEDURE PaintRoundRect(VAR theRect:Rect;cornerWidth,cornerHeight:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B1H);
	CODE(RestoreA7);CODE(Return);
END PaintRoundRect;
PROCEDURE FillRoundRect(VAR theRect:Rect;
		cornerWidth,cornerHeigth:INTEGER;
		VAR fillPat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B4H);
	CODE(RestoreA7);CODE(Return);
END FillRoundRect;
PROCEDURE EraseRoundRect(VAR theRect:Rect;cornerWidth,cornerHeight:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B2H);
	CODE(RestoreA7);CODE(Return);
END EraseRoundRect;
PROCEDURE InvertRoundRect(VAR theRect:Rect;cornerWidth,cornerHeigth:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B3H);
	CODE(RestoreA7);CODE(Return);
END InvertRoundRect;

(* Drawing Ovals *)
PROCEDURE FrameOval(VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B7H);
	CODE(RestoreA7);CODE(Return);
END FrameOval;
PROCEDURE PaintOval(VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B8H);
	CODE(RestoreA7);CODE(Return);
END PaintOval;
PROCEDURE EraseOval(VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8B9H);
	CODE(RestoreA7);CODE(Return);
END EraseOval;
PROCEDURE InvertOval(VAR inRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8BAH);
	CODE(RestoreA7);CODE(Return);
END InvertOval;
PROCEDURE FillOval(VAR inRect:Rect;VAR pat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8BBH);
	CODE(RestoreA7);CODE(Return);
END FillOval;

(* Arc Routines *)
PROCEDURE FrameArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8BEH);
	CODE(RestoreA7);CODE(Return);
END FrameArc;
PROCEDURE PaintArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8BFH);
	CODE(RestoreA7);CODE(Return);
END PaintArc;
PROCEDURE FillArc(VAR inRect:Rect;
	startAngle,arcAngle:INTEGER;
	VAR fillpat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C2H);
	CODE(RestoreA7);CODE(Return);
END FillArc;
PROCEDURE EraseArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C0H);
	CODE(RestoreA7);CODE(Return);
END EraseArc;
PROCEDURE InvertArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C1H);
	CODE(RestoreA7);CODE(Return);
END InvertArc;
PROCEDURE xPtToAngle(VAR inRect:Rect;P:LONGINT;VAR theAngle:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C3H);
	CODE(RestoreA7);CODE(Return);
END xPtToAngle;
PROCEDURE PtToAngle (inRect:Rect;thePoint:Point;VAR theAngle:INTEGER);
(*$P+*)(*$S-*)
BEGIN
	xPtToAngle(inRect,thePoint.param,theAngle)
END PtToAngle;

(* Polygon Routines *)
PROCEDURE OpenPoly():PolyHandle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CBH);
	CODE(RestoreA7);CODE(Return);
END OpenPoly;
PROCEDURE ClosePoly;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CCH);
	CODE(RestoreA7);CODE(Return);
END ClosePoly;
PROCEDURE KillPoly(thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CDH);
	CODE(RestoreA7);CODE(Return);
END KillPoly;
PROCEDURE OffsetPoly(thePolygon:PolyHandle;hOffset,vOffset:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CEH);
	CODE(RestoreA7);CODE(Return);
END OffsetPoly;
PROCEDURE MapPoly (thePolygon:PolyHandle;VAR fromRect,toRect:Rect);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8FCH);
	CODE(RestoreA7);CODE(Return);
END MapPoly;
PROCEDURE FramePoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C6H);
	CODE(RestoreA7);CODE(Return);
END FramePoly;
PROCEDURE PaintPoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C7H);
	CODE(RestoreA7);CODE(Return);
END PaintPoly;
PROCEDURE FillPoly (thePolygon:PolyHandle;VAR fillPat:Pattern);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8CAH);
	CODE(RestoreA7);CODE(Return);
END FillPoly;
PROCEDURE ErasePoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C8H);
	CODE(RestoreA7);CODE(Return);
END ErasePoly;
PROCEDURE InvertPoly (thePolygon:PolyHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8C9H);
	CODE(RestoreA7);CODE(Return);
END InvertPoly;

(* Graphical Operations on BitMaps *)
PROCEDURE ScrollRect(VAR dstRect:Rect;dh,dv:INTEGER;updateRgn:RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8EFH);
	CODE(RestoreA7);CODE(Return);
END ScrollRect;
PROCEDURE CopyBits  (VAR srcBits,dstBits: BitMap;
                     VAR srcRect,dstRect: Rect;
                     mode:            INTEGER;
                     maskRgn:         RgnHandle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A8ECH);
	CODE(RestoreA7);CODE(Return);
END CopyBits;
(* later...
PROCEDURE SetStdProcs
PROCEDURE StdText
PROCEDURE StdLine
PROCEDURE StdRect
PROCEDURE StdRRect
PROCEDURE StdOval
PROCEDURE StdArc
PROCEDURE StdPoly
PROCEDURE StdRgn
PROCEDURE StdBits
PROCEDURE StdComment
PROCEDURE StdTxMeas
PROCEDURE StdGetPic
PROCEDURE StdPutPic
*)
(* Misc Utility Routines *)
PROCEDURE GetPixel(h,v:INTEGER):BOOLEAN;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A865H);
	CODE(RestoreA7);CODE(Return);
END GetPixel;
PROCEDURE ForeColor (color:LONGINT);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A862H);
	CODE(RestoreA7);CODE(Return);
END ForeColor;
PROCEDURE BackColor (color:LONGINT);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A863H);
	CODE(RestoreA7);CODE(Return);
END BackColor;
PROCEDURE ColorBit (whichBit:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A864H);
	CODE(RestoreA7);CODE(Return);
END ColorBit;

BEGIN
	InitGraf(ADR(thePort));
END QuickDraw.
!Funky!Stuff!
echo x - ResourceManager.MOD
cat >ResourceManager.MOD <<'!Funky!Stuff!'
IMPLEMENTATION MODULE ResourceManager;
FROM SYSTEM IMPORT ADDRESS,CODE,ADR;
FROM MacSYSTEM IMPORT LONGINT,Handle;
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 *)


(* Opening and Closing Resource Files *)
PROCEDURE xCreateResFile(fileName:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9B1H);
	CODE(RestoreA7);CODE(Return);
END xCreateResFile;
PROCEDURE CreateResFile(VAR fileName:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(fileName,Str);
	xCreateResFile(ADR(Str))
END CreateResFile;

PROCEDURE xOpenResFile(fileName:ADDRESS):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A997H);
	CODE(RestoreA7);CODE(Return);
END xOpenResFile;
PROCEDURE OpenResFile(VAR fileName:ARRAY OF CHAR):INTEGER;
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(fileName,Str);
	RETURN(xOpenResFile(ADR(Str)))
END OpenResFile;

PROCEDURE CloseResFile(refNum:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99AH);
	CODE(RestoreA7);CODE(Return);
END CloseResFile;

(* Checking for Errors *)
PROCEDURE ResError():INTEGER;
BEGIN
	RETURN(ResErr);
END ResError;

(* Setting the Current Resource File *)
PROCEDURE CurResFile():INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A994H);
	CODE(RestoreA7);CODE(Return);
END CurResFile;

PROCEDURE HomeResFile(theResource:Handle):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A4H);
	CODE(RestoreA7);CODE(Return);
END HomeResFile;

PROCEDURE UseResFile(refNum:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A998H);
	CODE(RestoreA7);CODE(Return);
END UseResFile;

(* Getting Resource Types *)
PROCEDURE CountTypes():INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99EH);
	CODE(RestoreA7);CODE(Return);
END CountTypes;

PROCEDURE GetIndType(VAR theType:ResType;index:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99FH);
	CODE(RestoreA7);CODE(Return);
END GetIndType;


(* Getting and Disposing of Resources *)
PROCEDURE SetResLoad(load:BOOLEAN);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99BH);
	CODE(RestoreA7);CODE(Return);
END SetResLoad;
PROCEDURE xCountResources(theType:LONGINT):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99CH);
	CODE(RestoreA7);CODE(Return);
END xCountResources;
PROCEDURE CountResources(theType:ResType):INTEGER;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	RETURN(xCountResources(x.param))
END CountResources;

PROCEDURE xGetIndResource(theType:LONGINT;index:INTEGER):Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A99DH);
	CODE(RestoreA7);CODE(Return);
END xGetIndResource;
PROCEDURE GetIndResource(theType:ResType;index:INTEGER):Handle;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	RETURN(xGetIndResource(x.param,index))
END GetIndResource;

PROCEDURE xGetResource(theType:LONGINT;theID:INTEGER):Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A0H);
	CODE(RestoreA7);CODE(Return);
END xGetResource;
PROCEDURE GetResource(theType:ResType;theID:INTEGER):Handle;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	RETURN(xGetResource(x.param,theID))
END GetResource;

PROCEDURE xGetNamedResource(theType:LONGINT;name:ADDRESS):Handle;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A1H);
	CODE(RestoreA7);CODE(Return);
END xGetNamedResource;
PROCEDURE GetNamedResource(theType:ResType;VAR name:ARRAY OF CHAR):Handle;
(*$P+*)(*$S-*)
VAR
	x:ParamResType;
	Str:ARRAY [0..255] OF CHAR;
BEGIN
	x.res := theType;
	MakePascalString(name,Str);
	RETURN(xGetNamedResource(x.param,ADR(Str)))
END GetNamedResource;

PROCEDURE LoadResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A2H);
	CODE(RestoreA7);CODE(Return);
END LoadResource;
PROCEDURE ReleaseResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A3H);
	CODE(RestoreA7);CODE(Return);
END ReleaseResource;
PROCEDURE DetachResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A992H);
	CODE(RestoreA7);CODE(Return);
END DetachResource;

(* Getting Resource Information *)
PROCEDURE xUniqueID(theType:LONGINT):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9ABH);
	CODE(RestoreA7);CODE(Return);
END xUniqueID;
PROCEDURE UniqueID(theType:ResType):INTEGER;
(*$P+*)(*$S-*)
VAR x:ParamResType;
BEGIN
	x.res := theType;
	RETURN(xUniqueID(x.param))
END UniqueID;

PROCEDURE xGetResInfo(theResource:Handle;VAR theID:INTEGER;
	VAR theType:ResType; name:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A8H);
	CODE(RestoreA7);CODE(Return);
END xGetResInfo;
PROCEDURE GetResInfo(theResource:Handle;VAR theID:INTEGER;
	VAR theType:ResType; VAR name:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	xGetResInfo(theResource,theID,theType,ADR(Str));
	MakeModulaString(Str,name)
END GetResInfo;
PROCEDURE GetResAttrs(theResource:Handle):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A6H);
	CODE(RestoreA7);CODE(Return);
END GetResAttrs;
PROCEDURE SizeResource(theResource:Handle):LONGINT;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A5H);
	CODE(RestoreA7);CODE(Return);
END SizeResource;

(* Modifying Resources *)
PROCEDURE xSetResInfo(theResource:Handle; theID:INTEGER;name:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A9H);
	CODE(RestoreA7);CODE(Return);
END xSetResInfo;
PROCEDURE SetResInfo(theResource:Handle; theID:INTEGER;VAR name:ARRAY OF CHAR);
(*$P+*)(*$S-*)
VAR Str:ARRAY [0..255] OF CHAR;
BEGIN
	MakePascalString(name,Str);
	xSetResInfo(theResource,theID,ADR(Str))
END SetResInfo;

PROCEDURE SetResAttrs(theResource:Handle;attrs:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9A7H);
	CODE(RestoreA7);CODE(Return);
END SetResAttrs;
PROCEDURE ChangedResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9AAH);
	CODE(RestoreA7);CODE(Return);
END ChangedResource;
PROCEDURE xAddResource(theData:Handle;theType:LONGINT;theID:INTEGER;
	name:ADDRESS);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9ABH);
	CODE(RestoreA7);CODE(Return);
END xAddResource;
PROCEDURE AddResource(theData:Handle;theType:ResType;theID:INTEGER;
	VAR name:ARRAY OF CHAR);
(*$P+*)(*$S+*)
VAR Str:ARRAY [0..255] OF CHAR;
	x:ParamResType;
BEGIN
	x.res := theType;
	MakePascalString(name,Str);
	xAddResource(theData,x.param,theID,ADR(Str));
END AddResource;

PROCEDURE RmveResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9ADH);
	CODE(RestoreA7);CODE(Return);
END RmveResource;
PROCEDURE UpdateResFile(refNum:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A999H);
	CODE(RestoreA7);CODE(Return);
END UpdateResFile;
PROCEDURE WriteResource(theResource:Handle);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9B0H);
	CODE(RestoreA7);CODE(Return);
END WriteResource;
PROCEDURE SetResPurge(install:BOOLEAN);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A993H);
	CODE(RestoreA7);CODE(Return);
END SetResPurge;

(* Advanced Routines *)
PROCEDURE GetResFileAttrs(refNum:INTEGER):INTEGER;
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9F6H);
	CODE(RestoreA7);CODE(Return);
END GetResFileAttrs;
PROCEDURE SetResFileAttrs(refNum:INTEGER;attrs:INTEGER);
(*$P-*)
BEGIN
	CODE(GetRet);CODE(SaveA7);
	CODE(0A9F7H);
	CODE(RestoreA7);CODE(Return);
END SetResFileAttrs;

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

FROM    SYSTEM IMPORT ADDRESS,WORD,ADR,CODE,REGISTER,SETREG;
FROM	MacSYSTEM IMPORT LONGINT;
FROM	QuickDraw IMPORT Point;
FROM	FileTypes IMPORT OSType;
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 *)
	Pack3       = 0A9EAH;
	SFGetF      = 2;
	SFPGetF     = 4;
	SFPPutF		= 3;
	SFPutF		= 1;
	Push        = 03F3CH;     (* MOVE #VAL,-(A7) *)

PROCEDURE NoDlg():ADDRESS; (*??*)
BEGIN
	RETURN(ADDRESS(0))
END NoDlg;

VAR	ProcDlg	:	MyDlgType;

PROCEDURE DlgInterface;
(*$P-*)
BEGIN
	CODE(04E56H);CODE(0);		(* LINK    A6,#0				*)
	CODE(048E7H);CODE(0FFFCH);	(* MOVEM.L D0-D7/A0-A5,-(A7)	*)
	CODE(02F2EH);CODE(0AH);		(* MOVE.L  0A(A6),-(A7)			*)
	CODE(03F2EH);CODE(08H);		(* MOVE.W  08(A6),-(A7)			*)
	SETREG(8,ProcDlg);
	CODE(04E90H);				(* JSR     (A6)                 *)
	CODE(05C8FH);				(* ADDQ.L  #6,A7				*)
	CODE(04CDFH);CODE(03FFFH);	(* MOVEM.L (A7)+,D0-D7/A0-A4	*)
	CODE(04E5EH);				(* UNLK    A6                   *)
	CODE(02F5FH);CODE(2H);		(* MOVE.L  (A7)+,2(A7)          *)
	CODE(0548FH);				(* ADDQ.L  #2,A7                *)
	CODE(04E75H);				(* RTS							*)
END DlgInterface;

PROCEDURE UseDlg(Dlg:MyDlgType):ADDRESS;
(*$P+*)(*$S-*)
BEGIN
	ProcDlg := Dlg;
	SETREG(8,DlgInterface);
	RETURN(REGISTER(8))
END UseDlg;

PROCEDURE NoFileFilter():ADDRESS;
BEGIN
	RETURN(ADDRESS(0))
END NoFileFilter;

VAR	ProcFilter	:	MyFileFilterType;

PROCEDURE FilterInterface;
(*$P-*)
BEGIN
	CODE(04E56H);CODE(0);			(* LINK    A6,#0					*)
	CODE(048E7H);CODE(0FFFCH);	(* MOVEM.L D0-D7/A0-A5,-(A7)	*)
	CODE(02F2EH);CODE(08H);		(* MOVE.L  0A(A6),-(A7)			*)
	SETREG(8,ProcFilter);
	CODE(04E90H);					(* JSR		(A6)					*)
	CODE(0588FH);					(* ADDQ.L	#4,A7					*)
	CODE(04CDFH);CODE(03FFFH);	(* MOVEM.L (A7)+,D0-D7/A0-A4	*)
	CODE(04E5EH);					(* UNLK	A6						*)
	CODE(02E9FH);					(* MOVE.L	(A7)+,(A7)				*)
	CODE(04E75H);					(* RTS								*)
END FilterInterface;

PROCEDURE UseFileFilter(FileFilter:MyFileFilterType):ADDRESS;
(*$P+*)(*$S-*)
BEGIN
	ProcFilter := FileFilter;
	SETREG(8,FilterInterface);
	RETURN(REGISTER(8))
END UseFileFilter;

PROCEDURE xSFPutFile(lefttop:LONGINT;prompt: ADDRESS;
	origName: ADDRESS;dlgHook: ADDRESS;
	VAR reply: SFReply);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFPutF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFPutFile;

PROCEDURE SFPutFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
	VAR origName: ARRAY OF CHAR;dlgHook: ADDRESS;
	VAR reply: SFReply);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name:ARRAY [0..63] OF CHAR;
	I:CARDINAL;
BEGIN
	MakePascalString(prompt,p);
	MakePascalString(origName,name);
	xSFPutFile(lefttop.param,ADR(p),ADR(name),dlgHook,reply);
	MakeModulaString(reply.fName,name);
	FOR I := 0 TO 63 DO
		reply.fName[I] := name[I]
	END
END SFPutFile;

PROCEDURE xSFPPutFile(lefttop:LONGINT;prompt: ADDRESS;
  origName: ADDRESS;dlgHook: ADDRESS; VAR reply: SFReply;
  dlgID: INTEGER;filterProc: ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFPPutF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFPPutFile;
 
PROCEDURE SFPPutFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
  VAR origName: ARRAY OF CHAR;dlgHook: ADDRESS; VAR reply: SFReply;
  dlgID: INTEGER;filterProc: ADDRESS);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name:ARRAY [0..63] OF CHAR;
	I:INTEGER;
BEGIN
  MakePascalString(prompt,p);
  MakePascalString(origName,name);
  xSFPPutFile(lefttop.param,ADR(p),ADR(name),dlgHook,reply,dlgID,filterProc);
  MakeModulaString(reply.fName,name);
	FOR I := 0 TO 63 DO
		reply.fName[I] := name[I]
	END
END SFPPutFile;

PROCEDURE xSFGetFile(lefttop:LONGINT;prompt: ADDRESS;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFGetF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFGetFile;

PROCEDURE SFGetFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
    name : ARRAY [0..63] OF CHAR;
	I:INTEGER;
BEGIN
	MakePascalString(prompt,p);
	xSFGetFile(lefttop.param,ADR(p),fileFilter,numTypes,typeList,
	dlgHook,reply);
	MakeModulaString(reply.fName,name);
	FOR I := 0 TO 63 DO
		reply.fName[I] := name[I]
	END
END SFGetFile;

PROCEDURE xSFPGetFile(lefttop:LONGINT;prompt: ADDRESS;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply; dlgID: INTEGER;
    filterProc: ADDRESS);
(*$P-*)
BEGIN
  CODE(GetRet);
  CODE(SaveA7);
  CODE(Push);
  CODE(SFPGetF);
  CODE(Pack3);
  CODE(RestoreA7);
  CODE(Return);
END xSFPGetFile;
 
PROCEDURE SFPGetFile(lefttop:Point;VAR prompt: ARRAY OF CHAR;
    fileFilter: ADDRESS;numTypes: INTEGER; VAR typeList: SFTypeList;
    dlgHook: ADDRESS; VAR reply: SFReply; dlgID: INTEGER;
    filterProc: ADDRESS);
(*$P+*)(*$S-*)
VAR p:ARRAY [0..255] OF CHAR;
	name:ARRAY [0..63] OF CHAR;
	I:INTEGER;
BEGIN
	MakePascalString(prompt,p);
	xSFPGetFile(lefttop.param,ADR(p),fileFilter,numTypes,typeList,
	dlgHook,reply,dlgID,filterProc);
	MakeModulaString(reply.fName,name);
	FOR I := 0 TO 63 DO
		reply.fName[I] := name[I]
	END
END SFPGetFile;

END  SFPackage.
!Funky!Stuff!