home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / util / mg-3b.lha / mg-3b / src.LZH / amiga / storage.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-23  |  17.1 KB  |  373 lines
  1. /* === rexx/storage.h ==================================================
  2.  *
  3.  * Copyright (c) 1986, 1987 by William S. Hawes (All Rights Reserved)
  4.  *
  5.  * =====================================================================
  6.  * Header file to define ARexx data structures.
  7.  */
  8.  
  9. #ifndef REXX_STORAGE_H
  10. #define REXX_STORAGE_H
  11.  
  12. #ifndef EXEC_TYPES_H
  13. #include "exec/types.h"
  14. #endif
  15.  
  16. #ifndef EXEC_NODES_H
  17. #include "exec/nodes.h"
  18. #endif
  19.  
  20. #ifndef EXEC_LISTS_H
  21. #include "exec/lists.h"
  22. #endif
  23.  
  24. #ifndef EXEC_PORTS_H
  25. #include "exec/ports.h"
  26. #endif
  27.  
  28. #ifndef EXEC_LIBRARIES_H
  29. #include "exec/libraries.h"
  30. #endif
  31.  
  32. #ifndef LIBRARIES_DOS_H
  33. #include <libraries/dos.h>
  34. #endif
  35.  
  36. /* The NexxStr structure is used to maintain the internal strings in REXX.
  37.  * It includes the buffer area for the string and associated attributes.
  38.  * This is actually a variable-length structure; it is allocated for a
  39.  * specific length string, and the length is never modified thereafter
  40.  * (since it's used for recycling).
  41.  */
  42.  
  43. struct NexxStr {
  44.    LONG     ns_Ivalue;                 /* integer value                 */
  45.    UWORD    ns_Length;                 /* length in bytes (excl null)   */
  46.    UBYTE    ns_Flags;                  /* attribute flags               */
  47.    UBYTE    ns_Hash;                   /* hash code                     */
  48.    BYTE     ns_Buff[8];                /* buffer area for strings       */
  49.    };                                  /* size: 16 bytes (minimum)      */
  50.  
  51. #define NXADDLEN 9                     /* offset plus null byte         */
  52. #define IVALUE(nsPtr) (nsPtr->ns_Ivalue)
  53.  
  54. /* String attribute flag bit definitions                                */
  55. #define NSB_KEEP     0                 /* permanent string?             */
  56. #define NSB_STRING   1                 /* string form valid?            */
  57. #define NSB_NOTNUM   2                 /* non-numeric?                  */
  58. #define NSB_NUMBER   3                 /* a valid number?               */
  59. #define NSB_BINARY   4                 /* integer value saved?          */
  60. #define NSB_FLOAT    5                 /* floating point format?        */
  61. #define NSB_EXT      6                 /* an external string?           */
  62. #define NSB_SOURCE   7                 /* part of the program source?   */
  63.  
  64. /* The flag form of the string attributes                               */
  65. #define NSF_KEEP     (1 << NSB_KEEP  )
  66. #define NSF_STRING   (1 << NSB_STRING)
  67. #define NSF_NOTNUM   (1 << NSB_NOTNUM)
  68. #define NSF_NUMBER   (1 << NSB_NUMBER)
  69. #define NSF_BINARY   (1 << NSB_BINARY)
  70. #define NSF_FLOAT    (1 << NSB_FLOAT )
  71. #define NSF_EXT      (1 << NSB_EXT   )
  72. #define NSF_SOURCE   (1 << NSB_SOURCE)
  73.  
  74. /* Combinations of flags                                                */
  75. #define NSF_INTNUM   (NSF_NUMBER | NSF_BINARY | NSF_STRING)
  76. #define NSF_DPNUM    (NSF_NUMBER | NSF_FLOAT)
  77. #define NSF_ALPHA    (NSF_NOTNUM | NSF_STRING)
  78. #define NSF_OWNED    (NSF_SOURCE | NSF_EXT    | NSF_KEEP)
  79. #define KEEPSTR      (NSF_STRING | NSF_SOURCE | NSF_NOTNUM)
  80. #define KEEPNUM      (NSF_STRING | NSF_SOURCE | NSF_NUMBER | NSF_BINARY)
  81.  
  82. /* The RexxArg structure is identical to the NexxStr structure, but
  83.  * is allocated from system memory rather than from internal storage.
  84.  * This structure is used for passing arguments to external programs.
  85.  * It is usually passed as an "argstring", a pointer to the string buffer.
  86.  */
  87.  
  88. struct RexxArg {
  89.    LONG     ra_Size;                   /* total allocated length        */
  90.    UWORD    ra_Length;                 /* length of string              */
  91.    UBYTE    ra_Flags;                  /* attribute flags               */
  92.    UBYTE    ra_Hash;                   /* hash code                     */
  93.    BYTE     ra_Buff[8];                /* buffer area                   */
  94.    };                                  /* size: 16 bytes (minimum)      */
  95.  
  96. /* The RexxMsg structure is used for all communications with REXX
  97.  * programs.  It is an EXEC message with a parameter block appended.
  98.  */
  99.  
  100. struct RexxMsg {
  101.    struct Message rm_Node;             /* EXEC message structure        */
  102.    APTR     rm_TaskBlock;              /* global structure (private)    */
  103.    APTR     rm_LibBase;                /* library base (private)        */
  104.    LONG     rm_Action;                 /* command (action) code         */
  105.    LONG     rm_Result1;                /* primary result (return code)  */
  106.    LONG     rm_Result2;                /* secondary result              */
  107.    STRPTR   rm_Args[16];               /* argument block (ARG0-ARG15)   */
  108.  
  109.    struct MsgPort *rm_PassPort;        /* forwarding port               */
  110.    STRPTR   rm_CommAddr;               /* host address (port name)      */
  111.    STRPTR   rm_FileExt;                /* file extension                */
  112.    LONG     rm_Stdin;                  /* input stream (filehandle)     */
  113.    LONG     rm_Stdout;                 /* output stream (filehandle)    */
  114.    LONG     rm_avail;                  /* future expansion              */
  115.    };                                  /* size: 128 bytes               */
  116.  
  117. /* Field definitions                                                    */
  118. #define ARG0(rmp) (rmp->rm_Args[0])    /* start of argblock             */
  119. #define ARG1(rmp) (rmp->rm_Args[1])    /* first argument                */
  120. #define ARG2(rmp) (rmp->rm_Args[2])    /* second argument               */
  121.  
  122. #define MAXRMARG  15                   /* maximum arguments             */
  123.  
  124. /* Command (action) codes for message packets                           */
  125. #define RXCOMM    0x01000000           /* a command-level invocation    */
  126. #define RXFUNC    0x02000000           /* a function call               */
  127. #define RXCLOSE   0x03000000           /* close the REXX server         */
  128. #define RXQUERY   0x04000000           /* query for information         */
  129. #define RXADDFH   0x07000000           /* add a function host           */
  130. #define RXADDLIB  0x08000000           /* add a function library        */
  131. #define RXREMLIB  0x09000000           /* remove a function library     */
  132. #define RXADDCON  0x0A000000           /* add/update a ClipList string  */
  133. #define RXREMCON  0x0B000000           /* remove a ClipList string      */
  134. #define RXTCOPN   0x0C000000           /* open the trace console        */
  135. #define RXTCCLS   0x0D000000           /* close the trace console       */
  136.  
  137. /* Command modifier flag bits                                           */
  138. #define RXFB_NOIO    16                /* suppress I/O inheritance?     */
  139. #define RXFB_RESULT  17                /* result string expected?       */
  140. #define RXFB_STRING  18                /* program is a "string file"?   */
  141. #define RXFB_TOKEN   19                /* tokenize the command line?    */
  142. #define RXFB_NONRET  20                /* a "no-return" message?        */
  143.  
  144. /* The flag form of the command modifiers                               */
  145. #define RXFF_NOIO    (1L << RXFB_NOIO  )
  146. #define RXFF_RESULT  (1L << RXFB_RESULT)
  147. #define RXFF_STRING  (1L << RXFB_STRING)
  148. #define RXFF_TOKEN   (1L << RXFB_TOKEN )
  149. #define RXFF_NONRET  (1L << RXFB_NONRET)
  150.  
  151. #define RXCODEMASK   0xFF000000
  152. #define RXARGMASK    0x0000000F
  153.  
  154. /* The RexxRsrc structure is used to manage global resources.  Each node 
  155.  * has a name string created as a RexxArg structure, and the total size
  156.  * of the node is saved in the "rr_Size" field.  The REXX systems library
  157.  * provides functions to allocate and release resource nodes.  If special
  158.  * deletion operations are required, an offset and base can be provided in
  159.  * "rr_Func" and "rr_Base", respectively.  This "autodelete" function will
  160.  * be called with the base in register A6 and the node in A0.
  161.  */
  162.  
  163. struct RexxRsrc {
  164.    struct Node rr_Node;
  165.    WORD     rr_Func;                   /* "auto-delete" offset          */
  166.    APTR     rr_Base;                   /* "auto-delete" base            */
  167.    LONG     rr_Size;                   /* total size of node            */
  168.    LONG     rr_Arg1;                   /* available ...                 */
  169.    LONG     rr_Arg2;                   /* available ...                 */
  170.    };                                  /* size: 32 bytes                */
  171.  
  172. /* Resource node types                                                  */
  173. #define RRT_ANY      0                 /* any node type ...             */
  174. #define RRT_LIB      1                 /* a function library            */
  175. #define RRT_PORT     2                 /* a public port                 */
  176. #define RRT_FILE     3                 /* a file IoBuff                 */
  177. #define RRT_HOST     4                 /* a function host               */
  178. #define RRT_CLIP     5                 /* a Clip List node              */
  179.  
  180. /* The RexxTask structure holds the fields used by REXX to communicate with
  181.  * external processes, including the client task.  It includes the global
  182.  * data structure (and the base environment).  The structure is passed to
  183.  * the newly-created task in its "wake-up" message.
  184.  */
  185.  
  186. #define GLOBALSZ  200                  /* total size of GlobalData      */
  187.  
  188. struct RexxTask {
  189.    BYTE     rt_Global[GLOBALSZ];       /* global data structure         */
  190.    struct MsgPort rt_MsgPort;          /* global message port           */
  191.    UBYTE    rt_Flags;                  /* task flag bits                */
  192.    BYTE     rt_SigBit;                 /* signal bit                    */
  193.  
  194.    APTR     rt_ClientID;               /* the client's task ID          */
  195.    APTR     rt_MsgPkt;                 /* the packet being processed    */
  196.    APTR     rt_TaskID;                 /* our task ID                   */
  197.    APTR     rt_RexxPort;               /* the REXX public port          */
  198.  
  199.    APTR     rt_ErrTrap;                /* Error trap address            */
  200.    APTR     rt_StackPtr;               /* stack pointer for traps       */
  201.  
  202.    struct List rt_Header1;             /* Environment list              */
  203.    struct List rt_Header2;             /* Memory freelist               */
  204.    struct List rt_Header3;             /* Memory allocation list        */
  205.    struct List rt_Header4;             /* Files list                    */
  206.    struct List rt_Header5;             /* Message Ports List            */
  207.    };
  208.  
  209. /* Definitions for RexxTask flag bits                                   */
  210. #define RTFB_TRACE   0                 /* external trace flag           */
  211. #define RTFB_HALT    1                 /* external halt flag            */
  212. #define RTFB_SUSP    2                 /* suspend task?                 */
  213. #define RTFB_TCUSE   3                 /* trace console in use?         */
  214. #define RTFB_WAIT    6                 /* waiting for reply?            */
  215. #define RTFB_CLOSE   7                 /* task completed?               */
  216.  
  217. /* Definitions for memory allocation constants                          */
  218. #define MEMQUANT  16L                  /* quantum of memory space       */
  219. #define MEMMASK   0xFFFFFFF0           /* mask for rounding the size    */
  220.  
  221. #define MEMQUICK  (1L << 0 )           /* EXEC flags: MEMF_PUBLIC       */
  222. #define MEMCLEAR  (1L << 16)           /* EXEC flags: MEMF_CLEAR        */
  223.  
  224. /* The SrcNode is a temporary structure used to hold values destined for
  225.  * a segment array.  It is also used to maintain the memory freelist.
  226.  */
  227.  
  228. struct SrcNode {
  229.    struct SrcNode *sn_Succ;            /* next node                     */
  230.    struct SrcNode *sn_Pred;            /* previous node                 */
  231.    APTR     sn_Ptr;                    /* pointer value                 */
  232.    LONG     sn_Size;                   /* size of object                */
  233.    };                                  /* size: 16 bytes                */
  234.  
  235. #ifdef    LATTICE
  236. struct NexxStr*ErrorMsg(long) ;
  237. long IsSymbol(char *) ;
  238. struct List *CurrentEnv(struct RexxTask *) ;
  239. void FreeSpace(struct List *, void *, long) ;
  240. struct RexxArg *CreateArgstring(char *, long) ;
  241. void DeleteArgstring(struct RexxArg *) ;
  242. long LengthArgstring(struct RexxArg *) ;
  243. struct RexxMsg *CreateRexxMsg(struct MsgPort *, char *, char *) ;
  244. void DeleteRexxMsg(struct RexxMsg *) ;
  245. void ClearRexxMsg(struct RexxMsg *, long) ;
  246. long FillRexxMsg(struct RexxMsg *, long, long) ;
  247. long IsRexxMsg(struct RexxMsg *) ;
  248. struct RexxRsrc *AddRsrcNode(struct List *, char *, long) ;
  249. struct RexxRsrc *FindRsrcNode(struct List *, char *, long) ;
  250. void RemRsrcList(struct List *) ;
  251. void RemRsrcNode(struct RexxRsrc *) ;
  252. struct RexxRsrc *OpenPublicPort(struct List *, char *) ;
  253. void ClosePublicPort(struct RexxRsrc *) ;
  254. char *ListNames(struct List *, char) ;
  255. void ClearMem(APTR, long) ;
  256. void InitList(struct List *) ;
  257. struct MsgPort *InitPort(struct MsgPort *, char *) ;
  258. void FreePort(struct MsgPort *) ;
  259. long CmpString(char *, char *) ;
  260. char *StcToken(char *) ;
  261. long StrcmpN(char *, char *, long) ;
  262. long StrcmpU(char *, char *, long) ;
  263. long StrcpyA(char *, char *, long) ;
  264. long StrcpyN(char *, char *, long) ;
  265. long StrcpyU(char *, char *, long) ;
  266. void StrflipN(char *, long) ;
  267. long Strlen(char *) ;
  268. char ToUpper(char) ;
  269. long CVa2i(char *) ;
  270. char *CVi2a(char *, long, long) ;
  271. char *CVi2arg(long) ;
  272. char *CVi2az(char *, long, long) ;
  273. long CVc2x(char *, char *, long, long) ;
  274. long CVx2c(char *, char *, long, long) ;
  275. struct IoBuff *OpenF(struct List *, char *, long, long) ;
  276. void CloseF(struct IoBuff *) ;
  277. char *ReadStr(struct IoBuff *, char *, long) ;
  278. long ReadF(struct IoBuff *, char *, long) ;
  279. long WriteF(struct IoBuff *, char *, long) ;
  280. long SeekF(struct IoBuff *, long, long) ;
  281. long QueueF(struct IoBuff *, char *, long) ;
  282. long StackF(struct IoBuff *, char *, long) ;
  283. long ExistF(char *) ;
  284. long DOSRead(BPTR, char *, long) ;
  285. long DOSWrite(BPTR, char *, long) ;
  286. struct StandardPacket *CreateDOSPkt(void) ;
  287. void DeleteDOSPkt(struct StandardPacket *) ;
  288. struct Node *FindDevice(char *, long) ;
  289. struct RexxRsrc *AddClipNode(struct List *, char *, long, long) ;
  290. void RemClipNode(struct RexxRsrc *) ;
  291. void LockRexxBase(long) ;
  292. void UnlockRexxBase(long) ;
  293.  
  294. long __stdargs SetRexxVar(struct RexxMsg *, char *, char *, long) ;
  295.  
  296. #ifndef    NO_PRAGMAS
  297. /* #pragma libcall RexxSysBase Rexx 1e            ; Main entry point */
  298. /* #pragma libcall RexxSysBase rxParse 24         ; (private) */
  299. /* #pragma libcall RexxSysBase rxInstruct 2a      ; (private) */
  300. /* #pragma libcall RexxSysBase rxSuspend 30       ; (private) */
  301. /* #pragma libcall RexxSysBase EvalOp 36          ; (private) */
  302. /* #pragma libcall RexxSysBase AssignValue 3c     ; (private) */
  303. /* #pragma libcall RexxSysBase EnterSymbol 42     ; (private) */
  304. /* #pragma libcall RexxSysBase FetchValue 48      ; (private) */
  305. /* #pragma libcall RexxSysBase LookUpValue 4e     ; (private) */
  306. /* #pragma libcall RexxSysBase SetValue 54        ; (private) */
  307. /* #pragma libcall RexxSysBase SymExpand 5a       ; (private) */
  308. #pragma libcall RexxSysBase ErrorMsg 60 081
  309. #pragma libcall RexxSysBase IsSymbol 66 081
  310. #pragma libcall RexxSysBase CurrentEnv 6c 081
  311. #pragma libcall RexxSysBase GetSpace 72 0882
  312. #pragma libcall RexxSysBase FreeSpace 78 09803
  313. #pragma libcall RexxSysBase CreateArgstring 7e 0882
  314. #pragma libcall RexxSysBase DeleteArgstring 84 801
  315. #pragma libcall RexxSysBase LengthArgstring 8a 801    /* A guess... */
  316. #pragma libcall RexxSysBase CreateRexxMsg 90 09883
  317. #pragma libcall RexxSysBase DeleteRexxMsg 96 801
  318. #pragma libcall RexxSysBase ClearRexxMsg 9c 0802
  319. #pragma libcall RexxSysBase FillRexxMsg a2 10803
  320. #pragma libcall RexxSysBase IsRexxMsg a8 801
  321. #pragma libcall RexxSysBase AddRsrcNode ae 09883
  322. #pragma libcall RexxSysBase FindRsrcNode b4 09883
  323. #pragma libcall RexxSysBase RemRsrcList ba 801
  324. #pragma libcall RexxSysBase RemRsrcNode c0 801
  325. #pragma libcall RexxSysBase OpenPublicPort c6 9882
  326. #pragma libcall RexxSysBase ClosePublicPort cc 801
  327. #pragma libcall RexxSysBase ListNames d2 0882
  328. #pragma libcall RexxSysBase ClearMem d8 0802
  329. #pragma libcall RexxSysBase InitList de 801
  330. #pragma libcall RexxSysBase InitPort e4 9892
  331. #pragma libcall RexxSysBase FreePort ea 801
  332. #pragma libcall RexxSysBase CmpString f0 9802
  333. #pragma libcall RexxSysBase StcToken f6 891
  334. #pragma libcall RexxSysBase StrcmpN fc 09803
  335. #pragma libcall RexxSysBase StrcmpU 102 09803
  336. #pragma libcall RexxSysBase StrcpyA 108 09803
  337. #pragma libcall RexxSysBase StrcpyN 10e 09803
  338. #pragma libcall RexxSysBase StrcpyU 114 09803
  339. #pragma libcall RexxSysBase StrflipN 11a 0802
  340. #pragma libcall RexxSysBase Strlen 120 801
  341. #pragma libcall RexxSysBase ToUpper 126 001
  342. #pragma libcall RexxSysBase CVa2i 12c 811
  343. #pragma libcall RexxSysBase CVi2a 132 10883
  344. #pragma libcall RexxSysBase CVi2arg 138 081
  345. #pragma libcall RexxSysBase CVi2az 13e 10883
  346. #pragma libcall RexxSysBase CVc2x 144 109804
  347. #pragma libcall RexxSysBase CVx2c 14a 109804
  348. #pragma libcall RexxSysBase OpenF 150  109884
  349. #pragma libcall RexxSysBase CloseF 156 801
  350. #pragma libcall RexxSysBase ReadStr 15c 09893
  351. #pragma libcall RexxSysBase ReadF 162 09803
  352. #pragma libcall RexxSysBase WriteF 168 09803
  353. #pragma libcall RexxSysBase SeekF 16e 10803
  354. #pragma libcall RexxSysBase QueueF 174 09803
  355. #pragma libcall RexxSysBase StackF 17a 09803
  356. #pragma libcall RexxSysBase ExistF 180 801
  357. /* #pragma libcall RexxSysBase DOSCommand 186 */
  358. #pragma libcall RexxSysBase DOSRead 18c 09803
  359. #pragma libcall RexxSysBase DOSWrite 192 09803
  360. #pragma libcall RexxSysBase CreateDOSPkt 198 80
  361. #pragma libcall RexxSysBase DeleteDOSPkt 19e 801
  362. /* #pragma libcall RexxSysBase SendDOSPkt 1a4 */
  363. /* #pragma libcall RexxSysBase WaitDOSPkt 1aa */
  364. #pragma libcall RexxSysBase FindDevice 1b0 0882
  365. #pragma libcall RexxSysBase AddClipNode 1b6 109884
  366. #pragma libcall RexxSysBase RemClipNode 1c2 801
  367. #pragma libcall RexxSysBase LockRexxBase 1c8 001
  368. #pragma libcall RexxSysBase UnlockRexxBase 1ce 001
  369. #endif
  370. #endif
  371.  
  372. #endif
  373.