Menu
▾
▴
[Oorexx-svn] SF.net SVN: oorexx: [2592] sandbox/rick/opt
|
From: <bi...@us...> - 2008-06-27 15:58:29
|
Revision: 2592
http://oorexx.svn.sourceforge.net/oorexx/?rev=2592&view=rev
Author: bigrixx
Date: 2008-06-27 08:32:21 -0700 (Fri, 27 Jun 2008)
Log Message:
-----------
merge kernel updates to trunk into the sandbox
Modified Paths:
--------------
sandbox/rick/opt/kernel/classes/ObjectClass.cpp
sandbox/rick/opt/kernel/expression/ExpressionMessage.cpp
sandbox/rick/opt/kernel/expression/ExpressionStem.cpp
sandbox/rick/opt/kernel/expression/ExpressionVariable.cpp
sandbox/rick/opt/kernel/instructions/LabelInstruction.cpp
sandbox/rick/opt/kernel/instructions/ParseTrigger.cpp
sandbox/rick/opt/kernel/runtime/InterpreterInstance.cpp
sandbox/rick/opt/kernel/runtime/RexxActivation.cpp
sandbox/rick/opt/kernel/runtime/RexxActivation.hpp
sandbox/rick/opt/kernel/runtime/RexxActivity.cpp
sandbox/rick/opt/kernel/runtime/RexxActivity.hpp
sandbox/rick/opt/kernel/runtime/RexxMemory.cpp
sandbox/rick/opt/kernel/runtime/RexxMemory.hpp
sandbox/rick/opt/kernel/runtime/RexxNativeActivation.cpp
sandbox/rick/opt/rexutils/rxftp.cls
sandbox/rick/opt/rexutils/unix/rexxutil.cpp
Modified: sandbox/rick/opt/kernel/classes/ObjectClass.cpp
===================================================================
--- sandbox/rick/opt/kernel/classes/ObjectClass.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/classes/ObjectClass.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -1487,7 +1487,7 @@
/******************************************************************************/
{
/* check the behaviour for the method*/
- return (this->behaviour->methodObject(msgname) != OREF_NULL) ? TheTrueObject : TheFalseObject;
+ return (this->behaviour->methodLookup(msgname) != OREF_NULL) ? TheTrueObject : TheFalseObject;
}
RexxClass *RexxObject::classObject()
@@ -2186,9 +2186,9 @@
/******************************************************************************/
{
/* create a new object */
- RexxObject *newObject = new (classObject) RexxObject;
+ ProtectedObject newObject = new (classObject) RexxObject;
/* now drive the user INIT */
- newObject->sendMessage(OREF_INIT, args, argCount);
+ ((RexxObject *)newObject)->sendMessage(OREF_INIT, args, argCount);
return(RexxObject *)newObject; /* and returnthe new object */
}
Modified: sandbox/rick/opt/kernel/expression/ExpressionMessage.cpp
===================================================================
--- sandbox/rick/opt/kernel/expression/ExpressionMessage.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/expression/ExpressionMessage.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -271,6 +271,8 @@
// send with an override
stack->send(this->messageName, _super, argcount + 1, result);
}
+ /* trace if necessary */
+ context->traceAssignment(messageName, (RexxObject *)result);
// remove all arguments (arguments + target + assignment value)
stack->popn(argcount + 2);
}
Modified: sandbox/rick/opt/kernel/expression/ExpressionStem.cpp
===================================================================
--- sandbox/rick/opt/kernel/expression/ExpressionStem.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/expression/ExpressionStem.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -36,7 +36,7 @@
/* */
/*----------------------------------------------------------------------------*/
/******************************************************************************/
-/* REXX Translator ExpressionStem.c */
+/* REXX Translator ExpressionStem.cpp */
/* */
/* Primitive Translator Expression Parsing Stem Reference Class */
/* */
@@ -99,20 +99,18 @@
/* Function: Evaluate a REXX stem variable */
/******************************************************************************/
{
- RexxObject *value; /* final variable value */
-
- /* look up the name */
- value = context->getLocalStem(this->stem, this->index);
- /* NOTE: stem accesses do NOT */
- /* report NOVALUE so that DO OVER, */
- /* call-by-reference with a stem and */
- /* return with a stem does not */
- /* trigger a novalue trap */
- /* unexpectedly */
- stack->push(value); /* place on the evaluation stack */
- /* trace if necessary */
- context->traceVariable(stem, value);
- return value; /* return the located variable */
+ /* look up the name */
+ RexxObject *value = context->getLocalStem(this->stem, this->index);
+ /* NOTE: stem accesses do NOT */
+ /* report NOVALUE so that DO OVER, */
+ /* call-by-reference with a stem and */
+ /* return with a stem does not */
+ /* trigger a novalue trap */
+ /* unexpectedly */
+ stack->push(value); /* place on the evaluation stack */
+ /* trace if necessary */
+ context->traceVariable(stem, value);
+ return value; /* return the located variable */
}
RexxObject *RexxStemVariable::getValue(
@@ -123,7 +121,7 @@
/******************************************************************************/
{
/* look up the name */
- return dictionary->getStem(this->stem);
+ return dictionary->getStem(this->stem);
}
RexxObject *RexxStemVariable::getValue(
@@ -134,7 +132,7 @@
/******************************************************************************/
{
/* look up the name */
- return context->getLocalStem(stem, index);
+ return context->getLocalStem(stem, index);
}
/**
@@ -148,7 +146,7 @@
*/
RexxObject *RexxStemVariable::getRealValue(RexxVariableDictionary *dictionary)
{
- return dictionary->getStem(this->stem);
+ return dictionary->getStem(this->stem);
}
/**
@@ -162,7 +160,7 @@
*/
RexxObject *RexxStemVariable::getRealValue(RexxActivation *context)
{
- return context->getLocalStem(stem, index);
+ return context->getLocalStem(stem, index);
}
void RexxStemVariable::set(
@@ -172,20 +170,19 @@
/* Function: Fast set of a stem variable value */
/******************************************************************************/
{
- RexxStem *stem_table; /* retrieved stem table */
- RexxVariable *variable; /* stem variable entry */
-
- /* look up the name */
- variable = context->getLocalStemVariable(stem, index);
- if (isOfClass(Stem, value)) { /* stem to stem assignment */
- variable->set(value); /* overlay the reference stem object */
- }
- else {
- /* create a new stem object as value */
- stem_table = new RexxStem (this->stem);
- variable->set(stem_table); /* overlay the reference stem object */
- stem_table->setValue(value); /* set the default value */
- }
+ /* look up the name */
+ RexxVariable *variable = context->getLocalStemVariable(stem, index);
+ if (isOfClass(Stem, value))
+ { /* stem to stem assignment */
+ variable->set(value); /* overlay the reference stem object */
+ }
+ else
+ {
+ /* create a new stem object as value */
+ RexxStem *stem_table = new RexxStem (this->stem);
+ variable->set(stem_table); /* overlay the reference stem object */
+ stem_table->setValue(value); /* set the default value */
+ }
}
@@ -196,20 +193,19 @@
/* Function: Fast set of a stem variable value */
/******************************************************************************/
{
- RexxStem *stem_table; /* retrieved stem table */
- RexxVariable *variable; /* stem variable entry */
-
- /* look up the name */
- variable = dictionary->getStemVariable(this->stem);
- if (isOfClass(Stem, value)) { /* stem to stem assignment */
- variable->set(value); /* overlay the reference stem object */
- }
- else {
- /* create a new stem object as value */
- stem_table = new RexxStem (this->stem);
- variable->set(stem_table); /* overlay the reference stem object */
- stem_table->setValue(value); /* set the default value */
- }
+ /* look up the name */
+ RexxVariable *variable = dictionary->getStemVariable(this->stem);
+ if (isOfClass(Stem, value))
+ { /* stem to stem assignment */
+ variable->set(value); /* overlay the reference stem object */
+ }
+ else
+ {
+ /* create a new stem object as value */
+ RexxStem *stem_table = new RexxStem (this->stem);
+ variable->set(stem_table); /* overlay the reference stem object */
+ stem_table->setValue(value); /* set the default value */
+ }
}
@@ -220,7 +216,7 @@
/******************************************************************************/
{
/* retrieve the variable value */
- return context->localStemVariableExists(stem, index);
+ return context->localStemVariableExists(stem, index);
}
void RexxStemVariable::assign(
@@ -231,20 +227,20 @@
/* Function: Assign a value to a stem variable */
/******************************************************************************/
{
- RexxStem *stem_table; /* retrieved stem table */
- RexxVariable *variable; /* stem variable entry */
-
- /* look up the name */
- variable = context->getLocalStemVariable(stem, index);
- if (isOfClass(Stem, value)) { /* stem to stem assignment */
- variable->set(value); /* overlay the reference stem object */
- }
- else {
- /* create a new stem object as value */
- stem_table = new RexxStem (this->stem);
- variable->set(stem_table); /* overlay the reference stem object */
- stem_table->setValue(value); /* set the default value */
- }
+ RexxVariable *variable = context->getLocalStemVariable(stem, index);
+ if (isOfClass(Stem, value))
+ { /* stem to stem assignment */
+ variable->set(value); /* overlay the reference stem object */
+ }
+ else
+ {
+ /* create a new stem object as value */
+ RexxStem *stem_table = new RexxStem (this->stem);
+ variable->set(stem_table); /* overlay the reference stem object */
+ stem_table->setValue(value); /* set the default value */
+ }
+ // trace the assignment
+ context->traceAssignment(stem, value);
}
void RexxStemVariable::drop(
@@ -253,8 +249,8 @@
/* Function: Drop a variable object */
/******************************************************************************/
{
- /* drop the stem value */
- context->dropLocalStem(stem, index);
+ /* drop the stem value */
+ context->dropLocalStem(stem, index);
}
void RexxStemVariable::procedureExpose(
@@ -265,17 +261,18 @@
/* Function: Expose a stem variable */
/******************************************************************************/
{
- RexxVariable *old_variable; /* variable from the prior level */
+ /* get the old variable entry */
+ RexxVariable *old_variable = parent->getLocalStemVariable(stem, index);
- /* get the old variable entry */
- old_variable = parent->getLocalStemVariable(stem, index);
-
- /* set the entry in the new table */
- if (index == 0) {
- context->updateLocalVariable(old_variable);
- } else {
- context->putLocalVariable(old_variable, index);
+ /* set the entry in the new table */
+ if (index == 0)
+ {
+ context->updateLocalVariable(old_variable);
}
+ else
+ {
+ context->putLocalVariable(old_variable, index);
+ }
}
@@ -288,10 +285,8 @@
/* Function: Expose a stem variable */
/******************************************************************************/
{
- RexxVariable *old_stem; /* variable from the prior level */
-
/* get the old variable entry */
- old_stem = object_dictionary->getStemVariable(stem);
+ RexxVariable *old_stem = object_dictionary->getStemVariable(stem);
/* set the entry in the new table */
context->putLocalVariable(old_stem, index);
}
@@ -303,11 +298,9 @@
/* Set a guard variable notification on a stem variable */
/******************************************************************************/
{
- RexxVariable *variable; /* target variable object */
-
/* look up the name */
- variable = context->getLocalStemVariable(this->stem, this->index);
- variable->inform(ActivityManager::currentActivity); /* mark the variable entry */
+ RexxVariable *variable = context->getLocalStemVariable(this->stem, this->index);
+ variable->inform(ActivityManager::currentActivity); /* mark the variable entry */
}
void RexxStemVariable::clearGuard(
@@ -316,11 +309,9 @@
/* Remove a guard variable notification on an object variable */
/******************************************************************************/
{
- RexxVariable *variable; /* target variable object */
-
/* look up the name */
- variable = context->getLocalStemVariable(this->stem, this->index);
- variable->uninform(ActivityManager::currentActivity); /* mark the variable entry */
+ RexxVariable *variable = context->getLocalStemVariable(this->stem, this->index);
+ variable->uninform(ActivityManager::currentActivity); /* mark the variable entry */
}
@@ -342,12 +333,10 @@
/* Function: Create a new translator object */
/******************************************************************************/
{
- RexxObject *newObject; /* newly created object */
-
- /* Get new object */
- newObject = (RexxObject *)new_object(size);
- /* Give new object its behaviour */
- newObject->setBehaviour(TheStemVariableTermBehaviour);
- return newObject; /* return the new object */
+ /* Get new object */
+ RexxObject *newObject = (RexxObject *)new_object(size);
+ /* Give new object its behaviour */
+ newObject->setBehaviour(TheStemVariableTermBehaviour);
+ return newObject; /* return the new object */
}
Modified: sandbox/rick/opt/kernel/expression/ExpressionVariable.cpp
===================================================================
--- sandbox/rick/opt/kernel/expression/ExpressionVariable.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/expression/ExpressionVariable.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -36,7 +36,7 @@
/* */
/*----------------------------------------------------------------------------*/
/******************************************************************************/
-/* REXX Translator ExpressionVariable.c */
+/* REXX Translator ExpressionVariable.cpp */
/* */
/* Primitive Translator Expression Parsing Variable Reference Class */
/* */
@@ -228,6 +228,7 @@
{
/* The context handles the details of this */
context->setLocalVariable(variableName, index, value);
+ context->traceAssignment(variableName, value);
}
void RexxParseVariable::drop(
Modified: sandbox/rick/opt/kernel/instructions/LabelInstruction.cpp
===================================================================
--- sandbox/rick/opt/kernel/instructions/LabelInstruction.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/instructions/LabelInstruction.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -36,7 +36,7 @@
/* */
/*----------------------------------------------------------------------------*/
/******************************************************************************/
-/* REXX Translator LabelInstruction.c */
+/* REXX Translator LabelInstruction.cpp */
/* */
/* Primitive Label Parse Class */
/* */
@@ -54,6 +54,6 @@
/****************************************************************************/
{
context->traceLabel(this); /* trace if necessary */
- context->pauseInstruction(); /* pause if in debug mode */
+ context->pauseLabel(); /* pause if in debug mode */
}
Modified: sandbox/rick/opt/kernel/instructions/ParseTrigger.cpp
===================================================================
--- sandbox/rick/opt/kernel/instructions/ParseTrigger.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/instructions/ParseTrigger.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -36,7 +36,7 @@
/* */
/*----------------------------------------------------------------------------*/
/******************************************************************************/
-/* REXX Translator ParseTrigger.c */
+/* REXX Translator ParseTrigger.cpp */
/* */
/* Primitive Procedure Parse Trigger Class */
/* */
@@ -106,101 +106,124 @@
/* Function: Apply a parsing trigger against a parsing target */
/******************************************************************************/
{
- RexxObject *_value = OREF_NULL;/* evaluated trigger part */
- RexxString *stringvalue; /* new string value */
- stringsize_t integer; /* target integer value */
- size_t i; /* loop counter */
- size_t size; /* size of variables array */
- RexxVariableBase *variable; /* current variable processing */
+ RexxObject *_value = OREF_NULL;/* evaluated trigger part */
+ RexxString *stringvalue; /* new string value */
+ stringsize_t integer; /* target integer value */
+ size_t i; /* loop counter */
+ size_t size; /* size of variables array */
+ RexxVariableBase *variable; /* current variable processing */
- if (this->value != OREF_NULL) { /* need a value processed? */
- /* evaluate the expression part */
- _value = this->value->evaluate(context, stack);
- context->traceResult(_value); /* trace if necessary */
- stack->pop(); /* Get rid of the value off the stack*/
- }
- switch (this->getType()) { /* perform the trigger operations */
+ if (this->value != OREF_NULL)
+ { /* need a value processed? */
+ /* evaluate the expression part */
+ _value = this->value->evaluate(context, stack);
+ context->traceResult(_value); /* trace if necessary */
+ stack->pop(); /* Get rid of the value off the stack*/
+ }
+ switch (this->getType())
+ { /* perform the trigger operations */
- case TRIGGER_END: /* just match to the end */
- target->moveToEnd(); /* move the pointers */
- break;
+ case TRIGGER_END: /* just match to the end */
+ target->moveToEnd(); /* move the pointers */
+ break;
- case TRIGGER_PLUS: /* positive relative target */
- integer = this->integerTrigger(_value); /* get binary version of trigger */
- target->forward(integer); /* move the position */
- break;
+ case TRIGGER_PLUS: /* positive relative target */
+ integer = this->integerTrigger(_value); /* get binary version of trigger */
+ target->forward(integer); /* move the position */
+ break;
- case TRIGGER_MINUS: /* negative relative target */
- integer = this->integerTrigger(_value); /* get binary version of trigger */
- target->backward(integer); /* move the position */
- break;
+ case TRIGGER_MINUS: /* negative relative target */
+ integer = this->integerTrigger(_value); /* get binary version of trigger */
+ target->backward(integer); /* move the position */
+ break;
- case TRIGGER_PLUS_LENGTH: /* positive length */
- integer = this->integerTrigger(_value); /* get binary version of trigger */
- target->forwardLength(integer); /* move the position */
- break;
+ case TRIGGER_PLUS_LENGTH: /* positive length */
+ integer = this->integerTrigger(_value); /* get binary version of trigger */
+ target->forwardLength(integer); /* move the position */
+ break;
- case TRIGGER_MINUS_LENGTH: /* negative relative target */
- integer = this->integerTrigger(_value); /* get binary version of trigger */
- target->backwardLength(integer); /* move the position */
- break;
+ case TRIGGER_MINUS_LENGTH: /* negative relative target */
+ integer = this->integerTrigger(_value); /* get binary version of trigger */
+ target->backwardLength(integer); /* move the position */
+ break;
- case TRIGGER_ABSOLUTE: /* absolute column position */
- integer = this->integerTrigger(_value); /* get binary version of trigger */
- target->absolute(integer); /* move the position */
- break;
+ case TRIGGER_ABSOLUTE: /* absolute column position */
+ integer = this->integerTrigger(_value); /* get binary version of trigger */
+ target->absolute(integer); /* move the position */
+ break;
- case TRIGGER_STRING: /* string search */
- /* force to string form */
- stringvalue = this->stringTrigger(_value);
- target->search(stringvalue); /* perform the search */
- break;
+ case TRIGGER_STRING: /* string search */
+ /* force to string form */
+ stringvalue = this->stringTrigger(_value);
+ target->search(stringvalue); /* perform the search */
+ break;
- case TRIGGER_MIXED: /* string search */
- /* force to string form */
- stringvalue = this->stringTrigger(_value);
- /* and go search */
- target->caselessSearch(stringvalue);
- break;
- }
- if (context->tracingResults()) { /* are we tracing? */
- /* loop through the entire list */
- for (i = 0, size = this->variableCount; i < size; i++) {
- if (i + 1 == size) /* last variable? */
- _value = target->remainder(); /* extract the remainder */
- else
- _value = target->getWord(); /* just get the next word */
- variable = this->variables[i]; /* get the next variable retriever */
- if (variable != OREF_NULL) { /* not a place holder dummy? */
- /* set the value */
- variable->assign(context, stack, _value);
- context->traceResult(_value); /* trace if necessary */
- }
- else /* dummy variable, just trace it */
- /* trace if necessary */
- context->traceIntermediate(_value, TRACE_PREFIX_DUMMY);
+ case TRIGGER_MIXED: /* string search */
+ /* force to string form */
+ stringvalue = this->stringTrigger(_value);
+ /* and go search */
+ target->caselessSearch(stringvalue);
+ break;
}
- }
- else { /* not tracing, can optimize */
- /* loop through the entire list */
- for (i = 0, size = this->variableCount; i < size; i++) {
- variable = this->variables[i]; /* get the next variable retriever */
- if (variable != OREF_NULL) { /* not a place holder dummy? */
- if (i + 1 == size) /* last variable? */
- _value = target->remainder(); /* extract the remainder */
- else
- _value = target->getWord(); /* just get the next word */
- /* set the value */
- variable->assign(context, stack, _value);
- }
- else { /* dummy variable, just skip it */
- if (i + 1 == size) /* last variable? */
- target->skipRemainder(); /* skip the remainder */
- else
- target->skipWord(); /* just skip the next word */
- }
+ if (context->tracingResults())
+ { /* are we tracing? */
+ /* loop through the entire list */
+ for (i = 0, size = this->variableCount; i < size; i++)
+ {
+ if (i + 1 == size) /* last variable? */
+ {
+ _value = target->remainder(); /* extract the remainder */
+ }
+ else
+ {
+ _value = target->getWord(); /* just get the next word */
+ }
+ variable = this->variables[i]; /* get the next variable retriever */
+ if (variable != OREF_NULL)
+ { /* not a place holder dummy? */
+ /* set the value */
+ // NOTE: The different variable tpes handle their own assignment tracing
+ variable->assign(context, stack, _value);
+ }
+ else /* dummy variable, just trace it */
+ {
+ /* trace if necessary */
+ context->traceIntermediate(_value, TRACE_PREFIX_DUMMY);
+ }
+ }
}
- }
+ else
+ { /* not tracing, can optimize */
+ /* loop through the entire list */
+ for (i = 0, size = this->variableCount; i < size; i++)
+ {
+ variable = this->variables[i]; /* get the next variable retriever */
+ if (variable != OREF_NULL)
+ { /* not a place holder dummy? */
+ if (i + 1 == size) /* last variable? */
+ {
+ _value = target->remainder(); /* extract the remainder */
+ }
+ else
+ {
+ _value = target->getWord(); /* just get the next word */
+ }
+ /* set the value */
+ variable->assign(context, stack, _value);
+ }
+ else
+ { /* dummy variable, just skip it */
+ if (i + 1 == size) /* last variable? */
+ {
+ target->skipRemainder(); /* skip the remainder */
+ }
+ else
+ {
+ target->skipWord(); /* just skip the next word */
+ }
+ }
+ }
+ }
}
void RexxTrigger::live(size_t liveMark)
Modified: sandbox/rick/opt/kernel/runtime/InterpreterInstance.cpp
===================================================================
--- sandbox/rick/opt/kernel/runtime/InterpreterInstance.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/runtime/InterpreterInstance.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -266,7 +266,7 @@
activity->activate();
// before we update of the data structures, make sure we process any
// pending uninit activity.
- memoryObject.forceUninits();
+ memoryObject.runUninits();
// ok, deactivate this again.
activity->deactivate();
signalShutdown = true;
@@ -436,9 +436,11 @@
// This activity is currently the current activity. We're going to run the
// uninits on this one, so reactivate it until we're done running
enterOnCurrentThread();
+ // release any global references we've been holding.
+ globalReferences->empty();
// before we update of the data structures, make sure we process any
// pending uninit activity.
- memoryObject.forceUninits();
+ memoryObject.collectAndUninit();
// ok, deactivate this again...this will return the activity because the terminating
// flag is on.
exitCurrentThread();
Modified: sandbox/rick/opt/kernel/runtime/RexxActivation.cpp
===================================================================
--- sandbox/rick/opt/kernel/runtime/RexxActivation.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/runtime/RexxActivation.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -2722,6 +2722,7 @@
">C>", /* TRACE_PREFIX_COMPOUND */
">M>", /* TRACE_PREFIX_MESSAGE */
">A>", /* TRACE_PREFIX_ARGUMENT */
+ ">=>", /* TRACE_PREFIX_ASSIGNMENT */
};
/* extra space required to format a */
@@ -2740,8 +2741,6 @@
#define PREFIX_OFFSET (LINENUMBER + 1) /* location of the prefix field */
#define PREFIX_LENGTH 3 /* length of the prefix flag */
#define INDENT_SPACING 2 /* spaces per indentation amount */
-// marker used for tagged traces to separate tag from the value
-#define VALUE_MARKER " => "
// over head for adding quotes
#define QUOTES_OVERHEAD 2
@@ -2800,7 +2799,7 @@
* @param value The associated trace value.
*/
void RexxActivation::traceTaggedValue(int prefix, const char *tagPrefix, bool quoteTag,
- RexxString *tag, RexxObject * value)
+ RexxString *tag, const char *marker, RexxObject * value)
{
// the trace settings would normally require us to trace this, but there are conditions
// where we just skip doing this anyway.
@@ -2821,7 +2820,7 @@
// now calculate the length of the traced string
stringsize_t outLength = tag->getLength() + stringVal->getLength();
// these are fixed overheads
- outLength += TRACE_OVERHEAD + strlen(VALUE_MARKER);
+ outLength += TRACE_OVERHEAD + strlen(marker);
// now the indent spacing
outLength += this->settings.traceindent * INDENT_SPACING;
// now other conditionals
@@ -2866,8 +2865,8 @@
}
// now add the data marker
- buffer->put(dataOffset, VALUE_MARKER, strlen(VALUE_MARKER));
- dataOffset += strlen(VALUE_MARKER);
+ buffer->put(dataOffset, marker, strlen(marker));
+ dataOffset += strlen(marker);
// the leading quote around the value
buffer->putChar(dataOffset, '\"');
@@ -2966,8 +2965,6 @@
}
-
-
/**
* Trace a compound variable entry that's of the form 'tag =>
* "value"'.
@@ -2981,7 +2978,7 @@
void RexxActivation::traceCompoundValue(int prefix, RexxString *stemName, RexxObject **tails, size_t tailCount,
RexxCompoundTail *tail)
{
- traceCompoundValue(TRACE_PREFIX_COMPOUND, stemName, tails, tailCount, tail->createCompoundName(stemName));
+ traceCompoundValue(TRACE_PREFIX_COMPOUND, stemName, tails, tailCount, VALUE_MARKER, tail->createCompoundName(stemName));
}
@@ -2995,7 +2992,7 @@
* @param tailCount The count of tail elements.
* @param value The associated trace value.
*/
-void RexxActivation::traceCompoundValue(int prefix, RexxString *stemName, RexxObject **tails, size_t tailCount,
+void RexxActivation::traceCompoundValue(int prefix, RexxString *stemName, RexxObject **tails, size_t tailCount, const char *marker,
RexxObject * value)
{
// the trace settings would normally require us to trace this, but there are conditions
@@ -3027,7 +3024,7 @@
outLength += tailCount - 1;
// these are fixed overheads
- outLength += TRACE_OVERHEAD + strlen(VALUE_MARKER);
+ outLength += TRACE_OVERHEAD + strlen(marker);
// now the indent spacing
outLength += this->settings.traceindent * INDENT_SPACING;
@@ -3051,8 +3048,8 @@
dataOffset += tail.getLength();
// now add the data marker
- buffer->put(dataOffset, VALUE_MARKER, strlen(VALUE_MARKER));
- dataOffset += strlen(VALUE_MARKER);
+ buffer->put(dataOffset, marker, strlen(marker));
+ dataOffset += strlen(marker);
// the leading quote around the value
buffer->putChar(dataOffset, '\"');
@@ -3646,7 +3643,13 @@
// Dot variables retrieve from the environment
case STRING_LITERAL:
- return(RexxVariableBase *)new RexxDotVariable(variable->extract(1, variable->getLength() - 1));
+ // this is only a dot variable if it begins with a period
+ if (variable->getChar(0) == '.')
+ {
+ return (RexxVariableBase *)new RexxDotVariable(variable->extract(1, variable->getLength() - 1));
+ }
+ // this is a literal symbol not beginning with a period
+ return (RexxVariableBase *)variable;
/* if it is a stem */
case STRING_STEM:
@@ -3932,7 +3935,12 @@
/* and set the value */
stem_table->setCompoundVariable(&resolved_tail, value);
/* trace resolved compound name */
- traceCompoundName(stemName, tail, tailCount, &resolved_tail);
+ if (tracingIntermediates())
+ {
+ traceCompoundName(stemName, tail, tailCount, &resolved_tail);
+ /* trace variable value */
+ traceCompoundAssignment(stemName, tail, tailCount, value);
+ }
}
Modified: sandbox/rick/opt/kernel/runtime/RexxActivation.hpp
===================================================================
--- sandbox/rick/opt/kernel/runtime/RexxActivation.hpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/runtime/RexxActivation.hpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -51,6 +51,7 @@
#include "RexxDateTime.hpp"
#include "RexxCode.hpp"
#include "ActivityManager.hpp"
+#include "RexxCompoundTail.hpp"
class RexxInstructionCallBase;
@@ -269,9 +270,9 @@
size_t currentLine();
void arguments(RexxObject *);
void traceValue(RexxObject *, int);
- void traceCompoundValue(int prefix, RexxString *stem, RexxObject **tails, size_t tailCount, RexxObject * value);
- void traceCompoundValue(int prefix, RexxString *stem, RexxObject **tails, size_t tailCount, RexxCompoundTail *tailName);
- void traceTaggedValue(int prefix, const char *tagPrefix, bool quoteTag, RexxString *tag, RexxObject * value);
+ void traceCompoundValue(int prefix, RexxString *stemName, RexxObject **tails, size_t tailCount, RexxCompoundTail *tail);
+ void traceCompoundValue(int prefix, RexxString *stem, RexxObject **tails, size_t tailCount, const char *marker, RexxObject * value);
+ void traceTaggedValue(int prefix, const char *tagPrefix, bool quoteTag, RexxString *tag, const char *marker, RexxObject * value);
void traceOperatorValue(int prefix, const char *tag, RexxObject *value);
void traceSourceString();
void traceClause(RexxInstruction *, int);
@@ -372,20 +373,23 @@
inline void traceIntermediate(RexxObject * v, int p) { if (this->settings.intermediate_trace) this->traceValue(v, p); };
inline void traceVariable(RexxString *n, RexxObject *v)
- { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_VARIABLE, NULL, false, n, v); } };
+ { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_VARIABLE, NULL, false, n, VALUE_MARKER, v); } };
inline void traceDotVariable(RexxString *n, RexxObject *v)
- { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_DOTVARIABLE, ".", false, n, v); } };
+ { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_DOTVARIABLE, ".", false, n, VALUE_MARKER, v); } };
inline void traceFunction(RexxString *n, RexxObject *v)
- { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_FUNCTION, NULL, false, n, v); } };
+ { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_FUNCTION, NULL, false, n, VALUE_MARKER, v); } };
inline void traceMessage(RexxString *n, RexxObject *v)
- { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_MESSAGE, NULL, true, n, v); } };
+ { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_MESSAGE, NULL, true, n, VALUE_MARKER, v); } };
inline void traceOperator(const char *n, RexxObject *v)
{ if (this->settings.intermediate_trace) { this->traceOperatorValue(TRACE_PREFIX_OPERATOR, n, v); } };
inline void tracePrefix(const char *n, RexxObject *v)
{ if (this->settings.intermediate_trace) { this->traceOperatorValue(TRACE_PREFIX_PREFIX, n, v); } };
- inline void traceCompoundName(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxCompoundTail *tail) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_COMPOUND, stemVar, tails, tailCount, tail); };
- inline void traceCompoundName(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxString *tail) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_COMPOUND, stemVar, tails, tailCount, stemVar->concat(tail)); };
- inline void traceCompound(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxObject *value) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_VARIABLE, stemVar, tails, tailCount, value); };
+ inline void traceAssignment(RexxString *n, RexxObject *v)
+ { if (this->settings.intermediate_trace) { this->traceTaggedValue(TRACE_PREFIX_ASSIGNMENT, NULL, false, n, ASSIGNMENT_MARKER, v); } };
+ inline void traceCompoundName(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxCompoundTail *tail) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_COMPOUND, stemVar, tails, tailCount, VALUE_MARKER, tail->createCompoundName(stemVar)); };
+ inline void traceCompoundName(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxString *tail) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_COMPOUND, stemVar, tails, tailCount, VALUE_MARKER, stemVar->concat(tail)); };
+ inline void traceCompound(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxObject *value) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_VARIABLE, stemVar, tails, tailCount, VALUE_MARKER, value); };
+ inline void traceCompoundAssignment(RexxString *stemVar, RexxObject **tails, size_t tailCount, RexxObject *value) { if (this->settings.intermediate_trace) this->traceCompoundValue(TRACE_PREFIX_ASSIGNMENT, stemVar, tails, tailCount, ASSIGNMENT_MARKER, value); };
inline void traceResult(RexxObject * v) { if ((this->settings.flags&trace_results)) this->traceValue(v, TRACE_PREFIX_RESULT); };
inline bool tracingInstructions(void) { return (this->settings.flags&trace_all) != 0; }
inline void traceInstruction(RexxInstruction * v) { if (this->settings.flags&trace_all) this->traceClause(v, TRACE_PREFIX_CLAUSE); }
Modified: sandbox/rick/opt/kernel/runtime/RexxActivity.cpp
===================================================================
--- sandbox/rick/opt/kernel/runtime/RexxActivity.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/runtime/RexxActivity.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -100,7 +100,7 @@
SysInitializeThread(); /* system specific thread init */
/* establish the stack base pointer */
- this->nestedInfo.stackptr = SysGetThreadStackBase(TOTAL_STACK_SIZE);
+ this->stackBase = SysGetThreadStackBase(TOTAL_STACK_SIZE);
SysRegisterExceptions(&exreg); /* create needed exception handlers */
for (;;)
{
@@ -204,6 +204,11 @@
{
// deactivate the nesting level
deactivate();
+ // if we're inactive, try to run any pending uninits
+ if (isInactive())
+ {
+ memoryObject.runUninits();
+ }
// this activity owned the kernel semaphore before entering here...release it
// now.
releaseAccess();
@@ -277,7 +282,7 @@
#endif
this->priority = MEDIUM_PRIORITY;/* switch to medium priority */
/* establish the stack base pointer */
- this->nestedInfo.stackptr = SysGetThreadStackBase(TOTAL_STACK_SIZE);
+ this->stackBase = SysGetThreadStackBase(TOTAL_STACK_SIZE);
}
this->generateRandomNumberSeed(); /* get a fresh random seed */
/* Create table for progream being */
@@ -314,18 +319,19 @@
/* Function: Generate a fresh random number seed. */
/******************************************************************************/
{
- RexxDateTime timestamp; /* current timestamp */
- int i; /* loop counter */
- static int rnd = 0;
+ RexxDateTime timestamp; /* current timestamp */
+ int i; /* loop counter */
+ static int rnd = 0;
- rnd++;
- SysGetCurrentTime(×tamp); /* get a fresh time stamp */
- /* take the seed from the time */
- this->nestedInfo.randomSeed = rnd + (((timestamp.hours * 60 + timestamp.minutes) * 60 + timestamp.seconds) * 1000) + timestamp.microseconds/1000;
- for (i = 0; i < 13; i++) { /* randomize the seed number a bit */
- /* scramble the seed a bit */
- this->nestedInfo.randomSeed = RANDOMIZE(this->nestedInfo.randomSeed);
- }
+ rnd++;
+ SysGetCurrentTime(×tamp); /* get a fresh time stamp */
+ /* take the seed from the time */
+ randomSeed = rnd + (((timestamp.hours * 60 + timestamp.minutes) * 60 + timestamp.seconds) * 1000) + timestamp.microseconds/1000;
+ for (i = 0; i < 13; i++)
+ { /* randomize the seed number a bit */
+ /* scramble the seed a bit */
+ randomSeed = RANDOMIZE(randomSeed);
+ }
}
@@ -1582,7 +1588,7 @@
// copy all of the system exits
for (int i = 0; i < LAST_EXIT; i++)
{
- nestedInfo.sysexits[i] = interpreter->getExitHandler(i + 1);
+ sysexits[i] = interpreter->getExitHandler(i + 1);
}
// set the appropriate exit interlocks
queryTrcHlt();
@@ -1873,7 +1879,7 @@
{
#ifdef STACKCHECK
size_t temp; /* if checking and there isn't room */
- if ((char *)&temp - (char *)this->nestedInfo.stackptr < MIN_C_STACK && this->stackcheck == true)
+ if (((char *)&temp - (char *)this->stackBase) < MIN_C_STACK && this->stackcheck == true)
/* go raise an exception */
reportException(Error_Control_stack_full);
#endif
@@ -1901,19 +1907,19 @@
/* and set a flag to indicate this. */
/******************************************************************************/
{ /* is HALT sys exit set */
- if (isExitEnabled(RXHLT))
- {
- this->nestedInfo.clauseExitUsed = true; /* set flag to indicate one is found */
- return; /* and return */
- }
- /* is TRACE sys exit set */
- if (isExitEnabled(RXTRC))
- {
- this->nestedInfo.clauseExitUsed = true; /* set flag to indicate one is found */
- return; /* and return */
- }
+ if (isExitEnabled(RXHLT))
+ {
+ this->clauseExitUsed = true; /* set flag to indicate one is found */
+ return; /* and return */
+ }
+ /* is TRACE sys exit set */
+ if (isExitEnabled(RXTRC))
+ {
+ this->clauseExitUsed = true; /* set flag to indicate one is found */
+ return; /* and return */
+ }
- this->nestedInfo.clauseExitUsed = false; /* remember that none are set */
+ this->clauseExitUsed = false; /* remember that none are set */
}
@@ -1944,7 +1950,7 @@
{
/* disable the I/O exit from here to */
/* prevent recursive error conditions */
- nestedInfo.sysexits[RXSIO].disable();
+ sysexits[RXSIO].disable();
}
if (function != RXTER) /* not the termination exit? */
{
@@ -2884,10 +2890,9 @@
{
SYSEXCEPTIONBLOCK exreg; /* system specific exception info */
size_t startDepth; /* starting depth of activation stack*/
- NestedActivityState saveInfo; /* saved activity info */
/* make sure we have the stack base */
- this->nestedInfo.stackptr = SysGetThreadStackBase(TOTAL_STACK_SIZE);
+ this->stackBase = SysGetThreadStackBase(TOTAL_STACK_SIZE);
this->generateRandomNumberSeed(); /* get a fresh random seed */
/* Push marker onto stack so we know */
this->createNewActivationStack(); /* what level we entered. */
@@ -2925,7 +2930,6 @@
restoreActivationLevel(activityLevel);
// give uninit objects a chance to run
memoryObject.runUninits();
- this->restoreNestedInfo(saveInfo); /* now restore to previous nesting */
SysDeregisterSignals(&exreg); /* deregister the signal handlers */
// unwind to the same stack depth as the start, removing all new entries
unwindToDepth(startDepth);
@@ -2967,9 +2971,9 @@
// copy all of the system exits
for (int i = 0; i < LAST_EXIT; i++)
{
- nestedInfo.sysexits[i] = parent->nestedInfo.sysexits[i];
+ sysexits[i] = parent->sysexits[i];
}
- nestedInfo.clauseExitUsed = parent->nestedInfo.clauseExitUsed;
+ clauseExitUsed = parent->clauseExitUsed;
}
Modified: sandbox/rick/opt/kernel/runtime/RexxActivity.hpp
===================================================================
--- sandbox/rick/opt/kernel/runtime/RexxActivity.hpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/runtime/RexxActivity.hpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -86,8 +86,16 @@
TRACE_PREFIX_COMPOUND ,
TRACE_PREFIX_MESSAGE ,
TRACE_PREFIX_ARGUMENT ,
+ TRACE_PREFIX_ASSIGNMENT,
};
+
+// marker used for tagged traces to separate tag from the value
+#define VALUE_MARKER " => "
+// marker used for tagged traces to separate tag from the value
+#define ASSIGNMENT_MARKER " <= "
+
+
#define MAX_TRACEBACK_LIST 80 /* 40 messages are displayed */
#define MAX_TRACEBACK_INDENT 20 /* 10 messages are indented */
@@ -102,19 +110,6 @@
// used only internally, can be moved to a differnet value, if the using code is adapted accordingly
#define LAST_EXIT (RXNOOFEXITS - 1) /* top bound of the exits */
- /* information must be saved and */
- /* restored on nested entries to the */
- /* interpreter that use the same */
- /* activity */
-class NestedActivityState
-{
-public:
- char *stackptr; /* pointer to base of C stack */
- bool clauseExitUsed; /* halt/trace sys exit not set ==> 1 */
- size_t randomSeed; /* random number seed */
- ExitHandler sysexits[LAST_EXIT]; /* Array to hold system exits */
-};
-
/* NOTE: The following object */
/* definitions are only included in */
/* a module if the define */
@@ -207,7 +202,7 @@
thread_id_t threadIdMethod();
bool isThread(thread_id_t id) { return threadid == id; }
void setShvVal(RexxString *);
- inline bool isClauseExitUsed() { return this->nestedInfo.clauseExitUsed; }
+ inline bool isClauseExitUsed() { return clauseExitUsed; }
void queryTrcHlt();
bool callExit(RexxActivation * activation, const char *exitName, int function, int subfunction, void *exitbuffer);
void callInitializationExit(RexxActivation *);
@@ -276,10 +271,8 @@
inline RexxActivity *getNextWaitingActivity() { return nextWaitingActivity; }
inline void waitKernel() { EVWAIT(this->runsem); }
inline void clearWait() { EVSET(this->runsem); }
- inline size_t getRandomSeed() { return nestedInfo.randomSeed; }
- inline void setRandomSeed(size_t seed) { this->nestedInfo.randomSeed = seed; };
- inline void saveNestedInfo(NestedActivityState &saveInfo) { saveInfo = nestedInfo; }
- inline void restoreNestedInfo(NestedActivityState &saveInfo) { nestedInfo = saveInfo; }
+ inline size_t getRandomSeed() { return randomSeed; }
+ inline void setRandomSeed(size_t seed) { randomSeed = seed; };
inline RexxString *getLastMessageName() { return lastMessageName; }
inline RexxMethod *getLastMethod() { return lastMethod; }
inline void setLastMethod(RexxString *n, RexxMethod *m) { lastMessageName = n; lastMethod = m; }
@@ -326,7 +319,7 @@
protected:
- ExitHandler &getExitHandler(int exitNum) { return nestedInfo.sysexits[exitNum - 1]; }
+ ExitHandler &getExitHandler(int exitNum) { return sysexits[exitNum - 1]; }
bool isExitEnabled(int exitNum) { return getExitHandler(exitNum).isEnabled(); }
@@ -373,7 +366,10 @@
bool attached; // this is attached to an instance (vs. created directly)
SEV guardsem; /* guard expression semaphore */
size_t nestedCount; /* extent of the nesting */
- NestedActivityState nestedInfo; /* info saved and restored on calls */
+ char *stackBase; /* pointer to base of C stack */
+ bool clauseExitUsed; /* halt/trace sys exit not set ==> 1 */
+ size_t randomSeed; /* random number seed */
+ ExitHandler sysexits[LAST_EXIT]; /* Array to hold system exits */
ProtectedObject *protectedObjects; // list of stack-based object protectors
RexxString *lastMessageName; // class called message
RexxMethod *lastMethod; // last called method
Modified: sandbox/rick/opt/kernel/runtime/RexxMemory.cpp
===================================================================
--- sandbox/rick/opt/kernel/runtime/RexxMemory.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/runtime/RexxMemory.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -464,9 +464,22 @@
}
+/**
+ * Force a last-gasp garbage collection and running of the
+ * uninits during interpreter instance shutdown. This is an
+ * attempt to ensure that all objects with uninit methods get
+ * a chance to clean up prior to termination.
+ */
+void RexxMemory::collectAndUninit()
+{
+ collect();
+ runUninits();
+}
+
+
void RexxMemory::forceUninits()
/******************************************************************************/
-/* FUNCTION: we will run the UNINIT method of all objetcs in the UNINIT */
+/* FUNCTION: we will run the UNINIT method of all objects in the UNINIT */
/* table for our process. Even if the object is "dead", this is because the */
/* process is going away an its our last chance. Instead of removing the */
/* objects as we go, we run the entire table and then reset table. */
@@ -532,8 +545,7 @@
/* uninitTabe exists, run UNINIT */
for (iterTable = uninitTable->first();
- (zombieObj = uninitTable->index(iterTable)) != OREF_NULL;
- iterTable = uninitTable->next(iterTable))
+ (zombieObj = uninitTable->index(iterTable)) != OREF_NULL;)
{
// TODO: Ther's a bug here. Removing the object can cause the
// iterator to skip over an entry....something should be done to
@@ -552,7 +564,22 @@
catch (ActivityException) { }
/* remove zombie from uninit table */
uninitTable->remove(zombieObj);
+
+
+ // because we just did a remove operation, this will effect the iteration
+ // process. There are two possibilities here. Either A) we were at the end of the
+ // chain and this is now an empty slot or B) the removal process moved an new item
+ // into this slot. If it is case A), then we need to search for the next item. If
+ // it is case B) we'll just leave the index alone and process this position again.
+ if (uninitTable->index(iterTable) == OREF_NULL)
+ {
+ iterTable = uninitTable->next(iterTable);
+ }
}
+ else
+ {
+ iterTable = uninitTable->next(iterTable);
+ }
} /* now go check next object in table */
/* make sure we remove the recursion protection */
processingUninits = false;
Modified: sandbox/rick/opt/kernel/runtime/RexxMemory.hpp
===================================================================
--- sandbox/rick/opt/kernel/runtime/RexxMemory.hpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/runtime/RexxMemory.hpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -243,6 +243,7 @@
void scavengeSegmentSets(MemorySegmentSet *requester, size_t allocationLength);
void setUpMemoryTables(RexxObjectTable *old2newTable);
void forceUninits();
+ void collectAndUninit();
inline RexxDirectory *getGlobalStrings() { return globalStrings; }
void addWeakReference(WeakReference *ref);
void checkWeakReferences();
Modified: sandbox/rick/opt/kernel/runtime/RexxNativeActivation.cpp
===================================================================
--- sandbox/rick/opt/kernel/runtime/RexxNativeActivation.cpp 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/kernel/runtime/RexxNativeActivation.cpp 2008-06-27 15:32:21 UTC (rev 2592)
@@ -1017,7 +1017,7 @@
{
// make sure we protect this from a GC triggered by this table creation.
ProtectedObject p1(objr);
- if (this->savelist == OREF_NULL) /* second saved object? */
+ if (this->savelist == OREF_NULL) /* first saved object? */
{
/* create the save list now */
this->savelist = new_list();
Modified: sandbox/rick/opt/rexutils/rxftp.cls
===================================================================
--- sandbox/rick/opt/rexutils/rxftp.cls 2008-06-27 04:54:34 UTC (rev 2591)
+++ sandbox/rick/opt/rexutils/rxftp.cls 2008-06-27 15:32:21 UTC (rev 2592)
@@ -116,7 +116,7 @@
/* set the receive done flag to false */
self~rdone = .false
-thrdstatus = ''
+self~thrdstatus = ''
/* get a socket */
self~debugsay('Getting a socket.')
@@ -184,8 +184,7 @@
end
self~debugsay('Connected, recieving data.')
-bufsize = 4096
-bytesrcvd = SockRecv(ndsock, 'resp', bufsize)
+bytesrcvd = SockRecv(ndsock, 'resp', self~bufsize)
do while bytesrcvd > 0
self~debugsay('SockRecv:' bytesrcvd 'bytes received.')
self~data = ...
[truncated message content] |