home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / amiga / programm / programi / gcc_9112.lzh / include20 / inline / dos.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-15  |  60.0 KB  |  2,704 lines
  1. #include <inline/stub.h>
  2. #ifndef BASE_EXT_DECL
  3. #define BASE_EXT_DECL extern struct DOSBase * DOSBase;
  4. #endif
  5. #ifndef BASE_PAR_DECL
  6. #define BASE_PAR_DECL
  7. #define BASE_PAR_DECL0 void
  8. #endif
  9. #ifndef BASE_NAME
  10. #define BASE_NAME DOSBase
  11. #endif
  12. __inline static BPTR Open(BASE_PAR_DECL UBYTE* name, long int accessMode)
  13. {
  14.     BASE_EXT_DECL
  15.     register BPTR res __asm("d0");
  16.     register void *a6 __asm ("a6");
  17.     register UBYTE* d1 __asm("d1");
  18.     register long int d2 __asm("d2");
  19.  
  20.     a6 = BASE_NAME;
  21.     d1 = name;
  22.     d2 = accessMode;
  23.     __asm volatile ("
  24.     jsr a6@(-0x1e)"
  25.     : "=g" (res)
  26.     : "g" (a6), "g" (d1), "g" (d2)
  27.     : "d0", "d1", "a0", "a1", "d2");
  28.     return res;
  29. }
  30. __inline static LONG Close(BASE_PAR_DECL BPTR file)
  31. {
  32.     BASE_EXT_DECL
  33.     register LONG res __asm("d0");
  34.     register void *a6 __asm ("a6");
  35.     register BPTR d1 __asm("d1");
  36.  
  37.     a6 = BASE_NAME;
  38.     d1 = file;
  39.     __asm volatile ("
  40.     jsr a6@(-0x24)"
  41.     : "=g" (res)
  42.     : "g" (a6), "g" (d1)
  43.     : "d0", "d1", "a0", "a1");
  44.     return res;
  45. }
  46. __inline static LONG Read(BASE_PAR_DECL BPTR file, APTR buffer, long int length)
  47. {
  48.     BASE_EXT_DECL
  49.     register LONG res __asm("d0");
  50.     register void *a6 __asm ("a6");
  51.     register BPTR d1 __asm("d1");
  52.     register APTR d2 __asm("d2");
  53.     register long int d3 __asm("d3");
  54.  
  55.     a6 = BASE_NAME;
  56.     d1 = file;
  57.     d2 = buffer;
  58.     d3 = length;
  59.     __asm volatile ("
  60.     jsr a6@(-0x2a)"
  61.     : "=g" (res)
  62.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  63.     : "d0", "d1", "a0", "a1", "d2", "d3");
  64.     return res;
  65. }
  66. __inline static LONG Write(BASE_PAR_DECL BPTR file, APTR buffer, long int length)
  67. {
  68.     BASE_EXT_DECL
  69.     register LONG res __asm("d0");
  70.     register void *a6 __asm ("a6");
  71.     register BPTR d1 __asm("d1");
  72.     register APTR d2 __asm("d2");
  73.     register long int d3 __asm("d3");
  74.  
  75.     a6 = BASE_NAME;
  76.     d1 = file;
  77.     d2 = buffer;
  78.     d3 = length;
  79.     __asm volatile ("
  80.     jsr a6@(-0x30)"
  81.     : "=g" (res)
  82.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  83.     : "d0", "d1", "a0", "a1", "d2", "d3");
  84.     return res;
  85. }
  86. __inline static BPTR Input(BASE_PAR_DECL0)
  87. {
  88.     BASE_EXT_DECL
  89.     register BPTR res __asm("d0");
  90.     register void *a6 __asm ("a6");
  91.     a6 = BASE_NAME;
  92.     __asm volatile ("
  93.     jsr a6@(-0x36)"
  94.     : "=g" (res)
  95.     : "g" (a6)
  96.     : "d0", "d1", "a0", "a1");
  97.     return res;
  98. }
  99. __inline static BPTR Output(BASE_PAR_DECL0)
  100. {
  101.     BASE_EXT_DECL
  102.     register BPTR res __asm("d0");
  103.     register void *a6 __asm ("a6");
  104.     a6 = BASE_NAME;
  105.     __asm volatile ("
  106.     jsr a6@(-0x3c)"
  107.     : "=g" (res)
  108.     : "g" (a6)
  109.     : "d0", "d1", "a0", "a1");
  110.     return res;
  111. }
  112. __inline static LONG Seek(BASE_PAR_DECL BPTR file, long int position, long int offset)
  113. {
  114.     BASE_EXT_DECL
  115.     register LONG res __asm("d0");
  116.     register void *a6 __asm ("a6");
  117.     register BPTR d1 __asm("d1");
  118.     register long int d2 __asm("d2");
  119.     register long int d3 __asm("d3");
  120.  
  121.     a6 = BASE_NAME;
  122.     d1 = file;
  123.     d2 = position;
  124.     d3 = offset;
  125.     __asm volatile ("
  126.     jsr a6@(-0x42)"
  127.     : "=g" (res)
  128.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  129.     : "d0", "d1", "a0", "a1", "d2", "d3");
  130.     return res;
  131. }
  132. __inline static LONG DeleteFile(BASE_PAR_DECL UBYTE* name)
  133. {
  134.     BASE_EXT_DECL
  135.     register LONG res __asm("d0");
  136.     register void *a6 __asm ("a6");
  137.     register UBYTE* d1 __asm("d1");
  138.  
  139.     a6 = BASE_NAME;
  140.     d1 = name;
  141.     __asm volatile ("
  142.     jsr a6@(-0x48)"
  143.     : "=g" (res)
  144.     : "g" (a6), "g" (d1)
  145.     : "d0", "d1", "a0", "a1");
  146.     return res;
  147. }
  148. __inline static LONG Rename(BASE_PAR_DECL UBYTE* oldName, UBYTE* newName)
  149. {
  150.     BASE_EXT_DECL
  151.     register LONG res __asm("d0");
  152.     register void *a6 __asm ("a6");
  153.     register UBYTE* d1 __asm("d1");
  154.     register UBYTE* d2 __asm("d2");
  155.  
  156.     a6 = BASE_NAME;
  157.     d1 = oldName;
  158.     d2 = newName;
  159.     __asm volatile ("
  160.     jsr a6@(-0x4e)"
  161.     : "=g" (res)
  162.     : "g" (a6), "g" (d1), "g" (d2)
  163.     : "d0", "d1", "a0", "a1", "d2");
  164.     return res;
  165. }
  166. __inline static BPTR Lock(BASE_PAR_DECL UBYTE* name, long int type)
  167. {
  168.     BASE_EXT_DECL
  169.     register BPTR res __asm("d0");
  170.     register void *a6 __asm ("a6");
  171.     register UBYTE* d1 __asm("d1");
  172.     register long int d2 __asm("d2");
  173.  
  174.     a6 = BASE_NAME;
  175.     d1 = name;
  176.     d2 = type;
  177.     __asm volatile ("
  178.     jsr a6@(-0x54)"
  179.     : "=g" (res)
  180.     : "g" (a6), "g" (d1), "g" (d2)
  181.     : "d0", "d1", "a0", "a1", "d2");
  182.     return res;
  183. }
  184. __inline static void UnLock(BASE_PAR_DECL BPTR lock)
  185. {
  186.     BASE_EXT_DECL
  187.     register void *a6 __asm ("a6");
  188.     register BPTR d1 __asm("d1");
  189.  
  190.     a6 = BASE_NAME;
  191.     d1 = lock;
  192.     __asm volatile ("
  193.     jsr a6@(-0x5a)"
  194.     : /* no output */
  195.     : "g" (a6), "g" (d1)
  196.     : "d0", "d1", "a0", "a1");
  197. }
  198. __inline static BPTR DupLock(BASE_PAR_DECL BPTR lock)
  199. {
  200.     BASE_EXT_DECL
  201.     register BPTR res __asm("d0");
  202.     register void *a6 __asm ("a6");
  203.     register BPTR d1 __asm("d1");
  204.  
  205.     a6 = BASE_NAME;
  206.     d1 = lock;
  207.     __asm volatile ("
  208.     jsr a6@(-0x60)"
  209.     : "=g" (res)
  210.     : "g" (a6), "g" (d1)
  211.     : "d0", "d1", "a0", "a1");
  212.     return res;
  213. }
  214. __inline static LONG Examine(BASE_PAR_DECL BPTR lock, struct FileInfoBlock* fileInfoBlock)
  215. {
  216.     BASE_EXT_DECL
  217.     register LONG res __asm("d0");
  218.     register void *a6 __asm ("a6");
  219.     register BPTR d1 __asm("d1");
  220.     register struct FileInfoBlock* d2 __asm("d2");
  221.  
  222.     a6 = BASE_NAME;
  223.     d1 = lock;
  224.     d2 = fileInfoBlock;
  225.     __asm volatile ("
  226.     jsr a6@(-0x66)"
  227.     : "=g" (res)
  228.     : "g" (a6), "g" (d1), "g" (d2)
  229.     : "d0", "d1", "a0", "a1", "d2");
  230.     return res;
  231. }
  232. __inline static LONG ExNext(BASE_PAR_DECL BPTR lock, struct FileInfoBlock* fileInfoBlock)
  233. {
  234.     BASE_EXT_DECL
  235.     register LONG res __asm("d0");
  236.     register void *a6 __asm ("a6");
  237.     register BPTR d1 __asm("d1");
  238.     register struct FileInfoBlock* d2 __asm("d2");
  239.  
  240.     a6 = BASE_NAME;
  241.     d1 = lock;
  242.     d2 = fileInfoBlock;
  243.     __asm volatile ("
  244.     jsr a6@(-0x6c)"
  245.     : "=g" (res)
  246.     : "g" (a6), "g" (d1), "g" (d2)
  247.     : "d0", "d1", "a0", "a1", "d2");
  248.     return res;
  249. }
  250. __inline static LONG Info(BASE_PAR_DECL BPTR lock, struct InfoData* parameterBlock)
  251. {
  252.     BASE_EXT_DECL
  253.     register LONG res __asm("d0");
  254.     register void *a6 __asm ("a6");
  255.     register BPTR d1 __asm("d1");
  256.     register struct InfoData* d2 __asm("d2");
  257.  
  258.     a6 = BASE_NAME;
  259.     d1 = lock;
  260.     d2 = parameterBlock;
  261.     __asm volatile ("
  262.     jsr a6@(-0x72)"
  263.     : "=g" (res)
  264.     : "g" (a6), "g" (d1), "g" (d2)
  265.     : "d0", "d1", "a0", "a1", "d2");
  266.     return res;
  267. }
  268. __inline static BPTR CreateDir(BASE_PAR_DECL UBYTE* name)
  269. {
  270.     BASE_EXT_DECL
  271.     register BPTR res __asm("d0");
  272.     register void *a6 __asm ("a6");
  273.     register UBYTE* d1 __asm("d1");
  274.  
  275.     a6 = BASE_NAME;
  276.     d1 = name;
  277.     __asm volatile ("
  278.     jsr a6@(-0x78)"
  279.     : "=g" (res)
  280.     : "g" (a6), "g" (d1)
  281.     : "d0", "d1", "a0", "a1");
  282.     return res;
  283. }
  284. __inline static BPTR CurrentDir(BASE_PAR_DECL BPTR lock)
  285. {
  286.     BASE_EXT_DECL
  287.     register BPTR res __asm("d0");
  288.     register void *a6 __asm ("a6");
  289.     register BPTR d1 __asm("d1");
  290.  
  291.     a6 = BASE_NAME;
  292.     d1 = lock;
  293.     __asm volatile ("
  294.     jsr a6@(-0x7e)"
  295.     : "=g" (res)
  296.     : "g" (a6), "g" (d1)
  297.     : "d0", "d1", "a0", "a1");
  298.     return res;
  299. }
  300. __inline static LONG IoErr(BASE_PAR_DECL0)
  301. {
  302.     BASE_EXT_DECL
  303.     register LONG res __asm("d0");
  304.     register void *a6 __asm ("a6");
  305.     a6 = BASE_NAME;
  306.     __asm volatile ("
  307.     jsr a6@(-0x84)"
  308.     : "=g" (res)
  309.     : "g" (a6)
  310.     : "d0", "d1", "a0", "a1");
  311.     return res;
  312. }
  313. __inline static struct MsgPort* CreateProc(BASE_PAR_DECL UBYTE* name, long int pri, BPTR segList, long int stackSize)
  314. {
  315.     BASE_EXT_DECL
  316.     register struct MsgPort* res __asm("d0");
  317.     register void *a6 __asm ("a6");
  318.     register UBYTE* d1 __asm("d1");
  319.     register long int d2 __asm("d2");
  320.     register BPTR d3 __asm("d3");
  321.     register long int d4 __asm("d4");
  322.  
  323.     a6 = BASE_NAME;
  324.     d1 = name;
  325.     d2 = pri;
  326.     d3 = segList;
  327.     d4 = stackSize;
  328.     __asm volatile ("
  329.     jsr a6@(-0x8a)"
  330.     : "=g" (res)
  331.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4)
  332.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4");
  333.     return res;
  334. }
  335. __inline static void Exit(BASE_PAR_DECL long int returnCode)
  336. {
  337.     BASE_EXT_DECL
  338.     register void *a6 __asm ("a6");
  339.     register long int d1 __asm("d1");
  340.  
  341.     a6 = BASE_NAME;
  342.     d1 = returnCode;
  343.     __asm volatile ("
  344.     jsr a6@(-0x90)"
  345.     : /* no output */
  346.     : "g" (a6), "g" (d1)
  347.     : "d0", "d1", "a0", "a1");
  348. }
  349. __inline static BPTR LoadSeg(BASE_PAR_DECL UBYTE* name)
  350. {
  351.     BASE_EXT_DECL
  352.     register BPTR res __asm("d0");
  353.     register void *a6 __asm ("a6");
  354.     register UBYTE* d1 __asm("d1");
  355.  
  356.     a6 = BASE_NAME;
  357.     d1 = name;
  358.     __asm volatile ("
  359.     jsr a6@(-0x96)"
  360.     : "=g" (res)
  361.     : "g" (a6), "g" (d1)
  362.     : "d0", "d1", "a0", "a1");
  363.     return res;
  364. }
  365. __inline static void UnLoadSeg(BASE_PAR_DECL BPTR seglist)
  366. {
  367.     BASE_EXT_DECL
  368.     register void *a6 __asm ("a6");
  369.     register BPTR d1 __asm("d1");
  370.  
  371.     a6 = BASE_NAME;
  372.     d1 = seglist;
  373.     __asm volatile ("
  374.     jsr a6@(-0x9c)"
  375.     : /* no output */
  376.     : "g" (a6), "g" (d1)
  377.     : "d0", "d1", "a0", "a1");
  378. }
  379. #ifdef PRIVATE
  380. #endif
  381. __inline static struct MsgPort* DeviceProc(BASE_PAR_DECL UBYTE* name)
  382. {
  383.     BASE_EXT_DECL
  384.     register struct MsgPort* res __asm("d0");
  385.     register void *a6 __asm ("a6");
  386.     register UBYTE* d1 __asm("d1");
  387.  
  388.     a6 = BASE_NAME;
  389.     d1 = name;
  390.     __asm volatile ("
  391.     jsr a6@(-0xae)"
  392.     : "=g" (res)
  393.     : "g" (a6), "g" (d1)
  394.     : "d0", "d1", "a0", "a1");
  395.     return res;
  396. }
  397. __inline static LONG SetComment(BASE_PAR_DECL UBYTE* name, UBYTE* comment)
  398. {
  399.     BASE_EXT_DECL
  400.     register LONG res __asm("d0");
  401.     register void *a6 __asm ("a6");
  402.     register UBYTE* d1 __asm("d1");
  403.     register UBYTE* d2 __asm("d2");
  404.  
  405.     a6 = BASE_NAME;
  406.     d1 = name;
  407.     d2 = comment;
  408.     __asm volatile ("
  409.     jsr a6@(-0xb4)"
  410.     : "=g" (res)
  411.     : "g" (a6), "g" (d1), "g" (d2)
  412.     : "d0", "d1", "a0", "a1", "d2");
  413.     return res;
  414. }
  415. __inline static LONG SetProtection(BASE_PAR_DECL UBYTE* name, long int protect)
  416. {
  417.     BASE_EXT_DECL
  418.     register LONG res __asm("d0");
  419.     register void *a6 __asm ("a6");
  420.     register UBYTE* d1 __asm("d1");
  421.     register long int d2 __asm("d2");
  422.  
  423.     a6 = BASE_NAME;
  424.     d1 = name;
  425.     d2 = protect;
  426.     __asm volatile ("
  427.     jsr a6@(-0xba)"
  428.     : "=g" (res)
  429.     : "g" (a6), "g" (d1), "g" (d2)
  430.     : "d0", "d1", "a0", "a1", "d2");
  431.     return res;
  432. }
  433. __inline static struct DateStamp* DateStamp(BASE_PAR_DECL struct DateStamp* date)
  434. {
  435.     BASE_EXT_DECL
  436.     register struct DateStamp* res __asm("d0");
  437.     register void *a6 __asm ("a6");
  438.     register struct DateStamp* d1 __asm("d1");
  439.  
  440.     a6 = BASE_NAME;
  441.     d1 = date;
  442.     __asm volatile ("
  443.     jsr a6@(-0xc0)"
  444.     : "=g" (res)
  445.     : "g" (a6), "g" (d1)
  446.     : "d0", "d1", "a0", "a1");
  447.     return res;
  448. }
  449. __inline static void Delay(BASE_PAR_DECL long int timeout)
  450. {
  451.     BASE_EXT_DECL
  452.     register void *a6 __asm ("a6");
  453.     register long int d1 __asm("d1");
  454.  
  455.     a6 = BASE_NAME;
  456.     d1 = timeout;
  457.     __asm volatile ("
  458.     jsr a6@(-0xc6)"
  459.     : /* no output */
  460.     : "g" (a6), "g" (d1)
  461.     : "d0", "d1", "a0", "a1");
  462. }
  463. __inline static LONG WaitForChar(BASE_PAR_DECL BPTR file, long int timeout)
  464. {
  465.     BASE_EXT_DECL
  466.     register LONG res __asm("d0");
  467.     register void *a6 __asm ("a6");
  468.     register BPTR d1 __asm("d1");
  469.     register long int d2 __asm("d2");
  470.  
  471.     a6 = BASE_NAME;
  472.     d1 = file;
  473.     d2 = timeout;
  474.     __asm volatile ("
  475.     jsr a6@(-0xcc)"
  476.     : "=g" (res)
  477.     : "g" (a6), "g" (d1), "g" (d2)
  478.     : "d0", "d1", "a0", "a1", "d2");
  479.     return res;
  480. }
  481. __inline static BPTR ParentDir(BASE_PAR_DECL BPTR lock)
  482. {
  483.     BASE_EXT_DECL
  484.     register BPTR res __asm("d0");
  485.     register void *a6 __asm ("a6");
  486.     register BPTR d1 __asm("d1");
  487.  
  488.     a6 = BASE_NAME;
  489.     d1 = lock;
  490.     __asm volatile ("
  491.     jsr a6@(-0xd2)"
  492.     : "=g" (res)
  493.     : "g" (a6), "g" (d1)
  494.     : "d0", "d1", "a0", "a1");
  495.     return res;
  496. }
  497. __inline static LONG IsInteractive(BASE_PAR_DECL BPTR file)
  498. {
  499.     BASE_EXT_DECL
  500.     register LONG res __asm("d0");
  501.     register void *a6 __asm ("a6");
  502.     register BPTR d1 __asm("d1");
  503.  
  504.     a6 = BASE_NAME;
  505.     d1 = file;
  506.     __asm volatile ("
  507.     jsr a6@(-0xd8)"
  508.     : "=g" (res)
  509.     : "g" (a6), "g" (d1)
  510.     : "d0", "d1", "a0", "a1");
  511.     return res;
  512. }
  513. __inline static LONG Execute(BASE_PAR_DECL UBYTE* string, BPTR file, BPTR file2)
  514. {
  515.     BASE_EXT_DECL
  516.     register LONG res __asm("d0");
  517.     register void *a6 __asm ("a6");
  518.     register UBYTE* d1 __asm("d1");
  519.     register BPTR d2 __asm("d2");
  520.     register BPTR d3 __asm("d3");
  521.  
  522.     a6 = BASE_NAME;
  523.     d1 = string;
  524.     d2 = file;
  525.     d3 = file2;
  526.     __asm volatile ("
  527.     jsr a6@(-0xde)"
  528.     : "=g" (res)
  529.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  530.     : "d0", "d1", "a0", "a1", "d2", "d3");
  531.     return res;
  532. }
  533. __inline static APTR AllocDosObject(BASE_PAR_DECL long unsigned int type, struct TagItem* tags)
  534. {
  535.     BASE_EXT_DECL
  536.     register APTR res __asm("d0");
  537.     register void *a6 __asm ("a6");
  538.     register long unsigned int d1 __asm("d1");
  539.     register struct TagItem* d2 __asm("d2");
  540.  
  541.     a6 = BASE_NAME;
  542.     d1 = type;
  543.     d2 = tags;
  544.     __asm volatile ("
  545.     jsr a6@(-0xe4)"
  546.     : "=g" (res)
  547.     : "g" (a6), "g" (d1), "g" (d2)
  548.     : "d0", "d1", "a0", "a1", "d2");
  549.     return res;
  550. }
  551. __inline static void FreeDosObject(BASE_PAR_DECL long unsigned int type, APTR ptr)
  552. {
  553.     BASE_EXT_DECL
  554.     register void *a6 __asm ("a6");
  555.     register long unsigned int d1 __asm("d1");
  556.     register APTR d2 __asm("d2");
  557.  
  558.     a6 = BASE_NAME;
  559.     d1 = type;
  560.     d2 = ptr;
  561.     __asm volatile ("
  562.     jsr a6@(-0xea)"
  563.     : /* no output */
  564.     : "g" (a6), "g" (d1), "g" (d2)
  565.     : "d0", "d1", "a0", "a1", "d2");
  566. }
  567. __inline static LONG DoPkt(BASE_PAR_DECL struct MsgPort* port, long int action, long int arg1, long int arg2, long int arg3, long int arg4, long int arg5)
  568. {
  569.     BASE_EXT_DECL
  570.     register LONG res __asm("d0");
  571.     register void *a6 __asm ("a6");
  572.     register struct MsgPort* d1 __asm("d1");
  573.     register long int d2 __asm("d2");
  574.     register long int d3 __asm("d3");
  575.     register long int d4 __asm("d4");
  576.     register long int d5 __asm("d5");
  577.     register long int d6 __asm("d6");
  578.     register long int d7 __asm("d7");
  579.  
  580.     a6 = BASE_NAME;
  581.     d1 = port;
  582.     d2 = action;
  583.     d3 = arg1;
  584.     d4 = arg2;
  585.     d5 = arg3;
  586.     d6 = arg4;
  587.     d7 = arg5;
  588.     __asm volatile ("" : /* no input */
  589.     : "g" (d1));
  590.     __asm volatile ("
  591.     jsr a6@(-0xf0)"
  592.     : "=g" (res)
  593.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4), "g" (d5), "g" (d6)
  594.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4", "d5", "d6", "d7");
  595.     return res;
  596. }
  597. __inline static void SendPkt(BASE_PAR_DECL struct DosPacket* dp, struct MsgPort* port, struct MsgPort* replyport)
  598. {
  599.     BASE_EXT_DECL
  600.     register void *a6 __asm ("a6");
  601.     register struct DosPacket* d1 __asm("d1");
  602.     register struct MsgPort* d2 __asm("d2");
  603.     register struct MsgPort* d3 __asm("d3");
  604.  
  605.     a6 = BASE_NAME;
  606.     d1 = dp;
  607.     d2 = port;
  608.     d3 = replyport;
  609.     __asm volatile ("
  610.     jsr a6@(-0xf6)"
  611.     : /* no output */
  612.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  613.     : "d0", "d1", "a0", "a1", "d2", "d3");
  614. }
  615. __inline static struct DosPacket* WaitPkt(BASE_PAR_DECL0)
  616. {
  617.     BASE_EXT_DECL
  618.     register struct DosPacket* res __asm("d0");
  619.     register void *a6 __asm ("a6");
  620.     a6 = BASE_NAME;
  621.     __asm volatile ("
  622.     jsr a6@(-0xfc)"
  623.     : "=g" (res)
  624.     : "g" (a6)
  625.     : "d0", "d1", "a0", "a1");
  626.     return res;
  627. }
  628. __inline static void ReplyPkt(BASE_PAR_DECL struct DosPacket* dp, long int res1, long int res2)
  629. {
  630.     BASE_EXT_DECL
  631.     register void *a6 __asm ("a6");
  632.     register struct DosPacket* d1 __asm("d1");
  633.     register long int d2 __asm("d2");
  634.     register long int d3 __asm("d3");
  635.  
  636.     a6 = BASE_NAME;
  637.     d1 = dp;
  638.     d2 = res1;
  639.     d3 = res2;
  640.     __asm volatile ("
  641.     jsr a6@(-0x102)"
  642.     : /* no output */
  643.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  644.     : "d0", "d1", "a0", "a1", "d2", "d3");
  645. }
  646. __inline static void AbortPkt(BASE_PAR_DECL struct MsgPort* port, struct DosPacket* pkt)
  647. {
  648.     BASE_EXT_DECL
  649.     register void *a6 __asm ("a6");
  650.     register struct MsgPort* d1 __asm("d1");
  651.     register struct DosPacket* d2 __asm("d2");
  652.  
  653.     a6 = BASE_NAME;
  654.     d1 = port;
  655.     d2 = pkt;
  656.     __asm volatile ("
  657.     jsr a6@(-0x108)"
  658.     : /* no output */
  659.     : "g" (a6), "g" (d1), "g" (d2)
  660.     : "d0", "d1", "a0", "a1", "d2");
  661. }
  662. __inline static BOOL LockRecord(BASE_PAR_DECL BPTR fh, long unsigned int offset, long unsigned int length, long unsigned int mode, long unsigned int timeout)
  663. {
  664.     BASE_EXT_DECL
  665.     register BOOL res __asm("d0");
  666.     register void *a6 __asm ("a6");
  667.     register BPTR d1 __asm("d1");
  668.     register long unsigned int d2 __asm("d2");
  669.     register long unsigned int d3 __asm("d3");
  670.     register long unsigned int d4 __asm("d4");
  671.     register long unsigned int d5 __asm("d5");
  672.  
  673.     a6 = BASE_NAME;
  674.     d1 = fh;
  675.     d2 = offset;
  676.     d3 = length;
  677.     d4 = mode;
  678.     d5 = timeout;
  679.     __asm volatile ("
  680.     jsr a6@(-0x10e)"
  681.     : "=g" (res)
  682.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4), "g" (d5)
  683.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4", "d5");
  684.     return res;
  685. }
  686. __inline static BOOL LockRecords(BASE_PAR_DECL struct RecordLock* recArray, long unsigned int timeout)
  687. {
  688.     BASE_EXT_DECL
  689.     register BOOL res __asm("d0");
  690.     register void *a6 __asm ("a6");
  691.     register struct RecordLock* d1 __asm("d1");
  692.     register long unsigned int d2 __asm("d2");
  693.  
  694.     a6 = BASE_NAME;
  695.     d1 = recArray;
  696.     d2 = timeout;
  697.     __asm volatile ("
  698.     jsr a6@(-0x114)"
  699.     : "=g" (res)
  700.     : "g" (a6), "g" (d1), "g" (d2)
  701.     : "d0", "d1", "a0", "a1", "d2");
  702.     return res;
  703. }
  704. __inline static BOOL UnLockRecord(BASE_PAR_DECL BPTR fh, long unsigned int offset, long unsigned int length)
  705. {
  706.     BASE_EXT_DECL
  707.     register BOOL res __asm("d0");
  708.     register void *a6 __asm ("a6");
  709.     register BPTR d1 __asm("d1");
  710.     register long unsigned int d2 __asm("d2");
  711.     register long unsigned int d3 __asm("d3");
  712.  
  713.     a6 = BASE_NAME;
  714.     d1 = fh;
  715.     d2 = offset;
  716.     d3 = length;
  717.     __asm volatile ("
  718.     jsr a6@(-0x11a)"
  719.     : "=g" (res)
  720.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  721.     : "d0", "d1", "a0", "a1", "d2", "d3");
  722.     return res;
  723. }
  724. __inline static BOOL UnLockRecords(BASE_PAR_DECL struct RecordLock* recArray)
  725. {
  726.     BASE_EXT_DECL
  727.     register BOOL res __asm("d0");
  728.     register void *a6 __asm ("a6");
  729.     register struct RecordLock* d1 __asm("d1");
  730.  
  731.     a6 = BASE_NAME;
  732.     d1 = recArray;
  733.     __asm volatile ("
  734.     jsr a6@(-0x120)"
  735.     : "=g" (res)
  736.     : "g" (a6), "g" (d1)
  737.     : "d0", "d1", "a0", "a1");
  738.     return res;
  739. }
  740. __inline static BPTR SelectInput(BASE_PAR_DECL BPTR fh)
  741. {
  742.     BASE_EXT_DECL
  743.     register BPTR res __asm("d0");
  744.     register void *a6 __asm ("a6");
  745.     register BPTR d1 __asm("d1");
  746.  
  747.     a6 = BASE_NAME;
  748.     d1 = fh;
  749.     __asm volatile ("
  750.     jsr a6@(-0x126)"
  751.     : "=g" (res)
  752.     : "g" (a6), "g" (d1)
  753.     : "d0", "d1", "a0", "a1");
  754.     return res;
  755. }
  756. __inline static BPTR SelectOutput(BASE_PAR_DECL BPTR fh)
  757. {
  758.     BASE_EXT_DECL
  759.     register BPTR res __asm("d0");
  760.     register void *a6 __asm ("a6");
  761.     register BPTR d1 __asm("d1");
  762.  
  763.     a6 = BASE_NAME;
  764.     d1 = fh;
  765.     __asm volatile ("
  766.     jsr a6@(-0x12c)"
  767.     : "=g" (res)
  768.     : "g" (a6), "g" (d1)
  769.     : "d0", "d1", "a0", "a1");
  770.     return res;
  771. }
  772. __inline static LONG FGetC(BASE_PAR_DECL BPTR fh)
  773. {
  774.     BASE_EXT_DECL
  775.     register LONG res __asm("d0");
  776.     register void *a6 __asm ("a6");
  777.     register BPTR d1 __asm("d1");
  778.  
  779.     a6 = BASE_NAME;
  780.     d1 = fh;
  781.     __asm volatile ("
  782.     jsr a6@(-0x132)"
  783.     : "=g" (res)
  784.     : "g" (a6), "g" (d1)
  785.     : "d0", "d1", "a0", "a1");
  786.     return res;
  787. }
  788. __inline static void FPutC(BASE_PAR_DECL BPTR fh, long unsigned int ch)
  789. {
  790.     BASE_EXT_DECL
  791.     register void *a6 __asm ("a6");
  792.     register BPTR d1 __asm("d1");
  793.     register long unsigned int d2 __asm("d2");
  794.  
  795.     a6 = BASE_NAME;
  796.     d1 = fh;
  797.     d2 = ch;
  798.     __asm volatile ("
  799.     jsr a6@(-0x138)"
  800.     : /* no output */
  801.     : "g" (a6), "g" (d1), "g" (d2)
  802.     : "d0", "d1", "a0", "a1", "d2");
  803. }
  804. __inline static LONG UnGetC(BASE_PAR_DECL BPTR fh, long int character)
  805. {
  806.     BASE_EXT_DECL
  807.     register LONG res __asm("d0");
  808.     register void *a6 __asm ("a6");
  809.     register BPTR d1 __asm("d1");
  810.     register long int d2 __asm("d2");
  811.  
  812.     a6 = BASE_NAME;
  813.     d1 = fh;
  814.     d2 = character;
  815.     __asm volatile ("
  816.     jsr a6@(-0x13e)"
  817.     : "=g" (res)
  818.     : "g" (a6), "g" (d1), "g" (d2)
  819.     : "d0", "d1", "a0", "a1", "d2");
  820.     return res;
  821. }
  822. __inline static LONG FRead(BASE_PAR_DECL BPTR fh, APTR block, long unsigned int blocklen, long unsigned int number)
  823. {
  824.     BASE_EXT_DECL
  825.     register LONG res __asm("d0");
  826.     register void *a6 __asm ("a6");
  827.     register BPTR d1 __asm("d1");
  828.     register APTR d2 __asm("d2");
  829.     register long unsigned int d3 __asm("d3");
  830.     register long unsigned int d4 __asm("d4");
  831.  
  832.     a6 = BASE_NAME;
  833.     d1 = fh;
  834.     d2 = block;
  835.     d3 = blocklen;
  836.     d4 = number;
  837.     __asm volatile ("
  838.     jsr a6@(-0x144)"
  839.     : "=g" (res)
  840.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4)
  841.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4");
  842.     return res;
  843. }
  844. __inline static LONG FWrite(BASE_PAR_DECL BPTR fh, APTR block, long unsigned int blocklen, long unsigned int number)
  845. {
  846.     BASE_EXT_DECL
  847.     register LONG res __asm("d0");
  848.     register void *a6 __asm ("a6");
  849.     register BPTR d1 __asm("d1");
  850.     register APTR d2 __asm("d2");
  851.     register long unsigned int d3 __asm("d3");
  852.     register long unsigned int d4 __asm("d4");
  853.  
  854.     a6 = BASE_NAME;
  855.     d1 = fh;
  856.     d2 = block;
  857.     d3 = blocklen;
  858.     d4 = number;
  859.     __asm volatile ("
  860.     jsr a6@(-0x14a)"
  861.     : "=g" (res)
  862.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4)
  863.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4");
  864.     return res;
  865. }
  866. __inline static UBYTE* FGets(BASE_PAR_DECL BPTR fh, UBYTE* buf, long unsigned int buflen)
  867. {
  868.     BASE_EXT_DECL
  869.     register UBYTE* res __asm("d0");
  870.     register void *a6 __asm ("a6");
  871.     register BPTR d1 __asm("d1");
  872.     register UBYTE* d2 __asm("d2");
  873.     register long unsigned int d3 __asm("d3");
  874.  
  875.     a6 = BASE_NAME;
  876.     d1 = fh;
  877.     d2 = buf;
  878.     d3 = buflen;
  879.     __asm volatile ("
  880.     jsr a6@(-0x150)"
  881.     : "=g" (res)
  882.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  883.     : "d0", "d1", "a0", "a1", "d2", "d3");
  884.     return res;
  885. }
  886. __inline static LONG FPuts(BASE_PAR_DECL BPTR fh, UBYTE* str)
  887. {
  888.     BASE_EXT_DECL
  889.     register LONG res __asm("d0");
  890.     register void *a6 __asm ("a6");
  891.     register BPTR d1 __asm("d1");
  892.     register UBYTE* d2 __asm("d2");
  893.  
  894.     a6 = BASE_NAME;
  895.     d1 = fh;
  896.     d2 = str;
  897.     __asm volatile ("
  898.     jsr a6@(-0x156)"
  899.     : "=g" (res)
  900.     : "g" (a6), "g" (d1), "g" (d2)
  901.     : "d0", "d1", "a0", "a1", "d2");
  902.     return res;
  903. }
  904. __inline static void VFWritef(BASE_PAR_DECL BPTR fh, UBYTE* format, LONG* argarray)
  905. {
  906.     BASE_EXT_DECL
  907.     register void *a6 __asm ("a6");
  908.     register BPTR d1 __asm("d1");
  909.     register UBYTE* d2 __asm("d2");
  910.     register LONG* d3 __asm("d3");
  911.  
  912.     a6 = BASE_NAME;
  913.     d1 = fh;
  914.     d2 = format;
  915.     d3 = argarray;
  916.     __asm volatile ("
  917.     jsr a6@(-0x15c)"
  918.     : /* no output */
  919.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  920.     : "d0", "d1", "a0", "a1", "d2", "d3");
  921. }
  922. __inline static LONG VFPrintf(BASE_PAR_DECL BPTR fh, UBYTE* format, LONG* argarray)
  923. {
  924.     BASE_EXT_DECL
  925.     register LONG res __asm("d0");
  926.     register void *a6 __asm ("a6");
  927.     register BPTR d1 __asm("d1");
  928.     register UBYTE* d2 __asm("d2");
  929.     register LONG* d3 __asm("d3");
  930.  
  931.     a6 = BASE_NAME;
  932.     d1 = fh;
  933.     d2 = format;
  934.     d3 = argarray;
  935.     __asm volatile ("
  936.     jsr a6@(-0x162)"
  937.     : "=g" (res)
  938.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  939.     : "d0", "d1", "a0", "a1", "d2", "d3");
  940.     return res;
  941. }
  942. __inline static void Flush(BASE_PAR_DECL BPTR fh)
  943. {
  944.     BASE_EXT_DECL
  945.     register void *a6 __asm ("a6");
  946.     register BPTR d1 __asm("d1");
  947.  
  948.     a6 = BASE_NAME;
  949.     d1 = fh;
  950.     __asm volatile ("
  951.     jsr a6@(-0x168)"
  952.     : /* no output */
  953.     : "g" (a6), "g" (d1)
  954.     : "d0", "d1", "a0", "a1");
  955. }
  956. __inline static LONG SetVBuf(BASE_PAR_DECL BPTR fh, UBYTE* buff, long int type, long int size)
  957. {
  958.     BASE_EXT_DECL
  959.     register LONG res __asm("d0");
  960.     register void *a6 __asm ("a6");
  961.     register BPTR d1 __asm("d1");
  962.     register UBYTE* d2 __asm("d2");
  963.     register long int d3 __asm("d3");
  964.     register long int d4 __asm("d4");
  965.  
  966.     a6 = BASE_NAME;
  967.     d1 = fh;
  968.     d2 = buff;
  969.     d3 = type;
  970.     d4 = size;
  971.     __asm volatile ("
  972.     jsr a6@(-0x16e)"
  973.     : "=g" (res)
  974.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4)
  975.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4");
  976.     return res;
  977. }
  978. __inline static BPTR DupLockFromFH(BASE_PAR_DECL BPTR fh)
  979. {
  980.     BASE_EXT_DECL
  981.     register BPTR res __asm("d0");
  982.     register void *a6 __asm ("a6");
  983.     register BPTR d1 __asm("d1");
  984.  
  985.     a6 = BASE_NAME;
  986.     d1 = fh;
  987.     __asm volatile ("
  988.     jsr a6@(-0x174)"
  989.     : "=g" (res)
  990.     : "g" (a6), "g" (d1)
  991.     : "d0", "d1", "a0", "a1");
  992.     return res;
  993. }
  994. __inline static BPTR OpenFromLock(BASE_PAR_DECL BPTR lock)
  995. {
  996.     BASE_EXT_DECL
  997.     register BPTR res __asm("d0");
  998.     register void *a6 __asm ("a6");
  999.     register BPTR d1 __asm("d1");
  1000.  
  1001.     a6 = BASE_NAME;
  1002.     d1 = lock;
  1003.     __asm volatile ("
  1004.     jsr a6@(-0x17a)"
  1005.     : "=g" (res)
  1006.     : "g" (a6), "g" (d1)
  1007.     : "d0", "d1", "a0", "a1");
  1008.     return res;
  1009. }
  1010. __inline static BPTR ParentOfFH(BASE_PAR_DECL BPTR fh)
  1011. {
  1012.     BASE_EXT_DECL
  1013.     register BPTR res __asm("d0");
  1014.     register void *a6 __asm ("a6");
  1015.     register BPTR d1 __asm("d1");
  1016.  
  1017.     a6 = BASE_NAME;
  1018.     d1 = fh;
  1019.     __asm volatile ("
  1020.     jsr a6@(-0x180)"
  1021.     : "=g" (res)
  1022.     : "g" (a6), "g" (d1)
  1023.     : "d0", "d1", "a0", "a1");
  1024.     return res;
  1025. }
  1026. __inline static BOOL ExamineFH(BASE_PAR_DECL BPTR fh, struct FileInfoBlock* fib)
  1027. {
  1028.     BASE_EXT_DECL
  1029.     register BOOL res __asm("d0");
  1030.     register void *a6 __asm ("a6");
  1031.     register BPTR d1 __asm("d1");
  1032.     register struct FileInfoBlock* d2 __asm("d2");
  1033.  
  1034.     a6 = BASE_NAME;
  1035.     d1 = fh;
  1036.     d2 = fib;
  1037.     __asm volatile ("
  1038.     jsr a6@(-0x186)"
  1039.     : "=g" (res)
  1040.     : "g" (a6), "g" (d1), "g" (d2)
  1041.     : "d0", "d1", "a0", "a1", "d2");
  1042.     return res;
  1043. }
  1044. __inline static LONG SetFileDate(BASE_PAR_DECL UBYTE* name, struct DateStamp* date)
  1045. {
  1046.     BASE_EXT_DECL
  1047.     register LONG res __asm("d0");
  1048.     register void *a6 __asm ("a6");
  1049.     register UBYTE* d1 __asm("d1");
  1050.     register struct DateStamp* d2 __asm("d2");
  1051.  
  1052.     a6 = BASE_NAME;
  1053.     d1 = name;
  1054.     d2 = date;
  1055.     __asm volatile ("
  1056.     jsr a6@(-0x18c)"
  1057.     : "=g" (res)
  1058.     : "g" (a6), "g" (d1), "g" (d2)
  1059.     : "d0", "d1", "a0", "a1", "d2");
  1060.     return res;
  1061. }
  1062. __inline static LONG NameFromLock(BASE_PAR_DECL BPTR lock, UBYTE* buffer, long int len)
  1063. {
  1064.     BASE_EXT_DECL
  1065.     register LONG res __asm("d0");
  1066.     register void *a6 __asm ("a6");
  1067.     register BPTR d1 __asm("d1");
  1068.     register UBYTE* d2 __asm("d2");
  1069.     register long int d3 __asm("d3");
  1070.  
  1071.     a6 = BASE_NAME;
  1072.     d1 = lock;
  1073.     d2 = buffer;
  1074.     d3 = len;
  1075.     __asm volatile ("
  1076.     jsr a6@(-0x192)"
  1077.     : "=g" (res)
  1078.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  1079.     : "d0", "d1", "a0", "a1", "d2", "d3");
  1080.     return res;
  1081. }
  1082. __inline static LONG NameFromFH(BASE_PAR_DECL BPTR fh, UBYTE* buffer, long int len)
  1083. {
  1084.     BASE_EXT_DECL
  1085.     register LONG res __asm("d0");
  1086.     register void *a6 __asm ("a6");
  1087.     register BPTR d1 __asm("d1");
  1088.     register UBYTE* d2 __asm("d2");
  1089.     register long int d3 __asm("d3");
  1090.  
  1091.     a6 = BASE_NAME;
  1092.     d1 = fh;
  1093.     d2 = buffer;
  1094.     d3 = len;
  1095.     __asm volatile ("
  1096.     jsr a6@(-0x198)"
  1097.     : "=g" (res)
  1098.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  1099.     : "d0", "d1", "a0", "a1", "d2", "d3");
  1100.     return res;
  1101. }
  1102. __inline static WORD SplitName(BASE_PAR_DECL UBYTE* name, long unsigned int seperator, UBYTE* buf, long int oldpos, long int size)
  1103. {
  1104.     BASE_EXT_DECL
  1105.     register WORD res __asm("d0");
  1106.     register void *a6 __asm ("a6");
  1107.     register UBYTE* d1 __asm("d1");
  1108.     register long unsigned int d2 __asm("d2");
  1109.     register UBYTE* d3 __asm("d3");
  1110.     register long int d4 __asm("d4");
  1111.     register long int d5 __asm("d5");
  1112.  
  1113.     a6 = BASE_NAME;
  1114.     d1 = name;
  1115.     d2 = seperator;
  1116.     d3 = buf;
  1117.     d4 = oldpos;
  1118.     d5 = size;
  1119.     __asm volatile ("
  1120.     jsr a6@(-0x19e)"
  1121.     : "=g" (res)
  1122.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4), "g" (d5)
  1123.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4", "d5");
  1124.     return res;
  1125. }
  1126. __inline static LONG SameLock(BASE_PAR_DECL BPTR lock1, BPTR lock2)
  1127. {
  1128.     BASE_EXT_DECL
  1129.     register LONG res __asm("d0");
  1130.     register void *a6 __asm ("a6");
  1131.     register BPTR d1 __asm("d1");
  1132.     register BPTR d2 __asm("d2");
  1133.  
  1134.     a6 = BASE_NAME;
  1135.     d1 = lock1;
  1136.     d2 = lock2;
  1137.     __asm volatile ("
  1138.     jsr a6@(-0x1a4)"
  1139.     : "=g" (res)
  1140.     : "g" (a6), "g" (d1), "g" (d2)
  1141.     : "d0", "d1", "a0", "a1", "d2");
  1142.     return res;
  1143. }
  1144. __inline static LONG SetMode(BASE_PAR_DECL BPTR fh, long int mode)
  1145. {
  1146.     BASE_EXT_DECL
  1147.     register LONG res __asm("d0");
  1148.     register void *a6 __asm ("a6");
  1149.     register BPTR d1 __asm("d1");
  1150.     register long int d2 __asm("d2");
  1151.  
  1152.     a6 = BASE_NAME;
  1153.     d1 = fh;
  1154.     d2 = mode;
  1155.     __asm volatile ("
  1156.     jsr a6@(-0x1aa)"
  1157.     : "=g" (res)
  1158.     : "g" (a6), "g" (d1), "g" (d2)
  1159.     : "d0", "d1", "a0", "a1", "d2");
  1160.     return res;
  1161. }
  1162. __inline static LONG ExAll(BASE_PAR_DECL BPTR lock, struct ExAllData* buffer, long int size, long int data, struct ExAllControl* control)
  1163. {
  1164.     BASE_EXT_DECL
  1165.     register LONG res __asm("d0");
  1166.     register void *a6 __asm ("a6");
  1167.     register BPTR d1 __asm("d1");
  1168.     register struct ExAllData* d2 __asm("d2");
  1169.     register long int d3 __asm("d3");
  1170.     register long int d4 __asm("d4");
  1171.     register struct ExAllControl* d5 __asm("d5");
  1172.  
  1173.     a6 = BASE_NAME;
  1174.     d1 = lock;
  1175.     d2 = buffer;
  1176.     d3 = size;
  1177.     d4 = data;
  1178.     d5 = control;
  1179.     __asm volatile ("
  1180.     jsr a6@(-0x1b0)"
  1181.     : "=g" (res)
  1182.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4), "g" (d5)
  1183.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4", "d5");
  1184.     return res;
  1185. }
  1186. __inline static LONG ReadLink(BASE_PAR_DECL struct MsgPort* port, BPTR lock, UBYTE* path, UBYTE* buffer, long unsigned int size)
  1187. {
  1188.     BASE_EXT_DECL
  1189.     register LONG res __asm("d0");
  1190.     register void *a6 __asm ("a6");
  1191.     register struct MsgPort* d1 __asm("d1");
  1192.     register BPTR d2 __asm("d2");
  1193.     register UBYTE* d3 __asm("d3");
  1194.     register UBYTE* d4 __asm("d4");
  1195.     register long unsigned int d5 __asm("d5");
  1196.  
  1197.     a6 = BASE_NAME;
  1198.     d1 = port;
  1199.     d2 = lock;
  1200.     d3 = path;
  1201.     d4 = buffer;
  1202.     d5 = size;
  1203.     __asm volatile ("
  1204.     jsr a6@(-0x1b6)"
  1205.     : "=g" (res)
  1206.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4), "g" (d5)
  1207.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4", "d5");
  1208.     return res;
  1209. }
  1210. __inline static LONG MakeLink(BASE_PAR_DECL UBYTE* name, long int dest, long int soft)
  1211. {
  1212.     BASE_EXT_DECL
  1213.     register LONG res __asm("d0");
  1214.     register void *a6 __asm ("a6");
  1215.     register UBYTE* d1 __asm("d1");
  1216.     register long int d2 __asm("d2");
  1217.     register long int d3 __asm("d3");
  1218.  
  1219.     a6 = BASE_NAME;
  1220.     d1 = name;
  1221.     d2 = dest;
  1222.     d3 = soft;
  1223.     __asm volatile ("
  1224.     jsr a6@(-0x1bc)"
  1225.     : "=g" (res)
  1226.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  1227.     : "d0", "d1", "a0", "a1", "d2", "d3");
  1228.     return res;
  1229. }
  1230. __inline static LONG ChangeMode(BASE_PAR_DECL long int type, BPTR fh, long int newmode)
  1231. {
  1232.     BASE_EXT_DECL
  1233.     register LONG res __asm("d0");
  1234.     register void *a6 __asm ("a6");
  1235.     register long int d1 __asm("d1");
  1236.     register BPTR d2 __asm("d2");
  1237.     register long int d3 __asm("d3");
  1238.  
  1239.     a6 = BASE_NAME;
  1240.     d1 = type;
  1241.     d2 = fh;
  1242.     d3 = newmode;
  1243.     __asm volatile ("
  1244.     jsr a6@(-0x1c2)"
  1245.     : "=g" (res)
  1246.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  1247.     : "d0", "d1", "a0", "a1", "d2", "d3");
  1248.     return res;
  1249. }
  1250. __inline static LONG SetFileSize(BASE_PAR_DECL BPTR fh, long int pos, long int mode)
  1251. {
  1252.     BASE_EXT_DECL
  1253.     register LONG res __asm("d0");
  1254.     register void *a6 __asm ("a6");
  1255.     register BPTR d1 __asm("d1");
  1256.     register long int d2 __asm("d2");
  1257.     register long int d3 __asm("d3");
  1258.  
  1259.     a6 = BASE_NAME;
  1260.     d1 = fh;
  1261.     d2 = pos;
  1262.     d3 = mode;
  1263.     __asm volatile ("
  1264.     jsr a6@(-0x1c8)"
  1265.     : "=g" (res)
  1266.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  1267.     : "d0", "d1", "a0", "a1", "d2", "d3");
  1268.     return res;
  1269. }
  1270. __inline static LONG SetIoErr(BASE_PAR_DECL long int result)
  1271. {
  1272.     BASE_EXT_DECL
  1273.     register LONG res __asm("d0");
  1274.     register void *a6 __asm ("a6");
  1275.     register long int d1 __asm("d1");
  1276.  
  1277.     a6 = BASE_NAME;
  1278.     d1 = result;
  1279.     __asm volatile ("
  1280.     jsr a6@(-0x1ce)"
  1281.     : "=g" (res)
  1282.     : "g" (a6), "g" (d1)
  1283.     : "d0", "d1", "a0", "a1");
  1284.     return res;
  1285. }
  1286. __inline static BOOL Fault(BASE_PAR_DECL long int code, UBYTE* header, UBYTE* buffer, long int len)
  1287. {
  1288.     BASE_EXT_DECL
  1289.     register BOOL res __asm("d0");
  1290.     register void *a6 __asm ("a6");
  1291.     register long int d1 __asm("d1");
  1292.     register UBYTE* d2 __asm("d2");
  1293.     register UBYTE* d3 __asm("d3");
  1294.     register long int d4 __asm("d4");
  1295.  
  1296.     a6 = BASE_NAME;
  1297.     d1 = code;
  1298.     d2 = header;
  1299.     d3 = buffer;
  1300.     d4 = len;
  1301.     __asm volatile ("
  1302.     jsr a6@(-0x1d4)"
  1303.     : "=g" (res)
  1304.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4)
  1305.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4");
  1306.     return res;
  1307. }
  1308. __inline static BOOL PrintFault(BASE_PAR_DECL long int code, UBYTE* header)
  1309. {
  1310.     BASE_EXT_DECL
  1311.     register BOOL res __asm("d0");
  1312.     register void *a6 __asm ("a6");
  1313.     register long int d1 __asm("d1");
  1314.     register UBYTE* d2 __asm("d2");
  1315.  
  1316.     a6 = BASE_NAME;
  1317.     d1 = code;
  1318.     d2 = header;
  1319.     __asm volatile ("
  1320.     jsr a6@(-0x1da)"
  1321.     : "=g" (res)
  1322.     : "g" (a6), "g" (d1), "g" (d2)
  1323.     : "d0", "d1", "a0", "a1", "d2");
  1324.     return res;
  1325. }
  1326. __inline static LONG ErrorReport(BASE_PAR_DECL long int code, long int type, long unsigned int arg1, struct MsgPort* device)
  1327. {
  1328.     BASE_EXT_DECL
  1329.     register LONG res __asm("d0");
  1330.     register void *a6 __asm ("a6");
  1331.     register long int d1 __asm("d1");
  1332.     register long int d2 __asm("d2");
  1333.     register long unsigned int d3 __asm("d3");
  1334.     register struct MsgPort* d4 __asm("d4");
  1335.  
  1336.     a6 = BASE_NAME;
  1337.     d1 = code;
  1338.     d2 = type;
  1339.     d3 = arg1;
  1340.     d4 = device;
  1341.     __asm volatile ("
  1342.     jsr a6@(-0x1e0)"
  1343.     : "=g" (res)
  1344.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4)
  1345.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4");
  1346.     return res;
  1347. }
  1348. __inline static struct CommandLineInterface* Cli(BASE_PAR_DECL0)
  1349. {
  1350.     BASE_EXT_DECL
  1351.     register struct CommandLineInterface* res __asm("d0");
  1352.     register void *a6 __asm ("a6");
  1353.     a6 = BASE_NAME;
  1354.     __asm volatile ("
  1355.     jsr a6@(-0x1ec)"
  1356.     : "=g" (res)
  1357.     : "g" (a6)
  1358.     : "d0", "d1", "a0", "a1");
  1359.     return res;
  1360. }
  1361. __inline static struct Process* CreateNewProc(BASE_PAR_DECL struct TagItem* tags)
  1362. {
  1363.     BASE_EXT_DECL
  1364.     register struct Process* res __asm("d0");
  1365.     register void *a6 __asm ("a6");
  1366.     register struct TagItem* d1 __asm("d1");
  1367.  
  1368.     a6 = BASE_NAME;
  1369.     d1 = tags;
  1370.     __asm volatile ("
  1371.     jsr a6@(-0x1f2)"
  1372.     : "=g" (res)
  1373.     : "g" (a6), "g" (d1)
  1374.     : "d0", "d1", "a0", "a1");
  1375.     return res;
  1376. }
  1377. __inline static LONG RunCommand(BASE_PAR_DECL BPTR seg, long int stack, UBYTE* paramptr, long int paramlen)
  1378. {
  1379.     BASE_EXT_DECL
  1380.     register LONG res __asm("d0");
  1381.     register void *a6 __asm ("a6");
  1382.     register BPTR d1 __asm("d1");
  1383.     register long int d2 __asm("d2");
  1384.     register UBYTE* d3 __asm("d3");
  1385.     register long int d4 __asm("d4");
  1386.  
  1387.     a6 = BASE_NAME;
  1388.     d1 = seg;
  1389.     d2 = stack;
  1390.     d3 = paramptr;
  1391.     d4 = paramlen;
  1392.     __asm volatile ("
  1393.     jsr a6@(-0x1f8)"
  1394.     : "=g" (res)
  1395.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4)
  1396.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4");
  1397.     return res;
  1398. }
  1399. __inline static struct MsgPort* GetConsoleTask(BASE_PAR_DECL0)
  1400. {
  1401.     BASE_EXT_DECL
  1402.     register struct MsgPort* res __asm("d0");
  1403.     register void *a6 __asm ("a6");
  1404.     a6 = BASE_NAME;
  1405.     __asm volatile ("
  1406.     jsr a6@(-0x1fe)"
  1407.     : "=g" (res)
  1408.     : "g" (a6)
  1409.     : "d0", "d1", "a0", "a1");
  1410.     return res;
  1411. }
  1412. __inline static struct MsgPort* SetConsoleTask(BASE_PAR_DECL struct MsgPort* task)
  1413. {
  1414.     BASE_EXT_DECL
  1415.     register struct MsgPort* res __asm("d0");
  1416.     register void *a6 __asm ("a6");
  1417.     register struct MsgPort* d1 __asm("d1");
  1418.  
  1419.     a6 = BASE_NAME;
  1420.     d1 = task;
  1421.     __asm volatile ("
  1422.     jsr a6@(-0x204)"
  1423.     : "=g" (res)
  1424.     : "g" (a6), "g" (d1)
  1425.     : "d0", "d1", "a0", "a1");
  1426.     return res;
  1427. }
  1428. __inline static struct MsgPort* GetFileSysTask(BASE_PAR_DECL0)
  1429. {
  1430.     BASE_EXT_DECL
  1431.     register struct MsgPort* res __asm("d0");
  1432.     register void *a6 __asm ("a6");
  1433.     a6 = BASE_NAME;
  1434.     __asm volatile ("
  1435.     jsr a6@(-0x20a)"
  1436.     : "=g" (res)
  1437.     : "g" (a6)
  1438.     : "d0", "d1", "a0", "a1");
  1439.     return res;
  1440. }
  1441. __inline static struct MsgPort* SetFileSysTask(BASE_PAR_DECL struct MsgPort* task)
  1442. {
  1443.     BASE_EXT_DECL
  1444.     register struct MsgPort* res __asm("d0");
  1445.     register void *a6 __asm ("a6");
  1446.     register struct MsgPort* d1 __asm("d1");
  1447.  
  1448.     a6 = BASE_NAME;
  1449.     d1 = task;
  1450.     __asm volatile ("
  1451.     jsr a6@(-0x210)"
  1452.     : "=g" (res)
  1453.     : "g" (a6), "g" (d1)
  1454.     : "d0", "d1", "a0", "a1");
  1455.     return res;
  1456. }
  1457. __inline static UBYTE* GetArgStr(BASE_PAR_DECL0)
  1458. {
  1459.     BASE_EXT_DECL
  1460.     register UBYTE* res __asm("d0");
  1461.     register void *a6 __asm ("a6");
  1462.     a6 = BASE_NAME;
  1463.     __asm volatile ("
  1464.     jsr a6@(-0x216)"
  1465.     : "=g" (res)
  1466.     : "g" (a6)
  1467.     : "d0", "d1", "a0", "a1");
  1468.     return res;
  1469. }
  1470. __inline static BOOL SetArgStr(BASE_PAR_DECL UBYTE* string)
  1471. {
  1472.     BASE_EXT_DECL
  1473.     register BOOL res __asm("d0");
  1474.     register void *a6 __asm ("a6");
  1475.     register UBYTE* d1 __asm("d1");
  1476.  
  1477.     a6 = BASE_NAME;
  1478.     d1 = string;
  1479.     __asm volatile ("
  1480.     jsr a6@(-0x21c)"
  1481.     : "=g" (res)
  1482.     : "g" (a6), "g" (d1)
  1483.     : "d0", "d1", "a0", "a1");
  1484.     return res;
  1485. }
  1486. __inline static struct Process* FindCliProc(BASE_PAR_DECL long unsigned int num)
  1487. {
  1488.     BASE_EXT_DECL
  1489.     register struct Process* res __asm("d0");
  1490.     register void *a6 __asm ("a6");
  1491.     register long unsigned int d1 __asm("d1");
  1492.  
  1493.     a6 = BASE_NAME;
  1494.     d1 = num;
  1495.     __asm volatile ("
  1496.     jsr a6@(-0x222)"
  1497.     : "=g" (res)
  1498.     : "g" (a6), "g" (d1)
  1499.     : "d0", "d1", "a0", "a1");
  1500.     return res;
  1501. }
  1502. __inline static ULONG MaxCli(BASE_PAR_DECL0)
  1503. {
  1504.     BASE_EXT_DECL
  1505.     register ULONG res __asm("d0");
  1506.     register void *a6 __asm ("a6");
  1507.     a6 = BASE_NAME;
  1508.     __asm volatile ("
  1509.     jsr a6@(-0x228)"
  1510.     : "=g" (res)
  1511.     : "g" (a6)
  1512.     : "d0", "d1", "a0", "a1");
  1513.     return res;
  1514. }
  1515. __inline static BOOL SetCurrentDirName(BASE_PAR_DECL UBYTE* name)
  1516. {
  1517.     BASE_EXT_DECL
  1518.     register BOOL res __asm("d0");
  1519.     register void *a6 __asm ("a6");
  1520.     register UBYTE* d1 __asm("d1");
  1521.  
  1522.     a6 = BASE_NAME;
  1523.     d1 = name;
  1524.     __asm volatile ("
  1525.     jsr a6@(-0x22e)"
  1526.     : "=g" (res)
  1527.     : "g" (a6), "g" (d1)
  1528.     : "d0", "d1", "a0", "a1");
  1529.     return res;
  1530. }
  1531. __inline static BOOL GetCurrentDirName(BASE_PAR_DECL UBYTE* buf, long int len)
  1532. {
  1533.     BASE_EXT_DECL
  1534.     register BOOL res __asm("d0");
  1535.     register void *a6 __asm ("a6");
  1536.     register UBYTE* d1 __asm("d1");
  1537.     register long int d2 __asm("d2");
  1538.  
  1539.     a6 = BASE_NAME;
  1540.     d1 = buf;
  1541.     d2 = len;
  1542.     __asm volatile ("
  1543.     jsr a6@(-0x234)"
  1544.     : "=g" (res)
  1545.     : "g" (a6), "g" (d1), "g" (d2)
  1546.     : "d0", "d1", "a0", "a1", "d2");
  1547.     return res;
  1548. }
  1549. __inline static BOOL SetProgramName(BASE_PAR_DECL UBYTE* name)
  1550. {
  1551.     BASE_EXT_DECL
  1552.     register BOOL res __asm("d0");
  1553.     register void *a6 __asm ("a6");
  1554.     register UBYTE* d1 __asm("d1");
  1555.  
  1556.     a6 = BASE_NAME;
  1557.     d1 = name;
  1558.     __asm volatile ("
  1559.     jsr a6@(-0x23a)"
  1560.     : "=g" (res)
  1561.     : "g" (a6), "g" (d1)
  1562.     : "d0", "d1", "a0", "a1");
  1563.     return res;
  1564. }
  1565. __inline static BOOL GetProgramName(BASE_PAR_DECL UBYTE* buf, long int len)
  1566. {
  1567.     BASE_EXT_DECL
  1568.     register BOOL res __asm("d0");
  1569.     register void *a6 __asm ("a6");
  1570.     register UBYTE* d1 __asm("d1");
  1571.     register long int d2 __asm("d2");
  1572.  
  1573.     a6 = BASE_NAME;
  1574.     d1 = buf;
  1575.     d2 = len;
  1576.     __asm volatile ("
  1577.     jsr a6@(-0x240)"
  1578.     : "=g" (res)
  1579.     : "g" (a6), "g" (d1), "g" (d2)
  1580.     : "d0", "d1", "a0", "a1", "d2");
  1581.     return res;
  1582. }
  1583. __inline static BOOL SetPrompt(BASE_PAR_DECL UBYTE* name)
  1584. {
  1585.     BASE_EXT_DECL
  1586.     register BOOL res __asm("d0");
  1587.     register void *a6 __asm ("a6");
  1588.     register UBYTE* d1 __asm("d1");
  1589.  
  1590.     a6 = BASE_NAME;
  1591.     d1 = name;
  1592.     __asm volatile ("
  1593.     jsr a6@(-0x246)"
  1594.     : "=g" (res)
  1595.     : "g" (a6), "g" (d1)
  1596.     : "d0", "d1", "a0", "a1");
  1597.     return res;
  1598. }
  1599. __inline static BOOL GetPrompt(BASE_PAR_DECL UBYTE* buf, long int len)
  1600. {
  1601.     BASE_EXT_DECL
  1602.     register BOOL res __asm("d0");
  1603.     register void *a6 __asm ("a6");
  1604.     register UBYTE* d1 __asm("d1");
  1605.     register long int d2 __asm("d2");
  1606.  
  1607.     a6 = BASE_NAME;
  1608.     d1 = buf;
  1609.     d2 = len;
  1610.     __asm volatile ("
  1611.     jsr a6@(-0x24c)"
  1612.     : "=g" (res)
  1613.     : "g" (a6), "g" (d1), "g" (d2)
  1614.     : "d0", "d1", "a0", "a1", "d2");
  1615.     return res;
  1616. }
  1617. __inline static BPTR SetProgramDir(BASE_PAR_DECL BPTR lock)
  1618. {
  1619.     BASE_EXT_DECL
  1620.     register BPTR res __asm("d0");
  1621.     register void *a6 __asm ("a6");
  1622.     register BPTR d1 __asm("d1");
  1623.  
  1624.     a6 = BASE_NAME;
  1625.     d1 = lock;
  1626.     __asm volatile ("
  1627.     jsr a6@(-0x252)"
  1628.     : "=g" (res)
  1629.     : "g" (a6), "g" (d1)
  1630.     : "d0", "d1", "a0", "a1");
  1631.     return res;
  1632. }
  1633. __inline static BPTR GetProgramDir(BASE_PAR_DECL0)
  1634. {
  1635.     BASE_EXT_DECL
  1636.     register BPTR res __asm("d0");
  1637.     register void *a6 __asm ("a6");
  1638.     a6 = BASE_NAME;
  1639.     __asm volatile ("
  1640.     jsr a6@(-0x258)"
  1641.     : "=g" (res)
  1642.     : "g" (a6)
  1643.     : "d0", "d1", "a0", "a1");
  1644.     return res;
  1645. }
  1646. __inline static LONG SystemTagList(BASE_PAR_DECL UBYTE* command, struct TagItem* tags)
  1647. {
  1648.     BASE_EXT_DECL
  1649.     register LONG res __asm("d0");
  1650.     register void *a6 __asm ("a6");
  1651.     register UBYTE* d1 __asm("d1");
  1652.     register struct TagItem* d2 __asm("d2");
  1653.  
  1654.     a6 = BASE_NAME;
  1655.     d1 = command;
  1656.     d2 = tags;
  1657.     __asm volatile ("
  1658.     jsr a6@(-0x25e)"
  1659.     : "=g" (res)
  1660.     : "g" (a6), "g" (d1), "g" (d2)
  1661.     : "d0", "d1", "a0", "a1", "d2");
  1662.     return res;
  1663. }
  1664. __inline static LONG AssignLock(BASE_PAR_DECL UBYTE* name, BPTR lock)
  1665. {
  1666.     BASE_EXT_DECL
  1667.     register LONG res __asm("d0");
  1668.     register void *a6 __asm ("a6");
  1669.     register UBYTE* d1 __asm("d1");
  1670.     register BPTR d2 __asm("d2");
  1671.  
  1672.     a6 = BASE_NAME;
  1673.     d1 = name;
  1674.     d2 = lock;
  1675.     __asm volatile ("
  1676.     jsr a6@(-0x264)"
  1677.     : "=g" (res)
  1678.     : "g" (a6), "g" (d1), "g" (d2)
  1679.     : "d0", "d1", "a0", "a1", "d2");
  1680.     return res;
  1681. }
  1682. __inline static BOOL AssignLate(BASE_PAR_DECL UBYTE* name, UBYTE* path)
  1683. {
  1684.     BASE_EXT_DECL
  1685.     register BOOL res __asm("d0");
  1686.     register void *a6 __asm ("a6");
  1687.     register UBYTE* d1 __asm("d1");
  1688.     register UBYTE* d2 __asm("d2");
  1689.  
  1690.     a6 = BASE_NAME;
  1691.     d1 = name;
  1692.     d2 = path;
  1693.     __asm volatile ("
  1694.     jsr a6@(-0x26a)"
  1695.     : "=g" (res)
  1696.     : "g" (a6), "g" (d1), "g" (d2)
  1697.     : "d0", "d1", "a0", "a1", "d2");
  1698.     return res;
  1699. }
  1700. __inline static BOOL AssignPath(BASE_PAR_DECL UBYTE* name, UBYTE* path)
  1701. {
  1702.     BASE_EXT_DECL
  1703.     register BOOL res __asm("d0");
  1704.     register void *a6 __asm ("a6");
  1705.     register UBYTE* d1 __asm("d1");
  1706.     register UBYTE* d2 __asm("d2");
  1707.  
  1708.     a6 = BASE_NAME;
  1709.     d1 = name;
  1710.     d2 = path;
  1711.     __asm volatile ("
  1712.     jsr a6@(-0x270)"
  1713.     : "=g" (res)
  1714.     : "g" (a6), "g" (d1), "g" (d2)
  1715.     : "d0", "d1", "a0", "a1", "d2");
  1716.     return res;
  1717. }
  1718. __inline static BOOL AssignAdd(BASE_PAR_DECL UBYTE* name, BPTR lock)
  1719. {
  1720.     BASE_EXT_DECL
  1721.     register BOOL res __asm("d0");
  1722.     register void *a6 __asm ("a6");
  1723.     register UBYTE* d1 __asm("d1");
  1724.     register BPTR d2 __asm("d2");
  1725.  
  1726.     a6 = BASE_NAME;
  1727.     d1 = name;
  1728.     d2 = lock;
  1729.     __asm volatile ("
  1730.     jsr a6@(-0x276)"
  1731.     : "=g" (res)
  1732.     : "g" (a6), "g" (d1), "g" (d2)
  1733.     : "d0", "d1", "a0", "a1", "d2");
  1734.     return res;
  1735. }
  1736. __inline static LONG RemAssignList(BASE_PAR_DECL UBYTE* name, BPTR lock)
  1737. {
  1738.     BASE_EXT_DECL
  1739.     register LONG res __asm("d0");
  1740.     register void *a6 __asm ("a6");
  1741.     register UBYTE* d1 __asm("d1");
  1742.     register BPTR d2 __asm("d2");
  1743.  
  1744.     a6 = BASE_NAME;
  1745.     d1 = name;
  1746.     d2 = lock;
  1747.     __asm volatile ("
  1748.     jsr a6@(-0x27c)"
  1749.     : "=g" (res)
  1750.     : "g" (a6), "g" (d1), "g" (d2)
  1751.     : "d0", "d1", "a0", "a1", "d2");
  1752.     return res;
  1753. }
  1754. __inline static struct DevProc* GetDeviceProc(BASE_PAR_DECL UBYTE* name, struct DevProc* dp)
  1755. {
  1756.     BASE_EXT_DECL
  1757.     register struct DevProc* res __asm("d0");
  1758.     register void *a6 __asm ("a6");
  1759.     register UBYTE* d1 __asm("d1");
  1760.     register struct DevProc* d2 __asm("d2");
  1761.  
  1762.     a6 = BASE_NAME;
  1763.     d1 = name;
  1764.     d2 = dp;
  1765.     __asm volatile ("
  1766.     jsr a6@(-0x282)"
  1767.     : "=g" (res)
  1768.     : "g" (a6), "g" (d1), "g" (d2)
  1769.     : "d0", "d1", "a0", "a1", "d2");
  1770.     return res;
  1771. }
  1772. __inline static void FreeDeviceProc(BASE_PAR_DECL struct DevProc* dp)
  1773. {
  1774.     BASE_EXT_DECL
  1775.     register void *a6 __asm ("a6");
  1776.     register struct DevProc* d1 __asm("d1");
  1777.  
  1778.     a6 = BASE_NAME;
  1779.     d1 = dp;
  1780.     __asm volatile ("
  1781.     jsr a6@(-0x288)"
  1782.     : /* no output */
  1783.     : "g" (a6), "g" (d1)
  1784.     : "d0", "d1", "a0", "a1");
  1785. }
  1786. __inline static struct DosList* LockDosList(BASE_PAR_DECL long unsigned int flags)
  1787. {
  1788.     BASE_EXT_DECL
  1789.     register struct DosList* res __asm("d0");
  1790.     register void *a6 __asm ("a6");
  1791.     register long unsigned int d1 __asm("d1");
  1792.  
  1793.     a6 = BASE_NAME;
  1794.     d1 = flags;
  1795.     __asm volatile ("
  1796.     jsr a6@(-0x28e)"
  1797.     : "=g" (res)
  1798.     : "g" (a6), "g" (d1)
  1799.     : "d0", "d1", "a0", "a1");
  1800.     return res;
  1801. }
  1802. __inline static void UnLockDosList(BASE_PAR_DECL long unsigned int flags)
  1803. {
  1804.     BASE_EXT_DECL
  1805.     register void *a6 __asm ("a6");
  1806.     register long unsigned int d1 __asm("d1");
  1807.  
  1808.     a6 = BASE_NAME;
  1809.     d1 = flags;
  1810.     __asm volatile ("
  1811.     jsr a6@(-0x294)"
  1812.     : /* no output */
  1813.     : "g" (a6), "g" (d1)
  1814.     : "d0", "d1", "a0", "a1");
  1815. }
  1816. __inline static struct DosList* AttemptLockDosList(BASE_PAR_DECL long unsigned int flags)
  1817. {
  1818.     BASE_EXT_DECL
  1819.     register struct DosList* res __asm("d0");
  1820.     register void *a6 __asm ("a6");
  1821.     register long unsigned int d1 __asm("d1");
  1822.  
  1823.     a6 = BASE_NAME;
  1824.     d1 = flags;
  1825.     __asm volatile ("
  1826.     jsr a6@(-0x29a)"
  1827.     : "=g" (res)
  1828.     : "g" (a6), "g" (d1)
  1829.     : "d0", "d1", "a0", "a1");
  1830.     return res;
  1831. }
  1832. __inline static BOOL RemDosEntry(BASE_PAR_DECL struct DosList* dlist)
  1833. {
  1834.     BASE_EXT_DECL
  1835.     register BOOL res __asm("d0");
  1836.     register void *a6 __asm ("a6");
  1837.     register struct DosList* d1 __asm("d1");
  1838.  
  1839.     a6 = BASE_NAME;
  1840.     d1 = dlist;
  1841.     __asm volatile ("
  1842.     jsr a6@(-0x2a0)"
  1843.     : "=g" (res)
  1844.     : "g" (a6), "g" (d1)
  1845.     : "d0", "d1", "a0", "a1");
  1846.     return res;
  1847. }
  1848. __inline static struct DosList* AddDosEntry(BASE_PAR_DECL struct DosList* dlist)
  1849. {
  1850.     BASE_EXT_DECL
  1851.     register struct DosList* res __asm("d0");
  1852.     register void *a6 __asm ("a6");
  1853.     register struct DosList* d1 __asm("d1");
  1854.  
  1855.     a6 = BASE_NAME;
  1856.     d1 = dlist;
  1857.     __asm volatile ("
  1858.     jsr a6@(-0x2a6)"
  1859.     : "=g" (res)
  1860.     : "g" (a6), "g" (d1)
  1861.     : "d0", "d1", "a0", "a1");
  1862.     return res;
  1863. }
  1864. __inline static struct DosList* FindDosEntry(BASE_PAR_DECL struct DosList* dlist, UBYTE* name, long unsigned int flags)
  1865. {
  1866.     BASE_EXT_DECL
  1867.     register struct DosList* res __asm("d0");
  1868.     register void *a6 __asm ("a6");
  1869.     register struct DosList* d1 __asm("d1");
  1870.     register UBYTE* d2 __asm("d2");
  1871.     register long unsigned int d3 __asm("d3");
  1872.  
  1873.     a6 = BASE_NAME;
  1874.     d1 = dlist;
  1875.     d2 = name;
  1876.     d3 = flags;
  1877.     __asm volatile ("
  1878.     jsr a6@(-0x2ac)"
  1879.     : "=g" (res)
  1880.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  1881.     : "d0", "d1", "a0", "a1", "d2", "d3");
  1882.     return res;
  1883. }
  1884. __inline static struct DosList* NextDosEntry(BASE_PAR_DECL struct DosList* dlist, long unsigned int flags)
  1885. {
  1886.     BASE_EXT_DECL
  1887.     register struct DosList* res __asm("d0");
  1888.     register void *a6 __asm ("a6");
  1889.     register struct DosList* d1 __asm("d1");
  1890.     register long unsigned int d2 __asm("d2");
  1891.  
  1892.     a6 = BASE_NAME;
  1893.     d1 = dlist;
  1894.     d2 = flags;
  1895.     __asm volatile ("
  1896.     jsr a6@(-0x2b2)"
  1897.     : "=g" (res)
  1898.     : "g" (a6), "g" (d1), "g" (d2)
  1899.     : "d0", "d1", "a0", "a1", "d2");
  1900.     return res;
  1901. }
  1902. __inline static struct DosList* MakeDosEntry(BASE_PAR_DECL UBYTE* name, long int type)
  1903. {
  1904.     BASE_EXT_DECL
  1905.     register struct DosList* res __asm("d0");
  1906.     register void *a6 __asm ("a6");
  1907.     register UBYTE* d1 __asm("d1");
  1908.     register long int d2 __asm("d2");
  1909.  
  1910.     a6 = BASE_NAME;
  1911.     d1 = name;
  1912.     d2 = type;
  1913.     __asm volatile ("
  1914.     jsr a6@(-0x2b8)"
  1915.     : "=g" (res)
  1916.     : "g" (a6), "g" (d1), "g" (d2)
  1917.     : "d0", "d1", "a0", "a1", "d2");
  1918.     return res;
  1919. }
  1920. __inline static void FreeDosEntry(BASE_PAR_DECL struct DosList* dlist)
  1921. {
  1922.     BASE_EXT_DECL
  1923.     register void *a6 __asm ("a6");
  1924.     register struct DosList* d1 __asm("d1");
  1925.  
  1926.     a6 = BASE_NAME;
  1927.     d1 = dlist;
  1928.     __asm volatile ("
  1929.     jsr a6@(-0x2be)"
  1930.     : /* no output */
  1931.     : "g" (a6), "g" (d1)
  1932.     : "d0", "d1", "a0", "a1");
  1933. }
  1934. __inline static BOOL IsFileSystem(BASE_PAR_DECL UBYTE* name)
  1935. {
  1936.     BASE_EXT_DECL
  1937.     register BOOL res __asm("d0");
  1938.     register void *a6 __asm ("a6");
  1939.     register UBYTE* d1 __asm("d1");
  1940.  
  1941.     a6 = BASE_NAME;
  1942.     d1 = name;
  1943.     __asm volatile ("
  1944.     jsr a6@(-0x2c4)"
  1945.     : "=g" (res)
  1946.     : "g" (a6), "g" (d1)
  1947.     : "d0", "d1", "a0", "a1");
  1948.     return res;
  1949. }
  1950. __inline static BOOL Format(BASE_PAR_DECL UBYTE* filesystem, UBYTE* volumename, long unsigned int dostype)
  1951. {
  1952.     BASE_EXT_DECL
  1953.     register BOOL res __asm("d0");
  1954.     register void *a6 __asm ("a6");
  1955.     register UBYTE* d1 __asm("d1");
  1956.     register UBYTE* d2 __asm("d2");
  1957.     register long unsigned int d3 __asm("d3");
  1958.  
  1959.     a6 = BASE_NAME;
  1960.     d1 = filesystem;
  1961.     d2 = volumename;
  1962.     d3 = dostype;
  1963.     __asm volatile ("
  1964.     jsr a6@(-0x2ca)"
  1965.     : "=g" (res)
  1966.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  1967.     : "d0", "d1", "a0", "a1", "d2", "d3");
  1968.     return res;
  1969. }
  1970. __inline static LONG Relabel(BASE_PAR_DECL UBYTE* drive, UBYTE* newname)
  1971. {
  1972.     BASE_EXT_DECL
  1973.     register LONG res __asm("d0");
  1974.     register void *a6 __asm ("a6");
  1975.     register UBYTE* d1 __asm("d1");
  1976.     register UBYTE* d2 __asm("d2");
  1977.  
  1978.     a6 = BASE_NAME;
  1979.     d1 = drive;
  1980.     d2 = newname;
  1981.     __asm volatile ("
  1982.     jsr a6@(-0x2d0)"
  1983.     : "=g" (res)
  1984.     : "g" (a6), "g" (d1), "g" (d2)
  1985.     : "d0", "d1", "a0", "a1", "d2");
  1986.     return res;
  1987. }
  1988. __inline static LONG Inhibit(BASE_PAR_DECL UBYTE* name, long int onoff)
  1989. {
  1990.     BASE_EXT_DECL
  1991.     register LONG res __asm("d0");
  1992.     register void *a6 __asm ("a6");
  1993.     register UBYTE* d1 __asm("d1");
  1994.     register long int d2 __asm("d2");
  1995.  
  1996.     a6 = BASE_NAME;
  1997.     d1 = name;
  1998.     d2 = onoff;
  1999.     __asm volatile ("
  2000.     jsr a6@(-0x2d6)"
  2001.     : "=g" (res)
  2002.     : "g" (a6), "g" (d1), "g" (d2)
  2003.     : "d0", "d1", "a0", "a1", "d2");
  2004.     return res;
  2005. }
  2006. __inline static LONG AddBuffers(BASE_PAR_DECL UBYTE* name, long int number)
  2007. {
  2008.     BASE_EXT_DECL
  2009.     register LONG res __asm("d0");
  2010.     register void *a6 __asm ("a6");
  2011.     register UBYTE* d1 __asm("d1");
  2012.     register long int d2 __asm("d2");
  2013.  
  2014.     a6 = BASE_NAME;
  2015.     d1 = name;
  2016.     d2 = number;
  2017.     __asm volatile ("
  2018.     jsr a6@(-0x2dc)"
  2019.     : "=g" (res)
  2020.     : "g" (a6), "g" (d1), "g" (d2)
  2021.     : "d0", "d1", "a0", "a1", "d2");
  2022.     return res;
  2023. }
  2024. __inline static LONG CompareDates(BASE_PAR_DECL struct DateStamp* date1, struct DateStamp* date2)
  2025. {
  2026.     BASE_EXT_DECL
  2027.     register LONG res __asm("d0");
  2028.     register void *a6 __asm ("a6");
  2029.     register struct DateStamp* d1 __asm("d1");
  2030.     register struct DateStamp* d2 __asm("d2");
  2031.  
  2032.     a6 = BASE_NAME;
  2033.     d1 = date1;
  2034.     d2 = date2;
  2035.     __asm volatile ("
  2036.     jsr a6@(-0x2e2)"
  2037.     : "=g" (res)
  2038.     : "g" (a6), "g" (d1), "g" (d2)
  2039.     : "d0", "d1", "a0", "a1", "d2");
  2040.     return res;
  2041. }
  2042. __inline static LONG DateToStr(BASE_PAR_DECL struct DateTime* datetime)
  2043. {
  2044.     BASE_EXT_DECL
  2045.     register LONG res __asm("d0");
  2046.     register void *a6 __asm ("a6");
  2047.     register struct DateTime* d1 __asm("d1");
  2048.  
  2049.     a6 = BASE_NAME;
  2050.     d1 = datetime;
  2051.     __asm volatile ("
  2052.     jsr a6@(-0x2e8)"
  2053.     : "=g" (res)
  2054.     : "g" (a6), "g" (d1)
  2055.     : "d0", "d1", "a0", "a1");
  2056.     return res;
  2057. }
  2058. __inline static LONG StrToDate(BASE_PAR_DECL struct DateTime* datetime)
  2059. {
  2060.     BASE_EXT_DECL
  2061.     register LONG res __asm("d0");
  2062.     register void *a6 __asm ("a6");
  2063.     register struct DateTime* d1 __asm("d1");
  2064.  
  2065.     a6 = BASE_NAME;
  2066.     d1 = datetime;
  2067.     __asm volatile ("
  2068.     jsr a6@(-0x2ee)"
  2069.     : "=g" (res)
  2070.     : "g" (a6), "g" (d1)
  2071.     : "d0", "d1", "a0", "a1");
  2072.     return res;
  2073. }
  2074. __inline static BPTR InternalLoadSeg(BASE_PAR_DECL BPTR fh, BPTR table, LONG* funcarray, LONG* stack)
  2075. {
  2076.     BASE_EXT_DECL
  2077.     register BPTR res __asm("d0");
  2078.     register void *a6 __asm ("a6");
  2079.     register BPTR d0 __asm("d0");
  2080.     register BPTR a0 __asm("a0");
  2081.     register LONG* a1 __asm("a1");
  2082.     register LONG* a2 __asm("a2");
  2083.  
  2084.     a6 = BASE_NAME;
  2085.     d0 = fh;
  2086.     a0 = table;
  2087.     a1 = funcarray;
  2088.     a2 = stack;
  2089.     __asm volatile ("
  2090.     jsr a6@(-0x2f4)"
  2091.     : "=g" (res)
  2092.     : "g" (a6), "g" (d0), "g" (a0), "g" (a1), "g" (a2)
  2093.     : "d0", "d1", "a0", "a1", "a2");
  2094.     return res;
  2095. }
  2096. __inline static void InternalUnLoadSeg(BASE_PAR_DECL BPTR seglist, void (*freefunc)())
  2097. {
  2098.     BASE_EXT_DECL
  2099.     register void *a6 __asm ("a6");
  2100.     register BPTR d1 __asm("d1");
  2101.     register void (*a1)() __asm("a1");
  2102.  
  2103.     a6 = BASE_NAME;
  2104.     d1 = seglist;
  2105.     a1 = freefunc;
  2106.     __asm volatile ("
  2107.     jsr a6@(-0x2fa)"
  2108.     : /* no output */
  2109.     : "g" (a6), "g" (d1), "g" (a1)
  2110.     : "d0", "d1", "a0", "a1");
  2111. }
  2112. __inline static BPTR NewLoadSeg(BASE_PAR_DECL UBYTE* file, struct TagItem* tags)
  2113. {
  2114.     BASE_EXT_DECL
  2115.     register BPTR res __asm("d0");
  2116.     register void *a6 __asm ("a6");
  2117.     register UBYTE* d1 __asm("d1");
  2118.     register struct TagItem* d2 __asm("d2");
  2119.  
  2120.     a6 = BASE_NAME;
  2121.     d1 = file;
  2122.     d2 = tags;
  2123.     __asm volatile ("
  2124.     jsr a6@(-0x300)"
  2125.     : "=g" (res)
  2126.     : "g" (a6), "g" (d1), "g" (d2)
  2127.     : "d0", "d1", "a0", "a1", "d2");
  2128.     return res;
  2129. }
  2130. __inline static LONG AddSegment(BASE_PAR_DECL UBYTE* name, BPTR seg, long int system)
  2131. {
  2132.     BASE_EXT_DECL
  2133.     register LONG res __asm("d0");
  2134.     register void *a6 __asm ("a6");
  2135.     register UBYTE* d1 __asm("d1");
  2136.     register BPTR d2 __asm("d2");
  2137.     register long int d3 __asm("d3");
  2138.  
  2139.     a6 = BASE_NAME;
  2140.     d1 = name;
  2141.     d2 = seg;
  2142.     d3 = system;
  2143.     __asm volatile ("
  2144.     jsr a6@(-0x306)"
  2145.     : "=g" (res)
  2146.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  2147.     : "d0", "d1", "a0", "a1", "d2", "d3");
  2148.     return res;
  2149. }
  2150. __inline static struct Segment* FindSegment(BASE_PAR_DECL UBYTE* name, struct Segment* seg, long int system)
  2151. {
  2152.     BASE_EXT_DECL
  2153.     register struct Segment* res __asm("d0");
  2154.     register void *a6 __asm ("a6");
  2155.     register UBYTE* d1 __asm("d1");
  2156.     register struct Segment* d2 __asm("d2");
  2157.     register long int d3 __asm("d3");
  2158.  
  2159.     a6 = BASE_NAME;
  2160.     d1 = name;
  2161.     d2 = seg;
  2162.     d3 = system;
  2163.     __asm volatile ("
  2164.     jsr a6@(-0x30c)"
  2165.     : "=g" (res)
  2166.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  2167.     : "d0", "d1", "a0", "a1", "d2", "d3");
  2168.     return res;
  2169. }
  2170. __inline static LONG RemSegment(BASE_PAR_DECL struct Segment* seg)
  2171. {
  2172.     BASE_EXT_DECL
  2173.     register LONG res __asm("d0");
  2174.     register void *a6 __asm ("a6");
  2175.     register struct Segment* d1 __asm("d1");
  2176.  
  2177.     a6 = BASE_NAME;
  2178.     d1 = seg;
  2179.     __asm volatile ("
  2180.     jsr a6@(-0x312)"
  2181.     : "=g" (res)
  2182.     : "g" (a6), "g" (d1)
  2183.     : "d0", "d1", "a0", "a1");
  2184.     return res;
  2185. }
  2186. __inline static LONG CheckSignal(BASE_PAR_DECL long int mask)
  2187. {
  2188.     BASE_EXT_DECL
  2189.     register LONG res __asm("d0");
  2190.     register void *a6 __asm ("a6");
  2191.     register long int d1 __asm("d1");
  2192.  
  2193.     a6 = BASE_NAME;
  2194.     d1 = mask;
  2195.     __asm volatile ("
  2196.     jsr a6@(-0x318)"
  2197.     : "=g" (res)
  2198.     : "g" (a6), "g" (d1)
  2199.     : "d0", "d1", "a0", "a1");
  2200.     return res;
  2201. }
  2202. __inline static struct RDArgs* ReadArgs(BASE_PAR_DECL UBYTE* template, LONG* array, struct RDArgs* args)
  2203. {
  2204.     BASE_EXT_DECL
  2205.     register struct RDArgs* res __asm("d0");
  2206.     register void *a6 __asm ("a6");
  2207.     register UBYTE* d1 __asm("d1");
  2208.     register LONG* d2 __asm("d2");
  2209.     register struct RDArgs* d3 __asm("d3");
  2210.  
  2211.     a6 = BASE_NAME;
  2212.     d1 = template;
  2213.     d2 = array;
  2214.     d3 = args;
  2215.     __asm volatile ("
  2216.     jsr a6@(-0x31e)"
  2217.     : "=g" (res)
  2218.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  2219.     : "d0", "d1", "a0", "a1", "d2", "d3");
  2220.     return res;
  2221. }
  2222. __inline static LONG FindArg(BASE_PAR_DECL UBYTE* keyword, UBYTE* template)
  2223. {
  2224.     BASE_EXT_DECL
  2225.     register LONG res __asm("d0");
  2226.     register void *a6 __asm ("a6");
  2227.     register UBYTE* d1 __asm("d1");
  2228.     register UBYTE* d2 __asm("d2");
  2229.  
  2230.     a6 = BASE_NAME;
  2231.     d1 = keyword;
  2232.     d2 = template;
  2233.     __asm volatile ("
  2234.     jsr a6@(-0x324)"
  2235.     : "=g" (res)
  2236.     : "g" (a6), "g" (d1), "g" (d2)
  2237.     : "d0", "d1", "a0", "a1", "d2");
  2238.     return res;
  2239. }
  2240. __inline static LONG ReadItem(BASE_PAR_DECL UBYTE* name, long int maxchars, struct CSource* cSource)
  2241. {
  2242.     BASE_EXT_DECL
  2243.     register LONG res __asm("d0");
  2244.     register void *a6 __asm ("a6");
  2245.     register UBYTE* d1 __asm("d1");
  2246.     register long int d2 __asm("d2");
  2247.     register struct CSource* d3 __asm("d3");
  2248.  
  2249.     a6 = BASE_NAME;
  2250.     d1 = name;
  2251.     d2 = maxchars;
  2252.     d3 = cSource;
  2253.     __asm volatile ("
  2254.     jsr a6@(-0x32a)"
  2255.     : "=g" (res)
  2256.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  2257.     : "d0", "d1", "a0", "a1", "d2", "d3");
  2258.     return res;
  2259. }
  2260. __inline static LONG StrToLong(BASE_PAR_DECL UBYTE* string, LONG* value)
  2261. {
  2262.     BASE_EXT_DECL
  2263.     register LONG res __asm("d0");
  2264.     register void *a6 __asm ("a6");
  2265.     register UBYTE* d1 __asm("d1");
  2266.     register LONG* d2 __asm("d2");
  2267.  
  2268.     a6 = BASE_NAME;
  2269.     d1 = string;
  2270.     d2 = value;
  2271.     __asm volatile ("
  2272.     jsr a6@(-0x330)"
  2273.     : "=g" (res)
  2274.     : "g" (a6), "g" (d1), "g" (d2)
  2275.     : "d0", "d1", "a0", "a1", "d2");
  2276.     return res;
  2277. }
  2278. __inline static LONG MatchFirst(BASE_PAR_DECL UBYTE* pat, struct AnchorPath* anchor)
  2279. {
  2280.     BASE_EXT_DECL
  2281.     register LONG res __asm("d0");
  2282.     register void *a6 __asm ("a6");
  2283.     register UBYTE* d1 __asm("d1");
  2284.     register struct AnchorPath* d2 __asm("d2");
  2285.  
  2286.     a6 = BASE_NAME;
  2287.     d1 = pat;
  2288.     d2 = anchor;
  2289.     __asm volatile ("
  2290.     jsr a6@(-0x336)"
  2291.     : "=g" (res)
  2292.     : "g" (a6), "g" (d1), "g" (d2)
  2293.     : "d0", "d1", "a0", "a1", "d2");
  2294.     return res;
  2295. }
  2296. __inline static LONG MatchNext(BASE_PAR_DECL struct AnchorPath* anchor)
  2297. {
  2298.     BASE_EXT_DECL
  2299.     register LONG res __asm("d0");
  2300.     register void *a6 __asm ("a6");
  2301.     register struct AnchorPath* d1 __asm("d1");
  2302.  
  2303.     a6 = BASE_NAME;
  2304.     d1 = anchor;
  2305.     __asm volatile ("
  2306.     jsr a6@(-0x33c)"
  2307.     : "=g" (res)
  2308.     : "g" (a6), "g" (d1)
  2309.     : "d0", "d1", "a0", "a1");
  2310.     return res;
  2311. }
  2312. __inline static void MatchEnd(BASE_PAR_DECL struct AnchorPath* anchor)
  2313. {
  2314.     BASE_EXT_DECL
  2315.     register void *a6 __asm ("a6");
  2316.     register struct AnchorPath* d1 __asm("d1");
  2317.  
  2318.     a6 = BASE_NAME;
  2319.     d1 = anchor;
  2320.     __asm volatile ("
  2321.     jsr a6@(-0x342)"
  2322.     : /* no output */
  2323.     : "g" (a6), "g" (d1)
  2324.     : "d0", "d1", "a0", "a1");
  2325. }
  2326. __inline static BOOL ParsePattern(BASE_PAR_DECL UBYTE* pat, UBYTE* buf, long int buflen)
  2327. {
  2328.     BASE_EXT_DECL
  2329.     register BOOL res __asm("d0");
  2330.     register void *a6 __asm ("a6");
  2331.     register UBYTE* d1 __asm("d1");
  2332.     register UBYTE* d2 __asm("d2");
  2333.     register long int d3 __asm("d3");
  2334.  
  2335.     a6 = BASE_NAME;
  2336.     d1 = pat;
  2337.     d2 = buf;
  2338.     d3 = buflen;
  2339.     __asm volatile ("
  2340.     jsr a6@(-0x348)"
  2341.     : "=g" (res)
  2342.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  2343.     : "d0", "d1", "a0", "a1", "d2", "d3");
  2344.     return res;
  2345. }
  2346. __inline static BOOL MatchPattern(BASE_PAR_DECL UBYTE* pat, UBYTE* str)
  2347. {
  2348.     BASE_EXT_DECL
  2349.     register BOOL res __asm("d0");
  2350.     register void *a6 __asm ("a6");
  2351.     register UBYTE* d1 __asm("d1");
  2352.     register UBYTE* d2 __asm("d2");
  2353.  
  2354.     a6 = BASE_NAME;
  2355.     d1 = pat;
  2356.     d2 = str;
  2357.     __asm volatile ("
  2358.     jsr a6@(-0x34e)"
  2359.     : "=g" (res)
  2360.     : "g" (a6), "g" (d1), "g" (d2)
  2361.     : "d0", "d1", "a0", "a1", "d2");
  2362.     return res;
  2363. }
  2364. #ifdef PRIVATE
  2365. #endif
  2366. __inline static void FreeArgs(BASE_PAR_DECL struct RDArgs* args)
  2367. {
  2368.     BASE_EXT_DECL
  2369.     register void *a6 __asm ("a6");
  2370.     register struct RDArgs* d1 __asm("d1");
  2371.  
  2372.     a6 = BASE_NAME;
  2373.     d1 = args;
  2374.     __asm volatile ("
  2375.     jsr a6@(-0x35a)"
  2376.     : /* no output */
  2377.     : "g" (a6), "g" (d1)
  2378.     : "d0", "d1", "a0", "a1");
  2379. }
  2380. __inline static UBYTE* FilePart(BASE_PAR_DECL UBYTE* path)
  2381. {
  2382.     BASE_EXT_DECL
  2383.     register UBYTE* res __asm("d0");
  2384.     register void *a6 __asm ("a6");
  2385.     register UBYTE* d1 __asm("d1");
  2386.  
  2387.     a6 = BASE_NAME;
  2388.     d1 = path;
  2389.     __asm volatile ("
  2390.     jsr a6@(-0x366)"
  2391.     : "=g" (res)
  2392.     : "g" (a6), "g" (d1)
  2393.     : "d0", "d1", "a0", "a1");
  2394.     return res;
  2395. }
  2396. __inline static UBYTE* PathPart(BASE_PAR_DECL UBYTE* path)
  2397. {
  2398.     BASE_EXT_DECL
  2399.     register UBYTE* res __asm("d0");
  2400.     register void *a6 __asm ("a6");
  2401.     register UBYTE* d1 __asm("d1");
  2402.  
  2403.     a6 = BASE_NAME;
  2404.     d1 = path;
  2405.     __asm volatile ("
  2406.     jsr a6@(-0x36c)"
  2407.     : "=g" (res)
  2408.     : "g" (a6), "g" (d1)
  2409.     : "d0", "d1", "a0", "a1");
  2410.     return res;
  2411. }
  2412. __inline static BOOL AddPart(BASE_PAR_DECL UBYTE* dirname, UBYTE* filename, long unsigned int size)
  2413. {
  2414.     BASE_EXT_DECL
  2415.     register BOOL res __asm("d0");
  2416.     register void *a6 __asm ("a6");
  2417.     register UBYTE* d1 __asm("d1");
  2418.     register UBYTE* d2 __asm("d2");
  2419.     register long unsigned int d3 __asm("d3");
  2420.  
  2421.     a6 = BASE_NAME;
  2422.     d1 = dirname;
  2423.     d2 = filename;
  2424.     d3 = size;
  2425.     __asm volatile ("
  2426.     jsr a6@(-0x372)"
  2427.     : "=g" (res)
  2428.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  2429.     : "d0", "d1", "a0", "a1", "d2", "d3");
  2430.     return res;
  2431. }
  2432. __inline static BOOL StartNotify(BASE_PAR_DECL struct NotifyRequest* notify)
  2433. {
  2434.     BASE_EXT_DECL
  2435.     register BOOL res __asm("d0");
  2436.     register void *a6 __asm ("a6");
  2437.     register struct NotifyRequest* d1 __asm("d1");
  2438.  
  2439.     a6 = BASE_NAME;
  2440.     d1 = notify;
  2441.     __asm volatile ("
  2442.     jsr a6@(-0x378)"
  2443.     : "=g" (res)
  2444.     : "g" (a6), "g" (d1)
  2445.     : "d0", "d1", "a0", "a1");
  2446.     return res;
  2447. }
  2448. __inline static void EndNotify(BASE_PAR_DECL struct NotifyRequest* notify)
  2449. {
  2450.     BASE_EXT_DECL
  2451.     register void *a6 __asm ("a6");
  2452.     register struct NotifyRequest* d1 __asm("d1");
  2453.  
  2454.     a6 = BASE_NAME;
  2455.     d1 = notify;
  2456.     __asm volatile ("
  2457.     jsr a6@(-0x37e)"
  2458.     : /* no output */
  2459.     : "g" (a6), "g" (d1)
  2460.     : "d0", "d1", "a0", "a1");
  2461. }
  2462. __inline static BOOL SetVar(BASE_PAR_DECL UBYTE* name, UBYTE* buffer, long int size, long int flags)
  2463. {
  2464.     BASE_EXT_DECL
  2465.     register BOOL res __asm("d0");
  2466.     register void *a6 __asm ("a6");
  2467.     register UBYTE* d1 __asm("d1");
  2468.     register UBYTE* d2 __asm("d2");
  2469.     register long int d3 __asm("d3");
  2470.     register long int d4 __asm("d4");
  2471.  
  2472.     a6 = BASE_NAME;
  2473.     d1 = name;
  2474.     d2 = buffer;
  2475.     d3 = size;
  2476.     d4 = flags;
  2477.     __asm volatile ("
  2478.     jsr a6@(-0x384)"
  2479.     : "=g" (res)
  2480.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4)
  2481.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4");
  2482.     return res;
  2483. }
  2484. __inline static LONG GetVar(BASE_PAR_DECL UBYTE* name, UBYTE* buffer, long int size, long int flags)
  2485. {
  2486.     BASE_EXT_DECL
  2487.     register LONG res __asm("d0");
  2488.     register void *a6 __asm ("a6");
  2489.     register UBYTE* d1 __asm("d1");
  2490.     register UBYTE* d2 __asm("d2");
  2491.     register long int d3 __asm("d3");
  2492.     register long int d4 __asm("d4");
  2493.  
  2494.     a6 = BASE_NAME;
  2495.     d1 = name;
  2496.     d2 = buffer;
  2497.     d3 = size;
  2498.     d4 = flags;
  2499.     __asm volatile ("
  2500.     jsr a6@(-0x38a)"
  2501.     : "=g" (res)
  2502.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3), "g" (d4)
  2503.     : "d0", "d1", "a0", "a1", "d2", "d3", "d4");
  2504.     return res;
  2505. }
  2506. __inline static LONG DeleteVar(BASE_PAR_DECL UBYTE* name, long unsigned int flags)
  2507. {
  2508.     BASE_EXT_DECL
  2509.     register LONG res __asm("d0");
  2510.     register void *a6 __asm ("a6");
  2511.     register UBYTE* d1 __asm("d1");
  2512.     register long unsigned int d2 __asm("d2");
  2513.  
  2514.     a6 = BASE_NAME;
  2515.     d1 = name;
  2516.     d2 = flags;
  2517.     __asm volatile ("
  2518.     jsr a6@(-0x390)"
  2519.     : "=g" (res)
  2520.     : "g" (a6), "g" (d1), "g" (d2)
  2521.     : "d0", "d1", "a0", "a1", "d2");
  2522.     return res;
  2523. }
  2524. __inline static struct LocalVar* FindVar(BASE_PAR_DECL UBYTE* name, long unsigned int type)
  2525. {
  2526.     BASE_EXT_DECL
  2527.     register struct LocalVar* res __asm("d0");
  2528.     register void *a6 __asm ("a6");
  2529.     register UBYTE* d1 __asm("d1");
  2530.     register long unsigned int d2 __asm("d2");
  2531.  
  2532.     a6 = BASE_NAME;
  2533.     d1 = name;
  2534.     d2 = type;
  2535.     __asm volatile ("
  2536.     jsr a6@(-0x396)"
  2537.     : "=g" (res)
  2538.     : "g" (a6), "g" (d1), "g" (d2)
  2539.     : "d0", "d1", "a0", "a1", "d2");
  2540.     return res;
  2541. }
  2542. __inline static LONG CliInit(BASE_PAR_DECL struct DosPacket* dp)
  2543. {
  2544.     BASE_EXT_DECL
  2545.     register LONG res __asm("d0");
  2546.     register void *a6 __asm ("a6");
  2547.     register struct DosPacket* a0 __asm("a0");
  2548.  
  2549.     a6 = BASE_NAME;
  2550.     a0 = dp;
  2551.     __asm volatile ("
  2552.     jsr a6@(-0x39c)"
  2553.     : "=g" (res)
  2554.     : "g" (a6), "g" (a0)
  2555.     : "d0", "d1", "a0", "a1");
  2556.     return res;
  2557. }
  2558. __inline static LONG CliInitNewcli(BASE_PAR_DECL struct DosPacket* dp)
  2559. {
  2560.     BASE_EXT_DECL
  2561.     register LONG res __asm("d0");
  2562.     register void *a6 __asm ("a6");
  2563.     register struct DosPacket* a0 __asm("a0");
  2564.  
  2565.     a6 = BASE_NAME;
  2566.     a0 = dp;
  2567.     __asm volatile ("
  2568.     jsr a6@(-0x3a2)"
  2569.     : "=g" (res)
  2570.     : "g" (a6), "g" (a0)
  2571.     : "d0", "d1", "a0", "a1");
  2572.     return res;
  2573. }
  2574. __inline static LONG CliInitRun(BASE_PAR_DECL struct DosPacket* dp)
  2575. {
  2576.     BASE_EXT_DECL
  2577.     register LONG res __asm("d0");
  2578.     register void *a6 __asm ("a6");
  2579.     register struct DosPacket* a0 __asm("a0");
  2580.  
  2581.     a6 = BASE_NAME;
  2582.     a0 = dp;
  2583.     __asm volatile ("
  2584.     jsr a6@(-0x3a8)"
  2585.     : "=g" (res)
  2586.     : "g" (a6), "g" (a0)
  2587.     : "d0", "d1", "a0", "a1");
  2588.     return res;
  2589. }
  2590. __inline static LONG WriteChars(BASE_PAR_DECL UBYTE* buf, long unsigned int buflen)
  2591. {
  2592.     BASE_EXT_DECL
  2593.     register LONG res __asm("d0");
  2594.     register void *a6 __asm ("a6");
  2595.     register UBYTE* d1 __asm("d1");
  2596.     register long unsigned int d2 __asm("d2");
  2597.  
  2598.     a6 = BASE_NAME;
  2599.     d1 = buf;
  2600.     d2 = buflen;
  2601.     __asm volatile ("
  2602.     jsr a6@(-0x3ae)"
  2603.     : "=g" (res)
  2604.     : "g" (a6), "g" (d1), "g" (d2)
  2605.     : "d0", "d1", "a0", "a1", "d2");
  2606.     return res;
  2607. }
  2608. __inline static LONG PutStr(BASE_PAR_DECL UBYTE* str)
  2609. {
  2610.     BASE_EXT_DECL
  2611.     register LONG res __asm("d0");
  2612.     register void *a6 __asm ("a6");
  2613.     register UBYTE* d1 __asm("d1");
  2614.  
  2615.     a6 = BASE_NAME;
  2616.     d1 = str;
  2617.     __asm volatile ("
  2618.     jsr a6@(-0x3b4)"
  2619.     : "=g" (res)
  2620.     : "g" (a6), "g" (d1)
  2621.     : "d0", "d1", "a0", "a1");
  2622.     return res;
  2623. }
  2624. __inline static LONG VPrintf(BASE_PAR_DECL UBYTE* format, LONG* argarray)
  2625. {
  2626.     BASE_EXT_DECL
  2627.     register LONG res __asm("d0");
  2628.     register void *a6 __asm ("a6");
  2629.     register UBYTE* d1 __asm("d1");
  2630.     register LONG* d2 __asm("d2");
  2631.  
  2632.     a6 = BASE_NAME;
  2633.     d1 = format;
  2634.     d2 = argarray;
  2635.     __asm volatile ("
  2636.     jsr a6@(-0x3ba)"
  2637.     : "=g" (res)
  2638.     : "g" (a6), "g" (d1), "g" (d2)
  2639.     : "d0", "d1", "a0", "a1", "d2");
  2640.     return res;
  2641. }
  2642. __inline static BOOL ParsePatternNoCase(BASE_PAR_DECL UBYTE* pat, UBYTE* buf, long int buflen)
  2643. {
  2644.     BASE_EXT_DECL
  2645.     register BOOL res __asm("d0");
  2646.     register void *a6 __asm ("a6");
  2647.     register UBYTE* d1 __asm("d1");
  2648.     register UBYTE* d2 __asm("d2");
  2649.     register long int d3 __asm("d3");
  2650.  
  2651.     a6 = BASE_NAME;
  2652.     d1 = pat;
  2653.     d2 = buf;
  2654.     d3 = buflen;
  2655.     __asm volatile ("
  2656.     jsr a6@(-0x3c6)"
  2657.     : "=g" (res)
  2658.     : "g" (a6), "g" (d1), "g" (d2), "g" (d3)
  2659.     : "d0", "d1", "a0", "a1", "d2", "d3");
  2660.     return res;
  2661. }
  2662. __inline static BOOL MatchPatternNoCase(BASE_PAR_DECL UBYTE* pat, UBYTE* str)
  2663. {
  2664.     BASE_EXT_DECL
  2665.     register BOOL res __asm("d0");
  2666.     register void *a6 __asm ("a6");
  2667.     register UBYTE* d1 __asm("d1");
  2668.     register UBYTE* d2 __asm("d2");
  2669.  
  2670.     a6 = BASE_NAME;
  2671.     d1 = pat;
  2672.     d2 = str;
  2673.     __asm volatile ("
  2674.     jsr a6@(-0x3cc)"
  2675.     : "=g" (res)
  2676.     : "g" (a6), "g" (d1), "g" (d2)
  2677.     : "d0", "d1", "a0", "a1", "d2");
  2678.     return res;
  2679. }
  2680. #ifdef PRIVATE
  2681. #endif
  2682. __inline static BOOL SameDevice(BASE_PAR_DECL BPTR lock1, BPTR lock2)
  2683. {
  2684.     BASE_EXT_DECL
  2685.     register BOOL res __asm("d0");
  2686.     register void *a6 __asm ("a6");
  2687.     register BPTR d1 __asm("d1");
  2688.     register BPTR d2 __asm("d2");
  2689.  
  2690.     a6 = BASE_NAME;
  2691.     d1 = lock1;
  2692.     d2 = lock2;
  2693.     __asm volatile ("
  2694.     jsr a6@(-0x3d8)"
  2695.     : "=g" (res)
  2696.     : "g" (a6), "g" (d1), "g" (d2)
  2697.     : "d0", "d1", "a0", "a1", "d2");
  2698.     return res;
  2699. }
  2700. #undef BASE_EXT_DECL
  2701. #undef BASE_PAR_DECL
  2702. #undef BASE_PAR_DECL0
  2703. #undef BASE_NAME
  2704.