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)  

ThreadContextStubs.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.ibm.com/developerworks/oss/CPLv1.0.htm */
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 API support */
40 /* */
41 /* Stub functions for all APIs accessed via the NativeMethodContext */
42 /* */
43 /******************************************************************************/
44 
45 #include "RexxCore.h"
46 #include "ContextApi.hpp"
47 #include "RexxActivity.hpp"
48 #include "StringClass.hpp"
49 #include "IntegerClass.hpp"
50 #include "BufferClass.hpp"
51 #include "SupplierClass.hpp"
52 #include "ArrayClass.hpp"
53 #include "DirectoryClass.hpp"
54 #include "MethodClass.hpp"
55 #include "RoutineClass.hpp"
56 #include "PackageClass.hpp"
57 #include "Interpreter.hpp"
58 #include "InterpreterInstance.hpp"
59 #include "SystemInterpreter.hpp"
60 #include "PointerClass.hpp"
61 #include "ActivityManager.hpp"
62 #include "RexxStartDispatcher.hpp"
63 #include "PackageManager.hpp"
64 #include "MutableBufferClass.hpp"
65 
67 
69 {
70  // we do this one without grabbing the lock because we're going away.
71  ApiContext context(c, false);
72  try
73  {
74  context.activity->detachThread();
75  }
76  catch (RexxNativeActivation *)
77  {
78  }
79 }
80 
81 
86 {
87  ApiContext context(c);
88  try
89  {
90  context.activity->halt(OREF_NULL);
91  }
92  catch (RexxNativeActivation *)
93  {
94  }
95 }
96 
97 
99 {
100  ApiContext context(c);
101  try
102  {
103  context.activity->setTrace(setting != 0);
104  }
105  catch (RexxNativeActivation *)
106  {
107  }
108 }
109 
110 
112 {
113  ApiContext context(c);
114  try
115  {
117  return o;
118  }
119  catch (RexxNativeActivation *)
120  {
121  }
122  return NULLOBJECT;
123 }
124 
125 
127 {
128  ApiContext context(c);
129  try
130  {
132  }
133  catch (RexxNativeActivation *)
134  {
135  }
136 }
137 
138 
140 {
141  ApiContext context(c);
142  try
143  {
144  context.context->removeLocalReference((RexxObject *)o);
145  }
146  catch (RexxNativeActivation *)
147  {
148  }
149 }
150 
151 //NB: The name "SendMessage" has a conflict with a Windows API, so this name differs from
152 // the call vector version.
154 {
155  ApiContext context(c);
156  try
157  {
158  RexxString *message = new_upper_string(m);
159  ProtectedObject p(message);
160 
161  return context.ret(((RexxObject *)o)->sendMessage(message, (RexxArray *)a));
162  }
163  catch (RexxNativeActivation *)
164  {
165  }
166  return NULLOBJECT;
167 }
168 
169 
171 {
172  ApiContext context(c);
173  try
174  {
175  RexxString *message = new_upper_string(m);
176  ProtectedObject p(message);
177  return context.ret(((RexxObject *)o)->sendMessage(message));
178  }
179  catch (RexxNativeActivation *)
180  {
181  }
182  return NULLOBJECT;
183 }
184 
185 
187 {
188  ApiContext context(c);
189  try
190  {
191  RexxString *message = new_upper_string(m);
192  ProtectedObject p(message);
193  return context.ret(((RexxObject *)o)->sendMessage(message, (RexxObject *)a1));
194  }
195  catch (RexxNativeActivation *)
196  {
197  }
198  return NULLOBJECT;
199 }
200 
202 {
203  ApiContext context(c);
204  try
205  {
206  RexxString *message = new_upper_string(m);
207  ProtectedObject p(message);
208  return context.ret(((RexxObject *)o)->sendMessage(message, (RexxObject *)a1, (RexxObject *)a2));
209  }
210  catch (RexxNativeActivation *)
211  {
212  }
213  return NULLOBJECT;
214 }
215 
217 {
218  ApiContext context(c);
219  try
220  {
221  return (RexxDirectoryObject)context.activity->getLocal();
222  }
223  catch (RexxNativeActivation *)
224  {
225  }
226  return NULLOBJECT;
227 }
228 
230 {
231  ApiContext context(c);
232  try
233  {
235  }
236  catch (RexxNativeActivation *)
237  {
238 
239  }
240  return NULLOBJECT;
241 }
242 
244 {
245  ApiContext context(c);
246  try
247  {
248  return ((RexxObject *)o)->isInstanceOf((RexxClass *)cl);
249  }
250  catch (RexxNativeActivation *)
251  {
252  }
253  return 0;
254 }
255 
257 {
258  ApiContext context(c);
259  try
260  {
261  // convert the name to a string instance, and get the class object from
262  // our current context
263  RexxString *name = new_upper_string(cn);
264  ProtectedObject p(name);
265  RexxClass *classObject = context.context->findClass(name);
266  // if not found, this is always false
267  if (classObject == OREF_NULL)
268  {
269  return false;
270  }
271  return ((RexxObject *)o)->isInstanceOf(classObject);
272  }
273  catch (RexxNativeActivation *)
274  {
275  }
276  return 0;
277 }
278 
279 
281 {
282  ApiContext context(c);
283  try
284  {
285  RexxString *name = new_upper_string(n);
286  ProtectedObject p(name);
287  // convert the name to a string instance, and check the environments.
288  return ((RexxObject *)o)->hasMethod(name) == TheTrueObject;
289 
290  }
291  catch (RexxNativeActivation *)
292  {
293  }
294  return 0;
295 }
296 
297 
299 {
300  ApiContext context(c);
301  try
302  {
303  RexxString *name = new_string(n);
304  ProtectedObject p(name);
305  RexxString *resolvedName = context.activity->getInstance()->resolveProgramName(name, OREF_NULL, OREF_NULL);
306 
307  // convert the name to a string instance, and check the environments.
308  return (RexxPackageObject)context.ret(context.activity->getInstance()->loadRequires(context.activity, name, resolvedName));
309  }
310  catch (RexxNativeActivation *)
311  {
312  }
313  return NULLOBJECT;
314 }
315 
316 
318 {
319  ApiContext context(c);
320  try
321  {
322  RexxString *name = new_string(n);
323  ProtectedObject p(name);
324  return (RexxPackageObject)context.ret(context.activity->getInstance()->loadRequires(context.activity, name, d, l));
325  }
326  catch (RexxNativeActivation *)
327  {
328  }
329  return NULLOBJECT;
330 }
331 
332 
334 {
335  ApiContext context(c);
336  try
337  {
338  RexxString *name = new_string(n);
339  ProtectedObject p(name);
340 
341  // convert the name to a string instance, and check the environments.
342  return PackageManager::loadLibrary(name) != OREF_NULL;
343  }
344  catch (RexxNativeActivation *)
345  {
346  }
347  return false;
348 }
349 
350 
352 {
353  ApiContext context(c);
354  try
355  {
356  RexxString *name = new_string(n);
357  ProtectedObject p(name);
358 
359  // convert the name to a string instance, and check the environments.
360  return PackageManager::registerPackage(name, e);
361  }
362  catch (RexxNativeActivation *)
363  {
364  }
365  return false;
366 }
367 
368 
370 {
371  ApiContext context(c);
372  try
373  {
374  // convert the name to a string instance, and check the environments.
375  RexxString *name = new_upper_string(n);
376  ProtectedObject p(name);
377  return (RexxClassObject)context.ret(context.context->findClass(name));
378 
379  }
380  catch (RexxNativeActivation *)
381  {
382  }
383  return NULLOBJECT;
384 }
385 
386 
388 {
389  ApiContext context(c);
390  try
391  {
392  // convert the name to a string instance, and check the environments.
393  RexxString *name = new_upper_string(n);
394  ProtectedObject p(name);
395  return (RexxClassObject)context.ret(((PackageClass *)m)->findClass(name));
396 
397  }
398  catch (RexxNativeActivation *)
399  {
400  }
401  return NULLOBJECT;
402 }
403 
404 
406 {
407  ApiContext context(c);
408  try
409  {
410  return (RexxDirectoryObject)context.ret(((PackageClass *)m)->getRoutines());
411  }
412  catch (RexxNativeActivation *)
413  {
414  }
415  return NULLOBJECT;
416 }
417 
418 
420 {
421  ApiContext context(c);
422  try
423  {
424  return (RexxDirectoryObject)context.ret(((PackageClass *)m)->getPublicRoutines());
425  }
426  catch (RexxNativeActivation *)
427  {
428  }
429  return NULLOBJECT;
430 }
431 
433 {
434  ApiContext context(c);
435  try
436  {
437  return (RexxDirectoryObject)context.ret(((PackageClass *)m)->getClasses());
438  }
439  catch (RexxNativeActivation *)
440  {
441  }
442  return NULLOBJECT;
443 }
444 
446 {
447  ApiContext context(c);
448  try
449  {
450  return (RexxDirectoryObject)context.ret(((PackageClass *)m)->getPublicClasses());
451  }
452  catch (RexxNativeActivation *)
453  {
454  }
455  return NULLOBJECT;
456 }
457 
459 {
460  ApiContext context(c);
461  try
462  {
463  return (RexxDirectoryObject)context.ret(((PackageClass *)m)->getClasses());
464  }
465  catch (RexxNativeActivation *)
466  {
467  }
468  return NULLOBJECT;
469 }
470 
471 
473 {
474  ApiContext context(c);
475  try
476  {
477  CallRoutineDispatcher dispatcher((RoutineClass *)r, (RexxArray *)a);
478  context.activity->run(dispatcher);
479  return (RexxObjectPtr)context.ret(dispatcher.result);
480  }
481  catch (RexxNativeActivation *)
482  {
483  }
484  return NULLOBJECT;
485 }
486 
487 
489 {
490  ApiContext context(c);
491  try
492  {
493  CallProgramDispatcher dispatcher(p, (RexxArray *)a);
494  context.activity->run(dispatcher);
495  return (RexxObjectPtr)context.ret(dispatcher.result);
496  }
497  catch (RexxNativeActivation *)
498  {
499  }
500  return NULLOBJECT;
501 }
502 
503 
505 {
506  ApiContext context(c);
507  try
508  {
509  RexxString *name = new_string(n);
510  ProtectedObject p(name);
511  // convert the name to a string instance, and check the environments.
512  return (RexxMethodObject)context.ret(new RexxMethod(new_string(n), source, length));
513  }
514  catch (RexxNativeActivation *)
515  {
516  }
517  return NULLOBJECT;
518 }
519 
520 
522 {
523  ApiContext context(c);
524  try
525  {
526  RexxString *name = new_string(n);
527  ProtectedObject p(name);
528  // convert the name to a string instance, and check the environments.
529  return (RexxRoutineObject)context.ret(new RoutineClass(name, source, length));
530  }
531  catch (RexxNativeActivation *)
532  {
533  }
534  return NULLOBJECT;
535 }
536 
537 
539 {
540  ApiContext context(c);
541  try
542  {
543  // convert the name to a string instance, and check the environments.
544  return (logical_t)((RexxObject *)o)->isInstanceOf(TheRoutineClass);
545  }
546  catch (RexxNativeActivation *)
547  {
548  }
549  return false;
550 }
551 
552 
554 {
555  ApiContext context(c);
556  try
557  {
558  // convert the name to a string instance, and check the environments.
559  return (logical_t)((RexxObject *)o)->isInstanceOf(TheMethodClass);
560  }
561  catch (RexxNativeActivation *)
562  {
563  }
564  return false;
565 }
566 
567 
569 {
570  ApiContext context(c);
571  try
572  {
573  // convert the name to a string instance, and check the environments.
574  return (RexxPackageObject)context.ret(((RoutineClass *)o)->getPackage());
575  }
576  catch (RexxNativeActivation *)
577  {
578  }
579  return false;
580 }
581 
582 
584 {
585  ApiContext context(c);
586  try
587  {
588  // convert the name to a string instance, and check the environments.
589  return (RexxPackageObject)context.ret(((RexxMethod *)o)->getPackage());
590  }
591  catch (RexxNativeActivation *)
592  {
593  }
594  return false;
595 }
596 
597 
599 {
600  ApiContext context(c);
601  try
602  {
603  // ask the object to figure this out
604  return ((RexxObject *)o)->getCSelf();
605  }
606  catch (RexxNativeActivation *)
607  {
608  }
609  return NULL;
610 }
611 
612 
614 {
615  ApiContext context(c);
616  try
617  {
618  // ask the object to figure this out
619  return ((RexxObject *)o)->getCSelf((RexxObject *)s);
620  }
621  catch (RexxNativeActivation *)
622  {
623  }
624  return NULL;
625 }
626 
627 
629 {
630  ApiContext context(c);
631  try
632  {
633  return context.ret(Numerics::wholenumberToObject((wholenumber_t)n));
634  }
635  catch (RexxNativeActivation *)
636  {
637  }
638  return NULLOBJECT;
639 }
640 
642 {
643  ApiContext context(c);
644  try
645  {
646  return context.ret(Numerics::uintptrToObject(n));
647  }
648  catch (RexxNativeActivation *)
649  {
650  }
651  return NULLOBJECT;
652 }
653 
655 {
656  ApiContext context(c);
657  try
658  {
659  return context.ret(Numerics::intptrToObject(n));
660  }
661  catch (RexxNativeActivation *)
662  {
663  }
664  return NULLOBJECT;
665 }
666 
667 
669 {
670  ApiContext context(c);
671  try
672  {
673  return (RexxObjectPtr)context.ret(context.context->valueToObject(d));
674  }
675  catch (RexxNativeActivation *)
676  {
678  }
679  return NULLOBJECT;
680 }
681 
682 
684 {
685  ApiContext context(c);
686  try
687  {
688  return (RexxArrayObject)context.ret(context.context->valuesToObject(d, count));
689  }
690  catch (RexxNativeActivation *)
691  {
693  }
694  return NULLOBJECT;
695 }
696 
697 
699 {
700  ApiContext context(c);
701  try
702  {
703  return context.context->objectToValue((RexxObject *)o, d);
704  }
705  catch (RexxNativeActivation *)
706  {
707  // some conversion failures result in an exception...cancel that, and
708  // just return FALSE;
710  }
711  return false;
712 }
713 
715 {
716  ApiContext context(c);
717  try
718  {
719  return context.ret(Numerics::stringsizeToObject((stringsize_t)n));
720  }
721  catch (RexxNativeActivation *)
722  {
723  }
724  return NULLOBJECT;
725 }
726 
727 
729 {
730  ApiContext context(c);
731  try
732  {
733  wholenumber_t temp;
734  // this uses the entire value range
735  // NB: SSIZE_MIN appears to be defined as 0 for some bizarre reason on some platforms,
736  // so we'll make things relative to SIZE_MAX.
738  {
739  *n = (wholenumber_t)temp;
740  return true;
741  }
742  return false;
743  }
744  catch (RexxNativeActivation *)
745  {
746  }
747  return 0;
748 }
749 
750 
752 {
753  ApiContext context(c);
754  try
755  {
756  return context.ret(Numerics::wholenumberToObject((wholenumber_t)n));
757  }
758  catch (RexxNativeActivation *)
759  {
760  }
761  return NULLOBJECT;
762 }
763 
764 
766 {
767  ApiContext context(c);
768  try
769  {
770  return context.ret(Numerics::stringsizeToObject((uint32_t)n));
771  }
772  catch (RexxNativeActivation *)
773  {
774  }
775  return NULLOBJECT;
776 }
777 
778 
780 {
781  ApiContext context(c);
782  try
783  {
784  stringsize_t temp;
785  // this uses the entire value range
787  {
788  *n = (stringsize_t)temp;
789  return true;
790  }
791  return false;
792  }
793  catch (RexxNativeActivation *)
794  {
795  }
796  return 0;
797 }
798 
799 
801 {
802  ApiContext context(c);
803  try
804  {
805  ssize_t temp;
806  // this uses the entire value range
807  // NB: SSIZE_MIN appears to be defined as 0 for some bizarre reason on some platforms,
808  // so we'll make things relative to SIZE_MAX.
809  if (Numerics::objectToSignedInteger((RexxObject *)o, temp, INT32_MAX, INT32_MIN))
810  {
811  *n = (int32_t)temp;
812  return true;
813  }
814  return false;
815  }
816  catch (RexxNativeActivation *)
817  {
818  }
819  return 0;
820 }
821 
822 
824 {
825  ApiContext context(c);
826  try
827  {
828  size_t temp;
829  // this uses the entire value range
830  if (Numerics::objectToUnsignedInteger((RexxObject *)o, temp, UINT32_MAX))
831  {
832  *n = (uint32_t)temp;
833  return true;
834  }
835  return false;
836  }
837  catch (RexxNativeActivation *)
838  {
839  }
840  return 0;
841 }
842 
843 
845 {
846  ApiContext context(c);
847  try
848  {
849  return context.ret(Numerics::int64ToObject(n));
850  }
851  catch (RexxNativeActivation *)
852  {
853  }
854  return NULLOBJECT;
855 }
856 
858 {
859  ApiContext context(c);
860  try
861  {
862  return context.ret(Numerics::uint64ToObject(n));
863  }
864  catch (RexxNativeActivation *)
865  {
866  }
867  return NULLOBJECT;
868 }
869 
871 {
872  ApiContext context(c);
873  try
874  {
875  // this uses the entire value range
876  return Numerics::objectToInt64((RexxObject *)o, *n);
877  }
878  catch (RexxNativeActivation *)
879  {
880  }
881  return 0;
882 }
883 
885 {
886  ApiContext context(c);
887  try
888  {
889  // this uses the entire value range
891  }
892  catch (RexxNativeActivation *)
893  {
894  }
895  return 0;
896 }
897 
899 {
900  ApiContext context(c);
901  try
902  {
903  // this uses the entire value range
904  return Numerics::objectToUintptr((RexxObject *)o, *n);
905  }
906  catch (RexxNativeActivation *)
907  {
908  }
909  return 0;
910 }
911 
913 {
914  ApiContext context(c);
915  try
916  {
917  // this uses the entire value range
918  return Numerics::objectToIntptr((RexxObject *)o, *n);
919  }
920  catch (RexxNativeActivation *)
921  {
922  }
923  return 0;
924 }
925 
927 {
928  ApiContext context(c);
929  try
930  {
931  // this uses the entire value range
932  return ((RexxObject *)o)->logicalValue(*n);
933  }
934  catch (RexxNativeActivation *)
935  {
936  }
937  return 0;
938 }
939 
941 {
942  ApiContext context(c);
943  try
944  {
946  }
947  catch (RexxNativeActivation *)
948  {
949  }
950  return NULLOBJECT;
951 }
952 
954 {
955  ApiContext context(c);
956  try
957  {
958  return context.ret(new_numberstringFromDouble(n));
959  }
960  catch (RexxNativeActivation *)
961  {
962  }
963  return NULLOBJECT;
964 }
965 
967 {
968  ApiContext context(c);
969  try
970  {
971  return context.ret(new_numberstringFromDouble(n, precision));
972  }
973  catch (RexxNativeActivation *)
974  {
975  }
976  return NULLOBJECT;
977 }
978 
980 {
981  ApiContext context(c);
982  try
983  {
984  return ((RexxObject *)o)->doubleValue(*n);
985  }
986  catch (RexxNativeActivation *)
987  {
988  }
989  return 0;
990 }
991 
993 {
994  ApiContext context(c);
995  try
996  {
997  return (RexxStringObject)context.ret(REQUEST_STRING((RexxObject *)o));
998  }
999  catch (RexxNativeActivation *)
1000  {
1001  }
1002  return NULLOBJECT;
1003 }
1004 
1006 {
1007  ApiContext context(c);
1008  try
1009  {
1010  RexxString *temp = REQUEST_STRING((RexxObject *)o);
1011  context.ret(temp);
1012  return (CSTRING)temp->getStringData();
1013  }
1014  catch (RexxNativeActivation *)
1015  {
1016  }
1017  return NULL;
1018 }
1019 
1020 size_t RexxEntry StringGet(RexxThreadContext *c, RexxStringObject s, size_t o, POINTER r, size_t l)
1021 {
1022  ApiContext context(c);
1023  try
1024  {
1025  RexxString *temp = (RexxString *)s;
1026  return temp->copyData(o - 1, (char *)r, l);
1027  }
1028  catch (RexxNativeActivation *)
1029  {
1030  }
1031  return 0;
1032 }
1033 
1035 {
1036  ApiContext context(c);
1037  try
1038  {
1039  RexxString *temp = (RexxString *)s;
1040  return temp->getLength();
1041  }
1042  catch (RexxNativeActivation *)
1043  {
1044  }
1045  return 0;
1046 }
1047 
1049 {
1050  ApiContext context(c);
1051  try
1052  {
1053  RexxString *temp = (RexxString *)s;
1054  return (CSTRING)temp->getStringData();
1055  }
1056  catch (RexxNativeActivation *)
1057  {
1058  }
1059  return NULL;
1060 }
1061 
1063 {
1064  ApiContext context(c);
1065  try
1066  {
1067  return (RexxStringObject)context.ret(new_string(s, (stringsize_t)l));
1068  }
1069  catch (RexxNativeActivation *)
1070  {
1071  }
1072  return NULLOBJECT;
1073 }
1074 
1076 {
1077  ApiContext context(c);
1078  try
1079  {
1080  return (RexxStringObject)context.ret(new_string((const char *)s));
1081  }
1082  catch (RexxNativeActivation *)
1083  {
1084  }
1085  return NULLOBJECT;
1086 }
1087 
1089 {
1090  ApiContext context(c);
1091  try
1092  {
1093  RexxString *temp = (RexxString *)s;
1094  return (RexxStringObject)context.ret(temp->upper());
1095  }
1096  catch (RexxNativeActivation *)
1097  {
1098  }
1099  return NULLOBJECT;
1100 }
1101 
1103 {
1104  ApiContext context(c);
1105  try
1106  {
1107  RexxString *temp = (RexxString *)s;
1108  return (RexxStringObject)context.ret(temp->lower());
1109  }
1110  catch (RexxNativeActivation *)
1111  {
1112  }
1113  return NULLOBJECT;
1114 }
1115 
1117 {
1118  ApiContext context(c);
1119  try
1120  {
1121  return isString((RexxObject *)o);
1122  }
1123  catch (RexxNativeActivation *)
1124  {
1125  }
1126  return 0;
1127 }
1128 
1130 {
1131  ApiContext context(c);
1132  try
1133  {
1134  return (RexxBufferStringObject)context.ret(raw_string((stringsize_t)l));
1135  }
1136  catch (RexxNativeActivation *)
1137  {
1138  }
1139  return NULLOBJECT;
1140 }
1141 
1143 {
1144  ApiContext context(c);
1145  try
1146  {
1147  RexxString *temp = (RexxString *)s;
1148  return temp->getLength();
1149  }
1150  catch (RexxNativeActivation *)
1151  {
1152  }
1153  return 0;
1154 }
1155 
1157 {
1158  ApiContext context(c);
1159  try
1160  {
1161  RexxString *temp = (RexxString *)s;
1162  return (POINTER)temp->getWritableData();
1163  }
1164  catch (RexxNativeActivation *)
1165  {
1166  }
1167  return NULL;
1168 }
1169 
1171 {
1172  ApiContext context(c);
1173  try
1174  {
1175  RexxString *temp = (RexxString *)s;
1176  temp->finish(l);
1177  return s;
1178  }
1179  catch (RexxNativeActivation *)
1180  {
1181  }
1182  return NULL;
1183 }
1184 
1186 {
1187  ApiContext context(c);
1188  try
1189  {
1190  RexxString *index = new_string(i);
1191  ProtectedObject p(index);
1192  ((RexxDirectory *)t)->put((RexxObject *)o, index);
1193  }
1194  catch (RexxNativeActivation *)
1195  {
1196  }
1197 }
1198 
1200 {
1201  ApiContext context(c);
1202  try
1203  {
1204  RexxString *index = new_string(i);
1205  ProtectedObject p(index);
1206  return context.ret(((RexxDirectory *)t)->at(index));
1207  }
1208  catch (RexxNativeActivation *)
1209  {
1210  }
1211  return OREF_NULL;
1212 }
1213 
1215 {
1216  ApiContext context(c);
1217  try
1218  {
1219  RexxString *index = new_string(i);
1220  ProtectedObject p(index);
1221  return context.ret(((RexxDirectory *)t)->remove(index));
1222  }
1223  catch (RexxNativeActivation *)
1224  {
1225  }
1226  return OREF_NULL;
1227 }
1228 
1230 {
1231  ApiContext context(c);
1232  try
1233  {
1234  return (RexxDirectoryObject)context.ret(new_directory());
1235  }
1236  catch (RexxNativeActivation *)
1237  {
1238  }
1239  return OREF_NULL;
1240 }
1241 
1243 {
1244  ApiContext context(c);
1245  try
1246  {
1247  return isOfClass(Directory, (RexxObject *)o);
1248  }
1249  catch (RexxNativeActivation *)
1250  {
1251  }
1252  return false;
1253 }
1254 
1256 {
1257  ApiContext context(c);
1258  try
1259  {
1260  if (i == 0)
1261  {
1263  }
1264  return (RexxObjectPtr)context.ret(((RexxArray *)a)->getApi(i));
1265  }
1266  catch (RexxNativeActivation *)
1267  {
1268  }
1269  return OREF_NULL;
1270 }
1271 
1272 
1274 {
1275  ApiContext context(c);
1276  try
1277  {
1278  if (i == 0)
1279  {
1281  }
1282  ((RexxArray *)a)->putApi((RexxObject *)o, i);
1283  }
1284  catch (RexxNativeActivation *)
1285  {
1286  }
1287 }
1288 
1289 
1291 {
1292  ApiContext context(c);
1293  try
1294  {
1295  return ((RexxArray *)a)->append((RexxObject *)o);
1296  }
1297  catch (RexxNativeActivation *)
1298  {
1299  return 0;
1300  }
1301 }
1302 
1303 
1305 {
1306  ApiContext context(c);
1307  try
1308  {
1309  RexxString *str = new_string(s, (stringsize_t)l);
1310  ProtectedObject p(str);
1311  return ((RexxArray *)a)->append(str);
1312  }
1313  catch (RexxNativeActivation *)
1314  {
1315  return 0;
1316  }
1317 }
1318 
1319 
1321 {
1322  ApiContext context(c);
1323  try
1324  {
1325  return ((RexxArray *)a)->size();
1326  }
1327  catch (RexxNativeActivation *)
1328  {
1329  }
1330  return 0;
1331 }
1332 
1333 
1335 {
1336  ApiContext context(c);
1337  try
1338  {
1339  return ((RexxArray *)a)->items();
1340  }
1341  catch (RexxNativeActivation *)
1342  {
1343  }
1344  return 0;
1345 }
1346 
1348 {
1349  ApiContext context(c);
1350  try
1351  {
1352  return ((RexxArray *)a)->getDimension();
1353  }
1354  catch (RexxNativeActivation *)
1355  {
1356  }
1357  return 0;
1358 }
1359 
1361 {
1362  ApiContext context(c);
1363  try
1364  {
1365  return (RexxArrayObject)context.ret(new_array(s));
1366  }
1367  catch (RexxNativeActivation *)
1368  {
1369  }
1370  return NULLOBJECT;
1371 }
1372 
1374 {
1375  ApiContext context(c);
1376  try
1377  {
1378  return (RexxArrayObject)context.ret(new_array((RexxObject *)o));
1379  }
1380  catch (RexxNativeActivation *)
1381  {
1382  }
1383  return NULLOBJECT;
1384 }
1385 
1387 {
1388  ApiContext context(c);
1389  try
1390  {
1391  return (RexxArrayObject)context.ret(new_array((RexxObject *)o1, (RexxObject *)o2));
1392  }
1393  catch (RexxNativeActivation *)
1394  {
1395  }
1396  return NULLOBJECT;
1397 }
1398 
1400 {
1401  ApiContext context(c);
1402  try
1403  {
1404  return (RexxArrayObject)context.ret(new_array((RexxObject *)o1, (RexxObject *)o2, (RexxObject *)o3));
1405  }
1406  catch (RexxNativeActivation *)
1407  {
1408  }
1409  return NULLOBJECT;
1410 }
1411 
1413 {
1414  ApiContext context(c);
1415  try
1416  {
1417  return (RexxArrayObject)context.ret(new_array((RexxObject *)o1, (RexxObject *)o2, (RexxObject *)o3, (RexxObject *)o4));
1418  }
1419  catch (RexxNativeActivation *)
1420  {
1421  }
1422  return NULLOBJECT;
1423 }
1424 
1425 
1427 {
1428  ApiContext context(c);
1429  try
1430  {
1431  return isArray((RexxObject *)o);
1432  }
1433  catch (RexxNativeActivation *)
1434  {
1435  }
1436  return false;
1437 }
1438 
1440 {
1441  ApiContext context(c);
1442  try
1443  {
1444  return (POINTER)((RexxBuffer *)b)->getData();
1445  }
1446  catch (RexxNativeActivation *)
1447  {
1448  }
1449  return NULL;
1450 }
1451 
1453 {
1454  ApiContext context(c);
1455  try
1456  {
1457  return ((RexxBuffer *)b)->getDataLength();
1458  }
1459  catch (RexxNativeActivation *)
1460  {
1461  }
1462  return 0;
1463 }
1464 
1466 {
1467  ApiContext context(c);
1468  try
1469  {
1470  return (RexxBufferObject)context.ret((RexxObject *)new_buffer(l));
1471  }
1472  catch (RexxNativeActivation *)
1473  {
1474  }
1475  return NULLOBJECT;
1476 }
1477 
1479 {
1480  ApiContext context(c);
1481  try
1482  {
1483  return isOfClass(Buffer, (RexxObject *)o);
1484  }
1485  catch (RexxNativeActivation *)
1486  {
1487  }
1488  return false;
1489 }
1490 
1492 {
1493  ApiContext context(c);
1494  try
1495  {
1496  return (POINTER)((RexxPointer *)o)->pointer();
1497  }
1498  catch (RexxNativeActivation *)
1499  {
1500  }
1501  return NULL;
1502 }
1503 
1505 {
1506  ApiContext context(c);
1507  try
1508  {
1509  return (RexxPointerObject)context.ret(new_pointer(p));
1510  }
1511  catch (RexxNativeActivation *)
1512  {
1513  }
1514  return NULLOBJECT;
1515 }
1516 
1518 {
1519  ApiContext context(c);
1520  try
1521  {
1522  return isOfClass(Pointer, (RexxObject *)o);
1523  }
1524  catch (RexxNativeActivation *)
1525  {
1526  }
1527  return false;
1528 }
1529 
1531 {
1532  ApiContext context(c);
1533  try
1534  {
1535  return context.ret(((RexxSupplier *)o)->value());
1536  }
1537  catch (RexxNativeActivation *)
1538  {
1539  }
1540  return NULLOBJECT;
1541 }
1542 
1544 {
1545  ApiContext context(c);
1546  try
1547  {
1548  return context.ret(((RexxSupplier *)o)->index());
1549  }
1550  catch (RexxNativeActivation *)
1551  {
1552  }
1553  return NULLOBJECT;
1554 }
1555 
1557 {
1558  ApiContext context(c);
1559  try
1560  {
1561  return ((RexxSupplier *)o)->available() == TheTrueObject;
1562  }
1563  catch (RexxNativeActivation *)
1564  {
1565  }
1566  return false;
1567 }
1568 
1570 {
1571  ApiContext context(c);
1572  try
1573  {
1574  ((RexxSupplier *)o)->next();
1575  }
1576  catch (RexxNativeActivation *)
1577  {
1578  }
1579 }
1580 
1582 {
1583  ApiContext context(c);
1584  try
1585  {
1586  return (RexxSupplierObject)context.ret(new_supplier((RexxArray *)values, (RexxArray *)names));
1587  }
1588  catch (RexxNativeActivation *)
1589  {
1590  }
1591  return NULLOBJECT;
1592 }
1593 
1595 {
1596  ApiContext context(c);
1597  try
1598  {
1599  if (n == NULL)
1600  {
1601  return (RexxStemObject)context.ret(new RexxStem(OREF_NULL));
1602  }
1603  else
1604  {
1605  RexxString *name = new_string(n);
1606  ProtectedObject p(name);
1607  return (RexxStemObject)context.ret(new RexxStem(name));
1608  }
1609 
1610  }
1611  catch (RexxNativeActivation *)
1612  {
1613  }
1614  return NULLOBJECT;
1615 }
1616 
1618 {
1619  ApiContext context(c);
1620  try
1621  {
1622  ((RexxStem *)s)->setElement(n, (RexxObject *)v);
1623  }
1624  catch (RexxNativeActivation *)
1625  {
1626  }
1627 }
1628 
1630 {
1631  ApiContext context(c);
1632  try
1633  {
1634  return context.ret(((RexxStem *)s)->getElement(n));
1635  }
1636  catch (RexxNativeActivation *)
1637  {
1638  }
1639  return NULLOBJECT;
1640 }
1641 
1643 {
1644  ApiContext context(c);
1645  try
1646  {
1647  ((RexxStem *)s)->dropElement(n);
1648  }
1649  catch (RexxNativeActivation *)
1650  {
1651  }
1652 }
1653 
1655 {
1656  ApiContext context(c);
1657  try
1658  {
1659  ((RexxStem *)s)->setElement((size_t )i, (RexxObject *)v);
1660  }
1661  catch (RexxNativeActivation *)
1662  {
1663  }
1664 }
1665 
1667 {
1668  ApiContext context(c);
1669  try
1670  {
1671  return context.ret(((RexxStem *)s)->getElement((size_t)i));
1672  }
1673  catch (RexxNativeActivation *)
1674  {
1675  }
1676  return NULLOBJECT;
1677 }
1678 
1680 {
1681  ApiContext context(c);
1682  try
1683  {
1684  ((RexxStem *)s)->dropElement((size_t)i);
1685  }
1686  catch (RexxNativeActivation *)
1687  {
1688  }
1689 }
1690 
1692 {
1693  ApiContext context(c);
1694  try
1695  {
1696  return (RexxDirectoryObject)context.ret(((RexxStem *)s)->toDirectory());
1697  }
1698  catch (RexxNativeActivation *)
1699  {
1700  }
1701  return NULLOBJECT;
1702 }
1703 
1705 {
1706  ApiContext context(c);
1707  try
1708  {
1709  return context.ret(((RexxStem *)s)->getStemValue());
1710  }
1711  catch (RexxNativeActivation *)
1712  {
1713  }
1714  return NULLOBJECT;
1715 }
1716 
1718 {
1719  ApiContext context(c);
1720  try
1721  {
1722  return isOfClass(Stem, (RexxObject *)o);
1723  }
1724  catch (RexxNativeActivation *)
1725  {
1726  }
1727  return false;
1728 }
1729 
1731 {
1732  ApiContext context(c);
1733  try
1734  {
1736  }
1737  catch (RexxNativeActivation *)
1738  {
1739  }
1740 }
1741 
1743 {
1744  ApiContext context(c);
1745  try
1746  {
1748  }
1749  catch (RexxNativeActivation *)
1750  {
1751  }
1752 }
1753 
1755 {
1756  ApiContext context(c);
1757  try
1758  {
1760  }
1761  catch (RexxNativeActivation *)
1762  {
1763  }
1764 }
1765 
1767 {
1768  ApiContext context(c);
1769  try
1770  {
1772  }
1773  catch (RexxNativeActivation *)
1774  {
1775  }
1776 }
1777 
1779 {
1780  ApiContext context(c);
1781  try
1782  {
1783  RexxString *name = new_upper_string(n);
1784  ProtectedObject p(name);
1785  context.context->enableConditionTrap();
1786  context.activity->raiseCondition(name, OREF_NULL, (RexxString *)desc, (RexxObject *)add, (RexxObject *)result);
1787  }
1788  catch (RexxNativeActivation *)
1789  {
1790  }
1791 }
1792 
1794 {
1795  ApiContext context(c);
1796  try
1797  {
1798  return context.context->getConditionInfo() != OREF_NULL;
1799  }
1800  catch (RexxNativeActivation *)
1801  {
1802  }
1803  return false;
1804 }
1805 
1807 {
1808  ApiContext context(c);
1809  try
1810  {
1811  return context.activity->displayCondition(context.context->getConditionInfo());
1812  }
1813  catch (RexxNativeActivation *)
1814  {
1815  }
1816  return Error_Interpretation/1000; // this is a default one if something goes wrong
1817 }
1818 
1820 {
1821  ApiContext context(c);
1822  try
1823  {
1824  return (RexxDirectoryObject)context.ret(context.context->getConditionInfo());
1825  }
1826  catch (RexxNativeActivation *)
1827  {
1828  }
1829  return OREF_NULL;
1830 }
1831 
1832 
1834 {
1835  ApiContext context(c);
1836  try
1837  {
1839  }
1840  catch (RexxNativeActivation *)
1841  {
1842  }
1843 }
1844 
1846 {
1847  ApiContext context(c);
1848  try
1849  {
1851  }
1852  catch (RexxNativeActivation *)
1853  {
1854  }
1855 }
1856 
1858 {
1859  ApiContext context(c);
1860  try
1861  {
1862  return (POINTER)((RexxMutableBuffer *)b)->getData();
1863  }
1864  catch (RexxNativeActivation *)
1865  {
1866  }
1867  return NULL;
1868 }
1869 
1871 {
1872  ApiContext context(c);
1873  try
1874  {
1875  return ((RexxMutableBuffer *)b)->getLength();
1876  }
1877  catch (RexxNativeActivation *)
1878  {
1879  }
1880  return 0;
1881 }
1882 
1884 {
1885  ApiContext context(c);
1886  try
1887  {
1888  return ((RexxMutableBuffer *)b)->setDataLength(length);
1889  }
1890  catch (RexxNativeActivation *)
1891  {
1892  }
1893  return 0;
1894 }
1895 
1897 {
1898  ApiContext context(c);
1899  try
1900  {
1901  return ((RexxMutableBuffer *)b)->getCapacity();
1902  }
1903  catch (RexxNativeActivation *)
1904  {
1905  }
1906  return 0;
1907 }
1908 
1910 {
1911  ApiContext context(c);
1912  try
1913  {
1914  return (POINTER)((RexxMutableBuffer *)b)->setCapacity(length);
1915  }
1916  catch (RexxNativeActivation *)
1917  {
1918  }
1919  return 0;
1920 }
1921 
1923 {
1924  ApiContext context(c);
1925  try
1926  {
1927  return (RexxMutableBufferObject)context.ret((RexxObject *)new RexxMutableBuffer(l, l));
1928  }
1929  catch (RexxNativeActivation *)
1930  {
1931  }
1932  return NULLOBJECT;
1933 }
1934 
1936 {
1937  ApiContext context(c);
1938  try
1939  {
1940  return isOfClass(MutableBuffer, (RexxObject *)o);
1941  }
1942  catch (RexxNativeActivation *)
1943  {
1944  }
1945  return false;
1946 }
1947 
1948 END_EXTERN_C()
1949 
1950 RexxThreadInterface RexxActivity::threadContextFunctions =
1951 {
1953  DetachThread,
1954  HaltThread,
1959 
1961  SendMessage0,
1962  SendMessage1,
1963  SendMessage2,
1964 
1967 
1968  IsInstanceOf,
1969  IsOfType,
1970  HasMethod,
1971  LoadPackage,
1975  FindClass,
1982  CallRoutine,
1983  CallProgram,
1984 
1985  NewMethod,
1986  NewRoutine,
1987  IsRoutine,
1988  IsMethod,
1991 
1992  ObjectToCSelf,
1996  ValueToObject,
1998  ObjectToValue,
2002  Int64ToObject,
2004  ObjectToInt64,
2006  Int32ToObject,
2008  ObjectToInt32,
2017 
2020  StringGet,
2021  StringLength,
2022  StringData,
2023  NewString,
2025  StringUpper,
2026  StringLower,
2027  IsString,
2028 
2033 
2034  DirectoryPut,
2035  DirectoryAt,
2037  NewDirectory,
2038  IsDirectory,
2039 
2040  ArrayAt,
2041  ArrayPut,
2042  ArrayAppend,
2044  ArraySize,
2045  ArrayItems,
2047  NewArray,
2048  ArrayOfOne,
2049  ArrayOfTwo,
2050  ArrayOfThree,
2051  ArrayOfFour,
2052  IsArray,
2053 
2054  BufferData,
2055  BufferLength,
2056  NewBuffer,
2057  IsBuffer,
2058 
2059  PointerValue,
2060  NewPointer,
2061  IsPointer,
2062 
2063  SupplierItem,
2064  SupplierIndex,
2066  SupplierNext,
2067  NewSupplier,
2068 
2069  NewStem,
2077  GetStemValue,
2078  IsStem,
2079 
2089 
2090  OREF_NULL,
2091  OREF_NULL,
2092  OREF_NULL,
2093  OREF_NULL,
2103 };
SendMessage1
RexxObjectPtr RexxEntry SendMessage1(RexxThreadContext *c, RexxObjectPtr o, CSTRING m, RexxObjectPtr a1)
Definition: ThreadContextStubs.cpp:186
Numerics::objectToInt64
static bool objectToInt64(RexxObject *o, int64_t &result)
Definition: Numerics.cpp:409
SendMessageArray
RexxObjectPtr RexxEntry SendMessageArray(RexxThreadContext *c, RexxObjectPtr o, CSTRING m, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:153
Error_Interpretation
#define Error_Interpretation
Definition: RexxErrorCodes.h:400
Numerics::objectToStringSize
static bool objectToStringSize(RexxObject *o, stringsize_t &result, stringsize_t max)
Definition: Numerics.cpp:312
PackageManager::loadLibrary
static LibraryPackage * loadLibrary(RexxString *name)
Definition: PackageManager.cpp:208
ArrayDimension
size_t RexxEntry ArrayDimension(RexxThreadContext *c, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:1347
new_array
RexxArray * new_array(size_t s)
Definition: ArrayClass.hpp:250
StringLower
RexxStringObject RexxEntry StringLower(RexxThreadContext *c, RexxStringObject s)
Definition: ThreadContextStubs.cpp:1102
logical_t
size_t logical_t
Definition: rexx.h:230
RexxDirectoryObject
struct _RexxDirectoryObject * RexxDirectoryObject
Definition: rexx.h:137
CSTRING
const typedef char * CSTRING
Definition: rexx.h:78
IsStem
logical_t RexxEntry IsStem(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1717
RexxArray
Definition: ArrayClass.hpp:100
RexxObject::isInstanceOf
bool isInstanceOf(RexxClass *)
Definition: ObjectClass.cpp:226
ObjectToCSelfScoped
POINTER RexxEntry ObjectToCSelfScoped(RexxThreadContext *c, RexxObjectPtr o, RexxObjectPtr s)
Definition: ThreadContextStubs.cpp:613
RaiseCondition
void RexxEntry RaiseCondition(RexxThreadContext *c, CSTRING n, RexxStringObject desc, RexxObjectPtr add, RexxObjectPtr result)
Definition: ThreadContextStubs.cpp:1778
StringData
CSTRING RexxEntry StringData(RexxThreadContext *c, RexxStringObject s)
Definition: ThreadContextStubs.cpp:1048
TheRoutineClass
#define TheRoutineClass
Definition: RexxCore.h:155
RexxActivity::getLocal
RexxDirectory * getLocal()
Definition: RexxActivity.cpp:1980
SupplierItem
RexxObjectPtr RexxEntry SupplierItem(RexxThreadContext *c, RexxSupplierObject o)
Definition: ThreadContextStubs.cpp:1530
TheFalseObject
#define TheFalseObject
Definition: RexxCore.h:184
GetPackagePublicRoutines
RexxDirectoryObject RexxEntry GetPackagePublicRoutines(RexxThreadContext *c, RexxPackageObject m)
Definition: ThreadContextStubs.cpp:419
RexxArrayObject
struct _RexxArrayObject * RexxArrayObject
Definition: rexx.h:130
CallProgram
RexxObjectPtr RexxEntry CallProgram(RexxThreadContext *c, const char *p, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:488
RaiseException2
void RexxEntry RaiseException2(RexxThreadContext *c, size_t n, RexxObjectPtr o1, RexxObjectPtr o2)
Definition: ThreadContextStubs.cpp:1754
RexxThreadContext_
Definition: oorexxapi.h:710
MethodClass.hpp
RexxString::finish
void finish(stringsize_t l)
Definition: StringClass.hpp:332
CallRoutineDispatcher::result
ProtectedObject result
Definition: RexxStartDispatcher.hpp:74
GetLocalEnvironment
RexxDirectoryObject RexxEntry GetLocalEnvironment(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:216
NewArray
RexxArrayObject RexxEntry NewArray(RexxThreadContext *c, size_t s)
Definition: ThreadContextStubs.cpp:1360
PackageClass.hpp
CallRoutine
RexxObjectPtr RexxEntry CallRoutine(RexxThreadContext *c, RexxRoutineObject r, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:472
StringLength
size_t RexxEntry StringLength(RexxThreadContext *c, RexxStringObject s)
Definition: ThreadContextStubs.cpp:1034
SetStemArrayElement
void RexxEntry SetStemArrayElement(RexxThreadContext *c, RexxStemObject s, size_t i, RexxObjectPtr v)
Definition: ThreadContextStubs.cpp:1654
RexxMutableBuffer
Definition: MutableBufferClass.hpp:61
MutableBufferLength
size_t RexxEntry MutableBufferLength(RexxThreadContext *c, RexxMutableBufferObject b)
Definition: ThreadContextStubs.cpp:1870
isArray
bool isArray(RexxObject *o)
Definition: RexxCore.h:266
InterpreterInstance::removeGlobalReference
void removeGlobalReference(RexxObject *o)
Definition: InterpreterInstance.cpp:527
Interpreter::decodeConditionData
static void decodeConditionData(RexxDirectory *conditionObj, RexxCondition *condData)
Definition: Interpreter.cpp:460
IntptrToObject
RexxObjectPtr RexxEntry IntptrToObject(RexxThreadContext *c, intptr_t n)
Definition: ThreadContextStubs.cpp:654
ObjectToIntptr
logical_t RexxEntry ObjectToIntptr(RexxThreadContext *c, RexxObjectPtr o, intptr_t *n)
Definition: ThreadContextStubs.cpp:912
ClearCondition
void RexxEntry ClearCondition(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1845
ArrayAppendString
size_t RexxEntry ArrayAppendString(RexxThreadContext *c, RexxArrayObject a, CSTRING s, size_t l)
Definition: ThreadContextStubs.cpp:1304
ValueToObject
RexxObjectPtr RexxEntry ValueToObject(RexxThreadContext *c, ValueDescriptor *d)
Definition: ThreadContextStubs.cpp:668
FinishBufferString
RexxStringObject RexxEntry FinishBufferString(RexxThreadContext *c, RexxBufferStringObject s, size_t l)
Definition: ThreadContextStubs.cpp:1170
GetConditionInfo
RexxDirectoryObject RexxEntry GetConditionInfo(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1819
RequestGlobalReference
RexxObjectPtr RexxEntry RequestGlobalReference(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:111
IntegerClass.hpp
RoutineClass.hpp
RexxThreadInterface
Definition: oorexxapi.h:455
WholeNumberToObject
RexxObjectPtr RexxEntry WholeNumberToObject(RexxThreadContext *c, wholenumber_t n)
Definition: ThreadContextStubs.cpp:628
RoutineClass
Definition: RoutineClass.hpp:49
Numerics::objectToSignedInteger
static bool objectToSignedInteger(RexxObject *o, ssize_t &result, ssize_t max, ssize_t min)
Definition: Numerics.cpp:269
NewString
RexxStringObject RexxEntry NewString(RexxThreadContext *c, CSTRING s, size_t l)
Definition: ThreadContextStubs.cpp:1062
RexxActivity::detachThread
void detachThread()
Definition: RexxActivity.cpp:1714
SetStemElement
void RexxEntry SetStemElement(RexxThreadContext *c, RexxStemObject s, CSTRING n, RexxObjectPtr v)
Definition: ThreadContextStubs.cpp:1617
RexxActivity::halt
bool halt(RexxString *)
Definition: RexxActivity.cpp:1886
ActivityManager.hpp
SupplierClass.hpp
RexxCondition
Definition: oorexxapi.h:423
RexxNativeActivation::valueToObject
RexxObject * valueToObject(ValueDescriptor *value)
Definition: RexxNativeActivation.cpp:697
PointerClass.hpp
new_supplier
RexxSupplier * new_supplier(RexxArray *c, RexxArray *f)
Definition: SupplierClass.hpp:80
RexxBufferObject
struct _RexxBufferObject * RexxBufferObject
Definition: rexx.h:131
RexxActivity::run
void run()
Definition: RexxActivity.cpp:1384
CallProgramDispatcher
Definition: RexxStartDispatcher.hpp:82
BufferStringData
POINTER RexxEntry BufferStringData(RexxThreadContext *c, RexxBufferStringObject s)
Definition: ThreadContextStubs.cpp:1156
ApiContext::context
RexxNativeActivation * context
Definition: ContextApi.hpp:181
RexxString::getLength
size_t getLength()
Definition: StringClass.hpp:330
GetMethodPackage
RexxPackageObject RexxEntry GetMethodPackage(RexxThreadContext *c, RexxMethodObject o)
Definition: ThreadContextStubs.cpp:583
ValuesToObject
RexxArrayObject RexxEntry ValuesToObject(RexxThreadContext *c, ValueDescriptor *d, size_t count)
Definition: ThreadContextStubs.cpp:683
ValueDescriptor
Definition: oorexxapi.h:261
RexxPointer
Definition: PointerClass.hpp:49
NewRoutine
RexxRoutineObject RexxEntry NewRoutine(RexxThreadContext *c, CSTRING n, CSTRING source, stringsize_t length)
Definition: ThreadContextStubs.cpp:521
GetGlobalEnvironment
RexxDirectoryObject RexxEntry GetGlobalEnvironment(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:229
SupplierIndex
RexxObjectPtr RexxEntry SupplierIndex(RexxThreadContext *c, RexxSupplierObject o)
Definition: ThreadContextStubs.cpp:1543
IsArray
logical_t RexxEntry IsArray(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1426
SetMutableBufferLength
size_t RexxEntry SetMutableBufferLength(RexxThreadContext *c, RexxMutableBufferObject b, size_t length)
Definition: ThreadContextStubs.cpp:1883
ObjectToCSelf
POINTER RexxEntry ObjectToCSelf(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:598
GetStemElement
RexxObjectPtr RexxEntry GetStemElement(RexxThreadContext *c, RexxStemObject s, CSTRING n)
Definition: ThreadContextStubs.cpp:1629
Numerics::int64ToObject
static RexxObject * int64ToObject(int64_t v)
Definition: Numerics.cpp:140
HaltThread
void RexxEntry HaltThread(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:85
reportException
void reportException(wholenumber_t error)
Definition: ActivityManager.hpp:136
DoubleToObject
RexxObjectPtr RexxEntry DoubleToObject(RexxThreadContext *c, double n)
Definition: ThreadContextStubs.cpp:953
RexxString::getWritableData
char * getWritableData()
Definition: StringClass.hpp:334
CallProgramDispatcher::result
ProtectedObject result
Definition: RexxStartDispatcher.hpp:90
ApiContext
Definition: ContextApi.hpp:56
Numerics::wholenumberToObject
static RexxObject * wholenumberToObject(wholenumber_t v)
Definition: Numerics.cpp:182
Numerics::MAX_WHOLENUMBER
static const wholenumber_t MAX_WHOLENUMBER
Definition: Numerics.hpp:62
NewBuffer
RexxBufferObject RexxEntry NewBuffer(RexxThreadContext *c, size_t l)
Definition: ThreadContextStubs.cpp:1465
RexxNativeActivation::removeLocalReference
void removeLocalReference(RexxObject *objr)
Definition: RexxNativeActivation.cpp:1185
Numerics::objectToUnsignedInteger
static bool objectToUnsignedInteger(RexxObject *o, size_t &result, size_t max)
Definition: Numerics.cpp:361
DirectoryRemove
RexxObjectPtr RexxEntry DirectoryRemove(RexxThreadContext *c, RexxDirectoryObject t, CSTRING i)
Definition: ThreadContextStubs.cpp:1214
ApiContext::ret
RexxObjectPtr ret(RexxObject *o)
Definition: ContextApi.hpp:168
TheTrueObject
#define TheTrueObject
Definition: RexxCore.h:185
RexxActivity::setTrace
bool setTrace(bool)
Definition: RexxActivity.cpp:1909
RexxSupplier
Definition: SupplierClass.hpp:47
MutableBufferClass.hpp
GetPackageClasses
RexxDirectoryObject RexxEntry GetPackageClasses(RexxThreadContext *c, RexxPackageObject m)
Definition: ThreadContextStubs.cpp:432
RexxString::getStringData
const char * getStringData()
Definition: StringClass.hpp:333
PackageManager::registerPackage
static bool registerPackage(RexxString *name, RexxPackageEntry *p)
Definition: PackageManager.cpp:483
Int32ToObject
RexxObjectPtr RexxEntry Int32ToObject(RexxThreadContext *c, int32_t n)
Definition: ThreadContextStubs.cpp:751
RexxClassObject
struct _RexxClassObject * RexxClassObject
Definition: rexx.h:136
RexxBuffer
Definition: BufferClass.hpp:91
IsDirectory
logical_t RexxEntry IsDirectory(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1242
Numerics::uintptrToObject
static RexxObject * uintptrToObject(uintptr_t v)
Definition: Numerics.cpp:844
RexxBufferStringObject
struct _RexxBufferStringObject * RexxBufferStringObject
Definition: rexx.h:129
DirectoryAt
RexxObjectPtr RexxEntry DirectoryAt(RexxThreadContext *c, RexxDirectoryObject t, CSTRING i)
Definition: ThreadContextStubs.cpp:1199
ArrayOfThree
RexxArrayObject RexxEntry ArrayOfThree(RexxThreadContext *c, RexxObjectPtr o1, RexxObjectPtr o2, RexxObjectPtr o3)
Definition: ThreadContextStubs.cpp:1399
RexxMethodObject
struct _RexxMethodObject * RexxMethodObject
Definition: rexx.h:133
LoadPackage
RexxPackageObject RexxEntry LoadPackage(RexxThreadContext *c, CSTRING n)
Definition: ThreadContextStubs.cpp:298
NewMutableBuffer
RexxMutableBufferObject RexxEntry NewMutableBuffer(RexxThreadContext *c, size_t l)
Definition: ThreadContextStubs.cpp:1922
Numerics::objectToUintptr
static bool objectToUintptr(RexxObject *source, uintptr_t &result)
Definition: Numerics.cpp:526
HasMethod
logical_t RexxEntry HasMethod(RexxThreadContext *c, RexxObjectPtr o, CSTRING n)
Definition: ThreadContextStubs.cpp:280
CallRoutineDispatcher
Definition: RexxStartDispatcher.hpp:66
Interpreter.hpp
ArrayItems
size_t RexxEntry ArrayItems(RexxThreadContext *c, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:1334
isOfClass
#define isOfClass(t, r)
Definition: RexxCore.h:211
NewStem
RexxStemObject RexxEntry NewStem(RexxThreadContext *c, CSTRING n)
Definition: ThreadContextStubs.cpp:1594
Numerics::uint64ToObject
static RexxObject * uint64ToObject(uint64_t v)
Definition: Numerics.cpp:161
RexxActivity::displayCondition
wholenumber_t displayCondition(RexxDirectory *conditionObject)
Definition: RexxActivity.cpp:376
APIRaiseException
void RexxEntry APIRaiseException(RexxThreadContext *c, size_t n, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:1766
GetStemValue
RexxObjectPtr RexxEntry GetStemValue(RexxThreadContext *c, RexxStemObject s)
Definition: ThreadContextStubs.cpp:1704
SetMutableBufferCapacity
POINTER RexxEntry SetMutableBufferCapacity(RexxThreadContext *c, RexxMutableBufferObject b, size_t length)
Definition: ThreadContextStubs.cpp:1909
RexxNativeActivation::enableConditionTrap
void enableConditionTrap()
Definition: RexxNativeActivation.hpp:178
RexxStartDispatcher.hpp
raw_string
RexxString * raw_string(stringsize_t l)
Definition: StringClass.hpp:529
RaiseException1
void RexxEntry RaiseException1(RexxThreadContext *c, size_t n, RexxObjectPtr o1)
Definition: ThreadContextStubs.cpp:1742
RexxPackageObject
struct _RexxPackageObject * RexxPackageObject
Definition: rexx.h:135
RaiseException0
void RexxEntry RaiseException0(RexxThreadContext *c, size_t n)
Definition: ThreadContextStubs.cpp:1730
ObjectToInt32
logical_t RexxEntry ObjectToInt32(RexxThreadContext *c, RexxObjectPtr o, int32_t *n)
Definition: ThreadContextStubs.cpp:800
RexxPointerObject
struct _RexxPointerObject * RexxPointerObject
Definition: rexx.h:132
RexxStem
Definition: StemClass.hpp:70
RexxNativeActivation::setConditionInfo
void setConditionInfo(RexxDirectory *info)
Definition: RexxNativeActivation.hpp:132
ObjectToUnsignedInt32
logical_t RexxEntry ObjectToUnsignedInt32(RexxThreadContext *c, RexxObjectPtr o, uint32_t *n)
Definition: ThreadContextStubs.cpp:823
Numerics::objectToWholeNumber
static bool objectToWholeNumber(RexxObject *o, wholenumber_t &result, wholenumber_t max, wholenumber_t min)
Definition: Numerics.cpp:226
NewPointer
RexxPointerObject RexxEntry NewPointer(RexxThreadContext *c, POINTER p)
Definition: ThreadContextStubs.cpp:1504
new_string
RexxString * new_string(const char *s, stringsize_t l)
Definition: StringClass.hpp:524
SystemInterpreter.hpp
ObjectToStringValue
CSTRING RexxEntry ObjectToStringValue(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1005
NewDirectory
RexxDirectoryObject RexxEntry NewDirectory(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1229
OREF_NULL
#define OREF_NULL
Definition: RexxCore.h:60
BufferLength
size_t RexxEntry BufferLength(RexxThreadContext *c, RexxBufferObject b)
Definition: ThreadContextStubs.cpp:1452
ArrayClass.hpp
RexxActivity
Definition: RexxActivity.hpp:127
InterpreterInstance::loadRequires
PackageClass * loadRequires(RexxActivity *activity, RexxString *shortName, const char *data, size_t length)
Definition: InterpreterInstance.cpp:987
ObjectToStringSize
logical_t RexxEntry ObjectToStringSize(RexxThreadContext *c, RexxObjectPtr o, stringsize_t *n)
Definition: ThreadContextStubs.cpp:779
BufferStringLength
size_t RexxEntry BufferStringLength(RexxThreadContext *c, RexxBufferStringObject s)
Definition: ThreadContextStubs.cpp:1142
RexxDirectory
Definition: DirectoryClass.hpp:49
IsMethod
logical_t RexxEntry IsMethod(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:553
RexxClass
Definition: ClassClass.hpp:49
RexxActivity::raiseCondition
bool raiseCondition(RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *)
Definition: RexxActivity.cpp:434
SendMessage2
RexxObjectPtr RexxEntry SendMessage2(RexxThreadContext *c, RexxObjectPtr o, CSTRING m, RexxObjectPtr a1, RexxObjectPtr a2)
Definition: ThreadContextStubs.cpp:201
NewStringFromAsciiz
RexxStringObject RexxEntry NewStringFromAsciiz(RexxThreadContext *c, CSTRING s)
Definition: ThreadContextStubs.cpp:1075
ProtectedObject
Definition: ProtectedObject.hpp:46
ArraySize
size_t RexxEntry ArraySize(RexxThreadContext *c, RexxArrayObject a)
Definition: ThreadContextStubs.cpp:1320
ArrayPut
void RexxEntry ArrayPut(RexxThreadContext *c, RexxArrayObject a, RexxObjectPtr o, size_t i)
Definition: ThreadContextStubs.cpp:1273
RexxNativeActivation::getConditionInfo
RexxDirectory * getConditionInfo()
Definition: RexxNativeActivation.hpp:133
StringClass.hpp
FindClass
RexxClassObject RexxEntry FindClass(RexxThreadContext *c, CSTRING n)
Definition: ThreadContextStubs.cpp:369
IsInstanceOf
logical_t RexxEntry IsInstanceOf(RexxThreadContext *c, RexxObjectPtr o, RexxClassObject cl)
Definition: ThreadContextStubs.cpp:243
ReleaseLocalReference
void RexxEntry ReleaseLocalReference(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:139
Error_Incorrect_method_positive
#define Error_Incorrect_method_positive
Definition: RexxErrorCodes.h:461
MutableBufferData
POINTER RexxEntry MutableBufferData(RexxThreadContext *c, RexxMutableBufferObject b)
Definition: ThreadContextStubs.cpp:1857
SupplierNext
void RexxEntry SupplierNext(RexxThreadContext *c, RexxSupplierObject o)
Definition: ThreadContextStubs.cpp:1569
Numerics::stringsizeToObject
static RexxObject * stringsizeToObject(stringsize_t v)
Definition: Numerics.cpp:203
InterpreterInstance::resolveProgramName
RexxString * resolveProgramName(RexxString *name, RexxString *dir, RexxString *ext)
Definition: InterpreterInstance.hpp:106
RexxMutableBufferObject
struct _RexxMutableBufferObject * RexxMutableBufferObject
Definition: rexx.h:140
DisplayCondition
wholenumber_t RexxEntry DisplayCondition(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1806
StringUpper
RexxStringObject RexxEntry StringUpper(RexxThreadContext *c, RexxStringObject s)
Definition: ThreadContextStubs.cpp:1088
StringGet
size_t RexxEntry StringGet(RexxThreadContext *c, RexxStringObject s, size_t o, POINTER r, size_t l)
Definition: ThreadContextStubs.cpp:1020
MutableBufferCapacity
size_t RexxEntry MutableBufferCapacity(RexxThreadContext *c, RexxMutableBufferObject b)
Definition: ThreadContextStubs.cpp:1896
PackageClass
Definition: PackageClass.hpp:48
DropStemElement
void RexxEntry DropStemElement(RexxThreadContext *c, RexxStemObject s, CSTRING n)
Definition: ThreadContextStubs.cpp:1642
TheEnvironment
#define TheEnvironment
Definition: RexxCore.h:173
ObjectToUnsignedInt64
logical_t RexxEntry ObjectToUnsignedInt64(RexxThreadContext *c, RexxObjectPtr o, uint64_t *n)
Definition: ThreadContextStubs.cpp:884
GetPackageMethods
RexxDirectoryObject RexxEntry GetPackageMethods(RexxThreadContext *c, RexxPackageObject m)
Definition: ThreadContextStubs.cpp:458
ObjectToValue
logical_t RexxEntry ObjectToValue(RexxThreadContext *c, RexxObjectPtr o, ValueDescriptor *d)
Definition: ThreadContextStubs.cpp:698
IsRoutine
logical_t RexxEntry IsRoutine(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:538
DropStemArrayElement
void RexxEntry DropStemArrayElement(RexxThreadContext *c, RexxStemObject s, size_t i)
Definition: ThreadContextStubs.cpp:1679
RegisterLibrary
logical_t RexxEntry RegisterLibrary(RexxThreadContext *c, CSTRING n, RexxPackageEntry *e)
Definition: ThreadContextStubs.cpp:351
ObjectToLogical
logical_t RexxEntry ObjectToLogical(RexxThreadContext *c, RexxObjectPtr o, logical_t *n)
Definition: ThreadContextStubs.cpp:926
Numerics::intptrToObject
static RexxObject * intptrToObject(intptr_t v)
Definition: Numerics.cpp:866
LoadLibraryPackage
logical_t RexxEntry LoadLibraryPackage(RexxThreadContext *c, CSTRING n)
Definition: ThreadContextStubs.cpp:333
BEGIN_EXTERN_C
#define BEGIN_EXTERN_C()
Definition: rexx.h:60
ArrayOfFour
RexxArrayObject RexxEntry ArrayOfFour(RexxThreadContext *c, RexxObjectPtr o1, RexxObjectPtr o2, RexxObjectPtr o3, RexxObjectPtr o4)
Definition: ThreadContextStubs.cpp:1412
ObjectToUintptr
logical_t RexxEntry ObjectToUintptr(RexxThreadContext *c, RexxObjectPtr o, uintptr_t *n)
Definition: ThreadContextStubs.cpp:898
NewSupplier
RexxSupplierObject RexxEntry NewSupplier(RexxThreadContext *c, RexxArrayObject values, RexxArrayObject names)
Definition: ThreadContextStubs.cpp:1581
new_numberstringFromDouble
RexxNumberString * new_numberstringFromDouble(double n)
Definition: NumberStringClass.hpp:299
ContextApi.hpp
REQUEST_STRING
RexxString * REQUEST_STRING(RexxObject *object)
Definition: RexxCore.h:276
DoubleToObjectWithPrecision
RexxObjectPtr RexxEntry DoubleToObjectWithPrecision(RexxThreadContext *c, double n, size_t precision)
Definition: ThreadContextStubs.cpp:966
IsPointer
logical_t RexxEntry IsPointer(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1517
RexxNativeActivation::findClass
RexxClass * findClass(RexxString *className)
Definition: RexxNativeActivation.cpp:2712
ObjectToWholeNumber
logical_t RexxEntry ObjectToWholeNumber(RexxThreadContext *c, RexxObjectPtr o, wholenumber_t *n)
Definition: ThreadContextStubs.cpp:728
THREAD_INTERFACE_VERSION
#define THREAD_INTERFACE_VERSION
Definition: oorexxapi.h:451
new_directory
RexxDirectory * new_directory()
Definition: DirectoryClass.hpp:101
wholenumber_t
ssize_t wholenumber_t
Definition: rexx.h:229
SupplierAvailable
logical_t RexxEntry SupplierAvailable(RexxThreadContext *c, RexxSupplierObject o)
Definition: ThreadContextStubs.cpp:1556
RexxRoutineObject
struct _RexxRoutineObject * RexxRoutineObject
Definition: rexx.h:134
RexxString::lower
RexxString * lower()
Definition: StringClass.cpp:1526
LogicalToObject
RexxObjectPtr RexxEntry LogicalToObject(RexxThreadContext *c, logical_t n)
Definition: ThreadContextStubs.cpp:940
new_buffer
RexxBuffer * new_buffer(size_t s)
Definition: BufferClass.hpp:116
UintptrToObject
RexxObjectPtr RexxEntry UintptrToObject(RexxThreadContext *c, uintptr_t n)
Definition: ThreadContextStubs.cpp:641
stringsize_t
size_t stringsize_t
Definition: rexx.h:228
SetThreadTrace
void RexxEntry SetThreadTrace(RexxThreadContext *c, logical_t setting)
Definition: ThreadContextStubs.cpp:98
ObjectToInt64
logical_t RexxEntry ObjectToInt64(RexxThreadContext *c, RexxObjectPtr o, int64_t *n)
Definition: ThreadContextStubs.cpp:870
_RexxPackageEntry
Definition: oorexxapi.h:241
GetPackageRoutines
RexxDirectoryObject RexxEntry GetPackageRoutines(RexxThreadContext *c, RexxPackageObject m)
Definition: ThreadContextStubs.cpp:405
ArrayAppend
size_t RexxEntry ArrayAppend(RexxThreadContext *c, RexxArrayObject a, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1290
CheckCondition
logical_t RexxEntry CheckCondition(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:1793
POINTER
void * POINTER
Definition: rexx.h:79
TheMethodClass
#define TheMethodClass
Definition: RexxCore.h:154
BufferData
POINTER RexxEntry BufferData(RexxThreadContext *c, RexxBufferObject b)
Definition: ThreadContextStubs.cpp:1439
DirectoryPut
void RexxEntry DirectoryPut(RexxThreadContext *c, RexxDirectoryObject t, RexxObjectPtr o, CSTRING i)
Definition: ThreadContextStubs.cpp:1185
PointerValue
POINTER RexxEntry PointerValue(RexxThreadContext *c, RexxPointerObject o)
Definition: ThreadContextStubs.cpp:1491
RexxNativeActivation
Definition: RexxNativeActivation.hpp:62
isString
bool isString(RexxObject *o)
Definition: RexxCore.h:264
ArrayOfOne
RexxArrayObject RexxEntry ArrayOfOne(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1373
Numerics::objectToUnsignedInt64
static bool objectToUnsignedInt64(RexxObject *o, uint64_t &result)
Definition: Numerics.cpp:483
ObjectToDouble
logical_t RexxEntry ObjectToDouble(RexxThreadContext *c, RexxObjectPtr o, double *n)
Definition: ThreadContextStubs.cpp:979
DecodeConditionInfo
void RexxEntry DecodeConditionInfo(RexxThreadContext *c, RexxDirectoryObject d, RexxCondition *cd)
Definition: ThreadContextStubs.cpp:1833
UnsignedInt64ToObject
RexxObjectPtr RexxEntry UnsignedInt64ToObject(RexxThreadContext *c, uint64_t n)
Definition: ThreadContextStubs.cpp:857
RexxActivity.hpp
new_pointer
RexxPointer * new_pointer(void *p)
Definition: PointerClass.hpp:81
RexxSupplierObject
struct _RexxSupplierObject * RexxSupplierObject
Definition: rexx.h:138
IsOfType
logical_t RexxEntry IsOfType(RexxThreadContext *c, RexxObjectPtr o, CSTRING cn)
Definition: ThreadContextStubs.cpp:256
RexxNativeActivation::objectToValue
bool objectToValue(RexxObject *o, ValueDescriptor *value)
Definition: RexxNativeActivation.cpp:849
RexxString::copyData
size_t copyData(size_t, char *, size_t)
Definition: StringClass.cpp:450
StringSizeToObject
RexxObjectPtr RexxEntry StringSizeToObject(RexxThreadContext *c, stringsize_t n)
Definition: ThreadContextStubs.cpp:714
GetStemArrayElement
RexxObjectPtr RexxEntry GetStemArrayElement(RexxThreadContext *c, RexxStemObject s, size_t i)
Definition: ThreadContextStubs.cpp:1666
InterpreterInstance.hpp
DetachThread
void RexxEntry DetachThread(RexxThreadContext *c)
Definition: ThreadContextStubs.cpp:68
RexxStemObject
struct _RexxStemObject * RexxStemObject
Definition: rexx.h:139
SendMessage0
RexxObjectPtr RexxEntry SendMessage0(RexxThreadContext *c, RexxObjectPtr o, CSTRING m)
Definition: ThreadContextStubs.cpp:170
RexxCore.h
IsBuffer
logical_t RexxEntry IsBuffer(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1478
DirectoryClass.hpp
InterpreterInstance::addGlobalReference
void addGlobalReference(RexxObject *o)
Definition: InterpreterInstance.cpp:514
NewBufferString
RexxBufferStringObject RexxEntry NewBufferString(RexxThreadContext *c, size_t l)
Definition: ThreadContextStubs.cpp:1129
IsMutableBuffer
logical_t RexxEntry IsMutableBuffer(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1935
Numerics::MIN_WHOLENUMBER
static const wholenumber_t MIN_WHOLENUMBER
Definition: Numerics.hpp:63
ArrayOfTwo
RexxArrayObject RexxEntry ArrayOfTwo(RexxThreadContext *c, RexxObjectPtr o1, RexxObjectPtr o2)
Definition: ThreadContextStubs.cpp:1386
RexxMethod
Definition: MethodClass.hpp:101
GetPackagePublicClasses
RexxDirectoryObject RexxEntry GetPackagePublicClasses(RexxThreadContext *c, RexxPackageObject m)
Definition: ThreadContextStubs.cpp:445
ArrayAt
RexxObjectPtr RexxEntry ArrayAt(RexxThreadContext *c, RexxArrayObject a, size_t i)
Definition: ThreadContextStubs.cpp:1255
IsString
logical_t RexxEntry IsString(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:1116
new_upper_string
RexxString * new_upper_string(const char *s, stringsize_t l)
Definition: StringClass.hpp:573
NewMethod
RexxMethodObject RexxEntry NewMethod(RexxThreadContext *c, CSTRING n, CSTRING source, stringsize_t length)
Definition: ThreadContextStubs.cpp:504
LoadPackageFromData
RexxPackageObject RexxEntry LoadPackageFromData(RexxThreadContext *c, CSTRING n, CSTRING d, size_t l)
Definition: ThreadContextStubs.cpp:317
RexxStringObject
struct _RexxStringObject * RexxStringObject
Definition: rexx.h:128
RexxString::upper
RexxString * upper()
Definition: StringClass.cpp:1442
ReleaseGlobalReference
void RexxEntry ReleaseGlobalReference(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:126
RexxEntry
#define RexxEntry
Definition: rexx.h:233
Numerics::objectToIntptr
static bool objectToIntptr(RexxObject *source, intptr_t &result)
Definition: Numerics.cpp:549
GetRoutinePackage
RexxPackageObject RexxEntry GetRoutinePackage(RexxThreadContext *c, RexxRoutineObject o)
Definition: ThreadContextStubs.cpp:568
ObjectToString
RexxStringObject RexxEntry ObjectToString(RexxThreadContext *c, RexxObjectPtr o)
Definition: ThreadContextStubs.cpp:992
Int64ToObject
RexxObjectPtr RexxEntry Int64ToObject(RexxThreadContext *c, int64_t n)
Definition: ThreadContextStubs.cpp:844
GetAllStemElements
RexxDirectoryObject RexxEntry GetAllStemElements(RexxThreadContext *c, RexxStemObject s)
Definition: ThreadContextStubs.cpp:1691
BufferClass.hpp
NULLOBJECT
#define NULLOBJECT
Definition: rexx.h:147
RexxObject
Definition: ObjectClass.hpp:311
PackageManager.hpp
ApiContext::activity
RexxActivity * activity
Definition: ContextApi.hpp:177
RexxNativeActivation::valuesToObject
RexxArray * valuesToObject(ValueDescriptor *value, size_t count)
Definition: RexxNativeActivation.cpp:676
END_EXTERN_C
#define END_EXTERN_C()
Definition: rexx.h:61
RexxString
Definition: StringClass.hpp:119
RexxObjectPtr
struct _RexxObjectPtr * RexxObjectPtr
Definition: rexx.h:127
RexxActivity::getInstance
InterpreterInstance * getInstance()
Definition: RexxActivity.hpp:250
UnsignedInt32ToObject
RexxObjectPtr RexxEntry UnsignedInt32ToObject(RexxThreadContext *c, uint32_t n)
Definition: ThreadContextStubs.cpp:765
FindClassFromPackage
RexxClassObject RexxEntry FindClassFromPackage(RexxThreadContext *c, RexxPackageObject m, CSTRING n)
Definition: ThreadContextStubs.cpp:387