Club Amiga de Montreal - CAM/CAM_CD_1.iso/files/122.lha/Arp_v1.1/Libraries/arpbase.h

C/C++ Source or Header | 1986-11-20 | 26KB | 663 lines

#ifndef LIBRARIES_ARPBASE_H
#define LIBRARIES_ARPBASE_H
/**********************************************************************
 *
 *    AmigaDOS Replacement Project (ARP) -- Library Include File 'C'
 *
 **********************************************************************
 *
 *    History:
 *
 *    Version:    arpbase.h,v 34.00 02/27/88
 *
 *    Created by:    SDB
 *    Revised:    SDB -- Just bag earlier versions, since didn't have
 *                   time to maintain C header during 'the last days'.
 *                   Created this file mainly from arpbase.i.
 *
 *    Revised:    SDB -- Added stuff for version 32, ASyncRun()
 *                   returns and data structures.
 *            SDB -- Added ERROR_NO_CLI
 *            SDB -- Added final resident data structures,
 *                   final ASyncRun() data structures, and
 *                   date. Final edits for V33.4 release.
 **********************************************************************
 *
 *
 *    Copyright (c) 1987, by Scott Ballantyne
 *
 *    The arp.library, and related code and files may be freely used
 *    by supporters of ARP.  Modules in the arp.library may not be
 *    extracted for us in independent code, but you are welcome to provide
 *    the arp.library with your work and call on it freely.
 *
 *    You are equally welcome to contribute new functions, improve the
 *    ones within, or suggest additions.
 *
 *    BCPL programs are not welcome to call on the arp.library.
 *    The welcome mat is out to all others.
 *
 *********************************************************************/

#ifndef EXEC_TYPES_H
#include <exec/types.h>
#endif  !EXEC_TYPES_H

#ifndef EXEC_LIBRARIES_H
#include <exec/libraries.h>
#endif  !EXEC_LIBRARIES_H

#ifndef EXEC_LISTS_H
#include <exec/lists.h>
#endif  !EXEC_LISTS_H

#ifndef EXEC_SEMAPHORES_H
#include <exec/semaphores.h>
#endif  !EXEC_SEMAPHORES_H

#ifndef LIBRARIES_DOS_H
#include <libraries/dos.h>
#endif  !LIBRARIES_DOS_H

/* arp.library's node structure, not too hefty even now. */

struct ArpBase {
    struct Library    LibNode;    /* Standard library node    */
    BPTR        SegList;    /* Pointer to loaded libcode    */
    UBYTE        Flags;        /* Not used, yet!        */
    UBYTE        ESCChar;    /* Character used for escaping    */
    LONG        ArpReserved1;    /* ArpLib's use only!        */
    struct Library    *EnvBase;    /* Dummy library for MANX compatibility */
    struct Library    *DosBase;    /* Dos library pointer        */
    struct Library    *GfxBase;    /* Graphics lib pointer        */
    struct Library    *IntuiBase;    /* Intuition lib pointer    */
    struct MinList    ResLists;    /* Resource trackers        */
    struct ResidentPrgNode *ResidentPrgList; /* Installed programs */
    struct SignalSemaphore ResPrgProtection; /* Protection for above */
};

/* Following is here *only* for information and for compatibility
 * with MANX, don't use in new code!
 */

struct EnvBase {
    struct Library    LibNode;    /* Standard library node for linkage */
    BYTE        *EnvSpace;    /* Access only when Forbidden! */
    ULONG        EnvSize;    /* Total allocated mem for EnvSpace */
    struct ArpBase    *ArpBase;    /* Added in V32 for Resource Tracking */
};

/* These are used in release 33.4, but not by the library code. Instead,
 * individual programs check for these flags. Not ideal, but such is life.
 *
 */

#define ARPB_WILD_WORLD 0L        ; Mixed BCPL/Normal wildcards.
#define ARPB_WILD_BCPL  1L        ; Pure BCPL wildcards.

#define ARPF_WILD_WORLD (1L << 0)
#define ARPF_WILD_BCPL  (1L << 1)

/*************** C SPECIFIC STUFF *************************************/
/* There are a few things in arp.library that are only directly acessable
 * from assembler.  The glue routines provided by us for all 'C' compilers
 * use the following conventions to make these available to C programs.
 * The glue for other language's should use as similar a mechanism as
 * possible, so that no matter what language or compiler we speak, when
 * talk about arp, we will know what the other guy is saying.
 *
 * Here are the cases:
 *    Atol() - if a bad digit is encountered, will store a ERRBADINT in
 *         Errno, the return from Atol() will be the bad character
 *         encountered.  Note: Atol() will not clear Errno if return
 *         is successful.
 *    Trackers: All tracking calls return the Tracker pointer in A1 as a
 *          secondary result, you can obtain this from the global
 *          variable LastTracker immediately after the call.
 * Finally, GetTracker() syntax is differnt for C and assembler, for 'C'
 * the Syntax is GetTraker( ID ), the binding routine will store the ID
 * into the tracker on return.
 *
 * In cases where you have allocated a tracker before you have obtained a
 * resource (usually the most efficient method), and the resource has not
 * been obtained, you will need to clear the tracker id.  The macro CLEAR_ID()
 * has been provided for that purpose.  It expects a pointer to a DefaultTracker
 * sort of struct.
 *
 */

extern LONG Errno;    /* Error returns not reportable by functions */
extern struct DefaultTracker *LastTracker;    /* Look here after a tracking call */
#define ERRBADINT    1L    /* Atol() could not convert string to number */

#define CLEAR_ID( t )    ((SHORT *) t)[-1] = NULL

/*
 * Non controversial, normal library style stuff
 */

#define ArpName        "arp.library"        /* Name to use when opening */
#define ArpVersion    34L            /* Current version of arplib */


/*
 * The alert object is what you use if you really must return an
 * alert to the user. You would normally OR this with another alert number
 * from the alerts.h file, generally, these should be NON deadend alerts.
 *
 * For example, if you can't open ArpLibrary:
 *    Alert( (AG_OpenLib|AO_ArpLib), 0L);
 *
 */
#define AO_ArpLib    0x00008036L        /* Alert object */

/*
 * Alerts that arp.library can return.
 */

#define AN_ArpLib    0x03600000L    /* Alert number            */
#define AN_ArpNoMem    0x03610000L    /* No more memory        */
#define AN_ArpInputMem    0x03610002L    /* No memory for input buffer    */
#define AN_ArpNoMakeEnv    0x83610003L    /* No memory to make EnvLib    */

#define AN_ArpNoDOS    0x83630001L    /* Can't open DOS        */
#define AN_ArpNoGfx    0x83630002L    /* Can't open graphics.library    */
#define AN_ArpNoIntuit    0x83630003L    /* Can't open intuition        */
#define AN_BadPackBlues    0x83640000L    /* Bad packet returned to SendPacket()    */
#define AN_Zombie    0x83600003L    /* Zombie roaming around system */

#define AN_ArpScattered    0x83600002L    /* Scatter loading not allowed for arp */

/* Return codes you can get from calling arp.library's Assign() function */

#define ASSIGN_OK    0L    /* Everything is cool and groovey */
#define ASSIGN_NODEV    1L    /* "Physical" is not valid for assignment */
#define ASSIGN_FATAL    2L    /* Something really icky happened */
#define ASSIGN_CANCEL    3L    /* Tried to cancel something but it won't cancel */

/* Size of buffer you need if you are going to call ReadLine() */

#define MaxInputBuf    256L

/************************** File Requester ****************************/
/***************** Submit the following to FileRequest() **************/
/**********************************************************************/

struct FileRequester {
    BYTE    *fr_Hail;        /* Hailing text            */
    BYTE    *fr_File;        /* Filename array (FCHARS * N)    */
    BYTE    *fr_Dir;        /* Directory array (DSIZE + 1)    */
    struct Window *fr_Window;    /* Window requesting files or NULL*/
    UBYTE    fr_FuncFlags;        /* Set bitdef's below        */
    UBYTE    fr_reserved1;        /* Set to NULL            */
    VOID    (*fr_Function)();    /* Your function, see bitdef's    */
    LONG    fr_reserved2;        /* RESERVED            */
};

/* The following are the defines for fr_FuncFlags.  These bits tell
 * FileRequest() what your fr_UserFunc is expecting, and what FileRequest()
 * should call it for.
 *
 * You are called like so:
 * fr_Function(Mask, Object)
 * ULONG    Mask;
 * CPTR        *Object;
 *
 * The Mask is a copy of the flag value that caused FileRequest() to call
 * your function. You can use this to determine what action you need to
 * perform, and exactly what Object is, so you know what to do and
 * what to return.
 */

#define FRB_DoWildFunc    7L /* Call me with a FIB and a name, ZERO return accepts. */
#define FRB_DoMsgFunc    6L /* You get all IDCMP messages not for FileRequest() */
#define FRB_DoColor    5L /* Set this bit for that new and different look */
#define FRB_NewIDCMP    4L /* Force a new IDCMP (only if fr_Window != NULL) */
#define FRB_NewWindFunc    3L /* You get to modify the newwindow structure. */
#define FRB_AddGadFunc    2L /* You get to add gadgets. */
#define FRB_GEventFunc    1L /* Function to call if one of your gadgets is selected. */
#define    FRB_ListFunc    0L /* Not implemented yet. */

#define FRF_DoWildFunc    (1L << 7)
#define FRF_DoMsgFunc    (1L << 6)
#define    FRF_DoColor    (1L << 5)
#define FRF_NewIDCMP    (1L << 4)
#define FRF_NewWindFunc    (1L << 3)
#define FRF_AddGadFunc    (1L << 2)
#define FRF_GEventFunc    (1L << 1)
#define FRF_ListFunc    (1L << 0)

#define FCHARS    32L            /* Filename size */
#define DSIZE    33L            /* Directory name size */

#define FR_FIRST_GADGET    0x7680L    /* User gadgetID's must be less than this value */

/*************************************************************************/
/********************** PATTERN MATCHING *********************************/
/*************************************************************************/

/* Structure expected by FindFirst(), FindNext() */
/*
 * You need to allocate this structure and initialize it as follows:
 *
 * Set ap_BreakBits to the signal bits (CDEF) that you want to take a
 * break on, or NULL, if you don't want to convenience the user.
 *
 * if you want to have the FULL PATH NAME of the files you found, allocate
 * a buffer at the END of this structure, and put the size of it into
 * ap_Length.  If you don't want the full path name, make sure you set
 * ap_Length to zero.  In this case, the name of the file, and stats are
 * available in the ap_Info, as per usual.
 *
 * Then call FindFirst() and then afterwards, FindNext() with this structure.
 * You should check the return value each time (see below) and take the
 * appropriate action, ultimately calling FreeAnchorChain() when there
 * are no more files and you are done.  You can tell when you are done by
 * checking for the normal AmigaDOS return code ERROR_NO_MORE_ENTRIES.
 *
 * You will also have to check the DirEntryType variable in the ap_Info
 * structure to determine what exactly you have received.
 */

struct AnchorPath {
    struct Anchor    *ap_Base;    /* Pointer to first anchor */
    struct Anchor    *ap_Last;    /* Pointer to last anchor */
    LONG    ap_BreakBits;    /* Bits to break on */
    LONG    ap_FoundBreak;    /* Bits we broke on. Also returns ERROR_BREAK */
    ULONG    ap_Length;    /* Actual size of ap_Buf, set to 0 if no ap_Buf */
    struct    FileInfoBlock    ap_Info;
    BYTE    ap_Buf[1];    /* Allocate a buffer here, if desired */
};
/*
 * structure used by the pattern matching functions, no need to obtain, diddle
 * or allocate this yourself.
 */

struct Anchor {
    struct Anchor        *an_Next;
    struct Anchor        *an_Pred;
    struct FileLock        *an_Lock;
    struct FileInfoBlock    *an_Info;
    LONG    an_Status;        /* Type of this anchor node */
    union {
        WORD    an_Text;    /* Actual instance of a BSTRing */
        BYTE    an_Actual[2];    /* more memory allocated as required */
    } an_BSTR;
};
/* This structure takes a pointer, and returns FALSE if wildcard was not
 * found by FindFirst()
 */
#define IsWild( ptr )        ( *((LONG *)(ptr)) )

/* Constants used by wildcard routines */
/* These are the pre-parsed tokens referred to by pattern match.  It is not
 * necessary for you to do anything about these, FindFirst() FindNext()
 * handle all these for you.
 */

#define P_ANY        0x80L    /* Token for '*' or '#?' */
#define P_SINGLE    0x81L    /* Token for '?' */
#define P_ORSTART    0x82L    /* Token for '(' */
#define P_ORNEXT    0x83L    /* Token for '|' */
#define P_OREND        0x84L    /* Token for ')' */
#define P_TAG        0x85L    /* Token for '{' */
#define P_TAGEND    0x86L    /* Token for '}' */
#define P_NOTCLASS    0x87L    /* Token for '^' */
#define P_CLASS        0x88L    /* Token for '[]' */
#define P_REPBEG    0x89L    /* Token for '[' */
#define P_REPEND    0x8AL    /* Token for ']' */

/* Values for an_Status, NOTE: these are the actual bit numbers. */
#define COMPLEX_BIT    1L    /* Parsing complex pattern */
#define EXAMINE_BIT    2L    /* Searching directory */

/* Returns from FindFirst() FindNext() */
/* Note that you can also get return codes as defined in dos.h,
 * particularly you can get ERROR_NO_MORE_ENTRIES.
 */

#define ERROR_BUFFER_OVERFLOW    303L    /* User or internal buffer overflow */
#define ERROR_BREAK        304L    /* A break character was received */

/* Structure used by AddDANode(), AddDADevs(), FreeDAList().
 *
 * This structure is used to create lists of names, which normally
 * are devices, assigns, volumes, files, or directories.
 */

struct DirectoryEntry {
    struct DirectoryEntry    *de_Next;    /* Next in list */
    BYTE    de_Type;            /* DLX_mumble */
    BYTE    de_Flags;        /* For future expansion, DO NOT USE! */
    BYTE    de_Name[1];        /* The name of the thing found */
};

/* Defines you use to get a list of the devices you want to look at.
 * For example, to get a list of all directories and volumes, do:
 *
 *    AddDADevs( mydalist, (DLF_DIRS | DLF_VOLUMES) )
 *
 * After this, you can examine the de_type field of the elements added to
 * your list (if any) to discover specifics about the objects added.
 *
 * Note that if you want only devices which are also disks, you must request
 * (DLF_DEVICES | DLF_DISKONLY).
 */

#define DLB_DEVICES    0L    /* Return devices */
#define DLB_DISKONLY    1L    /* Modifier for above: Return disk devices only */
#define DLB_VOLUMES    2L    /* Return volumes only */
#define DLB_DIRS    3L    /* Return assigned devices only */

#define DLF_DEVICES    (1L << 0)
#define DLF_DISKONLY    (1L << 1)
#define DLF_VOLUMES    (1L << 2)
#define DLF_DIRS    (1L << 3)

/* Legal de_Type values, check for these after a call to AddDADevs(), or use
 * on your own as the ID values in AddDANode().
 */

#define DLX_FILE    0L    /* AddDADevs() can't determine this */
#define DLX_DIR        8L    /* AddDADevs() can't determine this */
#define DLX_DEVICE    16L    /* It's a resident device */

#define DLX_VOLUME    24L    /* Device is a volume */
#define DLX_UNMOUNTED    32L    /* Device is not resident */

#define DLX_ASSIGN    40L    /* Device is a logical assignment */

/*********************************************************************/
/********************** RESOURCE TRACKING ****************************/
/*********************************************************************/

/* Note: ResList MUST be a DosAllocMem'ed list!, this is done for
 * you when you call CreateTaskResList(), typically, you won't need
 * to access/allocate this structure.
 */

struct ResList {
    struct MinNode    rl_Node;    /* Used by arplib to link reslist's */
    struct Task    *rl_TaskID;    /* Owner of this list */
    struct MinList    rl_FirstItem;    /* List of TrackedResource's */
    struct ArpResList *rl_Link;    /* SyncRun's use - hide list here */
};
/*
 * The rl_FirstItem list (above) is a list of TrackedResource (below).
 * It is very important that nothing in this list depend on the task
 * existing at resource freeing time (i.e., RemTask(0L) type stuff,
 * DeletePort() and the rest).
 *
 * The tracking functions return a struct Tracker *Tracker to you, this
 * is a pointer to whatever follows the tr_ID variable.
 * The default case is reflected below, and you get it if you call
 * GetTracker() ( see DefaultTracker below).
 *
 * NOTE: The two user variables mentioned in an earlier version don't
 * exist, and never did. Sorry about that (SDB).
 *
 * However, you can still use ArpAlloc() to allocate your own tracking nodes
 * and they can be any size or shape you like, as long as the base structure
 * is preserved. They will be freed automagically just like the default trackers.
 */

struct TrackedResource {
    struct MinNode    tr_Node;    /* Double linked pointer */
    BYTE        tr_Flags;    /* Don't touch */
    BYTE        tr_Lock;    /* Don't touch, for Get/FreeAccess() */
    SHORT        tr_ID;        /* Item's ID */
    /*
     * The struct DefaultTracker *Tracker portion of the structure.
     * The stuff below this point can conceivably vary, depending
     * on user needs, etc.  This reflects the default.
     */
    union {
        CPTR    tr_Resource;    /* Whatever */
                LONG    tg_Verify;    /* For use during TRAK_GENERIC */
    } tr_Object;            /* The thing being tracked */
    union {
        VOID    (*tg_Function)(); /* Function to call for TRAK_GENERIC */
        struct    Window    *tr_Window2;    /* For TRAK_WINDOW */
    } tr_Extra;                /* Only needed sometimes */
};

#define tg_Value tg_Verify    /* Ancient compatibility */

/* You get a pointer to a struct of the following type when you call
 * GetTracker().  You can change this, and use ArpAlloc() instead of
 * GetTracker() to do tracking. Of course, you have to take a wee bit
 * more responsibility if you do, as well as if you use TRAK_GENERIC
 * stuff.
 *
 * TRAK_GENERIC folks need to set up a task function to be called when an
 * item is freed.  Some care is required to set this up properly.
 *
 * Some special cases are indicated by the unions below, for TRAK_WINDOW,
 * if you have more than one window opened, and don't want the IDCMP closed
 * particularly, you need to set a ptr to the other window in dt_Window2.
 * See CloseWindowSafely() for more info.  If only one window, set this to NULL.
 *
 */

struct DefaultTracker {
    union {
        CPTR    dt_Resource;    /* Whatever */
        LONG    tg_Verify;    /* For use during TRAK_GENERIC */
    } dt_Object;            /* The object being tracked */
    union {
        VOID    (*tg_Function)();  /* Function to call for TRAK_GENERIC */
        struct Window *dt_Window2;    /* For TRAK_WINDOW */
    } dt_Extra;
};

/* Items the tracker knows what to do about */

#define TRAK_AAMEM    0L    /* Default (ArpAlloc) element */
#define TRAK_LOCK    1L    /* File lock */
#define TRAK_FILE    2L    /* Opened file */
#define TRAK_WINDOW    3L    /* Window -- see docs */
#define TRAK_SCREEN    4L    /* Screen */
#define TRAK_LIBRARY    5L    /* Opened library */
#define TRAK_DAMEM    6L    /* Pointer to DosAllocMem block */
#define TRAK_MEMNODE    7L    /* AllocEntry() node */
#define TRAK_SEGLIST    8L    /* Program segment */
#define TRAK_RESLIST    9L    /* ARP (nested) ResList */
#define TRAK_MEM    10L    /* Memory ptr/length */
#define TRAK_GENERIC    11L    /* Generic Element, your choice */
#define TRAK_DALIST    12L    /* DAlist ( aka file request ) */
#define TRAK_ANCHOR    13L    /* Anchor chain (pattern matching) */
#define TRAK_MAX    13L    /* Poof, anything higher is tossed */

#define TRB_UNLINK    7L    /* Free node bit */
#define TRB_RELOC    6L    /* This may be relocated (not used yet) */
#define TRB_MOVED    5L    /* Item moved */

#define TRF_UNLINK    (1L << 7)
#define TRF_RELOC    (1L << 6)
#define TRF_MOVED    (1L << 5)

/* Returns from CompareLock() */
#define LCK_EQUAL    0L    /* The two locks refer to the same object */
#define LCK_VOLUME    1L    /* Locks are on the same volume */
#define LCK_DIFVOL1    2L    /* Locks are on different volumes */
#define LCK_DIFVOL2    3L    /* Locks are on different volumes */

/****************************** ASyncRun() ***************************/
/*
 * Message sent back on your request by an exiting process.
 * You request this by putting the address of your message in pcb_LastGasp,
 * and initializing the ReplyPort variable of your ZombieMsg to the
 * port you wish the message posted to.
 */

struct ZombieMsg {
    struct Message    zm_ExecMessage;
    ULONG    zm_TaskNum;        /* Task ID */
    ULONG    zm_ReturnCode;        /* Process's return code */
    ULONG    zm_Result2;        /* System return code */
    struct    DateStamp zm_ExitTime;    /* Date stamp at time of exit */
    ULONG    zm_UserInfo;        /* For whatever you wish. */
};

/* Structure required by ASyncRun() -- see docs for more info. */

struct ProcessControlBlock {
    ULONG    pcb_StackSize;        /* Stacksize for new process */
    BYTE    pcb_Pri;        /* Priority of new task */
    BYTE    pcb_Control;        /* Control bits, see defines below */
    APTR    pcb_TrapCode;        /* Optional Trap Code */
    ULONG    pcb_Input,p_Output;    /* Optional stdin, stdout */
    union {
        ULONG    pcb_SplatFile;    /* File to use for Open("*") */
        BYTE    *pcb_ConName;    /* CON: filename */
    } pcb_Console;
    ULONG    pcb_SplatFile;        /* File to use for Open("*") */
    CPTR    pcb_LoadedCode;     /* If not null, will not load/unload code */
    struct ZombieMsg *pcb_LastGasp;     /* ReplyMsg() to be filled in by exit */
    struct MsgPort    *pcb_WBProcess;    /* Valid only when PRB_NOCLI */
};

/* Some programs appear to have bugs in the startup code that does not handle
 * well a zero length command line (lattice startup has this, but is probably
 * not unique).  Use this macro to pass a null cmd line to a process using
 * either ASyncRun() or SyncRun()
 */

#define NOCMD    "\n"

/* The following control bits determine what ASyncRun() does on Abnormal Exits
 * and on background process termination.
 */

#define    PRB_SAVEIO    0L    /* Don't free/check file handles on exit */
#define PRB_CLOSESPLAT    1L    /* Close Splat file, must request explicitly */
#define PRB_NOCLI    2L    /* Don't create a CLI process */
#define PRB_INTERACTIVE    3L    /* This should be interactive */
#define PRB_CODE    4L    /* Dangerous yet enticing */
#define PRB_STDIO    5L    /* Do the stdio thing, splat = CON:Filename */

#define PRF_SAVEIO    (1L << 0)
#define PRF_CLOSESPLAT    (1L << 1)
#define PRF_NOCLI    (1L << 2)
#define PRF_INTERACTIVE    (1L << 3)
#define PRF_CODE    (1L << 4)
#define PRF_STDIO    (1L << 5)

/* Error returns from SyncRun() and ASyncRun() */
#define PR_NOFILE    -1L    /* Could not LoadSeg() the file */
#define    PR_NOMEM    -2L    /* No memory for something */
#define PR_NOCLI    -3L    /* Only SyncRun() will fail if call not cli */
#define PR_NOSLOT    -4L    /* No room in TaskArray */
#define PR_NOINPUT    -5L    /* Could not open input file */
#define PR_NOOUTPUT    -6L    /* Could not get output file */
#define PR_NOLOCK    -7L    /* Could not get a lock */
#define PR_ARGERR    -8L    /* Bad argument to ASyncRun() */
#define PR_NOBCPL    -9L    /* Bad program passed to ASyncRun() */
#define PR_BADLIB    -10    /* Bad library version */
#define PR_NOSTDIO    -11    /* Couldn't get stdio handles */

/* Programs should return this as result2 if need a cli and don't have one. */

#define ERROR_NOT_CLI    400L        /* Program/function neeeds to be cli */

/******************** Resident Program Support *****************************/
/*
 * This is the kind of node allocated for you when yhou AddResidentPrg() a code
 * segment.  They are stored as a single linked list with the root in
 * ArpBase.  If you absolutely *must* wander through this list instead of
 * using the supplied functions, then you must first obtain the semaphore
 * which protects this list, and then release it afterwards.
 * Do not use Forbid() and Permit() to gain exclusive access!
 * Note that the supplied functions handle this locking protocol for you.
 */

struct ResidentPrgNode {
    struct ResidentPrgNode         *rpn_Next;    /* next or NULL */
    LONG                rpn_Usage;    /* Number of current users */
    ULONG                rpn_CheckSum;    /* Checksum of code */
    BPTR                rpn_Segment;    /* Actual segment */
    BYTE                rpn_Name[1];    /* Allocated as needed */
};


/* If your program starts with this structure, ASyncRun() and SyncRun() will
 * override a users stack request with the value in rpt_StackSize.
 * Furthermore, if you are actually attached to the resident list, a memory
 * block of size rpt_DataSize will be allocated for you, and
 * a pointer to this data passed to you in register A4.  You may use this
 * block to clone the data segment of programs, thus resulting in one
 * copy of text, but multiple copies of data/bss for each process
 * invocation.  If you are resident, your program will start at
 * rpt_Instruction, otherwise, it will be launched from the initial branch.
 */

struct ResidentProgramTag {
    BPTR    rpt_NextSeg;    /* Provided by DOS at LoadSeg time. */
    UWORD    rpt_BRA;    /* Short branch to executable */
    UWORD    rpt_Magic;    /* Resident majik value */
    ULONG    rpt_StackSize;    /* min stack for this process */
    ULONG    rpt_DataSize;    /* Data size to allocate if resident */
    /*     rpt_Instruction; /* Start here if resident */
};
/*
 * The form of the ARP allocated node in your tasks memlist when launched
 * as a resident program. Note that the data portion of the node will only
 * exist if you have specified a nonzero value for rpt_DataSize. Note also
 * that this structure is READ ONLY, modify values in this at your own
 * risk.  The stack stuff is for tracking, if you need actual addresses
 * or stack size, check the normal places for it in your process/task struct.
 */
struct ProcessMemory {
    struct Node    pm_Node;
    UWORD        pm_Num;        /* This is 1 if no data, two if data */
    CPTR        pm_Stack;
    ULONG        pm_StackSize;
    CPTR        pm_Data;    /* Only here if pm_Num == 2 */
    ULONG        pm_DataSize;
};

/* To find the above on your memlist, search for the following name.
 * We guarantee this will be the only arp.library allocated node on
 * your memlist with this name, i.e. FindName(task->tcb_MemEntry, PMEM_NAME);
 */
#define PMEM_NAME    "ARP_MEM"

#define RESIDENT_MAGIC        0x4AFC        /* same as RTC_MATCHWORD (trapf) */

/* The initial branch destination and rpt_Instruction do not have to be the same.
 * This allows different actions to be taken if you are diskloaded or
 * resident. DataSize memory will be allocated only if you are resident,
 * but StackSize will override all user stack requests.
 */

/*********************** String/Data structures *************************/

struct DateTime {
    struct    DateStamp dat_Stamp;    /* DOS Datestamp */
    UBYTE        dat_Format;    /* controls appearance ot dat_StrDate */
    UBYTE        dat_Flags;    /* See BITDEF's below */
    BYTE        *dat_StrDay;    /* day of the week string */
    BYTE        *dat_StrDate;    /* date string */
    BYTE        *dat_StrTime;    /* time string */
};

/* Size of buffer you need for each DateTime strings: */
#define LEN_DATSTRING    10L

/* For dat_Flags */

#define DTB_SUBST    0L    /* Substitute "Today" "Tomorrow" where appropriate */
#define DTB_FUTURE    1L    /* Day of the week is in future */

#define DTF_SUBST    (1L << 0)
#define DTF_FUTURE    (1L << 1)

/* For dat_Format */
#define FORMAT_DOS    0L        /* dd-mmm-yy AmigaDOS's own, unique style */
#define FORMAT_INT    1L        /* yy-mm-dd International format */
#define FORMAT_USA    2L        /* mm-dd-yy The good'ol'USA.    */
#define FORMAT_CDN    3L        /* dd-mm-yy Our brothers and sisters to the north */
#define FORMAT_MAX    FORMAT_CDN    /* Larger than this? Defaults to AmigaDOS */

#endif !LIBRARIES_ARPBASE_H