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)  

oorexxapi.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 /* ooRexx Macros */
40 /* */
41 /* Header file for ooRexx methods written in C. */
42 /* */
43 /******************************************************************************/
44 #ifndef RexxNativeInterface_Included
45 #define RexxNativeInterface_Included
46 
47 #include "rexx.h"
48 #include "oorexxerrors.h"
49 
50 
51 /******************************************************************************/
52 /* Interface Datatypes (used in macro expansions) */
53 /******************************************************************************/
54 #define REXX_ARGUMENT_TERMINATOR 0
55 #define REXX_VALUE_ARGLIST 2
56 #define REXX_VALUE_NAME 3
57 #define REXX_VALUE_SCOPE 4
58 #define REXX_VALUE_CSELF 5
59 #define REXX_VALUE_OSELF 6
60 #define REXX_VALUE_SUPER 7
61 
62 // each of the following types have an optional equivalent
63 
64 #define REXX_VALUE_RexxObjectPtr 11
65 #define REXX_VALUE_int 12
66 #define REXX_VALUE_wholenumber_t 13
67 #define REXX_VALUE_double 14
68 #define REXX_VALUE_CSTRING 15
69 #define REXX_VALUE_POINTER 16
70 #define REXX_VALUE_RexxStringObject 17
71 #define REXX_VALUE_stringsize_t 18
72 #define REXX_VALUE_float 19
73 #define REXX_VALUE_int8_t 20
74 #define REXX_VALUE_int16_t 21
75 #define REXX_VALUE_int32_t 22
76 #define REXX_VALUE_int64_t 23
77 #define REXX_VALUE___int64_t 23
78 #define REXX_VALUE_uint8_t 24
79 #define REXX_VALUE_uint16_t 25
80 #define REXX_VALUE_uint32_t 26
81 #define REXX_VALUE_uint64_t 27
82 #define REXX_VALUE___uint64_t 27 -- aliased
83 #define REXX_VALUE_intptr_t 28
84 #define REXX_VALUE_uintptr_t 29
85 #define REXX_VALUE___uintptr_t 29 -- aliased
86 #define REXX_VALUE_logical_t 30
87 #define REXX_VALUE_RexxArrayObject 31
88 #define REXX_VALUE_RexxStemObject 32
89 #define REXX_VALUE_size_t 33
90 #define REXX_VALUE_ssize_t 34
91 #define REXX_VALUE_POINTERSTRING 35
92 #define REXX_VALUE_RexxClassObject 36
93 #define REXX_VALUE_RexxMutableBufferObject 37
94 
95 #define REXX_OPTIONAL_ARGUMENT 0x8000
96 
97 #define REXX_VALUE_OPTIONAL_RexxObjectPtr (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_RexxObjectPtr)
98 #define REXX_VALUE_OPTIONAL_int (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_int)
99 #define REXX_VALUE_OPTIONAL_wholenumber_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_wholenumber_t)
100 #define REXX_VALUE_OPTIONAL_double (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_double)
101 #define REXX_VALUE_OPTIONAL_CSTRING (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_CSTRING)
102 #define REXX_VALUE_OPTIONAL_POINTER (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_POINTER)
103 #define REXX_VALUE_OPTIONAL_RexxStringObject (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_RexxStringObject)
104 #define REXX_VALUE_OPTIONAL_stringsize_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_stringsize_t)
105 #define REXX_VALUE_OPTIONAL_float (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_float)
106 #define REXX_VALUE_OPTIONAL_int8_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_int8_t)
107 #define REXX_VALUE_OPTIONAL_int16_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_int16_t)
108 #define REXX_VALUE_OPTIONAL_int32_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_int32_t)
109 #define REXX_VALUE_OPTIONAL_int64_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_int64_t)
110 #define REXX_VALUE_OPTIONAL_uint8_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_uint8_t)
111 #define REXX_VALUE_OPTIONAL_uint16_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_uint16_t)
112 #define REXX_VALUE_OPTIONAL_uint32_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_uint32_t)
113 #define REXX_VALUE_OPTIONAL_uint64_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_uint64_t)
114 #define REXX_VALUE_OPTIONAL_size_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_size_t)
115 #define REXX_VALUE_OPTIONAL_ssize_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_ssize_t)
116 #define REXX_VALUE_OPTIONAL_intptr_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_intptr_t)
117 #define REXX_VALUE_OPTIONAL_uintptr_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_uintptr_t)
118 #define REXX_VALUE_OPTIONAL_logical_t (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_logical_t)
119 #define REXX_VALUE_OPTIONAL_RexxArrayObject (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_RexxArrayObject)
120 #define REXX_VALUE_OPTIONAL_RexxStemObject (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_RexxStemObject)
121 #define REXX_VALUE_OPTIONAL_POINTERSTRING (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_POINTERSTRING)
122 #define REXX_VALUE_OPTIONAL_RexxClassObject (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_RexxClassObject)
123 #define REXX_VALUE_OPTIONAL_RexxMutableBufferObject (REXX_OPTIONAL_ARGUMENT | REXX_VALUE_RexxMutableBufferObject)
124 
126 
127 // forward defininitions of the context structure types
128 struct RexxInstance_;
129 #ifdef __cplusplus
131 #else
132 typedef const struct RexxInstance_ *RexxInstance;
133 #endif
134 
135 struct RexxThreadContext_;
136 #ifdef __cplusplus
138 #else
139 typedef const struct RexxThreadContext_ *RexxThreadContext;
140 #endif
141 
142 struct RexxMethodContext_;
143 #ifdef __cplusplus
145 #else
146 typedef const struct RexxMethodContext_ *RexxMethodContext;
147 #endif
148 
149 struct RexxCallContext_;
150 #ifdef __cplusplus
152 #else
153 typedef const struct RexxCallContext_ *RexxCallContext;
154 #endif
155 
156 struct RexxExitContext_;
157 #ifdef __cplusplus
159 #else
160 typedef const struct RexxExitContext_ *RexxExitContext;
161 #endif
162 
163 
164 /* This typedef simplifies coding of an Exit handler. */
166 
167 
168 
169 typedef struct _RexxContextExit
170 {
171  RexxContextExitHandler *handler; /* subcom enviro for sysexit */
172  int sysexit_code; /* sysexit function code */
174 
175 
176 typedef struct _RexxRoutineEntry
177 {
178  int style; // function call style
179  int reserved1; // reserved for future use
180  const char *name; // name of the function
181  void *entryPoint; // resolved function entry point
182  int reserved2; // reserved for future use
183  int reserved3; // reserved for future use
185 
186 #define ROUTINE_TYPED_STYLE 1
187 #define ROUTINE_CLASSIC_STYLE 2
188 
189 #define REXX_ROUTINE(s, n, e) { s, 0, #n, (void *)e, 0, 0 }
190 
191 #define REXX_TYPED_ROUTINE(n, e) REXX_ROUTINE(ROUTINE_TYPED_STYLE, n, e)
192 #define REXX_CLASSIC_ROUTINE(n, e) REXX_ROUTINE(ROUTINE_CLASSIC_STYLE, n, e)
193 #define REXX_LAST_ROUTINE() { 0, 0, NULL, (void *)NULL, 0, 0 }
194 
195 #define REXX_CLASSIC_ROUTINE_PROTOTYPE(name) size_t RexxEntry name(const char *, size_t, CONSTRXSTRING *, const char *, RXSTRING *)
196 
197 typedef struct _RexxMethodEntry
198 {
199  int style; // function call style
200  int reserved1; // reserved for future use
201  const char *name; // name of the method
202  void *entryPoint; // resolved function entry point
203  int reserved2; // reserved for future use
204  int reserved3; // reserved for future use
206 
207 #define METHOD_TYPED_STYLE 1
208 
209 #define REXX_METHOD_ENTRY(n, e) { METHOD_TYPED_STYLE, 0, #n, (void *)e, 0, 0 }
210 
211 #define REXX_METHOD(n, e) REXX_METHOD_ENTRY(n, e)
212 #define REXX_LAST_METHOD() { 0, 0, NULL, (void *)NULL, 0, 0 }
213 
214 #define REXX_PACKAGE_API_NO 20081030
215 // The interpreter version gets defined using two digits for major, minor, and revision.
216 #define REXX_INTERPRETER_4_0_0 0x00040000
217 #define REXX_INTERPRETER_4_0_1 0x00040001
218 #define REXX_INTERPRETER_4_1_0 0x00040100
219 #define REXX_INTERPRETER_4_1_1 0x00040101
220 #define REXX_INTERPRETER_4_1_2 0x00040102
221 #define REXX_INTERPRETER_4_1_3 0x00040103
222 #define REXX_INTERPRETER_4_2_0 0x00040200
223 #define REXX_CURRENT_INTERPRETER_VERSION REXX_INTERPRETER_4_2_0
224 #define NO_VERSION_YET NULL
225 
226 #define REXX_LANGUAGE_6_03 0x00000603
227 #define REXX_LANGUAGE_6_04 0x00000604
228 #define REXX_CURRENT_LANGUAGE_LEVEL REXX_LANGUAGE_6_04
229 
230 #define STANDARD_PACKAGE_HEADER sizeof(RexxPackageEntry), REXX_PACKAGE_API_NO,
231 
232 #define OOREXX_GET_PACKAGE(name) \
233  BEGIN_EXTERN_C()\
234  RexxPackageEntry *RexxEntry RexxGetPackage(void) { return &name##_package_entry; }\
235  END_EXTERN_C()
236 
237 
240 
241 typedef struct _RexxPackageEntry
242 {
243  int size; // size of the structure...helps compatibility
244  int apiVersion; // version this was compiled with
245  int requiredVersion; // minimum required interpreter version (0 means any)
246  const char *packageName; // package identifier
247  const char *packageVersion; // package version #
248  RexxPackageLoader loader; // the package loader
249  RexxPackageUnloader unloader; // the package unloader
250  struct _RexxRoutineEntry *routines; // routines contained in this package
251  struct _RexxMethodEntry *methods; // methods contained in this package
253 
254 END_EXTERN_C()
255 
256 // argument existence indicator
257 #define ARGUMENT_EXISTS 0x01
258 // the argument is a "special" virtual argument derived from context
259 #define SPECIAL_ARGUMENT 0x02
260 
261 typedef struct
262 {
263 // union containing argument values for each of the passable/returnable
264 // types from a method/function call. The arguments are pass/retrieved
265 // using the appropriate type names, which bypasses any endian issues of
266 // how different sized values might be stored with a union.
267  union
268  {
281  double value_double;
285  float value_float;
286  int8_t value_int8_t;
287  int16_t value_int16_t;
288  int32_t value_int32_t;
289  int64_t value_int64_t;
291  uint8_t value_uint8_t;
292  uint16_t value_uint16_t;
293  uint32_t value_uint32_t;
294  uint64_t value_uint64_t;
296  intptr_t value_intptr_t;
297  uintptr_t value_uintptr_t;
298  uintptr_t value___uintptr_t;
299  size_t value_size_t;
300  ssize_t value_ssize_t;
305 
306  // following just duplicate the non-optional variations...
307  // it was difficult (if not impossible) to get the
308  // preprocessor to generate a mapped symbol name.
336  } value;
337 
338  uint16_t type; // type of the value
339  uint16_t flags; // argument flags
340 
341 
342 // these methods are only available for C++ code
343 #ifdef __cplusplus
344  inline operator RexxObjectPtr() { return value.value_RexxObjectPtr; }
345  inline void operator=(RexxObjectPtr o) { type = REXX_VALUE_RexxObjectPtr; value.value_RexxObjectPtr = o; }
346  inline operator RexxStringObject() { return value.value_RexxStringObject; }
347  inline void operator=(RexxStringObject o) { type = REXX_VALUE_RexxStringObject; value.value_RexxStringObject = o; }
348  inline operator RexxArrayObject() { return value.value_RexxArrayObject; }
349  inline void operator=(RexxArrayObject o) { type = REXX_VALUE_RexxArrayObject; value.value_RexxArrayObject = o; }
350  inline operator RexxStemObject() { return value.value_RexxStemObject; }
351  inline void operator=(RexxStemObject o) { type = REXX_VALUE_RexxStemObject; value.value_RexxStemObject = o; }
352  inline operator RexxMutableBufferObject() { return value.value_RexxMutableBufferObject; }
353  inline void operator=(RexxMutableBufferObject o) { type = REXX_VALUE_RexxMutableBufferObject; value.value_RexxMutableBufferObject = o; }
354  inline operator CSTRING() { return value.value_CSTRING; }
355  inline void operator=(CSTRING o) { type = REXX_VALUE_CSTRING; value.value_CSTRING = o; }
356  inline operator POINTER() { return value.value_POINTER; }
357  inline void operator=(POINTER o) { type = REXX_VALUE_POINTER; value.value_POINTER = o; }
358  inline operator wholenumber_t() { return value.value_wholenumber_t; }
359  inline void operator=(wholenumber_t o) { type = REXX_VALUE_wholenumber_t; value.value_wholenumber_t = o; }
360  inline operator stringsize_t() { return value.value_stringsize_t; }
361  inline void operator=(float o) { type = REXX_VALUE_float; value.value_float = o; }
362  inline operator float() { return value.value_float; }
363  inline operator double() { return value.value_double; }
364  inline void operator=(double o) { type = REXX_VALUE_double; value.value_double = o; }
365 #endif
367 
368 
369 // The initial address environment, passed as a CSTRING value.
370 #define INITIAL_ADDRESS_ENVIRONMENT "InitialAddress"
371 // Opaque user data, passed as a POINTER value.
372 #define APPLICATION_DATA "ApplicationData"
373 // External function search path
374 #define EXTERNAL_CALL_PATH "ExternalCallPath"
375 // list of lookup extensions to search for on external calls
376 #define EXTERNAL_CALL_EXTENSIONS "ExternalCallPathExt"
377 // a library that will be loaded during initialization
378 // specified as a CSTRING name
379 #define LOAD_REQUIRED_LIBRARY "LoadRequiredLibrary"
380 // The set of exits to use. These are old-style exits, using registered exit names.
381 #define REGISTERED_EXITS "RegisteredExits"
382 // The set of exits to use. These are new-style exits, using direct exit addresses and
383 // the object oriented RexxExitContext calling convention.
384 #define DIRECT_EXITS "DirectExits"
385 // The set of command envronments to use. These use registered command handler names.
386 #define REGISTERED_ENVIRONMENTS "RegisteredEnvironments"
387 // The set of command environments to use. These are direct call addresses using the
388 // object-oriented calling convetion.
389 #define DIRECT_ENVIRONMENTS "DirectEnvironments"
390 // register a library for an in-process package
391 #define REGISTER_LIBRARY "RegisterLibrary"
392 
393 
394 /* This typedef simplifies coding of an Exit handler. */
396 
397 
398 typedef struct
399 {
400  RexxContextCommandHandler *handler; // the environment handler
401  const char *name; // the handler name
403 
404 typedef struct
405 {
406  const char *registeredName; // the environment handler
407  const char *name; // the handler name
409 
410 typedef struct
411 {
412  const char *registeredName; // the package name (case sensitive)
413  RexxPackageEntry *table; // the package table associated with the package
415 
416 typedef struct
417 {
418  const char *optionName; // name of the option
419  ValueDescriptor option; // a value appropriate to the option
420 } RexxOption;
421 
422 
423 typedef struct {
424  wholenumber_t code; // full condition code
425  wholenumber_t rc; // return code value
426  size_t position; // line number position
427  RexxStringObject conditionName; // name of the condition
428  RexxStringObject message; // fully filled in message
429  RexxStringObject errortext; // major error text
430  RexxStringObject program; // program name
431  RexxStringObject description; // program name
432  RexxArrayObject additional; // additional information
433 } RexxCondition;
434 
435 #define INSTANCE_INTERFACE_VERSION 100
436 
437 typedef struct
438 {
439  wholenumber_t interfaceVersion; // The interface version identifier
440 
441  void (RexxEntry *Terminate)(RexxInstance *);
444  size_t (RexxEntry *LanguageLevel)(RexxInstance *);
445  void (RexxEntry *Halt)(RexxInstance *);
448 
449 #define THREAD_INTERFACE_VERSION_4_0_0 100
450 #define THREAD_INTERFACE_VERSION_4_1_1 101
451 #define THREAD_INTERFACE_VERSION 102
452 
454 
455 typedef struct
456 {
457  wholenumber_t interfaceVersion; // The interface version identifier
458 
465 
470 
473 
477 
480  logical_t (RexxEntry *LoadLibrary)(RexxThreadContext *, CSTRING n);
491 
498 
524 
535 
540 
546 
560 
565 
569 
575 
586 
587  void (RexxEntry *RaiseException0)(RexxThreadContext *, size_t);
590  void (RexxEntry *RaiseException)(RexxThreadContext *, size_t, RexxArrayObject);
596 
601 
604 
612 
614 
615 
616 #define METHOD_INTERFACE_VERSION_4_0_0 100
617 #define METHOD_INTERFACE_VERSION 101
618 
619 typedef struct
620 {
621  wholenumber_t interfaceVersion; // The interface version identifier
622 
623  RexxArrayObject (RexxEntry *GetArguments)(RexxMethodContext *);
639 
640 #define CALL_INTERFACE_VERSION 100
641 
642 typedef struct
643 {
644  wholenumber_t interfaceVersion; // The interface version identifier
645 
646  RexxArrayObject (RexxEntry *GetArguments)(RexxCallContext *);
662 
663 #define EXIT_INTERFACE_VERSION 100
664 
665 typedef struct
666 {
667  wholenumber_t interfaceVersion; // The interface version identifier
674 
675 END_EXTERN_C()
676 
678 {
679  RexxInstanceInterface *functions; // the interface function vector
680  void *applicationData; // creator defined data pointer
681 #ifdef __cplusplus
682  void Terminate()
683  {
684  functions->Terminate(this);
685  }
687  {
688  return functions->AttachThread(this, tc);
689  }
690  size_t InterpreterVersion()
691  {
692  return functions->InterpreterVersion(this);
693  }
694  size_t LanguageLevel()
695  {
696  return functions->LanguageLevel(this);
697  }
698  void Halt()
699  {
700  functions->Halt(this);
701  }
702  void SetTrace(logical_t s)
703  {
704  functions->SetTrace(this, s);
705  }
706 #endif
707 };
708 
709 
711 {
712  RexxInstance *instance; // the owning instance
713  RexxThreadInterface *functions; // the interface function vector
714 #ifdef __cplusplus
715  POINTER GetApplicationData()
716  {
717  return instance->applicationData;
718  }
719  size_t InterpreterVersion()
720  {
721  return instance->InterpreterVersion();
722  }
723  size_t LanguageLevel()
724  {
725  return instance->LanguageLevel();
726  }
727  void DetachThread()
728  {
729  functions->DetachThread(this);
730  }
731  void HaltThread()
732  {
733  functions->HaltThread(this);
734  }
735  void SetThreadTrace(logical_t s)
736  {
737  functions->SetThreadTrace(this, s);
738  }
740  {
741  return functions->RequestGlobalReference(this, o);
742  }
744  {
745  functions->ReleaseGlobalReference(this, o);
746  }
748  {
749  functions->ReleaseLocalReference(this, o);
750  }
751 
752  RexxObjectPtr SendMessage(RexxObjectPtr o, CSTRING msg, RexxArrayObject arr)
753  {
754  return functions->SendMessage(this, o, msg, arr);
755  }
757  {
758  return functions->SendMessage0(this, o, msg);
759  }
761  {
762  return functions->SendMessage1(this, o, msg, a1);
763  }
765  {
766  return functions->SendMessage2(this, o, msg, a1, a2);
767  }
768 
770  {
771  return functions->GetLocalEnvironment(this);
772  }
774  {
775  return functions->GetGlobalEnvironment(this);
776  }
778  {
779  return functions->IsInstanceOf(this, o, co);
780  }
782  {
783  return functions->IsOfType(this, o, cn);
784  }
786  {
787  return functions->FindClass(this, s);
788  }
789  RexxClassObject FindPackageClass(RexxPackageObject m, CSTRING n)
790  {
791  return functions->FindPackageClass(this, m, n);
792  }
794  {
795  return functions->HasMethod(this, o, m);
796  }
797  RexxMethodObject NewMethod(CSTRING n, CSTRING s, size_t l)
798  {
799  return functions->NewMethod(this, n, s, l);
800  }
802  {
803  return functions->NewRoutine(this, n, s, l);
804  }
806  {
807  return functions->IsRoutine(this, o);
808  }
810  {
811  return functions->IsMethod(this, o);
812  }
814  {
815  return functions->GetRoutinePackage(this, o);
816  }
818  {
819  return functions->GetMethodPackage(this, o);
820  }
821 
822 
824  {
825  return functions->GetPackageRoutines(this, m);
826  }
828  {
829  return functions->GetPackagePublicRoutines(this, m);
830  }
832  {
833  return functions->GetPackageClasses(this, m);
834  }
836  {
837  return functions->GetPackagePublicClasses(this, m);
838  }
840  {
841  return functions->GetPackageMethods(this, m);
842  }
844  {
845  return functions->CallRoutine(this, m, a);
846  }
848  {
849  return functions->CallProgram(this, n, a);
850  }
852  {
853  return functions->LoadPackage(this, d);
854  }
856  {
857  return functions->LoadPackageFromData(this, n, d, l);
858  }
859  logical_t LoadLibrary(CSTRING n)
860  {
861  return functions->LoadLibrary(this, n);
862  }
864  {
865  return functions->RegisterLibrary(this, n, e);
866  }
868  {
869  return functions->ObjectToCSelf(this, o);
870  }
872  {
873  return functions->ObjectToCSelfScoped(this, o, s);
874  }
876  {
877  return functions->WholeNumberToObject(this, n);
878  }
879  RexxObjectPtr WholeNumber(wholenumber_t n)
880  {
881  return functions->WholeNumberToObject(this, n);
882  }
883  RexxObjectPtr UintptrToObject(uintptr_t n)
884  {
885  return functions->UintptrToObject(this, n);
886  }
887  RexxObjectPtr Uintptr(uintptr_t n)
888  {
889  return functions->UintptrToObject(this, n);
890  }
891  RexxObjectPtr IntptrToObject(intptr_t n)
892  {
893  return functions->IntptrToObject(this, n);
894  }
895  RexxObjectPtr Intptr(intptr_t n)
896  {
897  return functions->IntptrToObject(this, n);
898  }
900  {
901  return functions->StringSizeToObject(this, n);
902  }
903  RexxObjectPtr StringSize(size_t n)
904  {
905  return functions->StringSizeToObject(this, n);
906  }
908  {
909  return functions->ObjectToWholeNumber(this, o, n);
910  }
911  logical_t WholeNumber(RexxObjectPtr o, wholenumber_t *n)
912  {
913  return functions->ObjectToWholeNumber(this, o, n);
914  }
916  {
917  return functions->ObjectToStringSize(this, o, n);
918  }
919  logical_t StringSize(RexxObjectPtr o, size_t *n)
920  {
921  return functions->ObjectToStringSize(this, o, n);
922  }
923  RexxObjectPtr Int64ToObject(int64_t i)
924  {
925  return functions->Int64ToObject(this, i);
926  }
927  RexxObjectPtr Int64(int64_t i)
928  {
929  return functions->Int64ToObject(this, i);
930  }
932  {
933  return functions->UnsignedInt64ToObject(this, u);
934  }
935  RexxObjectPtr UnsignedInt64(uint64_t u)
936  {
937  return functions->UnsignedInt64ToObject(this, u);
938  }
939  logical_t ObjectToInt64(RexxObjectPtr o, int64_t *i)
940  {
941  return functions->ObjectToInt64(this, o, i);
942  }
943  logical_t Int64(RexxObjectPtr o, int64_t *i)
944  {
945  return functions->ObjectToInt64(this, o, i);
946  }
948  {
949  return functions->ObjectToUnsignedInt64(this, o, u);
950  }
951  logical_t UnsignedInt64(RexxObjectPtr o, uint64_t *u)
952  {
953  return functions->ObjectToUnsignedInt64(this, o, u);
954  }
955  RexxObjectPtr Int32ToObject(int32_t i)
956  {
957  return functions->Int32ToObject(this, i);
958  }
959  RexxObjectPtr Int32(int32_t i)
960  {
961  return functions->Int32ToObject(this, i);
962  }
964  {
965  return functions->UnsignedInt32ToObject(this, u);
966  }
967  RexxObjectPtr UnsignedInt32(uint32_t u)
968  {
969  return functions->UnsignedInt32ToObject(this, u);
970  }
971  logical_t ObjectToInt32(RexxObjectPtr o, int32_t *i)
972  {
973  return functions->ObjectToInt32(this, o, i);
974  }
975  logical_t Int32(RexxObjectPtr o, int32_t *i)
976  {
977  return functions->ObjectToInt32(this, o, i);
978  }
980  {
981  return functions->ObjectToUnsignedInt32(this, o, u);
982  }
983  logical_t UnsignedInt32(RexxObjectPtr o, uint32_t *u)
984  {
985  return functions->ObjectToUnsignedInt32(this, o, u);
986  }
987  logical_t ObjectToUintptr(RexxObjectPtr o, uintptr_t *n)
988  {
989  return functions->ObjectToUintptr(this, o, n);
990  }
991  logical_t Uintptr(RexxObjectPtr o, uintptr_t *n)
992  {
993  return functions->ObjectToUintptr(this, o, n);
994  }
995  logical_t ObjectToIntptr(RexxObjectPtr o, intptr_t *n)
996  {
997  return functions->ObjectToIntptr(this, o, n);
998  }
999  logical_t Intptr(RexxObjectPtr o, intptr_t *n)
1000  {
1001  return functions->ObjectToIntptr(this, o, n);
1002  }
1004  {
1005  return functions->ObjectToLogical(this, o, n);
1006  }
1007  logical_t Logical(RexxObjectPtr o, logical_t *n)
1008  {
1009  return functions->ObjectToLogical(this, o, n);
1010  }
1012  {
1013  return functions->LogicalToObject(this, l);
1014  }
1015  RexxObjectPtr Logical(logical_t l)
1016  {
1017  return functions->LogicalToObject(this, l);
1018  }
1019  RexxObjectPtr DoubleToObject(double d)
1020  {
1021  return functions->DoubleToObject(this, d);
1022  }
1023  RexxObjectPtr Double(double d)
1024  {
1025  return functions->DoubleToObject(this, d);
1026  }
1027  RexxObjectPtr DoubleToObjectWithPrecision(double d, size_t precision)
1028  {
1029  return functions->DoubleToObjectWithPrecision(this, d, precision);
1030  }
1031  logical_t ObjectToDouble(RexxObjectPtr o, double *d)
1032  {
1033  return functions->ObjectToDouble(this, o, d);
1034  }
1035  logical_t Double(RexxObjectPtr o, double *d)
1036  {
1037  return functions->ObjectToDouble(this, o, d);
1038  }
1040  {
1041  return functions->ValueToObject(this, v);
1042  }
1044  {
1045  return functions->ValuesToObject(this, v, c);
1046  }
1048  {
1049  return functions->ObjectToValue(this, o, v);
1050  }
1052  {
1053  return functions->ObjectToString(this, o);
1054  }
1056  {
1057  return functions->ObjectToStringValue(this, o);
1058  }
1059  CSTRING CString(RexxObjectPtr o)
1060  {
1061  return functions->ObjectToStringValue(this, o);
1062  }
1063  size_t StringGet(RexxStringObject o, size_t len1, POINTER s, size_t len2)
1064  {
1065  return functions->StringGet(this, o, len1, s, len2);
1066  }
1067  size_t StringLength(RexxStringObject o)
1068  {
1069  return functions->StringLength(this, o);
1070  }
1072  {
1073  return functions->StringData(this, o);
1074  }
1075  RexxStringObject NewString(CSTRING s, size_t len)
1076  {
1077  return functions->NewString(this, s, len);
1078  }
1080  {
1081  return functions->NewStringFromAsciiz(this, s);
1082  }
1083  RexxStringObject String(CSTRING s, size_t len)
1084  {
1085  return functions->NewString(this, s, len);
1086  }
1087  RexxStringObject String(CSTRING s)
1088  {
1089  return functions->NewStringFromAsciiz(this, s);
1090  }
1091  RexxStringObject CString(CSTRING s)
1092  {
1093  return functions->NewStringFromAsciiz(this, s);
1094  }
1096  {
1097  return functions->StringUpper(this, s);
1098  }
1100  {
1101  return functions->StringLower(this, s);
1102  }
1104  {
1105  return functions->IsString(this, o);
1106  }
1107 
1109  {
1110  return functions->NewBufferString(this, len);
1111  }
1112 
1114  {
1115  return functions->BufferStringLength(this, o);
1116  }
1117 
1119  {
1120  return functions->BufferStringData(this, o);
1121  }
1122 
1124  {
1125  return functions->FinishBufferString(this, o, l);
1126  }
1127 
1129  {
1130  functions->DirectoryPut(this, diro, o, s);
1131  }
1133  {
1134  return functions->DirectoryAt(this, to, s);
1135  }
1137  {
1138  return functions->DirectoryRemove(this, to, s);
1139  }
1141  {
1142  return functions->NewDirectory(this);
1143  }
1145  {
1146  return functions->IsDirectory(this, o);
1147  }
1148 
1149  RexxObjectPtr ArrayAt(RexxArrayObject ao, size_t n)
1150  {
1151  return functions->ArrayAt(this, ao, n);
1152  }
1153  void ArrayPut(RexxArrayObject ao, RexxObjectPtr o, size_t n)
1154  {
1155  functions->ArrayPut(this, ao, o, n);
1156  }
1158  {
1159  return functions->ArrayAppend(this, ao, o);
1160  }
1161  size_t ArrayAppendString(RexxArrayObject ao, CSTRING s, size_t l)
1162  {
1163  return functions->ArrayAppendString(this, ao, s, l);
1164  }
1165  size_t ArraySize(RexxArrayObject ao)
1166  {
1167  return functions->ArraySize(this, ao);
1168  }
1169  size_t ArrayItems(RexxArrayObject ao)
1170  {
1171  return functions->ArrayItems(this, ao);
1172  }
1173  size_t ArrayDimension(RexxArrayObject ao)
1174  {
1175  return functions->ArrayDimension(this, ao);
1176  }
1177  RexxArrayObject NewArray(size_t n)
1178  {
1179  return functions->NewArray(this, n);
1180  }
1182  {
1183  return functions->ArrayOfOne(this, o);
1184  }
1186  {
1187  return functions->ArrayOfTwo(this, o1, o2);
1188  }
1190  {
1191  return functions->ArrayOfThree(this, o1, o2, o3);
1192  }
1194  {
1195  return functions->ArrayOfFour(this, o1, o2, o3, o4);
1196  }
1198  {
1199  return functions->ArrayOfOne(this, o);
1200  }
1202  {
1203  return functions->ArrayOfTwo(this, o1, o2);
1204  }
1206  {
1207  return functions->ArrayOfThree(this, o1, o2, o3);
1208  }
1210  {
1211  return functions->ArrayOfFour(this, o1, o2, o3, o4);
1212  }
1214  {
1215  return functions->IsArray(this, o);
1216  }
1217 
1219  {
1220  return functions->BufferData(this, bo);
1221  }
1222  size_t BufferLength(RexxBufferObject bo)
1223  {
1224  return functions->BufferLength(this, bo);
1225  }
1227  {
1228  return functions->NewBuffer(this, n);
1229  }
1231  {
1232  return functions->IsBuffer(this, o);
1233  }
1234 
1236  {
1237  return functions->MutableBufferData(this, bo);
1238  }
1239 
1241  {
1242  return functions->MutableBufferLength(this, bo);
1243  }
1244 
1245  size_t SetMutableBufferLength(RexxMutableBufferObject bo, size_t l)
1246  {
1247  return functions->SetMutableBufferLength(this, bo, l);
1248  }
1249 
1251  {
1252  return functions->NewMutableBuffer(this, n);
1253  }
1254 
1256  {
1257  return functions->IsMutableBuffer(this, o);
1258  }
1259 
1261  {
1262  return functions->MutableBufferCapacity(this, bo);
1263  }
1264 
1266  {
1267  return functions->SetMutableBufferCapacity(this, bo, l);
1268  }
1269 
1271  {
1272  return functions->PointerValue(this, po);
1273  }
1275  {
1276  return functions->NewPointer(this, po);
1277  }
1279  {
1280  return functions->IsPointer(this, o);
1281  }
1282 
1284  {
1285  return functions->SupplierItem(this, so);
1286  }
1288  {
1289  return functions->SupplierIndex(this, so);
1290  }
1292  {
1293  return functions->SupplierAvailable(this, so);
1294  }
1296  {
1297  functions->SupplierNext(this, so);
1298  }
1300  {
1301  return functions->NewSupplier(this, values, names);
1302  }
1303 
1305  {
1306  return functions->NewStem(this, n);
1307  }
1309  {
1310  functions->SetStemElement(this, so, s, o);
1311  }
1313  {
1314  return functions->GetStemElement(this, so, s);
1315  }
1317  {
1318  functions->DropStemElement(this, so, s);
1319  }
1320  void SetStemArrayElement(RexxStemObject so, size_t n, RexxObjectPtr o)
1321  {
1322  functions->SetStemArrayElement(this, so, n, o);
1323  }
1325  {
1326  return functions->GetStemArrayElement(this, so, n);
1327  }
1328  void DropStemArrayElement(RexxStemObject so, size_t n)
1329  {
1330  functions->DropStemArrayElement(this, so, n);
1331  }
1333  {
1334  return functions->GetAllStemElements(this, so);
1335  }
1337  {
1338  return functions->GetStemValue(this, so);
1339  }
1341  {
1342  return functions->IsStem(this, o);
1343  }
1344  void RaiseException0(size_t n)
1345  {
1346  functions->RaiseException0(this, n);
1347  }
1348  void RaiseException1(size_t n, RexxObjectPtr o)
1349  {
1350  functions->RaiseException1(this, n, o);
1351  }
1352  void RaiseException2(size_t n, RexxObjectPtr o1, RexxObjectPtr o2)
1353  {
1354  functions->RaiseException2(this, n, o1, o2);
1355  }
1356  void RaiseException(size_t n, RexxArrayObject ao)
1357  {
1358  functions->RaiseException(this, n, ao);
1359  }
1361  {
1362  functions->RaiseCondition(this, s1, s2, ao, o);
1363  }
1365  {
1366  return functions->CheckCondition(this);
1367  }
1369  {
1370  return functions->DisplayCondition(this);
1371  }
1373  {
1374  return functions->GetConditionInfo(this);
1375  }
1377  {
1378  functions->DecodeConditionInfo(this, diro, c);
1379  }
1380  void ClearCondition()
1381  {
1382  functions->ClearCondition(this);
1383  }
1384 
1385  RexxObjectPtr Nil()
1386  {
1387  return functions->RexxNil;
1388  }
1389  RexxObjectPtr True()
1390  {
1391  return functions->RexxTrue;
1392  }
1393  RexxObjectPtr False()
1394  {
1395  return functions->RexxFalse;
1396  }
1397  RexxStringObject NullString()
1398  {
1399  return functions->RexxNullString;
1400  }
1401 #endif
1402 };
1403 
1405 {
1406  RexxThreadContext *threadContext; // the interpreter instance state
1407  MethodContextInterface *functions; // functions available in a method context
1408  ValueDescriptor *arguments; // the argument descriptor
1409 
1410 #ifdef __cplusplus
1411  POINTER GetApplicationData()
1412  {
1413  return threadContext->GetApplicationData();
1414  }
1415  size_t InterpreterVersion()
1416  {
1417  return threadContext->InterpreterVersion();
1418  }
1419  size_t LanguageLevel()
1420  {
1421  return threadContext->LanguageLevel();
1422  }
1424  {
1425  return threadContext->RequestGlobalReference(o);
1426  }
1428  {
1429  threadContext->ReleaseGlobalReference(o);
1430  }
1432  {
1433  threadContext->ReleaseLocalReference(o);
1434  }
1435 
1436  RexxObjectPtr SendMessage(RexxObjectPtr o, CSTRING s, RexxArrayObject ao)
1437  {
1438  return threadContext->SendMessage(o, s, ao);
1439  }
1441  {
1442  return threadContext->SendMessage0(o, s);
1443  }
1445  {
1446  return threadContext->SendMessage1(o, s, a1);
1447  }
1449  {
1450  return threadContext->SendMessage2(o, s, a1, a2);
1451  }
1452 
1454  {
1455  return threadContext->GetLocalEnvironment();
1456  }
1458  {
1459  return threadContext->GetGlobalEnvironment();
1460  }
1461 
1463  {
1464  return threadContext->IsInstanceOf(o, co);
1465  }
1467  {
1468  return threadContext->IsOfType(o, cn);
1469  }
1471  {
1472  return threadContext->FindClass(s);
1473  }
1474  RexxClassObject FindPackageClass(RexxPackageObject m, CSTRING n)
1475  {
1476  return threadContext->FindPackageClass(m, n);
1477  }
1479  {
1480  return threadContext->HasMethod(o, m);
1481  }
1482  RexxMethodObject NewMethod(CSTRING n, CSTRING s, size_t l)
1483  {
1484  return threadContext->NewMethod(n, s, l);
1485  }
1487  {
1488  return threadContext->NewRoutine(n, s, l);
1489  }
1491  {
1492  return threadContext->IsRoutine(o);
1493  }
1495  {
1496  return threadContext->IsMethod(o);
1497  }
1499  {
1500  return threadContext->GetRoutinePackage(o);
1501  }
1503  {
1504  return threadContext->GetMethodPackage(o);
1505  }
1506 
1508  {
1509  return threadContext->GetPackageRoutines(m);
1510  }
1512  {
1513  return threadContext->GetPackagePublicRoutines(m);
1514  }
1516  {
1517  return threadContext->GetPackageClasses(m);
1518  }
1520  {
1521  return threadContext->GetPackagePublicClasses(m);
1522  }
1524  {
1525  return threadContext->GetPackageMethods(m);
1526  }
1528  {
1529  return threadContext->CallRoutine(m, a);
1530  }
1532  {
1533  return threadContext->CallProgram(n, a);
1534  }
1536  {
1537  return threadContext->LoadPackage(d);
1538  }
1540  {
1541  return threadContext->LoadPackageFromData(n, d, l);
1542  }
1543  logical_t LoadLibrary(CSTRING n)
1544  {
1545  return threadContext->LoadLibrary(n);
1546  }
1548  {
1549  return threadContext->RegisterLibrary(n, e);
1550  }
1551 
1553  {
1554  return threadContext->ObjectToCSelf(o);
1555  }
1556 
1558  {
1559  return threadContext->ObjectToCSelf(o, s);
1560  }
1562  {
1563  return threadContext->WholeNumberToObject(n);
1564  }
1565  RexxObjectPtr WholeNumber(wholenumber_t n)
1566  {
1567  return threadContext->WholeNumberToObject(n);
1568  }
1569  RexxObjectPtr UintptrToObject(uintptr_t n)
1570  {
1571  return threadContext->UintptrToObject(n);
1572  }
1573  RexxObjectPtr Uintptr(uintptr_t n)
1574  {
1575  return threadContext->UintptrToObject(n);
1576  }
1577  RexxObjectPtr IntptrToObject(intptr_t n)
1578  {
1579  return threadContext->IntptrToObject(n);
1580  }
1581  RexxObjectPtr Intptr(intptr_t n)
1582  {
1583  return threadContext->IntptrToObject(n);
1584  }
1586  {
1587  return threadContext->ValueToObject(v);
1588  }
1590  {
1591  return threadContext->ValuesToObject(v, c);
1592  }
1594  {
1595  return threadContext->ObjectToValue(o, v);
1596  }
1598  {
1599  return threadContext->StringSizeToObject(u);
1600  }
1601  RexxObjectPtr StringSize(size_t u)
1602  {
1603  return threadContext->StringSizeToObject(u);
1604  }
1606  {
1607  return threadContext->ObjectToWholeNumber(o, n);
1608  }
1609  logical_t WholeNumber(RexxObjectPtr o, wholenumber_t *n)
1610  {
1611  return threadContext->ObjectToWholeNumber(o, n);
1612  }
1614  {
1615  return threadContext->ObjectToStringSize(o, n);
1616  }
1617  logical_t StringSize(RexxObjectPtr o, size_t *n)
1618  {
1619  return threadContext->ObjectToStringSize(o, n);
1620  }
1621  RexxObjectPtr Int64ToObject(int64_t i)
1622  {
1623  return threadContext->Int64ToObject(i);
1624  }
1625  RexxObjectPtr Int64(int64_t i)
1626  {
1627  return threadContext->Int64ToObject(i);
1628  }
1630  {
1631  return threadContext->UnsignedInt64ToObject(u);
1632  }
1633  RexxObjectPtr UnsignedInt64(uint64_t u)
1634  {
1635  return threadContext->UnsignedInt64ToObject(u);
1636  }
1637  logical_t ObjectToInt64(RexxObjectPtr o, int64_t *i)
1638  {
1639  return threadContext->ObjectToInt64(o, i);
1640  }
1641  logical_t Int64(RexxObjectPtr o, int64_t *i)
1642  {
1643  return threadContext->ObjectToInt64(o, i);
1644  }
1646  {
1647  return threadContext->ObjectToUnsignedInt64(o, u);
1648  }
1649  logical_t UnsignedInt64(RexxObjectPtr o, uint64_t *u)
1650  {
1651  return threadContext->ObjectToUnsignedInt64(o, u);
1652  }
1653  RexxObjectPtr Int32ToObject(int32_t i)
1654  {
1655  return threadContext->Int32ToObject(i);
1656  }
1657  RexxObjectPtr Int32(int32_t i)
1658  {
1659  return threadContext->Int32ToObject(i);
1660  }
1662  {
1663  return threadContext->UnsignedInt32ToObject(u);
1664  }
1665  RexxObjectPtr UnsignedInt32(uint32_t u)
1666  {
1667  return threadContext->UnsignedInt32ToObject(u);
1668  }
1669  logical_t ObjectToInt32(RexxObjectPtr o, int32_t *i)
1670  {
1671  return threadContext->ObjectToInt32(o, i);
1672  }
1673  logical_t Int32(RexxObjectPtr o, int32_t *i)
1674  {
1675  return threadContext->ObjectToInt32(o, i);
1676  }
1678  {
1679  return threadContext->ObjectToUnsignedInt32(o, u);
1680  }
1681  logical_t UnsignedInt32(RexxObjectPtr o, uint32_t *u)
1682  {
1683  return threadContext->ObjectToUnsignedInt32(o, u);
1684  }
1685  logical_t ObjectToUintptr(RexxObjectPtr o, uintptr_t *n)
1686  {
1687  return threadContext->ObjectToUintptr(o, n);
1688  }
1689  logical_t Uintptr(RexxObjectPtr o, uintptr_t *n)
1690  {
1691  return threadContext->ObjectToUintptr(o, n);
1692  }
1693  logical_t ObjectToIntptr(RexxObjectPtr o, intptr_t *n)
1694  {
1695  return threadContext->ObjectToIntptr(o, n);
1696  }
1697  logical_t Intptr(RexxObjectPtr o, intptr_t *n)
1698  {
1699  return threadContext->ObjectToIntptr(o, n);
1700  }
1702  {
1703  return threadContext->ObjectToLogical(o, n);
1704  }
1705  logical_t Logical(RexxObjectPtr o, logical_t *n)
1706  {
1707  return threadContext->ObjectToLogical(o, n);
1708  }
1710  {
1711  return threadContext->LogicalToObject(l);
1712  }
1713  RexxObjectPtr Logical(logical_t l)
1714  {
1715  return threadContext->LogicalToObject(l);
1716  }
1717  RexxObjectPtr DoubleToObject(double d)
1718  {
1719  return threadContext->DoubleToObject(d);
1720  }
1721  RexxObjectPtr Double(double d)
1722  {
1723  return threadContext->DoubleToObject(d);
1724  }
1725  RexxObjectPtr DoubleToObjectWithPrecision(double d, size_t precision)
1726  {
1727  return threadContext->DoubleToObjectWithPrecision(d, precision);
1728  }
1729  logical_t ObjectToDouble(RexxObjectPtr o, double *d)
1730  {
1731  return threadContext->ObjectToDouble(o, d);
1732  }
1733  logical_t Double(RexxObjectPtr o, double *d)
1734  {
1735  return threadContext->ObjectToDouble(o, d);
1736  }
1737 
1739  {
1740  return threadContext->ObjectToString(o);
1741  }
1743  {
1744  return threadContext->ObjectToStringValue(o);
1745  }
1746  CSTRING CString(RexxObjectPtr o)
1747  {
1748  return threadContext->ObjectToStringValue(o);
1749  }
1750  size_t StringGet(RexxStringObject o, size_t n1, POINTER s, size_t n2)
1751  {
1752  return threadContext->StringGet(o, n1, s, n2);
1753  }
1754  size_t StringLength(RexxStringObject o)
1755  {
1756  return threadContext->StringLength(o);
1757  }
1759  {
1760  return threadContext->StringData(o);
1761  }
1762  RexxStringObject NewString(CSTRING s, size_t len)
1763  {
1764  return threadContext->NewString(s, len);
1765  }
1767  {
1768  return threadContext->NewStringFromAsciiz(s);
1769  }
1770  RexxStringObject String(CSTRING s, size_t len)
1771  {
1772  return threadContext->NewString(s, len);
1773  }
1774  RexxStringObject String(CSTRING s)
1775  {
1776  return threadContext->NewStringFromAsciiz(s);
1777  }
1778  RexxStringObject CString(CSTRING s)
1779  {
1780  return threadContext->NewStringFromAsciiz(s);
1781  }
1783  {
1784  return threadContext->StringUpper(s);
1785  }
1787  {
1788  return threadContext->StringLower(s);
1789  }
1791  {
1792  return threadContext->IsString(o);
1793  }
1794 
1796  {
1797  return threadContext->NewBufferString(len);
1798  }
1799 
1801  {
1802  return threadContext->BufferStringLength(o);
1803  }
1804 
1806  {
1807  return threadContext->BufferStringData(o);
1808  }
1809 
1811  {
1812  return threadContext->FinishBufferString(o, l);
1813  }
1814 
1816  {
1817  threadContext->DirectoryPut(diro, o, s);
1818  }
1820  {
1821  return threadContext->DirectoryAt(to, s);
1822  }
1824  {
1825  return threadContext->DirectoryRemove(to, s);
1826  }
1828  {
1829  return threadContext->NewDirectory();
1830  }
1832  {
1833  return threadContext->IsDirectory(o);
1834  }
1835 
1836  RexxObjectPtr ArrayAt(RexxArrayObject ao, size_t n)
1837  {
1838  return threadContext->ArrayAt(ao, n);
1839  }
1840  void ArrayPut(RexxArrayObject ao, RexxObjectPtr o, size_t n)
1841  {
1842  threadContext->ArrayPut(ao, o, n);
1843  }
1845  {
1846  return threadContext->ArrayAppend(ao, o);
1847  }
1848  size_t ArrayAppendString(RexxArrayObject ao, CSTRING s, size_t l)
1849  {
1850  return threadContext->ArrayAppendString(ao, s, l);
1851  }
1852  size_t ArraySize(RexxArrayObject ao)
1853  {
1854  return threadContext->ArraySize(ao);
1855  }
1856  size_t ArrayItems(RexxArrayObject ao)
1857  {
1858  return threadContext->ArrayItems(ao);
1859  }
1860  size_t ArrayDimension(RexxArrayObject ao)
1861  {
1862  return threadContext->ArrayDimension(ao);
1863  }
1864  RexxArrayObject NewArray(size_t n)
1865  {
1866  return threadContext->NewArray(n);
1867  }
1869  {
1870  return threadContext->ArrayOfOne(o);
1871  }
1873  {
1874  return threadContext->ArrayOfTwo(o1, o2);
1875  }
1877  {
1878  return threadContext->ArrayOfThree(o1, o2, o3);
1879  }
1881  {
1882  return threadContext->ArrayOfFour(o1, o2, o3, o4);
1883  }
1885  {
1886  return threadContext->ArrayOfOne(o);
1887  }
1889  {
1890  return threadContext->ArrayOfTwo(o1, o2);
1891  }
1893  {
1894  return threadContext->ArrayOfThree(o1, o2, o3);
1895  }
1897  {
1898  return threadContext->ArrayOfFour(o1, o2, o3, o4);
1899  }
1901  {
1902  return threadContext->IsArray(o);
1903  }
1904 
1906  {
1907  return threadContext->BufferData(bo);
1908  }
1909  size_t BufferLength(RexxBufferObject bo)
1910  {
1911  return threadContext->BufferLength(bo);
1912  }
1914  {
1915  return threadContext->NewBuffer(n);
1916  }
1918  {
1919  return threadContext->IsBuffer(o);
1920  }
1921 
1923  {
1924  return threadContext->MutableBufferData(bo);
1925  }
1926 
1928  {
1929  return threadContext->MutableBufferLength(bo);
1930  }
1931 
1932  size_t SetMutableBufferLength(RexxMutableBufferObject bo, size_t l)
1933  {
1934  return threadContext->SetMutableBufferLength(bo, l);
1935  }
1936 
1938  {
1939  return threadContext->NewMutableBuffer(n);
1940  }
1941 
1943  {
1944  return threadContext->IsMutableBuffer(o);
1945  }
1946 
1947 
1949  {
1950  return threadContext->MutableBufferCapacity(bo);
1951  }
1952 
1954  {
1955  return threadContext->SetMutableBufferCapacity(bo, l);
1956  }
1957 
1959  {
1960  return threadContext->PointerValue(po);
1961  }
1963  {
1964  return threadContext->NewPointer(p);
1965  }
1967  {
1968  return threadContext->IsPointer(o);
1969  }
1970 
1972  {
1973  return threadContext->SupplierItem(so);
1974  }
1976  {
1977  return threadContext->SupplierIndex(so);
1978  }
1980  {
1981  return threadContext->SupplierAvailable(so);
1982  }
1984  {
1985  threadContext->SupplierNext(so);
1986  }
1988  {
1989  return threadContext->NewSupplier(values, names);
1990  }
1991 
1993  {
1994  return threadContext->NewStem(n);
1995  }
1997  {
1998  threadContext->SetStemElement(so, s, o);
1999  }
2001  {
2002  return threadContext->GetStemElement(so, s);
2003  }
2005  {
2006  threadContext->DropStemElement(so, s);
2007  }
2008  void SetStemArrayElement(RexxStemObject so, size_t n, RexxObjectPtr o)
2009  {
2010  threadContext->SetStemArrayElement(so, n, o);
2011  }
2013  {
2014  return threadContext->GetStemArrayElement(so, n);
2015  }
2016  void DropStemArrayElement(RexxStemObject so, size_t n)
2017  {
2018  threadContext->DropStemArrayElement(so, n);
2019  }
2021  {
2022  return threadContext->GetAllStemElements(so);
2023  }
2025  {
2026  return threadContext->GetStemValue(so);
2027  }
2029  {
2030  return threadContext->IsStem(o);
2031  }
2032 
2033  void RaiseException0(size_t n)
2034  {
2035  threadContext->RaiseException0(n);
2036  }
2037  void RaiseException1(size_t n, RexxObjectPtr o)
2038  {
2039  threadContext->RaiseException1(n, o);
2040  }
2041  void RaiseException2(size_t n, RexxObjectPtr o1, RexxObjectPtr o2)
2042  {
2043  threadContext->RaiseException2(n, o1, o2);
2044  }
2045  void RaiseException(size_t n, RexxArrayObject ao)
2046  {
2047  threadContext->RaiseException(n, ao);
2048  }
2050  {
2051  threadContext->RaiseCondition(s1, s2, ao, o);
2052  }
2054  {
2055  return threadContext->CheckCondition();
2056  }
2058  {
2059  return threadContext->DisplayCondition();
2060  }
2062  {
2063  return threadContext->GetConditionInfo();
2064  }
2066  {
2067  threadContext->DecodeConditionInfo(diro, c);
2068  }
2069  void ClearCondition()
2070  {
2071  threadContext->ClearCondition();
2072  }
2073 
2074  RexxObjectPtr Nil()
2075  {
2076  return threadContext->Nil();
2077  }
2078  RexxObjectPtr True()
2079  {
2080  return threadContext->True();
2081  }
2082  RexxObjectPtr False()
2083  {
2084  return threadContext->False();
2085  }
2086  RexxStringObject NullString()
2087  {
2088  return threadContext->NullString();
2089  }
2090 
2091  RexxArrayObject GetArguments()
2092  {
2093  return functions->GetArguments(this);
2094  }
2095  RexxObjectPtr GetArgument(size_t n)
2096  {
2097  return functions->GetArgument(this, n);
2098  }
2100  {
2101  return functions->GetMessageName(this);
2102  }
2103  RexxMethodObject GetMethod()
2104  {
2105  return functions->GetMethod(this);
2106  }
2108  {
2109  return functions->GetSelf(this);
2110  }
2112  {
2113  return functions->GetSuper(this);
2114  }
2116  {
2117  return functions->GetScope(this);
2118  }
2119  POINTER GetCSelf()
2120  {
2121  return functions->GetCSelf(this);
2122  }
2124  {
2125  functions->SetObjectVariable(this, s, o);
2126  }
2128  {
2129  return functions->GetObjectVariable(this, s);
2130  }
2131  void DropObjectVariable(CSTRING s)
2132  {
2133  functions->DropObjectVariable(this, s);
2134  }
2136  {
2137  return functions->ForwardMessage(this, o, s, c, a);
2138  }
2139  void SetGuardOn()
2140  {
2141  functions->SetGuardOn(this);
2142  }
2143  void SetGuardOff()
2144  {
2145  functions->SetGuardOff(this);
2146  }
2148  {
2149  return functions->FindContextClass(this, n);
2150  }
2151 #endif
2152 };
2153 
2155 {
2156  RexxThreadContext *threadContext; // the interpreter instance state
2157  CallContextInterface *functions; // functions available in a method context
2158  ValueDescriptor *arguments; // the argument descriptor
2159 
2160 #ifdef __cplusplus
2161  POINTER GetApplicationData()
2162  {
2163  return threadContext->GetApplicationData();
2164  }
2165  size_t InterpreterVersion()
2166  {
2167  return threadContext->InterpreterVersion();
2168  }
2169  size_t LanguageLevel()
2170  {
2171  return threadContext->LanguageLevel();
2172  }
2174  {
2175  return threadContext->RequestGlobalReference(o);
2176  }
2178  {
2179  threadContext->ReleaseGlobalReference(o);
2180  }
2182  {
2183  threadContext->ReleaseLocalReference(o);
2184  }
2185  RexxObjectPtr SendMessage(RexxObjectPtr o, CSTRING s, RexxArrayObject ao)
2186  {
2187  return threadContext->SendMessage(o, s, ao);
2188  }
2190  {
2191  return threadContext->SendMessage0(o, s);
2192  }
2194  {
2195  return threadContext->SendMessage1(o, s, a1);
2196  }
2198  {
2199  return threadContext->SendMessage2(o, s, a1, a2);
2200  }
2201 
2203  {
2204  return threadContext->GetLocalEnvironment();
2205  }
2207  {
2208  return threadContext->GetGlobalEnvironment();
2209  }
2210 
2212  {
2213  return threadContext->IsInstanceOf(o, co);
2214  }
2216  {
2217  return threadContext->IsOfType(o, cn);
2218  }
2220  {
2221  return threadContext->FindClass(s);
2222  }
2223  RexxClassObject FindPackageClass(RexxPackageObject m, CSTRING n)
2224  {
2225  return threadContext->FindPackageClass(m, n);
2226  }
2228  {
2229  return threadContext->HasMethod(o, m);
2230  }
2231 
2232  RexxMethodObject NewMethod(CSTRING n, CSTRING s, size_t l)
2233  {
2234  return threadContext->NewMethod(n, s, l);
2235  }
2236 
2238  {
2239  return threadContext->NewRoutine(n, s, l);
2240  }
2242  {
2243  return threadContext->IsRoutine(o);
2244  }
2246  {
2247  return threadContext->IsMethod(o);
2248  }
2250  {
2251  return threadContext->GetRoutinePackage(o);
2252  }
2254  {
2255  return threadContext->GetMethodPackage(o);
2256  }
2257 
2259  {
2260  return threadContext->GetPackageRoutines(m);
2261  }
2263  {
2264  return threadContext->GetPackagePublicRoutines(m);
2265  }
2267  {
2268  return threadContext->GetPackageClasses(m);
2269  }
2271  {
2272  return threadContext->GetPackagePublicClasses(m);
2273  }
2275  {
2276  return threadContext->GetPackageMethods(m);
2277  }
2279  {
2280  return threadContext->CallRoutine(m, a);
2281  }
2283  {
2284  return threadContext->CallProgram(n, a);
2285  }
2287  {
2288  return threadContext->LoadPackage(d);
2289  }
2291  {
2292  return threadContext->LoadPackageFromData(n, d, l);
2293  }
2294  logical_t LoadLibrary(CSTRING n)
2295  {
2296  return threadContext->LoadLibrary(n);
2297  }
2299  {
2300  return threadContext->RegisterLibrary(n, e);
2301  }
2303  {
2304  return threadContext->ObjectToCSelf(o);
2305  }
2306 
2308  {
2309  return threadContext->ObjectToCSelf(o, s);
2310  }
2312  {
2313  return threadContext->WholeNumberToObject(n);
2314  }
2315  RexxObjectPtr WholeNumber(wholenumber_t n)
2316  {
2317  return threadContext->WholeNumberToObject(n);
2318  }
2319  RexxObjectPtr UintptrToObject(uintptr_t n)
2320  {
2321  return threadContext->UintptrToObject(n);
2322  }
2323  RexxObjectPtr Uintptr(uintptr_t n)
2324  {
2325  return threadContext->UintptrToObject(n);
2326  }
2327  RexxObjectPtr IntptrToObject(intptr_t n)
2328  {
2329  return threadContext->IntptrToObject(n);
2330  }
2331  RexxObjectPtr Intptr(intptr_t n)
2332  {
2333  return threadContext->IntptrToObject(n);
2334  }
2336  {
2337  return threadContext->ValueToObject(v);
2338  }
2340  {
2341  return threadContext->ValuesToObject(v, c);
2342  }
2344  {
2345  return threadContext->ObjectToValue(o, v);
2346  }
2348  {
2349  return threadContext->StringSizeToObject(u);
2350  }
2351  RexxObjectPtr StringSize(size_t u)
2352  {
2353  return threadContext->StringSizeToObject(u);
2354  }
2356  {
2357  return threadContext->ObjectToWholeNumber(o, n);
2358  }
2359  logical_t WholeNumber(RexxObjectPtr o, wholenumber_t *n)
2360  {
2361  return threadContext->ObjectToWholeNumber(o, n);
2362  }
2364  {
2365  return threadContext->ObjectToStringSize(o, n);
2366  }
2367  logical_t StringSize(RexxObjectPtr o, size_t *n)
2368  {
2369  return threadContext->ObjectToStringSize(o, n);
2370  }
2371  RexxObjectPtr Int64ToObject(int64_t i)
2372  {
2373  return threadContext->Int64ToObject(i);
2374  }
2375  RexxObjectPtr Int64(int64_t i)
2376  {
2377  return threadContext->Int64ToObject(i);
2378  }
2380  {
2381  return threadContext->UnsignedInt64ToObject(u);
2382  }
2383  RexxObjectPtr UnsignedInt64(uint64_t u)
2384  {
2385  return threadContext->UnsignedInt64ToObject(u);
2386  }
2387  logical_t ObjectToInt64(RexxObjectPtr o, int64_t *i)
2388  {
2389  return threadContext->ObjectToInt64(o, i);
2390  }
2391  logical_t Int64(RexxObjectPtr o, int64_t *i)
2392  {
2393  return threadContext->ObjectToInt64(o, i);
2394  }
2396  {
2397  return threadContext->ObjectToUnsignedInt64(o, u);
2398  }
2399  logical_t UnsignedInt64(RexxObjectPtr o, uint64_t *u)
2400  {
2401  return threadContext->ObjectToUnsignedInt64(o, u);
2402  }
2403  RexxObjectPtr Int32ToObject(int32_t i)
2404  {
2405  return threadContext->Int32ToObject(i);
2406  }
2407  RexxObjectPtr Int32(int32_t i)
2408  {
2409  return threadContext->Int32ToObject(i);
2410  }
2412  {
2413  return threadContext->UnsignedInt32ToObject(u);
2414  }
2415  RexxObjectPtr UnsignedInt32(uint32_t u)
2416  {
2417  return threadContext->UnsignedInt32ToObject(u);
2418  }
2419  logical_t ObjectToInt32(RexxObjectPtr o, int32_t *i)
2420  {
2421  return threadContext->ObjectToInt32(o, i);
2422  }
2423  logical_t Int32(RexxObjectPtr o, int32_t *i)
2424  {
2425  return threadContext->ObjectToInt32(o, i);
2426  }
2428  {
2429  return threadContext->ObjectToUnsignedInt32(o, u);
2430  }
2431  logical_t UnsignedInt32(RexxObjectPtr o, uint32_t *u)
2432  {
2433  return threadContext->ObjectToUnsignedInt32(o, u);
2434  }
2435  logical_t ObjectToUintptr(RexxObjectPtr o, uintptr_t *n)
2436  {
2437  return threadContext->ObjectToUintptr(o, n);
2438  }
2439  logical_t Uintptr(RexxObjectPtr o, uintptr_t *n)
2440  {
2441  return threadContext->ObjectToUintptr(o, n);
2442  }
2443  logical_t ObjectToIntptr(RexxObjectPtr o, intptr_t *n)
2444  {
2445  return threadContext->ObjectToIntptr(o, n);
2446  }
2447  logical_t Intptr(RexxObjectPtr o, intptr_t *n)
2448  {
2449  return threadContext->ObjectToIntptr(o, n);
2450  }
2452  {
2453  return threadContext->ObjectToLogical(o, n);
2454  }
2455  logical_t Logical(RexxObjectPtr o, logical_t *n)
2456  {
2457  return threadContext->ObjectToLogical(o, n);
2458  }
2460  {
2461  return threadContext->LogicalToObject(l);
2462  }
2463  RexxObjectPtr Logical(logical_t l)
2464  {
2465  return threadContext->LogicalToObject(l);
2466  }
2467  RexxObjectPtr DoubleToObject(double d)
2468  {
2469  return threadContext->DoubleToObject(d);
2470  }
2471  RexxObjectPtr Double(double d)
2472  {
2473  return threadContext->DoubleToObject(d);
2474  }
2475  RexxObjectPtr DoubleToObjectWithPrecision(double d, size_t precision)
2476  {
2477  return threadContext->DoubleToObjectWithPrecision(d, precision);
2478  }
2479  logical_t ObjectToDouble(RexxObjectPtr o, double *d)
2480  {
2481  return threadContext->ObjectToDouble(o, d);
2482  }
2483  logical_t Double(RexxObjectPtr o, double *d)
2484  {
2485  return threadContext->ObjectToDouble(o, d);
2486  }
2487 
2489  {
2490  return threadContext->ObjectToString(o);
2491  }
2493  {
2494  return threadContext->ObjectToStringValue(o);
2495  }
2496  CSTRING CString(RexxObjectPtr o)
2497  {
2498  return threadContext->ObjectToStringValue(o);
2499  }
2500  size_t StringGet(RexxStringObject o, size_t n1, POINTER s, size_t n2)
2501  {
2502  return threadContext->StringGet(o, n1, s, n2);
2503  }
2504  size_t StringLength(RexxStringObject o)
2505  {
2506  return threadContext->StringLength(o);
2507  }
2509  {
2510  return threadContext->StringData(o);
2511  }
2512  RexxStringObject NewString(CSTRING s, size_t len)
2513  {
2514  return threadContext->NewString(s, len);
2515  }
2517  {
2518  return threadContext->NewStringFromAsciiz(s);
2519  }
2520  RexxStringObject String(CSTRING s, size_t len)
2521  {
2522  return threadContext->NewString(s, len);
2523  }
2524  RexxStringObject String(CSTRING s)
2525  {
2526  return threadContext->NewStringFromAsciiz(s);
2527  }
2528  RexxStringObject CString(CSTRING s)
2529  {
2530  return threadContext->NewStringFromAsciiz(s);
2531  }
2533  {
2534  return threadContext->StringUpper(s);
2535  }
2537  {
2538  return threadContext->StringLower(s);
2539  }
2541  {
2542  return threadContext->IsString(o);
2543  }
2544 
2546  {
2547  return threadContext->NewBufferString(len);
2548  }
2549 
2551  {
2552  return threadContext->BufferStringLength(o);
2553  }
2554 
2556  {
2557  return threadContext->BufferStringData(o);
2558  }
2559 
2561  {
2562  return threadContext->FinishBufferString(o, l);
2563  }
2564 
2566  {
2567  threadContext->DirectoryPut(diro, o, s);
2568  }
2570  {
2571  return threadContext->DirectoryAt(to, s);
2572  }
2574  {
2575  return threadContext->DirectoryRemove(to, s);
2576  }
2578  {
2579  return threadContext->NewDirectory();
2580  }
2582  {
2583  return threadContext->IsDirectory(o);
2584  }
2585 
2586  RexxObjectPtr ArrayAt(RexxArrayObject ao, size_t n)
2587  {
2588  return threadContext->ArrayAt(ao, n);
2589  }
2590  void ArrayPut(RexxArrayObject ao, RexxObjectPtr o, size_t n)
2591  {
2592  threadContext->ArrayPut(ao, o, n);
2593  }
2595  {
2596  return threadContext->ArrayAppend(ao, o);
2597  }
2598  size_t ArrayAppendString(RexxArrayObject ao, CSTRING s, size_t l)
2599  {
2600  return threadContext->ArrayAppendString(ao, s, l);
2601  }
2602  size_t ArraySize(RexxArrayObject ao)
2603  {
2604  return threadContext->ArraySize(ao);
2605  }
2606  size_t ArrayItems(RexxArrayObject ao)
2607  {
2608  return threadContext->ArrayItems(ao);
2609  }
2610  size_t ArrayDimension(RexxArrayObject ao)
2611  {
2612  return threadContext->ArrayDimension(ao);
2613  }
2614  RexxArrayObject NewArray(size_t n)
2615  {
2616  return threadContext->NewArray(n);
2617  }
2619  {
2620  return threadContext->ArrayOfOne(o);
2621  }
2623  {
2624  return threadContext->ArrayOfTwo(o1, o2);
2625  }
2627  {
2628  return threadContext->ArrayOfThree(o1, o2, o3);
2629  }
2631  {
2632  return threadContext->ArrayOfFour(o1, o2, o3, o4);
2633  }
2635  {
2636  return threadContext->ArrayOfOne(o);
2637  }
2639  {
2640  return threadContext->ArrayOfTwo(o1, o2);
2641  }
2643  {
2644  return threadContext->ArrayOfThree(o1, o2, o3);
2645  }
2647  {
2648  return threadContext->ArrayOfFour(o1, o2, o3, o4);
2649  }
2651  {
2652  return threadContext->IsArray(o);
2653  }
2654 
2656  {
2657  return threadContext->BufferData(bo);
2658  }
2659  size_t BufferLength(RexxBufferObject bo)
2660  {
2661  return threadContext->BufferLength(bo);
2662  }
2664  {
2665  return threadContext->NewBuffer(n);
2666  }
2668  {
2669  return threadContext->IsBuffer(o);
2670  }
2671 
2673  {
2674  return threadContext->MutableBufferData(bo);
2675  }
2676 
2678  {
2679  return threadContext->MutableBufferLength(bo);
2680  }
2681 
2682  size_t SetMutableBufferLength(RexxMutableBufferObject bo, size_t l)
2683  {
2684  return threadContext->SetMutableBufferLength(bo, l);
2685  }
2686 
2688  {
2689  return threadContext->NewMutableBuffer(n);
2690  }
2691 
2693  {
2694  return threadContext->IsMutableBuffer(o);
2695  }
2696 
2697 
2699  {
2700  return threadContext->MutableBufferCapacity(bo);
2701  }
2702 
2704  {
2705  return threadContext->SetMutableBufferCapacity(bo, l);
2706  }
2707 
2709  {
2710  return threadContext->PointerValue(po);
2711  }
2713  {
2714  return threadContext->NewPointer(p);
2715  }
2717  {
2718  return threadContext->IsPointer(o);
2719  }
2720 
2722  {
2723  return threadContext->SupplierItem(so);
2724  }
2726  {
2727  return threadContext->SupplierIndex(so);
2728  }
2730  {
2731  return threadContext->SupplierAvailable(so);
2732  }
2734  {
2735  threadContext->SupplierNext(so);
2736  }
2738  {
2739  return threadContext->NewSupplier(values, names);
2740  }
2741 
2743  {
2744  return threadContext->NewStem(n);
2745  }
2747  {
2748  threadContext->SetStemElement(so, s, o);
2749  }
2751  {
2752  return threadContext->GetStemElement(so, s);
2753  }
2755  {
2756  threadContext->DropStemElement(so, s);
2757  }
2758  void SetStemArrayElement(RexxStemObject so, size_t n, RexxObjectPtr o)
2759  {
2760  threadContext->SetStemArrayElement(so, n, o);
2761  }
2763  {
2764  return threadContext->GetStemArrayElement(so, n);
2765  }
2766  void DropStemArrayElement(RexxStemObject so, size_t n)
2767  {
2768  threadContext->DropStemArrayElement(so, n);
2769  }
2771  {
2772  return threadContext->GetAllStemElements(so);
2773  }
2775  {
2776  return threadContext->GetStemValue(so);
2777  }
2779  {
2780  return threadContext->IsStem(o);
2781  }
2782 
2783  void RaiseException0(size_t n)
2784  {
2785  threadContext->RaiseException0(n);
2786  }
2787  void RaiseException1(size_t n, RexxObjectPtr o)
2788  {
2789  threadContext->RaiseException1(n, o);
2790  }
2791  void RaiseException2(size_t n, RexxObjectPtr o1, RexxObjectPtr o2)
2792  {
2793  threadContext->RaiseException2(n, o1, o2);
2794  }
2795  void RaiseException(size_t n, RexxArrayObject ao)
2796  {
2797  threadContext->RaiseException(n, ao);
2798  }
2800  {
2801  threadContext->RaiseCondition(s1, s2, ao, o);
2802  }
2804  {
2805  return threadContext->CheckCondition();
2806  }
2808  {
2809  return threadContext->DisplayCondition();
2810  }
2812  {
2813  return threadContext->GetConditionInfo();
2814  }
2816  {
2817  threadContext->DecodeConditionInfo(diro, c);
2818  }
2819  void ClearCondition()
2820  {
2821  threadContext->ClearCondition();
2822  }
2823 
2824  RexxObjectPtr Nil()
2825  {
2826  return threadContext->Nil();
2827  }
2828  RexxObjectPtr True()
2829  {
2830  return threadContext->True();
2831  }
2832  RexxObjectPtr False()
2833  {
2834  return threadContext->False();
2835  }
2836  RexxStringObject NullString()
2837  {
2838  return threadContext->NullString();
2839  }
2840 
2841  RexxArrayObject GetArguments()
2842  {
2843  return functions->GetArguments(this);
2844  }
2845  RexxObjectPtr GetArgument(size_t n)
2846  {
2847  return functions->GetArgument(this, n);
2848  }
2850  {
2851  return functions->GetRoutineName(this);
2852  }
2853  RexxRoutineObject GetRoutine()
2854  {
2855  return functions->GetRoutine(this);
2856  }
2858  {
2859  functions->SetContextVariable(this, s, o);
2860  }
2862  {
2863  return functions->GetContextVariable(this, s);
2864  }
2866  {
2867  functions->DropContextVariable(this, s);
2868  }
2870  {
2871  return functions->ResolveStemVariable(this, v);
2872  }
2873 
2875  {
2876  return functions->GetAllContextVariables(this);
2877  }
2878  void InvalidRoutine()
2879  {
2880  functions->InvalidRoutine(this);
2881  }
2883  {
2884  return functions->GetContextDigits(this);
2885  }
2887  {
2888  return functions->GetContextFuzz(this);
2889  }
2891  {
2892  return functions->GetContextForm(this);
2893  }
2895  {
2896  return functions->GetCallerContext(this);
2897  }
2899  {
2900  return functions->FindContextClass(this, n);
2901  }
2902 
2903 #endif
2904 };
2905 
2907 {
2908  RexxThreadContext *threadContext; // the interpreter instance state
2909  ExitContextInterface *functions; // functions available in a method context
2910  ValueDescriptor *arguments; // the argument descriptor
2911 
2912 #ifdef __cplusplus
2913  POINTER GetApplicationData()
2914  {
2915  return threadContext->GetApplicationData();
2916  }
2917  size_t InterpreterVersion()
2918  {
2919  return threadContext->InterpreterVersion();
2920  }
2921  size_t LanguageLevel()
2922  {
2923  return threadContext->LanguageLevel();
2924  }
2926  {
2927  return threadContext->RequestGlobalReference(o);
2928  }
2930  {
2931  threadContext->ReleaseGlobalReference(o);
2932  }
2934  {
2935  threadContext->ReleaseLocalReference(o);
2936  }
2937 
2938  RexxObjectPtr SendMessage(RexxObjectPtr o, CSTRING s, RexxArrayObject ao)
2939  {
2940  return threadContext->SendMessage(o, s, ao);
2941  }
2943  {
2944  return threadContext->SendMessage0(o, s);
2945  }
2947  {
2948  return threadContext->SendMessage1(o, s, a1);
2949  }
2951  {
2952  return threadContext->SendMessage2(o, s, a1, a2);
2953  }
2954 
2956  {
2957  return threadContext->GetLocalEnvironment();
2958  }
2960  {
2961  return threadContext->GetGlobalEnvironment();
2962  }
2963 
2965  {
2966  return threadContext->IsInstanceOf(o, co);
2967  }
2969  {
2970  return threadContext->IsOfType(o, cn);
2971  }
2973  {
2974  return threadContext->FindClass(s);
2975  }
2976  RexxClassObject FindPackageClass(RexxPackageObject m, CSTRING n)
2977  {
2978  return threadContext->FindPackageClass(m, n);
2979  }
2981  {
2982  return threadContext->HasMethod(o, m);
2983  }
2984 
2985  RexxMethodObject NewMethod(CSTRING n, CSTRING s, size_t l)
2986  {
2987  return threadContext->NewMethod(n, s, l);
2988  }
2990  {
2991  return threadContext->NewRoutine(n, s, l);
2992  }
2994  {
2995  return threadContext->IsRoutine(o);
2996  }
2998  {
2999  return threadContext->IsMethod(o);
3000  }
3002  {
3003  return threadContext->GetRoutinePackage(o);
3004  }
3006  {
3007  return threadContext->GetMethodPackage(o);
3008  }
3009 
3011  {
3012  return threadContext->GetPackageRoutines(m);
3013  }
3015  {
3016  return threadContext->GetPackagePublicRoutines(m);
3017  }
3019  {
3020  return threadContext->GetPackageClasses(m);
3021  }
3023  {
3024  return threadContext->GetPackagePublicClasses(m);
3025  }
3027  {
3028  return threadContext->GetPackageMethods(m);
3029  }
3031  {
3032  return threadContext->CallRoutine(m, a);
3033  }
3035  {
3036  return threadContext->CallProgram(n, a);
3037  }
3039  {
3040  return threadContext->LoadPackage(d);
3041  }
3043  {
3044  return threadContext->LoadPackageFromData(n, d, l);
3045  }
3046  logical_t LoadLibrary(CSTRING n)
3047  {
3048  return threadContext->LoadLibrary(n);
3049  }
3051  {
3052  return threadContext->RegisterLibrary(n, e);
3053  }
3055  {
3056  return threadContext->ObjectToCSelf(o);
3057  }
3058 
3060  {
3061  return threadContext->ObjectToCSelf(o, s);
3062  }
3064  {
3065  return threadContext->WholeNumberToObject(n);
3066  }
3067  RexxObjectPtr WholeNumber(wholenumber_t n)
3068  {
3069  return threadContext->WholeNumberToObject(n);
3070  }
3071  RexxObjectPtr UintptrToObject(uintptr_t n)
3072  {
3073  return threadContext->UintptrToObject(n);
3074  }
3075  RexxObjectPtr Uintptr(uintptr_t n)
3076  {
3077  return threadContext->UintptrToObject(n);
3078  }
3079  RexxObjectPtr IntptrToObject(intptr_t n)
3080  {
3081  return threadContext->IntptrToObject(n);
3082  }
3083  RexxObjectPtr Intptr(intptr_t n)
3084  {
3085  return threadContext->IntptrToObject(n);
3086  }
3088  {
3089  return threadContext->ValueToObject(v);
3090  }
3092  {
3093  return threadContext->ValuesToObject(v, c);
3094  }
3096  {
3097  return threadContext->ObjectToValue(o, v);
3098  }
3100  {
3101  return threadContext->StringSizeToObject(u);
3102  }
3103  RexxObjectPtr StringSize(size_t u)
3104  {
3105  return threadContext->StringSizeToObject(u);
3106  }
3108  {
3109  return threadContext->ObjectToWholeNumber(o, n);
3110  }
3111  logical_t WholeNumber(RexxObjectPtr o, wholenumber_t *n)
3112  {
3113  return threadContext->ObjectToWholeNumber(o, n);
3114  }
3116  {
3117  return threadContext->ObjectToStringSize(o, n);
3118  }
3119  logical_t StringSize(RexxObjectPtr o, size_t *n)
3120  {
3121  return threadContext->ObjectToStringSize(o, n);
3122  }
3123  RexxObjectPtr Int64ToObject(int64_t i)
3124  {
3125  return threadContext->Int64ToObject(i);
3126  }
3127  RexxObjectPtr Int64(int64_t i)
3128  {
3129  return threadContext->Int64ToObject(i);
3130  }
3132  {
3133  return threadContext->UnsignedInt64ToObject(u);
3134  }
3135  RexxObjectPtr UnsignedInt64(uint64_t u)
3136  {
3137  return threadContext->UnsignedInt64ToObject(u);
3138  }
3139  logical_t ObjectToInt64(RexxObjectPtr o, int64_t *i)
3140  {
3141  return threadContext->ObjectToInt64(o, i);
3142  }
3143  logical_t Int64(RexxObjectPtr o, int64_t *i)
3144  {
3145  return threadContext->ObjectToInt64(o, i);
3146  }
3148  {
3149  return threadContext->ObjectToUnsignedInt64(o, u);
3150  }
3151  logical_t UnsignedInt64(RexxObjectPtr o, uint64_t *u)
3152  {
3153  return threadContext->ObjectToUnsignedInt64(o, u);
3154  }
3155  RexxObjectPtr Int32ToObject(int32_t i)
3156  {
3157  return threadContext->Int32ToObject(i);
3158  }
3159  RexxObjectPtr Int32(int32_t i)
3160  {
3161  return threadContext->Int32ToObject(i);
3162  }
3164  {
3165  return threadContext->UnsignedInt32ToObject(u);
3166  }
3167  RexxObjectPtr UnsignedInt32(uint32_t u)
3168  {
3169  return threadContext->UnsignedInt32ToObject(u);
3170  }
3171  logical_t ObjectToInt32(RexxObjectPtr o, int32_t *i)
3172  {
3173  return threadContext->ObjectToInt32(o, i);
3174  }
3175  logical_t Int32(RexxObjectPtr o, int32_t *i)
3176  {
3177  return threadContext->ObjectToInt32(o, i);
3178  }
3180  {
3181  return threadContext->ObjectToUnsignedInt32(o, u);
3182  }
3183  logical_t UnsignedInt32(RexxObjectPtr o, uint32_t *u)
3184  {
3185  return threadContext->ObjectToUnsignedInt32(o, u);
3186  }
3187  logical_t ObjectToUintptr(RexxObjectPtr o, uintptr_t *n)
3188  {
3189  return threadContext->ObjectToUintptr(o, n);
3190  }
3191  logical_t Uintptr(RexxObjectPtr o, uintptr_t *n)
3192  {
3193  return threadContext->ObjectToUintptr(o, n);
3194  }
3195  logical_t ObjectToIntptr(RexxObjectPtr o, intptr_t *n)
3196  {
3197  return threadContext->ObjectToIntptr(o, n);
3198  }
3199  logical_t Intptr(RexxObjectPtr o, intptr_t *n)
3200  {
3201  return threadContext->ObjectToIntptr(o, n);
3202  }
3204  {
3205  return threadContext->ObjectToLogical(o, n);
3206  }
3207  logical_t Logical(RexxObjectPtr o, logical_t *n)
3208  {
3209  return threadContext->ObjectToLogical(o, n);
3210  }
3212  {
3213  return threadContext->LogicalToObject(l);
3214  }
3215  RexxObjectPtr Logical(logical_t l)
3216  {
3217  return threadContext->LogicalToObject(l);
3218  }
3219  RexxObjectPtr DoubleToObject(double d)
3220  {
3221  return threadContext->DoubleToObject(d);
3222  }
3223  RexxObjectPtr Double(double d)
3224  {
3225  return threadContext->DoubleToObject(d);
3226  }
3227  RexxObjectPtr DoubleToObjectWithPrecision(double d, size_t precision)
3228  {
3229  return threadContext->DoubleToObjectWithPrecision(d, precision);
3230  }
3231  logical_t ObjectToDouble(RexxObjectPtr o, double *d)
3232  {
3233  return threadContext->ObjectToDouble(o, d);
3234  }
3235  logical_t Double(RexxObjectPtr o, double *d)
3236  {
3237  return threadContext->ObjectToDouble(o, d);
3238  }
3239 
3241  {
3242  return threadContext->ObjectToString(o);
3243  }
3245  {
3246  return threadContext->ObjectToStringValue(o);
3247  }
3248  CSTRING CString(RexxObjectPtr o)
3249  {
3250  return threadContext->ObjectToStringValue(o);
3251  }
3252  size_t StringGet(RexxStringObject o, size_t n1, POINTER s, size_t n2)
3253  {
3254  return threadContext->StringGet(o, n1, s, n2);
3255  }
3256  size_t StringLength(RexxStringObject o)
3257  {
3258  return threadContext->StringLength(o);
3259  }
3261  {
3262  return threadContext->StringData(o);
3263  }
3264  RexxStringObject NewString(CSTRING s, size_t len)
3265  {
3266  return threadContext->NewString(s, len);
3267  }
3269  {
3270  return threadContext->NewStringFromAsciiz(s);
3271  }
3272  RexxStringObject String(CSTRING s, size_t len)
3273  {
3274  return threadContext->NewString(s, len);
3275  }
3276  RexxStringObject String(CSTRING s)
3277  {
3278  return threadContext->NewStringFromAsciiz(s);
3279  }
3280  RexxStringObject CString(CSTRING s)
3281  {
3282  return threadContext->NewStringFromAsciiz(s);
3283  }
3285  {
3286  return threadContext->StringUpper(s);
3287  }
3289  {
3290  return threadContext->StringLower(s);
3291  }
3293  {
3294  return threadContext->IsString(o);
3295  }
3296 
3298  {
3299  return threadContext->NewBufferString(len);
3300  }
3301 
3303  {
3304  return threadContext->BufferStringLength(o);
3305  }
3306 
3308  {
3309  return threadContext->BufferStringData(o);
3310  }
3311 
3313  {
3314  return threadContext->FinishBufferString(o, l);
3315  }
3316 
3318  {
3319  threadContext->DirectoryPut(diro, o, s);
3320  }
3322  {
3323  return threadContext->DirectoryAt(to, s);
3324  }
3326  {
3327  return threadContext->DirectoryRemove(to, s);
3328  }
3330  {
3331  return threadContext->NewDirectory();
3332  }
3334  {
3335  return threadContext->IsDirectory(o);
3336  }
3337 
3338  RexxObjectPtr ArrayAt(RexxArrayObject ao, size_t n)
3339  {
3340  return threadContext->ArrayAt(ao, n);
3341  }
3342  void ArrayPut(RexxArrayObject ao, RexxObjectPtr o, size_t n)
3343  {
3344  threadContext->ArrayPut(ao, o, n);
3345  }
3347  {
3348  return threadContext->ArrayAppend(ao, o);
3349  }
3350  size_t ArrayAppendString(RexxArrayObject ao, CSTRING s, size_t l)
3351  {
3352  return threadContext->ArrayAppendString(ao, s, l);
3353  }
3354  size_t ArraySize(RexxArrayObject ao)
3355  {
3356  return threadContext->ArraySize(ao);
3357  }
3358  size_t ArrayItems(RexxArrayObject ao)
3359  {
3360  return threadContext->ArrayItems(ao);
3361  }
3362  size_t ArrayDimension(RexxArrayObject ao)
3363  {
3364  return threadContext->ArrayDimension(ao);
3365  }
3366  RexxArrayObject NewArray(size_t n)
3367  {
3368  return threadContext->NewArray(n);
3369  }
3371  {
3372  return threadContext->ArrayOfOne(o);
3373  }
3375  {
3376  return threadContext->ArrayOfTwo(o1, o2);
3377  }
3379  {
3380  return threadContext->ArrayOfThree(o1, o2, o3);
3381  }
3383  {
3384  return threadContext->ArrayOfFour(o1, o2, o3, o4);
3385  }
3387  {
3388  return threadContext->ArrayOfOne(o);
3389  }
3391  {
3392  return threadContext->ArrayOfTwo(o1, o2);
3393  }
3395  {
3396  return threadContext->ArrayOfThree(o1, o2, o3);
3397  }
3399  {
3400  return threadContext->ArrayOfFour(o1, o2, o3, o4);
3401  }
3403  {
3404  return threadContext->IsArray(o);
3405  }
3406 
3408  {
3409  return threadContext->BufferData(bo);
3410  }
3411  size_t BufferLength(RexxBufferObject bo)
3412  {
3413  return threadContext->BufferLength(bo);
3414  }
3416  {
3417  return threadContext->NewBuffer(n);
3418  }
3420  {
3421  return threadContext->IsBuffer(o);
3422  }
3423 
3425  {
3426  return threadContext->MutableBufferData(bo);
3427  }
3428 
3430  {
3431  return threadContext->MutableBufferLength(bo);
3432  }
3433 
3434  size_t SetMutableBufferLength(RexxMutableBufferObject bo, size_t l)
3435  {
3436  return threadContext->SetMutableBufferLength(bo, l);
3437  }
3438 
3440  {
3441  return threadContext->NewMutableBuffer(n);
3442  }
3443 
3445  {
3446  return threadContext->IsMutableBuffer(o);
3447  }
3448 
3449 
3451  {
3452  return threadContext->MutableBufferCapacity(bo);
3453  }
3454 
3456  {
3457  return threadContext->SetMutableBufferCapacity(bo, l);
3458  }
3459 
3461  {
3462  return threadContext->PointerValue(po);
3463  }
3465  {
3466  return threadContext->NewPointer(p);
3467  }
3469  {
3470  return threadContext->IsPointer(o);
3471  }
3472 
3474  {
3475  return threadContext->SupplierItem(so);
3476  }
3478  {
3479  return threadContext->SupplierIndex(so);
3480  }
3482  {
3483  return threadContext->SupplierAvailable(so);
3484  }
3486  {
3487  threadContext->SupplierNext(so);
3488  }
3490  {
3491  return threadContext->NewSupplier(values, names);
3492  }
3493 
3495  {
3496  return threadContext->NewStem(n);
3497  }
3499  {
3500  threadContext->SetStemElement(so, s, o);
3501  }
3503  {
3504  return threadContext->GetStemElement(so, s);
3505  }
3507  {
3508  threadContext->DropStemElement(so, s);
3509  }
3510  void SetStemArrayElement(RexxStemObject so, size_t n, RexxObjectPtr o)
3511  {
3512  threadContext->SetStemArrayElement(so, n, o);
3513  }
3515  {
3516  return threadContext->GetStemArrayElement(so, n);
3517  }
3518  void DropStemArrayElement(RexxStemObject so, size_t n)
3519  {
3520  threadContext->DropStemArrayElement(so, n);
3521  }
3523  {
3524  return threadContext->GetAllStemElements(so);
3525  }
3527  {
3528  return threadContext->GetStemValue(so);
3529  }
3531  {
3532  return threadContext->IsStem(o);
3533  }
3534 
3535  void RaiseException0(size_t n)
3536  {
3537  threadContext->RaiseException0(n);
3538  }
3539  void RaiseException1(size_t n, RexxObjectPtr o)
3540  {
3541  threadContext->RaiseException1(n, o);
3542  }
3543  void RaiseException2(size_t n, RexxObjectPtr o1, RexxObjectPtr o2)
3544  {
3545  threadContext->RaiseException2(n, o1, o2);
3546  }
3547  void RaiseException(size_t n, RexxArrayObject ao)
3548  {
3549  threadContext->RaiseException(n, ao);
3550  }
3552  {
3553  threadContext->RaiseCondition(s1, s2, ao, o);
3554  }
3556  {
3557  return threadContext->CheckCondition();
3558  }
3560  {
3561  return threadContext->DisplayCondition();
3562  }
3564  {
3565  return threadContext->GetConditionInfo();
3566  }
3568  {
3569  threadContext->DecodeConditionInfo(diro, c);
3570  }
3571  void ClearCondition()
3572  {
3573  threadContext->ClearCondition();
3574  }
3575 
3576  RexxObjectPtr Nil()
3577  {
3578  return threadContext->Nil();
3579  }
3580  RexxObjectPtr True()
3581  {
3582  return threadContext->True();
3583  }
3584  RexxObjectPtr False()
3585  {
3586  return threadContext->False();
3587  }
3588  RexxStringObject NullString()
3589  {
3590  return threadContext->NullString();
3591  }
3593  {
3594  functions->SetContextVariable(this, s, o);
3595  }
3597  {
3598  return functions->GetContextVariable(this, s);
3599  }
3601  {
3602  functions->DropContextVariable(this, s);
3603  }
3605  {
3606  return functions->GetAllContextVariables(this);
3607  }
3609  {
3610  return functions->GetCallerContext(this);
3611  }
3612 #endif
3613 };
3614 
3616 
3618 
3619 END_EXTERN_C()
3620 
3621 #define ARGUMENT_TYPE_ARGLIST RexxArrayObject
3622 #define ARGUMENT_TYPE_NAME CSTRING
3623 #define ARGUMENT_TYPE_SCOPE RexxObjectPtr
3624 #define ARGUMENT_TYPE_CSELF POINTER
3625 #define ARGUMENT_TYPE_OSELF RexxObjectPtr
3626 #define ARGUMENT_TYPE_SUPER RexxClassObject
3627 
3628 // each of the following types have an optional equivalent
3629 
3630 #define ARGUMENT_TYPE_RexxObjectPtr RexxObjectPtr
3631 #define ARGUMENT_TYPE_RexxClassObject RexxClassObject
3632 #define ARGUMENT_TYPE_int int
3633 #define ARGUMENT_TYPE_wholenumber_t wholenumber_t
3634 #define ARGUMENT_TYPE_stringsize_t stringsize_t
3635 #define ARGUMENT_TYPE_double double
3636 #define ARGUMENT_TYPE_CSTRING CSTRING
3637 #define ARGUMENT_TYPE_POINTER POINTER
3638 #define ARGUMENT_TYPE_RexxStringObject RexxStringObject
3639 #define ARGUMENT_TYPE_float float
3640 #define ARGUMENT_TYPE_int8_t int8_t
3641 #define ARGUMENT_TYPE_int16_t int16_t
3642 #define ARGUMENT_TYPE_int32_t int32_t
3643 #define ARGUMENT_TYPE_int64_t int64_t
3644 #define ARGUMENT_TYPE___int64_t int64_t
3645 #define ARGUMENT_TYPE_uint8_t uint8_t
3646 #define ARGUMENT_TYPE_uint16_t uint16_t
3647 #define ARGUMENT_TYPE_uint32_t uint32_t
3648 #define ARGUMENT_TYPE_uint64_t uint64_t
3649 #define ARGUMENT_TYPE___uint64_t uint64_t
3650 #define ARGUMENT_TYPE_size_t size_t
3651 #define ARGUMENT_TYPE_ssize_t ssize_t
3652 #define ARGUMENT_TYPE_intptr_t intptr_t
3653 #define ARGUMENT_TYPE_uintptr_t uintptr_t
3654 #define ARGUMENT_TYPE___uintptr_t uintptr_t
3655 #define ARGUMENT_TYPE_logical_t logical_t
3656 #define ARGUMENT_TYPE_RexxArrayObject RexxArrayObject
3657 #define ARGUMENT_TYPE_RexxStemObject RexxStemObject
3658 #define ARGUMENT_TYPE_POINTERSTRING POINTER
3659 #define ARGUMENT_TYPE_RexxMutableBufferObject RexxMutableBufferObject
3660 
3661 #define ARGUMENT_TYPE_OPTIONAL_RexxObjectPtr RexxObjectPtr
3662 #define ARGUMENT_TYPE_OPTIONAL_int int
3663 #define ARGUMENT_TYPE_OPTIONAL_wholenumber_t wholenumber_t
3664 #define ARGUMENT_TYPE_OPTIONAL_stringsize_t stringsize_t
3665 #define ARGUMENT_TYPE_OPTIONAL_double double
3666 #define ARGUMENT_TYPE_OPTIONAL_CSTRING CSTRING
3667 #define ARGUMENT_TYPE_OPTIONAL_POINTER POINTER
3668 #define ARGUMENT_TYPE_OPTIONAL_RexxStringObject RexxStringObject
3669 #define ARGUMENT_TYPE_OPTIONAL_float float
3670 #define ARGUMENT_TYPE_OPTIONAL_int8_t int8_t
3671 #define ARGUMENT_TYPE_OPTIONAL_int16_t int16_t
3672 #define ARGUMENT_TYPE_OPTIONAL_int32_t int32_t
3673 #define ARGUMENT_TYPE_OPTIONAL_int64_t int64_t
3674 #define ARGUMENT_TYPE_OPTIONAL_uint8_t uint8_t
3675 #define ARGUMENT_TYPE_OPTIONAL_uint16_t uint16_t
3676 #define ARGUMENT_TYPE_OPTIONAL_uint32_t uint32_t
3677 #define ARGUMENT_TYPE_OPTIONAL_uint64_t uint64_t
3678 #define ARGUMENT_TYPE_OPTIONAL_size_t size_t
3679 #define ARGUMENT_TYPE_OPTIONAL_ssize_t ssize_t
3680 #define ARGUMENT_TYPE_OPTIONAL_intptr_t intptr_t
3681 #define ARGUMENT_TYPE_OPTIONAL_uintptr_t uintptr_t
3682 #define ARGUMENT_TYPE_OPTIONAL_logical_t logical_t
3683 #define ARGUMENT_TYPE_OPTIONAL_RexxArrayObject RexxArrayObject
3684 #define ARGUMENT_TYPE_OPTIONAL_RexxStemObject RexxStemObject
3685 #define ARGUMENT_TYPE_OPTIONAL_POINTERSTRING POINTER
3686 #define ARGUMENT_TYPE_OPTIONAL_RexxClassObject RexxClassObject
3687 #define ARGUMENT_TYPE_OPTIONAL_RexxMutableBufferObject RexxMutableBufferObject
3688 
3689 #define ARGUMENT_TYPE(t) ((t) & ~REXX_OPTIONAL_ARGUMENT)
3690 #define IS_OPTIONAL_ARGUMENT(t) (((t) & REXX_OPTIONAL_ARGUMENT) != 0)
3691 
3692 
3693 #define argumentExists(i) ((context->arguments[i].flags & ARGUMENT_EXISTS) != 0)
3694 #define argumentOmitted(i) (!argumentExists(i))
3695 
3696 
3697 #define __type(t) ARGUMENT_TYPE_##t
3698 #define __arg(p, t) arguments[p].value.value_##t
3699 #define __ret(t, v) arguments[0].value.value_##t = (v); return NULL;
3700 #define __adcl(t, n) __type(t) n
3701 #define __tdcl(t) REXX_VALUE_##t
3702 
3703 #define __methodstub(name) uint16_t * RexxEntry name (RexxMethodContext *context, ValueDescriptor *arguments)
3704 
3705 #ifdef __cplusplus
3706 #define __cpp_method_proto(name) extern "C" __methodstub(name);
3707 #else
3708 #define __cpp_method_proto(name) __methodstub(name);
3709 #endif
3710 
3711 
3712 // macro to simply the process of a setting a value descriptor
3713 #define SET_REXX_VALUE(v, t, val) \
3714 { \
3715  (v).type = REXX_VALUE##t; \
3716  (v).value.value_##t = (val);\
3717 }
3718 
3719 // macro to simplify getting a value from a value descriptor
3720 #define GET_REXX_VALUE(v, t) ((v).value.value_##t)
3721 
3722 
3723 #define REXX_METHOD_PROTOTYPE(name) __cpp_method_proto(name)
3724 
3725 // zero argument method call
3726 
3727 #define RexxMethod0(returnType, name) \
3728 /* forward reference definition for method */ \
3729 __type(returnType) name##_impl (RexxMethodContext * context); \
3730  \
3731 /* method signature definition */ \
3732 static uint16_t name##_types[] = {__tdcl(returnType), REXX_ARGUMENT_TERMINATOR}; \
3733 \
3734 __cpp_method_proto(name) \
3735 /* generated calling stub function */ \
3736 __methodstub(name) \
3737 { \
3738  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3739  { \
3740  /* forward to the method implementation */ \
3741  __ret(returnType, (name##_impl(context))); \
3742  } \
3743  return name##_types; /* return the type signature */ \
3744 } \
3745 /* the real target method code */ \
3746 __type(returnType) name##_impl(RexxMethodContext *context)
3747 
3748 
3749 // method with one argument
3750 #define RexxMethod1(returnType ,name, t1, n1) \
3751 /* forward reference definition for method */ \
3752 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1)); \
3753  \
3754 /* method signature definition */ \
3755 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), REXX_ARGUMENT_TERMINATOR}; \
3756 \
3757 __cpp_method_proto(name) \
3758 /* generated calling stub function */ \
3759 __methodstub(name) \
3760 { \
3761  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3762  { \
3763  /* forward to the method implementation */ \
3764  __ret(returnType, name##_impl(context, __arg(1, t1))); \
3765  } \
3766  return name##_types; /* return the type signature */ \
3767 } \
3768 /* the real target method code */ \
3769 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1))
3770 
3771 
3772 // method with two arguments
3773 #define RexxMethod2(returnType ,name, t1, n1, t2, n2) \
3774 /* forward reference definition for method */ \
3775 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2)); \
3776  \
3777 /* method signature definition */ \
3778 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), REXX_ARGUMENT_TERMINATOR}; \
3779 \
3780 __cpp_method_proto(name) \
3781 /* generated calling stub function */ \
3782 __methodstub(name) \
3783 { \
3784  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3785  { \
3786  /* forward to the method implementation */ \
3787  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2))); \
3788  } \
3789  return name##_types; /* return the type signature */ \
3790 } \
3791 /* the real target method code */ \
3792 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2))
3793 
3794 
3795 // method with three arguments
3796 #define RexxMethod3(returnType ,name, t1, n1, t2, n2, t3, n3) \
3797 /* forward reference definition for method */ \
3798 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3)); \
3799  \
3800 /* method signature definition */ \
3801 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), REXX_ARGUMENT_TERMINATOR}; \
3802 \
3803 __cpp_method_proto(name) \
3804 /* generated calling stub function */ \
3805 __methodstub(name) \
3806 { \
3807  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3808  { \
3809  /* forward to the method implementation */ \
3810  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3))); \
3811  } \
3812  return name##_types; /* return the type signature */ \
3813 } \
3814 /* the real target method code */ \
3815 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3))
3816 
3817 
3818 // method with four arguments
3819 #define RexxMethod4(returnType ,name, t1, n1, t2, n2, t3, n3, t4, n4) \
3820 /* forward reference definition for method */ \
3821 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4)); \
3822  \
3823 /* method signature definition */ \
3824 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), REXX_ARGUMENT_TERMINATOR}; \
3825 \
3826 __cpp_method_proto(name) \
3827 /* generated calling stub function */ \
3828 __methodstub(name) \
3829 { \
3830  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3831  { \
3832  /* forward to the method implementation */ \
3833  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4))); \
3834  } \
3835  return name##_types; /* return the type signature */ \
3836 } \
3837 /* the real target method code */ \
3838 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4))
3839 
3840 
3841 // method with five arguments
3842 #define RexxMethod5(returnType ,name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5) \
3843 /* forward reference definition for method */ \
3844 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5)); \
3845  \
3846 /* method signature definition */ \
3847 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), REXX_ARGUMENT_TERMINATOR}; \
3848 \
3849 __cpp_method_proto(name) \
3850 /* generated calling stub function */ \
3851 __methodstub(name) \
3852 { \
3853  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3854  { \
3855  /* forward to the method implementation */ \
3856  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5))); \
3857  } \
3858  return name##_types; /* return the type signature */ \
3859 } \
3860 /* the real target method code */ \
3861 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5))
3862 
3863 
3864 // method with six arguments
3865 #define RexxMethod6(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6) \
3866 /* forward reference definition for method */ \
3867 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6)); \
3868  \
3869 /* method signature definition */ \
3870 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), REXX_ARGUMENT_TERMINATOR}; \
3871 \
3872 __cpp_method_proto(name) \
3873 /* generated calling stub function */ \
3874 __methodstub(name) \
3875 { \
3876  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3877  { \
3878  /* forward to the method implementation */ \
3879  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6))); \
3880  } \
3881  return name##_types; /* return the type signature */ \
3882 } \
3883 /* the real target method code */ \
3884 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6))
3885 
3886 
3887 // method with seven arguments
3888 #define RexxMethod7(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7) \
3889 /* forward reference definition for method */ \
3890 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7)); \
3891  \
3892 /* method signature definition */ \
3893 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), REXX_ARGUMENT_TERMINATOR}; \
3894 \
3895 __cpp_method_proto(name) \
3896 /* generated calling stub function */ \
3897 __methodstub(name) \
3898 { \
3899  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3900  { \
3901  /* forward to the method implementation */ \
3902  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6), __arg(7, t7))); \
3903  } \
3904  return name##_types; /* return the type signature */ \
3905 } \
3906 /* the real target method code */ \
3907 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7))
3908 
3909 
3910 // method with eight arguments
3911 #define RexxMethod8(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8) \
3912 /* forward reference definition for method */ \
3913 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8)); \
3914  \
3915 /* method signature definition */ \
3916 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), REXX_ARGUMENT_TERMINATOR}; \
3917 \
3918 __cpp_method_proto(name) \
3919 /* generated calling stub function */ \
3920 __methodstub(name) \
3921 { \
3922  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3923  { \
3924  /* forward to the method implementation */ \
3925  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6), __arg(7, t7), __arg(8, t8))); \
3926  } \
3927  return name##_types; /* return the type signature */ \
3928 } \
3929 /* the real target method code */ \
3930 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8))
3931 
3932 
3933 // method with nine arguments
3934 #define RexxMethod9(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8, t9, n9) \
3935 /* forward reference definition for method */ \
3936 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9)); \
3937  \
3938 /* method signature definition */ \
3939 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), __tdcl(t9), REXX_ARGUMENT_TERMINATOR}; \
3940 \
3941 __cpp_method_proto(name) \
3942 /* generated calling stub function */ \
3943 __methodstub(name) \
3944 { \
3945  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3946  { \
3947  /* forward to the method implementation */ \
3948  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6), __arg(7, t7), __arg(8, t8), __arg(9, t9))); \
3949  } \
3950  return name##_types; /* return the type signature */ \
3951 } \
3952 /* the real target method code */ \
3953 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9))
3954 
3955 
3956 // method with 10 arguments
3957 #define RexxMethod10(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8, t9, n9, t10, n10) \
3958 /* forward reference definition for method */ \
3959 __type(returnType) name##_impl (RexxMethodContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10)); \
3960  \
3961 /* method signature definition */ \
3962 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), __tdcl(t9), __tdcl(t10), REXX_ARGUMENT_TERMINATOR}; \
3963 \
3964 __cpp_method_proto(name) \
3965 /* generated calling stub function */ \
3966 __methodstub(name) \
3967 { \
3968  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
3969  { \
3970  /* forward to the method implementation */ \
3971  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6), __arg(7, t7), __arg(8, t8), __arg(9, t9), __arg(10, t10))); \
3972  } \
3973  return name##_types; /* return the type signature */ \
3974 } \
3975 /* the real target method code */ \
3976 __type(returnType) name##_impl(RexxMethodContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10))
3977 
3978 
3979 #define __functionstub(name) uint16_t * RexxEntry name(RexxCallContext *context, ValueDescriptor *arguments)
3980 
3981 #ifdef __cplusplus
3982 #define __cpp_function_proto(name) extern "C" __functionstub(name);
3983 #else
3984 #define __cpp_function_proto(name) __functionstub(name);
3985 #endif
3986 
3987 #define REXX_TYPED_ROUTINE_PROTOTYPE(name) __cpp_function_proto(name)
3988 
3989 // zero argument function call
3990 
3991 #define RexxRoutine0(returnType, name) \
3992 /* forward reference definition for method */ \
3993 __type(returnType) name##_impl (RexxCallContext * context); \
3994  \
3995 /* method signature definition */ \
3996 static uint16_t name##_types[] = {__tdcl(returnType), REXX_ARGUMENT_TERMINATOR}; \
3997 \
3998 __cpp_function_proto(name) \
3999 /* generated calling stub function */ \
4000 __functionstub(name) \
4001 { \
4002  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4003  { \
4004  /* forward to the method implementation */ \
4005  __ret(returnType, name##_impl(context)); \
4006  } \
4007  return name##_types; /* return the type signature */ \
4008 } \
4009 /* the real target method code */ \
4010 __type(returnType) name##_impl(RexxCallContext *context)
4011 
4012 
4013 // method with one argument
4014 #define RexxRoutine1(returnType ,name, t1, n1) \
4015 /* forward reference definition for method */ \
4016 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1)); \
4017  \
4018 /* method signature definition */ \
4019 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), REXX_ARGUMENT_TERMINATOR}; \
4020 \
4021 __cpp_function_proto(name) \
4022 /* generated calling stub function */ \
4023 __functionstub(name) \
4024 { \
4025  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4026  { \
4027  /* forward to the method implementation */ \
4028  __ret(returnType, name##_impl(context, __arg(1, t1))); \
4029  } \
4030  return name##_types; /* return the type signature */ \
4031 } \
4032 /* the real target method code */ \
4033 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1))
4034 
4035 
4036 // method with two arguments
4037 #define RexxRoutine2(returnType ,name, t1, n1, t2, n2) \
4038 /* forward reference definition for method */ \
4039 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2)); \
4040  \
4041 /* method signature definition */ \
4042 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), REXX_ARGUMENT_TERMINATOR }; \
4043 \
4044 __cpp_function_proto(name) \
4045 /* generated calling stub function */ \
4046 __functionstub(name) \
4047 { \
4048  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4049  { \
4050  /* forward to the method implementation */ \
4051  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2))); \
4052  } \
4053  return name##_types; /* return the type signature */ \
4054 } \
4055 /* the real target method code */ \
4056 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2))
4057 
4058 
4059 // method with three arguments
4060 #define RexxRoutine3(returnType ,name, t1, n1, t2, n2, t3, n3) \
4061 /* forward reference definition for method */ \
4062 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3)); \
4063  \
4064 /* method signature definition */ \
4065 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), REXX_ARGUMENT_TERMINATOR}; \
4066 \
4067 __cpp_function_proto(name) \
4068 /* generated calling stub function */ \
4069 __functionstub(name) \
4070 { \
4071  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4072  { \
4073  /* forward to the method implementation */ \
4074  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3))); \
4075  } \
4076  return name##_types; /* return the type signature */ \
4077 } \
4078 /* the real target method code */ \
4079 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3))
4080 
4081 
4082 // method with four arguments
4083 #define RexxRoutine4(returnType ,name, t1, n1, t2, n2, t3, n3, t4, n4) \
4084 /* forward reference definition for method */ \
4085 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4)); \
4086  \
4087 /* method signature definition */ \
4088 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), REXX_ARGUMENT_TERMINATOR}; \
4089 \
4090 __cpp_function_proto(name) \
4091 /* generated calling stub function */ \
4092 __functionstub(name) \
4093 { \
4094  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4095  { \
4096  /* forward to the method implementation */ \
4097  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4))); \
4098  } \
4099  return name##_types; /* return the type signature */ \
4100 } \
4101 /* the real target method code */ \
4102 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4))
4103 
4104 
4105 // method with five arguments
4106 #define RexxRoutine5(returnType ,name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5) \
4107 /* forward reference definition for method */ \
4108 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5)); \
4109  \
4110 /* method signature definition */ \
4111 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), REXX_ARGUMENT_TERMINATOR}; \
4112 \
4113 __cpp_function_proto(name) \
4114 /* generated calling stub function */ \
4115 __functionstub(name) \
4116 { \
4117  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4118  { \
4119  /* forward to the method implementation */ \
4120  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5))); \
4121  } \
4122  return name##_types; /* return the type signature */ \
4123 } \
4124 /* the real target method code */ \
4125 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5))
4126 
4127 
4128 // method with six arguments
4129 #define RexxRoutine6(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6) \
4130 /* forward reference definition for method */ \
4131 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6)); \
4132  \
4133 /* method signature definition */ \
4134 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), REXX_ARGUMENT_TERMINATOR}; \
4135 \
4136 __cpp_function_proto(name) \
4137 /* generated calling stub function */ \
4138 __functionstub(name) \
4139 { \
4140  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4141  { \
4142  /* forward to the method implementation */ \
4143  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6))); \
4144  } \
4145  return name##_types; /* return the type signature */ \
4146 } \
4147 /* the real target method code */ \
4148 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6))
4149 
4150 // method with seven arguments
4151 #define RexxRoutine7(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7) \
4152 /* forward reference definition for method */ \
4153 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7)); \
4154  \
4155 /* method signature definition */ \
4156 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), REXX_ARGUMENT_TERMINATOR}; \
4157 \
4158 __cpp_function_proto(name) \
4159 /* generated calling stub function */ \
4160 __functionstub(name) \
4161 { \
4162  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4163  { \
4164  /* forward to the method implementation */ \
4165  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6), __arg(7, t7))); \
4166  } \
4167  return name##_types; /* return the type signature */ \
4168 } \
4169 /* the real target method code */ \
4170 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7))
4171 
4172 
4173 // function with eight arguments
4174 #define RexxRoutine8(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8) \
4175 /* forward reference definition for method */ \
4176 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8)); \
4177  \
4178 /* method signature definition */ \
4179 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), REXX_ARGUMENT_TERMINATOR}; \
4180 \
4181 __cpp_function_proto(name) \
4182 /* generated calling stub function */ \
4183 __functionstub(name) \
4184 { \
4185  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4186  { \
4187  /* forward to the method implementation */ \
4188  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6), __arg(7, t7), __arg(8, t8))); \
4189  } \
4190  return name##_types; /* return the type signature */ \
4191 } \
4192 /* the real target method code */ \
4193 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8))
4194 
4195 
4196 // function with nine arguments
4197 #define RexxRoutine9(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8, t9, n9) \
4198 /* forward reference definition for method */ \
4199 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9)); \
4200  \
4201 /* method signature definition */ \
4202 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), __tdcl(t9), REXX_ARGUMENT_TERMINATOR}; \
4203 \
4204 __cpp_function_proto(name) \
4205 /* generated calling stub function */ \
4206 __functionstub(name) \
4207 { \
4208  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4209  { \
4210  /* forward to the method implementation */ \
4211  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6), __arg(7, t7), __arg(8, t8), __arg(9, t9))); \
4212  } \
4213  return name##_types; /* return the type signature */ \
4214 } \
4215 /* the real target method code */ \
4216 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9))
4217 
4218 
4219 // function with ten arguments
4220 #define RexxRoutine10(returnType, name, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5, t6, n6, t7, n7, t8, n8, t9, n9, t10, n10) \
4221 /* forward reference definition for method */ \
4222 __type(returnType) name##_impl (RexxCallContext * context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10)); \
4223  \
4224 /* method signature definition */ \
4225 static uint16_t name##_types[] = {__tdcl(returnType), __tdcl(t1), __tdcl(t2), __tdcl(t3), __tdcl(t4), __tdcl(t5), __tdcl(t6), __tdcl(t7), __tdcl(t8), __tdcl(t9), __tdcl(t10), REXX_ARGUMENT_TERMINATOR}; \
4226 \
4227 __cpp_function_proto(name) \
4228 /* generated calling stub function */ \
4229 __functionstub(name) \
4230 { \
4231  if (arguments != NULL) /* if no arguments passed, this a signature request */ \
4232  { \
4233  /* forward to the method implementation */ \
4234  __ret(returnType, name##_impl(context, __arg(1, t1), __arg(2, t2), __arg(3, t3), __arg(4, t4), __arg(5, t5), __arg(6, t6), __arg(7, t7), __arg(8, t8), __arg(9, t9), __arg(10, t10))); \
4235  } \
4236  return name##_types; /* return the type signature */ \
4237 } \
4238 /* the real target method code */ \
4239 __type(returnType) name##_impl(RexxCallContext *context, __adcl(t1, n1), __adcl(t2, n2), __adcl(t3, n3), __adcl(t4, n4), __adcl(t5, n5), __adcl(t6, n6), __adcl(t7, n7), __adcl(t8, n8), __adcl(t9, n9), __adcl(t10, n10))
4240 
4241 /******************************************************************************/
4242 /* Types (used in macro expansions and function prototypes) */
4243 /******************************************************************************/
4245 typedef void * CSELF;
4246 typedef void * BUFFER;
4250 typedef CSTRING NAME;
4251 
4252 #endif
_RexxMethodEntry
Definition: oorexxapi.h:197
GetSelf
RexxObjectPtr RexxEntry GetSelf(RexxMethodContext *c)
Definition: MethodContextStubs.cpp:104
ValueDescriptor::value_uint32_t
uint32_t value_uint32_t
Definition: oorexxapi.h:293
_RexxMethodEntry::name
const char * name
Definition: oorexxapi.h:201
SendMessage1
RexxObjectPtr RexxEntry SendMessage1(RexxThreadContext *c, RexxObjectPtr o, CSTRING m, RexxObjectPtr a1)
Definition: ThreadContextStubs.cpp:186
RexxContextEnvironment::handler
RexxContextCommandHandler * handler
Definition: oorexxapi.h:400
ValueDescriptor::value_logical_t
logical_t value_logical_t
Definition: oorexxapi.h:280
RexxInstance_::functions
RexxInstanceInterface * functions
Definition: oorexxapi.h:679
ArrayDimension
size_t RexxEntry ArrayDimension(RexxThreadContext *c, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:1347
ValueDescriptor::value_uintptr_t
uintptr_t value_uintptr_t
Definition: oorexxapi.h:297
StringLower
RexxStringObject RexxEntry StringLower(RexxThreadContext *c, RexxStringObject s)
Definition: ThreadContextStubs.cpp:1102
logical_t
size_t logical_t
Definition: rexx.h:230
ValueDescriptor::value_int64_t
int64_t value_int64_t
Definition: oorexxapi.h:289
RexxDirectoryObject
struct _RexxDirectoryObject * RexxDirectoryObject
Definition: rexx.h:137
CSTRING
const typedef char * CSTRING
Definition: rexx.h:78
_RexxPackageEntry::packageName
const char * packageName
Definition: oorexxapi.h:246
_RexxRoutineEntry::style
int style
Definition: oorexxapi.h:178
IsStem
logical_t RexxEntry IsStem(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1717
_RexxContextExit::handler
RexxContextExitHandler * handler
Definition: oorexxapi.h:171
GetCSelf
POINTER RexxEntry GetCSelf(RexxMethodContext *c)
Definition: MethodContextStubs.cpp:117
ValueDescriptor::value_OPTIONAL_int8_t
int8_t value_OPTIONAL_int8_t
Definition: oorexxapi.h:320
RexxThreadInterface::d
CSTRING d
Definition: oorexxapi.h:478
ExitContextInterface::RexxObjectPtr
RexxObjectPtr
Definition: oorexxapi.h:668
RexxMethodContext_::functions
MethodContextInterface * functions
Definition: oorexxapi.h:1407
ObjectToCSelfScoped
POINTER RexxEntry ObjectToCSelfScoped(RexxThreadContext *c, RexxObjectPtr o, RexxObjectPtr s)
Definition: ThreadContextStubs.cpp:613
RaiseCondition
void RexxEntry RaiseCondition(RexxThreadContext *c, CSTRING n, RexxStringObject desc, RexxObjectPtr add, RexxObjectPtr result)
Definition: ThreadContextStubs.cpp:1778
StringData
CSTRING RexxEntry StringData(RexxThreadContext *c, RexxStringObject s)
Definition: ThreadContextStubs.cpp:1048
ValueDescriptor::value_OPTIONAL_double
double value_OPTIONAL_double
Definition: oorexxapi.h:314
RexxLibraryPackage::table
RexxPackageEntry * table
Definition: oorexxapi.h:413
_RexxPackageEntry::routines
struct _RexxRoutineEntry * routines
Definition: oorexxapi.h:250
rexx.h
RexxCondition::code
wholenumber_t code
Definition: oorexxapi.h:424
SupplierItem
RexxObjectPtr RexxEntry SupplierItem(RexxThreadContext *c, RexxSupplierObject o)
Definition: ThreadContextStubs.cpp:1530
_RexxRoutineEntry
Definition: oorexxapi.h:176
ValueDescriptor::value_OPTIONAL_CSTRING
CSTRING value_OPTIONAL_CSTRING
Definition: oorexxapi.h:315
GetPackagePublicRoutines
RexxDirectoryObject RexxEntry GetPackagePublicRoutines(RexxThreadContext *c, RexxPackageObject m)
Definition: ThreadContextStubs.cpp:419
ValueDescriptor::value_RexxClassObject
RexxClassObject value_RexxClassObject
Definition: oorexxapi.h:276
RexxArrayObject
struct _RexxArrayObject * RexxArrayObject
Definition: rexx.h:130
CallProgram
RexxObjectPtr RexxEntry CallProgram(RexxThreadContext *c, const char *p, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:488
MethodContextInterface
Definition: oorexxapi.h:619
FindContextClass
RexxClassObject RexxEntry FindContextClass(RexxMethodContext *c, CSTRING n)
Definition: MethodContextStubs.cpp:233
ValueDescriptor::value_int16_t
int16_t value_int16_t
Definition: oorexxapi.h:287
RaiseException2
void RexxEntry RaiseException2(RexxThreadContext *c, size_t n, RexxObjectPtr o1, RexxObjectPtr o2)
Definition: ThreadContextStubs.cpp:1754
RexxThreadContext_
Definition: oorexxapi.h:710
RexxThreadInterface::intptr_t
intptr_t
Definition: oorexxapi.h:502
RexxThreadInterface::RexxObjectPtr
int32_t uint32_t uintptr_t RexxObjectPtr
Definition: oorexxapi.h:518
RexxThreadInterface::RexxMethodObject
RexxMethodObject
Definition: oorexxapi.h:497
CallContextInterface::RexxObjectPtr
RexxObjectPtr
Definition: oorexxapi.h:650
GetLocalEnvironment
RexxDirectoryObject RexxEntry GetLocalEnvironment(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:216
NewArray
RexxArrayObject RexxEntry NewArray(RexxThreadContext *c, size_t s)
Definition: ThreadContextStubs.cpp:1360
CallRoutine
RexxObjectPtr RexxEntry CallRoutine(RexxThreadContext *c, RexxRoutineObject r, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:472
StringLength
size_t RexxEntry StringLength(RexxThreadContext *c, RexxStringObject s)
Definition: ThreadContextStubs.cpp:1034
ValueDescriptor::value_RexxObjectPtr
RexxObjectPtr value_RexxObjectPtr
Definition: oorexxapi.h:275
SetStemArrayElement
void RexxEntry SetStemArrayElement(RexxThreadContext *c, RexxStemObject s, size_t i, RexxObjectPtr v)
Definition: ThreadContextStubs.cpp:1654
RexxThreadInterface::RexxSupplierObject
RexxSupplierObject
Definition: oorexxapi.h:570
RexxMethodEntry
struct _RexxMethodEntry RexxMethodEntry
ValueDescriptor::value_wholenumber_t
wholenumber_t value_wholenumber_t
Definition: oorexxapi.h:278
ValueDescriptor::value_ssize_t
ssize_t value_ssize_t
Definition: oorexxapi.h:300
MutableBufferLength
size_t RexxEntry MutableBufferLength(RexxThreadContext *c, RexxMutableBufferObject b)
Definition: ThreadContextStubs.cpp:1870
GetSuper
RexxClassObject RexxEntry GetSuper(RexxMethodContext *c)
Definition: MethodContextStubs.cpp:130
type
int type
Definition: cmdparse.cpp:1965
IntptrToObject
RexxObjectPtr RexxEntry IntptrToObject(RexxThreadContext *c, intptr_t n)
Definition: ThreadContextStubs.cpp:654
SUPER
RexxClassObject SUPER
Definition: oorexxapi.h:4249
ObjectToIntptr
logical_t RexxEntry ObjectToIntptr(RexxThreadContext *c, RexxObjectPtr o, intptr_t *n)
Definition: ThreadContextStubs.cpp:912
ClearCondition
void RexxEntry ClearCondition(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1845
RexxThreadInterface::RexxArrayObject
RexxArrayObject
Definition: oorexxapi.h:466
SetContextVariable
void RexxEntry SetContextVariable(RexxCallContext *c, CSTRING n, RexxObjectPtr v)
Definition: CallContextStubs.cpp:108
ValueDescriptor::value_OPTIONAL_RexxArrayObject
RexxArrayObject value_OPTIONAL_RexxArrayObject
Definition: oorexxapi.h:332
_RexxMethodEntry::reserved2
int reserved2
Definition: oorexxapi.h:203
ArrayAppendString
size_t RexxEntry ArrayAppendString(RexxThreadContext *c, RexxArrayObject a, CSTRING s, size_t l)
Definition: ThreadContextStubs.cpp:1304
RexxInstance
const struct RexxInstance_ * RexxInstance
Definition: oorexxapi.h:132
ValueToObject
RexxObjectPtr RexxEntry ValueToObject(RexxThreadContext *c, ValueDescriptor *d)
Definition: ThreadContextStubs.cpp:668
FinishBufferString
RexxStringObject RexxEntry FinishBufferString(RexxThreadContext *c, RexxBufferStringObject s, size_t l)
Definition: ThreadContextStubs.cpp:1170
GetConditionInfo
RexxDirectoryObject RexxEntry GetConditionInfo(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1819
RequestGlobalReference
RexxObjectPtr RexxEntry RequestGlobalReference(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:111
ValueDescriptor::value_OPTIONAL_RexxObjectPtr
RexxObjectPtr value_OPTIONAL_RexxObjectPtr
Definition: oorexxapi.h:309
CallContextInterface
Definition: oorexxapi.h:642
RexxThreadInterface
Definition: oorexxapi.h:455
RexxReturnCode
int RexxReturnCode
Definition: rexx.h:73
ValueDescriptor::value_NAME
CSTRING value_NAME
Definition: oorexxapi.h:270
WholeNumberToObject
RexxObjectPtr RexxEntry WholeNumberToObject(RexxThreadContext *c, wholenumber_t n)
Definition: ThreadContextStubs.cpp:628
ValueDescriptor::value_OPTIONAL_RexxStringObject
RexxStringObject value_OPTIONAL_RexxStringObject
Definition: oorexxapi.h:318
_RexxContextExit
Definition: oorexxapi.h:169
_RexxContextExit::sysexit_code
int sysexit_code
Definition: oorexxapi.h:172
NewString
RexxStringObject RexxEntry NewString(RexxThreadContext *c, CSTRING s, size_t l)
Definition: ThreadContextStubs.cpp:1062
RexxThreadInterface::RexxDirectoryObject
RexxDirectoryObject
Definition: oorexxapi.h:541
SetStemElement
void RexxEntry SetStemElement(RexxThreadContext *c, RexxStemObject s, CSTRING n, RexxObjectPtr v)
Definition: ThreadContextStubs.cpp:1617
ValueDescriptor::value_OPTIONAL_RexxClassObject
RexxClassObject value_OPTIONAL_RexxClassObject
Definition: oorexxapi.h:316
ValueDescriptor::value_RexxMutableBufferObject
RexxMutableBufferObject value_RexxMutableBufferObject
Definition: oorexxapi.h:304
RexxCondition
Definition: oorexxapi.h:423
ExitContextInterface::interfaceVersion
wholenumber_t interfaceVersion
Definition: oorexxapi.h:667
CallContextInterface::size_t
size_t
Definition: oorexxapi.h:647
RexxBufferObject
struct _RexxBufferObject * RexxBufferObject
Definition: rexx.h:131
RexxThreadInterface::RexxRoutineObject
RexxRoutineObject
Definition: oorexxapi.h:489
BufferStringData
POINTER RexxEntry BufferStringData(RexxThreadContext *c, RexxBufferStringObject s)
Definition: ThreadContextStubs.cpp:1156
BUFFER
void * BUFFER
Definition: oorexxapi.h:4246
ValueDescriptor::value_stringsize_t
stringsize_t value_stringsize_t
Definition: oorexxapi.h:279
RexxExitContext
const struct RexxExitContext_ * RexxExitContext
Definition: oorexxapi.h:160
GetMethodPackage
RexxPackageObject RexxEntry GetMethodPackage(RexxThreadContext *c, RexxMethodObject o)
Definition: ThreadContextStubs.cpp:583
RexxOption::optionName
const char * optionName
Definition: oorexxapi.h:418
SetGuardOff
void RexxEntry SetGuardOff(RexxMethodContext *c)
Definition: MethodContextStubs.cpp:221
ValuesToObject
RexxArrayObject RexxEntry ValuesToObject(RexxThreadContext *c, ValueDescriptor *d, size_t count)
Definition: ThreadContextStubs.cpp:683
ValueDescriptor
Definition: oorexxapi.h:261
RexxThreadInterface::RexxStringObject
RexxStringObject
Definition: oorexxapi.h:527
RexxPackageLoader
void(REXXENTRY * RexxPackageLoader)(RexxThreadContext *)
Definition: oorexxapi.h:238
DropContextVariable
void RexxEntry DropContextVariable(RexxCallContext *c, CSTRING n)
Definition: CallContextStubs.cpp:133
NewRoutine
RexxRoutineObject RexxEntry NewRoutine(RexxThreadContext *c, CSTRING n, CSTRING source, stringsize_t length)
Definition: ThreadContextStubs.cpp:521
ValueDescriptor::value_OPTIONAL_float
float value_OPTIONAL_float
Definition: oorexxapi.h:319
GetGlobalEnvironment
RexxDirectoryObject RexxEntry GetGlobalEnvironment(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:229
ValueDescriptor::value_OPTIONAL_uint16_t
uint16_t value_OPTIONAL_uint16_t
Definition: oorexxapi.h:325
SupplierIndex
RexxObjectPtr RexxEntry SupplierIndex(RexxThreadContext *c, RexxSupplierObject o)
Definition: ThreadContextStubs.cpp:1543
IsArray
logical_t RexxEntry IsArray(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1426
RexxRegisteredEnvironment::registeredName
const char * registeredName
Definition: oorexxapi.h:406
SetMutableBufferLength
size_t RexxEntry SetMutableBufferLength(RexxThreadContext *c, RexxMutableBufferObject b, size_t length)
Definition: ThreadContextStubs.cpp:1883
RexxCondition::conditionName
RexxStringObject conditionName
Definition: oorexxapi.h:427
ObjectToCSelf
POINTER RexxEntry ObjectToCSelf(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:598
GetMessageName
CSTRING RexxEntry GetMessageName(RexxMethodContext *c)
Definition: MethodContextStubs.cpp:91
GetObjectVariable
RexxObjectPtr RexxEntry GetObjectVariable(RexxMethodContext *c, CSTRING n)
Definition: MethodContextStubs.cpp:168
GetStemElement
RexxObjectPtr RexxEntry GetStemElement(RexxThreadContext *c, RexxStemObject s, CSTRING n)
Definition: ThreadContextStubs.cpp:1629
ValueDescriptor::value_POINTER
POINTER value_POINTER
Definition: oorexxapi.h:283
REXX_VALUE_RexxArrayObject
#define REXX_VALUE_RexxArrayObject
Definition: oorexxapi.h:87
HaltThread
void RexxEntry HaltThread(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:85
DoubleToObject
RexxObjectPtr RexxEntry DoubleToObject(RexxThreadContext *c, double n)
Definition: ThreadContextStubs.cpp:953
RexxCondition::message
RexxStringObject message
Definition: oorexxapi.h:428
MethodContextInterface::RexxObjectPtr
RexxObjectPtr
Definition: oorexxapi.h:630
oorexxerrors.h
CallContextInterface::interfaceVersion
wholenumber_t interfaceVersion
Definition: oorexxapi.h:644
REXX_VALUE_float
#define REXX_VALUE_float
Definition: oorexxapi.h:72
ValueDescriptor::value_uint8_t
uint8_t value_uint8_t
Definition: oorexxapi.h:291
NewBuffer
RexxBufferObject RexxEntry NewBuffer(RexxThreadContext *c, size_t l)
Definition: ThreadContextStubs.cpp:1465
RexxPackageEntry
struct _RexxPackageEntry RexxPackageEntry
DirectoryRemove
RexxObjectPtr RexxEntry DirectoryRemove(RexxThreadContext *c, RexxDirectoryObject t, CSTRING i)
Definition: ThreadContextStubs.cpp:1214
ValueDescriptor::value_OPTIONAL_logical_t
logical_t value_OPTIONAL_logical_t
Definition: oorexxapi.h:313
GetPackageClasses
RexxDirectoryObject RexxEntry GetPackageClasses(RexxThreadContext *c, RexxPackageObject m)
Definition: ThreadContextStubs.cpp:432
ValueDescriptor::value_OPTIONAL_int32_t
int32_t value_OPTIONAL_int32_t
Definition: oorexxapi.h:322
ForwardMessage
RexxObjectPtr RexxEntry ForwardMessage(RexxMethodContext *c, RexxObjectPtr o, CSTRING n, RexxClassObject clazz, RexxArrayObject a)
Definition: MethodContextStubs.cpp:193
Int32ToObject
RexxObjectPtr RexxEntry Int32ToObject(RexxThreadContext *c, int32_t n)
Definition: ThreadContextStubs.cpp:751
RexxClassObject
struct _RexxClassObject * RexxClassObject
Definition: rexx.h:136
IsDirectory
logical_t RexxEntry IsDirectory(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1242
GetContextFuzz
stringsize_t RexxEntry GetContextFuzz(RexxCallContext *c)
Definition: CallContextStubs.cpp:264
RexxBufferStringObject
struct _RexxBufferStringObject * RexxBufferStringObject
Definition: rexx.h:129
DirectoryAt
RexxObjectPtr RexxEntry DirectoryAt(RexxThreadContext *c, RexxDirectoryObject t, CSTRING i)
Definition: ThreadContextStubs.cpp:1199
RexxThreadInterface::uintptr_t
uintptr_t
Definition: oorexxapi.h:501
ArrayOfThree
RexxArrayObject RexxEntry ArrayOfThree(RexxThreadContext *c, RexxObjectPtr o1, RexxObjectPtr o2, RexxObjectPtr o3)
Definition: ThreadContextStubs.cpp:1399
ResolveStemVariable
RexxStemObject RexxEntry ResolveStemVariable(RexxCallContext *c, RexxObjectPtr s)
Definition: CallContextStubs.cpp:158
RexxThreadInterface::RexxBufferObject
RexxBufferObject
Definition: oorexxapi.h:561
RexxThreadInterface::n
CSTRING n
Definition: oorexxapi.h:479
RexxThreadInterface::logical_t
int32_t uint32_t uintptr_t intptr_t logical_t logical_t
Definition: oorexxapi.h:520
RexxMethodObject
struct _RexxMethodObject * RexxMethodObject
Definition: rexx.h:133
ValueDescriptor::value_int
int value_int
Definition: oorexxapi.h:277
LoadPackage
RexxPackageObject RexxEntry LoadPackage(RexxThreadContext *c, CSTRING n)
Definition: ThreadContextStubs.cpp:298
LanguageLevel
size_t RexxEntry LanguageLevel(RexxInstance *)
Definition: InterpreterInstanceStubs.cpp:84
NewMutableBuffer
RexxMutableBufferObject RexxEntry NewMutableBuffer(RexxThreadContext *c, size_t l)
Definition: ThreadContextStubs.cpp:1922
HasMethod
logical_t RexxEntry HasMethod(RexxThreadContext *c, RexxObjectPtr o, CSTRING n)
Definition: ThreadContextStubs.cpp:280
RexxInstanceInterface::interfaceVersion
wholenumber_t interfaceVersion
Definition: oorexxapi.h:439
ArrayItems
size_t RexxEntry ArrayItems(RexxThreadContext *c, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:1334
ValueDescriptor::value_OPTIONAL_ssize_t
ssize_t value_OPTIONAL_ssize_t
Definition: oorexxapi.h:330
NewStem
RexxStemObject RexxEntry NewStem(RexxThreadContext *c, CSTRING n)
Definition: ThreadContextStubs.cpp:1594
GetAllContextVariables
RexxDirectoryObject RexxEntry GetAllContextVariables(RexxCallContext *c)
Definition: CallContextStubs.cpp:145
RexxThreadInterface::uint64_t
uint64_t
Definition: oorexxapi.h:510
SCOPE
RexxObjectPtr SCOPE
Definition: oorexxapi.h:4248
REXX_VALUE_double
#define REXX_VALUE_double
Definition: oorexxapi.h:67
RexxThreadInterface::RexxPackageObject
RexxPackageObject
Definition: oorexxapi.h:483
GetStemValue
RexxObjectPtr RexxEntry GetStemValue(RexxThreadContext *c, RexxStemObject s)
Definition: ThreadContextStubs.cpp:1704
ValueDescriptor::value_RexxArrayObject
RexxArrayObject value_RexxArrayObject
Definition: oorexxapi.h:301
SetMutableBufferCapacity
POINTER RexxEntry SetMutableBufferCapacity(RexxThreadContext *c, RexxMutableBufferObject b, size_t length)
Definition: ThreadContextStubs.cpp:1909
RexxThreadInterface::RexxObjectPtr
int32_t uint32_t uintptr_t intptr_t RexxObjectPtr
Definition: oorexxapi.h:519
ValueDescriptor::value_size_t
size_t value_size_t
Definition: oorexxapi.h:299
ValueDescriptor::value_uint16_t
uint16_t value_uint16_t
Definition: oorexxapi.h:292
ValueDescriptor::value_OPTIONAL_intptr_t
intptr_t value_OPTIONAL_intptr_t
Definition: oorexxapi.h:328
RexxThreadInterface::RexxMutableBufferObject
RexxMutableBufferObject
Definition: oorexxapi.h:605
PEXIT
char * PEXIT
Definition: rexx.h:215
RaiseException1
void RexxEntry RaiseException1(RexxThreadContext *c, size_t n, RexxObjectPtr o1)
Definition: ThreadContextStubs.cpp:1742
RexxPackageObject
struct _RexxPackageObject * RexxPackageObject
Definition: rexx.h:135
REXX_VALUE_CSTRING
#define REXX_VALUE_CSTRING
Definition: oorexxapi.h:68
RaiseException0
void RexxEntry RaiseException0(RexxThreadContext *c, size_t n)
Definition: ThreadContextStubs.cpp:1730
ObjectToInt32
logical_t RexxEntry ObjectToInt32(RexxThreadContext *c, RexxObjectPtr o, int32_t *n)
Definition: ThreadContextStubs.cpp:800
RexxMethodContext_
Definition: oorexxapi.h:1404
RexxPointerObject
struct _RexxPointerObject * RexxPointerObject
Definition: rexx.h:132
GetContextVariable
RexxObjectPtr RexxEntry GetContextVariable(RexxCallContext *c, CSTRING n)
Definition: CallContextStubs.cpp:120
ObjectToUnsignedInt32
logical_t RexxEntry ObjectToUnsignedInt32(RexxThreadContext *c, RexxObjectPtr o, uint32_t *n)
Definition: ThreadContextStubs.cpp:823
RexxThreadInterface::RexxPointerObject
RexxPointerObject
Definition: oorexxapi.h:566
NewPointer
RexxPointerObject RexxEntry NewPointer(RexxThreadContext *c, POINTER p)
Definition: ThreadContextStubs.cpp:1504
ValueDescriptor::value_intptr_t
intptr_t value_intptr_t
Definition: oorexxapi.h:296
RexxThreadInterface::values
RexxArrayObject values
Definition: oorexxapi.h:574
ObjectToStringValue
CSTRING RexxEntry ObjectToStringValue(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1005
NewDirectory
RexxDirectoryObject RexxEntry NewDirectory(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1229
GetScope
RexxObjectPtr RexxEntry GetScope(RexxMethodContext *c)
Definition: MethodContextStubs.cpp:143
CSELF
void * CSELF
Definition: oorexxapi.h:4245
ValueDescriptor::value_OPTIONAL_stringsize_t
stringsize_t value_OPTIONAL_stringsize_t
Definition: oorexxapi.h:312
BufferLength
size_t RexxEntry BufferLength(RexxThreadContext *c, RexxBufferObject b)
Definition: ThreadContextStubs.cpp:1452
_RexxRoutineEntry::reserved2
int reserved2
Definition: oorexxapi.h:182
RexxContextExit
struct _RexxContextExit RexxContextExit
RexxThreadContext_::functions
RexxThreadInterface * functions
Definition: oorexxapi.h:713
ARGLIST
RexxArrayObject ARGLIST
Definition: oorexxapi.h:4247
RexxThreadInterface::int32_t
int64_t uint64_t int32_t
Definition: oorexxapi.h:513
ObjectToStringSize
logical_t RexxEntry ObjectToStringSize(RexxThreadContext *c, RexxObjectPtr o, stringsize_t *n)
Definition: ThreadContextStubs.cpp:779
ValueDescriptor::value_OPTIONAL_POINTERSTRING
POINTER value_OPTIONAL_POINTERSTRING
Definition: oorexxapi.h:334
RexxThreadInterface::uint32_t
uint32_t
Definition: oorexxapi.h:514
Halt
void RexxEntry Halt(RexxInstance *c)
Definition: InterpreterInstanceStubs.cpp:67
BufferStringLength
size_t RexxEntry BufferStringLength(RexxThreadContext *c, RexxBufferStringObject s)
Definition: ThreadContextStubs.cpp:1142
RexxOption::option
ValueDescriptor option
Definition: oorexxapi.h:419
RexxThreadInterface::int64_t
wholenumber_t stringsize_t int64_t
Definition: oorexxapi.h:509
IsMethod
logical_t RexxEntry IsMethod(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:553
ValueDescriptor::value___uintptr_t
uintptr_t value___uintptr_t
Definition: oorexxapi.h:298
SendMessage2
RexxObjectPtr RexxEntry SendMessage2(RexxThreadContext *c, RexxObjectPtr o, CSTRING m, RexxObjectPtr a1, RexxObjectPtr a2)
Definition: ThreadContextStubs.cpp:201
_RexxPackageEntry::unloader
RexxPackageUnloader unloader
Definition: oorexxapi.h:249
ValueDescriptor::value_RexxStemObject
RexxStemObject value_RexxStemObject
Definition: oorexxapi.h:302
RexxThreadInterface::double
double
Definition: oorexxapi.h:521
NewStringFromAsciiz
RexxStringObject RexxEntry NewStringFromAsciiz(RexxThreadContext *c, CSTRING s)
Definition: ThreadContextStubs.cpp:1075
RexxThreadInterface::logical_t
logical_t
Definition: oorexxapi.h:461
ArraySize
size_t RexxEntry ArraySize(RexxThreadContext *c, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:1320
ArrayPut
void RexxEntry ArrayPut(RexxThreadContext *c, RexxArrayObject a, RexxObjectPtr o, size_t i)
Definition: ThreadContextStubs.cpp:1273
RexxThreadInterface::wholenumber_t
wholenumber_t
Definition: oorexxapi.h:500
RexxThreadInterface::RexxStemObject
RexxStemObject
Definition: oorexxapi.h:577
RexxThreadInterface::RexxObjectPtr
int64_t RexxObjectPtr
Definition: oorexxapi.h:512
ValueDescriptor::value_RexxStringObject
RexxStringObject value_RexxStringObject
Definition: oorexxapi.h:284
ValueDescriptor::value_int32_t
int32_t value_int32_t
Definition: oorexxapi.h:288
RexxThreadInterface::RexxNil
RexxObjectPtr RexxNil
Definition: oorexxapi.h:597
ValueDescriptor::value_OPTIONAL_RexxMutableBufferObject
RexxMutableBufferObject value_OPTIONAL_RexxMutableBufferObject
Definition: oorexxapi.h:335
FindClass
RexxClassObject RexxEntry FindClass(RexxThreadContext *c, CSTRING n)
Definition: ThreadContextStubs.cpp:369
RexxExitContext_
Definition: oorexxapi.h:2906
OSELF
RexxObjectPtr OSELF
Definition: oorexxapi.h:4244
RexxMethodContext
const struct RexxMethodContext_ * RexxMethodContext
Definition: oorexxapi.h:146
IsInstanceOf
logical_t RexxEntry IsInstanceOf(RexxThreadContext *c, RexxObjectPtr o, RexxClassObject cl)
Definition: ThreadContextStubs.cpp:243
ReleaseLocalReference
void RexxEntry ReleaseLocalReference(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:139
ValueDescriptor::value___uint64_t
uint64_t value___uint64_t
Definition: oorexxapi.h:295
SetGuardOn
void RexxEntry SetGuardOn(RexxMethodContext *c)
Definition: MethodContextStubs.cpp:209
RexxCondition::program
RexxStringObject program
Definition: oorexxapi.h:430
MutableBufferData
POINTER RexxEntry MutableBufferData(RexxThreadContext *c, RexxMutableBufferObject b)
Definition: ThreadContextStubs.cpp:1857
SupplierNext
void RexxEntry SupplierNext(RexxThreadContext *c, RexxSupplierObject o)
Definition: ThreadContextStubs.cpp:1569
DisplayCondition
wholenumber_t RexxEntry DisplayCondition(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1806
RexxMutableBufferObject
struct _RexxMutableBufferObject * RexxMutableBufferObject
Definition: rexx.h:140
StringUpper
RexxStringObject RexxEntry StringUpper(RexxThreadContext *c, RexxStringObject s)
Definition: ThreadContextStubs.cpp:1088
StringGet
size_t RexxEntry StringGet(RexxThreadContext *c, RexxStringObject s, size_t o, POINTER r, size_t l)
Definition: ThreadContextStubs.cpp:1020
RexxPackageUnloader
void(REXXENTRY * RexxPackageUnloader)(RexxThreadContext *)
Definition: oorexxapi.h:239
MutableBufferCapacity
size_t RexxEntry MutableBufferCapacity(RexxThreadContext *c, RexxMutableBufferObject b)
Definition: ThreadContextStubs.cpp:1896
RexxOption
Definition: oorexxapi.h:416
_RexxPackageEntry::apiVersion
int apiVersion
Definition: oorexxapi.h:244
DropStemElement
void RexxEntry DropStemElement(RexxThreadContext *c, RexxStemObject s, CSTRING n)
Definition: ThreadContextStubs.cpp:1642
RexxContextCommandHandler
RexxObjectPtr REXXENTRY RexxContextCommandHandler(RexxExitContext *, RexxStringObject, RexxStringObject)
Definition: oorexxapi.h:395
ObjectToUnsignedInt64
logical_t RexxEntry ObjectToUnsignedInt64(RexxThreadContext *c, RexxObjectPtr o, uint64_t *n)
Definition: ThreadContextStubs.cpp:884
GetPackageMethods
RexxDirectoryObject RexxEntry GetPackageMethods(RexxThreadContext *c, RexxPackageObject m)
Definition: ThreadContextStubs.cpp:458
REXXENTRY
#define REXXENTRY
Definition: rexxapitypes.h:61
GetCallerContext
RexxObjectPtr RexxEntry GetCallerContext(RexxCallContext *c)
Definition: CallContextStubs.cpp:290
RexxThreadInterface::count
ValueDescriptor ValueDescriptor size_t count
Definition: oorexxapi.h:504
ObjectToValue
logical_t RexxEntry ObjectToValue(RexxThreadContext *c, RexxObjectPtr o, ValueDescriptor *d)
Definition: ThreadContextStubs.cpp:698
RexxRegisteredEnvironment::name
const char * name
Definition: oorexxapi.h:407
RexxRoutineEntry
struct _RexxRoutineEntry RexxRoutineEntry
ValueDescriptor::value_CSELF
POINTER value_CSELF
Definition: oorexxapi.h:272
ValueDescriptor::value_SUPER
RexxClassObject value_SUPER
Definition: oorexxapi.h:274
RexxThreadInterface::RexxObjectPtr
int32_t uint32_t RexxObjectPtr
Definition: oorexxapi.h:517
IsRoutine
logical_t RexxEntry IsRoutine(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:538
DropStemArrayElement
void RexxEntry DropStemArrayElement(RexxThreadContext *c, RexxStemObject s, size_t i)
Definition: ThreadContextStubs.cpp:1679
RegisterLibrary
logical_t RexxEntry RegisterLibrary(RexxThreadContext *c, CSTRING n, RexxPackageEntry *e)
Definition: ThreadContextStubs.cpp:351
RexxThreadInterface::RexxFalse
RexxObjectPtr RexxFalse
Definition: oorexxapi.h:599
REXX_VALUE_POINTER
#define REXX_VALUE_POINTER
Definition: oorexxapi.h:69
RexxContextEnvironment::name
const char * name
Definition: oorexxapi.h:401
ObjectToLogical
logical_t RexxEntry ObjectToLogical(RexxThreadContext *c, RexxObjectPtr o, logical_t *n)
Definition: ThreadContextStubs.cpp:926
RexxMethodContext_::arguments
ValueDescriptor * arguments
Definition: oorexxapi.h:1408
MethodContextInterface::size_t
size_t
Definition: oorexxapi.h:624
REXX_VALUE_RexxMutableBufferObject
#define REXX_VALUE_RexxMutableBufferObject
Definition: oorexxapi.h:93
AttachThread
logical_t RexxEntry AttachThread(RexxInstance *c, RexxThreadContext **tc)
Definition: InterpreterInstanceStubs.cpp:61
BEGIN_EXTERN_C
#define BEGIN_EXTERN_C()
Definition: rexx.h:60
ArrayOfFour
RexxArrayObject RexxEntry ArrayOfFour(RexxThreadContext *c, RexxObjectPtr o1, RexxObjectPtr o2, RexxObjectPtr o3, RexxObjectPtr o4)
Definition: ThreadContextStubs.cpp:1412
ObjectToUintptr
logical_t RexxEntry ObjectToUintptr(RexxThreadContext *c, RexxObjectPtr o, uintptr_t *n)
Definition: ThreadContextStubs.cpp:898
RexxThreadInterface::RexxClassObject
RexxClassObject
Definition: oorexxapi.h:474
NewSupplier
RexxSupplierObject RexxEntry NewSupplier(RexxThreadContext *c, RexxArrayObject values, RexxArrayObject names)
Definition: ThreadContextStubs.cpp:1581
RexxCondition::errortext
RexxStringObject errortext
Definition: oorexxapi.h:429
RexxContextExitHandler
int REXXENTRY RexxContextExitHandler(RexxExitContext *, int, int, PEXIT)
Definition: oorexxapi.h:165
ValueDescriptor::value_OPTIONAL_int64_t
int64_t value_OPTIONAL_int64_t
Definition: oorexxapi.h:323
RexxThreadInterface::RexxTrue
RexxObjectPtr RexxTrue
Definition: oorexxapi.h:598
DoubleToObjectWithPrecision
RexxObjectPtr RexxEntry DoubleToObjectWithPrecision(RexxThreadContext *c, double n, size_t precision)
Definition: ThreadContextStubs.cpp:966
IsPointer
logical_t RexxEntry IsPointer(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1517
ObjectToWholeNumber
logical_t RexxEntry ObjectToWholeNumber(RexxThreadContext *c, RexxObjectPtr o, wholenumber_t *n)
Definition: ThreadContextStubs.cpp:728
wholenumber_t
ssize_t wholenumber_t
Definition: rexx.h:229
SupplierAvailable
logical_t RexxEntry SupplierAvailable(RexxThreadContext *c, RexxSupplierObject o)
Definition: ThreadContextStubs.cpp:1556
RexxRoutineObject
struct _RexxRoutineObject * RexxRoutineObject
Definition: rexx.h:134
_RexxRoutineEntry::name
const char * name
Definition: oorexxapi.h:180
_RexxPackageEntry::size
int size
Definition: oorexxapi.h:243
ValueDescriptor::value_OPTIONAL_uint64_t
uint64_t value_OPTIONAL_uint64_t
Definition: oorexxapi.h:327
ValueDescriptor::value_ARGLIST
RexxArrayObject value_ARGLIST
Definition: oorexxapi.h:269
LogicalToObject
RexxObjectPtr RexxEntry LogicalToObject(RexxThreadContext *c, logical_t n)
Definition: ThreadContextStubs.cpp:940
ValueDescriptor::value_int8_t
int8_t value_int8_t
Definition: oorexxapi.h:286
Terminate
void RexxEntry Terminate(RexxInstance *c)
Definition: InterpreterInstanceStubs.cpp:52
ValueDescriptor::value_SCOPE
RexxObjectPtr value_SCOPE
Definition: oorexxapi.h:271
RexxThreadInterface::precision
size_t precision
Definition: oorexxapi.h:522
ValueDescriptor::value_OPTIONAL_size_t
size_t value_OPTIONAL_size_t
Definition: oorexxapi.h:331
UintptrToObject
RexxObjectPtr RexxEntry UintptrToObject(RexxThreadContext *c, uintptr_t n)
Definition: ThreadContextStubs.cpp:641
MethodContextInterface::RexxClassObject
RexxClassObject
Definition: oorexxapi.h:633
stringsize_t
size_t stringsize_t
Definition: rexx.h:228
ExitContextInterface
Definition: oorexxapi.h:665
RexxThreadInterface::size_t
size_t
Definition: oorexxapi.h:492
RexxCreateInterpreter
RexxReturnCode REXXENTRY RexxCreateInterpreter(RexxInstance **, RexxThreadContext **, RexxOption *)
Definition: InterpreterAPI.cpp:380
SetThreadTrace
void RexxEntry SetThreadTrace(RexxThreadContext *c, logical_t setting)
Definition: ThreadContextStubs.cpp:98
ObjectToInt64
logical_t RexxEntry ObjectToInt64(RexxThreadContext *c, RexxObjectPtr o, int64_t *n)
Definition: ThreadContextStubs.cpp:870
_RexxPackageEntry
Definition: oorexxapi.h:241
RexxContextEnvironment
Definition: oorexxapi.h:398
GetPackageRoutines
RexxDirectoryObject RexxEntry GetPackageRoutines(RexxThreadContext *c, RexxPackageObject m)
Definition: ThreadContextStubs.cpp:405
ValueDescriptor::value_OPTIONAL_uint32_t
uint32_t value_OPTIONAL_uint32_t
Definition: oorexxapi.h:326
ArrayAppend
size_t RexxEntry ArrayAppend(RexxThreadContext *c, RexxArrayObject a, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1290
CheckCondition
logical_t RexxEntry CheckCondition(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1793
RexxThreadInterface::interfaceVersion
wholenumber_t interfaceVersion
Definition: oorexxapi.h:457
REXX_VALUE_RexxStemObject
#define REXX_VALUE_RexxStemObject
Definition: oorexxapi.h:88
NAME
CSTRING NAME
Definition: oorexxapi.h:4250
POINTER
void * POINTER
Definition: rexx.h:79
_RexxRoutineEntry::reserved3
int reserved3
Definition: oorexxapi.h:183
BufferData
POINTER RexxEntry BufferData(RexxThreadContext *c, RexxBufferObject b)
Definition: ThreadContextStubs.cpp:1439
DirectoryPut
void RexxEntry DirectoryPut(RexxThreadContext *c, RexxDirectoryObject t, RexxObjectPtr o, CSTRING i)
Definition: ThreadContextStubs.cpp:1185
PointerValue
POINTER RexxEntry PointerValue(RexxThreadContext *c, RexxPointerObject o)
Definition: ThreadContextStubs.cpp:1491
ValueDescriptor::value_OPTIONAL_wholenumber_t
wholenumber_t value_OPTIONAL_wholenumber_t
Definition: oorexxapi.h:311
RexxCondition::description
RexxStringObject description
Definition: oorexxapi.h:431
ValueDescriptor::flags
uint16_t flags
Definition: oorexxapi.h:339
_RexxRoutineEntry::entryPoint
void * entryPoint
Definition: oorexxapi.h:181
RexxCallContext
const struct RexxCallContext_ * RexxCallContext
Definition: oorexxapi.h:153
RexxInstanceInterface
Definition: oorexxapi.h:437
_RexxPackageEntry::loader
RexxPackageLoader loader
Definition: oorexxapi.h:248
_RexxRoutineEntry::reserved1
int reserved1
Definition: oorexxapi.h:179