fpc/rtl/netwlibc/libc.pp

{
    This file is part of the Free Pascal run time library.
    Copyright (c) 2004 Armin Diehl, member of the Free Pascal
    development team

    Interface to Netware libc

    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.

 **********************************************************************}



{$ifndef INCLUDED_FROM_SYSTEM}
{$mode objfpc}
unit libc;
interface


{ Netware libc interface
  Translated from c ndk Armin Diehl 2004/09/02 }
{$endif}

const
  libc_nlm='libc';
  system_nlm='!netware';

{ Pointers to basic pascal types, inserted by h2pas conversion program.}
Type
{ $ifndef INCLUDED_FROM_SYSTEM - (always available in 2.0.x and above - TH)
  PLongint  = ^Longint;
  PSmallInt = ^SmallInt;
  PByte     = ^Byte;
  PWord     = ^Word;
  PDWord    = ^DWord;
  PDouble   = ^Double;
$endif}
  PPPChar   = ^PPChar;
  void      = pointer;
  cint      = longint;
  TNLMHandle = Pointer;

const
  NullNlmHandle = nil;

{$PACKRECORDS C}

// string.h
// limits.h

{ some limits wanted by POSIX...  }
{ exact-width signed types...  }
type

   Pint8_t = ^int8_t;
   int8_t = char;

   Pint16 = ^Tint16;
   Tint16 = smallint;

   Pint64_t = ^Tint64;
   Tint64 = int64;
{ exact-width unsigned types...  }

   Puint64 = ^Tuint64;
   Tuint64 = qword;
{ lower and upper bound of exact width integer types...  }
{ macros for minimum-width integer constants...  }
{ minimum-width signed integer types...  }

   Pint_least8_t = ^int_least8_t;
   int_least8_t = char;

   Pint_least16_t = ^int_least16_t;
   int_least16_t = smallint;

   Pint_least32_t = ^int_least32_t;
   int_least32_t = longint;

   Pint_least64_t = ^int_least64_t;
   int_least64_t = int64;
{ minimum-width unsigned integer types...  }

   Puint_least8_t = ^uint_least8_t;
   uint_least8_t = byte;

   Puint_least16_t = ^uint_least16_t;
   uint_least16_t = word;

   Puint_least32_t = ^uint_least32_t;
   uint_least32_t = dword;

   Puint_least64_t = ^uint_least64_t;
   uint_least64_t = qword;
{ lower and upper bound of exact width integer types...  }
{ fastest minimum-width signed integer types...  }

   Pint_fast8_t = ^int_fast8_t;
   int_fast8_t = char;

   Pint_fast16_t = ^int_fast16_t;
   int_fast16_t = smallint;

   Pint_fast32_t = ^int_fast32_t;
   int_fast32_t = longint;

   Pint_fast64_t = ^int_fast64_t;
   int_fast64_t = int64;
{ fastest minimum-width unsigned integer types...  }

   Puint_fast8_t = ^uint_fast8_t;
   uint_fast8_t = byte;

   Puint_fast16_t = ^uint_fast16_t;
   uint_fast16_t = word;

   Puint_fast32_t = ^uint_fast32_t;
   uint_fast32_t = dword;

   Puint_fast64_t = ^uint_fast64_t;
   uint_fast64_t = qword;
{ lower and upper bound of fastest minimum-width integer types...  }
{ integer types capable of holding object pointer...  }

   Pintptr_t = ^intptr_t;
   intptr_t = longint;

   Puintptr_t = ^uintptr_t;
   uintptr_t = dword;
{ limit of integer type capable of holding object pointer...  }
{ maximum-width integer types...  }

   Pintmax_t = ^intmax_t;
   intmax_t = int64;

   Puintmax_t = ^uintmax_t;
   uintmax_t = Tuint64;
{ macros for maximum-width integer constants...  }
{ limits for other integer types...  }

   Psize_t = ^size_t;
   size_t = dword;
{ type yielded by sizeof()  }

   Pssize_t = ^ssize_t;
   ssize_t = longint;
{ signed byte counts for file I/O  }

   Psize64_t = ^size64_t;
   size64_t = Tuint64;
{ used for 64-bit (long) file I/O  }

   Pmode_t = ^mode_t;
   mode_t = dword;
{ file attributes, permissions  }

   Poff_t = ^off_t;
   off_t = longint;
{ file offset value  }

   Poff64_t = ^off64_t;
   off64_t = int64;
{ 64-bit (long) file offset value  }

   Pino_t = ^ino_t;
   ino_t = Tuint64;

   Ppid_t = ^pid_t;
   pid_t = longint;
{ capable of holding a pointer or -1  }

   Puid_t = ^uid_t;
   uid_t = Tuint64;

   Pgid_t = ^gid_t;
   gid_t = Tuint64;

   Pblksize_t = ^blksize_t;
   blksize_t = Tuint64;

   Pblkcnt_t = ^blkcnt_t;
   blkcnt_t = Tuint64;

   Pdev_t = ^dev_t;
   dev_t = Tuint64;

   Pnlink_t = ^nlink_t;
   nlink_t = dword;

   Pptrdiff_t = ^ptrdiff_t;
   ptrdiff_t = longint;

   Pwchar_t = ^wchar_t;
   wchar_t = WideChar;
   PPwchar_t = ^Pwchar_t;


{ prototypes for functions standard and nonstandard...  }

function memchr(_para1:pointer; _para2:longint; _para3:size_t):pointer;cdecl;external libc_nlm name 'memchr';
function memcmp(_para1, _para2:pointer; _para3:size_t):longint;cdecl;external libc_nlm name 'memcmp';
function memcpy(__restrict, __restrict1:pointer; _para3:size_t):pointer;cdecl;external libc_nlm name 'memcpy';
function memmove(_para1, _para2:pointer; _para3:size_t):pointer;cdecl;external libc_nlm name 'memmove';
function memset(_para1:pointer; _para2:longint; _para3:size_t):pointer;cdecl;external libc_nlm name 'memset';
function strcasecmp(_para1, _para2:Pchar):longint;cdecl;external libc_nlm name 'strcasecmp';
function strcat(dst,src:Pchar):Pchar;cdecl;external libc_nlm name 'strcat';
function strchr(_para1:Pchar; _para2:longint):Pchar;cdecl;external libc_nlm name 'strchr';
function strcmp(_para1, _para2:Pchar):longint;cdecl;external libc_nlm name 'strcmp';
function strcoll(_para1, _para2:Pchar):longint;cdecl;external libc_nlm name 'strcoll';
function strcpy(__restrict, __restrict1:Pchar):Pchar;cdecl;external libc_nlm name 'strcpy';
function strcspn(_para1, _para2:Pchar):size_t;cdecl;external libc_nlm name 'strcspn';
function strerror(_para1:longint):Pchar;cdecl;external libc_nlm name 'strerror';
function strlcat(__restrict, __restrict1:Pchar; _para3:size_t):size_t;cdecl;external libc_nlm name 'strlcat';
function strlcpy(__restrict, __restrict1:Pchar; _para3:size_t):size_t;cdecl;external libc_nlm name 'strlcpy';
function {$ifdef INCLUDED_FROM_SYSTEM}libc_strlen{$else}strlen{$endif}(_para1:Pchar):size_t;cdecl;external libc_nlm name 'strlen';
function strncasecmp(_para1, _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'strncasecmp';
function strncat(__restrict, __restrict1:Pchar; _para3:size_t):Pchar;cdecl;external libc_nlm name 'strncat';
function strncmp(_para1, _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'strncmp';
function strncoll(_para1, _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'strncoll';
function strncpy(__restrict, __restrict1:Pchar; _para3:size_t):Pchar;cdecl;external libc_nlm name 'strncpy';
function strnicmp(_para1, _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'strnicmp';
function strnset(_para1, _para2:longint; _para3:size_t):Pchar;cdecl;external libc_nlm name 'strnset';
function strpbrk(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'strpbrk';
function strrchr(_para1, _para2:longint):Pchar;cdecl;external libc_nlm name 'strrchr';
function strrev(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'strrev';
function strset(_para1:Pchar; _para2:longint):Pchar;cdecl;external libc_nlm name 'strset';
function strspn(_para1, _para2:Pchar):size_t;cdecl;external libc_nlm name 'strspn';
function strstr(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'strstr';
function strtok(__restrict, __restrict1:Pchar):Pchar;cdecl;external libc_nlm name 'strtok';
function strxfrm(__restrict, __restrict1:Pchar; _para3:size_t):size_t;cdecl;external libc_nlm name 'strxfrm';
{ POSIX and other functions...  }

function strtok_r(__restrict, __restrict1, __restrict2:PPchar):Pchar;cdecl;external libc_nlm name 'strtok_r';
function memicmp(_para1, _para2:pointer; _para3:size_t):longint;cdecl;external libc_nlm name 'memicmp';
function stpcpy(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'stpcpy';
function stricmp(_para1, _para2:Pchar):longint;cdecl;external libc_nlm name 'stricmp';
function strdup(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'strdup';
function strecpy(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'strecpy';
function strerror_r(_para1:longint; _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'strerror_r';

{$ifndef DisableArrayOfConst}
function strlist(_para1, _para2:Pchar; args:array of const):Pchar;cdecl;external libc_nlm name 'strlist';
{$endif}
function strlist(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'strlist';
function strlwr(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'strlwr';
function strrindex(_para1:Pchar; _para2:size_t; _para3:longint):Pchar;cdecl;external libc_nlm name 'strrindex';
function strwhich(_para1:Pchar; _para2:longint; _para3:Pchar):Pchar;cdecl;external libc_nlm name 'strwhich';
function strupr(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'strupr';
procedure swab(_para1, _para2:pointer; _para3:size_t);cdecl;external libc_nlm name 'swab';
procedure swaw(_para1, _para2:pointer; _para3:size_t);cdecl;external libc_nlm name 'swaw';
procedure ungettok(__restrict, __restrict1:Pchar);cdecl;external libc_nlm name 'ungettok';
procedure ungettok_r(__restrict, __restrict1:Pchar; __restrict2:PPchar);cdecl;external libc_nlm name 'ungettok_r';
{ multibyte (double) interfaces for locale code page work...  }
function Lstrbcpy(__restrict, __restrict1:Pchar; _para3:size_t):Pchar;cdecl;external libc_nlm name 'Lstrbcpy';
function Lstrchr(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'Lstrchr';
function Lstrcmp(_para1, _para2:Pchar):longint;cdecl;external libc_nlm name 'Lstrcmp';
function Lstrcoll(_para1, _para2:Pchar):longint;cdecl;external libc_nlm name 'Lstrcoll';
function Lstrcspn(_para1, _para2:Pchar):size_t;cdecl;external libc_nlm name 'Lstrcspn';
function Lstricmp(_para1, _para2:Pchar):longint;cdecl;external libc_nlm name 'Lstricmp';
function Lstrlen(_para1:Pchar):size_t;cdecl;external libc_nlm name 'Lstrlen';
function Lstrlwr(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'Lstrlwr';
function Lstrncat(__restrict:Pchar; __restrict1:Pchar; _para3:size_t):Pchar;cdecl;external libc_nlm name 'Lstrncat';
function Lstrncmp(_para1, _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'Lstrncmp';
function Lstrncoll(_para1, _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'Lstrncoll';
function Lstrncpy(__restrict, __restrict1:Pchar; _para3:size_t):Pchar;cdecl;external libc_nlm name 'Lstrncpy';
function Lstrnicmp(_para1, _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'Lstrnicmp';
function Lstrpbrk(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'Lstrpbrk';
function Lstrrchr(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'Lstrrchr';
function Lstrrev(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'Lstrrev';
function Lstrspn(_para1, _para2:Pchar):size_t;cdecl;external libc_nlm name 'Lstrspn';
function Lstrstr(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'Lstrstr';
function Lstrtok_r(__restrict:Pchar; __restrict1:Pchar; __restrict2:PPchar):Pchar;cdecl;external libc_nlm name 'Lstrtok_r';
function Lstrupr(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'Lstrupr';
function Lstrxfrm(__restrict:Pchar; __restrict1:Pchar; _para3:size_t):size_t;cdecl;external libc_nlm name 'Lstrxfrm';
{ length-preceeded string manipulation...  }
function ASCIIZToLenStr(_para1, _para2:Pchar):longint;cdecl;external libc_nlm name 'ASCIIZToLenStr';
function ASCIIZToMaxLenStr(_para1, _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'ASCIIZToMaxLenStr';
function LenStrCat(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'LenStrCat';
function LenStrCmp(_para1, _para2:Pchar):longint;cdecl;external libc_nlm name 'LenStrCmp';
function LenStrCpy(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'LenStrCpy';
function LenToASCIIZStr(_para1,_para2:Pchar):longint;cdecl;external libc_nlm name 'LenToASCIIZStr';
function strindex(_para1, _para2:Pchar):Pchar;cdecl;external libc_nlm name 'strindex';


// stdarg.h

  const
     //EOF = -(1);
     BUFSIZ = 8096;           { default buffer size--change with setbuf()  }
     FOPEN_MAX = 1024;        { at least this many FILEs available         }
     FILENAME_MAX = 1024;     { maximum characters in any path name        }
                              { values for argument 'flags' to setvbuf()...}
     _IONBF = $0010;          { unbuffered (e.g.: stdout and stderr)       }
     _IOLBF = $0020;          { line buffered (e.g.: stdin)                }
     _IOFBF = $0040;          { fully buffered (most files)                }
                              { values for fseek()'s whence argument       }
     SEEK_SET = 0;            { add 'offset' to beginning of file          }
     SEEK_CUR = 1;            { add 'offset' to current position in file   }
     SEEK_END = 2;            { add 'offset' to end of file                }
                              { definitions for tmpnam() and tmpfil()      }
     TMP_MAX = 1000000;       { "T-000000.TMP" to "T-999999.TMP"           }
     L_tmpnam = 36;
     P_tmpdir = 'sys:/tmp';
  { FILE type definition (result is opaque)    }


type

   Pva_list = ^va_list;
   va_list = char;

   P_iobuf = ^_iobuf;
   _iobuf = record
        reserved : longint;
     end;
   TFILE = _iobuf;
   PFILE = ^TFILE;
   PPFILE = ^PFILE;

   Pfpos_t = ^fpos_t;
   fpos_t = longint;

   Pfpos64_t = ^fpos64_t;
   fpos64_t = off64_t;

procedure clearerr(_para1:PFILE);cdecl;external libc_nlm name 'clearerr';
function fclose(_para1:PFILE):longint;cdecl;external libc_nlm name 'fclose';
function feof(_para1:PFILE):longint;cdecl;external libc_nlm name 'feof';
function ferror(_para1:PFILE):longint;cdecl;external libc_nlm name 'ferror';
function fflush(_para1:PFILE):longint;cdecl;external libc_nlm name 'fflush';
function fgetc(_para1:PFILE):longint;cdecl;external libc_nlm name 'fgetc';
function fgetpos(_para1:PFILE; _para2:Pfpos_t):longint;cdecl;external libc_nlm name 'fgetpos';
function fgets(_para1:Pchar; _para2:longint; _para3:PFILE):Pchar;cdecl;external libc_nlm name 'fgets';


function fopen(__restrict:Pchar; __restrict1:Pchar):PFILE;cdecl;external libc_nlm name 'fopen';
{$ifndef DisableArrayOfConst}
function fprintf(__restrict:PFILE; __restrict1:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'fprintf';
{$endif}
function fprintf(__restrict:PFILE; __restrict1:Pchar):longint;cdecl;external libc_nlm name 'fprintf';
function fputc(_para1:longint; _para2:PFILE):longint;cdecl;external libc_nlm name 'fputc';

function fputs(__restrict:Pchar; __restrict1:PFILE):longint;cdecl;external libc_nlm name 'fputs';
function fread(__restrict:pointer; _para2:size_t; _para3:size_t; __restrict1:PFILE):size_t;cdecl;external libc_nlm name 'fread';


function freopen(__restrict:Pchar; __restrict1:Pchar; __restrict2:PFILE):PFILE;cdecl;external libc_nlm name 'freopen';
{$ifndef DisableArrayOfConst}
function fscanf(__restrict:PFILE; __restrict1:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'fscanf';
{$endif}
function fscanf(__restrict:PFILE; __restrict1:Pchar):longint;cdecl;external libc_nlm name 'fscanf';
function fseek(fp:PFILE; offset:longint; whence:longint):longint;cdecl;external libc_nlm name 'fseek';

function fsetpos(_para1:PFILE; _para2:Pfpos_t):longint;cdecl;external libc_nlm name 'fsetpos';
function ftell(_para1:PFILE):longint;cdecl;external libc_nlm name 'ftell';

function fwrite(__restrict:pointer; _para2:size_t; _para3:size_t; __restrict1:PFILE):size_t;cdecl;external libc_nlm name 'fwrite';
function getc(_para1:PFILE):longint;cdecl;external libc_nlm name 'getc';
function getchar:longint;cdecl;external libc_nlm name 'getchar';
function gets(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'gets';
procedure {$ifdef INCLUDED_FROM_SYSTEM}libc_perror{$else}perror{$endif}(_para1:Pchar);cdecl;external libc_nlm name 'perror';

{$ifndef DisableArrayOfConst}
function printf(__restrict:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'printf';
{$endif}
function printf(__restrict:Pchar):longint;cdecl;external libc_nlm name 'printf';
function putc(_para1:longint; _para2:PFILE):longint;cdecl;external libc_nlm name 'putc';
function putchar(_para1:longint):longint;cdecl;external libc_nlm name 'putchar';
function puts(_para1:Pchar):longint;cdecl;external libc_nlm name 'puts';
function remove(_para1:Pchar):longint;cdecl;external libc_nlm name 'remove';
function rename(_para1:Pchar; _para2:Pchar):longint;cdecl;external libc_nlm name 'rename';
procedure rewind(_para1:PFILE);cdecl;external libc_nlm name 'rewind';

{$ifndef DisableArrayOfConst}
function scanf(__restrict:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'scanf';
{$endif}
function scanf(__restrict:Pchar):longint;cdecl;external libc_nlm name 'scanf';
procedure setbuf(__restrict:PFILE; __restrict1:Pchar);cdecl;external libc_nlm name 'setbuf';
function setvbuf(__restrict:PFILE; __restrict1:Pchar; _para3:longint; _para4:size_t):longint;cdecl;external libc_nlm name 'setvbuf';
{$ifndef DisableArrayOfConst}
function sprintf(__restrict:Pchar; __restrict1:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'sprintf';
{$endif}
function sprintf(__restrict:Pchar; __restrict1:Pchar):longint;cdecl;external libc_nlm name 'sprintf';
{$ifndef DisableArrayOfConst}
function snprintf(__restrict:Pchar; n:size_t; Format:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'snprintf';
{$endif}
function snprintf(__restrict:Pchar; n:size_t; Format:Pchar):longint;cdecl;external libc_nlm name 'snprintf';
function snprintf(__restrict:Pchar; n:size_t; Format:Pchar; p1:longint):longint;cdecl;external libc_nlm name 'snprintf';
function snprintf(__restrict:Pchar; n:size_t; Format:Pchar; p1:longint; p2:pchar):longint;cdecl;external libc_nlm name 'snprintf';
function snprintf(__restrict:Pchar; n:size_t; Format:Pchar; p1:pchar):longint;cdecl;external libc_nlm name 'snprintf';
function snprintf(__restrict:Pchar; n:size_t; Format:Pchar; p1,p2:pchar):longint;cdecl;external libc_nlm name 'snprintf';
function snprintf(__restrict:Pchar; n:size_t; Format:Pchar; p1,p2,p3:pchar):longint;cdecl;external libc_nlm name 'snprintf';
function snprintf(__restrict:Pchar; n:size_t; Format:Pchar; p1,p2:longint):longint;cdecl;external libc_nlm name 'snprintf';
function snprintf(__restrict:Pchar; n:size_t; Format:Pchar; p1,p2,p3:longint):longint;cdecl;external libc_nlm name 'snprintf';

{$ifndef DisableArrayOfConst}
function sscanf(__restrict:Pchar; __restrict1:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'sscanf';
{$endif}
function sscanf(__restrict:Pchar; __restrict1:Pchar):longint;cdecl;external libc_nlm name 'sscanf';
function tmpfile:PFILE;cdecl;external libc_nlm name 'tmpfile';
function tmpnam(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'tmpnam';
function ungetc(_para1:longint; _para2:PFILE):longint;cdecl;external libc_nlm name 'ungetc';

function vfprintf(__restrict:PFILE; __restrict1:Pchar; _para3:va_list):longint;cdecl;external libc_nlm name 'vfprintf';
function vfscanf(__restrict:PFILE; __restrict1:Pchar; _para3:va_list):longint;cdecl;external libc_nlm name 'vfscanf';
function vprintf(__restrict:Pchar; _para2:va_list):longint;cdecl;external libc_nlm name 'vprintf';
function vscanf(__restrict:Pchar; _para2:va_list):longint;cdecl;external libc_nlm name 'vscanf';
function vsnprintf(__restrict:Pchar; n:size_t; __restrict1:Pchar; _para4:va_list):longint;cdecl;external libc_nlm name 'vsnprintf';
function vsprintf(__restrict:Pchar; __restrict1:Pchar; _para3:va_list):longint;cdecl;external libc_nlm name 'vsprintf';

function vsscanf(__restrict:Pchar; __restrict1:Pchar; _para3:va_list):longint;cdecl;external libc_nlm name 'vsscanf';
{ functions underlying macro support...  }
function ___stdin:PPFILE;cdecl;external libc_nlm name '___stdin';
function ___stdout:PPFILE;cdecl;external libc_nlm name '___stdout';
function ___stderr:PPFILE;cdecl;external libc_nlm name '___stderr';
function ___cin:PPFILE;cdecl;external libc_nlm name '___cin';
function ___cout:PPFILE;cdecl;external libc_nlm name '___cout';
{ POSIX-defined and other additions...  }

function fdopen(_para1:longint; __restrict:Pchar):PFILE;cdecl;external libc_nlm name 'fdopen';
function fileno(_para1:PFILE):longint;cdecl;external libc_nlm name 'fileno';
procedure flockfile(_para1:PFILE);cdecl;external libc_nlm name 'flockfile';
function ftrylockfile(_para1:PFILE):longint;cdecl;external libc_nlm name 'ftrylockfile';
procedure funlockfile(_para1:PFILE);cdecl;external libc_nlm name 'funlockfile';
function getc_unlocked(_para1:PFILE):longint;cdecl;external libc_nlm name 'getc_unlocked';
function getchar_unlocked:longint;cdecl;external libc_nlm name 'getchar_unlocked';
function getw(_para1:PFILE):longint;cdecl;external libc_nlm name 'getw';
function pclose(stream:PFILE):longint;cdecl;external libc_nlm name 'pclose';
function popen(command:Pchar; mode:Pchar):PFILE;cdecl;external libc_nlm name 'popen';
function putc_unlocked(c:longint; _para2:PFILE):longint;cdecl;external libc_nlm name 'putc_unlocked';
function putchar_unlocked(c:longint):longint;cdecl;external libc_nlm name 'putchar_unlocked';
function tempnam(dirpath:Pchar; prefix:Pchar):Pchar;cdecl;external libc_nlm name 'tempnam';
{ nonstandard (transitional) addtions for 64-bit file I/O...  }
function fgetpos64(_para1:PFILE; _para2:Pfpos64_t):longint;cdecl;external libc_nlm name 'fgetpos64';
function fseek64(fp:PFILE; offset:fpos64_t; whence:longint):longint;cdecl;external libc_nlm name 'fseek64';
function fsetpos64(_para1:PFILE; _para2:Pfpos64_t):longint;cdecl;external libc_nlm name 'fsetpos64';
function ftell64(_para1:PFILE):off64_t;cdecl;external libc_nlm name 'ftell64';
{ hard-wired console I/O support (cannot be redirected)...  }
function cgetc:longint;cdecl;external libc_nlm name 'cgetc';
function cgets(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'cgets';

{$ifndef DisableArrayOfConst}
function cprintf(_para1:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'cprintf';
{$endif}
function cprintf(_para1:Pchar):longint;cdecl;external libc_nlm name 'cprintf';
function cputc(_para1:longint):longint;cdecl;external libc_nlm name 'cputc';
function cputs(_para1:Pchar):longint;cdecl;external libc_nlm name 'cputs';
{$ifndef DisableArrayOfConst}
function cscanf(__restrict:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'cscanf';
{$endif}
function cscanf(__restrict:Pchar):longint;cdecl;external libc_nlm name 'cscanf';
function vcprintf(__restrict:Pchar; _para2:va_list):longint;cdecl;external libc_nlm name 'vcprintf';
function vcscanf(__restrict:Pchar; _para2:va_list):longint;cdecl;external libc_nlm name 'vcscanf';
function vasprintf(__restrict:PPchar; __restrict1:Pchar; _para3:va_list):longint;cdecl;external libc_nlm name 'vasprintf';
{ defined as macros in both C and C++...  }
{ UNIX 98/POSIX.1-2002 defined additions  }


// stdlib.h
{ pshpack1.h }
{ turn on 1-byte packing...  }

  const
     EXIT_FAILURE = -(1);
     EXIT_SUCCESS = 0;
     RAND_MAX = 32767;


type
   Pdiv_t = ^div_t;
   div_t = record
        quot : longint;
        rem : longint;
     end;

   Pldiv_t = ^ldiv_t;
   ldiv_t = record
        quot : longint;
        rem : longint;
     end;

   Plldiv_t = ^lldiv_t;
   lldiv_t = record
        quot : Tint64;
        rem : Tint64;
     end;

(** unsupported pragma#pragma pack()*)

type TCDeclProcedure = procedure; cdecl;

procedure abort;cdecl;external libc_nlm name 'abort';
// function {$ifdef INCLUDED_FROM_SYSTEM}libc_abs{$else}abs{$endif}(_para1:longint):longint;cdecl;external libc_nlm name 'abs';
function atexit(_para1:TCDeclProcedure ):longint;cdecl;external libc_nlm name 'atexit';
function atof(_para1:Pchar):double;cdecl;external libc_nlm name 'atof';
function atoi(_para1:Pchar):longint;cdecl;external libc_nlm name 'atoi';
function atol(_para1:Pchar):longint;cdecl;external libc_nlm name 'atol';
function atoll(_para1:Pchar):Tint64;cdecl;external libc_nlm name 'atoll';

//!! function bsearch(_para1:pointer; _para2:pointer; _para3:size_t; _para4:size_t; _para5:function (_para1:pointer; _para2:pointer):longint):pointer;cdecl;external libc_nlm name 'bsearch';
function calloc(_para1:size_t; _para2:size_t):pointer;cdecl;external libc_nlm name 'calloc';
function __CW_div(_para1:longint; _para2:longint):div_t;cdecl;external libc_nlm name '__CW_div';
procedure libc_exit(status:longint);cdecl;external libc_nlm name 'exit';
procedure free(_para1:pointer);cdecl;external libc_nlm name 'free';
function getenv(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'getenv';
function labs(_para1:longint):longint;cdecl;external libc_nlm name 'labs';
function __CW_ldiv(_para1:longint; _para2:longint):ldiv_t;cdecl;external libc_nlm name '__CW_ldiv';
function llabs(_para1:Tint64):Tint64;cdecl;external libc_nlm name 'llabs';
function __CW_lldiv(_para1:Tint64; _para2:Tint64):lldiv_t;cdecl;external libc_nlm name '__CW_lldiv';
function malloc(_para1:size_t):pointer;cdecl;external libc_nlm name 'malloc';
function mblen(_para1:Pchar; _para2:size_t):longint;cdecl;external libc_nlm name 'mblen';
function mbstowcs(_para1:Pwchar_t; _para2:Pchar; _para3:size_t):size_t;cdecl;external libc_nlm name 'mbstowcs';
function mbtowc(_para1:Pwchar_t; _para2:Pchar; _para3:size_t):longint;cdecl;external libc_nlm name 'mbtowc';

type TQSortFunc = function (_para1:pointer; _para2:pointer):longint; cdecl;
procedure qsort(_para1:pointer; _para2:size_t; _para3:size_t; _para4:TQSortFunc);cdecl;external libc_nlm name 'qsort';
function rand:longint;cdecl;external libc_nlm name 'rand';
function realloc(_para1:pointer; _para2:size_t):pointer;cdecl;external libc_nlm name 'realloc';
procedure srand(_para1:dword);cdecl;external libc_nlm name 'srand';
function strtod(__restrict:Pchar; __restrict1:PPchar):double;cdecl;external libc_nlm name 'strtod';
function strtol(__restrict:Pchar; __restrict1:PPchar; _para3:longint):longint;cdecl;external libc_nlm name 'strtol';
function strtoll(__restrict:Pchar; __restrict1:PPchar; _para3:longint):Tint64;cdecl;external libc_nlm name 'strtoll';
function strtoul(__restrict:Pchar; __restrict1:PPchar; _para3:longint):dword;cdecl;external libc_nlm name 'strtoul';
function strtoull(__restrict:Pchar; __restrict1:PPchar; _para3:longint):Tuint64;cdecl;external libc_nlm name 'strtoull';
function system(_para1:Pchar):longint;cdecl;external libc_nlm name 'system';
function wcstombs(__restrict:Pchar; __restrict1:Pwchar_t; _para3:size_t):size_t;cdecl;external libc_nlm name 'wcstombs';
function wctomb(_para1:Pchar; _para2:wchar_t):longint;cdecl;external libc_nlm name 'wctomb';
function alloca(_para1:size_t):pointer;cdecl;external libc_nlm name 'alloca';
function clearenv:longint;cdecl;external libc_nlm name 'clearenv';
function getcmd(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'getcmd';
function flushenv(_para1:Pchar; _para2:longint):longint;cdecl;external libc_nlm name 'flushenv';
function getbsize(_para1:Plongint; _para2:Plongint):Pchar;cdecl;external libc_nlm name 'getbsize';
function htol(_para1:Pchar):dword;cdecl;external libc_nlm name 'htol';
function itoa(_para1:longint; _para2:Pchar; _para3:longint):Pchar;cdecl;external libc_nlm name 'itoa';
function itoab(_para1:dword; _para2:Pchar):Pchar;cdecl;external libc_nlm name 'itoab';
function ltoa(_para1:longint; _para2:Pchar; _para3:longint):Pchar;cdecl;external libc_nlm name 'ltoa';
function lltoa(_para1:Tint64; _para2:Pchar; _para3:longint):Pchar;cdecl;external libc_nlm name 'lltoa';
function _lrotr(_para1:dword; _para2:dword):dword;cdecl;external libc_nlm name '_lrotr';
function _lrotl(_para1:dword; _para2:dword):dword;cdecl;external libc_nlm name '_lrotl';
function mkdtemp(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'mkdtemp';
function mkstemp(_para1:Pchar):longint;cdecl;external libc_nlm name 'mkstemp';
function mktemp(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'mktemp';
function msize(_para1:pointer):size_t;cdecl;external libc_nlm name 'msize';
function multibyte:longint;cdecl;external libc_nlm name 'multibyte';
function mvalidrange(_para1:pointer; _para2:size_t):longint;cdecl;external libc_nlm name 'mvalidrange';
function nextmb(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'nextmb';
function prevmb(_para1:Pchar):Pchar;cdecl;external libc_nlm name 'prevmb';
function putenv(_para1:Pchar):longint;cdecl;external libc_nlm name 'putenv';
function rand_r(_para1:Pdword):longint;cdecl;external libc_nlm name 'rand_r';
function _rotr(_para1:dword; _para2:dword):dword;cdecl;external libc_nlm name '_rotr';
function _rotl(_para1:dword; _para2:dword):dword;cdecl;external libc_nlm name '_rotl';
function rotl8(_para1:byte; _para2:longint):byte;cdecl;external libc_nlm name 'rotl8';
function rotl16(_para1:word; _para2:longint):word;cdecl;external libc_nlm name 'rotl16';
function rotl32(_para1:dword; _para2:longint):dword;cdecl;external libc_nlm name 'rotl32';
function rotl64(_para1:Tuint64; _para2:longint):Tuint64;cdecl;external libc_nlm name 'rotl64';
function rotr8(_para1:byte; _para2:longint):byte;cdecl;external libc_nlm name 'rotr8';
function rotr16(_para1:word; _para2:longint):word;cdecl;external libc_nlm name 'rotr16';
function rotr32(_para1:dword; _para2:longint):dword;cdecl;external libc_nlm name 'rotr32';
function rotr64(_para1:Tuint64; _para2:longint):Tuint64;cdecl;external libc_nlm name 'rotr64';
function setenv(_para1:Pchar; _para2:Pchar; _para3:longint):longint;cdecl;external libc_nlm name 'setenv';
procedure setkey(_para1:Pchar);cdecl;external libc_nlm name 'setkey';
function stackavail:size_t;cdecl;external libc_nlm name 'stackavail';
function stackbase:pointer;cdecl;external libc_nlm name 'stackbase';
function stackwatermark:size_t;cdecl;external libc_nlm name 'stackwatermark';
function strtoi(_para1:Pchar; _para2:longint):longint;cdecl;external libc_nlm name 'strtoi';
function truncmb(_para1:Pchar; _para2:size_t):Pchar;cdecl;external libc_nlm name 'truncmb';
function ultoa(_para1:dword; _para2:Pchar; _para3:longint):Pchar;cdecl;external libc_nlm name 'ultoa';
function ulltoa(_para1:Tuint64; _para2:Pchar; _para3:longint):Pchar;cdecl;external libc_nlm name 'ulltoa';
function unsetenv(name:Pchar):longint;cdecl;external libc_nlm name 'unsetenv';
function utoa(_para1:dword; _para2:Pchar; _para3:longint):Pchar;cdecl;external libc_nlm name 'utoa';
function valuemb(_para1:Pchar):longint;cdecl;external libc_nlm name 'valuemb';
{ atomic functions...  }
procedure atomic_add(addr:Pdword; value:dword);cdecl;external libc_nlm name 'atomic_add';
function atomic_bts(addr:Pdword; offset:dword):dword;cdecl;external libc_nlm name 'atomic_bts';
function atomic_btr(addr:Pdword; offset:dword):dword;cdecl;external libc_nlm name 'atomic_btr';
procedure atomic_dec(addr:Pdword);cdecl;external libc_nlm name 'atomic_dec';
procedure atomic_inc(addr:Pdword);cdecl;external libc_nlm name 'atomic_inc';
procedure atomic_sub(addr:Pdword; value:dword);cdecl;external libc_nlm name 'atomic_sub';
function atomic_xchg(addr:Pdword; value:dword):dword;cdecl;external libc_nlm name 'atomic_xchg';
procedure atomic_or(addr:Pdword; value:dword);cdecl;external libc_nlm name 'atomic_or';
procedure atomic_xor(addr:Pdword; value:dword);cdecl;external libc_nlm name 'atomic_xor';
procedure atomic_and(addr:Pdword; value:dword);cdecl;external libc_nlm name 'atomic_and';
function atomic_xchgadd(addr:Pdword; value:dword):dword;cdecl;external libc_nlm name 'atomic_xchgadd';
function atomic_cmpxchg(addr:Pdword; cmpvalue:dword; newvalue:dword):dword;cdecl;external libc_nlm name 'atomic_cmpxchg';
procedure atomic64_inc(addr:Puint64);cdecl;external libc_nlm name 'atomic64_inc';
procedure atomic64_dec(addr:Puint64);cdecl;external libc_nlm name 'atomic64_dec';
procedure atomic64_add(addr:Puint64; value:tuint64);cdecl;external libc_nlm name 'atomic64_add';
procedure atomic64_sub(addr:Puint64; value:tuint64);cdecl;external libc_nlm name 'atomic64_sub';
function atomic64_xchg(addr:Puint64; value:tuint64):Tuint64;cdecl;external libc_nlm name 'atomic64_xchg';
function atomic64_xchgadd(addr:Puint64; value:Tuint64):Tuint64;cdecl;external libc_nlm name 'atomic64_xchgadd';
function atomic64_cmpxchg(addr:Puint64; cmpvalue:Tuint64; newvalue:Tuint64):Tuint64;cdecl;external libc_nlm name 'atomic64_cmpxchg';
{ compiler-specific implementations of alloca()...  }
function max(a:longint; b:longint):longint;cdecl;external libc_nlm name 'max';
function min(a:longint; b:longint):longint;cdecl;external libc_nlm name 'min';


// stropts.h
// sys/ioctl.h
// unistd.h
// sys/types.h

type
   Puchar_t = ^uchar_t;
   uchar_t = byte;

   Pushort_t = ^ushort_t;
   ushort_t = word;

   Puint_t = ^uint_t;
   uint_t = dword;

   Pulong_t = ^ulong_t;
   ulong_t = dword;

   Pu_char = ^u_char;
   u_char = byte;

   Pu_short = ^u_short;
   u_short = word;

   Pu_int = ^u_int;
   u_int = dword;

   Pu_long = ^u_long;
   u_long = dword;

   Pcaddr_t = ^caddr_t;
   caddr_t = char;

   Puseconds_t = ^useconds_t;
   useconds_t = Tuint64;

   Psuseconds_t = ^suseconds_t;
   suseconds_t = Tint64;

   Pu_int8_t = ^u_int8_t;
   u_int8_t = byte;

   Pu_int16_t = ^u_int16_t;
   u_int16_t = word;

   Pu_int32_t = ^u_int32_t;
   u_int32_t = dword;

   Pu_int64_t = ^u_int64_t;
   u_int64_t = Tuint64;

function getpid:pid_t;cdecl;external libc_nlm name 'getpid';
function getppid:pid_t;cdecl;external libc_nlm name 'getppid';
function getuid:uid_t;cdecl;external libc_nlm name 'getuid';
function geteuid:uid_t;cdecl;external libc_nlm name 'geteuid';
function getgid:gid_t;cdecl;external libc_nlm name 'getgid';
function getegid:gid_t;cdecl;external libc_nlm name 'getegid';
function setuid(uid:uid_t):longint;cdecl;external libc_nlm name 'setuid';
function setgid(gid:gid_t):longint;cdecl;external libc_nlm name 'setgid';
function getpgrp:pid_t;cdecl;external libc_nlm name 'getpgrp';
function setsid:pid_t;cdecl;external libc_nlm name 'setsid';
function setpgid(pid:pid_t; pgid:pid_t):longint;cdecl;external libc_nlm name 'setpgid';

function FpGetpid:pid_t;cdecl;external libc_nlm name 'getpid';
function FpGetppid:pid_t;cdecl;external libc_nlm name 'getppid';
function FpGetuid:uid_t;cdecl;external libc_nlm name 'getuid';
function FpGeteuid:uid_t;cdecl;external libc_nlm name 'geteuid';
function FpGetgid:gid_t;cdecl;external libc_nlm name 'getgid';
function FpGetegid:gid_t;cdecl;external libc_nlm name 'getegid';
function FpSetuid(uid:uid_t):longint;cdecl;external libc_nlm name 'setuid';
function FpSetgid(gid:gid_t):longint;cdecl;external libc_nlm name 'setgid';
function FpSetpgrp:pid_t;cdecl;external libc_nlm name 'getpgrp';
function FpSetsid:pid_t;cdecl;external libc_nlm name 'setsid';
function FpSetpgid(pid:pid_t; pgid:pid_t):longint;cdecl;external libc_nlm name 'setpgid';


// sys/unistd.h

type
  TFilDes = Array [0..1] of cInt;
  pFilDes = ^TFilDes;

  const
     R_OK = 1;
  { test for write permission                  }
     W_OK = 2;
  { test for execute permission                }
     X_OK = 4;
  { test for existence of file                 }
     F_OK = 8;
  { values for 'whence' in lseek()...                                  }
  { set file pointer to 'offset'               }
    // SEEK_SET = 0;
  { set file pointer to current plus 'offset'  }
     // SEEK_CUR = 1;
  { set file pointer to EOF plus 'offset'      }
     // SEEK_END = 2;
  { old Berkeley names...                                              }
     L_SET = SEEK_SET;
     L_INCR = SEEK_CUR;
     L_XTND = SEEK_END;
  { test using effective ids                   }
     EFF_ONLY_OK = 8;
  { descriptor underlying 'stdin'              }
     STDIN_FILENO = 0;
  { ibid for 'stdout'                          }
     STDOUT_FILENO = 1;
  { ibid for 'stderr'                          }
     STDERR_FILENO = 2;
     _POSIX_THREAD_SAFE_FUNCTIONS = 1;
     _POSIX_THREAD_ATTR_STACKADDR = 1;
     _POSIX_THREAD_ATTR_STACKSIZE = 1;
     _POSIX_MAPPED_FILES = 1;
     _POSIX_MEMLOCK = 1;
     _POSIX_MEMLOCK_RANGE = 1;
     _POSIX_MEMORY_PROTECTION = 1;
     _POSIX_SYNCHRONIZED_IO = 1;
     _POSIX_FSYNC = 1;
     _POSIX_ASYNC_IO = -(1);
     _POSIX_CHOWN_RESTRICTED = -(1);
     _POSIX_NO_TRUNC = -(1);
     _POSIX_PRIO_IO = -(1);
     _POSIX_SYNC_IO = 1;
     _POSIX_VDISABLE = 0;


function access(path:Pchar; mode:longint):longint;cdecl;external libc_nlm name 'access';
function FpAccess(path:Pchar; mode:longint):longint;cdecl;external libc_nlm name 'access';
function alarm(seconds:dword):dword;cdecl;external libc_nlm name 'alarm';
function FpChdir(path:Pchar):longint;cdecl;external libc_nlm name 'chdir';
function {$ifdef INCLUDED_FROM_SYSTEM}libc_chsize{$else}chsize{$endif}(fildes:longint; size:size_t):longint;cdecl;external libc_nlm name 'chsize';
function FpChsize(fildes:longint; size:size_t):longint;cdecl;external libc_nlm name 'chsize';
function FpClose(fildes:longint):longint;cdecl;external libc_nlm name 'close';
function crypt(key:Pchar; salt:Pchar):Pchar;cdecl;external libc_nlm name 'crypt';
function dup(fildes:longint):longint;cdecl;external libc_nlm name 'dup';
function Fpdup(fildes:longint):longint;cdecl;external libc_nlm name 'dup';
function dup2(fildes1:longint; fildes2:longint):longint;cdecl;external libc_nlm name 'dup2';
function Fpdup2(fildes1:longint; fildes2:longint):longint;cdecl;external libc_nlm name 'dup2';
type TArr064char = array [0..63] of char;
procedure encrypt(block:TArr064char; edflag:longint);cdecl;external libc_nlm name 'encrypt';
procedure _exit(status:longint);cdecl;external libc_nlm name '_exit';
procedure FpExit(status:longint);cdecl;external libc_nlm name '_exit';
function fchdir(fildes:longint):longint;cdecl;external libc_nlm name 'fchdir';
function fdatasync(fildes:longint):longint;cdecl;external libc_nlm name 'fdatasync';
function fork:pid_t;cdecl;external libc_nlm name 'fork';
function fsync(fildes:longint):longint;cdecl;external libc_nlm name 'fsync';
function fpathconf(fildes:longint; name:longint):longint;cdecl;external libc_nlm name 'fpathconf';
function ftruncate(fildes:longint; len:off_t):longint;cdecl;external libc_nlm name 'ftruncate';
function getcwd(path:Pchar; len:size_t):Pchar;cdecl;external libc_nlm name 'getcwd';
function gethostid:longint;cdecl;external libc_nlm name 'gethostid';
(* Const before declarator ignored *)

function getopt(argc:longint; argv:array of Pchar; optstr:Pchar):longint;cdecl;external libc_nlm name 'getopt';
{$ifndef DisableArrayOfConst}
function Fpioctl(_para1:longint; _para2:longint; args:array of const):longint;cdecl;external libc_nlm name 'ioctl';
{$endif}
function Fpioctl(_para1:longint; _para2:longint):longint;cdecl;external libc_nlm name 'ioctl';
function Fpisatty(fildes:longint):longint;cdecl;external libc_nlm name 'isatty';
//function lseek(fildes:longint; offset:off_t; whence:longint):off_t;cdecl;external libc_nlm name 'lseek';
function fplseek(fildes:longint; offset:off_t; whence:longint):off_t;cdecl;external libc_nlm name 'lseek';

function pathconf(path:Pchar; name:longint):longint;cdecl;external libc_nlm name 'pathconf';
//!!function pipe(fildes:array[0..1] of longint):longint;cdecl;external libc_nlm name 'pipe';
function FpPipe(var fildes:TFilDes):cInt;cdecl;external libc_nlm name 'pipe';
function pread(fildes:longint; buf:pointer; nbytes:size_t; off:off_t):ssize_t;cdecl;external libc_nlm name 'pread';
function pwrite(fildes:longint; buf:pointer; nbytes:size_t; off:off_t):ssize_t;cdecl;external libc_nlm name 'pwrite';
function FpRead(fildes:longint; buf:pointer; nbytes:size_t):ssize_t;cdecl;external libc_nlm name 'read';
function FpRead(fildes:longint; var buf; nbytes:size_t):ssize_t;cdecl;external libc_nlm name 'read';
function Fprmdir(path:Pchar):longint;cdecl;external libc_nlm name 'rmdir';
procedure sync;cdecl;external libc_nlm name 'sync';
function sysconf(name:longint):longint;cdecl;external libc_nlm name 'sysconf';
function unlink(path:Pchar):longint;cdecl;external libc_nlm name 'unlink';
function FpUnlink(path:Pchar):longint;cdecl;external libc_nlm name 'unlink';
function FpWrite(fildes:longint; buf:pointer; nbytes:size_t):ssize_t;cdecl;external libc_nlm name 'write';
function FpWrite(fildes:longint; var buf; nbytes:size_t):ssize_t;cdecl;external libc_nlm name 'write';
{ appeared in BSD...  }
function brk(endds:pointer):longint;cdecl;external libc_nlm name 'brk';
function getdtablehi:longint;cdecl;external libc_nlm name 'getdtablehi';
function getdtablesize:longint;cdecl;external libc_nlm name 'getdtablesize';
function getpagesize:longint;cdecl;external libc_nlm name 'getpagesize';

function readlink(path:Pchar; buf:Pchar; bufsize:size_t):longint;cdecl;external libc_nlm name 'readlink';
function FpReadlink(path:Pchar; buf:Pchar; bufsize:size_t):longint;cdecl;external libc_nlm name 'readlink';
function sbrk(incr:intptr_t):pointer;cdecl;external libc_nlm name 'sbrk';
{ nonstandard additions (see also fsio.h)...  }
function cancel(t_id:longint):longint;cdecl;external libc_nlm name 'cancel';
function confstr(name:longint; buf:Pchar; len:size_t):size_t;cdecl;external libc_nlm name 'confstr';
function delay(milliseconds:dword):longint;cdecl;external libc_nlm name 'delay';
function _delay(milliseconds:dword):longint;cdecl;external libc_nlm name 'delay';
function sethostid(hostid:longint):longint;cdecl;external libc_nlm name 'sethostid';
function setmode(fildes:longint; oflag:longint):longint;cdecl;external libc_nlm name 'setmode';
function sleep(seconds:dword):dword;cdecl;external libc_nlm name 'sleep';
function FpSleep(seconds:dword):dword;cdecl;external libc_nlm name 'sleep';
function usleep(useconds:useconds_t):longint;cdecl;external libc_nlm name 'usleep';
{ nonstandard (transitional) addtions for 64-bit file I/O...  }
function chsize64(fildes:longint; size:size64_t):longint;cdecl;external libc_nlm name 'chsize64';
function Fpchsize64(fildes:longint; size:size64_t):longint;cdecl;external libc_nlm name 'chsize64';
function ftruncate64(fildes:longint; len:off64_t):longint;cdecl;external libc_nlm name 'ftruncate64';
function Fpftruncate64(fildes:longint; len:off64_t):longint;cdecl;external libc_nlm name 'ftruncate64';
function lseek64(fildes:longint; offset:off64_t; whence:longint):off64_t;cdecl;external libc_nlm name 'lseek64';
function Fplseek64(fildes:longint; offset:off64_t; whence:longint):off64_t;cdecl;external libc_nlm name 'lseek64';
function pread64(fildes:longint; buf:pointer; nbytes:size_t; off:off64_t):ssize_t;cdecl;external libc_nlm name 'pread64';
function pwrite64(fildes:longint; buf:pointer; nbytes:size_t; off:off64_t):ssize_t;cdecl;external libc_nlm name 'pwrite64';
function tell64(fildes:longint):off64_t;cdecl;external libc_nlm name 'tell64';
function Fptell64(fildes:longint):off64_t;cdecl;external libc_nlm name 'tell64';
function ____environ:PPPchar;cdecl;external libc_nlm name '____environ';
function ___optarg:PPchar;cdecl;external libc_nlm name '___optarg';
function ___optind:Plongint;cdecl;external libc_nlm name '___optind';
function ___opterr:Plongint;cdecl;external libc_nlm name '___opterr';
function ___optopt:Plongint;cdecl;external libc_nlm name '___optopt';
function ___optreset:Plongint;cdecl;external libc_nlm name '___optreset';
function want_posix_semantics(timestamp:longint):longint;cdecl;external libc_nlm name 'want_posix_semantics';
{
** Prototype for libraries writing their own start-up and shut-down code. This
** is not an interface, but only a prototype for code furnished by the UNIX-
** style NLM library. The presence of these is noted by the prelude object.
 }
function _init:longint;cdecl;external libc_nlm name '_init';
function _fini:longint;cdecl;external libc_nlm name '_fini';
{ globals for getopt() implementation...  }
{ the prototype for ioctl() is in unistd.h...  }


// sys/byteorder.h
function htonl(_para1:dword):dword;cdecl;external libc_nlm name 'htonl';
function htons(_para1:word):word;cdecl;external libc_nlm name 'htons';
function ntohl(_para1:dword):dword;cdecl;external libc_nlm name 'ntohl';
function ntohs(_para1:word):word;cdecl;external libc_nlm name 'ntohs';


// sys/cdefs.h
// sys/dir.h
// dirent.h
// sys/mode.h

{ POSIX file types...  }
{ POSIX file modes: owner (user) permission...  }
{ POSIX file modes: group permission...  }
{ POSIX file modes: other permission...  }
{ POSIX setuid(), setgid(), and sticky...  }
{ for use with stat(), readdir(), chmod(), mkdir(), etc.  }
{ NetWare-specific additions to the upper half of mode_t...  }
{ values for field 'd_type'...  }

{ pshpack1.h }
{ turn on 1-byte packing...  }

  const
     S_IFMT = $F000;
  { first-in/first-out (FIFO/pipe)            }
     S_IFIFO = $1000;
  { character-special file (tty/console)      }
     S_IFCHR = $2000;
  { directory                                 }
     S_IFDIR = $4000;
  { blocking device (unused)                  }
     S_IFBLK = $6000;
  { regular                                   }
     S_IFREG = $8000;
  { symbolic link (unused)                    }
     S_IFLNK = $A000;
  { Berkeley socket                           }
     S_IFSOCK = $C000;
     S_IRWXU = $01C0;
     S_IRUSR = $0100;
     S_IWUSR = $0080;
     S_IXUSR = $0040;
     S_IREAD = S_IRUSR;
     S_IWRITE = S_IWUSR;
     S_IEXEC = S_IXUSR;
  { POSIX file modes: group permission...  }
     S_IRWXG = $0038;
     S_IRGRP = $0020;
     S_IWGRP = $0010;
     S_IXGRP = $0008;
  { POSIX file modes: other permission...  }
     S_IRWXO = $0007;
     S_IROTH = $0004;
     S_IWOTH = $0002;
     S_IXOTH = $0001;
  { POSIX setuid(), setgid(), and sticky...  }
     S_ISUID = $0800;
     S_ISGID = $0400;
     S_ISVTX = $0200;
  { for use with stat(), readdir(), chmod(), mkdir(), etc.  }
  { NetWare-specific additions to the upper half of mode_t...  }
     M_A_RDONLY          = $00010000;    // read-only entry
     M_A_HIDDEN          = $00020000;    // hidden entry
     M_A_SYSTEM          = $00040000;    // system entry
     M_A_SUBDIR          = $00080000;    // is Subdir
     M_A_ARCH            = $00100000;    // file has been archived
     M_A_SHARE           = $00200000;    // file is shared
     M_A_TRANS           = $00400000;    // file transactions are tracked
     M_A_IMMPURG         = $00800000;    // purge deleted file immediately
     M_A_NORENAM         = $01000000;    // inhibit renaming
     M_A_NODELET         = $02000000;    // inhibit deletion
     M_A_NOCOPY          = $04000000;    // inhibit copying
     M_A_IMMCOMPRESS     = $08000000;    // compress immediately
     M_A_FILE_COMPRESSED = $10000000;    // file is compressed
     M_A_DONT_COMPRESS   = $20000000;    // inhibit compression
     M_A_CANT_COMPRESS   = $40000000;    // file cannot be compressed
     M_A_BITS_SIGNIFICANT= $80000000;    // these M_A_- bits are important

     DT_UNKNOWN = 0;
     DT_TTY = 1;           { console (won't occur) }
     DT_REG = S_IFREG;     { normal file }
     DT_DIR = S_IFDIR;     { subdirectory }
     DT_FIFO = S_IFIFO;    { first-in/first-out (FIFO/pipe) }
     DT_SOCK = S_IFSOCK;   { socket (won't occur) }
     DT_CHR = S_IFCHR;     { character-special file (unused)}
     DT_BLK = S_IFBLK;     { blocking device (unused) }
     DT_LNK = S_IFLNK;     { symbolic or hard link (won't occur) }

type
   Pdirent = ^Tdirent;
   Tdirent = record
        d_userspec : dword;
        d_flags    : dword;
        d_type     : mode_t;
        d_mode     : mode_t;
        d_ino      : ino_t;
        d_size     : off64_t;
        d_spare    : array[0..54] of dword;
        d_pad1     : byte;
        d_pad2     : byte;
        d_pad3     : byte;
        d_namelen  : byte;
        d_name     : array[0..(255 + 1)-1] of char;
     end;
    PPdirent = ^Pdirent;
   //DIR = dirent;
   //PDIR = ^DIR;
   //TDir = Dir;
{ sizeof(struct dirent) == 0x200 (512.)  }

(** unsupported pragma#pragma pack()*)


function closedir(dirp:Pdirent):longint;cdecl;external libc_nlm name 'closedir';
function opendir(pathName:Pchar):Pdirent;cdecl;external libc_nlm name 'opendir';
function readdir(dirp:Pdirent):Pdirent;cdecl;external libc_nlm name 'readdir';
function readdir_r(dirp:Pdirent; entry:Pdirent; result:PPdirent):longint;cdecl;external libc_nlm name 'readdir_r';
procedure rewinddir(dirp:Pdirent);cdecl;external libc_nlm name 'rewinddir';

function Fpclosedir(dirp:Pdirent):longint;cdecl;external libc_nlm name 'closedir';
function Fpopendir(pathName:Pchar):Pdirent;cdecl;external libc_nlm name 'opendir';
function Fpreaddir(dirp:Pdirent):Pdirent;cdecl;external libc_nlm name 'readdir';
function Fpreaddir_r(dirp:Pdirent; entry:Pdirent; result:PPdirent):longint;cdecl;external libc_nlm name 'readdir_r';
procedure Fprewinddir(dirp:Pdirent);cdecl;external libc_nlm name 'rewinddir';

// sys/file.h
// fcntl.h

{ 'cmd' values for fcntl()...                                               }
const
 F_GETFL      = 1;        // get file status flags
 F_SETFL      = 2;        // set file status flags
 F_DUPFD      = 3;        // duplicate file descriptor
 F_GETFD      = 4;        // get file descriptor flags
 F_SETFD      = 5;        // set file descriptor flags
 F_SETLK      = 6;        // set record locking info
 F_SETLK64    = 16;       // set record locking info (64-bit)
 F_GETLK      = 7;        // get record locking info
 F_GETLK64    = 17;       // get record locking info (64-bit)
 F_SETLKW     = 8;        // get record locking info; wait if blocked
 F_SETLKW64   = 18;       // get record locking info (64-bit)
 F_CLOEXEC    = 9;        // close on execute

// values for 'l_type' field of 'struct flock'...
 F_RDLCK      = 1;        // shared or read lock
 F_WRLCK      = 2;        // exclusive or write lock
 F_UNLCK      = 3;        // unlock

// values for 'oflag' in open()...
 O_RDONLY     =$00000000; // open for read only
 O_WRONLY     =$00000001; // open for write only
 O_RDWR       =$00000002; // open for read and write
 O_ACCMODE    =$00000003; // access flags mask
 O_reserved1  =$00000004; // reserved
 O_reserved2  =$00000008; // reserved
 O_APPEND     =$00000010; // writes done at end of file
 O_CREAT      =$00000020; // create new file
 O_TRUNC      =$00000040; // truncate existing file
 O_EXCL       =$00000080; // exclusive open
 O_NOCTTY     =$00000100; // no controlling terminal--unsupported
 O_BINARY     =$00000200; // binary file--all files
 O_NDELAY     =$00000400; // nonblocking flag
 O_reserved3  =$00000800; // reserved
 O_SYNC       =$00001000; // synchronized I/O file integrity
 O_DSYNC      =$00002000; // synchronized I/O data integrity
 O_RSYNC      =$00004000; // synchronized read I/O
 O_NONBLOCK   = O_NDELAY; // alias
 FD_CLOEXEC   =$00008000; // parent closes after call to process()
 O_UPDATE     =$00010000; // keep legacy files updated
 O_FIFO       =$00100000; // opening one end of a FIFO [non-standard]

// value for third argument when 'cmd' is F_SETFL in fcntl()...
 FNDELAY      = O_NDELAY;   // fcntl() non-blocking I/O

// 'shflag' values for sopen()...
 SH_DENYRW    = $00000010; // deny read/write mode
 SH_DENYWR    = $00000020; // deny write mode
 SH_DENYRD    = $00000030; // deny read mode
 SH_DENYNO    = $00000040; // deny none mode

type
   Pflock = ^flock;
   flock = record
        l_pid : pid_t;                { process ID of owner, get with F_GETLK       }
        l_tid : pid_t;                { thread ID of owner, get with F_GETLK        }
        l_type : smallint;            { F_RDLCK or F_WRLCK                          }
        l_whence : smallint;          { flag for starting offset                    }
        ________spare : longint;      { unused                                      }
        ________reserved1 : longint;  { padding to resemble 64-bit structure        }
        l_start : off_t;              { relative offset in bytes                    }
        ________reserved2 : longint;  { padding to resemble 64-bit structure        }
        l_len : off_t;                { size; if 0, then until EOF                  }
     end;

   Pflock64 = ^flock64;
   flock64 = record                   { with F_GETLK64, F_SETLK64, FSETLKW64        }
        l_pid : pid_t;                { process ID of owner, get with F_GETLK       }
        l_tid : pid_t;                { thread ID of owner, get with F_GETLK        }
        l_type : smallint;            { F_RDLCK or F_WRLCK                          }
        l_whence : smallint;          { flag for starting offset                    }
        ________spare : longint;      { unused                                      }
        l_start : off64_t;            { relative offset in bytes                    }
        l_len : off64_t;              { size; if 0, then until EOF                  }
     end;

function creat(path:Pchar; mode:mode_t):longint;cdecl;external libc_nlm name 'creat';
{$ifndef DisableArrayOfConst}
function fcntl(fildes:longint; cmd:longint; args:array of const):longint;cdecl;external libc_nlm name 'fcntl';
{$endif}
function fcntl(fildes:longint; cmd:longint):longint;cdecl;external libc_nlm name 'fcntl';
{$ifndef DisableArrayOfConst}
function open(path:Pchar; oflag:longint; args:array of const):longint;cdecl;external libc_nlm name 'open';
{$endif}
function open(path:Pchar; oflag:longint):longint;cdecl;external libc_nlm name 'open';
function open(path:Pchar; oflag,mode:longint):longint;cdecl;external libc_nlm name 'open';
function FpOpen(path:Pchar; oflag:longint):longint;cdecl;external libc_nlm name 'open';
function FpOpen(path:Pchar; oflag,mode:longint):longint;cdecl;external libc_nlm name 'open';

function pipe_open(path:Pchar; oflag:longint):longint;cdecl;external libc_nlm name 'pipe_open';
function pipe_open(path:Pchar; oflag,mode:longint):longint;cdecl;external libc_nlm name 'pipe_open';
{$ifndef DisableArrayOfConst}
function sopen(path:Pchar; oflag:longint; shflag:longint; args:array of const):longint;cdecl;external libc_nlm name 'sopen';
{$endif}
function sopen(path:Pchar; oflag:longint; shflag:longint):longint;cdecl;external libc_nlm name 'sopen';


// sys/filio.h
{ defines for ioctl()...  }
// sys/ipc.h

{ mode bits...  }
{ keys...  }
{ control commands for semctl() and shmctl()...  }
type
   Pkey_t = ^key_t;
   key_t = longint;
   Pipc_perm = ^ipc_perm;
   ipc_perm = record
        uid  : uid_t;    // owner
        gid  : gid_t;    // owner
        cuid : uid_t;    // creator
        cgid : gid_t;    // creator
        mode : mode_t;   // read write permission
     end;



function ftok(path:Pchar; id:longint):key_t;cdecl;external libc_nlm name 'ftok';


// sys/mman.h

{ return value of mmap() in case of error...  }
{ 'flags' values for mlockall()...  }
{ 'protection' values for mmap()...  }
{ 'flags' values for mmap()...  }
{ 'flags' values for msync()...  }
{ 'advice' to madvice()...  }
{ effectual dummies that will never do anything...  }

function mlock(addr:pointer; len:size_t):longint;cdecl;external libc_nlm name 'mlock';
function mlockall(flags:longint):longint;cdecl;external libc_nlm name 'mlockall';
function munlock(addr:pointer; len:size_t):longint;cdecl;external libc_nlm name 'munlock';
function munlockall:longint;cdecl;external libc_nlm name 'munlockall';
function mprotect(addr:pointer; len:size_t; prot:longint):longint;cdecl;external libc_nlm name 'mprotect';
function madvise(addr:pointer; len:size_t; advice:longint):longint;cdecl;external libc_nlm name 'madvise';



// sys/param.h
// sys/stat.h
// time.h
type

   Pclock_t = ^clock_t;
   clock_t = dword;
   TClock  = clock_t;

   Ptime_t = ^time_t;
   time_t = longint;
   Ttime  = time_t;

{ turn on 1-byte packing...  }

type
   Ptm = ^Ttm;
   Ttm = record                // ANSI/ISO 'broken-down' time
        tm_sec   : longint;    // seconds after the minute [0..59]
        tm_min   : longint;    // minutes after the hour [0..59]
        tm_hour  : longint;    // hours since midnight [0..23]
        tm_mday  : longint;    // days of the month [1..31]
        tm_mon   : longint;    // months since January [0..11]
        tm_year  : longint;    // years since 1900 [0..ì]
        tm_wday  : longint;    // days since Sunday [0..6]
        tm_yday  : longint;    // days since first of January [0..365]
        tm_isdst: longint;    // on summer time (-1 unknown, 0 no, !0 yes)
     end;

   Ptimespec = ^Ttimespec;
   Ttimespec = record        // time expressed in seconds and nanoseconds
        tv_sec  : time_t;    // seconds
        tv_nsec : longint;   // nanoseconds
     end;
   timespec_t = Ttimespec;
   Ptimespec_t = ^timespec_t;
   timestrc_t = Ttimespec;
   Ptimestrc_t = ^timestrc_t;

   Pitimerspec = ^Titimerspec;
   Titimerspec = record
        it_interval : Ttimespec;  // timer period
        it_value    : Ttimespec;  // expiration
     end;
   itimerspec_t = Titimerspec;
   Pitimerspec_t = ^itimerspec_t;
{ DOS 'broken-down' time                     }
{ two-second increments only                 }
{ 0-59                                       }
{ 0-23                                       }
{ 1-31                                       }
{ 1-12                                       }
{ years since 1980 (limit: 0-119)            }
   Pdos_tm = ^Tdos_tm;
   Tdos_tm = record
        flag0 : longint;
     end;


const
   bm_dos_tm_bisecond = $1F;
   bp_dos_tm_bisecond = 0;
   bm_dos_tm_minute = $7E0;
   bp_dos_tm_minute = 5;
   bm_dos_tm_hour = $F800;
   bp_dos_tm_hour = 11;
   bm_dos_tm_day = $1F0000;
   bp_dos_tm_day = 16;
   bm_dos_tm_month = $1E00000;
   bp_dos_tm_month = 21;
   bm_dos_tm_year = $FE000000;
   bp_dos_tm_year = 25;

{$ifndef INCLUDED_FROM_SYSTEM}
function bisecond(var a : Tdos_tm) : word;
procedure set_bisecond(var a : Tdos_tm; __bisecond : word);
function minute(var a : Tdos_tm) : word;
procedure set_minute(var a : Tdos_tm; __minute : word);
function hour(var a : Tdos_tm) : word;
procedure set_hour(var a : Tdos_tm; __hour : word);
function day(var a : Tdos_tm) : word;
procedure set_day(var a : Tdos_tm; __day : word);
function month(var a : Tdos_tm) : word;
procedure set_month(var a : Tdos_tm; __month : word);
function year(var a : Tdos_tm) : word;
procedure set_year(var a : Tdos_tm; __year : word);
{$endif}


type
   Pdos_d = ^Tdos_d;
   Tdos_d = packed record   // DOS date separated from time
        time : word;        // time fields
        date : word;        // date fields
     end;

{ utility for passing DOS time               }
{ scalar for passing as argument             }
{ separated-out DOS time and date            }
{ broken-down DOS time and date              }
   Pdos_tm_u = ^Tdos_tm_u;
   Tdos_tm_u = record
       case longint of
          0 : ( long_dt : dword );
          1 : ( struct_dt : Tdos_d );
          2 : ( struct_tm : Tdos_tm );
       end;

(** unsupported pragma#pragma pack()*)


function asctime(localtime:Ptm):Pchar;cdecl;external libc_nlm name 'asctime';
function asctime(var localtime:Ttm):Pchar;cdecl;external libc_nlm name 'asctime';
function clock:clock_t;cdecl;external libc_nlm name 'clock';
function ctime(calendar:Ptime_t):Pchar;cdecl;external libc_nlm name 'ctime';
function ctime(var calendar:Ttime):Pchar;cdecl;external libc_nlm name 'ctime';
function difftime(t1, t2:Ttime):double;cdecl;external libc_nlm name 'difftime';
function gmtime(calendar:Ptime_t):Ptm;cdecl;external libc_nlm name 'gmtime';
function gmtime(var calendar:Ttime):Ptm;cdecl;external libc_nlm name 'gmtime';
function localtime(calendar:Ptime_t):Ptm;cdecl;external libc_nlm name 'localtime';
function localtime(var calendar:Ttime):Ptm;cdecl;external libc_nlm name 'localtime';
function mktime(localtime:Ptm):time_t;cdecl;external libc_nlm name 'mktime';
function mktime(var localtime:Ttm):time_t;cdecl;external libc_nlm name 'mktime';

//size_t strftime ( char * __restrict s, size_t, const char * __restrict format,
//size_t strftime ( char * __restrict s, size_t, const char * __restrict format,
//                      const tm * __restrict localtime );

function time(calendar:Ptime_t):time_t;cdecl;external libc_nlm name 'time';
function time(var calendar:Ttime):time_t;cdecl;external libc_nlm name 'time';
function ___clocks_per_sec:longint;cdecl;external libc_nlm name '___clocks_per_sec';
{ POSIX data and helper functions...  }
function ___daylight:Plongint;cdecl;external libc_nlm name '___daylight';
function ___daylightOnOff:Plongint;cdecl;external libc_nlm name '___daylightOnOff';
function ___daylightOffset:Ptime_t;cdecl;external libc_nlm name '___daylightOffset';
function ___timezone:Ptime_t;cdecl;external libc_nlm name '___timezone';
function ___tzname:PPchar;cdecl;external libc_nlm name '___tzname';
function __isleap(year:longint):longint;cdecl;external libc_nlm name '__isleap';
procedure tzset;cdecl;external libc_nlm name 'tzset';
{ POSIX-defined reentrant additions...  }

function asctime_r(localtime:Ptm; timestr:Pchar):Pchar;cdecl;external libc_nlm name 'asctime_r';
function asctime_r(var localtime:Ttm; timestr:Pchar):Pchar;cdecl;external libc_nlm name 'asctime_r';
function ctime_r(calendar:Ptime_t; timestr:Pchar):Pchar;cdecl;external libc_nlm name 'ctime_r';
function ctime_r(var calendar:Ttime; timestr:Pchar):Pchar;cdecl;external libc_nlm name 'ctime_r';
function gmtime_r(calendar:Ptime_t; localtime:Ptm):Ptm;cdecl;external libc_nlm name 'gmtime_r';
function gmtime_r(var calendar:Ttime; localtime:Ptm):Ptm;cdecl;external libc_nlm name 'gmtime_r';
function localtime_r(calendar:Ptime_t; localtime:Ptm):Ptm;cdecl;external libc_nlm name 'localtime_r';
function localtime_r(var calendar:Ttime; var localtime:Ttm):Ptm;cdecl;external libc_nlm name 'localtime_r';
{ Single UNIX Specification additions...  }
function nanosleep(rqtp, rmtp:Ptimespec):longint;cdecl;external libc_nlm name 'nanosleep';
function nanosleep(var rqtp, rmtp:Ttimespec):longint;cdecl;external libc_nlm name 'nanosleep';
{ Novell-defined additions...  }
function ltime(calendar:Ptime_t):time_t;cdecl;external libc_nlm name 'ltime';
function ltime(var calendar:Ttime):time_t;cdecl;external libc_nlm name 'ltime';
function mkgmtime(gmtime:Ptm):time_t;cdecl;external libc_nlm name 'mkgmtime';
function mkgmtime(var gmtime:Ttm):time_t;cdecl;external libc_nlm name 'mkgmtime';
function dos2calendar(dostime:Tdos_d):time_t;cdecl;external libc_nlm name 'dos2calendar';
function calendar2dos(calendar:time_t):Tdos_d;cdecl;external libc_nlm name 'calendar2dos';


// sys/time.h
// sys/timeval.h
// sys/times.h

type
   Ptms = ^Ttms;
   Ttms = record                        { describes CPU time used by process, children  }
        tms_utime  : clock_t;           { user CPU time }
        tms_stime  : clock_t;           { system CPU time (identical to 'tms_utime')    }
        tms_cutime : clock_t;           { unimplemented }
        tms_cstime : clock_t;           { unimplemented }
     end;

   Ptimezone = ^Ttimezone;
   TTimezone = record                   { returned by gettimeofday() }
        tz_secondswest : time_t;        { seconds west of UTC }
        tz_minuteswest : longint;       { minutes west of UTC (GMT) }
        tz_dsttime     : longint;       { nonzero if DST is ever in effect }
     end;
   Timezone = TTimezone;

{
** Normally this functions fills struct tms with several time values. Most of
** the time it is very important to have only the return value, that is the
** realtime that has been elapsed.
 }

function times(__buffer:Ptms):clock_t;cdecl;external libc_nlm name 'times';
function times(var __buffer:Ttms):clock_t;cdecl;external libc_nlm name 'times';
{ turn on 1-byte packing...  }

{ this structure is returned by gettimeofday() and used in select()...  }
type
   Ptimeval = ^Ttimeval;
   Ttimeval = record
        tv_sec  : longint;
        tv_usec : longint;
     end;
   Timeval = TTimeval;

(** unsupported pragma#pragma pack()*)
{ operations on struct timeval; note timercmp() does not work for >= or <=  }

function gettimeofday(tp:Ptimeval; tpz:Ptimezone):longint;cdecl;external libc_nlm name 'gettimeofday';
function Fpgettimeofday(tp:Ptimeval; tpz:Ptimezone):longint;cdecl;external libc_nlm name 'gettimeofday';
function settimeofday(tp:Ptimeval; tpz:Ptimezone):longint;cdecl;external libc_nlm name 'settimeofday';
function gettimeofday(var tp:Ttimeval; var tpz:Ttimezone):longint;cdecl;external libc_nlm name 'gettimeofday';
function settimeofday(var tp:Ttimeval; var tpz:Ttimezone):longint;cdecl;external libc_nlm name 'settimeofday';
function Fpgettimeofday(var tp:Ttimeval; var tpz:Ttimezone):longint;cdecl;external libc_nlm name 'gettimeofday';
function Fpsettimeofday(var tp:Ttimeval; var tpz:Ttimezone):longint;cdecl;external libc_nlm name 'settimeofday';

{ turn on 1-byte packing...  }
type
   Pstat = ^Tstat;
   Tstat = record
        st_userspec: dword;                         // untouched by stat()
        st_flags   : dword;                         // flags for this entry
        st_mode    : mode_t;                        // emulated file mode
        st_spare1  : dword;
        st_gen     : Tuint64;                       // generation number of inode
        st_ino     : ino_t;                         // directory entry number
        st_dev     : dev_t;                         // volume number
        st_rdev    : dev_t;                         // device type (always 0)
        st_size    : off64_t;                       // total file size
        st_spare2  : Tuint64;
        st_blocks  : blkcnt_t;                      // count of blocks allocated to file
        st_blksize : blksize_t;                     // block size for allocation--files only
        st_nlink   : nlink_t;                       // count of hard links (always 1)
        st_spare3  : array[0..2] of dword;
        st_uid     : uid_t;                         // owner (object) identity
        st_gid     : gid_t;                         // group-id (always 0)
        st_bid     : uid_t;                         // identity of last archiver
        st_mid     : uid_t;                         // identity of last updator
        st_atim    : timespec_t;                    // last access date--files only
        st_mtim    : timespec_t;                    // last modify date and time
        st_ctim    : timespec_t;                    // last file attributes modification
        st_btim    : timespec_t;                    // last archived date and time
                                                    // NOT returned by stat() or fstat()...
        st_rights  : dword;                         // NetWare rights
        st_spare4  : array[0..2] of dword;
        st_name    : array[0..(255 + 1)-1] of char; // object name as if from readdir()
        st_spare5  : array[0..19] of dword;
     end;

{ sizeof(struct stat) == 0x200 (512.)      }

(** unsupported pragma#pragma pack()*)


function Fpchmod(path:Pchar; mode:mode_t):longint;cdecl;external libc_nlm name 'chmod';
function Fpfchmod(fildes:longint; mode:mode_t):longint;cdecl;external libc_nlm name 'fchmod';
function Fpfstat(fildes:longint; buf:Pstat):longint;cdecl;external libc_nlm name 'fstat';
function Fpfstat(fildes:longint; var buf:Tstat):longint;cdecl;external libc_nlm name 'fstat';
function Fplstat(path:Pchar; buf:Pstat):longint;cdecl;external libc_nlm name 'lstat';
function Fplstat(path:Pchar; var buf:Tstat):longint;cdecl;external libc_nlm name 'lstat';
function Fpmkdir(pathname:Pchar; mode:mode_t):longint;cdecl;external libc_nlm name 'mkdir';
function Fpmkfifo(pathname:Pchar; mode:mode_t):longint;cdecl;external libc_nlm name 'mkfifo';
function Fpmknod(path:Pchar; mode:mode_t; dev:dev_t):longint;cdecl;external libc_nlm name 'mknod';
function Fprealname(pathname:Pchar; name:Pchar):longint;cdecl;external libc_nlm name 'realname';
function Fpstat(path:Pchar; buf:Pstat):longint;cdecl;external libc_nlm name 'stat';
function Fpstat(path:Pchar; var buf:Tstat):longint;cdecl;external libc_nlm name 'stat';
function Fpumask(cmask:mode_t):mode_t;cdecl;external libc_nlm name 'umask';
{
** The following value is not really correct, but it is a value that has been
** used for a long time seems to be usable. Normally, NOFILE should not be used
** anyway.
 }
{ bit map related macros...   }
{ macros for counting and rounding...  }
{ supplementary macros for min/max...   }
{ unit of sys/stat.h `st_blocks'...   }


// sys/select.h

{
** Including file may make this bigger or smaller as long as the FD_- macros
** are faithfully used.
 }
type

   Pfd_set = ^Tfd_set;
   Tfd_set = record
        fd_count : longint;
        fd_array : array[0..63] of longint;
     end;
{ heterogeneous select calls (socket+pipe) unsupported on NetWare...  }


function Fppipe_select(nfds:longint; readfds, writefds, exceptfds:Pfd_set; timeout:Ptimeval):longint;cdecl;external libc_nlm name 'pipe_select';
function Fppipe_select(nfds:longint; var readfds, writefds, exceptfds:Tfd_set; var timeout:Ttimeval):longint;cdecl;external libc_nlm name 'pipe_select';

//function select(nfds:longint; readfds:Pfd_set; writefds:Pfd_set; exceptfds:Pfd_set; timeout:Ptimeval):longint;cdecl;external libc_nlm name 'select';
//function select(nfds:longint; var readfds, writefds, exceptfds:Tfd_set; var timeout:Ttimeval):longint;cdecl;external libc_nlm name 'select';
function FpSelect(nfds:longint; readfds:Pfd_set; writefds:Pfd_set; exceptfds:Pfd_set; timeout:Ptimeval):longint;cdecl;external libc_nlm name 'select';
function FpSelect(nfds:longint; var readfds, writefds, exceptfds:Tfd_set; var timeout:Ttimeval):longint;cdecl;external libc_nlm name 'select';
function ___fd_isset(fd:longint; _set:Pfd_set):longint;cdecl;external libc_nlm name '___fd_isset';
function ___fd_isset(fd:longint; var _set:Tfd_set):longint;cdecl;external libc_nlm name '___fd_isset';


// sys/sem.h

{ semctl() command definitions...  }
{ semaphore text map address        }
{ pid of last operation             }
{ count awaiting (semval > cval)    }
{ count awaiting (semval == 0)      }
type
   Psem = ^Tsem;
   Tsem = record
        semval  : ushort_t;
        semadj  : ushort_t;
        sempid  : pid_t;
        semncnt : ushort_t;
        semzcnt : ushort_t;
        semptr  : pointer;       // semaphore on which this is based
     end;
   TSemaphore = Tsem;
   PSemaphore = Psem;

   Psemid_ds = ^Tsemid_ds;
   Tsemid_ds = record
        sem_perm    : ipc_perm;
        sem_base    : Psem;       // pointer to first semaphore in set
        sem_nsems   : word;       // number of semaphores in set
        sem_otime   : time_t;     // last semop time
        sem_ctime   : time_t;     // last change time
        sem_ptr     : pointer;    // actual underlying semaphore
        sem_realkey : longint;    // 'real' semaphore key
     end;

   Psembuf = ^Tsembuf;
   Tsembuf = record
        sem_num : word;           // Number
        sem_op  : smallint;       // operation
        sem_flg : smallint;       // flags
     end;

   Psemun = ^Tsemun;
   Tsemun = record
       case longint of
          0 : ( val : longint );
          1 : ( buf : Psemid_ds );
          2 : ( _array : Pword );
       end;

{$ifndef DisableArrayOfConst}
function semctl(semid:longint; semnum:longint; cmd:longint; args:array of const):longint;cdecl;external libc_nlm name 'semctl';
{$endif}
function semctl(semid:longint; semnum:longint; cmd:longint):longint;cdecl;external libc_nlm name 'semctl';
function semget(key:key_t; nsems:longint; semflag:longint):longint;cdecl;external libc_nlm name 'semget';
function semop(semid:longint; sops:Psembuf; nsops:size_t):longint;cdecl;external libc_nlm name 'semop';
function semop(semid:longint; var sops:Tsembuf; nsops:size_t):longint;cdecl;external libc_nlm name 'semop';


// sys/sendfile.h

function sendfile(out_fd,in_fd:longint; offset:Poff_t; count:size_t):ssize_t;cdecl;external libc_nlm name 'sendfile';
function sendfile64(out_fd,in_fd:longint; offset:Poff64_t; count:size_t):ssize_t;cdecl;external libc_nlm name 'sendfile64';


// sys/shm.h

type

   Pshmatt_t = ^shmatt_t;
   shmatt_t = dword;
{ turn on 1-byte packing...  }

{ size of segment in bytes               }
{ process ID of last shared operation    }
{ process ID of creator                  }
{ number of current attaches             }
{ time of last shmat()                   }
{ time of last shmdt()                   }
{ time of last change by shmctl()        }
{ operation permission structure         }
type
   Pshmid_ds = ^shmid_ds;
   shmid_ds = record
        shm_segsz : size_t;
        shm_lpid : pid_t;
        shm_cpid : pid_t;
        shm_nattch : shmatt_t;
        shm_atime : time_t;
        shm_dtime : time_t;
        shm_ctime : time_t;
        shm_spare1 : longint;
        shm_perm : ipc_perm;
        shm_spare2 : array[0..2] of longint;
     end;

(** unsupported pragma#pragma pack()*)


function shmat(shmid:longint; shmaddr:pointer; shmflag:longint):pointer;cdecl;external libc_nlm name 'shmat';
function shmctl(shmid:longint; cmd:longint; buf:Pshmid_ds):longint;cdecl;external libc_nlm name 'shmctl';

function shmdt(shmaddr:pointer):longint;cdecl;external libc_nlm name 'shmdt';
function shmget(key:key_t; size:size_t; shmflag:longint):longint;cdecl;external libc_nlm name 'shmget';

// signal.h

    const
       SIGABRT = 1;
       SIGFPE = 2;
       SIGILL = 3;
       SIGINT = 4;
       SIGSEGV = 5;
       SIGTERM = 6;
       SIGPOLL = 7;
    { currently unimplemented POSIX-mandated signals  }
       SIGKILL  = 11;
       SIGSPARE = 12;
       SIGALRM  = 13;
       SIGCHILD = 14;
       SIGCHLD  = SIGCHILD;
       SIGCONT  = 15;
       SIGHUP   = 16;
       SIGPIPE  = 17;
       SIGQUIT  = 18;
       SIGSTOP  = 19;
       SIGTSTP  = 20;
       SIGTTIN  = 21;
       SIGTTOU  = 22;
       SIGUSR1  = 23;
       SIGUSR2  = 24;
       SIGUSR3  = 25;
       SIGUSR4  = 26;
       SIGUSR5  = 27;
       SIGUSR6  = 28;
       SIGUSR7  = 29;
    { Novell-defined signals  }
       SIG_FINI         = 30;
       SIG_LOCALECHANGE = 31;
       NSIG             = 32;
       SIG_BLOCK        = $00000000;
       SIG_UNBLOCK      = $00000001;
       SIG_SETMASK      = $FFFFFFFF;
//       SIGEMPTYSET      = $0000000000000000;
       SIGFULLSET       = $FFFFFFFFFFFFFFFF;


type
   Psig_atomic_t = ^sig_atomic_t;
   sig_atomic_t = longint;

   Psigset_t = ^sigset_t;
   sigset_t = Tuint64;
{ flags for sa_flags in struct sigaction  }
   Psigaction = ^sigaction;
   sigaction = record
        sa_handler : procedure (_para1:longint);cdecl;
        sa_mask    : sigset_t;
        sa_flags   : longint;
     end;

type TCDeclProc1LIntPara = procedure (_para1:longint); cdecl;
function Fpraise(_para1:longint):longint;cdecl;external libc_nlm name 'raise';
function Fpsignal(sig:longint; func:TCDeclProc1LIntPara):TCDeclProc1LIntPara;cdecl;external libc_nlm name 'signal';
function Fpsigwait(_set:Psigset_t; sig:Plongint):longint;cdecl;external libc_nlm name 'sigwait';
{ signal vector functions...  }

//!! function sigaction(sig:longint; act:Psigaction; oact:Psigaction):longint;cdecl;external libc_nlm name 'sigaction';

function Fpsigaddset(_para1:Psigset_t; _para2:longint):longint;cdecl;external libc_nlm name 'sigaddset';
function Fpsigdelset(_para1:Psigset_t; _para2:longint):longint;cdecl;external libc_nlm name 'sigdelset';
function Fpsigismember(_para1:Psigset_t; _para2:longint):longint;cdecl;external libc_nlm name 'sigismember';
function Fpsigfillset(_para1:Psigset_t):longint;cdecl;external libc_nlm name 'sigfillset';
function Fpsigemptyset(_para1:Psigset_t):longint;cdecl;external libc_nlm name 'sigemptyset';
function Fpsigpending(_set:Psigset_t):longint;cdecl;external libc_nlm name 'sigpending';
function Fpsigsuspend(mask:Psigset_t):longint;cdecl;external libc_nlm name 'sigsuspend';
function Fpsigprocmask(how:longint; act:Psigset_t; oldact:Psigset_t):longint;cdecl;external libc_nlm name 'sigprocmask';
function Fpkill(pid:pid_t; sig:longint):longint;cdecl;external libc_nlm name 'kill';


// sys/socket.h
// sys/uio.h
{ turn on 1-byte packing...  }

type
   Piovec = ^iovec;
   iovec = record
        iov_base : caddr_t;
        iov_len : longint;
     end;
   iovec_t = iovec;
   Piovec_t = ^iovec_t;

(** unsupported pragma#pragma pack()*)


function Fpreadv(fildes:longint; iov:Piovec; iovcnt:longint):ssize_t;cdecl;external libc_nlm name 'readv';
function Fpwritev(fildes:longint; iov:Piovec; iovcnt:longint):ssize_t;cdecl;external libc_nlm name 'writev';
{ socket types...  }
{ option flags per-socket...  }
{ additional options, not kept in so_options...  }
{ additional option to be used with level IPPROTO_TCP...  }
{ level number for get/setsockopt() to apply to socket itself...  }
{ address families  }
{ protocol families, same as address families for now...  }
{ values for shutdown() 'how'...  }

{
** Note:
**
** The Novell NDK headers for NKS/LibC contain structures that are explicitly
** hand-packed for best use on the platform in question (usually IA32). To
** avoid the impredictability encountered when compiling with different
** compilers, these headers rely on 1-byte packing.
 }
{ this header sets packing to 1 for different compilers  }
{ save off the previous packing directive in a compiler specific way...  }
{ turn on 1-byte packing...  }

{ structure used for manipulating linger option...  }
{ option on/off                          }
{ linger time                            }
type
   Plinger = ^linger;
   linger = record
        l_onoff : longint;
        l_linger : longint;
     end;

{ structure used to define addresses for bind(), connect(), etc...  }

   Psa_family_t = ^sa_family_t;
   sa_family_t = word;
{ address family                         }
{ up to 14 bytes of direct address       }
   Psockaddr = ^sockaddr;
   sockaddr = record
        sa_family : sa_family_t;
        sa_data : array[0..13] of char;
     end;

{ used by kernel to pass protocol info.  }
{    in raw sockets                      }
{ address family                         }
{ protocol                               }
   Psockproto = ^sockproto;
   sockproto = packed record
        sp_family : word;
        sp_protocol : word;
     end;


   Psocklen_t = ^socklen_t;
   socklen_t = dword;
{
** SUS' and BSD 4.4 message passing. struct msghdr has an additional field
** (msg_flags) and slightly different fieldnames over what we used to
** promote. msg_accrights(len) is done differently.
 }
{ optional address                       }
{ size of address                        }
{ scatter/gather array                   }
{ count of elements in msg_iov           }
{ access rights sent/received            }
   Pmsghdr = ^msghdr;
   msghdr = record
        msg_name : caddr_t;
        msg_namelen : socklen_t;
        msg_iov : Piovec;
        msg_iovlen : longint;
        msg_accrights : caddr_t;
        msg_accrightslen : socklen_t;
        msg_flags : longint;
     end;

{
** POSIX 1003.1g: Ancillary data object information consisting of a sequence
** of pairs of (cmsghdr, cmsg_data[1]).
 }
{ data byte count including header       }
{ originating protocol                   }
{ protocol-specific type                 }
   Pcmsghdr = ^cmsghdr;
   cmsghdr = record
        cmsg_len : socklen_t;
        cmsg_level : longint;
        cmsg_type : longint;
     end;


(** unsupported pragma#pragma pack()*)

function Fpaccept(s:longint; addr:Psockaddr; len:Psize_t):longint;cdecl;external libc_nlm name 'accept';
function Fpbind(s:longint; addr:Psockaddr; _para3:size_t):longint;cdecl;external libc_nlm name 'bind';
function Fpconnect(s:longint; addr:Psockaddr; len:size_t):longint;cdecl;external libc_nlm name 'connect';
function Fpgetpeername(s:longint; addr:Psockaddr; len:Psize_t):longint;cdecl;external libc_nlm name 'getpeername';
function Fpgetsockname(s:longint; addr:Psockaddr; len:Psize_t):longint;cdecl;external libc_nlm name 'getsockname';
function Fpgetsockopt(s:longint; level:longint; optname:longint; optval:pointer; optlen:Psize_t):longint;cdecl;external libc_nlm name 'getsockopt';
function Fplisten(s:longint; backlog:longint):longint;cdecl;external libc_nlm name 'listen';
function Fprecv(s:longint; buf:pointer; len:size_t; flags:longint):ssize_t;cdecl;external libc_nlm name 'recv';
function Fprecvfrom(s:longint; buf:pointer; len:size_t; flags:longint; from:Psockaddr;
           fromlen:Psize_t):ssize_t;cdecl;external libc_nlm name 'recvfrom';
function Fprecvmsg(s:longint; msg:Pmsghdr; flags:longint):ssize_t;cdecl;external libc_nlm name 'recvmsg';
function Fpsend(s:longint; msg:pointer; len:size_t; flags:longint):ssize_t;cdecl;external libc_nlm name 'send';
function Fpsendmsg(s:longint; _para2:Pmsghdr; flags:longint):ssize_t;cdecl;external libc_nlm name 'sendmsg';
function Fpsendto(s:longint; msg:pointer; len:size_t; flags:longint; _to:Psockaddr;
           tolen:size_t):ssize_t;cdecl;external libc_nlm name 'sendto';
function Fpsetsockopt(s:longint; level:longint; optname:longint; optval:pointer; optlen:size_t):longint;cdecl;external libc_nlm name 'setsockopt';
function Fpshutdown(s:longint; how:longint):longint;cdecl;external libc_nlm name 'shutdown';
function Fpsocket(domain:longint; _type:longint; protocol:longint):longint;cdecl;external libc_nlm name 'socket';


// sys/sockio.h
// sys/stat.h
{ turn on 1-byte packing...  }

{ file system type               }
{ fragment size                  }
{ block size                     }
{ total number of blocks         }
{ count of free blocks           }
{ total number of file nodes     }
{ count of free file nodes       }
{ server name                    }
{ volume name                    }
{ pack name                      }
type
   Pstatfs = ^Tstatfs;
   Tstatfs = record
        f_fstyp  : longint;
        f_frsize : size_t;
        f_bsize  : blksize_t;
        f_blocks : blkcnt_t;
        f_bfree,
        f_files,
        f_ffree  : Tuint64;
        f_fspare : array[0..1] of Tuint64;
        f_fserver: array[0..(48 + 4)-1] of char;
        f_fname  : array[0..(16 + 4)-1] of char;
        f_fpack  : array[0..19] of char;
     end;

(** unsupported pragma#pragma pack()*)


function Fpstatfs(path:Pchar; buf:Pstatfs):longint;cdecl;external libc_nlm name 'statfs';
function Fpstatfs(path:Pchar; var buf:Tstatfs):longint;cdecl;external libc_nlm name 'statfs';
function Fpfstatfs(fildes:longint; buf:Pstatfs):longint;cdecl;external libc_nlm name 'fstatfs';
function Fpfstatfs(fildes:longint; var buf:Tstatfs):longint;cdecl;external libc_nlm name 'fstatfs';

// sys/ttydefaults.h

{ system wide defaults for terminal state, mostly for porting help  }
{ defaults on "first" open...  }
{ control character defaults...  }
{ compatibility:  }
// sys/un.h

{ used in place of struct sockaddr_t to define addresses for UNIX domain...  }
type
   Psockaddr_un = ^sockaddr_un;
   sockaddr_un = record
        sun_family : sa_family_t;
        sun_path : array[0..510] of char;
     end;

// ======= sys/utsname.h ===============================================

{ turn on 1-byte packing...  }

// (request) bits for uname2()...
const
   UNAME_NLMMODULE      = $00000001;  // nlmmodule (if it can be gotten)
   UNAME_POSIXFIELDS    = $00000002;  // POSIX fields (see sys/utsname.h)
   UNAME_LIBVERSION     = $00000004;  // libminor/major/revision/threshold
   UNAME_FSVERSION      = $00000008;  // major/minor/revision/service pack
   UNAME_NETWAREVERSION = $00000010;  // netware_major/minor/revision
   UNAME_SERVERNAME     = $00000020;  // servername
   UNAME_CLUSTERNAME    = $00000040;  // clustername
   UNAME_LANGINFO       = $00000080;  // languagename/alt/id/altid/codepage
   UNAME_NLMMESSAGES    = $00000100;  // nlmmessagecount/table
   UNAME_NLMVERSION     = $00000200;  // nlmmajor/minor/revision
   UNAME_NLMINFO        = $00000400;  // nlmtimer/loadflags
   UNAME_NLMNAME        = $00000800;  // nlmname
   UNAME_NLMLOADPATH    = $00001000;  // nlmloadpath
   UNAME_NLMCOPYRIGHT   = $00002000;  // nlmcopyright
   UNAME_NLMDESCRIPTION = $00004000;  // nlmdescription
   UNAME_NLMCOMMANDLINE = $00008000;  // nlmcommandline
   UNAME_NDSTREENAME    = $00010000;  // treename
   UNAME_NLMCODEANDDATA = $00020000;  // code and datastart/-length

type
   Putsname = ^Tutsname;
   Tutsname = record
        userspec         : longint;     // untouched by uname()
                                        // Novell fields
                                        // Standard C Library implementation:
        libmajor         : longint;     //   major version number
        libminor         : longint;     //   minor version number
        librevision      : longint;     //   revision number
                                        // NetWare OS implementation
        major            : longint;     //   major version number
        minor            : longint;     //   minor version number
        revision         : longint;     //   revision number
                                        // NetWare C Library implementation
        libthreshold     : longint;     //   functionality and semantics timestamp
                                        // NetWare product distribution
        servicepack      : longint;
        netware_major    : longint;
        netware_minor    : longint;
        netware_revision : longint;
        servername       : array[0..63] of char;
        clustername      : array[0..63] of char;
        languagename     : array[0..31] of char;  // Server current language name
        altlanguagename  : array[0..31] of char;  // NLM's current language name
        languageid       : longint;
        altlanguageid    : longint;
        codepage         : longint;
        reserved1        : longint;
        reserved2        : array[0..3] of longint;
        nlmmodule        : pointer;              // NetWare-loadable module (NLM) handle
        nlmmajor         : longint;
        nlmminor         : longint;
        nlmrevision      : longint;
        nlmtimer         : time_t;               // module's date and time stamp in UTC
        nlmcommandline   : Pchar;
        nlmmessagecount  : dword;
        nlmmessagetable  : ^Pchar;
        nlmname          : array[0..35] of char;
        nlmloadpath      : array[0..255] of char;
        nlmcopyright     : array[0..255] of char;
        nlmdescription   : array[0..127] of char;
        nlmloadflags     : longint;
        reserved3        : longint;
        release          : array[0..15] of char;
        version          : array[0..15] of char;
        sysname          : array[0..15] of char;
        machine          : array[0..15] of char;
        nodename         : array[0..15] of char;
        treename         : array[0..95] of char; // name of NDS tree
        codeoffset       : pointer;
        codelength       : dword;
        dataoffset       : pointer;
        datalength       : dword;
        reserved4        : array[0..27] of longint;
     end;

(** unsupported pragma#pragma pack()*)

function Fpuname(name:Putsname):longint;cdecl;external libc_nlm name 'uname';
function Fpuname(var name:Tutsname):longint;cdecl;external libc_nlm name 'uname';
function Fpuname2(handle:pointer; info:Putsname; bits:dword):longint;cdecl;external libc_nlm name 'uname2';
function Fpuname2(handle:pointer; var info:Tutsname; bits:dword):longint;cdecl;external libc_nlm name 'uname2';


// sys/wait.h

function Fpwait(stat_loc:Plongint):pid_t;cdecl;external libc_nlm name 'wait';
function Fpwait(var stat_loc:longint):pid_t;cdecl;external libc_nlm name 'wait';
function Fpwaitpid(pid:pid_t; stat_loc:Plongint; options:longint):pid_t;cdecl;external libc_nlm name 'waitpid';
function Fpwaitpid(pid:pid_t; var stat_loc:longint; options:longint):pid_t;cdecl;external libc_nlm name 'waitpid';

// arpa/inet.h
// netinet/in.h

{ protocols...  }
{ port/socket numbers: network standard functions  }
{ port/socket numbers: host specific functions...  }
{ UNIX TCP sockets...   }
{ UNIX UDP sockets...  }
{
** Ports numbered less than IPPORT_RESERVED are reserved for privileged
** processes like 'root.'
 }
{ link numbers...  }
{
** Definitions of bits in Internet address integers. On subnets, the
** decomposition of addresses to host and net parts is done according
** to subnet mask, not the masks here.
 }
{ options for use with [gs]etsockopt at IP level...  }
{ macro to stuff the loopback address into an Internet address...  }
{ address testing macros...  }
{ type definitions...  }
type
   Pin_addr = ^in_addr;
   in_addr = record
        S_un : record
            case longint of
               0 : ( S_un_b : record
                    s_b1 : byte;
                    s_b2 : byte;
                    s_b3 : byte;
                    s_b4 : byte;
                 end );
               1 : ( S_un_w : record
                    s_w1 : word;
                    s_w2 : word;
                 end );
               2 : ( S_addr : dword );
            end;
     end;

   //!! in_addr = in_addr_t;
{ socket address, internet style    }
   Psockaddr_in = ^sockaddr_in;
   sockaddr_in = record
        sin_family : smallint;
        sin_port : u_short;
        sin_addr : in_addr;
        sin_zero : array[0..7] of char;
     end;

   //!! sockaddr_in = sockaddr_in_t;
   Pin6_addr = ^in6_addr;
   in6_addr = record
        in6a_u : record
            case longint of
               0 : ( bytes : array[0..15] of u_char );
               1 : ( shorts : array[0..7] of u_short );
               2 : ( words : array[0..3] of u_long );
            end;
     end;

   Psockaddr_in6 = ^sockaddr_in6;
   sockaddr_in6 = record
        sin6_family : smallint;
        sin6_port : u_short;
        sin6_flowinfo : u_long;
        sin6_addr : in6_addr;
        sin6_scope_id : u_long;
     end;

{ for IP_ADD_MEMBERSHIP and IP_DROP_MEMBERSHIP...  }
{ IP multicast address of group    }
{ local IP address of interface    }
   Pip_mreq = ^ip_mreq;
   ip_mreq = record
        imr_multiaddr : in_addr;
        imr_interface : in_addr;
     end;

{ data...  }

//  var
//     in6addr_any : in6_addr;cvar;external;
//     in6addr_loopback : in6_addr;cvar;external;


function inet_addr(_string:Pchar):dword;cdecl;external libc_nlm name 'inet_addr';
function inet_aton(cp:Pchar; addr:Pin_addr):longint;cdecl;external libc_nlm name 'inet_aton';
function inet_makeaddr(net_num:in_addr; loc_addr:in_addr):in_addr;cdecl;external libc_nlm name 'inet_makeaddr';
function inet_network(_string:Pchar):in_addr;cdecl;external libc_nlm name 'inet_network';
function inet_ntoa(addr:in_addr):Pchar;cdecl;external libc_nlm name 'inet_ntoa';
function inet_ntop(af:longint; src:pointer; dst:Pchar; size:size_t):Pchar;cdecl;external libc_nlm name 'inet_ntop';
function inet_pton(af:longint; cp:Pchar; ap:pointer):longint;cdecl;external libc_nlm name 'inet_pton';


// netinet/in.h

{ User-settable options (used with setsockopt). }


// nks/defs.h

  const
     NX_MAX_KEYS = 64;
     NX_MAX_OBJECT_NAME_LEN = 31;
     NX_INTR1 = 0;
     NX_INTR2 = 1;
     NX_INTR3 = 2;
     NX_INTR4 = 3;
     NX_INTR5 = 4;
     NX_INTR6 = 5;
     NX_INTR7 = 6;
     NX_INTR8 = 7;
     NX_INTR9 = 8;
     NX_INTR10 = 9;
     NX_INTR11 = 10;
     NX_INTR12 = 11;
     NX_INTR13 = 12;
     NX_INTR14 = 13;
     NX_INTR15 = 14;
     NX_INTR16 = 15;
     NX_INTR17 = 16;
     NX_INTR18 = 17;
     NX_INTR19 = 18;
     NX_INTR20 = 19;
     NX_INTR21 = 20;
     NX_INTR22 = 21;
     NX_INTR23 = 22;
     NX_INTR24 = 23;
     NX_INTR25 = 24;
     NX_INTR26 = 25;
     NX_INTR27 = 26;
     NX_INTR28 = 27;
     NX_INTR29 = 28;
     NX_INTR30 = 29;
     NX_INTR31 = 30;
     NX_INTR32 = 31;
     NX_INTR33 = 32;
     NX_INTR34 = 33;
     NX_INTR35 = 34;
     NX_INTR36 = 35;
     NX_INTR37 = 36;
     NX_INTR38 = 37;
     NX_INTR39 = 38;
     NX_INTR40 = 39;
     NX_INTR41 = 40;
     NX_INTR42 = 41;
     NX_INTR43 = 42;
     NX_INTR44 = 43;
     NX_INTR45 = 44;
     NX_INTR46 = 45;
     NX_INTR47 = 46;
     NX_INTR48 = 47;
     NX_INTR49 = 48;
     NX_INTR50 = 49;
     NX_INTR51 = 50;
     NX_INTR52 = 51;
     NX_INTR53 = 52;
     NX_INTR54 = 53;
     NX_INTR55 = 54;
     NX_INTR56 = 55;
     NX_INTR57 = 56;
     NX_INTR58 = 57;
     NX_INTR59 = 58;
     NX_INTR60 = 59;
     NX_INTR61 = 60;
     NX_INTR62 = 61;
     NX_INTR63 = 62;
     NX_INTR64 = 63;


type

   PNXBool_t = ^NXBool_t;
   NXBool_t = longint;

   PNXVmId_t = ^NXVmId_t;
   NXVmId_t = longint;
{ values for NXInterruptId_t...  }


// nks/dirio.h
// nks/fsio.h
// unilib.h

  const
     UNI_ERR_MEM_ALLOC = -(494);
  { nonexistant rule table handle      }
     UNI_ERR_BAD_HANDLE = -(496);
  { table corruption detected          }
     UNI_ERR_TABLE_CORRUPT = -(498);
  { insufficient room in string        }
     UNI_ERR_TOO_FEW_BYTES = -(500);
  { unable to open data file           }
     UNI_ERR_FILE_OPEN = -(501);
  {                                    }
     UNI_ERR_FILE_EXIST = -(502);
  { unable to read data file           }
     UNI_ERR_FILE_READ = -(504);
  { functional stub only               }
     UNI_ERR_UNIMPLEMENTED = -(505);
  { premature end-of-string            }
     UNI_ERR_PREMATURE_END = -(506);
  { discovered during translation      }
     UNI_ERR_UNMAPPABLE_CHAR = -(532);
  { invalid UTF-8 character sequence   }
     UNI_ERR_INVALID_UTF8_SEQ = $FFFF;
  { the local, default rule table for argument 'table' below...  }
  { respective to local codepage       }
     UNI_LOCAL_DEFAULT = -(1);
  { 'noMapFlag' values; when no mapping found...  }
  { return UNI_ERR_UNMAPPABLE_CHAR     }
     UNI_MAP_NO_CHAR = 0;
  { use value in 'noMapChar' unless 0  }
     UNI_MAP_CHAR = 1;
  { use 'noMapFunc' if non-nil         }
     UNI_MAP_BY_FUNC = 1;
  { use character itself               }
     UNI_MAP_SELF = 2;
  { no-map character if 'noMapChar' 0  }
     UNI_NOMAP_DEFAULT = '?';
  { character classification (UniClass_t)...  }
  { no classification                      }
     UNI_UNDEF = $00000000;
  { control character                      }
     UNI_CNTRL = $00000001;
  { non-printing space                     }
     UNI_SPACE = $00000002;
  { printing (visible) character           }
     UNI_PRINT = $00000004;
  { dingbats, special symbols, et al.      }
     UNI_SPECIAL = $00000008;
  { general punctuation                    }
     UNI_PUNCT = $00000010;
  { decimal digit                          }
     UNI_DIGIT = $00000020;
  { hexadecimal digit                      }
     UNI_XDIGIT = $00000040;
  { reserved for future use                }
     UNI_RESERVED1 = $00000080;
  { lower-case if applicable               }
     UNI_LOWER = $00000100;
  { upper-case if applicable               }
     UNI_UPPER = $00000200;
  { reserved for future use                }
     UNI_RESERVED2 = $00000400;
  { non-number, non-punctuation including: }
     UNI_ALPHA = $00000800;
  { Latin-based                            }
     UNI_LATIN = $00001000;
  { Greek                                  }
     UNI_GREEK = $00002000;
  { Cyrillic                               }
     UNI_CYRILLIC = $00004000;
  { Hebrew                                 }
     UNI_HEBREW = $00008000;
  { Arabic                                 }
     UNI_ARABIC = $00010000;
  { Chinese/Japanese/Korean characters     }
     UNI_CJK = $00020000;
  { Devanagari, Bengali, Tamil, et al.     }
     UNI_INDIAN = $00040000;
  { southeast Asia: Thai, Lao              }
     UNI_SEASIA = $00080000;
  { cent. Asia: Armenian Tibetain, Georg.  }
     UNI_CENASIA = $00100000;
  { none of the above                      }
     UNI_OTHER = $80000000;


type
   Punicode_t = ^unicode_t;
   unicode_t = wchar_t;
   PPunicode_t = ^Punicode_t;

   PUniRuleTable_t = ^UniRuleTable_t;
   UniRuleTable_t = longint;
{ more a cookie than anything else      }

   PUniClass_t = ^UniClass_t;
   UniClass_t = dword;
{ Unicode character classification       }
{ for uni2mono(), unicase(), et al.      }
{ default monocasing as implemented      }
{ character is not 'alphabetic'          }
{ character has no case                  }
{ emphatically upper case                }
{ emphatically lower case                }

   PUniCase_t = ^UniCase_t;
   UniCase_t =  Longint;
   Const
     UNI_CASE_DEFAULT = $FFFFFFFD;
     UNI_CASE_NONE = $FFFFFFFE;
     UNI_CASE_AMBIGUOUS = $FFFFFFFF;
     UNI_CASE_UPPER = $00000000;
     UNI_CASE_LOWER = $00000001;
     UNI_CASE_TITLE = $00000002;

{ unmappable character handling function types...  }

type

   Loc2UniNoMapFunc_t = function (dest:PPunicode_t; remaining:size_t; src:PPchar; userParm:pointer):longint;cdecl;


   Loc2Utf8NoMapFunc_t = function (dest:PPchar; remaining:size_t; src:PPchar; userParm:pointer):longint;cdecl;


   Utf82LocNoMapFunc_t = function (dest:PPchar; remaining:size_t; src:PPchar; userParm:pointer):longint;cdecl;


   Utf82UniNoMapFunc_t = function (dest:PPchar; remaining:size_t; src:PPunicode_t; userParm:pointer):longint;cdecl;


   Uni2LocNoMapFunc_t = function (dest:PPchar; remaining:size_t; src:PPunicode_t; userParm:pointer):longint;cdecl;


   Uni2Utf8NoMapFunc_t = function (dest:PPchar; remaining:size_t; src:PPunicode_t; userParm:pointer):longint;cdecl;
{ rule table management...  }

function UniGetTable(codePage:longint; table:PUniRuleTable_t):longint;cdecl;external libc_nlm name 'UniGetTable';

function UniGetMacintoshTable(name:Pchar; table:PUniRuleTable_t):longint;cdecl;external libc_nlm name 'UniGetMacintoshTable';
function UniSetDefault(table:UniRuleTable_t):longint;cdecl;external libc_nlm name 'UniSetDefault';
function UniDisposeTable(table:UniRuleTable_t):longint;cdecl;external libc_nlm name 'UniDisposeTable';
function UniGetHostCodePage:longint;cdecl;external libc_nlm name 'UniGetHostCodePage';
{ translation between local and other codepages, Unicode and UTF-8...  }

function loc2uni(table:UniRuleTable_t; dest:Punicode_t; src:Pchar; noMapCh:unicode_t; noMapFlag:longint):longint;cdecl;external libc_nlm name 'loc2uni';

function loc2unipath(table:UniRuleTable_t; dest:Punicode_t; src:Pchar; dryRunSize:Psize_t):longint;cdecl;external libc_nlm name 'loc2unipath';

function locn2uni(table:UniRuleTable_t; dest:Punicode_t; destLen:Psize_t; src:Pchar; srcLen:size_t;
           noMapCh:unicode_t; noMapFlag:longint):longint;cdecl;external libc_nlm name 'locn2uni';
function locnp2uni(table:UniRuleTable_t; target:PPunicode_t; destLen:Psize_t; source:PPchar; srcLen:size_t;
           noMapCh:unicode_t; noMapFlag:longint):longint;cdecl;external libc_nlm name 'locnp2uni';

function locnx2uni(table:UniRuleTable_t; dest:Punicode_t; destLen:Psize_t; src:Pchar; srcLen:size_t;
           noMapFunc:Loc2UniNoMapFunc_t; noMapFuncParm:pointer; noMapFlag:longint):longint;cdecl;external libc_nlm name 'locnx2uni';

function locnx2unipath(table:UniRuleTable_t; dest:Punicode_t; destLen:Psize_t; src:Pchar; srcLen:size_t;
           noMapFunc:Loc2UniNoMapFunc_t; noMapFuncParm:pointer; noMapFlag:longint; dryRunSize:Psize_t):longint;cdecl;external libc_nlm name 'locnx2unipath';

function locn2unispecial(handle:UniRuleTable_t; dest:Punicode_t; destLen:Psize_t; src:Pchar; srcLen:size_t):longint;cdecl;external libc_nlm name 'locn2unispecial';

function loc2utf8(handle:UniRuleTable_t; dest:Pchar; src:Pchar; noMapCh:char; noMapFlag:longint):longint;cdecl;external libc_nlm name 'loc2utf8';

function loc2utf8path(table:UniRuleTable_t; dest:Pchar; src:Pchar; dryRunSize:Psize_t):longint;cdecl;external libc_nlm name 'loc2utf8path';

function locn2utf8(table:UniRuleTable_t; dest:Pchar; destLen:Psize_t; src:Pchar; srcLen:size_t;
           noMapCh:char; noMapFlag:longint):longint;cdecl;external libc_nlm name 'locn2utf8';

function locnx2utf8(table:UniRuleTable_t; dest:Pchar; destLen:Psize_t; src:Pchar; srcLen:size_t;
           noMapFunc:Loc2Utf8NoMapFunc_t; noMapFuncParm:pointer; noMapFlag:longint):longint;cdecl;external libc_nlm name 'locnx2utf8';

function uni2loc(table:UniRuleTable_t; dest:Pchar; src:Punicode_t; noMapCh:char; noMapFlag:longint):longint;cdecl;external libc_nlm name 'uni2loc';

function uni2locpath(table:UniRuleTable_t; dest:Pchar; src:Punicode_t; dryRunSize:Psize_t):longint;cdecl;external libc_nlm name 'uni2locpath';

function unin2loc(table:UniRuleTable_t; dest:Pchar; destLen:Psize_t; src:Punicode_t; srcLen:size_t;
           noMapCh:char; noMapFlag:longint):longint;cdecl;external libc_nlm name 'unin2loc';
function uninp2loc(table:UniRuleTable_t; target:PPchar; destLen:Psize_t; source:PPunicode_t; srcLen:size_t;
           noMapCh:char; noMapFlag:longint):longint;cdecl;external libc_nlm name 'uninp2loc';

function uninx2loc(table:UniRuleTable_t; dest:Pchar; destLen:Psize_t; src:Punicode_t; srcLen:size_t;
           noMapFunc:Uni2LocNoMapFunc_t; noMapFuncParm:pointer; noMapFlag:longint):longint;cdecl;external libc_nlm name 'uninx2loc';

function uninx2locpath(table:UniRuleTable_t; dest:Pchar; destLen:Psize_t; src:Punicode_t; srcLen:size_t;
           noMapFunc:Uni2LocNoMapFunc_t; noMapFuncParm:pointer; noMapFlag:longint; dryRunSize:Psize_t):longint;cdecl;external libc_nlm name 'uninx2locpath';

function unin2locspecial(handle:UniRuleTable_t; dest:Pchar; destLen:Psize_t; src:Punicode_t; srcLen:size_t):longint;cdecl;external libc_nlm name 'unin2locspecial';

function uni2utf8(dest:Pchar; src:Punicode_t):longint;cdecl;external libc_nlm name 'uni2utf8';

function uni2utf8path(dest:Pchar; src:Punicode_t; dryRunSize:Psize_t):longint;cdecl;external libc_nlm name 'uni2utf8path';

function unin2utf8(dest:Pchar; destLen:Psize_t; src:Punicode_t; srcLen:size_t):longint;cdecl;external libc_nlm name 'unin2utf8';

function utf82loc(handle:UniRuleTable_t; dest:Pchar; src:Pchar; noMapCh:char; noMapFlag:longint):longint;cdecl;external libc_nlm name 'utf82loc';

function utf8n2loc(table:UniRuleTable_t; dest:Pchar; destLen:Psize_t; src:Pchar; srcLen:size_t;
           noMapCh:char; noMapFlag:longint):longint;cdecl;external libc_nlm name 'utf8n2loc';

function utf8nx2loc(table:UniRuleTable_t; dest:Pchar; destLen:Psize_t; src:Pchar; srcLen:size_t;
           noMapFunc:Utf82LocNoMapFunc_t; noMapFuncParm:pointer; noMapFlag:longint):longint;cdecl;external libc_nlm name 'utf8nx2loc';

function utf82uni(dest:Punicode_t; src:Pchar):longint;cdecl;external libc_nlm name 'utf82uni';

function utf8n2uni(dest:Punicode_t; destLen:Psize_t; src:Pchar; srcLen:size_t):longint;cdecl;external libc_nlm name 'utf8n2uni';
{ quick, 7-bit ASCII-capable translations--not preferred set...  }

function asc2uni(dest:Punicode_t; src:Pchar):Punicode_t;cdecl;external libc_nlm name 'asc2uni';

function ascn2uni(dest:Punicode_t; src:Pchar; nbytes:size_t):Punicode_t;cdecl;external libc_nlm name 'ascn2uni';

function uni2asc(dest:Pchar; src:Punicode_t):Pchar;cdecl;external libc_nlm name 'uni2asc';

function unin2asc(dest:Pchar; src:Punicode_t; nchars:size_t):Pchar;cdecl;external libc_nlm name 'unin2asc';
{ default 'noMapFunc' for X-translation to ensure round-trip conversion...  }

function LocToUniTagFunc(dest:PPunicode_t; remaining:size_t; src:PPchar; userParm:pointer):longint;cdecl;external libc_nlm name 'LocToUniTagFunc';

function UniToLocTagFunc(dest:PPchar; remaining:size_t; src:PPunicode_t; userParm:pointer):longint;cdecl;external libc_nlm name 'UniToLocTagFunc';
{ string size calculation...  }

function LocToUniSize(table:UniRuleTable_t; str:Pchar; unmappedCharSize:size_t; noMapFlag:longint; uniBufSize:Psize_t):longint;cdecl;external libc_nlm name 'LocToUniSize';

function LocToUtf8Size(table:UniRuleTable_t; str:Pchar; unmappedCharSize:size_t; noMapFlag:longint; utf8BufSize:Psize_t):longint;cdecl;external libc_nlm name 'LocToUtf8Size';

function UniToLocSize(table:UniRuleTable_t; str:Punicode_t; unmappedCharSize:size_t; noMapFlag:longint; locBufSize:Psize_t):longint;cdecl;external libc_nlm name 'UniToLocSize';

function UniToUtf8Size(str:Punicode_t; utf8BufSize:Psize_t):longint;cdecl;external libc_nlm name 'UniToUtf8Size';

function Utf8ToLocSize(table:UniRuleTable_t; str:Pchar; unmappedCharSize:size_t; noMapFlag:longint; locBufSize:Psize_t):longint;cdecl;external libc_nlm name 'Utf8ToLocSize';

function Utf8ToUniSize(str:Pchar; uniBufSize:Psize_t):longint;cdecl;external libc_nlm name 'Utf8ToUniSize';
{-----------------------------------------------------------------------------
** Little utility functions. These are not to be preferred over the interfaces
** from wchar.h.
 }
{ utility to measure width of a character in a codepage...  }

function dbcs_width(codepage:longint; str:Pchar):longint;cdecl;external libc_nlm name 'dbcs_width';
{ classification...  }
function unitype(ch:unicode_t):UniClass_t;cdecl;external libc_nlm name 'unitype';
{ collation...  }


function unicoll(s1:Punicode_t; s2:Punicode_t):longint;cdecl;external libc_nlm name 'unicoll';


function unincoll(s1:Punicode_t; s2:Punicode_t; n:size_t):longint;cdecl;external libc_nlm name 'unincoll';
{ casing...  }
function unicase(ch:unicode_t):UniCase_t;cdecl;external libc_nlm name 'unicase';

function uni2mono(dest:Punicode_t; src:Punicode_t; casing:UniCase_t):Punicode_t;cdecl;external libc_nlm name 'uni2mono';

function unin2mono(dest:Punicode_t; src:Punicode_t; casing:UniCase_t; destLen:size_t):Punicode_t;cdecl;external libc_nlm name 'unin2mono';
function chr2upr(ch:unicode_t):unicode_t;cdecl;external libc_nlm name 'chr2upr';
function chr2lwr(ch:unicode_t):unicode_t;cdecl;external libc_nlm name 'chr2lwr';
function chr2title(ch:unicode_t):unicode_t;cdecl;external libc_nlm name 'chr2title';
function unilwr(_string:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'unilwr';
function uniupr(_string:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'uniupr';

function uni2lwr(dest:Punicode_t; src:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'uni2lwr';

function unin2lwr(dest:Punicode_t; src:Punicode_t; destLen:size_t):Punicode_t;cdecl;external libc_nlm name 'unin2lwr';

function uni2upr(dest:Punicode_t; src:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'uni2upr';

function unin2upr(dest:Punicode_t; src:Punicode_t; destLen:size_t):Punicode_t;cdecl;external libc_nlm name 'unin2upr';

function uni2title(dest:Punicode_t; src:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'uni2title';

function unin2title(dest:Punicode_t; src:Punicode_t; destLen:size_t):Punicode_t;cdecl;external libc_nlm name 'unin2title';
{ length...  }

function unilen(_string:Punicode_t):size_t;cdecl;external libc_nlm name 'unilen';

function uninlen(_string:Punicode_t; max:size_t):size_t;cdecl;external libc_nlm name 'uninlen';

function unisize(_string:Punicode_t):size_t;cdecl;external libc_nlm name 'unisize';
{ copying...  }

function unicpy(tgt:Punicode_t; src:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'unicpy';

function unincpy(tgt:Punicode_t; src:Punicode_t; n:size_t):Punicode_t;cdecl;external libc_nlm name 'unincpy';
function uniset(base:Punicode_t; ch:unicode_t):Punicode_t;cdecl;external libc_nlm name 'uniset';
function uninset(base:Punicode_t; ch:unicode_t; n:size_t):Punicode_t;cdecl;external libc_nlm name 'uninset';
{ concatenation...  }

function unicat(tgt:Punicode_t; src:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'unicat';

function unincat(tgt:Punicode_t; src:Punicode_t; n:size_t):Punicode_t;cdecl;external libc_nlm name 'unincat';

{$ifndef DisableArrayOfConst}
function unilist(tgt:Punicode_t; s1:Punicode_t; args:array of const):Punicode_t;cdecl;external libc_nlm name 'unilist';
{$endif}
function unilist(tgt:Punicode_t; s1:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'unilist';
{ comparison...  }


function unicmp(s1:Punicode_t; s2:Punicode_t):longint;cdecl;external libc_nlm name 'unicmp';


function uniicmp(s1:Punicode_t; s2:Punicode_t):longint;cdecl;external libc_nlm name 'uniicmp';


function unincmp(s1:Punicode_t; s2:Punicode_t; n:size_t):longint;cdecl;external libc_nlm name 'unincmp';


function uninicmp(s1:Punicode_t; s2:Punicode_t; n:size_t):longint;cdecl;external libc_nlm name 'uninicmp';
{ character matching, indexing and miscellaneous...  }

function unichr(_string:Punicode_t; ch:unicode_t):Punicode_t;cdecl;external libc_nlm name 'unichr';
function unirchr(_string:Punicode_t; ch:unicode_t):Punicode_t;cdecl;external libc_nlm name 'unirchr';
function uniindex(_string:Punicode_t; search:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'uniindex';
function unistr(as1:Punicode_t; as2:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'unistr';
function unirev(base:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'unirev';
function unispn(_string:Punicode_t; charset:Punicode_t):size_t;cdecl;external libc_nlm name 'unispn';
function unicspn(_string:Punicode_t; charset:Punicode_t):size_t;cdecl;external libc_nlm name 'unicspn';
function unipbrk(s1:Punicode_t; s2:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'unipbrk';
function unitok(_string:Punicode_t; sepset:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'unitok';
function unitok_r(_string:Punicode_t; sepset:Punicode_t; lasts:PPunicode_t):Punicode_t;cdecl;external libc_nlm name 'unitok_r';
function unidup(s1:Punicode_t):Punicode_t;cdecl;external libc_nlm name 'unidup';
// nks/time.h

{ values for 'epoch' for NXGetTime()...  }
{ values for 'units' for NXGetTime()...  }
{ turn on 1-byte packing...  }

type

   PNXTime_t = ^NXTime_t;
   NXTime_t = Tuint64;

   PNXTimerVal_t = ^NXTimerVal_t;
   NXTimerVal_t = record
        tvPeriod : dword;
        tvCurrent : dword;
     end;

   PNXTimeOut_t = ^NXTimeOut_t;
   NXTimeOut_t = record
        reserved1 : array[0..3] of dword;
        toRoutine : procedure (_para1:pointer);cdecl;
        toArg : pointer;
        toTimerVal : NXTimerVal_t;
        reserved2 : array[0..15] of dword;
     end;

(** unsupported pragma#pragma pack()*)
{ Time and time-out...  }

function NXTimeOutCancel(tout:PNXTimeOut_t; wait:NXBool_t; status:PNXBool_t):longint;cdecl;external libc_nlm name 'NXTimeOutCancel';
function NXTimeOutSchedule(tout:PNXTimeOut_t):longint;cdecl;external libc_nlm name 'NXTimeOutSchedule';
function NXGetTime(epoch:longint; units:longint; time:PNXTime_t):longint;cdecl;external libc_nlm name 'NXGetTime';


// nks/thread.h
// nks/plat.h
type

   PNXCpuId_t = ^NXCpuId_t;
   NXCpuId_t = longint;
{ Platform-specific services...  }

function NXGetCacheLineSize:size_t;cdecl;external libc_nlm name 'NXGetCacheLineSize';
function NXGetCpuCount:dword;cdecl;external libc_nlm name 'NXGetCpuCount';
function NXGetCpuId:NXCpuId_t;cdecl;external libc_nlm name 'NXGetCpuId';
function NXGetPageSize:size_t;cdecl;external libc_nlm name 'NXGetPageSize';
function NXSeedRandom(width:size_t; seed:pointer):longint;cdecl;external libc_nlm name 'NXSeedRandom';
function NXGetSystemTick:dword;cdecl;external libc_nlm name 'NXGetSystemTick';
{ values for thread priority...  }
{ values for thread context flags...  }
{ values for thread flags...  }
{ value returned that specifies that the thread is unbound  }
{ value passed to NXThreadBind to bind it to the current CPU  }
{ return from NXThreadGetId indicating no-context or other error  }

{ turn on 1-byte packing...  }

type

   PNXContext_t = ^NXContext_t;
   NXContext_t = void;

   PNXWorkId_t = ^NXWorkId_t;
   NXWorkId_t = longint;

   PNXKey_t = ^NXKey_t;
   NXKey_t = longint;

   PNXThreadId_t = ^NXThreadId_t;
   NXThreadId_t = longint;

   PNXInterruptId_t = ^NXInterruptId_t;
   NXInterruptId_t = longint;

   PNXInterruptSet_t = ^NXInterruptSet_t;
   NXInterruptSet_t = Tuint64;

   PNXContextState_t = ^NXContextState_t;
   NXContextState_t =  Longint;
   Const
     NX_CTXSTATE_INIT = $FFFFFFFF;
     NX_CTXSTATE_BOUND = $00000001;
     NX_CTXSTATE_UNBOUND = $00000000;

type

   PNXContextInfo_t = ^NXContextInfo_t;
   NXContextInfo_t = record
        ciState : NXContextState_t;
        ciFunc : procedure (_para1:pointer);cdecl;
        ciArg : pointer;
        ciPriority : longint;
        ciStackSize : size_t;
        ciFlags : dword;
     end;

   PlwWork = ^lwWork;
   lwWork = record
        reserved : array[0..6] of pointer;
        lwWorkFunc : procedure (_para1:PlwWork; _para2:pointer);cdecl;
        lwAppRef : pointer;
     end;
   NXLwWork_t = lwWork;
   PNXLwWork_t = ^NXLwWork_t;

(** unsupported pragma#pragma pack()*)
{ Context management...  }

type TCDeclProc1PtrArg = procedure (_para1:pointer); cdecl;

function NXContextAlloc(start_routine:TCDeclProc1PtrArg; arg:pointer; priority:longint; stackSize:size_t; flags:dword;
           error:Plongint):NXContext_t;cdecl;external libc_nlm name 'NXContextAlloc';
function NXContextFree(ctx:NXContext_t):longint;cdecl;external libc_nlm name 'NXContextFree';
function NXContextGet:NXContext_t;cdecl;external libc_nlm name 'NXContextGet';
function NXContextGetInfo(ctx:NXContext_t; info:PNXContextInfo_t):longint;cdecl;external libc_nlm name 'NXContextGetInfo';
function NXContextGetName(ctx:NXContext_t; name:Pchar; len:size_t):longint;cdecl;external libc_nlm name 'NXContextGetName';
function NXContextReinit(ctx:NXContext_t; start_routine:TCDeclProc1PtrArg; arg:pointer; priority:longint; flags:dword):longint;cdecl;external libc_nlm name 'NXContextReinit';

function NXContextSetName(ctx:NXContext_t; name:Pchar):longint;cdecl;external libc_nlm name 'NXContextSetName';
{ Key-value pairs (per-context data)...  }
type TCdeclProc = procedure; cdecl;
function NXKeyCreate(_destructor: TCDeclProc; value:pointer; key:PNXKey_t):longint;cdecl;external libc_nlm name 'NXKeyCreate';
function NXKeyDelete(key:NXKey_t):longint;cdecl;external libc_nlm name 'NXKeyDelete';
function NXKeyGetValue(key:NXKey_t; value:Ppointer):longint;cdecl;external libc_nlm name 'NXKeyGetValue';
function NXKeySetValue(key:NXKey_t; value:pointer):longint;cdecl;external libc_nlm name 'NXKeySetValue';
{ Thread management...  }
function NXThreadBind(cpu_id:NXCpuId_t):longint;cdecl;external libc_nlm name 'NXThreadBind';
function NXThreadContinue(tid:NXThreadId_t):longint;cdecl;external libc_nlm name 'NXThreadContinue';
function NXThreadCreate(ctx:NXContext_t; flags:dword; idp:PNXThreadId_t):longint;cdecl;external libc_nlm name 'NXThreadCreate';
function NXThreadCreateSx(start_routine:TCDeclProc1PtrArg; arg:pointer; thread_flags:dword; ctx:PNXContext_t; thr:PNXThreadId_t):longint;cdecl;external libc_nlm name 'NXThreadCreateSx';
procedure NXThreadDelay(delay:dword);cdecl;external libc_nlm name 'NXThreadDelay';
function NXThreadDestroy(tid:NXThreadId_t):longint;cdecl;external libc_nlm name 'NXThreadDestroy';
function NXThreadDetach(tid:NXThreadId_t):longint;cdecl;external libc_nlm name 'NXThreadDetach';
procedure NXThreadExit(status:pointer);cdecl;external libc_nlm name 'NXThreadExit';
function NXThreadGetBinding:NXCpuId_t;cdecl;external libc_nlm name 'NXThreadGetBinding';
function NXThreadGetContext(tid:NXThreadId_t; ctx:PNXContext_t):longint;cdecl;external libc_nlm name 'NXThreadGetContext';
function NXThreadGetId:NXThreadId_t;cdecl;external libc_nlm name 'NXThreadGetId';
function NXThreadGetPriority(tid:NXThreadId_t; priority:Plongint):longint;cdecl;external libc_nlm name 'NXThreadGetPriority';
function NXThreadInterrupt(tid:NXThreadId_t; interId:NXInterruptId_t):longint;cdecl;external libc_nlm name 'NXThreadInterrupt';
function NXThreadIsInterrupted(_set:PNXInterruptSet_t):NXBool_t;cdecl;external libc_nlm name 'NXThreadIsInterrupted';
function NXThreadJoin(wait_for:NXThreadId_t; departed_thread:PNXThreadId_t; status:Ppointer):longint;cdecl;external libc_nlm name 'NXThreadJoin';
function NXThreadSetPriority(tid:NXThreadId_t; priority:longint):longint;cdecl;external libc_nlm name 'NXThreadSetPriority';
function NXThreadSuspend(tid:NXThreadId_t):longint;cdecl;external libc_nlm name 'NXThreadSuspend';
function NXThreadSwapContext(newctx:NXContext_t; prevctx:PNXContext_t):longint;cdecl;external libc_nlm name 'NXThreadSwapContext';
function NXThreadUnbind:longint;cdecl;external libc_nlm name 'NXThreadUnbind';
procedure NXThreadYield;cdecl;external libc_nlm name 'NXThreadYield';
function nxThreadCreate(start_routine:TCDeclProc1PtrArg; flags:dword; arg:pointer; ctxp:PNXContext_t; idp:PNXThreadId_t):longint;cdecl;external libc_nlm name 'nxThreadCreate';
{ Work-to-dos...  }
function NXDelayedWorkSchedule(ctx:NXContext_t; timerval:PNXTimerVal_t; bind:NXBool_t; wid:PNXWorkId_t):longint;cdecl;external libc_nlm name 'NXDelayedWorkSchedule';
function NXLwWorkCancel(work:PNXLwWork_t):longint;cdecl;external libc_nlm name 'NXLwWorkCancel';
function NXLwWorkSchedule(reserved:pointer; work:PNXLwWork_t; bind:NXBool_t):longint;cdecl;external libc_nlm name 'NXLwWorkSchedule';
function NXWorkCancel(wid:NXWorkId_t; wait:NXBool_t; status:PNXBool_t):longint;cdecl;external libc_nlm name 'NXWorkCancel';
function NXWorkSchedule(context:NXContext_t; bind:NXBool_t; wid:PNXWorkId_t):longint;cdecl;external libc_nlm name 'NXWorkSchedule';
{ Miscellaneous...  }
function NXProcessInterruptSet(_set:PNXInterruptSet_t; id:NXInterruptId_t; processed_id:PNXInterruptId_t):NXBool_t;cdecl;external libc_nlm name 'NXProcessInterruptSet';
{ values and masks for file modes...  }
{ values and masks for file operations...  }
{ for NXDeviceOpen() and NXConsoleOpen()...  }
{ aliases for above...  }
{ open flags...  }
{ sharing flags...  }
{ delegation type...  }
{ flush flags...  }
{ values and masks for access flags...  }
{ values for setting file length...  }
{ values for file byte-range locking flags...  }


{ turn on 1-byte packing...  }

  const
     NX_MAX_NAME_LEN = 255;
  { (big! --this isn't used yet)  }
{$define NX_MAX_FILESIZE}
  { values and masks for file modes...  }
     NX_O_RDONLY = $00000000;
     NX_O_WRONLY = $00000001;
     NX_O_RDWR = $00000002;
     NX_O_ACCMODE = $00000003;
  { values and masks for file operations...  }
     NX_O_APPEND = $00000010;
     NX_O_CREAT = $00000020;
     NX_O_TRUNC = $00000040;
     NX_O_EXCL = $00000080;
     NX_O_TRANS = $00000100;
     NX_O_NONBLOCK = $00000400;
     NX_O_OPMODE = $000005E0;
  { for NXDeviceOpen() and NXConsoleOpen()...  }
     NX_O_SCROLLABLE = $00000800;
  { aliases for above...  }
     NX_O_CREATE = NX_O_CREAT;
     NX_O_TRUNCATE = NX_O_TRUNC;
     NX_O_EXCLUSIVE = NX_O_EXCL;
  { open flags...  }
     NX_OFLAG_DIRECTIO = $00010000;
     NX_OFLAG_CRONLY = $00020000;
     NX_OFLAG_BACKUP = $00040000;
     NX_OFLAG_RESTORE = $00080000;
     NX_OFLAG_EXTEND = $00100000;
     NX_OFLAG_SYNCWR = $00200000;
     NX_OFLAG_ATOMIC_RW = $00400000;
     NX_OFLAG_NOTRAVERSE_LINK = $00800000;
     NX_OFLAG_MASK = $00FF0000;
  { sharing flags...  }
     NX_SHARE_DENYNO = $00000000;
     NX_SHARE_DENYRD = $00100000;
     NX_SHARE_DENYWR = $00200000;
     NX_SHARE_DENYALL = $00400000;
     NX_SHARE_MASK = $00700000;
  { delegation type...  }
     NX_DELEG_NONE = $00000000;
  { flush flags...  }
     NX_FLUSH_DATA = $00000001;
     NX_FLUSH_METADATA = $00000002;
     NX_FLUSH_ASYNC = $00000004;
  { values and masks for access flags...  }
     NX_R_OK = $00000001;
     NX_W_OK = $00000002;
     NX_X_OK = $00000004;
     NX_F_OK = $00000008;
  { values for setting file length...  }
     NX_FOP_RETURN_EXTEND = $00000001;
     NX_FOP_RETURN_TRUNC_FREE = $00000002;
     NX_FOP_RETURN_SPARSE = $00000004;
  { values for file byte-range locking flags...  }
     NX_RANGE_LOCK_SHARED = $00000001;
     NX_RANGE_LOCK_EXCL = $00000002;
     NX_RANGE_LOCK_CHECK = $00000004;
     NX_RANGE_LOCK_TRYLOCK = $00000008;
     NX_RANGE_LOCK_COURTESY = $00000010;
     NX_RANGE_LOCK_CANCEL = $00000020;
     NX_RANGE_LOCK_POSIX = $00000040;



type
   //Pfsio = ^fsio;
   //fsio = record
       {undefined structure}
    // end;


   PNXMode_t = ^NXMode_t;
   NXMode_t = dword;

   PNXOFlags_t = ^NXOFlags_t;
   NXOFlags_t = dword;

   PNXShareMode_t = ^NXShareMode_t;
   NXShareMode_t = dword;

   PNXOffset_t = ^NXOffset_t;
   NXOffset_t = Tuint64;
{ (file offsets and lengths)  }

   PNXSOffset_t = ^NXSOffset_t;
   NXSOffset_t = Tint64;

   PNXLockToken_t = ^NXLockToken_t;
   NXLockToken_t = Tuint64;

   PNXHandle_t = ^NXHandle_t;
   NXHandle_t = longint;

   PNXPathCtx_t = ^NXPathCtx_t;
   NXPathCtx_t = longint;

   PNXDelegType_t = ^NXDelegType_t;
   NXDelegType_t = longint;

   PNXAsyncId_t = ^NXAsyncId_t;
   NXAsyncId_t = void;
{ I/O objects supported...  }

   PNXObjType_t = ^NXObjType_t;
   NXObjType_t =  Longint;
   Const
     NX_OBJ_UNKNOWN = $FFFFFFFF;
     NX_OBJ_DEFAULT = $FFFFFFFE;
     NX_OBJ_FILE = $FFFFFFFD;
     NX_OBJ_DIR = $FFFFFFFC;
     NX_OBJ_FIFO = $FFFFFFFB;
     NX_OBJ_DEVICE = $FFFFFFFA;
     NX_OBJ_CONSOLE = $FFFFFFF9;
     NX_OBJ_SYMLINK = $FFFFFFF8;

type

   PNXGuid_t = ^NXGuid_t;
   NXGuid_t = record
       case longint of
          0 : ( guid_field : array[0..1] of Tuint64 );
       end;

   PNXFid_t = ^NXFid_t;
   NXFid_t = record
        fidFsId : NXGuid_t;
        fidFileId : array[0..1] of Tuint64;
     end;

   PNXUpCallReason_t = ^NXUpCallReason_t;
   NXUpCallReason_t =  Longint;
   Const
     NX_UPCALL_UNKNOWN = $FFFFFFFF;
     NX_UPCALL_DELEGRECALL = $00000000;
     NX_UPCALL_BACKUPIMMINENT = $00000001;

 Const
     NX_LOCK_RANGE_UNKNOWN = 2147483647;
     NX_LOCK_RANGE_FORWARD = 1;
     NX_LOCK_RANGE_BACKWARD = 2;

type

   NXFsUpCall_t = procedure (fileHandle:NXHandle_t; reason:NXUpCallReason_t; parm:pointer);cdecl;
{ generic filesystem name if used            }
{ Macintosh data stream (data or resource)   }

   PNXDataStream_t = ^NXDataStream_t;
   NXDataStream_t = record
       case longint of
          0 : ( name : pointer );
          1 : ( macintoshId : dword );
       end;
{ based on which 'fosPathname' is understood }

{ relative to 'fosPathCtx'                   }
{ NX_O_RDONLY, NX_O_RDWR, etc.               }
{ NX_OFLAG_SYNCWR, NX_OFLAG_DIRECTIO, etc.   }
{ NX_SHARE_DENYRD, NX_DENY_ALL, etc.         }
{ contiguous file block allocation hint      }
{ contiguous file block allocation hint      }
{ delegation type: NX_DELEG_NONE             }
{ data stream (if not part of fosPathname)   }
{ called to warn of delegation revocation    }
{ description of successful conclusion       }
{ actual grant of delegation                 }
{ returns FID of opened file                 }
{ time of last access                        }
{ time of last modification                  }
{ time of file creation                     }
{ time of last back-up                       }
{ length of file at open                     }
{ create/open operation results              }

   PNXFileOpenSpec_t = ^NXFileOpenSpec_t;
   NXFileOpenSpec_t = record
        fosPathCtx : NXPathCtx_t;
        fosPathname : pointer;
        fosMode : NXMode_t;
        fosOFlags : NXOFlags_t;
        fosShareMode : NXShareMode_t;
        fosExtentSize : size_t;
        reserved1 : dword;
        fosDelegType : NXDelegType_t;
        fosDataStream : NXDataStream_t;
        fosUpCallFunc : NXFsUpCall_t;
        fosResult : record
             actionTaken : NXMode_t;
             delegType : NXDelegType_t;
             fid : NXFid_t;
             accessTime : NXTime_t;
             modifyTime : NXTime_t;
             creationTime : NXTime_t;
             archiveTime : NXTime_t;
             length : NXOffset_t;
          end;
        reserved2 : dword;
        reserved3 : dword;
     end;
   Pfsio = ^fsio;
   NXIoComp_t = function (ioInfo:Pfsio):longint;cdecl;
{ length of I/O buffer                       }
{ pointer to data for I/O operation          }
{ application-maintained reference           }

   PNXIoVec_t = ^NXIoVec_t;
   NXIoVec_t = record
        ivLength : size_t;
        reserved : dword;
        ivBuffer : pointer;
        ivOpRef : pointer;
     end;
{ I/O objects supported...  }
{ For Internal Use Only                }

   PNXLockRange_t = ^NXLockRange_t;
   NXLockRange_t =  Longint;


{ application-maintained reference           }
{ file, FIFO, console, device, etc. handle   }
{ I/O flags and hints                        }
{ hint as to remaining number of bytes      }
{ from NXFileRangeLockEx()                   }
{ completion function if asynchronous        }
{ only for non-file system operations        }
{ offset at which to begin I/O               }
{ number of records in vector                }
{ IN/OUT: I/O operation record vector        }
{ OUT: asynchronous transaction ID           }
{ OUT: for asynchronous use                  }
{ OUT: total bytes written or read           }

   fsio = record
        ioAppRef : pointer;
        ioHandle : NXHandle_t;
        ioFlags : dword;
        reserved : dword;
        ioRemainingHint : NXOffset_t;
        ioLockToken : NXLockToken_t;
        ioCompletion : NXIoComp_t;
        ioTimeOut : dword;
        ioOffset : NXOffset_t;
        ioVecCount : longint;
        ioVector : PNXIoVec_t;
        ioAsyncID : NXAsyncId_t;
        ioStatus : longint;
        ioProcessed : NXOffset_t;
     end;
   NXIo_t = fsio;
   PNXIo_t = ^NXIo_t;
{ in file (0-based)                         }
{ magnitude of range                        }
{ NX_LOCK_RANGE_FORWARD, ...                }
{ usually 0; reserved to server apps        }
{ in use only with NX_RANGE_LOCK_NETWARE    }

   PNXFileLockDesc_t = ^NXFileLockDesc_t;
   NXFileLockDesc_t = record
        ldOffset : NXOffset_t;
        ldLength : NXOffset_t;
        ldDirection : NXLockRange_t;
        ldToken : NXLockToken_t;
        ldHandle : NXHandle_t;
        reserved : dword;
     end;

   NXLockUpCall_t = procedure (fileHandle:NXHandle_t; appRef:pointer; lockDesc:PNXFileLockDesc_t);cdecl;
{ application-maintained reference          }
{ handle on which file was opened           }
{ mandatory (TRUE) or merely advisory?     }
{ NX_RANGE_LOCK_EXCL, etc.                  }
{ maximum time to wait for lock             }
{ call-back by file system to release lock  }
{ info. on existing conflicting lock  }
{ info. for VM holding conflicting lock }
{ count of locks described in array         }
{ array of lock descriptions                }

   PNXFileRangeLockSpec_t = ^NXFileRangeLockSpec_t;
   NXFileRangeLockSpec_t = record
        rlsAppRef : pointer;
        rlsHandle : NXHandle_t;
        rlsMandatory : NXBool_t;
        rlsFlags : dword;
        rlsTimeOut : dword;
        rlsUpCall : NXLockUpCall_t;
        rlsConflictLockVm : NXVmId_t;
        rlsConflictLock : NXFileLockDesc_t;
        rlsVecCount : longint;
        rlsDescVec : PNXFileLockDesc_t;
     end;

(** unsupported pragma#pragma pack()*)
{ File I/O...  }

function NXClose(handle:NXHandle_t):longint;cdecl;external libc_nlm name 'NXClose';
function NXFileAllocExtentWithHandle(fileHandle:NXHandle_t; offset:NXOffset_t; length:NXOffset_t; flags:dword):longint;cdecl;external libc_nlm name 'NXFileAllocExtentWithHandle';
function NXFileCancelIo(async_id:NXAsyncId_t; wait:NXBool_t; status:PNXBool_t):longint;cdecl;external libc_nlm name 'NXFileCancelIo';
function NXFileFlushBuffers(fileHandle:NXHandle_t; flags:dword; offset:NXOffset_t; length:NXOffset_t):longint;cdecl;external libc_nlm name 'NXFileFlushBuffers';

function NXFileGetLength(pathCtx:NXPathCtx_t; pathname:pointer; length:PNXOffset_t):longint;cdecl;external libc_nlm name 'NXFileGetLength';
function NXFileGetLengthWithHandle(fileHandle:NXHandle_t; length:PNXOffset_t):longint;cdecl;external libc_nlm name 'NXFileGetLengthWithHandle';

function NXFileOpen(pathCtx:NXPathCtx_t; pathname:pointer; mode:NXMode_t; fileHandle:PNXHandle_t):longint;cdecl;external libc_nlm name 'NXFileOpen';
function NXFileOpenEx(openSpec:PNXFileOpenSpec_t; fileHandle:PNXHandle_t):longint;cdecl;external libc_nlm name 'NXFileOpenEx';
function NXFileRangeLock(fileHandle:NXHandle_t; flags:dword; offset:NXOffset_t; length:NXSOffset_t):longint;cdecl;external libc_nlm name 'NXFileRangeLock';
function NXFileRangeLockEx(lockSpec:NXFileRangeLockSpec_t):longint;cdecl;external libc_nlm name 'NXFileRangeLockEx';
function NXFileRangeUnlock(fileHandle:NXHandle_t; flags:dword; offset:NXOffset_t; length:NXSOffset_t):longint;cdecl;external libc_nlm name 'NXFileRangeUnlock';
function NXFileRangeUnlockEx(lockSpec:NXFileRangeLockSpec_t):longint;cdecl;external libc_nlm name 'NXFileRangeUnlockEx';
function NXFileRemoveWithHandle(handle:NXHandle_t):longint;cdecl;external libc_nlm name 'NXFileRemoveWithHandle';

function NXFileRenameWithHandle(fileHandle:NXHandle_t; targetPathCtx:NXPathCtx_t; newname:pointer; overwrite:NXBool_t):longint;cdecl;external libc_nlm name 'NXFileRenameWithHandle';
function NXFileSetLength(pathCtx:NXPathCtx_t; pathname:pointer; length:NXOffset_t; flags:dword):longint;cdecl;external libc_nlm name 'NXFileSetLength';
function NXFileSetLengthWithHandle(fileHandle:NXHandle_t; length:NXOffset_t; flags:dword):longint;cdecl;external libc_nlm name 'NXFileSetLengthWithHandle';
function NXRead(handle:NXHandle_t; offset:NXOffset_t; length:size_t; address:pointer; flags:dword;
           bytesRead:Psize_t):longint;cdecl;external libc_nlm name 'NXRead';
function NXReadEx(ioInfo:PNXIo_t; ioAsyncId:PNXAsyncId_t):longint;cdecl;external libc_nlm name 'NXReadEx';

function NXRemove(pathCtx:NXPathCtx_t; pathname:pointer):longint;cdecl;external libc_nlm name 'NXRemove';


function NXRename(sourcePathCtx:NXPathCtx_t; oldname:pointer; targetPathCtx:NXPathCtx_t; newname:pointer; overwrite:NXBool_t):longint;cdecl;external libc_nlm name 'NXRename';

function NXWrite(handle:NXHandle_t; offset:NXOffset_t; length:size_t; address:pointer; flags:dword;
           bytesWritten:Psize_t):longint;cdecl;external libc_nlm name 'NXWrite';
function NXWriteEx(ioInfo:PNXIo_t; ioAsyncId:PNXAsyncId_t):longint;cdecl;external libc_nlm name 'NXWriteEx';
{ Additional I/O (including FIFOs, devices, etc.)...  }

function NXDeviceOpen(pathCtx:NXPathCtx_t; name:pointer; mode:NXMode_t; shareMode:NXShareMode_t; flags:dword;
           ioBlockSize:Psize_t; deviceHandle:PNXHandle_t):longint;cdecl;external libc_nlm name 'NXDeviceOpen';

function NXFifoOpen(pathCtx:NXPathCtx_t; pathname:pointer; mode:NXMode_t; fifoSize:size_t; fifoHandle:PNXHandle_t):longint;cdecl;external libc_nlm name 'NXFifoOpen';
function NXIoSetBlockingState(handle:NXHandle_t; blocking:NXBool_t):longint;cdecl;external libc_nlm name 'NXIoSetBlockingState';
function NXIoGetOpenMode(handle:NXHandle_t; mode:PNXMode_t):longint;cdecl;external libc_nlm name 'NXIoGetOpenMode';


function NXLinkCreate(srcPathCtx:NXPathCtx_t; source:pointer; tgtPathCtx:PNXPathCtx_t; target:pointer; _type:longint):longint;cdecl;external libc_nlm name 'NXLinkCreate';


function NXLinkCreateSymbolic(srcPathCtx:NXPathCtx_t; linkname:pointer; target:pointer):longint;cdecl;external libc_nlm name 'NXLinkCreateSymbolic';
{ macro for useful alias...  }
{ basic change bits for NXSetAttr()...  }
{ flag values for NXDirAttr_t and NXDeEnum_t, etc...  }
{ deEffectiveRights bits  }

{ turn on 1-byte packing...  }

  { basic change bits for NXSetAttr()...  }

  const
     NX_DIRENT_EFFECTIVERIGHTS = $0000000000000001;
     NX_DIRENT_FLAGS = $0000000000000002;
     NX_DIRENT_OWNERID = $0000000000000004;
     NX_DIRENT_CREATETIME = $0000000000000008;
     NX_DIRENT_CHANGETIME = $0000000000000010;
     NX_DIRENT_ACCESSTIME = $0000000000000020;
     NX_DIRENT_MODIFYTIME = $0000000000000040;
     NX_DIRENT_ATTRIBUTES = $0000000000000080;
     NX_DIRENT_RESERVED1 = $0000000000000100;
     NX_DIRENT_RESERVED2 = $0000000000000200;
     NX_DIRENT_RESERVED3 = $0000000000000400;
     NX_DIRENT_RESERVED4 = $0000000000000800;
  { flag values for NXDirAttr_t and NXDeEnum_t, etc...  }
     NX_DEFLAGS_COMPRESSED = $00000001;
     NX_DEFLAGS_ENCRYPTED = $00000002;
     NX_DEFLAGS_TEMPORARY = $00000004;
     NX_DEFLAGS_MIGRATED = $00000008;
     NX_DEFLAGS_DELETED = $00000010;
     NX_DEFLAGS_SPARSE = $00000020;
  { deEffectiveRights bits  }
     NX_READ_EXISTING_FILE = $00000001;
     NX_WRITE_EXISTING_FILE = $00000002;
     NX_CREATE_NEW_ENTRY = $00000008;
     NX_DELETE_EXISTING_ENTRY = $00000010;
     NX_CHANGE_ACCESS_CONTROL = $00000020;
     NX_SEE_FILES = $00000040;
     NX_MODIFY_ENTRY = $00000080;
     NX_SUPERVISOR_PRIVILEGES = $00000100;
     NX_ACCESS_RIGHTS_MASK = $000001FB;



type

   PNXChangeBits_t = ^NXChangeBits_t;
   NXChangeBits_t = Tuint64;
   TNXChangeBits = NXChangeBits_t;
   PNXChangeBits = PNXChangeBits_t;
{ pathname format (PNF) enumeration         }
{ use PNF in effect at open                 }
{ generic NKS pathname format               }
{ DOS                                       }
{ Macintosh/AFP 3.0                         }
{ UNIX/NFS                                  }
{ Windows NT, OS/2                          }
{ Novell Storage Services (NSS)             }

   PNXPathFormat_t = ^NXPathFormat_t;
   NXPathFormat_t =  Longint;
   Const
     NX_PNF_DEFAULT = 2147483647;
     NX_PNF_NKS = 0;
     NX_PNF_DOS = 1;
     NX_PNF_MAC = 2;
     NX_PNF_UNIX = 4;
     NX_PNF_WIN = 5;
     NX_PNF_NSS = 7;

{ basic attribute information              }
{ filename                                 }
{ extended file system information         }
type

   PNXDeLevel_t = ^NXDeLevel_t;
   NXDeLevel_t =  Longint;
   Const
     NX_DELEVEL_BASIC = $7FFFFFFF;
     NX_DELEVEL_NAME_ONLY = $80000000;
     NX_DELEVEL_EXTENDED = $80000001;

{ marking place in directory enumeration    }
{ all private to implementation             }
type

   PNXDirMark_t = ^NXDirMark_t;
   NXDirMark_t = record
        mark : array[0..43] of byte;
        pathCtx : pointer;
        entryInfo : pointer;
     end;
{ structure size is 52 bytes on NetWare     }
{ information common to all PNF structures  }
{ total length of entry including any       }
{ type of entry (file, FIFO, etc.)          }
{ file system yielding information          }
{ level specified in NXDirEnumStart()       }

   PNXDeHeader_t = ^NXDeHeader_t;
   NXDeHeader_t = record
        length     : size_t;
        objectType : NXObjType_t;
        pathFormat : NXPathFormat_t;
        infoLevel  : NXDeLevel_t;
     end;
   PNXDeHeader = PNXDeHeader_t;
   TNDDeHeader = NXDeHeader_t;
{ common information                        }
{                                           }
{ length of file                            }
{ compressed, sparse, encrypted, etc.       }
{ timestamp of last attribute change        }
{ timestamp of last write+attribute change  }
{ timestamp of last write                   }
{ preferred I/O blocksize                   }

   PNXDirAttr_t = ^NXDirAttr_t;
   NXDirAttr_t = record
        deHeader : NXDeHeader_t;
        deFid : NXFid_t;
        deEffectiveRights : dword;
        deFileSize : NXOffset_t;
        deFlags : Tuint64;
        deAttrChangeTime : NXTime_t;
        deAccessTime : NXTime_t;
        deModifyTime : NXTime_t;
        deIoBlockSize : size_t;
     end;
{ plus name                                 }

   PNXDirAttrWithName_t = ^NXDirAttrWithName_t;
   NXDirAttrWithName_t = record
        deHeader : NXDeHeader_t;
        deName : pointer;
     end;
{ information fields                        }
{ NXDirEnum- navigational mark              }

   PNXDirEnum_t = ^NXDirEnum_t;
   NXDirEnum_t = record
        deDirAttr : NXDirAttr_t;
        deDirMark : NXDirMark_t;
        deName : pointer;
     end;
{ generic NKS (NX_PNF_NKS) attributes       }

   PNXDirAttrNks_t = ^NXDirAttrNks_t;
   NXDirAttrNks_t = record
        xdeHeader : NXDeHeader_t;
        xdeFid : NXFid_t;
        xdeEffectiveRights : dword;
        xdeFileSize : NXOffset_t;
        xdeFlags : Tuint64;
        xdeChangeTime : NXTime_t;
        xdeAccessTime : NXTime_t;
        xdeModifyTime : NXTime_t;
        xdeCreateTime : NXTime_t;
        xdeOwnerId : NXGuid_t;
     end;
{ generic NKS (NX_PNF_NKS) information...   }
{ ...including name                         }

   PNXDirEnumNks_t = ^NXDirEnumNks_t;
   NXDirEnumNks_t = record
        deNksDirAttr : NXDirAttrNks_t;
        deDirMark : NXDirMark_t;
        deName : pointer;
     end;

(** unsupported pragma#pragma pack()*)
{ Path context...  }

function NXFreePathContext(pathCtx:NXPathCtx_t):longint;cdecl;external libc_nlm name 'NXFreePathContext';

function NXCreatePathContext(pathCtx:NXPathCtx_t; pathname:pchar; format:NXPathFormat_t; securityBadge:pointer; newPathCtx:PNXPathCtx_t):longint;cdecl;external libc_nlm name 'NXCreatePathContext';
function NXCreatePathContext(pathCtx:NXPathCtx_t; pathname:pchar; format:NXPathFormat_t; securityBadge:pointer; var newPathCtx:NXPathCtx_t):longint;cdecl;external libc_nlm name 'NXCreatePathContext';
function NXCreatePathContextWithFid(fid:NXFid_t; format:NXPathFormat_t; securityBadge:pointer; newPathCtx:PNXPathCtx_t):longint;cdecl;external libc_nlm name 'NXCreatePathContextWithFid';
{ Directory I/O...  }

function NXDirCreate(pathCtx:NXPathCtx_t; pathname:pointer; reserved:pointer; newPathCtx:PNXPathCtx_t):longint;cdecl;external libc_nlm name 'NXDirCreate';

function NXDirRemove(pathCtx:NXPathCtx_t; pathname:pointer):longint;cdecl;external libc_nlm name 'NXDirRemove';
{ Directory entry attributes...  }

function NXGetAttr(pathCtx:NXPathCtx_t; pathname:pointer; level:NXDeLevel_t; buffer:pointer; length:size_t;
           flags:dword):longint;cdecl;external libc_nlm name 'NXGetAttr';
function NXGetAttrWithHandle(handle:NXHandle_t; format:NXPathFormat_t; level:NXDeLevel_t; buffer:pointer; length:size_t;
           flags:dword):longint;cdecl;external libc_nlm name 'NXGetAttrWithHandle';


function NXSetAttr(pathCtx:NXPathCtx_t; pathname:pointer; level:NXDeLevel_t; buffer:pointer; changeBits:NXChangeBits_t):longint;cdecl;external libc_nlm name 'NXSetAttr';

function NXSetAttrWithHandle(handle:NXHandle_t; format:NXPathFormat_t; level:NXDeLevel_t; buffer:pointer; changeBits:NXChangeBits_t):longint;cdecl;external libc_nlm name 'NXSetAttrWithHandle';
{ Subdirectory enumeration...  }
function NXDirMarkInit(handle:NXHandle_t; dirMark:PNXDirMark_t):longint;cdecl;external libc_nlm name 'NXDirMarkInit';
function NXDirMarkInit(handle:NXHandle_t; var dirMark:NXDirMark_t):longint;cdecl;external libc_nlm name 'NXDirMarkInit';
function NXDirEnumEnd(handle:NXHandle_t):longint;cdecl;external libc_nlm name 'NXDirEnumEnd';
function NXDirEnumGetEntries(handle:NXHandle_t; start:PNXDirMark_t; buffer:pointer; length:size_t; entriesReturned:Psize_t;
           next:PNXDirMark_t; sequenceGuarantee:PNXBool_t):longint;cdecl;external libc_nlm name 'NXDirEnumGetEntries';

function NXDirEnumStart(pathCtx:NXPathCtx_t; pathname:pchar; level:NXDeLevel_t; handle:PNXHandle_t):longint;cdecl;external libc_nlm name 'NXDirEnumStart';
function NXDirEnumStart(pathCtx:NXPathCtx_t; pathname:pchar; level:NXDeLevel_t; var handle:NXHandle_t):longint;cdecl;external libc_nlm name 'NXDirEnumStart';


// nks/doswin.h
// wchar.h
{ turn on 1-byte packing...  }

type

   Pwint_t = ^wint_t;
   wint_t = longint;

   Pwuchar_t = ^wuchar_t;
   wuchar_t = word;

   Pmbstate_t = ^mbstate_t;
   mbstate_t = longint;

(** unsupported pragma#pragma pack()*)


function mbsrtowcs(__restrict:Pwchar_t; __restrict1:PPchar; _para3:size_t; __restrict2:Pmbstate_t):size_t;cdecl;external libc_nlm name 'mbsrtowcs';

{$ifndef DisableArrayOfConst}
function fwprintf(__restrict:P_iobuf; __restrict1:Pwchar_t; args:array of const):longint;cdecl;external libc_nlm name 'fwprintf';
{$endif}
function fwprintf(__restrict:P_iobuf; __restrict1:Pwchar_t):longint;cdecl;external libc_nlm name 'fwprintf';

{$ifndef DisableArrayOfConst}
function fwscanf(__restrict:P_iobuf; __restrict1:Pwchar_t; args:array of const):longint;cdecl;external libc_nlm name 'fwscanf';
{$endif}
function fwscanf(__restrict:P_iobuf; __restrict1:Pwchar_t):longint;cdecl;external libc_nlm name 'fwscanf';

{$ifndef DisableArrayOfConst}
function swprintf(__restrict:Pwchar_t; _para2:size_t; __restrict1:Pwchar_t; args:array of const):longint;cdecl;external libc_nlm name 'swprintf';
{$endif}
function swprintf(__restrict:Pwchar_t; _para2:size_t; __restrict1:Pwchar_t):longint;cdecl;external libc_nlm name 'swprintf';

{$ifndef DisableArrayOfConst}
function swscanf(__restrict:Pwchar_t; __restrict1:Pwchar_t; args:array of const):longint;cdecl;external libc_nlm name 'swscanf';
{$endif}
function swscanf(__restrict:Pwchar_t; __restrict1:Pwchar_t):longint;cdecl;external libc_nlm name 'swscanf';

function vfwprintf(__restrict:P_iobuf; __restrict1:Pwchar_t; _para3:va_list):longint;cdecl;external libc_nlm name 'vfwprintf';

function vfwscanf(_para1:P_iobuf; _para2:Pwchar_t; _para3:va_list):longint;cdecl;external libc_nlm name 'vfwscanf';

function vwscanf(_para1:Pwchar_t; _para2:va_list):longint;cdecl;external libc_nlm name 'vwscanf';
function vswscanf(_para1:Pwchar_t; _para2:Pwchar_t; _para3:va_list):longint;cdecl;external libc_nlm name 'vswscanf';
function wcrtomb(__restrict:Pchar; _para2:wchar_t; __restrict1:Pmbstate_t):size_t;cdecl;external libc_nlm name 'wcrtomb';
function wcscat(__restrict:Pwchar_t; __restrict1:Pwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcscat';
function wcschr(_para1:Pwchar_t; _para2:wchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcschr';
function wcscmp(_para1:Pwchar_t; _para2:Pwchar_t):longint;cdecl;external libc_nlm name 'wcscmp';
function wcscoll(_para1:Pwchar_t; _para2:Pwchar_t):longint;cdecl;external libc_nlm name 'wcscoll';
function wcscpy(__restrict:Pwchar_t; __restrict1:Pwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcscpy';
function wcscspn(_para1:Pwchar_t; _para2:Pwchar_t):size_t;cdecl;external libc_nlm name 'wcscspn';
function wcsftime(__restrict:Pwchar_t; _para2:size_t; __restrict1:Pwchar_t; __restrict2:Ptm):size_t;cdecl;external libc_nlm name 'wcsftime';
function wcslen(_para1:Pwchar_t):size_t;cdecl;external libc_nlm name 'wcslen';
function wcsncat(__restrict:Pwchar_t; __restrict1:Pwchar_t; _para3:size_t):Pwchar_t;cdecl;external libc_nlm name 'wcsncat';
function wcsncmp(_para1:Pwchar_t; _para2:Pwchar_t; _para3:size_t):longint;cdecl;external libc_nlm name 'wcsncmp';
function wcsncpy(__restrict:Pwchar_t; __restrict1:Pwchar_t; _para3:size_t):Pwchar_t;cdecl;external libc_nlm name 'wcsncpy';
function wcspbrk(_para1:Pwchar_t; _para2:Pwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcspbrk';
function wcsrchr(_para1:Pwchar_t; _para2:wchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcsrchr';
function wcsrtombs(__restrict:Pchar; __restrict1:PPwchar_t; _para3:size_t; __restrict2:Pmbstate_t):size_t;cdecl;external libc_nlm name 'wcsrtombs';
function wcsspn(_para1:Pwchar_t; _para2:Pwchar_t):size_t;cdecl;external libc_nlm name 'wcsspn';
function wcsstr(_para1:Pwchar_t; _para2:Pwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcsstr';
function wcstod(__restrict:Pwchar_t; __restrict1:PPwchar_t):double;cdecl;external libc_nlm name 'wcstod';
function wcstof(__restrict:Pwchar_t; __restrict1:PPwchar_t):double;cdecl;external libc_nlm name 'wcstof';
function wcstok(__restrict:Pwchar_t; __restrict1:Pwchar_t; __restrict2:PPwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcstok';
function wcstok_r(__restrict:Pwchar_t; __restrict1:Pwchar_t; __restrict2:PPwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcstok_r';
function wcstol(__restrict:Pwchar_t; __restrict1:PPwchar_t; xx:longint):longint;cdecl;external libc_nlm name 'wcstol';

// long double wcstold(const wchar_t * __restrict1, wchar_t ** __restrict);
// long double wcstold(const wchar_t * __restrict1, wchar_t ** __restrict);

function wcstoll(__restrict:Pwchar_t; __restrict1:PPwchar_t; xx:longint):Tint64;cdecl;external libc_nlm name 'wcstoll';
function wcstoul(__restrict:Pwchar_t; __restrict1:PPwchar_t; _para3:longint):dword;cdecl;external libc_nlm name 'wcstoul';
function wcstoull(__restrict:Pwchar_t; __restrict1:PPwchar_t; _para3:longint):Tuint64;cdecl;external libc_nlm name 'wcstoull';
function wcsxfrm(__restrict:Pwchar_t; __restrict1:Pwchar_t; _para3:size_t):size_t;cdecl;external libc_nlm name 'wcsxfrm';
function wctob(_para1:wint_t):longint;cdecl;external libc_nlm name 'wctob';
function wmemchr(ws:Pwchar_t; wc:wchar_t; n:size_t):Pwchar_t;cdecl;external libc_nlm name 'wmemchr';
function wmemcmp(__restrict:Pwchar_t; __restrict1:Pwchar_t; _para3:size_t):longint;cdecl;external libc_nlm name 'wmemcmp';
function wmemcpy(__restrict:Pwchar_t; __restrict1:Pwchar_t; _para3:size_t):Pwchar_t;cdecl;external libc_nlm name 'wmemcpy';
function wmemmove(_para1:Pwchar_t; _para2:Pwchar_t; _para3:size_t):Pwchar_t;cdecl;external libc_nlm name 'wmemmove';
function wmemset(ws:Pwchar_t; wc:wchar_t; n:size_t):Pwchar_t;cdecl;external libc_nlm name 'wmemset';
function putwc(_para1:wchar_t; _para2:P_iobuf):wint_t;cdecl;external libc_nlm name 'putwc';
function putwchar(_para1:wchar_t):wint_t;cdecl;external libc_nlm name 'putwchar';
function fwide(_para1:P_iobuf; _para2:longint):longint;cdecl;external libc_nlm name 'fwide';
function fputwc(_para1:wchar_t; _para2:P_iobuf):wint_t;cdecl;external libc_nlm name 'fputwc';
function fputws(__restrict:Pwchar_t; __restrict1:P_iobuf):longint;cdecl;external libc_nlm name 'fputws';
function fgetwc(_para1:P_iobuf):wint_t;cdecl;external libc_nlm name 'fgetwc';
function fgetws(__restrict:Pwchar_t; _para2:longint; __restrict1:P_iobuf):Pwchar_t;cdecl;external libc_nlm name 'fgetws';
function getwc(_para1:P_iobuf):wint_t;cdecl;external libc_nlm name 'getwc';
function getwchar:wint_t;cdecl;external libc_nlm name 'getwchar';
function ungetwc(_para1:wint_t; __restrict:P_iobuf):wint_t;cdecl;external libc_nlm name 'ungetwc';

{$ifndef DisableArrayOfConst}
function wprintf(__restrict:Pwchar_t; args:array of const):longint;cdecl;external libc_nlm name 'wprintf';
{$endif}
function wprintf(__restrict:Pwchar_t):longint;cdecl;external libc_nlm name 'wprintf';

{$ifndef DisableArrayOfConst}
function wscanf(__restrict:Pwchar_t; args:array of const):longint;cdecl;external libc_nlm name 'wscanf';
{$endif}
function wscanf(__restrict:Pwchar_t):longint;cdecl;external libc_nlm name 'wscanf';
function vwprintf(__restrict:Pwchar_t; _para2:va_list):longint;cdecl;external libc_nlm name 'vwprintf';
function vswprintf(__restrict:Pwchar_t; _para2:size_t; __restrict1:Pwchar_t; _para4:va_list):longint;cdecl;external libc_nlm name 'vswprintf';
function wcscasecmp(_para1:Pwchar_t; _para2:Pwchar_t):longint;cdecl;external libc_nlm name 'wcscasecmp';
function wcserror(_para1:longint):Pwchar_t;cdecl;external libc_nlm name 'wcserror';
function wcsicmp(_para1:Pwchar_t; _para2:Pwchar_t):longint;cdecl;external libc_nlm name 'wcsicmp';
function wcsindex(_para1:Pwchar_t; _para2:Pwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcsindex';

{$ifndef DisableArrayOfConst}
function wcslist(_para1:Pwchar_t; _para2:Pwchar_t; args:array of const):Pwchar_t;cdecl;external libc_nlm name 'wcslist';
{$endif}
function wcslist(_para1:Pwchar_t; _para2:Pwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcslist';
function wcslwr(_para1:Pwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcslwr';
function wcsmemcmp(__restrict:Pwchar_t; __restrict1:Pwchar_t; _para3:size_t):longint;cdecl;external libc_nlm name 'wcsmemcmp';
function wcsmemcpy(__restrict:Pwchar_t; __restrict1:Pwchar_t; _para3:size_t):Pwchar_t;cdecl;external libc_nlm name 'wcsmemcpy';
function wcsmemmove(_para1:Pwchar_t; _para2:Pwchar_t; _para3:size_t):Pwchar_t;cdecl;external libc_nlm name 'wcsmemmove';
function wcsncasecmp(_para1:Pwchar_t; _para2:Pwchar_t; _para3:size_t):longint;cdecl;external libc_nlm name 'wcsncasecmp';
function wcsnicmp(_para1:Pwchar_t; _para2:Pwchar_t; _para3:size_t):longint;cdecl;external libc_nlm name 'wcsnicmp';
function wcsnset(_para1:Pwchar_t; _para2:longint; _para3:size_t):Pwchar_t;cdecl;external libc_nlm name 'wcsnset';
function wcsrev(_para1:Pwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcsrev';
function wcsrindex(_para1:Pwchar_t; _para2:size_t; _para3:longint):Pwchar_t;cdecl;external libc_nlm name 'wcsrindex';
function wcsset(_para1:Pwchar_t; _para2:longint):Pwchar_t;cdecl;external libc_nlm name 'wcsset';
function wcsupr(_para1:Pwchar_t):Pwchar_t;cdecl;external libc_nlm name 'wcsupr';
procedure wungettok(__restrict:Pwchar_t; __restrict1:Pwchar_t; __restrict2:PPwchar_t);cdecl;external libc_nlm name 'wungettok';
procedure wungettok_r(__restrict:Pwchar_t; __restrict1:Pwchar_t; __restrict2:PPwchar_t);cdecl;external libc_nlm name 'wungettok_r';
function btowc(_para1:longint):wint_t;cdecl;external libc_nlm name 'btowc';
function mbrlen(__restrict:Pchar; _para2:size_t; __restrict1:Pmbstate_t):longint;cdecl;external libc_nlm name 'mbrlen';
function mbrtowc(__restrict:Pwchar_t; __restrict1:Pchar; _para3:size_t; __restrict2:Pmbstate_t):longint;cdecl;external libc_nlm name 'mbrtowc';
function mbsinit(_para1:Pmbstate_t):longint;cdecl;external libc_nlm name 'mbsinit';
function wcwidth(_para1:wchar_t):longint;cdecl;external libc_nlm name 'wcwidth';
function wcswidth(_para1:Pwchar_t; _para2:size_t):longint;cdecl;external libc_nlm name 'wcswidth';
{ macros that overcome implementation's function call overhead...  }
{ attributes for NXDirAttrDos_t 'attrib' field...  }


// fsio.h
// netware.h
  const
     LD_MODULE_REENTRANT_BIT       = $00000001;
     LD_MODULE_MULTIPLE_LOAD       = $00000002;       { multiple load            }
     LD_SYNCHRONIZE_START          = $00000004;       { uses SynchronizeStart()  }
     LD_PSEUDOPREEMPTION_BIT       = $00000008;       { accept preemption        }
     LD_KERNEL_LOAD                = $00000010;       { ring 0-only              }
     LD_DONT_SHARE_CODE            = $00000020;
  { once dependencies gone   }
     LD_AUTO_UNLOAD                = $00000040;
     LD_HIDDEN_MODULE              = $00000080;
     LD_DIGITALLY_SIGNED_FILE      = $00000100;
     LD_PROTECTED_LOAD             = $00000200;       { protected address space  }
     LD_SHARED_LIBRARY             = $00000400;
     LD_RESTARTABLE                = $00000800;
     LD_MODULE_HAS_MPK_STUBS       = $00001000;
     LD_NOT_MULTIPROCESSOR_SAFE    = $00002000;
     LD_PREEMPTABLE                = $00004000;
     LD_HAS_SYSTEM_CALLS           = $00008000;
     LD_VIRTUAL_MEMORY             = $00010000;
     LD_ALL_EXPORTS_SAFE           = $00020000;
     LD_RESERVED_1                 = $00040000;
     LD_RESERVED_2                 = $00080000;
     LD_RESERVED_3                 = $00100000;
     LD_RESERVED_4                 = $00200000;
     LD_WANT_POSIX_SEMANTICS       = $00400000;       { assume POSIX semantics   }
     LD_UTF8_STRINGS               = $00800000;       { UTF-8 strings            }
     LD_TSR                        = $01000000;       { terminate-stay-resident  }
     LD_PROMPT_USER_AND_PASSWORD   = $02000000;       { with LD_WANT_POSIX...    }
     LD_HOTSWAP_DRIVER             = $04000000;
     LD_STARTUP_DEVICE_NLM_BIT     = $08000000;
     LD_BOUND_NLM_BIT              = $10000000;
     LD_DONT_UNLOAD_BIT            = $20000000;       { never unload             }
     LD_MODULE_BEING_DEBUGGED      = $40000000;       { (debugging)              }
     LD_MEMORY_ON_4K_BOUNDRIES_BIT = $80000000;       { (debugging)              }
  { Note LD_UNICODE_STRINGS mostly obsolete--used only by NKS applications:   }
     LD_UNICODE_STRINGS            = $02000000;       { Unicode strings          }


type
   Prtag_t = ^rtag_t;
   rtag_t = pointer;
   Trtag = rtag_t;
   Prtag = Prtag_t;

   {this is from the lan driver sdk () cmsm.h

    but be warned, like the ScanScreen function available in
    clib, there is no MP save way to access netware screens, a
    comment from Russell Bateman (libc developer @ novell) dated
    way to do screen discovery on NetWare. }

   PScreenStruct = ^TScreenStruct;
   TScreenStruct = packed record
     previousScreen       : PScreenStruct;
     nextScreen           : PScreenStruct;
     popUpOriginalScreen  : PScreenStruct;
     CLIBScreenStructure  : pdword;
     currentPalette       : byte;
     _Filler1             : byte;
     popUpCount           : byte;
     _Filler2             : byte;
     screenList           : byte;
     _Filler3             : byte;
     activeCount          : byte;
     _Filler4             : byte;
     resourceTag          : Prtag_t;
     screenName           : pchar;
     screenMemory         : pointer;
     flags                : dword;
     state                : dword;
     outputCursorPosition : word;
     inputCursorPosition  : word;
   end;

   Pscr_t = ^scr_t;
   scr_t = PScreenStruct;
   TScr = scr_t;
   PScr = Pscr_t;

// event.h
// screen.h

  const
     MAX_SCREEN_STRING_LEN = 255;
  { screen mode flags...  }
     SCR_NO_MODE           = $00000000;
     SCR_AUTOCLOSE_ON_EXIT = $00000001;   // default
     SCR_COLOR_ATTRS       = $00000002;
  { key types...  }
     NORMAL_KEY        = $00;
     FUNCTION_KEY      = $01;
     ENTER_KEY         = $02;
     ESCAPE_KEY        = $03;
     BACKSPACE_KEY     = $04;
     DELETE_KEY        = $05;
     INSERT_KEY        = $06;
     CURSOR_UP_KEY     = $07;
     CURSOR_DOWN_KEY   = $08;
     CURSOR_RIGHT_KEY  = $09;
     CURSOR_LEFT_KEY   = $0A;
     CURSOR_HOME_KEY   = $0B;
     CURSOR_END_KEY    = $0C;
     CURSOR_PUP_KEY    = $0D;
     CURSOR_PDOWN_KEY  = $0E;
  { some name equivalents...  }
     ENTER             = $0D;
     ESCAPE            = $1B;
     BACKSPACE         = $08;
  { modifier code constituents...  }
     SHIFT_KEY_HELD    = $01;
     CTRL_KEY_HELD     = $04;
     ALT_KEY_HELD      = $08;
     CAPS_LOCK_IS_ON   = $40;
     NUM_LOCK_IS_ON    = $20;
     SCROLL_LOCK_IS_ON = $10;
     _PASSWORD_LEN     = 128;  // suggested 'maxlen' argument for getpassword()...
  { string-embeddable color representations...  }
     COLOR_STR_BLACK   = '\x1B[0;30m';
     COLOR_STR_MAROON  = '\x1B[0;31m';
     COLOR_STR_GREEN   = '\x1B[0;32m';
     COLOR_STR_OLIVE   = '\x1B[0;33m';
     COLOR_STR_NAVY    = '\x1B[0;34m';
     COLOR_STR_PURPLE  = '\x1B[0;35m';
     COLOR_STR_TEAL    = '\x1B[0;36m';
     COLOR_STR_SILVER  = '\x1B[0;37m';
     COLOR_STR_GREY    = '\x1B[1;30m';
     COLOR_STR_RED     = '\x1B[1;31m';
     COLOR_STR_LIME    = '\x1B[1;32m';
     COLOR_STR_YELLOW  = '\x1B[1;33m';
     COLOR_STR_BLUE    = '\x1B[1;34m';
     COLOR_STR_MAGENTA = '\x1B[1;35m';
     COLOR_STR_CYAN    = '\x1B[1;36m';
     COLOR_STR_WHITE   = '\x1B[1;37m';

     COLOR_STR_NORMAL  = COLOR_STR_SILVER;  // dim/unhighlighted white
     COLOR_STR_GRAY    = COLOR_STR_GREY;
  { attributes for OutputToScreenWithAttributes(); cf. HTML color names  }

     COLOR_ATTR_NONE   = 0;            // black, no color at all
     COLOR_ATTR_NAVY   = 1;            // dim blue
     COLOR_ATTR_BLUE   = $01 or 8;
     COLOR_ATTR_GREEN  = 2;
     COLOR_ATTR_LIME   = 2 or 8;       // bright green
     COLOR_ATTR_TEAL   = 3;            // dim cyan
     COLOR_ATTR_CYAN   = 3 or 8;
     COLOR_ATTR_MAROON = 4;            // dim red
     COLOR_ATTR_RED    = 4 or 8;
     COLOR_ATTR_PURPLE = 5;
     COLOR_ATTR_MAGENTA= 5 or 8;       // bright purple
     COLOR_ATTR_OLIVE  = 6;            // brown, dim yellow
     COLOR_ATTR_YELLOW = 6 or 8;
     COLOR_ATTR_SILVER = 7;            // normal white, dim/unhighlighted
     COLOR_ATTR_GREY   = 8;            // dimmed white
     COLOR_ATTR_WHITE  = 15;           // bright, highlighted white

  const
//     OutputToScreenWithVaList = OutputToScreenWithPointer;
  { return and default values for Prompt functions...  }
     SCR_PROMPT_ANSWER_NO   = 0;
     SCR_PROMPT_ANSWER_YES  = 1;
     SCR_PROMPT_ANSWER_SKIP = 2;
     SCR_PROMPT_ANSWER_ALL  = 3;

  { cursor types...  }
     CURSOR_NORMAL = $0C0B;
     CURSOR_THICK  = $0C09;
     CURSOR_BLOCK  = $0C00;
     CURSOR_TOP    = $0400;
  { screen types...  }
     SCREEN_TYPE_TTY         = $00000000;
     SCREEN_TYPE_MONOCHROME  = $00000001;
     SCREEN_TYPE_DUAL_MODE   = $00000002;
     SCREEN_TYPE_CGA         = $00000003;
     SCREEN_TYPE_EGA         = $00000004;
     SCREEN_TYPE_VGA         = $00000005;
  { screen modes...  }
     SCREEN_MODE_TTY         = $00000000;
     SCREEN_MODE_80X25       = $00000001;
     SCREEN_MODE_80X43       = $00000002;
     SCREEN_MODE_80X50       = $00000003;
     SCREEN_MODE_D           = $0000000D;
     SCREEN_MODE_E           = $0000000E;
     SCREEN_MODE_F           = $0000000F;
     SCREEN_MODE_10          = $00000010;
     SCREEN_MODE_11          = $00000011;
     SCREEN_MODE_12          = $00000012;
     SCREEN_MODE_13          = $00000013;
  { voracious for memory!  }
     SCREEN_MODE_SCROLLABLE  = $80000000;
  { screen state...  }
     SCREEN_NON_SWITCHABLE   = $00000001;
     SCREEN_DUMMY            = $00000100;
     SCREEN_HIDDEN           = $00000200;

procedure clearscreen;cdecl;external libc_nlm name 'clearscreen';

{$ifndef DisableArrayOfConst}
function consoleprintf(txt:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'consoleprintf';
function consoleprintf(txt:Pchar):longint;cdecl;external libc_nlm name 'consoleprintf';
{$endif}
function __consoleprintfl1(txt:Pchar;p1:longint):longint;cdecl;external libc_nlm name 'consoleprintf';
function __consoleprintfl2(txt:Pchar;p1,p2:longint):longint;cdecl;external libc_nlm name 'consoleprintf';
function __consoleprintfl3(txt:Pchar;p1,p2,p3:longint):longint;cdecl;external libc_nlm name 'consoleprintf';
function getscreenmode(mode:Pdword):longint;cdecl;external libc_nlm name 'getscreenmode';
function getscreenmode(var mode:dword):longint;cdecl;external libc_nlm name 'getscreenmode';
function getcharacter:longint;cdecl;external libc_nlm name 'getcharacter';
function getkey(keytype,modifer,scancode:Plongint):longint;cdecl;external libc_nlm name 'getkey';
function getkey(var keytype, modifer, scancode:longint):longint;cdecl;external libc_nlm name 'getkey';
function getalternateconsole:scr_t;cdecl;external libc_nlm name 'getalternateconsole';
function getnetwareconsole:scr_t;cdecl;external libc_nlm name 'getnetwareconsole';
function getnetwarelogger:scr_t;cdecl;external libc_nlm name 'getnetwarelogger';

function getpassword(prompt,password:Pchar; maxlen:size_t):Pchar;cdecl;external libc_nlm name 'getpassword';
function getscreenhandle:scr_t;cdecl;external libc_nlm name 'getscreenhandle';
function getstring(_string:Pchar; max:size_t; display:longint):Pchar;cdecl;external libc_nlm name 'getstring';
function gotorowcol(row, col:longint):longint;cdecl;external libc_nlm name 'gotorowcol';
function kbhit:longint;cdecl;external libc_nlm name 'kbhit';
function pressanykey:longint;cdecl;external libc_nlm name 'pressanykey';
function pressanykeytocontinue:longint;cdecl;external libc_nlm name 'pressanykey';
function pressescape:longint;cdecl;external libc_nlm name 'pressescape';
function pressenter:longint;cdecl;external libc_nlm name 'pressenter';
function putcharacter(ch:longint):longint;cdecl;external libc_nlm name 'putcharacter';

function putstring(_string:Pchar):longint;cdecl;external libc_nlm name 'putstring';

{$ifndef DisableArrayOfConst}
function screenprintf(_para1:scr_t; _para2:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'screenprintf';
{$endif}
function screenprintf(_para1:scr_t; _para2:Pchar):longint;cdecl;external libc_nlm name 'screenprintf';
function screenprintf(_para1:scr_t; _para2:Pchar; l1:longint):longint;cdecl;external libc_nlm name 'screenprintf';
function screenprintf(_para1:scr_t; _para2:Pchar; l1,l2:longint):longint;cdecl;external libc_nlm name 'screenprintf';
function screenprintf(_para1:scr_t; _para2:Pchar; l1,l2,l3:longint):longint;cdecl;external libc_nlm name 'screenprintf';

function setscreenmode(mode:dword):longint;cdecl;external libc_nlm name 'setscreenmode';

function renamescreen(name:Pchar):longint;cdecl;external libc_nlm name 'renamescreen';
procedure ringbell;cdecl;external libc_nlm name 'ringbell';
function ungetcharacter(ch:longint):longint;cdecl;external libc_nlm name 'ungetcharacter';
function ungetkey(keytype:longint; modifer:longint; scancode:longint):longint;cdecl;external libc_nlm name 'ungetkey';

function vconsoleprintf(_para1:Pchar; _para2:va_list):longint;cdecl;external libc_nlm name 'vconsoleprintf';

function vscreenprintf(_para1:scr_t; _para2:Pchar; _para3:va_list):longint;cdecl;external libc_nlm name 'vscreenprintf';
function wherecol:longint;cdecl;external libc_nlm name 'wherecol';
function whererow:longint;cdecl;external libc_nlm name 'whererow';
function whererowcol(row,col:Plongint):longint;cdecl;external libc_nlm name 'whererowcol';
function whererowcol(var row,col:longint):longint;cdecl;external libc_nlm name 'whererowcol';
{ obsolete...  }
function getconsolehandle:scr_t;cdecl;external libc_nlm name 'getconsolehandle';
{ direct NetWare OS interfaces...  }
type

   Pscroll_t = ^scroll_t;
   scroll_t =  Longint;
   Const
     SCROLL_DOWN = 0;
     SCROLL_UP   = 1;
     SCROLL_NONE = 2147483647;


procedure ActivatePopUpScreen(scrID:scr_t);cdecl;external libc_nlm name 'ActivatePopUpScreen';
procedure ActivateScreen(scrID:scr_t);cdecl;external libc_nlm name 'ActivateScreen';
procedure ChangeToSystemConsoleScreen;cdecl;external libc_nlm name 'ChangeToSystemConsoleScreen';
function CheckIfScreenActive(scrID:scr_t; waitFlag:dword):longint;cdecl;external libc_nlm name 'CheckIfScreenActive';
function CheckKeyStatus(scrID:scr_t):longint;cdecl;external libc_nlm name 'CheckKeyStatus';
procedure ClearScreen(scrID:scr_t);cdecl;external libc_nlm name 'ClearScreen';
procedure CloseScreen(scrID:scr_t);cdecl;external libc_nlm name 'CloseScreen';
procedure ConsoleHungMenu;cdecl;external libc_nlm name 'ConsoleHungMenu';
procedure DisableInputCursor(scrID:scr_t);cdecl;external libc_nlm name 'DisableInputCursor';
function DisplayScreenLine(scrID:scr_t; line:dword; col:dword; length:dword; textAndAttr:Pbyte):longint;cdecl;external libc_nlm name 'DisplayScreenLine';
function DisplayScreenText(scrID:scr_t; line:dword; col:dword; length:dword; text:Pchar):longint;cdecl;external libc_nlm name 'DisplayScreenText';
function DisplayScreenTextWithAttribute(scrID:scr_t; line:dword; col:dword; length:dword; lineAttr:byte;
           text:Pchar):longint;cdecl;external libc_nlm name 'DisplayScreenTextWithAttribute';
procedure EnableInputCursor(scrID:scr_t);cdecl;external libc_nlm name 'EnableInputCursor';
procedure EndPopUpScreen(scr:scr_t);cdecl;external libc_nlm name 'EndPopUpScreen';
function FillScreenArea(scrID:scr_t; line:dword; col:dword; height:dword; width:dword;
           character:char; attr:byte):longint;cdecl;external libc_nlm name 'FillScreenArea';
function FillScreenAreaAttribute(scrID:scr_t; line:dword; col:dword; height:dword; width:dword;
           attr:byte):longint;cdecl;external libc_nlm name 'FillScreenAreaAttribute';
function GetActiveScreen:scr_t;cdecl;external system_nlm name 'GetActiveScreen';
function GetActualScreenSize(scrID:scr_t; height:Pdword; width:Pdword; bufferSize:Psize_t):longint;cdecl;external system_nlm name 'GetActualScreenSize';
function GetConsoleSecuredFlag:longint;cdecl;external libc_nlm name 'GetConsoleSecuredFlag';
procedure GetCursorStyle(scrID:scr_t; cursorStyle:Pword);cdecl;external system_nlm name 'GetCursorStyle';
procedure GetCursorStyle(scrID:scr_t; var cursorStyle:word);cdecl;external system_nlm name 'GetCursorStyle';
procedure GetInputCursorPosition(scrID:scr_t; row:Pword; col:Pword);cdecl;external system_nlm name 'GetInputCursorPosition';
procedure GetKey(scrID:scr_t; _type,value,status,scancode:Pbyte;linesToProtect:size_t);cdecl;external system_nlm name 'GetKey';
procedure GetKey(scrID:scr_t; var _type,value,status,scancode:byte;linesToProtect:size_t);cdecl;external system_nlm name 'GetKey';
procedure GetOutputCursorPosition(scrID:scr_t; row,col:Pword);cdecl;external system_nlm name 'GetOutputCursorPosition';
procedure GetOutputCursorPosition(scrID:scr_t; var row,col:word);cdecl;external system_nlm name 'GetOutputCursorPosition';
function GetRawKeyWithScreen(scrID:scr_t; _type,value,status,scancode:Pbyte):longint;cdecl;external libc_nlm name 'GetRawKeyWithScreen';
function GetRawKeyWithScreen(scrID:scr_t; var _type,value,status,scancode:byte):longint;cdecl;external libc_nlm name 'GetRawKeyWithScreen';
function GetScreenAddress:pointer;cdecl;external system_nlm name 'GetScreenAddress';  // not in protected mode
function GetScreenName(scrID:scr_t; nameBuffer:Pchar):longint;cdecl;external system_nlm name 'GetScreenName';
function GetScreenPhysicalAddress:pointer;cdecl;external libc_nlm name 'GetScreenPhysicalAddress';
procedure GetScreenSize(height,width:Pword);cdecl;external system_nlm name 'GetScreenSize';
procedure GetScreenSize(var height,width:word);cdecl;external system_nlm name 'GetScreenSize';

{$ifndef DisableArrayOfConst}
function InputFromScreen(scrID:scr_t; allowedCharacterSet:Pchar; bufferLength:size_t; editWidth:size_t; buffer:Pchar;
           linesToProtect:longint; hasDefaultString:longint; defaultString:Pchar; promptText:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'InputFromScreen';
{$endif}
function InputFromScreen(scrID:scr_t; allowedCharacterSet:Pchar; bufferLength:size_t; editWidth:size_t; buffer:Pchar;
           linesToProtect:longint; hasDefaultString:longint; defaultString:Pchar; promptText:Pchar):longint;cdecl;external libc_nlm name 'InputFromScreen';
function IsScreenModeSupported(screenMode:dword):longint;cdecl;external system_nlm name 'IsScreenModeSupported';

function OpenCustomScreen(name:Pchar; rTag:rtag_t; newScrID:Pscr_t; mode:longint):longint;cdecl;external libc_nlm name 'OpenCustomScreen';

function OpenPopUpScreen(name:Pchar; rTag:rtag_t; newScrID:Pscr_t):longint;cdecl;external libc_nlm name 'OpenPopUpScreen';

function OpenScreen(name:Pchar; rTag:rtag_t; newScrID:Pscr_t):longint;cdecl;external system_nlm name 'OpenScreen';

{$ifndef DisableArrayOfConst}
function OutputToScreen(scrID:scr_t; format:Pchar; args:array of const):longint;cdecl;external system_nlm name 'OutputToScreen';
{$endif}
function OutputToScreen(scrID:scr_t; format:Pchar):longint;cdecl;external system_nlm name 'OutputToScreen';

{$ifndef DisableArrayOfConst}
function OutputToScreenWithAttribute(scrID:scr_t; attr:byte; format:Pchar; args:array of const):longint;cdecl;external system_nlm name 'OutputToScreenWithAttribute';
{$endif}
function OutputToScreenWithAttribute(scrID:scr_t; attr:byte; format:Pchar):longint;cdecl;external system_nlm name 'OutputToScreenWithAttribute';


function OutputToScreenWithPointer(scrID:scr_t; format:Pchar; arguments:va_list):longint;cdecl;external system_nlm name 'OutputToScreenWithPointer';
procedure Pause(scrID:scr_t);cdecl;external system_nlm name 'Pause';
function PauseWithEscape(scrID:scr_t):longint;cdecl;external system_nlm name 'PauseWithEscape';
procedure PositionInputCursor(scrID:scr_t; row:word; col:word);cdecl;external system_nlm name 'PositionInputCursor';
function PositionOutputCursor(scrID:scr_t; row:word; col:word):longint;cdecl;external system_nlm name 'PositionOutputCursor';

function PromptForString(scr:scr_t; length:size_t; editWidth:size_t; _string:Pchar; hasDefaultValue:longint;
           defaultValue:Pchar; linesToProtect:longint; promptText:pointer):Pchar;cdecl;external libc_nlm name 'PromptForString';

function PromptForPassword(scr:scr_t; prompt:Pchar; blotOutChar:longint; password:Pchar; maxlen:size_t):Pchar;cdecl;external libc_nlm name 'PromptForPassword';

{$ifndef DisableArrayOfConst}
function PromptForUnsignedNumber(scrID:scr_t; result:Pdword; minValue:dword; maxValue:dword; radix:longint;
           linesToProtect:longint; hasDefaultValue:byte; defaultValue:dword; promptText:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'PromptForUnsignedNumber';
{$endif}
function PromptForUnsignedNumber(scrID:scr_t; result:Pdword; minValue:dword; maxValue:dword; radix:longint;
           linesToProtect:longint; hasDefaultValue:byte; defaultValue:dword; promptText:Pchar):longint;cdecl;external libc_nlm name 'PromptForUnsignedNumber';

{$ifndef DisableArrayOfConst}
function PromptForYesOrNo(scrID:scr_t; linesToProtect,defaultValue:longint; promptText:pointer; args:array of const):longint;cdecl;external libc_nlm name 'PromptForYesOrNo';
{$endif}
function PromptForYesOrNo(scrID:scr_t; linesToProtect,defaultValue:longint; promptText:pointer):longint;cdecl;external libc_nlm name 'PromptForYesOrNo';

{$ifndef DisableArrayOfConst}
function PromptForYesNoAllOrSkip(scrID:scr_t; linesToProtect:longint; defaultValue:dword; promptText:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'PromptForYesNoAllOrSkip';
{$endif}
function PromptForYesNoAllOrSkip(scrID:scr_t; linesToProtect:longint; defaultValue:dword; promptText:Pchar):longint;cdecl;external libc_nlm name 'PromptForYesNoAllOrSkip';
function ReadScreenCharacter(scrID:scr_t; line,col:dword; character:Pchar):longint;cdecl;external system_nlm name 'ReadScreenCharacter';

function RenameScreen(scrID:scr_t; name:Pchar):longint;cdecl;external system_nlm name 'RenameScreen';
function RestoreFullScreen(scrID:scr_t; buffer:pointer):longint;cdecl;external system_nlm name 'RestoreFullScreen';
function RestoreScreenArea(scrID:scr_t; line,col,height,width:dword; buffer:pointer):longint;cdecl;external system_nlm name 'RestoreScreenArea';
procedure ReturnScreenType(_type,colorFlag:Pdword);cdecl;external system_nlm name 'ReturnScreenType';
procedure ReturnScreenType(var _type,colorFlag:dword);cdecl;external system_nlm name 'ReturnScreenType';
procedure RingTheBell;cdecl;external system_nlm name 'RingTheBell';
function SaveFullScreen(scrID:scr_t; buffer:pointer):longint;cdecl;external system_nlm name 'SaveFullScreen';
function SaveScreenArea(scrID:scr_t; line,col,height,width:dword; buffer:pointer):longint;cdecl;external system_nlm name 'SaveScreenArea';
procedure SetConsoleSecuredFlag(value:byte);cdecl;external system_nlm name 'SetConsoleSecuredFlag';
procedure SetCursorStyle(scrID:scr_t; newStyle:word);cdecl;external system_nlm name 'SetCursorStyle';
procedure SetInputToOutputCursorPosition(scrID:scr_t);cdecl;external system_nlm name 'SetInputToOutputCursorPosition';
function ScrollScreenArea(scrID:scr_t; line,col,height,width,count:dword; newLineAttribute:byte; direction:scroll_t):longint;cdecl;external system_nlm name 'ScrollScreenArea';

procedure ShowTitleBarText(screenMemoryAddress:pointer; titleBarText:Pchar; textLength:size_t);cdecl;external system_nlm name 'ShowTitleBarText';
function UngetKey(scrID:scr_t; _type,value,status,scancode:byte):longint;cdecl;external system_nlm name 'UngetKey';
function ValidateScreenHandle(scrID:scr_t):longint;cdecl;external system_nlm name 'ValidateScreenHandle';
procedure WaitForKey(scrID:scr_t);cdecl;external system_nlm name 'WaitForKey';
function WriteScreenCharacter(scrID:scr_t; line,col:dword; character:char):longint;cdecl;external system_nlm name 'WriteScreenCharacter';
function WriteScreenCharacterAttribute(scrID:scr_t; line,col:dword; character:char; attr:byte):longint;cdecl;external system_nlm name 'WriteScreenCharacterAttribute';

{ turn on 1-byte packing...  }



{ file server event notification interfaces...  }
const
     EVENT_VOL_SYS_MOUNT = 0;
     EVENT_VOL_SYS_DISMOUNT = 1;
     EVENT_ANY_VOL_MOUNT = 2;
     EVENT_ANY_VOL_DISMOUNT = 3;
     EVENT_DOWN_SERVER = 4;        { (see EVENT_PRE_DOWN_SERVER)  }
     EVENT_EXIT_TO_DOS = 7;
     EVENT_MODULE_UNLOAD = 8;
     EVENT_MODULE_UNLOAD_POST_EXIT = 115;
     EVENT_CLEAR_CONNECTION = 9;
     EVENT_LOGIN_USER = 10;
     EVENT_CREATE_BINDERY_OBJ = 11;
     EVENT_DELETE_BINDERY_OBJ = 12;
     EVENT_CHANGE_SECURITY = 13;
     EVENT_CHANGE_SECURITY_ADD_EQUIVALENCE = 1;
     EVENT_ACTIVATE_SCREEN = 14;
     EVENT_UPDATE_SCREEN = 15;
     EVENT_UPDATE_CURSOR = 16;
     EVENT_KEY_WAS_PRESSED = 17;
     EVENT_DEACTIVATE_SCREEN = 18;
     EVENT_TRUSTEE_CHANGE = 19;
     EVENT_NO_RELINQUISH_CONTROL = 23;
     EVENT_THREAD_SWITCH = 25;
     EVENT_MODULE_LOAD = 27;
     EVENT_CREATE_PROCESS = 28;
     EVENT_DESTROY_PROCESS = 29;
     EVENT_NEW_PUBLIC = 32;
     EVENT_PROTOCOL_BIND = 33;
     EVENT_PROTOCOL_UNBIND = 34;
     EVENT_ALLOCATE_CONNECTION = 37;
     EVENT_LOGOUT_CONNECTION = 38;
     EVENT_MLID_REGISTER = 39;
     EVENT_MLID_DEREGISTER = 40;
     EVENT_DATA_MIGRATION = 41;
     EVENT_DATA_DEMIGRATION = 42;
     EVENT_CREATE_OBJECT = 46;
     EVENT_DELETE_OBJECT = 47;
     EVENT_RENAME_OBJECT = 48;
     EVENT_VALUE_CHANGE = 49;
     EVENT_MOVE_OBJECT = 52;
     EVENT_VALUE_ADD = 53;
     EVENT_VALUE_DEL = 54;
     EVENT_CHANGE_TIME = 51;
     EVENT_DM_KEY_MODIFIED = 55;
     EVENT_MODULE_UNLOADED = 56;
     EVENT_REMOVE_PUBLIC = 57;
     EVENT_UNICODE = 59;
     EVENT_SFT3_SERVER_STATE = 60;
     EVENT_SFT3_IMAGE_STATE = 61;
     EVENT_SFT3_PRESYNC_STATE = 62;
     EVENT_ALTERNATE_MOUNT_VOLUME = 63;
     EVENT_CONSOLE_CONFIG_COMMAND = 64;
     EVENT_CONSOLE_VERSION_COMMAND = 65;
     EVENT_PRE_LOAD_NLM = 66;
     EVENT_LOW_MEMORY = 67;
     EVENT_PRE_DOWN_SERVER = 129;     // called before NDS disappears
     EVENT_GET_KEY_INFORMATION = 148;
     EGKStructVersion =  $00000001;
     EVENT_PRIORITY_APPLICATION = 20;
     EVENT_PRIORITY_DEVICE = 40;      // lowest

  {** A consumer registering for an event sets this flag in the event type to
   ** denote that the consumer is multiprocessor safe. This allows us to
   ** distinguish multiprocessor safe consumers from unsafe ones. }
     EVENT_CONSUMER_MT_SAFE     = $40000000;
  { ** Values for fields of EventNetWareAlertStruct_t. }
     QueueThisAlertMask         = $00000001;
     AlertIDValidMask           = $00000002;
     AlertLocusValidMask        = $00000004;
     AlertEventNotifyOnlyMask   = $00000008;
     AlertNoEventNotifyMask     = $00000010;
     AlertMessageNumberValid    = $00010000;
     NoDisplayAlertUID          = $00200000;
     AlertNoRingBell            = $00400000;
     AlertIDNotUniqueBit        = $00800000;
     OldStyleSystemAlertMask    = $01000000;
     OldStyleINWSystemAlertMask = $02000000;
  { can be pointer or number  }
     OverloadMessageNumFieldBit = $04000000;
     NoDisplayLocusBit          = $10000000;
     NoDisplayAlertIDBit        = $20000000;
     OverrideNotificationBits   = $40000000;
     TargetStationIsAPointer    = $80000000;
     Alert300Mask = (AlertIDValidMask or AlertLocusValidMask) or OldStyleSystemAlertMask;
     Alert311Mask = AlertIDValidMask or OldStyleINWSystemAlertMask;
     //Alert320Mask = ((AlertIDValidMask or AlertMessageNumberValid) or AlertLocusValidMask) or NoDisp
     //QAlertMask = ((AlertIDValidMask or AlertLocusValidMask) or NoDisplayAlertIDBit) or QueueThisAle
     //QAlert320Mask = Alert320Mask or QueueThisAlertMask;
 { allotted ModuleNumbers for 'alertID' in EventNetWareAlertStruct_t...  }
     ALERT_BINDERY    = $01020000;   // Bindary
     ALERT_OS         = $01030000;   // OS Event Subject
     ALERT_LLC        = $01040000;   // LLC
     ALERT_SDLC       = $01050000;   // SDLC Stack
     ALERT_REMOTE     = $01060000;   // RConsole
     ALERT_MLID       = $01070000;   // MLID Lan Drivers
     ALERT_QLLC       = $01080000;   // QLLC
     ALERT_UPS        = $01090000;   // UPS Monitor
     ALERT_DS         = $010a0000;   // Directory Service
     ALERT_RSPX       = $010c0000;   // RSPX
     ALERT_R232       = $010d0000;   // Serial
     ALERT_TIME_SYNC  = $010e0000;   // TimeSync
     ALERT_CLIB       = $010f0000;   // Clib
     ALERT_PRINT      = $01100000;   // Print
     ALERT_NRS        = $01200000;   // Novell Replication Services
     ALERT_DNS        = $01300000;   // IP/Domain Name Services
     ALERT_DHCP       = $01400000;   // DHCP Services
     ALERT_MM         = $01500000;   // Media Manager
{
  ** OS-defined AlertNumber values for 'alertID' in EventNetWareAlertStruct_t
  ** structure.
   }
  { starting with NetWare 4...  }
     nmAllocFailed = 1;
     nmErrWrtExtDir = 2;
     nmSysErrWrtDSnoFN = 3;
     nmStaErrWrtDSnoFN = 4;
     nmSysErrWrtDSwithFN = 5;
     nmStaErrWrtDSwithFN = 6;
     nmSysErrRdDSnoFN = 7;
     nmStaErrRdDSnoFN = 8;
     nmSysErrRdDSwithFN = 9;
     nmStaErrRdDSwithFN = 10;
     nmSysWrtPreRDnoFN = 11;
     nmStaWrtPreRDnoFN = 12;
     nmSysWrtPreRDwithFN = 13;
     nmStaWrtPreRDwithFN = 14;
     nmCacheMemLimitExceded = 15;
     nmCacheMemOutOfMem = 16;
     nmCacheBufsGetLo = 17;
     nmDskSpcNoDelFiles = 18;
     nmDskSpcNoLimbo = 19;
     nmVolSpcAlmostGone = 20;
     nmFATWrtErr = 21;
     nmDirWrtErr = 22;
     nmDirCopyRdErr = 23;
     nmDirDblRdErr = 24;
     nmAllocDirWrtErr = 25;
     nmDirExpansionErr = 26;
     nmDirTooLarge = 27;
     nmErrExpandingDir = 28;
     nmErrExpandingMem = 29;
     nmErrDirGetTooLarge = 30;
     nmDskBottleneck = 31;
     nmWDClearedConn = 32;
     nmCpyrtViolation = 33;
     nmReadFault = 35;
     nmPktTooSmall = 36;
     nmCreatingVolLog = 37;
     nmWrtVolLog = 38;
     nmVolDmtDevDeact = 39;
     nmLoginDisabled = 40;
     nmLoginEnabled = 41;
     nmClrSta = 42;
     nmClrStaByUsr = 43;
     nmFSDownByUser = 44;
     nmRIPAlreadyOpn = 45;
     nmRouterConfigErr = 46;
     nmLANLoopbackErr = 47;
     nmRouterConfigErrNoInfo = 48;
     nmIPXUnreachable = 49;
     nmIPXUnbind = 50;
     nmSAPAlreadyOpn = 51;
     nmRouterConfigErrNameInfo = 52;
     nmSpuriousInt = 53;
     nmChecksumInvalidAlert = 54;
     nmPrimaryPicLostInt = 55;
     nmSecondaryPicLostInt = 56;
     nmCompErrHoleCountMismatch = 57;
     nmInvalidScreen = 58;
     nmRelinquishControl = 59;
     nmFSUserDeleted = 60;
     nmAccDelByUser = 61;
     nmInvalidRTag = 62;
     nmDeactUnknown = 63;
     nmDeactDriveUnld = 64;
     nmDeactDevFailure = 65;
     nmDeactUsrRequest = 66;
     nmDeactMediaDismount = 67;
     nmDeactMediaEject = 68;
     nmDeactServerDown = 69;
     nmDeactServerFailure = 70;
     nmResourceRelErr = 71;
     nmMirrorsNotSync = 72;
     nmMirrorsSyncUp = 73;
     nmPartMirrorSync = 74;
     nmPartMirrorNotSync = 75;
     nmReMirroringPart = 76;
     nmReMirroringPartAborted = 77;
     nmLogPartMirrorInconsist = 78;
     nmSysFileLockThresh = 79;
     nmStaFileLockThresh = 80;
     nmSysRecLockThresh = 81;
     nmStaRecLockThresh = 82;
     nmOpnNETACCTFailed = 83;
     nmNCPSearchLimitSys = 84;
     nmNCPSearchLimitSta = 85;
     nmInsMediaAck = 86;
     nmInsMediaAborted = 87;
     nmRemMediaAck = 88;
     nmRemMediaAbort = 89;
     nmInsMediaInto = 90;
     nmRemMediaFrom = 91;
     nmReDirectedBlockPart = 92;
     nmReDirectedBlockPartErr = 93;
     nmOutOfHotFixBlocks = 94;
     nmLowWarningHotFixBlocks = 95;
     nmReDirectInconsistNoFix = 96;
     nmReDirectInconsistFixed = 97;
     nmInvalidRTagHOptions = 98;
     nmCheckAndAddHWNoGetRTag = 99;
     nmRemHWBadPtr = 100;
     nmErrUnldNLM = 101;
     nmIvldRTagCrProc = 102;
     nmCrProcStkTooSmall = 103;
     nmCrProcNoPCB = 104;
     nmDelToLimboFileErr = 105;
     nmDelToLimboNoSpace = 106;
     nmMLIDResetLanBd = 107;
     nmRouterReset = 108;
     nmVolWrongDOSType = 109;
     nmNoOwnerNSfound = 110;
     nmRTDMDefSMchanged = 111;
     nmErrOpnTTSLOG = 112;
     nmErrWrtTTSLOG = 113;
     nmTTSdownVolDismount = 114;
     nmTTSdisableByStaUsr = 115;
     nmTTSdisByOp = 116;
     nmTTSdisErrRdBackFile = 117;
     nmTTSdisErrWrBackFile = 118;
     nmTTSdisTooManyDefVol = 119;
     nmTTSdisWrtVolDefInfo = 120;
     nmTTSdisErrRdBkFlRecGen = 121;
     nmTTSdisGrowMemTables = 122;
     nmTTSdisErrAllDiskSp = 123;
     nmTTSdisDirErrOnBkFile = 124;
     nmTTSEnableByStaUsr = 125;
     nmTTStransAbortedForSta = 126;
     nmTTStooManyTransDelaying = 127;
     nmTTSNoMemForExpTransNodes = 128;
     nmAuditEvent = 129;
     nmAuditDisNoAuditCfg = 130;
     nmInvldConnTypeToAllocConn = 131;
     nmInvldRTagToAllocConn = 132;
     nmOutOfServerConns = 133;
     nmConnTermAfter5Min = 134;
     nmUsrAccDisableBySta = 135;
     nmUnEncryptPwdNotAllowed = 136;
     nmSuperAccLockedByConsole = 137;
     nmSystemTimeChangedByCon = 138;
     nmSystemTimeChangedBySta = 139;
     nmVolStillActWithError = 140;
     nmRouterFalsehood = 141;
     nmServerAddressChanged = 142;
     nmExtFileNoOwnerCharge = 143;
     nmRouterConfigErrNode = 144;
     nmRouterConfigErrMyAddr = 145;
     nmNoMigratorLd = 146;
     nmNoSMLd = 147;
     nmNotEnoughRamForCompression = 148;
     nmDiskErrorCompressing = 149;
     nmUnknownErrorCompressing = 150;
     nmInsufficientSpaceForDeCompression = 151;
     nmDecompressUnknownCompressionVersion = 152;
     nmUnknownDecompressError = 153;
     nmInsufficientRAMToDecompress = 154;
     nmCompressedFileIsCorrupt = 155;
     nmStaAttemptedToUseBadPckt = 156;
     nmStaUsedABadPckt = 157;
     nmStaAttemptedToUseBadSFL = 158;
     nmStaUsedABadSFL = 159;
     nmCorruptCompFileWithName = 160;
     nmCorruptCompFileWithNameAndStation = 161;
     nmLowPriThreadsNotRun = 162;
     nmWorkToDoNotRun = 163;
     nmCompressErrorTempFileError = 164;
     nmCompressErrorLengthTotalsMismatch = 165;
     nmCompressErrorOffsetTotalsMismatch = 166;
     nmCompressErrorDataCodeCountMismatch = 167;
     nmCompressErrorLengthCountMismatch = 168;
     nmCompressErrorLargeLengthCountMismatch = 169;
     nmCompressErrorReadZeroBytesOrg = 170;
     nmCompressErrorTreeTooBig = 171;
     nmCompressErrorMatchSizeFail = 172;
     nmSignatureInvalidAlert = 173;
     nmLicenseIsInvalid = 174;
     nmDeactHotFixError = 175;
     nmUnknownDecompressErrorFN = 176;
     nmInsufficientRAMToDecompressFN = 177;
     nmDecompressUnderFreePercentage = 178;
     nmNegPktTriedLargeBuffer = 179;
     nmLoginDisabledByConsole = 180;
     nmLoginEnabledByConsole = 181;
     nmGrwStkNotAvail = 182;
     nmLicenseFileIsMissing = 183;
     nmFailedToDeletedMigratedFile = 184;
     nmNoMemForAuditing = 185;
     nmAuditFileWriteError = 186;
     nmAuditFileFull = 187;
     nmAuditFileThresholdOverflow = 188;
     nmCompressErrorReadZeroBytesInt = 189;
     nmEASpaceLimit = 190;
     nmThreadAreaNotEmpty = 191;
     nmErrMovingLogToMSEngine = 192;
     nmFaultInConsoleCmdHandler = 193;
     nmServerToServerComLinkActivated = 194;
     nmServerToServerComLinkFailure = 195;
     nmServerToServerComLinkDeact = 196;
     nmOtherServerAttemptedToSync = 197;
     nmServerToServerComLinkBrokeOK = 198;
     nmServerSyncStartingIAmSecondary = 199;
     nmBadSvrInitMsgFromOtherSvr = 200;
     nmSvrToSvrCommLinkInitFailed = 201;
     nmFailedDuringSyncWithReason = 202;
     nmCommDrvLdDuringActivateWait = 203;
     nmErrWritingStatusDump = 204;
     nmComDrvFailureOnPrimary = 205;
     nmComDrvFailureOnSecondary = 206;
     nmErrFinishingGenStatusDump = 207;
     nmSFTIIWhatToDoWithReasonString = 208;
     nmSFTIIErrorUnexpected = 209;
     nmSyncErrFromCustomServerNLM = 210;
     nmSvrLinkHasPluggedPacket = 211;
     nmSvrToBeRevived = 212;
     nmServersAreSyncPri = 213;
     nmSvrCantRouteIPXSec = 214;
     nmSrvIPXRouteInfoSec = 215;
     nmErrGivingRAMtoMS = 216;
     nmMoreRAMgivenToMS = 217;
     nmServersAreSyncSec = 218;
     nmSvrCantRouteIPXPri = 219;
     nmSrvIPXRouteInfoPri = 220;
     nmPriSvrFailedButSecDown = 221;
     nmPriSvrFailedNewPri = 222;
     nmNumMemSegsExceedLimit = 223;
     nmNumScreenExceedsLimit = 224;
     nmIOVersionMismatch = 225;
     nmOtherSvrProtectLvlNoMatch = 226;
     nmOtherSvrScrAddrMismatch = 227;
     nmIOEngNotAtSameAddr = 228;
     nmBothSvrHaveMSEng = 229;
     nmNoMSEngOnServers = 230;
     nmSecSvrMissingRAM = 231;
     nmBothSrvHaveSameIPXAddr = 232;
     nmIOEngIPXAddrMatchMSEng = 233;
     nmIOEngsMismatchRxSizes = 234;
     nmIOEngsHaveSameName = 235;
     nmNoMemForIOEngName = 236;
     nmSrvToSvrLinkBeginSync = 237;
     nmMSEngActivated = 238;
     nmMSEngActNowSyncOther = 239;
     nmIOtoMSComMisMatchUnload = 240;
     nmSFTIIIOutOfMsgCodes = 241;
     nmErrXferDumpToSystem = 242;
     nmFailureChkPrimary = 243;
     nmNoMemForOtherIOEngScr = 244;
     nmErrStarting2ndProc = 245;
     nmSrvFailureMsg = 246;
     nmSecIOEngSupModNotLd = 247;
     nmMSLBdNumHasConn = 248;
     nmSecSvrLANIsBetter = 249;
     nmIPXrtnStatusPckts = 250;
     nmIPXnotRtnStatChkPckts = 251;
     nmIPXnotRtnStatLANJam = 252;
     nmFailReasonByOtherSrv = 253;
     nmIPXMayBeTooSlowForSecSrv = 254;
     nmIPXToOtherSrvTooManyHops = 255;
     nmIPXappearsDown = 256;
     nmIPXFoundRouteToOtherSrv = 257;
     nmIPXLostRoute = 258;
     nmSecSrvGoingToDie = 259;
     nmPriSrcDyingTimerStart = 260;
     nmPriSrvDying = 261;
     nmIPXInternetIsJammed = 262;
     nmIPXNewRouteToSecSvr = 263;
     nmSrvsSyncing = 264;
     nmFSHookRegistered = 265;
     nmFSHookDeRegistered = 266;
     nmIOEngCantBorrowMemory = 267;
     nmDecompressNoCompressionOnVolume = 268;
     nmMkProcessUsingTooSmallStk = 269;
     nmQueueEventReportNoMemory = 270;
     nmServerPartMirrorNotSync = 271;
     nmStaWithoutRightsConsoleRPC = 272;
     nmAuditOverflowFileThreshold = 273;
     nmAuditOverflowFileFull = 274;
     nmSwitchStacksGrwStk = 275;
     nmConsoleCommandProcRestarted = 276;
     nmGrowableStackGrew = 278;
     nmOtherSvrIOLogSpaceNoMatch = 279;
     nmDFSLogicalStackRead = 280;
     nmDFSLogicalStackWrite = 281;
     nmSecureEraseFailure = 282;
     nmDropBadPktBurstConn = 283;
     nmOutOfIPXSockets = 284;
     nmVolumeObjectIDChanged = 285;
     nmAbendRecovery = 286;
     nmOpLockTimeout = 287;
     nmAbendRecovered = 288;
     nmUnknownSetCmd = 289;    { starting with NetWare 5...  }
     nmAddressSpaceProtectionFault = 290;
     nmAddressSpaceFailedToRestart = 291;
     nmAddressSpaceRestarted = 292;
     nmCorruptMemoryNodeDetected = 293;
     nmAddressSpaceCleanupFailure = 294;
     nmInvalidParameter = 295;
     nmInvalidObjectHandle = 296;
     nmNullPointer = 297;
     nmVolDmtMedDmt = 298;
     nmVolDmtmedChgd = 299;
     nmAccDelByUsrActConn = 300;
     nmResourcesRelErr = 301;
     nmDemoVersion = 302;
     nmDemoVersionTooLong = 303;
     nmLicenseReSellerFileIsMissing = 304;
     nmLicenseUpgradeIsMissing = 305;
     nmLicenseVersionInvalid = 306;
     nmLicenseProductInvalid = 307;
     nmLicenseNoMoreFiles = 308;
     nmLicensePIDInvalid = 309;
     nmLicenseContentInalid = 310;
     nmLicenseBadUpgrade = 311;
     nmLicensePrevMaxConnMisMatch = 312;
     nmLicenseContentResellerBad = 313;
     nmLicenseSNMisMatch = 314;
     nmLicenseUIDMisMatch = 315;
     nmLicenseOpenError = 316;
     nmLicenseCompanionErr = 317;
     nmLicenseSNUpgradeMisMatch = 318;
     nmLicenseUnableToRemMSL = 319;
     nmLicenseUnableToRemULF = 320;
     nmLicenseUnableToRemRLF = 321;
     nmLicenseUnableToGetFileSize = 322;
     nmLicenseUnkLicenseType = 323;
     nmLicenseReadErr = 324;
     nmLicenseFileSizeMisMatch = 325;
     nmLicenseDupServerLic = 326;
     nmLicenseNeedUpgrade = 327;
     nmLicenseMirrorNeedUpgrade = 328;
     nmLicenseDupLicDiscovered = 329;
     nmLicenseDupLicDiscoveredDel = 330;
     nmLicenseCpyRightViolated = 331;
     nmLicenseExpired = 332;
     nmVolDmtDevMedChgd = 333;
     nmVolDmtDevMedDmt = 334;
     nmInsMediaAckDS = 335;
     nmInsMediaAckMag = 336;
     nmInsMediaAbortedDS = 337;
     nmInsMediaAbortedMag = 338;
     nmRemMediaAckDS = 339;
     nmRemMediaAckMag = 340;
     nmRemMediaAbortDS = 341;
     nmRemMediaAbortMag = 342;
     nmInsMediaIntoDS = 343;
     nmInsMediaIntoMag = 344;
     nmRemMediaFromDS = 345;
     nmRemMediaFromMag = 346;
     nmServAddr = 347;
     nmSwapInError = 348;
     nmSwapOutError = 349;
     nmAveragePageInThresholdExceeded = 350;
     nmIllegalRequest = 351;
     nmTTSThrottleDelayError = 352;
     nmTTSLackOfResourcesError = 353;
     nmTTSLackOfResourcesNoReason = 354;
     nmDelayedWTDNotRunning = 355;
     nmInvalidCharacterInName = 356;
  { starting with NetWare 6...  }
     nmMPKBadThreadState = 357;
     nmPoolSeriousError = 358;
     nmPoolSeriousReadError = 359;
     nmVolSeriousError = 360;
     nmVolSeriousReadError = 361;
     nmVolDeactSeriousIOError = 362;
     nmVolDeactSeriousNonIOError = 363;
     nmPoolDeactSeriousIOError = 364;
     nmPoolDeactSeriousNonIOError = 365;
     nmTaskZeroCheck = 366;
  { values for 'alertLocus' in EventNetWareAlertStruct_t...  }
     LOCUS_UNKNOWN = 0;
     LOCUS_MEMORY = 1;
     LOCUS_FILESYSTEM = 2;
     LOCUS_DISKS = 3;
     LOCUS_LANBOARDS = 4;
     LOCUS_COMSTACKS = 5;
     LOCUS_TTS = 7;
     LOCUS_BINDERY = 8;
     LOCUS_STATION = 9;
     LOCUS_ROUTER = 10;
     LOCUS_LOCKS = 11;
     LOCUS_KERNEL = 12;
     LOCUS_UPS = 13;
     LOCUS_SERVICE_PROTOCOL = 14;
     LOCUS_SFT_III = 15;
     LOCUS_RESOURCE_TRACKING = 16;
     LOCUS_NLM = 17;
     LOCUS_OS_INFORMATION = 18;
     LOCUS_CACHE = 19;
  { values for 'alertClass' in EventNetWareAlertStruct_t...  }
     CLASS_UNKNOWN = 0;
     CLASS_OUT_OF_RESOURCE = 1;
     CLASS_TEMP_SITUATION = 2;
     CLASS_AUTHORIZATION_FAILURE = 3;
     CLASS_INTERNAL_ERROR = 4;
     CLASS_HARDWARE_FAILURE = 5;
     CLASS_SYSTEM_FAILURE = 6;
     CLASS_REQUEST_ERROR = 7;
     CLASS_NOT_FOUND = 8;
     CLASS_BAD_FORMAT = 9;
     CLASS_LOCKED = 10;
     CLASS_MEDIA_FAILURE = 11;
     CLASS_ITEM_EXISTS = 12;
     CLASS_STATION_FAILURE = 13;
     CLASS_LIMIT_EXCEEDED = 14;
     CLASS_CONFIGURATION_ERROR = 15;
     CLASS_LIMIT_ALMOST_EXCEEDED = 16;
     CLASS_SECURITY_AUDIT_INFO = 17;
     CLASS_DISK_INFORMATION = 18;
     CLASS_GENERAL_INFORMATION = 19;
     CLASS_FILE_COMPRESSION = 20;
     CLASS_PROTECTION_VIOLATION = 21;
     CLASS_VIRTUAL_MEMORY = 22;
  { values for 'alertSeverity' in EventNetWareAlertStruct_t...  }
  { counters reached thresholds          }
     SEVERITY_INFORMATIONAL = 0;
  { config errors, etc. no damage        }
     SEVERITY_WARNING = 1;
  { hot fix disk, etc. worked around     }
     SEVERITY_RECOVERABLE = 2;
  { disk mirror failure, etc. fix-up attempted  }
     SEVERITY_CRITICAL = 3;
  { resource fatally affected--shut down }
     SEVERITY_FATAL = 4;
  { cannot complete--result unknown      }
     SEVERITY_OPERATION_ABORTED = 5;
  { cannot complete--will not affect OS  }
     SEVERITY_NONOS_UNRECOVERABLE = 6;
  { values for 'targetNotificationBits' in EventNetWareAlertStruct_t...  }
     NOTIFY_CONNECTION_BIT = $00000001;
     NOTIFY_EVERYONE_BIT = $00000002;
     NOTIFY_ERROR_LOG_BIT = $00000004;
     NOTIFY_CONSOLE_BIT = $00000008;
  { use if alert to be queued  }
     NOTIFY_QUEUE_MESSAGE = $10000000;
     NOTIFY_DONT_NOTIFY_NMAGENT = $80000000;

type
  TnwAlertDataFreeProc = procedure (nwAlertDataPtr:pointer);cdecl;
  PNetWareAlertStructure  = ^TNetWareAlertStructure;
  TNetWareAlertStructure = record
    pNetworkManagementAttribute  : pointer;
    nwAlertFlags,
    nwTargetStation,
    nwTargetNotificationBits,
    nwAlertID,
    nwAlertLocus,
    nwAlertClass,
    nwAlertSeverity              : longint;
    nwAlertDataPtr               : pointer;
    nwAlertDataFree              : TnwAlertDataFreeProc;
    nwControlString              : pchar;
    nwControlStringMessageNumber : longint;
  end;

{$ifndef INCLUDED_FROM_SYSTEM}
procedure NetWareAlert(nlmHandle      : TNLMHandle;
                       nwAlert        : PNetWareAlertStructure;
                       parameterCount : longint;
                       args           : array of const); cdecl; external system_nlm name 'NetWareAlert';
{$endif}

procedure NetWareAlert(nlmHandle      : TNLMHandle;
                       nwAlert        : PNetWareAlertStructure;
                       parameterCount : longint); cdecl; external system_nlm name 'NetWareAlert';

type

   PEventSecurityChange_t = ^EventSecurityChange_t;
   EventSecurityChange_t = record
        objectID : dword;
        equivalentID : dword;
        changeFlags : dword;
     end;

   PEventTrusteeChange_t = ^EventTrusteeChange_t;
   EventTrusteeChange_t = record
        objectID : dword;
        entryID : dword;
        volumeNumber : longint;
        changeFlags : dword;
        newRights : dword;
     end;

   PEventModifyDirEntry_t = ^EventModifyDirEntry_t;
   EventModifyDirEntry_t = record
        primaryDirectoryEntry : dword;
        nameSpace : longint;
        modifyBits : dword;
        modifyVector : pointer;
        volumeNumber : longint;
        directoryEntry : dword;
     end;

   PEventProtocolBind_t = ^EventProtocolBind_t;
   EventProtocolBind_t = record
        boardNumber : longint;
        protocolNumber : longint;
     end;

   PEventDateMigrationInfo_t = ^EventDateMigrationInfo_t;
   EventDateMigrationInfo_t = record
        FileSystemTypeID : dword;
        Volume : longint;
        DOSDirEntry : dword;
        OwnerDirEntry : dword;
        OwnerNameSpace : longint;
        OwnerFileName : array[0..(1 + 255)-1] of char;
     end;

   PEventQueueNote_t = ^EventQueueNote_t;
   EventQueueNote_t = record
        QAction : longint;
        QID : dword;
        QName : array[0..(49 + 1)-1] of char;
     end;

   PEventNetWareAlert_t = ^EventNetWareAlert_t;
   EventNetWareAlert_t = record
        alertFlags : dword;
        alertId : dword;
        alertLocus : dword;
        alertClass : dword;
        alertSeverity : dword;
        targetStationCount : longint;
        targetStationList : array[0..31] of dword;
        targetNotificationBits : dword;
        alertParmCount : longint;
        alertDataPtr : pointer;
        NetWorkManagementAttributePointer : pointer;
        alertUnused : array[0..1] of dword;
        alertControlStringMessageNumber : longint;
        alertControlString : array[0..255] of char;
        alertParameters : array[0..(256 + 256)-1] of char;
        alertModuleName : array[0..35] of char;
        alertModuleMajorVersion : longint;
        alertModuleMinorVersion : longint;
        alertModuleRevision : longint;
     end;

   PEventBinderyObject_t = ^EventBinderyObject_t;
   EventBinderyObject_t = record
        EventObjectSignature : dword;
        ObjectID : dword;
        ObjectType : dword;
     end;

function DSAllocateEventTag(signature:dword):pointer;cdecl;external libc_nlm name 'DSAllocateEventTag';

type

   PEventDSObject_t = ^EventDSObject_t;
   EventDSObject_t = record
        EventObjectSignature : dword;
        EventType : dword;
        entry : pointer;
     end;

   PEventCloseFileInfo_t = ^EventCloseFileInfo_t;
   EventCloseFileInfo_t = record
        fileHandle : dword;
        station : longint;
        task : longint;
        fileHandleFlags : dword;
        completionCode : longint;
     end;

   PEventCheckKeyInfo_t = ^EventCheckKeyInfo_t;
   EventCheckKeyInfo_t = record
        structVersion : dword;
        keyData : dword;
        scrID : scr_t;
     end;
{
** A consumer registering for an event sets this flag in the event type to
** denote that the consumer is multiprocessor safe. This allows us to
** distinguish multiprocessor safe consumers from unsafe ones.
 }
{
** Values for fields of EventNetWareAlertStruct_t.
 }
{
** Values for 'alertID' in EventNetWareAlertStruct_t comprised of two parts,
** the ModuleNumber (upper 16 bits) and AlertNumber (lower 16 bits).
** AlertNumber is under the control of the module specified by ModuleNumber.
**
** ModuleNumber specifies which module is generating the alert and AlertNumber
** can then be used for a specific alert generated by that module.
**
** Any ModuleNumber in the range 0x8000xxxx to 0xFFFFxxxx. Range 0x0001xxxx
** through 0x7fffxxxx is reserved for Novell. Value 0x0000xxxx is considered
** invalid and is used for all legacy alerts.
 }
{ allotted ModuleNumbers for 'alertID' in EventNetWareAlertStruct_t...  }
{
** OS-defined AlertNumber values for 'alertID' in EventNetWareAlertStruct_t
** structure. }

   Pevent_handle_t = ^event_handle_t;
   event_handle_t = longint;

   Report_t = procedure (parm:pointer; userParm:pointer);cdecl;

   Warn_t = function (printf:pointer; parm:pointer; userParm:pointer):longint;cdecl;

function RegisterForEventNotification(rtag:rtag_t; _type:longint; priority:longint; warn:Warn_t; report:Report_t;
           userParm:pointer):event_handle_t;cdecl;external system_nlm name 'RegisterForEventNotification';
function UnRegisterEventNotification(handle:event_handle_t):longint;cdecl;external system_nlm name 'UnRegisterEventNotification';
function CanEventBlock(_type:longint):longint;cdecl;external system_nlm name 'CanEventBlock';
function CheckForRegisteredEvent(_type:longint):longint;cdecl;external system_nlm name 'CheckForRegisteredEvent';
function EventCheck(_type:longint; printf:pointer; parm:pointer):longint;cdecl;external system_nlm name 'EventCheck';
function EventReport(_type:longint; parm:pointer):longint;cdecl;external system_nlm name 'EventReport';


{ server interfaces...  }
{ ShutdownServer() 'flags'...  }

    const
       NW_POST65_MAX_CMDLINE_LEN = 2048 + 1;
       SHUTDOWN_RESET            = $00000001;   { ShutdownServer() 'flags'...  }
       SHUTDOWN_POWEROFF         = $00000002;   { unimplemented }


procedure RestartServer(commandLine:Pchar);cdecl;external system_nlm name 'RestartServer';
function ShutdownServer(scrID:scr_t; forceDown:byte; alternateMessage:Pchar; flags:dword):longint;cdecl;external system_nlm name 'ShutdownServer';
function ShutdownServer(scrID:scr_t; forceDown:boolean; alternateMessage:Pchar; flags:dword):longint;cdecl;external system_nlm name 'ShutdownServer';
function StopServer(scrID:scr_t; forceDown:byte; reserved1:dword; reserved2:pointer; alternateMessage:Pchar;
           reserved3:dword):longint;cdecl;external system_nlm name 'StopServer';
function StopServer(scrID:scr_t; forceDown:boolean; reserved1:dword; reserved2:pointer; alternateMessage:Pchar;
           reserved3:dword):longint;cdecl;external system_nlm name 'StopServer';

{ resource tag interfaces...  }
const
  AllocSignature               = $54524C41;
  BreakpointSignature          = $54504B42;
  ConsoleCommandSignature      = $4D4F4343;
  CommandLineServicesSignature = $5043574E;
  DebugCommandSignature        = $53504344;
  DebuggerSignature            = $47554244;
  EventSignature               = $544E5645;
  ScreenSignature              = $4E524353;
  SettableParameterSignature   = $4D505453;
  RTAG_DESC_LEN                = 63;


type
   Cleanup_t = procedure (rTag:rtag_t; forceFlag:longint);cdecl;

   Prtag_info = ^rtag_info;
   rtag_info = record
        tag         : rtag_t;
        signature   : dword;
        NLMHandle   : TNLMHandle;
        use_count   : longint;
        description : array[0..(63 + 1)-1] of char;
     end;
   rtag_info_t  = rtag_info;
   Prtag_info_t = ^rtag_info_t;


function AllocateResourceTag(NLMHandle:TNLMHandle; description:Pchar; signature:dword):rtag_t;cdecl;external system_nlm name 'AllocateResourceTag';
function GetModuleResourceTagInfo(rTag:rtag_t; NLMHandle:TNLMHandle; info:Prtag_info_t):longint;cdecl;external system_nlm name 'GetModuleResourceTagInfo';
function ReturnResourceTag(rTag:rtag_t; displayErrorsFlag:longint):longint;cdecl;external system_nlm name 'ReturnResourceTag';
function RegisterTrackedResource(NLMHandle:TNLMHandle; signature:dword; cleanup:Cleanup_t; description:Pchar):longint;cdecl;external system_nlm name 'RegisterTrackedResource';
function UnRegisterTrackedResource(NLMHandle:TNLMHandle; signature:dword):longint;cdecl;external system_nlm name 'UnRegisterTrackedResource';
function AddPollingProcedureRTag(proc:TCDeclProcedure ; rTag:rtag_t):longint;cdecl;external system_nlm name 'AddPollingProcedureRTag';
procedure RemovePollingProcedure(proc:TCDeclProcedure);cdecl;external system_nlm name 'RemovePollingProcedure';

{ NetWare-loader interfaces...  }
const
  MAX_SYMBOL_NAME_LEN = 80;

function ExportPublicObject(NLMHandle:TNLMHandle; name:Pchar; _object:pointer):longint;cdecl;external system_nlm name 'ExportPublicObject';
function ImportPublicObject(NLMHandle:TNLMHandle; name:Pchar):pointer;cdecl;external system_nlm name 'ImportPublicObject';

    const
       LO_NORMAL = $00000000;
       LO_PROTECT = $00000002;
       LO_LOAD_LOW = $00000020;
       LO_RETURN_HANDLE = $00000040;
       LO_LOAD_SILENT = $00000080;
       LO_RESTART = $00000200;
       LO_DONT_DISPLAY_ERROR = $00002000;
       LO_MEMORY_DEBUG = $00010000;          { debug only; no production use  }
       LO_RELAXED_MEMORY_DEBUG = $00020000;  { debug only; no production use  }
       ERR_LOADER_COULD_NOT_FIND_FILE = 1;   { error returns from LoadModule()  }
       ERR_LOADER_ERROR_READING_FILE = 2;
       ERR_LOADER_NOT_NLM_FILE_FORMAT = 3;
       ERR_LOADER_WRONG_NLM_FILE_VERSION = 4;
       ERR_LOADER_REENTRANT_INITIALIZE_FAILURE = 5;
       ERR_LOADER_CAN_NOT_LOAD_MULTIPLE_COPIES = 6;
       ERR_LOADER_ALREADY_IN_PROGRESS = 7;
       ERR_LOADER_NOT_ENOUGH_MEMORY = 8;
       ERR_LOADER_INITIALIZE_FAILURE = 9;
       ERR_LOADER_INCONSISTENT_FILE_FORMAT = 10;
       ERR_LOADER_CAN_NOT_LOAD_AT_STARTUP = 11;
       ERR_LOADER_AUTO_LOAD_MODULES_NOT_LOADED = 12;
       ERR_LOADER_UNRESOLVED_EXTERNAL = 13;
       ERR_LOADER_PUBLIC_ALREADY_DEFINED = 14;
       ERR_LOADER_XDC_DATA_ERROR = 15;
       ERR_LOADER_NOT_KERNEL = 16;
       ERR_LOADER_NIOS_ONLY_NLM = 17;
       ERR_LOADER_ADDRESS_SPACE_CREATION = 18;
       ERR_LOADER_INITIALIZE_FAULT = 19;
type
  TLoadModulePath = record
    case longint of
      0 : (NLMHandle : TNLMHandle);
      1 : (path      : array [0..1024] of char);
    end;


function GetNLMNames(NLMHandle:TNLMHandle; name:Pchar; description:Pchar):longint;cdecl;external system_nlm name 'GetNLMNames';
procedure KillMe(NLMHandle:TNLMHandle);cdecl;external system_nlm name 'KillMe';
function ReturnMessageInformation(NLMHandle:TNLMHandle; table:PPPchar; stringCount:Psize_t; languageID:Plongint; helpFile:pointer):longint;cdecl;external system_nlm name 'ReturnMessageInformation';
function SetAutoUnloadFlag(NLMHandle:TNLMHandle):longint;cdecl;external system_nlm name 'SetAutoUnloadFlag';

function UnImportPublicObject(NLMHandle:TNLMHandle; name:Pchar):longint;cdecl;external system_nlm name 'UnImportPublicObject';
function AddSearchPathAtEnd(scrID:scr_t; path:Pchar):longint;cdecl;external system_nlm name 'AddSearchPathAtEnd';
function DeleteSearchPath(scrID:scr_t; searchPathNumber:longint):longint;cdecl;external system_nlm name 'DeleteSearchPath';
function GetSearchPathElement(index:longint; isDOSFlag:Pdword; path:Pchar):longint;cdecl;external system_nlm name 'GetSearchPathElement';
function GetSearchPathElement(index:longint; var isDOSFlag:dword; path:Pchar):longint;cdecl;external system_nlm name 'GetSearchPathElement';
function GetSearchPathElement(index:longint; var isDOSFlag:longint; path:Pchar):longint;cdecl;external system_nlm name 'GetSearchPathElement';
function InsertSearchPath(scrID:scr_t; searchPathNumber:longint; path:Pchar):longint;cdecl;external system_nlm name 'InsertSearchPath';
function LoadModule(scrID:scr_t; path:Pchar; options:dword):longint;cdecl;external system_nlm name 'LoadModule';
function LoadModule(scrID:scr_t; var path:TLoadModulePath; options:dword):longint;cdecl;external system_nlm name 'LoadModule';
function UnloadModule(scrID:scr_t; commandline:Pchar):longint;cdecl;external system_nlm name 'UnloadModule';
{ memory management interfaces }
function _Alloc(size:size_t; rTag:rtag_t):pointer;cdecl;external system_nlm name 'Alloc';
function Alloc(size:size_t; rTag:rtag_t):pointer;cdecl;external system_nlm name 'Alloc';
function _AllocSleepOK(size:size_t; rTag:rtag_t; slept:Plongint):pointer;cdecl;external system_nlm name 'AllocSleepOK';
function AllocSleepOK(size:size_t; rTag:rtag_t; slept:Plongint):pointer;cdecl;external system_nlm name 'AllocSleepOK';
function _AllocSleepOK(size:size_t; rTag:rtag_t; var slept:longint):pointer;cdecl;external system_nlm name 'AllocSleepOK';
function AllocSleepOK(size:size_t; rTag:rtag_t; var slept:longint):pointer;cdecl;external system_nlm name 'AllocSleepOK';
procedure NWGarbageCollect(NLMHandle:TNLMHandle);cdecl;external system_nlm name 'NWGarbageCollect';
function NWGetAvailableMemory:size_t;cdecl;external system_nlm name 'NWGetAvailableMemory';
function NWGetPageSize:size_t;cdecl;external system_nlm name 'NWGetPageSize';
function NWMemorySizeAddressable(addr:pointer; size:size_t):longint;cdecl;external system_nlm name 'NWMemorySizeAddressable';
function _ReallocSleepOK(addr:pointer; size:size_t; rTag:rtag_t; slept:Plongint):pointer;cdecl;external system_nlm name 'ReallocSleepOK';
function _ReallocSleepOK(addr:pointer; size:size_t; rTag:rtag_t; var slept:longint):pointer;cdecl;external system_nlm name 'ReallocSleepOK';
function ReallocSleepOK(addr:pointer; size:size_t; rTag:rtag_t; slept:Plongint):pointer;cdecl;external system_nlm name 'ReallocSleepOK';
function ReallocSleepOK(addr:pointer; size:size_t; rTag:rtag_t; var slept:longint):pointer;cdecl;external system_nlm name 'ReallocSleepOK';
procedure _Free(addr:pointer);cdecl;external system_nlm name 'Free';

 const
       CMD_CONFIG_INFO     = $00000001;
       CMD_CONVERT_UPPER   = $00000002;   { convert command line to upper case?  }
       CMD_SERVER_RUNNING  = $00000004;   { server need to be running?  }
       CMD_LEGAL_SERVER    = $00000008;   { command legal on regular server?  }
       CMD_HIDDEN_CMD      = $00200000;   { don't display this command  }
       CMD_SUB_CMDS_AVAIL  = $00100000;   { command has sub commands  }
       CMD_NO_CMD_CHAIN    = $00010000;   { disallow chaining of command keyword  }
       CMD_PASS_ON_ERROR   = $00020000;   { ignore error  }
       CMD_ANY_PROCESS     = $80000000;   { can run on any process with keyboard  }
    { keyword flags for RegisterCommand()...  }
       CMD_MSG_NUMBER      = $80000000;   { pointer to keyword is number  }
       CMD_LENGTH_PREC     = $40000000;   { keyword is length-preceeded  }
    { insertion flags for RegisterCommand()...  }
       CMD_INSERT_AT_HEAD  = $00000001;   { insert at head  }
       CMD_INSERT_AT_TAIL  = $00000002;   { insert at tail  }
       CMD_PERM_POSITION   = $80000000;   { leave in place (head or tail)  }
    { valid error returns from command handler...  }
       CMD_CMD_EXECUTED    = $00000000;   { processed, go to next handler  }
       CMD_HALT_CMD_CHAIN  = $70000000;   { processed, but don't go on to next  }
       CMD_BAD_CMD_SYNTAX  = $70000010;   { not processed, syntax error  }
       CMD_NOT_RUNNING     = $70000011;   { won't execute until server up  }
       CMD_LINE_FAULT      = $70000012;   { command line fault--no error display  }
       CMD_BAD_MOD_HANDLE  = $70000021;   { NLM handle is invalid  }
       CMD_BAD_RTAG        = $70000022;   { invalid resource tag  }
       CMD_BAD_KEY         = $70000023;   { keyword is invalid  }
       CMD_RTAG_AND_MOD    = $70000024;   { resource tag doesn't match NLM  }
       CMD_NO_HANDLER      = $70000025;   { handler is missing  }
       CMD_KEY_TOO_LONG    = $70000026;   { keyword is too long  }
       CMD_INVAL_PERM      = $70000027;   { invalid syntax to make permanent  }
       CMD_NO_MEMORY       = $70000028;   { unable to allocate memory  }
       CMD_NOT_REGISTERED  = $70000029;   { unregistered command  }
       CMD_HAS_CHAIN       = $7000002A;   { command has a chain  }
       CMD_CANT_MAKE_HEAD  = $7000002B;   { cannot make command permanent head  }
       CMD_CANT_MAKE_TAIL  = $7000002C;   { cannot make command permanent tail  }
       CMD_PASS_TO_NEXT    = $7000002D;   { not processed, go to next handler  }
       CMD_PRIV_ON_ALT     = $7000002E;   { no privilege on alternate handler  }
       CMD_STOP_CMDS       = $7000002F;   { system no longer parsing commands  }
    { simplified versions of returns from command handler...  }
       CMD_PROCESSED_OK    = CMD_HALT_CMD_CHAIN;
       CMD_CHAIN_NEXT_CMD  = CMD_CMD_EXECUTED;
       CMD_SYNTAX_ERROR    = CMD_BAD_CMD_SYNTAX;
       CMD_NOT_MY_COMMAND  = CMD_PASS_TO_NEXT;
    { command handler function codes...  }
       CMD_HELP_ON_CMD     = $00000000;
       CMD_GET_SUB_CMDS    = $00000001;
       CMD_PROCESS_CMD     = $00000002;
       //CMD_MAX_HELP_CMDS = ProcessCommand;
    { error codes...  }
       ERR_INVALID_MODULE     = $00000001;
       ERR_INVALID_RTAG       = $00000002;
       ERR_INVALID_KEYWORD    = $00000003;
       ERR_MODULE_RTAG_MIX    = $00000004;
       ERR_MISSING_HANDLER    = $00000005;
       ERR_KEYWORD_TOO_LONG   = $00000006;
       ERR_INVALID_REQUEST    = $00000007;
       ERR_OUT_OF_MEMORY      = $00000008;
       ERR_FAILED_TO_REGISTER = $00000009;
       ERR_ALREADY_REGISTERED = $0000000A;
       ERR_CANT_GRANT_TOP     = $0000000B;
       ERR_CANT_GRANT_END     = $0000000C;

function SizeOfAllocBlock(addr:pointer):size_t;cdecl;external system_nlm name 'SizeOfAllocBlock';

type
   CommandHandler_t = function (funcCode:longint; scrID:pointer; command:Pchar; upperCaseCommand:Pchar; callerReference:pointer):longint;cdecl;


function DeRegisterCommand(NLMHandle:TNLMHandle; rTag:rtag_t; keywordFlags:dword; keyword:Pchar):longint;cdecl;external system_nlm name 'DeRegisterCommand';

function RegisterCommand(NLMHandle:TNLMHandle; rTag:rtag_t; keywordFlags:dword; keyword:Pchar; handlerFlags:dword;
           insertionFlags:dword; handler:CommandHandler_t; callerReference:pointer):longint;cdecl;external system_nlm name 'RegisterCommand';
{ legacy command parsing; uses ConsoleCommandSignature...  }

type
   TCommandParserFunc = function (scrID:scr_t; commandline:Pchar):longint;cdecl;

{ allocate with ConsoleCommandSignature  }

   PCommandParserStructure = ^TCommandParserStructure;
   TCommandParserStructure = record
        link   : pointer;
        case longint of
          0 : (parser : TCommandParserFunc; rTag : rtag_t);
          1 : (parseRoutine : TCommandParserFunc; rTag2 : rtag_t);
     end;
   TCommandParser = TCommandParserStructure;
   PCommandParser = PCommandParserStructure;

const
  HANDLEDCOMMAND  = 0;
  NOTMYCOMMAND    = 1;

function ParseCommand(commandLine:Pchar):longint;cdecl;external system_nlm name 'ParseCommand';
function RegisterConsoleCommand(cmdParser:PCommandParser):longint;cdecl;external system_nlm name 'RegisterConsoleCommand';
function RegisterConsoleCommand(var cmdParser:TCommandParser):longint;cdecl;external system_nlm name 'RegisterConsoleCommand';
function UnRegisterConsoleCommand(cmdParser:PCommandParser):longint;cdecl;external libc_nlm name 'UnRegisterConsoleCommand';
function UnRegisterConsoleCommand(var cmdParser:TCommandParser):longint;cdecl;external libc_nlm name 'UnRegisterConsoleCommand';

    const
       SP_TYPE_NUMBER = 0;
    { 'value' points to DWORD (0 or !0) }
       SP_TYPE_BOOLEAN = 1;
       SP_TYPE_TICKS = 2;
       SP_TYPE_BLOCK_SHIFT = 3;
    { [+|-]hh:mm:ss converted to seconds  }
       SP_TYPE_TIME_OFFSET = 4;
    { 'value' points to char buffer  }
       SP_TYPE_STRING = 5;
       SP_TYPE_TRIGGER = 6;
    { settable parameter flags...  }
       SP_STARTUP_ONLY = $01;
       SP_HIDE = $02;
       SP_ADVANCED = $04;
       SP_STARTUP_OR_LATER = $08;
    { can't be done on secured console  }
       SP_NOT_SECURED_CONSOLE = $10;
    { lock console RPC from changing value  }
       SP_RPC_LOCKOUT = $20;
    { settable parameter categories...  }
       SP_COMMUNICATIONS = 0;
       SP_MEMORY = 1;
       SP_FILE_CACHE = 2;
       SP_DIR_CACHE = 3;
       SP_FILE_SYSTEM = 4;
       SP_LOCKS = 5;
       SP_TRANS_TRACKING = 6;
       SP_DISK = 7;
       SP_TIME = 8;
       SP_NCP = 9;
    { recommended most common  }
       SP_MISCELLANEOUS = 10;
       SP_ERRORS = 11;
       SP_DIRECTORY_SERVICES = 12;
       SP_MULTIPROCESSOR = 13;
    { type depends on 'type' field  }
    { for parameter name  }
    { for parameter description  }


type

   Psettableparms_t = ^Tsettableparms;
   Tsettableparms = record
        link        : pointer;
        value       : pointer;
        rTag        : rtag_t;
        name        : Pchar;
        _type       : byte;
        flags       : byte;
        category    : byte;
        reserved    : byte;
        lower_limit : dword;
        upper_limit : dword;
        callback    : procedure (oldValue:dword);cdecl;
        description : Pchar;
        msg_namenum : word;
        msg_descnum : word;
     end;
    Psettableparms = Psettableparms_t;

function RegisterSetableParameter(setparms:Psettableparms_t):longint;cdecl;external system_nlm name 'RegisterSetableParameter';
function RegisterSetableParameter(var setparms:Tsettableparms):longint;cdecl;external system_nlm name 'RegisterSetableParameter';
function DeRegisterSetableParameter(setparms:Psettableparms_t):longint;cdecl;external system_nlm name 'DeRegisterSetableParameter';
function DeRegisterSetableParameter(var setparms:Tsettableparms):longint;cdecl;external system_nlm name 'DeRegisterSetableParameter';

function GetSetableParameterValue(slot:longint; name:Pchar; value:pointer):longint;cdecl;external system_nlm name 'GetSetableParameterValue';
function GetSetableParameterValue(slot:longint; name:Pchar; var value):longint;cdecl;external system_nlm name 'GetSetableParameterValue';

function ScanSetableParameters(scanCategory:longint; scanSequence:Pdword; name:Pchar; _type:Plongint; flags:Pdword;
           category:Plongint; description:pointer; value:pointer; lowerLimit:Plongint; upperLimit:Plongint):longint;cdecl;external system_nlm name 'ScanSetableParameters';
function ScanSetableParameters(scanCategory:longint; var scanSequence:dword; name:Pchar; var _type:longint; var flags:dword;
           var category:longint; var description, value; var lowerLimit,upperLimit:longint):longint;cdecl;external system_nlm name 'ScanSetableParameters';

function SetSetableParameterValue(slot:longint; name:Pchar; newValue:pointer):longint;cdecl;external system_nlm name 'SetSetableParameterValue';
function SetSetableParameterValue(slot:longint; name:Pchar; var newValue):longint;cdecl;external system_nlm name 'SetSetableParameterValue';
{ NLM start-up synchronization...  }
procedure SynchronizeStart;cdecl;external system_nlm name 'SynchronizeStart';
{ message table loading...  }
function LoadLanguageMessageTable(table:PPPchar; count:Plongint; languageID:Plongint):longint;cdecl;external system_nlm name 'LoadLanguageMessageTable';
{ timer interfaces...  }
function GetHighResolutionTimer:dword;cdecl;external system_nlm name 'GetHighResolutionTimer';
function GetSuperHighResolutionTimer:dword;cdecl;external system_nlm name 'GetSuperHighResolutionTimer';

{ spin locks for use in the kernel (not from a protected address space)...  }
type
   Pspinlock_t = ^spinlock_t;
   spinlock_t  = pointer;
   TSpinlock = spinlock_T;
   PSpinlock = Pspinlock_t;

function KernelSpinLockInit(lock:Pspinlock_t):longint;cdecl;external system_nlm name 'KernelSpinLockInit';
procedure KernelSpinLock(lock:Pspinlock_t);cdecl;external system_nlm name 'KernelSpinLock';
function KernelSpinTryLock(lock:Pspinlock_t):longint;cdecl;external system_nlm name 'KernelSpinTryLock';
procedure KernelSpinUnlock(lock:Pspinlock_t);cdecl;external system_nlm name 'KernelSpinUnlock';
function KernelSpinLockDisable(lock:Pspinlock_t):dword;cdecl;external system_nlm name 'KernelSpinLockDisable';
function KernelSpinTryLockDisable(lock:Pspinlock_t; flags:Pdword):longint;cdecl;external system_nlm name 'KernelSpinTryLockDisable';
procedure KernelSpinUnlockRestore(lock:Pspinlock_t; flags:dword);cdecl;external system_nlm name 'KernelSpinUnlockRestore';

function KernelSpinLockInit(var lock:spinlock_t):longint;cdecl;external system_nlm name 'KernelSpinLockInit';
procedure KernelSpinLock(var lock:spinlock_t);cdecl;external system_nlm name 'KernelSpinLock';
function KernelSpinTryLock(var lock:spinlock_t):longint;cdecl;external system_nlm name 'KernelSpinTryLock';
procedure KernelSpinUnlock(var lock:spinlock_t);cdecl;external system_nlm name 'KernelSpinUnlock';
function KernelSpinLockDisable(var lock:spinlock_t):dword;cdecl;external system_nlm name 'KernelSpinLockDisable';
function KernelSpinTryLockDisable(var lock:spinlock_t; flags:Pdword):longint;cdecl;external system_nlm name 'KernelSpinTryLockDisable';
procedure KernelSpinUnlockRestore(var lock:spinlock_t; flags:dword);cdecl;external system_nlm name 'KernelSpinUnlockRestore';


{ nonpreferred locale interfaces...  }
type
   Pcountryinfo_t = ^Tcountryinfo;
   Tcountryinfo = record
        infoID : byte;
        size : word;
        countryID : word;
        codePage : word;
        dateFormat : word;
        currencySymbol : array[0..4] of char;
        thousandSeparator : array[0..1] of char;
        decimalSeparator : array[0..1] of char;
        dateSeparator : array[0..1] of char;
        timeSeparator : array[0..1] of char;
        currencyFormatFlags : char;
        digitsInCurrency : char;
        timeFormat : char;
        UpperCase : procedure ;cdecl;
        dataListSeparator : array[0..1] of char;
        spare : array[0..9] of char;
     end;
   Pcountryinfo = Pcountryinfo_t;

function OSGetCodePage:longint;cdecl;external libc_nlm name 'OSGetCodePage';
procedure OSGetCountryInfo(_para1:Pcountryinfo_t);cdecl;external system_nlm name 'OSGetCountryInfo';
procedure OSGetCountryInfo(var _para1:Tcountryinfo);cdecl;external system_nlm name 'OSGetCountryInfo';

    const
       EXCEPTION_HANDLED     = 0;
       EXCEPTION_NOT_HANDLED = 1;     // chain to next handler
       { registered debugger parser returns:  }
       NEXT_DEBUG_PARSER     = -(2);  // call next debug parser
       NEXT_ALT_DEBUG_PARSER = -(1);  // call next registered debug parser
       COMMAND_HANDLED       = 0;     // call no other parser
       INTERNAL_DEBUGGER     = 1;     // pass to NetWare System Debugger


type
   Pexceptionframe = ^exceptionframe;
   exceptionframe = record
        xfReserved : array[0..6] of dword;
        xfCR3 : Pdword;
        xfEIP : dword;
        xfSystemFlags : dword;
        xfEAX : dword;
        xfECX : dword;
        xfEDX : dword;
        xfEBX : dword;
        xfESP : dword;
        xfEBP : dword;
        xfESI : dword;
        xfEDI : dword;
        xfES : array[0..1] of word;
        xfCS : array[0..1] of word;
        xfSS : array[0..1] of word;
        xfDS : array[0..1] of word;
        xfFS : array[0..1] of word;
        xfGS : array[0..1] of word;
        xfLDT : array[0..1] of word;
        xfSpecial : array[0..1] of word;
        xfNumber : dword;
        xfDescription : Pchar;
        xfFlags : dword;
        xfErrorCode : dword;
        xfPageFaultCR2 : dword;
        xfFPUState : dword;
        xfHistogram : dword;
        xfProcessorID : dword;
     end;
   xframe_t = exceptionframe;
   Pxframe_t = ^xframe_t;

   SoftBPHandler_t = function (number:longint; address:pointer; frame:Pxframe_t):longint;cdecl;
   DebugParser_t = function (scr:scr_t; command:Pchar; frame:Pxframe_t):longint;cdecl;


procedure Abend(message:Pchar);cdecl;external system_nlm name 'Abend';
function AddressOfSoftBreakpoint(number:longint):pointer;cdecl;external system_nlm name 'AddressOfSoftBreakpoint';
function AddSoftBreakpoint(addr:pointer; handler:SoftBPHandler_t):longint;cdecl;external system_nlm name 'AddSoftBreakpoint';
function CSetABreakpoint(number:longint; addr:pointer; _type:byte; length:byte):longint;cdecl;external system_nlm name 'CSetABreakpoint';
procedure EnterDebugger;cdecl;external system_nlm name 'EnterDebugger';
function GetDebuggerActiveCount:longint;cdecl;external system_nlm name 'GetDebuggerActiveCount';
function RegisterDebugCommandParser(parseRoutine:DebugParser_t; rTag:rtag_t):longint;cdecl;external system_nlm name 'RegisterDebugCommandParser';
function RemoveSoftBreakpoint(number:longint):longint;cdecl;external system_nlm name 'RemoveSoftBreakpoint';
function ReserveABreakpointRTag(_para1:rtag_t):longint;cdecl;external system_nlm name 'ReserveABreakpointRTag';
function UnRegisterDebugCommandParser(parseRoutine:DebugParser_t):longint;cdecl;external system_nlm name 'UnRegisterDebugCommandParser';
function UnReserveABreakpoint(_para1:longint):longint;cdecl;external system_nlm name 'UnReserveABreakpoint';


//?? dont know what this is: (exported by system)
//var preferredModule : pointer;cvar;external;

{ Prototypes for libraries and drivers writing their own start-up and shut-
  down code. (DllMain() is also part of this list and defined in windows.h.)
  These are not interfaces, but only prototypes for code furnished by the
  NLM application, library, driver, etc. }

function _NonAppCheckUnload:longint;cdecl;external libc_nlm name '_NonAppCheckUnload';

type TReadRoutine = function (conn:longint; fileHandle:pointer; offset,nbytes,bytesRead:Psize_t; buffer:pointer):longint; cdecl;
function _NonAppStart(NLMHandle:TNLMHandle; errorScreen:pointer; commandLine:Pchar; loadDirPath:Pchar; uninitializedDataLength:size_t;
           NLMFileHandle:pointer; readRoutineP:TReadRoutine; customDataOffset:size_t; customDataSize:size_t; messageCount:longint;
           messages:PPchar):longint;cdecl;external libc_nlm name '_NonAppStart';
procedure _NonAppStop;cdecl;external libc_nlm name '_NonAppStop';

  const
     CTX_ACTUAL_CWD = $01;
  { for set_pathname_format(), namespace appellations...  }
     SHORT_NAMES     = 0;    { 8.3 format  }
     MACINTOSH_NAMES = 1;
     NFS_NAMES       = 2;
     FTAM_NAMES      = 3;
     LONG_NAMES      = 4;    { default long-name format  }
     NT_NAMES        = 5;
  { definitions useful to fshooks.h (attribute-match) and others...  }

     ATTR_NORMAL             = $00000000;  { no read/write restrictions  }
     ATTR_READ_ONLY          = $00000001;  { read-only file }
     ATTR_HIDDEN             = $00000002;  { hidden file }
     ATTR_SYSTEM             = $00000004;  { system file }
     ATTR_EXECUTE            = $00000008;  { execute only file }
     ATTR_VOLUME_ID          = $00000008;  { file system label           }
     ATTR_DIRECTORY          = $00000010;  { subdirectory                }
     ATTR_ARCHIVE            = $00000020;  { archive file                }
     ATTR_SHARE              = $00000080;  { Sharable file               }
     ATTR_NO_SUBALLOC        = $00000800;  { don't sub allocate file     }
     ATTR_TRANS              = $00001000;  { trans'l file, TTS-usable    }
     ATTR_READAUD            = $00004000;  { read audit                  }
     ATTR_WRITAUD            = $00008000;  { write audit                 }
     ATTR_IMMPURG            = $00010000;  { immediate purge             }
     ATTR_NORENAM            = $00020000;  { rename inhibit              }
     ATTR_NODELET            = $00040000;  { delete inhibit              }
     ATTR_NOCOPY             = $00080000;  { copy inhibit                }

     ATTR_FILE_MIGRATED      = $00400000;  { file has been migrated      }
     ATTR_DONT_MIGRATE       = $00800000;  { don't migrate this file     }
     ATTR_IMMEDIATE_COMPRESS = $02000000;  { compress file immediately   }
     ATTR_FILE_COMPRESSED    = $04000000;  { file is compressed          }
     ATTR_DONT_COMPRESS      = $08000000;  { don't compress this file    }
     ATTR_CANT_COMPRESS      = $20000000;  { can't compress this file    }
     ATTR_ATTR_ARCHIVE       = $40000000;  { entry has been modified     }
  { Faster, better when getstat() or fgetstat() used with request bit map...  }
     ST_NONE        = $00000000;
     ST_FLAGS_BIT   = $00000001;
     ST_MODE_BIT    = $00000002;
     ST_GEN_BIT     = $00000004;
     ST_INO_BIT     = $00000008;
     ST_DEV_BIT     = $00000010;
     ST_RDEV_BIT    = $00000020;
     ST_SIZE_BIT    = $00000040;
     ST_BLOCKS_BIT  = $00000080;
     ST_BLKSIZE_BIT = $00000100;
     ST_NLINK_BIT   = $00000200;
     ST_UID_BIT     = $00000400;
     ST_GID_BIT     = $00000800;
     ST_BID_BIT     = $00001000;
     ST_MID_BIT     = $00002000;
     ST_ATIME_BIT   = $00004000;
     ST_MTIME_BIT   = $00008000;
     ST_CTIME_BIT   = $00010000;
     ST_BTIME_BIT   = $00020000;
     ST_STAT_BITS   = $0003FFFF;        { bits for normal stat call }
  { the following are not returned by a normal stat call }
     ST_RIGHTS_BIT  = $00040000;
     ST_NAME_BIT    = $00080000;
     ST_NS_BIT      = $00100000;        { return name in specified namespace }
  { path analysis/parsing 'type' and 'flags' arguments for [de]construct() }
     PATH_UNDEF     = $00000000;

     PATH_DOS       = PATH_UNDEF;       { indicates potential DOS path }
     PATH_UNC       = $00000001;        { double slash found at beginning }
     PATH_UNIX      = $00000002;        { forward slashes only }
     PATH_NETWARE   = $00000004;        { slash and colon followed by slashes }
     PATH_MACINTOSH = $00000008;        { only colons }
     PATH_ROOTED    = $00000010;        { starts with delimiter }
     PATH_VOLROOTED = $00000020;        { volume plus colon appears }
     PATH_EXTENSION = $00000040;        { contains period }
     PATH_HIERARCHY = $00000080;        { at least one subdirectory element }
     PATH_SHORTNAME = $00000100;        { 8.3 names only }
     PATH_LONGNAME  = $00000200;        { at least one element greater than 8.3 }
     PATH_ENDED     = $00000400;        { ends in delimiter }
     PATH_DOSDRIVE  = $00001000;        { single-letter drive, colon and path }
     PATH_MIXEDCASE = $00002000;        { at least one element in mixed case }
     PATH_DOTS      = $00004000;        { path contains dots }
     PATH_SLASH     = $00008000;        { path contains a slash }
     PATH_BACKSLASH = $00010000;        { path contains a backslash }
     PATH_COLON     = $00020000;        { path contains a colon }
     PATH_ILLEGAL   = $80000000;        { illegal character or combination }
     //PATH_MIXED = PATH_SHORT or PATH_LONG;
{     d_cdatetime = d_cdatetim.tv_sec;
     d_adatetime = d_adatetim.tv_sec;
     d_bdatetime = d_bdatetim.tv_sec;
     d_ddatetime = d_ddatetim.tv_sec;}
       FSKEY_NONE = -(1);
       FSKEY_TRAD = 0;
       FSKEY_NSS  = 1;
    { values returned by _fildes_type(): see sys/mode.h  }
    { values returned by _fs_type()...  }
    { 'fildes' is not a file                        }
       FS_NOT_FS  = $00000000;
       FS_LFS     = $00000100;  { file in local, traditional file system }
       FS_REMOTE  = $00000200;  { file in remote file system }
       FS_DOS     = $00000400;  { file in local, DOS file system }
       FS_NSS     = $00000800;  { file in Novell Storage Services }




{ for getcwdpath(), get NKS context for current working directory...  }
{ for set_pathname_format(), namespace appellations...  }
{ definitions useful to fshooks.h (attribute-match) and others...  }
{ Faster, better when getstat() or fgetstat() used with request bit map...  }
{ the following are not returned by a normal stat call                       }
{ path analysis/parsing 'type' and 'flags' arguments for [de]construct()     }
{ d_ddatetim & d_deletedID valid only in scanerasedfiles                     }
{ c.f. these fields in struct dirent...  }
{ untouched by scanerasedfiles()         }

type
   Pnwdirent = ^Tnwdirent;
   Tnwdirent = record
        d_userspec : dword;
        d_flags : dword;                         // flags for this entry
        d_type : mode_t;                         // type of entry
        d_mode : mode_t;                         // emulated file mode
        d_ino : ino_t;                           // directory entry number of d_name
        d_size : off64_t;                        // size of file
        d_spare : array[0..38] of dword;
        d_cdatetim : timespec_t;                 // creation date and time
        d_adatetim : timespec_t;                 // last access date--files only
        d_bdatetim : timespec_t;                 // last archive date and time
        d_ddatetim : timespec_t;                 // deleted date/time
        d_uid : uid_t;                           // owner id (object id)
        d_archivedID : uid_t;                    // object ID that last archived file
        d_updatedID : uid_t;                     // object ID that last updated file
        d_deletedID : uid_t;                     // deleted ID
        d_pad1 : byte;
        d_pad2 : byte;
        d_pad3 : byte;
        d_namelen : byte;                        // lenght of following name:
        d_name : array[0..(255 + 1)-1] of char;  // only portable field in this structure
     end;
   TNWDIR = Tnwdirent;
   PNWDIR = ^TNWDIR;
{ sizeof(struct nwdirent)==0x200 (512.)  }
{ extensions of unistd.h path parsing functions...  }


function deconstruct(path:Pchar; server:Pchar; volume:Pchar; directory:Pchar; name:Pchar;
           extension:Pchar; elements:Plongint; flags:Plongint):longint;cdecl;external libc_nlm name 'deconstruct';
function construct(path:Pchar; server:Pchar; volume:Pchar; directory:Pchar; name:Pchar;
           extension:Pchar; flags:longint):longint;cdecl;external libc_nlm name 'construct';
{ extensions of client.h identity functions...  }
function get_identity(pathctx:NXPathCtx_t; identity:Plongint):longint;cdecl;external libc_nlm name 'get_identity';
{ extensions of unistd.h current working directory I/O functions...  }
function getcwdpath(buf:Pchar; pathCtx:PNXPathCtx_t; flags:dword):Pchar;cdecl;external libc_nlm name 'getcwdpath';

function chdir2(path:Pchar):longint;cdecl;external libc_nlm name 'chdir2';
function setcwd(pathCtx:NXPathCtx_t):longint;cdecl;external libc_nlm name 'setcwd';
function setcwd2(pathCtx:NXPathCtx_t):longint;cdecl;external libc_nlm name 'setcwd2';
{ extensions of unistd.h file I/O functions...  }
function Fpeof(fildes:longint):longint;cdecl;external libc_nlm name 'eof';
function tell(fildes:longint):off_t;cdecl;external libc_nlm name 'tell';
function Fptell(fildes:longint):off_t;cdecl;external libc_nlm name 'tell';
{ extensions of sys/stat.h functions...  }
function fgetstat(fildes:longint; buf:Pstat; requestmap:dword):longint;cdecl;external libc_nlm name 'fgetstat';

function getstat(ctx:NXPathCtx_t; path:Pchar; buf:Pstat; requestmap:dword):longint;cdecl;external libc_nlm name 'getstat';
function fgetstat_with_namespace(fildes:longint; buf:Pstat; requestmap:dword; _namespace:longint):longint;cdecl;external libc_nlm name 'fgetstat_with_namespace';

function getstat_with_namespace(ctx:NXPathCtx_t; path:Pchar; buf:Pstat; requestmap:dword; _namespace:longint):longint;cdecl;external libc_nlm name 'getstat_with_namespace';
{ pathname format (namespace) state...  }
function set_pathname_format(newformat:longint; oldformat:Plongint):longint;cdecl;external libc_nlm name 'set_pathname_format';
{ for use with Novell Clustering...  }

function isclusteredvirtualserver(servername:Pchar):longint;cdecl;external libc_nlm name 'isclusteredvirtualserver';
{ equivalent to CLib's FileServerFileCopy()...  }
function fscopy(fildes1:longint; fildes2:longint; offset1:off64_t; offset2:off64_t; length:size_t;
           nbytes:Psize_t):longint;cdecl;external libc_nlm name 'fscopy';
{ equivalent to similarly named calls in CLib...  }

function purgeerasedfile(path:Pchar; sequence:longint):longint;cdecl;external libc_nlm name 'purgeerasedfile';


function salvageerasedfile(pathName:Pchar; sequence:longint; newFileName:Pchar):longint;cdecl;external libc_nlm name 'salvageerasedfile';

function scanerasedfiles(path:Pchar; nextEntryNumber:Plongint; deletedFileInfo:PNWDIR):longint;cdecl;external libc_nlm name 'scanerasedfiles';
function _fs_type(fildes:longint):longint;cdecl;external libc_nlm name '_fs_type';
function _fildes_type(fildes:longint):longint;cdecl;external libc_nlm name '_fildes_type';
function _fildes_from_nsskey(key:Tuint64; oflag:longint):longint;cdecl;external libc_nlm name '_fildes_from_nsskey';
function _key_from_fildes(fildes:longint; _type:Plongint; err:Plongint):Tuint64;cdecl;external libc_nlm name '_key_from_fildes';
{ fast type of a file descriptor--st_mode in fstat()...  }
{ equates to move between NKS file handles and POSIX descriptors...  }
{ derivation of POSIX descriptor from NSS open file key...  }
{ back-derivation of file system key...  }
{ types returned in back-derivation...  }
{ values returned by _fildes_type(): see sys/mode.h  }
{ values returned by _fs_type()...  }
{ attributes for NXDirAttrWin_t 'dwFileAttributes' field...  }


{ turn on 1-byte packing...  }

  const
     FILE_ATTRIBUTE_READONLY            = $00000001;
     FILE_ATTRIBUTE_HIDDEN              = $00000002;
     FILE_ATTRIBUTE_SYSTEM              = $00000004;
     FILE_ATTRIBUTE_DIRECTORY           = $00000010;
     FILE_ATTRIBUTE_ARCHIVE             = $00000020;
     FILE_ATTRIBUTE_ENCRYPTED           = $00000040;
     FILE_ATTRIBUTE_NORMAL              = $00000080;
     FILE_ATTRIBUTE_TEMPORARY           = $00000100;
     FILE_ATTRIBUTE_SPARSE_FILE         = $00000200;
     FILE_ATTRIBUTE_REPARSE_POINT       = $00000400;
     FILE_ATTRIBUTE_COMPRESSED          = $00000800;
     FILE_ATTRIBUTE_OFFLINE             = $00001000;
     FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = $00002000;


type
   PNXDirAttrDos_t = ^NXDirAttrDos_t;
   NXDirAttrDos_t = record                    { DOS/FAT32 (NX_PNF_DOS) attributes    }
        xdeHeader : NXDeHeader_t;
        xdeFid : NXFid_t;
        xdeEffectiveRights : dword;
                                              { FAT32 File System Spec., p. 22       }
        xdeAttr : dword;
        xdeCrtDate : word;
        xdeCrtTime : word;
        xdeCrtTimeTenth : word;
        xdeLastAccDate : word;
        xdeWrtDate : word;
        xdeWrtTime : word;
        xdeFileSize : dword;
        Reserved1 : dword;
        Reserved2 : dword;
     end;
{ DOS/FAT32 (NX_PNF_DOS) information.. }
{ ...including name                    }
{ maximum length is 255 characters     }

   PNXDirEnumDos_t = ^NXDirEnumDos_t;
   NXDirEnumDos_t = record
        deDosDirAttr : NXDirAttrDos_t;
        deDirMark : NXDirMark_t;
        deShortName : array[0..15] of char;
        deName : pointer;
     end;
{ Win32 (NX_PNF_WIN) attributes        }
{ see WIN32_FIND_DATA...               }
{ FILE_ATTRIBUTE_NORMAL, etc.          }
{ date and time of creation or -1      }
{ date and time of last access         }
{ date and time of last modification   }
{ date and time of last attr change    }
{ see BY_HANDLE_FILE_INFORMATION...    }
{ always 1 for FAT                     }
{ unique identifier                    }
{ CIFS Specification 0.9, 4.2.16.8...  }
{ file system block size               }
{ (currently) Ramesh-invented fields... }
{ not in Win32 docs, but exists        }
{ Boolean flag fields for CIFS         }
{ total size of extended attributes    }
{ size of compressed file           }
{ format of of compression           }

   PNXDirAttrWin_t = ^NXDirAttrWin_t;
   NXDirAttrWin_t = record
        xdeHeader : NXDeHeader_t;
        xdeFid : NXFid_t;
        xdeEffectiveRights : dword;
        xdeFileAttributes : dword;
        xdeCreateTime : Tuint64;
        xdeLastAccessTime : Tuint64;
        xdeLastWriteTime : Tuint64;
        xdeLastChangeTime : Tuint64;
        xdeFileSize : Tuint64;
        Reserved0 : dword;
        Reserved1 : dword;
        Reserved2 : dword;
        Reserved3 : dword;
        xdeNumberOfLinks : dword;
        xdeVolumeSerialNumber : dword;
        Reserved4 : dword;
        Reserved5 : dword;
        xdeFileIndex : Tuint64;
        Reserved6 : Tuint64;
        xdeAllocationSize : dword;
        xdeAccessFlags : dword;
        xdeMiscFlags : dword;
        Reserved7 : dword;
        xdeEaSize : Tuint64;
        xdeCompressedFileSize : Tuint64;
        xdeCompressionFormat : word;
        Reserved8 : word;
        Reserved9 : dword;
        Reserved10 : Tuint64;
     end;
{ Win32 (NX_PNF_WIN) information...    }
{ ...including name                    }
{ see WIN32_FIND_DATA...               }
{ maximum length is 255 characters     }

   PNXDirEnumWin_t = ^NXDirEnumWin_t;
   NXDirEnumWin_t = record
        deWinDirAttr : NXDirAttrWin_t;
        deDirMark : NXDirMark_t;
        deAlternativeFileName : array[0..15] of char;
        deName : pointer;
     end;

// nks/errno.h

  const
     NX_EOF = -(1);
     NX_ENOENT = 1;        { no such file or directory                      }
     NX_E2BIG = 2;         { argument list too big                          }
     NX_ENOEXEC = 3;       { exec format error                              }
     NX_EBADF = 4;         { bad file number (descriptor or handle)         }
     NX_ENOMEM = 5;        { not enough memory                              }
     NX_EACCES = 6;        { permission denied                              }
     NX_EEXIST = 7;        { file exists                                    }
     NX_EXDEV = 8;         { cross-device link                              }
     NX_EINVAL = 9;        { invalid argument                               }
     NX_ENFILE = 10;       { file table overflow                            }
     NX_EMFILE = 11;       { too many open files                            }
     NX_ENOSPC = 12;       { no space left on device                        }
     NX_ERANGE = 14;       { result too large                               }
     NX_EDEADLK = 15;      { resource deadlock would occur                  }
     NX_EINUSE = 16;       { resource(s) in use                             }
     NX_ESERVER = 17;      { server error (memory out, I/O error, etc.)     }
     NX_ENOSERVR = 18;     { no server (queue server, file server, etc.)    }
     NX_EWRNGKND = 19;     { wrong kind--an operation is being...           }
                           {  ...attempted on the wrong kind of object      }
     NX_ETRNREST = 20;     { transaction restarted                          }
     NX_ERESOURCE = 21;    { resources unavailable (maybe permanently)      }
     NX_EBADHNDL = 22;     { bad non-file handle (screen, semaphore, etc.)  }
     NX_EAGAIN = 24;       { resource temporarily unavailable               }
     NX_EIO = 28;          { physical I/O error                             }
     NX_EPIPE = 32;        { broken pipe                                    }
     NX_EALREADY = 37;     { operation already in progress                  }
     NX_ETIMEDOUT = 60;    { connection timed out                           }
     NX_EBUSY = 62;        { resource busy                                  }
     NX_EINTR = 63;        { interrupted function call                      }
     NX_EISDIR = 64;       { is a directory (not a file)                    }
     NX_ENAMETOOLONG = 65; { filename too long                              }
     NX_ENOSYS = 66;       { function not implemented                       }
     NX_ENOTDIR = 67;      { not a directory                                }
     NX_ENOTEMPTY = 68;    { directory is not empty                         }
     NX_EPERM = 69;        { operation not permitted                        }
     NX_ECHILD = 70;       { no child process                               }
     NX_EFBIG = 71;        { file too large                                 }
     NX_EMLINK = 72;       { too many links                                 }
     NX_ENOLCK = 74;       { no locks available                             }
     NX_ESRCH = 77;        { no such object                                 }
     NX_ENOTSUP = 79;      { this optional functionality not supported      }
     NX_EBADTYPE = 80;     { bad type for operation                         }
     NX_EOVERFLOW = 81;    { operation would overflow                       }
     NX_EHOSTDOWN = 82;    { host is down                                   }
     NX_EHOSTUNREACH = 83; { no route to host                               }
     NX_EPROCLIM = 84;     { too many processes                             }
     NX_EUNKNOWN = 99;     { unknown error occurring                        }
     NX_ENLMDATA = 100;    { anomaly in NLM data structure                  }
     NX_EILSEQ = 101;      { illegal character sequence in multibyte        }
     NX_EINCONSIS = 102;   { internal library inconsistency                 }
     NX_EDOSTEXTEOL = 103; { DOS-text file inconsistency--no newline...     }
                           { ...after carriage return                       }
     NX_ENONEXTANT = 104;  { object doesn't exist                           }
     NX_ENOCONTEXT = 105;  { the caller is not an NKS thread                }
     NX_ENAMESPACE = 106;  { invalid namespace or namespace operation       }
     NX_EBADCONN = 107;    { invalid connection                             }
     NX_EEXHAUSTED = 108;  { end of search                                  }
     NX_EFILESYS = 111;    { generic file system error                      }
     NX_ESUFFICIENT = 112; { insufficient space for any operation result    }
     NX_EPARTONLY = 113;   { partial result only  for lack of space         }
     NX_EBADIDENT = 114;   { invalid user or other identity                 }
     { aliases...  }
     NX_ENOSUPPORT = NX_ENOTSUP;
     //NX_ENORESOURCE = NX_BADIDENT;


procedure NXGetNKSVersion(major:Plongint; minor:Plongint; revision:Plongint; platformName:pointer; maxNameLength:size_t);cdecl;external libc_nlm name 'NXGetNKSVersion';
procedure NXGetNKSVersion(var major, minor, revision:longint; platformName:pchar; maxNameLength:size_t);cdecl;external libc_nlm name 'NXGetNKSVersion';
function NXStrError(errornumber:longint):Pchar;cdecl;external libc_nlm name 'NXStrError';


// nks/mac.h
{ turn on 1-byte packing...  }

  { values for 'fdFlags' (Inside Macintosh IV-105)...  }

const
  fOnDesk    = 1;
  fHasBundle = 8192;
  fInvisible = 16384;
  { values for 'fdLocation' (Inside Macintosh IV-105)...  }
  fDisk      = 0;
  fDesktop   = -(2);
  fTrash     = -(3);
  { 'ioFlAttrib' values...  }
  flLocked   = $01;
  flResOpen  = $04;
  flDatOpen  = $08;
  flIsDir    = $10;
  flBothOpen = $80;

type
   POSType = ^OSType;
   OSType = char;
{ (Inside Macintosh II-373)  }
{ (Inside Macintosh I-139)  }

   PPoint = ^Point;
   Point = record
        v : word;
        h : word;
     end;
{ (Inside Macintosh I-141)  }

   PRect = ^Rect;
   Rect = record
       case longint of
          0 : ( corner : record
               topLeft : Point;
               botRight : Point;
            end );
          1 : ( point : record
               top : word;
               left : word;
               bottom : word;
               right : word;
            end );
       end;
{ (Inside Macintosh IV-104)  }
{ window  }

   PFInfo = ^FInfo;
   FInfo = record
        fdType : OSType;
        fdCreator : OSType;
        fdFlags : word;
        fdLocation : Point;
        fdFldr : word;
     end;
{ (Inside Macintosh IV-105)  }
{ Finder (Desktop) comment ID  }
{ home directory ID  }

   PFXInfo = ^FXInfo;
   FXInfo = record
        fdIconID : word;
        fdUnused : array[0..3] of word;
        fdComment : word;
        fdPutAway : dword;
     end;
{ (Inside Macintosh IV-105)  }
{ folder's rectangle  }

   PDInfo = ^DInfo;
   DInfo = record
        frRect : Rect;
        frFlags : word;
        frLocation : Point;
        frView : word;
     end;
{ scroll position                            }
{ directory ID chain of open folders         }
{ directory ID                               }

   PDXInfo = ^DXInfo;
   DXInfo = record
        frScroll : Point;
        frOpenChain : dword;
        frUnused : word;
        frComment : word;
        frPutAway : dword;
     end;
{ information used by the Finder             }
{ directory ID or file number                }
{ first allocation block of data fork        }
{ logical end-of-file of data fork           }
{ physical end-of-file of data fork          }
{ first allocation block of resource fork    }
{ logical end-of-file of resource fork       }
{ physical end-of-file of resource fork      }
{ date and time of creation                  }
{ date and time of last modification         }
{ date and time of last back-up              }
{ additional information used by the Finder  }
{ file's parent directory ID                 }
{ file's clump size                          }

   PhFileInfo = ^hFileInfo;
   hFileInfo = record
        ioFlFndrInfo : FInfo;
        ioDirID : dword;
        ioFlStBlk : word;
        ioFlLgLen : dword;
        ioFlPyLen : dword;
        ioFlRStBlk : word;
        ioFlRLgLen : dword;
        ioFlRPyLen : dword;
        ioFlCrDat : dword;
        ioFlMdDat : dword;
        ioFlBkDat : dword;
        ioFlXFndrInfo : FXInfo;
        ioFlParID : dword;
        ioFlClpSiz : dword;
     end;
{ information used by the Finder             }
{ number of files in directory               }
{ date and time of creation                  }
{ date and time of last modification         }
{ date and time of last backup               }
{ additional information used by the Finder  }
{ directory's parent directory ID            }

   PdirInfo = ^dirInfo;
   dirInfo = record
        ioDrUsrWds : DInfo;
        ioDrDirID : dword;
        ioDrNmFls : word;
        filler3 : array[0..8] of word;
        ioDrCrDat : dword;
        ioDrMdDat : dword;
        ioDrBkDat : dword;
        ioDrFndrInfo : DXInfo;
        ioDrParID : dword;
     end;

   PCInfoPBRec = ^CInfoPBRec;
   CInfoPBRec = record
       case longint of
          0 : ( _file : hFileInfo );
          1 : ( dir : dirInfo );
       end;
{ Macintosh (NX_PNF_MAC) attributes          }
{ (Inside Macintosh IV-125)  }
{ path reference number  }

   PNXDirAttrMac_t = ^NXDirAttrMac_t;
   NXDirAttrMac_t = record
        xdeHeader : NXDeHeader_t;
        xdeFid : NXFid_t;
        xdeEffectRights : dword;
        xdeIoFRefNum : word;
        xdeIofVersNum : int8_t;
        filler1 : int8_t;
        xdeIoFDirIndex : word;
        xdeIoFlAttrib : int8_t;
        filler2 : int8_t;
        filler3 : dword;
        xdeInfo : CInfoPBRec;
     end;
{ Macintosh (NX_PNF_MAC) information...      }
{ ...including                               }
{ maximum length is 255 characters     }

   PNXDirEnumMac_t = ^NXDirEnumMac_t;
   NXDirEnumMac_t = record
        deMacDirAttr : NXDirAttrMac_t;
        deDirMark : NXDirMark_t;
        deName : pointer;
     end;

(** unsupported pragma#pragma pack()*)

// nks/memory.h

  { deprecated values for memory control flags...  }

  const
     NX_PAGE_UNLOCK       = $00000000;
     NX_PAGE_LOCK         = $00000001;
     NX_PAGE_RESERVE      = $00000020;
     NX_PAGE_COMMIT       = $00000040;
     NX_PAGE_PHYSICAL     = $00000080;
     NX_PAGE_RESERVE_ONLY = $00000100;
  { final values for memory control flags...  }
     NX_MEM_UNLOCK        = $00000000;
     NX_MEM_LOCK          = $00000001;
     NX_MEM_DECOMMIT      = $00000020;
     NX_MEM_COMMIT        = $00000040;
     NX_MEM_RESERVE       = $00000100;

function NXMemAlloc(size:size_t; alignment:size_t):pointer;cdecl;external libc_nlm name 'NXMemAlloc';
function NXMemCtl(start:pointer; size:size_t; flags:dword):longint;cdecl;external libc_nlm name 'NXMemCtl';
procedure NXMemFree(memory:pointer);cdecl;external libc_nlm name 'NXMemFree';
function NXMemRealloc(old:pointer; newSize:size_t; alignment:size_t):pointer;cdecl;external libc_nlm name 'NXMemRealloc';
function NXPageAlloc(pageCount:size_t; flags:dword):pointer;cdecl;external libc_nlm name 'NXPageAlloc';
procedure NXPageFree(memory:pointer);cdecl;external libc_nlm name 'NXPageFree';


{ nks/netware.h =============================================================}
{ turn on 1-byte packing...  }

type

   PnxTrustees_t = ^nxTrustees_t;
   nxTrustees_t = record
        trObjectID,
        trRights   : dword;
     end;

(** unsupported pragma#pragma pack()*)
{----------------------------------------------------------------------------
 The following are unofficial NKS interfaces and can only be used on NetWare.
 ----------------------------------------------------------------------------}

procedure nxCancelCheck;cdecl;external libc_nlm name 'nxCancelCheck';
procedure nxCancelDisable;cdecl;external libc_nlm name 'nxCancelDisable';
procedure nxCancelEnable;cdecl;external libc_nlm name 'nxCancelEnable';
function nxContextFlushName(context:PNXContext_t):longint;cdecl;external libc_nlm name 'nxContextFlushName';

function nxExportInterface(funcAddr:pointer; funcName:Pchar):longint;cdecl;external libc_nlm name 'nxExportInterface';

function nxExportInterfaceWrapped(funcAddr:pointer; stackWords:longint; funcName:Pchar; reference:Ppointer):longint;cdecl;external libc_nlm name 'nxExportInterfaceWrapped';
function nxGetEnviron:PPchar;cdecl;external libc_nlm name 'nxGetEnviron';
function nxIsLoadedProtected:NXBool_t;cdecl;external libc_nlm name 'nxIsLoadedProtected';
function nxIsProtectedAddress(_para1:pointer):NXBool_t;cdecl;external libc_nlm name 'nxIsProtectedAddress';
function nxMemGetSize(block:pointer):size_t;cdecl;external libc_nlm name 'nxMemGetSize';
procedure nxUnexportInterfaceWrapped(reference:pointer);cdecl;external libc_nlm name 'nxUnexportInterfaceWrapped';
{ NetWare trustees...  }

function nxAddTrustee(pathCtx:NXPathCtx_t; pathname:Pchar; objectID:dword; rights:dword):longint;cdecl;external libc_nlm name 'nxAddTrustee';
function nxDeleteTrustee(pathCtx:NXPathCtx_t; pathname:Pchar; objectID:dword):longint;cdecl;external libc_nlm name 'nxDeleteTrustee';
function nxScanTrustees(pathCtx:NXPathCtx_t; pathname:Pchar; sequence:dword; count:Pdword; trusteeVector:PnxTrustees_t;
           nextSequence:Pdword):longint;cdecl;external libc_nlm name 'nxScanTrustees';
{ wrap/unwrap sobriquets...  }
// nks/synch.h

{ turn on 1-byte packing...  }

type
   PNXHierarchy_t = ^NXHierarchy_t;
   NXHierarchy_t = longint;

   PNXMutex_t = ^NXMutex_t;
   NXMutex_t = record
        reserved1 : Tuint64;
        reserved2 : array[0..9] of pointer;
     end;

   PNXRwLock_t = ^NXRwLock_t;
   NXRwLock_t = record
        reserved1 : Tuint64;
        reserved2 : array[0..9] of pointer;
     end;

   PNXSema_t = ^NXSema_t;
   NXSema_t = record
        reserved1 : Tuint64;
        reserved2 : array[0..4] of pointer;
     end;

   PNXCond_t = ^NXCond_t;
   NXCond_t = record
        reserved1 : Tuint64;
        reserved2 : array[0..4] of pointer;
     end;

   PNXLockInfo_t = ^NXLockInfo_t;
   NXLockInfo_t = record
        liName : array[0..(31 + 1)-1] of char;
        liFlags : dword;
        liPad : array[0..1] of dword;
     end;

(** unsupported pragma#pragma pack()*)
{ Mutexes...  }


function NXMutexAlloc(flags:dword; hierarchy:NXHierarchy_t; info:PNXLockInfo_t):PNXMutex_t;cdecl;external libc_nlm name 'NXMutexAlloc';
procedure NXMutexDeinit(mutex:PNXMutex_t);cdecl;external libc_nlm name 'NXMutexDeinit';
function NXMutexDepth(mutex:PNXMutex_t):longint;cdecl;external libc_nlm name 'NXMutexDepth';
procedure NXMutexFree(mutex:PNXMutex_t);cdecl;external libc_nlm name 'NXMutexFree';
function NXMutexInit(mutex:PNXMutex_t; flags:dword; hierarchy:NXHierarchy_t; info:PNXLockInfo_t):longint;cdecl;external libc_nlm name 'NXMutexInit';
function NXMutexIsOwned(mutex:PNXMutex_t):NXBool_t;cdecl;external libc_nlm name 'NXMutexIsOwned';
function NXMutexTestFlag(mutex:PNXMutex_t; flag:dword):NXBool_t;cdecl;external libc_nlm name 'NXMutexTestFlag';
function NXLock(mutex:PNXMutex_t):longint;cdecl;external libc_nlm name 'NXLock';
function NXTryLock(mutex:PNXMutex_t):NXBool_t;cdecl;external libc_nlm name 'NXTryLock';
function NXUnlock(mutex:PNXMutex_t):longint;cdecl;external libc_nlm name 'NXUnlock';

{ Reader-writer locks...  }
function NXRwLockAlloc(hierarchy:NXHierarchy_t; info:PNXLockInfo_t):PNXRwLock_t;cdecl;external libc_nlm name 'NXRwLockAlloc';
procedure NXRwLockDeinit(lock:PNXRwLock_t);cdecl;external libc_nlm name 'NXRwLockDeinit';
procedure NXRwLockFree(lock:PNXRwLock_t);cdecl;external libc_nlm name 'NXRwLockFree';
function NXRwLockInit(lock:PNXRwLock_t; hierarchy:NXHierarchy_t; info:PNXLockInfo_t):longint;cdecl;external libc_nlm name 'NXRwLockInit';
function NXRwLockIsOwned(lock:PNXRwLock_t; mode:dword):NXBool_t;cdecl;external libc_nlm name 'NXRwLockIsOwned';
procedure NXRdLock(lock:PNXRwLock_t);cdecl;external libc_nlm name 'NXRdLock';
procedure NXWrLock(lock:PNXRwLock_t);cdecl;external libc_nlm name 'NXWrLock';
function NXTryRdLock(lock:PNXRwLock_t):NXBool_t;cdecl;external libc_nlm name 'NXTryRdLock';
function NXTryWrLock(lock:PNXRwLock_t):NXBool_t;cdecl;external libc_nlm name 'NXTryWrLock';
procedure NXRwUnlock(lock:PNXRwLock_t);cdecl;external libc_nlm name 'NXRwUnlock';
function NXRwLockUpgrade(lock:PNXRwLock_t):longint;cdecl;external libc_nlm name 'NXRwLockUpgrade';
function NXRwLockDowngrade(lock:PNXRwLock_t):longint;cdecl;external libc_nlm name 'NXRwLockDowngrade';
{ Semaphores...  }
function NXSemaAlloc(count:dword; arg:pointer):PNXSema_t;cdecl;external libc_nlm name 'NXSemaAlloc';
procedure NXSemaDeinit(sema:PNXSema_t);cdecl;external libc_nlm name 'NXSemaDeinit';
procedure NXSemaFree(sema:PNXSema_t);cdecl;external libc_nlm name 'NXSemaFree';
function NXSemaInit(sema:PNXSema_t; count:dword; arg:pointer):longint;cdecl;external libc_nlm name 'NXSemaInit';
procedure NXSemaPost(sema:PNXSema_t);cdecl;external libc_nlm name 'NXSemaPost';
function NXSemaTryWait(sema:PNXSema_t):NXBool_t;cdecl;external libc_nlm name 'NXSemaTryWait';
procedure NXSemaWait(sema:PNXSema_t);cdecl;external libc_nlm name 'NXSemaWait';
{ Condition variables...  }
function NXCondAlloc(arg:pointer):PNXCond_t;cdecl;external libc_nlm name 'NXCondAlloc';
procedure NXCondBroadcast(cond:PNXCond_t);cdecl;external libc_nlm name 'NXCondBroadcast';
procedure NXCondDeinit(cond:PNXCond_t);cdecl;external libc_nlm name 'NXCondDeinit';
procedure NXCondFree(cond:PNXCond_t);cdecl;external libc_nlm name 'NXCondFree';
function NXCondInit(cond:PNXCond_t; arg:pointer):longint;cdecl;external libc_nlm name 'NXCondInit';
procedure NXCondSignal(cond:PNXCond_t);cdecl;external libc_nlm name 'NXCondSignal';
function NXCondWait(cond:PNXCond_t; mutex:PNXMutex_t):longint;cdecl;external libc_nlm name 'NXCondWait';
function NXCondTimedWait(cond:PNXCond_t; mutex:PNXMutex_t; interval:dword):longint;cdecl;external libc_nlm name 'NXCondTimedWait';




//  assert.h

procedure _assert(_para1,_para2, _para3:Pchar; ActionCode:longint);cdecl;external libc_nlm name '_assert';
procedure FpAssert(_para1,_para2, _para3:Pchar; ActionCode:longint);cdecl;external libc_nlm name '_assert';

type
   Taction_code =  Longint;
Const                         // modifications to behavior of assert()
  __IGNORE = -(1);            // assert() prints but returns -1
  __NOERR = 0;                // (value returned for no assertion)
  __ABORT = 1;                // assert() aborts (normal, default action)
  __DEBUGGER = 2;             // assert() prints and drops into the debugger

function assert_action(_para1:Taction_code):longint;cdecl;external libc_nlm name 'assert_action';
function _assert_expr(_para1:longint; _para2,_para3,_para4:Pchar; _para5:longint):longint;cdecl;external libc_nlm name '_assert_expr';

// nks/unix.h

{ turn on 1-byte packing...  }

{ UNIX (NX_PNF_UNIX) attributes           }
{ file mode                               }
{ number of links                         }
{ last access time (files only)           }
{ last modify time                        }
{ last archive time                       }
{ last attribute change time (or 0)       }
{ generation; bumped when file modified   }
{ entry serial number                     }
{ file system (device) containing entry   }
{ ID of raw device containing this entry  }
{ user ID of the owner of this entry      }
{ group ID of the group of this entry     }
{ length of file in bytes                 }
{ number of 512-byte blocks allocated     }
{ preferred I/O block size                }
type

   PNXDirAttrUnix_t = ^NXDirAttrUnix_t;
   NXDirAttrUnix_t = record
        xdeHeader : NXDeHeader_t;
        xdeFid : NXFid_t;
        xdeEffectiveRights : dword;
        xde_mode : dword;
        xde_nlink : dword;
        spare1 : dword;
        xde_atime : time_t;
        xde_mtime : time_t;
        xde_btime : time_t;
        xde_ctime : time_t;
        xde_change : Tuint64;
        xde_ino : Tuint64;
        xde_dev : array[0..1] of Tuint64;
        xde_rdev : array[0..1] of Tuint64;
        xde_uid : Tuint64;
        xde_gid : Tuint64;
        xde_size : Tuint64;
        xde_blocks : Tuint64;
        xde_blksize : dword;
        spare2 : dword;
        spare3 : Tuint64;
        spare4 : Tuint64;
        spare5 : Tuint64;
        spare6 : Tuint64;
        spare7 : Tuint64;
        spare8 : Tuint64;
     end;
{ UNIX (NX_PNF_UNIX) information...       }
{ ...including name                       }
{ maximum length is 255 characters        }

   PNXDirEnumUnix_t = ^NXDirEnumUnix_t;
   NXDirEnumUnix_t = record
        deUnixDirAttr : NXDirAttrUnix_t;
        deDirMark : NXDirMark_t;
        deName : pointer;
     end;

(** unsupported pragma#pragma pack()*)
//  nks/vm.h

{ value for 'wait_for' in NXVmJoin()...  }
{ values for 'flags' in NXVmSpawn()...  }
{ returned in newVm if NXVmSpawn() is passed NX_VM_DETACHED or if it fails  }

{ turn on 1-byte packing...  }

type
   PNXStrType_t = ^NXStrType_t;
   NXStrType_t  =  Longint;
Const
   NX_STR_ASCII   = $FFFFFFFF;
   NX_STR_UTF8    = $00000000;
   NX_STR_UNICODE = $00000001;

{ NX_OBJ_FILE, NX_OBJ_CONSOLE, NX_OBJ_FIFO, etc. }
{ set to 0                                       }
{ ancestor of 'ssPath'                           }
{ relative to 'ssPathCtx'                        }
type
   PNXNameSpec_t = ^NXNameSpec_t;
   NXNameSpec_t = record
        ssType : NXObjType_t;
        ssReserved : longint;
        ssPathCtx : NXPathCtx_t;
        ssPath : pointer;
     end;
   NXStreamSpec_t = NXNameSpec_t;
   PNXStreamSpec_t = ^NXStreamSpec_t;
{ unused; set to 0                               }
{ count of arguments in 'esArgv'                 }
{ command-line arguments to spawned VM           }
{ starting environment of spawned VM             }
{ wiring of standard input for spawned VM        }
{ wiring of standard output for spawned VM       }
{ wiring of standard error for spawned VM        }

   PNXExecEnvSpec_t = ^NXExecEnvSpec_t;
   NXExecEnvSpec_t = record
        esFlags : longint;
        esArgc : longint;
        esArgv : ^pointer;
        esEnv : ^pointer;
        esStdin : NXStreamSpec_t;
        esStdout : NXStreamSpec_t;
        esStderr : NXStreamSpec_t;
     end;
{ maxmimum number of threads in worker pool      }
{ implementation-reserved                        }

   PNXVmWorkerThreadConfig_t = ^NXVmWorkerThreadConfig_t;
   NXVmWorkerThreadConfig_t = record
        wtcThreads : size_t;
        reserved : array[0..4] of longint;
     end;

(** unsupported pragma#pragma pack()*)
{ Virtual machine management...  }

function  NXVmDestroy(id:NXVmId_t):longint;cdecl;external libc_nlm name 'NXVmDestroy';
procedure NXVmExit(status:longint);cdecl;external libc_nlm name 'NXVmExit';
function  NXVmGetId:NXVmId_t;cdecl;external libc_nlm name 'NXVmGetId';
function  NXVmGetWorkerThreadConfig(reserved:pointer; config:PNXVmWorkerThreadConfig_t):longint;cdecl;external libc_nlm name 'NXVmGetWorkerThreadConfig';
function  NXVmGetStringType(_type:PNXStrType_t):longint;cdecl;external libc_nlm name 'NXVmGetStringType';
function  NXVmJoin(wait_for:NXVmId_t; departed_vm:PNXVmId_t; status:Plongint):longint;cdecl;external libc_nlm name 'NXVmJoin';
function  NXVmRegisterExitHandler(cleanup:TCDeclProc1PtrArg; arg:pointer):longint;cdecl;external libc_nlm name 'NXVmRegisterExitHandler';
function  NXVmSetWorkerThreadConfig(reserved:pointer; config:PNXVmWorkerThreadConfig_t):longint;cdecl;external libc_nlm name 'NXVmSetWorkerThreadConfig';
function  NXVmSpawn(name:PNXNameSpec_t; envSpec:PNXExecEnvSpec_t; flags:dword; newVm:PNXVmId_t):longint;cdecl;external libc_nlm name 'NXVmSpawn';
function  NXVmUnregisterExitHandler(func:TCDeclProc1PtrArg; arg:pointer):longint;cdecl;external libc_nlm name 'NXVmUnregisterExitHandler';


// alloca.h
{ Non-standard functions from stdlib.h }
//** void   *alloca( size_t );


// client.h

// stdbool.h

{ origin flags...  }
{ address type flags (used in combination with ORIGIN_ADDRESS)...  }
{ transport type flags...  }
{ NMAS sequence passed...  }
{ string format flags...  }
{ suggested maximum lengths (in characters)...  }

{ turn on 1-byte packing...  }

  const
     ORIGIN_NAME    = $0010;
     ORIGIN_ADDRESS = $0020;    { interpret 'server' as 'netaddr_t'      }
  { address type flags (used in combination with ORIGIN_ADDRESS)...  }
  { address is IPX                         }
     ADDR_IPX = $0100;
     ADDR_IP = $0200;           { address is Internet Protocol           }
     ADDR_IPV6 = $0400;         { address is Internet Protocol version 6 }
  { transport type flags...  }
  { transport type unspecified             }
     XPORT_WILD = $0000;
  { prefer Novell IPX                      }
     XPORT_IPX = $0001;
  { prefer TCP                             }
     XPORT_TCP = $0002;
  { NMAS sequence passed...  }
  { alternative NMAS-based authentication  }
     NMAS_SEQUENCE = $8000;
  { string format flags...  }
     USERNAME_ASCII = $00000;
     USERNAME_UTF8 = $10000;
     USERNAME_UNICODE = $20000;
  { suggested maximum lengths (in characters)...  }
  { ASCII, Unicode or UTF-8                }
     MAX_USERNAME_LEN = 255;
  { (always in ASCII characters)           }
     MAX_PASSWORD_LEN = 255;
     MAX_TREENAME_LEN = 48;
     MAX_SERVERNAME_LEN = 48;


type

   Pnetaddr_t = ^netaddr_t;
   netaddr_t = record
        _type : longint;
        length : size_t;
        address : array[0..47] of byte;
     end;

   Pfrag_t = ^frag_t;
   frag_t = record
        data : pointer;
        length : size_t;
     end;

(** unsupported pragma#pragma pack()*)
{ managing user identity...  }


{$ifndef DisableArrayOfConst}
function build_username(max:size_t; flags:dword; username:Pchar; user:Pchar; args:array of const):longint;cdecl;external libc_nlm name 'build_username';
{$endif}
function build_username(max:size_t; flags:dword; username:Pchar; user:Pchar):longint;cdecl;external libc_nlm name 'build_username';


function create_identity(treename:Pchar; username:pointer; password:Pchar; nmas_sequence:pointer; flags:dword;
           identity:Plongint):longint;cdecl;external libc_nlm name 'create_identity';
function create_server_identity(identity:Plongint):longint;cdecl;external libc_nlm name 'create_server_identity';
function is_valid_identity(identity:longint; error:Plongint):longint;cdecl;external libc_nlm name 'is_valid_identity';
procedure delete_identity(identity:longint);cdecl;external libc_nlm name 'delete_identity';
{ managing NCP sessions with a remote server...  }

function open_ncp_session(identity:longint; flags:dword; servername:Pchar; session:Plongint):longint;cdecl;external libc_nlm name 'open_ncp_session';
function close_ncp_session(session:longint):longint;cdecl;external libc_nlm name 'close_ncp_session';
function send_ncp(session:longint; requestCode:longint; sendFragCount:longint; sendFrags:array of frag_t; replyFragCount:longint;
           replyFrags:array of frag_t; replyFragsUsed:Plongint; ncp_error:Plongint):longint;cdecl;external libc_nlm name 'send_ncp';

// complex.h

{ not presently supported  }


// ctype.h
//  var __ctype : array of byte;cvar;external;
{ standard prototypes...  }

function isalnum(_para1:longint):longint;cdecl;external libc_nlm name 'isalnum';
function isalpha(_para1:longint):longint;cdecl;external libc_nlm name 'isalpha';
function isblank(_para1:longint):longint;cdecl;external libc_nlm name 'isblank';
function iscntrl(_para1:longint):longint;cdecl;external libc_nlm name 'iscntrl';
function isdigit(_para1:longint):longint;cdecl;external libc_nlm name 'isdigit';
function isgraph(_para1:longint):longint;cdecl;external libc_nlm name 'isgraph';
function islower(_para1:longint):longint;cdecl;external libc_nlm name 'islower';
function isprint(_para1:longint):longint;cdecl;external libc_nlm name 'isprint';
function ispunct(_para1:longint):longint;cdecl;external libc_nlm name 'ispunct';
function isspace(_para1:longint):longint;cdecl;external libc_nlm name 'isspace';
function isupper(_para1:longint):longint;cdecl;external libc_nlm name 'isupper';
function isxdigit(_para1:longint):longint;cdecl;external libc_nlm name 'isxdigit';
function tolower(_para1:longint):longint;cdecl;external libc_nlm name 'tolower';
function toupper(_para1:longint):longint;cdecl;external libc_nlm name 'toupper';
function isascii(_para1:longint):longint;cdecl;external libc_nlm name 'isascii';
function toascii(_para1:longint):longint;cdecl;external libc_nlm name 'toascii';
function ismultibyte(_para1:Pchar):longint;cdecl;external libc_nlm name 'ismultibyte';
function Lisalnum(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lisalnum';
function Lisalpha(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lisalpha';
function Lisblank(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lisblank';
function Liscntrl(_para1:Pchar):longint;cdecl;external libc_nlm name 'Liscntrl';
function Lisdigit(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lisdigit';
function Lisgraph(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lisgraph';
function Lislower(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lislower';
function Lisprint(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lisprint';
function Lispunct(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lispunct';
function Lisspace(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lisspace';
function Lisupper(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lisupper';
function Lisxdigit(_para1:Pchar):longint;cdecl;external libc_nlm name 'Lisxdigit';


// dfs.h

{===========================================================
  Traditional direct file system
  These were interfaced by CLib in its NDK header, nwdfs.h
============================================================}

  const
     DFS_FAILURE = -(1);
     DFS_SUCCESS = 0;
     DFS_ERR_INSUFFICIENT_SPACE = 1;
     DFS_ERR_VOLUME_SEGMENT_DEACTIVATED = 4;
     DFS_ERR_TRUNCATION_FAILURE = 16;
     DFS_ERR_HOLE_IN_FILE = 17;
     DFS_ERR_PARAMETER = 18;
     DFS_ERR_OVERLAP = 19;
     DFS_ERR_SEGMENT = 20;
     DFS_ERR_BOUNDARY = 21;
     DFS_ERR_INSUFFICIENT_LIMBO_FILE_SPACE = 22;
     DFS_ERR_NOT_IN_DIRECT_FILE_MODE = 23;
     DFS_ERR_OPERATION_BEYOND_EOF = 24;
     DFS_ERR_OUT_OF_FILDES = 129;
     DFS_ERR_HARD_IO = 131;
     DFS_ERR_EBADF = 136;
     DFS_ERR_CANT_READ = 147;
     DFS_ERR_CANT_WRITE = 148;
     DFS_ERR_FILE_DETACHED = 149;
     DFS_ERR_ENOMEM = 150;
     DFS_ERR_INVALID_VOLUME = 152;
     DFS_ERR_IO_LOCK = 162;
  { setSizeFlags  }

     DFS_SETSIZE_NON_SPARSE_FILE = $00000001;    { to extend the file  }
     DFS_SETSIZE_NO_ZERO_FILL    = $00000002;    { do not zero fill  }
     DFS_SETSIZE_UNDO_ON_ERROR   = $00000004;    { truncate to original eof  }
     DFS_SETSIZE_PHYSICAL_ONLY   = $00000008;    { change physical EOF only  }
     DFS_SETSIZE_LOGICAL_ONLY    = $00000010;    { change only the logical EOF  }


{ type definitions...  }
type

   Pdfs_filemap_t = ^dfs_filemap_t;
   dfs_filemap_t = record
        FileBlock : longint;
        VolumeBlock : longint;
        NumberOfBlocks : longint;
     end;

   Pdfs_volinfo_t = ^dfs_volinfo_t;
   dfs_volinfo_t = record
        VolumeAllocationUnitSizeInBytes : size_t;
        VolumeSizeInAllocationUnits : size_t;
        VolumeSectorSize : size_t;
        AllocationUnitsUsed : longint;
        AllocationUnitsFreelyAvailable : longint;
        AllocationUnitsInDeletedFilesNotAvailable : longint;
        AllocationUnitsInAvailableDeletedFiles : longint;
        NumberOfPhysicalSegmentsInVolume : longint;
        PhysicalSegmentSizeInAllocationUnits : array[0..63] of size_t;
     end;

   Pdfs_cbparms_t = ^dfs_cbparms_t;
   dfs_cbparms_t = record
        sema : pointer;
        ccode : longint;
     end;
{  dlfcn.h
==============================================================================
=  Interfaces from the Single UNIX Specification of the Open Group for the
=  management of imported symbols and shared (dynamic) libraries. The imple-
=  mentation on NetWare is narrower as noted by the number of features that
=  are ignored or unsupported.
==============================================================================}
  const
     RTLD_LAZY = $01;
     RTLD_NOW = $02;               { ignored }
     RTLD_GLOBAL = $04;            { ignored }
     RTLD_LOCAL = $08;             { ignored }
     RTLD_MULTIPLE = $10;          { NetWare: force-load multiple times  }
     MAX_DLL_NAME_LEN = 8;         { special purpose value for 'handle' in dlsym()...  }
     MAX_SYMNAME_LEN = 255;        { maximim length of 'name' in dlsym()...  }


function dlopen(path:Pchar; mode:longint):pointer;cdecl;external libc_nlm name 'dlopen';
function dlsym(handle:pointer; name:Pchar):pointer;cdecl;external libc_nlm name 'dlsym';
function dlclose(handle:pointer):longint;cdecl;external libc_nlm name 'dlclose';
function dlerror:Pchar;cdecl;external libc_nlm name 'dlerror';


// endian.h
{ defines `__BYTE_ORDER' for the hosting environment...  }
{ some environments use a different "endianness" for floating point values  }

  const
     __LITTLE_ENDIAN = 1234;
     __BIG_ENDIAN = 4321;
     __PDP_ENDIAN = 3412;
  { defines `__BYTE_ORDER' for the hosting environment...  }
     __BYTE_ORDER = __LITTLE_ENDIAN;
     __FLOAT_WORD_ORDER = __BYTE_ORDER;
     LITTLE_ENDIAN = __LITTLE_ENDIAN;
     BIG_ENDIAN = __BIG_ENDIAN;
     PDP_ENDIAN = __PDP_ENDIAN;
     BYTE_ORDER = __BYTE_ORDER;



// err.h

{$ifndef DisableArrayOfConst}
procedure err(_para1:longint; _para2:Pchar; args:array of const);cdecl;external libc_nlm name 'err';
{$endif}
procedure err(_para1:longint; _para2:Pchar);cdecl;external libc_nlm name 'err';
procedure verr(_para1:longint; _para2:Pchar; _para3:va_list);cdecl;external libc_nlm name 'verr';

{$ifndef DisableArrayOfConst}
procedure errx(_para1:longint; _para2:Pchar; args:array of const);cdecl;external libc_nlm name 'errx';
{$endif}
procedure errx(_para1:longint; _para2:Pchar);cdecl;external libc_nlm name 'errx';
procedure verrx(_para1:longint; _para2:Pchar; _para3:va_list);cdecl;external libc_nlm name 'verrx';

{$ifndef DisableArrayOfConst}
procedure warn(_para1:Pchar; args:array of const);cdecl;external libc_nlm name 'warn';
{$endif}
procedure warn(_para1:Pchar);cdecl;external libc_nlm name 'warn';
procedure vwarn(_para1:Pchar; _para2:va_list);cdecl;external libc_nlm name 'vwarn';

{$ifndef DisableArrayOfConst}
procedure warnx(_para1:Pchar; args:array of const);cdecl;external libc_nlm name 'warnx';
{$endif}
procedure warnx(_para1:Pchar);cdecl;external libc_nlm name 'warnx';
procedure vwarnx(_para1:Pchar; _para2:va_list);cdecl;external libc_nlm name 'vwarnx';



// errno.h

  const
     ENOENT = 1;
     E2BIG = 2;           { arg list too big                               }
     ENOEXEC = 3;         { exec format error                              }
     EBADF = 4;           { bad file number                                }
     ENOMEM = 5;          { not enough memory                              }
     EACCES = 6;          { permission denied                              }
     EEXIST = 7;          { file exists                                    }
     EXDEV = 8;           { cross-device link                              }
     EINVAL = 9;          { invalid argument                               }
     ENFILE = 10;         { file table overflow                            }
     EMFILE = 11;         { too many open files                            }
     ENOSPC = 12;         { no space left on device                        }
     EDOM = 13;           { argument too large                             }
     ERANGE = 14;         { result too large                               }
     EDEADLK = 15;        { resource deadlock would occur                  }
  { -------------------------- Miscellaneous NLM Library constants ----------  }
     EINUSE = 16;         { resource(s) in use                             }
     ESERVER = 17;        { server error (memory out, I/O error, etc.)     }
     ENOSERVR = 18;       { no server (queue server, file server, etc.)    }
     EWRNGKND = 19;       { wrong kind--an operation is being...           }
                          {  ...attempted on the wrong kind of object      }
     ETRNREST = 20;       { transaction restarted                          }
     ERESOURCE = 21;      { resources unavailable (maybe permanently)      }
     EBADHNDL = 22;       { bad non-file handle (screen, semaphore, etc.)  }
     ENO_SCRNS = 23;      { screen I/O attempted when no screens           }
  { -------------------------- Additional POSIX / traditional UNIX constants   }
     EAGAIN = 24;         { resource temporarily unavailable               }
     ENXIO = 25;          { no such device or address                      }
     EBADMSG = 26;        { not a data message                             }
     EFAULT = 27;         { bad address                                    }
     EIO = 28;            { physical I/O error                             }
     ENODATA = 29;        { no data                                        }
     ENOSTRMS = 30;       { streams not available                          }
  { Berkeley sockets constants ------------------  }
     EPROTO = 31;         { fatal protocol error                           }
     EPIPE = 32;          { broken pipe                                    }
     ESPIPE = 33;         { illegal seek                                   }
  { Non-blocking and interrupt I/O constants ----  }
     ETIME = 34;          { ioctl acknowledge timeout                      }
     EWOULDBLOCK = 35;    { operation would block                          }
     EINPROGRESS = 36;    { operation now in progress                      }
     EALREADY = 37;       { operation already in progress                  }
  { IPC network argument constants --------------  }
     ENOTSOCK = 38;       { socket operation on non-socket                 }
     EDESTADDRREQ = 39;   { destination address required                   }
     EMSGSIZE = 40;       { message too long                               }
     EPROTOTYPE = 41;     { protocol wrong type for socket                 }
     ENOPROTOOPT = 42;    { protocol not available                         }
     EPROTONOSUPPORT = 43;{ protocol not supported                         }
     ESOCKTNOSUPPORT = 44;{ socket type not supported                      }
     EOPNOTSUPP = 45;     { operation not supported on socket              }
     EPFNOSUPPORT = 46;   { protocol family not supported                  }
     EAFNOSUPPORT = 47;   { address family unsupported by protocol family  }
     EADDRINUSE = 48;     { address already in use                         }
     EADDRNOTAVAIL = 49;  { can't assign requested address                 }
  { Operational constants -----------------------  }
     ENETDOWN = 50;       { network is down                                }
     ENETUNREACH = 51;    { network is unreachable                         }
     ENETRESET = 52;      { network dropped connection on reset            }
     ECONNABORTED = 53;   { software caused connection abort               }
     ECONNRESET = 54;     { connection reset by peer                       }
     ENOBUFS = 55;        { no buffer space available                      }
     EISCONN = 56;        { socket is already connected                    }
     ENOTCONN = 57;       { socket is not connected                        }
     ESHUTDOWN = 58;      { can't send after socket shutdown               }
     ETOOMANYREFS = 59;   { too many references: can't splice              }
     ETIMEDOUT = 60;      { connection timed out                           }
     ECONNREFUSED = 61;   { connection refused                             }
  { -------------------------- Additional POSIX-mandated constants ----------  }
     EBUSY = 62;          { resource busy                                  }
     EINTR = 63;          { interrupted function call                      }
     EISDIR = 64;         { is a directory                                 }
     ENAMETOOLONG = 65;   { filename too long                              }
     ENOSYS = 66;         { function not implemented                       }
     ENOTDIR = 67;        { not a directory                                }
     ENOTEMPTY = 68;      { directory not empty                            }
     EPERM = 69;          { operation not permitted                        }
     ECHILD = 70;         { no child process                               }
     EFBIG = 71;          { file too large                                 }
     EMLINK = 72;         { too many links                                 }
     ENODEV = 73;         { no such device                                 }
     ENOLCK = 74;         { no locks available                             }
     ENOTTY = 75;         { inappropriate I/O control operation            }
     EFTYPE = ENOTTY;     { inappropriate operation for file type       }
     EROFS = 76;          { read-only file system                          }
     ESRCH = 77;          { no such process                                }
     ECANCELED = 78;      { operation was cancelled                        }
     ENOTSUP = 79;        { this optional functionality not supported      }
     ECANCELLED = ECANCELED;
     EBADTYPE = 80;       { bad type for operation                         }
     EOVERFLOW = 81;      { operation would overflow                       }
     EHOSTDOWN = 82;      { host is down                                   }
     EHOSTUNREACH = 83;   { no route to host                               }
     EPROCLIM = 84;       { too many processes                             }
  { -------------------------- Additional POSIX / traditional UNIX constants   }
     ENOMSG = 90;         { message does not exist                         }
  { -------------------------- LibC-implementation-specific constants -------  }
     ENLMDATA = 100;      { anomaly in NLM data structure                  }
     EILSEQ = 101;        { illegal character sequence in multibyte        }
     EINCONSIS = 102;     { internal library inconsistency                 }
     EDOSTEXTEOL = 103;   { DOS-text file inconsistency--no newline...     }
                          { ...after carriage return                       }
     ENONEXTANT = 104;    { object doesn't exist                           }
     ENOCONTEXT = 105;    { no thread library context present              }
     ENAMESPACE = 106;    { invalid namespace or operation                 }
     EBADCONN = 107;      { invalid connection                             }
     ENAMEINVAL = 108;    { invalid NDS name                               }
     EPASSINVAL = 109;    { invalid password                               }
     ENCPINVAL = 110;     { invalid or erroneous NCP                       }
     EFILESYS = 111;      { generic file system error, see 'filesyserrno'  }
     ESUFFICIENT = 112;   { insufficient space for any operation result    }
     EPARTONLY = 113;     { partial result only  for lack of space         }
     EBADIDENT = 114;     { invalid user or other identity                 }
     ENDS = 115;          { generic eDirectory error, see 'h_errno'        }
     ENCP = 116;          { generic NCP error, see 'h_errno'               }
     ELOOKUP = 117;       { generic look-up error, see 'h_errno'           }
     ELASTERR = ELOOKUP;


function ___errno:Plongint;cdecl;external libc_nlm name '___errno';
function __errno_location:Plongint;cdecl;external libc_nlm name '___errno';
function ___lastClientErrno:Plongint;cdecl;external libc_nlm name '___lastClientErrno';
function ___lastFileSysErrno:Plongint;cdecl;external libc_nlm name '___lastFileSysErrno';


// esm.h

  const
     ERR_ESM_AVAL = 1;
     ERR_SIZE_ZERO = 2;           { ESMAlloc size requested is zero          }
     ERR_TABLE_FULL = 3;          { allocation table is full                 }
     ERR_NOT_CONTIGUOUS = 4;      { ESMAlloc request cannot be continguous   }
     ERR_INVAL_ADDRESS = 5;       { already free or out of range             }
     ERR_INVAL_SRC_ADDR = 6;      { bad source address (ESMCopy)             }
     ERR_INVAL_DEST_ADDR = 7;     { bad destination address(ESMCopy/ESMFill) }
     ERR_SRC_DEST_OVERLAP = 8;    { buffer overlap (ESMCopy)                 }
  { (will be obsolete when the overlapping buffer copy implemented...)         }
     ERR_MAP_4M_PAGE = 9;         { mapping particular 4M page failed        }
     ERR_BUFFER_SIZE = 10;        { buffer passed too small (ESMQuery)       }
     ERR_LOGICAL_SPACE = 11;      { adequate logical/window not available    }
     ERR_ACQUIRING_LOCK = 12;     { failed to acquire lock (please retry)    }

type
   Paddr64_t = ^addr64_t;
   addr64_t = Tuint64;

   PESMQueryInfo_t = ^ESMQueryInfo_t;
   ESMQueryInfo_t = record
        TotalExtendedMemory : size64_t;
        RemainingExtendedMemory : size64_t;
        TotalMemoryBelow4G : size_t;
     end;

function ESMAlloc(size:size64_t; options:dword; esmAddress:Paddr64_t):longint;cdecl;external libc_nlm name 'ESMAlloc';
function ESMAllocWindow(size:size_t; logicalAddress:Ppointer; callerID:pointer):longint;cdecl;external libc_nlm name 'ESMAllocWindow';
function ESMCopy(source:addr64_t; destination:addr64_t; length:size64_t):longint;cdecl;external libc_nlm name 'ESMCopy';
function ESMFill(pattern:dword; destination:addr64_t; length:size64_t):longint;cdecl;external libc_nlm name 'ESMFill';
function ESMFree(esmAddress:addr64_t):longint;cdecl;external libc_nlm name 'ESMFree';
function ESMFreeWindow(logicalAddress:pointer; callerID:pointer):longint;cdecl;external libc_nlm name 'ESMFreeWindow';
function ESMMapMemory(windowAddress:pointer; memoryAddress:addr64_t; size:size_t):longint;cdecl;external libc_nlm name 'ESMMapMemory';
function ESMQuery(bufferSize:size_t; buffer:PESMQueryInfo_t):longint;cdecl;external libc_nlm name 'ESMQuery';



// float.h
{ turn on 1-byte packing...  }

{
typedef union __fp_u

   unsigned char __uc[16];
   float         __f;
   double        __d;
   long double   __ld;
 __fp_u;
 }
{
typedef struct __fp_s

   int    __MANT_DIG;
   int    __DIG;
   int    __MIN_EXP;
   int    __MIN_10_EXP;
   int    __MAX_EXP;
   int    __MAX_10_EXP;
   __fp_u __EPSILON[2];
   __fp_u __MIN[2];
   __fp_u __MAX[2];
 __fp_s;
 }

(** unsupported pragma#pragma pack()*)
{ extern const __fp_s __fp_characteristics[3]; }


// fenv.h

{ these interfaces not presently supported!  }
{ floating-point exception bits for 'excepts' argument  }

{ turn on 1-byte packing...  }

  { these interfaces not presently supported!  }

 const
   _MAX_FPFLAGS  = 8;
  { floating-point exception bits for 'excepts' argument  }
   FE_DIVBYZERO  = $00000001;
   FE_INEXACT    = $00000002;
   FE_INVALID    = $00000004;
   FE_OVERFLOW   = $00000008;
   FE_UNDERFLOW  = $00000010;
   FE_ALL_EXCEPT = $00000020;
   FE_DOWNWARD   = $00000040;
   FE_TONEAREST  = $00000080;
   FE_TOWARDZERO = $00000100;
   FE_UPWARD     = $00000200;
   FE_DFL_ENV    = $00000400;


type
   Pfexcept_t = ^fexcept_t;
   fexcept_t = dword;

   Pfenv_t = ^fenv_t;
   fenv_t = record
        excepts : longint;
        flagp : fexcept_t;
     end;


(** unsupported pragma#pragma pack()*)
{ not presently supported...  }

procedure feclearexcept(excepts:longint);cdecl;external libc_nlm name 'feclearexcept';
procedure fegetexceptflag(flagp:Pfexcept_t; excepts:longint);cdecl;external libc_nlm name 'fegetexceptflag';
procedure feraiseexceptflag(flagp:Pfexcept_t; excepts:longint);cdecl;external libc_nlm name 'feraiseexceptflag';
procedure fesetexceptflag(flagp:Pfexcept_t; excepts:longint);cdecl;external libc_nlm name 'fesetexceptflag';
function fetestexcept(excepts:longint):longint;cdecl;external libc_nlm name 'fetestexcept';
function fegetround(round:longint):longint;cdecl;external libc_nlm name 'fegetround';
function fesetround:longint;cdecl;external libc_nlm name 'fesetround';
function fegetenv(envp:Pfenv_t):longint;cdecl;external libc_nlm name 'fegetenv';
function feholdexcept(envp:Pfenv_t):longint;cdecl;external libc_nlm name 'feholdexcept';
procedure fesetenv(envp:Pfenv_t);cdecl;external libc_nlm name 'fesetenv';
procedure feupdateenv(envp:Pfenv_t);cdecl;external libc_nlm name 'feupdateenv';



// fnmatch.h

  const
     FNM_NOMATCH = -(1);     { string fails to match pattern  }
  { values for field 'flags'...  }
     FNM_NOSYS       = $01;  { reserved (unused)                              }
     FNM_PATHNAME    = $02;  { slash in string must match in pattern          }
     FNM_PERIOD      = $04;  { leading period in string must match in pattern }
     FNM_NOESCAPE    = $08;  { disable backslash escaping                     }
     FNM_CASEFOLD    = $10;  { ignore case                                    }
     FNM_LEADING_DIR = $20;  { Ignore `/...' after a match                    }
     FNM_FILE_NAME   = FNM_PATHNAME;



function fnmatch(pattern, _string:Pchar; flags:longint):longint;cdecl;external libc_nlm name 'fnmatch';



// fshooks.h

  const
     FSHOOK_MAY_NOT_SLEEP_BIT    = $00000001;
     FSHOOK_SORT_LOW_TO_HIGH_BIT = $00000002;
     FSHOOK_CONSUMABLE_BIT       = $00000004;
     FSHOOK_NO_SA_BIT            = $00000008;
     FSHOOK_NO_AUDITOR_BIT       = $00000010;
     FSHOOK_NO_CHECK_BIT         = $00000020;
     FSHOOK_NESL_DATA_BIT        = $00000040;
     FSHOOK_NESL_SHIM_BIT        = $00000080;
     FSHOOK_DATA_FILTERED_BIT    = $80000000;

     FSHOOK_TYPE_DELETE_WARN               = 0;
     FSHOOK_TYPE_DELETE_REPORT             = 1;
     FSHOOK_TYPE_CREATE_WARN               = 2;
     FSHOOK_TYPE_CREATE_REPORT             = 3;
     FSHOOK_TYPE_OPEN_WARN                 = 4;
     FSHOOK_TYPE_OPEN_REPORT               = 5;
     FSHOOK_TYPE_CLOSE_WARN                = 6;
     FSHOOK_TYPE_CLOSE_REPORT              = 7;
     FSHOOK_TYPE_RENAME_WARN               = 8;
     FSHOOK_TYPE_RENAME_REPORT             = 9;
     FSHOOK_TYPE_MODIFYINFO_WARN           = 10;
     FSHOOK_TYPE_MODIFYINFO_REPORT         = 11;
     FSHOOK_TYPE_SETDATASIZE_WARN          = 12;
     FSHOOK_TYPE_SETDATASIZE_REPORT        = 13;
     FSHOOK_TYPE_ADDTRUSTEE_WARN           = 14;
     FSHOOK_TYPE_ADDTRUSTEE_REPORT         = 15;
     FSHOOK_TYPE_REMOVETRUSTEE_WARN        = 16;
     FSHOOK_TYPE_REMOVETRUSTEE_REPORT      = 17;
     FSHOOK_TYPE_SETINHERITEDRIGHTS_WARN   = 18;
     FSHOOK_TYPE_SETINHERITEDRIGHTS_REPORT = 19;
     FSHOOK_TYPE_CHANGEVOLSTATE_WARN       = 20;
     FSHOOK_TYPE_CHANGEVOLSTATE_REPORT     = 21;
     FSHOOK_TYPE_CHANGEPOOLSTATE_WARN      = 22;
     FSHOOK_TYPE_CHANGEPOOLSTATE_REPORT    = 23;


{==========================================================
  NSS file system hooks
  These are based on the Novell Event Bus, supported by NSS
==========================================================}
type
   Pfse_info = ^fse_info;
   fse_info = record
        version   : longint;                  // event block version
        reserved1 : longint;                  // do not modify
        reserved2 : pointer;                  // do not modify
        rtag      : rtag_t;                   // registerer's resource tag
        link      : Pfse_info;                // used by registerer to link blocks
        regID     : pointer;                  // registerer of the event
        regSpace  : pointer;                  // scratch space for registerer's use
        consID    : pointer;                  // consumer of event if relevant
        length    : size_t;                   // in bytes of event data
        data      : pointer;                  // pointer to data
        reserved3 : array[0..3] of pointer;   // do not modify
        _type     : longint;                  // one of NSS_FSTYPE_-...
        userParm  : pointer;                  // specified at time of registration
        parm0     : pointer;                  // value depends on event type
        parm1     : pointer;                  // ibid
        flags     : dword;                    // as noted above
     end;
   fsevent_info_t = fse_info;
   Pfsevent_info_t = ^fsevent_info_t;
   Pfsevent_info = Pfsevent_info_t;
   Tfsevent_info = fsevent_info_t;

   Pzkey_t = ^zkey_t;
   zkey_t = Tuint64;

   Pzid_t = ^zid_t;
   zid_t = Tuint64;

   Pvolid_t = ^volid_t;
   volid_t = record
        timeLow : dword;
        timeMid : word;
        timeHighAndVersion : word;
        clockSeqHighAndReserved : byte;
        clockSeqLow : byte;
        node : array[0..5] of byte;
     end;
   userid_t = volid_t;
   Puserid_t = ^userid_t;
   TVolId = volid_t;
   PVolId = pvolid_t;
   TUserId = userid_t;
   PUserId = puserid_t;

   Ptimeinfo_t = ^timeinfo_t;
   timeinfo_t = record
        accessedTime,                    // last time file was accessed
        createdTime,                     // time file was created
        modifiedTime,                    // last time data was changed
        metaDataModifiedTime : time_t;   // last time metadata was changed
     end;
   Ttimeinfo = timeinfo_t;
   Ptimeinfo = Ptimeinfo_t;

{ commonlity in call-back structures...  }
{ NSS (NetWare 6) filesystem hooks events and call-back data structures...  }

   Pdel_warn_t = ^del_warn_t;
   del_warn_t = record
        enterExitID,
        slotID,
        taskID : dword;
        zid    : zid_t;
        volID  : volid_t;
     end;
   Tdel_warn = del_warn_t;
   Pdel_warn = Pdel_warn_t;


   Pdel_report_t = ^del_report_t;
   del_report_t = record
        enterExitID    : dword;
        enterRetStatus,
        opRetCode      : longint;
     end;
   Tdel_report = del_report_t;
   Pdel_report = Pdel_report_t;

   Pcreate_warn_t = ^create_warn_t;
   create_warn_t = record
        enterExitID,
        slotID,
        taskID          : dword;
        zid             : zid_t;
        volID           : volid_t;
        name            : Punicode_t;
        fileType,
        fileAttributes,
        createFlags     : dword;
        createParms     : pointer;
        requestedRights,
        createAndOpen   : dword;
     end;
   Tcreate_warn = create_warn_t;
   Pcreate_warn = Pcreate_warn_t;

   Pcreate_report_t = ^create_report_t;
   create_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
        retOpenCreateAction : dword;
        retKey : zkey_t;
        retZid : zid_t;
        retVolID : volid_t;
        times : timeinfo_t;
     end;
   Tcreate_report = create_report_t;
   Pcreate_report = Pcreate_report_t;

   Popen_warn_t = ^open_warn_t;
   open_warn_t = record
        enterExitID : dword;
        slotID : dword;
        taskID : dword;
        zid : zid_t;
        volID : volid_t;
        requestedRights : dword;
        openParms : pointer;
     end;
   Topen_warn = open_warn_t;
   Popen_warn = Popen_warn_t;

   Popen_report_t = ^open_report_t;
   open_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
        retKey : zkey_t;
        retZid : zid_t;
        retVolID : volid_t;
        times : timeinfo_t;
     end;
   Topen_report = open_report_t;
   Popen_report = Popen_report_t;

   Pclose_warn_t = ^close_warn_t;
   close_warn_t = record
        enterExitID : dword;
        slotID : dword;
        key : zkey_t;
        fhState : dword;
        times : timeinfo_t;
     end;
   Tclose_warn = close_warn_t;
   Pclose_warn = Pclose_warn_t;

   Pclose_report_t = ^close_report_t;
   close_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
        fileDeleted : dword;
     end;
   Tclose_report = close_report_t;
   Pclose_report = Pclose_report_t;

   Pren_warn_t = ^ren_warn_t;
   ren_warn_t = record
        enterExitID : dword;
        slotID : dword;
        taskID : dword;
        zid : zid_t;
        volID : volid_t;
        destZid : zid_t;
        destName : Punicode_t;
        renameFlags : dword;
     end;
   Tren_warn = ren_warn_t;
   Pren_warn = Pren_warn_t;

   Pren_report_t = ^ren_report_t;
   ren_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
     end;
   Tren_report = ren_report_t;
   Pren_report = Pren_report_t;


   Pzinfo_t = ^zinfo_t;
   zinfo_t = record
        version : dword;
        totalBytes : size_t;
        nextByte : size_t;
        padding : dword;
        retMask : Tuint64;
        std : record
             zid : zid_t;
             dataStreamZid : zid_t;
             parentZid : zid_t;
             logicalEOF : off64_t;
             volumeID : volid_t;
             fileType : dword;
             fileAttributes : dword;
             fileAttributesModMask : dword;
             padding : dword;
          end;
        storageUsed : record
             physicalEOF : size64_t;
             dataBytes : size64_t;
             metaDataBytes : size64_t;
          end;
        primaryNameSpaceID : longint;
        nameStart : off_t;
        names : record
             numEntries : size_t;
             fileNameArray : off_t;
          end;
        time : record
             created : Tuint64;
             archived : Tuint64;
             modified : Tuint64;
             accessed : Tuint64;
             metaDataModified : Tuint64;
          end;
        id : record
             owner : userid_t;
             archiver : userid_t;
             modifier : userid_t;
             metaDataModifier : userid_t;
          end;
        blockSize : record
             size : size_t;
             sizeShift : off_t;
          end;
        count : record
             open : longint;
             hardLink : longint;
          end;
        dataStream : record
             count : longint;
             totalNameSize : size_t;
             totalDataSize : size64_t;
          end;
        extAttr : record
             count : size_t;
             totalNameSize : size_t;
             totalDataSize : size64_t;
          end;
        deleted : record
             time : Tuint64;
             id : userid_t;
          end;
        macNS : record
             finderInfo : record
                 case longint of
                    0 : ( generic : array[0..31] of byte );
                    1 : ( macintosh : record
                         FInfo : record
                              fdType : longint;
                              fdCreator : longint;
                              fdFlags : Tint16;
                              fdLocation : record
                                   v : Tint16;
                                   h : Tint16;
                                end;
                              fdFldr : Tint16;
                           end;
                         extended : record
                             case longint of
                                0 : ( FXInfo : record
                                     fdIconID : Tint16;
                                     fdUnused : Tint16;
                                     fdScript : int8_t;
                                     fdFlags : int8_t;
                                     fdComment : Tint16;
                                     fdPutAway : longint;
                                  end );
                                1 : ( DXInfo : record
                                     frScroll : record
                                          v : Tint16;
                                          h : Tint16;
                                       end;
                                     frOpenChain : longint;
                                     fdScript : int8_t;
                                     fdFlags : int8_t;
                                     fdComment : Tint16;
                                     fdPutAway : longint;
                                  end );
                             end;
                      end );
                 end;
             proDOSInfo : array[0..5] of byte;
             filler : array[0..1] of byte;
             dirRightsMask : dword;
          end;
        unixNS : record
             fMode : dword;
             rDev : dword;
             myFlags : dword;
             nfsUID : dword;
             nfsGID : dword;
             nwUID : dword;
             nwGID : dword;
             nwEveryone : dword;
             nwUIDRights : dword;
             nwGIDRights : dword;
             nwEveryoneRights : dword;
             acsFlags : byte;
             firstCreated : byte;
             variableSize : size_t;
             offsetToData : off_t;
          end;
        volumeID : volid_t;
        ndsObjectID : userid_t;
        volumeState : dword;
        nameSpaceMask : dword;
        features : record
             enabled : Tuint64;
             enableModMask : Tuint64;
             supported : Tuint64;
          end;
        maximumFileSize : size64_t;
        totalSpaceQuota : size64_t;
        numUsedBytes : size64_t;
        numObjects : size64_t;
        numFiles : size64_t;
        authModelID : dword;
        dataShreddingCount : size_t;
        salvage : record
             purgeableBytes : size64_t;
             nonPurgeableBytes : size64_t;
             numDeletedFiles : size64_t;
             oldestDeletedTime : Tuint64;
             minKeepSeconds : size_t;
             maxKeepSeconds : size_t;
             lowWaterMark : size_t;
             highWaterMark : size_t;
          end;
        comp : record
             numCompressedFiles : size64_t;
             numCompDelFiles : size64_t;
             numUncompressibleFiles : size64_t;
             numPreCompressedBytes : size64_t;
             numCompressedBytes : size64_t;
          end;
        pool : record
             poolID : volid_t;
             ndsObjectID : userid_t;
             poolState : dword;
             nameSpaceMask : dword;
             features : record
                  enabled : Tuint64;
                  enableModMask : Tuint64;
                  supported : Tuint64;
               end;
             totalSpace : size64_t;
             numUsedBytes : size64_t;
             purgeableBytes : size64_t;
             nonPurgeableBytes : size64_t;
          end;
        extAttrUserFlags : dword;
        variableData : array[0..0] of byte;
     end;
   Tzinfo = zinfo_t;
   Pzinfo = Pzinfo_t;

   Pmod_warn_t = ^mod_warn_t;
   mod_warn_t = record
        enterExitID : dword;
        slotID : dword;
        taskID : dword;
        zid : zid_t;
        volID : volid_t;
        modifyInfoMask : dword;
        modifyTypeInfoMask : dword;
        modifyInfo : Pzinfo_t;
        modifyTypeInfo : pointer;
     end;
   Tmod_warn = mod_warn_t;
   Pmod_warn = Pmod_warn_t;

   Pmod_report_t = ^mod_report_t;
   mod_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
     end;
   Tmod_report = mod_report_t;
   Pmod_report = Pmod_report_t;

   Psetsize_warn_t = ^setsize_warn_t;
   setsize_warn_t = record
        enterExitID : dword;
        slotID : dword;
        key : zkey_t;
        curEOF : Tuint64;
        newEOF : Tuint64;
        setSizeFlags : dword;
     end;
   Tsetsize_warn = setsize_warn_t;
   Psetsize_warn = Psetsize_warn_t;

   Psetsize_report_t = ^setsize_report_t;
   setsize_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
        newEOF : Tuint64;
     end;
   Tsetsize_report = setsize_report_t;
   Psetsize_report = Psetsize_report_t;

   Paddtrustee_warn_t = ^addtrustee_warn_t;
   addtrustee_warn_t = record
        enterExitID : dword;
        slotID : dword;
        taskID : dword;
        zid : zid_t;
        volID : volid_t;
        trusteeID : userid_t;
        rights : dword;
        attributes : dword;
     end;
   Taddtrustee_warn = addtrustee_warn_t;
   Paddtrustee_warn = Paddtrustee_warn_t;

   Paddtrustee_report_t = ^addtrustee_report_t;
   addtrustee_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
     end;

   Taddtrustee_report = addtrustee_report_t;
   Paddtrustee_report = Paddtrustee_report_t;

   Premtrustee_warn_t = ^remtrustee_warn_t;
   remtrustee_warn_t = record
        enterExitID : dword;
        slotID : dword;
        taskID : dword;
        zid : zid_t;
        volID : volid_t;
        trusteeID : userid_t;
        purgedFileFlag : dword;
     end;
   Tremtrustee_warn = remtrustee_warn_t;
   Premtrustee_warn = Premtrustee_warn_t;

   Premtrustee_report_t = ^remtrustee_report_t;
   remtrustee_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
     end;
   Tremtrustee_report = remtrustee_report_t;
   Premtrustee_report = Premtrustee_report_t;

   Psetrights_warn_t = ^setrights_warn_t;
   setrights_warn_t = record
        enterExitID : dword;
        slotID : dword;
        taskID : dword;
        zid : zid_t;
        volID : volid_t;
        inheritedRights : dword;
        authorizeFlag : longint;
     end;
   Tsetrights_warn = setrights_warn_t;
   Psetrights_warn = Psetrights_warn_t;

   Psetrights_report_t = ^setrights_report_t;
   setrights_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
     end;
   Tsetrights_report = setrights_report_t;
   Psetrights_report = Psetrights_report_t;

   Pxvolstate_warn_t = ^xvolstate_warn_t;
   xvolstate_warn_t = record
        enterExitID : dword;
        oldState : word;
        newState : word;
        mode : dword;
        volID : volid_t;
        poolID : volid_t;
     end;
   Txvolstate_warn = xvolstate_warn_t;
   Pxvolstate_warn = Pxvolstate_warn_t;

   Pxvolstate_report_t = ^xvolstate_report_t;
   xvolstate_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
        oldState : word;
        newState : word;
        mode : dword;
        volID : volid_t;
        poolID : volid_t;
     end;
   Txvolstate_report = xvolstate_report_t;
   Pxvolstate_report = Pxvolstate_report_t;

   Pxpoolstate_warn_t = ^xpoolstate_warn_t;
   xpoolstate_warn_t = record
        enterExitID : dword;
        oldState : word;
        newState : word;
        mode : dword;
        poolID : volid_t;
     end;
   Txpoolstate_warn = xpoolstate_warn_t;
   Pxpoolstate_warn = Pxpoolstate_warn_t;


   Pxpoolstate_report_t = ^xpoolstate_report_t;
   xpoolstate_report_t = record
        enterExitID : dword;
        enterRetStatus : longint;
        opRetCode : longint;
        oldState : word;
        newState : word;
        mode : dword;
        poolID : volid_t;
     end;
   Txpoolstate_report = xpoolstate_report_t;
   Pxpoolstate_report = Pxpoolstate_report_t;

{============================================================
 Traditional file system hooks
 These were interfaced by CLib in its NDK header, nwfshook.h.
============================================================}

   PEraseFileCallBackStruct = ^TEraseFileCallBackStruct;
   TEraseFileCallBackStruct = record
     case longint of
      0: (slot : longint);
      1: (connection : longint;
          task : longint;
          volume : longint;
          dirBase : longint;
          pathString : Pchar;
          pathComponentCount : longint;
          nameSpace : longint;
          attributeMatchBits : dword);
     end;
{ (see fsio.h)  }

   POpenFileCallBackStruct = ^TOpenFileCallBackStruct;
   TOpenFileCallBackStruct = record
        case longint of
          0: (slot : longint);
          1: (connection : longint;
              task : longint;
              volume : longint;
              dirBase : longint;
              pathString : Pchar;
              pathComponentCount : longint;
              nameSpace : longint;
              attributeMatchBits : dword;
              requestedAccessRights : dword;
              dataStreamNumber : longint;
              fileHandle : Plongint);
     end;

   PCreateFileCallBackStruct = ^TCreateFileCallBackStruct;
   TCreateFileCallBackStruct = record
      case integer of
        0: (connection : longint);
        1: (slot : longint;
            task : longint;
            volume : longint;
            dirBase : longint;
            pathString : Pchar;
            pathComponentCount : longint;
            nameSpace : longint;
            createAttributeBits : dword;
            createFlagBits : dword;
            dataStreamNumber : longint;
            fileHandle : Plongint);
     end;

   PCreateAndOpenCallBackStruct = ^TCreateAndOpenCallBackStruct;
   TCreateAndOpenCallBackStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           volume : longint;
           dirBase : longint;
           pathString : Pchar;
           pathComponentCount : longint;
           nameSpace : longint;
           createAttributeBits : dword;
           requestedAccessRights : dword;
           createFlagBits : dword;
           dataStreamNumber : longint;
           fileHandle : Plongint);
     end;

   PRenameMoveEntryCallBackStruct = ^TRenameMoveEntryCallBackStruct;
   TRenameMoveEntryCallBackStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           volume : longint;
           dirBase : longint;
           pathString : Pchar;
           pathComponentCount : longint;
           nameSpace : longint;
           attributeMatchBits : dword;
           subDirsOnlyFlag : longint;
           newDirBase : longint;
           newPathString : Pchar;
           originalNewCount : longint;
           compatibilityFlag : dword;
           allowRenamesToMyselfFlag : longint);
     end;

   PCloseFileCallBackStruct = ^TCloseFileCallBackStruct;
   TCloseFileCallBackStruct = record
     case integer of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           fileHandle : longint);
     end;

   PCreateDirCallBackStruct = ^TCreateDirCallBackStruct;
   TCreateDirCallBackStruct = record
     case integer of
       0: (connection : longint);
       1: (slot : longint;
           volume : longint;
           dirBase : longint;
           pathString : Pchar;
           pathComponentCount : longint;
           nameSpace : longint;
           directoryAccessMask : dword);
     end;

   PDeleteDirCallBackStruct = ^TDeleteDirCallBackStruct;
   TDeleteDirCallBackStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           volume : longint;
           dirBase : longint;
           pathString : Pchar;
           pathComponentCount : longint;
           nameSpace : longint);
     end;

   Tmodifyvector = record
             MModifyName : Pchar;
             MFileAttributes : dword;
             MFileAttributesMask : dword;
             MCreateDate : word;
             MCreateTime : word;
             MOwnerID : dword;
             MLastArchivedDate : word;
             MLastArchivedTime : word;
             MLastArchivedID : dword;
             MLastUpdatedDate : word;
             MLastUpdatedTime : word;
             MLastUpdatedID : dword;
             MLastAccessedDate : word;
             MInheritanceGrantMask : word;
             MInheritanceRevokeMask : word;
             MMaximumSpace : size_t;
             MLastUpdatedInSeconds : time_t;
          end;
   Pmodifyvector = ^Tmodifyvector;

   PModifyDirEntryCallBackStruct = ^TModifyDirEntryCallBackStruct;
   TModifyDirEntryCallBackStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           volume : longint;
           dirBase : longint;
           pathString : Pchar;
           pathComponentCount : longint;
           nameSpace : longint;
           attributeMatchBits : dword;
           targetNameSpace : longint;
           modifyVector : Pmodifyvector;
           modifyBits : dword;
           allowWildCardsFlag : longint);
     end;

   PSalvageDeletedCallBackStruct = ^TSalvageDeletedCallBackStruct;
   TSalvageDeletedCallBackStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           volume : longint;
           dirBase : longint;
           toBeSalvagedDirBase : longint;
           nameSpace : longint;
           newName : Pchar);
     end;

   PPurgeDeletedCallBackStruct = ^TPurgeDeletedCallBackStruct;
   TPurgeDeletedCallBackStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           volume : longint;
           dirBase : longint;
           toBePurgedDirBase : longint;
           nameSpace : longint);
     end;

   PRenameNSEntryCallBackStruct = ^TRenameNSEntryCallBackStruct;
   TRenameNSEntryCallBackStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           volume : longint;
           dirBase : longint;
           pathString : Pchar;
           pathComponentCount : longint;
           nameSpace : longint;
           matchBits : dword;
           newName : Pchar);
     end;

   PGenericSalvageDeletedCBStruct = ^TGenericSalvageDeletedCBStruct;
   TGenericSalvageDeletedCBStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           nameSpace : longint;
           sequence : longint;
           volume : longint;
           dirBase : longint;
           newName : Pchar);
     end;

   PGenericPurgeDeletedCBStruct = ^TGenericPurgeDeletedCBStruct;
   TGenericPurgeDeletedCBStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           nameSpace : longint;
           sequence : longint;
           volume : longint;
           dirBase : longint);
     end;

   PGenericOpenCreateCBStruct = ^TGenericOpenCreateCBStruct;
   TGenericOpenCreateCBStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           volume : longint;
           pathComponentCount : longint;
           dirBase : longint;
           pathString : Pchar;
           nameSpace : longint;
           dataStreamNumber : longint;
           openCreateFlags : dword;
           searchAttributes : dword;
           createAttributes : dword;
           requestedAccessRights : dword;
           returnInfoMask : dword;
           fileHandle : Plongint;
           openCreateAction : Pchar);
     end;

   PGenericRenameCBStruct = ^TGenericRenameCBStruct;
   TGenericRenameCBStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           nameSpace : longint;
           renameFlag : longint;
           searchAttributes : dword;
           srcVolume : longint;
           srcPathComponentCount : longint;
           srcDirBase : longint;
           srcPathString : Pchar;
           dstVolume : longint;
           dstPathComponentCount : longint;
           dstDirBase : longint;
           dstPathString : Pchar);
     end;

   PGenericEraseFileCBStruct = ^TGenericEraseFileCBStruct;
   TGenericEraseFileCBStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           volume : longint;
           pathComponentCount : longint;
           dirBase : longint;
           pathString : Pchar;
           nameSpace : longint;
           searchAttributes : dword);
     end;

   PGenericModifyDOSInfoCBStruct = ^TGenericModifyDOSInfoCBStruct;
   TGenericModifyDOSInfoCBStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           volume : longint;
           pathComponentCount : longint;
           dirBase : longint;
           pathString : Pchar;
           nameSpace : longint;
           searchAttributes : dword;
           modifyMask : dword;
           modifyInfo : pointer);
     end;

   PGenericModifyNSInfoCBStruct = ^TGenericModifyNSInfoCBStruct;
   TGenericModifyNSInfoCBStruct = record
     case longint of
       0: (connection : longint);
       1: (slot : longint;
           task : longint;
           dataLength : size_t;
           srcNameSpace : longint;
           dstNameSpace : longint;
           volume : longint;
           dirBase : longint;
           modifyMask : dword;
           modifyInfo : pointer);
     end;
{============================================================================
** NSS file system hook prototypes...
 }

//type TCdeclPfsEventFunc = function (info:Pfsevent_info_t):longint; cdecl;
type TCdeclPfsEventFunc = function (var info:Tfsevent_info):longint; cdecl;

function fs_register(_type:longint; cbFunc:TCdeclPfsEventFunc; userParm:pointer):longint;cdecl;external libc_nlm name 'fs_register';
function fs_unregister(_type:longint; cbFunc:TCdeclPfsEventFunc):longint;cdecl;external libc_nlm name 'fs_unregister';

function fs_mapkeytopath(key:zkey_t; path:Punicode_t; maxpathlen:Psize_t; want_volume:longint):longint;cdecl;external libc_nlm name 'fs_mapkeytopath';
function fs_mapkeytopath(key:zkey_t; path:Punicode_t; maxpathlen:Psize_t; want_volume:longbool):longint;cdecl;external libc_nlm name 'fs_mapkeytopath';
function fs_mapkeytopath(key:zkey_t; path:Punicode_t; var maxpathlen:longint; want_volume:longint):longint;cdecl;external libc_nlm name 'fs_mapkeytopath';
function fs_mapkeytopath(key:zkey_t; path:Punicode_t; var maxpathlen:longint; want_volume:longbool):longint;cdecl;external libc_nlm name 'fs_mapkeytopath';

function fs_mapzidtopath(zid:zid_t; volId:Pvolid_t; path:Punicode_t; maxpathlen:Psize_t; want_volume:longint):longint;cdecl;external libc_nlm name 'fs_mapzidtopath';
function fs_mapzidtopath(zid:zid_t; volId:Pvolid_t; path:Punicode_t; maxpathlen:Psize_t; want_volume:longbool):longint;cdecl;external libc_nlm name 'fs_mapzidtopath';
function fs_mapzidtopath(zid:zid_t; var volId:volid_t; path:Punicode_t; var maxpathlen:longint; want_volume:longint):longint;cdecl;external libc_nlm name 'fs_mapzidtopath';
function fs_mapzidtopath(zid:zid_t; var volId:volid_t; path:Punicode_t; var maxpathlen:longint; want_volume:longbool):longint;cdecl;external libc_nlm name 'fs_mapzidtopath';

function fs_read(key:zkey_t; buf:pointer; off:off64_t; len:size_t; bytes:Pssize_t):longint;cdecl;external libc_nlm name 'fs_read';
function fs_read(key:zkey_t; var buf; off:off64_t; len:size_t; var bytes:ssize_t):longint;cdecl;external libc_nlm name 'fs_read';

function fs_write(key:zkey_t; buf:pointer; off:off64_t; len:size_t; bytes:Pssize_t):longint;cdecl;external libc_nlm name 'fs_write';
function fs_write(key:zkey_t; var buf; off:off64_t; len:size_t; var bytes:ssize_t):longint;cdecl;external libc_nlm name 'fs_write';


{============================================================================
 Generic information (NEB and traditional) based on connection slot. This
 has little to do with file system hooks, but in LibC, there is no way to
 get a hold of a connection slot except through file system hook interfaces.}
function fs_getslotinfo(slot:longint;
                        name:Pchar;
                        objectType:PWord;
                        objectId:Pdword;
                        loginTime:Pointer):longint;cdecl;external libc_nlm name 'fs_getslotinfo';
function fs_getslotinfo(slot:longint;
                        name:Pchar;
                        var objectType:word;
                        var objectId:dword;
                        var loginTime):longint;cdecl;external libc_nlm name 'fs_getslotinfo';

// Clib compatible function name:
function GetConnectionInformation (connectionNumber:longint;
                                   objectName      :Pchar;
                                   objectType      :PWORD;
                                   objectID        :Plongint;
                                   loginTime       :pointer):longint;cdecl;external libc_nlm name 'fs_getslotinfo';
function GetConnectionInformation (connectionNumber:longint;
                                   objectName      :Pchar;
                               var objectType      :word;
                               var objectID        :longint;
                               var loginTime):longint;cdecl;external libc_nlm name 'fs_getslotinfo';



{==========================================
 Traditional file system hook prototypes... }

type TCDeclFunc1PtrArgLongint = function (info:pointer):longint; cdecl;

function fst_register(_type:longint; cbFunc:pointer):longint;cdecl;external libc_nlm name 'fst_register';
function fst_unregister(_type:longint; cbFunc:pointer):longint;cdecl;external libc_nlm name 'fst_unregister';
function fst_getvoldir(slot:longint; fileHandle:longint; namespace:longint; volNum:Plongint; dirBase:Plongint):longint;cdecl;external libc_nlm name 'fst_getvoldir';
function fst_getvoldir(slot, fileHandle, namespace:longint; var volNum, dirBase:longint):longint;cdecl;external libc_nlm name 'fst_getvoldir';
function fst_getorignamespace(volNum, dirBase:longint; namespace:Plongint):longint;cdecl;external libc_nlm name 'fst_getorignamespace';
function fst_getorignamespace(volNum, dirBase:longint; var namespace:longint):longint;cdecl;external libc_nlm name 'fst_getorignamespace';
function fst_mapvoldirtopath(volNum,dirBase,namespace:longint; path:Pchar; maxPathLen:longint):longint;cdecl;external libc_nlm name 'fst_mapvoldirtopath';
function fst_mapvoltoname(volNum:longint; name:Pchar):longint;cdecl;external libc_nlm name 'fst_mapvoltoname';
function fst_read(slot,fileHandle:longint; buffer:pointer; offset:off64_t; length:size_t;
           bytes:Plongint):longint;cdecl;external libc_nlm name 'fst_read';
function fst_read(slot,fileHandle:longint; buffer:pointer; offset:off64_t; length:size_t;
           var bytes:longint):longint;cdecl;external libc_nlm name 'fst_read';
function fst_write(slot, fileHandle:longint; buffer:pointer; offset:off64_t; length:size_t;
           bytes:Plongint):longint;cdecl;external libc_nlm name 'fst_write';
function fst_write(slot, fileHandle:longint; buffer:pointer; offset:off64_t; length:size_t;
           var bytes:longint):longint;cdecl;external libc_nlm name 'fst_write';
function fst_size(slot, fileHandle:longint; length:Poff64_t):longint;cdecl;external libc_nlm name 'fst_size';
function fst_flush(slot, fileHandle:longint):longint;cdecl;external libc_nlm name 'fst_flush';


type
   Pfst_info_t = ^fst_info_t;
   fst_info_t = record
        volNum,
        DosBase,
        dirBase,
        namespace,
        datastream : longint;
        flags : dword;
     end;
    Tfst_info = fst_info_t;
    Pfst_info = Pfst_info_t;

function fst_getinfo(slot,fileHandle:longint; info:Pfst_info_t):longint;cdecl;external libc_nlm name 'fst_getinfo';
function fst_getinfo(slot,fileHandle:longint; var info:fst_info_t):longint;cdecl;external libc_nlm name 'fst_getinfo';


// getopt.h

{ values for 'has_arg'...  }
const
  no_argument = 0;
  required_argument = 1;
  optional_argument = 2;

{ definition for getopt_long() and getopt_long_only()...  }

type
   Poption = ^option;
   option = record
        name    : Pchar;
        has_arg : longint;
        flag    : Plongint;
        val     : longint;
     end;

function getopt_long(argc:longint; argv:array of Pchar; optstring:Pchar; longopts:Poption; longindex:Plongint):longint;cdecl;external libc_nlm name 'getopt_long';
function getopt_long_only(argc:longint; argv:array of Pchar; optstring:Pchar; longopts:Poption; longindex:Plongint):longint;cdecl;external libc_nlm name 'getopt_long_only';

// err.h

  const
     GLOB_APPEND = $0001;
     GLOB_DOOFFS = $0002;        { use gl_offs                                }
     GLOB_ERR = $0004;           { return on error                            }
     GLOB_MARK = $0008;          { append / to matching directories           }
     GLOB_NOCHECK = $0010;       { return pattern itself if nothing matches   }
     GLOB_NOSORT = $0020;        { don't sort                                 }
     GLOB_ALTDIRFUNC = $0040;    { use alternately specified directory funcs  }
     GLOB_BRACE = $0080;         { expand braces ala csh                      }
     GLOB_MAGCHAR = $0100;       { pattern had globbing characters            }
     GLOB_NOMAGIC = $0200;       { GLOB_NOCHECK without magic chars (csh)     }
     GLOB_QUOTE = $0400;         { quote special chars with \                 }
     GLOB_TILDE = $0800;         { expand tilde names from the passwd file    }
     GLOB_NOESCAPE = $1000;      { disable backslash escaping                 }
     GLOB_LIMIT = $2000;         { limit pattern match output to ARG_MAX      }
  { error values returned by glob(3)  }
     GLOB_NOSPACE = -(1);        { malloc call failed                         }
     GLOB_ABORTED = -(2);        { unignored error                            }
     GLOB_NOMATCH = -(3);        { no match and GLOB_NOCHECK not set          }
  { function not supported }
     GLOB_NOSYS = -(4);
     GLOB_ABEND = GLOB_ABORTED;

type
   Pglob_t = ^glob_t;
   glob_t = record
        gl_pathc : longint;
        gl_matchc : longint;
        gl_offs : longint;
        gl_flags : longint;
        gl_pathv : ^Pchar;
        gl_errfunc : function (_para1:Pchar; _para2:longint):longint;cdecl;
        gl_closedir : procedure (_para1:pointer);
        gl_readdir : function (_para1:pointer):Pdirent;
        gl_opendir : function (_para1:Pchar):pointer;
        gl_lstat : function (_para1:Pchar; _para2:Pstat):longint;
        gl_stat : function (_para1:Pchar; _para2:Pstat):longint;
     end;

// grp.h

type
   Pgroup = ^group;
   group = record
        gr_name : Pchar;
        gr_passwd : Pchar;
        gr_gid : gid_t;
        gr_spare : gid_t;
        gr_mem : ^Pchar;
     end;

function getgrgid(gid:gid_t):Pgroup;cdecl;external libc_nlm name 'getgrgid';
function getgrnam(name:Pchar):Pgroup;cdecl;external libc_nlm name 'getgrnam';

// guid.h
// iconv.h

type
   Piconv_t = ^iconv_t;
   iconv_t = longint;

function iconv_open(tocode:Pchar; fromcode:Pchar):iconv_t;cdecl;external libc_nlm name 'iconv_open';
function iconv(cd:iconv_t; inbuf:PPchar; inbytesleft:Psize_t; outbuf:PPchar; outbytesleft:Psize_t):size_t;cdecl;external libc_nlm name 'iconv';
function iconv_close(cd:iconv_t):longint;cdecl;external libc_nlm name 'iconv_close';


// inttypes.h

{ printf-style macros for signed and unsigned integers...  }
{ scanf-style macros for signed and unsigned integers...  }


// iso646.h

// nl_types.h

  const
     NL_SETD = 1;
  { 'oflag' value for catopen()...  }
  { base on value of environment variable "LANG"  }
     NL_CAT_DEFAULT = 0;
  { base on LC_MESSAGES in effect  }
     NL_CAT_LOCALE = 1;
{$define _NL_ITEM}

type
   Pnl_item = ^nl_item;
   nl_item = longint;
   Pnl_catd = ^nl_catd;
   nl_catd = longint;

function catclose(catd:nl_catd):longint;cdecl;external libc_nlm name 'catclose';
function catgets(catd:nl_catd; set_id:longint; msg_id:longint; _string:Pchar):Pchar;cdecl;external libc_nlm name 'catgets';
function catopen(name:Pchar; oflag:longint):nl_catd;cdecl;external libc_nlm name 'catopen';

// langinfo.h

  const
     DAY_1 = 1;    // Sunday
     DAY_2 = 2;    // Monday
     DAY_3 = 3;    // Tuesday
     DAY_4 = 4;    // Wednesday
     DAY_5 = 5;    // Thursday
     DAY_6 = 6;    // Friday
     DAY_7 = 7;    // Saturday
     ABDAY_1 = 8;  // Sun
     ABDAY_2 = 9;  // Mon
     ABDAY_3 = 10; // Tue
     ABDAY_4 = 11; // Wed
     ABDAY_5 = 12; // Thu
     ABDAY_6 = 13; // Fri
     ABDAY_7 = 14; // Sat
     MON_1 = 15;   // January
     MON_2 = 16;   // February
     MON_3 = 17;   // March
     MON_4 = 18;   // April
     MON_5 = 19;   // May
     MON_6 = 20;   // June
     MON_7 = 21;   // July
     MON_8 = 22;   // August
     MON_9 = 23;   // September
     MON_10 = 24;  // October
     MON_11 = 25;  // November
     MON_12 = 26;  // December
     ABMON_1 = 27; // Jan
     ABMON_2 = 28; // Feb
     ABMON_3 = 29;     // Mar
     ABMON_4 = 30;     // Apr
     ABMON_5 = 31;     // May
     ABMON_6 = 32;     // Jun
     ABMON_7 = 33;     // Jul
     ABMON_8 = 34;     // Aug
     ABMON_9 = 35;     // Sep
     ABMON_10 = 36;    // Oct
     ABMON_11 = 37;    // Nov
     ABMON_12 = 38;    // Dec
     RADIXCHAR = 39;   // radix character (not supported)
     THOUSEP = 40;     // separator for thousand
     CRNCYSTR = 43;    // currency symbol
     D_T_FMT = 44;     // string for formatting date and time
     D_FMT = 45;       // date format
     T_FMT = 46;       // time format
     AM_STR = 47;      // am string
     PM_STR = 48;      // pm string
     CODESET = 49;     // code set name
     T_FMT_AMPM = 50;  // a.m. or p.m. time format string (not supported)
     ERA = 51;         //era description segments (not supported)
     ERA_D_FMT = 52;   // era date format string (not supported)
     ERA_D_T_FMT = 53; // era date and time format string (not supported)
     ERA_T_FMT = 54;   // era time format string (not supported)
     ALT_DIGITS = 55;  // alternative symbols for digits  (not supported)
     _MAXSTRMSG = 57;  // maximum number of strings in langinfo


function nl_langinfo(item:nl_item):Pchar;cdecl;external libc_nlm name 'nl_langinfo';


// libgen.h

function basename(path:Pchar):Pchar;cdecl;external libc_nlm name 'basename';
function dirname(path:Pchar):Pchar;cdecl;external libc_nlm name 'dirname';


// library.h

{ return flags for get_app_type()...  }
  const
     LIBRARY_UNKNOWN = $01;
     LIBRARY_LIBC    = $02;  { thread has specific NKS/LibC context    }
     LIBRARY_CLIB    = $04;  { thread has CLib context                 }
     LIBRARY_JAVA    = $08;  { thread belongs to Java Virtual Machine  }

type
   Paddrsp_t = ^addrsp_t;
   addrsp_t = void;
{ O_RDONLY, etc. from fcntl.h...  }

   Predirect_t = ^redirect_t;
   redirect_t = record
        pathname : Pchar;
        oflag : longint;
     end;
{ traditional NetWare solution for libraries...  }

function get_app_data(lib_id:longint):pointer;cdecl;external libc_nlm name 'get_app_data';
function get_app_type:longint;cdecl;external libc_nlm name 'get_app_type';
function register_library(cleanupFunc:TCDeclFunc1PtrArgLongint):longint;cdecl;external libc_nlm name 'register_library';
function register_destructor(libid:longint; cleanupFunc:TCDeclFunc1PtrArgLongint):longint;cdecl;external libc_nlm name 'register_destructor';
function set_app_data(lib_id:longint; data_area:pointer):longint;cdecl;external libc_nlm name 'set_app_data';
function unregister_library(lib_id:longint):longint;cdecl;external libc_nlm name 'unregister_library';
{ more prototypes for library creators, debugging and other uses...  }
function cleardontunloadflag(handle:pointer):longint;cdecl;external libc_nlm name 'cleardontunloadflag';
function findnlmhandle(name:Pchar; space:addrsp_t):TNLMHandle;cdecl;external libc_nlm name 'findnlmhandle';
function getaddressspace:addrsp_t;cdecl;external libc_nlm name 'getaddressspace';
function getaddressspacename(space:addrsp_t; name:Pchar):Pchar;cdecl;external libc_nlm name 'getaddressspacename';
function getallocresourcetag:rtag_t;cdecl;external libc_nlm name 'getallocresourcetag';
function getnativethread:pointer;cdecl;external libc_nlm name 'getnativethread';
{ (current process)  }
function getnlmhandle:TNLMHandle;cdecl;external libc_nlm name 'getnlmhandle';
function getnlmhandlefromthread(thread:pointer):TNLMHandle;cdecl;external libc_nlm name 'getnlmhandlefromthread';
function getnlmname(handle:TNLMHandle; name:Pchar):Pchar;cdecl;external libc_nlm name 'getnlmname';
function getnlmloadpath(loadpath:Pchar):Pchar;cdecl;external libc_nlm name 'getnlmloadpath';
function getthreadname(threadid:pointer; name:Pchar; maxlen:size_t):longint;cdecl;external libc_nlm name 'getthreadname';
function _getthreadid:pointer;cdecl;external libc_nlm name 'getthreadid';
function library_calloc(handle:pointer; size:size_t; count:size_t):pointer;cdecl;external libc_nlm name 'library_calloc';
procedure library_free(addr:pointer);cdecl;external libc_nlm name 'library_free';
function library_malloc(handle:pointer; size:size_t):pointer;cdecl;external libc_nlm name 'library_malloc';
function library_msize(addr:pointer):size_t;cdecl;external libc_nlm name 'library_msize';
function library_realloc(handle:pointer; old:pointer; size:size_t):pointer;cdecl;external libc_nlm name 'library_realloc';
function nlmisloadedprotected:longint;cdecl;external libc_nlm name 'nlmisloadedprotected';
function setdontunloadflag(handle:pointer):longint;cdecl;external libc_nlm name 'setdontunloadflag';
function setthreadname(threadid:pointer; name:Pchar):longint;cdecl;external libc_nlm name 'setthreadname';
//!! function uname2(handle:pointer; info:Putsname; bits:dword):longint;cdecl;external libc_nlm name 'uname2';
function validateaddressrange(addr:pointer; bytes:size_t):longint;cdecl;external libc_nlm name 'validateaddressrange';
function verifynlmhandle(handle:pointer):pointer;cdecl;external libc_nlm name 'verifynlmhandle';
function construct_argc_argv(command_line:Pchar; argv0:Pchar; argc:Plongint; argv:array of Pchar):longint;cdecl;external libc_nlm name 'construct_argc_argv';
type TRedirectSpecs = array [0..2] of redirect_t;
function detect_redirection(r:TRedirectSpecs; argc:Plongint; argv:array of Pchar):longint;cdecl;external libc_nlm name 'detect_redirection';
{ name-logical additions to library_malloc...  }


// locale.h

{ locale categories...  }
{ turn on 1-byte packing...  }

  { for use with LC_ALL                          }

const
   MAX_LOCNAME_LEN = 31 + 1;
  { locale categories...  }
   LC_CTYPE    = 0;  { character classification (unsupported) }
   LC_COLLATE  = 1;  { the locale's collation table (unsupported) }
   LC_NUMERIC  = 2;  { the numeric part of struct lconv }
   LC_MONETARY = 3;  { the monetary part of struct lconv }
   LC_TIME     = 4;  { the time and date part of struct lconv }
   LC_MESSAGES = 5;  { new starting in NetWare v4.11 (unsupported) }
   LC_ALL      = 6;



{ for the current locale...                    }
{ internal representations...                  }
{ ibid                                         }
{ as returned from setlocale(LC_ALL, NULL)     }
{ -------------------------- [Numeric Conventions] ---------------------  }
{ decimal point                                }
{ separator for digits left of decimal         }
{ digit grouping size                          }
{ -------------------------- [Monetary Conventions] --------------------  }
{ currency symbol                              }
{ decimal point                                }
{ separator for digits left of decimal         }
{ digit grouping sizes                         }
{ string indicating positive quantities        }
{ string indicating negative quantities        }
{ count of digits right of decimal             }
{ for positive monetary quantities:            }
{   currency symbol precedes quantity          }
{   currency symbol separated by blank         }
{   position of positive symbol                }
{ for negative monetary quantities:            }
{   currency symbol precedes quantity          }
{   currency symbol separated by blank         }
{   position of negative symbol                }
{ (reserved for future use)                    }
{ -------------------------- [International Monetary Conventions] ------  }
{ international currency symbol and separator  }
{ (international) digits right of decimal      }
{ -------------------------- [Time and Date Conventions] ---------------  }
{ always enforce 24-hour display (Boolean)     }
{ hour and seconds separator                   }
{ hour separator when no seconds displayed     }
{ month/day/year separator                     }
{ hours:minutes:seconds format (hh:mm:ss)      }
{ month/day/year format (mm/dd/yyyy)           }
{ weekday, month, day and year format          }
{ delimited string indicating am and pm        }
{ delimited string indicating AM and PM        }
{ delimited string of day names                }
{ delimited string of abbreviated day names    }
{ delimited string of month names              }
{ delimited string of abbreviated month names  }
type
   Plconv = ^lconv;
   lconv = record
        country : longint;//cdecl;
        language : longint;
        name : array[0..7] of char;
        decimal_point : array[0..3] of char;
        thousands_sep : array[0..3] of char;
        grouping : array[0..3] of char;
        currency_symbol : array[0..3] of char;
        mon_decimal_point : array[0..3] of char;
        mon_thousands_sep : array[0..3] of char;
        mon_grouping : array[0..7] of char;
        positive_sign : array[0..3] of char;
        negative_sign : array[0..3] of char;
        frac_digits : char;
        p_cs_precedes : char;
        p_sep_by_space : char;
        p_sign_posn : char;
        n_cs_precedes : char;
        n_sep_by_space : char;
        n_sign_posn : char;
        reserved : char;
        int_curr_symbol : array[0..14] of char;
        int_frac_digits : char;
        always_24 : longint;
        hour_sep : array[0..3] of char;
        hour_sans_sec_sep : array[0..3] of char;
        date_sep : array[0..3] of char;
        time_fmt : array[0..15] of char;
        date_fmt : array[0..15] of char;
        full_date_fmt : array[0..31] of char;
        ampm : array[0..31] of char;
        _AMPM : array[0..31] of char;
        days : array[0..159] of char;
        day_abbrevs : array[0..159] of char;
        months : array[0..159] of char;
        month_abbrevs : array[0..159] of char;
     end;

{ sizeof(struct lconv) == 0x360 (864.)         }


(** unsupported pragma#pragma pack()*)
{ prototypes for functions standard and nonstandard...  }

function localeconv:Plconv;cdecl;external libc_nlm name 'localeconv';
function setlocale(_para1:longint; _para2:Pchar):Pchar;cdecl;external libc_nlm name 'setlocale';
//!! function derivelocale(_para1:Pchar; _para2:Pchar; _para3:array[0..(31 + 1)-1] of char):Pchar;cdecl;external libc_nlm name 'derivelocale';
function setlocale_r(_para1:longint; _para2:Pchar; _para3:Plconv; _para4:Pchar):Pchar;cdecl;external libc_nlm name 'setlocale_r';


// malloc.h
{
** According to ISO/IEC (ANSI) 9899:1990 and 1999, memory allocation and
** management functions are properly the domain of stdlib.h:
** void   *calloc ( size_t, size_t );
** void    free   ( void * );
** void   *malloc ( size_t );
** void   *realloc( void *, size_t );
**
** Non-standard functions from stdlib.h (don't define __STDC__ or these
** disappear):
** void   *alloca        ( size_t );
** size_t  msize         ( void * );
** int     mvalidate     ( void * );
** size_t  stackavail    ( void );
** void   *stackbase     ( void );
** size_t  stackwatermark( void );
 }


// math.h

{ constants for type exception using matherr()       }
{ turn on 1-byte packing...  }

  const
     DOMAIN = 1;
     SING = 2;      { argument singularity }
     OVERFLOW = 3;  { overflow range error }
     UNDERFLOW = 4; { underflow range error  }
     TLOSS = 5;     { total loss of significance }
     PLOSS = 6;     { partial loss of significance  }


{ for C++, __fp_exception; for C, exception  }
type
   Pexception = ^Texception;
   Texception = record
        _type : longint;
        name : Pchar;
        arg1 : double;
        arg2 : double;
        retval : double;
     end;

{ for C++, __COMPLEX; for C, complex  }
   Pcomplex = ^complex;
   complex = record
        real : double;
        imag : double;
     end;

(** unsupported pragma#pragma pack()*)
//var
//  ___nan_float : double;cvar;external;
//  ___huge_float : double;cvar;external;
//  ___huge_double : double;cvar;external;
//  ___huge_long_double : double;cvar;external;

function acos(_para1:double):double;cdecl;external libc_nlm name 'acos';
function asin(_para1:double):double;cdecl;external libc_nlm name 'asin';
function atan(_para1:double):double;cdecl;external libc_nlm name 'atan';
function atan2(_para1:double; _para2:double):double;cdecl;external libc_nlm name 'atan2';
function cbrt(_para1:double):double;cdecl;external libc_nlm name 'cbrt';
function ceil(_para1:double):double;cdecl;external libc_nlm name 'ceil';
function cos(_para1:double):double;cdecl;external libc_nlm name 'cos';
function cosh(_para1:double):double;cdecl;external libc_nlm name 'cosh';
function exp(_para1:double):double;cdecl;external libc_nlm name 'exp';
function fabs(_para1:double):double;cdecl;external libc_nlm name 'fabs';
function floor(_para1:double):double;cdecl;external libc_nlm name 'floor';
function fmod(_para1:double; _para2:double):double;cdecl;external libc_nlm name 'fmod';
function frexp(_para1:double; _para2:Plongint):double;cdecl;external libc_nlm name 'frexp';
function hypot(_para1:double; _para2:double):double;cdecl;external libc_nlm name 'hypot';
function ldexp(_para1:double; _para2:longint):double;cdecl;external libc_nlm name 'ldexp';
function log(_para1:double):double;cdecl;external libc_nlm name 'log';
function log10(_para1:double):double;cdecl;external libc_nlm name 'log10';
function modf(_para1:double; _para2:Pdouble):double;cdecl;external libc_nlm name 'modf';
function pow(_para1:double; _para2:double):double;cdecl;external libc_nlm name 'pow';
function remainder(_para1:double; _para2:double):double;cdecl;external libc_nlm name 'remainder';
function rint(_para1:double):double;cdecl;external libc_nlm name 'rint';
function sin(_para1:double):double;cdecl;external libc_nlm name 'sin';
function sinh(_para1:double):double;cdecl;external libc_nlm name 'sinh';
function sqrt(_para1:double):double;cdecl;external libc_nlm name 'sqrt';
function tan(_para1:double):double;cdecl;external libc_nlm name 'tan';
function tanh(_para1:double):double;cdecl;external libc_nlm name 'tanh';
function cabs(_para1:complex):double;cdecl;external libc_nlm name 'cabs';
function finite(_para1:double):longint;cdecl;external libc_nlm name 'finite';
function j0(_para1:double):double;cdecl;external libc_nlm name 'j0';
function j1(_para1:double):double;cdecl;external libc_nlm name 'j1';
function jn(_para1:longint; _para2:double):double;cdecl;external libc_nlm name 'jn';
function y0(_para1:double):double;cdecl;external libc_nlm name 'y0';
function y1(_para1:double):double;cdecl;external libc_nlm name 'y1';
function yn(_para1:longint; _para2:double):double;cdecl;external libc_nlm name 'yn';
function matherr(_para1:Pexception):longint;cdecl;external libc_nlm name 'matherr';
type TmathErrHandlerFunc = function (_para1:Pexception):longint; cdecl;
function matherr_handler(_para1:TmathErrHandlerFunc):longint;cdecl;external libc_nlm name 'matherr_handler';
function ___fpclassify_f(_para1:double):longint;cdecl;external libc_nlm name '___fpclassify_f';
function ___fpclassify_d(_para1:double):longint;cdecl;external libc_nlm name '___fpclassify_d';
function ___fpclassify_ld(double:longint):longint;cdecl;external libc_nlm name '___fpclassify_ld';
function ___isfinite_f(_para1:double):longint;cdecl;external libc_nlm name '___isfinite_f';
function ___isfinite_d(_para1:double):longint;cdecl;external libc_nlm name '___isfinite_d';
function ___isfinite_ld(double:longint):longint;cdecl;external libc_nlm name '___isfinite_ld';
function ___signbit_f(_para1:double):longint;cdecl;external libc_nlm name '___signbit_f';
function ___signbit_d(_para1:double):longint;cdecl;external libc_nlm name '___signbit_d';
function ___signbit_ld(double:longint):longint;cdecl;external libc_nlm name '___signbit_ld';


// monitor.h
{ turn on 1-byte packing...  }

type
   Pconn_info = ^Tconn_info;
   Tconn_info = record
        codepage : longint;
        spares   : array[0..507] of byte;
     end;

{ additional processor information that may be available...  }
{ (may not equal 'ThreadsOnProcessor' when totalled:)  }
   Pcpu_info = ^Tcpu_info;
   Tcpu_info = record
        which : longint;
        CurrentProcessor : longint;
        ProcessorUtilization : dword;
        ThreadsOnProcessor : dword;
        reserved1 : dword;
        Family : dword;
        Model : dword;
        Stepping : dword;
        Revision : dword;
        FeatureFlags : dword;
        SerialNumber : Tuint64;
        Speed : dword;
        L1CacheSize : dword;
        L2CacheSize : dword;
        L3CacheSize : dword;
        ReadyThreads : dword;
        RunningThreads : dword;
        SuspendedThreads : dword;
        reserved2 : dword;
        ThreadCPUTime : Tuint64;
        reserved3 : Tuint64;
        reserved4 : array[0..7] of dword;
     end;

   Pfilesystem_info = ^Tfilesystem_info;
   Tfilesystem_info = record
        OpenFileCount : longint;
        CurrentDiskRequests : longint;
        reserved : array[0..61] of dword;
     end;

   Prestag_info = ^Trestag_info;
   Trestag_info = record                      { per-NLM resource-allocation information  }
        tag_count : longint;                  { count of discrete resource tags  }
        res_count : size_t;                   { total number of resources across tags  }
        reserved1 : longint;                  { used only by 'ALRT' tags  }
        signature : dword;                    { type of resource (see netware.h)  }
        description : array[0..79] of char;   { resource tag description string  }
     end;

   Pmem_restag_info = ^Tmem_restag_info;
   Tmem_restag_info = record                  { per-NLM memory information  }
        tag_count   : longint;                { discrete memory allocation resource tags  }
        total_bytes : size_t;                 { total number of bytes allocated across tags  }
        allocations : longint;                { total actual calls to allocator  }
        reserved2   : dword;                  { always signature ('ALRT')  }
        description : array[0..79] of char;   { resource tag description string  }
     end;

   Pmemory_info = ^Tmemory_info;
   Tmemory_info = record
        AllocatedMemoryPool    : size64_t;
        CacheBufferSize        : size64_t;
        CacheBufferMemory      : size64_t;
        CacheMoveableMemory    : size64_t;
        CacheNonmoveableMemory : size64_t;
        CodeMemory             : size64_t;
        DataMemory             : size64_t;
        TotalWorkMemory        : size64_t;
        OtherCachePagesMemory  : size64_t;
        reserved1              : size64_t;
        TotalKnownSystemMemoryUnder4Gb : size64_t;
        TotalKnownSystemMemory : size64_t;
        reserved               : array[0..11] of dword;
     end;

   Pvmemory_info = ^Tvmemory_info;
   Tvmemory_info = record
        PageInCount : Tuint64;
        PageOutCount : Tuint64;
        SwapResvCount : Tuint64;
        SwapPageCount : Tuint64;
        SwapFreeCount : Tuint64;
        PageFaultCount : Tuint64;
        freeCachePages : Tuint64;
        freeCleanPages : Tuint64;
        freeDirtyPages : Tuint64;
        VMPhysicalPageCount : Tuint64;
        reserved : array[0..19] of dword;
     end;

   Pnet_info = ^Tnet_info;
   Tnet_info = record
        MaximumConnections : longint;
        spare0 : array[0..11] of dword;
        IPXAddr : array[0..5] of byte;
        spare1 : array[0..1] of byte;
        MaximumBoards : dword;
        spare3 : array[0..11] of dword;
        IPAddrsBound : array[0..11] of dword;
        spare4 : array[0..23] of dword;
     end;

   Pos_info = ^Tos_info;
   Tos_info = record
        AbendedProcessCount    : longint;
        CurrentServerProcesses : longint;
        reserved               : array[0..61] of dword;
     end;

{ includes namespace list  }
   Pvolume_info = ^Tvolume_info;
   Tvolume_info = record
        which : longint;
        flags : dword;
        name : array[0..(31 + 1)-1] of char;
        SectorSize : dword;
        SectorsPerCluster : dword;
        VolumeSizeInClusters : dword;
        FreedClusters : dword;
        SubAllocFreeableClusters : dword;
        FreeableLimboSectors : dword;
        NonFreeableLimboSectors : dword;
        NonFreeableAvailableSubAllocSectors : dword;
        NotUsableSubAllocSectors : dword;
        SubAllocClusters : dword;
        DataStreamsCount : dword;
        LimboDataStreamsCount : dword;
        OldestDeletedFileAgeInTicks : dword;
        CompressedDataStreamsCount : dword;
        CompressedLimboDataStreamsCount : dword;
        UnCompressableDataStreamsCount : dword;
        PreCompressedSectors : dword;
        CompressedSectors : dword;
        MigratedFiles : dword;
        MigratedSectors : dword;
        ClustersUsedByFAT : dword;
        ClustersUsedByDirectories : dword;
        ClustersUsedByExtendedDirectories : dword;
        TotalDirectoryEntries : dword;
        UnUsedDirectoryEntries : dword;
        TotalExtendedDirectoryExtants : dword;
        UnUsedExtendedDirectoryExtants : dword;
        ExtendedAttributesDefined : dword;
        ExtendedAttributeExtantsUsed : dword;
        DirectoryServicesObjectID : dword;
        VolumeLastModifiedDateAndTime : dword;
        mounted : longint;
        BlockCount : Tuint64;
        BlocksFree : Tuint64;
        BlockSize : dword;
        reserved : array[0..57] of dword;
     end;

(** unsupported pragma#pragma pack()*)
{ prototypes...  }

function netware_conn_info(info:Pconn_info; sequence:Plongint):longint;cdecl;external libc_nlm name 'netware_conn_info';
function netware_conn_info_from_slot(info:Pconn_info; slot:longint):longint;cdecl;external libc_nlm name 'netware_conn_info_from_slot';
function netware_cpu_info(info:Pcpu_info; sequence:Plongint):longint;cdecl;external libc_nlm name 'netware_cpu_info';
function netware_fs_info(info:Pfilesystem_info):longint;cdecl;external libc_nlm name 'netware_fs_info';
function netware_net_info(info:Pnet_info):longint;cdecl;external libc_nlm name 'netware_net_info';
//!! function netware_net_macaddr(board:longint; macAddr:array[0..5] of byte):longint;cdecl;external libc_nlm name 'netware_net_macaddr';
function netware_mem_info(info:Pmemory_info):longint;cdecl;external libc_nlm name 'netware_mem_info';
function netware_mem_info_for_nlm(info:Pmem_restag_info; handle:pointer):longint;cdecl;external libc_nlm name 'netware_mem_info_for_nlm';
function netware_os_info(info:Pos_info):longint;cdecl;external libc_nlm name 'netware_os_info';
function netware_vmem_info(info:Pvmemory_info):longint;cdecl;external libc_nlm name 'netware_vmem_info';
function netware_vol_info(info:Pvolume_info; sequence:Plongint):longint;cdecl;external libc_nlm name 'netware_vol_info';
function netware_vol_info_from_number(info:Pvolume_info; volNum:longint):longint;cdecl;external libc_nlm name 'netware_vol_info_from_number';
function netware_vol_info_from_name(info:Pvolume_info; name:Pchar):longint;cdecl;external libc_nlm name 'netware_vol_info_from_name';
function netware_restag_info_for_nlm(info:Prestag_info; handle:pointer; signature:dword; which:longint):longint;cdecl;external libc_nlm name 'netware_restag_info_for_nlm';

function netware_conn_info(var info:Tconn_info; var sequence:longint):longint;cdecl;external libc_nlm name 'netware_conn_info';
function netware_conn_info_from_slot(var info:Tconn_info; slot:longint):longint;cdecl;external libc_nlm name 'netware_conn_info_from_slot';
function netware_cpu_info(var info:Tcpu_info; var sequence:longint):longint;cdecl;external libc_nlm name 'netware_cpu_info';
function netware_fs_info(var info:Tfilesystem_info):longint;cdecl;external libc_nlm name 'netware_fs_info';
function netware_net_info(var info:Tnet_info):longint;cdecl;external libc_nlm name 'netware_net_info';
//!! function netware_net_macaddr(board:longint; macAddr:array[0..5] of byte):longint;cdecl;external libc_nlm name 'netware_net_macaddr';
function netware_mem_info(var info:Tmemory_info):longint;cdecl;external libc_nlm name 'netware_mem_info';
function netware_mem_info_for_nlm(var info:Tmem_restag_info; handle:pointer):longint;cdecl;external libc_nlm name 'netware_mem_info_for_nlm';
function netware_os_info(var info:Tos_info):longint;cdecl;external libc_nlm name 'netware_os_info';
function netware_vmem_info(var info:Tvmemory_info):longint;cdecl;external libc_nlm name 'netware_vmem_info';
function netware_vol_info(var info:Tvolume_info; var sequence:longint):longint;cdecl;external libc_nlm name 'netware_vol_info';
function netware_vol_info_from_number(var info:Tvolume_info; volNum:longint):longint;cdecl;external libc_nlm name 'netware_vol_info_from_number';
function netware_vol_info_from_name(var info:Tvolume_info; name:Pchar):longint;cdecl;external libc_nlm name 'netware_vol_info_from_name';
function netware_restag_info_for_nlm(var info:Trestag_info; handle:pointer; signature:dword; which:longint):longint;cdecl;external libc_nlm name 'netware_restag_info_for_nlm';


// ncpx.h

const
     MAX_NCPX_NAMELEN = 33;
     NCPX_BEGIN_SCAN = $FFFFFFFF;
     NCPX_REPLY_IS_FRAGGED = $FFFFFFFF;
     NCPX_BEING_RESTARTED = $01101001;
     NCPX_BEING_KILLED = $02202002;
     NCPX_BEING_LOGGED_OUT = $03303003;
     NCPX_BEING_FREED = $04404004;

type

   Pncpx_id_t = ^ncpx_id_t;
   ncpx_id_t = dword;

   Pncpx_client_t = ^ncpx_client_t;
   ncpx_client_t = Tuint64;

   Pncpx_frag_element_t = ^ncpx_frag_element_t;
   ncpx_frag_element_t = record
        addr : pointer;
        size : size_t;
     end;

   Pncpx_msgfrag_t = ^ncpx_msgfrag_t;
   ncpx_msgfrag_t = record
        totalMessageSize : size_t;
        fragCount : longint;
        fragList : array[0..3] of ncpx_frag_element_t;
     end;

   Pncpx_vers_t = ^ncpx_vers_t;
   ncpx_vers_t = record
        major : longint;
        minor : longint;
        revision : longint;
     end;
{ the handler that implements the extended NCP service... }

   ncpx_handler_t = function (client:Pncpx_client_t; request:pointer; requestLen:size_t; reply:pointer; replyLen:Psize_t):longint;cdecl;
{ the call-back made when the session goes away for whatever reason... }

   sess_handler_t = procedure (session:longint; _type:longint);cdecl;
{ the handler that replies to extended NCP requests (if any)... }

   reply_mgr_t = procedure (client:Pncpx_client_t; repBuffer:pointer);cdecl;
{ server registering an extended NCP service...  }
function NcpxRegister(name:Pchar; ncpHandler:ncpx_handler_t; sessionHandler:sess_handler_t; replyManager:reply_mgr_t; version:ncpx_vers_t;
           queryData:Ppointer):longint;cdecl;external libc_nlm name 'NcpxRegister';
function NcpxRegisterWithId(id:ncpx_id_t; name:Pchar; ncpHandler:ncpx_handler_t; sessionHandler:sess_handler_t; replyManager:reply_mgr_t;
           version:ncpx_vers_t; queryData:Ppointer):longint;cdecl;external libc_nlm name 'NcpxRegisterWithId';
function NcpxDeregister(queryData:pointer):longint;cdecl;external libc_nlm name 'NcpxDeregister';
{ client getting information about extended NCP services...  }
function NcpxGetInfoByName(name:Pchar; id:Pncpx_id_t; version:ncpx_vers_t; queryData:pointer):longint;cdecl;external libc_nlm name 'NcpxGetInfoByName';
function NcpxGetInfoById(id:ncpx_id_t; name:Pchar; version:ncpx_vers_t; queryData:pointer):longint;cdecl;external libc_nlm name 'NcpxGetInfoById';
function NcpxScan(id:Pncpx_id_t; name:Pchar; version:ncpx_vers_t; queryData:pointer):longint;cdecl;external libc_nlm name 'NcpxScan';
{ for the client sending extended NCP packets to a service...  }

function NcpxSend(id:ncpx_id_t; request:pointer; requestLen:size_t; reply:pointer; replyLen:Psize_t):longint;cdecl;external libc_nlm name 'NcpxSend';
function NcpxSendFragged(id:ncpx_id_t; reqFrag:Pncpx_msgfrag_t; repFrag:Pncpx_msgfrag_t):longint;cdecl;external libc_nlm name 'NcpxSendFragged';

// ndkvers.h
{==============================================================================
=  This is a timestamp offered by the NDK. Calling libcthreshold() with the
=  defined value as first argument (the second argument returns that of the
=  currently loaded libc.nlm), will ensure at least the functionality and
=  semantics offered by the NDK this file accompanied or this function returns
=  an error (ENOTSUP). Whether or not this function fails, it always returns
=  the loaded library's threshold.
==============================================================================}

  const
     CURRENT_NDK_THRESHOLD = 406230000;
  { timestamps for known releases of LibC on NetWare...  }
     NETWARE_65_FCS = 306250000;        { 25 June 2003  }
     NETWARE_65_SP1 = 310090000;        { 9 October 2003  }
     NETWARE_CSP10  = 310070000;        { 7 October 2003  }
     NETWARE_51_SP7 = NETWARE_CSP10;
     NETWARE_60_SP4 = NETWARE_CSP10;
     NETWARE_CSP11  = 405260000;        { 26 May 2004  }
     NETWARE_60_SP5 = NETWARE_CSP11;
     NETWARE_65_SP2 = NETWARE_CSP11;
     NETWARE_CSP12  = 410310000;       { 31 October 2004 (just a guess)  }
     NETWARE_51_SP8 = NETWARE_CSP12;
     NETWARE_65_SP3 = NETWARE_CSP12;


function libcthreshold(desiredthreshold:longint; libthreshold:Plongint):longint;cdecl;external libc_nlm name 'libcthreshold';
function libcthreshold(desiredthreshold:longint; var libthreshold:longint):longint;cdecl;external libc_nlm name 'libcthreshold';

// netdb.h

  const
     NETDB_INTERNAL = -(1);
     NETDB_SUCCESS = 0;      { no problem  }
     HOST_NOT_FOUND = 1;     { authoritative answer host not found  }
     TRY_AGAIN = 2;          { non authoritative host not found or SERVERFAIL  }
     NO_RECOVERY = 3;        { non recoverable: FORMERR, REFUSED, NOTIMP  }
     NO_DATA = 4;            { valid name, no data record of requested type  }
     NO_ADDRESS = NO_DATA;   { no address, look for MX record  }


{ Addresses are supplied in host order and returned in network order. }
type
   Phostent = ^hostent;
   hostent = record
        h_name      : Pchar;     { official name of host }
        h_aliases   : PPchar;    { alias list }
        h_addrtype  : smallint;  { host address type }
        h_length    : smallint;  { length of address }
        h_addr_list : PPchar;    { list of addresses }
     end;

{ It is assumed here that a network number fits in 32 bits. }
   Pnetent = ^netent;
   netent = record
        n_name     : Pchar;      { official name of net }
        n_aliases  : PPchar;     { alias list }
        n_addrtype : smallint;   { net address type }
        n_net      : u_long;     { network number }
     end;

   Pservent = ^servent;
   servent = record
        s_name    : Pchar;       { official service name }
        s_aliases : PPchar;      { alias list }
        s_port    : smallint;    { port number }
        s_proto   : Pchar;       { protocol to use }
     end;

   Pprotoent = ^protoent;
   protoent = record
        p_name    : Pchar;       { official protocol name }
        p_aliases : PPchar;      { alias list }
        p_proto   : smallint;    { protocol number }
     end;


function gethostbyaddr(_para1:Pchar; _para2:longint; _para3:longint):Phostent;cdecl;external libc_nlm name 'gethostbyaddr';
function gethostbyname(_para1:Pchar):Phostent;cdecl;external libc_nlm name 'gethostbyname';
function gethostname(_para1:Pchar; _para2:longint):longint;cdecl;external libc_nlm name 'gethostname';
function getprotobyname(_para1:Pchar):Pprotoent;cdecl;external libc_nlm name 'getprotobyname';
function getprotobynumber(_para1:longint):Pprotoent;cdecl;external libc_nlm name 'getprotobynumber';
function getservbyname(_para1:Pchar; _para2:Pchar):Pservent;cdecl;external libc_nlm name 'getservbyname';
function getservbyport(_para1:longint; _para2:Pchar):Pservent;cdecl;external libc_nlm name 'getservbyport';
function ___h_errno:Plongint;cdecl;external libc_nlm name '___h_errno';


// nks/nksapi.h
// nlmformat.h

{ 0x002E --------------------------- }
{ 0x0032 --------------------------- }
{ 0x0036 --------------------------- }
{ 0x003A --------------------------- }
{ 0x003E --------------------------- }
{ 0x0042 --------------------------- }
{ 0x0046 --------------------------- }
{ 0x004A --------------------------- }
{ 0x004E --------------------------- }
{ 0x0052 --------------------------- }
{ 0x0056 --------------------------- }
{ 0x005A --------------------------- }
{ 0x005E --------------------------- }
{ 0x0062 --------------------------- }
{ 0x0066 --------------------------- }
{ 0x006A --------------------------- }
{ 0x006E --------------------------- }
{ 0x0072 --------------------------- }
{ 0x0076 --------------------------- }
{ 0x007A --------------------------- }
{ 0x007E --------------------------- }
{ 0x0082 --------------------------- }
{ -------------------------------------------------------------------------
   ** NB: Here begins the variable part of this structure's format; what is
   ** shown here are the maximums. Consequently, sizeof(NLM_HEADER) is almost
   ** always meaningless--the 400 bytes of 'otherData' actually referring to
   ** the original size of the scratch buffer in NLMLINK set up to hold the
   ** data before writing it to the binary file.
   ** -------------------------------------------------------------------------
    }

const
 MAX_DESCRIPTION_LENGTH   = 127;
 OLD_THREAD_NAME_LENGTH   = 5;    // (exactly " LONG")
 MAX_SCREEN_NAME_LENGTH   = 71;
 MAX_THREAD_NAME_LENGTH   = 71;


{ 0x0083 --------------------------- }
{ 0x0103 --------------------------- }
{ 0x0107 --------------------------- }
{ 0x010B --------------------------- }
{ 0x0110 --------------------------- }
{ 0x0111 --------------------------- }
{ 0x0158 --------------------------- }
{ 0x015C --------------------------- }
{ 0x01A3 --------------------------- }
type

   PNLM_HEADER = ^NLM_HEADER;
   NLM_HEADER = record                                       { offset in structure -------------- }
        signature                  : array[0..23] of char;   { "NetWare Loadable Modulex\1A" }
        version                    : dword;               { 0x0018 --------------------------- }
        moduleName                 : array[0..13] of char;   { 0x001C --------------------------- }
        codeImageOffset            : dword;               { 0x002A --------------------------- }
        codeImageSize              : dword;
        dataImageOffset            : dword;
        dataImageSize              : dword;
        uninitializedDataSize      : dword;
        customDataOffset           : dword;
        customDataSize             : dword;
        moduleDependencyOffset     : dword;
        numberOfModuleDependencies : dword;
        relocationFixupOffset      : dword;
        numberOfRelocationFixups   : dword;
        externalReferencesOffset   : dword;
        numberOfExternalReferences : dword;
        publicsOffset              : dword;
        numberOfPublics            : dword;
        debugInfoOffset            : dword;
        numberOfDebugRecords       : dword;
        codeStartOffset            : dword;
        exitProcedureOffset        : dword;
        checkUnloadProcedureOffset : dword;
        moduleType                 : dword;
        flags                      : dword;
        descriptionLength          : byte;
        descriptionText            : array[0..126] of char;
        stackSize                  : dword;
        reserved                   : dword;
        reserved2                  : array[0..4] of byte;
        screenNameLength           : byte;
        screenName                 : array[0..70] of char;
        threadNameLength           : byte;
        threadName                 : array[0..70] of char;
        otherData                  : array[0..399] of byte;
     end;
{ (note: length not actually 0x0333) }
{ starts 'otherData' of NLM_HEADER }
{ offset in structure -------------- }
{ 0x0000 (exactly "VeRsIoN#") }
{ 0x0008 --------------------------- }
{ 0x000C --------------------------- }
{ 0x0010 --------------------------- }
{ 0x0014 --------------------------- }
{ 0x0018 --------------------------- }
{ 0x001A --------------------------- }

   PVERSION_MASK = ^VERSION_MASK;
   VERSION_MASK = record
        VeRsIoN : array[0..7] of char;
        majorVersion : dword;
        minorVersion : dword;
        revision : dword;
        year : dword;
        month : dword;
        day : dword;
     end;                                           { 0x0020 (structure length) }


   PCOPYRIGHT_MASK = ^COPYRIGHT_MASK;               { immediately follows VERSION_MASK }
   COPYRIGHT_MASK = record                          { offset in structure -------------- }
        _CoPyRiGhT      : array[0..9] of char;      { 0x0000 (exactly "CoPyRiGhT=") }
        copyrightLength : byte;                  { 0x000A --------------------------- }
        copyright       : array[0..251] of char;    { 0x000B --------------------------- }
     end;
{ 0x0107 (structure length) }
{ immediately follows COPYRIGHT_MASK }
{ offset in structure -------------- }
{ 0x0000 (exactly "MeSsAgEs") }
{ 0x0008 --------------------------- }
{ 0x000C --------------------------- }
{ 0x0010 --------------------------- }
{ 0x0014 --------------------------- }
{ 0x0018 --------------------------- }
{ 0x001C --------------------------- }
{ 0x0020 --------------------------- }
{ 0x0024 --------------------------- }
{ 0x0028 (ignore to end of structure }
{ 0x0030     ...all these are either }
{ 0x0034     no longer used or never }
{ 0x0038     really have been) }
{ 0x003C --------------------------- }
{ 0x0040 --------------------------- }
{ 0x0044 --------------------------- }
{ 0x0048 --------------------------- }
{ 0x004C --------------------------- }
{ 0x0050 --------------------------- }
{ 0x0054 --------------------------- }
{ 0x0058 --------------------------- }
{ 0x0064 --------------------------- }
{ 0x0068 --------------------------- }
{ 0x006C --------------------------- }
{ 0x0070 --------------------------- }
{ 0x0074 --------------------------- }
{ 0x0078 --------------------------- }
{ 0x007C (* see CODEWARRIOR_LASTMOD) }

   PEXTENDED_HEADER = ^EXTENDED_HEADER;
   EXTENDED_HEADER = record
        MeSsAgEs : array[0..7] of char;
        languageID : dword;
        messageFileOffset : dword;
        messageFileLength : dword;
        messageCount : dword;
        helpFileOffset : dword;
        helpFileLength : dword;
        RPCDataOffset : dword;
        RPCDataLength : dword;
        sharedCodeOffset : dword;
        sharedCodeLength : dword;
        sharedDataOffset : dword;
        sharedDataLength : dword;
        sharedRelocationFixupOffset : dword;
        sharedRelocationFixupLength : dword;
        sharedExternalReferenceOffset : dword;
        sharedExternalReferenceCount : dword;
        sharedPublicsOffset : dword;
        sharedPublicsCount : dword;
        sharedDebugRecordOffset : dword;
        sharedDebugRecordCount : dword;
        sharedInitializationOffset : function :dword;cdecl;
        sharedExitProcedureOffset : procedure ;
        productID : dword;
        reserved0 : dword;
        reserved1 : dword;
        reserved2 : dword;
        reserved3 : dword;
        reserved4 : dword;
        reserved5 : dword;
     end;
{ 0x0080 (structure length) }
{
** The following syntagm appears only in NLMs linked with Metrowerks
** Code Warrior. In the hexadecimal dump, it appears starting at 'reserved5'
** in EXTENDED_HEADER above and appears thus (purely for example):
**
** 1C0: 4C 61 53 74  4D 6F 44 69  20 54 68 75  20 4F 63 74   "LaStMoDi Thu Oct"
** 1D0: 20 20 39 20  31 35 3A 30  33 3A 33 30  20 32 30 30   "  9 19:22:31 200"
** 1E0: 33 0A 00                                             "3..             "
**
** The start point shown (1C0) is variable, but LASTMOD_MASK will appear at
** very nearly this offset.
 }
{ at 'reserved5' in EXTENDED_HEADER }
{ offset in structure }
{ 0x0000 (exactly "LaStMoDi") }
{ 0x0009 --------------------------- }
{ 0x000A --------------------------- }
{ 0x000D --------------------------- }
{ 0x000E --------------------------- }
{ 0x0011 --------------------------- }
{ 0x0012 (blank-padded) ------------ }
{ 0x0014 --------------------------- }
{ 0x0015 --------------------------- }
{ 0x0017 --------------------------- }
{ 0x0018 --------------------------- }
{ 0x001A --------------------------- }
{ 0x001B --------------------------- }
{ 0x001D --------------------------- }
{ 0x001E --------------------------- }
{ 0x0022 --------------------------- }
{ 0x0023 --------------------------- }

   PLASTMOD_MASK = ^LASTMOD_MASK;
   LASTMOD_MASK = record
        LaStMoDi : array[0..7] of char;
        space : char;
        weekday : array[0..2] of char;
        space2 : char;
        month : array[0..2] of char;
        space3 : char;
        day : array[0..1] of char;
        space4 : char;
        hours24 : array[0..1] of char;
        colon1 : char;
        minutes : array[0..1] of char;
        colon2 : char;
        seconds : array[0..1] of char;
        space5 : char;
        year : array[0..3] of char;
        newline : char;
        null : char;
     end;


   PCUSTOM_HEADER_MASK = ^CUSTOM_HEADER_MASK;    { 0x0024 (structure length) }
   CUSTOM_HEADER_MASK = record                   { offset in structure -------------- }
        CuStHeAd : array[0..7] of byte;          { 0x0000 "CuStHeAd" }
     end;                                        { (note: length is custom) }

// nwieeefp.h

type fp_except = longint;
const
  FP_X_INV  = $01;  { invalid operation exception }
  FP_X_DNML = $02;  { denormal operation exception }
  FP_X_DZ   = $04;  { divide by zero exception }
  FP_X_OFL  = $08;  { overflow exception }
  FP_X_UFL  = $10;  { underflow exception }
  FP_X_IMP  = $20;  { inexact (precision) exception  }

type
   Pfp_rnd = ^fp_rnd;
   fp_rnd =  Longint;
Const
   FP_RN = 0;   { round to nearest representable number, tie -> even }
   FP_RM = 1;   { round toward minus infinity }
   FP_RP = 2;   { round toward plus infinity }
   FP_RZ = 3;   { round toward zero (truncate) }

(** unsupported pragma#pragma pack()*)

function fpgetmask:longint;cdecl;external libc_nlm name 'fpgetmask';
function fpgetround:fp_rnd;cdecl;external libc_nlm name 'fpgetround';
function fpgetsticky:longint;cdecl;external libc_nlm name 'fpgetsticky';
function fpsetmask(newmask:longint):longint;cdecl;external libc_nlm name 'fpsetmask';
function fpsetround(newround:fp_rnd):fp_rnd;cdecl;external libc_nlm name 'fpsetround';
function fpsetsticky(newsticky:longint):longint;cdecl;external libc_nlm name 'fpsetsticky';


(** unsupported pragma#pragma pack()*)


// paths.h

const
  _PATH_DEFPATH = '/system';
  _PATH_STDPATH = '/system';
  _PATH_DEVNULL = '/dev/null';
  _PATH_MAILDIR = '/mail';
  _PATH_DEV     = '/system/';
  _PATH_TMP     = '/tmp/';


// proc.h

const
  PROC_DETACHED = $00000001;
  PROC_CURRENT_SPACE = $00000004;    { use current address space    }
  PROC_MEMORY_DEBUG = $00000008;     { same as load -m              }
  PROC_LOAD_SILENT = $00000010;      { no console messages          }
  PROC_INHERIT_CWD = $00000020;      { child start in same CWD      }
  PROC_INHERIT_ID = $00000040;       { child inherits identity      }
  FD_UNUSED  = -1;                   { ignore: do not wire the console }

type
   Pwiring_t = ^wiring_t;    { standard console wiring for process()... }
   wiring_t = record
        infd  : longint;     { new process' standard input, etc. }
        outfd : longint;
        errfd : longint;
     end;
   TWiring = wiring_t;
   PWiring = Pwiring_t;

{$ifndef DisableArrayOfConst}
//function procle(path:Pchar; flags:dword; env:array of Pchar; wiring:Pwiring_t; fds:Pfd_set;
//           appdata:pointer; appdata_size:size_t; reserved:pointer; arg0:Pchar; args:array of const):pid_t;cdecl;external libc_nlm name 'procle';
{$endif}
{function procle(path:Pchar; flags:dword; env:array of Pchar; wiring:Pwiring_t; fds:Pfd_set;
           appdata:pointer; appdata_size:size_t; reserved:pointer; arg0:Pchar):pid_t;cdecl;external libc_nlm name 'procle';
function procve(path:Pchar; flags:dword; env:array of Pchar; wiring:Pwiring_t; fds:Pfd_set;
           appdata:pointer; appdata_size:size_t; reserved:pointer; argv:array of Pchar):pid_t;cdecl;external libc_nlm name 'procve';}
function procve(path:Pchar; flags:dword; env:pointer; wiring:Pwiring_t; fds:Pfd_set;
           appdata:pointer; appdata_size:size_t; reserved:pointer; argv:ppchar):pid_t;cdecl;external libc_nlm name 'procve';
function procle(path:Pchar; flags:dword; env:pointer; wiring:Pwiring_t; fds:Pfd_set;
           appdata:pointer; appdata_size:size_t; reserved:pointer; arg0:Pchar; args:ppchar):pid_t;cdecl;external libc_nlm name 'procle';

// pthread.h
// sched.h
{ turn on 1-byte packing...  }

const
  SCHED_UNKNOWN = 0;
  SCHED_FIFO = 1;         { first-in, first-out      (default NetWare MPK)  }
  SCHED_RR = 2;           { round-robin                    (unimplemented)  }
  SCHED_SPORADIC = 3;     { Single UNIX Specification      (unimplemented)  }
  SCHED_OTHER = 4;        { "other" policy                 (unimplemented)  }

type
   Psched_param = ^sched_param;
   sched_param = record
        sched_priority        : longint;    { for SPORADIC (unimplemented):   }
        sched_ss_low_priority : longint;    { low scheduling priority         }
        sched_ss_repl_period  : Ttimespec;  { replenishment period for        }
        sched_ss_init_budget  : Ttimespec;  { initial budget                  }
        sched_ss_max_repl     : longint;    { maximum pending replenishments  }
        sched_policy          : longint;
     end;

(** unsupported pragma#pragma pack()*)

  const
     PTHREAD_KEYS_MAX = 64;
  { no actual maximum   }
     PTHREAD_THREADS_MAX = 32767;
     PTHREAD_STACK_MIN = 16384;
  { pthread_setdetachstate, etc...  }
     PTHREAD_CREATE_DETACHED = $00000010;
     PTHREAD_CREATE_JOINABLE = 0;
  { values for field 'attr_scope'...  }
     PTHREAD_SCOPE_PROCESS = 0;
  { as yet unsupported  }
     PTHREAD_SCOPE_SYSTEM = 1;
  { values for field 'mattr_flags', 'cattr_flags' and 'rwattr_flags'...  }
     PTHREAD_PROCESS_PRIVATE = 0;
  { as yet unsupported  }
     PTHREAD_PROCESS_SHARED = 1;
  { pthread_setcancelstate, etc...  }
     PTHREAD_CANCELED = -(1);
     PTHREAD_CANCEL_ASYNCHRONOUS = 1;
     PTHREAD_CANCEL_DEFERRED = 2;
     PTHREAD_CANCEL_DISABLE = 0;
     PTHREAD_CANCEL_ENABLE = 1;
  { values for field 'attr_flags'...  }
     PTHREAD_EXPLICIT_SCHED = $0002;
  { as yet unsupported  }
     PTHREAD_INHERIT_SCHED = $0004;
  { values for field 'mattr_protocol'...  }
  { as yet unsupported  }
     PTHREAD_PRIO_PROTECT = -(1);
  { as yet unsupported  }
     PTHREAD_PRIO_INHERIT = 1;
  { as yet unsupported  }
     PTHREAD_PRIO_NONE = 0;
     PTHREAD_ONCE_INIT = 0;
  { values for field 'mattr_kind'...  }
     PTHREAD_MUTEX_NORMAL = $0000;
     PTHREAD_MUTEX_RECURSIVE = $0010;
  { as yet unsupported  }
     PTHREAD_MUTEX_ERRORCHECK = $0020;
  { as yet unsupported  }
     PTHREAD_MUTEX_DEFAULT = $0040;

type
   Ppthread_once_t = ^pthread_once_t;
   pthread_once_t = longint;

   Ppthread_key_t = ^pthread_key_t;
   pthread_key_t = longint;

   Ppthread_t = ^pthread_t;
   pthread_t = pointer; // longint;

{ turn on 1-byte packing...  }

   Ppthread_cond_t = ^pthread_cond_t;
   pthread_cond_t = record
        cond : pointer;
        spares : array[0..5] of longint;
     end;

   Ppthread_mutex_t = PRtlCriticalSection;
   pthread_mutex_t = TRtlCriticalSection;
   TpthreadMutex = TRtlCriticalSection;

   Ppthread_rwlock_t = ^pthread_rwlock_t;
   pthread_rwlock_t = record
        rwlock : pointer;
        reserved : array[0..2] of dword;
     end;

   Ppthread_attr_t = ^pthread_attr_t;
   pthread_attr_t = record
        attr_flags : dword;
        attr_scope : longint;
        attr_priority : longint;
        attr_detachstate : longint;
        attr_stackaddr : pointer;
        attr_stacksize : size_t;
        attr_policy : longint;
        attr_name : array[0..19] of char;
     end;

   Ppthread_condattr_t = ^pthread_condattr_t;
   pthread_condattr_t = record
        cattr_flags : dword;
        cattr_arg : pointer;
        cattr_spare1 : longint;
        cattr_spare2 : longint;
     end;

   Ppthread_mutexattr_t = ^pthread_mutexattr_t;
   pthread_mutexattr_t = record
        mattr_flags : dword;
        mattr_kind : longint;
        mattr_priority : longint;
        mattr_prioceiling : longint;
        mattr_protocol : longint;
        mattr_spares2 : array[0..5] of longint;
        mattr_name : array[0..31] of char;
     end;
   Ppthread_mutex_attr_t = Ppthread_mutexattr_t;
   pthread_mutex_attr_t = pthread_mutexattr_t;
   TMutexAttribute = pthread_mutex_attr_t;

   Ppthread_rwlockattr_t = ^pthread_rwlockattr_t;
   pthread_rwlockattr_t = record
        rwattr_flags : dword;
        rwattr_spare1 : longint;
        rwattr_priority : longint;
        rwattr_prioceiling : longint;
        rwattr_protocol : longint;
        rwattr_spares2 : array[0..5] of longint;
        rwattr_name : array[0..31] of char;
     end;

(** unsupported pragma#pragma pack()*)
{ pthread functions...  }


type TPTThreadStartFunction = function (_para1:pointer):pointer; cdecl;

function pthread_create(thread:Ppthread_t; attr:Ppthread_attr_t; start_routine:TPTThreadStartFunction; arg:pointer):longint;cdecl;external libc_nlm name 'pthread_create';
function pthread_cancel(thread:pthread_t):longint;cdecl;external libc_nlm name 'pthread_cancel';
function pthread_join(thread:pthread_t; status:Ppointer):longint;cdecl;external libc_nlm name 'pthread_join';
procedure pthread_exit(status:pointer);cdecl;external libc_nlm name 'pthread_exit';
function pthread_equal(t1:pthread_t; t2:pthread_t):longint;cdecl;external libc_nlm name 'pthread_equal';
procedure pthread_yield;cdecl;external libc_nlm name 'pthread_yield';
function pthread_kill(thread:pthread_t; sig:longint):longint;cdecl;external libc_nlm name 'pthread_kill';
function pthread_detach(thread:pthread_t):longint;cdecl;external libc_nlm name 'pthread_detach';

function pthread_once(once_control:Ppthread_once_t; init_routine:TCDeclProcedure ):longint;cdecl;external libc_nlm name 'pthread_once';
function pthread_self:pthread_t;cdecl;external libc_nlm name 'pthread_self';
function pthread_key_create(_para1:Ppthread_key_t; _destructor:TCDeclProc1PtrArg):longint;cdecl;external libc_nlm name 'pthread_key_create';
function pthread_key_delete(key:pthread_key_t):longint;cdecl;external libc_nlm name 'pthread_key_delete';
function pthread_getspecific(key:pthread_key_t):pointer;cdecl;external libc_nlm name 'pthread_getspecific';

function pthread_setspecific(key:pthread_key_t; value:pointer):longint;cdecl;external libc_nlm name 'pthread_setspecific';
function pthread_getschedparam(thread:pthread_t; policy:Plongint; param:Psched_param):longint;cdecl;external libc_nlm name 'pthread_getschedparam';

function pthread_setschedparam(thread:pthread_t; policy:longint; param:Psched_param):longint;cdecl;external libc_nlm name 'pthread_setschedparam';
function pthread_setcancelstate(state:longint; oldstate:Plongint):longint;cdecl;external libc_nlm name 'pthread_setcancelstate';
function pthread_setcanceltype(_type:longint; oldtype:Plongint):longint;cdecl;external libc_nlm name 'pthread_setcanceltype';
procedure pthread_testcancel;cdecl;external libc_nlm name 'pthread_testcancel';

function pthread_sigmask(how:longint; _set:Psigset_t; oset:Psigset_t):longint;cdecl;external libc_nlm name 'pthread_sigmask';
procedure pthread_cleanup_push(routine:TCDeclProc1PtrArg; arg:pointer);cdecl;external libc_nlm name 'pthread_cleanup_push';
procedure pthread_cleanup_pop(execute:longint);cdecl;external libc_nlm name 'pthread_cleanup_pop';
{ pthread attribute functions...  }
function pthread_attr_init(attr:Ppthread_attr_t):longint;cdecl;external libc_nlm name 'pthread_attr_init';
function pthread_attr_destroy(attr:Ppthread_attr_t):longint;cdecl;external libc_nlm name 'pthread_attr_destroy';

function pthread_attr_getdetachstate(attr:Ppthread_attr_t; detachstate:Plongint):longint;cdecl;external libc_nlm name 'pthread_attr_getdetachstate';
function pthread_attr_setdetachstate(attr:Ppthread_attr_t; detachstate:longint):longint;cdecl;external libc_nlm name 'pthread_attr_setdetachstate';

function pthread_attr_getinheritsched(attr:Ppthread_attr_t; inheritsched:Plongint):longint;cdecl;external libc_nlm name 'pthread_attr_getinheritsched';
function pthread_attr_setinheritsched(attr:Ppthread_attr_t; inheritsched:longint):longint;cdecl;external libc_nlm name 'pthread_attr_setinheritsched';
function pthread_attr_getschedparam(attr:Ppthread_attr_t; param:Psched_param):longint;cdecl;external libc_nlm name 'pthread_attr_getschedparam';
function pthread_attr_setschedparam(attr:Ppthread_attr_t; param:Psched_param):longint;cdecl;external libc_nlm name 'pthread_attr_setschedparam';
function pthread_attr_getschedpolicy(attr:Ppthread_attr_t; policy:Plongint):longint;cdecl;external libc_nlm name 'pthread_attr_getschedpolicy';
function pthread_attr_setschedpolicy(attr:Ppthread_attr_t; policy:longint):longint;cdecl;external libc_nlm name 'pthread_attr_setschedpolicy';
function pthread_attr_getscope(attr:Ppthread_attr_t; contentionscope:Plongint):longint;cdecl;external libc_nlm name 'pthread_attr_getscope';
function pthread_attr_setscope(attr:Ppthread_attr_t; contentionscope:longint):longint;cdecl;external libc_nlm name 'pthread_attr_setscope';
function pthread_attr_getstackaddr(attr:Ppthread_attr_t; stackaddr:Ppointer):longint;cdecl;external libc_nlm name 'pthread_attr_getstackaddr';
function pthread_attr_setstackaddr(attr:Ppthread_attr_t; stackaddr:pointer):longint;cdecl;external libc_nlm name 'pthread_attr_setstackaddr';
function pthread_attr_getstacksize(attr:Ppthread_attr_t; stacksize:Psize_t):longint;cdecl;external libc_nlm name 'pthread_attr_getstacksize';
function pthread_attr_setstacksize(attr:Ppthread_attr_t; stacksize:size_t):longint;cdecl;external libc_nlm name 'pthread_attr_setstacksize';
function pthread_attr_getname_np(attr:Ppthread_attr_t; name:Pchar; len:size_t; mbz:Ppointer):longint;cdecl;external libc_nlm name 'pthread_attr_getname_np';
function pthread_attr_setname_np(attr:Ppthread_attr_t; name:Pchar; mbz:pointer):longint;cdecl;external libc_nlm name 'pthread_attr_setname_np';
{ condition variable functions...  }

function pthread_cond_init(cond:Ppthread_cond_t; attr:Ppthread_condattr_t):longint;cdecl;external libc_nlm name 'pthread_cond_init';
function pthread_cond_destroy(cond:Ppthread_cond_t):longint;cdecl;external libc_nlm name 'pthread_cond_destroy';
function pthread_cond_signal(cond:Ppthread_cond_t):longint;cdecl;external libc_nlm name 'pthread_cond_signal';
function pthread_cond_broadcast(cond:Ppthread_cond_t):longint;cdecl;external libc_nlm name 'pthread_cond_broadcast';
function pthread_cond_wait(cond:Ppthread_cond_t; mutex:Ppthread_mutex_t):longint;cdecl;external libc_nlm name 'pthread_cond_wait';

function pthread_cond_timedwait(cond:Ppthread_cond_t; mutex:Ppthread_mutex_t; abstime:Ptimespec):longint;cdecl;external libc_nlm name 'pthread_cond_timedwait';
{ condition variable attribute functions...  }
function pthread_condattr_init(attr:Ppthread_condattr_t):longint;cdecl;external libc_nlm name 'pthread_condattr_init';
function pthread_condattr_destroy(attr:Ppthread_condattr_t):longint;cdecl;external libc_nlm name 'pthread_condattr_destroy';
function pthread_condattr_getpshared(attr:Ppthread_condattr_t; pshared:Plongint):longint;cdecl;external libc_nlm name 'pthread_condattr_getpshared';
function pthread_condattr_setpshared(attr:Ppthread_condattr_t; pshared:longint):longint;cdecl;external libc_nlm name 'pthread_condattr_setpshared';
{ mutex functions...  }

function pthread_mutex_init(mutex:Ppthread_mutex_t; attr:Ppthread_mutexattr_t):longint;cdecl;external libc_nlm name 'pthread_mutex_init';
function pthread_mutex_destroy(mutex:Ppthread_mutex_t):longint;cdecl;external libc_nlm name 'pthread_mutex_destroy';
function pthread_mutex_lock(mutex:Ppthread_mutex_t):longint;cdecl;external libc_nlm name 'pthread_mutex_lock';
function pthread_mutex_trylock(mutex:Ppthread_mutex_t):longint;cdecl;external libc_nlm name 'pthread_mutex_trylock';
function pthread_mutex_unlock(mutex:Ppthread_mutex_t):longint;cdecl;external libc_nlm name 'pthread_mutex_unlock';
{ mutex attribute functions...  }
function pthread_mutexattr_init(attr:Ppthread_mutexattr_t):longint;cdecl;external libc_nlm name 'pthread_mutexattr_init';
function pthread_mutexattr_destroy(attr:Ppthread_mutexattr_t):longint;cdecl;external libc_nlm name 'pthread_mutexattr_destroy';
function pthread_mutexattr_getprioceiling(attr:Ppthread_mutexattr_t; prioceiling:Plongint):longint;cdecl;external libc_nlm name 'pthread_mutexattr_getprioceiling';
function pthread_mutexattr_setprioceiling(attr:Ppthread_mutexattr_t; prioceiling:longint):longint;cdecl;external libc_nlm name 'pthread_mutexattr_setprioceiling';
function pthread_mutexattr_getprotocol(attr:Ppthread_mutexattr_t; protocol:Plongint):longint;cdecl;external libc_nlm name 'pthread_mutexattr_getprotocol';
function pthread_mutexattr_setprotocol(attr:Ppthread_mutexattr_t; protocol:longint):longint;cdecl;external libc_nlm name 'pthread_mutexattr_setprotocol';
function pthread_mutexattr_getpshared(attr:Ppthread_mutexattr_t; pshared:Plongint):longint;cdecl;external libc_nlm name 'pthread_mutexattr_getpshared';
function pthread_mutexattr_setpshared(attr:Ppthread_mutexattr_t; pshared:longint):longint;cdecl;external libc_nlm name 'pthread_mutexattr_setpshared';
function pthread_mutexattr_gettype(attr:Ppthread_mutexattr_t; kind:Plongint):longint;cdecl;external libc_nlm name 'pthread_mutexattr_gettype';
function pthread_mutexattr_settype(attr:Ppthread_mutexattr_t; kind:longint):longint;cdecl;external libc_nlm name 'pthread_mutexattr_settype';
{ reader-writer lock functions...  }
function pthread_rwlock_init(rwlp:Ppthread_rwlock_t; attr:Ppthread_rwlockattr_t):longint;cdecl;external libc_nlm name 'pthread_rwlock_init';
function pthread_rwlock_destroy(rwlp:Ppthread_rwlock_t):longint;cdecl;external libc_nlm name 'pthread_rwlock_destroy';
function pthread_rwlock_rdlock(rwlp:Ppthread_rwlock_t):longint;cdecl;external libc_nlm name 'pthread_rwlock_rdlock';
function pthread_rwlock_wrlock(rwlp:Ppthread_rwlock_t):longint;cdecl;external libc_nlm name 'pthread_rwlock_wrlock';
function pthread_rwlock_tryrdlock(rwlp:Ppthread_rwlock_t):longint;cdecl;external libc_nlm name 'pthread_rwlock_tryrdlock';
function pthread_rwlock_trywrlock(rwlp:Ppthread_rwlock_t):longint;cdecl;external libc_nlm name 'pthread_rwlock_trywrlock';
function pthread_rwlock_unlock(rwlp:Ppthread_rwlock_t):longint;cdecl;external libc_nlm name 'pthread_rwlock_unlock';
function pthread_rwlock_timedrdlock(rwlock:Ppthread_rwlock_t; abs_timeout:Ptimespec):longint;cdecl;external libc_nlm name 'pthread_rwlock_timedrdlock';
function pthread_rwlock_timedwrlock(rwlock:Ppthread_rwlock_t; abs_timeout:Ptimespec):longint;cdecl;external libc_nlm name 'pthread_rwlock_timedwrlock';
{ reader-writer lock attribute functions...  }
function pthread_rwlockattr_init(attr:Ppthread_rwlockattr_t):longint;cdecl;external libc_nlm name 'pthread_rwlockattr_init';
function pthread_rwlockattr_destroy(attr:Ppthread_rwlockattr_t):longint;cdecl;external libc_nlm name 'pthread_rwlockattr_destroy';
function pthread_rwlockattr_getpshared(attr:Ppthread_rwlockattr_t; pshared:Plongint):longint;cdecl;external libc_nlm name 'pthread_rwlockattr_getpshared';
function pthread_rwlockattr_setpshared(attr:Ppthread_rwlockattr_t; pshared:longint):longint;cdecl;external libc_nlm name 'pthread_rwlockattr_setpshared';
{ registering functions to execute at call to fork()...  }
function pthread_atfork(prepare, parent, child:TCDeclProcedure):longint;cdecl;external libc_nlm name 'pthread_atfork';


type
   Ppasswd = ^passwd;
   passwd = record
        pw_uid     : uid_t;     // user id
        pw_spare1  : uid_t;
        pw_gid     : gid_t;     // group id
        pw_spare2  : gid_t;
        pw_name    : Pchar;     // username
        pw_dir     : Pchar;     // home directory
        pw_shell   : Pchar;     // default shell
        pw_LDAPName: Pchar;     // real name
        pw_passwd  : Pchar;     // password (always nil)
        pw_gecos   : Pchar;     // general information
        pw_comment : Pchar;     // commend
        pw_change  : time_t;    // password change time
        pw_expire  : time_t;    // account expiration
        spare1 : array[0..2] of pointer;
        spare2 : array[0..3] of pointer;
     end;


//!! function geteuid:uid_t;cdecl;external libc_nlm name 'geteuid';
//!! function getuid:uid_t;cdecl;external libc_nlm name 'getuid';
function posixlogin(host:Pchar; port:longint; name:Pchar; pwd:Pchar; ctx:Pchar):longint;cdecl;external libc_nlm name 'posixlogin';
function posixlogout:longint;cdecl;external libc_nlm name 'posixlogout';

{$ifdef EnableLibcRegex}


// regex.h
type
   Pregoff_t = ^regoff_t;
   regoff_t = off_t;

   Preg_syntax_t = ^reg_syntax_t;
   reg_syntax_t = dword;

   Ps_reg_t = ^s_reg_t;
   s_reg_t = longint;

   Pactive_reg_t = ^active_reg_t;
   active_reg_t = dword;
{ number of parenthesized subexpressions  }

{ end pointer for REG_PEND                }
{ not visible                             }

   Pregex_t = ^regex_t;
   regex_t = record
        re_magic : longint;
        re_nsub : size_t;
        re_endp : Pchar;
        re_g : Pre_guts;
     end;

  const
     REG_BASIC = 0000;
     REG_EXTENDED = 0001;
     REG_ICASE = 0002;
     REG_NOSUB = 0004;
     REG_NEWLINE = 0010;
     REG_NOSPEC = 0020;
     REG_PEND = 0040;
     REG_DUMP = 0200;
  { regerror() flags  }
     REG_NOMATCH = 1;
     REG_BADPAT = 2;
     REG_ECOLLATE = 3;
     REG_ECTYPE = 4;
     REG_EESCAPE = 5;
     REG_ESUBREG = 6;
     REG_EBRACK = 7;
     REG_EPAREN = 8;
     REG_EBRACE = 9;
     REG_BADBR = 10;
     REG_ERANGE = 11;
     REG_ESPACE = 12;
     REG_BADRPT = 13;
     REG_EMPTY = 14;
     REG_ASSERT = 15;
     REG_INVARG = 16;
  { convert name to number (!)  }
     REG_ATOI = 255;
  { convert number to name (!)  }
     REG_ITOA = 0400;
  { regexec() flags  }
     REG_NOTBOL = 00001;
     REG_NOTEOL = 00002;
     REG_STARTEND = 00004;
  { tracing of execution        }
     REG_TRACE = 00400;
  { force large representation  }
     REG_LARGE = 01000;
  { force use of backref code   }
     REG_BACKR = 02000;


   Pregmatch_t = ^regmatch_t;
   regmatch_t = record
        rm_so : regoff_t;
        rm_eo : regoff_t;
     end;
{ regcomp() flags...  }
{ regerror() flags  }
{ regexec() flags  }

{$endif EnableLibcRegex}


// ringx.h

const PAGE_SIZE = 4096;


type RxCleanup_t = procedure (addr:pointer);cdecl;
{ preliminary (registration and clean-up)...  }

function RxIdentifyCode(startFuncAddr:pointer; endFuncAddrPlusOne:pointer; marshallingCodeReference:Plongint):longint;cdecl;external system_nlm name 'RxIdentifyCode';
function RxUnidentifyCode(marshallingCodeReference:longint):longint;cdecl;external system_nlm name 'RxUnidentifyCode';
function RxRegisterSysCall(marshalledFuncAddr:pointer; unmarshalledName:Pchar; argCount:longint):longint;cdecl;external system_nlm name 'RxRegisterSysCall';
function RxUnregisterSysCall(unmarshalledName:Pchar):longint;cdecl;external system_nlm name 'RxUnregisterSysCall';
{ mundane calls...  }
function RxLockMemory(addr:pointer; length:size_t):longint;cdecl;external system_nlm name 'RxLockMemory';
function RxUnlockMemory(addr:pointer; length:size_t):longint;cdecl;external system_nlm name 'RxUnlockMemory';
{ to handle address space fault and threads caught in kernel...  }
function RxRegisterKernelResource(_para1:pointer; _para2:RxCleanup_t):longint;cdecl;external system_nlm name 'RxRegisterKernelResource';
function RxRegisterThreadResource(_para1:pointer; _para2:RxCleanup_t):longint;cdecl;external system_nlm name 'RxRegisterThreadResource';
function RxUnregisterKernelResource(_para1:pointer):longint;cdecl;external system_nlm name 'RxUnregisterKernelResource';
function RxUnregisterThreadResource(_para1:pointer):longint;cdecl;external system_nlm name 'RxUnregisterThreadResource';
{ data; referenced to avoid compiler optimization of code including this  }
//??  var
//??     RxTmp : longint;cvar;public;
{ main working macros (buffers and structures, char and wide strings...  }


// semaphore.h

const
  SEM_VALUE_MAX = $7FFFFFFF;
// #define SEM_FAILED      ((sem_t *) 0)

type
   Psem_t = ^sem_t;
   sem_t = record
        sema : pointer;
        spares : array[0..5] of longint;
     end;

function sem_init(sem:Psem_t; pshared:longint; value:dword):longint;cdecl;external libc_nlm name 'sem_init';
function sem_destroy(sem:Psem_t):longint;cdecl;external libc_nlm name 'sem_destroy';
function sem_getvalue(sem:Psem_t; sval:Plongint):longint;cdecl;external libc_nlm name 'sem_getvalue';
function sem_post(sem:Psem_t):longint;cdecl;external libc_nlm name 'sem_post';
function sem_wait(sem:Psem_t):longint;cdecl;external libc_nlm name 'sem_wait';
function sem_trywait(sem:Psem_t):longint;cdecl;external libc_nlm name 'sem_trywait';
function sem_timedwait(sem:Psem_t; abstime:Ptimespec):longint;cdecl;external libc_nlm name 'sem_timedwait';


// setjmp.h

type
   _Pjmp_buf = ^_jmp_buf;
   _jmp_buf = double;

procedure __longjmp(_para1:_jmp_buf; _para2:longint);cdecl;external libc_nlm name '__longjmp';
function __setjmp(_para1:_jmp_buf):longint;cdecl;external libc_nlm name '__setjmp';

// synch.h

const
  USYNC_THREAD    = 0;
  USYNC_PROCESS   = 1;  { shared between processes (unsupported)}
  USYNC_DESTROYED = 2;  { deallocated object }

type
   //!! timespec = timestruc_t;
   Pbarrier = ^barrier;
   barrier = record
        reserved : array[0..7] of longint;
     end;
   barrier_t = barrier;
   Pbarrier_t = ^barrier_t;

   Pcond_t = ^cond_t;
   cond_t = pthread_cond_t;

   Pmutex_t = ^mutex_t;
   mutex_t = pthread_mutex_t;

   Prwlock_t = ^rwlock_t;
   rwlock_t = pthread_rwlock_t;

   Psema_t = ^sema_t;
   sema_t = sem_t;

function barrier_init(bp:Pbarrier_t; threads:longint):longint;cdecl;external libc_nlm name 'barrier_init';
procedure barrier_destroy(bp:Pbarrier_t);cdecl;external libc_nlm name 'barrier_destroy';
function barrier_wait(bp:Pbarrier_t):longint;cdecl;external libc_nlm name 'barrier_wait';
function barrier_inc(bp:Pbarrier_t):longint;cdecl;external libc_nlm name 'barrier_inc';
function barrier_dec(bp:Pbarrier_t):longint;cdecl;external libc_nlm name 'barrier_dec';
function cond_init(cvp:Pcond_t; _type:longint; arg:longint):longint;cdecl;external libc_nlm name 'cond_init';
function cond_destroy(cvp:Pcond_t):longint;cdecl;external libc_nlm name 'cond_destroy';
function cond_broadcast(cvp:Pcond_t):longint;cdecl;external libc_nlm name 'cond_broadcast';
function cond_signal(cvp:Pcond_t):longint;cdecl;external libc_nlm name 'cond_signal';
function cond_wait(cvp:Pcond_t; mp:Pmutex_t):longint;cdecl;external libc_nlm name 'cond_wait';
//!! function cond_timedwait(cvp:Pcond_t; mp:Pmutex_t; abstime:Ptimestruc_t):longint;cdecl;external libc_nlm name 'cond_timedwait';
function mutex_init(mp:Pmutex_t; _type:longint; arg:pointer):longint;cdecl;external libc_nlm name 'mutex_init';
function mutex_destroy(mp:Pmutex_t):longint;cdecl;external libc_nlm name 'mutex_destroy';
function mutex_lock(mp:Pmutex_t):longint;cdecl;external libc_nlm name 'mutex_lock';
function mutex_trylock(mp:Pmutex_t):longint;cdecl;external libc_nlm name 'mutex_trylock';
function mutex_unlock(mp:Pmutex_t):longint;cdecl;external libc_nlm name 'mutex_unlock';
function rwlock_init(rwlp:Prwlock_t; _type:longint; arg:pointer):longint;cdecl;external libc_nlm name 'rwlock_init';
function rwlock_destroy(rwlp:Prwlock_t):longint;cdecl;external libc_nlm name 'rwlock_destroy';
function rw_rdlock(rwlp:Prwlock_t):longint;cdecl;external libc_nlm name 'rw_rdlock';
function rw_wrlock(rwlp:Prwlock_t):longint;cdecl;external libc_nlm name 'rw_wrlock';
function rw_tryrdlock(rwlp:Prwlock_t):longint;cdecl;external libc_nlm name 'rw_tryrdlock';
function rw_trywrlock(rwlp:Prwlock_t):longint;cdecl;external libc_nlm name 'rw_trywrlock';
function rw_unlock(rwlp:Prwlock_t):longint;cdecl;external libc_nlm name 'rw_unlock';
function sema_init(sp:Psema_t; count:dword; _type:longint; arg:pointer):longint;cdecl;external libc_nlm name 'sema_init';
function sema_destroy(sp:Psema_t):longint;cdecl;external libc_nlm name 'sema_destroy';
function sema_post(sp:Psema_t):longint;cdecl;external libc_nlm name 'sema_post';
function sema_trywait(sp:Psema_t):longint;cdecl;external libc_nlm name 'sema_trywait';
function sema_wait(sp:Psema_t):longint;cdecl;external libc_nlm name 'sema_wait';

// syslog.h

{ log options for openlog()...  }
{ message facilities for openlog()...  }
{ for constructing 'maskpri' for setlogmask()...  }
{ values for priority argument of syslog()...  }
{ with no filename argument, syslogd.nlm uses this configuration file:  }
// termio.h
// termios.h
{
** Note: This is a very primitive and narrow adaptation of POSIX termios.h.
** Most of what is in this file is for completeness and to avoid locking
** termios.h interfaces off from advancing progressively as needed.}


  const
     NCCS = 32;
  { ^C  }
     INTR = $03;
  { ^D  }
     QUIT = $04;
  { ^Z  }
     SUSP = $1A;
  { currently unsupported                          }
     ECHO = $01;
  { currently unsupported                          }
     ECHOE = $02;
  { currently unsupported                          }
     ECHOK = $04;
  { currently unsupported                          }
     ECHONL = $08;
  { currently unsupported                          }
     ICANON = $10;
  { currently unsupported                          }
     IEXTEN = $20;
  { check against INTR, QUIT and SUSP (default)    }
     ISIG = $40;
  { currently unsupported                          }
     NOFLSH = $80;
  { c_iflag bits...  }
     IGNBRK = 0000001;
     BRKINT = 0000002;
     IGNPAR = 0000004;
     PARMRK = 0000010;
     INPCK = 0000020;
     ISTRIP = 0000040;
     INLCR = 0000100;
     IGNCR = 0000200;
     ICRNL = 0000400;
     IUCLC = 0001000;
     IXON = 0002000;
     IXANY = 0004000;
     IXOFF = 0010000;
     IMAXBEL = 0020000;
     CSIZE = 0000060;
     CS5 = 0000000;
     CS6 = 0000020;
     CS7 = 0000040;
     CS8 = 0000060;
     CSTOPB = 0000100;
     CREAD = 0000200;
     PARENB = 0000400;
     PARODD = 0001000;
     HUPCL = 0002000;
     CLOCAL = 0004000;
  { 'c_cc' control characters...  }
  { ^C                                             }
     VINTR = 1;
  { ^\   (unsupported)                             }
     VQUIT = 2;
  { del  (unsupported)                             }
     VERASE = 3;
  { ^D                                             }
     VEOF = 4;
  { @    (unsupported)                             }
     VKILL = 5;
  { currently unsupported                          }
     VTIME = 6;
  { currently unsupported                          }
     VMIN = 7;
  { ^q   (unsupported)                             }
     VSTART = 8;
  { ^s   (unsupported)                             }
     VSTOP = 9;
  { ^z                                             }
     VSUSP = 10;
  { '\0' (unsupported)                             }
     VEOL = 11;
  { 'optional_actions' causes action to be effectuated when:  }
  { immediately                                    }
     TCSANOW = 1;
  { output done                     (unsupported)  }
     TCSADRAIN = 2;
  { output done and input discarded (unsupported)  }
     TCSAFLUSH = 3;


{ c_iflag bits...  }
{ 'c_cc' control characters...  }
{ 'optional_actions' causes action to be effectuated when:  }
type
   Ptcflag_t = ^tcflag_t;
   tcflag_t = dword;

   Pcc_t = ^cc_t;
   cc_t = byte;

   Pspeed_t = ^speed_t;
   speed_t =  Longint;
   Const
     B0 = 0;
     B50 = 50;
     B75 = 75;
     B110 = 110;
     B134 = 134;
     B150 = 150;
     B200 = 200;
     B300 = 300;
     B600 = 600;
     B1200 = 1200;
     B1800 = 1800;
     B2400 = 2400;
     B4800 = 4800;
     B9600 = 9600;
     B19200 = 19200;
     B38400 = 38400;

{ ioctl() control packet...  }
{ input modes     --currently unused          }
{ output modes    --currently unused          }
{ control modes   --currently unused          }
{ local modes     --ISIG currently supported  }
{ input speed     --currently unused          }
{ output speed    --currently unused          }
{ line discipline --currently unused          }
{ control chars   --currently used            }
type
   Ptermios = ^termios;
   termios = record
        c_iflag : tcflag_t;
        c_oflag : tcflag_t;
        c_cflag : tcflag_t;
        c_lflag : tcflag_t;
        c_ispeed : speed_t;
        c_ospeed : speed_t;
        c_line : cc_t;
        c_spare1 : dword;
        c_cc : array[0..31] of cc_t;
        c_spare2 : dword;
        c_spare3 : dword;
        c_spare4 : dword;
        c_spare5 : dword;
     end;

{ POSIX-defined functions...  }

function tcgetattr(fildes:longint; tp:Ptermios):longint;cdecl;external libc_nlm name 'tcgetattr';
function tcsetattr(fildes:longint; optional_actions:longint; tp:Ptermios):longint;cdecl;external libc_nlm name 'tcsetattr';

// tgmath.h

{ syslog.h
  ==============================================================================}
  { log options for openlog()...  }
  { log the process ID with each message  }

  const
     LOG_PID = $00000001;
     LOG_CONS = $00000002;                   { log to the system console on error    }
     LOG_NDELAY = $00000004;                 { connect to syslog daemon immediately  }
     LOG_ODELAY = $00000008;                 { delay open until syslog() is called   }
     LOG_NOWAIT = $00000010;                 { do not wait for child processes       }
  { message facilities for openlog()...  }
     LOG_KERN = $00000001;                   { generated by system  }
     LOG_USER = $00000002;                   { generated by a process                }
     LOG_MAIL = $00000004;                   { generated by mail system              }
     LOG_NEWS = $00000008;                   { generated by news system              }
     LOG_UUCP = $00000010;                   { generated by UUCP system              }
     LOG_DAEMON = $00000020;                 { generated by daemon                   }
     LOG_AUTH = $00000040;                   { generated by auth. daemon             }
     LOG_CRON = $00000080;                   { generated by clock daemon             }
     LOG_LPR = $00000100;                    { generated by printer system           }
     LOG_LOCAL0 = $00000200;                 { local use                             }
     LOG_LOCAL1 = $00000400;
     LOG_LOCAL2 = $00000800;
     LOG_LOCAL3 = $00001000;
     LOG_LOCAL4 = $00002000;
     LOG_LOCAL5 = $00004000;
     LOG_LOCAL6 = $00008000;
     LOG_LOCAL7 = $00010000;
     LOG_UNUSED1 = $00020000;
     LOG_UNUSED2 = $00040000;
     LOG_UNUSED3 = $00080000;
     LOG_UNUSED4 = $00100000;
     LOG_UNUSED5 = $00200000;
     LOG_UNUSED6 = $00400000;                { unused                                }
     LOG_UNUSED7 = $00800000;                { unused                                }
  { for constructing 'maskpri' for setlogmask()...  }
  { was #define dname(params) para_def_expr }
  { argument types are unknown }
  { return type might be wrong }
//  function LOG_MASK(p : longint) : longint;
     LOG_EMERG = $01000000;
     LOG_ALERT = $02000000;                  { condition to correct immediately       }
     LOG_CRIT = $04000000;                   { critical condition                     }
     LOG_ERR = $08000000;                    { error message                          }
     LOG_WARNING = $10000000;                { warning message                        }
     LOG_NOTICE = $20000000;                 { condition requiring special handling   }
     LOG_INFO = $40000000;                   { general information message            }
     LOG_DEBUG = $80000000;                  { message useful for debugging programs  }
     P_cfgfile = 'sys:/etc/syslog.conf';     { with no filename argument, syslogd.nlm uses this configuration file:  }

  procedure closelog;cdecl;external libc_nlm name 'closelog';
  procedure openlog(ident:Pchar; logopt:longint; facility:longint);cdecl;external libc_nlm;
  function setlogmask(maskpri:longint):longint;cdecl;external libc_nlm name 'setlogmask';
{$ifndef DisableArrayOfConst}
  procedure syslog(priority:longint; message:Pchar; args:array of const);cdecl;external libc_nlm name 'syslog';
{$endif}
  procedure syslog(priority:longint; message:Pchar);cdecl;external libc_nlm name 'syslog';



// thread.h

  const
     THR_BOUND = $00000080;
     THR_DETACHED = PTHREAD_CREATE_DETACHED;
     THR_NEW_LWP = $FFFFFFFE;
     THR_SUSPENDED = $00000020;
     THR_DAEMON = $00000040;


{ type definitions...  }
type

//!!   Pthread_t = ^thread_t;
   thread_t = pthread_t;

//!!   Pthread_key_t = ^thread_key_t;
   thread_key_t = pthread_key_t;
{ prototypes...  }

type TThrStartRoutine = function (_para1:pointer):pointer; cdecl;
function thr_create(stack_based:pointer; stack_size:size_t;
           start_routine:TThrStartRoutine; arg:pointer; flags:longint;
           new_thr:Pthread_t):longint;cdecl;external libc_nlm name 'thr_create';
function thr_self:thread_t;cdecl;external libc_nlm name 'thr_self';
function thr_suspend(thr:thread_t):longint;cdecl;external libc_nlm name 'thr_suspend';
function thr_continue(thr:thread_t):longint;cdecl;external libc_nlm name 'thr_continue';
function thr_join(wait_for:thread_t; dead:Pthread_t; status:Ppointer):longint;cdecl;external libc_nlm name 'thr_join';
procedure thr_yield;cdecl;external libc_nlm name 'thr_yield';
procedure thr_exit(status:pointer);cdecl;external libc_nlm name 'thr_exit';
function thr_minstack:size_t;cdecl;external libc_nlm name 'thr_minstack';
function thr_kill(thr:thread_t; sig:longint):longint;cdecl;external libc_nlm name 'thr_kill';

function thr_sigsetmask(how:longint; _set:Psigset_t; oset:Psigset_t):longint;cdecl;external libc_nlm name 'thr_sigsetmask';
function thr_getconcurrency:longint;cdecl;external libc_nlm name 'thr_getconcurrency';
function thr_setconcurrency(new_level:longint):longint;cdecl;external libc_nlm name 'thr_setconcurrency';
function thr_getprio(thr:thread_t; pri:Plongint):longint;cdecl;external libc_nlm name 'thr_getprio';
function thr_setprio(thr:thread_t; pri:longint):longint;cdecl;external libc_nlm name 'thr_setprio';
function thr_keycreate(key:Pthread_key_t; _destructor:TCDeclProc1PtrArg):longint;cdecl;external libc_nlm name 'thr_keycreate';
function thr_getspecific(key:thread_key_t; value:Ppointer):longint;cdecl;external libc_nlm name 'thr_getspecific';
function thr_setspecific(key:thread_key_t; value:pointer):longint;cdecl;external libc_nlm name 'thr_setspecific';

// utf8.h

type
   Putf8_t = ^utf8_t;
   utf8_t = byte;
   PPutf8_t = ^Putf8_t;
// var __utf8width : array of byte;cvar;external;
{ prototypes...  }


function utf8width(ch:Putf8_t):size_t;cdecl;external libc_nlm name 'utf8width';
function utf8cat(tgt:Putf8_t; src:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8cat';
function utf8chr(_string:Putf8_t; ch:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8chr';
function utf8cmp(s1:Putf8_t; s2:Putf8_t):longint;cdecl;external libc_nlm name 'utf8cmp';
function utf8cpy(tgt:Putf8_t; src:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8cpy';
function utf8cspn(_string:Putf8_t; charset:Putf8_t):size_t;cdecl;external libc_nlm name 'utf8cspn';
function utf8dup(s:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8dup';
function utf8index(_string:Putf8_t; search:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8index';
function utf8len(_string:Putf8_t):size_t;cdecl;external libc_nlm name 'utf8len';
{$ifndef DisableArrayOfConst}
function utf8list(tgt:Putf8_t; s1:Putf8_t; args:array of const):Putf8_t;cdecl;external libc_nlm name 'utf8list';
{$endif}
function utf8list(tgt:Putf8_t; s1:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8list';
function utf8lwr(_string:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8lwr';
function utf8ncat(tgt:Putf8_t; src:Putf8_t; n:size_t):Putf8_t;cdecl;external libc_nlm name 'utf8ncat';
function utf8ncmp(s1:Putf8_t; s2:Putf8_t; n:size_t):longint;cdecl;external libc_nlm name 'utf8ncmp';
function utf8ncpy(tgt:Putf8_t; src:Putf8_t; n:size_t):Putf8_t;cdecl;external libc_nlm name 'utf8ncpy';
function utf8next(_string:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8next';
function utf8nlen(_string:Putf8_t; nbytes:size_t):size_t;cdecl;external libc_nlm name 'utf8nlen';
function utf8nset(base:Putf8_t; ch:Putf8_t; n:size_t):Putf8_t;cdecl;external libc_nlm name 'utf8nset';
function utf8pbrk(s1:Putf8_t; s2:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8pbrk';
function utf8prev(_string:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8prev';
function utf8rchr(_string:Putf8_t; ch:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8rchr';
function utf8rev(_string:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8rev';
function utf8size(_string:Putf8_t):size_t;cdecl;external libc_nlm name 'utf8size';
function utf8spn(_string:Putf8_t; charset:Putf8_t):size_t;cdecl;external libc_nlm name 'utf8spn';
function utf8str(as1:Putf8_t; as2:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8str';
function utf8tolower(_string:Putf8_t; dest:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8tolower';
function utf8tok_r(_string:Putf8_t; sepset:Putf8_t; lasts:PPutf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8tok_r';
function utf8toupper(_string:Putf8_t; dest:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8toupper';
function utf8upr(_string:Putf8_t):Putf8_t;cdecl;external libc_nlm name 'utf8upr';
function isutf8ascii(_string:Putf8_t):longint;cdecl;external libc_nlm name 'isutf8ascii';
function isutf8digit(_string:Putf8_t):longint;cdecl;external libc_nlm name 'isutf8digit';
function isutf8xdigit(_string:Putf8_t):longint;cdecl;external libc_nlm name 'isutf8xdigit';
function isutf8space(_string:Putf8_t):longint;cdecl;external libc_nlm name 'isutf8space';
function isutf8alnum(_string:Putf8_t):longint;cdecl;external libc_nlm name 'isutf8alnum';
function isutf8alpha(_string:Putf8_t):longint;cdecl;external libc_nlm name 'isutf8alpha';
function isutf8lower(_string:Putf8_t):longint;cdecl;external libc_nlm name 'isutf8lower';
function isutf8upper(_string:Putf8_t):longint;cdecl;external libc_nlm name 'isutf8upper';


// utime.h
{ turn on 1-byte packing...  }

{ access time  }
{ modification time  }
type
   Putimbuf = ^Tutimbuf;
   Tutimbuf = record
        actime  : time_t;
        modtime : time_t;
     end;
   utimbuf = Tutimbuf;

(** unsupported pragma#pragma pack()*)



function utime(path:Pchar; times:Putimbuf):longint;cdecl;external libc_nlm name 'utime';
function utime(path:Pchar; var times:Tutimbuf):longint;cdecl;external libc_nlm name 'utime';


// utsname.h
// wctype.h
type
   Pwctype_t = ^wctype_t;
   wctype_t =  Longint;
Const
   WCTYPE_UNDEF = 0;
   WCTYPE_ALNUM = 1;
   WCTYPE_ALPHA = 2;
   WCTYPE_BLANK = 3;
   WCTYPE_CNTRL = 4;
   WCTYPE_DIGIT = 5;
   WCTYPE_GRAPH = 6;
   WCTYPE_LOWER = 7;
   WCTYPE_PRINT = 8;
   WCTYPE_PUNCT = 9;
   WCTYPE_SPACE = 10;
   WCTYPE_UPPER = 11;
   WCTYPE_XDIGIT = 12;

type
   Pwctrans_t = ^wctrans_t;
   wctrans_t = wchar_t;

function iswalnum(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswalnum';
function iswalpha(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswalpha';
function iswblank(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswblank';
function iswcntrl(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswcntrl';
function iswdigit(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswdigit';
function iswgraph(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswgraph';
function iswlower(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswlower';
function iswprint(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswprint';
function iswpunct(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswpunct';
function iswspace(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswspace';
function iswupper(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswupper';
function iswxdigit(_para1:longint):longint;cdecl;external libc_nlm name 'iswxdigit';
function towlower(_para1:wint_t):wint_t;cdecl;external libc_nlm name 'towlower';
function towupper(_para1:wint_t):wint_t;cdecl;external libc_nlm name 'towupper';
function iswctype(_para1:wint_t; _para2:wctype_t):longint;cdecl;external libc_nlm name 'iswctype';

function wctype(_para1:Pchar):wctype_t;cdecl;external libc_nlm name 'wctype';
function towctrans(_para1:wint_t; _para2:wctrans_t):wint_t;cdecl;external libc_nlm name 'towctrans';

function wctrans(_para1:Pchar):wctrans_t;cdecl;external libc_nlm name 'wctrans';
function iswascii(_para1:wint_t):longint;cdecl;external libc_nlm name 'iswascii';


// windows.h


  const
     DLL_ACTUAL_DLLMAIN = 0;
     DLL_NLM_STARTUP = 1;        { start-up, 'lpvReserved' is NLM handle  }
     DLL_NLM_SHUTDOWN = 2;       { unload, 'lpvReserved' is NLM handle    }
     { standard DllMain() messages...  }
     DLL_PROCESS_ATTACH = 3;     { DLL "loaded" into application space    }
     DLL_THREAD_ATTACH = 4;      { application creating new thread        }
     DLL_THREAD_DETACH = 5;      { application thread exiting cleanly     }
     DLL_PROCESS_DETACH = 6;     { DLL "unloaded" from application space  }
     TLS_MINIMUM_AVAILABLE = 64; { minumum number of keys available       }


type

   PLPVOID = ^LPVOID;
   LPVOID = void;

   PBOOL = ^BOOL;
   BOOL = longint;

   PHMODULE = ^HMODULE;
   //HMODULE = void;

   PLPCTSTR = ^LPCTSTR;
   LPCTSTR = char;

   _PHINSTANCE = ^_HINSTANCE;
   _HINSTANCE = void;
{ Win32 DLL solutions for dynamic NLM libraries on NetWare...  }

function GetLastError:dword;cdecl;external libc_nlm name 'GetLastError';
procedure SetLastError(dwErrCode:dword);cdecl;external libc_nlm name 'SetLastError';
function FreeLibrary(hModule:HMODULE):BOOL;cdecl;external libc_nlm name 'FreeLibrary';
function LoadLibrary(lpFileName:LPCTSTR):HMODULE;cdecl;external libc_nlm name 'LoadLibrary';
{
** Prototype for libraries writing their own start-up and shut-down code.
** This is not an interface, but only a prototype for code furnished by the
** NLM library.
 }
function DllMain(hinstDLL:_HINSTANCE; fdwReason:dword; lpvReserve:LPVOID):BOOL;cdecl;external libc_nlm name 'DllMain';


// xmalloc.h

function xcalloc(_para1,_para2:size_t):pointer;cdecl;external libc_nlm name 'xcalloc';
procedure xfree(_para1:pointer);cdecl;external libc_nlm name 'xfree';
function xmalloc(_para1:size_t):pointer;cdecl;external libc_nlm name 'xmalloc';
function xrealloc(_para1:pointer; _para2:size_t):pointer;cdecl;external libc_nlm name 'xrealloc';


{$ifndef INCLUDED_FROM_SYSTEM}

implementation

function bisecond(var a : Tdos_tm) : word;
begin
   bisecond:=(a.flag0 and bm_dos_tm_bisecond) shr bp_dos_tm_bisecond;
end;

procedure set_bisecond(var a : Tdos_tm; __bisecond : word);
begin
   a.flag0:=a.flag0 or ((__bisecond shl bp_dos_tm_bisecond) and bm_dos_tm_bisecond);
end;

function minute(var a : Tdos_tm) : word;
begin
   minute:=(a.flag0 and bm_dos_tm_minute) shr bp_dos_tm_minute;
end;

procedure set_minute(var a : Tdos_tm; __minute : word);
begin
   a.flag0:=a.flag0 or ((__minute shl bp_dos_tm_minute) and bm_dos_tm_minute);
end;

function hour(var a : Tdos_tm) : word;
begin
   hour:=(a.flag0 and bm_dos_tm_hour) shr bp_dos_tm_hour;
end;

procedure set_hour(var a : Tdos_tm; __hour : word);
begin
   a.flag0:=a.flag0 or ((__hour shl bp_dos_tm_hour) and bm_dos_tm_hour);
end;

function day(var a : Tdos_tm) : word;
begin
   day:=(a.flag0 and bm_dos_tm_day) shr bp_dos_tm_day;
end;

procedure set_day(var a : Tdos_tm; __day : word);
begin
   a.flag0:=a.flag0 or ((__day shl bp_dos_tm_day) and bm_dos_tm_day);
end;

function month(var a : Tdos_tm) : word;
begin
   month:=(a.flag0 and bm_dos_tm_month) shr bp_dos_tm_month;
end;

procedure set_month(var a : Tdos_tm; __month : word);
begin
   a.flag0:=a.flag0 or ((__month shl bp_dos_tm_month) and bm_dos_tm_month);
end;

function year(var a : Tdos_tm) : word;
begin
   year:=(a.flag0 and bm_dos_tm_year) shr bp_dos_tm_year;
end;

procedure set_year(var a : Tdos_tm; __year : word);
begin
   a.flag0:=a.flag0 or ((__year shl bp_dos_tm_year) and bm_dos_tm_year);
end;

end.

{$endif}