ooRexx  4.2.0-source
About: ooRexx (Open Object Rexx) is a free implementation of Object Rexx. Object Rexx is an enhancement of the classic Rexx interpreter; a full-featured programming language with a human-oriented syntax.
  Fossies Dox: ooRexx-4.2.0-source.tar.gz  ("inofficial" and yet experimental doxygen-generated source code documentation)  

rexx.h
Go to the documentation of this file.
1 /*----------------------------------------------------------------------------*/
2 /* */
3 /* Copyright (c) 1995, 2004 IBM Corporation. All rights reserved. */
4 /* Copyright (c) 2005-2009 Rexx Language Association. All rights reserved. */
5 /* */
6 /* This program and the accompanying materials are made available under */
7 /* the terms of the Common Public License v1.0 which accompanies this */
8 /* distribution. A copy is also available at the following address: */
9 /* http://www.ibm.com/developerworks/oss/CPLv1.0.htm */
10 /* */
11 /* Redistribution and use in source and binary forms, with or */
12 /* without modification, are permitted provided that the following */
13 /* conditions are met: */
14 /* */
15 /* Redistributions of source code must retain the above copyright */
16 /* notice, this list of conditions and the following disclaimer. */
17 /* Redistributions in binary form must reproduce the above copyright */
18 /* notice, this list of conditions and the following disclaimer in */
19 /* the documentation and/or other materials provided with the distribution. */
20 /* */
21 /* Neither the name of Rexx Language Association nor the names */
22 /* of its contributors may be used to endorse or promote products */
23 /* derived from this software without specific prior written permission. */
24 /* */
25 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
26 /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
27 /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */
28 /* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */
29 /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */
30 /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */
31 /* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */
32 /* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */
33 /* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */
34 /* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */
35 /* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
36 /* */
37 /*----------------------------------------------------------------------------*/
38 
39 /*----------------------------------------------------------------------------*/
40 /* */
41 /* Module Name: rexx.h */
42 /* */
43 /* ooRexx Common Definitions File */
44 /* */
45 /* Note: This is a revision of the original IBM rexx.h header file. All of the*/
46 /* conditional sections have been removed and it has been split into multiple */
47 /* header files, some of which are platform specific. Many of the types have */
48 /* been changed to more portable types. */
49 /* */
50 /*----------------------------------------------------------------------------*/
51 
52 #ifndef REXXSAA_INCLUDED
53 #define REXXSAA_INCLUDED
54 
55 
56 #ifdef __cplusplus
57 #define BEGIN_EXTERN_C() extern "C" {
58 #define END_EXTERN_C() }
59 #else
60 #define BEGIN_EXTERN_C()
61 #define END_EXTERN_C()
62 #endif
63 
64 
65 #include "rexxapitypes.h" // Platform specific stuff
66 
67 /*----------------------------------------------------------------------------*/
68 /* */
69 /* Common */
70 /* */
71 /*----------------------------------------------------------------------------*/
72 
73 typedef int RexxReturnCode; // API return type
74 
75 /******************************************************************************/
76 /* Types (for general use) */
77 /******************************************************************************/
78 typedef const char *CSTRING; /* pointer to zero-terminated string */
79 typedef void *POINTER;
80 
81 #ifdef __cplusplus
82 
83 class _RexxObjectPtr {};
84 class _RexxStringObject : public _RexxObjectPtr {};
85 class _RexxBufferStringObject : public _RexxStringObject {};
86 class _RexxArrayObject : public _RexxObjectPtr {};
87 class _RexxBufferObject : public _RexxObjectPtr {};
88 class _RexxPointerObject : public _RexxObjectPtr {};
89 class _RexxMethodObject : public _RexxObjectPtr {};
90 class _RexxRoutineObject : public _RexxObjectPtr {};
91 class _RexxPackageObject : public _RexxObjectPtr {};
92 class _RexxClassObject : public _RexxObjectPtr {};
93 class _RexxDirectoryObject : public _RexxObjectPtr {};
94 class _RexxSupplierObject : public _RexxObjectPtr {};
95 class _RexxStemObject : public _RexxObjectPtr {};
96 class _RexxMutableBufferObject : public _RexxObjectPtr {};
97 
98 typedef _RexxObjectPtr *RexxObjectPtr;
99 typedef _RexxStringObject *RexxStringObject;
100 typedef _RexxBufferStringObject *RexxBufferStringObject;
101 typedef _RexxArrayObject *RexxArrayObject;
102 typedef _RexxBufferObject *RexxBufferObject;
103 typedef _RexxPointerObject *RexxPointerObject;
104 typedef _RexxMethodObject *RexxMethodObject;
105 typedef _RexxRoutineObject *RexxRoutineObject;
106 typedef _RexxPackageObject *RexxPackageObject;
107 typedef _RexxClassObject *RexxClassObject;
108 typedef _RexxDirectoryObject *RexxDirectoryObject;
109 typedef _RexxSupplierObject *RexxSupplierObject;
110 typedef _RexxStemObject *RexxStemObject;
111 typedef _RexxMutableBufferObject *RexxMutableBufferObject;
112 #else
113 struct _RexxObjectPtr;
114 struct _RexxStringObject;
115 struct _RexxArrayObject;
116 struct _RexxBufferObject;
117 struct _RexxPointerObject;
118 struct _RexxMethodObject;
119 struct _RexxRoutineObject;
120 struct _RexxPackageObject;
121 struct _RexxClassObject;
122 struct _RexxDirectoryObject;
123 struct _RexxSupplierObject;
124 struct _RexxStemObject;
125 struct _RexxMutableBufferObject;
126 
127 typedef struct _RexxObjectPtr *RexxObjectPtr;
128 typedef struct _RexxStringObject *RexxStringObject;
129 typedef struct _RexxBufferStringObject *RexxBufferStringObject;
130 typedef struct _RexxArrayObject *RexxArrayObject;
131 typedef struct _RexxBufferObject *RexxBufferObject;
132 typedef struct _RexxPointerObject *RexxPointerObject;
133 typedef struct _RexxMethodObject *RexxMethodObject;
134 typedef struct _RexxRoutineObject *RexxRoutineObject;
135 typedef struct _RexxPackageObject *RexxPackageObject;
136 typedef struct _RexxClassObject *RexxClassObject;
137 typedef struct _RexxDirectoryObject *RexxDirectoryObject;
138 typedef struct _RexxSupplierObject *RexxSupplierObject;
139 typedef struct _RexxStemObject *RexxStemObject;
140 typedef struct _RexxMutableBufferObject *RexxMutableBufferObject;
141 #endif
142 
143 /******************************************************************************/
144 /* Constant values (for general use) */
145 /******************************************************************************/
146 #define NO_CSTRING NULL
147 #define NULLOBJECT NULL
148 
149 
150 /*----------------------------------------------------------------------------*/
151 /*** RXSTRING defines */
152 /*----------------------------------------------------------------------------*/
153 
154 /*** Structure for external interface string (RXSTRING) */
155 
156 typedef struct _RXSTRING { /* rxstr */
157  size_t strlength; /* length of string */
158  char *strptr; /* pointer to string */
159 } RXSTRING;
160 
161 typedef struct _CONSTRXSTRING { /* const rxstr */
162  size_t strlength; /* length of string */
163  const char *strptr; /* pointer to string */
164 } CONSTRXSTRING;
165 
166 #ifndef OOREXX_COMPATIBILITY
167 #define CONSTANT_RXSTRING CONSTRXSTRING
168 #define CONSTANT_STRING CSTRING
169 #else
170 typedef char *PSZ;
171 #define CONSTANT_RXSTRING RXSTRING
172 #define CONSTANT_STRING PSZ
173 #endif
174 
175 /*** Macros for RexxString manipulation */
176 
177 #define RXNULLSTRING(r) ((r).strptr == NULL)
178 #define RXZEROLENSTRING(r) ((r).strptr != NULL && (r).strlength == 0)
179 #define RXVALIDSTRING(r) ((r).strptr != NULL && (r).strlength != 0)
180 #define RXSTRLEN(r) (RXNULLSTRING(r) ? 0 : (r).strlength)
181 #define RXSTRPTR(r) ((r).strptr)
182 #define MAKERXSTRING(r,p,l) { (r).strptr = p; (r).strlength = l; }
183 
184 
185 typedef RXSTRING *PRXSTRING; /* pointer to a RXSTRING */
186 typedef CONSTANT_RXSTRING *PCONSTRXSTRING; /* pointer to a RXSTRING */
187 
188 /*** Structure for system exit block (RXSYSEXIT) */
189 
190 typedef struct _RXSYSEXIT { /* syse */
191  CONSTANT_STRING sysexit_name; /* subcom enviro for sysexit */
192  int sysexit_code; /* sysexit function code */
193 } RXSYSEXIT;
194 typedef RXSYSEXIT *PRXSYSEXIT; /* pointer to a RXSYSEXIT */
195 
196 
197 
198 /*----------------------------------------------------------------------------*/
199 /*** Shared Variable Pool Interface defines */
200 /*----------------------------------------------------------------------------*/
201 
202 /*** Structure of Shared Variable Request Block (SHVBLOCK) */
203 
204 typedef struct _SHVBLOCK { /* shvb */
205  struct _SHVBLOCK *shvnext; /* pointer to the next block */
206  CONSTANT_RXSTRING shvname; /* Pointer to the name buffer */
207  RXSTRING shvvalue; /* Pointer to the value buffer */
208  size_t shvnamelen; /* Length of the name value */
209  size_t shvvaluelen; /* Length of the fetch value */
210  unsigned char shvcode; /* Function code for this block*/
211  unsigned char shvret; /* Individual Return Code Flags*/
212 } SHVBLOCK;
214 
215 typedef char *PEXIT; /* ptr to exit parameter block */
216 
217 
218 
219 
220 /*----------------------------------------------------------------------------*/
221 /*** Include the other common and platform specific stuff */
222 /*----------------------------------------------------------------------------*/
223 
224 /* These must be placed after RXSTRING and CONSTRXSTRING are defined */
225 #include "rexxapidefs.h"
226 #include "rexxplatformdefs.h" // Platform specific stuff
227 
228 typedef size_t stringsize_t; // a Rexx string size
229 typedef ssize_t wholenumber_t; // a Rexx whole number
230 typedef size_t logical_t; // a Rexx logical (1 or 0) value
231 
232 // a synonym for readability
233 #define RexxEntry REXXENTRY
234 
235 
236 /*** RexxPullFromQueue - Retrieve data from an External Data Queue */
237 typedef struct _RexxQueueTime { /* REXX time stamp format */
238  uint16_t hours; /* hour of the day (24-hour) */
239  uint16_t minutes; /* minute of the hour */
240  uint16_t seconds; /* second of the minute */
241  uint16_t hundredths; /* hundredths of a second */
242  uint16_t day; /* day of the month */
243  uint16_t month; /* month of the year */
244  uint16_t year; /* current year */
245  uint16_t weekday; /* day of the week */
246  uint32_t microseconds; /* microseconds */
247  uint32_t yearday; /* day number within the year */
248 } RexxQueueTime;
249 
250 
251 typedef struct _RexxConditionData
252 {
253  wholenumber_t code; // The condition CODE information
254  wholenumber_t rc; // The condition RC value
255  RXSTRING message; // The condition secondary message text
256  RXSTRING errortext; // The condition error text.
257  size_t position; // The failure line number value
258  RXSTRING program; // The running program name
260 
261 /*----------------------------------------------------------------------------*/
262 /* */
263 /* 32-bit */
264 /* */
265 /*----------------------------------------------------------------------------*/
266 
267 /*----------------------------------------------------------------------------*/
268 /*** Main Entry Point to the Rexx Interpreter */
269 /*----------------------------------------------------------------------------*/
270 
272 
273 int REXXENTRY RexxStart (
274  size_t, /* Num of args passed to rexx */
275  PCONSTRXSTRING, /* Array of args passed to rex */
276  CONSTANT_STRING, /* [d:][path] filename[.ext] */
277  PRXSTRING, /* Loc of rexx proc in memory */
278  CONSTANT_STRING, /* ASCIIZ initial environment.*/
279  int, /* type (command,subrtn,funct) */
280  PRXSYSEXIT, /* SysExit env. names & codes */
281  short *, /* Ret code from if numeric */
282  PRXSTRING ); /* Retvalue from the rexx proc */
284  CONSTANT_STRING, int, PRXSYSEXIT, short *,
285  PRXSTRING);
286 #define REXXSTART RexxStart
287 
288 // the following APIs are deprecated, and are included only for binary compatibility.
289 // These are nops if called.
291 typedef void (REXXENTRY *PFNREXXWAITFORTERMINATION)(void);
292 #define REXXWAITFORTERMINATION RexxWaitForTermination
293 
296 #define REXXDIDREXXTERMINATE RexxDidRexxTerminate
297 
300 #define REXXSHUTDOWNAPI RexxShutDownAPI
301 
302 
304  CONSTANT_STRING, // input program name
305  CONSTANT_STRING, // output file name
306  PRXSYSEXIT); // system exits to use during translation
307 
308 
310 
311 #define REXXTRANSLATEPROGRAM RexxTranslateProgram
312 
313 
315  CONSTANT_STRING, // input program name
316  CONSTANT_RXSTRING *, // program source
317  RXSTRING *); // returned image
318 
319 
321 
322 #define REXXTRANSLATEINSTOREPROGRAM RexxTranslateInstoreProgram
323 
324 
326 
327 typedef char *(REXXENTRY *PFNGETVERSIONINFORMATION)(void);
328 
329 #define REXXGETVERSIONINFORMATON RexxGetVersionInformation
330 
331 
332 /*----------------------------------------------------------------------------*/
333 /*** Subcommand Interface */
334 /*----------------------------------------------------------------------------*/
335 
336 /* This typedef simplifies coding of a Subcommand handler. */
338  unsigned short *,
339  PRXSTRING);
340 
341 /*** RexxRegisterSubcomDll -- Register a DLL entry point */
342 /*** as a Subcommand handler */
343 
345  CONSTANT_STRING, /* Name of subcom handler */
346  CONSTANT_STRING, /* Name of DLL */
347  CONSTANT_STRING, /* Name of procedure in DLL */
348  CONSTANT_STRING, /* User area */
349  size_t ); /* Drop authority. */
351  char *, size_t);
352 #define REXXREGISTERSUBCOMDLL RexxRegisterSubcomDll
353 
354 
355 /*** RexxRegisterSubcomExe -- Register an EXE entry point */
356 /*** as a Subcommand handler */
357 
359  CONSTANT_STRING, /* Name of subcom handler */
360  REXXPFN, /* address of handler in EXE */
361  CONSTANT_STRING); /* User area */
363 #define REXXREGISTERSUBCOMEXE RexxRegisterSubcomExe
364 
365 
366 /*** RexxQuerySubcom - Query an environment for Existance */
367 
369  CONSTANT_STRING, /* Name of the Environment */
370  CONSTANT_STRING, /* DLL Module Name */
371  unsigned short *, /* Stor for existance code */
372  char *); /* Stor for user word */
374  char *);
375 #define REXXQUERYSUBCOM RexxQuerySubcom
376 
377 
378 /*** RexxDeregisterSubcom - Drop registration of a Subcommand */
379 /*** environment */
380 
382  CONSTANT_STRING, /* Name of the Environment */
383  CONSTANT_STRING); /* DLL Module Name */
385 #define REXXDEREGISTERSUBCOM RexxDeregisterSubcom
386 
387 
388 /*----------------------------------------------------------------------------*/
389 /*** Shared Variable Pool Interface */
390 /*----------------------------------------------------------------------------*/
391 
392 /*** RexxVariablePool - Request Variable Pool Service */
393 
395  PSHVBLOCK); /* Pointer to list of SHVBLOCKs*/
397 #define REXXVARIABLEPOOL RexxVariablePool
398 
399 
400 /*----------------------------------------------------------------------------*/
401 /*** External Function Interface */
402 /*----------------------------------------------------------------------------*/
403 
404 /* This typedef simplifies coding of an External Function. */
405 
407  size_t,
410  PRXSTRING);
411 
413  size_t,
416  PRXSTRING);
417 
418 /*** RexxRegisterFunctionDll - Register a function in the AFT */
419 
421  CONSTANT_STRING, /* Name of function to add */
422  CONSTANT_STRING, /* Dll file name (if in dll) */
423  CONSTANT_STRING); /* Entry in dll */
425 #define REXXREGISTERFUNCTIONDLL RexxRegisterFunctionDll
426 
427 
428 /*** RexxRegisterFunctionExe - Register a function in the AFT */
429 
431  CONSTANT_STRING, /* Name of function to add */
432  REXXPFN); /* Entry point in EXE */
434 #define REXXREGISTERFUNCTIONEXE RexxRegisterFunctionExe
435 
436 
437 /*** RexxDeregisterFunction - Delete a function from the AFT */
438 
440  CONSTANT_STRING ); /* Name of function to remove */
442 #define REXXDEREGISTERFUNCTION RexxDeregisterFunction
443 
444 
445 /*** RexxQueryFunction - Scan the AFT for a function */
446 
448  CONSTANT_STRING ); /* Name of function to find */
450 #define REXXQUERYFUNCTION RexxQueryFunction
451 
452 
453 /*----------------------------------------------------------------------------*/
454 /*** System Exits */
455 /*----------------------------------------------------------------------------*/
456 
457 /*** Subfunction RXFNCCAL - External Function Calls */
458 
459 typedef struct _RXFNC_FLAGS { /* fl */
460  unsigned rxfferr : 1; /* Invalid call to routine. */
461  unsigned rxffnfnd : 1; /* Function not found. */
462  unsigned rxffsub : 1; /* Called as a subroutine */
463 } RXFNC_FLAGS ;
464 
465 typedef struct _RXFNCCAL_PARM { /* fnc */
466  RXFNC_FLAGS rxfnc_flags ; /* function flags */
467  CONSTANT_STRING rxfnc_name; /* Pointer to function name. */
468  unsigned short rxfnc_namel; /* Length of function name. */
469  CONSTANT_STRING rxfnc_que; /* Current queue name. */
470  unsigned short rxfnc_quel; /* Length of queue name. */
471  unsigned short rxfnc_argc; /* Number of args in list. */
472  PCONSTRXSTRING rxfnc_argv; /* Pointer to argument list. */
473  RXSTRING rxfnc_retc; /* Return value. */
474 } RXFNCCAL_PARM;
475 
476 
477 /*** Subfunction RXOFNCCAL - Object valued external function call */
478 
479 typedef struct _RXOFNC_FLAGS { /* fl */
480  unsigned rxfferr : 1; /* Invalid call to routine. */
481  unsigned rxffnfnd : 1; /* Function not found. */
482  unsigned rxffsub : 1; /* Called as a subroutine */
483 } RXOFNC_FLAGS ;
484 
485 typedef struct _RXOFNCCAL_PARM { /* fnc */
486  RXOFNC_FLAGS rxfnc_flags ; /* function flags */
487  CONSTANT_RXSTRING rxfnc_name; // the called function name
488  size_t rxfnc_argc; /* Number of args in list. */
489  RexxObjectPtr *rxfnc_argv; /* Pointer to argument list. */
490  RexxObjectPtr rxfnc_retc; /* Return value. */
492 
493 
494 
495 /*** Subfunction RXEXFCAL - Scripting Function Calls */
496 
497 typedef struct _RXEXF_FLAGS { /* fl */
498  unsigned rxfferr : 1; /* Invalid call to routine. */
499  unsigned rxffnfnd : 1; /* Function not found. */
500  unsigned rxffsub : 1; /* Called as a subroutine */
501 } RXEXF_FLAGS ;
502 
503 typedef struct _RXEXFCAL_PARM { /* fnc */
504  RXEXF_FLAGS rxfnc_flags ; /* function flags */
505  CONSTANT_RXSTRING rxfnc_name; // the called function name
506  size_t rxfnc_argc; /* Number of args in list. */
507  RexxObjectPtr *rxfnc_argv; /* Pointer to argument list. */
508  RexxObjectPtr rxfnc_retc; /* Return value. */
509 } RXEXFCAL_PARM;
510 
511 /*** Subfunction RXCMDHST -- Process Host Commands */
512 
513 typedef struct _RXCMD_FLAGS { /* fl */
514  unsigned rxfcfail : 1; /* Command failed. */
515  unsigned rxfcerr : 1; /* Command ERROR occurred. */
516 } RXCMD_FLAGS;
517 
518 typedef struct _RXCMDHST_PARM { /* rx */
519  RXCMD_FLAGS rxcmd_flags; /* error/failure flags */
520  CONSTANT_STRING rxcmd_address; /* Pointer to address name. */
521  unsigned short rxcmd_addressl; /* Length of address name. */
522  CONSTANT_STRING rxcmd_dll; /* dll name for command. */
523  unsigned short rxcmd_dll_len; /* Length of dll name. */
524  CONSTANT_RXSTRING rxcmd_command; /* The command string. */
525  RXSTRING rxcmd_retc; /* Pointer to return buffer */
526 } RXCMDHST_PARM;
527 
528 
529 /*** Subfunction RXMSQPLL -- Pull Entry from Queue */
530 
531 typedef struct _RXMSQPLL_PARM { /* pll */
532  RXSTRING rxmsq_retc; /* Pointer to dequeued entry */
533  /* buffer. User allocated. */
534 } RXMSQPLL_PARM;
535 
536 
537 /*** Subfunction RXMSQPSH -- Push Entry on Queue */
538 typedef struct _RXMSQ_FLAGS { /* fl */
539  unsigned rxfmlifo : 1; /* Stack entry LIFO if set */
540 } RXMSQ_FLAGS;
541 
542 
543 typedef struct _RXMSQPSH_PARM { /* psh */
544  RXMSQ_FLAGS rxmsq_flags; /* LIFO/FIFO flag */
545  CONSTANT_RXSTRING rxmsq_value; /* The entry to be pushed. */
546 } RXMSQPSH_PARM;
547 
548 
549 /*** Subfunction RXMSQSIZ -- Return the Current Queue Size */
550 
551 typedef struct _RXMSQSIZ_PARM { /* siz */
552  size_t rxmsq_size; /* Number of Lines in Queue */
553 } RXMSQSIZ_PARM;
554 
555 
556 /*** Subfunction RXMSQNAM -- Set Current Queue Name */
557 
558 typedef struct _RXMSQNAM_PARM { /* nam */
559  RXSTRING rxmsq_name; /* RXSTRING containing */
560  /* queue name. */
561 } RXMSQNAM_PARM;
562 
563 
564 /*** Subfunction RXSIOSAY -- Perform SAY Clause */
565 
566 typedef struct _RXSIOSAY_PARM { /* say */
567  CONSTANT_RXSTRING rxsio_string; /* String to display. */
568 } RXSIOSAY_PARM;
569 
570 
571 /*** Subfunction RXSIOTRC -- Write Trace Output */
572 
573 typedef struct _RXSIOTRC_PARM { /* trcparm */
574  CONSTANT_RXSTRING rxsio_string; /* Trace line to display. */
575 } RXSIOTRC_PARM;
576 
577 
578 /*** Subfunction RXSIOTRD -- Read Input from the Terminal */
579 
580 typedef struct _RXSIOTRD_PARM { /* trd */
581  RXSTRING rxsiotrd_retc; /* RXSTRING for output. */
582 } RXSIOTRD_PARM;
583 
584 
585 /*** Subfunction RXSIODTR -- Read Debug Input from the Terminal */
586 
587 typedef struct _RXSIODTR_PARM { /* dtr */
588  RXSTRING rxsiodtr_retc; /* RXSTRING for output. */
589 } RXSIODTR_PARM;
590 
591 
592 /*** Subfunction RXHSTTST -- Test for HALT Condition */
593 
594 typedef struct _RXHLT_FLAGS { /* fl Halt flag */
595  unsigned rxfhhalt : 1; /* Set if HALT occurred. */
596 } RXHLT_FLAGS;
597 
598 typedef struct _RXHLTTST_PARM { /* tst */
599  RXHLT_FLAGS rxhlt_flags; /* Set if HALT occurred */
600 } RXHLTTST_PARM;
601 
602 
603 /*** Subfunction RXTRCTST -- Test for TRACE Condition */
604 
605 typedef struct _RXTRC_FLAGS { /* fl Trace flags */
606  unsigned rxftrace : 1; /* Set to run external trace. */
607 } RXTRC_FLAGS;
608 
609 
610 typedef struct _RXTRCTST_PARM { /* tst */
611  RXTRC_FLAGS rxtrc_flags; /* Set to run external trace */
612 } RXTRCTST_PARM;
613 
614 
615 typedef struct _RXVARNOVALUE_PARM { /* var */
616  RexxStringObject variable_name; // the request variable name
617  RexxObjectPtr value; // returned variable value
619 
620 
621 typedef struct _RXVALCALL_PARM { /* val */
622  RexxStringObject selector; // the environment selector name
623  RexxStringObject variable_name; // the request variable name
624  RexxObjectPtr value; // returned variable value
626 
627 /* This typedef simplifies coding of an Exit handler. */
628 typedef int REXXENTRY RexxExitHandler(int, int, PEXIT);
629 
630 
631 /*** RexxRegisterExitDll - Register a system exit. */
632 
634  CONSTANT_STRING, /* Name of the exit handler */
635  CONSTANT_STRING, /* Name of the DLL */
636  CONSTANT_STRING, /* Name of the procedure */
637  CONSTANT_STRING, /* User area */
638  size_t); /* Drop authority */
640  char *, size_t);
641 #define REXXREGISTEREXITDLL RexxRegisterExitDll
642 
643 
644 /*** RexxRegisterExitExe - Register a system exit. */
645 
647  CONSTANT_STRING, /* Name of the exit handler */
648  REXXPFN, /* Address of exit handler */
649  CONSTANT_STRING); /* User area */
651 #define REXXREGISTEREXITEXE RexxRegisterExitExe
652 
653 
654 /*** RexxDeregisterExit - Drop registration of a system exit. */
655 
657  CONSTANT_STRING, /* Exit name */
658  CONSTANT_STRING) ; /* DLL module name */
660 #define REXXDEREGISTEREXIT RexxDeregisterExit
661 
662 
663 /*** RexxQueryExit - Query an exit for existance. */
664 
666  CONSTANT_STRING, /* Exit name */
667  CONSTANT_STRING, /* DLL Module name. */
668  unsigned short *, /* Existance flag. */
669  char * ); /* User data. */
671 #define REXXQUERYEXIT RexxQueryExit
672 
673 
674 /*----------------------------------------------------------------------------*/
675 /*** Asynchronous Request Interface */
676 /*----------------------------------------------------------------------------*/
677 
678 /*** RexxSetHalt - Request Program Halt */
679 
681  process_id_t, /* Process Id */
682  thread_id_t); /* Thread Id */
684 #define REXXSETHALT RexxSetHalt
685 
686 
687 /*** RexxSetTrace - Request Program Trace */
688 
690  process_id_t, /* Process Id */
691  thread_id_t); /* Thread Id */
693 #define REXXSETTRACE RexxSetTrace
694 
695 
696 /*** RexxResetTrace - Turn Off Program Trace */
697 
699  process_id_t, /* Process Id */
700  thread_id_t); /* Thread Id */
702 #define REXXRESETTRACE RexxResetTrace
703 
704 
705 /*----------------------------------------------------------------------------*/
706 /*** Macro Space Interface */
707 /*----------------------------------------------------------------------------*/
708 
709 /*** RexxAddMacro - Register a function in the Macro Space */
710 
712  CONSTANT_STRING, /* Function to add or change */
713  CONSTANT_STRING, /* Name of file to get function*/
714  size_t); /* Flag indicating search pos */
716 #define REXXADDMACRO RexxAddMacro
717 
718 
719 /*** RexxDropMacro - Remove a function from the Macro Space */
720 
722  CONSTANT_STRING); /* Name of function to remove */
724 #define REXXDROPMACRO RexxDropMacro
725 
726 
727 /*** RexxSaveMacroSpace - Save Macro Space functions to a file */
728 
730  size_t, /* Argument count (0==save all)*/
731  CONSTANT_STRING *, /* List of funct names to save */
732  CONSTANT_STRING); /* File to save functions in */
734 #define REXXSAVEMACROSPACE RexxSaveMacroSpace
735 
736 
737 /*** RexxLoadMacroSpace - Load Macro Space functions from a file */
738 
740  size_t, /* Argument count (0==load all)*/
741  CONSTANT_STRING *, /* List of funct names to load */
742  CONSTANT_STRING); /* File to load functions from */
744 #define REXXLOADMACROSPACE RexxLoadMacroSpace
745 
746 
747 /*** RexxQueryMacro - Find a function's search-order position */
748 
750  CONSTANT_STRING, /* Function to search for */
751  unsigned short * ); /* Ptr for position flag return*/
753 #define REXXQUERYMACRO RexxQueryMacro
754 
755 
756 /*** RexxReorderMacro - Change a function's search-order */
757 /*** position */
758 
760  CONSTANT_STRING, /* Name of funct change order */
761  size_t); /* New position for function */
763 #define REXXREORDERMACRO RexxReorderMacro
764 
765 
766 /*** RexxClearMacroSpace - Remove all functions from a MacroSpace */
767 
769  void ); /* No Arguments. */
771 #define REXXCLEARMACROSPACE RexxClearMacroSpace
772 
773 
774 /*----------------------------------------------------------------------------*/
775 /*** Queing Services */
776 /*----------------------------------------------------------------------------*/
777 
778 #define MAX_QUEUE_NAME_LENGTH 250
779 
780 /*** RexxCreateQueue - Create an External Data Queue */
781 
783  char *, /* Name of queue created */
784  size_t, /* Size of buf for ret name */
785  CONSTANT_STRING, /* Requested name for queue */
786  size_t *); /* Duplicate name flag. */
787 typedef RexxReturnCode (REXXENTRY *PFNREXXCREATEQUEUE)(char *, size_t, CONSTANT_STRING, size_t);
788 
789 /*** RexxOpenQueue - Create a named external queue, if necessary */
790 
792  CONSTANT_STRING, /* Requested name for queue */
793  size_t *); /* Flag for already created queue */
795 
796 
797 /*** RexxQueueExists - Check for the existance of an external data queue */
798 
800  CONSTANT_STRING); /* Name of queue to be deleted */
802 
803 /*** RexxDeleteQueue - Delete an External Data Queue */
804 
806  CONSTANT_STRING); /* Name of queue to be deleted */
808 
809 
810 /*** RexxQueryQueue - Query an External Data Queue for number of */
811 /*** entries */
812 
814  CONSTANT_STRING, /* Name of queue to query */
815  size_t *); /* Place to put element count */
817 
818 
819 /*** RexxAddQueue - Add an entry to an External Data Queue */
820 
822  CONSTANT_STRING, /* Name of queue to add to */
823  PCONSTRXSTRING, /* Data string to add */
824  size_t); /* Queue type (FIFO|LIFO) */
826 
827 /*** RexxPullFromQueue - Retrieve data from an External Data Queue */
829  CONSTANT_STRING, /* Name of queue to read from */
830  PRXSTRING, /* RXSTRING to receive data */
831  RexxQueueTime *, /* Stor for data date/time */
832  size_t); /* wait status (WAIT|NOWAIT) */
834  size_t);
835 
836 /*** RexxClearQueue - Clear all lines in a queue */
837 
839  CONSTANT_STRING ); /* Name of queue to be deleted */
841 
842 
843 #include "rexxplatformapis.h"
844 
845 /*----------------------------------------------------------------------------*/
846 /*** Memory Allocation Services */
847 /*----------------------------------------------------------------------------*/
848 
849 /*** RexxAllocateMemory */
850 
852  size_t); /* number of bytes to allocate */
853 typedef void *(REXXENTRY *PFNREXXALLOCATEMEMORY)(size_t );
854 
855 
856 /*** RexxFreeMemory */
857 
859  void *); /* pointer to the memory returned by */
860  /* RexxAllocateMemory */
862 
863 
864 END_EXTERN_C()
865 
866 #endif /* REXXSAA_INCLUDED */
867 
_RXEXF_FLAGS
Definition: rexx.h:497
PFNREXXSETTRACE
RexxReturnCode(REXXENTRY * PFNREXXSETTRACE)(process_id_t, thread_id_t)
Definition: rexx.h:692
PFNREXXPULLFROMQUEUE
RexxReturnCode(REXXENTRY * PFNREXXPULLFROMQUEUE)(CSTRING, PRXSTRING, RexxQueueTime *, size_t)
Definition: rexx.h:833
_RXHLTTST_PARM::rxhlt_flags
RXHLT_FLAGS rxhlt_flags
Definition: rexx.h:599
RexxQueryExit
RexxReturnCode REXXENTRY RexxQueryExit(CSTRING, CSTRING, unsigned short *, char *)
_RexxConditionData::code
wholenumber_t code
Definition: rexx.h:253
logical_t
size_t logical_t
Definition: rexx.h:230
RexxDirectoryObject
struct _RexxDirectoryObject * RexxDirectoryObject
Definition: rexx.h:137
CSTRING
const typedef char * CSTRING
Definition: rexx.h:78
_SHVBLOCK::shvvaluelen
size_t shvvaluelen
Definition: rexx.h:209
_RXSIODTR_PARM
Definition: rexx.h:587
_RexxQueueTime::minutes
uint16_t minutes
Definition: rexx.h:239
_RXHLT_FLAGS
Definition: rexx.h:594
_RXFNCCAL_PARM::rxfnc_quel
unsigned short rxfnc_quel
Definition: rexx.h:470
_RXMSQPLL_PARM::rxmsq_retc
RXSTRING rxmsq_retc
Definition: rexx.h:532
RexxExitHandler
int REXXENTRY RexxExitHandler(int, int, PEXIT)
Definition: rexx.h:628
_RXEXFCAL_PARM::rxfnc_name
CONSTRXSTRING rxfnc_name
Definition: rexx.h:505
PFNREXXQUERYSUBCOM
RexxReturnCode(REXXENTRY * PFNREXXQUERYSUBCOM)(CSTRING, CSTRING, unsigned short *, char *)
Definition: rexx.h:373
_RXMSQPSH_PARM::rxmsq_value
CONSTRXSTRING rxmsq_value
Definition: rexx.h:545
RXHLT_FLAGS
struct _RXHLT_FLAGS RXHLT_FLAGS
RexxArrayObject
struct _RexxArrayObject * RexxArrayObject
Definition: rexx.h:130
_RXSIOTRD_PARM::rxsiotrd_retc
RXSTRING rxsiotrd_retc
Definition: rexx.h:581
_RXEXF_FLAGS::rxffnfnd
unsigned rxffnfnd
Definition: rexx.h:499
RXSTRING
struct _RXSTRING RXSTRING
RXOFNCCAL_PARM
struct _RXOFNCCAL_PARM RXOFNCCAL_PARM
_RXFNCCAL_PARM::rxfnc_namel
unsigned short rxfnc_namel
Definition: rexx.h:468
PFNREXXTRANSLATEINSTOREPROGRAM
RexxReturnCode(REXXENTRY * PFNREXXTRANSLATEINSTOREPROGRAM)(CSTRING, CONSTRXSTRING *, RXSTRING *)
Definition: rexx.h:320
_RexxQueueTime::day
uint16_t day
Definition: rexx.h:242
_RXMSQNAM_PARM
Definition: rexx.h:558
RexxSaveMacroSpace
RexxReturnCode REXXENTRY RexxSaveMacroSpace(size_t, CSTRING *, CSTRING)
RexxPullFromQueue
RexxReturnCode REXXENTRY RexxPullFromQueue(CSTRING, PRXSTRING, RexxQueueTime *, size_t)
_RXSTRING::strlength
size_t strlength
Definition: rexx.h:157
RexxRegisterExitDll
RexxReturnCode REXXENTRY RexxRegisterExitDll(CSTRING, CSTRING, CSTRING, CSTRING, size_t)
RXCMDHST_PARM
struct _RXCMDHST_PARM RXCMDHST_PARM
PFNREXXTRANSLATEPROGRAM
RexxReturnCode(REXXENTRY * PFNREXXTRANSLATEPROGRAM)(CSTRING, CSTRING, PRXSYSEXIT)
Definition: rexx.h:309
RXSYSEXIT
struct _RXSYSEXIT RXSYSEXIT
RexxReturnCode
int RexxReturnCode
Definition: rexx.h:73
PFNREXXREGISTERFUNCTIONDLL
RexxReturnCode(REXXENTRY * PFNREXXREGISTERFUNCTIONDLL)(CSTRING, CSTRING, CSTRING)
Definition: rexx.h:424
_CONSTRXSTRING::strptr
const char * strptr
Definition: rexx.h:163
rexxapidefs.h
rexxapitypes.h
RexxDeregisterSubcom
RexxReturnCode REXXENTRY RexxDeregisterSubcom(CSTRING, CSTRING)
_RXVARNOVALUE_PARM
Definition: rexx.h:615
_RXTRCTST_PARM::rxtrc_flags
RXTRC_FLAGS rxtrc_flags
Definition: rexx.h:611
rexxplatformdefs.h
RexxBufferObject
struct _RexxBufferObject * RexxBufferObject
Definition: rexx.h:131
RXVARNOVALUE_PARM
struct _RXVARNOVALUE_PARM RXVARNOVALUE_PARM
_RXMSQPSH_PARM::rxmsq_flags
RXMSQ_FLAGS rxmsq_flags
Definition: rexx.h:544
RexxRegisterExitExe
RexxReturnCode REXXENTRY RexxRegisterExitExe(CSTRING, REXXPFN, CSTRING)
_RXFNCCAL_PARM::rxfnc_name
CSTRING rxfnc_name
Definition: rexx.h:467
CONSTRXSTRING
struct _CONSTRXSTRING CONSTRXSTRING
RexxWaitForTermination
void REXXENTRY RexxWaitForTermination(void)
Definition: InterpreterAPI.cpp:428
PSHVBLOCK
SHVBLOCK * PSHVBLOCK
Definition: rexx.h:213
_RXSTRING::strptr
char * strptr
Definition: rexx.h:158
RexxQueryQueue
RexxReturnCode REXXENTRY RexxQueryQueue(CSTRING, size_t *)
PFNREXXQUEUEEXISTS
RexxReturnCode(REXXENTRY * PFNREXXQUEUEEXISTS)(CSTRING)
Definition: rexx.h:801
PFNREXXSHUTDOWNAPI
RexxReturnCode(REXXENTRY * PFNREXXSHUTDOWNAPI)(void)
Definition: rexx.h:299
RXSIOTRD_PARM
struct _RXSIOTRD_PARM RXSIOTRD_PARM
_RXMSQPSH_PARM
Definition: rexx.h:543
_RXSIOTRC_PARM::rxsio_string
CONSTRXSTRING rxsio_string
Definition: rexx.h:574
_RXOFNC_FLAGS::rxffsub
unsigned rxffsub
Definition: rexx.h:482
_RXVARNOVALUE_PARM::variable_name
RexxStringObject variable_name
Definition: rexx.h:616
PFNGETVERSIONINFORMATION
char *(REXXENTRY * PFNGETVERSIONINFORMATION)(void)
Definition: rexx.h:327
RXHLTTST_PARM
struct _RXHLTTST_PARM RXHLTTST_PARM
RexxSubcomHandler
RexxReturnCode REXXENTRY RexxSubcomHandler(PCONSTRXSTRING, unsigned short *, PRXSTRING)
Definition: rexx.h:337
PRXSYSEXIT
RXSYSEXIT * PRXSYSEXIT
Definition: rexx.h:194
_RXEXFCAL_PARM::rxfnc_argv
RexxObjectPtr * rxfnc_argv
Definition: rexx.h:507
PFNREXXSETHALT
RexxReturnCode(REXXENTRY * PFNREXXSETHALT)(process_id_t, thread_id_t)
Definition: rexx.h:683
_RXFNC_FLAGS
Definition: rexx.h:459
PFNREXXDEREGISTERFUNCTION
RexxReturnCode(REXXENTRY * PFNREXXDEREGISTERFUNCTION)(CSTRING)
Definition: rexx.h:441
_RexxConditionData::message
RXSTRING message
Definition: rexx.h:255
_RXVALCALL_PARM::variable_name
RexxStringObject variable_name
Definition: rexx.h:623
PCONSTRXSTRING
CONSTRXSTRING * PCONSTRXSTRING
Definition: rexx.h:186
_RXOFNCCAL_PARM::rxfnc_argv
RexxObjectPtr * rxfnc_argv
Definition: rexx.h:489
_RXFNCCAL_PARM::rxfnc_argv
PCONSTRXSTRING rxfnc_argv
Definition: rexx.h:472
PFNREXXWAITFORTERMINATION
void(REXXENTRY * PFNREXXWAITFORTERMINATION)(void)
Definition: rexx.h:291
RXSIOTRC_PARM
struct _RXSIOTRC_PARM RXSIOTRC_PARM
PFNREXXFREEMEMORY
RexxReturnCode(REXXENTRY * PFNREXXFREEMEMORY)(void *)
Definition: rexx.h:861
_RXCMD_FLAGS::rxfcfail
unsigned rxfcfail
Definition: rexx.h:514
RexxTranslateProgram
RexxReturnCode REXXENTRY RexxTranslateProgram(CSTRING, CSTRING, PRXSYSEXIT)
RexxClassObject
struct _RexxClassObject * RexxClassObject
Definition: rexx.h:136
RexxResetTrace
RexxReturnCode REXXENTRY RexxResetTrace(process_id_t, thread_id_t)
Definition: InterpreterAPI.cpp:363
_RXMSQSIZ_PARM::rxmsq_size
size_t rxmsq_size
Definition: rexx.h:552
RexxBufferStringObject
struct _RexxBufferStringObject * RexxBufferStringObject
Definition: rexx.h:129
RexxLoadMacroSpace
RexxReturnCode REXXENTRY RexxLoadMacroSpace(size_t, CSTRING *, CSTRING)
thread_id_t
pthread_t thread_id_t
Definition: rexxapitypes.h:65
RexxMethodObject
struct _RexxMethodObject * RexxMethodObject
Definition: rexx.h:133
RexxGetVersionInformation
char *REXXENTRY RexxGetVersionInformation(void)
Definition: InterpreterAPI.cpp:233
_RXVARNOVALUE_PARM::value
RexxObjectPtr value
Definition: rexx.h:617
PFNREXXQUERYMACRO
RexxReturnCode(REXXENTRY * PFNREXXQUERYMACRO)(CSTRING, unsigned short *)
Definition: rexx.h:752
_RexxConditionData
Definition: rexx.h:251
PFNREXXREGISTEREXITEXE
RexxReturnCode(REXXENTRY * PFNREXXREGISTEREXITEXE)(CSTRING, REXXPFN, char *)
Definition: rexx.h:650
PFNREXXCLEARMACROSPACE
RexxReturnCode(REXXENTRY * PFNREXXCLEARMACROSPACE)(void)
Definition: rexx.h:770
PFNREXXREGISTEREXITDLL
RexxReturnCode(REXXENTRY * PFNREXXREGISTEREXITDLL)(CSTRING, CSTRING, CSTRING, char *, size_t)
Definition: rexx.h:639
_RexxQueueTime::microseconds
uint32_t microseconds
Definition: rexx.h:246
_RXEXFCAL_PARM
Definition: rexx.h:503
RexxOpenQueue
RexxReturnCode REXXENTRY RexxOpenQueue(CSTRING, size_t *)
_RXSYSEXIT::sysexit_code
int sysexit_code
Definition: rexx.h:192
PFNREXXOPENQUEUE
RexxReturnCode(REXXENTRY * PFNREXXOPENQUEUE)(CSTRING, size_t)
Definition: rexx.h:794
PEXIT
char * PEXIT
Definition: rexx.h:215
_RXCMDHST_PARM::rxcmd_retc
RXSTRING rxcmd_retc
Definition: rexx.h:525
RexxQueueTime
struct _RexxQueueTime RexxQueueTime
_RexxConditionData::rc
wholenumber_t rc
Definition: rexx.h:254
_RXEXFCAL_PARM::rxfnc_argc
size_t rxfnc_argc
Definition: rexx.h:506
RXFNC_FLAGS
struct _RXFNC_FLAGS RXFNC_FLAGS
RexxPackageObject
struct _RexxPackageObject * RexxPackageObject
Definition: rexx.h:135
_RexxQueueTime::weekday
uint16_t weekday
Definition: rexx.h:245
PFNREXXSAVEMACROSPACE
RexxReturnCode(REXXENTRY * PFNREXXSAVEMACROSPACE)(size_t, CSTRING *, CSTRING)
Definition: rexx.h:733
_RXEXFCAL_PARM::rxfnc_flags
RXEXF_FLAGS rxfnc_flags
Definition: rexx.h:504
_RXFNCCAL_PARM::rxfnc_retc
RXSTRING rxfnc_retc
Definition: rexx.h:473
PFNREXXDROPMACRO
RexxReturnCode(REXXENTRY * PFNREXXDROPMACRO)(CSTRING)
Definition: rexx.h:723
RexxPointerObject
struct _RexxPointerObject * RexxPointerObject
Definition: rexx.h:132
RexxRegisterSubcomExe
RexxReturnCode REXXENTRY RexxRegisterSubcomExe(CSTRING, REXXPFN, CSTRING)
process_id_t
pid_t process_id_t
Definition: rexxapitypes.h:64
_RexxQueueTime::yearday
uint32_t yearday
Definition: rexx.h:247
_RexxConditionData::position
size_t position
Definition: rexx.h:257
RexxRoutineHandler
size_t REXXENTRY RexxRoutineHandler(CSTRING, size_t, PCONSTRXSTRING, CSTRING, PRXSTRING)
Definition: rexx.h:406
_RXSIOTRC_PARM
Definition: rexx.h:573
RexxAddMacro
RexxReturnCode REXXENTRY RexxAddMacro(CSTRING, CSTRING, size_t)
_RXEXF_FLAGS::rxffsub
unsigned rxffsub
Definition: rexx.h:500
RexxDropMacro
RexxReturnCode REXXENTRY RexxDropMacro(CSTRING)
_RexxQueueTime::hours
uint16_t hours
Definition: rexx.h:238
RexxAddQueue
RexxReturnCode REXXENTRY RexxAddQueue(CSTRING, PCONSTRXSTRING, size_t)
RXMSQ_FLAGS
struct _RXMSQ_FLAGS RXMSQ_FLAGS
PFNREXXADDMACRO
RexxReturnCode(REXXENTRY * PFNREXXADDMACRO)(CSTRING, CSTRING, size_t)
Definition: rexx.h:715
_RXOFNC_FLAGS::rxfferr
unsigned rxfferr
Definition: rexx.h:480
rexxplatformapis.h
_RXOFNCCAL_PARM::rxfnc_retc
RexxObjectPtr rxfnc_retc
Definition: rexx.h:490
_RXSTRING
Definition: rexx.h:156
RXTRCTST_PARM
struct _RXTRCTST_PARM RXTRCTST_PARM
RXMSQNAM_PARM
struct _RXMSQNAM_PARM RXMSQNAM_PARM
REXXPFN
void * REXXPFN
Definition: rexxapitypes.h:63
PRXSTRING
RXSTRING * PRXSTRING
Definition: rexx.h:185
_SHVBLOCK::shvname
CONSTRXSTRING shvname
Definition: rexx.h:206
RXEXF_FLAGS
struct _RXEXF_FLAGS RXEXF_FLAGS
RexxDidRexxTerminate
RexxReturnCode REXXENTRY RexxDidRexxTerminate(void)
Definition: InterpreterAPI.cpp:441
_RXEXFCAL_PARM::rxfnc_retc
RexxObjectPtr rxfnc_retc
Definition: rexx.h:508
PFNREXXREGISTERSUBCOMDLL
RexxReturnCode(REXXENTRY * PFNREXXREGISTERSUBCOMDLL)(CSTRING, CSTRING, CSTRING, char *, size_t)
Definition: rexx.h:350
_RXCMDHST_PARM::rxcmd_dll
CSTRING rxcmd_dll
Definition: rexx.h:522
_SHVBLOCK::shvnamelen
size_t shvnamelen
Definition: rexx.h:208
PFNREXXREGISTERFUNCTIONEXE
RexxReturnCode(REXXENTRY * PFNREXXREGISTERFUNCTIONEXE)(CSTRING, REXXPFN)
Definition: rexx.h:433
RexxQueueExists
RexxReturnCode REXXENTRY RexxQueueExists(CSTRING)
_CONSTRXSTRING::strlength
size_t strlength
Definition: rexx.h:162
RexxClearQueue
RexxReturnCode REXXENTRY RexxClearQueue(CSTRING)
PFNREXXDEREGISTEREXIT
RexxReturnCode(REXXENTRY * PFNREXXDEREGISTEREXIT)(CSTRING, CSTRING)
Definition: rexx.h:659
RXVALCALL_PARM
struct _RXVALCALL_PARM RXVALCALL_PARM
_RXFNCCAL_PARM::rxfnc_flags
RXFNC_FLAGS rxfnc_flags
Definition: rexx.h:466
RexxSetTrace
RexxReturnCode REXXENTRY RexxSetTrace(process_id_t, thread_id_t)
Definition: InterpreterAPI.cpp:349
_SHVBLOCK::shvvalue
RXSTRING shvvalue
Definition: rexx.h:207
_RXSYSEXIT
Definition: rexx.h:190
RexxQuerySubcom
RexxReturnCode REXXENTRY RexxQuerySubcom(CSTRING, CSTRING, unsigned short *, char *)
RexxRegisterSubcomDll
RexxReturnCode REXXENTRY RexxRegisterSubcomDll(CSTRING, CSTRING, CSTRING, CSTRING, size_t)
_RXCMD_FLAGS::rxfcerr
unsigned rxfcerr
Definition: rexx.h:515
RexxStart
int REXXENTRY RexxStart(size_t, PCONSTRXSTRING, CSTRING, PRXSTRING, CSTRING, int, PRXSYSEXIT, short *, PRXSTRING)
_RXCMDHST_PARM::rxcmd_command
CONSTRXSTRING rxcmd_command
Definition: rexx.h:524
_RXSIOTRD_PARM
Definition: rexx.h:580
RexxMutableBufferObject
struct _RexxMutableBufferObject * RexxMutableBufferObject
Definition: rexx.h:140
_RXOFNCCAL_PARM
Definition: rexx.h:485
_SHVBLOCK
Definition: rexx.h:204
RexxShutDownAPI
RexxReturnCode REXXENTRY RexxShutDownAPI(void)
Definition: RegistrationAPI.cpp:588
RexxSetHalt
RexxReturnCode REXXENTRY RexxSetHalt(process_id_t, thread_id_t)
Definition: InterpreterAPI.cpp:293
_RXCMDHST_PARM::rxcmd_address
CSTRING rxcmd_address
Definition: rexx.h:520
RXTRC_FLAGS
struct _RXTRC_FLAGS RXTRC_FLAGS
_RXHLT_FLAGS::rxfhhalt
unsigned rxfhhalt
Definition: rexx.h:595
_RXCMDHST_PARM::rxcmd_flags
RXCMD_FLAGS rxcmd_flags
Definition: rexx.h:519
RexxAllocateMemory
void *REXXENTRY RexxAllocateMemory(size_t)
Definition: RegistrationAPI.cpp:553
REXXENTRY
#define REXXENTRY
Definition: rexxapitypes.h:61
_RXCMDHST_PARM::rxcmd_dll_len
unsigned short rxcmd_dll_len
Definition: rexx.h:523
_RexxQueueTime::month
uint16_t month
Definition: rexx.h:243
_RXFNCCAL_PARM::rxfnc_argc
unsigned short rxfnc_argc
Definition: rexx.h:471
_RexxConditionData::program
RXSTRING program
Definition: rexx.h:258
RXMSQPLL_PARM
struct _RXMSQPLL_PARM RXMSQPLL_PARM
_RXSYSEXIT::sysexit_name
CSTRING sysexit_name
Definition: rexx.h:191
PFNREXXREGISTERSUBCOMEXE
RexxReturnCode(REXXENTRY * PFNREXXREGISTERSUBCOMEXE)(CSTRING, REXXPFN, char *)
Definition: rexx.h:362
_SHVBLOCK::shvcode
unsigned char shvcode
Definition: rexx.h:210
RexxVariablePool
RexxReturnCode REXXENTRY RexxVariablePool(PSHVBLOCK)
Definition: InterpreterAPI.cpp:392
_RXCMDHST_PARM
Definition: rexx.h:518
_RXMSQ_FLAGS
Definition: rexx.h:538
_SHVBLOCK::shvret
unsigned char shvret
Definition: rexx.h:211
RexxConditionData
struct _RexxConditionData RexxConditionData
_RexxQueueTime::year
uint16_t year
Definition: rexx.h:244
CONSTANT_STRING
#define CONSTANT_STRING
Definition: rexx.h:168
RexxDeregisterFunction
RexxReturnCode REXXENTRY RexxDeregisterFunction(CSTRING)
_SHVBLOCK::shvnext
struct _SHVBLOCK * shvnext
Definition: rexx.h:205
_RXHLTTST_PARM
Definition: rexx.h:598
BEGIN_EXTERN_C
#define BEGIN_EXTERN_C()
Definition: rexx.h:60
_RXTRCTST_PARM
Definition: rexx.h:610
PFNREXXDELETEQUEUE
RexxReturnCode(REXXENTRY * PFNREXXDELETEQUEUE)(CSTRING)
Definition: rexx.h:807
SHVBLOCK
struct _SHVBLOCK SHVBLOCK
PFNREXXSTART
RexxReturnCode(REXXENTRY * PFNREXXSTART)(size_t, PCONSTRXSTRING, CSTRING, PRXSTRING, CSTRING, int, PRXSYSEXIT, short *, PRXSTRING)
Definition: rexx.h:283
RXOFNC_FLAGS
struct _RXOFNC_FLAGS RXOFNC_FLAGS
RXMSQSIZ_PARM
struct _RXMSQSIZ_PARM RXMSQSIZ_PARM
_RXFNCCAL_PARM::rxfnc_que
CSTRING rxfnc_que
Definition: rexx.h:469
PFNREXXCLEARQUEUE
RexxReturnCode(REXXENTRY * PFNREXXCLEARQUEUE)(CSTRING)
Definition: rexx.h:840
RexxClearMacroSpace
RexxReturnCode REXXENTRY RexxClearMacroSpace(void)
Definition: MacroSpaceApi.cpp:113
_RXFNC_FLAGS::rxfferr
unsigned rxfferr
Definition: rexx.h:460
PFNREXXQUERYEXIT
RexxReturnCode(REXXENTRY * PFNREXXQUERYEXIT)(CSTRING, CSTRING, unsigned short *, char *)
Definition: rexx.h:670
wholenumber_t
ssize_t wholenumber_t
Definition: rexx.h:229
_RXOFNCCAL_PARM::rxfnc_argc
size_t rxfnc_argc
Definition: rexx.h:488
RexxRoutineObject
struct _RexxRoutineObject * RexxRoutineObject
Definition: rexx.h:134
RXSIODTR_PARM
struct _RXSIODTR_PARM RXSIODTR_PARM
PFNREXXALLOCATEMEMORY
void *(REXXENTRY * PFNREXXALLOCATEMEMORY)(size_t)
Definition: rexx.h:853
PFNREXXDIDREXXTERMINATE
RexxReturnCode(REXXENTRY * PFNREXXDIDREXXTERMINATE)(void)
Definition: rexx.h:295
_RXOFNCCAL_PARM::rxfnc_name
CONSTRXSTRING rxfnc_name
Definition: rexx.h:487
RXSIOSAY_PARM
struct _RXSIOSAY_PARM RXSIOSAY_PARM
_RXTRC_FLAGS
Definition: rexx.h:605
RexxCreateQueue
RexxReturnCode REXXENTRY RexxCreateQueue(char *, size_t, CSTRING, size_t *)
_RXSIODTR_PARM::rxsiodtr_retc
RXSTRING rxsiodtr_retc
Definition: rexx.h:588
stringsize_t
size_t stringsize_t
Definition: rexx.h:228
RexxRegisterFunctionDll
RexxReturnCode REXXENTRY RexxRegisterFunctionDll(CSTRING, CSTRING, CSTRING)
RexxFunctionHandler
size_t REXXENTRY RexxFunctionHandler(CSTRING, size_t, PCONSTRXSTRING, CSTRING, PRXSTRING)
Definition: rexx.h:412
_RXTRC_FLAGS::rxftrace
unsigned rxftrace
Definition: rexx.h:606
POINTER
void * POINTER
Definition: rexx.h:79
PFNREXXCREATEQUEUE
RexxReturnCode(REXXENTRY * PFNREXXCREATEQUEUE)(char *, size_t, CSTRING, size_t)
Definition: rexx.h:787
RexxRegisterFunctionExe
RexxReturnCode REXXENTRY RexxRegisterFunctionExe(CSTRING, REXXPFN)
_RXMSQSIZ_PARM
Definition: rexx.h:551
RexxQueryFunction
RexxReturnCode REXXENTRY RexxQueryFunction(CSTRING)
_RXSIOSAY_PARM::rxsio_string
CONSTRXSTRING rxsio_string
Definition: rexx.h:567
_RexxQueueTime::seconds
uint16_t seconds
Definition: rexx.h:240
RXEXFCAL_PARM
struct _RXEXFCAL_PARM RXEXFCAL_PARM
_RXOFNC_FLAGS
Definition: rexx.h:479
_RXVALCALL_PARM::value
RexxObjectPtr value
Definition: rexx.h:624
_RXOFNCCAL_PARM::rxfnc_flags
RXOFNC_FLAGS rxfnc_flags
Definition: rexx.h:486
_RXCMDHST_PARM::rxcmd_addressl
unsigned short rxcmd_addressl
Definition: rexx.h:521
PFNREXXQUERYQUEUE
RexxReturnCode(REXXENTRY * PFNREXXQUERYQUEUE)(CSTRING, size_t *)
Definition: rexx.h:816
_RexxConditionData::errortext
RXSTRING errortext
Definition: rexx.h:256
_RexxQueueTime::hundredths
uint16_t hundredths
Definition: rexx.h:241
PFNREXXLOADMACROSPACE
RexxReturnCode(REXXENTRY * PFNREXXLOADMACROSPACE)(size_t, CSTRING *, CSTRING)
Definition: rexx.h:743
PFNREXXREORDERMACRO
RexxReturnCode(REXXENTRY * PFNREXXREORDERMACRO)(CSTRING, size_t)
Definition: rexx.h:762
PFNREXXRESETTRACE
RexxReturnCode(REXXENTRY * PFNREXXRESETTRACE)(process_id_t, thread_id_t)
Definition: rexx.h:701
RXMSQPSH_PARM
struct _RXMSQPSH_PARM RXMSQPSH_PARM
RexxSupplierObject
struct _RexxSupplierObject * RexxSupplierObject
Definition: rexx.h:138
RexxFreeMemory
RexxReturnCode REXXENTRY RexxFreeMemory(void *)
Definition: RegistrationAPI.cpp:575
_RXMSQPLL_PARM
Definition: rexx.h:531
_RXFNC_FLAGS::rxffsub
unsigned rxffsub
Definition: rexx.h:462
RexxReorderMacro
RexxReturnCode REXXENTRY RexxReorderMacro(CSTRING, size_t)
_RXMSQNAM_PARM::rxmsq_name
RXSTRING rxmsq_name
Definition: rexx.h:559
RexxDeleteQueue
RexxReturnCode REXXENTRY RexxDeleteQueue(CSTRING)
PFNREXXVARIABLEPOOL
RexxReturnCode(REXXENTRY * PFNREXXVARIABLEPOOL)(PSHVBLOCK)
Definition: rexx.h:396
RexxStemObject
struct _RexxStemObject * RexxStemObject
Definition: rexx.h:139
_RXMSQ_FLAGS::rxfmlifo
unsigned rxfmlifo
Definition: rexx.h:539
_RXSIOSAY_PARM
Definition: rexx.h:566
CONSTANT_RXSTRING
#define CONSTANT_RXSTRING
Definition: rexx.h:167
RXFNCCAL_PARM
struct _RXFNCCAL_PARM RXFNCCAL_PARM
_RXEXF_FLAGS::rxfferr
unsigned rxfferr
Definition: rexx.h:498
PFNREXXQUERYFUNCTION
RexxReturnCode(REXXENTRY * PFNREXXQUERYFUNCTION)(CSTRING)
Definition: rexx.h:449
RexxTranslateInstoreProgram
RexxReturnCode REXXENTRY RexxTranslateInstoreProgram(CSTRING, CONSTRXSTRING *, RXSTRING *)
_RexxQueueTime
Definition: rexx.h:237
RexxStringObject
struct _RexxStringObject * RexxStringObject
Definition: rexx.h:128
_RXCMD_FLAGS
Definition: rexx.h:513
_RXOFNC_FLAGS::rxffnfnd
unsigned rxffnfnd
Definition: rexx.h:481
_RXVALCALL_PARM
Definition: rexx.h:621
RexxDeregisterExit
RexxReturnCode REXXENTRY RexxDeregisterExit(CSTRING, CSTRING)
_CONSTRXSTRING
Definition: rexx.h:161
END_EXTERN_C
#define END_EXTERN_C()
Definition: rexx.h:61
_RXFNCCAL_PARM
Definition: rexx.h:465
RexxObjectPtr
struct _RexxObjectPtr * RexxObjectPtr
Definition: rexx.h:127
PFNREXXDEREGISTERSUBCOM
RexxReturnCode(REXXENTRY * PFNREXXDEREGISTERSUBCOM)(CSTRING, CSTRING)
Definition: rexx.h:384
PFNREXXADDQUEUE
RexxReturnCode(REXXENTRY * PFNREXXADDQUEUE)(CSTRING, PCONSTRXSTRING, size_t)
Definition: rexx.h:825
_RXFNC_FLAGS::rxffnfnd
unsigned rxffnfnd
Definition: rexx.h:461
RexxQueryMacro
RexxReturnCode REXXENTRY RexxQueryMacro(CSTRING, unsigned short *)
_RXVALCALL_PARM::selector
RexxStringObject selector
Definition: rexx.h:622
RXCMD_FLAGS
struct _RXCMD_FLAGS RXCMD_FLAGS