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