75 #include "SystemInterpreter.hpp"
87 bool firstDispatch =
true;
95 size_t activityLevel = 0;
103 this->
runsem.
wait(
"RexxActivity::runThread", 0);
115 firstDispatch =
false;
215 void *RexxActivity::operator
new(
size_t size)
233 : runsem(
"RexxActivity::runsem"), guardsem(
"RexxActivity::guardsem")
326 for (
int i = 0; i < 13; i++)
464 bool handled =
false;
472 handled = activation->trap(condition, conditionObj);
505 conditionObj->
put(condition, OREF_CONDITION);
507 conditionObj->
put(description ==
OREF_NULL ? OREF_NULLSTRING : description, OREF_DESCRIPTION);
512 conditionObj->
put(rc, OREF_RC);
516 conditionObj->
put(additional, OREF_ADDITIONAL);
520 conditionObj->
put(result, OREF_RESULT);
619 RexxArray *substitutions =
new_array(substitution1, substitution2, substitution3, substitution4);
635 RexxArray *substitutions =
new_array(substitution1, substitution2, substitution3, substitution4, substitution5);
642 const char *substitution1,
644 const char *substitution3,
654 RexxArray *substitutions =
new_array(ssubstitution1, substitution2, ssubstitution3, substitution4);
1054 if (topFrame == activation)
1126 sprintf(
work,
"%ld.%1ld", errcode/1000, errcode - primary);
1128 exobj->
put(code, OREF_CODE);
1132 exobj->
put(rc, OREF_RC);
1140 exobj->
put(errortext, OREF_ERRORTEXT);
1149 exobj->
put(additional, OREF_ADDITIONAL);
1151 if (primary != errcode)
1156 exobj->
put(message, OREF_NAME_MESSAGE);
1169 exobj->
put(OREF_NULLSTRING, OREF_DESCRIPTION);
1173 exobj->
put(description, OREF_DESCRIPTION);
1178 exobj->
put(result, OREF_RESULT);
1185 exobj->
put(OREF_SYNTAX, OREF_CONDITION);
1203 exobj->
put(stackFrames, OREF_STACKFRAMES);
1207 exobj->
put(traceback, OREF_TRACEBACK);
1214 while (frame != NULL)
1220 firstFrame = stackFrame;
1223 stackFrames->
append(stackFrame);
1225 frame = frame->
next;
1234 exobj->
put(lineNumber, OREF_POSITION);
1248 exobj->
put(OREF_NULLSTRING, OREF_PROGRAM);
1270 while (frame != NULL)
1280 stackFrames->
append(stackFrame);
1282 frame = frame->
next;
1319 size_t substitutions = additional->
size();
1323 for (
size_t i = 1; i <= substitutions; i++)
1326 sizeC_t subposition = message->
pos(OREF_AND, 0);
1327 if (subposition == 0)
1341 if (selector < '0' || selector >
'9')
1350 if (selector <= substitutions)
1384 newmessage = newmessage->
concat(front_stringVal);
1385 p_newmessage = newmessage;
1389 newmessage = newmessage->
concat(message);
1412 exobj->
remove(OREF_POSITION);
1413 exobj->
remove(OREF_PROGRAM);
1414 exobj->
remove(OREF_PACKAGE);
1422 if (errornumber != primary)
1427 sprintf(
work,
"%1ld%3.3ld", errornumber/1000, errornumber - primary);
1428 errornumber = atol(
work);
1436 exobj->
put(message, OREF_NAME_MESSAGE);
1457 activation->
trap(condition, conditionObj);
1472 this->
kill(conditionObj);
1490 size_t tracebackSize = trace_back->
size();
1492 for (
size_t i = 1; i <= tracebackSize; i++)
1527 if (programname !=
OREF_NULL && programname != OREF_NULLSTRING)
1545 text = text->
concatWith(positionString,
' ');
1562 rc = exobj->
at(OREF_CODE);
1584 text = text->
concat(secondary);
1619 secondary = (
RexxString *)exobj->
at(OREF_NAME_MESSAGE);
1631 text = text->
concat(secondary);
1879 while (poppedStackFrame != target)
2105 if (owningActivity == targetActivity)
2190 if (activation != NULL)
2192 activation->
yield();
2211 if (activation != NULL)
2214 return activation->
halt(d);
2234 if (activation != NULL)
2300 printf(
"RexxActivity::checkStackSpace : SP=%16.16x stackBase=%16.16x delta=%i MIN_C_STACK=%i %i %i\n",
2303 ((
char *)&temp - (
char *)this->stackBase),
2305 ((
char *)&temp - (
char *)this->stackBase) <
MIN_C_STACK,
2377 const char *exitName,
int function,
2378 int subfunction,
void *exitbuffer)
2382 int rc = handler.
call(
this, activation,
function, subfunction, exitbuffer);
2387 if (
function ==
RXSIO)
2568 exit_parm.
rxfnc_argc = (
unsigned short)argcount;
2583 for (
size_t argindex=0; argindex < exit_parm.
rxfnc_argc; argindex++)
2597 argrxarray[argindex].strlength = 0;
2598 argrxarray[argindex].strptr = (
const char *)NULL;
2656 size_t named_argcount)
2666 if (manager->
checkFunctionCall(rname, argcount, named_argcount, arguments, funcresult))
2788 if (manager->
checkCommand(
this, address, command, result, condition))
3031 bool currentsetting)
3166 p_line =
line->stringTrace();
3180 p_line = ((
RexxString*)p_line)->concatToCstring(buffer);
3246 value = OREF_NULLSTRING;
3251 value = OREF_NULLSTRING;
3279 value = this->
lineIn(activation);
3296 data =
line->getStringData();
3297 printf(
"%.*s\n",(
int)length, data);
3321 value = OREF_NULLSTRING;
3326 value = OREF_NULLSTRING;
3404 newNActa->
run(target);
3456 new_activation->
run(target);
3476 new_activation->
run(target);
void reportException(wholenumber_t error)
RexxArray * new_array(size_t s)
RexxDirectory * new_directory()
RexxInteger * new_integer(wholenumber_t v)
uint64_t RANDOMIZE(uint64_t seed)
const size_t ACT_STACK_SIZE
wholenumber_t requestAccessCount
RexxString * REQUEST_STRING(RexxObject *object)
#define Message_Translations_debug_error
#define Error_Function_no_data_function
#define Error_System_resources
#define Error_Interpretation
#define Message_Translations_running
#define Error_Control_stack_full
#define Error_Execution_invalid_thread
#define Message_Translations_error
#define Error_System_service_service
#define Message_Translations_line
#define Error_Execution_error_condition
#define Error_Incorrect_call_external
#define Error_Routine_not_found_name
#define Error_Execution_deadlock
RexxInternalStack * new_internalstack(size_t s)
#define memory_mark(oref)
RexxObject * new_object(size_t s)
#define memory_mark_general(oref)
RexxString * new_string(const char *s, stringsizeB_t bl, sizeC_t cl=-1)
#define CONCURRENCY_TRACE
#define CONCURRENCY_BUFFER_SIZE
virtual RexxMethod * method()=0
virtual StackFrameClass * createStackFrame()=0
virtual RexxString * messageName()=0
virtual RexxSource * getSource()=0
virtual void handleError(wholenumber_t, RexxDirectory *)
RexxDirectory * conditionData
static RexxNativeActivation * newNativeActivation(RexxActivity *activity, RexxActivation *parent)
static void relinquish(RexxActivity *activity)
static bool lockKernelImmediate()
static void unlockKernel()
static void activityEnded(RexxActivity *)
static void addWaitingActivity(RexxActivity *a, bool release)
static RexxActivity *volatile currentActivity
int call(RexxActivity *activity, RexxActivation *activation, int major, int minor, void *parms)
static wholenumber_t messageNumber(RexxString *)
static RexxString * getCurrentQueue()
bool poolActivity(RexxActivity *activity)
RexxObject * getLocalEnvironment(RexxString *)
RexxInstance * getInstanceContext()
ExitHandler & getExitHandler(int exitNum)
SecurityManager * getSecurityManager()
RexxDirectory * getLocal()
RexxActivity * spawnActivity(RexxActivity *parent)
RexxString * resolveProgramName(RexxString *name, RexxString *dir, RexxString *ext)
CommandHandler * resolveCommandHandler(RexxString *name)
static NumericSettings * setDefaultSettings()
static NumericSettings * getDefaultSettings()
static wholenumber_t maxVal(wholenumber_t n1, wholenumber_t n2)
static void setCurrentSettings(NumericSettings *s)
RexxObject * protectedObject
virtual NumericSettings * getNumericSettings()
virtual bool trap(RexxString *, RexxDirectory *)
virtual RexxObject * dispatch()
virtual void termination()
virtual bool isStackBase()
virtual SecurityManager * getSecurityManager()=0
virtual RexxActivation * findRexxContext()
void setPreviousStackFrame(RexxActivationBase *p)
RexxSource * getSourceObject()
bool isObjectScopeLocked()
SecurityManager * getEffectiveSecurityManager()
unsigned short getReserveCount()
RexxVariableDictionary * getVariableDictionary()
void liveGeneral(int reason)
size_t getActivationLevel()
bool callTraceTestExit(RexxActivation *, bool)
RexxActivity * nestedActivity
CommandHandler * resolveCommandHandler(RexxString *)
void queue(RexxActivation *, RexxString *, int)
void pushStackFrame(RexxActivationBase *new_activation)
void setupAttachedActivity(InterpreterInstance *interpreter)
static void initializeThreadContext()
void restoreActivationLevel(size_t l)
bool callScriptingExit(RexxActivation *, RexxString *, RexxObject *, ProtectedObject &, RexxObject **, size_t)
RexxDirectory * getThreadLocal()
void reportAnException(wholenumber_t, const char *)
RexxNativeActivation * getApiContext()
static MethodContextInterface methodContextFunctions
void callTerminationExit(RexxActivation *)
RexxActivation * currentRexxFrame
void kill(RexxDirectory *)
static wholenumber_t requestAccessCounter()
thread_id_t threadIdMethod()
void enterCurrentThread()
bool callHaltTestExit(RexxActivation *)
bool callQueueNameExit(RexxActivation *, RexxString *&)
RexxActivationStack frameStack
void generateProgramInformation(RexxDirectory *exObj)
ExitHandler sysexits[LAST_EXIT]
SecurityManager * getEffectiveSecurityManager()
RexxObject * displayDebug(RexxDirectory *)
RexxString * pullInput(RexxActivation *)
bool callObjectFunctionExit(RexxActivation *, RexxString *, RexxObject *, ProtectedObject &, RexxObject **, size_t, size_t)
void inheritSettings(RexxActivity *parent)
bool callNovalueExit(RexxActivation *, RexxString *, RexxObject *&)
void traceOutput(RexxActivation *, RexxString *)
void callInitializationExit(RexxActivation *)
static ExitContextInterface exitContextFunctions
RexxObject * getLocalEnvironment(RexxString *name)
void createMethodContext(MethodContext &context, RexxNativeActivation *owner)
bool callFunctionExit(RexxActivation *, RexxString *, RexxObject *, ProtectedObject &, RexxObject **, size_t)
RexxString * messageSubstitution(RexxString *, RexxArray *)
void raiseException(wholenumber_t, RexxString *, RexxArray *, RexxObject *)
void terminatePoolActivity()
RexxString * getLastMessageName()
size_t activationStackSize
RexxInternalStack * activations
ActivationFrame * activationFrames
RexxActivationBase * topStackFrame
void disableExit(int exitNum)
void popStackFrame(bool reply)
SysActivity currentThread
void cleanupActivityResources()
RexxActivity * spawnReply()
void liveGeneral(int reason)
RexxDirectory * threadLocalEnvironment
bool callTraceExit(RexxActivation *, RexxString *)
void unwindToDepth(size_t depth)
InterpreterInstance * instance
RexxString * buildMessage(wholenumber_t, RexxArray *)
NumericSettings * numericSettings
void addToInstance(InterpreterInstance *interpreter)
void reraiseException(RexxDirectory *)
bool isExitEnabled(int exitNum)
wholenumber_t displayCondition(RexxDirectory *conditionObject)
RexxString * lineIn(RexxActivation *)
void updateFrameMarkers()
void unwindToFrame(RexxActivation *frame)
RexxDirectory * conditionobj
void createNewActivationStack()
bool callPullExit(RexxActivation *, RexxString *&)
void createCallContext(CallContext &context, RexxNativeActivation *owner)
void resetRunningRequires()
void createExitContext(ExitContext &context, RexxNativeActivation *owner)
SecurityManager * getInstanceSecurityManager()
wholenumber_t errorNumber(RexxDirectory *conditionObject)
RexxMessage * dispatchMessage
void checkActivationStack()
void clearCurrentCondition()
void raisePropagate(RexxDirectory *)
bool callPushExit(RexxActivation *, RexxString *, int)
RexxDirectory * createConditionObject(RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *)
RexxMethod * getLastMethod()
static CallContextInterface callContextFunctions
bool callHaltClearExit(RexxActivation *)
static RexxThreadInterface threadContextFunctions
RexxTable * requiresTable
bool callExit(RexxActivation *activation, const char *exitName, int function, int subfunction, void *exitbuffer)
RexxString * resolveProgramName(RexxString *, RexxString *, RexxString *)
void generateRandomNumberSeed()
RexxActivationBase * getTopStackFrame()
void sayOutput(RexxActivation *, RexxString *)
bool callQueueSizeExit(RexxActivation *, RexxInteger *&)
bool callCommandExit(RexxActivation *, RexxString *, RexxString *, ProtectedObject &result, ProtectedObject &condition)
RexxDirectory * getLocal()
ActivityContext threadContext
RexxArray * generateStackFrames(bool skipFirst)
bool callValueExit(RexxActivation *, RexxString *, RexxString *, RexxObject *, RexxObject *&)
RexxObject * display(RexxDirectory *)
void flatten(RexxEnvelope *)
void checkDeadLock(RexxActivity *)
RexxDirectory * createExceptionObject(wholenumber_t, RexxString *, RexxArray *, RexxObject *)
void setSuspended(bool s)
RexxObject * waitingObject
ProtectedObject * protectedObjects
ExitHandler & getExitHandler(int exitNum)
bool callSayExit(RexxActivation *, RexxString *)
RexxObject * lineOut(RexxString *)
void cleanupStackFrame(RexxActivationBase *poppedStackFrame)
bool callTerminalInputExit(RexxActivation *, RexxString *&)
void waitReserve(RexxObject *)
bool raiseCondition(RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *)
bool callDebugInputExit(RexxActivation *, RexxString *&)
RexxActivation * getCurrentRexxFrame()
RexxString * traceInput(RexxActivation *)
size_t append(RexxObject *)
RexxObject * get(size_t pos)
RexxObject * at(RexxString *)
RexxObject * put(RexxObject *, RexxString *)
RexxObject * remove(RexxString *)
void setHasNoReferences()
RexxObject * peek(size_t v)
void push(RexxObject *value)
RexxObject * append(RexxObject *)
void verboseMessage(const char *message)
void run(RexxMethod *_method, RexxNativeMethod *_code, RexxObject *_receiver, RexxString *_msgname, RexxObject **_arglist, size_t _argcount, size_t _named_argcount, ProtectedObject &resultObj)
void setConditionInfo(RexxDirectory *info)
void enableVariablepool()
RexxString * stringValue()
void sendMessage(RexxString *, RexxArray *, RexxDirectory *, ProtectedObject &)
virtual bool numberValue(wholenumber_t &result, size_t precision)
virtual RexxString * defaultName()
RexxString * getProgramName()
PackageClass * getPackage()
RexxString * extractC(sizeC_t offset, sizeC_t sublength)
void toRxstring(CONSTRXSTRING &r)
const char * getStringData()
RexxString * concatWithCstring(const char *)
bool isEqual(RexxObject *)
RexxString * concat(RexxString *)
RexxString * concatWith(RexxString *, char)
sizeC_t pos(RexxString *, sizeC_t)
codepoint_t getCharC(sizeC_t p)
bool checkFunctionCall(RexxString *functionName, size_t count, size_t named_count, RexxObject **arguments, ProtectedObject &result)
bool checkCommand(RexxActivity *, RexxString *address, RexxString *command, ProtectedObject &result, ProtectedObject &condition)
RexxString * getTraceLine()
thread_id_t getThreadID()
void create(RexxActivity *activity, size_t stackSize)
char * getStackBase(size_t stackSize)
void wait(const char *ds, int di)
void setSemVariable(const char *variable)
static void getCurrentTime(RexxDateTime *Date)
static RexxString * getMessageText(wholenumber_t code)
static RexxString * getMessageHeader(wholenumber_t code)
static void * allocateResultMemory(sizeB_t)
static void releaseResultMemory(void *)
static wholenumber_t currentThreadId()
static bool traceConcurrency()
static int snprintf(char *buffer, size_t count, const char *format,...)
struct _RexxStringObject * RexxStringObject
CONSTANT_RXSTRING * PCONSTRXSTRING
struct _RexxObjectPtr * RexxObjectPtr
#define MAKERXSTRING(r, p, l)
#define RXEXIT_RAISE_ERROR
CONSTANT_STRING rxcmd_address
unsigned short rxcmd_dll_len
unsigned short rxcmd_addressl
CONSTANT_STRING rxcmd_dll
CONSTANT_RXSTRING rxcmd_command
CONSTANT_RXSTRING rxfnc_name
RexxObjectPtr * rxfnc_argv
PCONSTRXSTRING rxfnc_argv
unsigned short rxfnc_namel
CONSTANT_STRING rxfnc_que
unsigned short rxfnc_quel
unsigned short rxfnc_argc
CONSTANT_STRING rxfnc_name
CONSTANT_RXSTRING rxmsq_value
CONSTANT_RXSTRING rxfnc_name
RexxObjectPtr * rxfnc_argv
CONSTANT_RXSTRING rxsio_string
RexxStringObject variable_name
RexxStringObject selector
RexxStringObject variable_name
RexxActivity * owningActivity
RexxThreadContext threadContext
RexxNativeActivation * context
RexxCallContext threadContext
RexxNativeActivation * context
RexxExitContext threadContext
RexxNativeActivation * context
RexxMethodContext threadContext
CallContextInterface * functions
RexxThreadContext * threadContext
RexxThreadContext * threadContext
ExitContextInterface * functions
MethodContextInterface * functions
RexxThreadContext * threadContext
RexxThreadInterface * functions
RexxStringObject RexxNullString
void dbgprintf(const char *format,...)
unsigned __int64 uint64_t