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)  

RexxCore.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.oorexx.org/license.html */
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 /* REXX Kernel RexxCore.h */
40 /* */
41 /* Global Declarations */
42 /******************************************************************************/
43 
44 /******************************************************************************/
45 /* Globally required include files */
46 /******************************************************************************/
47 #ifndef RexxCore_INCLUDED
48 #define RexxCore_INCLUDED
49 
50 #include "oorexxapi.h" // this is the core to everything
51 
52 /* ANSI C definitions */
53 #include <stdio.h>
54 #include <stdarg.h>
55 #include <string.h>
56 #include <ctype.h>
57 #include <limits.h>
58 
59 /* REXX Library definitions */
60 #define OREF_NULL NULL /* definition of a NULL REXX object */
61 
63 
64 /******************************************************************************/
65 /* Literal definitions */
66 /******************************************************************************/
67 #include "RexxConstants.hpp"
68 
69 /******************************************************************************/
70 /* Kernel Internal Limits */
71 /******************************************************************************/
72 
73 const int MAX_ERROR_NUMBER = 99999; /* maximum error code number */
74 const int MAX_SYMBOL_LENGTH = 250; /* length of a symbol name */
75 
76 /******************************************************************************/
77 /* Defines for argument error reporting */
78 /******************************************************************************/
79 
80 const int ARG_ONE = 1;
81 const int ARG_TWO = 2;
82 const int ARG_THREE = 3;
83 const int ARG_FOUR = 4;
84 const int ARG_FIVE = 5;
85 const int ARG_SIX = 6;
86 const int ARG_SEVEN = 7;
87 const int ARG_EIGHT = 8;
88 const int ARG_NINE = 9;
89 const int ARG_TEN = 10;
90 
91 
92 /* Object Reference Assignment */
93 #ifndef CHECKOREFS
94 #define OrefSet(o,r,v) ((o)->isOldSpace() ? memoryObject.setOref((void *)&(r),(RexxObject *)v) : (RexxObject *)(r=v))
95 #else
96 #define OrefSet(o,r,v) memoryObject.checkSetOref((RexxObject *)o, (RexxObject **)&(r), (RexxObject *)v, __FILE__, __LINE__)
97 #endif
98 
99 
100 // forward declaration of commonly used classes
101 class RexxExpressionStack;
102 class RexxActivation;
103 class RexxObject;
104 class RexxClass;
105 class RexxDirectory;
106 class RexxIntegerClass;
107 class RexxArray;
108 class RexxMemory;
109 class RexxString;
110 
111 
112 /******************************************************************************/
113 /* Change EXTERN definition if not already created by GDATA */
114 /******************************************************************************/
115 
116 #ifndef INITGLOBALPTR // if not the global, this is a NOP.
117 #define INITGLOBALPTR
118 #endif
119 #ifndef EXTERN
120 #define EXTERN extern /* turn into external definition */
121 #endif
122 
123 #ifndef EXTERNMEM
124 #define EXTERNMEM extern /* turn into external definition */
125 #endif
126 
127 /******************************************************************************/
128 /* Primitive Method Type Definition Macros */
129 /******************************************************************************/
130  /* following two are used by OKINIT */
131  /* to build the VFT Array. */
132 #define CLASS_EXTERNAL(b,c)
133 #define CLASS_INTERNAL(b,c)
134 
135 #define koper(name) RexxObject *name(RexxObject *);
136 
137 
138 /******************************************************************************/
139 /* Global Objects - General */
140 /******************************************************************************/
141 
142 
143 // this one is special, and is truly global.
144 EXTERNMEM RexxMemory memoryObject; /* memory object */
145 
146 // TODO: make these into statics inside classes.
147 
148 #define TheArrayClass RexxArray::classInstance
149 #define TheClassClass RexxClass::classInstance
150 #define TheDirectoryClass RexxDirectory::classInstance
151 #define TheIntegerClass RexxInteger::classInstance
152 #define TheListClass RexxList::classInstance
153 #define TheMessageClass RexxMessage::classInstance
154 #define TheMethodClass RexxMethod::classInstance
155 #define TheRoutineClass RoutineClass::classInstance
156 #define ThePackageClass PackageClass::classInstance
157 #define TheRexxContextClass RexxContext::classInstance
158 #define TheNumberStringClass RexxNumberString::classInstance
159 #define TheObjectClass RexxObject::classInstance
160 #define TheQueueClass RexxQueue::classInstance
161 #define TheStemClass RexxStem::classInstance
162 #define TheStringClass RexxString::classInstance
163 #define TheMutableBufferClass RexxMutableBuffer::classInstance
164 #define TheSupplierClass RexxSupplier::classInstance
165 #define TheTableClass RexxTable::classInstance
166 #define TheIdentityTableClass RexxIdentityTable::classInstance
167 #define TheRelationClass RexxRelation::classInstance
168 #define ThePointerClass RexxPointer::classInstance
169 #define TheBufferClass RexxBuffer::classInstance
170 #define TheWeakReferenceClass WeakReference::classInstance
171 #define TheStackFrameClass StackFrameClass::classInstance
172 
173 #define TheEnvironment RexxMemory::environment
174 #define TheStaticRequires RexxMemory::staticRequires
175 #define TheFunctionsDirectory RexxMemory::functionsDir
176 #define TheCommonRetrievers RexxMemory::commonRetrievers
177 #define TheKernel RexxMemory::kernel
178 #define TheSystem RexxMemory::system
179 
180 #define TheNilObject RexxNilObject::nilObject
181 
182 #define TheNullArray RexxArray::nullArray
183 
184 #define TheFalseObject RexxInteger::falseObject
185 #define TheTrueObject RexxInteger::trueObject
186 #define TheNullPointer RexxPointer::nullPointer
187 
188 #define IntegerZero RexxInteger::integerZero
189 #define IntegerOne RexxInteger::integerOne
190 #define IntegerTwo RexxInteger::integerTwo
191 #define IntegerThree RexxInteger::integerThree
192 #define IntegerFour RexxInteger::integerFour
193 #define IntegerFive RexxInteger::integerFive
194 #define IntegerSix RexxInteger::integerSix
195 #define IntegerSeven RexxInteger::integerSeven
196 #define IntegerEight RexxInteger::integerEight
197 #define IntegerNine RexxInteger::integerNine
198 #define IntegerMinusOne RexxInteger::integerMinusOne
199 
200 #include "ClassTypeCodes.h"
201 
202 
203 
204 /******************************************************************************/
205 /* Utility Macros */
206 /******************************************************************************/
207 
208 #define RXROUNDUP(n,to) ((((n)+(to-1))/(to))*to)
209 #define rounddown(n,to) (((n)/(to))*to)
210 
211 #define isOfClass(t,r) (r)->isObjectType(The##t##Behaviour)
212 #define isOfClassType(t,r) (r)->isObjectType(T_##t)
213 
214 /******************************************************************************/
215 /* Utility Functions */
216 /******************************************************************************/
217 
218  /* find an environment symbol */
219 #define env_find(s) (TheEnvironment->entry(s))
220 
221 /******************************************************************************/
222 /* Thread constants */
223 /******************************************************************************/
224 
225 #define NO_THREAD -1
226 
227 /******************************************************************************/
228 /* Global Objects - Names */
229 /******************************************************************************/
230 #undef GLOBAL_NAME
231 #define GLOBAL_NAME(name, value) EXTERN RexxString * OREF_##name INITGLOBALPTR;
232 #include "GlobalNames.h"
233 
234 #include "ObjectClass.hpp" /* get real definition of Object */
235 
236  #include "TableClass.hpp"
237  #include "StackClass.hpp"
238  #include "RexxMemory.hpp" /* memory next, to get OrefSet */
239  #include "RexxBehaviour.hpp" /* now behaviours and */
240  #include "ClassClass.hpp" /* classes, which everything needs */
241  #include "RexxEnvelope.hpp" /* envelope is needed for flattens */
242  #include "RexxActivity.hpp" /* activity is needed for errors */
243  #include "NumberStringClass.hpp" /* added to make 'number_digits()' */
244  /* in 'ArrayClass.c' visible */
245 /******************************************************************************/
246 /* Method arguments special codes */
247 /******************************************************************************/
248 
249 const size_t A_COUNT = 127; /* pass arguments as pointer/count pair */
250 
251 /******************************************************************************/
252 /* Return codes */
253 /******************************************************************************/
254 
255 const int RC_OK = 0;
256 const int RC_LOGIC_ERROR = 2;
257 
258 const int POSITIVE = 1; /* integer must be positive */
259 const int NONNEGATIVE = 2; /* integer must be non-negative */
260 const int WHOLE = 3; /* integer must be whole */
261 
262 
263 // some very common class tests
264 inline bool isString(RexxObject *o) { return isOfClass(String, o); }
265 inline bool isInteger(RexxObject *o) { return isOfClass(Integer, o); }
266 inline bool isArray(RexxObject *o) { return isOfClass(Array, o); }
267 inline bool isStem(RexxObject *o) { return isOfClass(Stem, o); }
268 inline bool isActivation(RexxObject *o) { return isOfClass(Activation, o); }
269 inline bool isMethod(RexxObject *o) { return isOfClass(Method, o); }
270 
271 #include "ActivityManager.hpp"
272 
273 /* The next macro is specifically for REQUESTing a STRING, since there are */
274 /* four primitive classes that are equivalents for strings. It will trap on */
275 /* OREF_NULL. */
277 {
278  return (isOfClass(String, object) ? (RexxString *)object : (object)->requestString());
279 }
280 
281 
282 // The next routine checks for required arguments and raises a missing argument
283 // error for the given position.
284 inline void requiredArgument(RexxObject *object, size_t position)
285 {
286  if (object == OREF_NULL) /* missing argument? */
287  {
288  missingArgument(position); /* raise an error */
289  }
290 }
291 
292 
293 /* The next routine is specifically for REQUESTing a STRING needed as a method*/
294 /* argument. This raises an error if the object cannot be converted to a */
295 /* string value. */
296 inline RexxString * stringArgument(RexxObject *object, size_t position)
297 {
298  if (object == OREF_NULL) /* missing argument? */
299  {
300  missingArgument(position); /* raise an error */
301  }
302  /* force to a string value */
303  return object->requiredString(position);
304 }
305 
306 
307 /* The next routine is specifically for REQUESTing a STRING needed as a method*/
308 /* argument. This raises an error if the object cannot be converted to a */
309 /* string value. */
310 inline RexxString * stringArgument(RexxObject *object, const char *name)
311 {
312  if (object == OREF_NULL) /* missing argument? */
313  {
315  }
316  /* force to a string value */
317  return object->requiredString(name);
318 }
319 
320 
322 {
323  return (o == OREF_NULL ? d : stringArgument(o, p));
324 }
325 
326 
328 {
329  return (o == OREF_NULL ? d : stringArgument(o, p));
330 }
331 
332 
333 // resides in the string class util
334 size_t lengthArgument(RexxObject *o, size_t p);
335 
336 inline size_t optionalLengthArgument(RexxObject *o, size_t d, size_t p)
337 {
338  return (o == OREF_NULL ? d : lengthArgument(o, p));
339 }
340 
341 // resides in the string class util
342 size_t positionArgument(RexxObject *o, size_t p);
343 
344 inline size_t optionalPositionArgument(RexxObject *o, size_t d, size_t p)
345 {
346  return (o == OREF_NULL ? d : positionArgument(o, p));
347 }
348 
349 char padArgument(RexxObject *o, size_t p);
350 
351 inline char optionalPadArgument(RexxObject *o, char d, size_t p)
352 {
353  return (o == OREF_NULL ? d : padArgument(o, p));
354 }
355 
356 char optionArgument(RexxObject *o, size_t p);
357 
358 inline char optionalOptionArgument(RexxObject *o, char d, size_t p)
359 {
360  return (o == OREF_NULL ? d : optionArgument(o, p));
361 }
362 
363 inline size_t optionalNonNegative(RexxObject *o, size_t d, size_t p)
364 {
365  return (o == OREF_NULL ? d : o->requiredNonNegative(p));
366 }
367 
368 inline size_t optionalPositive(RexxObject *o, size_t d, size_t p)
369 {
370  return (o == OREF_NULL ? d : o->requiredPositive(p));
371 }
372 
373 /* The next routine is specifically for REQUESTing an ARRAY needed as a method*/
374 /* argument. This raises an error if the object cannot be converted to a */
375 /* single dimensional array item */
376 inline RexxArray *arrayArgument(RexxObject *object, size_t position)
377 {
378  if (object == OREF_NULL) /* missing argument? */
379  {
380  missingArgument(position); /* raise an error */
381  }
382  /* force to array form */
383  RexxArray *array = object->requestArray();
384  /* not an array? */
385  if (array == TheNilObject || array->getDimension() != 1)
386  {
387  /* raise an error */
389  }
390  return array;
391 }
392 
393 
394 inline RexxArray * arrayArgument(RexxObject *object, const char *name)
395 {
396  if (object == OREF_NULL) /* missing argument? */
397  {
399  }
400 
401  /* force to array form */
402  RexxArray *array = object->requestArray();
403  /* not an array? */
404  if (array == TheNilObject || array->getDimension() != 1)
405  {
406  /* raise an error */
408  }
409  return array;
410 }
411 
412 
413 /* The next routine is specifically for REQUESTing a STRING needed as a method*/
414 /* argument. This raises an error if the object cannot be converted to a */
415 /* string value. */
416 inline void classArgument(RexxObject *object, RexxClass *clazz, const char *name)
417 {
418  if (object == OREF_NULL) /* missing argument? */
419  {
421  }
422 
423  if (!object->isInstanceOf(clazz))
424  {
426  }
427 }
428 
429 
430 /* The next macro is specifically for REQUESTing an ARRAY, since there are */
431 /* six primitive classes that can produce array equivalents. It will trap on */
432 /* OREF_NULL. */
433 inline RexxArray * REQUEST_ARRAY(RexxObject *obj) { return ((obj)->requestArray()); }
434 
435 /* The next macro is specifically for REQUESTing an INTEGER, */
437 
438 /******************************************************************************/
439 /* Typed method invocation macros */
440 /******************************************************************************/
441 
442 inline RexxObject * callOperatorMethod(RexxObject *object, size_t methodOffset, RexxObject *argument) {
443  /* get the entry point */
444  PCPPM cppEntry = object->behaviour->getOperatorMethod(methodOffset);
445  /* go issue the method */
446  return (object->*((PCPPM1)cppEntry))(argument);
447 }
448 
449 #endif
ARG_SIX
const int ARG_SIX
Definition: RexxCore.h:85
RexxArray::getDimension
size_t getDimension()
Definition: ArrayClass.cpp:690
RexxExpressionStack
Definition: ExpressionStack.hpp:53
RexxArray
Definition: ArrayClass.hpp:100
Error_Invalid_argument_noarray
#define Error_Invalid_argument_noarray
Definition: RexxErrorCodes.h:417
RexxObject::isInstanceOf
bool isInstanceOf(RexxClass *)
Definition: ObjectClass.cpp:226
WHOLE
const int WHOLE
Definition: RexxCore.h:260
RexxMemory
Definition: RexxMemory.hpp:169
RexxInternalObject::behaviour
RexxBehaviour * behaviour
Definition: ObjectClass.hpp:306
optionalNonNegative
size_t optionalNonNegative(RexxObject *o, size_t d, size_t p)
Definition: RexxCore.h:363
isArray
bool isArray(RexxObject *o)
Definition: RexxCore.h:266
optionalLengthArgument
size_t optionalLengthArgument(RexxObject *o, size_t d, size_t p)
Definition: RexxCore.h:336
RexxClass::getId
RexxString * getId()
Definition: ClassClass.cpp:250
ActivityManager.hpp
requiredArgument
void requiredArgument(RexxObject *object, size_t position)
Definition: RexxCore.h:284
isMethod
bool isMethod(RexxObject *o)
Definition: RexxCore.h:269
memoryObject
RexxMemory memoryObject
Definition: RexxMemory.cpp:84
ARG_TWO
const int ARG_TWO
Definition: RexxCore.h:81
TableClass.hpp
reportException
void reportException(wholenumber_t error)
Definition: ActivityManager.hpp:136
RexxIntegerClass
Definition: IntegerClass.hpp:176
NONNEGATIVE
const int NONNEGATIVE
Definition: RexxCore.h:259
RexxEnvelope.hpp
padArgument
char padArgument(RexxObject *o, size_t p)
Definition: StringClassUtil.cpp:105
RexxMemory.hpp
REQUEST_ARRAY
RexxArray * REQUEST_ARRAY(RexxObject *obj)
Definition: RexxCore.h:433
ARG_NINE
const int ARG_NINE
Definition: RexxCore.h:88
isOfClass
#define isOfClass(t, r)
Definition: RexxCore.h:211
PCPPM1
RexxObject *(RexxObject::* PCPPM1)(RexxObject *)
Definition: ObjectClass.hpp:187
positionArgument
size_t positionArgument(RexxObject *o, size_t p)
Definition: StringClassUtil.cpp:82
Numerics::ARGUMENT_DIGITS
static const size_t ARGUMENT_DIGITS
Definition: Numerics.hpp:68
POSITIVE
const int POSITIVE
Definition: RexxCore.h:258
optionalPositionArgument
size_t optionalPositionArgument(RexxObject *o, size_t d, size_t p)
Definition: RexxCore.h:344
MAX_ERROR_NUMBER
const int MAX_ERROR_NUMBER
Definition: RexxCore.h:73
RC_LOGIC_ERROR
const int RC_LOGIC_ERROR
Definition: RexxCore.h:256
ARG_ONE
const int ARG_ONE
Definition: RexxCore.h:80
GlobalNames.h
optionalStringArgument
RexxString * optionalStringArgument(RexxObject *o, RexxString *d, size_t p)
Definition: RexxCore.h:321
OREF_NULL
#define OREF_NULL
Definition: RexxCore.h:60
Error_Invalid_argument_noclass
#define Error_Invalid_argument_noclass
Definition: RexxErrorCodes.h:418
ARG_THREE
const int ARG_THREE
Definition: RexxCore.h:82
RexxDirectory
Definition: DirectoryClass.hpp:49
arrayArgument
RexxArray * arrayArgument(RexxObject *object, size_t position)
Definition: RexxCore.h:376
callOperatorMethod
RexxObject * callOperatorMethod(RexxObject *object, size_t methodOffset, RexxObject *argument)
Definition: RexxCore.h:442
RexxClass
Definition: ClassClass.hpp:49
RexxObject::requiredNonNegative
stringsize_t requiredNonNegative(size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
Definition: ObjectClass.cpp:1442
optionArgument
char optionArgument(RexxObject *o, size_t p)
Definition: StringClassUtil.cpp:126
NumberStringClass.hpp
classArgument
void classArgument(RexxObject *object, RexxClass *clazz, const char *name)
Definition: RexxCore.h:416
ARG_EIGHT
const int ARG_EIGHT
Definition: RexxCore.h:87
isInteger
bool isInteger(RexxObject *o)
Definition: RexxCore.h:265
REQUEST_INTEGER
RexxInteger * REQUEST_INTEGER(RexxObject *obj)
Definition: RexxCore.h:436
optionalPadArgument
char optionalPadArgument(RexxObject *o, char d, size_t p)
Definition: RexxCore.h:351
PCPPM
RexxObject *(RexxObject::* PCPPM)()
Definition: ObjectClass.hpp:198
optionalPositive
size_t optionalPositive(RexxObject *o, size_t d, size_t p)
Definition: RexxCore.h:368
ObjectClass.hpp
StackClass.hpp
REQUEST_STRING
RexxString * REQUEST_STRING(RexxObject *object)
Definition: RexxCore.h:276
RexxPlatformDefinitions.h
RC_OK
const int RC_OK
Definition: RexxCore.h:255
RexxActivation
Definition: RexxActivation.hpp:156
missingArgument
void missingArgument(size_t argumentPosition)
Definition: ActivityManager.hpp:246
ARG_TEN
const int ARG_TEN
Definition: RexxCore.h:89
optionalOptionArgument
char optionalOptionArgument(RexxObject *o, char d, size_t p)
Definition: RexxCore.h:358
ARG_FOUR
const int ARG_FOUR
Definition: RexxCore.h:83
isStem
bool isStem(RexxObject *o)
Definition: RexxCore.h:267
lengthArgument
size_t lengthArgument(RexxObject *o, size_t p)
Definition: StringClassUtil.cpp:58
EXTERNMEM
#define EXTERNMEM
Definition: RexxCore.h:124
oorexxapi.h
TheNilObject
#define TheNilObject
Definition: RexxCore.h:180
isString
bool isString(RexxObject *o)
Definition: RexxCore.h:264
RexxActivity.hpp
RexxObject::requestInteger
RexxInteger * requestInteger(size_t)
Definition: ObjectClass.cpp:1295
ARG_SEVEN
const int ARG_SEVEN
Definition: RexxCore.h:86
stringArgument
RexxString * stringArgument(RexxObject *object, size_t position)
Definition: RexxCore.h:296
isActivation
bool isActivation(RexxObject *o)
Definition: RexxCore.h:268
RexxObject::requestArray
RexxArray * requestArray()
Definition: ObjectClass.cpp:1461
ClassTypeCodes.h
ClassClass.hpp
A_COUNT
const size_t A_COUNT
Definition: RexxCore.h:249
RexxBehaviour::getOperatorMethod
PCPPM getOperatorMethod(size_t index)
Definition: RexxBehaviour.hpp:142
RexxBehaviour.hpp
Error_Invalid_argument_noarg
#define Error_Invalid_argument_noarg
Definition: RexxErrorCodes.h:405
RexxObject::requiredPositive
stringsize_t requiredPositive(size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
Definition: ObjectClass.cpp:1423
Error_Execution_noarray
#define Error_Execution_noarray
Definition: RexxErrorCodes.h:532
ARG_FIVE
const int ARG_FIVE
Definition: RexxCore.h:84
MAX_SYMBOL_LENGTH
const int MAX_SYMBOL_LENGTH
Definition: RexxCore.h:74
RexxConstants.hpp
RexxInteger
Definition: IntegerClass.hpp:56
RexxObject::requestString
RexxString * requestString()
Definition: ObjectClass.cpp:1124
RexxObject
Definition: ObjectClass.hpp:311
RexxString
Definition: StringClass.hpp:119