Setup.cpp
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 */
40 /* */
41 /* Setup initial class definitions during an image build */
42 /* */
43 /* NOTE: The methods contained here are part of the RexxMemory class, but */
44 /* are in a separate file because of the extensive #include requirements */
45 /* for these particular methods and tables. */
46 /* */
47 /******************************************************************************/
48 #include <string.h>
49 #include "RexxCore.h"
50 #include "TableClass.hpp"
51 #include "RexxMemory.hpp"
52 #include "RexxBehaviour.hpp"
53 #include "ClassClass.hpp"
54 #include "NumberStringClass.hpp"
55 #include "IntegerClass.hpp"
56 #include "StringClass.hpp"
57 #include "MutableBufferClass.hpp"
58 #include "ArrayClass.hpp"
59 #include "DirectoryClass.hpp"
60 #include "RelationClass.hpp"
61 #include "ListClass.hpp"
62 #include "QueueClass.hpp"
63 #include "SupplierClass.hpp"
64 #include "MethodClass.hpp"
65 #include "RoutineClass.hpp"
66 #include "RexxEnvelope.hpp"
67 #include "MessageClass.hpp"
68 #include "StemClass.hpp"
69 #include "RexxMisc.hpp"
70 #include "RexxNativeCode.hpp"
71 #include "RexxActivity.hpp"
72 #include "ActivityManager.hpp"
73 #include "RexxNativeActivation.hpp"
74 #include "RexxVariableDictionary.hpp"
75 #include "ExpressionVariable.hpp"
76 #include "RexxLocalVariables.hpp"
77 #include "ProtectedObject.hpp"
78 #include "PointerClass.hpp"
79 #include "BufferClass.hpp"
80 #include "WeakReferenceClass.hpp"
81 #include "CPPCode.hpp"
82 #include "Interpreter.hpp"
83 #include "SystemInterpreter.hpp"
84 #include "InterpreterInstance.hpp"
85 #include "PackageManager.hpp"
86 #include "PackageClass.hpp"
87 #include "ContextClass.hpp"
88 #include "StackFrameClass.hpp"
89 #include "BlockClass.hpp"
90 #include "TextClass.hpp"
91 #include "SourceFile.hpp"
92 
93 
94 void RexxMemory::defineKernelMethod(
95  const char * name, /* ASCII-Z name for the method */
96  RexxBehaviour * behaviour, /* behaviour to use */
97  PCPPM entryPoint, /* method's entry point */
98  size_t arguments, /* count of arguments */
99  bool passNamedArgs /* pass the named arguments? */
100 )
101 /******************************************************************************/
102 /* Function: Add a C++ method to an object's behaviour */
103 /******************************************************************************/
104 {
105  behaviour->define(name, entryPoint, arguments, passNamedArgs);
106 }
107 
108 void RexxMemory::defineProtectedKernelMethod(
109  const char * name, /* ASCII-Z name for the method */
110  RexxBehaviour * behaviour, /* behaviour to use */
111  PCPPM entryPoint, /* method's entry point */
112  size_t arguments, /* count of arguments */
113  bool passNamedArgs /* pass the named arguments? */
114 )
115 /******************************************************************************/
116 /* Function: Add a C++ method to an object's behaviour */
117 /******************************************************************************/
118 {
119  RexxMethod *method = behaviour->define(name, entryPoint, arguments, passNamedArgs);
120  method->setProtected(); /* make this protected */
121 }
122 
123 
124 void RexxMemory::definePrivateKernelMethod(
125  const char * name, /* ASCII-Z name for the method */
126  RexxBehaviour * behaviour, /* behaviour to use */
127  PCPPM entryPoint, /* method's entry point */
128  size_t arguments, /* count of arguments */
129  bool passNamedArgs /* pass the named arguments? */
130 )
131 /******************************************************************************/
132 /* Function: Add a C++ method to an object's behaviour */
133 /******************************************************************************/
134 {
135  RexxMethod *method = behaviour->define(name, entryPoint, arguments, passNamedArgs);
136  // On 20/07/2014 rev 10318, official ooRexx was updated to no longer declare protected
137  //method->setProtected(); /* make this protected */
138  method->setPrivate(); /* make this protected */
139 }
140 
141 
142 /**
143  * Add a object to the kernel directory using the provided name.
144  *
145  * @param name The name of the new environment entry.
146  * @param value The value added.
147  */
148 void RexxMemory::addToSystem(const char *name, RexxInternalObject *value) // ooRexx5
149 {
150  // In ooRexx5, TheSystem is a StringTable which accepts RexxInternalObject*
151  // Here, TheSystem is a Directory which doesn't accept RexxInternalObject*
152  // Must cast...
153  TheSystem->put((RexxObject *)value, getGlobalName(name));
154 }
155 
156 #if 0 // This ooRexx5 macro is not used.
157  // Use directly addToSystem.
158 // Finish up one of the special classes (Integer and NumberString). Those are
159 // real classes, but are kept hidden.
160 #define EndSpecialClassDefinition(name) \
161  addToSystem(#name, currentClass); \
162 }
163 #endif
164 
165 /**
166  * Finalize a system class during image construction. This
167  * places the class in the Environment and also adds it to
168  * the Rexx package.
169  *
170  * @param name The class name.
171  * @param classObj The class object.
172  */
173 void RexxMemory::completeSystemClass(const char *name, RexxClass *classObj) // ooRexx5
174 {
175  // this gets added to the environment and the package in an uppercase name.
176  RexxString *className = getGlobalName(name);
177 
178 #if 0 // Not activated. This is done by kernel_public
179  TheEnvironment->put(classObj, className);
180 #endif
181 
182  // this is added as a public class in this package.
183 
184 #if 0 // jlf: can't use addPublicClass (crash because classObj not finalized)
185  TheRexxPackage->addPublicClass(className, classObj);
186 #else // Must use addInstalledClass (like ooRexx5)
187  TheRexxPackage->getSourceObject()->addInstalledClass(className, classObj, true);
188 #endif
189 }
190 
191 #if 0 // This ooRexx5 macro is not used.
192  // Use directly completeSystemClass.
193 // Add the created class object to the environment under its name and close
194 // the local variable scope
195 #define EndClassDefinition(name) \
196  completeSystemClass(#name, currentClass); \
197 }
198 #endif
199 
200 
201 /**
202  * Create the base Rexx package object. All Rexx-defined classes
203  * in the image will be added to this package.
204  */
205 void RexxMemory::createRexxPackage()
206 {
207  // this is a dummy package named "REXX" with the place holder
208  // sourceless program source
209  rexxPackage = new PackageClass(new RexxSource(OREF_REXX, "", 0));
210 }
211 
212 
213 /**
214  * Initialize the Rexx memory environment during an image built.
215  *
216  * @param imageTarget
217  * The location to save the created image file.
218  */
219 void RexxMemory::createImage(const char *imageTarget)
220 /******************************************************************************/
221 /* Function: Initialize the kernel on image build */
222 /******************************************************************************/
223 {
224  RexxMemory::create(); /* create initial memory stuff */
225 
226  Interpreter::init(); // the interpreter subsystem first
227  ActivityManager::init(); /* Initialize the activity managers */
228  // Get an instance. This also gives the root activity of the instance
229  // the kernel lock.
230  Interpreter::createInterpreterInstance();
231  memoryObject.createStrings(); /* create all of the OREF_ strings */
232  // initializer for native libraries
233  PackageManager::initialize();
234 
235  /* avoid that through caching */
236  /* TheTrueObject == IntegerOne etc. */
237  TheTrueObject = new RexxInteger(1);
238  TheFalseObject = new RexxInteger(0);
239 
240 
241  TheNilObject = new RexxNilObject;
242  /* We don't move the NIL object, we */
243  /*will use the remote systems NIL */
244  /*object. */
245  TheNilObject->makeProxiedObject();
246 
247  /* create string first */
248  RexxString::createInstance();
249  RexxText::createInstance(); // must be before the call new_text
250  RexxObject::createInstance();
251  RexxTable::createInstance();
252  RexxIdentityTable::createInstance();
253  RexxRelation::createInstance();
254 
255  TheFunctionsDirectory = new_directory();
256 
257  /* If first one through, generate all */
258  IntegerZero = new_integer(0); /* static integers we want to use... */
259  IntegerOne = new_integer(1); /* This will allow us to use the static */
260  IntegerTwo = new_integer(2); /* integers instead of having to do a */
261  IntegerThree = new_integer(3); /* new_integer every time.... */
262  IntegerFour = new_integer(4);
263  IntegerFive = new_integer(5);
264  IntegerSix = new_integer(6);
265  IntegerSeven = new_integer(7);
266  IntegerEight = new_integer(8);
267  IntegerNine = new_integer(9);
268  IntegerMinusOne = new_integer(-1);
269 
270  TheNullText = new_text("");
271 
272  /* RexxNumberString */
273  // NOTE: The number string class lies about its identity
274  RexxNumberString::createInstance();
275  RexxArray::createInstance();
276 
277  // The pointer class needs to be created early because other classes
278  // use the instances to store information.
279  RexxPointer::createInstance();
280 
281  RexxDirectory::createInstance();
282  CLASS_CREATE(Directory, "Directory", RexxClass); /* RexxDirectory */
283  TheEnvironment = new_directory(); /* create the environment directory */
284  /* setup OREF_ENV as the mark start */
285  /* point */
286  memoryObject.setMarkTable((RexxTable *)TheEnvironment);
287  TheKernel = new_directory(); /* now add the kernel and system */
288  TheSystem = new_directory(); /* directories */
289  /* Indicate these objects will not be*/
290  /* moved to another system, rather */
291  /* will re-establish themselves on */
292  /* the remote system. */
293  TheEnvironment->makeProxiedObject();
294  TheKernel->makeProxiedObject();
295  TheSystem->makeProxiedObject();
296 
297  /* RexxMethod */
298  RexxMethod::createInstance();
299  RoutineClass::createInstance();
300  PackageClass::createInstance();
301  RexxContext::createInstance();
302  RexxQueue::createInstance();
303  RexxList::createInstance();
304  RexxStem::createInstance();
305  RexxSupplier::createInstance();
306  RexxMessage::createInstance();
307  RexxMutableBuffer::createInstance();
308 
309  RexxBuffer::createInstance();
310  WeakReference::createInstance();
311  StackFrameClass::createInstance();
312  RexxBlock::createInstance();
313  Unicode::createInstance();
314 
315  /* build the common retriever tables */
316  TheCommonRetrievers = (RexxDirectory *)new_directory();
317  /* add all of the special variables */
318  TheCommonRetrievers->put((RexxObject *)new RexxParseVariable(OREF_SELF, VARIABLE_SELF), OREF_SELF);
319  TheCommonRetrievers->put((RexxObject *)new RexxParseVariable(OREF_SUPER, VARIABLE_SUPER), OREF_SUPER);
320  TheCommonRetrievers->put((RexxObject *)new RexxParseVariable(OREF_SIGL, VARIABLE_SIGL), OREF_SIGL);
321  TheCommonRetrievers->put((RexxObject *)new RexxParseVariable(OREF_RC, VARIABLE_RC), OREF_RC);
322  TheCommonRetrievers->put((RexxObject *)new RexxParseVariable(OREF_RESULT, VARIABLE_RESULT), OREF_RESULT);
323  memoryObject.enableOrefChecks(); /* enable setCheckOrefs... */
324 
325  // create the Rexx package so created classes can get added to it.
326  createRexxPackage(); // ooRexx5
327 
328 /******************************************************************************/
329 /* The following Rexx classes that are exposed to the users are set up as */
330 /* subclassable classes. */
331 /*****************************************************************************/
332 
333  /* The NEW method is exposed for the CLASS class behaviour. */
334  /* The CLASS class needs the methods of the CLASS instance behaviour */
335  /* so the instance behaviour methods are also in the CLASS class mdict. */
336  /* */
337  /* Also Since the CLASS class needs OBJECT instance methods the */
338  /* OBJECT class is setup. Then the class method SUBCLASSABLE can be */
339  /* invoked on OBJECT then CLASS and then all the subclassable classes. */
340 
341  /* add the Rexx class NEW method */
342  defineKernelMethod(CHAR_NEW, TheClassClassBehaviour, CPPM(RexxClass::newRexx), A_COUNT);
343 
344  /* set the scope of the method to */
345  /* the CLASS scope */
346  TheClassClassBehaviour->setMethodDictionaryScope(TheClassClass);
347 
348  /* add the instance methods to the */
349  /* class's instance mdict */
350  defineProtectedKernelMethod(CHAR_BASECLASS ,TheClassBehaviour, CPPM(RexxClass::getBaseClass), 0);
351  defineProtectedKernelMethod(CHAR_DEFINE ,TheClassBehaviour, CPPM(RexxClass::defineMethod), 2);
352  defineProtectedKernelMethod(CHAR_DEFINE_METHODS ,TheClassBehaviour, CPPM(RexxClass::defineMethods), 1);
353  defineProtectedKernelMethod("!DEFINE_CLASS_METHOD" ,TheClassBehaviour, CPPM(RexxClass::defineClassMethod), 2);
354  defineProtectedKernelMethod(CHAR_DELETE ,TheClassBehaviour, CPPM(RexxClass::deleteMethod), 1);
355  defineKernelMethod(CHAR_ENHANCED ,TheClassBehaviour, CPPM(RexxClass::enhanced), A_COUNT);
356  defineKernelMethod(CHAR_ID ,TheClassBehaviour, CPPM(RexxClass::getId), 0);
357  defineKernelMethod(CHAR_INHERIT ,TheClassBehaviour, CPPM(RexxClass::inherit), 2);
358  defineProtectedKernelMethod(CHAR_METACLASS ,TheClassBehaviour, CPPM(RexxClass::getMetaClass), 0);
359  defineKernelMethod(CHAR_METHOD ,TheClassBehaviour, CPPM(RexxClass::method), 1);
360  defineKernelMethod(CHAR_METHODS ,TheClassBehaviour, CPPM(RexxClass::methods), 1);
361  defineKernelMethod(CHAR_MIXINCLASS ,TheClassBehaviour, CPPM(RexxClass::mixinClassRexx), 3);
362  defineKernelMethod(CHAR_QUERYMIXINCLASS ,TheClassBehaviour, CPPM(RexxClass::queryMixinClass), 0);
363  defineKernelMethod(CHAR_ISMETACLASS ,TheClassBehaviour, CPPM(RexxClass::isMetaClassRexx), 0); // ooRexx5
364  defineKernelMethod(CHAR_ISABSTRACT ,TheClassBehaviour, CPPM(RexxClass::isAbstractRexx), 0); // ooRexx5
365  defineKernelMethod(CHAR_SUBCLASS ,TheClassBehaviour, CPPM(RexxClass::subclassRexx), 3);
366  defineProtectedKernelMethod(CHAR_SUBCLASSES ,TheClassBehaviour, CPPM(RexxClass::getSubClasses), 0);
367  defineProtectedKernelMethod(CHAR_SUPERCLASSES ,TheClassBehaviour, CPPM(RexxClass::getSuperClasses), 0);
368  defineProtectedKernelMethod(CHAR_SUPERCLASS ,TheClassBehaviour, CPPM(RexxClass::getSuperClass), 0);
369  defineProtectedKernelMethod(CHAR_UNINHERIT ,TheClassBehaviour, CPPM(RexxClass::uninherit), 1);
370  /* Class operator methods.... */
371  defineKernelMethod(CHAR_EQUAL ,TheClassBehaviour, CPPM(RexxClass::equal), 1);
372  defineKernelMethod(CHAR_STRICT_EQUAL ,TheClassBehaviour, CPPM(RexxClass::strictEqual), 1);
373  defineKernelMethod(CHAR_BACKSLASH_EQUAL ,TheClassBehaviour, CPPM(RexxClass::notEqual), 1);
374  defineKernelMethod(CHAR_LESSTHAN_GREATERTHAN ,TheClassBehaviour, CPPM(RexxClass::notEqual), 1);
375  defineKernelMethod(CHAR_GREATERTHAN_LESSTHAN ,TheClassBehaviour, CPPM(RexxClass::notEqual), 1);
376  defineKernelMethod(CHAR_STRICT_BACKSLASH_EQUAL ,TheClassBehaviour, CPPM(RexxClass::notEqual), 1);
377  defineKernelMethod(CHAR_ISSUBCLASSOF ,TheClassBehaviour, CPPM(RexxClass::isSubclassOf), 1);
378  defineKernelMethod(CHAR_PACKAGE ,TheClassBehaviour, CPPM(RexxClass::getPackage), 1);
379  defineProtectedKernelMethod(CHAR_SHRIEKREXXDEFINED,TheClassBehaviour, CPPM(RexxClass::setRexxDefined), 0);
380  defineKernelMethod(CHAR_DEFAULTNAME ,TheClassBehaviour, CPPM(RexxClass::defaultNameRexx), 0);
381  // this is explicitly inserted into the class behaviour because it gets used
382  // prior to the instance behavior merges.
383  defineKernelMethod(CHAR_HASHCODE ,TheClassBehaviour, CPPM(RexxObject::hashCode), 0);
384  // this is a NOP by default, so we'll just use the object init method as a fill in.
385  defineKernelMethod(CHAR_ACTIVATE ,TheClassBehaviour, CPPM(RexxObject::init), 0);
386 
387  /* set the scope of the methods to */
388  /* the CLASS scope */
389  TheClassBehaviour->setMethodDictionaryScope(TheClassClass);
390  completeSystemClass("CLASS", TheClassClass);
391 
392  /************************************************************************/
393  /* */
394  /* The OBJECT class and instance behaviour mdict's are needed next */
395  /* */
396  /************************************************************************/
397 
398  /* add the NEW method to the OBJECT */
399  /* behaviour mdict */
400  defineKernelMethod(CHAR_NEW, TheObjectClassBehaviour, CPPM(RexxObject::newRexx), A_COUNT);
401 
402  /* set the scope of the method to */
403  /* the OBJECT scope */
404  TheObjectClassBehaviour->setMethodDictionaryScope(TheObjectClass);
405 
406  /* now set up the instance behaviour */
407  /* mdict */
408  defineKernelMethod(CHAR_INIT ,TheObjectBehaviour, CPPM(RexxObject::init), 0);
409  defineKernelMethod(CHAR_EQUAL ,TheObjectBehaviour, CPPM(RexxObject::equal), 1);
410  defineKernelMethod(CHAR_STRICT_EQUAL ,TheObjectBehaviour, CPPM(RexxObject::strictEqual), 1);
411  defineKernelMethod(CHAR_HASHCODE ,TheObjectBehaviour, CPPM(RexxObject::hashCode), 0);
412  defineKernelMethod(CHAR_BACKSLASH_EQUAL ,TheObjectBehaviour, CPPM(RexxObject::notEqual), 1);
413  defineKernelMethod(CHAR_LESSTHAN_GREATERTHAN ,TheObjectBehaviour, CPPM(RexxObject::notEqual), 1);
414  defineKernelMethod(CHAR_GREATERTHAN_LESSTHAN ,TheObjectBehaviour, CPPM(RexxObject::notEqual), 1);
415  defineKernelMethod(CHAR_STRICT_BACKSLASH_EQUAL ,TheObjectBehaviour, CPPM(RexxObject::strictNotEqual), 1);
416  defineKernelMethod(CHAR_NULLSTRING ,TheObjectBehaviour, CPPM(RexxObject::concatRexx), 1);
417  defineKernelMethod(CHAR_BLANK ,TheObjectBehaviour, CPPM(RexxObject::concatBlank), 1);
418  defineKernelMethod(CHAR_CONCATENATE ,TheObjectBehaviour, CPPM(RexxObject::concatRexx), 1);
419  defineKernelMethod(CHAR_COPY ,TheObjectBehaviour, CPPM(RexxObject::copyRexx), 0);
420  defineKernelMethod(CHAR_CLASS ,TheObjectBehaviour, CPPM(RexxObject::classObject), 0);
421  defineKernelMethod(CHAR_HASMETHOD ,TheObjectBehaviour, CPPM(RexxObject::hasMethodRexx), 1);
422  defineKernelMethod(CHAR_DEFAULTNAME ,TheObjectBehaviour, CPPM(RexxObject::defaultNameRexx), 0);
423  defineKernelMethod(CHAR_OBJECTNAME ,TheObjectBehaviour, CPPM(RexxObject::objectName), 0);
424  defineKernelMethod(CHAR_OBJECTNAMEEQUALS ,TheObjectBehaviour, CPPM(RexxObject::objectNameEquals), 1);
425  defineKernelMethod(CHAR_REQUEST ,TheObjectBehaviour, CPPM(RexxObject::requestRexx), 1);
426  defineKernelMethod(CHAR_START ,TheObjectBehaviour, CPPM(RexxObject::start), A_COUNT);
427  defineKernelMethod("STARTWITH" ,TheObjectBehaviour, CPPM(RexxObject::startWith), 2, true); // pass named arguments
428  defineKernelMethod("SEND" ,TheObjectBehaviour, CPPM(RexxObject::send), A_COUNT);
429  defineKernelMethod("SENDWITH" ,TheObjectBehaviour, CPPM(RexxObject::sendWith), 2, true); // pass named arguments
430  defineKernelMethod(CHAR_STRING ,TheObjectBehaviour, CPPM(RexxObject::stringRexx), 0);
431  defineKernelMethod(CHAR_ISINSTANCEOF ,TheObjectBehaviour, CPPM(RexxObject::isInstanceOfRexx), 1);
432  defineKernelMethod(CHAR_ISA ,TheObjectBehaviour, CPPM(RexxObject::isInstanceOfRexx), 1);
433  defineKernelMethod(CHAR_ISNIL ,TheObjectBehaviour, CPPM(RexxObject::isNilRexx), 1);
434  defineKernelMethod(CHAR_INSTANCEMETHOD ,TheObjectBehaviour, CPPM(RexxObject::instanceMethodRexx), 1);
435  defineKernelMethod(CHAR_INSTANCEMETHODS ,TheObjectBehaviour, CPPM(RexxObject::instanceMethodsRexx), 1);
436  defineKernelMethod(CHAR_DYNAMICTARGET ,TheObjectBehaviour, CPPM(RexxObject::dynamicTargetRexx), A_COUNT);
437  defineKernelMethod(CHAR_IDENTITYHASH ,TheObjectBehaviour, CPPM(RexxObject::identityHashRexx), 0);
438  definePrivateKernelMethod(CHAR_RUN ,TheObjectBehaviour, CPPM(RexxObject::run), A_COUNT);
439  definePrivateKernelMethod(CHAR_SETMETHOD ,TheObjectBehaviour, CPPM(RexxObject::setMethod), 3);
440  definePrivateKernelMethod(CHAR_UNSETMETHOD ,TheObjectBehaviour, CPPM(RexxObject::unsetMethod), 1);
441  /* set the scope of the methods to */
442  /* the OBJECT scope */
443  TheObjectBehaviour->setMethodDictionaryScope(TheObjectClass);
444  /* Now call the class subclassable */
445  /* method for OBJECT then CLASS */
446  TheObjectClass->subClassable(true);
447  TheClassClass->subClassable(true);
448  completeSystemClass("OBJECT", TheObjectClass);
449 
450  /************************************** The rest of the classes can now be */
451  /************************************** set up. */
452 
453  /***************************************************************************/
454  /* ARRAY */
455  /***************************************************************************/
456 
457  defineKernelMethod(CHAR_NEW, TheArrayClassBehaviour, CPPM(RexxArray::newRexx), A_COUNT);
458  defineKernelMethod(CHAR_OF, TheArrayClassBehaviour, CPPM(RexxArray::of), A_COUNT);
459  /* set the scope of the methods to */
460  /* this classes oref */
461  TheArrayClassBehaviour->setMethodDictionaryScope(TheArrayClass);
462 
463  defineKernelMethod(CHAR_BRACKETS ,TheArrayBehaviour, CPPM(RexxArray::getRexx), A_COUNT);
464  defineKernelMethod(CHAR_BRACKETSEQUAL,TheArrayBehaviour, CPPM(RexxArray::putRexx), A_COUNT);
465  defineKernelMethod(CHAR_AT ,TheArrayBehaviour, CPPM(RexxArray::getRexx), A_COUNT);
466  defineKernelMethod(CHAR_DIMENSION ,TheArrayBehaviour, CPPM(RexxArray::dimension), 1);
467  defineKernelMethod("DIMENSIONS" ,TheArrayBehaviour, CPPM(RexxArray::getDimensions), 0);
468  defineKernelMethod(CHAR_HASINDEX ,TheArrayBehaviour, CPPM(RexxArray::hasIndexRexx), A_COUNT);
469  defineKernelMethod(CHAR_ITEMS ,TheArrayBehaviour, CPPM(RexxArray::itemsRexx), 0);
470  defineKernelMethod(CHAR_MAKEARRAY ,TheArrayBehaviour, CPPM(RexxObject::makeArrayRexx), 0);
471  defineKernelMethod(CHAR_PUT ,TheArrayBehaviour, CPPM(RexxArray::putRexx), A_COUNT);
472  defineKernelMethod(CHAR_REMOVE ,TheArrayBehaviour, CPPM(RexxArray::removeRexx), A_COUNT);
473  defineKernelMethod(CHAR_SECTION ,TheArrayBehaviour, CPPM(RexxArray::sectionRexx), 2);
474  defineKernelMethod(CHAR_SIZE ,TheArrayBehaviour, CPPM(RexxArray::sizeRexx), 0);
475  defineKernelMethod(CHAR_SUPPLIER ,TheArrayBehaviour, CPPM(RexxArray::supplier), 1);
476  defineKernelMethod(CHAR_FIRST ,TheArrayBehaviour, CPPM(RexxArray::firstRexx), 0);
477  defineKernelMethod(CHAR_FIRSTITEM ,TheArrayBehaviour, CPPM(RexxArray::firstItem), 0);
478  defineKernelMethod(CHAR_LAST ,TheArrayBehaviour, CPPM(RexxArray::lastRexx), 0);
479  defineKernelMethod(CHAR_LASTITEM ,TheArrayBehaviour, CPPM(RexxArray::lastItem), 0);
480  defineKernelMethod(CHAR_NEXT ,TheArrayBehaviour, CPPM(RexxArray::nextRexx), A_COUNT);
481  defineKernelMethod(CHAR_PREVIOUS ,TheArrayBehaviour, CPPM(RexxArray::previousRexx), A_COUNT);
482  defineKernelMethod(CHAR_APPEND ,TheArrayBehaviour, CPPM(RexxArray::appendRexx), 1);
483  defineKernelMethod(CHAR_MAKESTRING ,TheArrayBehaviour, CPPM(RexxArray::makeString), 2);
484  defineKernelMethod(CHAR_TOSTRING ,TheArrayBehaviour, CPPM(RexxArray::toString), 2);
485  defineKernelMethod(CHAR_ALLINDEXES ,TheArrayBehaviour, CPPM(RexxArray::allIndexes), 1);
486  defineKernelMethod(CHAR_ALLITEMS ,TheArrayBehaviour, CPPM(RexxArray::allItems), 1);
487  defineKernelMethod(CHAR_EMPTY ,TheArrayBehaviour, CPPM(RexxArray::empty), 0);
488  defineKernelMethod(CHAR_ISEMPTY ,TheArrayBehaviour, CPPM(RexxArray::isEmpty), 0);
489  defineKernelMethod(CHAR_INDEX ,TheArrayBehaviour, CPPM(RexxArray::index), 1);
490  defineKernelMethod(CHAR_HASITEM ,TheArrayBehaviour, CPPM(RexxArray::hasItem), 1);
491  defineKernelMethod(CHAR_REMOVEITEM ,TheArrayBehaviour, CPPM(RexxArray::removeItem), 1);
492  defineKernelMethod(CHAR_INSERT ,TheArrayBehaviour, CPPM(RexxArray::insertRexx), 2);
493  defineKernelMethod(CHAR_DELETE ,TheArrayBehaviour, CPPM(RexxArray::deleteRexx), 1);
494  defineKernelMethod("FILL" ,TheArrayBehaviour, CPPM(RexxArray::fill), 1);
495  // there have been some problems with the quick sort used as the default sort, so map everything
496  // to the stable sort. The stable sort, in theory, uses more memory, but in practice, this is not true.
497  defineKernelMethod(CHAR_SORT ,TheArrayBehaviour, CPPM(RexxArray::stableSortRexx), 0);
498  defineKernelMethod(CHAR_SORTWITH ,TheArrayBehaviour, CPPM(RexxArray::stableSortWithRexx), 1);
499  defineKernelMethod(CHAR_STABLESORT ,TheArrayBehaviour, CPPM(RexxArray::stableSortRexx), 0);
500  defineKernelMethod(CHAR_STABLESORTWITH ,TheArrayBehaviour, CPPM(RexxArray::stableSortWithRexx), 1);
501  /* set the scope of the methods to */
502  /* this classes oref */
503  TheArrayBehaviour->setMethodDictionaryScope(TheArrayClass);
504 
505  /* Now call the class subclassable */
506  /* method */
507  TheArrayClass->subClassable(false);
508  completeSystemClass("ARRAY", TheArrayClass);
509 
510  /***************************************************************************/
511  /* DIRECTORY */
512  /***************************************************************************/
513 
514  defineKernelMethod(CHAR_NEW , TheDirectoryClassBehaviour, CPPM(RexxDirectory::newRexx), A_COUNT);
515 
516  /* set the scope of the method to */
517  /* this classes oref */
518  TheDirectoryClassBehaviour->setMethodDictionaryScope(TheDirectoryClass);
519 
520  /* add the instance methods */
521  defineKernelMethod(CHAR_BRACKETS , TheDirectoryBehaviour, CPPM(RexxDirectory::atRexx), 1);
522  defineKernelMethod(CHAR_BRACKETSEQUAL , TheDirectoryBehaviour, CPPM(RexxDirectory::put), 2);
523  defineKernelMethod(CHAR_AT , TheDirectoryBehaviour, CPPM(RexxDirectory::atRexx), 1);
524  defineKernelMethod(CHAR_ENTRY , TheDirectoryBehaviour, CPPM(RexxDirectory::entryRexx), 1);
525  defineKernelMethod(CHAR_HASENTRY , TheDirectoryBehaviour, CPPM(RexxDirectory::hasEntry), 1);
526  defineKernelMethod(CHAR_HASINDEX , TheDirectoryBehaviour, CPPM(RexxDirectory::hasIndex), 1);
527  defineKernelMethod(CHAR_ITEMS , TheDirectoryBehaviour, CPPM(RexxDirectory::itemsRexx), 0);
528  defineKernelMethod(CHAR_MAKEARRAY , TheDirectoryBehaviour, CPPM(RexxObject::makeArrayRexx), 0);
529  defineKernelMethod(CHAR_ALLITEMS , TheDirectoryBehaviour, CPPM(RexxDirectory::allItems), 0);
530  defineKernelMethod(CHAR_ALLINDEXES , TheDirectoryBehaviour, CPPM(RexxDirectory::allIndexes), 0);
531  defineKernelMethod(CHAR_EMPTY , TheDirectoryBehaviour, CPPM(RexxDirectory::empty), 0);
532  defineKernelMethod(CHAR_ISEMPTY , TheDirectoryBehaviour, CPPM(RexxDirectory::isEmpty), 0);
533  defineKernelMethod(CHAR_PUT , TheDirectoryBehaviour, CPPM(RexxDirectory::put), 2);
534  defineKernelMethod(CHAR_REMOVE , TheDirectoryBehaviour, CPPM(RexxDirectory::removeRexx), 1);
535  defineKernelMethod(CHAR_SETENTRY , TheDirectoryBehaviour, CPPM(RexxDirectory::setEntry), 2);
536  defineProtectedKernelMethod(CHAR_SETMETHOD , TheDirectoryBehaviour, CPPM(RexxDirectory::setMethod), 2);
537  defineKernelMethod(CHAR_SUPPLIER , TheDirectoryBehaviour, CPPM(RexxDirectory::supplier), 0);
538  defineKernelMethod(CHAR_UNKNOWN , TheDirectoryBehaviour, CPPM(RexxObject::unknownRexx), 2, true); // pass named arguments
539  defineProtectedKernelMethod(CHAR_UNSETMETHOD , TheDirectoryBehaviour, CPPM(RexxDirectory::removeRexx), 1);
540  defineKernelMethod(CHAR_INDEX , TheDirectoryBehaviour, CPPM(RexxDirectory::indexRexx), 1);
541  defineKernelMethod(CHAR_HASITEM , TheDirectoryBehaviour, CPPM(RexxDirectory::hasItem), 1);
542  defineKernelMethod(CHAR_REMOVEITEM , TheDirectoryBehaviour, CPPM(RexxDirectory::removeItem), 1);
543 
544  /* set the scope of the methods to */
545  /* this classes oref */
546  TheDirectoryBehaviour->setMethodDictionaryScope(TheDirectoryClass);
547 
548  /* Now call the class subclassable */
549  /* method */
550  TheDirectoryClass->subClassable(false);
551  completeSystemClass("DIRECTORY", TheDirectoryClass);
552 
553 
554  /***************************************************************************/
555  /* LIST */
556  /***************************************************************************/
557 
558  /* add the class behaviour methods */
559  defineKernelMethod(CHAR_NEW , TheListClassBehaviour, CPPM(RexxList::newRexx), A_COUNT);
560  defineKernelMethod(CHAR_OF , TheListClassBehaviour, CPPM(RexxList::classOf), A_COUNT);
561 
562  /* set the scope of the methods to */
563  /* this classes oref */
564  TheListClassBehaviour->setMethodDictionaryScope(TheListClass);
565 
566  /* add the instance behaviour methods*/
567  defineKernelMethod(CHAR_BRACKETS ,TheListBehaviour, CPPM(RexxList::value), 1);
568  defineKernelMethod(CHAR_BRACKETSEQUAL,TheListBehaviour, CPPM(RexxList::put), 2);
569  defineKernelMethod(CHAR_MAKEARRAY ,TheListBehaviour, CPPM(RexxObject::makeArrayRexx), 0);
570  defineKernelMethod(CHAR_AT ,TheListBehaviour, CPPM(RexxList::value), 1);
571  defineKernelMethod(CHAR_FIRSTITEM ,TheListBehaviour, CPPM(RexxList::firstItem), 0);
572  defineKernelMethod(CHAR_HASINDEX ,TheListBehaviour, CPPM(RexxList::hasIndex), 1);
573  defineKernelMethod(CHAR_INSERT ,TheListBehaviour, CPPM(RexxList::insertRexx), 2);
574  defineKernelMethod(CHAR_ITEMS ,TheListBehaviour, CPPM(RexxList::itemsRexx), 0);
575  defineKernelMethod(CHAR_LASTITEM ,TheListBehaviour, CPPM(RexxList::lastItem), 0);
576  defineKernelMethod(CHAR_FIRST ,TheListBehaviour, CPPM(RexxList::firstRexx), 0);
577  defineKernelMethod(CHAR_LAST ,TheListBehaviour, CPPM(RexxList::lastRexx), 0);
578  defineKernelMethod(CHAR_NEXT ,TheListBehaviour, CPPM(RexxList::next), 1);
579  defineKernelMethod(CHAR_PREVIOUS ,TheListBehaviour, CPPM(RexxList::previous), 1);
580  defineKernelMethod(CHAR_PUT ,TheListBehaviour, CPPM(RexxList::put), 2);
581  defineKernelMethod(CHAR_REMOVE ,TheListBehaviour, CPPM(RexxList::remove), 1);
582  // DELETE is the same as REMOVE for the List class
583  defineKernelMethod(CHAR_DELETE ,TheListBehaviour, CPPM(RexxList::remove), 1);
584  defineKernelMethod(CHAR_SECTION ,TheListBehaviour, CPPM(RexxList::section), 2);
585  defineKernelMethod(CHAR_SUPPLIER ,TheListBehaviour, CPPM(RexxList::supplier), 0);
586  defineKernelMethod(CHAR_APPEND ,TheListBehaviour, CPPM(RexxList::append), 1);
587  defineKernelMethod(CHAR_ALLITEMS ,TheListBehaviour, CPPM(RexxList::allItems), 0);
588  defineKernelMethod(CHAR_ALLINDEXES ,TheListBehaviour, CPPM(RexxList::allIndexes), 0);
589  defineKernelMethod(CHAR_EMPTY ,TheListBehaviour, CPPM(RexxList::empty), 0);
590  defineKernelMethod(CHAR_ISEMPTY ,TheListBehaviour, CPPM(RexxList::isEmpty), 0);
591  defineKernelMethod(CHAR_INDEX ,TheListBehaviour, CPPM(RexxList::index), 1);
592  defineKernelMethod(CHAR_HASITEM ,TheListBehaviour, CPPM(RexxList::hasItem), 1);
593  defineKernelMethod(CHAR_REMOVEITEM ,TheListBehaviour, CPPM(RexxList::removeItem), 1);
594  /* set the scope of the methods to */
595  /* this classes oref */
596  TheListBehaviour->setMethodDictionaryScope(TheListClass);
597 
598  /* Now call the class subclassable */
599  /* method */
600  TheListClass->subClassable(false);
601  completeSystemClass("LIST", TheListClass);
602 
603  /***************************************************************************/
604  /* MESSAGE */
605  /***************************************************************************/
606 
607  /* Define the NEW method in the */
608  /* class behaviour mdict */
609  defineKernelMethod(CHAR_NEW , TheMessageClassBehaviour, CPPM(RexxMessage::newRexx), A_COUNT);
610 
611  /* set the scope of the methods to */
612  /* this classes oref */
613  TheMessageClassBehaviour->setMethodDictionaryScope(TheMessageClass);
614 
615  /* Add the instance methods to the */
616  /* instance behaviour mdict */
617 
618  defineKernelMethod(CHAR_COMPLETED, TheMessageBehaviour, CPPM(RexxMessage::completed), 0);
619  defineKernelMethod(CHAR_HASERROR, TheMessageBehaviour, CPPM(RexxMessage::hasError), 0);
620  defineKernelMethod(CHAR_NOTIFY , TheMessageBehaviour, CPPM(RexxMessage::notify), 1);
621  defineKernelMethod(CHAR_RESULT , TheMessageBehaviour, CPPM(RexxMessage::result), 0);
622  defineKernelMethod(CHAR_TARGET , TheMessageBehaviour, CPPM(RexxMessage::messageTarget), 0);
623  defineKernelMethod(CHAR_MESSAGENAME , TheMessageBehaviour, CPPM(RexxMessage::messageName), 0);
624  defineKernelMethod(CHAR_ARGUMENTS , TheMessageBehaviour, CPPM(RexxMessage::arguments), 0);
625  defineKernelMethod(CHAR_ERRORCONDITION , TheMessageBehaviour, CPPM(RexxMessage::errorCondition), 0);
626  defineKernelMethod(CHAR_SEND , TheMessageBehaviour, CPPM(RexxMessage::send), 1);
627  defineKernelMethod(CHAR_START , TheMessageBehaviour, CPPM(RexxMessage::start), 1);
628 
629  /* set the scope of the methods to */
630  /* this classes oref */
631  TheMessageBehaviour->setMethodDictionaryScope(TheMessageClass);
632 
633  /* Now call the class subclassable */
634  /* method */
635  TheMessageClass->subClassable(true);
636  completeSystemClass("MESSAGE", TheMessageClass);
637 
638  /***************************************************************************/
639  /* METHOD */
640  /***************************************************************************/
641 
642  /* Add the NEW methods to the */
643  /* class behaviour */
644  defineKernelMethod(CHAR_NEW , TheMethodClassBehaviour, CPPM(RexxMethod::newRexx), A_COUNT);
645  defineKernelMethod(CHAR_NEWFILE , TheMethodClassBehaviour, CPPM(RexxMethod::newFileRexx), 1);
646  defineKernelMethod("LOADEXTERNALMETHOD" , TheMethodClassBehaviour, CPPM(RexxMethod::loadExternalMethod), 2);
647  /* set the scope of the methods to */
648  /* this classes oref */
649  TheMethodClassBehaviour->setMethodDictionaryScope(TheMethodClass);
650 
651  /* Add the instance methods to the */
652  /* instance behaviour mdict */
653  defineKernelMethod(CHAR_SETUNGUARDED ,TheMethodBehaviour, CPPM(RexxMethod::setUnguardedRexx), 0);
654  defineKernelMethod(CHAR_SETGUARDED ,TheMethodBehaviour, CPPM(RexxMethod::setGuardedRexx), 0);
655  defineKernelMethod(CHAR_SETPRIVATE ,TheMethodBehaviour, CPPM(RexxMethod::setPrivateRexx), 0);
656  defineKernelMethod(CHAR_ISGUARDED ,TheMethodBehaviour, CPPM(RexxMethod::isGuardedRexx), 0);
657  defineKernelMethod(CHAR_ISPRIVATE ,TheMethodBehaviour, CPPM(RexxMethod::isPrivateRexx), 0);
658  defineKernelMethod(CHAR_ISPROTECTED ,TheMethodBehaviour, CPPM(RexxMethod::isProtectedRexx), 0);
659  defineProtectedKernelMethod(CHAR_SETPROTECTED ,TheMethodBehaviour, CPPM(RexxMethod::setProtectedRexx), 0);
660  defineProtectedKernelMethod(CHAR_SETSECURITYMANAGER ,TheMethodBehaviour, CPPM(RexxMethod::setSecurityManager), 1);
661  defineKernelMethod("ISPACKAGE" ,TheMethodBehaviour, CPPM(RexxMethod::isPackageRexx), 0); // ooRexx5
662  defineKernelMethod("ISABSTRACT" ,TheMethodBehaviour, CPPM(RexxMethod::isAbstractRexx), 0); // ooRexx5
663  defineKernelMethod("ISCONSTANT" ,TheMethodBehaviour, CPPM(RexxMethod::isConstantRexx), 0); // ooRexx5
664  defineKernelMethod("ISATTRIBUTE" ,TheMethodBehaviour, CPPM(RexxMethod::isAttributeRexx), 0); // ooRexx5
665  defineKernelMethod("SCOPE" ,TheMethodBehaviour, CPPM(RexxMethod::getScopeRexx), 0); // ooRexx5
666  defineKernelMethod(CHAR_SOURCE ,TheMethodBehaviour, CPPM(BaseExecutable::source), 0);
667  defineKernelMethod(CHAR_PACKAGE ,TheMethodBehaviour, CPPM(BaseExecutable::getPackage), 0);
668  /* set the scope of the methods to */
669  /* this classes oref */
670  TheMethodBehaviour->setMethodDictionaryScope(TheMethodClass);
671 
672  /* Now call the class subclassable */
673  /* method */
674  TheMethodClass->subClassable(true);
675  completeSystemClass("METHOD", TheMethodClass);
676 
677  /***************************************************************************/
678  /* ROUTINE */
679  /***************************************************************************/
680 
681  /* Add the NEW methods to the */
682  /* class behaviour */
683  defineKernelMethod(CHAR_NEW , TheRoutineClassBehaviour, CPPM(RoutineClass::newRexx), A_COUNT);
684  defineKernelMethod(CHAR_NEWFILE , TheRoutineClassBehaviour, CPPM(RoutineClass::newFileRexx), 1);
685  defineKernelMethod("LOADEXTERNALROUTINE" , TheRoutineClassBehaviour, CPPM(RoutineClass::loadExternalRoutine), 2);
686  /* set the scope of the methods to */
687  /* this classes oref */
688  TheRoutineClassBehaviour->setMethodDictionaryScope(TheRoutineClass);
689 
690  /* Add the instance methods to the */
691  /* instance behaviour mdict */
692  defineProtectedKernelMethod(CHAR_SETSECURITYMANAGER ,TheRoutineBehaviour, CPPM(RoutineClass::setSecurityManager), 1);
693  defineKernelMethod(CHAR_SOURCE ,TheRoutineBehaviour, CPPM(BaseExecutable::source), 0);
694  defineKernelMethod(CHAR_PACKAGE ,TheRoutineBehaviour, CPPM(BaseExecutable::getPackage), 0);
695  defineKernelMethod(CHAR_CALL ,TheRoutineBehaviour, CPPM(RoutineClass::callRexx), A_COUNT);
696  defineKernelMethod(CHAR_CALLWITH ,TheRoutineBehaviour, CPPM(RoutineClass::callWithRexx), 1, true); // pass named arguments
697  /* set the scope of the methods to */
698  /* this classes oref */
699  TheRoutineBehaviour->setMethodDictionaryScope(TheRoutineClass);
700 
701  /* Now call the class subclassable */
702  /* method */
703  TheRoutineClass->subClassable(true);
704  completeSystemClass("ROUTINE", TheRoutineClass);
705 
706 
707  /***************************************************************************/
708  /* Package */
709  /***************************************************************************/
710 
711  /* Add the NEW methods to the */
712  /* class behaviour */
713  defineKernelMethod(CHAR_NEW , ThePackageClassBehaviour, CPPM(PackageClass::newRexx), A_COUNT);
714  /* set the scope of the methods to */
715  /* this classes oref */
716  ThePackageClassBehaviour->setMethodDictionaryScope(ThePackageClass);
717 
718  /* Add the instance methods to the */
719  /* instance behaviour mdict */
720  defineProtectedKernelMethod(CHAR_SETSECURITYMANAGER ,ThePackageBehaviour, CPPM(PackageClass::setSecurityManager), 1);
721  defineKernelMethod(CHAR_SOURCE ,ThePackageBehaviour, CPPM(PackageClass::getSource), 0);
722  defineKernelMethod(CHAR_SOURCELINE ,ThePackageBehaviour, CPPM(PackageClass::getSourceLineRexx), 1);
723  defineKernelMethod(CHAR_SOURCESIZE ,ThePackageBehaviour, CPPM(PackageClass::getSourceSize), 0);
724  defineKernelMethod(CHAR_CLASSES ,ThePackageBehaviour, CPPM(PackageClass::getClasses), 0);
725  defineKernelMethod(CHAR_PUBLICCLASSES ,ThePackageBehaviour, CPPM(PackageClass::getPublicClasses), 0);
726  defineKernelMethod(CHAR_IMPORTEDCLASSES ,ThePackageBehaviour, CPPM(PackageClass::getImportedClasses), 0);
727  defineKernelMethod(CHAR_DEFINEDMETHODS, ThePackageBehaviour, CPPM(PackageClass::getMethods), 0);
728  defineKernelMethod(CHAR_ROUTINES ,ThePackageBehaviour, CPPM(PackageClass::getRoutines), 0);
729  defineKernelMethod(CHAR_PUBLICROUTINES ,ThePackageBehaviour, CPPM(PackageClass::getPublicRoutines), 0);
730  defineKernelMethod(CHAR_IMPORTEDROUTINES ,ThePackageBehaviour, CPPM(PackageClass::getImportedRoutines), 0);
731  defineKernelMethod(CHAR_IMPORTEDPACKAGES ,ThePackageBehaviour, CPPM(PackageClass::getImportedPackages), 0);
732  defineKernelMethod(CHAR_LOADPACKAGE ,ThePackageBehaviour, CPPM(PackageClass::loadPackage), 2);
733  defineKernelMethod(CHAR_ADDPACKAGE ,ThePackageBehaviour, CPPM(PackageClass::addPackage), 1);
734  defineKernelMethod(CHAR_FINDCLASS ,ThePackageBehaviour, CPPM(PackageClass::findClassRexx), 1);
735  defineKernelMethod(CHAR_FINDROUTINE ,ThePackageBehaviour, CPPM(PackageClass::findRoutineRexx), 1);
736  defineKernelMethod("FINDPROGRAM" ,ThePackageBehaviour, CPPM(PackageClass::findProgramRexx), 1);
737  defineKernelMethod(CHAR_ADDROUTINE ,ThePackageBehaviour, CPPM(PackageClass::addRoutine), 2);
738  defineKernelMethod(CHAR_ADDPUBLICROUTINE ,ThePackageBehaviour, CPPM(PackageClass::addPublicRoutine), 2);
739  defineKernelMethod(CHAR_ADDCLASS ,ThePackageBehaviour, CPPM(PackageClass::addClass), 2);
740  defineKernelMethod(CHAR_ADDPUBLICCLASS ,ThePackageBehaviour, CPPM(PackageClass::addPublicClass), 2);
741  defineKernelMethod(CHAR_NAME ,ThePackageBehaviour, CPPM(PackageClass::getName), 0);
742  defineKernelMethod("LOADLIBRARY" ,ThePackageBehaviour, CPPM(PackageClass::loadLibrary), 1);
743  defineKernelMethod("DIGITS" ,ThePackageBehaviour, CPPM(PackageClass::digits), 0);
744  defineKernelMethod("FORM" ,ThePackageBehaviour, CPPM(PackageClass::form), 0);
745  defineKernelMethod("FUZZ" ,ThePackageBehaviour, CPPM(PackageClass::fuzz), 0);
746  defineKernelMethod("TRACE" ,ThePackageBehaviour, CPPM(PackageClass::trace), 0);
747  defineKernelMethod("!SETENCODING" ,ThePackageBehaviour, CPPM(PackageClass::setEncodingRexx), 1);
748  /* set the scope of the methods to */
749  /* this classes oref */
750  ThePackageBehaviour->setMethodDictionaryScope(ThePackageClass);
751 
752  /* Now call the class subclassable */
753  /* method */
754  ThePackageClass->subClassable(true);
755  completeSystemClass("PACKAGE", ThePackageClass);
756 
757 
758  /***************************************************************************/
759  /* RexxContext */
760  /***************************************************************************/
761 
762  /* Add the NEW methods to the */
763  /* class behaviour */
764  defineKernelMethod(CHAR_NEW ,TheRexxContextClassBehaviour, CPPM(RexxContext::newRexx), A_COUNT);
765  /* set the scope of the methods to */
766  /* this classes oref */
767  TheRexxContextClassBehaviour->setMethodDictionaryScope(TheRexxContextClass);
768 
769  defineKernelMethod(CHAR_COPY ,TheRexxContextBehaviour, CPPM(RexxContext::copyRexx), 0);
770  defineKernelMethod(CHAR_PACKAGE ,TheRexxContextBehaviour, CPPM(RexxContext::getPackage), 0);
771  defineKernelMethod(CHAR_EXECUTABLE ,TheRexxContextBehaviour, CPPM(RexxContext::getExecutable), 0);
772  defineKernelMethod(CHAR_FORM ,TheRexxContextBehaviour, CPPM(RexxContext::getForm), 0);
773  defineKernelMethod(CHAR_FUZZ ,TheRexxContextBehaviour, CPPM(RexxContext::getFuzz), 0);
774  defineKernelMethod(CHAR_DIGITS ,TheRexxContextBehaviour, CPPM(RexxContext::getDigits), 0);
775  defineKernelMethod("DIGITSPROPAGATE" ,TheRexxContextBehaviour, CPPM(RexxContext::getDigitsPropagate), 0);
776  defineKernelMethod(CHAR_VARIABLES ,TheRexxContextBehaviour, CPPM(RexxContext::getVariables), 0);
777  defineKernelMethod(CHAR_ARGS ,TheRexxContextBehaviour, CPPM(RexxContext::getArgs), 0);
778  defineKernelMethod(CHAR_SETARGS ,TheRexxContextBehaviour, CPPM(RexxContext::setArgs), 1, true); // pass named arguments
779  defineKernelMethod(CHAR_NAMEDARGS ,TheRexxContextBehaviour, CPPM(RexxContext::getNamedArgs), 0);
780  defineKernelMethod(CHAR_CONDITION ,TheRexxContextBehaviour, CPPM(RexxContext::getCondition), 0);
781  defineKernelMethod("LINE" ,TheRexxContextBehaviour, CPPM(RexxContext::getLine), 0);
782  defineKernelMethod("RS" ,TheRexxContextBehaviour, CPPM(RexxContext::getRS), 0);
783  defineKernelMethod(CHAR_NAME ,TheRexxContextBehaviour, CPPM(RexxContext::getName), 0);
784  defineKernelMethod("STACKFRAMES" ,TheRexxContextBehaviour, CPPM(RexxContext::getStackFrames), 0);
785  defineKernelMethod(CHAR_PARENTCONTEXT ,TheRexxContextBehaviour, CPPM(RexxContext::getParentContextObject), 0);
786 
787  /* Add the instance methods to the */
788  /* instance behaviour mdict */
789  /* set the scope of the methods to */
790  /* this classes oref */
791  TheRexxContextBehaviour->setMethodDictionaryScope(TheRexxContextClass);
792 
793  /* Now call the class subclassable */
794  /* method */
795  TheRexxContextClass->subClassable(true);
796  completeSystemClass("REXXCONTEXT", TheRexxContextClass);
797 
798  /***************************************************************************/
799  /* QUEUE */
800  /***************************************************************************/
801 
802  /* Add the NEW method to the class */
803  /* behaviour mdict */
804  defineKernelMethod(CHAR_NEW, TheQueueClassBehaviour, CPPM(RexxQueue::newRexx), A_COUNT);
805  defineKernelMethod(CHAR_OF, TheQueueClassBehaviour, CPPM(RexxQueue::ofRexx), A_COUNT);
806 
807  /* set the scope of the methods to */
808  /* this classes oref */
809  TheQueueClassBehaviour->setMethodDictionaryScope(TheQueueClass);
810 
811  /* Add the instance methods to the */
812  /* instance method mdict */
813 
814  defineKernelMethod(CHAR_MAKEARRAY ,TheQueueBehaviour, CPPM(RexxObject::makeArrayRexx), 0);
815  defineKernelMethod(CHAR_ITEMS ,TheQueueBehaviour, CPPM(RexxList::itemsRexx), 0);
816  defineKernelMethod(CHAR_SUPPLIER ,TheQueueBehaviour, CPPM(RexxQueue::supplier), 0);
817  defineKernelMethod(CHAR_PUSH ,TheQueueBehaviour, CPPM(RexxQueue::pushRexx), 1);
818  defineKernelMethod(CHAR_PEEK ,TheQueueBehaviour, CPPM(RexxQueue::peek), 0);
819  defineKernelMethod(CHAR_PULL ,TheQueueBehaviour, CPPM(RexxQueue::pullRexx), 0);
820  defineKernelMethod(CHAR_QUEUE ,TheQueueBehaviour, CPPM(RexxQueue::queueRexx), 1);
821  defineKernelMethod(CHAR_BRACKETS ,TheQueueBehaviour, CPPM(RexxQueue::at), 1);
822  defineKernelMethod(CHAR_BRACKETSEQUAL ,TheQueueBehaviour, CPPM(RexxQueue::put), 2);
823  defineKernelMethod(CHAR_AT ,TheQueueBehaviour, CPPM(RexxQueue::at), 1);
824  defineKernelMethod(CHAR_HASINDEX ,TheQueueBehaviour, CPPM(RexxQueue::hasindex), 1);
825  defineKernelMethod(CHAR_PUT ,TheQueueBehaviour, CPPM(RexxQueue::put), 2);
826  defineKernelMethod(CHAR_REMOVE ,TheQueueBehaviour, CPPM(RexxQueue::remove), 1);
827  // REMOVE and DELETE are synonyms for the QUEUE class
828  defineKernelMethod(CHAR_DELETE ,TheQueueBehaviour, CPPM(RexxQueue::remove), 1);
829  defineKernelMethod(CHAR_APPEND ,TheQueueBehaviour, CPPM(RexxQueue::append), 1);
830  defineKernelMethod(CHAR_ALLITEMS ,TheQueueBehaviour, CPPM(RexxList::allItems), 0);
831  defineKernelMethod(CHAR_ALLINDEXES ,TheQueueBehaviour, CPPM(RexxQueue::allIndexes), 0);
832  defineKernelMethod(CHAR_EMPTY ,TheQueueBehaviour, CPPM(RexxList::empty), 0);
833  defineKernelMethod(CHAR_ISEMPTY ,TheQueueBehaviour, CPPM(RexxList::isEmpty), 0);
834  defineKernelMethod(CHAR_INDEX ,TheQueueBehaviour, CPPM(RexxQueue::index), 1);
835  defineKernelMethod(CHAR_HASITEM ,TheQueueBehaviour, CPPM(RexxList::hasItem), 1);
836  defineKernelMethod(CHAR_REMOVEITEM ,TheQueueBehaviour, CPPM(RexxList::removeItem), 1);
837  defineKernelMethod(CHAR_FIRST ,TheQueueBehaviour, CPPM(RexxQueue::firstRexx), 0);
838  defineKernelMethod(CHAR_FIRSTITEM ,TheQueueBehaviour, CPPM(RexxList::firstItem), 0);
839  defineKernelMethod(CHAR_LAST ,TheQueueBehaviour, CPPM(RexxQueue::lastRexx), 0);
840  defineKernelMethod(CHAR_LASTITEM ,TheQueueBehaviour, CPPM(RexxList::lastItem), 0);
841  defineKernelMethod(CHAR_NEXT ,TheQueueBehaviour, CPPM(RexxQueue::next), 1);
842  defineKernelMethod(CHAR_PREVIOUS ,TheQueueBehaviour, CPPM(RexxQueue::previous), 1);
843  defineKernelMethod(CHAR_INSERT ,TheQueueBehaviour, CPPM(RexxQueue::insert), 2);
844  defineKernelMethod(CHAR_SECTION ,TheQueueBehaviour, CPPM(RexxQueue::section), 2);
845 
846  /* set the scope of the methods to */
847  /* this classes oref */
848  TheQueueBehaviour->setMethodDictionaryScope(TheQueueClass);
849 
850  /* Now call the class subclassable */
851  /* method */
852  TheQueueClass->subClassable(false);
853  completeSystemClass("QUEUE", TheQueueClass);
854 
855  /***************************************************************************/
856  /* RELATION */
857  /***************************************************************************/
858 
859  /* Add the NEW method to the */
860  /* class behaviour mdict */
861  defineKernelMethod(CHAR_NEW , TheRelationClassBehaviour, CPPM(RexxRelation::newRexx), A_COUNT);
862 
863  /* set the scope of the methods to */
864  /* this classes oref */
865  TheRelationClassBehaviour->setMethodDictionaryScope(TheRelationClass);
866 
867  /* Add the instance methods to the */
868  /* instance behaviour mdict */
869  defineKernelMethod(CHAR_BRACKETS , TheRelationBehaviour, CPPM(RexxHashTableCollection::getRexx), 1);
870  defineKernelMethod(CHAR_BRACKETSEQUAL, TheRelationBehaviour, CPPM(RexxRelation::put), 2);
871  defineKernelMethod(CHAR_ALLAT , TheRelationBehaviour, CPPM(RexxHashTableCollection::allAt), 1);
872  defineKernelMethod(CHAR_ALLINDEX , TheRelationBehaviour, CPPM(RexxRelation::allIndex), 1);
873  defineKernelMethod(CHAR_MAKEARRAY , TheRelationBehaviour, CPPM(RexxObject::makeArrayRexx), 0);
874  defineKernelMethod(CHAR_AT , TheRelationBehaviour, CPPM(RexxHashTableCollection::getRexx), 1);
875  defineKernelMethod(CHAR_HASINDEX , TheRelationBehaviour, CPPM(RexxHashTableCollection::hasIndexRexx), 1);
876  defineKernelMethod(CHAR_HASITEM , TheRelationBehaviour, CPPM(RexxRelation::hasItem), 2);
877  defineKernelMethod(CHAR_INDEX , TheRelationBehaviour, CPPM(RexxHashTableCollection::indexRexx), 1);
878  defineKernelMethod(CHAR_ITEMS , TheRelationBehaviour, CPPM(RexxRelation::itemsRexx), 1);
879  defineKernelMethod(CHAR_PUT , TheRelationBehaviour, CPPM(RexxRelation::put), 2);
880  defineKernelMethod(CHAR_REMOVE , TheRelationBehaviour, CPPM(RexxHashTableCollection::removeRexx), 1);
881  defineKernelMethod(CHAR_REMOVEITEM , TheRelationBehaviour, CPPM(RexxRelation::removeItemRexx), 2);
882  defineKernelMethod(CHAR_SUPPLIER , TheRelationBehaviour, CPPM(RexxRelation::supplier), 1);
883  defineKernelMethod(CHAR_ALLITEMS , TheRelationBehaviour, CPPM(RexxHashTableCollection::allItems), 0);
884  defineKernelMethod(CHAR_ALLINDEXES , TheRelationBehaviour, CPPM(RexxHashTableCollection::allIndexes), 0);
885  defineKernelMethod("UNIQUEINDEXES" , TheRelationBehaviour, CPPM(RexxHashTableCollection::uniqueIndexes), 0);
886  defineKernelMethod(CHAR_EMPTY , TheRelationBehaviour, CPPM(RexxHashTableCollection::empty), 0);
887  defineKernelMethod(CHAR_ISEMPTY , TheRelationBehaviour, CPPM(RexxHashTableCollection::isEmpty), 0);
888  defineKernelMethod("REMOVEALL" , TheRelationBehaviour, CPPM(RexxRelation::removeAll), 1);
889 
890  /* set the scope of the methods to */
891  /* this classes oref */
892  TheRelationBehaviour->setMethodDictionaryScope(TheRelationClass);
893 
894  /* Now call the class subclassable */
895  /* method */
896  TheRelationClass->subClassable(false);
897  completeSystemClass("RELATION", TheRelationClass);
898 
899  /***************************************************************************/
900  /* STEM */
901  /***************************************************************************/
902 
903  /* Add the NEW method to the class */
904  /* behaviour mdict */
905  defineKernelMethod(CHAR_NEW, TheStemClassBehaviour, CPPM(RexxStem::newRexx), A_COUNT);
906  /* set the scope of the methods to */
907  /* this classes oref */
908  TheStemClassBehaviour->setMethodDictionaryScope(TheStemClass);
909 
910  /* Add the instance methods to the */
911  /* instance behaviour mdict */
912  defineKernelMethod(CHAR_BRACKETS ,TheStemBehaviour, CPPM(RexxStem::bracket), A_COUNT);
913  defineKernelMethod(CHAR_BRACKETSEQUAL ,TheStemBehaviour, CPPM(RexxStem::bracketEqual), A_COUNT);
914  defineKernelMethod(CHAR_AT ,TheStemBehaviour, CPPM(RexxStem::bracket), A_COUNT);
915  defineKernelMethod(CHAR_PUT ,TheStemBehaviour, CPPM(RexxStem::bracketEqual), A_COUNT);
916  defineKernelMethod(CHAR_MAKEARRAY ,TheStemBehaviour, CPPM(RexxObject::makeArrayRexx), 0);
917  defineKernelMethod(CHAR_REQUEST ,TheStemBehaviour, CPPM(RexxStem::request), 1);
918  defineKernelMethod(CHAR_SUPPLIER ,TheStemBehaviour, CPPM(RexxStem::supplier), 0);
919  defineKernelMethod(CHAR_ALLINDEXES ,TheStemBehaviour, CPPM(RexxStem::allIndexes), 0);
920  defineKernelMethod(CHAR_ALLITEMS ,TheStemBehaviour, CPPM(RexxStem::allItems), 0);
921  defineKernelMethod(CHAR_EMPTY ,TheStemBehaviour, CPPM(RexxStem::empty), 0);
922  defineKernelMethod(CHAR_ISEMPTY ,TheStemBehaviour, CPPM(RexxStem::isEmpty), 0);
923  defineKernelMethod(CHAR_UNKNOWN ,TheStemBehaviour, CPPM(RexxObject::unknownRexx), 2, true); // pass named arguments
924 
925  defineKernelMethod(CHAR_ITEMS ,TheStemBehaviour, CPPM(RexxStem::itemsRexx), 0);
926  defineKernelMethod(CHAR_HASINDEX ,TheStemBehaviour, CPPM(RexxStem::hasIndex), A_COUNT);
927  defineKernelMethod(CHAR_REMOVE ,TheStemBehaviour, CPPM(RexxStem::remove), A_COUNT);
928  defineKernelMethod(CHAR_INDEX ,TheStemBehaviour, CPPM(RexxStem::index), 1);
929  defineKernelMethod(CHAR_HASITEM ,TheStemBehaviour, CPPM(RexxStem::hasItem), 1);
930  defineKernelMethod(CHAR_REMOVEITEM ,TheStemBehaviour, CPPM(RexxStem::removeItem), 1);
931  defineKernelMethod(CHAR_TODIRECTORY ,TheStemBehaviour, CPPM(RexxStem::toDirectory), 0);
932 
933  /* set the scope of the methods to */
934  /* this classes oref */
935  TheStemBehaviour->setMethodDictionaryScope(TheStemClass);
936 
937  /* delete these methods from stems by*/
938  /* using .nil as the methobj */
939  TheStemBehaviour->define(getGlobalName(CHAR_STRICT_EQUAL) , OREF_NULL);
940  TheStemBehaviour->define(getGlobalName(CHAR_EQUAL) , OREF_NULL);
941  TheStemBehaviour->define(getGlobalName(CHAR_STRICT_BACKSLASH_EQUAL), OREF_NULL);
942  TheStemBehaviour->define(getGlobalName(CHAR_BACKSLASH_EQUAL) , OREF_NULL);
943  TheStemBehaviour->define(getGlobalName(CHAR_LESSTHAN_GREATERTHAN) , OREF_NULL);
944  TheStemBehaviour->define(getGlobalName(CHAR_GREATERTHAN_LESSTHAN) , OREF_NULL);
945 
946  /* Now call the class subclassable */
947  /* method */
948  TheStemClass->subClassable(false);
949  completeSystemClass("STEM", TheStemClass);
950 
951  /***************************************************************************/
952  /* STRING */
953  /***************************************************************************/
954 
955  /* Add the NEW method to the class */
956  /* behaviour mdict */
957  defineKernelMethod(CHAR_NEW, TheStringClassBehaviour, CPPM(RexxString::newRexx), A_COUNT);
958 
959  /* set the scope of the methods to */
960  /* this classes oref */
961  TheStringClassBehaviour->setMethodDictionaryScope(TheStringClass);
962 
963  /* Add the instance methods to the */
964  /* instance behaviour mdict */
965  defineKernelMethod(CHAR_NULLSTRING ,TheStringBehaviour, CPPM(RexxString::concatRexx), 1);
966  defineKernelMethod(CHAR_BLANK ,TheStringBehaviour, CPPM(RexxString::concatBlank), 1);
967  defineKernelMethod(CHAR_CONCATENATE ,TheStringBehaviour, CPPM(RexxString::concatRexx), 1);
968  defineKernelMethod(CHAR_LENGTH ,TheStringBehaviour, CPPM(RexxString::lengthRexx), 0);
969  defineKernelMethod(CHAR_CENTER ,TheStringBehaviour, CPPM(RexxString::center), 2);
970  defineKernelMethod(CHAR_CENTRE ,TheStringBehaviour, CPPM(RexxString::center), 2);
971  defineKernelMethod(CHAR_DATATYPE ,TheStringBehaviour, CPPM(RexxString::dataType), 1);
972  defineKernelMethod(CHAR_DELSTR ,TheStringBehaviour, CPPM(RexxString::delstr), 2);
973  defineKernelMethod(CHAR_FORMAT ,TheStringBehaviour, CPPM(RexxString::format), 4);
974  defineKernelMethod(CHAR_INSERT ,TheStringBehaviour, CPPM(RexxString::insert), 4);
975  defineKernelMethod(CHAR_LEFT ,TheStringBehaviour, CPPM(RexxString::left), 2);
976  defineKernelMethod(CHAR_OVERLAY ,TheStringBehaviour, CPPM(RexxString::overlay), 4);
977  defineKernelMethod(CHAR_REPLACEAT ,TheStringBehaviour, CPPM(RexxString::replaceAt), 4);
978  defineKernelMethod(CHAR_REVERSE ,TheStringBehaviour, CPPM(RexxString::reverse), 0);
979  defineKernelMethod(CHAR_RIGHT ,TheStringBehaviour, CPPM(RexxString::right), 2);
980  defineKernelMethod(CHAR_STRIP ,TheStringBehaviour, CPPM(RexxString::strip), 2);
981  defineKernelMethod(CHAR_SUBSTR ,TheStringBehaviour, CPPM(RexxString::substr), 3);
982  defineKernelMethod(CHAR_SUBCHAR ,TheStringBehaviour, CPPM(RexxString::subchar), 1);
983  defineKernelMethod(CHAR_DELWORD ,TheStringBehaviour, CPPM(RexxString::delWord), 2);
984  defineKernelMethod(CHAR_SPACE ,TheStringBehaviour, CPPM(RexxString::space), 2);
985  defineKernelMethod(CHAR_SUBWORD ,TheStringBehaviour, CPPM(RexxString::subWord), 2);
986  defineKernelMethod("SUBWORDS" ,TheStringBehaviour, CPPM(RexxString::subWords), 2);
987  defineKernelMethod("FLOOR" ,TheStringBehaviour, CPPM(RexxString::floor), 0);
988  defineKernelMethod("CEILING" ,TheStringBehaviour, CPPM(RexxString::ceiling), 0);
989  defineKernelMethod("ROUND" ,TheStringBehaviour, CPPM(RexxString::round), 0);
990  defineKernelMethod(CHAR_TRUNC ,TheStringBehaviour, CPPM(RexxString::trunc), 1);
991  defineKernelMethod(CHAR_WORD ,TheStringBehaviour, CPPM(RexxString::word), 1);
992  defineKernelMethod(CHAR_WORDINDEX ,TheStringBehaviour, CPPM(RexxString::wordIndex), 1);
993  defineKernelMethod(CHAR_WORDLENGTH ,TheStringBehaviour, CPPM(RexxString::wordLength), 1);
994  defineKernelMethod(CHAR_WORDPOS ,TheStringBehaviour, CPPM(RexxString::wordPos), 2);
995  defineKernelMethod(CHAR_CASELESSWORDPOS ,TheStringBehaviour, CPPM(RexxString::caselessWordPos), 2);
996  defineKernelMethod(CHAR_WORDS ,TheStringBehaviour, CPPM(RexxString::words), 0);
997  defineKernelMethod(CHAR_ABBREV ,TheStringBehaviour, CPPM(RexxString::abbrev), 2);
998  defineKernelMethod(CHAR_CASELESSABBREV ,TheStringBehaviour, CPPM(RexxString::caselessAbbrev), 2);
999  defineKernelMethod(CHAR_CHANGESTR ,TheStringBehaviour, CPPM(RexxString::changeStr), 3);
1000  defineKernelMethod(CHAR_CASELESSCHANGESTR ,TheStringBehaviour, CPPM(RexxString::caselessChangeStr), 3);
1001  defineKernelMethod(CHAR_COMPARE ,TheStringBehaviour, CPPM(RexxString::compare), 2);
1002  defineKernelMethod(CHAR_CASELESSCOMPARE ,TheStringBehaviour, CPPM(RexxString::caselessCompare), 2);
1003  defineKernelMethod(CHAR_COPIES ,TheStringBehaviour, CPPM(RexxString::copies), 1);
1004  defineKernelMethod(CHAR_COUNTSTR ,TheStringBehaviour, CPPM(RexxString::countStrRexx), 1);
1005  defineKernelMethod(CHAR_CASELESSCOUNTSTR ,TheStringBehaviour, CPPM(RexxString::caselessCountStrRexx), 1);
1006  defineKernelMethod(CHAR_LASTPOS ,TheStringBehaviour, CPPM(RexxString::lastPosRexx), 3);
1007  defineKernelMethod(CHAR_POS ,TheStringBehaviour, CPPM(RexxString::posRexx), 3);
1008  defineKernelMethod(CHAR_CASELESSLASTPOS ,TheStringBehaviour, CPPM(RexxString::caselessLastPosRexx), 3);
1009  defineKernelMethod(CHAR_CASELESSPOS ,TheStringBehaviour, CPPM(RexxString::caselessPosRexx), 3);
1010  defineKernelMethod(CHAR_TRANSLATE ,TheStringBehaviour, CPPM(RexxString::translate), 5);
1011  defineKernelMethod(CHAR_VERIFY ,TheStringBehaviour, CPPM(RexxString::verify), 4);
1012  defineKernelMethod(CHAR_BITAND ,TheStringBehaviour, CPPM(RexxString::bitAnd), 2);
1013  defineKernelMethod(CHAR_BITOR ,TheStringBehaviour, CPPM(RexxString::bitOr), 2);
1014  defineKernelMethod(CHAR_BITXOR ,TheStringBehaviour, CPPM(RexxString::bitXor), 2);
1015  defineKernelMethod(CHAR_B2X ,TheStringBehaviour, CPPM(RexxString::b2x), 0);
1016  defineKernelMethod(CHAR_C2D ,TheStringBehaviour, CPPM(RexxString::c2d), 1);
1017  defineKernelMethod(CHAR_C2X ,TheStringBehaviour, CPPM(RexxString::c2x), 0);
1018  defineKernelMethod(CHAR_D2C ,TheStringBehaviour, CPPM(RexxString::d2c), 1);
1019  defineKernelMethod(CHAR_D2X ,TheStringBehaviour, CPPM(RexxString::d2x), 1);
1020  defineKernelMethod(CHAR_X2B ,TheStringBehaviour, CPPM(RexxString::x2b), 0);
1021  defineKernelMethod(CHAR_X2C ,TheStringBehaviour, CPPM(RexxString::x2c), 0);
1022  defineKernelMethod(CHAR_X2D ,TheStringBehaviour, CPPM(RexxString::x2d), 1);
1023  defineKernelMethod(CHAR_ENCODEBASE64 ,TheStringBehaviour, CPPM(RexxString::encodeBase64), 0);
1024  defineKernelMethod(CHAR_DECODEBASE64 ,TheStringBehaviour, CPPM(RexxString::decodeBase64), 0);
1025  defineKernelMethod(CHAR_MAKESTRING ,TheStringBehaviour, CPPM(RexxObject::makeStringRexx), 0);
1026  defineKernelMethod(CHAR_ABS ,TheStringBehaviour, CPPM(RexxString::abs), 0);
1027  defineKernelMethod(CHAR_ORXMAX ,TheStringBehaviour, CPPM(RexxString::Max), A_COUNT);
1028  defineKernelMethod(CHAR_ORXMIN ,TheStringBehaviour, CPPM(RexxString::Min), A_COUNT);
1029  defineKernelMethod(CHAR_SIGN ,TheStringBehaviour, CPPM(RexxString::sign), 0);
1030  defineKernelMethod(CHAR_EQUAL ,TheStringBehaviour, CPPM(RexxString::equal), 1);
1031  defineKernelMethod(CHAR_BACKSLASH_EQUAL ,TheStringBehaviour, CPPM(RexxString::notEqual), 1);
1032  defineKernelMethod(CHAR_LESSTHAN_GREATERTHAN ,TheStringBehaviour, CPPM(RexxString::notEqual), 1);
1033  defineKernelMethod(CHAR_GREATERTHAN_LESSTHAN ,TheStringBehaviour, CPPM(RexxString::notEqual), 1);
1034  defineKernelMethod(CHAR_GREATERTHAN ,TheStringBehaviour, CPPM(RexxString::isGreaterThan), 1);
1035  defineKernelMethod(CHAR_LESSTHAN ,TheStringBehaviour, CPPM(RexxString::isLessThan), 1);
1036  defineKernelMethod(CHAR_GREATERTHAN_EQUAL ,TheStringBehaviour, CPPM(RexxString::isGreaterOrEqual), 1);
1037  defineKernelMethod(CHAR_BACKSLASH_LESSTHAN ,TheStringBehaviour, CPPM(RexxString::isGreaterOrEqual), 1);
1038  defineKernelMethod(CHAR_LESSTHAN_EQUAL ,TheStringBehaviour, CPPM(RexxString::isLessOrEqual), 1);
1039  defineKernelMethod(CHAR_BACKSLASH_GREATERTHAN ,TheStringBehaviour, CPPM(RexxString::isLessOrEqual), 1);
1040  defineKernelMethod(CHAR_STRICT_EQUAL ,TheStringBehaviour, CPPM(RexxString::strictEqual), 1);
1041  defineKernelMethod(CHAR_STRICT_BACKSLASH_EQUAL ,TheStringBehaviour, CPPM(RexxString::strictNotEqual), 1);
1042  defineKernelMethod(CHAR_STRICT_GREATERTHAN ,TheStringBehaviour, CPPM(RexxString::strictGreaterThan), 1);
1043  defineKernelMethod(CHAR_STRICT_LESSTHAN ,TheStringBehaviour, CPPM(RexxString::strictLessThan), 1);
1044  defineKernelMethod(CHAR_STRICT_GREATERTHAN_EQUAL ,TheStringBehaviour, CPPM(RexxString::strictGreaterOrEqual), 1);
1045  defineKernelMethod(CHAR_STRICT_BACKSLASH_LESSTHAN ,TheStringBehaviour, CPPM(RexxString::strictGreaterOrEqual), 1);
1046  defineKernelMethod(CHAR_STRICT_LESSTHAN_EQUAL ,TheStringBehaviour, CPPM(RexxString::strictLessOrEqual), 1);
1047  defineKernelMethod(CHAR_STRICT_BACKSLASH_GREATERTHAN ,TheStringBehaviour, CPPM(RexxString::strictLessOrEqual), 1);
1048  defineKernelMethod(CHAR_PLUS ,TheStringBehaviour, CPPM(RexxString::plus), 1);
1049  defineKernelMethod(CHAR_SUBTRACT ,TheStringBehaviour, CPPM(RexxString::minus), 1);
1050  defineKernelMethod(CHAR_MULTIPLY ,TheStringBehaviour, CPPM(RexxString::multiply), 1);
1051  defineKernelMethod(CHAR_POWER ,TheStringBehaviour, CPPM(RexxString::power), 1);
1052  defineKernelMethod(CHAR_DIVIDE ,TheStringBehaviour, CPPM(RexxString::divide), 1);
1053  defineKernelMethod(CHAR_INTDIV ,TheStringBehaviour, CPPM(RexxString::integerDivide), 1);
1054  defineKernelMethod(CHAR_REMAINDER ,TheStringBehaviour, CPPM(RexxString::remainder), 1);
1055  defineKernelMethod(CHAR_BACKSLASH ,TheStringBehaviour, CPPM(RexxString::notOp), 0);
1056  defineKernelMethod(CHAR_AND ,TheStringBehaviour, CPPM(RexxString::andOp), 1);
1057  defineKernelMethod(CHAR_OR ,TheStringBehaviour, CPPM(RexxString::orOp), 1);
1058  defineKernelMethod(CHAR_XOR ,TheStringBehaviour, CPPM(RexxString::xorOp), 1);
1059  defineKernelMethod(CHAR_MAKEARRAY ,TheStringBehaviour, CPPM(RexxString::makeArrayRexx), 1);
1060  defineKernelMethod(CHAR_LOWER ,TheStringBehaviour, CPPM(RexxString::lowerRexx), 2);
1061  defineKernelMethod(CHAR_UPPER ,TheStringBehaviour, CPPM(RexxString::upperRexx), 2);
1062  defineKernelMethod(CHAR_MATCH ,TheStringBehaviour, CPPM(RexxString::match), 4);
1063  defineKernelMethod(CHAR_CASELESSMATCH ,TheStringBehaviour, CPPM(RexxString::caselessMatch), 4);
1064  defineKernelMethod(CHAR_MATCHCHAR ,TheStringBehaviour, CPPM(RexxString::matchChar), 2);
1065  defineKernelMethod(CHAR_CASELESSMATCHCHAR ,TheStringBehaviour, CPPM(RexxString::caselessMatchChar), 2);
1066  defineKernelMethod(CHAR_EQUALS ,TheStringBehaviour, CPPM(RexxString::equals), 1);
1067  defineKernelMethod(CHAR_CASELESSEQUALS ,TheStringBehaviour, CPPM(RexxString::caselessEquals), 1);
1068  defineKernelMethod(CHAR_COMPARETO ,TheStringBehaviour, CPPM(RexxString::compareToRexx), 3);
1069  defineKernelMethod(CHAR_CASELESSCOMPARETO ,TheStringBehaviour, CPPM(RexxString::caselessCompareToRexx), 3);
1070  defineKernelMethod(CHAR_ISASCII ,TheStringBehaviour, CPPM(RexxString::isASCIIRexx), 0);
1071  defineKernelMethod("!SETENCODING" ,TheStringBehaviour, CPPM(RexxString::setEncodingRexx), 1);
1072  defineKernelMethod("!SETTEXT" ,TheStringBehaviour, CPPM(RexxString::setTextRexx), 1);
1073  /* set the scope of the methods to */
1074  /* this classes oref */
1075  TheStringBehaviour->setMethodDictionaryScope(TheStringClass);
1076 
1077  /* Now call the class subclassable */
1078  /* method */
1079  TheStringClass->subClassable(false);
1080  completeSystemClass("STRING", TheStringClass);
1081 
1082 
1083  /***************************************************************************/
1084  /* MUTABLEBUFFER */
1085  /***************************************************************************/
1086 
1087  /* Add the NEW method to the class */
1088  /* behaviour mdict */
1089  defineKernelMethod(CHAR_NEW, TheMutableBufferClassBehaviour, CPPM(RexxMutableBufferClass::newRexx), A_COUNT);
1090 
1091  /* set the scope of the methods to */
1092  /* this classes oref */
1093  TheMutableBufferClassBehaviour->setMethodDictionaryScope(TheMutableBufferClass);
1094 
1095  /* Add the instance methods to the */
1096  /* instance behaviour mdict */
1097  defineKernelMethod(CHAR_APPEND ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::append), 1);
1098  defineKernelMethod(CHAR_INSERT ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::insert), 4);
1099  defineKernelMethod(CHAR_OVERLAY ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::overlay), 4);
1100  defineKernelMethod(CHAR_REPLACEAT ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::replaceAt), 4);
1101  defineKernelMethod(CHAR_DELETE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::mydelete), 2);
1102  defineKernelMethod(CHAR_DELSTR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::mydelete), 2);
1103  defineKernelMethod(CHAR_SUBSTR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::substr), 3);
1104  defineKernelMethod(CHAR_POS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::posRexx), 3);
1105  defineKernelMethod(CHAR_LASTPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::lastPos), 3);
1106  defineKernelMethod(CHAR_CASELESSPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessPos), 3);
1107  defineKernelMethod(CHAR_CASELESSLASTPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessLastPos), 3);
1108  defineKernelMethod(CHAR_SUBCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::subchar), 1);
1109  defineKernelMethod(CHAR_GETBUFFERSIZE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::getBufferSize), 0);
1110  defineKernelMethod(CHAR_SETBUFFERSIZE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::setBufferSize), 1);
1111 
1112  defineKernelMethod(CHAR_LENGTH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::lengthRexx), 0);
1113  defineKernelMethod(CHAR_MAKEARRAY ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::makeArrayRexx), 1);
1114  defineKernelMethod(CHAR_STRING ,TheMutableBufferBehaviour, CPPM(RexxObject::makeStringRexx), 0);
1115  defineKernelMethod(CHAR_COUNTSTR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::countStrRexx), 1);
1116  defineKernelMethod(CHAR_CASELESSCOUNTSTR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessCountStrRexx), 1);
1117  defineKernelMethod(CHAR_CHANGESTR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::changeStr), 3);
1118  defineKernelMethod(CHAR_CASELESSCHANGESTR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessChangeStr), 3);
1119  defineKernelMethod(CHAR_UPPER ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::upper), 2);
1120  defineKernelMethod(CHAR_LOWER ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::lower), 2);
1121  defineKernelMethod(CHAR_TRANSLATE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::translate), 5);
1122  defineKernelMethod(CHAR_MATCH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::match), 4);
1123  defineKernelMethod(CHAR_CASELESSMATCH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatch), 4);
1124  defineKernelMethod(CHAR_MATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::matchChar), 2);
1125  defineKernelMethod(CHAR_CASELESSMATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatchChar), 2);
1126  defineKernelMethod(CHAR_VERIFY ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::verify), 4);
1127  defineKernelMethod(CHAR_SPACE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::space), 2);
1128  defineKernelMethod(CHAR_SUBWORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::subWord), 2);
1129  defineKernelMethod("SUBWORDS" ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::subWords), 2);
1130  defineKernelMethod(CHAR_WORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::word), 1);
1131  defineKernelMethod(CHAR_WORDINDEX ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordIndex), 1);
1132  defineKernelMethod(CHAR_WORDLENGTH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordLength), 1);
1133  defineKernelMethod(CHAR_WORDS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::words), 0);
1134  defineKernelMethod(CHAR_WORDPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordPos), 2);
1135  defineKernelMethod(CHAR_CASELESSWORDPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessWordPos), 2);
1136  defineKernelMethod(CHAR_DELWORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::delWord), 2);
1137  defineKernelMethod(CHAR_ISASCII ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::isASCIIRexx), 0);
1138  defineKernelMethod("!SETENCODING" ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::setEncodingRexx), 1);
1139 
1140  /* set the scope of the methods to */
1141  /* this classes oref */
1142  TheMutableBufferBehaviour->setMethodDictionaryScope(TheMutableBufferClass);
1143  /* Now call the class subclassable */
1144  /* method */
1145  TheMutableBufferClass->subClassable(true);
1146  completeSystemClass("MUTABLEBUFFER", TheMutableBufferClass);
1147 
1148  /***************************************************************************/
1149  /* INTEGER */
1150  /***************************************************************************/
1151 
1152  /* If the integer class was set up correctly it would have the */
1153  /* class_id method in its own class but instead it points to the one */
1154  /* in the string class. .*/
1155 
1156  defineKernelMethod(CHAR_NEW, TheIntegerClassBehaviour, CPPM(RexxString::newRexx), A_COUNT);
1157 
1158  /* set the scope of the methods to */
1159  /* this classes oref */
1160  TheIntegerClassBehaviour->setMethodDictionaryScope(TheIntegerClass);
1161 
1162  /* Add the instance methods to the */
1163  /* instance behaviour mdict */
1164  defineKernelMethod(CHAR_PLUS ,TheIntegerBehaviour, CPPM(RexxInteger::plus), 1);
1165  defineKernelMethod(CHAR_SUBTRACT ,TheIntegerBehaviour, CPPM(RexxInteger::minus), 1);
1166  defineKernelMethod(CHAR_MULTIPLY ,TheIntegerBehaviour, CPPM(RexxInteger::multiply), 1);
1167  defineKernelMethod(CHAR_POWER ,TheIntegerBehaviour, CPPM(RexxInteger::power), 1);
1168  defineKernelMethod(CHAR_DIVIDE ,TheIntegerBehaviour, CPPM(RexxInteger::divide), 1);
1169  defineKernelMethod(CHAR_INTDIV ,TheIntegerBehaviour, CPPM(RexxInteger::integerDivide), 1);
1170  defineKernelMethod(CHAR_REMAINDER ,TheIntegerBehaviour, CPPM(RexxInteger::remainder), 1);
1171  defineKernelMethod(CHAR_BACKSLASH ,TheIntegerBehaviour, CPPM(RexxInteger::notOp), 0);
1172  defineKernelMethod(CHAR_AND ,TheIntegerBehaviour, CPPM(RexxInteger::andOp), 1);
1173  defineKernelMethod(CHAR_OR ,TheIntegerBehaviour, CPPM(RexxInteger::orOp), 1);
1174  defineKernelMethod(CHAR_XOR ,TheIntegerBehaviour, CPPM(RexxInteger::xorOp), 1);
1175  defineKernelMethod(CHAR_UNKNOWN ,TheIntegerBehaviour, CPPM(RexxObject::unknownRexx), 2, true); // pass named arguments
1176  defineKernelMethod(CHAR_D2C ,TheIntegerBehaviour, CPPM(RexxInteger::d2c), 1);
1177  defineKernelMethod(CHAR_D2X ,TheIntegerBehaviour, CPPM(RexxInteger::d2x), 1);
1178  defineKernelMethod(CHAR_ABS ,TheIntegerBehaviour, CPPM(RexxInteger::abs), 0);
1179  defineKernelMethod(CHAR_ORXMAX ,TheIntegerBehaviour, CPPM(RexxInteger::Max), A_COUNT);
1180  defineKernelMethod(CHAR_ORXMIN ,TheIntegerBehaviour, CPPM(RexxInteger::Min), A_COUNT);
1181  defineKernelMethod(CHAR_SIGN ,TheIntegerBehaviour, CPPM(RexxInteger::sign), 0);
1182  defineKernelMethod(CHAR_EQUAL ,TheIntegerBehaviour, CPPM(RexxInteger::equal), 1);
1183  defineKernelMethod(CHAR_BACKSLASH_EQUAL ,TheIntegerBehaviour, CPPM(RexxInteger::notEqual), 1);
1184  defineKernelMethod(CHAR_LESSTHAN_GREATERTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::notEqual), 1);
1185  defineKernelMethod(CHAR_GREATERTHAN_LESSTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::notEqual), 1);
1186  defineKernelMethod(CHAR_GREATERTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::isGreaterThan), 1);
1187  defineKernelMethod(CHAR_LESSTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::isLessThan), 1);
1188  defineKernelMethod(CHAR_GREATERTHAN_EQUAL ,TheIntegerBehaviour, CPPM(RexxInteger::isGreaterOrEqual), 1);
1189  defineKernelMethod(CHAR_BACKSLASH_LESSTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::isGreaterOrEqual), 1);
1190  defineKernelMethod(CHAR_LESSTHAN_EQUAL ,TheIntegerBehaviour, CPPM(RexxInteger::isLessOrEqual), 1);
1191  defineKernelMethod(CHAR_BACKSLASH_GREATERTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::isLessOrEqual), 1);
1192  defineKernelMethod(CHAR_STRICT_EQUAL ,TheIntegerBehaviour, CPPM(RexxInteger::strictEqual), 1);
1193  defineKernelMethod(CHAR_HASHCODE ,TheIntegerBehaviour, CPPM(RexxInteger::hashCode), 1);
1194  defineKernelMethod(CHAR_STRICT_BACKSLASH_EQUAL ,TheIntegerBehaviour, CPPM(RexxInteger::strictNotEqual), 1);
1195  defineKernelMethod(CHAR_STRICT_GREATERTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::strictGreaterThan), 1);
1196  defineKernelMethod(CHAR_STRICT_LESSTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::strictLessThan), 1);
1197  defineKernelMethod(CHAR_STRICT_GREATERTHAN_EQUAL ,TheIntegerBehaviour, CPPM(RexxInteger::strictGreaterOrEqual), 1);
1198  defineKernelMethod(CHAR_STRICT_BACKSLASH_LESSTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::strictGreaterOrEqual), 1);
1199  defineKernelMethod(CHAR_STRICT_LESSTHAN_EQUAL ,TheIntegerBehaviour, CPPM(RexxInteger::strictLessOrEqual), 1);
1200  defineKernelMethod(CHAR_STRICT_BACKSLASH_GREATERTHAN ,TheIntegerBehaviour, CPPM(RexxInteger::strictLessOrEqual), 1);
1201  defineKernelMethod(CHAR_MAKESTRING ,TheIntegerBehaviour, CPPM(RexxObject::makeStringRexx), 0);
1202  defineKernelMethod(CHAR_FORMAT ,TheIntegerBehaviour, CPPM(RexxInteger::format), 4);
1203  defineKernelMethod(CHAR_TRUNC ,TheIntegerBehaviour, CPPM(RexxInteger::trunc), 1);
1204  defineKernelMethod("FLOOR" ,TheIntegerBehaviour, CPPM(RexxInteger::floor), 0);
1205  defineKernelMethod("CEILING" ,TheIntegerBehaviour, CPPM(RexxInteger::ceiling), 0);
1206  defineKernelMethod("ROUND" ,TheIntegerBehaviour, CPPM(RexxInteger::round), 0);
1207  defineKernelMethod(CHAR_CLASS ,TheIntegerBehaviour, CPPM(RexxInteger::classObject), 0);
1208 
1209  /* set the scope of the methods to */
1210  /* this classes oref */
1211  TheIntegerBehaviour->setMethodDictionaryScope(TheIntegerClass);
1212 
1213  /* Now call the class subclassable */
1214  /* method */
1215  TheIntegerClass->subClassable(true);
1216  addToSystem("INTEGER", TheIntegerClass);
1217 
1218  /***************************************************************************/
1219  /* NUMBERSTRING */
1220  /***************************************************************************/
1221 
1222  /* If the numberstring class was set up correctly it should have the */
1223  /* class_id method in its own class but instead it points to the one */
1224  /* in the string class. */
1225 
1226  defineKernelMethod(CHAR_NEW, TheNumberStringClassBehaviour, CPPM(RexxString::newRexx), A_COUNT);
1227 
1228  /* set the scope of the methods to */
1229  /* this classes oref */
1230  TheNumberStringClassBehaviour->setMethodDictionaryScope(TheNumberStringClass);
1231 
1232  /* Add the instance methods to this */
1233  /* instance behaviour mdict */
1234  defineKernelMethod(CHAR_UNKNOWN ,TheNumberStringBehaviour, CPPM(RexxObject::unknownRexx), 2, true); // pass named arguments
1235  defineKernelMethod(CHAR_ABS ,TheNumberStringBehaviour, CPPM(RexxNumberString::abs), 0);
1236  defineKernelMethod(CHAR_ORXMAX ,TheNumberStringBehaviour, CPPM(RexxNumberString::Max), A_COUNT);
1237  defineKernelMethod(CHAR_ORXMIN ,TheNumberStringBehaviour, CPPM(RexxNumberString::Min), A_COUNT);
1238  defineKernelMethod(CHAR_SIGN ,TheNumberStringBehaviour, CPPM(RexxNumberString::Sign), 0);
1239  defineKernelMethod(CHAR_D2C ,TheNumberStringBehaviour, CPPM(RexxNumberString::d2c), 1);
1240  defineKernelMethod(CHAR_D2X ,TheNumberStringBehaviour, CPPM(RexxNumberString::d2x), 1);
1241  defineKernelMethod(CHAR_EQUAL ,TheNumberStringBehaviour, CPPM(RexxNumberString::equal), 1);
1242  defineKernelMethod(CHAR_BACKSLASH_EQUAL ,TheNumberStringBehaviour, CPPM(RexxNumberString::notEqual), 1);
1243  defineKernelMethod(CHAR_LESSTHAN_GREATERTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::notEqual), 1);
1244  defineKernelMethod(CHAR_GREATERTHAN_LESSTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::notEqual), 1);
1245  defineKernelMethod(CHAR_GREATERTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::isGreaterThan), 1);
1246  defineKernelMethod(CHAR_LESSTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::isLessThan), 1);
1247  defineKernelMethod(CHAR_GREATERTHAN_EQUAL ,TheNumberStringBehaviour, CPPM(RexxNumberString::isGreaterOrEqual), 1);
1248  defineKernelMethod(CHAR_BACKSLASH_LESSTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::isGreaterOrEqual), 1);
1249  defineKernelMethod(CHAR_LESSTHAN_EQUAL ,TheNumberStringBehaviour, CPPM(RexxNumberString::isLessOrEqual), 1);
1250  defineKernelMethod(CHAR_BACKSLASH_GREATERTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::isLessOrEqual), 1);
1251  defineKernelMethod(CHAR_STRICT_EQUAL ,TheNumberStringBehaviour, CPPM(RexxNumberString::strictEqual), 1);
1252  defineKernelMethod(CHAR_HASHCODE ,TheNumberStringBehaviour, CPPM(RexxNumberString::hashCode), 0);
1253  defineKernelMethod(CHAR_STRICT_BACKSLASH_EQUAL ,TheNumberStringBehaviour, CPPM(RexxNumberString::strictNotEqual), 1);
1254  defineKernelMethod(CHAR_STRICT_GREATERTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::strictGreaterThan), 1);
1255  defineKernelMethod(CHAR_STRICT_LESSTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::strictLessThan), 1);
1256  defineKernelMethod(CHAR_STRICT_GREATERTHAN_EQUAL ,TheNumberStringBehaviour, CPPM(RexxNumberString::strictGreaterOrEqual), 1);
1257  defineKernelMethod(CHAR_STRICT_BACKSLASH_LESSTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::strictGreaterOrEqual), 1);
1258  defineKernelMethod(CHAR_STRICT_LESSTHAN_EQUAL ,TheNumberStringBehaviour, CPPM(RexxNumberString::strictLessOrEqual), 1);
1259  defineKernelMethod(CHAR_STRICT_BACKSLASH_GREATERTHAN ,TheNumberStringBehaviour, CPPM(RexxNumberString::strictLessOrEqual), 1);
1260  defineKernelMethod(CHAR_PLUS ,TheNumberStringBehaviour, CPPM(RexxNumberString::plus), 1);
1261  defineKernelMethod(CHAR_SUBTRACT ,TheNumberStringBehaviour, CPPM(RexxNumberString::minus), 1);
1262  defineKernelMethod(CHAR_MULTIPLY ,TheNumberStringBehaviour, CPPM(RexxNumberString::multiply), 1);
1263  defineKernelMethod(CHAR_POWER ,TheNumberStringBehaviour, CPPM(RexxNumberString::power), 1);
1264  defineKernelMethod(CHAR_DIVIDE ,TheNumberStringBehaviour, CPPM(RexxNumberString::divide), 1);
1265  defineKernelMethod(CHAR_INTDIV ,TheNumberStringBehaviour, CPPM(RexxNumberString::integerDivide), 1);
1266  defineKernelMethod(CHAR_REMAINDER ,TheNumberStringBehaviour, CPPM(RexxNumberString::remainder), 1);
1267  defineKernelMethod(CHAR_BACKSLASH ,TheNumberStringBehaviour, CPPM(RexxNumberString::notOp), 0);
1268  defineKernelMethod(CHAR_AND ,TheNumberStringBehaviour, CPPM(RexxNumberString::andOp), 1);
1269  defineKernelMethod(CHAR_OR ,TheNumberStringBehaviour, CPPM(RexxNumberString::orOp), 1);
1270  defineKernelMethod(CHAR_XOR ,TheNumberStringBehaviour, CPPM(RexxNumberString::xorOp), 1);
1271  defineKernelMethod(CHAR_MAKESTRING ,TheNumberStringBehaviour, CPPM(RexxObject::makeStringRexx), 0);
1272  defineKernelMethod(CHAR_FORMAT ,TheNumberStringBehaviour, CPPM(RexxNumberString::formatRexx), 4);
1273  defineKernelMethod(CHAR_TRUNC ,TheNumberStringBehaviour, CPPM(RexxNumberString::trunc), 1);
1274  defineKernelMethod("FLOOR" ,TheNumberStringBehaviour, CPPM(RexxNumberString::floor), 0);
1275  defineKernelMethod("CEILING" ,TheNumberStringBehaviour, CPPM(RexxNumberString::ceiling), 0);
1276  defineKernelMethod("ROUND" ,TheNumberStringBehaviour, CPPM(RexxNumberString::round), 0);
1277  defineKernelMethod(CHAR_CLASS ,TheNumberStringBehaviour, CPPM(RexxNumberString::classObject), 0);
1278 
1279  /* set the scope of the methods to */
1280  /* this classes oref */
1281  TheNumberStringBehaviour->setMethodDictionaryScope(TheNumberStringClass);
1282 
1283  /* Now call the class subclassable */
1284  /* method */
1285  TheNumberStringClass->subClassable(true);
1286  addToSystem("NUMBERSTRING", TheNumberStringClass);
1287 
1288 
1289  /***************************************************************************/
1290  /* SUPPLIER */
1291  /***************************************************************************/
1292  /* Add the NEW methods to the class */
1293  /* behaviour mdict */
1294  defineKernelMethod(CHAR_NEW, TheSupplierClassBehaviour, CPPM(RexxSupplierClass::newRexx), A_COUNT);
1295  /* set the scope of the methods to */
1296  /* this classes oref */
1297  TheSupplierClassBehaviour->setMethodDictionaryScope(TheSupplierClass);
1298 
1299 
1300  /* Add the instance methods to the */
1301  /* instance behaviour mdict */
1302 
1303  defineKernelMethod(CHAR_AVAILABLE ,TheSupplierBehaviour, CPPM(RexxSupplier::available), 0);
1304  defineKernelMethod(CHAR_INDEX ,TheSupplierBehaviour, CPPM(RexxSupplier::index), 0);
1305  defineKernelMethod(CHAR_NEXT ,TheSupplierBehaviour, CPPM(RexxSupplier::next), 0);
1306  defineKernelMethod(CHAR_ITEM ,TheSupplierBehaviour, CPPM(RexxSupplier::value), 0);
1307  defineKernelMethod(CHAR_INIT ,TheSupplierBehaviour, CPPM(RexxSupplier::initRexx), 2);
1308 
1309  /* set the scope of the methods to */
1310  /* this classes oref */
1311  TheSupplierBehaviour->setMethodDictionaryScope(TheSupplierClass);
1312 
1313  /* Now call the class subclassable */
1314  /* method */
1315  TheSupplierClass->subClassable(false);
1316  completeSystemClass("SUPPLIER", TheSupplierClass);
1317 
1318  /***************************************************************************/
1319  /* TABLE */
1320  /***************************************************************************/
1321 
1322  /* Add the NEW methods to the class */
1323  /* behaviour mdict */
1324  defineKernelMethod(CHAR_NEW , TheTableClassBehaviour, CPPM(RexxTable::newRexx), A_COUNT);
1325 
1326  /* set the scope of the methods to */
1327  /* this classes oref */
1328  TheTableClassBehaviour->setMethodDictionaryScope(TheTableClass);
1329 
1330  /* Add the instance methods to the */
1331  /* instance behaviour mdict */
1332  defineKernelMethod(CHAR_BRACKETS , TheTableBehaviour, CPPM(RexxHashTableCollection::getRexx), 1);
1333  defineKernelMethod(CHAR_BRACKETSEQUAL, TheTableBehaviour, CPPM(RexxHashTableCollection::putRexx), 2);
1334  defineKernelMethod(CHAR_MAKEARRAY , TheTableBehaviour, CPPM(RexxObject::makeArrayRexx), 0);
1335  defineKernelMethod(CHAR_AT , TheTableBehaviour, CPPM(RexxHashTableCollection::getRexx), 1);
1336  defineKernelMethod(CHAR_HASINDEX , TheTableBehaviour, CPPM(RexxHashTableCollection::hasIndexRexx), 1);
1337  defineKernelMethod(CHAR_ITEMS , TheTableBehaviour, CPPM(RexxTable::itemsRexx), 0);
1338  defineKernelMethod(CHAR_PUT , TheTableBehaviour, CPPM(RexxHashTableCollection::putRexx), 2);
1339  defineKernelMethod(CHAR_REMOVE , TheTableBehaviour, CPPM(RexxHashTableCollection::removeRexx), 1);
1340  defineKernelMethod(CHAR_SUPPLIER , TheTableBehaviour, CPPM(RexxHashTableCollection::supplier), 0);
1341  defineKernelMethod(CHAR_ALLITEMS , TheTableBehaviour, CPPM(RexxHashTableCollection::allItems), 0);
1342  defineKernelMethod(CHAR_ALLINDEXES , TheTableBehaviour, CPPM(RexxHashTableCollection::allIndexes), 0);
1343  defineKernelMethod(CHAR_EMPTY , TheTableBehaviour, CPPM(RexxHashTableCollection::empty), 0);
1344  defineKernelMethod(CHAR_ISEMPTY , TheTableBehaviour, CPPM(RexxHashTableCollection::isEmpty), 0);
1345  defineKernelMethod(CHAR_INDEX , TheTableBehaviour, CPPM(RexxHashTableCollection::indexRexx), 1);
1346  defineKernelMethod(CHAR_HASITEM , TheTableBehaviour, CPPM(RexxHashTableCollection::hasItemRexx), 1);
1347  defineKernelMethod(CHAR_REMOVEITEM , TheTableBehaviour, CPPM(RexxHashTableCollection::removeItemRexx), 1);
1348 
1349  /* set the scope of the methods to */
1350  /* this classes oref */
1351  TheTableBehaviour->setMethodDictionaryScope(TheTableClass);
1352 
1353  /* Now call the class subclassable */
1354  /* method */
1355  TheTableClass->subClassable(false);
1356  completeSystemClass("TABLE", TheTableClass);
1357 
1358  /***************************************************************************/
1359  /* IDENTITYTABLE */
1360  /***************************************************************************/
1361 
1362  /* Add the NEW methods to the class */
1363  /* behaviour mdict */
1364  defineKernelMethod(CHAR_NEW , TheIdentityTableClassBehaviour, CPPM(RexxIdentityTable::newRexx), A_COUNT);
1365 
1366  /* set the scope of the methods to */
1367  /* this classes oref */
1368  TheIdentityTableClassBehaviour->setMethodDictionaryScope(TheIdentityTableClass);
1369 
1370  /* Add the instance methods to the */
1371  /* instance behaviour mdict */
1372  defineKernelMethod(CHAR_BRACKETS , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::getRexx), 1);
1373  defineKernelMethod(CHAR_BRACKETSEQUAL, TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::putRexx), 2);
1374  defineKernelMethod(CHAR_MAKEARRAY , TheIdentityTableBehaviour, CPPM(RexxObject::makeArrayRexx), 0);
1375  defineKernelMethod(CHAR_AT , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::getRexx), 1);
1376  defineKernelMethod(CHAR_HASINDEX , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::hasIndexRexx), 1);
1377  defineKernelMethod(CHAR_ITEMS , TheIdentityTableBehaviour, CPPM(RexxTable::itemsRexx), 0);
1378  defineKernelMethod(CHAR_PUT , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::putRexx), 2);
1379  defineKernelMethod(CHAR_REMOVE , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::removeRexx), 1);
1380  defineKernelMethod(CHAR_SUPPLIER , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::supplier), 0);
1381  defineKernelMethod(CHAR_ALLITEMS , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::allItems), 0);
1382  defineKernelMethod(CHAR_ALLINDEXES , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::allIndexes), 0);
1383  defineKernelMethod(CHAR_EMPTY , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::empty), 0);
1384  defineKernelMethod(CHAR_ISEMPTY , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::isEmpty), 0);
1385  defineKernelMethod(CHAR_INDEX , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::indexRexx), 1);
1386  defineKernelMethod(CHAR_HASITEM , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::hasItemRexx), 1);
1387  defineKernelMethod(CHAR_REMOVEITEM , TheIdentityTableBehaviour, CPPM(RexxHashTableCollection::removeItemRexx), 1);
1388 
1389  /* set the scope of the methods to */
1390  /* this classes oref */
1391  TheIdentityTableBehaviour->setMethodDictionaryScope(TheIdentityTableClass);
1392 
1393  /* Now call the class subclassable */
1394  /* method */
1395  TheIdentityTableClass->subClassable(false);
1396  completeSystemClass("IDENTITYTABLE", TheIdentityTableClass);
1397 
1398 
1399  /***************************************************************************/
1400  /* POINTER */
1401  /***************************************************************************/
1402  /* Add the NEW methods to the class */
1403  /* behaviour mdict */
1404  defineKernelMethod(CHAR_NEW, ThePointerClassBehaviour, CPPM(RexxPointer::newRexx), A_COUNT);
1405  /* set the scope of the methods to */
1406  /* this classes oref */
1407  ThePointerClassBehaviour->setMethodDictionaryScope(ThePointerClass);
1408 
1409 
1410  /* Add the instance methods to the */
1411  /* instance behaviour mdict */
1412  defineKernelMethod(CHAR_EQUAL ,ThePointerBehaviour, CPPM(RexxPointer::equal), 1);
1413  defineKernelMethod(CHAR_BACKSLASH_EQUAL ,ThePointerBehaviour, CPPM(RexxPointer::notEqual), 1);
1414  defineKernelMethod(CHAR_STRICT_EQUAL ,ThePointerBehaviour, CPPM(RexxPointer::equal), 1);
1415  defineKernelMethod(CHAR_STRICT_BACKSLASH_EQUAL ,ThePointerBehaviour, CPPM(RexxPointer::notEqual), 1);
1416  defineKernelMethod(CHAR_ISNULL ,ThePointerBehaviour, CPPM(RexxPointer::isNull), 0);
1417 
1418  /* set the scope of the methods to */
1419  /* this classes oref */
1420  ThePointerBehaviour->setMethodDictionaryScope(ThePointerClass);
1421 
1422  /* Now call the class subclassable */
1423  /* method */
1424  ThePointerClass->subClassable(false);
1425  completeSystemClass("POINTER", ThePointerClass);
1426 
1427 
1428  /***************************************************************************/
1429  /* BUFFER */
1430  /***************************************************************************/
1431  /* Add the NEW methods to the class */
1432  /* behaviour mdict */
1433  defineKernelMethod(CHAR_NEW, TheBufferClassBehaviour, CPPM(RexxBuffer::newRexx), A_COUNT);
1434  /* set the scope of the methods to */
1435  /* this classes oref */
1436  TheBufferClassBehaviour->setMethodDictionaryScope(TheBufferClass);
1437 
1438 
1439  /* Add the instance methods to the */
1440  /* instance behaviour mdict */
1441 
1442  // NO instance methods on buffer
1443 
1444  /* set the scope of the methods to */
1445  /* this classes oref */
1446  TheBufferBehaviour->setMethodDictionaryScope(TheBufferClass);
1447 
1448  /* Now call the class subclassable */
1449  /* method */
1450  TheBufferClass->subClassable(false);
1451  completeSystemClass("BUFFER", TheBufferClass);
1452 
1453 
1454  /***************************************************************************/
1455  /* WEAKREFERENCE */
1456  /***************************************************************************/
1457  /* Add the NEW methods to the class */
1458  /* behaviour mdict */
1459  defineKernelMethod(CHAR_NEW, TheWeakReferenceClassBehaviour, CPPM(WeakReference::newRexx), A_COUNT);
1460  /* set the scope of the methods to */
1461  /* this classes oref */
1462  TheWeakReferenceClassBehaviour->setMethodDictionaryScope(TheWeakReferenceClass);
1463 
1464 
1465  /* Add the instance methods to the */
1466  /* instance behaviour mdict */
1467  defineKernelMethod(CHAR_VALUE ,TheWeakReferenceBehaviour, CPPM(WeakReference::value), 0);
1468  /* set the scope of the methods to */
1469  /* this classes oref */
1470  TheWeakReferenceBehaviour->setMethodDictionaryScope(TheWeakReferenceClass);
1471 
1472  /* Now call the class subclassable */
1473  /* method */
1474  TheWeakReferenceClass->subClassable(false);
1475  completeSystemClass("WEAKREFERENCE", TheWeakReferenceClass);
1476 
1477 
1478  /***************************************************************************/
1479  /* STACKFRAME */
1480  /***************************************************************************/
1481  /* Add the NEW methods to the class */
1482  /* behaviour mdict */
1483  defineKernelMethod(CHAR_NEW, TheStackFrameClassBehaviour, CPPM(StackFrameClass::newRexx), A_COUNT);
1484  /* set the scope of the methods to */
1485  /* this classes oref */
1486  TheStackFrameClassBehaviour->setMethodDictionaryScope(TheStackFrameClass);
1487 
1488 
1489  /* Add the instance methods to the */
1490  /* instance behaviour mdict */
1491  defineKernelMethod("NAME", TheStackFrameBehaviour, CPPM(StackFrameClass::getName), 0);
1492  defineKernelMethod("EXECUTABLE", TheStackFrameBehaviour, CPPM(StackFrameClass::getExecutable), 0);
1493  defineKernelMethod("LINE", TheStackFrameBehaviour, CPPM(StackFrameClass::getLine), 0);
1494  defineKernelMethod("TARGET", TheStackFrameBehaviour, CPPM(StackFrameClass::getTarget), 0);
1495  defineKernelMethod("TRACELINE", TheStackFrameBehaviour, CPPM(StackFrameClass::getTraceLine), 0);
1496  defineKernelMethod("TYPE", TheStackFrameBehaviour, CPPM(StackFrameClass::getType), 0);
1497  defineKernelMethod("ARGUMENTS", TheStackFrameBehaviour, CPPM(StackFrameClass::getArguments), 0);
1498  // the string method just maps to TRACELINE
1499  defineKernelMethod("STRING", TheStackFrameBehaviour, CPPM(StackFrameClass::getTraceLine), 0);
1500  defineKernelMethod("MAKESTRING", TheStackFrameBehaviour, CPPM(StackFrameClass::getTraceLine), 0);
1501 
1502  /* set the scope of the methods to */
1503  /* this classes oref */
1504  TheStackFrameBehaviour->setMethodDictionaryScope(TheStackFrameClass);
1505 
1506  /* Now call the class subclassable */
1507  /* method */
1508  TheStackFrameClass->subClassable(false);
1509  completeSystemClass("STACKFRAME", TheStackFrameClass);
1510 
1511  /***************************************************************************/
1512  /* RexxBlock */
1513  /***************************************************************************/
1514 
1515  /* Add the NEW methods to the */
1516  /* class behaviour */
1517  defineKernelMethod(CHAR_NEW ,TheRexxBlockClassBehaviour, CPPM(RexxBlock::newRexx), A_COUNT);
1518  /* set the scope of the methods to */
1519  /* this classes oref */
1520  TheRexxBlockClassBehaviour->setMethodDictionaryScope(TheRexxBlockClass);
1521 
1522  defineKernelMethod(CHAR_COPY ,TheRexxBlockBehaviour, CPPM(RexxBlock::copyRexx), 0);
1523  defineKernelMethod(CHAR_SOURCE ,TheRexxBlockBehaviour, CPPM(RexxBlock::getSource), 0);
1524  defineKernelMethod(CHAR_PACKAGE ,TheRexxBlockBehaviour, CPPM(RexxBlock::getPackage), 0);
1525  defineKernelMethod(CHAR_VARIABLES ,TheRexxBlockBehaviour, CPPM(RexxBlock::getVariables), 0);
1526  defineKernelMethod(CHAR_KIND ,TheRexxBlockBehaviour, CPPM(RexxBlock::getKind), 0);
1527  defineKernelMethod(CHAR_RAWEXECUTABLE ,TheRexxBlockBehaviour, CPPM(RexxBlock::getRawExecutable), 0);
1528 
1529  /* Add the instance methods to the */
1530  /* instance behaviour mdict */
1531  /* set the scope of the methods to */
1532  /* this classes oref */
1533  TheRexxBlockBehaviour->setMethodDictionaryScope(TheRexxBlockClass);
1534 
1535  /* Now call the class subclassable */
1536  /* method */
1537  TheRexxBlockClass->subClassable(true);
1538  completeSystemClass("REXXBLOCK", TheRexxBlockClass);
1539 
1540  /***************************************************************************/
1541  /* RexxText */
1542  /***************************************************************************/
1543 
1544  defineKernelMethod(CHAR_NEW, TheRexxTextClassBehaviour, CPPM(RexxText::newRexx), A_COUNT);
1545  /* set the scope of the methods to */
1546  /* this classes oref */
1547  TheRexxTextClassBehaviour->setMethodDictionaryScope(TheRexxTextClass);
1548 
1549  /* set the scope of the methods to */
1550  /* this classes oref */
1551  TheRexxTextBehaviour->setMethodDictionaryScope(TheRexxTextClass);
1552 
1553  /* Now call the class subclassable */
1554  /* method */
1555  TheRexxTextClass->subClassable(true);
1556  completeSystemClass("REXXTEXT", TheRexxTextClass);
1557 
1558  /***************************************************************************/
1559  /* Unicode */
1560  /***************************************************************************/
1561 
1562  defineKernelMethod(CHAR_NEW , TheUnicodeClassBehaviour, CPPM(Unicode::newRexx), A_COUNT);
1563  defineKernelMethod(CHAR_COPY , TheUnicodeClassBehaviour, CPPM(Unicode::copyRexx), 0);
1564  defineKernelMethod("SYSTEMISLITTLEENDIAN" , TheUnicodeClassBehaviour, CPPM(Unicode::systemIsLittleEndian), 0);
1565 
1566  defineKernelMethod("UTF8PROC_VERSION" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_version), 0);
1567  defineKernelMethod("UTF8PROC_GRAPHEMEBREAK" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_graphemeBreak), 1);
1568  defineKernelMethod("UTF8PROC_CODEPOINTCATEGORY" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointCategory), 1);
1569  defineKernelMethod("UTF8PROC_CODEPOINTCOMBININGCLASS" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointCombiningClass), 1);
1570  defineKernelMethod("UTF8PROC_CODEPOINTBIDICLASS" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointBidiClass), 1);
1571  defineKernelMethod("UTF8PROC_CODEPOINTBIDIMIRRORED" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointBidiMirrored), 1);
1572  defineKernelMethod("UTF8PROC_CODEPOINTDECOMPOSITIONTYPE" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointDecompositionType), 1);
1573  defineKernelMethod("UTF8PROC_CODEPOINTIGNORABLE" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointIgnorable), 1);
1574  defineKernelMethod("UTF8PROC_CODEPOINTCONTROLBOUNDARY" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointControlBoundary), 1);
1575  defineKernelMethod("UTF8PROC_CODEPOINTCHARWIDTH" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointCharWidth), 1);
1576  defineKernelMethod("UTF8PROC_CODEPOINTBOUNDCLASS" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointBoundClass), 1);
1577  defineKernelMethod("UTF8PROC_CODEPOINTTOLOWERSIMPLE" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointToLowerSimple), 1);
1578  defineKernelMethod("UTF8PROC_CODEPOINTTOUPPERSIMPLE" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointToUpperSimple), 1);
1579  defineKernelMethod("UTF8PROC_CODEPOINTTOTITLESIMPLE" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointToTitleSimple), 1);
1580  defineKernelMethod("UTF8PROC_CODEPOINTISLOWER" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointIsLower), 1);
1581  defineKernelMethod("UTF8PROC_CODEPOINTISUPPER" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_codepointIsUpper), 1);
1582  defineKernelMethod("UTF8PROC_TRANSFORM" , TheUnicodeClassBehaviour, CPPM(Unicode::utf8proc_transform), 1, true); // pass named arguments
1583 
1584  defineKernelMethod("UNIALGO_VERSION" , TheUnicodeClassBehaviour, CPPM(Unicode::unialgo_version), 0);
1585 
1586  /* set the scope of the methods to */
1587  /* this classes oref */
1588  TheUnicodeClassBehaviour->setMethodDictionaryScope(TheUnicodeClass);
1589 
1590  /* set the scope of the methods to */
1591  /* this classes oref */
1592  TheUnicodeBehaviour->setMethodDictionaryScope(TheUnicodeClass);
1593 
1594  /* Now call the class subclassable */
1595  /* method */
1596  TheUnicodeClass->subClassable(true);
1597  completeSystemClass("UNICODE", TheUnicodeClass);
1598 
1599 
1600  /***************************************************************************/
1601  /***************************************************************************/
1602  /***************************************************************************/
1603  /* These classes don't have any class methods */
1604  /* and are not subclassed from object */
1605 
1606 #define kernel_public(name, object, dir) ((RexxDirectory *)dir)->setEntry(getGlobalName(name), (RexxObject *)object)
1607 
1608  /* put the kernel-provided public objects in the environment directory */
1609  kernel_public(CHAR_ARRAY ,TheArrayClass ,TheEnvironment);
1610  kernel_public(CHAR_CLASS ,TheClassClass ,TheEnvironment);
1611  kernel_public(CHAR_DIRECTORY ,TheDirectoryClass ,TheEnvironment);
1612  kernel_public(CHAR_ENVIRONMENT ,TheEnvironment ,TheEnvironment);
1613  kernel_public(CHAR_FALSE ,TheFalseObject ,TheEnvironment);
1614  kernel_public(CHAR_KERNEL ,TheKernel ,TheEnvironment);
1615  kernel_public("GLOBALROUTINES" ,TheFunctionsDirectory ,TheEnvironment); // jlf: give direct access to TheFunctionsDirectory. Later, TheKernel will be removed from TheEnvironment.
1616  kernel_public(CHAR_LIST ,TheListClass ,TheEnvironment);
1617  kernel_public(CHAR_MESSAGE ,TheMessageClass ,TheEnvironment);
1618  kernel_public(CHAR_METHOD ,TheMethodClass ,TheEnvironment);
1619  kernel_public(CHAR_ROUTINE ,TheRoutineClass ,TheEnvironment);
1620  kernel_public(CHAR_PACKAGE ,ThePackageClass ,TheEnvironment);
1621  kernel_public(CHAR_REXXCONTEXT ,TheRexxContextClass ,TheEnvironment);
1622  kernel_public(CHAR_REXXBLOCK ,TheRexxBlockClass ,TheEnvironment);
1623  kernel_public(CHAR_REXXTEXT ,TheRexxTextClass ,TheEnvironment);
1624  kernel_public(CHAR_UNICODE ,TheUnicodeClass ,TheEnvironment);
1625  kernel_public(CHAR_NIL ,TheNilObject ,TheEnvironment);
1626  kernel_public(CHAR_OBJECT ,TheObjectClass ,TheEnvironment);
1627  kernel_public(CHAR_QUEUE ,TheQueueClass ,TheEnvironment);
1628  kernel_public(CHAR_RELATION ,TheRelationClass,TheEnvironment);
1629  kernel_public(CHAR_STRING ,TheStringClass ,TheEnvironment);
1630  kernel_public(CHAR_MUTABLEBUFFER ,TheMutableBufferClass ,TheEnvironment);
1631  kernel_public(CHAR_STEM ,TheStemClass ,TheEnvironment);
1632  kernel_public(CHAR_SUPPLIER ,TheSupplierClass,TheEnvironment);
1633  //kernel_public(CHAR_SYSTEM ,TheSystem ,TheEnvironment); // jlf: not sure what's the purpose of this entry... The infos in this directory are totally wrong for MacOs
1634  kernel_public(CHAR_TABLE ,TheTableClass ,TheEnvironment);
1635  kernel_public(CHAR_IDENTITYTABLE ,TheIdentityTableClass,TheEnvironment);
1636  kernel_public(CHAR_POINTER ,ThePointerClass ,TheEnvironment);
1637  //kernel_public(CHAR_BUFFER ,TheBufferClass ,TheEnvironment); // jlf: not sure why this class is declared in TheEnvironment... This class is used only internally for the API (see RexxObject::getCSelf)
1638  kernel_public(CHAR_WEAKREFERENCE ,TheWeakReferenceClass ,TheEnvironment);
1639  kernel_public("STACKFRAME" ,TheStackFrameClass ,TheEnvironment);
1640  kernel_public(CHAR_TRUE ,TheTrueObject ,TheEnvironment);
1641 
1642  /* set up the kernel directory (MEMORY done elsewhere) */
1643  kernel_public(CHAR_INTEGER ,TheIntegerClass , TheKernel);
1644  kernel_public(CHAR_NUMBERSTRING ,TheNumberStringClass, TheKernel);
1645 
1646  // TODO: Make the kernel directory part of the memory object, but not in the
1647  // environment.
1648 
1649  kernel_public(CHAR_FUNCTIONS ,TheFunctionsDirectory ,TheKernel);
1650  kernel_public(CHAR_NULLARRAY ,TheNullArray ,TheKernel);
1651  kernel_public(CHAR_NULLPOINTER ,TheNullPointer ,TheKernel);
1652  kernel_public(CHAR_COMMON_RETRIEVERS,TheCommonRetrievers ,TheKernel);
1653  kernel_public(CHAR_ENVIRONMENT ,TheEnvironment ,TheKernel);
1654 
1655  /* set Oryx version */
1656  kernel_public(CHAR_VERSION, Interpreter::getVersionNumber(), TheKernel);
1657  /* set the system name */
1658 #if 0 // jlf deactivate because GetVersionEx API deprecated on Windows
1659  kernel_public(CHAR_NAME, SystemInterpreter::getSystemName(), TheSystem);
1660  /* set the internal system name */
1661  kernel_public(CHAR_INTERNALNAME, SystemInterpreter::getInternalSystemName(), TheSystem);
1662  /* and the system version info */
1663  kernel_public(CHAR_VERSION, SystemInterpreter::getSystemVersion(), TheSystem);
1664 #endif
1665  // initialize our thread vector for external calls.
1666  RexxActivity::initializeThreadContext();
1667 
1668 /******************************************************************************/
1669 /* Complete the image build process, calling BaseClasses to establish */
1670 /* the rest of the REXX image. */
1671 /******************************************************************************/
1672 
1673  /* set up the kernel methods that will be defined on OBJECT classes in */
1674  /* BaseClasses.ORX and ORYXJ.ORX. */
1675  {
1676  /* create a kernel methods directory */
1677  RexxDirectory *kernel_methods = new_directory();
1678  ProtectedObject p1(kernel_methods); // protect from GC
1679  kernel_methods->put(new RexxMethod(getGlobalName(CHAR_LOCAL), CPPCode::resolveExportedMethod(CHAR_LOCAL, CPPM(RexxLocal::local), 0, false)), getGlobalName(CHAR_LOCAL));
1680 
1681  /* create the BaseClasses method and run it*/
1682  RexxString *symb = getGlobalName(BASEIMAGELOAD); /* get a name version of the string */
1683  /* go resolve the program name */
1684  RexxString *programName = ActivityManager::currentActivity->resolveProgramName(symb, OREF_NULL, OREF_NULL);
1685  // create a new stack frame to run under
1686  ActivityManager::currentActivity->createNewActivationStack();
1687  try
1688  {
1689  /* create a method object out of this*/
1690  RoutineClass *loader = new RoutineClass(programName);
1691 
1692 
1693  // RexxObject *args = kernel_methods; // temporary to avoid type-punning warnings
1694  RexxObject *args[2];
1695  args[0] = kernel_methods; // 1st positional argument
1696  // we pass the internal Rexx package as an argument to the setup program.
1697  args[1] = TheRexxPackage; // ooRexx5
1698  ProtectedObject result;
1699  /* now call BaseClasses to finish the image*/
1700  loader->runProgram(ActivityManager::currentActivity, OREF_PROGRAM, OREF_NULL, (RexxObject **)&args, 2, 0, result);
1701  }
1702  catch (ActivityException )
1703  {
1704  ActivityManager::currentActivity->error(); /* do error cleanup */
1705  Interpreter::logicError("Error building kernel image. Image not saved.");
1706  }
1707 
1708  }
1709 
1710  // TheRexxPackage has no classes after RESTORINGIMAGE
1711  // Don't know why... Here, it has classes.
1712  RexxDirectory *classes = TheRexxPackage->getClasses();
1713  printf("********** TheRexxPackage classes=%zu\n", classes->items());
1714 
1715  /* define and suppress methods in the nil object */
1716  TheNilObject->defMethod(getGlobalName(CHAR_COPY), (RexxMethod *)TheNilObject);
1717  TheNilObject->defMethod(getGlobalName(CHAR_START), (RexxMethod *)TheNilObject);
1718  TheNilObject->defMethod(getGlobalName(CHAR_OBJECTNAMEEQUALS), (RexxMethod *)TheNilObject);
1719 
1720  // ok, .NIL has been constructed. As a last step before saving the image, we need to change
1721  // the type identifier in the behaviour so that this will get the correct virtual function table
1722  // restored when the image reloads.
1723  TheNilObject->behaviour->setClassType(T_NilObject);
1724 
1725  RexxClass *ordered = (RexxClass *)TheEnvironment->get(getGlobalName(CHAR_ORDEREDCOLLECTION));
1726 
1727  TheArrayClass->inherit(ordered, OREF_NULL);
1728  TheArrayClass->setRexxDefined();
1729 
1730  TheQueueClass->inherit(ordered, OREF_NULL);
1731  TheQueueClass->setRexxDefined();
1732 
1733  TheListClass->inherit(ordered, OREF_NULL);
1734  TheListClass->setRexxDefined();
1735 
1736  RexxClass *map = (RexxClass *)TheEnvironment->get(getGlobalName(CHAR_MAPCOLLECTION));
1737 
1738  TheTableClass->inherit(map, OREF_NULL);
1739  TheTableClass->setRexxDefined();
1740 
1741  TheIdentityTableClass->inherit(map, OREF_NULL);
1742  TheIdentityTableClass->setRexxDefined();
1743 
1744  TheRelationClass->inherit(map, OREF_NULL);
1745  TheRelationClass->setRexxDefined();
1746 
1747  TheDirectoryClass->inherit(map, OREF_NULL);
1748  TheDirectoryClass->setRexxDefined();
1749 
1750  TheStemClass->inherit(map, OREF_NULL);
1751  TheStemClass->setRexxDefined();
1752 
1753  RexxClass *comparable = (RexxClass *)TheEnvironment->get(getGlobalName(CHAR_COMPARABLE));
1754 
1755  TheStringClass->inherit(comparable, OREF_NULL);
1756  TheStringClass->setRexxDefined();
1757 
1758  // disable the special class methods we only use during the image build phase.
1759  // this removes this from all of the subclasses as well
1760  TheObjectClass->removeClassMethod(new_string(CHAR_DEFINE_METHODS));
1761  TheObjectClass->removeClassMethod(new_string(CHAR_SHRIEKREXXDEFINED));
1762  TheObjectClass->removeClassMethod(new_string("!DEFINE_CLASS_METHOD"));
1763 
1764  // now save the image
1765  memoryObject.saveImage(imageTarget);
1766  ActivityManager::returnActivity(ActivityManager::currentActivity);
1767  exit(RC_OK); // successful build
1768 }
T_NilObject
@ T_NilObject
Definition: ClassTypeCodes.h:116
new_directory
RexxDirectory * new_directory()
Definition: DirectoryClass.hpp:107
new_integer
RexxInteger * new_integer(wholenumber_t v)
Definition: IntegerClass.hpp:200
CPPM
#define CPPM(n)
Definition: ObjectClass.hpp:216
PCPPM
RexxObject *(RexxObject::* PCPPM)()
Definition: ObjectClass.hpp:215
TheStackFrameClassBehaviour
#define TheStackFrameClassBehaviour
Definition: PrimitiveBehaviourNames.h:99
TheStringBehaviour
#define TheStringBehaviour
Definition: PrimitiveBehaviourNames.h:74
TheObjectClassBehaviour
#define TheObjectClassBehaviour
Definition: PrimitiveBehaviourNames.h:53
TheRexxTextClassBehaviour
#define TheRexxTextClassBehaviour
Definition: PrimitiveBehaviourNames.h:103
ThePointerClassBehaviour
#define ThePointerClassBehaviour
Definition: PrimitiveBehaviourNames.h:85
TheNumberStringBehaviour
#define TheNumberStringBehaviour
Definition: PrimitiveBehaviourNames.h:68
ThePointerBehaviour
#define ThePointerBehaviour
Definition: PrimitiveBehaviourNames.h:84
TheStemBehaviour
#define TheStemBehaviour
Definition: PrimitiveBehaviourNames.h:72
TheMutableBufferBehaviour
#define TheMutableBufferBehaviour
Definition: PrimitiveBehaviourNames.h:82
TheIdentityTableClassBehaviour
#define TheIdentityTableClassBehaviour
Definition: PrimitiveBehaviourNames.h:97
TheUnicodeClassBehaviour
#define TheUnicodeClassBehaviour
Definition: PrimitiveBehaviourNames.h:105
TheNumberStringClassBehaviour
#define TheNumberStringClassBehaviour
Definition: PrimitiveBehaviourNames.h:69
TheBufferBehaviour
#define TheBufferBehaviour
Definition: PrimitiveBehaviourNames.h:86
TheIntegerBehaviour
#define TheIntegerBehaviour
Definition: PrimitiveBehaviourNames.h:60
TheListClassBehaviour
#define TheListClassBehaviour
Definition: PrimitiveBehaviourNames.h:63
TheRexxContextClassBehaviour
#define TheRexxContextClassBehaviour
Definition: PrimitiveBehaviourNames.h:95
TheUnicodeBehaviour
#define TheUnicodeBehaviour
Definition: PrimitiveBehaviourNames.h:104
TheRexxBlockClassBehaviour
#define TheRexxBlockClassBehaviour
Definition: PrimitiveBehaviourNames.h:101
TheWeakReferenceBehaviour
#define TheWeakReferenceBehaviour
Definition: PrimitiveBehaviourNames.h:88
TheRoutineBehaviour
#define TheRoutineBehaviour
Definition: PrimitiveBehaviourNames.h:90
TheRelationBehaviour
#define TheRelationBehaviour
Definition: PrimitiveBehaviourNames.h:80
TheArrayBehaviour
#define TheArrayBehaviour
Definition: PrimitiveBehaviourNames.h:56
TheMessageBehaviour
#define TheMessageBehaviour
Definition: PrimitiveBehaviourNames.h:64
TheWeakReferenceClassBehaviour
#define TheWeakReferenceClassBehaviour
Definition: PrimitiveBehaviourNames.h:89
TheIdentityTableBehaviour
#define TheIdentityTableBehaviour
Definition: PrimitiveBehaviourNames.h:96
TheMethodClassBehaviour
#define TheMethodClassBehaviour
Definition: PrimitiveBehaviourNames.h:67
TheRexxBlockBehaviour
#define TheRexxBlockBehaviour
Definition: PrimitiveBehaviourNames.h:100
TheListBehaviour
#define TheListBehaviour
Definition: PrimitiveBehaviourNames.h:62
TheSupplierBehaviour
#define TheSupplierBehaviour
Definition: PrimitiveBehaviourNames.h:76
TheClassBehaviour
#define TheClassBehaviour
Definition: PrimitiveBehaviourNames.h:54
ThePackageBehaviour
#define ThePackageBehaviour
Definition: PrimitiveBehaviourNames.h:92
TheIntegerClassBehaviour
#define TheIntegerClassBehaviour
Definition: PrimitiveBehaviourNames.h:61
TheRoutineClassBehaviour
#define TheRoutineClassBehaviour
Definition: PrimitiveBehaviourNames.h:91
TheStackFrameBehaviour
#define TheStackFrameBehaviour
Definition: PrimitiveBehaviourNames.h:98
TheMessageClassBehaviour
#define TheMessageClassBehaviour
Definition: PrimitiveBehaviourNames.h:65
TheDirectoryClassBehaviour
#define TheDirectoryClassBehaviour
Definition: PrimitiveBehaviourNames.h:59
TheTableBehaviour
#define TheTableBehaviour
Definition: PrimitiveBehaviourNames.h:78
TheBufferClassBehaviour
#define TheBufferClassBehaviour
Definition: PrimitiveBehaviourNames.h:87
TheRexxContextBehaviour
#define TheRexxContextBehaviour
Definition: PrimitiveBehaviourNames.h:94
TheClassClassBehaviour
#define TheClassClassBehaviour
Definition: PrimitiveBehaviourNames.h:55
TheMutableBufferClassBehaviour
#define TheMutableBufferClassBehaviour
Definition: PrimitiveBehaviourNames.h:83
TheQueueBehaviour
#define TheQueueBehaviour
Definition: PrimitiveBehaviourNames.h:70
TheStringClassBehaviour
#define TheStringClassBehaviour
Definition: PrimitiveBehaviourNames.h:75
ThePackageClassBehaviour
#define ThePackageClassBehaviour
Definition: PrimitiveBehaviourNames.h:93
TheRelationClassBehaviour
#define TheRelationClassBehaviour
Definition: PrimitiveBehaviourNames.h:81
TheObjectBehaviour
#define TheObjectBehaviour
Definition: PrimitiveBehaviourNames.h:52
TheQueueClassBehaviour
#define TheQueueClassBehaviour
Definition: PrimitiveBehaviourNames.h:71
TheSupplierClassBehaviour
#define TheSupplierClassBehaviour
Definition: PrimitiveBehaviourNames.h:77
TheTableClassBehaviour
#define TheTableClassBehaviour
Definition: PrimitiveBehaviourNames.h:79
TheRexxTextBehaviour
#define TheRexxTextBehaviour
Definition: PrimitiveBehaviourNames.h:102
TheArrayClassBehaviour
#define TheArrayClassBehaviour
Definition: PrimitiveBehaviourNames.h:57
TheStemClassBehaviour
#define TheStemClassBehaviour
Definition: PrimitiveBehaviourNames.h:73
TheMethodBehaviour
#define TheMethodBehaviour
Definition: PrimitiveBehaviourNames.h:66
TheDirectoryBehaviour
#define TheDirectoryBehaviour
Definition: PrimitiveBehaviourNames.h:58
ActivityException
ActivityException
Definition: RexxActivity.hpp:110
TheRexxPackage
#define TheRexxPackage
Definition: RexxCore.h:189
A_COUNT
const size_t A_COUNT
Definition: RexxCore.h:262
ThePackageClass
#define ThePackageClass
Definition: RexxCore.h:163
TheWeakReferenceClass
#define TheWeakReferenceClass
Definition: RexxCore.h:177
TheUnicodeClass
#define TheUnicodeClass
Definition: RexxCore.h:181
OREF_NULL
#define OREF_NULL
Definition: RexxCore.h:61
TheStackFrameClass
#define TheStackFrameClass
Definition: RexxCore.h:178
IntegerThree
#define IntegerThree
Definition: RexxCore.h:202
TheObjectClass
#define TheObjectClass
Definition: RexxCore.h:166
IntegerSeven
#define IntegerSeven
Definition: RexxCore.h:206
TheStemClass
#define TheStemClass
Definition: RexxCore.h:168
TheSystem
#define TheSystem
Definition: RexxCore.h:188
TheKernel
#define TheKernel
Definition: RexxCore.h:187
TheNullText
#define TheNullText
Definition: RexxCore.h:211
IntegerFour
#define IntegerFour
Definition: RexxCore.h:203
TheTableClass
#define TheTableClass
Definition: RexxCore.h:172
TheRexxTextClass
#define TheRexxTextClass
Definition: RexxCore.h:180
IntegerFive
#define IntegerFive
Definition: RexxCore.h:204
TheNullArray
#define TheNullArray
Definition: RexxCore.h:193
IntegerOne
#define IntegerOne
Definition: RexxCore.h:200
TheEnvironment
#define TheEnvironment
Definition: RexxCore.h:183
TheClassClass
#define TheClassClass
Definition: RexxCore.h:156
TheStringClass
#define TheStringClass
Definition: RexxCore.h:169
IntegerEight
#define IntegerEight
Definition: RexxCore.h:207
TheSupplierClass
#define TheSupplierClass
Definition: RexxCore.h:171
TheCommonRetrievers
#define TheCommonRetrievers
Definition: RexxCore.h:186
TheTrueObject
#define TheTrueObject
Definition: RexxCore.h:196
TheRelationClass
#define TheRelationClass
Definition: RexxCore.h:174
TheIntegerClass
#define TheIntegerClass
Definition: RexxCore.h:158
TheListClass
#define TheListClass
Definition: RexxCore.h:159
TheNullPointer
#define TheNullPointer
Definition: RexxCore.h:197
TheBufferClass
#define TheBufferClass
Definition: RexxCore.h:176
TheFunctionsDirectory
#define TheFunctionsDirectory
Definition: RexxCore.h:185
IntegerTwo
#define IntegerTwo
Definition: RexxCore.h:201
IntegerSix
#define IntegerSix
Definition: RexxCore.h:205
TheRexxContextClass
#define TheRexxContextClass
Definition: RexxCore.h:164
TheArrayClass
#define TheArrayClass
Definition: RexxCore.h:155
ThePointerClass
#define ThePointerClass
Definition: RexxCore.h:175
TheDirectoryClass
#define TheDirectoryClass
Definition: RexxCore.h:157
TheNilObject
#define TheNilObject
Definition: RexxCore.h:191
TheMessageClass
#define TheMessageClass
Definition: RexxCore.h:160
RC_OK
const int RC_OK
Definition: RexxCore.h:268
TheFalseObject
#define TheFalseObject
Definition: RexxCore.h:195
TheQueueClass
#define TheQueueClass
Definition: RexxCore.h:167
TheMethodClass
#define TheMethodClass
Definition: RexxCore.h:161
IntegerNine
#define IntegerNine
Definition: RexxCore.h:208
TheRoutineClass
#define TheRoutineClass
Definition: RexxCore.h:162
TheNumberStringClass
#define TheNumberStringClass
Definition: RexxCore.h:165
IntegerZero
#define IntegerZero
Definition: RexxCore.h:199
TheIdentityTableClass
#define TheIdentityTableClass
Definition: RexxCore.h:173
TheRexxBlockClass
#define TheRexxBlockClass
Definition: RexxCore.h:179
TheMutableBufferClass
#define TheMutableBufferClass
Definition: RexxCore.h:170
IntegerMinusOne
#define IntegerMinusOne
Definition: RexxCore.h:209
VARIABLE_SUPER
#define VARIABLE_SUPER
Definition: RexxLocalVariables.hpp:55
VARIABLE_RESULT
#define VARIABLE_RESULT
Definition: RexxLocalVariables.hpp:56
VARIABLE_RC
#define VARIABLE_RC
Definition: RexxLocalVariables.hpp:57
VARIABLE_SIGL
#define VARIABLE_SIGL
Definition: RexxLocalVariables.hpp:58
VARIABLE_SELF
#define VARIABLE_SELF
Definition: RexxLocalVariables.hpp:54
memoryObject
RexxMemory memoryObject
Definition: RexxMemory.cpp:86
CLASS_CREATE
#define CLASS_CREATE(name, id, className)
Definition: RexxMemory.hpp:503
kernel_public
#define kernel_public(name, object, dir)
new_string
RexxString * new_string(const char *s, stringsize_t l)
Definition: StringClass.hpp:600
TextClass.hpp
new_text
RexxText * new_text(RexxString *s)
Definition: TextClass.hpp:105
ActivityManager::init
static void init()
Definition: ActivityManager.cpp:79
ActivityManager::returnActivity
static void returnActivity(RexxActivity *)
Definition: ActivityManager.cpp:625
ActivityManager::currentActivity
static RexxActivity *volatile currentActivity
Definition: ActivityManager.hpp:98
BaseExecutable::getPackage
PackageClass * getPackage()
Definition: MethodClass.cpp:131
BaseExecutable::source
RexxArray * source()
Definition: MethodClass.cpp:150
CPPCode::resolveExportedMethod
static CPPCode * resolveExportedMethod(const char *, PCPPM targetMethod, size_t argcount, bool passNamedArgs)
Definition: CPPCode.cpp:1218
Interpreter::logicError
static void logicError(const char *desc, const char *info1=NULL, size_t info2=0)
Definition: Interpreter.cpp:556
Interpreter::init
static void init()
Definition: Interpreter.cpp:77
Interpreter::getVersionNumber
static RexxString * getVersionNumber()
Definition: Version.cpp:52
Interpreter::createInterpreterInstance
static InterpreterInstance * createInterpreterInstance()
Definition: Interpreter.hpp:95
PackageClass::getSourceLineRexx
RexxString * getSourceLineRexx(RexxObject *)
Definition: PackageClass.cpp:161
PackageClass::loadLibrary
RexxObject * loadLibrary(RexxString *name)
Definition: PackageClass.cpp:633
PackageClass::setEncodingRexx
RexxObject * setEncodingRexx(RexxObject *e)
Definition: PackageClass.hpp:106
PackageClass::addClass
RexxObject * addClass(RexxString *name, RexxClass *clazz)
Definition: PackageClass.cpp:434
PackageClass::findProgramRexx
RexxObject * findProgramRexx(RexxObject *name)
Definition: PackageClass.cpp:538
PackageClass::getImportedPackages
RexxArray * getImportedPackages()
Definition: PackageClass.cpp:336
PackageClass::form
RexxObject * form()
Definition: PackageClass.cpp:671
PackageClass::addPublicClass
RexxObject * addPublicClass(RexxString *name, RexxClass *clazz)
Definition: PackageClass.cpp:451
PackageClass::trace
RexxObject * trace()
Definition: PackageClass.cpp:682
PackageClass::digits
RexxObject * digits()
Definition: PackageClass.cpp:649
PackageClass::getImportedRoutines
RexxDirectory * getImportedRoutines()
Definition: PackageClass.cpp:293
PackageClass::findClassRexx
RexxClass * findClassRexx(RexxString *name)
Definition: PackageClass.cpp:487
PackageClass::getRoutines
RexxDirectory * getRoutines()
Definition: PackageClass.cpp:249
PackageClass::getMethods
RexxDirectory * getMethods()
Definition: PackageClass.cpp:314
PackageClass::loadPackage
PackageClass * loadPackage(RexxString *name, RexxArray *source)
Definition: PackageClass.cpp:359
PackageClass::addPackage
RexxObject * addPackage(PackageClass *package)
Definition: PackageClass.cpp:385
PackageClass::findRoutineRexx
RoutineClass * findRoutineRexx(RexxString *name)
Definition: PackageClass.cpp:519
PackageClass::fuzz
RexxObject * fuzz()
Definition: PackageClass.cpp:660
PackageClass::getClasses
RexxDirectory * getClasses()
Definition: PackageClass.cpp:185
PackageClass::addRoutine
RexxObject * addRoutine(RexxString *name, RoutineClass *routine)
Definition: PackageClass.cpp:400
PackageClass::getPublicClasses
RexxDirectory * getPublicClasses()
Definition: PackageClass.cpp:206
PackageClass::getName
RexxString * getName()
Definition: PackageClass.cpp:124
PackageClass::newRexx
PackageClass * newRexx(RexxObject **init_args, size_t argCount, size_t named_argCount)
Definition: PackageClass.cpp:564
PackageClass::getSource
RexxArray * getSource()
Definition: PackageClass.cpp:135
PackageClass::getSourceSize
RexxInteger * getSourceSize()
Definition: PackageClass.cpp:174
PackageClass::setSecurityManager
RexxObject * setSecurityManager(RexxObject *)
Definition: PackageClass.cpp:557
PackageClass::addPublicRoutine
RexxObject * addPublicRoutine(RexxString *name, RoutineClass *routine)
Definition: PackageClass.cpp:417
PackageClass::getImportedClasses
RexxDirectory * getImportedClasses()
Definition: PackageClass.cpp:228
PackageClass::createInstance
static void createInstance()
Definition: PackageClass.cpp:62
PackageClass::getPublicRoutines
RexxDirectory * getPublicRoutines()
Definition: PackageClass.cpp:271
PackageManager::initialize
static void initialize()
Definition: PackageManager.cpp:75
RexxActivity::initializeThreadContext
static void initializeThreadContext()
Definition: RexxActivity.cpp:2026
RexxActivity::error
wholenumber_t error()
Definition: RexxActivity.cpp:338
RexxActivity::createNewActivationStack
void createNewActivationStack()
Definition: RexxActivity.cpp:1810
RexxActivity::resolveProgramName
RexxString * resolveProgramName(RexxString *, RexxString *, RexxString *)
Definition: RexxActivity.cpp:3561
RexxArray::lastItem
RexxObject * lastItem()
Definition: ArrayClass.cpp:1309
RexxArray::isEmpty
RexxObject * isEmpty()
Definition: ArrayClass.cpp:301
RexxArray::getRexx
RexxObject * getRexx(RexxObject **, size_t, size_t)
Definition: ArrayClass.cpp:506
RexxArray::createInstance
static void createInstance()
Definition: ArrayClass.cpp:95
RexxArray::insertRexx
RexxObject * insertRexx(RexxObject *_value, RexxObject *index)
Definition: ArrayClass.cpp:344
RexxArray::of
RexxObject * of(RexxObject **, size_t, size_t)
Definition: ArrayClass.cpp:2785
RexxArray::supplier
RexxObject * supplier(RexxObject *maxItems=OREF_NULL)
Definition: ArrayClass.cpp:786
RexxArray::firstRexx
RexxObject * firstRexx()
Definition: ArrayClass.cpp:1235
RexxArray::sizeRexx
RexxInteger * sizeRexx()
Definition: ArrayClass.cpp:1070
RexxArray::putRexx
RexxObject * putRexx(RexxObject **, size_t, size_t)
Definition: ArrayClass.cpp:228
RexxArray::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: ArrayClass.cpp:2777
RexxArray::allItems
RexxArray * allItems(RexxObject *maxItems=OREF_NULL)
Definition: ArrayClass.cpp:1470
RexxArray::nextRexx
RexxObject * nextRexx(RexxObject **, size_t, size_t)
Definition: ArrayClass.cpp:1329
RexxArray::allIndexes
RexxArray * allIndexes(RexxObject *maxIndexes=OREF_NULL)
Definition: ArrayClass.cpp:1505
RexxArray::deleteRexx
RexxObject * deleteRexx(RexxObject *index)
Definition: ArrayClass.cpp:385
RexxArray::appendRexx
RexxObject * appendRexx(RexxObject *)
Definition: ArrayClass.cpp:314
RexxArray::itemsRexx
RexxObject * itemsRexx()
Definition: ArrayClass.cpp:685
RexxArray::empty
RexxObject * empty()
Definition: ArrayClass.cpp:273
RexxArray::index
RexxObject * index(RexxObject *)
Definition: ArrayClass.cpp:1875
RexxArray::stableSortRexx
RexxArray * stableSortRexx()
Definition: ArrayClass.cpp:2585
RexxArray::removeItem
RexxObject * removeItem(RexxObject *)
Definition: ArrayClass.cpp:1899
RexxArray::hasItem
RexxObject * hasItem(RexxObject *)
Definition: ArrayClass.cpp:1925
RexxArray::removeRexx
RexxObject * removeRexx(RexxObject **, size_t, size_t)
Definition: ArrayClass.cpp:626
RexxArray::lastRexx
RexxObject * lastRexx()
Definition: ArrayClass.cpp:1262
RexxArray::fill
RexxObject * fill(RexxObject *)
Definition: ArrayClass.cpp:253
RexxArray::getDimensions
RexxObject * getDimensions()
Definition: ArrayClass.cpp:714
RexxArray::stableSortWithRexx
RexxArray * stableSortWithRexx(RexxObject *comparator)
Definition: ArrayClass.cpp:2621
RexxArray::dimension
RexxObject * dimension(RexxObject *)
Definition: ArrayClass.cpp:729
RexxArray::hasIndexRexx
RexxObject * hasIndexRexx(RexxObject **, size_t, size_t)
Definition: ArrayClass.cpp:1406
RexxArray::sectionRexx
RexxObject * sectionRexx(RexxObject *, RexxObject *)
Definition: ArrayClass.cpp:1128
RexxArray::previousRexx
RexxObject * previousRexx(RexxObject **, size_t, size_t)
Definition: ArrayClass.cpp:1362
RexxArray::toString
RexxString * toString(RexxString *, RexxString *)
Definition: ArrayClass.cpp:1551
RexxArray::firstItem
RexxObject * firstItem()
Definition: ArrayClass.cpp:1283
RexxBehaviour::define
RexxObject * define(RexxString *, RexxMethod *)
Definition: RexxBehaviour.cpp:251
RexxBlock::getKind
RexxString * getKind()
Definition: BlockClass.hpp:105
RexxBlock::createInstance
static void createInstance()
Definition: BlockClass.cpp:189
RexxBlock::newRexx
RexxObject * newRexx(RexxObject **args, size_t argc, size_t named_argc)
Definition: BlockClass.cpp:254
RexxBlock::getVariables
RexxObject * getVariables()
Definition: BlockClass.hpp:104
RexxBlock::getRawExecutable
RexxObject * getRawExecutable()
Definition: BlockClass.hpp:106
RexxBlock::getPackage
PackageClass * getPackage()
Definition: BlockClass.hpp:103
RexxBlock::copyRexx
RexxObject * copyRexx()
Definition: BlockClass.cpp:268
RexxBlock::getSource
RexxArray * getSource()
Definition: BlockClass.hpp:102
RexxBuffer::createInstance
static void createInstance()
Definition: BufferClass.cpp:54
RexxBuffer::newRexx
RexxObject * newRexx(RexxObject **args, size_t argc, size_t named_argc)
Definition: BufferClass.cpp:117
RexxClass::newRexx
RexxClass * newRexx(RexxObject **args, size_t argCount, size_t named_argCount)
Definition: ClassClass.cpp:1756
RexxClass::deleteMethod
RexxObject * deleteMethod(RexxString *)
Definition: ClassClass.cpp:821
RexxClass::getSuperClass
RexxClass * getSuperClass()
Definition: ClassClass.cpp:333
RexxClass::subclassRexx
RexxClass * subclassRexx(RexxString *, RexxClass *, RexxObject *)
Definition: ClassClass.cpp:1466
RexxClass::getPackage
PackageClass * getPackage()
Definition: ClassClass.cpp:1683
RexxClass::method
RexxMethod * method(RexxString *)
Definition: ClassClass.cpp:850
RexxClass::getMetaClass
RexxClass * getMetaClass()
Definition: ClassClass.cpp:309
RexxClass::inherit
RexxObject * inherit(RexxClass *, RexxClass *)
Definition: ClassClass.cpp:1195
RexxClass::defaultNameRexx
RexxString * defaultNameRexx()
Definition: ClassClass.cpp:1653
RexxClass::isMetaClassRexx
RexxObject * isMetaClassRexx()
Definition: ClassClass.cpp:267
RexxClass::notEqual
RexxObject * notEqual(RexxObject *)
Definition: ClassClass.cpp:231
RexxClass::getSubClasses
RexxArray * getSubClasses()
Definition: ClassClass.cpp:358
RexxClass::getBaseClass
RexxClass * getBaseClass()
Definition: ClassClass.cpp:301
RexxClass::defineMethod
RexxObject * defineMethod(RexxString *, RexxMethod *)
Definition: ClassClass.cpp:653
RexxClass::getSuperClasses
RexxArray * getSuperClasses()
Definition: ClassClass.cpp:348
RexxClass::isAbstractRexx
RexxObject * isAbstractRexx()
Definition: ClassClass.cpp:278
RexxClass::isSubclassOf
RexxObject * isSubclassOf(RexxClass *other)
Definition: ClassClass.cpp:1647
RexxClass::enhanced
RexxObject * enhanced(RexxObject **, size_t, size_t)
Definition: ClassClass.cpp:1366
RexxClass::queryMixinClass
RexxInteger * queryMixinClass()
Definition: ClassClass.cpp:253
RexxClass::equal
RexxObject * equal(RexxObject *)
Definition: ClassClass.cpp:209
RexxClass::defineMethods
RexxObject * defineMethods(RexxTable *)
Definition: ClassClass.cpp:725
RexxClass::setRexxDefined
RexxObject * setRexxDefined()
Definition: ClassClass.cpp:292
RexxClass::defineClassMethod
RexxObject * defineClassMethod(RexxString *method_name, RexxMethod *newMethod)
Definition: ClassClass.cpp:772
RexxClass::methods
RexxSupplier * methods(RexxClass *)
Definition: ClassClass.cpp:869
RexxClass::mixinClassRexx
RexxClass * mixinClassRexx(RexxString *, RexxClass *, RexxObject *)
Definition: ClassClass.cpp:1423
RexxClass::strictEqual
RexxObject * strictEqual(RexxObject *)
Definition: ClassClass.cpp:172
RexxClass::uninherit
RexxObject * uninherit(RexxClass *)
Definition: ClassClass.cpp:1300
RexxClass::getId
RexxString * getId()
Definition: ClassClass.cpp:284
RexxContext::getFuzz
RexxObject * getFuzz()
Definition: ContextClass.cpp:206
RexxContext::copyRexx
RexxObject * copyRexx()
Definition: ContextClass.cpp:144
RexxContext::getDigits
RexxObject * getDigits()
Definition: ContextClass.cpp:182
RexxContext::getForm
RexxObject * getForm()
Definition: ContextClass.cpp:218
RexxContext::getArgs
RexxObject * getArgs()
Definition: ContextClass.cpp:255
RexxContext::getLine
RexxObject * getLine()
Definition: ContextClass.cpp:337
RexxContext::setArgs
RexxObject * setArgs(RexxObject *, RexxObject **, size_t)
Definition: ContextClass.cpp:288
RexxContext::getRS
RexxObject * getRS()
Definition: ContextClass.cpp:349
RexxContext::getPackage
PackageClass * getPackage()
Definition: ContextClass.cpp:170
RexxContext::getName
RexxObject * getName()
Definition: ContextClass.cpp:375
RexxContext::newRexx
RexxObject * newRexx(RexxObject **args, size_t argc, size_t named_argc)
Definition: ContextClass.cpp:96
RexxContext::createInstance
static void createInstance()
Definition: ContextClass.cpp:55
RexxContext::getExecutable
RexxObject * getExecutable()
Definition: ContextClass.cpp:243
RexxContext::getDigitsPropagate
RexxObject * getDigitsPropagate()
Definition: ContextClass.cpp:194
RexxContext::getVariables
RexxObject * getVariables()
Definition: ContextClass.cpp:231
RexxContext::getParentContextObject
RexxObject * getParentContextObject()
Definition: ContextClass.cpp:359
RexxContext::getStackFrames
RexxObject * getStackFrames()
Definition: ContextClass.cpp:386
RexxContext::getCondition
RexxObject * getCondition()
Definition: ContextClass.cpp:323
RexxContext::getNamedArgs
RexxObject * getNamedArgs()
Definition: ContextClass.cpp:269
RexxDirectory::hasItem
RexxObject * hasItem(RexxObject *)
Definition: DirectoryClass.cpp:760
RexxDirectory::allIndexes
RexxArray * allIndexes()
Definition: DirectoryClass.cpp:232
RexxDirectory::setMethod
RexxObject * setMethod(RexxString *, RexxMethod *)
Definition: DirectoryClass.cpp:500
RexxDirectory::indexRexx
RexxObject * indexRexx(RexxObject *)
Definition: DirectoryClass.cpp:719
RexxDirectory::allItems
RexxArray * allItems()
Definition: DirectoryClass.cpp:261
RexxDirectory::setEntry
RexxObject * setEntry(RexxString *, RexxObject *)
Definition: DirectoryClass.cpp:383
RexxDirectory::removeItem
RexxObject * removeItem(RexxObject *)
Definition: DirectoryClass.cpp:775
RexxDirectory::hasEntry
RexxObject * hasEntry(RexxString *)
Definition: DirectoryClass.cpp:351
RexxDirectory::put
RexxObject * put(RexxObject *, RexxString *)
Definition: DirectoryClass.cpp:646
RexxDirectory::isEmpty
RexxObject * isEmpty()
Definition: DirectoryClass.cpp:703
RexxDirectory::newRexx
RexxObject * newRexx(RexxObject **init_args, size_t, size_t)
Definition: DirectoryClass.cpp:788
RexxDirectory::supplier
RexxSupplier * supplier()
Definition: DirectoryClass.cpp:164
RexxDirectory::empty
RexxObject * empty()
Definition: DirectoryClass.cpp:691
RexxDirectory::atRexx
RexxObject * atRexx(RexxString *)
Definition: DirectoryClass.cpp:614
RexxDirectory::entryRexx
RexxObject * entryRexx(RexxString *)
Definition: DirectoryClass.cpp:299
RexxDirectory::itemsRexx
RexxObject * itemsRexx()
Definition: DirectoryClass.cpp:155
RexxDirectory::createInstance
static void createInstance()
Definition: DirectoryClass.cpp:60
RexxDirectory::hasIndex
RexxObject * hasIndex(RexxString *)
Definition: DirectoryClass.cpp:319
RexxDirectory::removeRexx
RexxObject * removeRexx(RexxString *)
Definition: DirectoryClass.cpp:423
RexxHashTableCollection::removeRexx
RexxObject * removeRexx(RexxObject *)
Definition: RexxCollection.cpp:168
RexxHashTableCollection::getRexx
RexxObject * getRexx(RexxObject *)
Definition: RexxCollection.cpp:219
RexxHashTableCollection::hasItemRexx
RexxObject * hasItemRexx(RexxObject *)
Definition: RexxCollection.cpp:456
RexxHashTableCollection::allAt
RexxObject * allAt(RexxObject *)
Definition: RexxCollection.cpp:196
RexxHashTableCollection::indexRexx
RexxObject * indexRexx(RexxObject *value)
Definition: RexxCollection.cpp:388
RexxHashTableCollection::supplier
RexxSupplier * supplier()
Definition: RexxCollection.cpp:476
RexxHashTableCollection::hasIndexRexx
RexxObject * hasIndexRexx(RexxObject *)
Definition: RexxCollection.cpp:369
RexxHashTableCollection::putRexx
RexxObject * putRexx(RexxObject *, RexxObject *)
Definition: RexxCollection.cpp:258
RexxHashTableCollection::removeItemRexx
RexxObject * removeItemRexx(RexxObject *value)
Definition: RexxCollection.cpp:426
RexxIdentityTable::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: IdentityTableClass.cpp:72
RexxIdentityTable::createInstance
static void createInstance()
Definition: IdentityTableClass.cpp:58
RexxInteger::isLessOrEqual
RexxInteger * isLessOrEqual(RexxObject *)
Definition: IntegerClass.cpp:870
RexxInteger::xorOp
RexxObject * xorOp(RexxObject *)
Definition: IntegerClass.cpp:1031
RexxInteger::equal
RexxInteger * equal(RexxObject *)
Definition: IntegerClass.cpp:785
RexxInteger::isLessThan
RexxInteger * isLessThan(RexxObject *)
Definition: IntegerClass.cpp:836
RexxInteger::strictGreaterOrEqual
RexxInteger * strictGreaterOrEqual(RexxObject *)
Definition: IntegerClass.cpp:922
RexxInteger::isGreaterThan
RexxInteger * isGreaterThan(RexxObject *)
Definition: IntegerClass.cpp:819
RexxInteger::notEqual
RexxInteger * notEqual(RexxObject *)
Definition: IntegerClass.cpp:802
RexxInteger::power
RexxObject * power(RexxObject *)
Definition: IntegerClass.cpp:655
RexxInteger::plus
RexxObject * plus(RexxInteger *)
Definition: IntegerClass.cpp:517
RexxInteger::remainder
RexxObject * remainder(RexxInteger *)
Definition: IntegerClass.cpp:628
RexxInteger::minus
RexxObject * minus(RexxInteger *)
Definition: IntegerClass.cpp:542
RexxInteger::notOp
RexxObject * notOp()
Definition: IntegerClass.cpp:956
RexxInteger::ceiling
RexxObject * ceiling()
Definition: IntegerClass.cpp:1217
RexxInteger::Max
RexxObject * Max(RexxObject **, size_t, size_t)
Definition: IntegerClass.cpp:1094
RexxInteger::round
RexxObject * round()
Definition: IntegerClass.cpp:1228
RexxInteger::d2x
RexxObject * d2x(RexxObject *)
Definition: IntegerClass.cpp:1256
RexxInteger::strictGreaterThan
RexxInteger * strictGreaterThan(RexxObject *)
Definition: IntegerClass.cpp:888
RexxInteger::strictLessOrEqual
RexxInteger * strictLessOrEqual(RexxObject *)
Definition: IntegerClass.cpp:939
RexxInteger::strictLessThan
RexxInteger * strictLessThan(RexxObject *)
Definition: IntegerClass.cpp:905
RexxInteger::trunc
RexxObject * trunc(RexxObject *)
Definition: IntegerClass.cpp:1191
RexxInteger::Min
RexxObject * Min(RexxObject **, size_t, size_t)
Definition: IntegerClass.cpp:1143
RexxInteger::isGreaterOrEqual
RexxInteger * isGreaterOrEqual(RexxObject *)
Definition: IntegerClass.cpp:853
RexxInteger::d2c
RexxObject * d2c(RexxObject *)
Definition: IntegerClass.cpp:1246
RexxInteger::classObject
RexxClass * classObject()
Definition: IntegerClass.cpp:1376
RexxInteger::andOp
RexxObject * andOp(RexxObject *)
Definition: IntegerClass.cpp:975
RexxInteger::multiply
RexxObject * multiply(RexxInteger *)
Definition: IntegerClass.cpp:569
RexxInteger::strictNotEqual
RexxInteger * strictNotEqual(RexxObject *)
Definition: IntegerClass.cpp:767
RexxInteger::orOp
RexxObject * orOp(RexxObject *)
Definition: IntegerClass.cpp:1003
RexxInteger::hashCode
RexxObject * hashCode()
Definition: IntegerClass.cpp:740
RexxInteger::sign
RexxObject * sign()
Definition: IntegerClass.cpp:1078
RexxInteger::abs
RexxObject * abs()
Definition: IntegerClass.cpp:1061
RexxInteger::format
RexxObject * format(RexxObject *, RexxObject *, RexxObject *, RexxObject *)
Definition: IntegerClass.cpp:1234
RexxInteger::strictEqual
RexxInteger * strictEqual(RexxObject *)
Definition: IntegerClass.cpp:748
RexxInteger::integerDivide
RexxObject * integerDivide(RexxInteger *)
Definition: IntegerClass.cpp:601
RexxInteger::floor
RexxObject * floor()
Definition: IntegerClass.cpp:1206
RexxInteger::divide
RexxObject * divide(RexxInteger *)
Definition: IntegerClass.cpp:591
RexxInternalObject::behaviour
RexxBehaviour * behaviour
Definition: ObjectClass.hpp:330
RexxList::lastRexx
RexxObject * lastRexx()
Definition: ListClass.cpp:728
RexxList::append
RexxObject * append(RexxObject *)
Definition: ListClass.cpp:538
RexxList::value
RexxObject * value(RexxObject *)
Definition: ListClass.cpp:246
RexxList::allIndexes
RexxArray * allIndexes()
Definition: ListClass.cpp:938
RexxList::allItems
RexxArray * allItems()
Definition: ListClass.cpp:888
RexxList::next
RexxObject * next(RexxObject *)
Definition: ListClass.cpp:744
RexxList::hasIndex
RexxObject * hasIndex(RexxObject *)
Definition: ListClass.cpp:845
RexxList::lastItem
RexxObject * lastItem()
Definition: ListClass.cpp:697
RexxList::previous
RexxObject * previous(RexxObject *)
Definition: ListClass.cpp:769
RexxList::removeItem
RexxObject * removeItem(RexxObject *)
Definition: ListClass.cpp:1023
RexxList::classOf
RexxList * classOf(RexxObject **, size_t, size_t)
Definition: ListClass.cpp:1261
RexxList::hasItem
RexxObject * hasItem(RexxObject *)
Definition: ListClass.cpp:994
RexxList::put
RexxObject * put(RexxObject *, RexxObject *)
Definition: ListClass.cpp:289
RexxList::itemsRexx
RexxObject * itemsRexx()
Definition: ListClass.cpp:1148
RexxList::index
RexxObject * index(RexxObject *)
Definition: ListClass.cpp:964
RexxList::firstRexx
RexxObject * firstRexx()
Definition: ListClass.cpp:712
RexxList::remove
RexxObject * remove(RexxObject *)
Definition: ListClass.cpp:630
RexxList::newRexx
RexxList * newRexx(RexxObject **, size_t, size_t)
Definition: ListClass.cpp:1226
RexxList::isEmpty
RexxObject * isEmpty()
Definition: ListClass.cpp:926
RexxList::section
RexxObject * section(RexxObject *, RexxObject *)
Definition: ListClass.cpp:309
RexxList::empty
RexxObject * empty()
Definition: ListClass.cpp:908
RexxList::createInstance
static void createInstance()
Definition: ListClass.cpp:60
RexxList::insertRexx
RexxObject * insertRexx(RexxObject *, RexxObject *)
Definition: ListClass.cpp:518
RexxList::firstItem
RexxObject * firstItem()
Definition: ListClass.cpp:682
RexxList::supplier
RexxSupplier * supplier()
Definition: ListClass.cpp:1131
RexxLocal::local
RexxDirectory * local()
Definition: RexxMisc.cpp:63
RexxMemory::definePrivateKernelMethod
static void definePrivateKernelMethod(const char *name, RexxBehaviour *behaviour, PCPPM entryPoint, size_t arguments, bool named_arguments=false)
Definition: Setup.cpp:124
RexxMemory::createRexxPackage
static void createRexxPackage()
Definition: Setup.cpp:205
RexxMemory::saveImage
void saveImage(const char *imageTarget)
Definition: RexxMemory.cpp:1704
RexxMemory::createStrings
static void createStrings()
Definition: GlobalNames.cpp:47
RexxMemory::createImage
static void createImage(const char *imageTarget)
Definition: Setup.cpp:219
RexxMemory::setMarkTable
void setMarkTable(RexxTable *marktable)
Definition: RexxMemory.hpp:225
RexxMemory::completeSystemClass
static void completeSystemClass(const char *name, RexxClass *classObj)
Definition: Setup.cpp:173
RexxMemory::defineKernelMethod
static void defineKernelMethod(const char *name, RexxBehaviour *behaviour, PCPPM entryPoint, size_t arguments, bool named_arguments=false)
Definition: Setup.cpp:94
RexxMemory::rexxPackage
static PackageClass * rexxPackage
Definition: RexxMemory.hpp:314
RexxMemory::addToSystem
static void addToSystem(const char *name, RexxInternalObject *classObj)
Definition: Setup.cpp:148
RexxMemory::defineProtectedKernelMethod
static void defineProtectedKernelMethod(const char *name, RexxBehaviour *behaviour, PCPPM entryPoint, size_t arguments, bool named_arguments=false)
Definition: Setup.cpp:108
RexxMemory::getGlobalName
static RexxString * getGlobalName(const char *value)
Definition: RexxMemory.cpp:2339
RexxMemory::enableOrefChecks
void enableOrefChecks()
Definition: RexxMemory.hpp:268
RexxMemory::create
static void create()
Definition: RexxMemory.cpp:2371
RexxMessage::messageName
RexxString * messageName()
Definition: MessageClass.cpp:506
RexxMessage::completed
RexxObject * completed()
Definition: MessageClass.cpp:428
RexxMessage::messageTarget
RexxObject * messageTarget()
Definition: MessageClass.cpp:494
RexxMessage::createInstance
static void createInstance()
Definition: MessageClass.cpp:64
RexxMessage::result
RexxObject * result()
Definition: MessageClass.cpp:220
RexxMessage::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: MessageClass.cpp:533
RexxMessage::notify
RexxObject * notify(RexxMessage *)
Definition: MessageClass.cpp:183
RexxMessage::start
RexxObject * start(RexxObject *)
Definition: MessageClass.cpp:334
RexxMessage::arguments
RexxArray * arguments()
Definition: MessageClass.cpp:517
RexxMessage::send
RexxObject * send(RexxObject *)
Definition: MessageClass.cpp:270
RexxMessage::hasError
RexxObject * hasError()
Definition: MessageClass.cpp:453
RexxMessage::errorCondition
RexxObject * errorCondition()
Definition: MessageClass.cpp:473
RexxMethod::newRexx
RexxMethod * newRexx(RexxObject **, size_t, size_t)
Definition: MethodClass.cpp:669
RexxMethod::createInstance
static void createInstance()
Definition: MethodClass.cpp:74
RexxMethod::isPrivateRexx
RexxObject * isPrivateRexx()
Definition: MethodClass.cpp:426
RexxMethod::setPrivateRexx
RexxObject * setPrivateRexx()
Definition: MethodClass.cpp:393
RexxMethod::setPrivate
void setPrivate()
Definition: MethodClass.hpp:174
RexxMethod::isAttributeRexx
RexxObject * isAttributeRexx()
Definition: MethodClass.cpp:472
RexxMethod::setUnguardedRexx
RexxObject * setUnguardedRexx()
Definition: MethodClass.cpp:375
RexxMethod::setProtectedRexx
RexxObject * setProtectedRexx()
Definition: MethodClass.cpp:402
RexxMethod::setSecurityManager
RexxObject * setSecurityManager(RexxObject *)
Definition: MethodClass.cpp:356
RexxMethod::isProtectedRexx
RexxObject * isProtectedRexx()
Definition: MethodClass.cpp:448
RexxMethod::isAbstractRexx
RexxObject * isAbstractRexx()
Definition: MethodClass.cpp:459
RexxMethod::newFileRexx
RexxMethod * newFileRexx(RexxString *)
Definition: MethodClass.cpp:760
RexxMethod::getScopeRexx
RexxObject * getScopeRexx()
Definition: MethodClass.cpp:497
RexxMethod::isGuardedRexx
RexxObject * isGuardedRexx()
Definition: MethodClass.cpp:416
RexxMethod::loadExternalMethod
RexxMethod * loadExternalMethod(RexxString *name, RexxString *descriptor)
Definition: MethodClass.cpp:974
RexxMethod::isPackageRexx
RexxObject * isPackageRexx()
Definition: MethodClass.cpp:437
RexxMethod::isConstantRexx
RexxObject * isConstantRexx()
Definition: MethodClass.cpp:485
RexxMethod::setProtected
void setProtected()
Definition: MethodClass.hpp:176
RexxMethod::setGuardedRexx
RexxObject * setGuardedRexx()
Definition: MethodClass.cpp:384
RexxMutableBufferClass::newRexx
RexxMutableBuffer * newRexx(RexxObject **, size_t, size_t)
Definition: MutableBufferClass.cpp:72
RexxMutableBuffer::isASCIIRexx
RexxInteger * isASCIIRexx()
Definition: MutableBufferClass.cpp:368
RexxMutableBuffer::caselessLastPos
RexxInteger * caselessLastPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range)
Definition: MutableBufferClass.cpp:874
RexxMutableBuffer::caselessChangeStr
RexxMutableBuffer * caselessChangeStr(RexxString *needle, RexxString *newNeedle, RexxInteger *countArg)
Definition: MutableBufferClass.cpp:1107
RexxMutableBuffer::translate
RexxMutableBuffer * translate(RexxString *tableo, RexxString *tablei, RexxString *pad, RexxInteger *, RexxInteger *)
Definition: MutableBufferClass.cpp:1343
RexxMutableBuffer::subchar
RexxString * subchar(RexxInteger *startPosition)
Definition: MutableBufferClass.cpp:903
RexxMutableBuffer::mydelete
RexxMutableBuffer * mydelete(RexxObject *, RexxObject *)
Definition: MutableBufferClass.cpp:671
RexxMutableBuffer::subWords
RexxArray * subWords(RexxInteger *, RexxInteger *)
Definition: MutableBufferClass.cpp:1682
RexxMutableBuffer::setEncodingRexx
RexxObject * setEncodingRexx(RexxObject *e)
Definition: MutableBufferClass.hpp:167
RexxMutableBuffer::changeStr
RexxMutableBuffer * changeStr(RexxString *needle, RexxString *newNeedle, RexxInteger *countArg)
Definition: MutableBufferClass.cpp:955
RexxMutableBuffer::verify
RexxInteger * verify(RexxString *, RexxString *, RexxInteger *, RexxInteger *)
Definition: MutableBufferClass.cpp:1647
RexxMutableBuffer::lower
RexxMutableBuffer * lower(RexxInteger *_start, RexxInteger *_length)
Definition: MutableBufferClass.cpp:1260
RexxMutableBuffer::createInstance
static void createInstance()
Definition: MutableBufferClass.cpp:63
RexxMutableBuffer::append
RexxMutableBuffer * append(RexxObject *)
Definition: MutableBufferClass.cpp:375
RexxMutableBuffer::posRexx
RexxInteger * posRexx(RexxString *needle, RexxInteger *_start, RexxInteger *_range)
Definition: MutableBufferClass.cpp:815
RexxMutableBuffer::space
RexxMutableBuffer * space(RexxInteger *space_count, RexxString *pad)
Definition: MutableBufferClass.cpp:1851
RexxMutableBuffer::delWord
RexxMutableBuffer * delWord(RexxInteger *position, RexxInteger *plength)
Definition: MutableBufferClass.cpp:1784
RexxMutableBuffer::wordPos
RexxInteger * wordPos(RexxString *, RexxInteger *)
Definition: MutableBufferClass.cpp:1754
RexxMutableBuffer::caselessWordPos
RexxInteger * caselessWordPos(RexxString *, RexxInteger *)
Definition: MutableBufferClass.cpp:1769
RexxMutableBuffer::caselessMatch
RexxInteger * caselessMatch(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_)
Definition: MutableBufferClass.cpp:1479
RexxMutableBuffer::upper
RexxMutableBuffer * upper(RexxInteger *_start, RexxInteger *_length)
Definition: MutableBufferClass.cpp:1301
RexxMutableBuffer::countStrRexx
RexxInteger * countStrRexx(RexxString *needle)
Definition: MutableBufferClass.cpp:920
RexxMutableBuffer::matchChar
RexxInteger * matchChar(RexxInteger *position_, RexxString *matchSet)
Definition: MutableBufferClass.cpp:1572
RexxMutableBuffer::lengthRexx
RexxObject * lengthRexx()
Definition: MutableBufferClass.cpp:352
RexxMutableBuffer::caselessCountStrRexx
RexxInteger * caselessCountStrRexx(RexxString *needle)
Definition: MutableBufferClass.cpp:933
RexxMutableBuffer::getBufferSize
RexxInteger * getBufferSize()
Definition: MutableBufferClass.hpp:93
RexxMutableBuffer::wordLength
RexxInteger * wordLength(RexxInteger *)
Definition: MutableBufferClass.cpp:1727
RexxMutableBuffer::wordIndex
RexxInteger * wordIndex(RexxInteger *)
Definition: MutableBufferClass.cpp:1711
RexxMutableBuffer::setBufferSize
RexxObject * setBufferSize(RexxInteger *)
Definition: MutableBufferClass.cpp:746
RexxMutableBuffer::lastPos
RexxInteger * lastPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range)
Definition: MutableBufferClass.cpp:832
RexxMutableBuffer::overlay
RexxMutableBuffer * overlay(RexxObject *, RexxObject *, RexxObject *, RexxObject *)
Definition: MutableBufferClass.cpp:503
RexxMutableBuffer::caselessMatchChar
RexxInteger * caselessMatchChar(RexxInteger *position_, RexxString *matchSet)
Definition: MutableBufferClass.cpp:1609
RexxMutableBuffer::replaceAt
RexxMutableBuffer * replaceAt(RexxObject *str, RexxObject *pos, RexxObject *len, RexxObject *pad)
Definition: MutableBufferClass.cpp:582
RexxMutableBuffer::subWord
RexxString * subWord(RexxInteger *, RexxInteger *)
Definition: MutableBufferClass.cpp:1662
RexxMutableBuffer::match
RexxInteger * match(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_)
Definition: MutableBufferClass.cpp:1435
RexxMutableBuffer::caselessPos
RexxInteger * caselessPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range)
Definition: MutableBufferClass.cpp:848
RexxMutableBuffer::word
RexxString * word(RexxInteger *)
Definition: MutableBufferClass.cpp:1696
RexxMutableBuffer::substr
RexxString * substr(RexxInteger *startPosition, RexxInteger *len, RexxString *pad)
Definition: MutableBufferClass.cpp:797
RexxMutableBuffer::insert
RexxMutableBuffer * insert(RexxObject *, RexxObject *, RexxObject *, RexxObject *)
Definition: MutableBufferClass.cpp:417
RexxNumberString::strictGreaterThan
RexxInteger * strictGreaterThan(RexxObject *)
Definition: NumberStringClass.cpp:3084
RexxNumberString::xorOp
RexxObject * xorOp(RexxObject *)
Definition: NumberStringClass.cpp:2747
RexxNumberString::isLessThan
RexxInteger * isLessThan(RexxObject *)
Definition: NumberStringClass.cpp:2996
RexxNumberString::strictEqual
RexxInteger * strictEqual(RexxObject *)
Definition: NumberStringClass.cpp:3058
RexxNumberString::strictLessThan
RexxInteger * strictLessThan(RexxObject *)
Definition: NumberStringClass.cpp:3096
RexxNumberString::isGreaterThan
RexxInteger * isGreaterThan(RexxObject *)
Definition: NumberStringClass.cpp:2980
RexxNumberString::multiply
RexxNumberString * multiply(RexxObject *)
Definition: NumberStringClass.cpp:3210
RexxNumberString::minus
RexxNumberString * minus(RexxObject *)
Definition: NumberStringClass.cpp:3175
RexxNumberString::Max
RexxNumberString * Max(RexxObject **, size_t, size_t)
Definition: NumberStringClass.cpp:3353
RexxNumberString::createInstance
static void createInstance()
Definition: NumberStringClass.cpp:67
RexxNumberString::formatRexx
RexxString * formatRexx(RexxObject *, RexxObject *, RexxObject *, RexxObject *)
Definition: NumberStringClass.cpp:1843
RexxNumberString::classObject
RexxClass * classObject()
Definition: NumberStringClass.cpp:3726
RexxNumberString::Sign
RexxInteger * Sign()
Definition: NumberStringClass.cpp:3325
RexxNumberString::Min
RexxNumberString * Min(RexxObject **, size_t, size_t)
Definition: NumberStringClass.cpp:3364
RexxNumberString::abs
RexxNumberString * abs()
Definition: NumberStringClass.cpp:3311
RexxNumberString::d2c
RexxString * d2c(RexxObject *)
Definition: NumberStringClass.cpp:3440
RexxNumberString::strictLessOrEqual
RexxInteger * strictLessOrEqual(RexxObject *)
Definition: NumberStringClass.cpp:3120
RexxNumberString::ceiling
RexxObject * ceiling()
Definition: NumberStringClass.cpp:1617
RexxNumberString::hashCode
RexxObject * hashCode()
Definition: NumberStringClass.cpp:3051
RexxNumberString::andOp
RexxObject * andOp(RexxObject *)
Definition: NumberStringClass.cpp:2742
RexxNumberString::integerDivide
RexxNumberString * integerDivide(RexxObject *)
Definition: NumberStringClass.cpp:3260
RexxNumberString::orOp
RexxObject * orOp(RexxObject *)
Definition: NumberStringClass.cpp:2737
RexxNumberString::trunc
RexxObject * trunc(RexxObject *)
Definition: NumberStringClass.cpp:1297
RexxNumberString::strictNotEqual
RexxInteger * strictNotEqual(RexxObject *)
Definition: NumberStringClass.cpp:3071
RexxNumberString::power
RexxNumberString * power(RexxObject *)
Definition: NumberStringMath2.cpp:682
RexxNumberString::remainder
RexxNumberString * remainder(RexxObject *)
Definition: NumberStringClass.cpp:3285
RexxNumberString::strictGreaterOrEqual
RexxInteger * strictGreaterOrEqual(RexxObject *)
Definition: NumberStringClass.cpp:3108
RexxNumberString::equal
RexxInteger * equal(RexxObject *)
Definition: NumberStringClass.cpp:2948
RexxNumberString::isGreaterOrEqual
RexxInteger * isGreaterOrEqual(RexxObject *)
Definition: NumberStringClass.cpp:3012
RexxNumberString::d2x
RexxString * d2x(RexxObject *)
Definition: NumberStringClass.cpp:3430
RexxNumberString::isLessOrEqual
RexxInteger * isLessOrEqual(RexxObject *)
Definition: NumberStringClass.cpp:3028
RexxNumberString::plus
RexxNumberString * plus(RexxObject *)
Definition: NumberStringClass.cpp:3132
RexxNumberString::divide
RexxNumberString * divide(RexxObject *)
Definition: NumberStringClass.cpp:3234
RexxNumberString::notEqual
RexxInteger * notEqual(RexxObject *)
Definition: NumberStringClass.cpp:2964
RexxObject::isInstanceOfRexx
RexxObject * isInstanceOfRexx(RexxClass *)
Definition: ObjectClass.cpp:245
RexxObject::stringRexx
RexxString * stringRexx()
Definition: ObjectClass.cpp:2878
RexxObject::defaultNameRexx
RexxString * defaultNameRexx()
Definition: ObjectClass.cpp:2902
RexxObject::start
RexxMessage * start(RexxObject **, size_t, size_t)
Definition: ObjectClass.cpp:2071
RexxObject::objectName
RexxString * objectName()
Definition: ObjectClass.cpp:1694
RexxObject::requestRexx
RexxObject * requestRexx(RexxString *)
Definition: ObjectClass.cpp:1851
RexxObject::dynamicTargetRexx
RexxObject * dynamicTargetRexx(RexxObject **arguments, size_t argCount, size_t named_argCount)
Definition: ObjectClass.cpp:1887
RexxObject::sendWith
RexxObject * sendWith(RexxObject *, RexxArray *, RexxObject **, size_t)
Definition: ObjectClass.cpp:1901
RexxObject::concatRexx
RexxString * concatRexx(RexxObject *)
Definition: ObjectClass.cpp:2853
RexxObject::unknownRexx
RexxObject * unknownRexx(RexxString *, RexxArray *, RexxObject **, size_t)
Definition: ObjectClass.cpp:2918
RexxObject::hasMethodRexx
RexxObject * hasMethodRexx(RexxString *)
Definition: ObjectClass.cpp:2937
RexxObject::instanceMethodRexx
RexxMethod * instanceMethodRexx(RexxString *)
Definition: ObjectClass.cpp:333
RexxObject::unsetMethod
RexxObject * unsetMethod(RexxString *)
Definition: ObjectClass.cpp:1837
RexxObject::createInstance
static void createInstance()
Definition: ObjectClass.cpp:73
RexxObject::strictEqual
RexxObject * strictEqual(RexxObject *)
Definition: ObjectClass.cpp:395
RexxObject::startWith
RexxMessage * startWith(RexxObject *, RexxArray *, RexxObject **, size_t)
Definition: ObjectClass.cpp:2011
RexxObject::setMethod
RexxObject * setMethod(RexxString *, RexxMethod *, RexxString *a=OREF_NULL)
Definition: ObjectClass.cpp:1791
RexxObject::makeString
RexxString * makeString()
Definition: ObjectClass.cpp:1227
RexxObject::send
RexxObject * send(RexxObject **, size_t, size_t)
Definition: ObjectClass.cpp:1975
RexxObject::objectNameEquals
RexxObject * objectNameEquals(RexxObject *)
Definition: ObjectClass.cpp:1719
RexxObject::equal
RexxObject * equal(RexxObject *)
Definition: ObjectClass.cpp:406
RexxObject::isNilRexx
RexxObject * isNilRexx()
Definition: ObjectClass.cpp:2672
RexxObject::notEqual
RexxObject * notEqual(RexxObject *other)
Definition: ObjectClass.cpp:426
RexxObject::identityHashRexx
RexxInteger * identityHashRexx()
Definition: ObjectClass.cpp:2661
RexxObject::makeStringRexx
RexxObject * makeStringRexx()
Definition: ObjectClass.cpp:2886
RexxObject::newRexx
RexxObject * newRexx(RexxObject **arguments, size_t argCount, size_t named_argCount)
Definition: ObjectClass.cpp:2698
RexxObject::concatBlank
RexxString * concatBlank(RexxObject *)
Definition: ObjectClass.cpp:2870
RexxObject::instanceMethodsRexx
RexxSupplier * instanceMethodsRexx(RexxClass *)
Definition: ObjectClass.cpp:350
RexxObject::classObject
RexxClass * classObject()
Definition: ObjectClass.cpp:1782
RexxObject::copyRexx
RexxObject * copyRexx()
Definition: ObjectClass.cpp:2910
RexxObject::run
RexxObject * run(RexxObject **, size_t, size_t)
Definition: ObjectClass.cpp:2197
RexxObject::makeArrayRexx
RexxObject * makeArrayRexx()
Definition: ObjectClass.cpp:2894
RexxObject::strictNotEqual
RexxObject * strictNotEqual(RexxObject *other)
Definition: ObjectClass.cpp:417
RexxObject::hashCode
RexxObject * hashCode()
Definition: ObjectClass.cpp:361
RexxObject::init
RexxObject * init()
Definition: ObjectClass.cpp:2645
RexxPointer::notEqual
RexxObject * notEqual(RexxObject *other)
Definition: PointerClass.cpp:92
RexxPointer::createInstance
static void createInstance()
Definition: PointerClass.cpp:55
RexxPointer::newRexx
RexxObject * newRexx(RexxObject **args, size_t argc, size_t named_argc)
Definition: PointerClass.cpp:128
RexxPointer::equal
RexxObject * equal(RexxObject *)
Definition: PointerClass.cpp:72
RexxPointer::isNull
RexxObject * isNull()
Definition: PointerClass.cpp:155
RexxQueue::next
RexxObject * next(RexxObject *)
Definition: QueueClass.cpp:427
RexxQueue::insert
RexxObject * insert(RexxObject *, RexxObject *)
Definition: QueueClass.cpp:211
RexxQueue::peek
RexxObject * peek()
Definition: QueueClass.cpp:317
RexxQueue::remove
RexxObject * remove(RexxObject *)
Definition: QueueClass.cpp:294
RexxQueue::lastRexx
RexxObject * lastRexx()
Definition: QueueClass.cpp:410
RexxQueue::createInstance
static void createInstance()
Definition: QueueClass.cpp:58
RexxQueue::index
RexxObject * index(RexxObject *)
Definition: QueueClass.cpp:370
RexxQueue::firstRexx
RexxObject * firstRexx()
Definition: QueueClass.cpp:393
RexxQueue::pushRexx
RexxObject * pushRexx(RexxObject *)
Definition: QueueClass.cpp:78
RexxQueue::hasindex
RexxObject * hasindex(RexxObject *)
Definition: QueueClass.cpp:305
RexxQueue::supplier
RexxObject * supplier()
Definition: QueueClass.cpp:326
RexxQueue::at
RexxObject * at(RexxObject *)
Definition: QueueClass.cpp:181
RexxQueue::previous
RexxObject * previous(RexxObject *)
Definition: QueueClass.cpp:453
RexxQueue::section
RexxObject * section(RexxObject *, RexxObject *)
Definition: QueueClass.cpp:512
RexxQueue::pullRexx
RexxObject * pullRexx()
Definition: QueueClass.cpp:64
RexxQueue::allIndexes
RexxArray * allIndexes()
Definition: QueueClass.cpp:345
RexxQueue::put
RexxObject * put(RexxObject *, RexxObject *)
Definition: QueueClass.cpp:162
RexxQueue::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: QueueClass.cpp:586
RexxQueue::ofRexx
RexxQueue * ofRexx(RexxObject **, size_t, size_t)
Definition: QueueClass.cpp:611
RexxQueue::append
RexxObject * append(RexxObject *)
Definition: QueueClass.cpp:99
RexxQueue::queueRexx
RexxObject * queueRexx(RexxObject *)
Definition: QueueClass.cpp:109
RexxRelation::hasItem
RexxObject * hasItem(RexxObject *, RexxObject *)
Definition: RelationClass.cpp:152
RexxRelation::createInstance
static void createInstance()
Definition: RelationClass.cpp:58
RexxRelation::removeItemRexx
RexxObject * removeItemRexx(RexxObject *, RexxObject *)
Definition: RelationClass.cpp:125
RexxRelation::removeAll
RexxObject * removeAll(RexxObject *)
Definition: RelationClass.cpp:201
RexxRelation::put
RexxObject * put(RexxObject *, RexxObject *)
Definition: RelationClass.cpp:209
RexxRelation::allIndex
RexxObject * allIndex(RexxObject *)
Definition: RelationClass.cpp:170
RexxRelation::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: RelationClass.cpp:230
RexxStem::itemsRexx
RexxObject * itemsRexx()
Definition: StemClass.cpp:384
RexxStem::remove
RexxObject * remove(RexxObject **, size_t, size_t)
Definition: StemClass.cpp:296
RexxStem::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: StemClass.cpp:538
RexxStem::isEmpty
RexxObject * isEmpty()
Definition: StemClass.cpp:999
RexxStem::createInstance
static void createInstance()
Definition: StemClass.cpp:63
RexxStem::index
RexxObject * index(RexxObject *)
Definition: StemClass.cpp:368
RexxStem::allItems
RexxArray * allItems()
Definition: StemClass.cpp:913
RexxStem::supplier
RexxSupplier * supplier()
Definition: StemClass.cpp:1023
RexxStem::bracketEqual
RexxObject * bracketEqual(RexxObject **, size_t, size_t)
Definition: StemClass.cpp:390
RexxStem::empty
RexxObject * empty()
Definition: StemClass.cpp:987
RexxStem::bracket
RexxObject * bracket(RexxObject **, size_t, size_t)
Definition: StemClass.cpp:236
RexxStem::toDirectory
RexxDirectory * toDirectory()
Definition: StemClass.cpp:1066
RexxStem::removeItem
RexxObject * removeItem(RexxObject *)
Definition: StemClass.cpp:345
RexxStem::request
RexxObject * request(RexxString *)
Definition: StemClass.cpp:509
RexxStem::hasIndex
RexxObject * hasIndex(RexxObject **, size_t, size_t)
Definition: StemClass.cpp:265
RexxStem::hasItem
RexxObject * hasItem(RexxObject *)
Definition: StemClass.cpp:330
RexxStem::allIndexes
RexxArray * allIndexes()
Definition: StemClass.cpp:1011
RexxString::isLessOrEqual
RexxInteger * isLessOrEqual(RexxObject *)
Definition: StringClass.cpp:1480
RexxString::subWords
RexxArray * subWords(RexxInteger *, RexxInteger *)
Definition: StringClassWord.cpp:249
RexxString::isLessThan
RexxInteger * isLessThan(RexxObject *)
Definition: StringClass.cpp:1446
RexxString::concatRexx
RexxString * concatRexx(RexxObject *)
Definition: StringClass.cpp:1600
RexxString::createInstance
static void createInstance()
Definition: StringClass.cpp:71
RexxString::strictEqual
RexxInteger * strictEqual(RexxObject *)
Definition: StringClass.cpp:1340
RexxString::c2x
RexxString * c2x()
Definition: StringClassConversion.cpp:213
RexxString::caselessEquals
RexxInteger * caselessEquals(RexxString *other)
Definition: StringClass.cpp:1333
RexxString::trunc
RexxObject * trunc(RexxInteger *decimals)
Definition: StringClass.cpp:1221
RexxString::changeStr
RexxString * changeStr(RexxString *, RexxString *, RexxInteger *)
Definition: StringClassMisc.cpp:561
RexxString::caselessLastPosRexx
RexxInteger * caselessLastPosRexx(RexxString *, RexxInteger *, RexxInteger *)
Definition: StringClassMisc.cpp:487
RexxString::xorOp
RexxObject * xorOp(RexxObject *)
Definition: StringClass.cpp:2264
RexxString::translate
RexxString * translate(RexxString *, RexxString *, RexxString *, RexxInteger *, RexxInteger *)
Definition: StringClassMisc.cpp:766
RexxString::Min
RexxObject * Min(RexxObject **args, size_t argCount, size_t named_argCount)
Definition: StringClass.cpp:1203
RexxString::bitOr
RexxString * bitOr(RexxString *, RexxString *)
Definition: StringClassBit.cpp:131
RexxString::strictGreaterThan
RexxInteger * strictGreaterThan(RexxObject *)
Definition: StringClass.cpp:1497
RexxString::delstr
RexxString * delstr(RexxInteger *, RexxInteger *)
Definition: StringClassSub.cpp:128
RexxString::upperRexx
RexxString * upperRexx(RexxInteger *, RexxInteger *)
Definition: StringClass.cpp:2041
RexxString::bitAnd
RexxString * bitAnd(RexxString *, RexxString *)
Definition: StringClassBit.cpp:60
RexxString::wordIndex
RexxInteger * wordIndex(RexxInteger *)
Definition: StringClassWord.cpp:274
RexxString::notEqual
RexxInteger * notEqual(RexxObject *)
Definition: StringClass.cpp:1412
RexxString::strictLessOrEqual
RexxInteger * strictLessOrEqual(RexxObject *)
Definition: StringClass.cpp:1548
RexxString::overlay
RexxString * overlay(RexxString *, RexxInteger *, RexxInteger *, RexxString *)
Definition: StringClassSub.cpp:340
RexxString::lengthRexx
RexxObject * lengthRexx()
Definition: StringClass.cpp:637
RexxString::abbrev
RexxInteger * abbrev(RexxString *, RexxInteger *)
Definition: StringClassMisc.cpp:186
RexxString::format
RexxObject * format(RexxObject *Integers, RexxObject *Decimals, RexxObject *MathExp, RexxObject *ExpTrigger)
Definition: StringClass.cpp:1292
RexxString::b2x
RexxString * b2x()
Definition: StringClassConversion.cpp:550
RexxString::caselessMatchChar
RexxInteger * caselessMatchChar(RexxInteger *position_, RexxString *matchSet)
Definition: StringClassMisc.cpp:1057
RexxString::subWord
RexxString * subWord(RexxInteger *, RexxInteger *)
Definition: StringClassWord.cpp:229
RexxString::verify
RexxInteger * verify(RexxString *, RexxString *, RexxInteger *, RexxInteger *)
Definition: StringClassMisc.cpp:854
RexxString::caselessMatch
RexxInteger * caselessMatch(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_)
Definition: StringClassMisc.cpp:927
RexxString::caselessChangeStr
RexxString * caselessChangeStr(RexxString *, RexxString *, RexxInteger *)
Definition: StringClassMisc.cpp:631
RexxString::space
RexxString * space(RexxInteger *, RexxString *)
Definition: StringClassWord.cpp:147
RexxString::encodeBase64
RexxString * encodeBase64()
Definition: StringClassConversion.cpp:64
RexxString::caselessPosRexx
RexxInteger * caselessPosRexx(RexxString *, RexxInteger *, RexxInteger *)
Definition: StringClassMisc.cpp:721
RexxString::integerDivide
RexxObject * integerDivide(RexxObject *right)
Definition: StringClass.cpp:1076
RexxString::remainder
RexxObject * remainder(RexxObject *right)
Definition: StringClass.cpp:1101
RexxString::d2x
RexxString * d2x(RexxInteger *)
Definition: StringClassConversion.cpp:273
RexxString::Max
RexxObject * Max(RexxObject **args, size_t argCount, size_t named_argCount)
Definition: StringClass.cpp:1185
RexxString::ceiling
RexxObject * ceiling()
Definition: StringClass.cpp:1260
RexxString::match
RexxInteger * match(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_)
Definition: StringClassMisc.cpp:883
RexxString::concatBlank
RexxString * concatBlank(RexxObject *)
Definition: StringClass.cpp:1697
RexxString::caselessCountStrRexx
RexxInteger * caselessCountStrRexx(RexxString *)
Definition: StringClassMisc.cpp:549
RexxString::d2c
RexxString * d2c(RexxInteger *)
Definition: StringClassConversion.cpp:256
RexxString::lastPosRexx
RexxInteger * lastPosRexx(RexxString *, RexxInteger *, RexxInteger *)
Definition: StringClassMisc.cpp:472
RexxString::setTextRexx
RexxObject * setTextRexx(RexxObject *t)
Definition: StringClass.hpp:358
RexxString::compareToRexx
RexxInteger * compareToRexx(RexxString *other, RexxInteger *start_, RexxInteger *len_)
Definition: StringClassMisc.cpp:1094
RexxString::compare
RexxInteger * compare(RexxString *, RexxString *)
Definition: StringClassMisc.cpp:256
RexxString::plus
RexxObject * plus(RexxObject *right)
Definition: StringClass.cpp:960
RexxString::caselessCompare
RexxInteger * caselessCompare(RexxString *, RexxString *)
Definition: StringClassMisc.cpp:339
RexxString::strictLessThan
RexxInteger * strictLessThan(RexxObject *)
Definition: StringClass.cpp:1514
RexxString::strictGreaterOrEqual
RexxInteger * strictGreaterOrEqual(RexxObject *)
Definition: StringClass.cpp:1531
RexxString::bitXor
RexxString * bitXor(RexxString *, RexxString *)
Definition: StringClassBit.cpp:202
RexxString::word
RexxString * word(RexxInteger *)
Definition: StringClassWord.cpp:262
RexxString::x2d
RexxString * x2d(RexxInteger *)
Definition: StringClassConversion.cpp:308
RexxString::left
RexxString * left(RexxInteger *, RexxString *)
Definition: StringClassSub.cpp:294
RexxString::words
RexxInteger * words()
Definition: StringClassWord.cpp:328
RexxString::matchChar
RexxInteger * matchChar(RexxInteger *position_, RexxString *matchSet)
Definition: StringClassMisc.cpp:1020
RexxString::notOp
RexxObject * notOp()
Definition: StringClass.cpp:2311
RexxString::equal
RexxInteger * equal(RexxObject *)
Definition: StringClass.cpp:1395
RexxString::multiply
RexxObject * multiply(RexxObject *right)
Definition: StringClass.cpp:1026
RexxString::subchar
RexxString * subchar(RexxInteger *)
Definition: StringClassSub.cpp:716
RexxString::substr
RexxString * substr(RexxInteger *, RexxInteger *, RexxString *)
Definition: StringClassSub.cpp:694
RexxString::replaceAt
RexxString * replaceAt(RexxString *, RexxInteger *, RexxInteger *, RexxString *)
Definition: StringClassSub.cpp:457
RexxString::dataType
RexxObject * dataType(RexxString *)
Definition: StringClassMisc.cpp:442
RexxString::setEncodingRexx
RexxObject * setEncodingRexx(RexxObject *e)
Definition: StringClass.hpp:371
RexxString::andOp
RexxObject * andOp(RexxObject *)
Definition: StringClass.cpp:2202
RexxString::caselessWordPos
RexxInteger * caselessWordPos(RexxString *, RexxInteger *)
Definition: StringClassWord.cpp:316
RexxString::c2d
RexxString * c2d(RexxInteger *)
Definition: StringClassConversion.cpp:602
RexxString::caselessCompareToRexx
RexxInteger * caselessCompareToRexx(RexxString *other, RexxInteger *start_, RexxInteger *len_)
Definition: StringClassMisc.cpp:1181
RexxString::round
RexxObject * round()
Definition: StringClass.cpp:1278
RexxString::posRexx
RexxInteger * posRexx(RexxString *, RexxInteger *, RexxInteger *)
Definition: StringClassMisc.cpp:702
RexxString::wordLength
RexxInteger * wordLength(RexxInteger *)
Definition: StringClassWord.cpp:286
RexxString::copies
RexxString * copies(RexxInteger *)
Definition: StringClassMisc.cpp:394
RexxString::right
RexxString * right(RexxInteger *, RexxString *)
Definition: StringClassSub.cpp:568
RexxString::x2b
RexxString * x2b()
Definition: StringClassConversion.cpp:612
RexxString::x2c
RexxString * x2c()
Definition: StringClassConversion.cpp:290
RexxString::reverse
RexxString * reverse()
Definition: StringClassSub.cpp:531
RexxString::isASCIIRexx
RexxInteger * isASCIIRexx()
Definition: StringClass.cpp:1836
RexxString::countStrRexx
RexxInteger * countStrRexx(RexxString *)
Definition: StringClassMisc.cpp:536
RexxString::wordPos
RexxInteger * wordPos(RexxString *, RexxInteger *)
Definition: StringClassWord.cpp:301
RexxString::floor
RexxObject * floor()
Definition: StringClass.cpp:1242
RexxString::caselessAbbrev
RexxInteger * caselessAbbrev(RexxString *, RexxInteger *)
Definition: StringClassMisc.cpp:227
RexxString::isGreaterOrEqual
RexxInteger * isGreaterOrEqual(RexxObject *)
Definition: StringClass.cpp:1463
RexxString::orOp
RexxObject * orOp(RexxObject *)
Definition: StringClass.cpp:2233
RexxString::newRexx
RexxString * newRexx(RexxObject **, size_t, size_t)
Definition: StringClass.cpp:2770
RexxString::divide
RexxObject * divide(RexxObject *right)
Definition: StringClass.cpp:1051
RexxString::insert
RexxString * insert(RexxString *, RexxInteger *, RexxInteger *, RexxString *)
Definition: StringClassSub.cpp:189
RexxString::strip
RexxString * strip(RexxString *, RexxString *)
Definition: StringClassSub.cpp:621
RexxString::delWord
RexxString * delWord(RexxInteger *, RexxInteger *)
Definition: StringClassWord.cpp:62
RexxString::equals
RexxInteger * equals(RexxString *other)
Definition: StringClass.cpp:1319
RexxString::abs
RexxObject * abs()
Definition: StringClass.cpp:1151
RexxString::isGreaterThan
RexxInteger * isGreaterThan(RexxObject *)
Definition: StringClass.cpp:1429
RexxString::power
RexxObject * power(RexxObject *right)
Definition: StringClass.cpp:1126
RexxString::decodeBase64
RexxString * decodeBase64()
Definition: StringClassConversion.cpp:128
RexxString::lowerRexx
RexxString * lowerRexx(RexxInteger *, RexxInteger *)
Definition: StringClass.cpp:2007
RexxString::strictNotEqual
RexxInteger * strictNotEqual(RexxObject *)
Definition: StringClass.cpp:1368
RexxString::center
RexxString * center(RexxInteger *, RexxString *)
Definition: StringClassSub.cpp:63
RexxString::sign
RexxObject * sign()
Definition: StringClass.cpp:1168
RexxString::minus
RexxObject * minus(RexxObject *right)
Definition: StringClass.cpp:993
RexxSupplierClass::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: SupplierClass.cpp:245
RexxSupplier::next
RexxObject * next()
Definition: SupplierClass.cpp:131
RexxSupplier::available
RexxInteger * available()
Definition: SupplierClass.cpp:122
RexxSupplier::value
RexxObject * value()
Definition: SupplierClass.cpp:146
RexxSupplier::index
RexxObject * index()
Definition: SupplierClass.cpp:166
RexxSupplier::initRexx
RexxObject * initRexx(RexxArray *values, RexxArray *indexes)
Definition: SupplierClass.cpp:220
RexxSupplier::createInstance
static void createInstance()
Definition: SupplierClass.cpp:59
RexxTable::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: TableClass.cpp:187
RexxTable::createInstance
static void createInstance()
Definition: TableClass.cpp:58
RexxTable::itemsRexx
RexxObject * itemsRexx()
Definition: TableClass.cpp:147
RexxText::createInstance
static void createInstance()
Definition: TextClass.cpp:56
RexxText::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: TextClass.cpp:126
RoutineClass::callRexx
RexxObject * callRexx(RexxObject **, size_t, size_t)
Definition: RoutineClass.cpp:266
RoutineClass::setSecurityManager
RexxObject * setSecurityManager(RexxObject *)
Definition: RoutineClass.cpp:364
RoutineClass::loadExternalRoutine
RoutineClass * loadExternalRoutine(RexxString *name, RexxString *descriptor)
Definition: RoutineClass.cpp:953
RoutineClass::callWithRexx
RexxObject * callWithRexx(RexxArray *, RexxObject **, size_t)
Definition: RoutineClass.cpp:282
RoutineClass::newRexx
RoutineClass * newRexx(RexxObject **, size_t, size_t)
Definition: RoutineClass.cpp:602
RoutineClass::newFileRexx
RoutineClass * newFileRexx(RexxString *)
Definition: RoutineClass.cpp:678
RoutineClass::createInstance
static void createInstance()
Definition: RoutineClass.cpp:77
StackFrameClass::getType
RexxString * getType()
Definition: StackFrameClass.cpp:179
StackFrameClass::newRexx
RexxObject * newRexx(RexxObject **args, size_t argc, size_t named_argc)
Definition: StackFrameClass.cpp:122
StackFrameClass::getTraceLine
RexxString * getTraceLine()
Definition: StackFrameClass.cpp:203
StackFrameClass::getArguments
RexxArray * getArguments()
Definition: StackFrameClass.cpp:246
StackFrameClass::createInstance
static void createInstance()
Definition: StackFrameClass.cpp:53
StackFrameClass::getLine
RexxObject * getLine()
Definition: StackFrameClass.cpp:228
StackFrameClass::getName
RexxString * getName()
Definition: StackFrameClass.cpp:191
StackFrameClass::getTarget
RexxObject * getTarget()
Definition: StackFrameClass.cpp:280
StackFrameClass::getExecutable
RexxObject * getExecutable()
Definition: StackFrameClass.cpp:214
SystemInterpreter::getSystemName
static RexxString * getSystemName()
Definition: windows/MiscSystem.cpp:56
Unicode::copyRexx
RexxObject * copyRexx()
Definition: TextClass.cpp:330
Unicode::utf8proc_transform
RexxObject * utf8proc_transform(RexxString *str, RexxObject **named_arglist, size_t named_argcount)
Definition: TextClass.cpp:681
Unicode::utf8proc_graphemeBreak
RexxInteger * utf8proc_graphemeBreak(RexxArray *)
Definition: TextClass.cpp:410
Unicode::utf8proc_codepointCharWidth
RexxInteger * utf8proc_codepointCharWidth(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:573
Unicode::utf8proc_codepointCategory
RexxInteger * utf8proc_codepointCategory(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:422
Unicode::utf8proc_codepointBidiClass
RexxInteger * utf8proc_codepointBidiClass(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:473
Unicode::utf8proc_codepointToTitleSimple
RexxInteger * utf8proc_codepointToTitleSimple(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:639
Unicode::createInstance
static void createInstance()
Definition: TextClass.cpp:318
Unicode::utf8proc_version
RexxString * utf8proc_version()
Definition: TextClass.cpp:393
Unicode::utf8proc_codepointControlBoundary
RexxInteger * utf8proc_codepointControlBoundary(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:565
Unicode::utf8proc_codepointToUpperSimple
RexxInteger * utf8proc_codepointToUpperSimple(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:632
Unicode::utf8proc_codepointIsLower
RexxInteger * utf8proc_codepointIsLower(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:646
Unicode::unialgo_version
RexxString * unialgo_version()
Definition: TextClass.cpp:800
Unicode::utf8proc_codepointToLowerSimple
RexxInteger * utf8proc_codepointToLowerSimple(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:625
Unicode::utf8proc_codepointDecompositionType
RexxInteger * utf8proc_codepointDecompositionType(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:517
Unicode::systemIsLittleEndian
RexxInteger * systemIsLittleEndian()
Definition: TextClass.cpp:359
Unicode::utf8proc_codepointBoundClass
RexxInteger * utf8proc_codepointBoundClass(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:585
Unicode::utf8proc_codepointIsUpper
RexxInteger * utf8proc_codepointIsUpper(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:654
Unicode::utf8proc_codepointIgnorable
RexxInteger * utf8proc_codepointIgnorable(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:557
Unicode::utf8proc_codepointBidiMirrored
RexxInteger * utf8proc_codepointBidiMirrored(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:509
Unicode::newRexx
RexxObject * newRexx(RexxObject **, size_t, size_t)
Definition: TextClass.cpp:323
Unicode::utf8proc_codepointCombiningClass
RexxInteger * utf8proc_codepointCombiningClass(RexxObject *rexxCodepoint)
Definition: TextClass.cpp:465
WeakReference::createInstance
static void createInstance()
Definition: WeakReferenceClass.cpp:52
WeakReference::newRexx
RexxObject * newRexx(RexxObject **args, size_t argc, size_t named_argc)
Definition: WeakReferenceClass.cpp:187
WeakReference::value
RexxObject * value()
Definition: WeakReferenceClass.cpp:177
loader
void RexxEntry loader(RexxThreadContext *context)
Definition: rxsock.cpp:623
BASEIMAGELOAD
#define BASEIMAGELOAD
Definition: unix/PlatformDefinitions.h:154