home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 1995 December / SOFM_Dec1995.bin / pc / os2 / vpascal / source / rtl / os2rexx.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1995-10-31  |  22.5 KB  |  527 lines
  1. {█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█}
  2. {█                                                       █}
  3. {█      Virtual Pascal Runtime Library.  Version 1.0.    █}
  4. {█      OS/2 REXX interface unit                         █}
  5. {█      ─────────────────────────────────────────────────█}
  6. {█      Copyright (C) 1995 B&M&T Corporation             █}
  7. {█      ─────────────────────────────────────────────────█}
  8. {█      Written by Vitaly Miryanov                       █}
  9. {█                                                       █}
  10. {▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀}
  11.  
  12. {$Cdecl+,AlignRec-,OrgName+}
  13.  
  14. unit Os2Rexx;
  15.  
  16. interface
  17.  
  18. uses Os2Def;
  19.  
  20. { Common }
  21. { This section defines return codes and constants that are the }
  22. { same for both 16-bit and 32-bit REXX calls.                  }
  23.  
  24. const
  25.   rxAutoBufLen                  = 256;
  26.  
  27. { Record for external interface string (RXSTRING) }
  28.  
  29. type
  30.   PRxString = ^RxString;
  31.   RxString = record
  32.     strlength: ULong;           { length of string  }
  33.     strptr:    PChar;           { pointer to string }
  34.   end;
  35.  
  36.  
  37.  
  38. { Record for system exit block (RXSYSEXIT) 32-bit }
  39.  
  40.   PRxSysExit = ^RxSysExit;
  41.   RxSysExit = record
  42.      sysexit_name: PChar;       { subcom enviro for sysexit  }
  43.      sysexit_code: Long;        { sysexit function code      }
  44.   end;
  45.  
  46. { Call type codes for use on interpreter startup }
  47. const
  48.   rxCommand                     = 0;    { Program called as Command    }
  49.   rxSubroutine                  = 1;    { Program called as Subroutine }
  50.   rxFunction                    = 2;    { Program called as Function   }
  51.  
  52. { Subcommand Interface defines}
  53.  
  54. { Drop Authority for RXSUBCOM interface }
  55.  
  56.   rxsubcom_Droppable            = $00;  { handler to be dropped by all }
  57.   rxsubcom_NonDrop              = $01;  { process with same PID as the }
  58.                                         { registrant may drop environ  }
  59. { Return Codes from RXSUBCOM interface }
  60.  
  61.   rxsubcom_IsReg                = $01;  { Subcommand is registered    }
  62.   rxsubcom_Error                = $01;  { Subcommand Ended in Error   }
  63.   rxsubcom_Failure              = $02;  { Subcommand Ended in Failure }
  64.   rxsubcom_BadEntry             = 1001; { Invalid Entry Conditions    }
  65.   rxsubcom_NoEMem               = 1002; { Insuff stor to complete req }
  66.   rxsubcom_BadType              = 1003; { Bad registration type.      }
  67.   rxsubcom_NotInit              = 1004; { API system not initialized. }
  68.   rxsubcom_Ok                   = 0;    { Function Complete           }
  69.   rxsubcom_Dup                  = 10;   { Duplicate Environment Name- }
  70.                                         { but Registration Completed  }
  71.   rxsubcom_MaxReg               = 20;   { Cannot register more        }
  72.                                         { handlers                    }
  73.   rxsubcom_NotReg               = 30;   { Name Not Registered         }
  74.   rxsubcom_NoCanDrop            = 40;   { Name not droppable          }
  75.   rxsubcom_LoadErr              = 50;   { Could not load function     }
  76.   rxsubcom_NoProc               = 127;  { RXSUBCOM routine - not found}
  77.  
  78. { Shared Variable Pool Interface defines }
  79. { Function Codes for Variable Pool Interface (shvcode) }
  80.  
  81.   rxshv_Set                     = $00;  { Set var from given value    }
  82.   rxshv_Fetch                   = $01;  { Copy value of var to buffer }
  83.   rxshv_DropV                   = $02;  { Drop variable               }
  84.   rxshv_SySet                   = $03;  { Symbolic name Set variable  }
  85.   rxshv_SyFet                   = $04;  { Symbolic name Fetch variable}
  86.   rxshv_SyDro                   = $05;  { Symbolic name Drop variable }
  87.   rxshv_NextV                   = $06;  { Fetch "next" variable       }
  88.   rxshv_Priv                    = $07;  { Fetch private information   }
  89.   rxshv_Exit                    = $08;  { Set function exit value     }
  90.  
  91. {  Return Codes for Variable Pool Interface }
  92.  
  93.   rxshv_NoAvl                   = 144;  { Interface not available     }
  94.  
  95. { Return Code Flags for Variable Pool Interface (shvret) }
  96.  
  97.   rxshv_Ok                      = $00;  { Execution was OK            }
  98.   rxshv_NewV                    = $01;  { Variable did not exist      }
  99.   rxshv_LVar                    = $02;  { Last var trans via SHVNEXTV }
  100.   rxshv_Trunc                   = $04;  { Truncation occurred-Fetch   }
  101.   rxshv_BadN                    = $08;  { Invalid variable name       }
  102.   rxshv_MemFl                   = $10;  { Out of memory failure       }
  103.   rxshv_BadF                    = $80;  { Invalid funct code (shvcode)}
  104.  
  105. { Record of Shared Variable Request Block (SHVBLOCK) }
  106. type
  107.   PShvBlock = ^ShvBlock;
  108.   ShvBlock = record
  109.     shvnext:     PShvBlock;           { pointer to the next block   }
  110.     shvname:     RxString;            { Pointer to the name buffer  }
  111.     shvvalue:    RxString;            { Pointer to the value buffer }
  112.     shvnamelen:  ULong;               { Length of the name value    }
  113.     shvvaluelen: ULong;               { Length of the fetch value   }
  114.     shvcode:     Byte;                { Function code for this block}
  115.     shvret:      Byte;                { Individual Return Code Flags}
  116.   end;
  117.  
  118. { External Function Interface }
  119. { Registration Type Identifiers for Available Function Table }
  120. const
  121.   rxfunc_DynaLink               = 1;  { Function Available in DLL  }
  122.   rxfunc_CallEntry              = 2;  { Registered as mem entry pt.}
  123.  
  124. { Return Codes from RxFunction interface }
  125.  
  126.   rxfunc_Ok                     = 0;  { REXX-API Call Successful   }
  127.   rxfunc_Defined                = 10; { Function Defined in AFT    }
  128.   rxfunc_NoMem                  = 20; { Not Enough Mem to Add      }
  129.   rxfunc_NotReg                 = 30; { Funct Not Registered in AFT}
  130.   rxfunc_ModNotFnd              = 40; { Funct Dll Module Not Found }
  131.   rxfunc_EntNotFnd              = 50; { Funct Entry Point Not Found}
  132.   rxfunc_NotInit                = 60; { API not initialized        }
  133.   rxfunc_BadType                = 70; { Bad function type          }
  134.  
  135. { System Exits defines }
  136. { Drop Authority for Rexx Exit interface }
  137.  
  138.   exit_Droppable                = 0;  { handle to be dropped by all }
  139.   exit_NonDrop                  = 1;  { process with same PID as the}
  140.                                       { registrant may drop environ }
  141. { Exit return actions }
  142.  
  143.   exit_Handled                  = 0;  { Exit handled exit event     }
  144.   exit_Not_Handled              = 1;  { Exit passes on exit event   }
  145.   exit_Raise_Error              = -1; { Exit handler error occurred }
  146.  
  147. { Return Codes from RXEXIT interface }
  148.  
  149.   rxexit_IsReg                  = $01;  { Exit is registered          }
  150.   rxexit_Error                  = $01;  { Exit Ended in Error         }
  151.   rxexit_Failure                = $02;  { Exit Ended in Failure       }
  152.   rxexit_BadEntry               = 1001; { Invalid Entry Conditions    }
  153.   rxexit_NoEmem                 = 1002; { Insuff stor to complete req }
  154.   rxexit_BadType                = 1003; { Bad registration type.      }
  155.   rxexit_NotInit                = 1004; { API system not initialized. }
  156.   rxexit_Ok                     = 0;    { Function Complete           }
  157.   rxexit_Dup                    = 10;   { Duplicate Exit Name-        }
  158.                                         { but Registration Completed  }
  159.   rxexit_MaxReg                 = 20;   { Cannot register more        }
  160.                                         { handlers                    }
  161.   rxexit_NotReg                 = 30;   { Name Not Registered         }
  162.   rxexit_NoCanDrop              = 40;   { Name not droppable          }
  163.   rxexit_LoadErr                = 50;   { Could not load function     }
  164.   rxexit_NoProc                 = 127;  { RXEXIT routine - not found  }
  165.  
  166. { System Exit function and sub-function definitions }
  167.  
  168.   rxEndLst                      = 0;    { End of exit list.           }
  169.   rxFnc                         = 2;    { Process external functions. }
  170.   rxFncCal                      = 1;    { subcode value.              }
  171.   rxCmd                         = 3;    { Process host commands.      }
  172.   rxCmdHst                      = 1;    { subcode value.              }
  173.   rxMsq                         = 4;    { Manipulate queue.           }
  174.   rxMsqPll                      = 1;    { Pull a line from queue      }
  175.   rxMsqPsh                      = 2;    { Place a line on queue       }
  176.   rxMsqSiz                      = 3;    { Return num of lines on queue}
  177.   rxMsqNam                      = 20;   { Set active queue name       }
  178.   rxSio                         = 5;    { Session I/O.                }
  179.   rxSioSay                      = 1;    { SAY a line to STDOUT        }
  180.   rxSioTrc                      = 2;    { Trace output                }
  181.   rxSioTrd                      = 3;    { Read from char stream       }
  182.   rxSioDtr                      = 4;    { DEBUG read from char stream }
  183.   rxSioTll                      = 5;    { Return linelength(N/A OS/2) }
  184.   rxHlt                         = 7;    { Halt processing.            }
  185.   rxHltClr                      = 1;    { Clear HALT indicator        }
  186.   rxHltTst                      = 2;    { Test HALT indicator         }
  187.   rxTrc                         = 8;    { Test ext trace indicator.   }
  188.   rxTrcTst                      = 1;    { subcode value.              }
  189.   rxIni                         = 9;    { Initialization processing.  }
  190.   rxIniExt                      = 1;    { subcode value.              }
  191.   rxTer                         = 10;   { Termination processing.     }
  192.   rxTerExt                      = 1;    { subcode value.              }
  193.   rxNoOfExits                   = 11;   { 1 + largest exit number.    }
  194.  
  195. type
  196.   PExit = ^Byte;                        { ptr to exit parameter block }
  197.  
  198. { Asynchronous Request Interface defines }
  199. { Return Codes from Asynchronous Request interface }
  200. const
  201.   rxari_Ok                      = 0;    { Interface completed         }
  202.   rxari_Not_Found               = 1;    { Target program not found    }
  203.   rxari_Processing_Error        = 2;    { Error processing request    }
  204.  
  205. {  Macro Space Interface defines }
  206. {  Registration Search Order Flags }
  207.  
  208.   rxmacro_Search_Before         = 1; { Beginning of search order   }
  209.   rxmacro_Search_After          = 2; { End of search order         }
  210.  
  211.  
  212. { Return Codes from RxMacroSpace interface }
  213.  
  214.   rxmacro_Ok                    = 0; { Macro interface completed   }
  215.   rxmacro_No_Storage            = 1; { Not Enough Storage Available}
  216.   rxmacro_Not_Found             = 2; { Requested function not found}
  217.   rxmacro_Extension_Required    = 3; { File ext required for save  }
  218.   rxmacro_Already_Exists        = 4; { Macro functions exist       }
  219.   rxmacro_File_Error            = 5; { File I/O error in save/load }
  220.   rxmacro_Signature_Error       = 6; { Incorrect format for load   }
  221.   rxmacro_Source_Not_Found      = 7; { Requested cannot be found   }
  222.   rxmacro_Invalid_Position      = 8; { Invalid search order pos    }
  223.   rxmacro_Not_Init              = 9; { API not initialized         }
  224.  
  225. { 32-bit }
  226. { Main Entry Point to the REXXSAA Interpreter }
  227.  
  228. function RexxStart (
  229.          ArgC:     Long;        { Num of args passed to rexx }
  230.          ArgV:     PRxString;   { Array of args passed to rex}
  231.          FileName: PChar;       { [d:][path] filename[.ext]  }
  232.          Proc:     PRxString;   { Loc of rexx proc in memory }
  233.          Env:      PChar;       { ASCIIZ initial environment.}
  234.          rType:    Long;        { type (command,subrtn,funct)}
  235.          Exit:     PRxSysExit;  { SysExit env. names &  codes}
  236.      var Ret:      Word;        { Ret code from if numeric   }
  237.      var RetVal:   RxString     { Retvalue from the rexx proc}
  238.          ): Long;
  239.  
  240. { Subcommand Interface }
  241. { RexxRegisterSubcomDll -- Register a DLL entry point }
  242. { as a Subcommand handler }
  243.  
  244. function RexxRegisterSubcomDll(
  245.          HName:    PChar;       { Name of subcom handler     }
  246.          DllName:  PChar;       { Name of DLL                }
  247.          ProcName: PChar;       { Name of procedure in DLL   }
  248.          UserArea: Pointer;     { User area                  }
  249.          Drop: ULong): ApiRet;  { Drop authority.            }
  250.  
  251. { RexxRegisterSubcomExe -- Register an EXE entry point }
  252. { as a Subcommand handler }
  253.  
  254. function RexxRegisterSubcomExe (
  255.          HName:       PChar;            { Name of subcom handler     }
  256.          HandlerAddr: PFn;              { address of handler in EXE  }
  257.          UserArea:    Pointer): ApiRet; { User area                  }
  258.  
  259. { RexxQuerySubcom - Query an environment for Existance }
  260.  
  261. function RexxQuerySubcom(
  262.          EnvName: PChar;                { Name of the Environment    }
  263.          DllName: PChar;                { DLL Module Name            }
  264.      var ExCode:  Word;                 { Stor for existance code    }
  265.      var User:    Word): ApiRet;        { Stor for user word         }
  266.  
  267. { RexxDeregisterSubcom - Drop registration of a Subcommand environment }
  268.  
  269. function RexxDeregisterSubcom(
  270.          EnvName: PChar;                { Name of the Environment    }
  271.          DllName: PChar): ApiRet;       { DLL Module Name            }
  272.  
  273. { Shared Variable Pool Interface }
  274.  
  275. { RexxVariablePool - Request Variable Pool Service }
  276.  
  277. function RexxVariablePool(var Pool: ShvBlock): ApiRet; { Pointer to list of SHVBLOCKs}
  278.  
  279. { External Function Interface }
  280. { RexxRegisterFunctionDll - Register a function in the AFT }
  281.  
  282. function RexxRegisterFunctionDll (
  283.         FnName:  PChar;                 { Name of function to add    }
  284.         DllName: PChar;                 { Dll file name (if in dll)  }
  285.         Entry:   PChar): ApiRet;        { Entry in dll               }
  286.  
  287. { RexxRegisterFunctionExe - Register a function in the AFT }
  288.  
  289. function RexxRegisterFunctionExe (
  290.         FnName: PChar;                  { Name of function to add    }
  291.         Entry:  PFn): ApiRet;           { Entry point in EXE         }
  292.  
  293. { RexxDeregisterFunction - Delete a function from the AFT }
  294.  
  295. function RexxDeregisterFunction(FnName: PChar): ApiRet; { Name of function to remove }
  296.  
  297. { RexxQueryFunction - Scan the AFT for a function }
  298.  
  299. function RexxQueryFunction(FnName: PChar): ApiRet; { Name of function to find }
  300.  
  301. { System Exits }
  302. { Subfunction RXFNCCAL - External Function Calls }
  303.  
  304. const
  305. { rxfnc_flags flags }
  306.   rxfferr                       = $01;  { Invalid call to routine.   }
  307.   rxffnfnd                      = $02;  { Function not found.        }
  308.   rxffsub                       = $04;  { Called as a subroutine     }
  309. type
  310.  
  311.   RxFnCCal_Parm = record
  312.     rxfnc_flags: Byte;          { function flags             }
  313.     rxfnc_name:  PChar;         { Pointer to function name.  }
  314.     rxfnc_namel: Word;          { Length of function name.   }
  315.     rxfnc_que:   PChar;         { Current queue name.        }
  316.     rxfnc_quel:  Word;          { Length of queue name.      }
  317.     rxfnc_argc:  Word;          { Number of args in list.    }
  318.     rxfnc_argv:  PRxString;     { Pointer to argument list.  }
  319.     rxfnc_retc:  RxString;      { Return value.              }
  320.   end;
  321.  
  322. { Subfunction RXCMDHST -- Process Host Commands }
  323. const
  324. { rxcmd_flags flags }
  325.   rxfcfail                      = $01;  { Command failed.            }
  326.   rxfcerr                       = $02;  { Command ERROR occurred.    }
  327. type
  328.   RxCmdHst_Parm = record
  329.     rxcmd_flags:    Byte;               { error/failure flags        }
  330.     rxcmd_address:  PChar;              { Pointer to address name.   }
  331.     rxcmd_addressl: Word;               { Length of address name.    }
  332.     rxcmd_dll:      PChar;              { dll name for command.      }
  333.     rxcmd_dll_len:  Word;               { Length of dll name.        }
  334.     rxcmd_command:  RxString;           { The command string.        }
  335.     rxcmd_retc:     RxString;           { Pointer to return buffer   }
  336.   end;
  337.  
  338. { Subfunction RXMSQPLL -- Pull Entry from Queue }
  339.  
  340.   RxMsqPll_Parm = record
  341.     rxmsq_retc: RxString;               { Pointer to dequeued entry  }
  342.   end;                                  { buffer.  User allocated.   }
  343.  
  344. {  Subfunction RXMSQPSH -- Push Entry on Queue }
  345. const
  346. { rxmsq_flags flags }
  347.    rxfmlifo                     = $01;  { Stack entry LIFO if set    }
  348. type
  349.   RxMsqPsh_Parm = record
  350.      rxmsq_flags: Byte;                 { LIFO/FIFO flag             }
  351.      rxmsq_value: RxString              { The entry to be pushed.    }
  352.   end;
  353.  
  354. {  Subfunction RXMSQSIZ -- Return the Current Queue Size }
  355.  
  356.   RxMsqSiz_Parm = record
  357.     rxmsq_size: ULong;                  { Number of Lines in Queue   }
  358.   end;
  359.  
  360. { Subfunction RXMSQNAM -- Set Current Queue Name }
  361.  
  362.   RxMsqNam_Parm = record
  363.     rxmsq_name: RxString;               { RxString containing        }
  364.   end;                                  { queue name.                }
  365.  
  366. { Subfunction RXSIOSAY -- Perform SAY Clause }
  367.  
  368.   RxSioSay_Parm = record
  369.     rxsio_string: RxString;             { String to display.         }
  370.   end;
  371.  
  372. { Subfunction RXSIOTRC -- Write Trace Output }
  373.  
  374.   RxSioTrc_Parm = record
  375.     rxsio_string: RxString;             { Trace line to display.     }
  376.   end;
  377.  
  378. { Subfunction RXSIOTRD -- Read Input from the Terminal }
  379.  
  380.   RxSioTrd_Parm = record
  381.     rxsiotrd_retc: RxString;            { RxString for output.       }
  382.   end;
  383.  
  384. { Subfunction RXSIODTR -- Read Debug Input from the Terminal }
  385.  
  386.   RxSioDtr_Parm = record
  387.     rxsiodtr_retc: RxString;            { RxString for output.       }
  388.   end;
  389.  
  390. { Subfunction RXHSTTST -- Test for HALT Condition }
  391. const
  392. { rxhlt_flags flags }
  393.   rxfhhalt                      = $01;  { Set if HALT occurred.      }
  394. type
  395.   RxHltTst_Parm = record
  396.     rxhlt_flags: Byte;                  { Set if HALT occurred       }
  397.   end;
  398.  
  399. { Subfunction RXTRCTST -- Test for TRACE Condition }
  400. const
  401. { rxtrc_flags flags }
  402.   rxftrace                      = $01;  { Set to run external trace. }
  403. type
  404.   RxTrcTst_Parm = record
  405.     rxtrc_flags: Byte;                  { Set to run external trace  }
  406.   end;
  407.  
  408. { RexxRegisterExitDll - Register a system exit. }
  409.  
  410. function RexxRegisterExitDll (
  411.          HExit:    PChar;               { Name of the exit handler   }
  412.          DllName:  PChar;               { Name of the DLL            }
  413.          ProcName: PChar;               { Name of the procedure      }
  414.          UserArea: Pointer;             { User area                  }
  415.          Drop:     ULong): ApiRet;      { Drop authority             }
  416.  
  417. { RexxRegisterExitExe - Register a system exit. }
  418.  
  419. function RexxRegisterExitExe (
  420.          HExit: PChar;                  { Name of the exit handler   }
  421.          HandlerAddr: PFn;              { Address of exit handler    }
  422.          UserArea: Pointer): ApiRet;    { User area                  }
  423.  
  424. { RexxDeregisterExit - Drop registration of a system exit. }
  425.  
  426. function RexxDeregisterExit (
  427.          ExitName: PChar;               { Exit name                  }
  428.          DllName:  PChar): ApiRet ;     { DLL module name            }
  429.  
  430. { RexxQueryExit - Query an exit for existance. }
  431.  
  432. function RexxQueryExit (
  433.          ExitName: PChar;               { Exit name                  }
  434.          DllName:  PChar;               { DLL Module name.           }
  435.      var ExFlag:   Word;                { Existance flag.            }
  436.          UserArea: Pointer): ApiRet;    { User data.                 }
  437.  
  438. { Asynchronous Request Interface }
  439. { RexxSetHalt - Request Program Halt }
  440.  
  441. function RexxSetHalt(
  442.          Pid: Pid;                      { Process Id                  }
  443.          Tid: Tid): ApiRet;             { Thread Id                   }
  444.  
  445. { RexxSetTrace - Request Program Trace }
  446.  
  447. function RexxSetTrace(
  448.          Pid: Pid;                      { Process Id                  }
  449.          Tid: Tid): ApiRet;             { Thread Id                   }
  450.  
  451. { RexxResetTrace - Turn Off Program Trace }
  452.  
  453. function RexxResetTrace(
  454.          Pid: Pid;                      { Process Id                  }
  455.          Tid: Tid): ApiRet;             { Thread Id                   }
  456.  
  457. { Macro Space Interface }
  458. { RexxAddMacro - Register a function in the Macro Space }
  459.  
  460. function RexxAddMacro (
  461.          FnName:   PChar;               { Function to add or change   }
  462.          FileName: PChar;               { Name of file to get function}
  463.          SrchPos:  ULong): ApiRet;      { Flag indicating search pos  }
  464.  
  465. { RexxDropMacro - Remove a function from the Macro Space }
  466.  
  467. function RexxDropMacro(FnName: PChar): ApiRet; { Name of function to remove }
  468.  
  469. { RexxSaveMacroSpace - Save Macro Space functions to a file }
  470.  
  471. function RexxSaveMacroSpace (
  472.          ArgC: ULong;                   { Argument count (0==save all)}
  473.      var NameLst: PChar;                { List of funct names to save }
  474.          FileName: PChar): ApiRet;      { File to save functions in   }
  475.  
  476. { RexxLoadMacroSpace - Load Macro Space functions from a file  }
  477.  
  478. function RexxLoadMacroSpace (
  479.          ArgC:     ULong;               { Argument count (0==load all)}
  480.      var NameLst:  PChar;               { List of funct names to load }
  481.          FileName: PChar): ApiRet;      { File to load functions from }
  482.  
  483. { RexxQueryMacro - Find a function's search-order position }
  484.  
  485. function RexxQueryMacro (
  486.          FnName: PChar;                 { Function to search for       }
  487.      var PtrPos: Word): ApiRet;         { Ptr for position flag return }
  488.  
  489. { RexxReorderMacro - Change a function's search-order position }
  490.  
  491. function RexxReorderMacro(
  492.          FnName: PChar;                 { Name of funct change order  }
  493.          NewPos: ULong): ApiRet;        { New position for function   }
  494.  
  495. { RexxClearMacroSpace - Remove all functions from a MacroSpace }
  496.  
  497. function RexxClearMacroSpace: ApiRet;   { No Arguments.               }
  498.  
  499. implementation
  500.  
  501. function RexxAddMacro;            external;
  502. function RexxClearMacroSpace;     external;
  503. function RexxDeregisterExit;      external;
  504. function RexxDeregisterFunction;  external;
  505. function RexxDeregisterSubcom;    external;
  506. function RexxDropMacro;           external;
  507. function RexxLoadMacroSpace;      external;
  508. function RexxQueryExit;           external;
  509. function RexxQueryFunction;       external;
  510. function RexxQueryMacro;          external;
  511. function RexxQuerySubcom;         external;
  512. function RexxRegisterExitDll;     external;
  513. function RexxRegisterExitExe;     external;
  514. function RexxRegisterFunctionDll; external;
  515. function RexxRegisterFunctionExe; external;
  516. function RexxRegisterSubcomDll;   external;
  517. function RexxRegisterSubcomExe;   external;
  518. function RexxReorderMacro;        external;
  519. function RexxResetTrace;          external;
  520. function RexxSaveMacroSpace;      external;
  521. function RexxSetHalt;             external;
  522. function RexxSetTrace;            external;
  523. function RexxStart;               external;
  524. function RexxVariablePool;        external;
  525.  
  526. end.
  527.