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"
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 
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 
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 
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 
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.
144  memoryObject.createStrings(); /* create all of the OREF_ strings */
145  // initializer for native libraries
147 
148  /* avoid that through caching */
149  /* TheTrueObject == IntegerOne etc. */
150  TheTrueObject = new RexxInteger(1);
151  TheFalseObject = new RexxInteger(0);
152 
153 
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 */
166 
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.... */
176  IntegerSix = new_integer(6);
181 
182 
183  /* RexxNumberString */
184  // NOTE: The number string class lies about its identity
187 
188  // The pointer class needs to be created early because other classes
189  // use the instances to store information.
191 
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 */
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 */
219 
223 
224  /* build the common retriever tables */
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 */
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 */
274  /* Class operator methods.... */
284  // this is explicitly inserted into the class behaviour because it gets used
285  // prior to the instance behavior merges.
287  // this is a NOP by default, so we'll just use the object init method as a fill in.
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 */
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 */
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 
358  /* set the scope of the methods to */
359  /* this classes oref */
360  TheArrayClassBehaviour->setMethodDictionaryScope(TheArrayClass);
361 
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.
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 
413 
414  /* set the scope of the method to */
415  /* this classes oref */
416  TheDirectoryClassBehaviour->setMethodDictionaryScope(TheDirectoryClass);
417 
418  /* add the instance methods */
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 */
458 
459  /* set the scope of the methods to */
460  /* this classes oref */
461  TheListClassBehaviour->setMethodDictionaryScope(TheListClass);
462 
463  /* add the instance behaviour methods*/
479  // DELETE is the same as REMOVE for the List class
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 */
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 
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 */
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 */
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 */
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 */
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 */
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 */
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 */
650  /* set the scope of the methods to */
651  /* this classes oref */
652  TheRexxContextClassBehaviour->setMethodDictionaryScope(TheRexxContextClass);
653 
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 */
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 
707  // REMOVE and DELETE are synonyms for the QUEUE class
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 */
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 */
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 */
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 */
802 
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 */
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 */
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 */
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 */
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 */
984 
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 
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 */
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 
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 */
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 */
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 
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
1360  // the string method just maps to TRACELINE
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 */
1409 
1410  /* set up the kernel directory (MEMORY done elsewhere) */
1413 
1414  // TODO: Make the kernel directory part of the memory object, but not in the
1415  // environment.
1416 
1422 
1423  /* set Oryx version */
1425  /* set the system name */
1427  /* set the internal system name */
1429  /* and the system version info */
1431  // initialize our thread vector for external calls.
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
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 */
1451  // create a new stack frame to run under
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 */
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 
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 
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 
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
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