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)  

MessageClass.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 /* Primitive Message Class */
42 /* */
43 /******************************************************************************/
44 #include "RexxCore.h"
45 #include "StringClass.hpp"
46 #include "DirectoryClass.hpp"
47 #include "ArrayClass.hpp"
48 #include "ListClass.hpp"
49 #include "MethodClass.hpp"
50 #include "RexxActivity.hpp"
51 #include "RexxActivation.hpp"
52 #include "RexxNativeActivation.hpp"
53 #include "MessageClass.hpp"
54 #include "RexxNativeCode.hpp"
55 #include "ProtectedObject.hpp"
56 
57 // singleton class instance
59 
60 
65 {
66  CLASS_CREATE(Message, "Message", RexxClass);
67 }
68 
69 
80 {
81  /* defult target is target specified */
82  OrefSet(this, this->receiver, _target);
83  OrefSet(this, this->target, _target); /* Target specified on new */
84  /* Args to be sent wuth tmessage */
85  OrefSet(this, this->args, _args);
86  OrefSet(this, this->message, msgName);
87  OrefSet(this, this->startscope, scope);
88 
89  /* initialize a list of message to be*/
90  /* once we have a result. */
91  OrefSet(this, this->interestedParties, new RexxList);
92 }
93 
94 void RexxMessage::live(size_t liveMark)
95 /******************************************************************************/
96 /* Function: Normal garbage collection live marking */
97 /******************************************************************************/
98 {
99  memory_mark(this->receiver);
100  memory_mark(this->target);
101  memory_mark(this->message);
102  memory_mark(this->startscope);
103  memory_mark(this->args);
104  memory_mark(this->resultObject);
106  memory_mark(this->condition);
107  memory_mark(this->startActivity);
108  memory_mark(this->objectVariables);
110 }
111 
112 void RexxMessage::liveGeneral(int reason)
113 /******************************************************************************/
114 /* Function: Generalized object marking */
115 /******************************************************************************/
116 {
121  memory_mark_general(this->args);
126  memory_mark_general(this->objectVariables);
128 }
129 
131 /******************************************************************************/
132 /* Function: Flatten an object */
133 /******************************************************************************/
134 {
136 
137  flatten_reference(newThis->receiver, envelope);
138  flatten_reference(newThis->target, envelope);
139  flatten_reference(newThis->message, envelope);
140  flatten_reference(newThis->startscope, envelope);
141  flatten_reference(newThis->args, envelope);
142  flatten_reference(newThis->resultObject, envelope);
143  flatten_reference(newThis->interestedParties, envelope);
144  flatten_reference(newThis->condition, envelope);
145  flatten_reference(newThis->startActivity, envelope);
146  flatten_reference(newThis->objectVariables, envelope);
147  flatten_reference(newThis->waitingActivities, envelope);
148 
150 }
151 
153 /******************************************************************************/
154 /* Function: Add a message object to the notification list */
155 /******************************************************************************/
156 {
157  /* is argument a real message object?*/
158  if (message != OREF_NULL && isOfClass(Message, _message))
159  {
160  /* Yes, then add it to the */
161  /* toBeNotified list. */
162 
163  if (this->allNotified()) /* Have all notifications been sent? */
164  {
165  /* Yes, then send notification right */
166  _message->send(OREF_NULL); /* away */
167  }
168  else
169  {
170  /* nope, add it to list and wait for */
171  /* for result. */
172  this->interestedParties->addLast(_message);
173  }
174  }
175  else
176  { /* nope, its and error, report it. */
177  if ( message == OREF_NULL)
178  {
180  }
181  else
182  {
184  }
185  }
186  return OREF_NULL; /* all done, we return nothing */
187 }
188 
190 /******************************************************************************/
191 /* Function: Return the message result...will wait if the message isn't done */
192 /******************************************************************************/
193 {
194 
195  /* Did send/satrt cause an error */
196  /*condition Yes, we need to raise it */
197  /*here. */
198  if (this->raiseError())
199  {
201  }
202  else
203  {
204  /* Quick test to see if result */
205  /*already present */
206  if (!this->resultReturned())
207  {
208  /* got an activity available? */
209  if (this->startActivity != OREF_NULL)
210  {
211  /* go perform dead lock checks */
213  }
214 
215  /* No result yet, now we need to wait*/
216  /* until we get a result. */
217  /* Is anyone else waiting ???? */
218  if (this->waitingActivities == OREF_NULL)
219  {
220  /* No, Create a waiting list */
221  OrefSet(this, this->waitingActivities, new_list());
222  }
223  /* add this activity to the list */
225  /* now go wait to be woken up */
227  if (this->raiseError()) /* do we need to raise an error. */
228  {
229  /* yes, */
230  this->setErrorReported(); /* indicate error was reported, and */
231  /* report and error. */
232  ActivityManager::currentActivity->reraiseException(this->condition);
233  }
234  }
235  }
236  return this->resultObject; /* ok, return the result. */
237 }
238 
240 /******************************************************************************/
241 /* Function: Send the message contained by this message object */
242 /******************************************************************************/
243 {
244  if (this->msgSent())
245  {
246  /* Yes, this is an error */
248  }
249 
250  /* get the activity I'm running under*/
252  /* If we have a pending start message*/
253  /* sure this send is a result of */
254  /*that message dispatch. */
255  if (this->startPending() && myActivity != this->startActivity )
256  {
257  /* Yes, this is an error */
259  }
260  this->setMsgSent(); /* indicate we were sent a message */
261 
262  if (_receiver != OREF_NULL) /* new receiver specified? */
263  {
264  /* Yes, indicate this is the receiver*/
265  OrefSet(this, this->receiver, _receiver);
266  }
267  /* validate startscope */
268  if (startscope != OREF_NULL)
269  {
270  if (!this->receiver->behaviour->checkScope(this->startscope))
271  {
273  }
274  }
275  /* this is a primitive object? */
276  /* tell the activation/nativeact, we */
277  /*are running under to let us know */
278  /*if an error occured. */
279  myActivity->getTopStackFrame()->setObjNotify(this);
280  /* set this for resource deadlock */
281  /* checking purposes */
282  OrefSet(this, this->startActivity, myActivity);
283  ProtectedObject p(myActivity);
284  /* call message_send to do the send */
285  /* and assign our result. */
286  if (this->startscope != OREF_NULL)/* have a starting scope? */
287  {
288  /* send it with an override */
289  this->receiver->messageSend(this->message, (RexxObject **)this->args->data(), this->args->size(), this->startscope, p);
290  }
291  else /* no over ride */
292  {
293  this->receiver->messageSend(this->message, (RexxObject **)this->args->data(), this->args->size(), p);
294  }
295  this->resultObject = (RexxObject *)p;
296  this->setResultReturned(); /* Indicate we have a result. */
297  this->sendNotification();
298  return this->resultObject; /* return the result of the send. */
299 }
300 
302 /******************************************************************************/
303 /* Function: Since a start is to happen Async, we create a new activity */
304 /* using ourselves as a dispatch target. */
305 /******************************************************************************/
306 {
307  /* has message already been sent or */
308  /* is another start message pending? */
309  if (this->msgSent() || this->startPending())
310  {
311  /* Yes, this is an error */
313  }
314  /* indicate object has received a */
315  /*start we need this additional bit */
316  /*so that the send message will */
317  /*accept this msg */
318  this->setStartPending();
319 
320 
321  if (_receiver != OREF_NULL) /* new receiver specified? */
322  {
323  /* Yes, indicate this is the receiver*/
324  OrefSet(this, this->receiver, _receiver);
325  }
326 
327  /* get the current activity */
329  /* Create the new activity */
330  RexxActivity *newActivity = oldActivity->spawnReply();
331  /* indicate the activity the send */
332  /*message should come in on. */
333  OrefSet(this, this->startActivity, newActivity);
334  // tell the activity to run this
335  newActivity->run(this);
336  return OREF_NULL; /* all done here, return to caller. */
337 }
338 
340 /******************************************************************************/
341 /* Function : we now have a result from message send/start, so notify */
342 /* all interested parties, and post the waitResult semopohore if it exists */
343 /******************************************************************************/
344 {
345  /* no longer care about any error */
346  /*condition */
348  /* others waiting for a result? */
349  if (this->waitingActivities != OREF_NULL)
350  {
351  size_t i = this->waitingActivities->getSize();/* get the waiting count */
352  while (i--) /* while we have items */
353  {
354  /* get the first item */
355  RexxActivity *waitingActivity = (RexxActivity *)this->waitingActivities->removeFirst();
356  waitingActivity->postDispatch(); /* go wake it up */
357  }
358  }
359  /* now traverse the list of Iterested*/
360  /* parties, and let them know we */
361  /*have a result */
362  for (size_t listIndex = this->interestedParties->firstIndex() ;
363  listIndex != LIST_END;
364  listIndex = this->interestedParties->nextIndex(listIndex) )
365  {
366  /* Get the next message object to */
367  /*process */
368  RexxMessage *thisMessage = (RexxMessage *)this->interestedParties->getValue(listIndex);
369  /* now just have this message send */
370  /*its message */
371  thisMessage->send(OREF_NULL);
372  }
373 
374  /* indicate we notified all */
375  /*Interested parties. Not used */
376  /*yet.... */
377  this->setAllNotified();
378 }
379 
380 
382  RexxDirectory *_condition) /* error condition object */
383 /******************************************************************************/
384 /* Function : called from nativaAct/Activation to notify us that the message */
385 /* from SEND/START. */
386 /******************************************************************************/
387 {
388  this->setRaiseError(); /* indicate we had an error condition*/
389  /* save the condition object in case */
390  /*we want it. */
391  OrefSet(this, this->condition, _condition);
392  this->sendNotification(); /* do cleanup items. */
393 }
394 
396 /******************************************************************************/
397 /* Function: Give a completed polling status */
398 /******************************************************************************/
399 {
400  /* Test to see if result already */
401  /*present or error occured in send? */
402  if (this->resultReturned() || this->raiseError())
403  {
404  return(RexxObject *)TheTrueObject; /* Yes, return true */
405  }
406  else
407  {
408  return(RexxObject *)TheFalseObject;/* nope return false. */
409  }
410 }
411 
412 
421 {
422  if (this->raiseError())
423  {
424  return TheTrueObject;
425  }
426  else
427  {
428  return TheFalseObject;
429  }
430 }
431 
441 {
442  if (this->condition == OREF_NULL)
443  {
444  return TheNilObject;
445  }
446  else
447  {
448  return this->condition;
449  }
450 
451 }
452 
453 
462 {
463  return receiver;
464 
465 }
466 
467 
474 {
475  return message;
476 }
477 
478 
485 {
486  return (RexxArray *)args->copy();
487 }
488 
489 
490 void *RexxMessage::operator new(size_t size)
491 /******************************************************************************/
492 /* Function: Construct a new message object */
493 /******************************************************************************/
494 {
495  return new_object(size, T_Message); /* Get new object */
496 }
497 
498 
500  RexxObject **msgArgs, /* message argument array */
501  size_t argCount) /* the number of arguments */
502 /******************************************************************************/
503 /* Function: Rexx level new routine */
504 /******************************************************************************/
505 {
506  RexxArray *argPtr = NULL; // the arguments used with the message.
507 
508  size_t num_args = argCount; /* get number of args passed */
509 
510  if (num_args < 2 ) /* passed less than 2 args? */
511  {
512  /* Yes, this is an error. */
514  }
515  RexxObject *_target = msgArgs[0]; /* Get the receiver object */
516  requiredArgument(_target, ARG_ONE);
517  RexxObject *_message = msgArgs[1]; /* get the message . */
518  RexxString *msgName;
519  RexxObject *_startScope;
520  // decode the message argument into name and scope
521  RexxObject::decodeMessageName(_target, _message, msgName, _startScope);
522 
523  /* are there arguments to be sent */
524  /*with the message? */
525  if (num_args > 2 )
526  {
527  /* get 3rd arg only concerned w/ 1st */
528  RexxString *optionString = (RexxString *)msgArgs[2];
529  /* Did we really get an option */
530  /*passed? */
531  if (optionString == OREF_NULL)
532  {
533  /* nope, use null array as argument */
534  argPtr = (RexxArray *)TheNullArray->copy();
535  }
536  else
537  {
538  /* Convert it into a string. */
539  optionString = stringArgument(optionString, ARG_THREE);
540  /* char and make it lower case */
541  char option = tolower(optionString->getChar(0));
542  if (option == 'a') /* args passed as an array? */
543  {
544  /* are there less than 4 required */
545  /*args? */
546  if (num_args < 4) /* this is an error */
547  {
549  }
550 
551  /* are there more than 4 required */
552  /*args? */
553  if (num_args > 4) /* this is an error */
554  {
556  }
557 
558  /* get the array of arguments */
559  argPtr = (RexxArray *)msgArgs[3];
560  if (argPtr == OREF_NULL) /* no array given? */
561  {
562  /* this is an error */
564  }
565  /* force to array form */
566  argPtr = (RexxArray *)REQUEST_ARRAY(argPtr);
567  /* not an array? */
568  if (argPtr == TheNilObject || argPtr->getDimension() != 1)
569  {
570  /* raise an error */
572  }
573  }
574  else if (option == 'i' ) /* specified as individual? */
575  {
576  /* yes, build array of all arguments */
577  argPtr = new (argCount - 3, msgArgs + 3) RexxArray;
578  }
579  else
580  {
582  }
583  }
584  }
585  else
586  {
587  /* no args, use a null array. */
588  argPtr = (RexxArray *)TheNullArray->copy();
589  }
590  /* all args are parcelled out, go */
591  /*create the new message object... */
592  RexxMessage *newMessage = new RexxMessage(_target, msgName, _startScope, argPtr);
593  /* actually a subclassed item? */
594  if (((RexxClass *)this)->isPrimitive())
595  {
596  ProtectedObject p(newMessage);
597  /* Give new object its behaviour */
598  newMessage->setBehaviour(((RexxClass *)this)->getInstanceBehaviour());
599  newMessage->sendMessage(OREF_INIT);/* call any rexx inits */
600  }
601  return newMessage; /* return the new message */
602 }
603 
RexxMessage::startActivity
RexxActivity * startActivity
Definition: MessageClass.hpp:106
Error_Incorrect_method_noarray
#define Error_Incorrect_method_noarray
Definition: RexxErrorCodes.h:490
RexxObject::sendMessage
void sendMessage(RexxString *, RexxArray *, ProtectedObject &)
Definition: ObjectClass.cpp:668
RexxArray::getDimension
size_t getDimension()
Definition: ArrayClass.cpp:690
RexxMessage::interestedParties
RexxList * interestedParties
Definition: MessageClass.hpp:104
RexxArray
Definition: ArrayClass.hpp:100
RexxObject::decodeMessageName
static void decodeMessageName(RexxObject *target, RexxObject *message, RexxString *&messageName, RexxObject *&startScope)
Definition: ObjectClass.cpp:1811
RexxMessage::errorCondition
RexxObject * errorCondition()
Definition: MessageClass.cpp:440
RexxMessage::hasError
RexxObject * hasError()
Definition: MessageClass.cpp:420
RexxList::removeFirst
RexxObject * removeFirst()
Definition: ListClass.hpp:109
TheFalseObject
#define TheFalseObject
Definition: RexxCore.h:184
RexxMessage::result
RexxObject * result()
Definition: MessageClass.cpp:189
RexxListTable::size
size_t size
Definition: RexxListTable.hpp:71
MethodClass.hpp
RexxMessage::startPending
bool startPending()
Definition: MessageClass.hpp:84
memory_mark_general
#define memory_mark_general(oref)
Definition: RexxMemory.hpp:437
RexxArray::copy
RexxObject * copy()
Definition: ArrayClass.cpp:120
RexxMessage::classInstance
static RexxClass * classInstance
Definition: MessageClass.hpp:94
RexxInternalObject::behaviour
RexxBehaviour * behaviour
Definition: ObjectClass.hpp:306
RexxActivation.hpp
OrefSet
#define OrefSet(o, r, v)
Definition: RexxCore.h:94
RexxMessage::msgSent
bool msgSent()
Definition: MessageClass.hpp:85
Error_Execution_message_reuse
#define Error_Execution_message_reuse
Definition: RexxErrorCodes.h:534
RexxArray::data
RexxObject ** data()
Definition: ArrayClass.hpp:202
ListClass.hpp
RexxNativeActivation.hpp
RexxMessage::message
RexxString * message
Definition: MessageClass.hpp:100
RexxMessage::newRexx
RexxObject * newRexx(RexxObject **, size_t)
Definition: MessageClass.cpp:499
RexxActivity::run
void run()
Definition: RexxActivity.cpp:1384
Error_Incorrect_method_minarg
#define Error_Incorrect_method_minarg
Definition: RexxErrorCodes.h:454
RexxActivity::postDispatch
void postDispatch()
Definition: RexxActivity.cpp:1834
requiredArgument
void requiredArgument(RexxObject *object, size_t position)
Definition: RexxCore.h:284
RexxObject::messageSend
void messageSend(RexxString *, RexxObject **, size_t, ProtectedObject &)
Definition: ObjectClass.cpp:759
RexxMessage::resultObject
RexxObject * resultObject
Definition: MessageClass.hpp:103
RexxArray::size
size_t size()
Definition: ArrayClass.hpp:200
RexxMessage::target
RexxObject * target
Definition: MessageClass.hpp:99
RexxMessage::setRaiseError
void setRaiseError()
Definition: MessageClass.hpp:87
Error_Incorrect_method_noarg
#define Error_Incorrect_method_noarg
Definition: RexxErrorCodes.h:457
reportException
void reportException(wholenumber_t error)
Definition: ActivityManager.hpp:136
RexxMessage::setResultReturned
void setResultReturned()
Definition: MessageClass.hpp:86
Error_Incorrect_method_array_noclass
#define Error_Incorrect_method_array_noclass
Definition: RexxErrorCodes.h:506
Error_Incorrect_method_nomessage
#define Error_Incorrect_method_nomessage
Definition: RexxErrorCodes.h:494
TheTrueObject
#define TheTrueObject
Definition: RexxCore.h:185
RexxString::getChar
char getChar(size_t p)
Definition: StringClass.hpp:338
RexxMessage::live
void live(size_t)
Definition: MessageClass.cpp:94
RexxActivity::reraiseException
void reraiseException(RexxDirectory *)
Definition: RexxActivity.cpp:1105
RexxEnvelope
Definition: RexxEnvelope.hpp:53
REQUEST_ARRAY
RexxArray * REQUEST_ARRAY(RexxObject *obj)
Definition: RexxCore.h:433
isOfClass
#define isOfClass(t, r)
Definition: RexxCore.h:211
RexxMessage::arguments
RexxArray * arguments()
Definition: MessageClass.cpp:484
RexxList::nextIndex
size_t nextIndex(size_t i)
Definition: ListClass.cpp:803
RexxMessage::args
RexxArray * args
Definition: MessageClass.hpp:102
RexxActivity::getTopStackFrame
RexxActivationBase * getTopStackFrame()
Definition: RexxActivity.hpp:281
RexxMessage::messageTarget
RexxObject * messageTarget()
Definition: MessageClass.cpp:461
RexxMessage::start
RexxObject * start(RexxObject *)
Definition: MessageClass.cpp:301
RexxMessage::resultReturned
bool resultReturned()
Definition: MessageClass.hpp:80
RexxMessage::createInstance
static void createInstance()
Definition: MessageClass.cpp:64
ARG_ONE
const int ARG_ONE
Definition: RexxCore.h:80
OREF_NULL
#define OREF_NULL
Definition: RexxCore.h:60
RexxMessage::allNotified
bool allNotified()
Definition: MessageClass.hpp:83
ArrayClass.hpp
RexxActivity
Definition: RexxActivity.hpp:127
ARG_THREE
const int ARG_THREE
Definition: RexxCore.h:82
RexxDirectory
Definition: DirectoryClass.hpp:49
IntegerTwo
#define IntegerTwo
Definition: RexxCore.h:190
RexxClass
Definition: ClassClass.hpp:49
RexxInternalObject::setBehaviour
void setBehaviour(RexxBehaviour *b)
Definition: ObjectClass.hpp:265
ProtectedObject.hpp
RexxMessage::sendNotification
void sendNotification()
Definition: MessageClass.cpp:339
flatten_reference
#define flatten_reference(oref, envel)
Definition: RexxMemory.hpp:440
cleanUpFlatten
#define cleanUpFlatten
Definition: RexxMemory.hpp:432
RexxActivity::checkDeadLock
void checkDeadLock(RexxActivity *)
Definition: RexxActivity.cpp:1768
ProtectedObject
Definition: ProtectedObject.hpp:46
MessageClass.hpp
RexxList::getValue
RexxObject * getValue(size_t i)
Definition: ListClass.cpp:275
StringClass.hpp
RexxMessage::setAllNotified
void setAllNotified()
Definition: MessageClass.hpp:89
RexxMessage::liveGeneral
void liveGeneral(int reason)
Definition: MessageClass.cpp:112
Error_Incorrect_method_maxarg
#define Error_Incorrect_method_maxarg
Definition: RexxErrorCodes.h:456
RexxMessage::raiseError
bool raiseError()
Definition: MessageClass.hpp:81
RexxMessage::waitingActivities
RexxList * waitingActivities
Definition: MessageClass.hpp:107
IntegerOne
#define IntegerOne
Definition: RexxCore.h:189
RexxMessage
Definition: MessageClass.hpp:54
RexxNativeCode.hpp
CLASS_CREATE
#define CLASS_CREATE(name, id, className)
Definition: RexxMemory.hpp:445
T_Message
Definition: ClassTypeCodes.h:69
RexxMessage::completed
RexxObject * completed()
Definition: MessageClass.cpp:395
memory_mark
#define memory_mark(oref)
Definition: RexxMemory.hpp:436
RexxBehaviour::checkScope
bool checkScope(RexxObject *)
Definition: RexxBehaviour.cpp:643
RexxMessage::setErrorReported
void setErrorReported()
Definition: MessageClass.hpp:88
RexxMessage::startscope
RexxObject * startscope
Definition: MessageClass.hpp:101
RexxMessage::notify
RexxObject * notify(RexxMessage *)
Definition: MessageClass.cpp:152
RexxMessage::flatten
void flatten(RexxEnvelope *)
Definition: MessageClass.cpp:130
RexxMessage::setMsgSent
void setMsgSent()
Definition: MessageClass.hpp:91
TheNullArray
#define TheNullArray
Definition: RexxCore.h:182
RexxMessage::error
void error(RexxDirectory *)
Definition: MessageClass.cpp:381
new_list
RexxList * new_list()
Definition: ListClass.hpp:147
RexxMessage::messageName
RexxString * messageName()
Definition: MessageClass.cpp:473
RexxInternalObject::isPrimitive
bool isPrimitive()
Definition: ObjectClass.hpp:245
setUpFlatten
#define setUpFlatten(type)
Definition: RexxMemory.hpp:427
IntegerFour
#define IntegerFour
Definition: RexxCore.h:192
TheNilObject
#define TheNilObject
Definition: RexxCore.h:180
ActivityManager::currentActivity
static RexxActivity *volatile currentActivity
Definition: ActivityManager.hpp:95
RexxMessage::condition
RexxDirectory * condition
Definition: MessageClass.hpp:105
RexxList::getSize
size_t getSize()
Definition: ListClass.hpp:126
RexxActivity.hpp
RexxActivity::waitReserve
void waitReserve(RexxObject *)
Definition: RexxActivity.cpp:1794
RexxMessage::setStartPending
void setStartPending()
Definition: MessageClass.hpp:90
LIST_END
#define LIST_END
Definition: ListClass.hpp:60
Error_Incorrect_method_option
#define Error_Incorrect_method_option
Definition: RexxErrorCodes.h:468
stringArgument
RexxString * stringArgument(RexxObject *object, size_t position)
Definition: RexxCore.h:296
RexxMessage::send
RexxObject * send(RexxObject *)
Definition: MessageClass.cpp:239
RexxMessage::RexxMessage
RexxMessage(RexxObject *, RexxString *, RexxObject *, RexxArray *)
Definition: MessageClass.cpp:79
RexxMessage::receiver
RexxObject * receiver
Definition: MessageClass.hpp:98
RexxCore.h
RexxActivity::spawnReply
RexxActivity * spawnReply()
Definition: RexxActivity.cpp:292
RexxList
Definition: ListClass.hpp:63
DirectoryClass.hpp
new_object
RexxObject * new_object(size_t s)
Definition: RexxMemory.hpp:422
RexxList::firstIndex
size_t firstIndex()
Definition: ListClass.hpp:84
RexxActivationBase::setObjNotify
virtual void setObjNotify(RexxMessage *)
Definition: ObjectClass.hpp:589
RexxList::addLast
void addLast(RexxObject *value)
Definition: ListClass.cpp:454
RexxObject
Definition: ObjectClass.hpp:311
RexxString
Definition: StringClass.hpp:119