home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / LowMem.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  45.5 KB  |  1,839 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        LowMem.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT LowMem;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __LOWMEM__}
  27. {$SETC __LOWMEM__ := 1}
  28.  
  29. {$I+}
  30. {$SETC LowMemIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __CONTROLS__}
  40. {$I Controls.p}
  41. {$ENDC}
  42. {    Quickdraw.p                                                    }
  43. {        MixedMode.p                                                }
  44. {        QuickdrawText.p                                            }
  45. {    Menus.p                                                        }
  46. {        Memory.p                                                }
  47. {        Events.p                                                }
  48. {            OSUtils.p                                            }
  49.  
  50. {$IFC UNDEFINED __FILES__}
  51. {$I Files.p}
  52. {$ENDC}
  53.  
  54. {$IFC UNDEFINED __FONTS__}
  55. {$I Fonts.p}
  56. {$ENDC}
  57.  
  58. {$IFC UNDEFINED __RESOURCES__}
  59. {$I Resources.p}
  60. {$ENDC}
  61.  
  62. {$IFC UNDEFINED __WINDOWS__}
  63. {$I Windows.p}
  64. {$ENDC}
  65.  
  66. {$PUSH}
  67. {$ALIGN MAC68K}
  68. {$LibExport+}
  69. FUNCTION LMGetScrVRes : SInt16;
  70.     {$IFC NOT CFMSYSTEMCALLS}
  71.     INLINE $3EB8, $0102;            { MOVE.W $0102,(SP) }
  72.     {$ENDC}
  73.  
  74. PROCEDURE LMSetScrVRes( value: SInt16 );
  75.     {$IFC NOT CFMSYSTEMCALLS}
  76.     INLINE $31DF, $0102;            { MOVE.W (SP)+,$0102 }
  77.     {$ENDC}
  78.  
  79. FUNCTION LMGetScrHRes : SInt16;
  80.     {$IFC NOT CFMSYSTEMCALLS}
  81.     INLINE $3EB8, $0104;            { MOVE.W $0104,(SP) }
  82.     {$ENDC}
  83.  
  84. PROCEDURE LMSetScrHRes( value: SInt16 );
  85.     {$IFC NOT CFMSYSTEMCALLS}
  86.     INLINE $31DF, $0104;            { MOVE.W (SP)+,$0104 }
  87.     {$ENDC}
  88.  
  89. FUNCTION LMGetMemTop : Ptr;
  90.     {$IFC NOT CFMSYSTEMCALLS}
  91.     INLINE $2EB8, $0108;            { MOVE.L $0108,(SP) }
  92.     {$ENDC}
  93.  
  94. PROCEDURE LMSetMemTop( value: Ptr );
  95.     {$IFC NOT CFMSYSTEMCALLS}
  96.     INLINE $21DF, $0108;            { MOVE.L (SP)+,$0108 }
  97.     {$ENDC}
  98.  
  99. FUNCTION LMGetBufPtr : Ptr;
  100.     {$IFC NOT CFMSYSTEMCALLS}
  101.     INLINE $2EB8, $010C;            { MOVE.L $010C,(SP) }
  102.     {$ENDC}
  103.  
  104. PROCEDURE LMSetBufPtr( value: Ptr );
  105.     {$IFC NOT CFMSYSTEMCALLS}
  106.     INLINE $21DF, $010C;            { MOVE.L (SP)+,$010C }
  107.     {$ENDC}
  108.  
  109. FUNCTION LMGetStackLowPoint : Ptr;
  110.     {$IFC NOT CFMSYSTEMCALLS}
  111.     INLINE $2EB8, $0110;            { MOVE.L $0110,(SP) }
  112.     {$ENDC}
  113.  
  114. PROCEDURE LMSetStackLowPoint( value: Ptr );
  115.     {$IFC NOT CFMSYSTEMCALLS}
  116.     INLINE $21DF, $0110;            { MOVE.L (SP)+,$0110 }
  117.     {$ENDC}
  118.  
  119. FUNCTION LMGetHeapEnd : Ptr;
  120.     {$IFC NOT CFMSYSTEMCALLS}
  121.     INLINE $2EB8, $0114;            { MOVE.L $0114,(SP) }
  122.     {$ENDC}
  123.  
  124. PROCEDURE LMSetHeapEnd( value: Ptr );
  125.     {$IFC NOT CFMSYSTEMCALLS}
  126.     INLINE $21DF, $0114;            { MOVE.L (SP)+,$0114 }
  127.     {$ENDC}
  128.  
  129. FUNCTION LMGetTheZone : THz;
  130.     {$IFC NOT CFMSYSTEMCALLS}
  131.     INLINE $2EB8, $0118;            { MOVE.L $0118,(SP) }
  132.     {$ENDC}
  133.  
  134. PROCEDURE LMSetTheZone( value: THz );
  135.     {$IFC NOT CFMSYSTEMCALLS}
  136.     INLINE $21DF, $0118;            { MOVE.L (SP)+,$0118 }
  137.     {$ENDC}
  138.  
  139. FUNCTION LMGetUTableBase : Ptr;
  140.     {$IFC NOT CFMSYSTEMCALLS}
  141.     INLINE $2EB8, $011C;            { MOVE.L $011C,(SP) }
  142.     {$ENDC}
  143.  
  144. PROCEDURE LMSetUTableBase( value: Ptr );
  145.     {$IFC NOT CFMSYSTEMCALLS}
  146.     INLINE $21DF, $011C;            { MOVE.L (SP)+,$011C }
  147.     {$ENDC}
  148.  
  149. FUNCTION LMGetCPUFlag : ByteParameter;
  150.     {$IFC NOT CFMSYSTEMCALLS}
  151.     INLINE $1EB8, $012F;            { MOVE.B $012F,(SP) }
  152.     {$ENDC}
  153.  
  154. PROCEDURE LMSetCPUFlag( value: ByteParameter );
  155.     {$IFC NOT CFMSYSTEMCALLS}
  156.     INLINE $11DF, $012F;            { MOVE.B (SP)+,$012F }
  157.     {$ENDC}
  158.  
  159. FUNCTION LMGetApplLimit : Ptr;
  160.     {$IFC NOT CFMSYSTEMCALLS}
  161.     INLINE $2EB8, $0130;            { MOVE.L $0130,(SP) }
  162.     {$ENDC}
  163.  
  164. PROCEDURE LMSetApplLimit( value: Ptr );
  165.     {$IFC NOT CFMSYSTEMCALLS}
  166.     INLINE $21DF, $0130;            { MOVE.L (SP)+,$0130 }
  167.     {$ENDC}
  168.  
  169. FUNCTION LMGetSysEvtMask : SInt16;
  170.     {$IFC NOT CFMSYSTEMCALLS}
  171.     INLINE $3EB8, $0144;            { MOVE.W $0144,(SP) }
  172.     {$ENDC}
  173.  
  174. PROCEDURE LMSetSysEvtMask( value: SInt16 );
  175.     {$IFC NOT CFMSYSTEMCALLS}
  176.     INLINE $31DF, $0144;            { MOVE.W (SP)+,$0144 }
  177.     {$ENDC}
  178.  
  179. FUNCTION LMGetRndSeed : SInt32;
  180.     {$IFC NOT CFMSYSTEMCALLS}
  181.     INLINE $2EB8, $0156;            { MOVE.L $0156,(SP) }
  182.     {$ENDC}
  183.  
  184. PROCEDURE LMSetRndSeed( value: SInt32 );
  185.     {$IFC NOT CFMSYSTEMCALLS}
  186.     INLINE $21DF, $0156;            { MOVE.L (SP)+,$0156 }
  187.     {$ENDC}
  188.  
  189. FUNCTION LMGetSEvtEnb : ByteParameter;
  190.     {$IFC NOT CFMSYSTEMCALLS}
  191.     INLINE $1EB8, $015C;            { MOVE.B $015C,(SP) }
  192.     {$ENDC}
  193.  
  194. PROCEDURE LMSetSEvtEnb( value: ByteParameter );
  195.     {$IFC NOT CFMSYSTEMCALLS}
  196.     INLINE $11DF, $015C;            { MOVE.B (SP)+,$015C }
  197.     {$ENDC}
  198.  
  199. FUNCTION LMGetTicks : SInt32;
  200.     {$IFC NOT CFMSYSTEMCALLS}
  201.     INLINE $2EB8, $016A;            { MOVE.L $016A,(SP) }
  202.     {$ENDC}
  203.  
  204. PROCEDURE LMSetTicks( value: SInt32 );
  205.     {$IFC NOT CFMSYSTEMCALLS}
  206.     INLINE $21DF, $016A;            { MOVE.L (SP)+,$016A }
  207.     {$ENDC}
  208.  
  209. FUNCTION LMGetKeyThresh : SInt16;
  210.     {$IFC NOT CFMSYSTEMCALLS}
  211.     INLINE $3EB8, $018E;            { MOVE.W $018E,(SP) }
  212.     {$ENDC}
  213.  
  214. PROCEDURE LMSetKeyThresh( value: SInt16 );
  215.     {$IFC NOT CFMSYSTEMCALLS}
  216.     INLINE $31DF, $018E;            { MOVE.W (SP)+,$018E }
  217.     {$ENDC}
  218.  
  219. FUNCTION LMGetKeyRepThresh : SInt16;
  220.     {$IFC NOT CFMSYSTEMCALLS}
  221.     INLINE $3EB8, $0190;            { MOVE.W $0190,(SP) }
  222.     {$ENDC}
  223.  
  224. PROCEDURE LMSetKeyRepThresh( value: SInt16 );
  225.     {$IFC NOT CFMSYSTEMCALLS}
  226.     INLINE $31DF, $0190;            { MOVE.W (SP)+,$0190 }
  227.     {$ENDC}
  228.  
  229. FUNCTION LMGetUnitTableEntryCount : SInt16;
  230.     {$IFC NOT CFMSYSTEMCALLS}
  231.     INLINE $3EB8, $01D2;            { MOVE.W $01D2,(SP) }
  232.     {$ENDC}
  233.  
  234. PROCEDURE LMSetUnitTableEntryCount( value: SInt16 );
  235.     {$IFC NOT CFMSYSTEMCALLS}
  236.     INLINE $31DF, $01D2;            { MOVE.W (SP)+,$01D2 }
  237.     {$ENDC}
  238.  
  239. FUNCTION LMGetVIA : Ptr;
  240.     {$IFC NOT CFMSYSTEMCALLS}
  241.     INLINE $2EB8, $01D4;            { MOVE.L $01D4,(SP) }
  242.     {$ENDC}
  243.  
  244. PROCEDURE LMSetVIA( value: Ptr );
  245.     {$IFC NOT CFMSYSTEMCALLS}
  246.     INLINE $21DF, $01D4;            { MOVE.L (SP)+,$01D4 }
  247.     {$ENDC}
  248.  
  249. FUNCTION LMGetSCCRd : Ptr;
  250.     {$IFC NOT CFMSYSTEMCALLS}
  251.     INLINE $2EB8, $01D8;            { MOVE.L $01D8,(SP) }
  252.     {$ENDC}
  253.  
  254. PROCEDURE LMSetSCCRd( value: Ptr );
  255.     {$IFC NOT CFMSYSTEMCALLS}
  256.     INLINE $21DF, $01D8;            { MOVE.L (SP)+,$01D8 }
  257.     {$ENDC}
  258.  
  259. FUNCTION LMGetSCCWr : Ptr;
  260.     {$IFC NOT CFMSYSTEMCALLS}
  261.     INLINE $2EB8, $01DC;            { MOVE.L $01DC,(SP) }
  262.     {$ENDC}
  263.  
  264. PROCEDURE LMSetSCCWr( value: Ptr );
  265.     {$IFC NOT CFMSYSTEMCALLS}
  266.     INLINE $21DF, $01DC;            { MOVE.L (SP)+,$01DC }
  267.     {$ENDC}
  268.  
  269. FUNCTION LMGetSPValid : ByteParameter;
  270.     {$IFC NOT CFMSYSTEMCALLS}
  271.     INLINE $1EB8, $01F8;            { MOVE.B $01F8,(SP) }
  272.     {$ENDC}
  273.  
  274. PROCEDURE LMSetSPValid( value: ByteParameter );
  275.     {$IFC NOT CFMSYSTEMCALLS}
  276.     INLINE $11DF, $01F8;            { MOVE.B (SP)+,$01F8 }
  277.     {$ENDC}
  278.  
  279. FUNCTION LMGetSPATalkA : ByteParameter;
  280.     {$IFC NOT CFMSYSTEMCALLS}
  281.     INLINE $1EB8, $01F9;            { MOVE.B $01F9,(SP) }
  282.     {$ENDC}
  283.  
  284. PROCEDURE LMSetSPATalkA( value: ByteParameter );
  285.     {$IFC NOT CFMSYSTEMCALLS}
  286.     INLINE $11DF, $01F9;            { MOVE.B (SP)+,$01F9 }
  287.     {$ENDC}
  288.  
  289. FUNCTION LMGetSPATalkB : ByteParameter;
  290.     {$IFC NOT CFMSYSTEMCALLS}
  291.     INLINE $1EB8, $01FA;            { MOVE.B $01FA,(SP) }
  292.     {$ENDC}
  293.  
  294. PROCEDURE LMSetSPATalkB( value: ByteParameter );
  295.     {$IFC NOT CFMSYSTEMCALLS}
  296.     INLINE $11DF, $01FA;            { MOVE.B (SP)+,$01FA }
  297.     {$ENDC}
  298.  
  299. FUNCTION LMGetSPConfig : ByteParameter;
  300.     {$IFC NOT CFMSYSTEMCALLS}
  301.     INLINE $1EB8, $01FB;            { MOVE.B $01FB,(SP) }
  302.     {$ENDC}
  303.  
  304. PROCEDURE LMSetSPConfig( value: ByteParameter );
  305.     {$IFC NOT CFMSYSTEMCALLS}
  306.     INLINE $11DF, $01FB;            { MOVE.B (SP)+,$01FB }
  307.     {$ENDC}
  308.  
  309. FUNCTION LMGetSPPortA : SInt16;
  310.     {$IFC NOT CFMSYSTEMCALLS}
  311.     INLINE $3EB8, $01FC;            { MOVE.W $01FC,(SP) }
  312.     {$ENDC}
  313.  
  314. PROCEDURE LMSetSPPortA( value: SInt16 );
  315.     {$IFC NOT CFMSYSTEMCALLS}
  316.     INLINE $31DF, $01FC;            { MOVE.W (SP)+,$01FC }
  317.     {$ENDC}
  318.  
  319. FUNCTION LMGetSPPortB : SInt16;
  320.     {$IFC NOT CFMSYSTEMCALLS}
  321.     INLINE $3EB8, $01FE;            { MOVE.W $01FE,(SP) }
  322.     {$ENDC}
  323.  
  324. PROCEDURE LMSetSPPortB( value: SInt16 );
  325.     {$IFC NOT CFMSYSTEMCALLS}
  326.     INLINE $31DF, $01FE;            { MOVE.W (SP)+,$01FE }
  327.     {$ENDC}
  328.  
  329. FUNCTION LMGetSPAlarm : SInt32;
  330.     {$IFC NOT CFMSYSTEMCALLS}
  331.     INLINE $2EB8, $0200;            { MOVE.L $0200,(SP) }
  332.     {$ENDC}
  333.  
  334. PROCEDURE LMSetSPAlarm( value: SInt32 );
  335.     {$IFC NOT CFMSYSTEMCALLS}
  336.     INLINE $21DF, $0200;            { MOVE.L (SP)+,$0200 }
  337.     {$ENDC}
  338.  
  339. FUNCTION LMGetSPFont : SInt16;
  340.     {$IFC NOT CFMSYSTEMCALLS}
  341.     INLINE $3EB8, $0204;            { MOVE.W $0204,(SP) }
  342.     {$ENDC}
  343.  
  344. PROCEDURE LMSetSPFont( value: SInt16 );
  345.     {$IFC NOT CFMSYSTEMCALLS}
  346.     INLINE $31DF, $0204;            { MOVE.W (SP)+,$0204 }
  347.     {$ENDC}
  348.  
  349. FUNCTION LMGetSPKbd : ByteParameter;
  350.     {$IFC NOT CFMSYSTEMCALLS}
  351.     INLINE $1EB8, $0206;            { MOVE.B $0206,(SP) }
  352.     {$ENDC}
  353.  
  354. PROCEDURE LMSetSPKbd( value: ByteParameter );
  355.     {$IFC NOT CFMSYSTEMCALLS}
  356.     INLINE $11DF, $0206;            { MOVE.B (SP)+,$0206 }
  357.     {$ENDC}
  358.  
  359. FUNCTION LMGetSPPrint : ByteParameter;
  360.     {$IFC NOT CFMSYSTEMCALLS}
  361.     INLINE $1EB8, $0207;            { MOVE.B $0207,(SP) }
  362.     {$ENDC}
  363.  
  364. PROCEDURE LMSetSPPrint( value: ByteParameter );
  365.     {$IFC NOT CFMSYSTEMCALLS}
  366.     INLINE $11DF, $0207;            { MOVE.B (SP)+,$0207 }
  367.     {$ENDC}
  368.  
  369. FUNCTION LMGetSPVolCtl : ByteParameter;
  370.     {$IFC NOT CFMSYSTEMCALLS}
  371.     INLINE $1EB8, $0208;            { MOVE.B $0208,(SP) }
  372.     {$ENDC}
  373.  
  374. PROCEDURE LMSetSPVolCtl( value: ByteParameter );
  375.     {$IFC NOT CFMSYSTEMCALLS}
  376.     INLINE $11DF, $0208;            { MOVE.B (SP)+,$0208 }
  377.     {$ENDC}
  378.  
  379. FUNCTION LMGetSPClikCaret : ByteParameter;
  380.     {$IFC NOT CFMSYSTEMCALLS}
  381.     INLINE $1EB8, $0209;            { MOVE.B $0209,(SP) }
  382.     {$ENDC}
  383.  
  384. PROCEDURE LMSetSPClikCaret( value: ByteParameter );
  385.     {$IFC NOT CFMSYSTEMCALLS}
  386.     INLINE $11DF, $0209;            { MOVE.B (SP)+,$0209 }
  387.     {$ENDC}
  388.  
  389. FUNCTION LMGetSPMisc2 : ByteParameter;
  390.     {$IFC NOT CFMSYSTEMCALLS}
  391.     INLINE $1EB8, $020B;            { MOVE.B $020B,(SP) }
  392.     {$ENDC}
  393.  
  394. PROCEDURE LMSetSPMisc2( value: ByteParameter );
  395.     {$IFC NOT CFMSYSTEMCALLS}
  396.     INLINE $11DF, $020B;            { MOVE.B (SP)+,$020B }
  397.     {$ENDC}
  398.  
  399. FUNCTION LMGetTime : SInt32;
  400.     {$IFC NOT CFMSYSTEMCALLS}
  401.     INLINE $2EB8, $020C;            { MOVE.L $020C,(SP) }
  402.     {$ENDC}
  403.  
  404. PROCEDURE LMSetTime( value: SInt32 );
  405.     {$IFC NOT CFMSYSTEMCALLS}
  406.     INLINE $21DF, $020C;            { MOVE.L (SP)+,$020C }
  407.     {$ENDC}
  408.  
  409. FUNCTION LMGetBootDrive : SInt16;
  410.     {$IFC NOT CFMSYSTEMCALLS}
  411.     INLINE $3EB8, $0210;            { MOVE.W $0210,(SP) }
  412.     {$ENDC}
  413.  
  414. PROCEDURE LMSetBootDrive( value: SInt16 );
  415.     {$IFC NOT CFMSYSTEMCALLS}
  416.     INLINE $31DF, $0210;            { MOVE.W (SP)+,$0210 }
  417.     {$ENDC}
  418.  
  419. FUNCTION LMGetSFSaveDisk : SInt16;
  420.     {$IFC NOT CFMSYSTEMCALLS}
  421.     INLINE $3EB8, $0214;            { MOVE.W $0214,(SP) }
  422.     {$ENDC}
  423.  
  424. PROCEDURE LMSetSFSaveDisk( value: SInt16 );
  425.     {$IFC NOT CFMSYSTEMCALLS}
  426.     INLINE $31DF, $0214;            { MOVE.W (SP)+,$0214 }
  427.     {$ENDC}
  428.  
  429. FUNCTION LMGetKbdLast : ByteParameter;
  430.     {$IFC NOT CFMSYSTEMCALLS}
  431.     INLINE $1EB8, $0218;            { MOVE.B $0218,(SP) }
  432.     {$ENDC}
  433.  
  434. PROCEDURE LMSetKbdLast( value: ByteParameter );
  435.     {$IFC NOT CFMSYSTEMCALLS}
  436.     INLINE $11DF, $0218;            { MOVE.B (SP)+,$0218 }
  437.     {$ENDC}
  438.  
  439. FUNCTION LMGetKbdType : ByteParameter;
  440.     {$IFC NOT CFMSYSTEMCALLS}
  441.     INLINE $1EB8, $021E;            { MOVE.B $021E,(SP) }
  442.     {$ENDC}
  443.  
  444. PROCEDURE LMSetKbdType( value: ByteParameter );
  445.     {$IFC NOT CFMSYSTEMCALLS}
  446.     INLINE $11DF, $021E;            { MOVE.B (SP)+,$021E }
  447.     {$ENDC}
  448.  
  449. FUNCTION LMGetMemErr : SInt16;
  450.     {$IFC NOT CFMSYSTEMCALLS}
  451.     INLINE $3EB8, $0220;            { MOVE.W $0220,(SP) }
  452.     {$ENDC}
  453.  
  454. PROCEDURE LMSetMemErr( value: SInt16 );
  455.     {$IFC NOT CFMSYSTEMCALLS}
  456.     INLINE $31DF, $0220;            { MOVE.W (SP)+,$0220 }
  457.     {$ENDC}
  458.  
  459. FUNCTION LMGetSdVolume : ByteParameter;
  460.     {$IFC NOT CFMSYSTEMCALLS}
  461.     INLINE $1EB8, $0260;            { MOVE.B $0260,(SP) }
  462.     {$ENDC}
  463.  
  464. PROCEDURE LMSetSdVolume( value: ByteParameter );
  465.     {$IFC NOT CFMSYSTEMCALLS}
  466.     INLINE $11DF, $0260;            { MOVE.B (SP)+,$0260 }
  467.     {$ENDC}
  468.  
  469. FUNCTION LMGetSoundPtr : Ptr;
  470.     {$IFC NOT CFMSYSTEMCALLS}
  471.     INLINE $2EB8, $0262;            { MOVE.L $0262,(SP) }
  472.     {$ENDC}
  473.  
  474. PROCEDURE LMSetSoundPtr( value: Ptr );
  475.     {$IFC NOT CFMSYSTEMCALLS}
  476.     INLINE $21DF, $0262;            { MOVE.L (SP)+,$0262 }
  477.     {$ENDC}
  478.  
  479. FUNCTION LMGetSoundBase : Ptr;
  480.     {$IFC NOT CFMSYSTEMCALLS}
  481.     INLINE $2EB8, $0266;            { MOVE.L $0266,(SP) }
  482.     {$ENDC}
  483.  
  484. PROCEDURE LMSetSoundBase( value: Ptr );
  485.     {$IFC NOT CFMSYSTEMCALLS}
  486.     INLINE $21DF, $0266;            { MOVE.L (SP)+,$0266 }
  487.     {$ENDC}
  488.  
  489. FUNCTION LMGetSoundLevel : ByteParameter;
  490.     {$IFC NOT CFMSYSTEMCALLS}
  491.     INLINE $1EB8, $027F;            { MOVE.B $027F,(SP) }
  492.     {$ENDC}
  493.  
  494. PROCEDURE LMSetSoundLevel( value: ByteParameter );
  495.     {$IFC NOT CFMSYSTEMCALLS}
  496.     INLINE $11DF, $027F;            { MOVE.B (SP)+,$027F }
  497.     {$ENDC}
  498.  
  499. FUNCTION LMGetCurPitch : SInt16;
  500.     {$IFC NOT CFMSYSTEMCALLS}
  501.     INLINE $3EB8, $0280;            { MOVE.W $0280,(SP) }
  502.     {$ENDC}
  503.  
  504. PROCEDURE LMSetCurPitch( value: SInt16 );
  505.     {$IFC NOT CFMSYSTEMCALLS}
  506.     INLINE $31DF, $0280;            { MOVE.W (SP)+,$0280 }
  507.     {$ENDC}
  508.  
  509. FUNCTION LMGetROM85 : SInt16;
  510.     {$IFC NOT CFMSYSTEMCALLS}
  511.     INLINE $3EB8, $028E;            { MOVE.W $028E,(SP) }
  512.     {$ENDC}
  513.  
  514. PROCEDURE LMSetROM85( value: SInt16 );
  515.     {$IFC NOT CFMSYSTEMCALLS}
  516.     INLINE $31DF, $028E;            { MOVE.W (SP)+,$028E }
  517.     {$ENDC}
  518.  
  519. FUNCTION LMGetPortBUse : ByteParameter;
  520.     {$IFC NOT CFMSYSTEMCALLS}
  521.     INLINE $1EB8, $0291;            { MOVE.B $0291,(SP) }
  522.     {$ENDC}
  523.  
  524. PROCEDURE LMSetPortBUse( value: ByteParameter );
  525.     {$IFC NOT CFMSYSTEMCALLS}
  526.     INLINE $11DF, $0291;            { MOVE.B (SP)+,$0291 }
  527.     {$ENDC}
  528.  
  529. FUNCTION LMGetGNEFilter : GNEFilterUPP;
  530.     {$IFC NOT CFMSYSTEMCALLS}
  531.     INLINE $2EB8, $029A;            { MOVE.L $029A,(SP) }
  532.     {$ENDC}
  533.  
  534. PROCEDURE LMSetGNEFilter( value: GNEFilterUPP );
  535.     {$IFC NOT CFMSYSTEMCALLS}
  536.     INLINE $21DF, $029A;            { MOVE.L (SP)+,$029A }
  537.     {$ENDC}
  538.  
  539. FUNCTION LMGetSysZone : THz;
  540.     {$IFC NOT CFMSYSTEMCALLS}
  541.     INLINE $2EB8, $02A6;            { MOVE.L $02A6,(SP) }
  542.     {$ENDC}
  543.  
  544. PROCEDURE LMSetSysZone( value: THz );
  545.     {$IFC NOT CFMSYSTEMCALLS}
  546.     INLINE $21DF, $02A6;            { MOVE.L (SP)+,$02A6 }
  547.     {$ENDC}
  548.  
  549. FUNCTION LMGetApplZone : THz;
  550.     {$IFC NOT CFMSYSTEMCALLS}
  551.     INLINE $2EB8, $02AA;            { MOVE.L $02AA,(SP) }
  552.     {$ENDC}
  553.  
  554. PROCEDURE LMSetApplZone( value: THz );
  555.     {$IFC NOT CFMSYSTEMCALLS}
  556.     INLINE $21DF, $02AA;            { MOVE.L (SP)+,$02AA }
  557.     {$ENDC}
  558.  
  559. FUNCTION LMGetROMBase : Ptr;
  560.     {$IFC NOT CFMSYSTEMCALLS}
  561.     INLINE $2EB8, $02AE;            { MOVE.L $02AE,(SP) }
  562.     {$ENDC}
  563.  
  564. PROCEDURE LMSetROMBase( value: Ptr );
  565.     {$IFC NOT CFMSYSTEMCALLS}
  566.     INLINE $21DF, $02AE;            { MOVE.L (SP)+,$02AE }
  567.     {$ENDC}
  568.  
  569. FUNCTION LMGetRAMBase : Ptr;
  570.     {$IFC NOT CFMSYSTEMCALLS}
  571.     INLINE $2EB8, $02B2;            { MOVE.L $02B2,(SP) }
  572.     {$ENDC}
  573.  
  574. PROCEDURE LMSetRAMBase( value: Ptr );
  575.     {$IFC NOT CFMSYSTEMCALLS}
  576.     INLINE $21DF, $02B2;            { MOVE.L (SP)+,$02B2 }
  577.     {$ENDC}
  578.  
  579. FUNCTION LMGetDSAlertTab : Ptr;
  580.     {$IFC NOT CFMSYSTEMCALLS}
  581.     INLINE $2EB8, $02BA;            { MOVE.L $02BA,(SP) }
  582.     {$ENDC}
  583.  
  584. PROCEDURE LMSetDSAlertTab( value: Ptr );
  585.     {$IFC NOT CFMSYSTEMCALLS}
  586.     INLINE $21DF, $02BA;            { MOVE.L (SP)+,$02BA }
  587.     {$ENDC}
  588.  
  589. FUNCTION LMGetDoubleTime : SInt32;
  590.     {$IFC NOT CFMSYSTEMCALLS}
  591.     INLINE $2EB8, $02F0;            { MOVE.L $02F0,(SP) }
  592.     {$ENDC}
  593.  
  594. PROCEDURE LMSetDoubleTime( value: SInt32 );
  595.     {$IFC NOT CFMSYSTEMCALLS}
  596.     INLINE $21DF, $02F0;            { MOVE.L (SP)+,$02F0 }
  597.     {$ENDC}
  598.  
  599. FUNCTION LMGetCaretTime : SInt32;
  600.     {$IFC NOT CFMSYSTEMCALLS}
  601.     INLINE $2EB8, $02F4;            { MOVE.L $02F4,(SP) }
  602.     {$ENDC}
  603.  
  604. PROCEDURE LMSetCaretTime( value: SInt32 );
  605.     {$IFC NOT CFMSYSTEMCALLS}
  606.     INLINE $21DF, $02F4;            { MOVE.L (SP)+,$02F4 }
  607.     {$ENDC}
  608.  
  609. FUNCTION LMGetScrDmpEnb : ByteParameter;
  610.     {$IFC NOT CFMSYSTEMCALLS}
  611.     INLINE $1EB8, $02F8;            { MOVE.B $02F8,(SP) }
  612.     {$ENDC}
  613.  
  614. PROCEDURE LMSetScrDmpEnb( value: ByteParameter );
  615.     {$IFC NOT CFMSYSTEMCALLS}
  616.     INLINE $11DF, $02F8;            { MOVE.B (SP)+,$02F8 }
  617.     {$ENDC}
  618.  
  619. FUNCTION LMGetBufTgFNum : SInt32;
  620.     {$IFC NOT CFMSYSTEMCALLS}
  621.     INLINE $2EB8, $02FC;            { MOVE.L $02FC,(SP) }
  622.     {$ENDC}
  623.  
  624. PROCEDURE LMSetBufTgFNum( value: SInt32 );
  625.     {$IFC NOT CFMSYSTEMCALLS}
  626.     INLINE $21DF, $02FC;            { MOVE.L (SP)+,$02FC }
  627.     {$ENDC}
  628.  
  629. FUNCTION LMGetBufTgFFlg : SInt16;
  630.     {$IFC NOT CFMSYSTEMCALLS}
  631.     INLINE $3EB8, $0300;            { MOVE.W $0300,(SP) }
  632.     {$ENDC}
  633.  
  634. PROCEDURE LMSetBufTgFFlg( value: SInt16 );
  635.     {$IFC NOT CFMSYSTEMCALLS}
  636.     INLINE $31DF, $0300;            { MOVE.W (SP)+,$0300 }
  637.     {$ENDC}
  638.  
  639. FUNCTION LMGetBufTgFBkNum : SInt16;
  640.     {$IFC NOT CFMSYSTEMCALLS}
  641.     INLINE $3EB8, $0302;            { MOVE.W $0302,(SP) }
  642.     {$ENDC}
  643.  
  644. PROCEDURE LMSetBufTgFBkNum( value: SInt16 );
  645.     {$IFC NOT CFMSYSTEMCALLS}
  646.     INLINE $31DF, $0302;            { MOVE.W (SP)+,$0302 }
  647.     {$ENDC}
  648.  
  649. FUNCTION LMGetBufTgDate : SInt32;
  650.     {$IFC NOT CFMSYSTEMCALLS}
  651.     INLINE $2EB8, $0304;            { MOVE.L $0304,(SP) }
  652.     {$ENDC}
  653.  
  654. PROCEDURE LMSetBufTgDate( value: SInt32 );
  655.     {$IFC NOT CFMSYSTEMCALLS}
  656.     INLINE $21DF, $0304;            { MOVE.L (SP)+,$0304 }
  657.     {$ENDC}
  658.  
  659. FUNCTION LMGetLo3Bytes : SInt32;
  660.     {$IFC NOT CFMSYSTEMCALLS}
  661.     INLINE $2EB8, $031A;            { MOVE.L $031A,(SP) }
  662.     {$ENDC}
  663.  
  664. PROCEDURE LMSetLo3Bytes( value: SInt32 );
  665.     {$IFC NOT CFMSYSTEMCALLS}
  666.     INLINE $21DF, $031A;            { MOVE.L (SP)+,$031A }
  667.     {$ENDC}
  668.  
  669. FUNCTION LMGetMinStack : SInt32;
  670.     {$IFC NOT CFMSYSTEMCALLS}
  671.     INLINE $2EB8, $031E;            { MOVE.L $031E,(SP) }
  672.     {$ENDC}
  673.  
  674. PROCEDURE LMSetMinStack( value: SInt32 );
  675.     {$IFC NOT CFMSYSTEMCALLS}
  676.     INLINE $21DF, $031E;            { MOVE.L (SP)+,$031E }
  677.     {$ENDC}
  678.  
  679. FUNCTION LMGetDefltStack : SInt32;
  680.     {$IFC NOT CFMSYSTEMCALLS}
  681.     INLINE $2EB8, $0322;            { MOVE.L $0322,(SP) }
  682.     {$ENDC}
  683.  
  684. PROCEDURE LMSetDefltStack( value: SInt32 );
  685.     {$IFC NOT CFMSYSTEMCALLS}
  686.     INLINE $21DF, $0322;            { MOVE.L (SP)+,$0322 }
  687.     {$ENDC}
  688.  
  689. FUNCTION LMGetGZRootHnd : Handle;
  690.     {$IFC NOT CFMSYSTEMCALLS}
  691.     INLINE $2EB8, $0328;            { MOVE.L $0328,(SP) }
  692.     {$ENDC}
  693.  
  694. PROCEDURE LMSetGZRootHnd( value: Handle );
  695.     {$IFC NOT CFMSYSTEMCALLS}
  696.     INLINE $21DF, $0328;            { MOVE.L (SP)+,$0328 }
  697.     {$ENDC}
  698.  
  699. FUNCTION LMGetGZMoveHnd : Handle;
  700.     {$IFC NOT CFMSYSTEMCALLS}
  701.     INLINE $2EB8, $0330;            { MOVE.L $0330,(SP) }
  702.     {$ENDC}
  703.  
  704. PROCEDURE LMSetGZMoveHnd( value: Handle );
  705.     {$IFC NOT CFMSYSTEMCALLS}
  706.     INLINE $21DF, $0330;            { MOVE.L (SP)+,$0330 }
  707.     {$ENDC}
  708.  
  709. FUNCTION LMGetFCBSPtr : Ptr;
  710.     {$IFC NOT CFMSYSTEMCALLS}
  711.     INLINE $2EB8, $034E;            { MOVE.L $034E,(SP) }
  712.     {$ENDC}
  713.  
  714. PROCEDURE LMSetFCBSPtr( value: Ptr );
  715.     {$IFC NOT CFMSYSTEMCALLS}
  716.     INLINE $21DF, $034E;            { MOVE.L (SP)+,$034E }
  717.     {$ENDC}
  718.  
  719. FUNCTION LMGetDefVCBPtr : Ptr;
  720.     {$IFC NOT CFMSYSTEMCALLS}
  721.     INLINE $2EB8, $0352;            { MOVE.L $0352,(SP) }
  722.     {$ENDC}
  723.  
  724. PROCEDURE LMSetDefVCBPtr( value: Ptr );
  725.     {$IFC NOT CFMSYSTEMCALLS}
  726.     INLINE $21DF, $0352;            { MOVE.L (SP)+,$0352 }
  727.     {$ENDC}
  728.  
  729. FUNCTION LMGetCurDirStore : SInt32;
  730.     {$IFC NOT CFMSYSTEMCALLS}
  731.     INLINE $2EB8, $0398;            { MOVE.L $0398,(SP) }
  732.     {$ENDC}
  733.  
  734. PROCEDURE LMSetCurDirStore( value: SInt32 );
  735.     {$IFC NOT CFMSYSTEMCALLS}
  736.     INLINE $21DF, $0398;            { MOVE.L (SP)+,$0398 }
  737.     {$ENDC}
  738.  
  739. FUNCTION LMGetToExtFS : UniversalProcPtr;
  740.     {$IFC NOT CFMSYSTEMCALLS}
  741.     INLINE $2EB8, $03F2;            { MOVE.L $03F2,(SP) }
  742.     {$ENDC}
  743.  
  744. PROCEDURE LMSetToExtFS( value: UniversalProcPtr );
  745.     {$IFC NOT CFMSYSTEMCALLS}
  746.     INLINE $21DF, $03F2;            { MOVE.L (SP)+,$03F2 }
  747.     {$ENDC}
  748.  
  749. FUNCTION LMGetFSFCBLen : SInt16;
  750.     {$IFC NOT CFMSYSTEMCALLS}
  751.     INLINE $3EB8, $03F6;            { MOVE.W $03F6,(SP) }
  752.     {$ENDC}
  753.  
  754. PROCEDURE LMSetFSFCBLen( value: SInt16 );
  755.     {$IFC NOT CFMSYSTEMCALLS}
  756.     INLINE $31DF, $03F6;            { MOVE.W (SP)+,$03F6 }
  757.     {$ENDC}
  758.  
  759. FUNCTION LMGetScrnBase : Ptr;
  760.     {$IFC NOT CFMSYSTEMCALLS}
  761.     INLINE $2EB8, $0824;            { MOVE.L $0824,(SP) }
  762.     {$ENDC}
  763.  
  764. PROCEDURE LMSetScrnBase( value: Ptr );
  765.     {$IFC NOT CFMSYSTEMCALLS}
  766.     INLINE $21DF, $0824;            { MOVE.L (SP)+,$0824 }
  767.     {$ENDC}
  768.  
  769. FUNCTION LMGetMainDevice : GDHandle;
  770.     {$IFC NOT CFMSYSTEMCALLS}
  771.     INLINE $2EB8, $08A4;            { MOVE.L $08A4,(SP) }
  772.     {$ENDC}
  773.  
  774. PROCEDURE LMSetMainDevice( value: GDHandle );
  775.     {$IFC NOT CFMSYSTEMCALLS}
  776.     INLINE $21DF, $08A4;            { MOVE.L (SP)+,$08A4 }
  777.     {$ENDC}
  778.  
  779. FUNCTION LMGetDeviceList : GDHandle;
  780.     {$IFC NOT CFMSYSTEMCALLS}
  781.     INLINE $2EB8, $08A8;            { MOVE.L $08A8,(SP) }
  782.     {$ENDC}
  783.  
  784. PROCEDURE LMSetDeviceList( value: GDHandle );
  785.     {$IFC NOT CFMSYSTEMCALLS}
  786.     INLINE $21DF, $08A8;            { MOVE.L (SP)+,$08A8 }
  787.     {$ENDC}
  788.  
  789. FUNCTION LMGetQDColors : Handle;
  790.     {$IFC NOT CFMSYSTEMCALLS}
  791.     INLINE $2EB8, $08B0;            { MOVE.L $08B0,(SP) }
  792.     {$ENDC}
  793.  
  794. PROCEDURE LMSetQDColors( value: Handle );
  795.     {$IFC NOT CFMSYSTEMCALLS}
  796.     INLINE $21DF, $08B0;            { MOVE.L (SP)+,$08B0 }
  797.     {$ENDC}
  798.  
  799. FUNCTION LMGetCrsrBusy : ByteParameter;
  800.     {$IFC NOT CFMSYSTEMCALLS}
  801.     INLINE $1EB8, $08CD;            { MOVE.B $08CD,(SP) }
  802.     {$ENDC}
  803.  
  804. PROCEDURE LMSetCrsrBusy( value: ByteParameter );
  805.     {$IFC NOT CFMSYSTEMCALLS}
  806.     INLINE $11DF, $08CD;            { MOVE.B (SP)+,$08CD }
  807.     {$ENDC}
  808.  
  809. FUNCTION LMGetWidthListHand : Handle;
  810.     {$IFC NOT CFMSYSTEMCALLS}
  811.     INLINE $2EB8, $08E4;            { MOVE.L $08E4,(SP) }
  812.     {$ENDC}
  813.  
  814. PROCEDURE LMSetWidthListHand( value: Handle );
  815.     {$IFC NOT CFMSYSTEMCALLS}
  816.     INLINE $21DF, $08E4;            { MOVE.L (SP)+,$08E4 }
  817.     {$ENDC}
  818.  
  819. FUNCTION LMGetJournalRef : SInt16;
  820.     {$IFC NOT CFMSYSTEMCALLS}
  821.     INLINE $3EB8, $08E8;            { MOVE.W $08E8,(SP) }
  822.     {$ENDC}
  823.  
  824. PROCEDURE LMSetJournalRef( value: SInt16 );
  825.     {$IFC NOT CFMSYSTEMCALLS}
  826.     INLINE $31DF, $08E8;            { MOVE.W (SP)+,$08E8 }
  827.     {$ENDC}
  828.  
  829. FUNCTION LMGetCrsrThresh : SInt16;
  830.     {$IFC NOT CFMSYSTEMCALLS}
  831.     INLINE $3EB8, $08EC;            { MOVE.W $08EC,(SP) }
  832.     {$ENDC}
  833.  
  834. PROCEDURE LMSetCrsrThresh( value: SInt16 );
  835.     {$IFC NOT CFMSYSTEMCALLS}
  836.     INLINE $31DF, $08EC;            { MOVE.W (SP)+,$08EC }
  837.     {$ENDC}
  838.  
  839. FUNCTION LMGetJFetch : UniversalProcPtr;
  840.     {$IFC NOT CFMSYSTEMCALLS}
  841.     INLINE $2EB8, $08F4;            { MOVE.L $08F4,(SP) }
  842.     {$ENDC}
  843.  
  844. PROCEDURE LMSetJFetch( value: UniversalProcPtr );
  845.     {$IFC NOT CFMSYSTEMCALLS}
  846.     INLINE $21DF, $08F4;            { MOVE.L (SP)+,$08F4 }
  847.     {$ENDC}
  848.  
  849. FUNCTION LMGetJStash : UniversalProcPtr;
  850.     {$IFC NOT CFMSYSTEMCALLS}
  851.     INLINE $2EB8, $08F8;            { MOVE.L $08F8,(SP) }
  852.     {$ENDC}
  853.  
  854. PROCEDURE LMSetJStash( value: UniversalProcPtr );
  855.     {$IFC NOT CFMSYSTEMCALLS}
  856.     INLINE $21DF, $08F8;            { MOVE.L (SP)+,$08F8 }
  857.     {$ENDC}
  858.  
  859. FUNCTION LMGetJIODone : UniversalProcPtr;
  860.     {$IFC NOT CFMSYSTEMCALLS}
  861.     INLINE $2EB8, $08FC;            { MOVE.L $08FC,(SP) }
  862.     {$ENDC}
  863.  
  864. PROCEDURE LMSetJIODone( value: UniversalProcPtr );
  865.     {$IFC NOT CFMSYSTEMCALLS}
  866.     INLINE $21DF, $08FC;            { MOVE.L (SP)+,$08FC }
  867.     {$ENDC}
  868.  
  869. FUNCTION LMGetCurApRefNum : SInt16;
  870.     {$IFC NOT CFMSYSTEMCALLS}
  871.     INLINE $3EB8, $0900;            { MOVE.W $0900,(SP) }
  872.     {$ENDC}
  873.  
  874. PROCEDURE LMSetCurApRefNum( value: SInt16 );
  875.     {$IFC NOT CFMSYSTEMCALLS}
  876.     INLINE $31DF, $0900;            { MOVE.W (SP)+,$0900 }
  877.     {$ENDC}
  878.  
  879. FUNCTION LMGetCurrentA5 : Ptr;
  880.     {$IFC NOT CFMSYSTEMCALLS}
  881.     INLINE $2EB8, $0904;            { MOVE.L $0904,(SP) }
  882.     {$ENDC}
  883.  
  884. PROCEDURE LMSetCurrentA5( value: Ptr );
  885.     {$IFC NOT CFMSYSTEMCALLS}
  886.     INLINE $21DF, $0904;            { MOVE.L (SP)+,$0904 }
  887.     {$ENDC}
  888.  
  889. FUNCTION LMGetCurStackBase : Ptr;
  890.     {$IFC NOT CFMSYSTEMCALLS}
  891.     INLINE $2EB8, $0908;            { MOVE.L $0908,(SP) }
  892.     {$ENDC}
  893.  
  894. PROCEDURE LMSetCurStackBase( value: Ptr );
  895.     {$IFC NOT CFMSYSTEMCALLS}
  896.     INLINE $21DF, $0908;            { MOVE.L (SP)+,$0908 }
  897.     {$ENDC}
  898.  
  899. FUNCTION LMGetCurJTOffset : SInt16;
  900.     {$IFC NOT CFMSYSTEMCALLS}
  901.     INLINE $3EB8, $0934;            { MOVE.W $0934,(SP) }
  902.     {$ENDC}
  903.  
  904. PROCEDURE LMSetCurJTOffset( value: SInt16 );
  905.     {$IFC NOT CFMSYSTEMCALLS}
  906.     INLINE $31DF, $0934;            { MOVE.W (SP)+,$0934 }
  907.     {$ENDC}
  908.  
  909. FUNCTION LMGetCurPageOption : SInt16;
  910.     {$IFC NOT CFMSYSTEMCALLS}
  911.     INLINE $3EB8, $0936;            { MOVE.W $0936,(SP) }
  912.     {$ENDC}
  913.  
  914. PROCEDURE LMSetCurPageOption( value: SInt16 );
  915.     {$IFC NOT CFMSYSTEMCALLS}
  916.     INLINE $31DF, $0936;            { MOVE.W (SP)+,$0936 }
  917.     {$ENDC}
  918.  
  919. FUNCTION LMGetHiliteMode : ByteParameter;
  920.     {$IFC NOT CFMSYSTEMCALLS}
  921.     INLINE $1EB8, $0938;            { MOVE.B $0938,(SP) }
  922.     {$ENDC}
  923.  
  924. PROCEDURE LMSetHiliteMode( value: ByteParameter );
  925.     {$IFC NOT CFMSYSTEMCALLS}
  926.     INLINE $11DF, $0938;            { MOVE.B (SP)+,$0938 }
  927.     {$ENDC}
  928.  
  929. FUNCTION LMGetPrintErr : SInt16;
  930.     {$IFC NOT CFMSYSTEMCALLS}
  931.     INLINE $3EB8, $0944;            { MOVE.W $0944,(SP) }
  932.     {$ENDC}
  933.  
  934. PROCEDURE LMSetPrintErr( value: SInt16 );
  935.     {$IFC NOT CFMSYSTEMCALLS}
  936.     INLINE $31DF, $0944;            { MOVE.W (SP)+,$0944 }
  937.     {$ENDC}
  938.  
  939. FUNCTION LMGetScrapSize : SInt32;
  940.     {$IFC NOT CFMSYSTEMCALLS}
  941.     INLINE $2EB8, $0960;            { MOVE.L $0960,(SP) }
  942.     {$ENDC}
  943.  
  944. PROCEDURE LMSetScrapSize( value: SInt32 );
  945.     {$IFC NOT CFMSYSTEMCALLS}
  946.     INLINE $21DF, $0960;            { MOVE.L (SP)+,$0960 }
  947.     {$ENDC}
  948.  
  949. FUNCTION LMGetScrapHandle : Handle;
  950.     {$IFC NOT CFMSYSTEMCALLS}
  951.     INLINE $2EB8, $0964;            { MOVE.L $0964,(SP) }
  952.     {$ENDC}
  953.  
  954. PROCEDURE LMSetScrapHandle( value: Handle );
  955.     {$IFC NOT CFMSYSTEMCALLS}
  956.     INLINE $21DF, $0964;            { MOVE.L (SP)+,$0964 }
  957.     {$ENDC}
  958.  
  959. FUNCTION LMGetScrapCount : SInt16;
  960.     {$IFC NOT CFMSYSTEMCALLS}
  961.     INLINE $3EB8, $0968;            { MOVE.W $0968,(SP) }
  962.     {$ENDC}
  963.  
  964. PROCEDURE LMSetScrapCount( value: SInt16 );
  965.     {$IFC NOT CFMSYSTEMCALLS}
  966.     INLINE $31DF, $0968;            { MOVE.W (SP)+,$0968 }
  967.     {$ENDC}
  968.  
  969. FUNCTION LMGetScrapState : SInt16;
  970.     {$IFC NOT CFMSYSTEMCALLS}
  971.     INLINE $3EB8, $096A;            { MOVE.W $096A,(SP) }
  972.     {$ENDC}
  973.  
  974. PROCEDURE LMSetScrapState( value: SInt16 );
  975.     {$IFC NOT CFMSYSTEMCALLS}
  976.     INLINE $31DF, $096A;            { MOVE.W (SP)+,$096A }
  977.     {$ENDC}
  978.  
  979. FUNCTION LMGetScrapName : StringPtr;
  980.     {$IFC NOT CFMSYSTEMCALLS}
  981.     INLINE $2EB8, $096C;            { MOVE.L $096C,(SP) }
  982.     {$ENDC}
  983.  
  984. PROCEDURE LMSetScrapName( value: StringPtr );
  985.     {$IFC NOT CFMSYSTEMCALLS}
  986.     INLINE $21DF, $096C;            { MOVE.L (SP)+,$096C }
  987.     {$ENDC}
  988.  
  989. FUNCTION LMGetROMFont0 : Handle;
  990.     {$IFC NOT CFMSYSTEMCALLS}
  991.     INLINE $2EB8, $0980;            { MOVE.L $0980,(SP) }
  992.     {$ENDC}
  993.  
  994. PROCEDURE LMSetROMFont0( value: Handle );
  995.     {$IFC NOT CFMSYSTEMCALLS}
  996.     INLINE $21DF, $0980;            { MOVE.L (SP)+,$0980 }
  997.     {$ENDC}
  998.  
  999. FUNCTION LMGetApFontID : SInt16;
  1000.     {$IFC NOT CFMSYSTEMCALLS}
  1001.     INLINE $3EB8, $0984;            { MOVE.W $0984,(SP) }
  1002.     {$ENDC}
  1003.  
  1004. PROCEDURE LMSetApFontID( value: SInt16 );
  1005.     {$IFC NOT CFMSYSTEMCALLS}
  1006.     INLINE $31DF, $0984;            { MOVE.W (SP)+,$0984 }
  1007.     {$ENDC}
  1008.  
  1009. FUNCTION LMGetWindowList : WindowRef;
  1010.     {$IFC NOT CFMSYSTEMCALLS}
  1011.     INLINE $2EB8, $09D6;            { MOVE.L $09D6,(SP) }
  1012.     {$ENDC}
  1013.  
  1014. FUNCTION LMGetSaveUpdate : SInt16;
  1015.     {$IFC NOT CFMSYSTEMCALLS}
  1016.     INLINE $3EB8, $09DA;            { MOVE.W $09DA,(SP) }
  1017.     {$ENDC}
  1018.  
  1019. PROCEDURE LMSetSaveUpdate( value: SInt16 );
  1020.     {$IFC NOT CFMSYSTEMCALLS}
  1021.     INLINE $31DF, $09DA;            { MOVE.W (SP)+,$09DA }
  1022.     {$ENDC}
  1023.  
  1024. FUNCTION LMGetPaintWhite : SInt16;
  1025.     {$IFC NOT CFMSYSTEMCALLS}
  1026.     INLINE $3EB8, $09DC;            { MOVE.W $09DC,(SP) }
  1027.     {$ENDC}
  1028.  
  1029. PROCEDURE LMSetPaintWhite( value: SInt16 );
  1030.     {$IFC NOT CFMSYSTEMCALLS}
  1031.     INLINE $31DF, $09DC;            { MOVE.W (SP)+,$09DC }
  1032.     {$ENDC}
  1033.  
  1034. FUNCTION LMGetWMgrPort : GrafPtr;
  1035.     {$IFC NOT CFMSYSTEMCALLS}
  1036.     INLINE $2EB8, $09DE;            { MOVE.L $09DE,(SP) }
  1037.     {$ENDC}
  1038.  
  1039. PROCEDURE LMSetWMgrPort( value: GrafPtr );
  1040.     {$IFC NOT CFMSYSTEMCALLS}
  1041.     INLINE $21DF, $09DE;            { MOVE.L (SP)+,$09DE }
  1042.     {$ENDC}
  1043.  
  1044. FUNCTION LMGetGrayRgn : RgnHandle;
  1045.     {$IFC NOT CFMSYSTEMCALLS}
  1046.     INLINE $2EB8, $09EE;            { MOVE.L $09EE,(SP) }
  1047.     {$ENDC}
  1048.  
  1049. FUNCTION LMGetDragHook : UniversalProcPtr;
  1050.     {$IFC NOT CFMSYSTEMCALLS}
  1051.     INLINE $2EB8, $09F6;            { MOVE.L $09F6,(SP) }
  1052.     {$ENDC}
  1053.  
  1054. PROCEDURE LMSetDragHook( value: UniversalProcPtr );
  1055.     {$IFC NOT CFMSYSTEMCALLS}
  1056.     INLINE $21DF, $09F6;            { MOVE.L (SP)+,$09F6 }
  1057.     {$ENDC}
  1058.  
  1059. {
  1060.  To best work with future versions of the window manager,
  1061.  avoid using anything not defined with STRICT_WINDOWS
  1062.  set to true.  Most, if not all of these will still
  1063.  be supported in the next major version of the window manager
  1064.  but will trigger non-optimal compatibility code paths that
  1065.  should be avoided if possible.
  1066. }
  1067. {$IFC NOT STRICT_WINDOWS }
  1068. {
  1069.  There is no reason to set the window list directly.
  1070.  Use BringToFront and SendBehind.
  1071.  
  1072.  If you need to do floating windows, avoid using GhostWindow 
  1073.  and especially avoid patching the window manager.
  1074.  
  1075.  See Dean Yu's article in Develop 15 about how to implement floating
  1076.  windows using low-level window manager calls.  The next generation
  1077.  Macintosh Window Manager will have built-in support for floating
  1078.  and modal windows.
  1079. }
  1080. PROCEDURE LMSetWindowList( value: WindowRef );
  1081.     {$IFC NOT CFMSYSTEMCALLS}
  1082.     INLINE $21DF, $09D6;            { MOVE.L (SP)+,$09D6 }
  1083.     {$ENDC}
  1084.  
  1085. FUNCTION LMGetGhostWindow : WindowRef;
  1086.     {$IFC NOT CFMSYSTEMCALLS}
  1087.     INLINE $2EB8, $0A84;            { MOVE.L $0A84,(SP) }
  1088.     {$ENDC}
  1089.  
  1090. PROCEDURE LMSetGhostWindow( value: WindowRef );
  1091.     {$IFC NOT CFMSYSTEMCALLS}
  1092.     INLINE $21DF, $0A84;            { MOVE.L (SP)+,$0A84 }
  1093.     {$ENDC}
  1094.  
  1095. {
  1096.  The auxiliary window record list will be empty in future
  1097.  versions of the window manager.  There is no reason to 
  1098.  walk it or change it. 
  1099. }
  1100. FUNCTION LMGetAuxWinHead : AuxWinHandle;
  1101.     {$IFC NOT CFMSYSTEMCALLS}
  1102.     INLINE $2EB8, $0CD0;            { MOVE.L $0CD0,(SP) }
  1103.     {$ENDC}
  1104.  
  1105. PROCEDURE LMSetAuxWinHead( value: AuxWinHandle );
  1106.     {$IFC NOT CFMSYSTEMCALLS}
  1107.     INLINE $21DF, $0CD0;            { MOVE.L (SP)+,$0CD0 }
  1108.     {$ENDC}
  1109.  
  1110. {
  1111.  Please rely on the event manager to deliver activate and 
  1112.  deactivate events and on the window manager to generate them.
  1113.  
  1114.  The next generation window manager will queue these events
  1115.  rather than just slamming these lowmems with the latest
  1116.  generated event, so it pays to rely on the event manager.
  1117. }
  1118. FUNCTION LMGetCurActivate : WindowRef;
  1119.     {$IFC NOT CFMSYSTEMCALLS}
  1120.     INLINE $2EB8, $0A64;            { MOVE.L $0A64,(SP) }
  1121.     {$ENDC}
  1122.  
  1123. PROCEDURE LMSetCurActivate( value: WindowRef );
  1124.     {$IFC NOT CFMSYSTEMCALLS}
  1125.     INLINE $21DF, $0A64;            { MOVE.L (SP)+,$0A64 }
  1126.     {$ENDC}
  1127.  
  1128. FUNCTION LMGetCurDeactive : WindowRef;
  1129.     {$IFC NOT CFMSYSTEMCALLS}
  1130.     INLINE $2EB8, $0A68;            { MOVE.L $0A68,(SP) }
  1131.     {$ENDC}
  1132.  
  1133. PROCEDURE LMSetCurDeactive( value: WindowRef );
  1134.     {$IFC NOT CFMSYSTEMCALLS}
  1135.     INLINE $21DF, $0A68;            { MOVE.L (SP)+,$0A68 }
  1136.     {$ENDC}
  1137.  
  1138. FUNCTION LMGetOldStructure : RgnHandle;
  1139.     {$IFC NOT CFMSYSTEMCALLS}
  1140.     INLINE $2EB8, $09E6;            { MOVE.L $09E6,(SP) }
  1141.     {$ENDC}
  1142.  
  1143. PROCEDURE LMSetOldStructure( value: RgnHandle );
  1144.     {$IFC NOT CFMSYSTEMCALLS}
  1145.     INLINE $21DF, $09E6;            { MOVE.L (SP)+,$09E6 }
  1146.     {$ENDC}
  1147.  
  1148. FUNCTION LMGetOldContent : RgnHandle;
  1149.     {$IFC NOT CFMSYSTEMCALLS}
  1150.     INLINE $2EB8, $09EA;            { MOVE.L $09EA,(SP) }
  1151.     {$ENDC}
  1152.  
  1153. PROCEDURE LMSetOldContent( value: RgnHandle );
  1154.     {$IFC NOT CFMSYSTEMCALLS}
  1155.     INLINE $21DF, $09EA;            { MOVE.L (SP)+,$09EA }
  1156.     {$ENDC}
  1157.  
  1158. {
  1159.  Please don't mess with the gray region.  There has
  1160.  to be a better way.  If not, please manipulate the
  1161.  existing region, don't change the value of the lowmem.
  1162. }
  1163. PROCEDURE LMSetGrayRgn( value: RgnHandle );
  1164.     {$IFC NOT CFMSYSTEMCALLS}
  1165.     INLINE $21DF, $09EE;            { MOVE.L (SP)+,$09EE }
  1166.     {$ENDC}
  1167.  
  1168. FUNCTION LMGetSaveVisRgn : RgnHandle;
  1169.     {$IFC NOT CFMSYSTEMCALLS}
  1170.     INLINE $2EB8, $09F2;            { MOVE.L $09F2,(SP) }
  1171.     {$ENDC}
  1172.  
  1173. PROCEDURE LMSetSaveVisRgn( value: RgnHandle );
  1174.     {$IFC NOT CFMSYSTEMCALLS}
  1175.     INLINE $21DF, $09F2;            { MOVE.L (SP)+,$09F2 }
  1176.     {$ENDC}
  1177.  
  1178. {$ENDC}
  1179. FUNCTION LMGetOneOne : SInt32;
  1180.     {$IFC NOT CFMSYSTEMCALLS}
  1181.     INLINE $2EB8, $0A02;            { MOVE.L $0A02,(SP) }
  1182.     {$ENDC}
  1183.  
  1184. PROCEDURE LMSetOneOne( value: SInt32 );
  1185.     {$IFC NOT CFMSYSTEMCALLS}
  1186.     INLINE $21DF, $0A02;            { MOVE.L (SP)+,$0A02 }
  1187.     {$ENDC}
  1188.  
  1189. FUNCTION LMGetMinusOne : SInt32;
  1190.     {$IFC NOT CFMSYSTEMCALLS}
  1191.     INLINE $2EB8, $0A06;            { MOVE.L $0A06,(SP) }
  1192.     {$ENDC}
  1193.  
  1194. PROCEDURE LMSetMinusOne( value: SInt32 );
  1195.     {$IFC NOT CFMSYSTEMCALLS}
  1196.     INLINE $21DF, $0A06;            { MOVE.L (SP)+,$0A06 }
  1197.     {$ENDC}
  1198.  
  1199. FUNCTION LMGetTopMenuItem : SInt16;
  1200.     {$IFC NOT CFMSYSTEMCALLS}
  1201.     INLINE $3EB8, $0A0A;            { MOVE.W $0A0A,(SP) }
  1202.     {$ENDC}
  1203.  
  1204. PROCEDURE LMSetTopMenuItem( value: SInt16 );
  1205.     {$IFC NOT CFMSYSTEMCALLS}
  1206.     INLINE $31DF, $0A0A;            { MOVE.W (SP)+,$0A0A }
  1207.     {$ENDC}
  1208.  
  1209. FUNCTION LMGetAtMenuBottom : SInt16;
  1210.     {$IFC NOT CFMSYSTEMCALLS}
  1211.     INLINE $3EB8, $0A0C;            { MOVE.W $0A0C,(SP) }
  1212.     {$ENDC}
  1213.  
  1214. PROCEDURE LMSetAtMenuBottom( value: SInt16 );
  1215.     {$IFC NOT CFMSYSTEMCALLS}
  1216.     INLINE $31DF, $0A0C;            { MOVE.W (SP)+,$0A0C }
  1217.     {$ENDC}
  1218.  
  1219. FUNCTION LMGetMenuList : Handle;
  1220.     {$IFC NOT CFMSYSTEMCALLS}
  1221.     INLINE $2EB8, $0A1C;            { MOVE.L $0A1C,(SP) }
  1222.     {$ENDC}
  1223.  
  1224. PROCEDURE LMSetMenuList( value: Handle );
  1225.     {$IFC NOT CFMSYSTEMCALLS}
  1226.     INLINE $21DF, $0A1C;            { MOVE.L (SP)+,$0A1C }
  1227.     {$ENDC}
  1228.  
  1229. FUNCTION LMGetMBarEnable : SInt16;
  1230.     {$IFC NOT CFMSYSTEMCALLS}
  1231.     INLINE $3EB8, $0A20;            { MOVE.W $0A20,(SP) }
  1232.     {$ENDC}
  1233.  
  1234. PROCEDURE LMSetMBarEnable( value: SInt16 );
  1235.     {$IFC NOT CFMSYSTEMCALLS}
  1236.     INLINE $31DF, $0A20;            { MOVE.W (SP)+,$0A20 }
  1237.     {$ENDC}
  1238.  
  1239. FUNCTION LMGetMenuFlash : SInt16;
  1240.     {$IFC NOT CFMSYSTEMCALLS}
  1241.     INLINE $3EB8, $0A24;            { MOVE.W $0A24,(SP) }
  1242.     {$ENDC}
  1243.  
  1244. PROCEDURE LMSetMenuFlash( value: SInt16 );
  1245.     {$IFC NOT CFMSYSTEMCALLS}
  1246.     INLINE $31DF, $0A24;            { MOVE.W (SP)+,$0A24 }
  1247.     {$ENDC}
  1248.  
  1249. FUNCTION LMGetTheMenu : SInt16;
  1250.     {$IFC NOT CFMSYSTEMCALLS}
  1251.     INLINE $3EB8, $0A26;            { MOVE.W $0A26,(SP) }
  1252.     {$ENDC}
  1253.  
  1254. PROCEDURE LMSetTheMenu( value: SInt16 );
  1255.     {$IFC NOT CFMSYSTEMCALLS}
  1256.     INLINE $31DF, $0A26;            { MOVE.W (SP)+,$0A26 }
  1257.     {$ENDC}
  1258.  
  1259. FUNCTION LMGetMBarHook : UniversalProcPtr;
  1260.     {$IFC NOT CFMSYSTEMCALLS}
  1261.     INLINE $2EB8, $0A2C;            { MOVE.L $0A2C,(SP) }
  1262.     {$ENDC}
  1263.  
  1264. PROCEDURE LMSetMBarHook( value: UniversalProcPtr );
  1265.     {$IFC NOT CFMSYSTEMCALLS}
  1266.     INLINE $21DF, $0A2C;            { MOVE.L (SP)+,$0A2C }
  1267.     {$ENDC}
  1268.  
  1269. FUNCTION LMGetMenuHook : UniversalProcPtr;
  1270.     {$IFC NOT CFMSYSTEMCALLS}
  1271.     INLINE $2EB8, $0A30;            { MOVE.L $0A30,(SP) }
  1272.     {$ENDC}
  1273.  
  1274. PROCEDURE LMSetMenuHook( value: UniversalProcPtr );
  1275.     {$IFC NOT CFMSYSTEMCALLS}
  1276.     INLINE $21DF, $0A30;            { MOVE.L (SP)+,$0A30 }
  1277.     {$ENDC}
  1278.  
  1279. FUNCTION LMGetTopMapHndl : Handle;
  1280.     {$IFC NOT CFMSYSTEMCALLS}
  1281.     INLINE $2EB8, $0A50;            { MOVE.L $0A50,(SP) }
  1282.     {$ENDC}
  1283.  
  1284. PROCEDURE LMSetTopMapHndl( value: Handle );
  1285.     {$IFC NOT CFMSYSTEMCALLS}
  1286.     INLINE $21DF, $0A50;            { MOVE.L (SP)+,$0A50 }
  1287.     {$ENDC}
  1288.  
  1289. FUNCTION LMGetSysMapHndl : Handle;
  1290.     {$IFC NOT CFMSYSTEMCALLS}
  1291.     INLINE $2EB8, $0A54;            { MOVE.L $0A54,(SP) }
  1292.     {$ENDC}
  1293.  
  1294. PROCEDURE LMSetSysMapHndl( value: Handle );
  1295.     {$IFC NOT CFMSYSTEMCALLS}
  1296.     INLINE $21DF, $0A54;            { MOVE.L (SP)+,$0A54 }
  1297.     {$ENDC}
  1298.  
  1299. FUNCTION LMGetSysMap : SInt16;
  1300.     {$IFC NOT CFMSYSTEMCALLS}
  1301.     INLINE $3EB8, $0A58;            { MOVE.W $0A58,(SP) }
  1302.     {$ENDC}
  1303.  
  1304. PROCEDURE LMSetSysMap( value: SInt16 );
  1305.     {$IFC NOT CFMSYSTEMCALLS}
  1306.     INLINE $31DF, $0A58;            { MOVE.W (SP)+,$0A58 }
  1307.     {$ENDC}
  1308.  
  1309. FUNCTION LMGetCurMap : SInt16;
  1310.     {$IFC NOT CFMSYSTEMCALLS}
  1311.     INLINE $3EB8, $0A5A;            { MOVE.W $0A5A,(SP) }
  1312.     {$ENDC}
  1313.  
  1314. PROCEDURE LMSetCurMap( value: SInt16 );
  1315.     {$IFC NOT CFMSYSTEMCALLS}
  1316.     INLINE $31DF, $0A5A;            { MOVE.W (SP)+,$0A5A }
  1317.     {$ENDC}
  1318.  
  1319. FUNCTION LMGetResLoad : ByteParameter;
  1320.     {$IFC NOT CFMSYSTEMCALLS}
  1321.     INLINE $1EB8, $0A5E;            { MOVE.B $0A5E,(SP) }
  1322.     {$ENDC}
  1323.  
  1324. PROCEDURE LMSetResLoad( value: ByteParameter );
  1325.     {$IFC NOT CFMSYSTEMCALLS}
  1326.     INLINE $11DF, $0A5E;            { MOVE.B (SP)+,$0A5E }
  1327.     {$ENDC}
  1328.  
  1329. FUNCTION LMGetResErr : SInt16;
  1330.     {$IFC NOT CFMSYSTEMCALLS}
  1331.     INLINE $3EB8, $0A60;            { MOVE.W $0A60,(SP) }
  1332.     {$ENDC}
  1333.  
  1334. PROCEDURE LMSetResErr( value: SInt16 );
  1335.     {$IFC NOT CFMSYSTEMCALLS}
  1336.     INLINE $31DF, $0A60;            { MOVE.W (SP)+,$0A60 }
  1337.     {$ENDC}
  1338.  
  1339. FUNCTION LMGetFScaleDisable : ByteParameter;
  1340.     {$IFC NOT CFMSYSTEMCALLS}
  1341.     INLINE $1EB8, $0A63;            { MOVE.B $0A63,(SP) }
  1342.     {$ENDC}
  1343.  
  1344. PROCEDURE LMSetFScaleDisable( value: ByteParameter );
  1345.     {$IFC NOT CFMSYSTEMCALLS}
  1346.     INLINE $11DF, $0A63;            { MOVE.B (SP)+,$0A63 }
  1347.     {$ENDC}
  1348.  
  1349. FUNCTION LMGetDeskHook : UniversalProcPtr;
  1350.     {$IFC NOT CFMSYSTEMCALLS}
  1351.     INLINE $2EB8, $0A6C;            { MOVE.L $0A6C,(SP) }
  1352.     {$ENDC}
  1353.  
  1354. PROCEDURE LMSetDeskHook( value: UniversalProcPtr );
  1355.     {$IFC NOT CFMSYSTEMCALLS}
  1356.     INLINE $21DF, $0A6C;            { MOVE.L (SP)+,$0A6C }
  1357.     {$ENDC}
  1358.  
  1359. FUNCTION LMGetTEDoText : UniversalProcPtr;
  1360.     {$IFC NOT CFMSYSTEMCALLS}
  1361.     INLINE $2EB8, $0A70;            { MOVE.L $0A70,(SP) }
  1362.     {$ENDC}
  1363.  
  1364. PROCEDURE LMSetTEDoText( value: UniversalProcPtr );
  1365.     {$IFC NOT CFMSYSTEMCALLS}
  1366.     INLINE $21DF, $0A70;            { MOVE.L (SP)+,$0A70 }
  1367.     {$ENDC}
  1368.  
  1369. FUNCTION LMGetTERecal : UniversalProcPtr;
  1370.     {$IFC NOT CFMSYSTEMCALLS}
  1371.     INLINE $2EB8, $0A74;            { MOVE.L $0A74,(SP) }
  1372.     {$ENDC}
  1373.  
  1374. PROCEDURE LMSetTERecal( value: UniversalProcPtr );
  1375.     {$IFC NOT CFMSYSTEMCALLS}
  1376.     INLINE $21DF, $0A74;            { MOVE.L (SP)+,$0A74 }
  1377.     {$ENDC}
  1378.  
  1379. FUNCTION LMGetResumeProc : UniversalProcPtr;
  1380.     {$IFC NOT CFMSYSTEMCALLS}
  1381.     INLINE $2EB8, $0A8C;            { MOVE.L $0A8C,(SP) }
  1382.     {$ENDC}
  1383.  
  1384. PROCEDURE LMSetResumeProc( value: UniversalProcPtr );
  1385.     {$IFC NOT CFMSYSTEMCALLS}
  1386.     INLINE $21DF, $0A8C;            { MOVE.L (SP)+,$0A8C }
  1387.     {$ENDC}
  1388.  
  1389. FUNCTION LMGetANumber : SInt16;
  1390.     {$IFC NOT CFMSYSTEMCALLS}
  1391.     INLINE $3EB8, $0A98;            { MOVE.W $0A98,(SP) }
  1392.     {$ENDC}
  1393.  
  1394. PROCEDURE LMSetANumber( value: SInt16 );
  1395.     {$IFC NOT CFMSYSTEMCALLS}
  1396.     INLINE $31DF, $0A98;            { MOVE.W (SP)+,$0A98 }
  1397.     {$ENDC}
  1398.  
  1399. FUNCTION LMGetACount : SInt16;
  1400.     {$IFC NOT CFMSYSTEMCALLS}
  1401.     INLINE $3EB8, $0A9A;            { MOVE.W $0A9A,(SP) }
  1402.     {$ENDC}
  1403.  
  1404. PROCEDURE LMSetACount( value: SInt16 );
  1405.     {$IFC NOT CFMSYSTEMCALLS}
  1406.     INLINE $31DF, $0A9A;            { MOVE.W (SP)+,$0A9A }
  1407.     {$ENDC}
  1408.  
  1409. FUNCTION LMGetDABeeper : UniversalProcPtr;
  1410.     {$IFC NOT CFMSYSTEMCALLS}
  1411.     INLINE $2EB8, $0A9C;            { MOVE.L $0A9C,(SP) }
  1412.     {$ENDC}
  1413.  
  1414. PROCEDURE LMSetDABeeper( value: UniversalProcPtr );
  1415.     {$IFC NOT CFMSYSTEMCALLS}
  1416.     INLINE $21DF, $0A9C;            { MOVE.L (SP)+,$0A9C }
  1417.     {$ENDC}
  1418.  
  1419. FUNCTION LMGetTEScrpLength : UInt16;
  1420.     {$IFC NOT CFMSYSTEMCALLS}
  1421.     INLINE $3EB8, $0AB0;            { MOVE.W $0AB0,(SP) }
  1422.     {$ENDC}
  1423.  
  1424. PROCEDURE LMSetTEScrpLength( value: UInt16 );
  1425.     {$IFC NOT CFMSYSTEMCALLS}
  1426.     INLINE $31DF, $0AB0;            { MOVE.W (SP)+,$0AB0 }
  1427.     {$ENDC}
  1428.  
  1429. FUNCTION LMGetTEScrpHandle : Handle;
  1430.     {$IFC NOT CFMSYSTEMCALLS}
  1431.     INLINE $2EB8, $0AB4;            { MOVE.L $0AB4,(SP) }
  1432.     {$ENDC}
  1433.  
  1434. PROCEDURE LMSetTEScrpHandle( value: Handle );
  1435.     {$IFC NOT CFMSYSTEMCALLS}
  1436.     INLINE $21DF, $0AB4;            { MOVE.L (SP)+,$0AB4 }
  1437.     {$ENDC}
  1438.  
  1439. FUNCTION LMGetAppParmHandle : Handle;
  1440.     {$IFC NOT CFMSYSTEMCALLS}
  1441.     INLINE $2EB8, $0AEC;            { MOVE.L $0AEC,(SP) }
  1442.     {$ENDC}
  1443.  
  1444. PROCEDURE LMSetAppParmHandle( value: Handle );
  1445.     {$IFC NOT CFMSYSTEMCALLS}
  1446.     INLINE $21DF, $0AEC;            { MOVE.L (SP)+,$0AEC }
  1447.     {$ENDC}
  1448.  
  1449. FUNCTION LMGetDSErrCode : SInt16;
  1450.     {$IFC NOT CFMSYSTEMCALLS}
  1451.     INLINE $3EB8, $0AF0;            { MOVE.W $0AF0,(SP) }
  1452.     {$ENDC}
  1453.  
  1454. PROCEDURE LMSetDSErrCode( value: SInt16 );
  1455.     {$IFC NOT CFMSYSTEMCALLS}
  1456.     INLINE $31DF, $0AF0;            { MOVE.W (SP)+,$0AF0 }
  1457.     {$ENDC}
  1458.  
  1459. FUNCTION LMGetResErrProc : ResErrUPP;
  1460.     {$IFC NOT CFMSYSTEMCALLS}
  1461.     INLINE $2EB8, $0AF2;            { MOVE.L $0AF2,(SP) }
  1462.     {$ENDC}
  1463.  
  1464. PROCEDURE LMSetResErrProc( value: ResErrUPP );
  1465.     {$IFC NOT CFMSYSTEMCALLS}
  1466.     INLINE $21DF, $0AF2;            { MOVE.L (SP)+,$0AF2 }
  1467.     {$ENDC}
  1468.  
  1469. FUNCTION LMGetDlgFont : SInt16;
  1470.     {$IFC NOT CFMSYSTEMCALLS}
  1471.     INLINE $3EB8, $0AFA;            { MOVE.W $0AFA,(SP) }
  1472.     {$ENDC}
  1473.  
  1474. PROCEDURE LMSetDlgFont( value: SInt16 );
  1475.     {$IFC NOT CFMSYSTEMCALLS}
  1476.     INLINE $31DF, $0AFA;            { MOVE.W (SP)+,$0AFA }
  1477.     {$ENDC}
  1478.  
  1479. FUNCTION LMGetROMMapHandle : Handle;
  1480.     {$IFC NOT CFMSYSTEMCALLS}
  1481.     INLINE $2EB8, $0B06;            { MOVE.L $0B06,(SP) }
  1482.     {$ENDC}
  1483.  
  1484. PROCEDURE LMSetROMMapHandle( value: Handle );
  1485.     {$IFC NOT CFMSYSTEMCALLS}
  1486.     INLINE $21DF, $0B06;            { MOVE.L (SP)+,$0B06 }
  1487.     {$ENDC}
  1488.  
  1489. FUNCTION LMGetWidthPtr : Ptr;
  1490.     {$IFC NOT CFMSYSTEMCALLS}
  1491.     INLINE $2EB8, $0B10;            { MOVE.L $0B10,(SP) }
  1492.     {$ENDC}
  1493.  
  1494. PROCEDURE LMSetWidthPtr( value: Ptr );
  1495.     {$IFC NOT CFMSYSTEMCALLS}
  1496.     INLINE $21DF, $0B10;            { MOVE.L (SP)+,$0B10 }
  1497.     {$ENDC}
  1498.  
  1499. FUNCTION LMGetATalkHk2 : Ptr;
  1500.     {$IFC NOT CFMSYSTEMCALLS}
  1501.     INLINE $2EB8, $0B18;            { MOVE.L $0B18,(SP) }
  1502.     {$ENDC}
  1503.  
  1504. PROCEDURE LMSetATalkHk2( value: Ptr );
  1505.     {$IFC NOT CFMSYSTEMCALLS}
  1506.     INLINE $21DF, $0B18;            { MOVE.L (SP)+,$0B18 }
  1507.     {$ENDC}
  1508.  
  1509. FUNCTION LMGetHWCfgFlags : SInt16;
  1510.     {$IFC NOT CFMSYSTEMCALLS}
  1511.     INLINE $3EB8, $0B22;            { MOVE.W $0B22,(SP) }
  1512.     {$ENDC}
  1513.  
  1514. PROCEDURE LMSetHWCfgFlags( value: SInt16 );
  1515.     {$IFC NOT CFMSYSTEMCALLS}
  1516.     INLINE $31DF, $0B22;            { MOVE.W (SP)+,$0B22 }
  1517.     {$ENDC}
  1518.  
  1519. FUNCTION LMGetWidthTabHandle : Handle;
  1520.     {$IFC NOT CFMSYSTEMCALLS}
  1521.     INLINE $2EB8, $0B2A;            { MOVE.L $0B2A,(SP) }
  1522.     {$ENDC}
  1523.  
  1524. PROCEDURE LMSetWidthTabHandle( value: Handle );
  1525.     {$IFC NOT CFMSYSTEMCALLS}
  1526.     INLINE $21DF, $0B2A;            { MOVE.L (SP)+,$0B2A }
  1527.     {$ENDC}
  1528.  
  1529. FUNCTION LMGetLastSPExtra : SInt32;
  1530.     {$IFC NOT CFMSYSTEMCALLS}
  1531.     INLINE $2EB8, $0B4C;            { MOVE.L $0B4C,(SP) }
  1532.     {$ENDC}
  1533.  
  1534. PROCEDURE LMSetLastSPExtra( value: SInt32 );
  1535.     {$IFC NOT CFMSYSTEMCALLS}
  1536.     INLINE $21DF, $0B4C;            { MOVE.L (SP)+,$0B4C }
  1537.     {$ENDC}
  1538.  
  1539. FUNCTION LMGetMenuDisable : SInt32;
  1540.     {$IFC NOT CFMSYSTEMCALLS}
  1541.     INLINE $2EB8, $0B54;            { MOVE.L $0B54,(SP) }
  1542.     {$ENDC}
  1543.  
  1544. PROCEDURE LMSetMenuDisable( value: SInt32 );
  1545.     {$IFC NOT CFMSYSTEMCALLS}
  1546.     INLINE $21DF, $0B54;            { MOVE.L (SP)+,$0B54 }
  1547.     {$ENDC}
  1548.  
  1549. FUNCTION LMGetROMMapInsert : ByteParameter;
  1550.     {$IFC NOT CFMSYSTEMCALLS}
  1551.     INLINE $1EB8, $0B9E;            { MOVE.B $0B9E,(SP) }
  1552.     {$ENDC}
  1553.  
  1554. PROCEDURE LMSetROMMapInsert( value: ByteParameter );
  1555.     {$IFC NOT CFMSYSTEMCALLS}
  1556.     INLINE $11DF, $0B9E;            { MOVE.B (SP)+,$0B9E }
  1557.     {$ENDC}
  1558.  
  1559. FUNCTION LMGetTmpResLoad : ByteParameter;
  1560.     {$IFC NOT CFMSYSTEMCALLS}
  1561.     INLINE $1EB8, $0B9F;            { MOVE.B $0B9F,(SP) }
  1562.     {$ENDC}
  1563.  
  1564. PROCEDURE LMSetTmpResLoad( value: ByteParameter );
  1565.     {$IFC NOT CFMSYSTEMCALLS}
  1566.     INLINE $11DF, $0B9F;            { MOVE.B (SP)+,$0B9F }
  1567.     {$ENDC}
  1568.  
  1569. FUNCTION LMGetIntlSpec : Ptr;
  1570.     {$IFC NOT CFMSYSTEMCALLS}
  1571.     INLINE $2EB8, $0BA0;            { MOVE.L $0BA0,(SP) }
  1572.     {$ENDC}
  1573.  
  1574. PROCEDURE LMSetIntlSpec( value: Ptr );
  1575.     {$IFC NOT CFMSYSTEMCALLS}
  1576.     INLINE $21DF, $0BA0;            { MOVE.L (SP)+,$0BA0 }
  1577.     {$ENDC}
  1578.  
  1579. FUNCTION LMGetWordRedraw : ByteParameter;
  1580.     {$IFC NOT CFMSYSTEMCALLS}
  1581.     INLINE $1EB8, $0BA5;            { MOVE.B $0BA5,(SP) }
  1582.     {$ENDC}
  1583.  
  1584. PROCEDURE LMSetWordRedraw( value: ByteParameter );
  1585.     {$IFC NOT CFMSYSTEMCALLS}
  1586.     INLINE $11DF, $0BA5;            { MOVE.B (SP)+,$0BA5 }
  1587.     {$ENDC}
  1588.  
  1589. FUNCTION LMGetSysFontFam : SInt16;
  1590.     {$IFC NOT CFMSYSTEMCALLS}
  1591.     INLINE $3EB8, $0BA6;            { MOVE.W $0BA6,(SP) }
  1592.     {$ENDC}
  1593.  
  1594. PROCEDURE LMSetSysFontFam( value: SInt16 );
  1595.     {$IFC NOT CFMSYSTEMCALLS}
  1596.     INLINE $31DF, $0BA6;            { MOVE.W (SP)+,$0BA6 }
  1597.     {$ENDC}
  1598.  
  1599. FUNCTION LMGetSysFontSize : SInt16;
  1600.     {$IFC NOT CFMSYSTEMCALLS}
  1601.     INLINE $3EB8, $0BA8;            { MOVE.W $0BA8,(SP) }
  1602.     {$ENDC}
  1603.  
  1604. PROCEDURE LMSetSysFontSize( value: SInt16 );
  1605.     {$IFC NOT CFMSYSTEMCALLS}
  1606.     INLINE $31DF, $0BA8;            { MOVE.W (SP)+,$0BA8 }
  1607.     {$ENDC}
  1608.  
  1609. FUNCTION LMGetMBarHeight : SInt16;
  1610.     {$IFC NOT CFMSYSTEMCALLS}
  1611.     INLINE $3EB8, $0BAA;            { MOVE.W $0BAA,(SP) }
  1612.     {$ENDC}
  1613.  
  1614. PROCEDURE LMSetMBarHeight( value: SInt16 );
  1615.     {$IFC NOT CFMSYSTEMCALLS}
  1616.     INLINE $31DF, $0BAA;            { MOVE.W (SP)+,$0BAA }
  1617.     {$ENDC}
  1618.  
  1619. FUNCTION LMGetTESysJust : SInt16;
  1620.     {$IFC NOT CFMSYSTEMCALLS}
  1621.     INLINE $3EB8, $0BAC;            { MOVE.W $0BAC,(SP) }
  1622.     {$ENDC}
  1623.  
  1624. PROCEDURE LMSetTESysJust( value: SInt16 );
  1625.     {$IFC NOT CFMSYSTEMCALLS}
  1626.     INLINE $31DF, $0BAC;            { MOVE.W (SP)+,$0BAC }
  1627.     {$ENDC}
  1628.  
  1629. FUNCTION LMGetHighHeapMark : Ptr;
  1630.     {$IFC NOT CFMSYSTEMCALLS}
  1631.     INLINE $2EB8, $0BAE;            { MOVE.L $0BAE,(SP) }
  1632.     {$ENDC}
  1633.  
  1634. PROCEDURE LMSetHighHeapMark( value: Ptr );
  1635.     {$IFC NOT CFMSYSTEMCALLS}
  1636.     INLINE $21DF, $0BAE;            { MOVE.L (SP)+,$0BAE }
  1637.     {$ENDC}
  1638.  
  1639. FUNCTION LMGetLastFOND : Handle;
  1640.     {$IFC NOT CFMSYSTEMCALLS}
  1641.     INLINE $2EB8, $0BC2;            { MOVE.L $0BC2,(SP) }
  1642.     {$ENDC}
  1643.  
  1644. PROCEDURE LMSetLastFOND( value: Handle );
  1645.     {$IFC NOT CFMSYSTEMCALLS}
  1646.     INLINE $21DF, $0BC2;            { MOVE.L (SP)+,$0BC2 }
  1647.     {$ENDC}
  1648.  
  1649. FUNCTION LMGetFractEnable : ByteParameter;
  1650.     {$IFC NOT CFMSYSTEMCALLS}
  1651.     INLINE $1EB8, $0BF4;            { MOVE.B $0BF4,(SP) }
  1652.     {$ENDC}
  1653.  
  1654. PROCEDURE LMSetFractEnable( value: ByteParameter );
  1655.     {$IFC NOT CFMSYSTEMCALLS}
  1656.     INLINE $11DF, $0BF4;            { MOVE.B (SP)+,$0BF4 }
  1657.     {$ENDC}
  1658.  
  1659. FUNCTION LMGetMMU32Bit : ByteParameter;
  1660.     {$IFC NOT CFMSYSTEMCALLS}
  1661.     INLINE $1EB8, $0CB2;            { MOVE.B $0CB2,(SP) }
  1662.     {$ENDC}
  1663.  
  1664. PROCEDURE LMSetMMU32Bit( value: ByteParameter );
  1665.     {$IFC NOT CFMSYSTEMCALLS}
  1666.     INLINE $11DF, $0CB2;            { MOVE.B (SP)+,$0CB2 }
  1667.     {$ENDC}
  1668.  
  1669. FUNCTION LMGetTheGDevice : GDHandle;
  1670.     {$IFC NOT CFMSYSTEMCALLS}
  1671.     INLINE $2EB8, $0CC8;            { MOVE.L $0CC8,(SP) }
  1672.     {$ENDC}
  1673.  
  1674. PROCEDURE LMSetTheGDevice( value: GDHandle );
  1675.     {$IFC NOT CFMSYSTEMCALLS}
  1676.     INLINE $21DF, $0CC8;            { MOVE.L (SP)+,$0CC8 }
  1677.     {$ENDC}
  1678.  
  1679. FUNCTION LMGetDeskCPat : PixPatHandle;
  1680.     {$IFC NOT CFMSYSTEMCALLS}
  1681.     INLINE $2EB8, $0CD8;            { MOVE.L $0CD8,(SP) }
  1682.     {$ENDC}
  1683.  
  1684. PROCEDURE LMSetDeskCPat( value: PixPatHandle );
  1685.     {$IFC NOT CFMSYSTEMCALLS}
  1686.     INLINE $21DF, $0CD8;            { MOVE.L (SP)+,$0CD8 }
  1687.     {$ENDC}
  1688.  
  1689. FUNCTION LMGetTimeDBRA : SInt16;
  1690.     {$IFC NOT CFMSYSTEMCALLS}
  1691.     INLINE $3EB8, $0D00;            { MOVE.W $0D00,(SP) }
  1692.     {$ENDC}
  1693.  
  1694. PROCEDURE LMSetTimeDBRA( value: SInt16 );
  1695.     {$IFC NOT CFMSYSTEMCALLS}
  1696.     INLINE $31DF, $0D00;            { MOVE.W (SP)+,$0D00 }
  1697.     {$ENDC}
  1698.  
  1699. FUNCTION LMGetTimeSCCDB : SInt16;
  1700.     {$IFC NOT CFMSYSTEMCALLS}
  1701.     INLINE $3EB8, $0D02;            { MOVE.W $0D02,(SP) }
  1702.     {$ENDC}
  1703.  
  1704. PROCEDURE LMSetTimeSCCDB( value: SInt16 );
  1705.     {$IFC NOT CFMSYSTEMCALLS}
  1706.     INLINE $31DF, $0D02;            { MOVE.W (SP)+,$0D02 }
  1707.     {$ENDC}
  1708.  
  1709. FUNCTION LMGetJVBLTask : UniversalProcPtr;
  1710.     {$IFC NOT CFMSYSTEMCALLS}
  1711.     INLINE $2EB8, $0D28;            { MOVE.L $0D28,(SP) }
  1712.     {$ENDC}
  1713.  
  1714. PROCEDURE LMSetJVBLTask( value: UniversalProcPtr );
  1715.     {$IFC NOT CFMSYSTEMCALLS}
  1716.     INLINE $21DF, $0D28;            { MOVE.L (SP)+,$0D28 }
  1717.     {$ENDC}
  1718.  
  1719. FUNCTION LMGetSynListHandle : Handle;
  1720.     {$IFC NOT CFMSYSTEMCALLS}
  1721.     INLINE $2EB8, $0D32;            { MOVE.L $0D32,(SP) }
  1722.     {$ENDC}
  1723.  
  1724. PROCEDURE LMSetSynListHandle( value: Handle );
  1725.     {$IFC NOT CFMSYSTEMCALLS}
  1726.     INLINE $21DF, $0D32;            { MOVE.L (SP)+,$0D32 }
  1727.     {$ENDC}
  1728.  
  1729. FUNCTION LMGetMenuCInfo : MCTableHandle;
  1730.     {$IFC NOT CFMSYSTEMCALLS}
  1731.     INLINE $2EB8, $0D50;            { MOVE.L $0D50,(SP) }
  1732.     {$ENDC}
  1733.  
  1734. PROCEDURE LMSetMenuCInfo( value: MCTableHandle );
  1735.     {$IFC NOT CFMSYSTEMCALLS}
  1736.     INLINE $21DF, $0D50;            { MOVE.L (SP)+,$0D50 }
  1737.     {$ENDC}
  1738.  
  1739. FUNCTION LMGetDTQueue : QHdrPtr;
  1740.     {$IFC NOT CFMSYSTEMCALLS}
  1741.     INLINE $2EB8, $0D92;            { MOVE.L $0D92,(SP) }
  1742.     {$ENDC}
  1743.  
  1744. PROCEDURE LMSetDTQueue( value: QHdrPtr );
  1745.     {$IFC NOT CFMSYSTEMCALLS}
  1746.     INLINE $21DF, $0D92;            { MOVE.L (SP)+,$0D92 }
  1747.     {$ENDC}
  1748.  
  1749. FUNCTION LMGetJDTInstall : UniversalProcPtr;
  1750.     {$IFC NOT CFMSYSTEMCALLS}
  1751.     INLINE $2EB8, $0D9C;            { MOVE.L $0D9C,(SP) }
  1752.     {$ENDC}
  1753.  
  1754. PROCEDURE LMSetJDTInstall( value: UniversalProcPtr );
  1755.     {$IFC NOT CFMSYSTEMCALLS}
  1756.     INLINE $21DF, $0D9C;            { MOVE.L (SP)+,$0D9C }
  1757.     {$ENDC}
  1758.  
  1759. FUNCTION LMGetTimeSCSIDB : SInt16;
  1760.     {$IFC NOT CFMSYSTEMCALLS}
  1761.     INLINE $3EB8, $0B24;            { MOVE.W $0B24,(SP) }
  1762.     {$ENDC}
  1763.  
  1764. PROCEDURE LMSetTimeSCSIDB( value: SInt16 );
  1765.     {$IFC NOT CFMSYSTEMCALLS}
  1766.     INLINE $31DF, $0B24;            { MOVE.W (SP)+,$0B24 }
  1767.     {$ENDC}
  1768.  
  1769. FUNCTION LMGetFSQHdr : QHdrPtr;
  1770.     {$IFC NOT CFMSYSTEMCALLS}
  1771.     INLINE $2EB8, $0360;            { MOVE.L $0360,(SP) }
  1772.     {$ENDC}
  1773.  
  1774. {*************************************************************************************
  1775.  
  1776.     MORE COMPLEX LOWMEM ACCESSORS
  1777.  
  1778. *************************************************************************************}
  1779. {$IFC CFMSYSTEMCALLS }
  1780. PROCEDURE LMGetDSAlertRect(VAR dsAlertRectValue: Rect);
  1781. PROCEDURE LMSetDSAlertRect({CONST}VAR dsAlertRectValue: Rect);
  1782. PROCEDURE LMGetDragPattern(VAR dragPatternValue: Pattern);
  1783. PROCEDURE LMSetDragPattern({CONST}VAR dragPatternValue: Pattern);
  1784. PROCEDURE LMGetDeskPattern(VAR deskPatternValue: Pattern);
  1785. PROCEDURE LMSetDeskPattern({CONST}VAR deskPatternValue: Pattern);
  1786. PROCEDURE LMGetHiliteRGB(VAR hiliteRGBValue: RGBColor);
  1787. PROCEDURE LMSetHiliteRGB({CONST}VAR hiliteRGBValue: RGBColor);
  1788. FUNCTION LMGetEventQueue: QHdrPtr;
  1789. PROCEDURE LMSetEventQueue(eventQueueValue: QHdrPtr);
  1790. FUNCTION LMGetVBLQueue: QHdrPtr;
  1791. PROCEDURE LMSetVBLQueue(vblQueueValue: QHdrPtr);
  1792. FUNCTION LMGetDrvQHdr: QHdrPtr;
  1793. PROCEDURE LMSetDrvQHdr(drvQHdrValue: QHdrPtr);
  1794. FUNCTION LMGetVCBQHdr: QHdrPtr;
  1795. PROCEDURE LMSetVCBQHdr(vcbQHdrValue: QHdrPtr);
  1796. {*************************************************************************************
  1797.     "BLOCKMOVE ACCESSORS"
  1798.     
  1799.         These lowmem accessors use the BlockMove trap
  1800. *************************************************************************************}
  1801. FUNCTION LMGetCurApName: StringPtr;
  1802. PROCEDURE LMSetCurApName(curApNameValue: ConstStr31Param);
  1803. FUNCTION LMGetSysResName: StringPtr;
  1804. PROCEDURE LMSetSysResName(sysResNameValue: ConstStr15Param);
  1805. FUNCTION LMGetFinderName: StringPtr;
  1806. PROCEDURE LMSetFinderName(finderNameValue: ConstStr15Param);
  1807. FUNCTION LMGetABusVars: Ptr;
  1808. PROCEDURE LMSetABusVars(aBusVarsValue: Ptr);
  1809. FUNCTION LMGetScratch20: Ptr;
  1810. PROCEDURE LMSetScratch20(scratch20Value: UNIV Ptr);
  1811. FUNCTION LMGetToolScratch: Ptr;
  1812. PROCEDURE LMSetToolScratch(toolScratchValue: UNIV Ptr);
  1813. FUNCTION LMGetApplScratch: Ptr;
  1814. PROCEDURE LMSetApplScratch(applScratchValue: UNIV Ptr);
  1815. {*************************************************************************************
  1816.     "INDEXED ACCESSORS"
  1817.     
  1818.         These lowmem accessors take an index parameter to get/set an indexed
  1819.         lowmem global.
  1820. *************************************************************************************}
  1821. FUNCTION LMGetDAStrings(whichString: INTEGER): StringHandle;
  1822. PROCEDURE LMSetDAStrings(DAStringsValue: StringHandle; whichString: INTEGER);
  1823. FUNCTION LMGetLvl2DT(vectorNumber: INTEGER): UniversalProcPtr;
  1824. PROCEDURE LMSetLvl2DT(Lvl2DTValue: UniversalProcPtr; vectorNumber: INTEGER);
  1825. FUNCTION LMGetExtStsDT(vectorNumber: INTEGER): UniversalProcPtr;
  1826. PROCEDURE LMSetExtStsDT(ExtStsDTValue: UniversalProcPtr; vectorNumber: INTEGER);
  1827. {$ENDC}
  1828.  
  1829. {$ALIGN RESET}
  1830. {$POP}
  1831.  
  1832. {$SETC UsingIncludes := LowMemIncludes}
  1833.  
  1834. {$ENDC} {__LOWMEM__}
  1835.  
  1836. {$IFC NOT UsingIncludes}
  1837.  END.
  1838. {$ENDC}
  1839.