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