/*
 * This is an example for using GCI. Enjoy, copy and paste!
 * We have three different execution paths for Unix, Win32 and OS/2.
 * For some interpreters, most notable the builtin interpreter of OS/2, you
 * have to rename this file to gci-try.cmd
 */
parse version version
say "Your REXX interpreter is" version

/******************************************************************************
 * Try to detect the system to show several things.
 */
parse var version "REXX-"ipret"_".
IsRegina = 0
if ipret = "Regina" then do
   IsRegina = 1
   uname = uname('S')
   options NOEXT_COMMANDS_AS_FUNCS
   end

parse source system . source

system = translate(system)
if left(system, 3) = "WIN" then do
   library = "GCI.DLL"
   CLib = "MSVCRT"
   system = "WIN"
   end
else if system = "OS/2" then do
   library = "GCI.DLL"
   system = "OS/2"
   end
else do
   library = "libgci.so"
   tr = trace()
   trace o
   "test `uname -s` = 'SunOS'"
   if RC = 0 then do
      CLib = "libc.so.1"
      MathLib = "m"
      end
   else do
      if IsRegina & Left(uname, 6) = 'CYGWIN' then do
         CLib = "cygwin1.dll"
         MathLib = "cygwin1.dll"
         end
      else do
         CLib = "libc.so.6"
         MathLib = "m"
         end
      end
   trace value tr
   end

/*
 * Check for a builtin RxFuncDefine. Call it with errorneous arguments and
 * expect a simple error if installed and a syntax signal if unknown.
 */
InternalGCI = 0
signal on syntax name NotInstalled
x = "X"
x. = "X"
h = RxFuncDefine(x,x,x,x)
if h \= 0 & h \= 10005 & DataType(h, "NUM") then
   InternalGCI = 1
NotInstalled:
drop GCI_RC

signal on syntax
if \InternalGCI then do
   /*
    * The DLL may have been loaded already. Prevent bugs at this stage.
    */
   call RxFuncDrop RxFuncDefine
   call RxFuncDrop GciPrefixChar
   call RxFuncDrop GciFuncDrop
   if RxFuncadd(RxFuncDefine, "gci", "RxFuncDefine") \= 0 then do
      msg = "Can't load RxFuncDefine of" library
      if IsRegina then
         msg = msg || ":" RxFuncErrMsg()
      say msg
      return 1
      end
   if RxFuncadd(GciFuncDrop, "gci", "GciFuncDrop") \= 0 then do
      msg = "Can't load GciFuncDrop of" library
      if IsRegina then
         msg = msg || ":" RxFuncErrMsg()
      say msg
      return 1
      end
   call RxFuncadd GciPrefixChar, "gci", "GciPrefixChar"
   say "Your interpreter has no internal support of GCI"
   end
else
   say "Your interpreter has internal support of GCI"

say ""

/******************************************************************************
 * After the prelimnaries try to use the GCI.
 */
if system = "OS/2" then signal useOS2

say "Trying to copy string 'hello' to a string 'world' using the C library"
stem.calltype = cdecl
stem.0 = 2
stem.1.name = "Target"
stem.1.type = indirect string80
stem.2.name = "Source"
stem.2.type = indirect string80
stem.return.type = ""           /* We are not interested in the return value */

call funcDefine strcpy, CLib, "strcpy", stem

stem.1.name = "Target"
stem.1.value = "world"
stem.2.name = "Source"
stem.2.value = "hello"
call strcpy stem
say stem.1.name"="stem.1.value stem.2.name"="stem.2.value

call funcDrop strcpy
say ""
/******************************************************************************
 * Check if v1.1 GciPrefixChar works.
 */

version = 1.0
signal on syntax name v1.0
say "Trying to detect and use v1.1 features (same result as above expected)"
oldChar = GciPrefixChar('!')
signal on syntax
stem.!calltype = cdecl
stem.0 = 2
stem.1.!name = "Target"
stem.1.!type = indirect string80
stem.2.!name = "Source"
stem.2.!type = indirect string80
stem.!return.!type = ""

call funcDefine strcpy, CLib, "strcpy", stem

stem.1.!name = "Target"
stem.1.!value = "world"
stem.2.!name = "Source"
stem.2.!value = "hello"
call strcpy stem
say stem.1.!name"="stem.1.!value stem.2.name"="stem.2.!value

call funcDrop strcpy
say ""
call GciPrefixChar oldChar
drop oldChar c1 c2
version = 1.1
v1.0:
/******************************************************************************
 * Use the "as function" feature
 */
say "Trying to find the last occurcance of '.' in 'James F. Cooper' using the C"
say "library using the 'as function' feature"
stem.calltype = cdecl as function
stem.0 = 2
stem.1.name = "String"
stem.1.type = indirect string80
stem.2.name = "Character"
stem.2.type = char
stem.return.type = indirect string80

call funcDefine strrchr, CLib, "strrchr", stem

stem.1.name = "Target"
stem.1.value = "James F. Cooper"
stem.2.name = "Character"
stem.2.value = .
say "The last dot starts at '" || strrchr( stem ) || "'"
say ""
say "Trying to find the last occurcance of '.' in 'James Cooper' using the C lib"
say "We expect a NULL pointer which leads to a dropped value which becomes ''"
say "for a return value."

stem.1.name = "Target"
stem.1.value = "James Cooper"
say "The last dot starts at '" || strrchr( stem ) || "'"

call funcDrop strrchr
say ""
/******************************************************************************
 * Use the "with parameters as function" feature.
 * Note that you must omit "as function" if the return value doesn't exist.
 * We use separate functions for Windows and unix.
 */
if system = "WIN" then signal useWindows

say "Trying to use the math library to compute some natural logarithms"
stem.calltype = cdecl with parameters as function
stem.0 = 1
stem.1.name = "X"
stem.1.type = float128
stem.return.type = float128
call RxFuncDefine logl, MathLib, "logl", stem
if RESULT \= 0 then do
   stem.1.type = float96
   stem.return.type = float96
   call RxFuncDefine logl, MathLib, "logl", stem
   end
if RESULT \= 0 then do
   stem.1.type = float64
   stem.return.type = float64
   call RxFuncDefine logl, MathLib, "log", stem
   end
if RESULT \= 0 then do
   if IsRegina & InternalGCI then
      say "Error, code" RESULT || ":" RxFuncErrMsg()
   else
      say "Error, code" RESULT || ":" GCI_RC
   return 1
   end

say "some logarithms"
do i = 1 to 5
   say "log("i")="logl(i)
   end

call funcDrop logl
say ""
/*******************************/
say "Using a structure and checking the file system's size."
say "You may look into the source."
/*
 * This examples has removed all unnecessary stuff.
 */
stem.calltype = cdecl as function
stem.0 = 2
stem.1.type = indirect string256
stem.2.type = indirect container
stem.2.0 = 10                                /* statvfs64 */
stem.2.1.type    = unsigned                  /* bsize */
stem.2.2.type    = unsigned                  /* frsize */
stem.2.3.type    = unsigned64                /* blocks */
stem.2.4.type    = unsigned64                /* bfree */
stem.2.5.type    = unsigned64                /* bavail */
stem.2.6.type    = unsigned64                /* files */
stem.2.7.type    = unsigned64                /* ffree */
stem.2.8.type    = unsigned64                /* favail */
stem.2.9.type    = unsigned                  /* fsid */
stem.2.10.type   = string256                /* indifferent between unices */
stem.return.type = integer

call funcDefine statvfs, CLib, "statvfs64", stem

args. = 0
args.1.value = source
args.2.value = 10    /* otherwise the argument becomes NULL */
if statvfs( args ) \= -1 then do
   say "statvfs-info of" source
   say "block size =" args.2.1.value "byte"
   size = trunc(args.2.3.value * args.2.1.value / (1024 * 1024))
   avail = trunc(args.2.5.value * args.2.1.value / (1024 * 1024))
   say "file system size =" size"MB, available =" avail"MB"
   say "file nodes =" args.2.6.value "available =" args.2.8.value
   say "sid =" args.2.9.value
   end
else
   say "Sorry, '"source"' not found."

call funcDrop statvfs
say ""
/*******************************/

say "We use qsort of the C library for sorting some strings using arrays."
/*
 * This examples has removed all unnecessary stuff.
 * We need a sorting routine. Without callbacks we have to use one of a
 * library. "strcmp" is a good example. We have to play with the dynamic
 * link loader.
 * The strategy is:
 * Load the loader functions (dlopen, dlsym, dlclose)
 * Load the compare routine (strcmp) using the loader functions
 * Load the sorting routine (qsort) and do the sort
 * Additional sort operations may have to redefine qsort only.
 */
stem.calltype = cdecl with parameters as function
stem.0 = 2
stem.1.type = indirect string256
stem.2.type = integer
stem.return.type = integer       /* handle, but who cares? */
call funcDefine dlopen, "dl", "dlopen", stem

stem.calltype = cdecl with parameters as function
stem.0 = 2
stem.1.type = integer            /* handle */
stem.2.type = indirect string256
stem.return.type = integer       /* entry point address, but who cares? */
call funcDefine dlsym, "dl", "dlsym", stem

stem.calltype = cdecl with parameters as function
stem.0 = 1
stem.1.type = integer            /* handle */
stem.return.type = integer
call funcDefine dlclose, "dl", "dlclose", stem

CLibHandle = dlopen( CLib, 1 /* RTLD_LAZY */ )
if CLibHandle = 0 then do
   say "dlopen() can't load" CLib
   return 1
   end

strcmp = dlsym( CLibHandle, "strcmp" )
if strcmp = 0 then do
   say "dlsym() can't relocate strcmp()"
   return 1
   end

stem.calltype = cdecl
stem.0 = 4
stem.1.type = indirect array
stem.1.0 = 3
stem.1.1.type = string95
stem.2.type = integer
stem.3.type = integer
stem.4.type = integer
stem.return.type = ""
call funcDefine qsort10, CLib, "qsort", stem

args.0 = 4
args.1.value = 3
args.1.1.value = "Ann"
args.1.2.value = "Charles"
args.1.3.value = "Betty"
args.2.value = 3
args.3.value = 96
args.4.value = strcmp
say "Sorting (" args.1.1.value args.1.2.value args.1.3.value ") ..."
call qsort10 args
say "Sorted values are (" args.1.1.value args.1.2.value args.1.3.value ")"

call dlclose CLibHandle
call funcDrop qsort
call funcDrop dlclose
call funcDrop dlsym
call funcDrop dlopen
say ""
call accessStructTm
return 0


/***************************************************/
useWindows:
stem.calltype = stdcall with parameters as function
stem.0 = 4
stem.1.name = "HWND"
stem.1.type = unsigned
stem.2.name = "Text"
stem.2.type = indirect string1024
stem.3.name = "Caption"
stem.3.type = indirect string1024
stem.4.name = "Type"
stem.4.type = unsigned
stem.return.type = integer

call funcDefine messagebox, "user32", "MessageBoxA", stem

MB_YESNO_INFO = x2d(44)
if messagebox( 0, "Do you love this rocking GCI?", "GCI", MB_YESNO_INFO ) = 6 then
   say "Yes, you're right, GCI is cool."
else
   say "No, you're kidding! GCI is cool."

call funcDrop messagebox
say ""
/*******************************/
say "We operate on containers and check this file's date."
say "You may look into the source."
/*
 * This examples has removed all unnecessary stuff.
 */
stem.calltype = stdcall as function
stem.0 = 2
stem.1.type = indirect string256
stem.2.type = indirect container
stem.2.0 = 8                                 /* WIN32_FIND_DATA */
stem.2.1.type = unsigned                     /* FileAttributes */
stem.2.2.type = unsigned64                   /* Creation */
stem.2.3.type = unsigned64                   /* Access */
stem.2.4.type = unsigned64                   /* Write */
stem.2.5.type = unsigned64                   /* Size */
stem.2.6.type = unsigned64                   /* Reserved */
stem.2.7.type = string259                    /* FileName */
stem.2.8.type = string13                     /* AlternateFileName */
stem.return.type = integer

stem2.calltype = stdcall with parameters
stem2.0 = 1
stem2.1.type = integer
stem2.return.type = ""

call funcDefine findfirstfile, "kernel32", "FindFirstFileA", stem

call funcDefine findclose, "kernel32", "FindClose", stem2

args. = 0
args.1.value = source
args.2.value = 8    /* otherwise the argument becomes NULL */
handle = findfirstfile( args )
if handle \= -1 then do
   say "argument's name="source
   say "filename="args.2.7.value
   say "8.3-name="args.2.8.value
   numeric digits 40
   filetime = args.2.4.value
   d = /*second*/ 1000*1000*10   *   /*seconds per day*/ 60*60*24
   daypart = trunc(filetime / d)
   date = date( 'N', daypart + date('B', 16010101, 'S'), 'B')
   ns = filetime - daypart * d
   secs = ns % (10*1000*1000)
   fract = ns // (10*1000*1000)
   time = time('N', secs, 'S') || "." || right(fract, 7, '0')
   say "ns from 1.1.1601="filetime "= GMT," date || "," time
   numeric digits 9
   call findclose handle
   end
else
   say "Sorry, '"source"' not found."

call funcDrop findfirstfile
call funcDrop findclose
say ""
call accessStructTm

return 0

/***************************************************/
accessStructTm: procedure expose IsRegina InternalGCI CLib version
if version < 1.1 then
   return
say "Finally, we use the LIKE keyword and check the number of the week."
say "You may look into the source, we use a PROCEDURE and v1.1 specific code."
/*
 * This examples has removed all unnecessary stuff.
 */
tm.0 = 10
tm.1.type = integer /* tm_sec */
tm.2.type = integer /* tm_min */
tm.3.type = integer /* tm_hour */
tm.4.type = integer /* tm_mday */
tm.5.type = integer /* tm_mon */
tm.6.type = integer /* tm_year */
tm.7.type = integer /* tm_wday */
tm.8.type = integer /* tm_yday */
tm.9.type = integer /* tm_isdst */
tm.10.type = string 32 /* reserved stuff sometimes used by the OS */

time_t.0 = 1
time_t.1.type = integer64 /* SURPRISE! some systems may use 64 bit data types
                           * already. We don't have problems with this,
                           * because we use double buffering.
                           */

stem.calltype = cdecl
stem.0 = 1
stem.1.type = indirect container like time_t
stem.return.type = ""
call funcDefine _time, CLib, "time", stem

stem.calltype = cdecl
stem.0 = 1
stem.1.type = indirect container like time_t
stem.return.type = indirect container like tm
call funcDefine localtime, CLib, "localtime", stem

stem.calltype = cdecl
stem.0 = 4
stem.1.type = indirect string256  /* dest */
stem.2.type = unsigned            /* size(dest) */
stem.3.type = indirect string256  /* template */
stem.4.type = indirect container like tm
stem.return.type = unsigned
call funcDefine strftime, CLib, "strftime", stem

time_val.1.value = 1
time_val.1.1.value = 1
call _time time_val

lct.1.value = 1
lct.1.1.value = time_val.1.1.value
call localtime lct

strf.1.value = ""
strf.2.value = 256
strf.3.value = "%A"
strf.4.value = lct.return.value
do i = 1 to 10
   strf.4.i.value = lct.return.i.value
   end
call strftime strf
dayname = strf.1.value

strf.3.value = "%B"
call strftime strf
monthname = strf.1.value

strf.3.value = "%U"
call strftime strf
week!Sun = strf.1.value

strf.3.value = "%W"
call strftime strf
week!Mon = strf.1.value

if week!Mon = week!Sun then
   add = "."
else
   add = " if you count Monday as the first day of the week. Otherwise it " ||,
         "is the" week!Sun || ". week."
say "Today is a" dayname "in" monthname || ". We have the" week!Mon || ". week" || add
say
call funcDrop strftime
call funcDrop localtime
call funcDrop _time

return

/***************************************************/
useOS2:
say "Checking the high precision system timer."
stem.calltype = stdcall
stem.0 = 1
stem.1.name = "Frequency"
stem.1.type = indirect unsigned
stem.return.type = "unsigned"

call funcDefine DosTmrQueryFreq, "doscalls", "#362", stem

stem.1.name = "Frequency"
stem.1.value = 0        /* don't raise NOVALUE */

call DosTmrQueryFreq stem
if stem.return.value \= 0 then
   say "Error" stem.return.value "while using DosTmrQueryFreq."
else
   say "The timer has a frequency of" stem.1.value "Hz"

call funcDrop DosTmrQueryFreq
say ""
/*******************************/
say "You should hear your beeper."
/*
 * Use the "with parameters" feature.
 */
stem.calltype = stdcall with parameters
stem.0 = 2
stem.1.name = "Frequency"
stem.1.type = unsigned
stem.2.name = "Duration"
stem.2.type = unsigned
stem.return.type = ""           /* We are not interested in the return value */

call funcDefine DosBeep, "doscalls", "#286", stem

do i = 500 to 3000 by 100
   call DosBeep i, 10
   end

call funcDrop DosBeep
say ""
/*******************************/
say "Checking the installed codepages."
/*
 * Use the "as function" feature.
 */
stem.calltype = stdcall as function
stem.0 = 3
stem.1.name = "cb"
stem.1.type = unsigned
stem.2.name = "arCP"
stem.2.type = indirect array
stem.2.0 = 25
stem.2.1.type = unsigned
stem.3.name = "pcCP"
stem.3.type = indirect unsigned
stem.return.type = "unsigned"

call funcDefine DosQueryCp, "doscalls", "#291", stem

drop stem.
stem. = 0 /* NOVALUE should not happen */
stem.0 = 3
stem.1.name = "cb"
stem.1.value = 100
stem.2.name = "arCP"
stem.2.value = 25
stem.3.name = "pcCP"
if DosQueryCp( stem ) = 0 then do
   say "current codepage:" stem.2.1.value
   do i = 2 to stem.3.value / 4
      say "prepared codepage:" stem.2.i.value
      end
   end
else
   say "Error calling DosQueryCp."

call funcDrop DosQueryCp
say ""
/*******************************/
say "Examining the file system on" left( source, 2 )
/*
 * Use the "as function" feature.
 */
stem.calltype = stdcall as function
stem.0 = 4
stem.1.name = "disknum"
stem.1.type = unsigned
stem.2.name = "infolevel"
stem.2.type = unsigned
stem.3.name = "pBuf"
stem.3.type = indirect container
stem.3.0 = 5
stem.3.1.name = "idFileSystem"
stem.3.1.type = unsigned
stem.3.2.name = "cSectorUnit"
stem.3.2.type = unsigned
stem.3.3.name = "cUnit"
stem.3.3.type = unsigned
stem.3.4.name = "cUnitAvail"
stem.3.4.type = unsigned
stem.3.5.name = "cbSector"
stem.3.5.type = unsigned16
stem.4.name = "cbBuf"
stem.4.type = unsigned
stem.return.type = "unsigned"

call funcDefine DosQueryFSInfo, "doscalls", "#278", stem

drop stem.
stem. = 0 /* NOVALUE should not happen */
stem.0 = 3
stem.1.name = "disknum"
stem.1.value = c2d( translate( left( source, 1 ) ) ) - c2d( 'A' ) + 1
stem.2.name = "infolevel"
stem.2.value = 1
stem.3.name = "pBuf"
stem.3.value = 5
stem.4.name = "cbBuf"
stem.4.value = 18
if DosQueryFSInfo( stem ) = 0 then do
   cluster = stem.3.2.value * stem.3.5.value
   say "Total size:" showFileSize( cluster*stem.3.3.value )
   say "Free  size:" showFileSize( cluster*stem.3.4.value )
   end
else
   say "Error calling DosQueryFSInfo."

call funcDrop DosQueryFSInfo
say ""
return 0

/*****/
showFileSize: procedure
   suffix = "byte"
   size = arg(1)
   suffixes = "KB MB GB TB"
   do i = 1 to words( suffixes )
      if size < 1024 then
         leave
      suffix = word( suffixes, i )
      size = size / 1024
      end
   if size >= 100 then
      size = format( size, , 0 )
   else if size >= 10 then
      size = format( size, , 1 )
   else
      size = format( size, , 2 )
   return size suffix

/*****************************************************************************/
syntax:
   /*
    * Not all interpreters are ANSI compatible.
    */
   code = .MN
   if code = '.MN' then
      code = RC
   if datatype( SIGL_FUNCDEFINE, "W" ) then
      SIGL = SIGL_FUNCDEFINE
   say "Error" code "in line" SIGL || ":" condition('D')
   say "GCI_RC=" || GCI_RC
   exit 0

/*****************************************************************************/
funcDrop:
   /*
    * Drops one defined function depending on whether is is defined in the
    * lightweight library or in the interpreter's kernel.
    */
   if InternalGCI then
      call RxFuncDrop arg(1)
   else
      call GciFuncDrop arg(1)
   return

/*****************************************************************************/
funcDefine:
   /*
    * Defines a new subroutine as RxFuncDefine does, additionally it undefines
    * (drops) the subroutine in front and it shows the error messages.
    * Finally it terminates the process is an error occurs.
    */
   _SIGL_FUNCDEFINE = SIGL
   call funcDrop arg(1)
   drop GCI_RC
   SIGL_FUNCDEFINE = _SIGL_FUNCDEFINE
   call RxFuncDefine arg(1), arg(2), arg(3), arg(4)
   drop SIGL_FUNCDEFINE _SIGL_FUNCDEFINE
   if RESULT = 0 then
      return
   if IsRegina & InternalGCI then
      errAdd = ":" RxFuncErrMsg()
   else do
      if GCI_RC \= "GCI_RC" then
         errAdd = ":" GCI_RC
      else
         errAdd = ""
      end
   say "Error defining '" || arg(1) || "', code" RESULT || errAdd

   exit 1

