{
    This file is part of the Free Pascal run time library.

    A file in Amiga system run time library.
    Copyright (c) 1998-2003 by Nils Sjoholm
    member of the Amiga RTL development team.

    See the file COPYING.FPC, included in this distribution,
    for details about the copyright.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 **********************************************************************}
{
    History:
    Added overlay functions for Pchar->Strings, functions
    and procedures.
    14 Jul 2000.
    
    Removed amigaoverlays, use smartlink instead.
    05 Nov 2002.

    Added the defines use_amiga_smartlink and
    use_auto_openlib. Implemented autoopening of
    the library.
    14 Jan 2003.

    Changed integer > smallint,
            cardinal > longword.
    09 Feb 2003.
    	    
    nils.sjoholm@mailbox.swipnet.se
}

{$I useamigasmartlink.inc}
{$ifdef use_amiga_smartlink}
   {$smartlink on}
{$endif use_amiga_smartlink}

UNIT rexx;

INTERFACE


USES exec;



{ === rexx/storage.h ==================================================
 *
 * Copyright (c) 1986, 1987 by William S. Hawes (All Rights Reserved)
 *
 * =====================================================================
 * Header file to define ARexx data structures.
}


{ The NexxStr structure is used to maintain the internal strings in REXX.
 * It includes the buffer area for the string and associated attributes.
 * This is actually a variable-length structure; it is allocated for a
 * specific length string, and the length is never modified thereafter
 * (since it's used for recycling).
 }

Type

    pNexxStr = ^tNexxStr;
    tNexxStr = record
    ns_Ivalue   : Longint;  { integer value                 }
    ns_Length   : Word;     { length in bytes (excl null)   }
    ns_Flags    : Byte;     { attribute flags               }
    ns_Hash     : Byte;     { hash code                     }
    ns_Buff     : Array [0..7] of Byte;
                    { buffer area for strings       }
    end;                { size: 16 bytes (minimum)      }

Const

    NXADDLEN    = 9;            { offset plus null byte         }

{ String attribute flag bit definitions                                }

    NSB_KEEP    = 0;            { permanent string?             }
    NSB_STRING  = 1;            { string form valid?            }
    NSB_NOTNUM  = 2;            { non-numeric?                  }
    NSB_NUMBER  = 3;            { a valid number?               }
    NSB_BINARY  = 4;            { integer value saved?          }
    NSB_FLOAT   = 5;            { floating point format?        }
    NSB_EXT = 6;            { an external string?           }
    NSB_SOURCE  = 7;            { part of the program source?   }

{ The flag form of the string attributes                               }

    NSF_KEEP    = 1;
    NSF_STRING  = 2;
    NSF_NOTNUM  = 4;
    NSF_NUMBER  = 8;
    NSF_BINARY  = 16;
    NSF_FLOAT   = 32;
    NSF_EXT = 64;
    NSF_SOURCE  = 128;

{ Combinations of flags                                                }

    NSF_INTNUM  = NSF_NUMBER + NSF_BINARY + NSF_STRING;
    NSF_DPNUM   = NSF_NUMBER + NSF_FLOAT;
    NSF_ALPHA   = NSF_NOTNUM + NSF_STRING;
    NSF_OWNED   = NSF_SOURCE + NSF_EXT    + NSF_KEEP;
    KEEPSTR = NSF_STRING + NSF_SOURCE + NSF_NOTNUM;
    KEEPNUM = NSF_STRING + NSF_SOURCE + NSF_NUMBER + NSF_BINARY;

{ The RexxArg structure is identical to the NexxStr structure, but
 * is allocated from system memory rather than from internal storage.
 * This structure is used for passing arguments to external programs.
 * It is usually passed as an "argstring", a pointer to the string buffer.
}

Type

    pRexxArg = ^tRexxArg;
    tRexxArg = record
    ra_Size     : Longint;  { total allocated length        }
    ra_Length   : Word;     { length of string              }
    ra_Flags    : Byte;     { attribute flags               }
    ra_Hash     : Byte;     { hash code                     }
    ra_Buff     : Array [0..7] of Byte;
                    { buffer area                   }
    end;                { size: 16 bytes (minimum)      }

{ The RexxMsg structure is used for all communications with REXX
 * programs.  It is an EXEC message with a parameter block appended.
}

    pRexxMsg = ^tRexxMsg;
    tRexxMsg = record
    rm_Node     : tMessage;  { EXEC message structure        }
    rm_TaskBlock    : Pointer;  { global structure (private)    }
    rm_LibBase  : Pointer;  { library base (private)        }
    rm_Action   : Longint;  { command (action) code         }
    rm_Result1  : Longint;  { primary result (return code)  }
    rm_Result2  : Longint;  { secondary result              }
    rm_Args     : Array [0..15] of STRPTR;
                    { argument block (ARG0-ARG15)   }

    rm_PassPort : pMsgPort;   { forwarding port               }
    rm_CommAddr : STRPTR;   { host address (port name)      }
    rm_FileExt  : STRPTR;   { file extension                }
    rm_Stdin    : Longint;  { input stream (filehandle)     }
    rm_Stdout   : Longint;  { output stream (filehandle)    }
    rm_avail    : Longint;  { future expansion              }
    end;                { size: 128 bytes               }

Const

    MAXRMARG        = 15;       { maximum arguments             }

{ Command (action) codes for message packets                           }

    RXCOMM      = $01000000;    { a command-level invocation    }
    RXFUNC      = $02000000;    { a function call               }
    RXCLOSE     = $03000000;    { close the REXX server         }
    RXQUERY     = $04000000;    { query for information         }
    RXADDFH     = $07000000;    { add a function host           }
    RXADDLIB        = $08000000;    { add a function library        }
    RXREMLIB        = $09000000;    { remove a function library     }
    RXADDCON        = $0A000000;    { add/update a ClipList string  }
    RXREMCON        = $0B000000;    { remove a ClipList string      }
    RXTCOPN     = $0C000000;    { open the trace console        }
    RXTCCLS     = $0D000000;    { close the trace console       }

{ Command modifier flag bits                                           }

    RXFB_NOIO       = 16;       { suppress I/O inheritance?     }
    RXFB_RESULT     = 17;       { result string expected?       }
    RXFB_STRING     = 18;       { program is a "string file"?   }
    RXFB_TOKEN      = 19;       { tokenize the command line?    }
    RXFB_NONRET     = 20;       { a "no-return" message?        }

{ The flag form of the command modifiers                               }

    RXFF_NOIO       = $00010000;
    RXFF_RESULT     = $00020000;
    RXFF_STRING     = $00040000;
    RXFF_TOKEN      = $00080000;
    RXFF_NONRET     = $00100000;

    RXCODEMASK      = $FF000000;
    RXARGMASK       = $0000000F;

{ The RexxRsrc structure is used to manage global resources.  Each node 
 * has a name string created as a RexxArg structure, and the total size
 * of the node is saved in the "rr_Size" field.  The REXX systems library
 * provides functions to allocate and release resource nodes.  If special
 * deletion operations are required, an offset and base can be provided in
 * "rr_Func" and "rr_Base", respectively.  This "autodelete" function will
 * be called with the base in register A6 and the node in A0.
 }

Type

    pRexxRsrc = ^tRexxRsrc;
    tRexxRsrc = record
    rr_Node     : tNode;
    rr_Func     : smallint;    { "auto-delete" offset          }
    rr_Base     : Pointer;  { "auto-delete" base            }
    rr_Size     : Longint;  { total size of node            }
    rr_Arg1     : Longint;  { available ...                 }
    rr_Arg2     : Longint;  { available ...                 }
    end;                { size: 32 bytes                }

Const

{ Resource node types                                                  }

    RRT_ANY     = 0;        { any node type ...             }
    RRT_LIB     = 1;        { a function library            }
    RRT_PORT        = 2;        { a public port                 }
    RRT_FILE        = 3;        { a file IoBuff                 }
    RRT_HOST        = 4;        { a function host               }
    RRT_CLIP        = 5;        { a Clip List node              }

{ The RexxTask structure holds the fields used by REXX to communicate with
 * external processes, including the client task.  It includes the global
 * data structure (and the base environment).  The structure is passed to
 * the newly-created task in its "wake-up" message.
 }

    GLOBALSZ        = 200;      { total size of GlobalData      }

Type

    pRexxTask = ^tRexxTask;
    tRexxTask = record
    rt_Global   : Array [0..GLOBALSZ-1] of Byte;
                    { global data structure         }
    rt_MsgPort  : tMsgPort;  { global message port           }
    rt_Flags    : Byte;     { task flag bits                }
    rt_SigBit   : Shortint;     { signal bit                    }

    rt_ClientID : Pointer;  { the client's task ID          }
    rt_MsgPkt   : Pointer;  { the packet being processed    }
    rt_TaskID   : Pointer;  { our task ID                   }
    rt_RexxPort : Pointer;  { the REXX public port          }

    rt_ErrTrap  : Pointer;  { Error trap address            }
    rt_StackPtr : Pointer;  { stack pointer for traps       }

    rt_Header1  : tList;     { Environment list              }
    rt_Header2  : tList;     { Memory freelist               }
    rt_Header3  : tList;     { Memory allocation list        }
    rt_Header4  : tList;     { Files list                    }
    rt_Header5  : tList;     { Message Ports List            }
    end;

Const

{ Definitions for RexxTask flag bits                                   }

    RTFB_TRACE      = 0;        { external trace flag           }
    RTFB_HALT       = 1;        { external halt flag            }
    RTFB_SUSP       = 2;        { suspend task?                 }
    RTFB_TCUSE      = 3;        { trace console in use?         }
    RTFB_WAIT       = 6;        { waiting for reply?            }
    RTFB_CLOSE      = 7;        { task completed?               }

{ Definitions for memory allocation constants                          }

    MEMQUANT        = 16;       { quantum of memory space       }
    MEMMASK     = $FFFFFFF0;    { mask for rounding the size    }

    MEMQUICK        = 1;        { EXEC flags: MEMF_PUBLIC       }
    MEMCLEAR        = $00010000;    { EXEC flags: MEMF_CLEAR        }

{ The SrcNode is a temporary structure used to hold values destined for
 * a segment array.  It is also used to maintain the memory freelist.
}

Type

    pSrcNode = ^tSrcNode;
    tSrcNode = record
    sn_Succ     : pSrcNode; { next node                     }
    sn_Pred     : pSrcNode; { previous node                 }
    sn_Ptr      : Pointer;  { pointer value                 }
    sn_Size     : Longint;  { size of object                }
    end;                { size: 16 bytes                }

{ === rexx/rexxio.h ====================================================
 *
 * Copyright (c) 1986, 1987 by William S. Hawes.  All Rights Reserved.
 *
 * ======================================================================
 * Header file for ARexx Input/Output related structures
}

Const

    RXBUFFSZ    = 204;          { buffer length                 }

{
 * The IoBuff is a resource node used to maintain the File List.  Nodes
 * are allocated and linked into the list whenever a file is opened.
}

Type

    pIoBuff = ^tIoBuff;
    tIoBuff = record
    iobNode     : tRexxRsrc; { structure for files/strings   }
    iobRpt      : Pointer;  { read/write pointer            }
    iobRct      : Longint;  { character count               }
    iobDFH      : Longint;  { DOS filehandle                }
    iobLock     : Longint;  { DOS lock                      }
    iobBct      : Longint;  { buffer length                 }
    iobArea     : Array [0..RXBUFFSZ-1] of Byte;
                    { buffer area                   }
    end;                { size: 256 bytes               }

Const

{ Access mode definitions                                              }

    RXIO_EXIST      = -1;       { an external filehandle        }
    RXIO_STRF       = 0;        { a "string file"               }
    RXIO_READ       = 1;        { read-only access              }
    RXIO_WRITE      = 2;        { write mode                    }
    RXIO_APPEND     = 3;        { append mode (existing file)   }

{
 * Offset anchors for SeekF()
}

    RXIO_BEGIN      = -1;       { relative to start             }
    RXIO_CURR       = 0;        { relative to current position  }
    RXIO_END        = 1;        { relative to end               }

{
 * A message port structure, maintained as a resource node.  The ReplyList
 * holds packets that have been received but haven't been replied.
}

Type

    pRexxMsgPort = ^tRexxMsgPort;
    tRexxMsgPort = record
    rmp_Node    : tRexxRsrc; { linkage node                  }
    rmp_Port    : tMsgPort;  { the message port              }
    rmp_ReplyList   : tList;     { messages awaiting reply       }
    end;

Const

{
 * DOS Device types
}

    DT_DEV  = 0;            { a device                      }
    DT_DIR  = 1;            { an ASSIGNed directory         }
    DT_VOL  = 2;            { a volume                      }

{
 * Private DOS packet types
}

    ACTION_STACK    = 2002;     { stack a line                  }
    ACTION_QUEUE    = 2003;     { queue a line                  }

{ === rexx/rxslib.h ===================================================
 *
 * Copyright (c) 1986, 1987, 1989 by William S. Hawes (All Rights Reserved)
 *
 * =====================================================================
 * The header file for the REXX Systems Library
}

{ Some macro definitions                                               }

Const

    RXSNAME    : PChar = 'rexxsyslib.library';
    RXSID      : PChar = 'rexxsyslib 1.06 (07 MAR 88)';
    RXSDIR     : PChar = 'REXX';
    RXSTNAME   : PChar = 'ARexx';

{ The REXX systems library structure.  This should be considered as    }
{ semi-private and read-only, except for documented exceptions.        }

Type

    pRxsLib = ^tRxsLib;
    tRxsLib = record
    rl_Node     : tLibrary;  { EXEC library node             }
    rl_Flags    : Byte;     { global flags                  }
    rl_pad      : Byte;
    rl_SysBase  : Pointer;  { EXEC library base             }
    rl_DOSBase  : Pointer;  { DOS library base              }
    rl_IeeeDPBase   : Pointer;  { IEEE DP math library base     }
    rl_SegList  : Longint;  { library seglist               }
    rl_NIL      : Longint;  { global NIL: filehandle        }
    rl_Chunk    : Longint;  { allocation quantum            }
    rl_MaxNest  : Longint;  { maximum expression nesting    }
    rl_NULL     : pNexxStr;   { static string: NULL           }
    rl_FALSE    : pNexxStr;   { static string: FALSE          }
    rl_TRUE     : pNexxStr;   { static string: TRUE           }
    rl_REXX     : pNexxStr;   { static string: REXX           }
    rl_COMMAND  : pNexxStr;   { static string: COMMAND        }
    rl_STDIN    : pNexxStr;   { static string: STDIN          }
    rl_STDOUT   : pNexxStr;   { static string: STDOUT         }
    rl_STDERR   : pNexxStr;   { static string: STDERR         }
    rl_Version  : STRPTR;   { version/configuration string  }

    rl_TaskName : STRPTR;   { name string for tasks         }
    rl_TaskPri  : Longint;  { starting priority             }
    rl_TaskSeg  : Longint;  { startup seglist               }
    rl_StackSize    : Longint;  { stack size                    }
    rl_RexxDir  : STRPTR;   { REXX directory                }
    rl_CTABLE   : STRPTR;   { character attribute table     }
    rl_Notice   : STRPTR;   { copyright notice              }

    rl_RexxPort : tMsgPort;  { REXX public port              }
    rl_ReadLock : Word;    { lock count                    }
    rl_TraceFH  : Longint;  { global trace console          }
    rl_TaskList : tList;     { REXX task list                }
    rl_NumTask  : smallint;    { task count                    }
    rl_LibList  : tList;     { Library List header           }
    rl_NumLib   : smallint;    { library count                 }
    rl_ClipList : tList;     { ClipList header               }
    rl_NumClip  : smallint;    { clip node count               }
    rl_MsgList  : tList;     { pending messages              }
    rl_NumMsg   : smallint;    { pending count                 }
    rl_PgmList  : tList;     { cached programs               }
    rl_NumPgm   : smallint;    { program count                 }

    rl_TraceCnt : Word;    { usage count for trace console }
    rl_avail    : smallint;
    end;

Const

{ Global flag bit definitions for RexxMaster                           }
    RLFB_TRACE  = RTFB_TRACE;       { interactive tracing?          }
    RLFB_HALT   = RTFB_HALT;        { halt execution?               }
    RLFB_SUSP   = RTFB_SUSP;        { suspend execution?            }
    RLFB_STOP   = 6;            { deny further invocations      }
    RLFB_CLOSE  = 7;            { close the master              }

    RLFMASK = 1 + 2 + 4;

{ Initialization constants                                             }

    RXSVERS = 34;           { main version                  }
    RXSREV  = 7;            { revision                      }
    RXSALLOC    = $800000;      { maximum allocation            }
    RXSCHUNK    = 1024;         { allocation quantum            }
    RXSNEST = 32;           { expression nesting limit      }
    RXSTPRI = 0;            { task priority                 }
    RXSSTACK    = 4096;         { stack size                    }
    RXSLISTH    = 5;            { number of list headers        }

{ Character attribute flag bits used in REXX.                          }

    CTB_SPACE   = 0;            { white space characters        }
    CTB_DIGIT   = 1;            { decimal digits 0-9            }
    CTB_ALPHA   = 2;            { alphabetic characters         }
    CTB_REXXSYM = 3;            { REXX symbol characters        }
    CTB_REXXOPR = 4;            { REXX operator characters      }
    CTB_REXXSPC = 5;            { REXX special symbols          }
    CTB_UPPER   = 6;            { UPPERCASE alphabetic          }
    CTB_LOWER   = 7;            { lowercase alphabetic          }
                                                                      
{ Attribute flags                                                      }

    CTF_SPACE   = 1;
    CTF_DIGIT   = 2;
    CTF_ALPHA   = 4;
    CTF_REXXSYM = 8;
    CTF_REXXOPR = 16;
    CTF_REXXSPC = 32;
    CTF_UPPER   = 64;
    CTF_LOWER   = 128;


VAR RexxSysBase : pLibrary;

const
    REXXSYSLIBNAME : PChar = 'rexxsyslib.library';

PROCEDURE ClearRexxMsg(msgptr : pRexxMsg; count : ULONG);
FUNCTION CreateArgstring(const argstring : pCHAR; length : ULONG) : pCHAR;
FUNCTION CreateRexxMsg(const port : pMsgPort;const extension : pCHAR; host : pCHAR) : pRexxMsg;
PROCEDURE DeleteArgstring(argstring : pCHAR);
PROCEDURE DeleteRexxMsg(packet : pRexxMsg);
FUNCTION FillRexxMsg(msgptr : pRexxMsg; count : ULONG; mask : ULONG) : BOOLEAN;
FUNCTION IsRexxMsg(const msgptr : pRexxMsg) : BOOLEAN;
FUNCTION LengthArgstring(const argstring : pCHAR) : ULONG;
PROCEDURE LockRexxBase(resource : ULONG);
PROCEDURE UnlockRexxBase(resource : ULONG);

FUNCTION CreateArgstring(const argstring : string; length : ULONG) : pCHAR;
FUNCTION CreateRexxMsg(const port : pMsgPort;const extension : string; host : pCHAR) : pRexxMsg;
FUNCTION CreateRexxMsg(const port : pMsgPort;const extension : pCHAR; host : string) : pRexxMsg;
FUNCTION CreateRexxMsg(const port : pMsgPort;const extension : string; host : string) : pRexxMsg;
PROCEDURE DeleteArgstring(argstring : string);
FUNCTION LengthArgstring(const argstring : string) : ULONG;

{Here we read how to compile this unit}
{You can remove this include and use a define instead}
{$I useautoopenlib.inc}
{$ifdef use_init_openlib}
procedure InitREXXSYSLIBLibrary;
{$endif use_init_openlib}

{This is a variable that knows how the unit is compiled}
var
    REXXSYSLIBIsCompiledHow : longint;

IMPLEMENTATION

uses
{$ifndef dont_use_openlib}
msgbox,
{$endif dont_use_openlib}
pastoc;


PROCEDURE ClearRexxMsg(msgptr : pRexxMsg; count : ULONG);
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVEA.L msgptr,A0
    MOVE.L  count,D0
    MOVEA.L RexxSysBase,A6
    JSR -156(A6)
    MOVEA.L (A7)+,A6
  END;
END;

FUNCTION CreateArgstring(const argstring : pCHAR; length : ULONG) : pCHAR;
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVEA.L argstring,A0
    MOVE.L  length,D0
    MOVEA.L RexxSysBase,A6
    JSR -126(A6)
    MOVEA.L (A7)+,A6
    MOVE.L  D0,@RESULT
  END;
END;

FUNCTION CreateRexxMsg(const port : pMsgPort;const extension : pCHAR; host : pCHAR) : pRexxMsg;
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVEA.L port,A0
    MOVEA.L extension,A1
    MOVE.L  host,D0
    MOVEA.L RexxSysBase,A6
    JSR -144(A6)
    MOVEA.L (A7)+,A6
    MOVE.L  D0,@RESULT
  END;
END;

PROCEDURE DeleteArgstring(argstring : pCHAR);
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVEA.L argstring,A0
    MOVEA.L RexxSysBase,A6
    JSR -132(A6)
    MOVEA.L (A7)+,A6
  END;
END;

PROCEDURE DeleteRexxMsg(packet : pRexxMsg);
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVEA.L packet,A0
    MOVEA.L RexxSysBase,A6
    JSR -150(A6)
    MOVEA.L (A7)+,A6
  END;
END;

FUNCTION FillRexxMsg(msgptr : pRexxMsg; count : ULONG; mask : ULONG) : BOOLEAN;
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVEA.L msgptr,A0
    MOVE.L  count,D0
    MOVE.L  mask,D1
    MOVEA.L RexxSysBase,A6
    JSR -162(A6)
    MOVEA.L (A7)+,A6
    TST.W   D0
    BEQ.B   @end
    MOVEQ   #1,D0
  @end: MOVE.B  D0,@RESULT
  END;
END;

FUNCTION IsRexxMsg(const msgptr : pRexxMsg) : BOOLEAN;
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVEA.L msgptr,A0
    MOVEA.L RexxSysBase,A6
    JSR -168(A6)
    MOVEA.L (A7)+,A6
    TST.W   D0
    BEQ.B   @end
    MOVEQ   #1,D0
  @end: MOVE.B  D0,@RESULT
  END;
END;

FUNCTION LengthArgstring(const argstring : pCHAR) : ULONG;
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVEA.L argstring,A0
    MOVEA.L RexxSysBase,A6
    JSR -138(A6)
    MOVEA.L (A7)+,A6
    MOVE.L  D0,@RESULT
  END;
END;

PROCEDURE LockRexxBase(resource : ULONG);
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVE.L  resource,D0
    MOVEA.L RexxSysBase,A6
    JSR -450(A6)
    MOVEA.L (A7)+,A6
  END;
END;

PROCEDURE UnlockRexxBase(resource : ULONG);
BEGIN
  ASM
    MOVE.L  A6,-(A7)
    MOVE.L  resource,D0
    MOVEA.L RexxSysBase,A6
    JSR -456(A6)
    MOVEA.L (A7)+,A6
  END;
END;


FUNCTION CreateArgstring(const argstring : string; length : ULONG) : pCHAR;
begin
       CreateArgstring := CreateArgstring(pas2c(argstring),length);
end;

FUNCTION CreateRexxMsg(const port : pMsgPort;const extension : string; host : pCHAR) : pRexxMsg;
begin
       CreateRexxMsg := CreateRexxMsg(port,pas2c(extension),host);
end;

FUNCTION CreateRexxMsg(const port : pMsgPort;const extension : pCHAR; host : string) : pRexxMsg;
begin
       CreateRexxMsg := CreateRexxMsg(port,extension,pas2c(host));
end;

FUNCTION CreateRexxMsg(const port : pMsgPort;const extension : string; host : string) : pRexxMsg;
begin
       CreateRexxMsg := CreateRexxMsg(port,pas2c(extension),pas2c(host));
end;

PROCEDURE DeleteArgstring(argstring : string);
begin
       DeleteArgstring(pas2c(argstring));
end;

FUNCTION LengthArgstring(const argstring : string) : ULONG;
begin
       LengthArgstring := LengthArgstring(pas2c(argstring));
end;

const
    { Change VERSION and LIBVERSION to proper values }

    VERSION : string[2] = '0';
    LIBVERSION : longword = 0;

{$ifdef use_init_openlib}
  {$Info Compiling initopening of rexxsyslib.library}
  {$Info don't forget to use InitREXXSYSLIBLibrary in the beginning of your program}

var
    rexxsyslib_exit : Pointer;

procedure CloserexxsyslibLibrary;
begin
    ExitProc := rexxsyslib_exit;
    if RexxSysBase <> nil then begin
        CloseLibrary(RexxSysBase);
        RexxSysBase := nil;
    end;
end;

procedure InitREXXSYSLIBLibrary;
begin
    RexxSysBase := nil;
    RexxSysBase := OpenLibrary(REXXSYSLIBNAME,LIBVERSION);
    if RexxSysBase <> nil then begin
        rexxsyslib_exit := ExitProc;
        ExitProc := @CloserexxsyslibLibrary;
    end else begin
        MessageBox('FPC Pascal Error',
        'Can''t open rexxsyslib.library version ' + VERSION + #10 +
        'Deallocating resources and closing down',
        'Oops');
        halt(20);
    end;
end;

begin
    REXXSYSLIBIsCompiledHow := 2;
{$endif use_init_openlib}

{$ifdef use_auto_openlib}
  {$Info Compiling autoopening of rexxsyslib.library}

var
    rexxsyslib_exit : Pointer;

procedure CloserexxsyslibLibrary;
begin
    ExitProc := rexxsyslib_exit;
    if RexxSysBase <> nil then begin
        CloseLibrary(RexxSysBase);
        RexxSysBase := nil;
    end;
end;

begin
    RexxSysBase := nil;
    RexxSysBase := OpenLibrary(REXXSYSLIBNAME,LIBVERSION);
    if RexxSysBase <> nil then begin
        rexxsyslib_exit := ExitProc;
        ExitProc := @CloserexxsyslibLibrary;
        REXXSYSLIBIsCompiledHow := 1;
    end else begin
        MessageBox('FPC Pascal Error',
        'Can''t open rexxsyslib.library version ' + VERSION + #10 +
        'Deallocating resources and closing down',
        'Oops');
        halt(20);
    end;

{$endif use_auto_openlib}

{$ifdef dont_use_openlib}
begin
    REXXSYSLIBIsCompiledHow := 3;
   {$Warning No autoopening of rexxsyslib.library compiled}
   {$Warning Make sure you open rexxsyslib.library yourself}
{$endif dont_use_openlib}


END. (* UNIT REXXSYSLIB *)

{
  $Log: rexx.pas,v $
  Revision 1.6  2003/02/10 17:59:46  nils
  *  fixes for delphi mode

  Revision 1.5  2003/02/07 20:48:36  nils
  * update for amigaos 3.9

  * changed startcode for library

  Revision 1.4  2003/01/14 18:46:04  nils
  * added defines use_amia_smartlink and use_auto_openlib

  * implemented autoopening of library

  Revision 1.3  2002/11/19 18:47:47  nils
    * update check internal log

}


