home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / Modula / Source / MemoryManager.MOD < prev    next >
Text File  |  1988-01-24  |  8KB  |  420 lines
  1. IMPLEMENTATION MODULE MemoryManager;
  2. (* C.Pfister 11-Jan-87
  3.    - MaxApplZone and MoveHHi only implemented for the 128K ROMs *)
  4.  
  5. FROM OSUtilities IMPORT GetLong;
  6. FROM MacTypes    IMPORT Ptr, Handle, ProcPtr, THz, Size, OSErr, Byte;
  7. FROM SYSTEM      IMPORT INLINE, ADR, ADDRESS, SHORT, VAL, REG, SETREG, LONG;
  8.  
  9. CONST
  10.   D0 = 0;
  11.   A0 = 8;
  12.   A1 = 9;
  13.  
  14. VAR err: INTEGER;
  15.  
  16.  
  17.   PROCEDURE InitApplZone;
  18.   BEGIN
  19.     INLINE(0A02CH);
  20.     err := SHORT(REG(D0))
  21.   END InitApplZone;
  22.   
  23.   PROCEDURE SetApplBase(startPtr: Ptr);
  24.   BEGIN 
  25.     SETREG(A0,startPtr); 
  26.     INLINE(0A057H);
  27.     err := SHORT(REG(D0))
  28.   END SetApplBase;
  29.   
  30.  
  31.   PROCEDURE InitZone(pgrowZone:    ProcPtr; 
  32.                      cmoreMasters: INTEGER;
  33.                      limitPtr,
  34.                      startPtr :    Ptr);
  35.   BEGIN
  36.     SETREG(A0,ADR(startPtr));
  37.     INLINE(0A019H);
  38.     err := SHORT(REG(D0))
  39.   END InitZone;
  40.  
  41.   PROCEDURE GetApplLimit(): Ptr;
  42.   VAR l: LONGINT;
  43.   BEGIN
  44.     RETURN GetLong(130H)
  45.   END GetApplLimit;
  46.  
  47.   PROCEDURE SetApplLimit(zoneLimit: Ptr);
  48.   BEGIN
  49.     SETREG(A0,zoneLimit);
  50.     INLINE(0A02DH);
  51.     err := SHORT(REG(D0))
  52.   END SetApplLimit;
  53.  
  54.   PROCEDURE MaxApplZone;
  55.   BEGIN
  56.     INLINE(0A063H);
  57.     err := SHORT(REG(D0))
  58.   END MaxApplZone;
  59.  
  60.   PROCEDURE MoreMasters;
  61.   BEGIN
  62.     INLINE(0A036H);
  63.     err := SHORT(REG(D0))
  64.   END MoreMasters;
  65.  
  66.  
  67.   PROCEDURE GetZone(): THz;
  68.   BEGIN
  69.     INLINE(0A11AH);
  70.     err := SHORT(REG(D0));
  71.     RETURN VAL(THz,REG(A0))
  72.   END GetZone;
  73.  
  74.   PROCEDURE SetZone(hz: THz);
  75.   BEGIN
  76.     SETREG(A0,hz);
  77.     INLINE(0A01BH);
  78.     err := SHORT(REG(D0))
  79.   END SetZone;
  80.  
  81.   PROCEDURE ApplicZone(): THz;
  82.   BEGIN
  83.     RETURN GetLong(2AAH)
  84.   END ApplicZone;
  85.   
  86.   PROCEDURE SystemZone(): THz;
  87.   BEGIN
  88.     RETURN GetLong(2A6H)
  89.   END SystemZone;
  90.  
  91.  
  92.   PROCEDURE NewHandle(byteCount: Size): ADDRESS;
  93.   BEGIN
  94.     SETREG(D0,byteCount);
  95.     INLINE(0A122H);
  96.     err := SHORT(REG(D0));
  97.     RETURN REG(A0)
  98.   END NewHandle;
  99.   
  100.   PROCEDURE DisposHandle(h: ADDRESS);
  101.   BEGIN
  102.     SETREG(A0,h);
  103.     INLINE(0A023H);
  104.     err := SHORT(REG(D0))
  105.   END DisposHandle;
  106.   
  107.   PROCEDURE GetHandleSize(h: ADDRESS): Size;
  108.   VAR Res: LONGINT;
  109.   BEGIN
  110.     SETREG(A0,h);
  111.     INLINE(0A025H);
  112.     Res := REG(D0);
  113.     IF Res > 0D THEN
  114.       err := 0; RETURN Res
  115.     ELSE
  116.       err := SHORT(Res); RETURN 0
  117.     END
  118.   END GetHandleSize;
  119.   
  120.   PROCEDURE SetHandleSize(h: ADDRESS; newSize: Size);
  121.   BEGIN
  122.     SETREG(A0,h);
  123.     SETREG(D0,newSize);
  124.     INLINE(0A024H);
  125.     err := SHORT(REG(D0))
  126.   END SetHandleSize;
  127.   
  128.   PROCEDURE HandleZone(h: ADDRESS): THz;
  129.   BEGIN
  130.     SETREG(A0,h);
  131.     INLINE(0A126H);
  132.     err := SHORT(REG(D0));
  133.     RETURN VAL(THz,REG(A0))
  134.   END HandleZone;
  135.   
  136.   PROCEDURE RecoverHandle(p: Ptr): ADDRESS;
  137.   BEGIN
  138.     SETREG(A0,p);
  139.     INLINE(0A128H);
  140.     err := 0;
  141.     RETURN REG(A0)
  142.   END RecoverHandle;
  143.   
  144.   PROCEDURE ReallocHandle(h: ADDRESS; byteCount: Size);
  145.   BEGIN
  146.     SETREG(A0,h);
  147.     SETREG(D0,byteCount);
  148.     INLINE(0A027H);
  149.     err := SHORT(REG(D0))
  150.   END ReallocHandle;
  151.  
  152.  
  153.   PROCEDURE NewPtr(byteCount: Size): Ptr;
  154.   BEGIN
  155.     SETREG(D0,byteCount);
  156.     INLINE(0A11EH);
  157.     err := SHORT(REG(D0));
  158.     RETURN REG(A0)
  159.   END NewPtr;
  160.   
  161.   PROCEDURE DisposPtr(p: Ptr);
  162.   BEGIN
  163.     SETREG(A0,p);
  164.     INLINE(0A01FH);
  165.     err := SHORT(REG(D0))
  166.   END DisposPtr;
  167.  
  168.   PROCEDURE GetPtrSize(p: Ptr): Size;
  169.   VAR Res: LONGINT;
  170.   BEGIN
  171.     SETREG(A0,p);
  172.     INLINE(0A021H);
  173.     Res := REG(D0);
  174.     IF Res > 0D THEN
  175.       err := 0; RETURN VAL(Size,Res)
  176.     ELSE
  177.       err := SHORT(Res); RETURN 0
  178.     END
  179.   END GetPtrSize;
  180.   
  181.   PROCEDURE SetPtrSize(p: Ptr; newSize: Size);
  182.   BEGIN
  183.     SETREG(A0,p);
  184.     SETREG(D0,newSize);
  185.     INLINE(0A020H);
  186.     err := SHORT(REG(D0))
  187.   END SetPtrSize;
  188.   
  189.   PROCEDURE PtrZone(p: Ptr): THz;
  190.   BEGIN
  191.     SETREG(A0,p);
  192.     INLINE(0A148H);
  193.     err := SHORT(REG(D0));
  194.     RETURN VAL(THz,REG(A0))
  195.   END PtrZone;
  196.  
  197.  
  198.   PROCEDURE FreeMem(): LONGINT;
  199.   BEGIN
  200.     INLINE(0A01CH);
  201.     err := 0;
  202.     RETURN REG(D0)
  203.   END FreeMem;
  204.   
  205.   PROCEDURE MaxMem(VAR grow: Size): Size;
  206.   BEGIN
  207.     INLINE(0A11DH);
  208.     err := 0;
  209.     grow := VAL(Size,REG(A0));
  210.     RETURN REG(D0)
  211.   END MaxMem;
  212.  
  213.   PROCEDURE CompactMem(cbNeeded: Size): Size;
  214.   BEGIN
  215.     SETREG(D0,cbNeeded);
  216.     INLINE(0A04CH);
  217.     err := 0;
  218.     RETURN REG(D0)
  219.   END CompactMem;
  220.  
  221.   PROCEDURE ResrvMem(cbNeeded: Size);
  222.   BEGIN
  223.     SETREG(D0,cbNeeded);
  224.     INLINE(0A040H);
  225.     err := SHORT(REG(D0))
  226.   END ResrvMem;
  227.  
  228.   PROCEDURE PurgeMem(cbNeeded: Size);
  229.   BEGIN
  230.     SETREG(D0,cbNeeded);
  231.     INLINE(0A04DH);
  232.     err := SHORT(REG(D0))
  233.   END PurgeMem;
  234.   
  235.   PROCEDURE EmptyHandle(h: ADDRESS);
  236.   BEGIN
  237.     SETREG(A0,h);
  238.     INLINE(0A02BH);
  239.     err := SHORT(REG(D0))
  240.   END EmptyHandle;
  241.  
  242.  
  243.   PROCEDURE HLock(h: ADDRESS);
  244.   BEGIN
  245.     SETREG(A0,h);
  246.     INLINE(0A029H);
  247.     err := SHORT(REG(D0))
  248.   END HLock;
  249.  
  250.   PROCEDURE HUnlock(h: ADDRESS);
  251.   BEGIN
  252.     SETREG(A0,h);
  253.     INLINE(0A02AH);
  254.     err := SHORT(REG(D0))
  255.   END HUnlock;
  256.   
  257.   PROCEDURE HPurge(h: ADDRESS);
  258.   BEGIN
  259.     SETREG(A0,h);
  260.     INLINE(0A049H);
  261.     err := SHORT(REG(D0))
  262.   END HPurge;
  263.   
  264.   PROCEDURE HNoPurge(h: ADDRESS);
  265.   BEGIN
  266.     SETREG(A0,h);
  267.     INLINE(0A04AH);
  268.     err := SHORT(REG(D0))
  269.   END HNoPurge;
  270.  
  271.  
  272.   PROCEDURE SetGrowZone(growZone: ProcPtr);
  273.   BEGIN
  274.     SETREG(A0,growZone);
  275.     INLINE(0A04BH);
  276.     err := SHORT(REG(D0))
  277.   END SetGrowZone;
  278.   
  279.   PROCEDURE GZSaveHnd(): ADDRESS;
  280.   BEGIN
  281.     RETURN GetLong(328H)
  282.   END GZSaveHnd;
  283.  
  284.  
  285.   PROCEDURE BlockMove(srcPtr, destPtr: Ptr; byteCount: Size);
  286.   BEGIN
  287.     SETREG(A0,srcPtr);
  288.     SETREG(A1,destPtr);
  289.     SETREG(D0,byteCount);
  290.     INLINE(0A02EH);
  291.     err := SHORT(REG(D0))
  292.   END BlockMove;
  293.   
  294.   PROCEDURE TopMem(): Ptr;
  295.   BEGIN
  296.     RETURN GetLong(108H)
  297.   END TopMem;
  298.  
  299.   PROCEDURE MoveHHi(h: ADDRESS);
  300.   BEGIN
  301.     SETREG(A0,h);
  302.     INLINE(0A064H);
  303.     err := SHORT(REG(D0))
  304.   END MoveHHi;
  305.  
  306.   PROCEDURE MemError(): OSErr;
  307.   BEGIN
  308.     RETURN err 
  309.   END MemError;
  310.  
  311.  
  312.   PROCEDURE HandToHand(VAR theHndl: ADDRESS): OSErr; 
  313.   BEGIN
  314.     SETREG(A0,theHndl);
  315.     INLINE(0A9E1H);
  316.     err := SHORT(REG(D0));
  317.     theHndl := REG(A0);
  318.     RETURN err
  319.   END HandToHand;
  320.   
  321.   PROCEDURE PtrToHand(srcPtr: Ptr; VAR dstHndl: ADDRESS;
  322.                       size: LONGINT): OSErr;
  323.   BEGIN
  324.     SETREG(A0,srcPtr);
  325.     SETREG(D0,size);
  326.     INLINE(0A9E3H);
  327.     err := SHORT(REG(D0));
  328.     dstHndl := REG(A0);
  329.     RETURN err
  330.   END PtrToHand;
  331.  
  332.   PROCEDURE PtrToXHand(srcPtr: Ptr; dstHndl: ADDRESS;
  333.                        size: LONGINT): OSErr;
  334.   BEGIN
  335.     SETREG(A0,srcPtr);
  336.     SETREG(A1,dstHndl);
  337.     SETREG(D0,size);
  338.     INLINE(0A9E2H);
  339.     err := SHORT(REG(D0));
  340.     RETURN err
  341.   END PtrToXHand;
  342.  
  343.   PROCEDURE HandAndHand(hand1, hand2: ADDRESS): OSErr;
  344.   BEGIN
  345.     SETREG(A0,hand1);
  346.     SETREG(A1,hand2);
  347.     INLINE(0A9E4H);
  348.     err := SHORT(REG(D0));
  349.     RETURN err
  350.   END HandAndHand;
  351.  
  352.   PROCEDURE PtrAndHand(ptr: Ptr; hand: ADDRESS;
  353.                        size: LONGINT): OSErr;
  354.   BEGIN
  355.     SETREG(A0,ptr);
  356.     SETREG(A1,hand);
  357.     INLINE(0A9EFH);
  358.     err := SHORT(REG(D0));
  359.     RETURN err
  360.   END PtrAndHand;
  361.  
  362.  
  363.   PROCEDURE MaxBlock(): LONGINT;
  364.   BEGIN
  365.     INLINE(0A061H);
  366.     RETURN REG(D0)
  367.   END MaxBlock;
  368.  
  369.   PROCEDURE PurgeSpace(VAR total, contig: LONGINT);
  370.   BEGIN
  371.     INLINE(0A062H);
  372.     total  := REG(D0);
  373.     contig := REG(A0)
  374.   END PurgeSpace;
  375.  
  376.   PROCEDURE StackSpace(): LONGINT;
  377.   BEGIN
  378.     INLINE(0A065H);
  379.     RETURN REG(D0)
  380.   END StackSpace;
  381.  
  382.   PROCEDURE NewEmptyHandle(): ADDRESS;
  383.   BEGIN
  384.     INLINE(0A166H);        (* Error was 0A066H, = preserve A0 ! *)
  385.     err := SHORT(REG(D0));
  386.     RETURN REG(A0)
  387.   END NewEmptyHandle;
  388.  
  389.   PROCEDURE HSetRBit(h: ADDRESS);
  390.   BEGIN
  391.     SETREG(A0,h);
  392.     INLINE(0A067H);
  393.     err := SHORT(REG(D0))
  394.   END HSetRBit;
  395.  
  396.   PROCEDURE HClrRBit(h: ADDRESS);
  397.   BEGIN
  398.     SETREG(A0,h);
  399.     INLINE(0A68H);
  400.     err := SHORT(REG(D0))
  401.   END HClrRBit;
  402.  
  403.   PROCEDURE HGetState(h: ADDRESS): Byte;
  404.   BEGIN
  405.     SETREG(A0,h);
  406.     INLINE(0A069H);
  407.     RETURN CHR(SHORT(REG(D0)))
  408.   END HGetState;
  409.  
  410.   PROCEDURE HSetState(h: ADDRESS; flags: Byte);
  411.   BEGIN
  412.     SETREG(A0,h);
  413.     SETREG(D0,LONG(ORD(flags)));
  414.     INLINE(0A6AH);
  415.     err := SHORT(REG(D0))
  416.   END HSetState;
  417.  
  418.  
  419. END MemoryManager.
  420.